Updates

README.markdown

@@ -9,18 +9,47 @@ commented code and explained as they go.
 ... to write more inline code tutorials. Just grab an existing file from
 this repo and copy the formatting (don't worry, it's all very simple).
 Make a new file, send a pull request, and if it passes muster I'll get it up pronto.
-Remember to fill in the author and author\_url fields so you get credited
+Remember to fill in the "contributors" fields so you get credited
 properly!
 
 ### Requests
 
-The most requested languages are:
+We've had a ton of interest, b
 
-* Go
+### Contributing
-* ~~Scala~~
-* ~~Javascript~~
 
-... but there are many more requests to do "every language", so don't let that stop you.
+All contributions welcome, from the tiniest typo to a brand new article. Translations
+in all languages are welcome (or, for that matter, original articles in any language).
+
+#### Style Guidelines
+
+* Try to keep **line length in code blocks to 80 characters or fewer**, or they'll overflow
+  and look odd.
+
+* Try to use as few words as possible. Code examples are preferred over exposition in all cases.
+
+* We welcome newcomers, but the target audience for this site is programmers with some experience.
+  So, try to avoid explaining basic concepts except for those specific to the language in question,
+  to keep articles succinct and scannable. We all know how to use google here.
+
+* For translations (or english articles with non-ASCII characters), please make sure your file is
+  utf-8 encoded.
+
+#### Header configuration
+
+The actual site uses Middleman to generate HTML files from these markdown ones. Middleman, or at least
+the custom scripts underpinning the site, required that some key information be defined in the header.
+
+The following fields are necessary for english articles about programming languages:
+
+* **language** The *programming language* in question
+* **contributors** A list of [author, url] lists to credit
+
+Other fields:
+
+* **filename**: The filename for this article's code. It will be fetched, mashed together, and made downloadable.
+  For non-english articles, *filename* should have a language-specific suffix.
+* **lang**: For translations, the human language this article is in. For categorization, mostly.
 
 ## License
 

bash.html.markdown

@@ -1,8 +1,10 @@
 ---
 
-language: bash
+category: tool
+tool: bash
 contributors:
-    - ["Max Yankov", "https://github.com/golergka" - "Darren Lin", "https://github.com/CogBear"]
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
 filename: LearnBash.sh
 
 ---
