14 files changed, 786 insertions, 236 deletions
diff --git a/brainfuck.html.markdown b/brainfuck.html.markdown
index 27ac6921..a76169c8 100644
--- a/brainfuck.html.markdown
+++ b/brainfuck.html.markdown
@@ -8,6 +8,8 @@ contributors:
 Brainfuck (not capitalized except at the start of a sentence) is an extremely
 minimal Turing-complete programming language with just 8 commands.
 
+You can try brainfuck on your browser with [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
 ```
 Any character not "><+-.,[]" (excluding quotation marks) is ignored.
 
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index ca27fdc7..83d59c8b 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -5,34 +5,34 @@ contributors:
     - ["Joseph Adams", "https://github.com/jcla1"]
 lang: de-de
 ---
-Go wurde entwickelt um probleme zu lösen. Sie ist zwar nicht der neuste Trend in
-der Informatik, aber sie ist eine der neusten und schnellsten Wege um Aufgabe in
+Go wurde entwickelt, um Probleme zu lösen. Sie ist zwar nicht der neueste Trend in
+der Informatik, aber sie ist einer der neuesten und schnellsten Wege, um Aufgabe in
 der realen Welt zu lösen.
 
-Sie hat vertraute Elemente von imperativen Sprachen mit statisher Typisierung
+Sie hat vertraute Elemente von imperativen Sprachen mit statischer Typisierung
 und kann schnell kompiliert und ausgeführt werden. Verbunden mit leicht zu
 verstehenden Parallelitäts-Konstrukten, um die heute üblichen mehrkern
 Prozessoren optimal nutzen zu können, eignet sich Go äußerst gut für große
 Programmierprojekte.
 
-Außerdem beinhaltet Go eine gut ausgestattete standard bibliothek und hat eine
-aktive community.
+Außerdem beinhaltet Go eine gut ausgestattete Standardbibliothek und hat eine
+aktive Community.
 
 ```go
 // Einzeiliger Kommentar
 /* Mehr-
    zeiliger Kommentar */
 
-// Eine jede Quelldatei beginnt mit einer Packet-Klausel.
-// "main" ist ein besonderer Packetname, da er ein ausführbares Programm
+// Eine jede Quelldatei beginnt mit einer Paket-Klausel.
+// "main" ist ein besonderer Pkaetname, da er ein ausführbares Programm
 // einleitet, im Gegensatz zu jedem anderen Namen, der eine Bibliothek
 // deklariert.
 package main
 
-// Ein "import" wird verwendet um Packte zu deklarieren, die in dieser
+// Ein "import" wird verwendet, um Pakete zu deklarieren, die in dieser
 // Quelldatei Anwendung finden.
 import (
-    "fmt"      // Ein Packet in der Go standard Bibliothek
+    "fmt"      // Ein Paket in der Go Standardbibliothek
     "net/http" // Ja, ein Webserver.
     "strconv"  // Zeichenkettenmanipulation
 )
@@ -42,10 +42,10 @@ import (
 // Programms. Vergessen Sie nicht die geschweiften Klammern!
 func main() {
     // Println gibt eine Zeile zu stdout aus.
-    // Der Prefix "fmt" bestimmt das Packet aus welchem die Funktion stammt.
+    // Der Prefix "fmt" bestimmt das Paket aus welchem die Funktion stammt.
     fmt.Println("Hello world!")
 
-    // Aufruf einer weiteren Funktion definiert innerhalb dieses Packets.
+    // Aufruf einer weiteren Funktion definiert innerhalb dieses Pakets.
     beyondHello()
 }
 
@@ -54,7 +54,7 @@ func main() {
 func beyondHello() {
     var x int // Deklaration einer Variable, muss vor Gebrauch geschehen.
     x = 3     // Zuweisung eines Werts.
-    // Kurze Deklaration: Benutzen Sie ":=" um die Typisierung automatisch zu
+    // Kurze Deklaration: Benutzen Sie ":=", um die Typisierung automatisch zu
     // folgern, die Variable zu deklarieren und ihr einen Wert zu zuweisen.
     y := 4
 
@@ -70,7 +70,7 @@ func learnMultiple(x, y int) (sum, prod int) {
     return x + y, x * y // Wiedergabe zweier Werte
 }
 
-// Überblick ueber einige eingebaute Typen und Literale.
+// Überblick über einige eingebaute Typen und Literale.
 func learnTypes() {
     // Kurze Deklarationen sind die Norm.
     s := "Lernen Sie Go!" // Zeichenketten-Typ
@@ -111,7 +111,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
     m["eins"] = 1
 
     // Ungebrauchte Variablen sind Fehler in Go
-    // Der Unterstrich wird verwendet um einen Wert zu verwerfen.
+    // Der Unterstrich wird verwendet, um einen Wert zu verwerfen.
     _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
     // Die Ausgabe zählt natürlich auch als Gebrauch
     fmt.Println(s, c, a4, s3, d2, m)
@@ -142,7 +142,7 @@ func learnFlowControl() {
     if true {
         fmt.Println("hab's dir ja gesagt!")
     }
-    // Die Formattierung ist durch den Befehl "go fmt" standardisiert
+    // Die Formatierung ist durch den Befehl "go fmt" standardisiert
     if false {
         // nicht hier
     } else {
@@ -170,7 +170,7 @@ func learnFlowControl() {
         continue // wird nie ausgeführt
     }
 
-    // Wie bei for, bedeutet := in einer Bedingten Anweisung zunächst die
+    // Wie bei for, bedeutet := in einer bedingten Anweisung zunächst die
     // Zuweisung und erst dann die Überprüfung der Bedingung.
     if y := expensiveComputation(); y > x {
         x = y
@@ -217,8 +217,8 @@ func learnInterfaces() {
     // Aufruf der String Methode von i, gleiche Ausgabe wie zuvor.
     fmt.Println(i.String())
 
-    // Funktionen des fmt-Packets rufen die String() Methode auf um eine
-    // druckbare variante des Empfängers zu erhalten.
+    // Funktionen des fmt-Pakets rufen die String() Methode auf um eine
+    // druckbare Variante des Empfängers zu erhalten.
     fmt.Println(p) // gleiche Ausgabe wie zuvor
     fmt.Println(i) // und wieder die gleiche Ausgabe wie zuvor
 
@@ -244,18 +244,18 @@ func learnErrorHandling() {
     learnConcurrency()
 }
 
-// c ist ein Kannal, ein sicheres Kommunikationsmedium.
+// c ist ein Kanal, ein sicheres Kommunikationsmedium.
 func inc(i int, c chan int) {
-    c <- i + 1 // <- ist der "send" Operator, wenn ein Kannal auf der Linken ist
+    c <- i + 1 // <- ist der "send" Operator, wenn ein Kanal auf der Linken ist
 }
 
 // Wir verwenden "inc" um Zahlen parallel zu erhöhen.
 func learnConcurrency() {
     // Die selbe "make"-Funktion wie vorhin. Sie initialisiert Speicher für
-    // maps, slices und Kannäle.
+    // maps, slices und Kanäle.
     c := make(chan int)
     // Starte drei parallele "Goroutines". Die Zahlen werden parallel (concurrently)
-    // erhöht. Alle drei senden ihr Ergebnis in den gleichen Kannal.
+    // erhöht. Alle drei senden ihr Ergebnis in den gleichen Kanal.
     go inc(0, c) // "go" ist das Statement zum Start einer neuen Goroutine
     go inc(10, c)
     go inc(-805, c)
@@ -269,16 +269,16 @@ func learnConcurrency() {
 
     // Start einer neuen Goroutine, nur um einen Wert zu senden
     go func() { c <- 84 }()
-    go func() { cs <- "wortreich" }() // schon wider, diesmal für
+    go func() { cs <- "wortreich" }() // schon wieder, diesmal für
     // "select" hat eine Syntax wie ein switch Statement, aber jeder Fall ist
-    // eine Kannaloperation. Es wählt eine Fall zufällig aus allen die
-    // kommunikationsbereit sind aus.
+    // eine Kanaloperation. Es wählt einen Fall zufällig aus allen, die
+    // kommunikationsbereit sind, aus.
     select {
     case i := <-c: // der empfangene Wert kann einer Variable zugewiesen werden
         fmt.Printf("es ist ein: %T", i)
     case <-cs: // oder der Wert kann verworfen werden
         fmt.Println("es ist eine Zeichenkette!")
-    case <-cc: // leerer Kannal, nicht bereit für den Empfang
+    case <-cc: // leerer Kanal, nicht bereit für den Empfang
         fmt.Println("wird nicht passieren.")
     }
     // Hier wird eine der beiden Goroutines fertig sein, die andere nicht.
@@ -287,16 +287,16 @@ func learnConcurrency() {
     learnWebProgramming() // Go kann es und Sie hoffentlich auch bald.
 }
 
-// Eine einzige Funktion aus dem http-Packet kann einen Webserver starten.
+// Eine einzige Funktion aus dem http-Paket kann einen Webserver starten.
 func learnWebProgramming() {
-    // Der erste Parameter von "ListenAndServe" ist eine TCP Addresse an die
+    // Der erste Parameter von "ListenAndServe" ist eine TCP Addresse, an die
     // sich angeschlossen werden soll.
     // Der zweite Parameter ist ein Interface, speziell: ein http.Handler
     err := http.ListenAndServe(":8080", pair{})
     fmt.Println(err) // Fehler sollte man nicht ignorieren!
 }
 
-// Wir lassen "pair" das http.Handler Interface erfüllen indem wir seine einzige
+// Wir lassen "pair" das http.Handler Interface erfüllen, indem wir seine einzige
 // Methode implementieren: ServeHTTP
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     // Senden von Daten mit einer Methode des http.ResponseWriter
@@ -313,6 +313,6 @@ Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
 kurz und auch gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
 ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/).
 Gut documentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
-verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktions-
-Namen in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
+verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
+in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
 
diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown
index 5ddb6f4b..ae29d6f9 100644
--- a/de-de/python-de.html.markdown
+++ b/de-de/python-de.html.markdown
@@ -149,7 +149,7 @@ li[0] #=> 1
 # Das letzte Element ansehen
 li[-1] #=> 3
 
-# Bei Zugriffen außerhal der Liste kommt es jedoch zu einem IndexError
+# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError
 li[4] # Raises an IndexError
 
 # Wir können uns Ranges mit Slice-Syntax ansehen
@@ -188,7 +188,7 @@ tup[:2] #=> (1, 2)
 
 # Wir können Tupel (oder Listen) in Variablen entpacken
 a, b, c = (1, 2, 3)     # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3
-# Tuple werden standardmäßig erstellt, wenn wir uns die Klammern sparen
+# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen
 d, e, f = 4, 5, 6
 # Es ist kinderleicht zwei Werte zu tauschen
 e, d = d, e     # d is now 5 and e is now 4
diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown
new file mode 100644
index 00000000..2ff5902f
--- /dev/null
+++ b/fr-fr/go-fr.html.markdown
@@ -0,0 +1,438 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
+    - ["Jean-Philippe Monette", "http://blogue.jpmonette.net/"]
+---
+
+Go a été créé dans l'optique de développer de façon efficace. Ce n'est pas la
+dernière tendance en ce qui est au développement, mais c'est la nouvelle façon
+de régler des défis réels de façon rapide.
+
+Le langage possède des concepts familiers à la programmation impérative avec
+typage. Il est rapide à compiler et exécuter, ajoute une concurrence facile à
+comprendre, pour les processeurs multi coeurs d'aujourd'hui et apporte des
+fonctionnalités facilitant le développement à grande échelle.
+
+Développer avec Go, c'est bénéficier d'une riche bibliothèque standard et d'une
+communauté active.
+
+```go
+// Commentaire ligne simple
+/* Commentaire
+ multiligne */
+
+// Un paquet débute avec une clause "package"
+// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt
+// qu'une bibliothèque
+package main
+
+// "Import" déclare les paquets référencés dans ce fichier.
+import (
+  "fmt"       // Un paquet dans la bibliothèque standard.
+  "io/ioutil" // Implémente des fonctions utilitaires I/O.
+  m "math"    // Bibliothèque mathématique utilisant un alias local "m".
+  "net/http"  // Un serveur Web!
+  "strconv"   // Bibliothèque pour convertir les chaînes de caractères.
+)
+
+// Une définition de fonction. La fonction "main" est spéciale - c'est le point
+// d'entrée du binaire.
+func main() {
+  // Println retournera la valeur à la console.
+  // Associez la fonction avec son paquet respectif, fmt.
+  fmt.Println("Hello world!")
+
+  // Appelez une fonction différente à partir de ce paquet.
+  beyondHello()
+}
+
+// Les fonctions ont des paramètres entre parenthèses.
+// Les parenthèses sont nécessaires avec ou sans paramètre.
+func beyondHello() {
+  var x int // Déclaration de variable. Les variables doivent être déclarées
+            // avant leur utilisation.
+  x = 3     // Assignation de valeur.
+  // Les déclarations courtes utilisent := pour inférer le type, déclarer et
+  // assigner.
+  y := 4
+  sum, prod := learnMultiple(x, y)        // La fonction retourne deux valeurs.
+  fmt.Println("sum:", sum, "prod:", prod) // Affichage simple.
+  learnTypes()                            // < y minutes, en savoir plus!
+}
+
+// Les fonctions peuvent avoir des paramètres et plusieurs valeurs retournées.
+func learnMultiple(x, y int) (sum, prod int) {
+  return x + y, x * y // Deux valeurs retournées.
+}
+
+// Quelques types inclus et littéraux.
+func learnTypes() {
+  // Une déclaration courte infère généralement le type désiré.
+  str := "Learn Go!" // Type string.
+
+  s2 := `Une chaîne de caractères peut contenir des
+sauts de ligne.` // Chaîne de caractère.
+
+  // Littéral non-ASCII. Les sources Go utilisent le charset UTF-8.
+  g := 'Σ' // type rune, un alias pour le type int32, contenant un caractère
+           // unicode.
+
+  f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit.
+  c := 3 + 4i  // complex128, considéré comme deux float64 par le compilateur.
+
+  // Syntaxe "var" avec une valeur d'initialisation.
+  var u uint = 7 // Non signé, mais la taille dépend selon l'entier.
+  var pi float32 = 22. / 7
+
+  // Conversion avec syntaxe courte.
+  n := byte('\n') // byte est un alias du type uint8.
+
+  // Les tableaux ont une taille fixe déclarée à la compilation.
+  var a4 [4]int           // Un tableau de 4 ints, tous initialisés à 0.
+  a3 := [...]int{3, 1, 5} // Un tableau initialisé avec une taille fixe de 3
+  // éléments, contenant les valeurs 3, 1 et 5.
+
+  // Les slices ont des tailles dynamiques. Les tableaux et slices ont chacun
+  // des avantages, mais les cas d'utilisation des slices sont plus fréquents.
+  s3 := []int{4, 5, 9}    // Comparable à a3.
+  s4 := make([]int, 4)    // Alloue un slice de 4 ints, initialisés à 0.
+  var d2 [][]float64      // Déclaration seulement, sans allocation de mémoire.
+  bs := []byte("a slice") // Conversion d'une chaîne en slice de bytes.
+
+  // Parce qu'elles sont dynamiques, les slices peuvent être jointes sur
+  // demande. Pour joindre un élément à une slice, la fonction standard append()
+  // est utilisée. Le premier argument est la slice à utiliser. Habituellement,
+  // la variable tableau est mise à jour sur place, voir ci-bas.
+  s := []int{1, 2, 3}     // Le résultat est une slice de taille 3.
+  s = append(s, 4, 5, 6)  // Ajout de 3 valeurs. La taille est de 6.
+  fmt.Println(s)          // La valeur est de [1 2 3 4 5 6]
+
+  // Pour ajouter une slice à une autre, au lieu d'utiliser une liste de valeurs
+  // atomiques, il est possible de mettre en argument une référence de
+  // slice littérale grâce aux points de suspension.
+  s = append(s, []int{7, 8, 9}...) // Le deuxième argument est une slice
+                                   // littérale.
+  fmt.Println(s)  // La slice contient [1 2 3 4 5 6 7 8 9]
+
+  p, q := learnMemory() // Déclare p, q comme étant des pointeurs de type int.
+  fmt.Println(*p, *q)   // * suit un pointeur. Ceci retourne deux ints.
+
+  // Les maps sont des tableaux associatifs de taille dynamique, comme les
+  // hash ou les types dictionnaires de certains langages.
+  m := map[string]int{"trois": 3, "quatre": 4}
+  m["un"] = 1
+
+  // Les valeurs inutilisées sont considérées comme des erreurs en Go.
+  // Un tiret bas permet d'ignorer une valeur inutilisée, évitant une erreur.
+  _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+
+  // Cependant, son affichage en console est considéré comme une utilisation,
+  // ce qui ne sera pas considéré comme une erreur à la compilation.
+  fmt.Println(s, c, a4, s3, d2, m)
+
+  learnFlowControl() // De retour dans le flux.
+}
+
+// Il est possible, à l'opposé de plusieurs autres langages, de retourner des
+// variables par leur nom à partir de fonctions.
+// Assigner un nom à un type retourné par une fonction permet de retrouver sa
+// valeur ainsi que d'utiliser le mot-clé "return" uniquement, sans plus.
+func learnNamedReturns(x, y int) (z int) {
+  z = x * y
+  return // z est implicite, car la variable a été définie précédemment.
+}
+
+// La récupération de la mémoire est automatique en Go. Le langage possède des
+// pointeurs, mais aucune arithmétique des pointeurs (*(a + b) en C). Vous
+// pouvez produire une erreur avec un pointeur nil, mais pas en incrémentant un
+// pointeur.
+func learnMemory() (p, q *int) {
+  // Les valeurs retournées p et q auront le type pointeur int.
+  p = new(int) // Fonction standard "new" alloue la mémoire.
+  // Le int alloué est initialisé à 0, p n'est plus nil.
+  s := make([]int, 20) // Alloue 20 ints en un seul bloc de mémoire.
+  s[3] = 7             // Assigne l'un des entiers.
+  r := -2              // Déclare une autre variable locale.
+  return &s[3], &r     // & retourne l'adresse d'un objet.
+}
+
+func expensiveComputation() float64 {
+  return m.Exp(10)
+}
+
+func learnFlowControl() {
+  // Bien que les "if" requièrent des accolades, les parenthèses ne sont pas
+  // nécessaires pour contenir le test booléen.
+  if true {
+    fmt.Println("voilà!")
+  }
+  // Le formatage du code est standardisé par la commande shell "go fmt."
+  if false {
+    // bing.
+  } else {
+    // bang.
+  }
+  // Utilisez "switch" au lieu des "if" en chaîne
+  x := 42.0
+  switch x {
+  case 0:
+  case 1:
+  case 42:
+    // Les "case" n'ont pas besoin de "break;".
+  case 43:
+    // Non-exécuté.
+  }
+  // Comme les "if", les "for" n'utilisent pas de parenthèses.
+  // Les variables déclarées dans les "for" et les "if" sont locales à leur
+  // portée.
+  for x := 0; x < 3; x++ { // ++ est une incrémentation.
+    fmt.Println("itération ", x)
+  }
+  // x == 42 ici.
+
+  // "For" est le seul type de boucle en Go, mais possède différentes formes.
+  for { // Boucle infinie
+    break    // C'est une farce
+    continue // Non atteint.
+  }
+
+  // Vous pouvez utiliser une "range" pour itérer dans un tableau, une slice, une
+  // chaîne, une map ou un canal. Les "range" retournent un canal ou deux
+  // valeurs (tableau, slice, chaîne et map).
+  for key, value := range map[string]int{"une": 1, "deux": 2, "trois": 3} {
+    // pour chaque pair dans une map, affichage de la valeur et clé
+    fmt.Printf("clé=%s, valeur=%d\n", key, value)
+  }
+
+  // À l'opposé du "for", := dans un "if" signifie la déclaration et
+  // l'assignation y en premier, et ensuite y > x
+  if y := expensiveComputation(); y > x {
+    x = y
+  }
+  // Les fonctions littérales sont des fermetures.
+  xBig := func() bool {
+    return x > 10000
+  }
+  fmt.Println("xBig:", xBig()) // true (la valeur e^10 a été assignée à x).
+  x = 1.3e3                    // Ceci fait x == 1300
+  fmt.Println("xBig:", xBig()) // Maintenant false.
+
+  // De plus, les fonctions littérales peuvent être définies et appelées
+  // sur la même ligne, agissant comme argument à cette fonction, tant que:
+  // a) la fonction littérale est appelée suite à (),
+  // b) le résultat correspond au type de l'argument.
+  fmt.Println("Ajoute + multiplie deux nombres : ",
+    func(a, b int) int {
+      return (a + b) * 2
+    }(10, 2)) // Appelle la fonction avec les arguments 10 et 2
+  // => Ajoute + double deux nombres : 24
+
+  // Quand vous en aurez besoin, vous allez l'adorer.
+  goto love
+love:
+
+  learnFunctionFactory() // func retournant func correspondant à fun(3)(3).
+  learnDefer()           // Un survol de cette instruction importante.
+  learnInterfaces()      // Incontournable !
+}
+
+func learnFunctionFactory() {
+  // Les deux syntaxes sont identiques, bien que la seconde soit plus pratique.
+  fmt.Println(sentenceFactory("été")("Une matinée d'", "agréable!"))
+
+  d := sentenceFactory("été")
+  fmt.Println(d("Une matinée d'", "agréable!"))
+  fmt.Println(d("Une soirée d'", "relaxante!"))
+}
+
+// Le décorateur est un patron de conception commun dans d'autres langages.
+// Il est possible de faire de même en Go avec des fonctions littérales
+// acceptant des arguments.
+func sentenceFactory(mystring string) func(before, after string) string {
+  return func(before, after string) string {
+    return fmt.Sprintf("%s %s %s", before, mystring, after) // nouvelle chaîne
+  }
+}
+
+func learnDefer() (ok bool) {
+  // Les déclarations différées sont exécutées avant la sortie d'une fonction.
+  defer fmt.Println("les déclarations différées s'exécutent en ordre LIFO.")
+  defer fmt.Println("\nCette ligne est affichée en premier parce que")
+  // Les déclarations différées sont utilisées fréquemment pour fermer un
+  // fichier, afin que la fonction ferme le fichier en fin d'exécution.
+  return true
+}
+
+// Défini Stringer comme étant une interface avec une méthode, String.
+type Stringer interface {
+  String() string
+}
+
+// Défini pair comme étant une structure contenant deux entiers, x et y.
+type pair struct {
+  x, y int
+}
+
+// Défini une méthode associée au type pair. Pair implémente maintenant Stringer
+func (p pair) String() string { // p s'appelle le "destinataire"
+  // Sprintf est une autre fonction publique dans le paquet fmt.
+  // La syntaxe avec point permet de faire référence aux valeurs de p.
+  return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+  // La syntaxe avec accolade défini une "structure littérale". Celle-ci
+  // s'évalue comme étant une structure. La syntaxe := déclare et initialise p
+  // comme étant une instance.
+  p := pair{3, 4}
+  fmt.Println(p.String()) // Appelle la méthode String de p, de type pair.
+  var i Stringer          // Déclare i instance de l'interface Stringer.
+  i = p                   // Valide, car pair implémente Stringer.
+  // Appelle la méthode String de i, de type Stringer. Retourne la même valeur
+  // que ci-haut.
+  fmt.Println(i.String())
+
+  // Les fonctions dans le paquet fmt appellent la méthode String, demandant
+  // aux objets d'afficher une représentation de leur structure.
+  fmt.Println(p) // Affiche la même chose que ci-haut. Println appelle la
+                 // méthode String.
+  fmt.Println(i) // Affiche la même chose que ci-haut.
+
+  learnVariadicParams("apprentissage", "génial", "ici!")
+}
+
+// Les fonctions peuvent être définie de façon à accepter un ou plusieurs
+// paramètres grâce aux points de suspension, offrant une flexibilité lors de
+// son appel.
+func learnVariadicParams(myStrings ...interface{}) {
+  // Itère chaque paramètre dans la range.
+  // Le tiret bas sert à ignorer l'index retourné du tableau.
+  for _, param := range myStrings {
+    fmt.Println("paramètre:", param)
+  }
+
+  // Passe une valeur variadique comme paramètre variadique.
+  fmt.Println("paramètres:", fmt.Sprintln(myStrings...))
+
+  learnErrorHandling()
+}
+
+func learnErrorHandling() {
+  // ", ok" idiome utilisée pour définir si l'opération s'est déroulée avec
+  // succès ou non
+  m := map[int]string{3: "trois", 4: "quatre"}
+  if x, ok := m[1]; !ok { // ok sera faux, car 1 n'est pas dans la map.
+    fmt.Println("inexistant")
+  } else {
+    fmt.Print(x) // x serait la valeur, si elle se trouvait dans la map.
+  }
+  // Une erreur ne retourne qu'un "ok", mais également plus d'information
+  // par rapport à un problème survenu.
+  if _, err := strconv.Atoi("non-int"); err != nil { // _ discarte la valeur
+    // retourne: 'strconv.ParseInt: parsing "non-int": invalid syntax'
+    fmt.Println(err)
+  }
+  // Nous réviserons les interfaces un peu plus tard. Pour l'instant,
+  learnConcurrency()
+}
+
+// c est un canal, un objet permettant de communiquer en simultané de façon
+// sécurisée.
+func inc(i int, c chan int) {
+  c <- i + 1 // <- est l'opérateur "envoi" quand un canal apparaît à
+             // gauche.
+}
+
+// Nous utiliserons inc pour incrémenter des nombres en même temps.
+func learnConcurrency() {
+  // La fonction "make" utilisée précédemment pour générer un slice. Elle
+  // alloue et initialise les slices, maps et les canaux.
+  c := make(chan int)
+  // Démarrage de trois goroutines simultanées. Les nombres seront incrémentés
+  // simultanément, peut-être en paralèle si la machine le permet et configurée
+  // correctement. Les trois utilisent le même canal.
+  go inc(0, c) // go est une instruction démarrant une nouvelle goroutine.
+  go inc(10, c)
+  go inc(-805, c)
+  // Lis et affiche trois résultats du canal - impossible de savoir dans quel
+  // ordre !
+  fmt.Println(<-c, <-c, <-c) // Canal à droite, <- est l'opérateur de
+                             // "réception".
+
+  cs := make(chan string)       // Un autre canal, celui-ci gère des chaînes.
+  ccs := make(chan chan string) // Un canal de canaux de chaînes.
+  go func() { c <- 84 }()       // Démarre une nouvelle goroutine, pour
+                                // envoyer une valeur.
+  go func() { cs <- "wordy" }() // De nouveau, pour cs cette fois-ci.
+  // Select possède une syntaxe similaire au switch, mais chaque cas requiert
+  // une opération impliquant un canal. Il sélectionne un cas aléatoirement
+  // prêt à communiquer.
+  select {
+  case i := <-c: // La valeur reçue peut être assignée à une variable,
+    fmt.Printf("c'est un %T", i)
+  case <-cs: // ou la valeur reçue peut être ignorée.
+    fmt.Println("c'est une chaîne")
+  case <-ccs: // Un canal vide, indisponible à la communication.
+    fmt.Println("ne surviendra pas.")
+  }
+  // À ce point, une valeur a été prise de c ou cs. L'une des deux goroutines
+  // démarrée plus haut a complétée, la seconde restera bloquée.
+
+  learnWebProgramming() // Go permet la programmation Web.
+}
+
+// Une seule fonction du paquet http démarre un serveur Web.
+func learnWebProgramming() {
+
+  // Le premier paramètre de ListenAndServe est une adresse TCP à écouter.
+  // Le second est une interface, de type http.Handler.
+  go func() {
+    err := http.ListenAndServe(":8080", pair{})
+    fmt.Println(err) // n'ignorez pas les erreurs !
+  }()
+
+  requestServer()
+}
+
+// Implémente la méthode ServeHTTP de http.Handler à pair, la rendant compatible
+// avec les opérations utilisant l'interface http.Handler.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+  // Répondez à une requête à l'aide de la méthode http.ResponseWriter.
+  w.Write([]byte("Vous avez appris Go en Y minutes!"))
+}
+
+func requestServer() {
+  resp, err := http.Get("http://localhost:8080")
+  fmt.Println(err)
+  defer resp.Body.Close()
+  body, err := ioutil.ReadAll(resp.Body)
+  fmt.Printf("\nLe serveur Web a dit: `%s`", string(body))
+}
+```
+
+## En savoir plus
+
+La référence Go se trouve sur [le site officiel de Go](http://golang.org/).
+Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus.
+
+Une lecture de la documentation du langage est grandement conseillée. C'est
+facile à lire et très court (comparé aux autres langages).
+
+Vous pouvez exécuter et modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go.
+
+Sur la liste de lecteur des étudiants de Go se trouve le [code source de la
+librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre
+le meilleur de la clarté de Go, le style ainsi que ses expressions. Sinon, vous
+pouvez cliquer sur le nom d'une fonction dans [la
+documentation](http://golang.org/pkg/) et le code source apparaît!
+
+Une autre excellente ressource pour apprendre est [Go par l'exemple](https://gobyexample.com/).
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 6c98c2b6..f28fcfe7 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -148,12 +148,12 @@ add 1 2 -- 3
 
 -- Guards: an easy way to do branching in functions
 fib x
-  | x < 2 = x
+  | x < 2 = 1
   | otherwise = fib (x - 1) + fib (x - 2)
 
 -- Pattern matching is similar. Here we have given three different
 -- definitions for fib. Haskell will automatically call the first
--- function that matches the pattern of the value. 
+-- function that matches the pattern of the value.
 fib 1 = 1
 fib 2 = 2
 fib x = fib (x - 1) + fib (x - 2)
@@ -181,7 +181,7 @@ foldl1 (\acc x -> acc + x) [1..5] -- 15
 ----------------------------------------------------
 
 -- partial application: if you don't pass in all the arguments to a function,
--- it gets "partially applied". That means it returns a function that takes the 
+-- it gets "partially applied". That means it returns a function that takes the
 -- rest of the arguments.
 
 add a b = a + b
@@ -320,13 +320,13 @@ Nothing         -- of type `Maybe a` for any `a`
 -- called. It must return a value of type `IO ()`. For example:
 
 main :: IO ()
-main = putStrLn $ "Hello, sky! " ++ (say Blue) 
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
 -- putStrLn has type String -> IO ()
 
--- It is easiest to do IO if you can implement your program as 
--- a function from String to String. The function 
+-- It is easiest to do IO if you can implement your program as
+-- a function from String to String. The function
 --    interact :: (String -> String) -> IO ()
--- inputs some text, runs a function on it, and prints out the 
+-- inputs some text, runs a function on it, and prints out the
 -- output.
 
 countLines :: String -> String
@@ -340,43 +340,43 @@ main' = interact countLines
 -- the `do` notation to chain actions together. For example:
 
 sayHello :: IO ()
-sayHello = do 
+sayHello = do
    putStrLn "What is your name?"
    name <- getLine -- this gets a line and gives it the name "name"
    putStrLn $ "Hello, " ++ name
-   
+
 -- Exercise: write your own version of `interact` that only reads
 --           one line of input.
-   
+
 -- The code in `sayHello` will never be executed, however. The only
--- action that ever gets executed is the value of `main`. 
--- To run `sayHello` comment out the above definition of `main` 
+-- action that ever gets executed is the value of `main`.
+-- To run `sayHello` comment out the above definition of `main`
 -- and replace it with:
 --   main = sayHello
 
--- Let's understand better how the function `getLine` we just 
+-- Let's understand better how the function `getLine` we just
 -- used works. Its type is:
 --    getLine :: IO String
 -- You can think of a value of type `IO a` as representing a
--- computer program that will generate a value of type `a` 
+-- computer program that will generate a value of type `a`
 -- when executed (in addition to anything else it does). We can
--- store and reuse this value using `<-`. We can also 
+-- store and reuse this value using `<-`. We can also
 -- make our own action of type `IO String`:
 
 action :: IO String
 action = do
    putStrLn "This is a line. Duh"
-   input1 <- getLine 
+   input1 <- getLine
    input2 <- getLine
    -- The type of the `do` statement is that of its last line.
-   -- `return` is not a keyword, but merely a function 
+   -- `return` is not a keyword, but merely a function
    return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
 
 -- We can use this just like we used `getLine`:
 
 main'' = do
     putStrLn "I will echo two lines!"
-    result <- action 
+    result <- action
     putStrLn result
     putStrLn "This was all, folks!"
 
diff --git a/haxe.html.markdown b/haxe.html.markdown
index 8599de8d..c807d2d7 100644
--- a/haxe.html.markdown
+++ b/haxe.html.markdown
@@ -3,6 +3,7 @@ language: haxe
 filename: LearnHaxe3.hx
 contributors:
     - ["Justin Donaldson", "https://github.com/jdonaldson/"]
+    - ["Dan Korostelev", "https://github.com/nadako/"]
 ---
 
 Haxe is a web-oriented language that provides platform support for C++, C#,
@@ -34,16 +35,20 @@ references.
 /*
    This is your first actual haxe code coming up, it's declaring an empty
    package.  A package isn't necessary, but it's useful if you want to create a
-   namespace for your code (e.g. org.module.ClassName).
+   namespace for your code (e.g. org.yourapp.ClassName).
+
+   Omitting package declaration is the same as declaring an empty package.
  */
 package; // empty package, no namespace.
 
 /*
-   Packages define modules for your code. Each module (e.g. org.module) must
-   be lower case, and should exist as a folder structure containing the class.
-   Class (and type) names must be capitalized. E.g, the class "org.module.Foo"
-   should have the folder structure org/module/Foo.hx, as accessible from the
-   compiler's working directory or class path.
+   Packages are directories that contain modules. Each module is a .hx file
+   that contains types defined in a package. Package names (e.g. org.yourapp)
+   must be lower case while module names are capitalized. A module contain one
+   or more types whose names are also capitalized.
+
+   E.g, the class "org.yourapp.Foo" should have the folder structure org/module/Foo.hx,
+   as accessible from the compiler's working directory or class path.
 
    If you import code from other files, it must be declared before the rest of
    the code.  Haxe provides a lot of common default classes to get you started:
@@ -53,6 +58,12 @@ import haxe.ds.ArraySort;
 // you can import many classes/modules at once with "*"
 import haxe.ds.*;
 
+// you can import static fields
+import Lambda.array;
+
+// you can also use "*" to import all static fields
+import Math.*;
+
 /*
    You can also import classes in a special way, enabling them to extend the
    functionality of other classes like a "mixin".  More on 'using' later.
@@ -172,7 +183,8 @@ class LearnHaxe3{
            Regexes are also supported, but there's not enough space to go into
            much detail.
          */
-        trace((~/foobar/.match('foo')) + " is the value for (~/foobar/.match('foo')))");
+        var re = ~/foobar/;
+        trace(re.match('foo') + " is the value for (~/foobar/.match('foo')))");
 
         /*
            Arrays are zero-indexed, dynamic, and mutable.  Missing values are
@@ -383,11 +395,7 @@ class LearnHaxe3{
         */
 
         // if statements
-        var k = if (true){
-            10;
-        } else {
-            20;
-        }
+        var k = if (true) 10 else 20;
 
         trace("K equals ", k); // outputs 10
 
@@ -628,6 +636,7 @@ enum ComplexEnum{
     ComplexEnumEnum(c:ComplexEnum);
 }
 // Note: The enum above can include *other* enums as well, including itself!
+// Note: This is what's called *Algebraic data type* in some other languages.
 
 class ComplexEnumTest{
     public static function example(){
diff --git a/java.html.markdown b/java.html.markdown
index ebe11bd3..10dd498c 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -103,15 +103,15 @@ public class LearnJava {
         // Arrays
         //The array size must be decided upon instantiation
         //The following formats work for declaring an array
-        //<datatype> [] <var name> = new <datatype>[<array size>];
+        //<datatype>[] <var name> = new <datatype>[<array size>];
         //<datatype> <var name>[] = new <datatype>[<array size>];
-        int [] intArray = new int[10];
-        String [] stringArray = new String[1];
-        boolean boolArray [] = new boolean[100];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
 
         // Another way to declare & initialize an array
-        int [] y = {9000, 1000, 1337};
-        String names [] = {"Bob", "John", "Fred", "Juan Pedro"};
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
         boolean bools[] = new boolean[] {true, false, false};
 
         // Indexing an array - Accessing an element
diff --git a/perl6.html.markdown b/perl6.html.markdown
index 85ab1d79..f0ef6600 100644
--- a/perl6.html.markdown
+++ b/perl6.html.markdown
@@ -560,7 +560,7 @@ subset VeryBigInteger of Int where * > 500;
 multi sub sayit(Int $n) { # note the `multi` keyword here
   say "Number: $n";
 }
-multi sayit(Str $s) } # a multi is a `sub` by default
+multi sayit(Str $s) { # a multi is a `sub` by default
   say "String: $s";
 }
 sayit("foo"); # prints "String: foo"
@@ -963,7 +963,7 @@ say join ',', gather if False {
 # But consider:
 constant thrice = gather for ^3 { say take $_ }; # Doesn't print anything
 # versus:
-constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2 3 4
+constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2
 
 # - `lazy` - Defer actual evaluation until value is fetched (forces lazy context)
 # Not yet implemented !!
diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/brainfuck-pt.html.markdown
new file mode 100644
index 00000000..72c2cf6e
--- /dev/null
+++ b/pt-br/brainfuck-pt.html.markdown
@@ -0,0 +1,84 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+lang: pt-pt
+---
+
+Brainfuck (em letras minúsculas, eceto no início de frases) é uma linguagem de
+programação Turing-completa extremamente simples com apenas 8 comandos.
+
+```
+Qualquer caractere exceto "><+-.,[]" (sem contar as aspas) é ignorado.
+
+Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
+e um ponteiro de dados que aponta para a célula atual.
+
+Existem 8 comandos:
++ : Incrementa o vaor da célula atual em 1.
+- : Decrementa o valor da célula atual em 1.
+> : Move o ponteiro de dados para a célula seguinte (célula à direita).
+< : Move o ponteiro de dados para a célula anterior (célula à esquerda).
+. : Imprime o valor ASCII da célula atual. (ex. 65 = 'A').
+, : Lê um único caractere para a célula atual.
+[ : Se o valor da célula atual for zero, salta para o ] correspondente.
+    Caso contrário, passa para a instrução seguinte.
+] : Se o valor da célula atual for zero, passa para a instrução seguinte.
+    Caso contrário, volta para a instrução relativa ao [ correspondente.
+
+[ e ] formam um ciclo while. Obviamente, devem ser equilibrados.
+
+Vamos ver alguns exemplos básicos em brainfuck:
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime a letra 'A'. Primeiro incrementa a célula #1 para 6.
+A célula #1 será usada num ciclo. Depois é iniciado o ciclo ([) e move-se
+o ponteiro de dados para a célula #2. O valor da célula #2 é incrementado 10
+vezes, move-se o ponteiro de dados de volta para a célula #1, e decrementa-se
+a célula #1. Este ciclo acontece 6 vezes (são necessários 6 decrementos para
+a célula #1 chegar a 0, momento em que se salta para o ] correspondente,
+continuando com a instrução seguinte).
+
+Nesta altura estamos na célula #1, cujo valor é 0, enquanto a célula #2
+tem o valor 60. Movemos o ponteiro de dados para a célula #2, incrementa-se 5
+vezes para um valor final de 65, e então é impresso o valor da célula #2. O valor
+65 corresponde ao caractere 'A' em ASCII, então 'A' é impresso no terminal.
+
+, [ > + < - ] > .
+
+Este programa lê um caractere e copia o seu valor para a célula #1. Um ciclo é
+iniciado. Movemos o ponteiro de dados para a célula #2, incrementamos o valor na
+célula #2, movemos o ponteiro de dados de volta para a célula #1 e finalmente
+decrementamos o valor na célula #1. Isto continua até o valor na célula #1 ser
+igual a 0 e a célula #2 ter o antigo valor da célula #1. Como o ponteiro de
+dados está apontando para a célula #1 no fim do ciclo, movemos o ponteiro para a
+célula #2 e imprimimos o valor em ASCII.
+
+Os espaços servem apenas para tornar o programa mais legível. Podemos escrever
+o mesmo programa da seguinte maneira:
+
+,[>+<-]>.
+
+Tente descobrir o que este programa faz:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa lê dois números e os multiplica.
+
+Basicamente o programa pede dois caracteres ao usuário. Depois é iniciado um
+ciclo exterior controlado pelo valor da célula #1. Movemos o ponteiro de dados
+para a célula #2 e inicia-se o ciclo interior controlado pelo valor da célula
+#2, incrementando o valor da célula #3. Porém existe um problema, no final do
+ciclo interior: a célula #2 tem o valor 0. Para resolver este problema o valor da
+célula #4 é também incrementado e copiado para a célula #2.
+```
+
+E isto é brainfuck. Simples, não? Por divertimento você pode escrever os
+seus próprios programas em brainfuck, ou então escrever um interpretador de
+brainfuck em outra linguagem. O interpretador é relativamente fácil de se
+implementar, mas caso você seja masoquista, tente escrever um interpretador de
+brainfuck… em brainfuck.
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
index 6d2a55cd..b8cbd0a9 100644
--- a/pt-br/git-pt.html.markdown
+++ b/pt-br/git-pt.html.markdown
@@ -1,110 +1,119 @@
 ---
 category: tool
 tool: git
+lang: pt-pt
+filename: LearnGit.txt
 contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
 translators:
-   	- ["Miguel Araújo", "https://github.com/miguelarauj1o"]
-lang: pt-br
-filename: learngit-pt.txt
+  - ["Suzane Sant Ana", "http://github.com/suuuzi"]
 ---
 
-Git é um sistema de controle de versão distribuído e de gerenciamento de código-fonte.
+Git é um sistema distribuido de gestão para código fonte e controle de versões.
 
-Ele faz isso através de uma série de momentos instantâneos de seu projeto, e ele funciona 
-com esses momentos para lhe fornecer a funcionalidade para a versão e 
-gerenciar o seu código-fonte.
+Funciona através de uma série de registos de estado do projeto e usa esse
+registo para permitir funcionalidades de versionamento e gestão de código
+fonte.
 
-## Versionando Conceitos
+## Conceitos de versionamento
 
-### O que é controle de versão?
+### O que é controle de versão
 
-O controle de versão é um sistema que registra alterações em um arquivo ou conjunto 
-de arquivos, ao longo do tempo.
+Controle de versão (*source control*) é um processo de registo de alterações
+a um arquivo ou conjunto de arquivos ao longo do tempo.
 
-### Versionamento Centralizado VS Versionamento Distribuído
+### Controle de versão:  Centralizado VS Distribuído
 
-* Controle de versão centralizado concentra-se na sincronização, controle e backup de arquivos.
-* Controle de versão distribuído concentra-se na partilha de mudanças. Toda mudança tem um ID único.
-* Sistemas Distribuídos não têm estrutura definida. Você poderia facilmente ter um estilo SVN, 
-sistema centralizado, com git.
+* Controle de versão centralizado foca na sincronização, registo e *backup*
+de arquivos.
+* Controle de versão distribuído foca em compartilhar alterações. Cada
+alteração é associada a um *id* único.
+* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema
+centralizado ao estilo SVN usando git.
 
-[Informação Adicional](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
 
-### Porque usar o Git?
+### Por que usar git?
 
-* Possibilidade de trabalhar offline
-* Colaborar com os outros é fácil!
-* Ramificação é fácil
-* Mesclagem é fácil
-* Git é rápido
-* Git é flexível.
+* Permite trabalhar offline.
+* Colaborar com outros é fácil!
+* Criar *branches* é fácil!
+* Fazer *merge* é fácil!
+* Git é rápido.
+* Git é flexivel.
+
+## Git - Arquitetura
 
-## Arquitetura Git
 
 ### Repositório
 
-Um conjunto de arquivos, diretórios, registros históricos, cometes, e cabeças. Imagine-o 
-como uma estrutura de dados de código-fonte, com o atributo que cada "elemento" do 
-código-fonte dá-lhe acesso ao seu histórico de revisão, entre outras coisas.
+Um conjunto de arquivos, diretórios, registos históricos, *commits* e
+referências. Pode ser descrito como uma estrutura de dados de código fonte
+com a particularidade de cada elemento do código fonte permitir acesso ao
+histórico das suas alterações, entre outras coisas.
 
-Um repositório git é composto do diretório git. e árvore de trabalho.
+Um repositório git é constituido pelo diretório .git e a *working tree*
 
 ### Diretório .git (componente do repositório)
 
-O diretório git. contém todas as configurações, registros, galhos, cabeça(HEAD) e muito mais.
-[Lista Detalhada](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+O repositório .git contém todas as configurações, *logs*, *branches*,
+referências e outros.
+
+[Lista detalhada (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
 
-### Árvore de trabalho (componente do repositório)
+### *Working Tree* (componente do repositório)
 
-Esta é, basicamente, os diretórios e arquivos no seu repositório. Ele é muitas vezes referida 
-como seu diretório de trabalho.
+A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto.
 
-### Índice (componente do diretório .git)
+### *Index* (componente do diretório .git)
 
-O Índice é a área de teste no git. É basicamente uma camada que separa a sua árvore de trabalho 
-a partir do repositório Git. Isso dá aos desenvolvedores mais poder sobre o que é enviado para o
-repositório Git.
+O *Index* é a camada da interface no git. É o elemento que separa
+o diretório do projeto do repositório git. Isto permite aos programadores um
+maior controle sobre o que é registado no repositório git.
 
-### Comete (commit)
+### *Commit*
 
-A commit git é um instantâneo de um conjunto de alterações ou manipulações a sua árvore de trabalho. 
-Por exemplo, se você adicionou 5 imagens, e removeu outros dois, estas mudanças serão contidas 
-em um commit (ou instantâneo). Esta confirmação pode ser empurrado para outros repositórios, ou não!
+Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto.
+Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações
+serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
+para outros repositórios ou não!
 
-### Ramo (branch)
+### *Branch*
 
-Um ramo é, essencialmente, um ponteiro que aponta para o último commit que você fez. Como 
-você se comprometer, este ponteiro irá atualizar automaticamente e apontar para o último commit.
+Um *branch* é essencialmente uma referência que aponta para o último *commit*
+efetuado. Na medida que são feitos novos commits, esta referência é atualizada
+automaticamente e passa a apontar para o commit mais recente.
 
-### Cabeça (HEAD) e cabeça (head) (componente do diretório .git)
+### *HEAD* e *head* (componentes do diretório .git)
 
-HEAD é um ponteiro que aponta para o ramo atual. Um repositório tem apenas 1 * ativo * HEAD. 
-head é um ponteiro que aponta para qualquer commit. Um repositório pode ter qualquer número de commits.
+*HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem
+uma *HEAD* activa.
+*head* é uma referência que aponta para qualquer *commit*. Um repositório pode
+ter um número indefinido de *heads*
 
-### Recursos Conceituais
+### Recursos conceituais (EN)
 
-* [Git para Cientistas da Computação](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git para Cientistas de Computação](http://eagain.net/articles/git-for-computer-scientists/)
 * [Git para Designers](http://hoth.entp.com/output/git_for_designers.html)
 
 ## Comandos
 
-### init
+### *init*
 
-Criar um repositório Git vazio. As configurações do repositório Git, informações armazenadas, 
-e mais são armazenados em um diretório (pasta) com o nome ". git".
+Cria um repositório Git vazio. As definições, informação guardada e outros do
+repositório git são guardados em uma pasta chamada ".git".
 
 ```bash
 $ git init
 ```
 
-### config
+### *config*
 
-Para configurar as definições. Quer seja para o repositório, o próprio sistema, ou 
-configurações globais.
+Permite configurar as definições, sejam as definições do repositório, sistema
+ou configurações globais.
 
 ```bash
-# Impressão e definir algumas variáveis de configuração básica (global)
+# Imprime e define algumas variáveis de configuração básicas (global)
 $ git config --global user.email
 $ git config --global user.name
 
@@ -112,22 +121,21 @@ $ git config --global user.email "MyEmail@Zoho.com"
 $ git config --global user.name "My Name"
 ```
 
-[Saiba mais sobre o git config.](http://git-scm.com/docs/git-config)
+[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
 
 ### help
 
-Para lhe dar um acesso rápido a um guia extremamente detalhada de cada comando. ou 
-apenas dar-lhe um rápido lembrete de algumas semânticas.
+Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica.
 
 ```bash
-# Rapidamente verificar os comandos disponíveis
+# Ver rapidamente os comandos disponiveis
 $ git help
 
-# Confira todos os comandos disponíveis
+# Ver todos os comandos disponiveis
 $ git help -a
 
-# Ajuda específica de comando - manual do usuário
-# git help <command_here>
+# Usar o *help* para um comando especifico
+# git help <comando_aqui>
 $ git help add
 $ git help commit
 $ git help init
@@ -135,85 +143,89 @@ $ git help init
 
 ### status
 
-Para mostrar as diferenças entre o arquivo de índice (basicamente o trabalho de 
-copiar/repo) e a HEAD commit corrente.
+Apresenta as diferenças entre o arquivo *index* (a versão corrente
+do repositório) e o *commit* da *HEAD* atual.
+
 
 ```bash
-# Irá exibir o ramo, os arquivos não monitorados, as alterações e outras diferenças
+# Apresenta o *branch*, arquivos não monitorados, alterações e outras
+# difereças
 $ git status
 
-# Para saber outras "tid bits" sobre git status
+# Para aprender mais detalhes sobre git *status*
 $ git help status
 ```
 
 ### add
 
-Para adicionar arquivos para a atual árvore/directory/repo trabalho. Se você não 
-der `git add` nos novos arquivos para o trabalhando árvore/diretório, eles não serão 
-incluídos em commits!
+Adiciona arquivos ao repositório corrente. Se os arquivos novos não forem
+adicionados através de `git add` ao repositório, então eles não serão
+incluidos nos commits!
 
 ```bash
-# Adicionar um arquivo no seu diretório de trabalho atual
+# adiciona um arquivo no diretório do projeto atual
 $ git add HelloWorld.java
 
-# Adicionar um arquivo em um diretório aninhado
+# adiciona um arquivo num sub-diretório
 $ git add /path/to/file/HelloWorld.c
 
-# Suporte a expressões regulares!
+# permite usar expressões regulares!
 $ git add ./*.java
 ```
 
 ### branch
 
-Gerenciar seus ramos. Você pode visualizar, editar, criar, apagar ramos usando este comando.
+Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este
+comando.
 
 ```bash
-# Lista ramos e controles remotos existentes
+# listar *branches* existentes e remotos
 $ git branch -a
 
-# Criar um novo ramo
+# criar um novo *branch*
 $ git branch myNewBranch
 
-# Apagar um ramo
+# apagar um *branch*
 $ git branch -d myBranch
 
-# Renomear um ramo
+# alterar o nome de um *branch*
 # git branch -m <oldname> <newname>
 $ git branch -m myBranchName myNewBranchName
 
-# Editar a descrição de um ramo
+# editar a descrição de um *branch*
 $ git branch myBranchName --edit-description
 ```
 
 ### checkout
 
-Atualiza todos os arquivos na árvore de trabalho para corresponder à versão no 
-índice, ou árvore especificada.
+Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
+à versão do index ou do *branch* especificado.
 
 ```bash
-# Finalizar um repo - padrão de ramo mestre
+# Checkout de um repositório - por padrão para o branch master
 $ git checkout
-# Checa um ramo especificado
+# Checkout de um branch especifico
 $ git checkout branchName
-# Criar um novo ramo e mudar para ela, como: "<nome> git branch; git checkout <nome>"
+# Cria um novo branch e faz checkout para ele.
+# Equivalente a: "git branch <name>; git checkout <name>"
 $ git checkout -b newBranch
 ```
 
 ### clone
 
-Clones, ou cópias, de um repositório existente para um novo diretório. Ele também adiciona 
-filiais remotas de rastreamento para cada ramo no repo clonado, que permite que você empurre 
-a um ramo remoto.
+Clona ou copia um repositório existente para um novo diretório. Também
+adiciona *branches* de monitoramento remoto para cada *branch* no repositório
+clonado o que permite enviar alterações para um *branch* remoto.
 
 ```bash
-# Clone learnxinyminutes-docs
+# Clona learnxinyminutes-docs
 $ git clone https://github.com/adambard/learnxinyminutes-docs.git
 ```
 
 ### commit
 
-Armazena o conteúdo atual do índice em um novo "commit". Este commit contém 
-as alterações feitas e uma mensagem criada pelo utilizador.
+Guarda o conteudo atual do index num novo *commit*. Este *commit* contém
+as alterações feitas e a mensagem criada pelo usuário.
 
 ```bash
 # commit com uma mensagem
@@ -222,170 +234,170 @@ $ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
 
 ### diff
 
-Mostra as diferenças entre um arquivo no diretório, o índice de trabalho e commits.
+Apresenta as diferenças entre um arquivo no repositório do projeto, *index*
+e *commits*
 
 ```bash
-# Mostrar diferença entre o seu diretório de trabalho e o índice.
+# Apresenta a diferença entre o diretório atual e o index
 $ git diff
 
-# Mostrar diferenças entre o índice e o commit mais recente.
+# Apresenta a diferença entre o index e os commits mais recentes
 $ git diff --cached
 
-# Mostrar diferenças entre o seu diretório de trabalho e o commit mais recente.
+# Apresenta a diferença entre o diretório atual e o commit mais recente
 $ git diff HEAD
 ```
 
 ### grep
 
-Permite procurar rapidamente um repositório.
+Permite procurar facilmente num repositório
 
 Configurações opcionais:
 
 ```bash
-# Obrigado ao Travis Jeffery por isto
-# Configure os números de linha a serem mostrados nos resultados de busca grep
+# Define a apresentação de números de linha nos resultados do grep
 $ git config --global grep.lineNumber true
 
-# Fazer resultados de pesquisa mais legível, incluindo agrupamento
+# Agrupa os resultados da pesquisa para facilitar a leitura
 $ git config --global alias.g "grep --break --heading --line-number"
 ```
 
 ```bash
-# Procure por "variableName" em todos os arquivos java
+# Pesquisa por "variableName" em todos os arquivos java
 $ git grep 'variableName' -- '*.java'
 
-# Procure por uma linha que contém "arrayListName" e "adicionar" ou "remover"
-$ git grep -e 'arrayListName' --and \( -e add -e remove \) 
+# Pesquisa por uma linha que contém "arrayListName" e "add" ou "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
 ```
 
-Google é seu amigo; para mais exemplos
-[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+O Google é seu amigo; para mais exemplos:
+[Git Grep Ninja (EN)](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
 
 ### log
 
-Mostrar commits para o repositório.
+Apresenta commits do repositório.
 
 ```bash
-# Mostrar todos os commits
+# Apresenta todos os commits
 $ git log
 
-# Mostrar um número X de commits
+# Apresenta X commits
 $ git log -n 10
 
-# Mostrar somente commits mesclados
+# Apresenta apenas commits de merge
 $ git log --merges
 ```
 
 ### merge
 
-"Merge" em mudanças de commits externos no branch atual.
+"Merge" junta as alterações de commits externos com o *branch* atual.
 
 ```bash
-# Mesclar o ramo especificado para o atual.
+# Junta o branch especificado com o atual
 $ git merge branchName
 
-# Gera sempre uma mesclagem commit ao mesclar
+# Para gerar sempre um commit ao juntar os branches
 $ git merge --no-ff branchName
 ```
 
 ### mv
 
-Renomear ou mover um arquivo
+Alterar o nome ou mover um arquivo.
 
 ```bash
-# Renomear um arquivo
+# Alterar o nome de um arquivo
 $ git mv HelloWorld.c HelloNewWorld.c
 
 # Mover um arquivo
 $ git mv HelloWorld.c ./new/path/HelloWorld.c
 
-# Força renomear ou mover
-# "ExistingFile" já existe no diretório, será substituído
+# Forçar a alteração de nome ou mudança local
+# "existingFile" já existe no directório, será sobrescrito.
 $ git mv -f myFile existingFile
 ```
 
 ### pull
 
-Puxa de um repositório e se funde com outro ramo.
+Puxa alterações de um repositório e as junta com outro branch
 
 ```bash
-# Atualize seu repo local, através da fusão de novas mudanças
-# A partir da "origem" remoto e ramo "master (mestre)".
+# Atualiza o repositório local, juntando as novas alterações
+# do repositório remoto 'origin' e branch 'master'
 # git pull <remote> <branch>
-# git pull => implícito por padrão => git pull origin master
+# git pull => aplica a predefinição => git pull origin master
 $ git pull origin master
 
-# Mesclar em mudanças de ramo remoto e rebase
-# Ramo commita em seu repo local, como: "git pull <remote> <branch>, git rebase <branch>"
+# Juntar alterações do branch remote e fazer rebase commits do branch
+# no repositório local, como: "git pull <remote> <branch>, git rebase <branch>"
 $ git pull origin master --rebase
 ```
 
 ### push
 
-Empurre e mesclar as alterações de uma ramificação para uma remota e ramo.
+Enviar e juntar alterações de um branch para o seu branch correspondente
+num repositório remoto.
 
 ```bash
-# Pressione e mesclar as alterações de um repo local para um 
-# Chamado remoto "origem" e ramo de "mestre".
+# Envia e junta as alterações de um repositório local
+# para um remoto denominado "origin" no branch "master".
 # git push <remote> <branch>
-# git push => implícito por padrão => git push origin master
+# git push => aplica a predefinição => git push origin master
 $ git push origin master
-
-# Para ligar atual filial local com uma filial remota, bandeira add-u:
-$ git push -u origin master
-# Agora, a qualquer hora que você quer empurrar a partir desse mesmo ramo local, uso de atalho:
-$ git push 
 ```
 
-### rebase (CAUTELA) 
+### rebase (cautela!)
 
-Tire todas as alterações que foram commitadas em um ramo, e reproduzi-las em outro ramo. 
-* Não rebase commits que você tenha empurrado a um repo público *.
+Pega em todas as alterações que foram registadas num branch e volta a
+aplicá-las em outro branch.
+*Não deve ser feito rebase de commits que foram enviados para um repositório
+público*
 
 ```bash
-# Rebase experimentBranch para mestre
+# Faz Rebase de experimentBranch para master
 # git rebase <basebranch> <topicbranch>
 $ git rebase master experimentBranch
 ```
 
-[Leitura Adicional.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+[Leitura adicional (EN).](http://git-scm.com/book/en/Git-Branching-Rebasing)
 
-### reset (CAUTELA)
+### reset (cuidado!)
 
-Repor o atual HEAD de estado especificado. Isto permite-lhe desfazer fusões (merge), 
-puxa (push), commits, acrescenta (add), e muito mais. É um grande comando, mas também 
-perigoso se não saber o que se está fazendo.
+Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*,
+*pulls*, *commits*, *adds* e outros. É um comando muito poderoso mas também
+perigoso quando não há certeza do que se está fazendo.
 
 ```bash
-# Repor a área de teste, para coincidir com o último commit (deixa diretório inalterado)
+# Restabelece a camada intermediária de registo para o último
+# commit (o directório fica sem alterações)
 $ git reset
 
-# Repor a área de teste, para coincidir com o último commit, e substituir diretório trabalhado
+# Restabelece a camada intermediária de registo para o último commit, e
+# sobrescreve o projeto atual
 $ git reset --hard
 
-# Move a ponta ramo atual para o especificado commit (deixa diretório inalterado)
-# Todas as alterações ainda existem no diretório.
+# Move a head do branch atual para o commit especificado, sem alterar o projeto.
+# todas as alterações ainda existem no projeto
 $ git reset 31f2bb1
 
-# Move a ponta ramo atual para trás, para o commit especificado
-# E faz o jogo dir trabalho (exclui mudanças não commitadas e todos os commits
-# Após o commit especificado).
+# Inverte a head do branch atual para o commit especificado
+# fazendo com que este esteja em sintonia com o diretório do projeto
+# Remove alterações não registadas e todos os commits após o commit especificado
 $ git reset --hard 31f2bb1
 ```
 
 ### rm
 
-O oposto do git add, git rm remove arquivos da atual árvore de trabalho.
+O oposto de git add, git rm remove arquivos do branch atual.
 
 ```bash
 # remove HelloWorld.c
 $ git rm HelloWorld.c
 
-# Remove um arquivo de um diretório aninhado
+# Remove um arquivo de um sub-directório
 $ git rm /pather/to/the/file/HelloWorld.c
 ```
 
-# # Mais informações
+## Informação complementar (EN)
 
 * [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
 
@@ -398,5 +410,3 @@ $ git rm /pather/to/the/file/HelloWorld.c
 * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
 
 * [GitGuys](http://www.gitguys.com/)
-
-* [Git - guia prático](http://rogerdudler.github.io/git-guide/index.pt_BR.html)
-\ No newline at end of file
diff --git a/pt-pt/git-pt.html.markdown b/pt-pt/git-pt.html.markdown
index 66cda07f..a85c9704 100644
--- a/pt-pt/git-pt.html.markdown
+++ b/pt-pt/git-pt.html.markdown
@@ -74,8 +74,7 @@ maior controlo sobre o que é registado no repositório git.
 
 ### *Commit*
 
-Um *commit** de git é um registo de um cojunto de alterações ou manipulações
-no nos ficheiros do projecto.
+Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos ficheiros do projecto.
 Por exemplo, ao adicionar cinco ficheiros e remover outros 2, estas alterações
 serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
 para outros repositórios ou não!
@@ -83,7 +82,7 @@ para outros repositórios ou não!
 ### *Branch*
 
 Um *branch* é essencialmente uma referência que aponta para o último *commit*
-efetuado. à medida que são feitos novos commits, esta referência é atualizada
+efetuado. À medida que são feitos novos commits, esta referência é atualizada
 automaticamente e passa a apontar para o commit mais recente.
 
 ### *HEAD* e *head* (componentes do directório .git)
@@ -115,7 +114,7 @@ Permite configurar as definições, sejam as definições do repositório, siste
 ou configurações globais.
 
 ```bash
-# Imprime & Define Algumas Variáveis de Configuração Básicas (Global)
+# Imprime e define algumas variáveis de configuração básicas (global)
 $ git config --global user.email
 $ git config --global user.name
 
@@ -123,7 +122,7 @@ $ git config --global user.email "MyEmail@Zoho.com"
 $ git config --global user.name "My Name"
 ```
 
-[Aprenda Mais Sobre git config. (EN)](http://git-scm.com/docs/git-config)
+[Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
 
 ### help
 
@@ -166,7 +165,7 @@ adicionados através de `git add` ao repositório, então eles não serão
 incluidos nos commits!
 
 ```bash
-# adiciona um ficheiro no directório do project atual
+# adiciona um ficheiro no directório do projecto atual
 $ git add HelloWorld.java
 
 # adiciona um ficheiro num sub-directório
@@ -371,7 +370,7 @@ Restabelece a HEAD atual ao estado definido. Isto permite reverter *merges*,
 perigoso se não há certeza quanto ao que se está a fazer.
 
 ```bash
-# Restabelece a camada intermediária dr registo para o último
+# Restabelece a camada intermediária de registo para o último
 # commit (o directório fica sem alterações)
 $ git reset
 
diff --git a/python.html.markdown b/python.html.markdown
index da04d381..478804cd 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -14,7 +14,7 @@ executable pseudocode.
 Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
 
 Note: This article applies to Python 2.7 specifically, but should be applicable
-to Python 2.x. For Python 3.x, take a look at the Python 3 tutorial.
+to Python 2.x. For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
 
 ```python
 
diff --git a/python3.html.markdown b/python3.html.markdown
index 6b1d3156..56126ad3 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -13,7 +13,7 @@ executable pseudocode.
 
 Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
 
-Note: This article applies to Python 3 specifically. Check out the other tutorial if you want to learn the old Python 2.7
+Note: This article applies to Python 3 specifically. Check out [here](http://learnxinyminutes.com/docs/python/) if you want to learn the old Python 2.7
 
 ```python
 
@@ -276,7 +276,7 @@ empty_set = set()
 # Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
 some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
 
-#Can set new variables to a set
+# Can set new variables to a set
 filled_set = some_set
 
 # Add one more item to the set 
@@ -394,7 +394,6 @@ our_iterator.__next__() # Raises StopIteration
 list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
 
 
-
 ####################################################
 ## 4. Functions
 ####################################################
@@ -410,7 +409,6 @@ add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
 # Another way to call functions is with keyword arguments
 add(y=6, x=5)   # Keyword arguments can arrive in any order.
 
-
 # You can define functions that take a variable number of
 # positional arguments
 def varargs(*args):
@@ -418,7 +416,6 @@ def varargs(*args):
 
 varargs(1, 2, 3)   # => (1, 2, 3)
 
-
 # You can define functions that take a variable number of
 # keyword arguments, as well
 def keyword_args(**kwargs):
@@ -501,7 +498,9 @@ class Human(object):
     # Basic initializer, this is called when this class is instantiated.
     # Note that the double leading and trailing underscores denote objects
     # or attributes that are used by python but that live in user-controlled
-    # namespaces. You should not invent such names on your own.
+    # namespaces. Methods(or objects or attributes) like: __init__, __str__, 
+    # __repr__ etc. are called magic methods (or sometimes called dunder methods)  
+    # You should not invent such names on your own.
     def __init__(self, name):
         # Assign the argument to the instance's name attribute
         self.name = name
@@ -636,6 +635,7 @@ print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
 * [The Official Docs](http://docs.python.org/3/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
 
 ### Dead Tree
 
diff --git a/ruby.html.markdown b/ruby.html.markdown
index 1883d1ad..792c9c95 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -11,6 +11,7 @@ contributors:
   - ["Ariel Krakowski", "http://www.learneroo.com"]
   - ["Dzianis Dashkevich", "https://github.com/dskecse"]
   - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
 
 ---
 
@@ -169,6 +170,9 @@ array[1..3] #=> [2, 3, 4]
 # Add to an array like this
 array << 6 #=> [1, 2, 3, 4, 5, 6]
 
+# Check if an item exists in an array
+array.include?(1) #=> true
+
 # Hashes are Ruby's primary dictionary with keys/value pairs.
 # Hashes are denoted with curly braces:
 hash = { 'color' => 'green', 'number' => 5 }
@@ -188,6 +192,10 @@ new_hash = { defcon: 3, action: true }
 
 new_hash.keys #=> [:defcon, :action]
 
+# Check existence of keys and values in hash
+new_hash.has_key?(:defcon) #=> true
+new_hash.has_value?(3) #=> true
+
 # Tip: Both Arrays and Hashes are Enumerable
 # They share a lot of useful methods such as each, map, count, and more