@@ -14,7 +16,8 @@ Nearly all examples below can be a part of a shell script or executed directly i
 
 ```bash
 #!/bin/sh
-# First line of the script is shebang which tells the system how to execute the script: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# First line of the script is shebang which tells the system how to execute
+# the script: http://en.wikipedia.org/wiki/Shebang_(Unix)
 # As you already figured, comments start with #. Shebang is also a comment.
 
 # Simple hello world example:
@@ -27,12 +30,15 @@ echo 'This is the first line'; echo 'This is the second line'
 VARIABLE="Some string"
 
 # But not like this:
-VARIABLE = "Some string" # Bash will decide that VARIABLE is a command he must execute and give an error because it couldn't be found.
+VARIABLE = "Some string"
+# Bash will decide that VARIABLE is a command it must execute and give an error
+# because it couldn't be found.
 
 # Using the variable:
 echo $VARIABLE
 echo "$VARIABLE"
-# When you use the variable itself — assign it, export it, or else — you write it's name without $. If you want to use variable's value, you should use $.
+# When you use the variable itself — assign it, export it, or else — you write
+# its name without $. If you want to use variable's value, you should use $.
 
 # Reading a value from input:
 echo "What's your name?"
@@ -50,19 +56,22 @@ fi
 # Expressions are denoted with the following format:
 echo $(( 10 + 5 ))
 
-# Unlike other programming languages, bash is a shell — so it works in a context of current directory.
+# Unlike other programming languages, bash is a shell — so it works in a context
-# You can list files and directories in the current directories with ls command:
+# of current directory. You can list files and directories in the current
+# directories with ls command:
 ls
 
 # These commands have options that control their execution:
 ls -l # Lists every file and directory on a separate line
 
 # Results of the previous command can be passed to the next command as input.
-# grep command filters the input with provided patterns. That's how we can list txt files in the current directory:
+# grep command filters the input with provided patterns. That's how we can list
+# txt files in the current directory:
 ls -l | grep "\.txt"
 
 # Commands can be substitued within other commands using $( ):
-# The following command displays the number of files and directories in the current directory.
+# The following command displays the number of files and directories in the
+# current directory.
 echo "There are $(ls | wc -l) items here."
 
 # Bash uses a case statement that works similarily to switch in Java and C++:

groovy.html.markdown

@@ -112,14 +112,31 @@ println devMap.values()
 
   When Groovy is compiled to bytecode, the following rules are used.
 
-    * If the name is declared with an access modifier (public, private or protected) then a field is generated.
+    * If the name is declared with an access modifier (public, private or
-    * A name declared with no access modifier generates a private field with public getter and setter (i.e. a property).
+      protected) then a field is generated.
-    * If a property is declared final the private field is created final and no setter is generated.
+
+    * A name declared with no access modifier generates a private field with
+      public getter and setter (i.e. a property).
+
+    * If a property is declared final the private field is created final and no
+      setter is generated.
+
     * You can declare a property and also declare your own getter or setter.
-    * You can declare a property and a field of the same name, the property will use that field then.
+
-    * If you want a private or protected property you have to provide your own getter and setter which must be declared private or protected.
+    * You can declare a property and a field of the same name, the property will
-    * If you access a property from within the class the property is defined in at compile time with implicit or explicit this (for example this.foo, or simply foo), Groovy will access the field directly instead of going though the getter and setter.
+      use that field then.
-    * If you access a property that does not exist using the explicit or implicit foo, then Groovy will access the property through the meta class, which may fail at runtime.
+
+    * If you want a private or protected property you have to provide your own
+      getter and setter which must be declared private or protected.
+
+    * If you access a property from within the class the property is defined in
+      at compile time with implicit or explicit this (for example this.foo, or
+      simply foo), Groovy will access the field directly instead of going though
+      the getter and setter.
+
+    * If you access a property that does not exist using the explicit or
+      implicit foo, then Groovy will access the property through the meta class,
+      which may fail at runtime.
 
 */
 
@@ -185,13 +202,14 @@ for ( e in map ) {
 /*
   Operators
 
-  Operator Overloading for a list of the common operators that Groovy supports: http://groovy.codehaus.org/Operator+Overloading
+  Operator Overloading for a list of the common operators that Groovy supports:
+  http://groovy.codehaus.org/Operator+Overloading
 
   Helpful groovy operators
 */
 //Spread operator:  invoke an action on all items of an aggregate object.
 def technologies = ['Groovy','Grails','Gradle']
-technologies*.toUpperCase() //equivalent to: technologies.collect { it?.toUpperCase() }
+technologies*.toUpperCase() // = to technologies.collect { it?.toUpperCase() }
 
 //Safe navigation operator: used to avoid a NullPointerException.
 def user = User.get(1)
@@ -200,7 +218,8 @@ def username = user?.username
 
 /*
   Closures
-  A Groovy Closure is like a "code block" or a method pointer. It is a piece of code that is defined and then executed at a later point.
+  A Groovy Closure is like a "code block" or a method pointer. It is a piece of
+  code that is defined and then executed at a later point.
 
   More info at: http://groovy.codehaus.org/Closures+-+Formal+Definition
 */
@@ -219,16 +238,13 @@ def x = 5
 def multiplyBy = { num -> num * x }
 println multiplyBy(10)
 
-//If you have a Closure that takes a single argument, you may omit the parameter definition of the Closure
+// If you have a Closure that takes a single argument, you may omit the
+// parameter definition of the Closure
 def clos = { print it }
 clos( "hi" )
 
 /*
-  Groovy can memorize closure results:
+  Groovy can memorize closure results [1][2][3]
-  More info at:
-            http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
-            http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
-            http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
 */
 def cl = {a, b ->
     sleep(3000) // simulate some time consuming processing
@@ -256,9 +272,10 @@ callClosure(3, 4)
 /*
   Expando
 
-  The Expando class is a dynamic bean so we can add properties and we can add closures as methods to an instance of this class
+  The Expando class is a dynamic bean so we can add properties and we can add
+  closures as methods to an instance of this class
 
-  Reference: http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+  http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
 */
   def user = new Expando(name:"Roberto")
   assert 'Roberto' == user.name
@@ -310,7 +327,8 @@ assertEquals "boo", f.boo
 
 /*
   TypeChecked and CompileStatic
-  Groovy, by nature, is and will always be a dynamic language but it supports typechecked and compilestatic
+  Groovy, by nature, is and will always be a dynamic language but it supports
+  typechecked and compilestatic
 
   More info: http://www.infoq.com/articles/new-groovy-20
 */
@@ -373,7 +391,9 @@ Join a [Groovy user group](http://groovy.codehaus.org/User+Groups)
 
 * [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do)
 
-
+[1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
+[2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
+[3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
 
 
 

hu-hu/go.html.markdown

@@ -1,8 +1,7 @@
 ---
-name: Go
-category: language
 language: Go
-filename: learngo.go
+lang: hu-hu
+filename: learngo-hu.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
 translators:
@@ -20,16 +19,19 @@ a mai számítógépek több magos processzorait, ez nagy rendszerek építésé
 
 A Go alap könyvtára mindenre területre kiterjed, ennek köszönhetően a nyelvnek egyre növekvő tábora van.
 
-```Go
+```go
 // Egy soros komment
 /* Több
    soros komment */
 
-// Minden forrás fájl egy csomag-definícióval kezdődik, ez hasonlít a Python csomagkezelésére
+// Minden forrás fájl egy csomag-definícióval kezdődik, ez hasonlít a Python
-// A main egy különleges csomagnév, ennek a fordítása futtatható állományt hoz létre egy könyvtár helyett.
+// csomagkezelésére
+// A main egy különleges csomagnév, ennek a fordítása futtatható állományt hoz
+// létre egy könyvtár helyett.
 package main
 
-// Az import rész meghatározza melyik csomagokat kívánjuk használni ebben a forrásfájlban
+// Az import rész meghatározza melyik csomagokat kívánjuk használni ebben a
+// forrásfájlban
 import (
     "fmt"      // A Go alap könyvtárának része
     "net/http" // Beépített webszerver!
@@ -39,7 +41,8 @@ import (
 // Funkció deklarás, a main nevű funkció a program kezdőpontja.
 func main() {
     // Println kiírja a beadott paramétereket a standard kimenetre.
-	// Ha más csomagot funkcióját akarjuk használni, akkor azt jelezni kell a csomag nevével
+    // Ha más csomagot funkcióját akarjuk használni, akkor azt jelezni kell a
+    // csomag nevével
     fmt.Println("Hello world!")
 
     // Meghívunk egy másik funkciót ebből a csomagból
@@ -51,9 +54,11 @@ func main() {
 func beyondHello() {
     var x int // Változó deklaráció, használat előtt muszáj ezt megtenni.
     x = 3     // Változó értékadás
-	// "Rövid" deklaráció is létezik, ez az érték alapján deklarálja, definiálja és értéket is ad a változónak
+    // "Rövid" deklaráció is létezik, ez az érték alapján deklarálja,
+    // definiálja és értéket is ad a változónak
     y := 4
-	sum, prod := learnMultiple(x, y)        // a függvényeknek több visszatérési értéke is lehet
+    sum, prod := learnMultiple(x, y)        // a függvényeknek több
+                                            // visszatérési értéke is lehet
     fmt.Println("sum:", sum, "prod:", prod) // egyszerű kiíratás
     learnTypes()
 }
@@ -76,16 +81,20 @@ func learnTypes() {
     s := "Tanulj Go-t!" // string típus
 
     s2 := `A "nyers" stringekben lehetnek
-	újsorok is!` // de ettől még ez is ugyanolyan string mint az s, nincs külön típusa
+    újsorok is!` // de ettől még ez is ugyanolyan string mint az s, nincs külön
+                 // típusa
 
     // nem ASCII karakterek.  Minden Go forrás UTF-8 és a stringek is azok.
-	g := 'Σ' // rúna(rune) típus, megegyezik az uint32-vel, egy UTF-8 karaktert tárol
+    g := 'Σ' // rúna(rune) típus, megegyezik az uint32-vel, egy UTF-8 karaktert
+             // tárol
 
-	f := 3.14195 // float64, az IEEE-754 szabványnak megfelelő 64-bites lebegőpontos szám
+    f := 3.14195 // float64, az IEEE-754 szabványnak megfelelő 64-bites
+                 // lebegőpontos szám
     c := 3 + 4i  // complex128, belsőleg két float64-el tárolva
 
     // Var szintaxis változó típus definiálással
-	var u uint = 7 // unsigned, az implementáció dönti el mekkora, akárcsak az int-nél
+    var u uint = 7 // unsigned, az implementáció dönti el mekkora, akárcsak az
+                   // int-nél
     var pi float32 = 22. / 7
 
     // Rövid deklarásnál átalakítás is lehetséges
@@ -93,10 +102,11 @@ func learnTypes() {
 
     // A tömböknek fordítás-időben fixált méretük van
     var a4 [4]int           // egy tömb 4 int-tel, mind 0-ra inicializálva
-	a3 := [...]int{3, 1, 5} // egy tömb 3 int-tel, láthatóan inicalizálva egyedi értékekre
+    a3 := [...]int{3, 1, 5} // egy tömb 3 int-tel, láthatóan inicalizálva egyedi
+                            // értékekre
 
-	// Szeleteknek dinamikus a méretük. A szeleteknek és a tömböknek is meg vannak az előnyeik
+    // Szeleteknek dinamikus a méretük. A szeleteknek és a tömböknek is meg
-	// de a szeleteket sokkal gyakrabban használjuk.
+    // vannak az előnyeik de a szeleteket sokkal gyakrabban használjuk.
     s3 := []int{4, 5, 9}    // vesd össze a3-al, nincsenek pontok.
     s4 := make([]int, 4)    // allokál 4 int-et, mind 0-ra inicializálva
     var d2 [][]float64      // ez csak deklaráció, semmi sincs még allokálva
@@ -119,11 +129,13 @@ func learnTypes() {
     learnFlowControl()
 }
 
-// A Go nyelv teljesen szemétgyűjtött (garbage-collected). Megtalálhatók benne mutatók, de nincs mutató aritmetika.
+// A Go nyelv teljesen szemétgyűjtött (garbage-collected). Megtalálhatók benne
-// Ez azt jelenti, hogy üres mutatóval még mindig hibázhatsz, de hozzáadni/műveleteket végezni már nem lehet.
+// mutatók, de nincs mutató aritmetika. Ez azt jelenti, hogy üres mutatóval még
+// mindig hibázhatsz, de hozzáadni/műveleteket végezni már nem lehet.
 func learnMemory() (p, q *int) {
     // Elnevezett visszatérési változóknak int-re mutató a típusa
-	p = new(int) // a beépített "new" funkció, egy típusnak elegendő memóriát allokál, és visszaad rá egy mutatót.
+    p = new(int) // a beépített "new" funkció, egy típusnak elegendő memóriát
+                 // allokál, és visszaad rá egy mutatót.
     // Az allokált int nullázva van, p többé nem üres mutató.
     s := make([]int, 20) // allokáljunk 20 int változót egy memóriaterületen.
     s[3] = 7             // adjunk értéket az egyiknek
@@ -140,7 +152,8 @@ func learnFlowControl() {
     if true {
         fmt.Println("megmondtam")
     }
-	// A kód formátumát a nyelvvel járó "go" parancssori program "go fmt" parancsa szabványosítja
+    // A kód formátumát a nyelvvel járó "go" parancssori program "go fmt"
+    // parancsa szabványosítja
     if false {
         // így lehet
     } else {
@@ -166,8 +179,9 @@ func learnFlowControl() {
         break    // csak vicceltem
         continue // soha nem fut le
     }
-	// Akárcsak a for-nál, az if-ben is lehet rövid deklarással egy lokális változót létrehozni
+    // Akárcsak a for-nál, az if-ben is lehet rövid deklarással egy lokális
-	// ami az blokk összes if/else-n keresztül érvényes marad.
+    // változót létrehozni ami az blokk összes if/else-n keresztül érvényes
+    // marad.
     if y := expensiveComputation(); y > x {
         x = y
     }
@@ -186,20 +200,23 @@ love:
     learnInterfaces() // Itt kezdődnek az érdekes dolgok!
 }
 
-// Definiáljuk a Stringert egy olyan interfésznek, amelynek egy metódusa van, a String, ami visszatér egy stringgel.
+// Definiáljuk a Stringert egy olyan interfésznek, amelynek egy metódusa van, a
+// String, ami visszatér egy stringgel.
 type Stringer interface {
     String() string
 }
 
-// Definiáljuk a pair-t egy olyan struktúrának amelynek két int változója van, x és y.
+// Definiáljuk a pair-t egy olyan struktúrának amelynek két int változója van,
+// x és y.
 type pair struct {
     x, y int
 }
 
-// Definiáljunk egy metódust a pair struktúrának, ezzel teljesítve a Stringer interf
+// Definiáljunk egy metódust a pair struktúrának, ezzel teljesítve a Stringer
+// interf
 func (p pair) String() string { // p lesz a "vevő"
-	// Sprintf az fmt csomag egy publikus függvénye, műkődése megegyezik a C-s megfelelőjével.
+    // Sprintf az fmt csomag egy publikus függvénye, műkődése megegyezik a C-s
-	// A pontokkal érjük el a mindenkori p struktúra elemeit
+    // megfelelőjével. A pontokkal érjük el a mindenkori p struktúra elemeit
     return fmt.Sprintf("(%d, %d)", p.x, p.y)
 }
 
@@ -209,13 +226,15 @@ func learnInterfaces() {
     p := pair{3, 4}
     fmt.Println(p.String()) // meghívjuk a p String metódusát.
     var i Stringer          // deklaráljuk i-t Stringer típusú interfésznek
-	i = p                   // lehetséges, mert a pair struktúra eleget tesz a Stringer interfésznek
+    i = p                   // lehetséges, mert a pair struktúra eleget tesz a
+                            // Stringer interfésznek
     // Meghívjuk i String metódusát, az eredmény ugyanaz, mint az előbb.
     fmt.Println(i.String())
 
     // Az fmt csomag funckciói  automatikusan meghívják a String funkciót
     // hogy megtudják egy objektum szöveges reprezentációját.
-	fmt.Println(p) // ugyan az az eredmény mint az előbb, a Println meghívja a String metódust.
+    fmt.Println(p) // ugyan az az eredmény mint az előbb, a Println meghívja
+                   // a String metódust.
     fmt.Println(i) // dettó
 
     learnErrorHandling()
@@ -229,8 +248,11 @@ func learnErrorHandling() {
     } else {
         fmt.Print(x) // x lenne az érték, ha benne lenne a map-ban.
     }
-	// A hiba érték többet is elmond a függvény kimeneteléről, mint hogy minden "ok" volt-e
+    // A hiba érték többet is elmond a függvény kimeneteléről, mint hogy minden
-	if _, err := strconv.Atoi("non-int"); err != nil { // _ eldobja az értéket, úgy se lesz jó jelen esetben
+    // "ok" volt-e
+    if _, err := strconv.Atoi("non-int"); err != nil { // _ eldobja az értéket,
+                                                       // úgy se lesz jó jelen
+                                                       // esetben
         // kiírja, hogy "strconv.ParseInt: parsing "non-int": invalid syntax"
         fmt.Println(err)
     }
@@ -240,7 +262,8 @@ func learnErrorHandling() {
 
 // c egy csatorna, egy konkurens-biztos kommunikációs objektum.
 func inc(i int, c chan int) {
-	c <- i + 1 // <- a "küldés" operátor, ha a bal oldalán csatorna van, így i+1-et küld be a csatornába
+    c <- i + 1 // <- a "küldés" operátor, ha a bal oldalán csatorna van, így
+               // i+1-et küld be a csatornába
 }
 
 // Az inc-et fogjuk arra használni, hogy konkurensen megnöveljünk számokat
@@ -249,21 +272,26 @@ func learnConcurrency() {
     // Make allokál mapokat, szeleteket és csatornákat.
     c := make(chan int)
     // Indítsunk három konkurens goroutine-t.  A számok konkurensen lesznek 
-	// megnövelve, ha a számítógép képes rá és jól be van állítva, akkor pedig paralellizálva/egymás mellett.
+    // megnövelve, ha a számítógép képes rá és jól be van állítva, akkor pedig
-	// Mind a 3 ugyanabba a csatornába küldi az eredményeket.
+    // paralellizálva/egymás mellett. Mind a 3 ugyanabba a csatornába küldi az
+    // eredményeket.
     go inc(0, c) // A go utasítás indít el goroutine-okat.
     go inc(10, c)
     go inc(-805, c)
     // Beolvassuk 3x a csatornából az eredményeket és kiírjuk őket a kimenetre.
     // Nem lehet tudni milyen sorrendben fognak érkezni az eredmények!
-	fmt.Println(<-c, <-c, <-c) // hogyha a jobb oldalon csatorna van, akkor a "<-" a beolvasó/kapó operátor
+    fmt.Println(<-c, <-c, <-c) // hogyha a jobb oldalon csatorna van, akkor a 
+                               // "<-" a beolvasó/kapó operátor
 
     cs := make(chan string)       // még egy csatorna, ez stringekkel kommunikál
     cc := make(chan chan string)  // egy csatorna csatornával
-	go func() { c <- 84 }()       // indítsunk egy új goroutine-t, csak azért hogy küldjünk egy számot
+    go func() { c <- 84 }()       // indítsunk egy új goroutine-t, csak azért
-	go func() { cs <- "wordy" }() // ugyanez, csak a cs csatornába stringet küldünk
+                                  // hogy küldjünk egy számot
-	// A select olyan mint a switch, csak feltételek helyett csatorna műveletek vannak.
+    go func() { cs <- "wordy" }() // ugyanez, csak a cs csatornába stringet
-	// Véletlenszerűen kiválasztja az első olyan esetet, ahol létrejöhet kommunikáció.
+                                  // küldünk
+    // A select olyan mint a switch, csak feltételek helyett csatorna műveletek
+    // vannak. Véletlenszerűen kiválasztja az első olyan esetet, ahol létrejöhet
+    // kommunikáció.
     select {
     case i := <-c: // a megkapott értéket el lehet tárolni egy változóban
         fmt.Println("ez egy", i)
@@ -273,7 +301,8 @@ func learnConcurrency() {
         fmt.Println("sose futok le :'( ")
     }
     // Ezen a ponton vagy c vagy a cs goroutineja lefutott.
-	// Amelyik hamarabb végzett, annak a megfelelő case-e lefutott, a másik blokkolva vár.
+    // Amelyik hamarabb végzett, annak a megfelelő case-e lefutott, a másik
+    // blokkolva vár.
 
     learnWebProgramming() // Go képes rá. Te is képes akarsz rá lenni.
 }
@@ -286,7 +315,8 @@ func learnWebProgramming() {
     fmt.Println(err) // nem felejtük el kiírni az esetleges hibákat!
 }
 
-// Csináljunk a pair-ból egy http.Handler-t úgy, hogy implementáljuk az egyetlen metódusát a ServeHTTP-t.
+// Csináljunk a pair-ból egy http.Handler-t úgy, hogy implementáljuk az
+// egyetlen metódusát a ServeHTTP-t.
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     // Minden kapcsolatra elküldjük ezt a http.ResponseWriter-el
     w.Write([]byte("Megtanultad a Go-t Y perc alatt!"))