Merge remote-tracking branch 'adambard/master'

402 files changed, 72613 insertions, 3853 deletions

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..183b7cdb
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,65 @@
+asciidoc*.html.markdown linguist-language=AsciiDoc
+angularjs*.html.markdown linguist-language=JavaScript
+bash*.html.markdown linguist-language=bash
+bf.html.markdown linguist-language=Brainfuck
+bf-*.html.markdown linguist-language=Brainfuck
+c-*.html.markdown linguist-language=C
+c.html.markdown linguist-language=C
+c++*.html.markdown linguist-language=C++
+chapel*.html.markdown linguist-language=Chapel
+clojure*.html.markdown linguist-language=Clojure
+cmake*.html.markdown linguist-language=CMake
+coffeescript*.html.markdown linguist-language=CoffeeScript
+coldfusion*.html.markdown linguist-language=ColdFusion
+common-lisp*.html.markdown linguist-language=lisp
+compojure*.html.markdown linguist-language=Clojure
+csharp*.html.markdown linguist-language=C#
+css*.html.markdown linguist-language=CSS
+d.html.markdown linguist-language=D
+d-*.html.markdown linguist-language=D
+dart*.html.markdown linguist-language=Dart
+edn*.html.markdown linguist-language=edn
+elisp*.html.markdown linguist-language=elisp
+elixir*.html.markdown linguist-language=Elixir
+elm*.html.markdown linguist-language=Elm
+erlang*.html.markdown linguist-language=Erlang
+factor*.html.markdown linguist-language=Factor
+forth*.html.markdown linguist-language=Forth
+fortran*.html.markdown linguist-language=FORTRAN
+fsharp*.html.markdown linguist-language=fsharp
+go.html.markdown linguist-language=Go
+go-*.html.markdown linguist-language=Go
+groovy*.html.markdown linguist-language=Groovy
+hack*.html.markdown linguist-language=Hack
+haml*.html.markdown linguist-language=Haml
+haskell*.html.markdown linguist-language=Haskell
+haxe*.html.markdown linguist-language=Haxe
+html*.html.markdown linguist-language=HTML
+hy.html.markdown linguist-language=Hy
+hy-*.html.markdown linguist-language=Hy
+inform7*.html.markdown linguist-language=inform7
+java.html.markdown linguist-language=Java
+java-*.html.markdown linguist-language=Java
+javascript*.html.markdown linguist-language=JavaScript
+jquery*.html.markdown linguist-language=JavaScript
+json*.html.markdown linguist-language=JSON
+julia*.html.markdown linguist-language=Julia
+kotlin*.html.markdown linguist-language=Kotlin
+latex*.html.markdown linguist-language=latex
+less*.html.markdown linguist-language=less
+livescript*.html.markdown linguist-language=LiveScript
+logtalk*.html.markdown linguist-language=Logtalk
+lua*.html.markdown linguist-language=Lua
+make*.html.markdown linguist-language=Makefile
+markdown*.html.markdown linguist-language=Markdown
+matlab*.html.markdown linguist-language=Matlab
+nim*.html.markdown linguist-language=Nimrod
+nix*.html.markdown linguist-language=Nix
+objective-c*.html.markdown linguist-language=Objective-C
+ocaml*.html.markdown linguist-language=OCaml
+paren*.html.markdown linguist-language=lisp
+pcre*.html.markdown linguist-language=Perl
+perl.html.markdown linguist-language=Perl
+perl-*.html.markdown linguist-language=Perl
+perl6*.html.markdown linguist-language=Perl6
+ruby*.html.markdown linguist-language=Ruby
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..dd41ec4a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,16 @@
+**/*~
+**/*#
+**/#*#
+**/*.swp
+**/*.swo
+**/*.bak
+**/*.log*
+**/*.sublime-workspace
+**/.DS_Store
+**/.DS_Store?
+**/._*
+**/.Spotlight-V100
+**/.Trashes
+**/ehthumbs.db
+**/Thumbs.db
+**/desktop.ini 
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..ab89cb23
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+    - 2.2
diff --git a/CHICKEN.html.markdown b/CHICKEN.html.markdown
new file mode 100644
index 00000000..080527a9
--- /dev/null
+++ b/CHICKEN.html.markdown
@@ -0,0 +1,519 @@
+---
+language: "CHICKEN"
+filename: CHICKEN.scm
+contributors:
+  - ["Diwakar Wagle", "https://github.com/deewakar"]
+---
+
+
+CHICKEN is an implementation of Scheme programming language that can
+compile Scheme programs to C code as well as interpret them. CHICKEN
+supports RSR5 and RSR7 (work in progress) standards and many extensions.
+
+
+```scheme
+;; #!/usr/bin/env csi -s
+
+;; Run the CHICKEN REPL in the commandline as follows :
+;; $ csi
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 0. Syntax
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Single line comments start with a semicolon
+
+#| Block comments
+   can span multiple lines and...
+   #| can be nested
+   |#
+|#
+
+;; S-expression comments are used to comment out expressions
+#; (display "nothing")    ; discard this expression 
+
+;; CHICKEN has two fundamental pieces of syntax: Atoms and S-expressions
+;; an atom is something that evaluates to itself
+;; all builtin data types viz. numbers, chars, booleans, strings etc. are atoms
+;; Furthermore an atom can be a symbol, an identifier, a keyword, a procedure
+;; or the empty list (also called null)
+'athing              ;; => athing 
+'+                   ;; => + 
++                    ;; => <procedure C_plus>
+
+;; S-expressions (short for symbolic expressions) consists of one or more atoms
+(quote +)            ;; => + ; another way of writing '+
+(+ 1 2 3)            ;; => 6 ; this S-expression evaluates to a function call
+'(+ 1 2 3)           ;; => (+ 1 2 3) ; evaluates to a list 
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 1. Primitive Datatypes and Operators 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Numbers
+99999999999999999999 ;; integers
+#b1010               ;; binary ; => 10
+#o10                 ;; octal  ; => 8
+#x8ded               ;; hexadecimal ; => 36333
+3.14                 ;; real
+6.02e+23
+3/4                  ;; rational
+
+;;Characters and Strings
+#\A                  ;; A char
+"Hello, World!"      ;; strings are fixed-length arrays of characters
+
+;; Booleans
+#t                  ;; true
+#f                  ;; false
+
+;; Function call is written as (f x y z ...)
+;; where f is a function and x,y,z, ... are arguments
+(print "Hello, World!")    ;; => Hello, World!
+;; formatted output
+(printf "Hello, ~a.\n" "World")  ;; => Hello, World.
+
+;; print commandline arguments
+(map print (command-line-arguments)) 
+
+(list 'foo 'bar 'baz)          ;; => (foo bar baz)
+(string-append "pine" "apple") ;; => "pineapple"
+(string-ref "tapioca" 3)       ;; => #\i;; character 'i' is at index 3
+(string->list "CHICKEN")       ;; => (#\C #\H #\I #\C #\K #\E #\N)
+(string->intersperse '("1" "2") ":") ;; => "1:2"
+(string-split "1:2:3" ":")     ;; => ("1" "2" "3")
+
+
+;; Predicates are special functions that return boolean values
+(atom? #t)                ;; => #t
+
+(symbol? #t)              ;; => #f
+
+(symbol? '+)              ;; => #t
+
+(procedure? +)            ;; => #t
+
+(pair? '(1 2))            ;; => #t
+
+(pair? '(1 2 . 3))        ;; => #t
+
+(pair? '())               ;; => #f
+
+(list? '())               ;; => #t
+
+
+;; Some arithmetic operations
+
+(+ 1 1)                   ;; => 2
+(- 8 1)                   ;; => 7
+(* 10 2)                  ;; => 20
+(expt 2 3)                ;; => 8
+(remainder 5 2)           ;; => 1
+(/ 35 5)                  ;; => 7
+(/ 1 3)                   ;; => 0.333333333333333
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 2. Variables
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; You can create variables with define
+;; A variable name can use any character except: ()[]{}",'`;#\
+(define myvar 5)
+myvar        ;; => 5
+
+;; Alias to a procedure
+(define ** expt)
+(** 2 3)     ;; => 8
+
+;; Accessing an undefined variable raises an exception
+s            ;; => Error: unbound variable: s
+
+;; Local binding
+(let ((me "Bob"))
+  (print me))     ;; => Bob
+
+(print me)        ;; => Error: unbound variable: me
+
+;; Assign a new value to previously defined variable
+(set! myvar 10) 
+myvar             ;; => 10
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 3. Collections
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Pairs
+;; 'cons' constructs pairs, 
+;; 'car' extracts the first element, 'cdr' extracts the rest of the elements
+(cons 'subject 'verb)       ;; => '(subject . verb)
+(car (cons 'subject 'verb)) ;; => subject
+(cdr (cons 'subject 'verb)) ;; => verb
+
+;; Lists
+;; cons creates a new list if the second item is a list
+(cons 0 '())         ;; => (0)
+(cons 1 (cons 2  (cons 3 '())))    ;; => (1 2 3)
+;; 'list' is a convenience variadic constructor for lists
+(list 1 2 3)    ;; => (1 2 3)
+
+
+;; Use 'append' to append lists together
+(append '(1 2) '(3 4)) ;; => (1 2 3 4)
+
+;; Some basic operations on lists
+(map add1 '(1 2 3))    ;; => (2 3 4)
+(reverse '(1 3 4 7))   ;; => (7 4 3 1)
+(sort '(11 22 33 44) >)   ;; => (44 33 22 11)
+
+(define days '(SUN MON FRI))
+(list-ref days 1)      ;; => MON
+(set! (list-ref days 1) 'TUE)
+days                   ;; => (SUN TUE FRI)
+
+;; Vectors
+;; Vectors are heterogeneous structures whose elements are indexed by integers
+;; A Vector typically occupies less space than a list of the same length
+;; Random access of an element in a vector is faster than in a list
+#(1 2 3)                     ;; => #(1 2 3) ;; literal syntax
+(vector 'a 'b 'c)            ;; => #(a b c) 
+(vector? #(1 2 3))           ;; => #t
+(vector-length #(1 (2) "a")) ;; => 3
+(vector-ref #(1 (2) (3 3)) 2);; => (3 3)
+
+(define vec #(1 2 3))
+(vector-set! vec 2 4)
+vec                         ;; => #(1 2 4)
+
+;; Vectors can be created from lists and vice-verca
+(vector->list #(1 2 4))     ;; => '(1 2 4)
+(list->vector '(a b c))     ;; => #(a b c)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 4. Functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use 'lambda' to create functions.
+;; A function always returns the value of its last expression
+(lambda () "Hello World")   ;; => #<procedure (?)> 
+
+;; Use extra parens around function definition to execute 
+((lambda () "Hello World")) ;; => Hello World ;; argument list is empty
+
+;; A function with an argument
+((lambda (x) (* x x)) 3)           ;; => 9
+;; A function with two arguments
+((lambda (x y) (* x y)) 2 3)       ;; => 6
+
+;; assign a function to a variable
+(define sqr (lambda (x) (* x x)))
+sqr                        ;; => #<procedure (sqr x)>
+(sqr 3)                    ;; => 9
+
+;; We can shorten this using the function definition syntactic sugar
+(define (sqr x) (* x x))
+(sqr 3)                    ;; => 9
+
+;; We can redefine existing procedures
+(foldl cons '() '(1 2 3 4 5)) ;; => (((((() . 1) . 2) . 3) . 4) . 5)
+(define (foldl func accu alist)
+  (if (null? alist)
+    accu
+    (foldl func (func (car alist) accu) (cdr alist))))
+
+(foldl cons '() '(1 2 3 4 5))   ;; => (5 4 3 2 1)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 5. Equality
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; For numbers use '='
+(= 3 3.0)                  ;; => #t
+(= 2 1)                    ;; => #f
+
+;; 'eq?' returns #t if two arguments refer to the same object in memory
+;; In other words, it's a simple pointer comparision.
+(eq? '() '())              ;; => #t ;; there's only one empty list in memory
+(eq? (list 3) (list 3))    ;; => #f ;; not the same object
+(eq? 'yes 'yes)            ;; => #t
+(eq? 3 3)                  ;; => #t ;; don't do this even if it works in this case
+(eq? 3 3.0)                ;; => #f ;; it's better to use '=' for number comparisions
+(eq? "Hello" "Hello")      ;; => #f
+
+;; 'eqv?' is same as 'eq?' all datatypes except numbers and characters
+(eqv? 3 3.0)               ;; => #f
+(eqv? (expt 2 3) (expt 2 3)) ;; => #t
+(eqv? 'yes 'yes)           ;; => #t
+
+;; 'equal?' recursively compares the contents of pairs, vectors, and strings,
+;; applying eqv? on other objects such as numbers and symbols. 
+;; A rule of thumb is that objects are generally equal? if they print the same.
+
+(equal? '(1 2 3) '(1 2 3)) ;; => #t
+(equal? #(a b c) #(a b c)) ;; => #t
+(equal? 'a 'a)             ;; => #t
+(equal? "abc" "abc")       ;; => #f
+
+;; In Summary:
+;; eq? tests if objects are identical
+;; eqv? tests if objects are operationally equivalent
+;; equal? tests if objects have same structure and contents
+
+;; Comparing strings for equality
+(string=? "Hello" "Hello") ;; => #t
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 6. Control Flow
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Conditionals
+(if #t                     ;; test expression
+  "True"                   ;; then expression
+  "False")                 ;; else expression
+                           ;; => "True"
+
+(if (> 3 2)
+  "yes"
+  "no")                    ;; => "yes"
+
+;; In conditionals, all values that are not '#f' are treated as true.
+;; 0, '(), #() "" , are all true values
+(if 0
+  "0 is not false"
+  "0 is false")            ;; => "0 is not false"
+
+;; 'cond' chains a series of tests and returns as soon as it encounters a true condition
+;; 'cond' can be used to simulate 'if/elseif/else' statements
+(cond ((> 2 2) "not true so don't return this")
+      ((< 2 5) "true, so return this")
+      (else "returning default"))    ;; => "true, so return this"
+
+
+;; A case expression is evaluated as follows:
+;; The key is evaluated and compared with each datum in sense of 'eqv?',
+;; The corresponding clause in the matching datum is evaluated and returned as result
+(case (* 2 3)              ;; the key is 6
+  ((2 3 5 7) 'prime)       ;; datum 1
+  ((1 4 6 8) 'composite))  ;; datum 2; matched!
+                           ;; => composite
+
+;; case with else clause
+(case (car '(c d))
+  ((a e i o u) 'vowel)
+  ((w y) 'semivowel)
+  (else 'consonant))       ;; =>  consonant
+
+;; Boolean expressions
+;; 'and' returns the first expression that evaluates to #f
+;; otherwise, it returns the result of the last expression
+(and #t #f (= 2 2.0))                ;; => #f
+(and (< 2 5) (> 2 0) "0 < 2 < 5")    ;; => "0 < 2 < 5"
+
+;; 'or' returns the first expression that evaluates to #t 
+;; otherwise the result of the last expression is returned
+(or #f #t #f)                        ;; => #t
+(or #f #f #f)                        ;; => #f
+
+;; 'when' is like 'if' without the else expression
+(when (positive? 5) "I'm positive")  ;; => "I'm positive"
+
+;; 'unless' is equivalent to (when (not <test>) <expr>)
+(unless (null? '(1 2 3)) "not null") ;; => "not null"
+
+
+;; Loops
+;; loops can be created with the help of tail-recursions
+(define (loop count)
+  (unless (= count 0)
+    (print "hello") 
+    (loop (sub1 count))))
+(loop 4)                             ;; => hello, hello ...
+
+;; Or with a named let
+(let loop ((i 0) (limit 5))
+  (when (< i limit)
+    (printf "i = ~a\n" i)
+    (loop (add1 i) limit)))          ;; => i = 0, i = 1....
+
+;; 'do' is another iteration construct
+;; It initializes a set of variables and updates them in each iteration
+;; A final expression is evaluated after the exit condition is met
+(do ((x 0 (add1 x )))            ;; initialize x = 0 and add 1 in each iteration
+  ((= x 10) (print "done"))      ;; exit condition and final expression
+  (print x))                     ;; command to execute in each step
+                                 ;; => 0,1,2,3....9,done
+
+;; Iteration over lists 
+(for-each (lambda (a) (print (* a a)))
+          '(3 5 7))                  ;; => 9, 25, 49
+
+;; 'map' is like for-each but returns a list
+(map add1 '(11 22 33))               ;; => (12 23 34)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 7. Extensions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; The CHICKEN core is very minimal, but additional features are provided by library extensions known as Eggs.
+;; You can install Eggs with 'chicken-install <eggname>' command.
+
+;; 'numbers' egg provides support for full numeric tower.
+(require-extension numbers)
+;; complex numbers
+3+4i                               ;; => 3+2i
+;; Supports fractions without falling back to inexact flonums
+1/3                                ;; => 1/3
+;; provides support for large integers through bignums
+(expt 9 20)                        ;; => 12157665459056928801 
+;; And other 'extended' functions
+(log 10 (exp 1))                   ;; => 2.30258509299405
+(numerator 2/3)                    ;; => 2
+
+;; 'utf8' provides unicode support
+(require-extension utf8)
+"\u03BBx:(\u03BC\u0251.\u0251\u2192\u0251).xx" ;; => "λx:(μɑ.ɑ→ɑ).xx"
+
+;; 'posix' provides file I/O and lots of other services for unix-like operating systems
+;; Some of the functions are not available in Windows system,
+;; See http://wiki.call-cc.org/man/4/Unit%20posix for more details
+
+;; Open a file to append, open "write only" and create file if it does not exist
+(define outfn (file-open "chicken-hen.txt" (+ open/append open/wronly open/creat)))
+;; write some text to the file
+(file-write outfn "Did chicken came before hen?") 
+;; close the file
+(file-close outfn)
+;; Open the file "read only"
+(define infn (file-open "chicken-hen.txt" open/rdonly))
+;; read some text from the file
+(file-read infn 30)         ;; => ("Did chicken came before hen?  ", 28)
+(file-close infn)
+
+;; CHICKEN also supports SRFI (Scheme Requests For Implementation) extensions
+;; See 'http://srfi.schemers.org/srfi-implementers.html" to see srfi's supported by CHICKEN
+(require-extension srfi-1)         ;; list library
+(filter odd? '(1 2 3 4 5 6 7))     ;; => (1 3 5 7)
+(count even? '(1 2 3 4 5))         ;; => 2
+(take '(12 24 36 48 60) 3)         ;; => (12 24 36)
+(drop '(12 24 36 48 60) 2)         ;; => (36 48 60)
+(circular-list 'z 'q)              ;; => z q z q ...
+
+(require-extension srfi-13)        ;; string library
+(string-reverse "pan")             ;; => "nap"
+(string-index "Turkey" #\k)        ;; => 3
+(string-every char-upper-case? "CHICKEN") ;; => #t
+(string-join '("foo" "bar" "baz") ":")    ;; => "foo:bar:baz"
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 8. Macros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; A 'for .. in ..' iteration like python, for lists
+(define-syntax for
+  (syntax-rules (in)
+                ((for elem in alist body ...)
+                 (for-each (lambda (elem) body ...) alist))))
+
+(for x in '(2 4 8 16)
+     (print x))          ;; => 2, 4, 8, 16
+
+(for chr in (string->list "PENCHANT")
+     (print chr))        ;; => P, E, N, C, H, A, N, T
+
+;; While loop
+(define-syntax while
+  (syntax-rules ()
+                ((while cond body ...)
+                 (let loop ()
+                   (when cond
+                     body ...
+                     (loop))))))
+
+(let ((str "PENCHANT") (i 0))
+  (while (< i (string-length str))     ;; while (condition)
+         (print (string-ref str i))    ;; body 
+         (set! i (add1 i))))           
+                                       ;; => P, E, N, C, H, A, N, T
+
+;; Advanced Syntax-Rules Primer -> http://petrofsky.org/src/primer.txt
+;; Macro system in chicken -> http://lists.gnu.org/archive/html/chicken-users/2008-04/msg00013.html
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 9. Modules
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Also See http://wiki.call-cc.org/man/4/Modules
+
+;; The 'test' module exports a value named 'hello' and a macro named 'greet'
+(module test (hello greet)
+  (import scheme)
+
+  (define-syntax greet
+    (syntax-rules ()
+      ((_ whom) 
+       (begin
+         (display "Hello, ")
+         (display whom)
+         (display " !\n") ) ) ) )
+
+  (define (hello)
+    (greet "world") )  )
+
+;; we can define our modules in a separate file (say test.scm) and load them to the interpreter with
+;;         (load "test.scm")
+
+;; import the module
+(import test)
+(hello)                ;; => Hello, world !
+(greet "schemers")     ;; => Hello, schemers !
+
+;; We can compile the module files in to shared libraries by using following command,
+;;         csc -s test.scm
+;;         (load "test.so")
+
+;; Functors
+;; Functors are high level modules that can be parameterized by other modules
+;; Following functor requires another module named 'M' that provides a function called 'multiply'
+;; The functor itself exports a generic function 'square'
+(functor (squaring-functor (M (multiply))) (square)
+         (import scheme M) 
+         (define (square x) (multiply x x)))
+
+;; Module 'nums' can be passed as a parameter to 'squaring-functor'
+(module nums (multiply) 
+        (import scheme)     ;; predefined modules
+        (define (multiply x y) (* x y))) 
+;; the final module can be imported and used in our program
+(module number-squarer = (squaring-functor nums)) 
+
+(import number-squarer)
+(square 3)              ;; => 9
+
+;; We can instantiate the functor for other inputs
+;; Here's another example module that can be passed to squaring-functor
+(module stars (multiply)
+        (import chicken scheme)  ;; chicken module for the 'use' keyword
+        (use srfi-1)             ;; we can use external libraries in our module
+        (define (multiply x y)
+          (list-tabulate x (lambda _ (list-tabulate y (lambda _ '*))))))
+(module star-squarer = (squaring-functor stars))
+
+(import star-squarer)
+(square 3)              ;; => ((* * *)(* * *)(* * *))
+
+```
+## Further Reading
+* [CHICKEN User's Manual](http://wiki.call-cc.org/man/4/The%20User%27s%20Manual).
+* [RSR5 standards](http://www.schemers.org/Documents/Standards/R5RS)
+
+
+## Extra Info
+
+* [For programmers of other languages](http://wiki.call-cc.org/chicken-for-programmers-of-other-languages)
+* [Compare CHICKEN syntax with other languages](http://plr.sourceforge.net/cgi-bin/plr/launch.py)
diff --git a/CONTRIBUTING.markdown b/CONTRIBUTING.markdown
new file mode 100644
index 00000000..5fa1d03d
--- /dev/null
+++ b/CONTRIBUTING.markdown
@@ -0,0 +1,73 @@
+# Contributing
+
+All contributions are 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). Send a pull request or open an issue any time of day
+or night.
+
+**Please prepend the tag `[language/lang-code]` to your issues and pull
+requests.** For example, `[python/en]` for English Python. This will help
+everyone pick out things they care about.
+
+We're happy for any contribution in any form, but if you're making more than one
+major change (i.e. translations for two different languages) it would be super
+cool of you to make a separate pull request for each one so that someone can
+review them more effectively and/or individually.
+
+## Style Guidelines
+
+- **Keep lines of under 80 chars**
+  + Try to keep **line length in code blocks to 80 characters or fewer**.
+  + Otherwise, the text will overflow and look odd.
+- **Prefer example to exposition**
+  + Try to use as few words as possible.
+  + Code examples are preferred over exposition in all cases.
+- **Eschew surplusage**
+  + We welcome newcomers, but the target audience for this site is programmers
+    with some experience.
+  + Try to avoid explaining basic concepts except for those specific to the
+    language in question.
+  + Keep articles succinct and scannable. We all know how to use Google here.
+- **Use UTF-8**
+  + For translations (or EN articles with non-ASCII characters) please make sure
+    your file is UTF-8 encoded.
+  + Try to leave out the byte-order-mark at the start of the file. (`:set nobomb`
+    in Vim)
+  + You can check if the file contains a BOM on Linux/Unix systems by running
+    `file language.html.markdown`  You will see this if it uses a BOM:
+	`UTF-8 Unicode (with BOM) text`.
+
+
+### 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, requires 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.
+
+Here's an example header for an Esperanto translation of Ruby:
+
+```yaml
+---
+language: ruby
+filename: learnruby-epo.ruby
+contributors:
+    - ["Doktor Esperanto", "http://example.com/"]
+    - ["Someone else", "http://someoneelseswebsite.com/"]
+lang: ep-ep
+---
+```
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 00000000..c30a6497
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+group :test do
+    gem 'rake'
+    gem 'charlock_holmes'
+end
diff --git a/Gemfile.lock b/Gemfile.lock
new file mode 100644
index 00000000..ba15ad75
--- /dev/null
+++ b/Gemfile.lock
@@ -0,0 +1,15 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    charlock_holmes (0.7.3)
+    rake (12.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  charlock_holmes
+  rake
+
+BUNDLED WITH
+   1.13.7
diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
new file mode 100644
index 00000000..022dedab
--- /dev/null
+++ b/ISSUE_TEMPLATE.md
@@ -0,0 +1,6 @@
+Make sure the issue title is prepended with '[language/lang-code]' if the language is
+already on the site.
+If it's a request for a new language, use: '[Request] [language/lang-code]'
+
+Issues are always welcome. If you are able and willing, we welcome any pull requests
+as this is a community powered project.
diff --git a/LOLCODE.html.markdown b/LOLCODE.html.markdown
new file mode 100644
index 00000000..217b7b7d
--- /dev/null
+++ b/LOLCODE.html.markdown
@@ -0,0 +1,185 @@
+---
+language: LOLCODE
+filename: learnLOLCODE.lol
+contributors:
+    - ["abactel", "https://github.com/abactel"]
+---
+
+LOLCODE is an esoteric programming language designed to resemble the speech of [lolcats](https://upload.wikimedia.org/wikipedia/commons/a/ab/Lolcat_in_folder.jpg?1493656347257).
+
+```
+BTW This is an inline comment
+BTW All code must begin with `HAI <language version>` and end with `KTHXBYE`
+
+HAI 1.3
+CAN HAS STDIO? BTW Importing standard headers
+
+OBTW
+     ==========================================================================
+     ================================= BASICS =================================
+     ==========================================================================
+TLDR
+
+BTW Displaying text:
+VISIBLE "HELLO WORLD"
+
+BTW Declaring variables:
+I HAS A MESSAGE ITZ "CATZ ARE GOOD"
+VISIBLE MESSAGE
+
+OBTW
+    (This is a codeblock.) Variables are dynamically typed so you don't need to
+    declare their type. A variable's type matches its content. These are the
+    types:
+TLDR
+
+I HAS A STRING  ITZ "DOGZ ARE GOOOD" BTW type is YARN
+I HAS A INTEGER ITZ 42               BTW type is NUMBR
+I HAS A FLOAT   ITZ 3.1415           BTW type is NUMBAR
+I HAS A BOOLEAN ITZ WIN              BTW type is TROOF
+I HAS A UNTYPED                      BTW type is NOOB
+
+BTW Accepting user input:
+I HAS A AGE
+GIMMEH AGE
+BTW The variable is stored as a YARN. To convert it into NUMBR:
+AGE IS NOW A NUMBR
+
+OBTW
+     ==========================================================================
+     ================================== MATH ==================================
+     ==========================================================================
+TLDR
+
+BTW LOLCODE uses polish notation style math.
+
+BTW Basic mathematical notation:
+
+SUM OF 21 AN 33         BTW 21 + 33
+DIFF OF 90 AN 10        BTW 90 - 10
+PRODUKT OF 12 AN 13     BTW 12 * 13
+QUOSHUNT OF 32 AN 43    BTW 32 / 43
+MOD OF 43 AN 64         BTW 43 modulo 64
+BIGGR OF 23 AN 53       BTW max(23, 53)
+SMALLR OF 53 AN 45      BTW min(53, 45)
+
+BTW Binary notation:
+
+BOTH OF WIN AN WIN           BTW and: WIN if x=WIN, y=WIN
+EITHER OF FAIL AN WIN        BTW or: FAIL if x=FAIL, y=FAIL
+WON OF WIN AN FAIL           BTW xor: FAIL if x=y
+NOT FAIL                     BTW unary negation: WIN if x=FAIL
+ALL OF WIN AN WIN MKAY   BTW infinite arity AND
+ANY OF WIN AN FAIL MKAY  BTW infinite arity OR
+
+BTW Comparison:
+
+BOTH SAEM "CAT" AN "DOG"             BTW WIN if x == y
+DIFFRINT 732 AN 184                  BTW WIN if x != y
+BOTH SAEM 12 AN BIGGR OF 12 AN 4     BTW x >= y
+BOTH SAEM 43 AN SMALLR OF 43 AN 56   BTW x <= y
+DIFFRINT 64 AN SMALLR OF 64 AN 2     BTW x > y
+DIFFRINT 75 AN BIGGR OF 75 AN 643    BTW x < y
+
+OBTW
+     ==========================================================================
+     ============================== FLOW CONTROL ==============================
+     ==========================================================================
+TLDR
+
+BTW If/then statement:
+I HAS A ANIMAL
+GIMMEH ANIMAL
+BOTH SAEM ANIMAL AN "CAT", O RLY?
+    YA RLY
+        VISIBLE "YOU HAV A CAT"
+    MEBBE BOTH SAEM ANIMAL AN "MAUS"
+        VISIBLE "NOM NOM NOM. I EATED IT."
+    NO WAI
+        VISIBLE "AHHH IS A WOOF WOOF"
+OIC
+
+BTW Case statement:
+I HAS A COLOR
+GIMMEH COLOR
+COLOR, WTF?
+    OMG "R"
+        VISIBLE "RED FISH"
+        GTFO
+    OMG "Y"
+        VISIBLE "YELLOW FISH"
+        BTW Since there is no `GTFO` the next statements will also be tested
+    OMG "G"
+    OMG "B"
+        VISIBLE "FISH HAS A FLAVOR"
+        GTFO
+    OMGWTF
+        VISIBLE "FISH IS TRANSPARENT OHNO WAT"
+OIC
+
+BTW For loop:
+I HAS A TEMPERATURE
+GIMMEH TEMPERATURE
+TEMPERATURE IS NOW A NUMBR
+IM IN YR LOOP UPPIN YR ITERATOR TIL BOTH SAEM ITERATOR AN TEMPERATURE
+    VISIBLE ITERATOR
+IM OUTTA YR LOOP
+
+BTW While loop:
+IM IN YR LOOP NERFIN YR ITERATOR WILE DIFFRINT ITERATOR AN -10
+    VISIBLE ITERATOR
+IM OUTTA YR LOOP
+
+OBTW
+     =========================================================================
+     ================================ Strings ================================
+     =========================================================================
+TLDR
+
+BTW Linebreaks:
+VISIBLE "FIRST LINE :) SECOND LINE"
+
+BTW Tabs:
+VISIBLE ":>SPACES ARE SUPERIOR"
+
+BTW Bell (goes beep):
+VISIBLE "NXT CUSTOMER PLS :o"
+
+BTW Literal double quote:
+VISIBLE "HE SAID :"I LIKE CAKE:""
+
+BTW Literal colon:
+VISIBLE "WHERE I LIVE:: CYBERSPACE"
+
+OBTW
+     =========================================================================
+     =============================== FUNCTIONS ===============================
+     =========================================================================
+TLDR
+
+BTW Declaring a new function:
+HOW IZ I SELECTMOVE YR MOVE BTW `MOVE` is an argument
+    BOTH SAEM MOVE AN "ROCK", O RLY?
+        YA RLY
+            VISIBLE "YOU HAV A ROCK"
+        NO WAI
+            VISIBLE "OH NO IS A SNIP-SNIP"
+    OIC
+    GTFO BTW This returns NOOB
+IF U SAY SO
+
+BTW Declaring a function and returning a value:
+HOW IZ I IZYELLOW
+    FOUND YR "YELLOW"
+IF U SAY SO
+
+BTW Calling a function:
+I IZ IZYELLOW MKAY
+
+KTHXBYE
+```
+
+## Further reading:
+
+-   [LCI compiler](https://github.com/justinmeza/lci)
+-   [Official spec](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md)
diff --git a/PULL_REQUEST_TEMPLATE.md b/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 00000000..fd9d1b31
--- /dev/null
+++ b/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,6 @@
+- [ ] I solemnly swear that this is all original content of which I am the original author
+- [ ] Pull request title is prepended with `[language/lang-code]`
+- [ ] Pull request touches only one file (or a set of logically related files with similar changes made)
+- [ ] Content changes are aimed at *intermediate to experienced programmers* (this is a poor format for explaining fundamental programming concepts)
+- [ ] If you've changed any part of the YAML Frontmatter, make sure it is formatted according to [CONTRIBUTING.md](https://github.com/adambard/learnxinyminutes-docs/blob/master/CONTRIBUTING.markdown)
+  - [ ] Yes, I have double-checked quotes and field names!
diff --git a/README.markdown b/README.markdown
index 092785f8..9a8a3752 100644
--- a/README.markdown
+++ b/README.markdown
@@ -1,88 +1,47 @@
-# [Learn X in Y minutes](http://learnxinyminutes.com)
+# [Learn X in Y minutes][1]
+
+[![Build Status](https://travis-ci.org/adambard/learnxinyminutes-docs.svg?branch=master)](https://travis-ci.org/adambard/learnxinyminutes-docs)
 
 Whirlwind tours of (several, hopefully many someday) popular and
-ought-to-be-more-popular programming languages, presented as valid,
-commented code and explained as they go.
+ought-to-be-more-popular programming languages, presented as valid, commented
+code and explained as they go.
 
 ## We need YOU!...
 
-... 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 "contributors" fields so you get credited
-properly!
+... 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 "contributors" fields so you get credited properly!
 
 ## Contributing
 
-All contributions are 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).
-Send a pull request or open an issue any time of day or night.
-
-**Please tag your issues and pull requests with [language/lang-code] at the beginning**
-**(e.g. [python/en] for English Python).** This will help everyone pick out things they
-care about.
-
-We're happy for any contribution in any form, but if you're making more than one major change
-(i.e. translations for two different languages) it would be super cool of you to make a
-separate pull request for each one so that someone can review them more effectively and/or
-individually.
-
-### Style Guidelines
-
-* **Keep lines under 80 chars**
-* **Prefer example to exposition**
-* **Eschew surplusage**
-* **Use UTF-8**
-
-Long version:
-
-* 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.
+All contributions are 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). Send a pull request or open an issue any time of day
+or night.
 
-* 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.
+**Please prepend the tag `[language/lang-code]` to your issues and pull
+requests.** For example, `[python/en]` for English Python. This will help
+everyone pick out things they care about.
 
-* For translations (or English articles with non-ASCII characters), please make sure your file is
-  UTF-8 encoded, and try to leave out the byte-order-mark at the start of the file. (`:set nobomb` in Vim)
+We're happy for any contribution in any form, but if you're making more than one
+major change (i.e. translations for two different languages) it would be super
+cool of you to make a separate pull request for each one so that someone can
+review them more effectively and/or individually.
 
-### Header configuration
+For a detailed style guide, please review the full [CONTRIBUTING][2] guidelines.
 
-The actual site uses Middleman to generate HTML files from these Markdown ones. Middleman, or at least
-the custom scripts underpinning the site, requires 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.
-
-Here's an example header for an Esperanto translation of Ruby:
+## License
 
-```yaml
----
-language: ruby
-filename: learnruby-epo.ruby
-contributors:
-    - ["Doktor Esperanto", "http://example.com/"]
-    - ["Someone else", "http://someoneelseswebsite.com/"]
-lang: ep-ep
----
-```
+Contributors retain copyright to their work, and can request removal at any
+time. By uploading a doc here, you agree to publish your work under the default
+[Creative Commons Attribution-ShareAlike 3.0 Unported][3] licensing included on
+each doc page.
 
-## License
+Anything not covered by the above -- basically, this README -- you can use as
+you wish, I guess.
 
-Contributors retain copyright to their work, and can request removal at any time.
-By uploading a doc here, you agree to publish your work under the default
-[Creative Commons Attribution-ShareAlike 3.0 Unported](http://creativecommons.org/licenses/by-sa/3.0/deed.en_US)
-licensing included on each doc page.
 
-Anything not covered by the above -- basically, this README -- you can use
-as you wish, I guess.
+[1]: http://learnxinyminutes.com
+[2]: /CONTRIBUTING.markdown
+[3]: http://creativecommons.org/licenses/by-sa/3.0/deed.en_US
diff --git a/Rakefile b/Rakefile
new file mode 100644
index 00000000..6a31bd72
--- /dev/null
+++ b/Rakefile
@@ -0,0 +1,23 @@
+task default: %w[encoding yaml return_code]
+$failure = 0
+task :encoding do
+  begin
+    ruby 'tests/encoding.rb'
+  rescue Exception => msg
+    puts msg
+    $failure += 1
+  end
+end
+task :yaml do
+  begin
+    ruby 'tests/yaml.rb'
+  rescue Exception => msg
+    puts msg
+    $failure += 1
+  end
+end
+task :return_code do
+  if $failure != 0
+    raise "Failed #{$failure} tests!!"
+  end
+end
diff --git a/angularjs.html.markdown b/angularjs.html.markdown
new file mode 100644
index 00000000..737b99c7
--- /dev/null
+++ b/angularjs.html.markdown
@@ -0,0 +1,708 @@
+---
+category: tool
+tool: AngularJS
+contributors:
+    - ["Walter Cordero", "http://waltercordero.com"]
+filename: learnangular.html
+---
+
+## AngularJS Tutorial.
+
+AngularJS version 1.0 was released in 2012.
+Miško Hevery, a Google employee, started to work with AngularJS in 2009.
+The idea turned out very well, and the project is now officially supported by Google.
+
+AngularJS is a JavaScript framework. It can be added to an HTML page with a "script" tag.
+AngularJS extends HTML attributes with Directives, and binds data to HTML with Expressions.
+
+##What You Should Already Know
+
+Before you study AngularJS, you should have a basic understanding of:
+
+- HTML
+- CSS
+- JavaScript
+
+```html
+// AngularJS is a JavaScript framework. It is a library written in JavaScript.
+// AngularJS is distributed as a JavaScript file, and can be added to a web page with a script tag:
+// <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+
+///////////////////////////////////
+// AngularJS Extends HTML
+
+//AngularJS extends HTML with ng-directives.
+//The ng-app directive defines an AngularJS application.
+//The ng-model directive binds the value of HTML controls (input, select, textarea) to application data.
+//The ng-bind directive binds application data to the HTML view.
+<!DOCTYPE html>
+<html>
+  <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div ng-app="">
+      <p>Name: <input type="text" ng-model="name"></p>
+      <p ng-bind="name"></p>
+    </div>
+  </body>
+</html>
+
+/*
+  * Example explained:
+  * AngularJS starts automatically when the web page has loaded.
+  * The ng-app directive tells AngularJS that the <div> element is the "owner" of an AngularJS application.
+  * The ng-model directive binds the value of the input field to the application variable name.
+  * The ng-bind directive binds the innerHTML of the <p> element to the application variable name.
+*/
+<tag> Here are content to be interpreted </tag>
+
+///////////////////////////////////
+// AngularJS Expressions
+
+// AngularJS expressions are written inside double braces: {{ expression }}.
+// AngularJS expressions binds data to HTML the same way as the ng-bind directive.
+// AngularJS will "output" data exactly where the expression is written.
+// AngularJS expressions are much like JavaScript expressions: They can contain literals, operators, and variables.
+// Example {{ 5 + 5 }} or {{ firstName + " " + lastName }}
+<!DOCTYPE html>
+<html>
+  <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div ng-app="">
+      <p>My first expression: {{ 5 + 5 }}</p>
+    </div>
+  </body>
+</html>
+
+//If you remove the ng-app directive, HTML will display the expression as it is, without solving it:
+<!DOCTYPE html>
+<html>
+  <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div>
+      <p>My first expression: {{ 5 + 5 }}</p>
+    </div>
+  </body>
+</html>
+
+// AngularJS expressions bind AngularJS data to HTML the same way as the ng-bind directive.
+<!DOCTYPE html>
+<html>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div ng-app="">
+      <p>Name: <input type="text" ng-model="name"></p>
+      <p>{{name}}</p>
+    </div>
+  </body>
+</html>
+
+// AngularJS numbers are like JavaScript numbers:
+<div ng-app="" ng-init="quantity=1;cost=5">
+  <p>Total in dollar: {{ quantity * cost }}</p>
+</div>
+
+//AngularJS strings are like JavaScript strings:
+<div ng-app="" ng-init="firstName='John';lastName='Doe'">
+  <p>The name is <span ng-bind="firstName + ' ' + lastName"></span></p>
+</div>
+
+//AngularJS objects are like JavaScript objects:
+<div ng-app="" ng-init="person={firstName:'John',lastName:'Doe'}">
+  <p>The name is {{ person.lastName }}</p>
+</div>
+
+//AngularJS arrays are like JavaScript arrays:
+<div ng-app="" ng-init="points=[1,15,19,2,40]">
+  <p>The third result is {{ points[2] }}</p>
+</div>
+
+// Like JavaScript expressions, AngularJS expressions can contain literals, operators, and variables.
+// Unlike JavaScript expressions, AngularJS expressions can be written inside HTML.
+// AngularJS expressions do not support conditionals, loops, and exceptions, while JavaScript expressions do.
+// AngularJS expressions support filters, while JavaScript expressions do not.
+
+///////////////////////////////////
+// AngularJS Directives
+
+
+//AngularJS directives are extended HTML attributes with the prefix ng-.
+//The ng-app directive initializes an AngularJS application.
+//The ng-init directive initializes application data.
+//The ng-model directive binds the value of HTML controls (input, select, textarea) to application data.
+<div ng-app="" ng-init="firstName='John'">
+  <p>Name: <input type="text" ng-model="firstName"></p>
+  <p>You wrote: {{ firstName }}</p>
+</div>
+
+//Using ng-init is not very common. You will learn how to initialize data in the chapter about controllers.
+
+//The ng-repeat directive repeats an HTML element:
+<div ng-app="" ng-init="names=['Jani','Hege','Kai']">
+  <ul>
+    <li ng-repeat="x in names">
+      {{ x }}
+    </li>
+  </ul>
+</div>
+
+//The ng-repeat directive used on an array of objects:
+<div ng-app="" ng-init="names=[
+{name:'Jani',country:'Norway'},
+{name:'Hege',country:'Sweden'},
+{name:'Kai',country:'Denmark'}]">
+  <ul>
+    <li ng-repeat="x  in names">
+      {{ x.name + ', ' + x.country }}
+    </li>
+  </ul>
+</div>
+
+// AngularJS is perfect for database CRUD (Create Read Update Delete) applications.
+// Just imagine if these objects were records from a database.
+
+// The ng-app directive defines the root element of an AngularJS application.
+// The ng-app directive will auto-bootstrap (automatically initialize) the application when a web page is loaded.
+// Later you will learn how ng-app can have a value (like ng-app="myModule"), to connect code modules.
+
+// The ng-init directive defines initial values for an AngularJS application.
+// Normally, you will not use ng-init. You will use a controller or module instead.
+// You will learn more about controllers and modules later.
+
+//The ng-model directive binds the value of HTML controls (input, select, textarea) to application data.
+//The ng-model directive can also:
+//Provide type validation for application data (number, email, required).
+//Provide status for application data (invalid, dirty, touched, error).
+//Provide CSS classes for HTML elements.
+//Bind HTML elements to HTML forms.
+
+//The ng-repeat directive clones HTML elements once for each item in a collection (in an array).
+
+///////////////////////////////////
+// AngularJS Controllers
+
+// AngularJS controllers control the data of AngularJS applications.
+// AngularJS controllers are regular JavaScript Objects.
+
+// AngularJS applications are controlled by controllers.
+// The ng-controller directive defines the application controller.
+// A controller is a JavaScript Object, created by a standard JavaScript object constructor.
+
+<div ng-app="myApp" ng-controller="myCtrl">
+
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('myCtrl', function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+});
+</script>
+
+//Application explained:
+
+//The AngularJS application is defined by  ng-app="myApp". The application runs inside the <div>.
+//The ng-controller="myCtrl" attribute is an AngularJS directive. It defines a controller.
+//The myCtrl function is a JavaScript function.
+//AngularJS will invoke the controller with a $scope object.
+//In AngularJS, $scope is the application object (the owner of application variables and functions).
+//The controller creates two properties (variables) in the scope (firstName and lastName).
+//The ng-model directives bind the input fields to the controller properties (firstName and lastName).
+
+//The example above demonstrated a controller object with two properties: lastName and firstName.
+//A controller can also have methods (variables as functions):
+<div ng-app="myApp" ng-controller="personCtrl">
+
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{fullName()}}
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('personCtrl', function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+    $scope.fullName = function() {
+        return $scope.firstName + " " + $scope.lastName;
+    }
+});
+</script>
+
+//In larger applications, it is common to store controllers in external files.
+//Just copy the code between the <script> </script> tags into an external file named personController.js:
+
+<div ng-app="myApp" ng-controller="personCtrl">
+
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+
+</div>
+
+<script src="personController.js"></script>
+
+// For the next example we will create a new controller file:
+angular.module('myApp', []).controller('namesCtrl', function($scope) {
+    $scope.names = [
+        {name:'Jani',country:'Norway'},
+        {name:'Hege',country:'Sweden'},
+        {name:'Kai',country:'Denmark'}
+    ];
+});
+
+//Save the file as  namesController.js:
+//And then use the controller file in an application:
+
+<div ng-app="myApp" ng-controller="namesCtrl">
+
+<ul>
+  <li ng-repeat="x in names">
+    {{ x.name + ', ' + x.country }}
+  </li>
+</ul>
+
+</div>
+
+<script src="namesController.js"></script>
+
+///////////////////////////////////
+// AngularJS Filters
+
+// Filters can be added to expressions and directives using a pipe character.
+// AngularJS filters can be used to transform data:
+
+- **currency**:  Format a number to a currency format.
+- **filter**:  Select a subset of items from an array.
+- **lowercase**: Format a string to lower case.
+- **orderBy**: Orders an array by an expression.
+- **uppercase**: Format a string to upper case.
+
+//A filter can be added to an expression with a pipe character (|) and a filter.
+//(For the next two examples we will use the person controller from the previous chapter)
+//The uppercase filter format strings to upper case:
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<p>The name is {{ lastName | uppercase }}</p>
+
+</div>
+
+//The lowercase filter format strings to lower case:
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<p>The name is {{ lastName | lowercase }}</p>
+
+</div>
+
+//The currency filter formats a number as currency:
+<div ng-app="myApp" ng-controller="costCtrl">
+
+<input type="number" ng-model="quantity">
+<input type="number" ng-model="price">
+
+<p>Total = {{ (quantity * price) | currency }}</p>
+
+</div> 
+
+//A filter can be added to a directive with a pipe character (|) and a filter.
+//The orderBy filter orders an array by an expression:
+<div ng-app="myApp" ng-controller="namesCtrl">
+
+<ul>
+  <li ng-repeat="x in names | orderBy:'country'">
+    {{ x.name + ', ' + x.country }}
+  </li>
+</ul>
+
+<div>
+
+//An input filter can be added to a directive with a pipe character (|) 
+//and filter followed by a colon and a model name.
+//The filter selects a subset of an array:
+
+<div ng-app="myApp" ng-controller="namesCtrl">
+
+<p><input type="text" ng-model="test"></p>
+
+<ul>
+  <li ng-repeat="x in names | filter:test | orderBy:'country'">
+    {{ (x.name | uppercase) + ', ' + x.country }}
+  </li>
+</ul>
+
+</div>
+
+///////////////////////////////////
+// AngularJS AJAX - $http
+
+//$http is an AngularJS service for reading data from remote servers.
+
+// The following data can be provided by a web server:
+// http://www.w3schools.com/angular/customers.php
+// **Check the URL to see the data format**
+
+// AngularJS $http is a core service for reading data from web servers.
+// $http.get(url) is the function to use for reading server data.
+<div ng-app="myApp" ng-controller="customersCtrl"> 
+
+<ul>
+  <li ng-repeat="x in names">
+    {{ x.Name + ', ' + x.Country }}
+  </li>
+</ul>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('customersCtrl', function($scope, $http) {
+    $http.get("http://www.w3schools.com/angular/customers.php")
+    .success(function(response) {$scope.names = response.records;});
+});
+</script>
+
+Application explained:
+
+// The AngularJS application is defined by ng-app. The application runs inside a <div>.
+// The ng-controller directive names the controller object.
+// The customersCtrl function is a standard JavaScript object constructor.
+// AngularJS will invoke customersCtrl with a $scope and $http object.
+// $scope is the application object (the owner of application variables and functions).
+// $http is an XMLHttpRequest object for requesting external data.
+// $http.get() reads JSON data from http://www.w3schools.com/angular/customers.php.
+// If success, the controller creates a property (names) in the scope, with JSON data from the server.
+
+
+// Requests for data from a different server (than the requesting page), are called cross-site HTTP requests.
+// Cross-site requests are common on the web. Many pages load CSS, images, and scripts from different servers.
+// In modern browsers, cross-site HTTP requests from scripts are restricted to same site for security reasons.
+// The following line, in our PHP examples, has been added to allow cross-site access.
+header("Access-Control-Allow-Origin: *");
+
+
+///////////////////////////////////
+// AngularJS Tables
+
+// Displaying tables with angular is very simple:
+<div ng-app="myApp" ng-controller="customersCtrl"> 
+
+<table>
+  <tr ng-repeat="x in names">
+    <td>{{ x.Name }}</td>
+    <td>{{ x.Country }}</td>
+  </tr>
+</table>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('customersCtrl', function($scope, $http) {
+    $http.get("http://www.w3schools.com/angular/customers.php")
+    .success(function (response) {$scope.names = response.records;});
+});
+</script>
+
+// To sort the table, add an orderBy filter: 
+<table>
+  <tr ng-repeat="x in names | orderBy : 'Country'">
+    <td>{{ x.Name }}</td>
+    <td>{{ x.Country }}</td>
+  </tr>
+</table>
+
+// To display the table index, add a <td> with $index: 
+<table>
+  <tr ng-repeat="x in names">
+    <td>{{ $index + 1 }}</td>
+    <td>{{ x.Name }}</td>
+    <td>{{ x.Country }}</td>
+  </tr>
+</table>
+
+// Using $even and $odd
+<table>
+  <tr ng-repeat="x in names">
+    <td ng-if="$odd" style="background-color:#f1f1f1">{{ x.Name }}</td>
+    <td ng-if="$even">{{ x.Name }}</td>
+    <td ng-if="$odd" style="background-color:#f1f1f1">{{ x.Country }}</td>
+    <td ng-if="$even">{{ x.Country }}</td>
+  </tr>
+</table>
+
+///////////////////////////////////
+// AngularJS HTML DOM
+
+//AngularJS has directives for binding application data to the attributes of HTML DOM elements.
+
+// The ng-disabled directive binds AngularJS application data to the disabled attribute of HTML elements.
+
+<div ng-app="" ng-init="mySwitch=true">
+
+<p>
+<button ng-disabled="mySwitch">Click Me!</button>
+</p>
+
+<p>
+<input type="checkbox" ng-model="mySwitch">Button
+</p>
+
+</div>
+
+//Application explained:
+
+// The ng-disabled directive binds the application data mySwitch to the HTML button's disabled attribute.
+// The ng-model directive binds the value of the HTML checkbox element to the value of mySwitch.
+// If the value of mySwitch evaluates to true, the button will be disabled: 
+<p>
+<button disabled>Click Me!</button>
+</p>
+
+// If the value of mySwitch evaluates to false, the button will not be disabled: 
+<p>
+  <button>Click Me!</button>
+</p>
+
+// The ng-show directive shows or hides an HTML element.
+
+<div ng-app="">
+
+<p ng-show="true">I am visible.</p>
+
+<p ng-show="false">I am not visible.</p>
+
+</div>
+
+// The ng-show directive shows (or hides) an HTML element based on the value of ng-show.
+// You can use any expression that evaluates to true or false:
+<div ng-app="">
+<p ng-show="hour > 12">I am visible.</p>
+</div>
+
+///////////////////////////////////
+// AngularJS Events
+
+// AngularJS has its own HTML events directives.
+
+// The ng-click directive defines an AngularJS click event.
+<div ng-app="myApp" ng-controller="myCtrl">
+
+<button ng-click="count = count + 1">Click me!</button>
+
+<p>{{ count }}</p>
+
+</div>
+<script>
+var app = angular.module('myApp', []);
+app.controller('myCtrl', function($scope) {
+    $scope.count = 0;
+});
+</script>
+
+// The ng-hide directive can be used to set the visibility of a part of an application.
+// The value ng-hide="true" makes an HTML element invisible.
+// The value ng-hide="false" makes the element visible.
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<button ng-click="toggle()">Toggle</button>
+
+<p ng-hide="myVar">
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+</p>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('personCtrl', function($scope) {
+    $scope.firstName = "John",
+    $scope.lastName = "Doe"
+    $scope.myVar = false;
+    $scope.toggle = function() {
+        $scope.myVar = !$scope.myVar;
+    };
+});
+</script>
+
+//Application explained:
+
+// The first part of the personController is the same as in the chapter about controllers.
+// The application has a default property (a variable): $scope.myVar = false;
+// The ng-hide directive sets the visibility, of a <p> element with two input fields, 
+// according to the value (true or false) of myVar.
+// The function toggle() toggles myVar between true and false.
+// The value ng-hide="true" makes the element invisible.
+
+
+// The ng-show directive can also be used to set the visibility of a part of an application.
+// The value ng-show="false" makes an HTML element invisible.
+// The value ng-show="true" makes the element visible.
+// Here is the same example as above, using ng-show instead of ng-hide:
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<button ng-click="toggle()">Toggle</button>
+
+<p ng-show="myVar">
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+</p>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('personCtrl', function($scope) {
+    $scope.firstName = "John",
+    $scope.lastName = "Doe"
+    $scope.myVar = true;
+    $scope.toggle = function() {
+        $scope.myVar = !$scope.myVar;
+    }
+});
+</script>
+
+///////////////////////////////////
+// AngularJS Modules
+
+// An AngularJS module defines an application.
+// The module is a container for the different parts of an application.
+// The module is a container for the application controllers.
+// Controllers always belong to a module.
+
+// This application ("myApp") has one controller ("myCtrl"):
+
+<!DOCTYPE html>
+<html>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+<body>
+
+<div ng-app="myApp" ng-controller="myCtrl">
+{{ firstName + " " + lastName }}
+</div>
+
+<script>
+var app = angular.module("myApp", []);
+app.controller("myCtrl", function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+});
+</script>
+
+</body>
+</html>
+
+// It is common in AngularJS applications to put the module and the controllers in JavaScript files.
+// In this example, "myApp.js" contains an application module definition, while "myCtrl.js" contains the controller:
+
+<!DOCTYPE html>
+<html>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+<body>
+
+<div ng-app="myApp" ng-controller="myCtrl">
+{{ firstName + " " + lastName }}
+</div>
+
+<script src="myApp.js"></script>
+<script src="myCtrl.js"></script>
+
+</body>
+</html>
+
+//myApp.js
+var app = angular.module("myApp", []); 
+
+// The [] parameter in the module definition can be used to define dependent modules.
+
+// myCtrl.js
+app.controller("myCtrl", function($scope) {
+    $scope.firstName  = "John";
+    $scope.lastName= "Doe";
+});
+
+// Global functions should be avoided in JavaScript. They can easily be overwritten 
+// or destroyed by other scripts.
+
+// AngularJS modules reduces this problem, by keeping all functions local to the module.
+
+// While it is common in HTML applications to place scripts at the end of the 
+// <body> element, it is recommended that you load the AngularJS library either
+// in the <head> or at the start of the <body>.
+
+// This is because calls to angular.module can only be compiled after the library has been loaded.
+
+<!DOCTYPE html>
+<html>
+<body>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+
+<div ng-app="myApp" ng-controller="myCtrl">
+{{ firstName + " " + lastName }}
+</div>
+
+<script>
+var app = angular.module("myApp", []);
+app.controller("myCtrl", function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+});
+</script>
+
+</body>
+</html>
+
+
+///////////////////////////////////
+// AngularJS Applications
+
+// AngularJS modules define AngularJS applications.
+// AngularJS controllers control AngularJS applications.
+// The ng-app directive defines the application, the ng-controller directive defines the controller.
+<div ng-app="myApp" ng-controller="myCtrl">
+  First Name: <input type="text" ng-model="firstName"><br>
+  Last Name: <input type="text" ng-model="lastName"><br>
+  <br>
+  Full Name: {{firstName + " " + lastName}}
+</div>
+<script>
+  var app = angular.module('myApp', []);
+  app.controller('myCtrl', function($scope) {
+      $scope.firstName= "John";
+      $scope.lastName= "Doe";
+  });
+</script>
+
+// AngularJS modules define applications:
+var app = angular.module('myApp', []);
+
+// AngularJS controllers control applications:
+app.controller('myCtrl', function($scope) {
+    $scope.firstName= "John";
+    $scope.lastName= "Doe";
+});
+```
+
+## Source & References
+
+**Examples**
+
+- http://www.w3schools.com/angular/angular_examples.asp
+
+**References**
+
+- http://www.w3schools.com/angular/angular_ref_directives.asp
+- http://www.w3schools.com/angular/default.asp
+- https://teamtreehouse.com/library/angular-basics/
diff --git a/ar-ar/html-ar.html.markdown b/ar-ar/html-ar.html.markdown
new file mode 100644
index 00000000..f17164cf
--- /dev/null
+++ b/ar-ar/html-ar.html.markdown
@@ -0,0 +1,121 @@
+---
+language: html
+lang: ar-ar
+filename: learnhtml-tf.html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Ader", "https://github.com/y1n0"]
+---
+
+HTML اختصار ل HyperText Markup Language، أي "لغة ترميز النص التشعبي". 
+هي لغة تمكننا من كتابة صفحات موجهة لشبكة الويب العالمي. 
+هي لغة توصيف للنص، تسمح بكتابة صفحات ويب عن طريق تحديد كيفية عرض النصوص والمعلومات. 
+في الحقيقة، ملفات html هي ملفات تحتوي على نصوص بسيطة. 
+ما هو توصيف النص هذا؟ هو طريقة لتنظيم معلومات النص عن طريق إحاطته بوُسوم فتح ووسوم غلق. 
+هذه الوسوم تعطي معاني محددة للنص الذي تحيطه. 
+كباقي لغات الحاسوب، هناك الكثير من إصدارات HTML. سنتحدث هنا عن HTLM5. 
+
+**ملاحظة:** يمكنك تجريب مختلف الوسوم والعناصر بينما تقرأ الدرس عبر موقع كـ [codepen](http://codepen.io/pen/) حتى ترى تأثيرها وتعرف كيف تعمل وتتعود على استعمالها.
+هذه المادة تُعنى أساسا بتركيب HTML .وبعض النصائح المفيدة
+
+
+```html
+<!-- التعاليق تحاط بوسوم كما في هذا السطر -->
+
+<!-- #################### الوسوم #################### -->
+   
+<!-- هنا مثال لملف html الذي سنقوم بالعمل عليه. -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>موقعي</title>
+		</head>
+		<body>
+			<h1>مرحبا بالعالم!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">الق نظرة كيف يبدو هذا من هنا</a>
+			<p>هذه فقرة.</p>
+			<p>هذه فقرة أخرى.</p>
+			<ul>
+				<li>هذا عنصر من لائحة غير مرقمة. (لائحة بالعرائض)</li>
+				<li>هذا عنصر آخر</li>
+				<li>وهذا آخر عنصر في اللائحة</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- ملف HTML يُبتدأ دائما بتبيين أنه ملف HTML للمتصفح -->
+<!doctype html>
+
+<!-- بعد هذا، يبدأ بفتح الوسم <html> -->
+<html>
+
+<!-- الذي سيغلق في نهاية الملف بـ </html>. -->
+</html>
+
+<!-- لا يجب كتابة أي شيء بعد وسم النهاية ذاك. -->
+
+<!-- داخل هذين الوسمين (<html></html>) نجد: -->
+
+<!-- "ترئيس" محدد ب <head> (يجب أن يغلق بـ </head>) -->
+<!-- الترأيس يحتوي على أوصاف وبعض المعلومات الإضافية التي لا تظهر في المتصفح, تدعي metadata (المعلومات الوصفية) -->
+
+<head>
+	<title>موقعي</title><!-- الوسم <title> يحدد للمتصفح العنوان الذي يظهر في المكان المخصص للعنوان في نافذة المتصفح. -->
+</head>
+
+<!-- بعد الجزء الخاص بـ <head>، نجد الوسم <body> -->
+<!-- حتى هنا، لا شيء مما كُتب سيظهر في النافذة الرئيسية للمتصفح. -->
+<!-- يجب ان نملأ "جسد" الصفحة بالمحتوى الذي نريد أن نُظهر -->
+
+<body>
+	<h1>مرحبا بالعالم!</h1> <!-- الوسم <h1> خاص بالعناوين الكبيرة. -->
+	<!-- هناك أيضا وسوم خاصة بالعناوين الفرعية من h1، الأكثر أهمية h2 والذي يليه حتى h6 الذي هو آخر عنوان داخلي. -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">ألق نظرة كيف يبدو هذا من هنا</a> <!-- يظهر رابطا للصفحة التي داخل السمة href="" -->
+	<p>هذه فقرة.</p> <!-- يمكن من اضافة نصوص للصفحة. يميز الفقرات -->
+	<p>هذه فقرة أخرى.</p>
+	<ul> <!-- الوسم <ul> يخلق لائحة بالعرائض -->
+	<!-- إذا أردت لائحة مرقمة، هناك الوسم <ol>. ويكون الترتيب فيه حسب تموضع العناصر داخله، الأول فالأول. -->
+		<li>هذا عنصر من لائحة غير مرقمة. (لائحة بالعرائض)</li>
+		<li>هذا عنصر آخر</li>
+		<li>وهذا آخر عنصر في اللائحة</li>
+	</ul>
+</body>
+
+<!-- وهكذا، كتابة ملفات HTML جد بسيطة -->
+
+<!-- يمكنك كذلك إضافة أنواع أخرى من الوسوم -->
+
+<!-- لادخال صورة: -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- مصدر الصورة يحدد داخل السمة: src="" -->
+<!-- مصدرها يمكن أن يكون رابطا أو مسارا لصورة في حاسوبك -->
+
+<!-- يمكنك كذلك تشكيل جداول. -->
+
+<table> <!-- نفتح الجدول بالوسم <table> -->
+	<tr> <!-- <tr> تسمح بتشكيل صف. -->
+		<th>العنوان الأول</th> <!-- <th> تسمح لنا بإعطاء عنوان لهذا العمود. -->
+		<th>العنوان الثاني</th>
+	</tr>
+	<tr>
+		<td>الصف الأول، العمود الأول</td> <!-- <td> تسمح بتشكيل الأعمدة، أو خانات داخل كل صف. -->
+		<td>الصف الأول، العمود الثاني</td>
+	</tr>
+	<tr>
+		<td>الصف الثاني، العمود الأول</td>
+		<td>الصف الثاني، العمود الأول</td>
+	</tr>
+</table>
+
+```
+
+## الاستعمال
+
+HTML يُكتب في ملفات تنتهي بـ `.html`.
+
+## لمعرفة المزيد 
+
+* [wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/asciidoc.html.markdown b/asciidoc.html.markdown
new file mode 100644
index 00000000..8326c581
--- /dev/null
+++ b/asciidoc.html.markdown
@@ -0,0 +1,122 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+filename: asciidoc.md
+---
+
+AsciiDoc is a markup language similar to Markdown and it can be used for anything from books to blogs. Created in 2002 by Stuart Rackham the language is simple but it allows for a great amount of customization.
+
+Document Header
+
+Headers are optional and can't contain blank lines. It must be offset from content by at least one blank line.
+
+Title Only
+
+```
+= Document Title
+
+First sentence of document.
+```
+
+Title and Author
+
+```
+= Document Title
+First Last <first.last@learnxinyminutes.com>
+
+Start of this document.
+```
+
+Multiple Authors
+
+```
+= Document Title
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Start of a doc with multiple authors.
+```
+
+Revision Line (requires an author line)
+
+```
+= Doc Title V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+This article about chips is going to be fun.
+```
+
+Paragraphs
+
+```
+You don't need anything special for paragraphs.
+
+Add a blank line between paragraphs to separate them.
+
+To create a line blank add a +
+and you will receive a line break!
+```
+
+Formatting Text
+
+```
+_underscore creates italics_
+*asterisks for bold*
+*_combine for extra fun_*
+`use ticks to signify monospace`
+`*bolded monospace*`
+```
+
+Section Titles
+
+```
+= Level 0 (may only be used in document's header)
+
+== Level 1 <h2>
+
+=== Level 2 <h3>
+
+==== Level 3 <h4>
+
+===== Level 4 <h5>
+
+====== Level 5 <h6>
+
+======= Level 6  <h7>
+
+```
+
+Lists
+
+To create a bulleted list use asterisks.
+
+```
+* foo
+* bar
+* baz
+```
+
+To create a numbered list use periods.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+You can nest lists by adding extra asterisks or periods up to five times.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown
index a516737e..6a6df968 100644
--- a/asymptotic-notation.html.markdown
+++ b/asymptotic-notation.html.markdown
@@ -3,41 +3,52 @@ category: Algorithms & Data Structures
 name: Asymptotic Notation
 contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Divay Prakash", "http://github.com/divayprakash"]
 ---
 
 # Asymptotic Notations
 
 ## What are they?
 
-Asymptotic Notations are languages that allow us to analyze an algorithm's running time by
-identifying its behavior as the input size for the algorithm increases. This is also known as
-an algorithm's growth rate. Does the algorithm suddenly become incredibly slow when the input
-size grows? Does it mostly maintain its quick run time as the input size increases?
-Asymptotic Notation gives us the ability to answer these questions.
+Asymptotic Notations are languages that allow us to analyze an algorithm's 
+running time by identifying its behavior as the input size for the algorithm 
+increases. This is also known as an algorithm's growth rate. Does the 
+algorithm suddenly become incredibly slow when the input size grows? Does it 
+mostly maintain its quick run time as the input size increases? Asymptotic 
+Notation gives us the ability to answer these questions.
 
 ## Are there alternatives to answering these questions?
 
-One way would be to count the number of primitive operations at different input sizes.
-Though this is a valid solution, the amount of work this takes for even simple algorithms
-does not justify its use.
+One way would be to count the number of primitive operations at different 
+input sizes. Though this is a valid solution, the amount of work this takes 
+for even simple algorithms does not justify its use.
 
-Another way is to physically measure the amount of time an algorithm takes to complete
-given different input sizes. However, the accuracy and relativity (times obtained would
-only be relative to the machine they were computed on) of this method is bound to
-environmental variables such as computer hardware specifications, processing power, etc.
+Another way is to physically measure the amount of time an algorithm takes to 
+complete given different input sizes. However, the accuracy and relativity 
+(times obtained would only be relative to the machine they were computed on) 
+of this method is bound to environmental variables such as computer hardware 
+specifications, processing power, etc.
 
 ## Types of Asymptotic Notation
 
-In the first section of this doc we described how an Asymptotic Notation identifies the
-behavior of an algorithm as the input size changes. Let us imagine an algorithm as a function
-f, n as the input size, and f(n) being the running time. So for a given algorithm f, with input
-size n you get some resultant run time f(n). This results in a graph where the Y axis is the
-runtime, X axis is the input size, and plot points are the resultants of the amount of time
-for a given input size.
-
-You can label a function, or algorithm, with an Asymptotic Notation in many different ways.
-Some examples are, you can describe an algorithm by its best case, worse case, or equivalent case.
-The most common is to analyze an algorithm by its worst case. You typically don't evaluate by best case because those conditions aren't what you're planning for. A very good example of this is sorting algorithms; specifically, adding elements to a tree structure. Best case for most algorithms could be as low as a single operation. However, in most cases, the element you're adding will need to be sorted appropriately through the tree, which could mean examining an entire branch. This is the worst case, and this is what we plan for.
+In the first section of this doc we described how an Asymptotic Notation 
+identifies the behavior of an algorithm as the input size changes. Let us 
+imagine an algorithm as a function f, n as the input size, and f(n) being 
+the running time. So for a given algorithm f, with input size n you get 
+some resultant run time f(n). This results in a graph where the Y axis is the 
+runtime, X axis is the input size, and plot points are the resultants of the 
+amount of time for a given input size.
+
+You can label a function, or algorithm, with an Asymptotic Notation in many 
+different ways. Some examples are, you can describe an algorithm by its best 
+case, worse case, or equivalent case. The most common is to analyze an 
+algorithm by its worst case. You typically don't evaluate by best case because 
+those conditions aren't what you're planning for. A very good example of this 
+is sorting algorithms; specifically, adding elements to a tree structure. Best 
+case for most algorithms could be as low as a single operation. However, in 
+most cases, the element you're adding will need to be sorted appropriately 
+through the tree, which could mean examining an entire branch. This is the 
+worst case, and this is what we plan for.
 
 ### Types of functions, limits, and simplification
 
@@ -45,16 +56,25 @@ The most common is to analyze an algorithm by its worst case. You typically don'
 Logarithmic Function - log n
 Linear Function - an + b
 Quadratic Function - an^2 + bn + c
-Polynomial Function - an^z + . . . + an^2 + a*n^1 + a*n^0, where z is some constant
+Polynomial Function - an^z + . . . + an^2 + a*n^1 + a*n^0, where z is some 
+constant
 Exponential Function - a^n, where a is some constant
 ```
 
-These are some basic function growth classifications used in various notations. The list starts at the slowest growing function (logarithmic, fastest execution time) and goes on to the fastest growing (exponential, slowest execution time). Notice that as 'n', or the input, increases in each of those functions, the result clearly increases much quicker in quadratic, polynomial, and exponential, compared to logarithmic and linear.
-
-One extremely important note is that for the notations about to be discussed you should do your best to use simplest terms. This means to disregard constants, and lower order terms, because as the input size (or n in our f(n)
-example) increases to infinity (mathematical limits), the lower order terms and constants are of little
-to no importance. That being said, if you have constants that are 2^9001, or some other ridiculous,
-unimaginable amount, realize that simplifying will skew your notation accuracy.
+These are some basic function growth classifications used in various 
+notations. The list starts at the slowest growing function (logarithmic, 
+fastest execution time) and goes on to the fastest growing (exponential, 
+slowest execution time). Notice that as 'n', or the input, increases in each 
+of those functions, the result clearly increases much quicker in quadratic, 
+polynomial, and exponential, compared to logarithmic and linear.
+
+One extremely important note is that for the notations about to be discussed 
+you should do your best to use simplest terms. This means to disregard 
+constants, and lower order terms, because as the input size (or n in our f(n) 
+example) increases to infinity (mathematical limits), the lower order terms 
+and constants are of little to no importance. That being said, if you have 
+constants that are 2^9001, or some other ridiculous, unimaginable amount, 
+realize that simplifying will skew your notation accuracy.
 
 Since we want simplest form, lets modify our table a bit...
 
@@ -67,10 +87,13 @@ Exponential - a^n, where a is some constant
 ```
 
 ### Big-O
-Big-O, commonly written as O, is an Asymptotic Notation for the worst case, or ceiling of growth
-for a given function. Say `f(n)` is your algorithm runtime, and `g(n)` is an arbitrary time complexity
-you are trying to relate to your algorithm. `f(n)` is O(g(n)), if for any real constant c (c > 0),
-`f(n)` <= `c g(n)` for every input size n (n > 0).
+Big-O, commonly written as **O**, is an Asymptotic Notation for the worst 
+case, or ceiling of growth for a given function. It provides us with an 
+_**asymptotic upper bound**_ for the growth rate of runtime of an algorithm.
+Say `f(n)` is your algorithm runtime, and `g(n)` is an arbitrary time 
+complexity you are trying to relate to your algorithm. `f(n)` is O(g(n)), if 
+for some real constants c (c > 0) and n<sub>0</sub>, `f(n)` <= `c g(n)` for every input size 
+n (n > n<sub>0</sub>).
 
 *Example 1*
 
@@ -87,7 +110,7 @@ Let's look to the definition of Big-O.
 3log n + 100 <= c * log n
 ```
 
-Is there some constant c that satisfies this for all n?
+Is there some pair of constants c, n<sub>0</sub> that satisfies this for all n > <sub>0</sub>?
 
 ```
 3log n + 100 <= 150 * log n, n > 2 (undefined at n = 1)
@@ -110,23 +133,66 @@ Let's look at the definition of Big-O.
 3 * n^2 <= c * n
 ```
 
-Is there some constant c that satisfies this for all n?
+Is there some pair of constants c, n<sub>0</sub> that satisfies this for all n > <sub>0</sub>?
 No, there isn't. `f(n)` is NOT O(g(n)).
 
 ### Big-Omega
-Big-Omega, commonly written as Ω, is an Asymptotic Notation for the best case, or a floor growth rate
-for a given function.
+Big-Omega, commonly written as **Ω**, is an Asymptotic Notation for the best 
+case, or a floor growth rate for a given function. It provides us with an 
+_**asymptotic lower bound**_ for the growth rate of runtime of an algorithm.
+
+`f(n)` is Ω(g(n)), if for some real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is >= `c g(n)` 
+for every input size n (n > n<sub>0</sub>).
+
+### Note
+
+The asymptotic growth rates provided by big-O and big-omega notation may or 
+may not be asymptotically tight. Thus we use small-o and small-omega notation 
+to denote bounds that are not asymptotically tight. 
+
+### Small-o
+Small-o, commonly written as **o**, is an Asymptotic Notation to denote the 
+upper bound (that is not asymptotically tight) on the growth rate of runtime 
+of an algorithm.
+
+`f(n)` is o(g(n)), if for some real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is < `c g(n)` 
+for every input size n (n > n<sub>0</sub>).
+
+The definitions of O-notation and o-notation are similar. The main difference 
+is that in f(n) = O(g(n)), the bound f(n) <= g(n) holds for _**some**_ 
+constant c > 0, but in f(n) = o(g(n)), the bound f(n) < c g(n) holds for 
+_**all**_ constants c > 0.
+
+### Small-omega
+Small-omega, commonly written as **ω**, is an Asymptotic Notation to denote 
+the lower bound (that is not asymptotically tight) on the growth rate of 
+runtime of an algorithm.
+
+`f(n)` is ω(g(n)), if for some real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is > `c g(n)` 
+for every input size n (n > n<sub>0</sub>).
+
+The definitions of Ω-notation and ω-notation are similar. The main difference 
+is that in f(n) = Ω(g(n)), the bound f(n) >= g(n) holds for _**some**_ 
+constant c > 0, but in f(n) = ω(g(n)), the bound f(n) > c g(n) holds for 
+_**all**_ constants c > 0.
+
+### Theta
+Theta, commonly written as **Θ**, is an Asymptotic Notation to denote the 
+_**asymptotically tight bound**_ on the growth rate of runtime of an algorithm. 
+
+`f(n)` is Θ(g(n)), if for some real constants c1, c2 and n<sub>0</sub> (c1 > 0, c2 > 0, n<sub>0</sub> > 0), 
+`c1 g(n)` is < `f(n)` is < `c2 g(n)` for every input size n (n > n<sub>0</sub>).
 
-`f(n)` is Ω(g(n)), if for any real constant c (c > 0), `f(n)` is >= `c g(n)` for every input size n (n > 0).
+∴ `f(n)` is Θ(g(n)) implies `f(n)` is O(g(n)) as well as `f(n)` is Ω(g(n)).
 
-Feel free to head over to additional resources for examples on this. Big-O is the primary notation used
-for general algorithm time complexity.
+Feel free to head over to additional resources for examples on this. Big-O 
+is the primary notation use for general algorithm time complexity.
 
 ### Ending Notes
-It's hard to keep this kind of topic short, and you should definitely go through the books and online
-resources listed. They go into much greater depth with definitions and examples.
-More where x='Algorithms & Data Structures' is on its way; we'll have a doc up on analyzing actual
-code examples soon.
+It's hard to keep this kind of topic short, and you should definitely go 
+through the books and online resources listed. They go into much greater depth 
+with definitions and examples. More where x='Algorithms & Data Structures' is 
+on its way; we'll have a doc up on analyzing actual code examples soon.
 
 ## Books
 
@@ -137,3 +203,4 @@ code examples soon.
 
 * [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf)
 * [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
+* [Big-O Cheatsheet](http://bigocheatsheet.com/) - common structures, operations, and algorithms, ranked by complexity.
diff --git a/awk.html.markdown b/awk.html.markdown
new file mode 100644
index 00000000..90f88b1a
--- /dev/null
+++ b/awk.html.markdown
@@ -0,0 +1,359 @@
+---
+language: awk
+filename: learnawk.awk
+contributors:
+    - ["Marshall Mason", "http://github.com/marshallmason"]
+lang: en
+---
+
+AWK is a standard tool on every POSIX-compliant UNIX system. It's like a
+stripped-down Perl, perfect for text-processing tasks and other scripting
+needs. It has a C-like syntax, but without semicolons, manual memory
+management, or static typing. It excels at text processing. You can call to it
+from a shell script, or you can use it as a stand-alone scripting language.
+
+Why use AWK instead of Perl? Mostly because AWK is part of UNIX. You can always
+count on it, whereas Perl's future is in question. AWK is also easier to read
+than Perl. For simple text-processing scripts, particularly ones that read
+files line by line and split on delimiters, AWK is probably the right tool for
+the job.
+
+```awk
+#!/usr/bin/awk -f
+
+# Comments are like this
+
+# AWK programs consist of a collection of patterns and actions. The most
+# important pattern is called BEGIN. Actions go into brace blocks.
+BEGIN {
+
+    # BEGIN will run at the beginning of the program. It's where you put all
+    # the preliminary set-up code, before you process any text files. If you
+    # have no text files, then think of BEGIN as the main entry point.
+
+    # Variables are global. Just set them or use them, no need to declare..
+    count = 0
+
+    # Operators just like in C and friends
+    a = count + 1
+    b = count - 1
+    c = count * 1
+    d = count / 1
+    e = count % 1 # modulus
+    f = count ^ 1 # exponentiation
+
+    a += 1
+    b -= 1
+    c *= 1
+    d /= 1
+    e %= 1
+    f ^= 1
+
+    # Incrementing and decrementing by one
+    a++
+    b--
+
+    # As a prefix operator, it returns the incremented value
+    ++a
+    --b
+
+    # Notice, also, no punctuation such as semicolons to terminate statements
+
+    # Control statements
+    if (count == 0)
+        print "Starting with count of 0"
+    else
+        print "Huh?"
+
+    # Or you could use the ternary operator
+    print (count == 0) ? "Starting with count of 0" : "Huh?"
+
+    # Blocks consisting of multiple lines use braces
+    while (a < 10) {
+        print "String concatenation is done" " with a series" " of"
+            " space-separated strings"
+        print a
+
+        a++
+    }
+
+    for (i = 0; i < 10; i++)
+        print "Good ol' for loop"
+
+    # As for comparisons, they're the standards:
+    a < b   # Less than
+    a <= b  # Less than or equal
+    a != b  # Not equal
+    a == b  # Equal
+    a > b   # Greater than
+    a >= b  # Greater than or equal
+
+    # Logical operators as well
+    a && b  # AND
+    a || b  # OR
+
+    # In addition, there's the super useful regular expression match
+    if ("foo" ~ "^fo+$")
+        print "Fooey!"
+    if ("boo" !~ "^fo+$")
+        print "Boo!"
+
+    # Arrays
+    arr[0] = "foo"
+    arr[1] = "bar"
+    # Unfortunately, there is no other way to initialize an array. Ya just
+    # gotta chug through every value line by line like that.
+
+    # You also have associative arrays
+    assoc["foo"] = "bar"
+    assoc["bar"] = "baz"
+
+    # And multi-dimensional arrays, with some limitations I won't mention here
+    multidim[0,0] = "foo"
+    multidim[0,1] = "bar"
+    multidim[1,0] = "baz"
+    multidim[1,1] = "boo"
+
+    # You can test for array membership
+    if ("foo" in assoc)
+        print "Fooey!"
+
+    # You can also use the 'in' operator to traverse the keys of an array
+    for (key in assoc)
+        print assoc[key]
+
+    # The command line is in a special array called ARGV
+    for (argnum in ARGV)
+        print ARGV[argnum]
+
+    # You can remove elements of an array
+    # This is particularly useful to prevent AWK from assuming the arguments
+    # are files for it to process
+    delete ARGV[1]
+
+    # The number of command line arguments is in a variable called ARGC
+    print ARGC
+
+    # AWK has several built-in functions. They fall into three categories. I'll
+    # demonstrate each of them in their own functions, defined later.
+
+    return_value = arithmetic_functions(a, b, c)
+    string_functions()
+    io_functions()
+}
+
+# Here's how you define a function
+function arithmetic_functions(a, b, c,     localvar) {
+
+    # Probably the most annoying part of AWK is that there are no local
+    # variables. Everything is global. For short scripts, this is fine, even
+    # useful, but for longer scripts, this can be a problem.
+
+    # There is a work-around (ahem, hack). Function arguments are local to the
+    # function, and AWK allows you to define more function arguments than it
+    # needs. So just stick local variable in the function declaration, like I
+    # did above. As a convention, stick in some extra whitespace to distinguish
+    # between actual function parameters and local variables. In this example,
+    # a, b, and c are actual parameters, while d is merely a local variable.
+
+    # Now, to demonstrate the arithmetic functions
+
+    # Most AWK implementations have some standard trig functions
+    localvar = sin(a)
+    localvar = cos(a)
+    localvar = atan2(a, b) # arc tangent of b / a
+
+    # And logarithmic stuff
+    localvar = exp(a)
+    localvar = log(a)
+
+    # Square root
+    localvar = sqrt(a)
+
+    # Truncate floating point to integer
+    localvar = int(5.34) # localvar => 5
+
+    # Random numbers
+    srand() # Supply a seed as an argument. By default, it uses the time of day
+    localvar = rand() # Random number between 0 and 1.
+
+    # Here's how to return a value
+    return localvar
+}
+
+function string_functions(    localvar, arr) {
+
+    # AWK, being a string-processing language, has several string-related
+    # functions, many of which rely heavily on regular expressions.
+
+    # Search and replace, first instance (sub) or all instances (gsub)
+    # Both return number of matches replaced
+    localvar = "fooooobar"
+    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+
+    # Search for a string that matches a regular expression
+    # index() does the same thing, but doesn't allow a regular expression
+    match(localvar, "t") # => 4, since the 't' is the fourth character
+
+    # Split on a delimiter
+    split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
+
+    # Other useful stuff
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
+    substr("foobar", 2, 3) # => "oob"
+    substr("foobar", 4) # => "bar"
+    length("foo") # => 3
+    tolower("FOO") # => "foo"
+    toupper("foo") # => "FOO"
+}
+
+function io_functions(    localvar) {
+
+    # You've already seen print
+    print "Hello world"
+
+    # There's also printf
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3)
+
+    # AWK doesn't have file handles, per se. It will automatically open a file
+    # handle for you when you use something that needs one. The string you used
+    # for this can be treated as a file handle, for purposes of I/O. This makes
+    # it feel sort of like shell scripting:
+
+    print "foobar" >"/tmp/foobar.txt"
+
+    # Now the string "/tmp/foobar.txt" is a file handle. You can close it:
+    close("/tmp/foobar.txt")
+
+    # Here's how you run something in the shell
+    system("echo foobar") # => prints foobar
+
+    # Reads a line from standard input and stores in localvar
+    getline localvar
+
+    # Reads a line from a pipe
+    "echo foobar" | getline localvar # localvar => "foobar"
+    close("echo foobar")
+
+    # Reads a line from a file and stores in localvar
+    getline localvar <"/tmp/foobar.txt"
+    close("/tmp/foobar.txt")
+}
+
+# As I said at the beginning, AWK programs consist of a collection of patterns
+# and actions. You've already seen the all-important BEGIN pattern. Other
+# patterns are used only if you're processing lines from files or standard
+# input.
+#
+# When you pass arguments to AWK, they are treated as file names to process.
+# It will process them all, in order. Think of it like an implicit for loop,
+# iterating over the lines in these files. these patterns and actions are like
+# switch statements inside the loop. 
+
+/^fo+bar$/ {
+    
+    # This action will execute for every line that matches the regular
+    # expression, /^fo+bar$/, and will be skipped for any line that fails to
+    # match it. Let's just print the line:
+
+    print
+
+    # Whoa, no argument! That's because print has a default argument: $0.
+    # $0 is the name of the current line being processed. It is created
+    # automatically for you.
+
+    # You can probably guess there are other $ variables. Every line is
+    # implicitely split before every action is called, much like the shell
+    # does. And, like the shell, each field can be access with a dollar sign
+
+    # This will print the second and fourth fields in the line
+    print $2, $4
+
+    # AWK automatically defines many other variables to help you inspect and
+    # process each line. The most important one is NF
+
+    # Prints the number of fields on this line
+    print NF
+
+    # Print the last field on this line
+    print $NF
+}
+
+# Every pattern is actually a true/false test. The regular expression in the
+# last pattern is also a true/false test, but part of it was hidden. If you
+# don't give it a string to test, it will assume $0, the line that it's
+# currently processing. Thus, the complete version of it is this:
+
+$0 ~ /^fo+bar$/ {
+    print "Equivalent to the last pattern"
+}
+
+a > 0 {
+    # This will execute once for each line, as long as a is positive
+}
+
+# You get the idea. Processing text files, reading in a line at a time, and
+# doing something with it, particularly splitting on a delimiter, is so common
+# in UNIX that AWK is a scripting language that does all of it for you, without
+# you needing to ask. All you have to do is write the patterns and actions
+# based on what you expect of the input, and what you want to do with it.
+
+# Here's a quick example of a simple script, the sort of thing AWK is perfect
+# for. It will read a name from standard input and then will print the average
+# age of everyone with that first name. Let's say you supply as an argument the
+# name of a this data file:
+#
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# Here's the script:
+
+BEGIN {
+
+    # First, ask the user for the name
+    print "What name would you like the average age for?"
+
+    # Get a line from standard input, not from files on the command line
+    getline name <"/dev/stdin"
+}
+
+# Now, match every line whose first field is the given name
+$1 == name {
+
+    # Inside here, we have access to a number of useful variables, already
+    # pre-loaded for us:
+    # $0 is the entire line
+    # $3 is the third field, the age, which is what we're interested in here
+    # NF is the number of fields, which should be 3
+    # NR is the number of records (lines) seen so far
+    # FILENAME is the name of the file being processed
+    # FS is the field separator being used, which is " " here
+    # ...etc. There are plenty more, documented in the man page.
+
+    # Keep track of a running total and how many lines matched
+    sum += $3
+    nlines++
+}
+
+# Another special pattern is called END. It will run after processing all the
+# text files. Unlike BEGIN, it will only run if you've given it input to
+# process. It will run after all the files have been read and processed
+# according to the rules and actions you've provided. The purpose of it is
+# usually to output some kind of final report, or do something with the
+# aggregate of the data you've accumulated over the course of the script.
+
+END {
+    if (nlines)
+        print "The average age for " name " is " sum / nlines
+}
+
+```
+Further Reading:
+
+* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
+* [Awk man page](https://linux.die.net/man/1/awk)
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk is found on most Linux systems.
diff --git a/bash.html.markdown b/bash.html.markdown
index bd2d5984..14366e4c 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -11,6 +11,10 @@ contributors:
     - ["Rahil Momin", "https://github.com/iamrahil"]
     - ["Gregrory Kielian", "https://github.com/gskielian"]
     - ["Etan Reisner", "https://github.com/deryni"]
+    - ["Jonathan Wang", "https://github.com/Jonathansw"]   
+    - ["Leo Rudberg", "https://github.com/LOZORD"]
+    - ["Betsy Lorton", "https://github.com/schbetsy"]
+    - ["John Detter", "https://github.com/jdetter"]
 filename: LearnBash.sh
 ---
 
@@ -54,6 +58,13 @@ echo '$Variable'
 # its name without $. If you want to use the variable's value, you should use $.
 # Note that ' (single quote) won't expand the variables!
 
+# Parameter expansion ${ }:
+echo ${Variable}
+# This is a simple usage of parameter expansion
+# Parameter Expansion gets a value from a variable.  It "expands" or prints the value
+# During the expansion time the value or parameter are able to be modified
+# Below are other modifications that add onto this expansion
+
 # String substitution in variables
 echo ${Variable/Some/A}
 # This will substitute the first occurrence of "Some" with "A"
@@ -68,6 +79,12 @@ echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
 # This works for null (Foo=) and empty string (Foo=""); zero (Foo=0) returns 0.
 # Note that it only returns default value and doesn't change variable value.
 
+# Brace Expansion { }
+# Used to generate arbitrary strings
+echo {1..10}
+echo {a..z}
+# This will output the range from the start value to the end value
+
 # Builtin variables:
 # There are some useful builtin variables, like
 echo "Last program's return value: $?"
@@ -76,6 +93,21 @@ echo "Number of arguments passed to script: $#"
 echo "All arguments passed to script: $@"
 echo "Script's arguments separated into different variables: $1 $2..."
 
+# Now that we know how to echo and use variables,
+# let's learn some of the other basics of bash!
+
+# Our current directory is available through the command `pwd`.
+# `pwd` stands for "print working directory".
+# We can also use the builtin variable `$PWD`.
+# Observe that the following are equivalent:
+echo "I'm in $(pwd)" # execs `pwd` and interpolates output
+echo "I'm in $PWD" # interpolates the variable
+
+# If you get too much output in your terminal, or from a script, the command
+# `clear` clears your screen
+clear
+# Ctrl-L also works for clearing output
+
 # Reading a value from input:
 echo "What's your name?"
 read Name # Note that we didn't need to declare a new variable
@@ -124,12 +156,54 @@ ls
 
 # These commands have options that control their execution:
 ls -l # Lists every file and directory on a separate line
+ls -t # Sorts the directory contents by last-modified date (descending)
+ls -R # Recursively `ls` this directory and all of its subdirectories
 
 # 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:
 ls -l | grep "\.txt"
 
+# Use `cat` to print files to stdout:
+cat file.txt
+
+# We can also read the file using `cat`:
+Contents=$(cat file.txt)
+echo "START OF FILE\n$Contents\nEND OF FILE"
+
+# Use `cp` to copy files or directories from one place to another.
+# `cp` creates NEW versions of the sources,
+# so editing the copy won't affect the original (and vice versa).
+# Note that it will overwrite the destination if it already exists.
+cp srcFile.txt clone.txt
+cp -r srcDirectory/ dst/ # recursively copy
+
+# Look into `scp` or `sftp` if you plan on exchanging files between computers.
+# `scp` behaves very similarly to `cp`.
+# `sftp` is more interactive.
+
+# Use `mv` to move files or directories from one place to another.
+# `mv` is similar to `cp`, but it deletes the source.
+# `mv` is also useful for renaming files!
+mv s0urc3.txt dst.txt # sorry, l33t hackers...
+
+# Since bash works in the context of a current directory, you might want to 
+# run your command in some other directory. We have cd for changing location:
+cd ~    # change to home directory
+cd ..   # go up one directory
+        # (^^say, from /home/username/Downloads to /home/username)
+cd /home/username/Documents   # change to specified directory
+cd ~/Documents/..    # still in home directory..isn't it??
+
+# Use subshells to work across directories
+(echo "First, I'm here: $PWD") && (cd someDir; echo "Then, I'm here: $PWD")
+pwd # still in first directory
+
+# Use `mkdir` to create new directories.
+mkdir myNewDir
+# The `-p` flag causes new intermediate directories to be created as necessary.
+mkdir -p myNewDir/with/intermediate/directories
+
 # You can redirect command input and output (stdin, stdout, and stderr).
 # Read from stdin until ^EOF$ and overwrite hello.py with the lines
 # between "EOF":
@@ -168,7 +242,9 @@ echo "#helloworld" | cat > output.out
 echo "#helloworld" | tee output.out >/dev/null
 
 # Cleanup temporary files verbosely (add '-i' for interactive)
+# WARNING: `rm` commands cannot be undone
 rm -v output.out error.err output-and-error.log
+rm -r tempDir/ # recursively delete
 
 # Commands can be substituted within other commands using $( ):
 # The following command displays the number of files and directories in the
@@ -259,10 +335,25 @@ sed -i 's/okay/great/g' file.txt
 grep "^foo.*bar$" file.txt
 # pass the option "-c" to instead print the number of lines matching the regex
 grep -c "^foo.*bar$" file.txt
+# Other useful options are:
+grep -r "^foo.*bar$" someDir/ # recursively `grep`
+grep -n "^foo.*bar$" file.txt # give line numbers
+grep -rI "^foo.*bar$" someDir/ # recursively `grep`, but ignore binary files
+# perform the same initial search, but filter out the lines containing "baz"
+grep "^foo.*bar$" file.txt | grep -v "baz"
+
 # if you literally want to search for the string,
 # and not the regex, use fgrep (or grep -F)
-fgrep "^foo.*bar$" file.txt
+fgrep "foobar" file.txt
+
+# trap command allows you to execute a command when a signal is received by your script.
+# Here trap command will execute rm if any one of the three listed signals is received.
+trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
 
+# `sudo` is used to perform commands as the superuser
+NAME1=$(whoami)
+NAME2=$(sudo whoami)
+echo "Was $NAME1, then became more powerful $NAME2"
 
 # Read Bash shell builtins documentation with the bash 'help' builtin:
 help
diff --git a/brainfuck.html.markdown b/bf.html.markdown
index a76169c8..9c603303 100644
--- a/brainfuck.html.markdown
+++ b/bf.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
@@ -10,7 +10,7 @@ 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/).
 
-```
+```bf
 Any character not "><+-.,[]" (excluding quotation marks) is ignored.
 
 Brainfuck is represented by an array with 30,000 cells initialized to zero
diff --git a/bg-bg/perl-bg.html.markdown b/bg-bg/perl-bg.html.markdown
new file mode 100644
index 00000000..babd2d4d
--- /dev/null
+++ b/bg-bg/perl-bg.html.markdown
@@ -0,0 +1,326 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl.pl
+contributors:
+    - ["Korjavin Ivan", "http://github.com/korjavin"]
+    - ["Dan Book", "http://github.com/Grinnz"]
+translators:
+    - ["Красимир Беров", "https://github.com/kberov"]
+lang: bg-bg
+---
+
+Perl 5 е изключително мощен език за програмиране с широка област на приложение
+и над 25 годишна история.
+
+Perl 5 работи на повече от 100 операционни системи от мини до супер-компютри и е
+подходящ както за бърза разработка на скриптове така и за огромни приложения.
+
+```perl
+# Едноредовите коментари започват със знака диез.
+
+#### Стриктен режим и предупреждения
+
+use strict;
+use warnings;
+
+# Силно препоръчително е всички скриптове и модули да включват тези редове.
+# strict спира компилацията в случай на необявени предварително променливи.
+# warnings показва предупредителни съобщения в случай на често допускани грешки,
+# например използване на променливи без стойност в низове.
+
+#### Типове променливи в Perl
+
+# Променливите започват със съответен знак (sigil - от латински sigillum ),
+# който представлява символ, указващ типа на променливата. Името на самата
+# променлива започва с буква или знак за подчертаване (_), следван от какъвто и
+# да е брой букви, цифри или знаци за подчертаване. Забележете, че ако напишете
+# 'use utf8;' (без кавичките), можете да използвате всякакви букви за имена на
+# променливите, включително и български.
+
+### Perl има три главни типа променливи: $scalar (скалар), @array (масив), and %hash (хеш).
+
+## Скалари
+#  Скаларът представлява единична стойност:
+my $animal = "camel";
+my $answer = 42;
+use utf8;
+my $животно = 'камила';
+
+# Стойностите на скаларите могат да бъдат низове, цели числа или числа с
+# плаваща запетая (десетични дроби). Perl автоматично ги ползва и превръща от
+# един тип стойност в друга, според както е необходимо.
+
+## Масиви
+#  Масивът представлява списък от стойности:
+my @animals = ("камила", "llama", "owl");
+my @numbers = (23, 42, 69);
+my @mixed   = ("camel", 42, 1.23);
+
+# Елементите на масива се достъпват като се използват квадратни скоби и $,
+# който указва каква стойност ще бъде върната (скалар).
+my $second = $animals[1];
+
+## Хешове
+#  Хешът представлява набор от двойки ключ/стойност:
+
+my %fruit_color = ("ябълка", "червена", "banana", "yellow");
+
+# Може да използвате празно пространство и оператора "=>" (тлъста запетая),
+# за да ги изложите по-прегледно:
+
+%fruit_color = (
+  ябълка  => "червена",
+  banana => "yellow",
+);
+
+# Елементите (стойностите) от хеша се достъпват чрез използване на ключовете.
+# Ключовете се ограждат с фигурни скоби и се поставя $ пред името на хеша.
+my $color = $fruit_color{ябълка};
+
+# Скаларите, масивите и хешовете са документирани по-пълно в perldata.
+# На командния ред напишете (без кавичките) 'perldoc perldata'.
+
+#### Указатели (Референции)
+
+# По-сложни типове данни могат да бъдат създавани чрез използване на указатели,
+# които ви позволяват да изграждате масиви и хешове в други масиви и хешове.
+
+my $array_ref = \@array;
+my $hash_ref = \%hash;
+my @array_of_arrays = (\@array1, \@array2, \@array3);
+
+# Също така можете да създавате безименни масиви и хешове, към които сочат само
+# указатели.
+
+my $fruits = ["apple", "banana"];
+my $colors = {apple => "red", banana => "yellow"};
+
+# Можете да достигате до безименните структури като поставяте отпред съответния
+# знак на структурата, която искате да достъпите (дереферирате).
+
+my @fruits_array = @$fruits;
+my %colors_hash = %$colors;
+
+# Можете да използвате оператора стрелка (->), за да достигнете до отделна
+# скаларна стойност.
+
+my $first = $array_ref->[0];
+my $value = $hash_ref->{banana};
+
+# Вижте perlreftut и perlref, където ще намерите по-задълбочена документация за
+# указателите (референциите).
+
+#### Условни изрази и цикли
+
+# В Perl ще срещнете повечето от обичайните изрази за условия и обхождане (цикли).
+
+if ($var) {
+  ...
+} elsif ($var eq 'bar') {
+  ...
+} else {
+  ...
+}
+
+unless (условие) {
+  ...
+}
+# Това е друг, по-четим вариант на "if (!условие)"
+
+# Perl-овския начин след-условие
+print "Yow!" if $zippy;
+print "Нямаме банани" unless $bananas;
+
+#  докато
+while (условие) {
+  ...
+}
+
+
+# цикли for и повторение
+for (my $i = 0; $i < $max; $i++) {
+  print "index is $i";
+}
+
+for (my $i = 0; $i < @elements; $i++) {
+  print "Current element is " . $elements[$i];
+}
+
+for my $element (@elements) {
+  print $element;
+}
+
+# мълчаливо - използва се подразбиращата се променлива $_.
+for (@elements) {
+  print;
+}
+
+# Отново Perl-овския начин след-
+print for @elements;
+
+# отпечатване на стойностите чрез обхождане ключовете на указател към хеш
+print $hash_ref->{$_} for keys %$hash_ref;
+
+#### Регулярни (обикновени) изрази
+
+# Поддръжката на регулярни изрази  е залеганала дълбоко в Perl. Задълбочена
+# документация ще намерите в perlrequick, perlretut и на други места.
+# Но ето накратко:
+
+# Просто съвпадение
+if (/foo/)       { ... }  # истина ако $_ съдържа "foo"
+if ($x =~ /foo/) { ... }  # истина ако $x съдържа "foo"
+
+# Просто заместване
+
+$x =~ s/foo/bar/;         # замества foo с bar в $x
+$x =~ s/foo/bar/g;        # Замества ВСИЧКИ ПОЯВИ на foo с bar в $x
+
+
+#### Файлове и Вход/Изход (I/O)
+
+# Можете да отворите файл за въвеждане на данни в него или за извеждане на
+# данни от него като използвате функцията "open()".
+
+open(my $in,  "<",  "input.txt")  or die "Не мога да отворя input.txt: $!";
+open(my $out, ">",  "output.txt") or die "Can't open output.txt: $!";
+open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";
+
+# Можете да четете от отворен файлов манипулатор като използвате оператора
+# "<>". В скаларен контекст той чете по един ред от файла наведнъж, а в списъчен
+# контекст изчита всички редове от файла наведнъж като присвоява всеки ред на
+# масива:
+
+my $line  = <$in>;
+my @lines = <$in>;
+
+#### Подпрограми (функции)
+
+# Да се пишат подпрограми е лесно:
+
+sub logger {
+  my $logmessage = shift;
+
+  open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
+
+  print $logfile $logmessage;
+}
+
+# Сега можем да ползваме подпрограмата като всяка друга вградена функция:
+
+logger("Имаме подпрограма, която пише във файл-отчет!");
+
+#### Модули
+
+# Модулът е набор от програмен код на Perl, обикновено подпрограми, който може
+# да бъде използван в друг програмен код на Perl. Обикновено се съхранява във
+# файл с разширение .pm, така че perl (програмата) да може лесно да го разпознае.
+
+# В MyModule.pm
+package MyModule;
+use strict;
+use warnings;
+
+sub trim {
+  my $string = shift;
+  $string =~ s/^\s+//;
+  $string =~ s/\s+$//;
+  return $string;
+}
+
+1;
+
+# От другаде:
+
+use MyModule;
+MyModule::trim($string);
+
+# Чрез модула Exporter може да направите функциите си износни, така че други
+# програми да могат да ги внасят (импортират).
+# Такива функции се използват така:
+
+use MyModule 'trim';
+trim($string);
+
+# Много Perl-модули могат да се свалят от CPAN (http://www.cpan.org/). Те
+# притежават редица полезни свойства, които ще ви помогнат да си свършите работа
+# без да откривате колелото. Голям брой известни модули като Exporter са включени
+# в дистрибуцията на самия Perl. Вижте perlmod  за повече подробности, свързани с
+# модулите в Perl.
+
+#### Обекти
+
+# Обектите в Perl са просто референции, които знаят на кой клас (пакет)
+# принадлежат. По този начин методите (подпрограми), които се извикват срещу
+# тях могат да бъдат намерени в съответния клас. За да се случи това, в
+# конструкторите (обикновено new) се използва вградената функция
+# bless. Ако използвате обаче модули като Moose или Moo, няма да ви се налага
+# сами да извиквате bless (ще видите малко по-долу).
+
+package MyCounter;
+use strict;
+use warnings;
+
+sub new {
+  my $class = shift;
+  my $self = {count => 0};
+  return bless $self, $class;
+}
+
+sub count {
+  my $self = shift;
+  return $self->{count};
+}
+
+sub increment {
+  my $self = shift;
+  $self->{count}++;
+}
+
+1;
+
+# Методите могат да се извикват на клас или на обект като се използва оператора 
+# стрелка (->).
+
+use MyCounter;
+my $counter = MyCounter->new;
+print $counter->count, "\n"; # 0
+$counter->increment;
+print $counter->count, "\n"; # 1
+
+# Модулите Moose и Moo от CPAN  ви помагат леснот да създавате класове. Те
+# предоставят готов конструктор (new) и прост синтаксис за деклариране на
+# свойства на обектите (attributes). Този клас може да се използва по същия начин
+# като предишния по-горе.
+
+package MyCounter;
+use Moo; # внася strict и warnings
+
+has 'count' => (is => 'rwp', default => 0, init_arg => undef);
+
+sub increment {
+  my $self = shift;
+  $self->_set_count($self->count + 1);
+}
+
+1;
+
+# Обектно-ориентираното програмиране е разгледано по-задълбочено в perlootut,
+# а изпълнението му на ниско ниво в Perl е обяснено в perlobj.
+```
+
+#### Често задавани въпроси (FAQ)
+
+# perlfaq съдържа въпроси и отговори, отнасящи се до много общи задачи и предлага
+# за ползване добри модлули от CPAN, подходящи за решаване на различни проблеми.
+
+#### Повече за четене
+ - [Въведение в Perl](http://www.slideshare.net/kberov/01-intro-bg)
+ - [PERL - Курс на МГУ "Св.Иван Рилски" (13 ЧАСТИ)](http://www.mgu.bg/drugi/ebooks/belchevski/perl.html)
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Learn at www.perl.com](http://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - и идващото с perl: `perldoc perlintro`
+
diff --git a/c++.html.markdown b/c++.html.markdown
index a59b4db8..1461c93e 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -6,6 +6,8 @@ contributors:
     - ["Matt Kline", "https://github.com/mrkline"]
     - ["Geoff Liu", "http://geoffliu.me"]
     - ["Connor Waters", "http://github.com/connorwaters"]
+    - ["Ankush Goyal", "http://github.com/ankushg07"]
+    - ["Jatin Dhankhar", "https://github.com/jatindhankhar"]
 lang: en
 ---
 
@@ -215,7 +217,7 @@ cout << myString + myOtherString; // "Hello World"
 
 cout << myString + " You"; // "Hello You"
 
-// C++ strings are mutable and have value semantics.
+// C++ strings are mutable.
 myString.append(" Dog");
 cout << myString; // "Hello Dog"
 
@@ -330,7 +332,7 @@ ECarTypes GetPreferredCarType()
 }
 
 // As of C++11 there is an easy way to assign a type to the enum which can be
-// useful in serialization of data and converting enums back-and-forth between 
+// useful in serialization of data and converting enums back-and-forth between
 // the desired type and their respective constants
 enum ECarTypes : uint8_t
 {
@@ -352,7 +354,7 @@ void WritePreferredCarTypeToFile(ECarTypes InputCarType)
 }
 
 // On the other hand you may not want enums to be accidentally cast to an integer
-// type or to other enums so it is instead possible to create an enum class which 
+// type or to other enums so it is instead possible to create an enum class which
 // won't be implicitly converted
 enum class ECarTypes : uint8_t
 {
@@ -454,7 +456,7 @@ void Dog::print() const
 
 Dog::~Dog()
 {
-    cout << "Goodbye " << name << "\n";
+    std::cout << "Goodbye " << name << "\n";
 }
 
 int main() {
@@ -468,7 +470,7 @@ int main() {
 // Inheritance:
 
 // This class inherits everything public and protected from the Dog class
-// as well as private but may not directly access private members/methods 
+// as well as private but may not directly access private members/methods
 // without a public or protected method for doing so
 class OwnedDog : public Dog {
 
@@ -806,8 +808,8 @@ void doSomethingWithAFile(const std::string& filename)
 // have default comparators, but you can override it.
 class Foo {
 public:
-	int j;
-	Foo(int a) : j(a) {}
+    int j;
+    Foo(int a) : j(a) {}
 };
 struct compareFunction {
     bool operator()(const Foo& a, const Foo& b) const {
@@ -825,10 +827,10 @@ fooMap.find(Foo(1)); //true
 ///////////////////////////////////////
 
 // lambdas are a convenient way of defining an anonymous function
-// object right at the location where it is invoked or passed as 
+// object right at the location where it is invoked or passed as
 // an argument to a function.
 
-// For example, consider sorting a vector of pairs using the second 
+// For example, consider sorting a vector of pairs using the second
 // value of the pair
 
 vector<pair<int, int> > tester;
@@ -856,7 +858,7 @@ sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int,
 vector<int> dog_ids;
 // number_of_dogs = 3;
 for(int i = 0; i < 3; i++) {
-	dog_ids.push_back(i);  
+	dog_ids.push_back(i);
 }
 
 int weight[3] = {30, 50, 10};
@@ -940,29 +942,13 @@ Foo f1;
 f1 = f2;
 
 
-// How to truly clear a container:
-class Foo { ... };
-vector<Foo> v;
-for (int i = 0; i < 10; ++i)
-  v.push_back(Foo());
-
-// Following line sets size of v to 0, but destructors don't get called
-// and resources aren't released!
-v.clear();
-v.push_back(Foo());  // New value is copied into the first Foo we inserted
-
-// Truly destroys all values in v. See section about temporary objects for
-// explanation of why this works.
-v.swap(vector<Foo>());
-
-
 ///////////////////////////////////////
 // Tuples (C++11 and above)
 ///////////////////////////////////////
 
 #include<tuple>
 
-// Conceptually, Tuples are similar to  old data structures (C-like structs) but instead of having named data members , 
+// Conceptually, Tuples are similar to  old data structures (C-like structs) but instead of having named data members,
 // its elements are accessed by their order in the tuple.
 
 // We start with constructing a tuple.
@@ -972,10 +958,10 @@ const int maxN = 1e9;
 const int maxL = 15;
 auto second = make_tuple(maxN, maxL);
 
-// printing elements of 'first' tuple
+// Printing elements of 'first' tuple
 cout << get<0>(first) << " " << get<1>(first) << "\n"; //prints : 10 A
 
-// printing elements of 'second' tuple
+// Printing elements of 'second' tuple
 cout << get<0>(second) << " " << get<1>(second) << "\n"; // prints: 1000000000 15
 
 // Unpacking tuple into variables
@@ -995,12 +981,149 @@ cout << tuple_size<decltype(third)>::value << "\n"; // prints: 3
 // tuple_cat concatenates the elements of all the tuples in the same order.
 
 auto concatenated_tuple = tuple_cat(first, second, third);
-// concatenated_tuple becomes = (10, 'A', 1e9, 15, 11, 'A' ,3.14141) 
+// concatenated_tuple becomes = (10, 'A', 1e9, 15, 11, 'A', 3.14141)
 
 cout << get<0>(concatenated_tuple) << "\n"; // prints: 10
 cout << get<3>(concatenated_tuple) << "\n"; // prints: 15
 cout << get<5>(concatenated_tuple) << "\n"; // prints: 'A'
 
+
+/////////////////////
+// Containers
+/////////////////////
+
+// Containers or the Standard Template Library are some predefined templates.
+// They manage the storage space for its elements and provide
+// member functions to access and manipulate them.
+
+// Few containers are as follows:
+
+// Vector (Dynamic array)
+// Allow us to Define the Array or list of objects at run time
+#include<vector>
+vector<Data_Type> Vector_name; // used to initialize the vector
+cin >> val;
+Vector_name.push_back(val); // will push the value of variable into array
+
+// To iterate through vector, we have 2 choices:
+// Normal looping
+for(int i=0; i<Vector_name.size(); i++)
+// It will iterate through the vector from index '0' till last index
+
+// Iterator
+vector<Data_Type>::iterator it; // initialize the iterator for vector
+for(it=vector_name.begin(); it!=vector_name.end();++it)
+
+// For accessing the element of the vector
+// Operator []
+var = vector_name[index]; // Will assign value at that index to var
+
+
+// Set
+// Sets are containers that store unique elements following a specific order.
+// Set is a very useful container to store unique values in sorted order
+// without any other functions or code.
+
+#include<set>
+set<int> ST;    // Will initialize the set of int data type
+ST.insert(30);  // Will insert the value 30 in set ST
+ST.insert(10);  // Will insert the value 10 in set ST
+ST.insert(20);  // Will insert the value 20 in set ST
+ST.insert(30);  // Will insert the value 30 in set ST
+// Now elements of sets are as follows
+//  10 20 30
+
+// To erase an element
+ST.erase(20);  // Will erase element with value 20
+// Set ST: 10 30
+// To iterate through Set we use iterators
+set<int>::iterator it;
+for(it=ST.begin();it<ST.end();it++) {
+	cout << *it << endl;
+}
+// Output:
+// 10
+// 30
+
+// To clear the complete container we use Container_name.clear()
+ST.clear();
+cout << ST.size();  // will print the size of set ST
+// Output: 0
+
+// NOTE: for duplicate elements we can use multiset
+
+// Map
+// Maps store elements formed by a combination of a key value
+// and a mapped value, following a specific order.
+
+#include<map>
+map<char, int> mymap;  // Will initialize the map with key as char and value as int
+
+mymap.insert(pair<char,int>('A',1));
+// Will insert value 1 for key A
+mymap.insert(pair<char,int>('Z',26));
+// Will insert value 26 for key Z
+
+// To iterate
+map<char,int>::iterator it;
+for (it=mymap.begin(); it!=mymap.end(); ++it)
+    std::cout << it->first << "->" << it->second << '\n';
+// Output:
+// A->1
+// Z->26
+
+// To find the value corresponding to a key
+it = mymap.find('Z');
+cout << it->second;
+
+// Output: 26
+
+
+///////////////////////////////////
+// Logical and Bitwise operators
+//////////////////////////////////
+
+// Most of the operators in C++ are same as in other languages
+
+// Logical operators
+
+// C++ uses Short-circuit evaluation for boolean expressions, i.e, the second argument is executed or
+// evaluated only if the first argument does not suffice to determine the value of the expression
+
+true && false // Performs **logical and** to yield false
+true || false // Performs **logical or** to yield true
+! true        // Performs **logical not** to yield false
+
+// Instead of using symbols equivalent keywords can be used
+true and false // Performs **logical and** to yield false
+true or false  // Performs **logical or** to yield true
+not true       // Performs **logical not** to yield false
+
+// Bitwise operators
+
+// **<<** Left Shift Operator
+// << shifts bits to the left
+4 << 1 // Shifts bits of 4 to left by 1 to give 8
+// x << n can be thought as x * 2^n
+
+
+// **>>** Right Shift Operator
+// >> shifts bits to the right
+4 >> 1 // Shifts bits of 4 to right by 1 to give 2
+// x >> n can be thought as x / 2^n
+
+~4    // Performs a bitwise not
+4 | 3 // Performs bitwise or
+4 & 3 // Performs bitwise and
+4 ^ 3 // Performs bitwise xor
+
+// Equivalent keywords are
+compl 4    // Performs a bitwise not
+4 bitor 3  // Performs bitwise or
+4 bitand 3 // Performs bitwise and
+4 xor 3    // Performs bitwise xor
+
+
 ```
 Further Reading:
 
diff --git a/c.html.markdown b/c.html.markdown
index d92d2ee6..18503eab 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -36,7 +36,6 @@ Multi-line comments don't nest /* Be careful */  // comment ends on this line...
 enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
 // MON gets 2 automatically, TUE gets 3, etc.
 
-
 // Import headers with #include
 #include <stdlib.h>
 #include <stdio.h>
@@ -114,7 +113,6 @@ int main (int argc, char** argv)
   // sizeof(obj) yields the size of the expression (variable, literal, etc.).
   printf("%zu\n", sizeof(int)); // => 4 (on most machines with 4-byte words)
 
-
   // If the argument of the `sizeof` operator is an expression, then its argument
   // is not evaluated (except VLAs (see below)).
   // The value it yields in this case is a compile-time constant.
@@ -130,7 +128,6 @@ int main (int argc, char** argv)
   int my_int_array[20]; // This array occupies 4 * 20 = 80 bytes
   // (assuming 4-byte words)
 
-
   // You can initialize an array to 0 thusly:
   char my_array[20] = {0};
 
@@ -146,9 +143,9 @@ int main (int argc, char** argv)
   // can be declared as well. The size of such an array need not be a compile
   // time constant:
   printf("Enter the array size: "); // ask the user for an array size
-  int size;
-  fscanf(stdin, "%d", &size);
-  int var_length_array[size]; // declare the VLA
+  int array_size;
+  fscanf(stdin, "%d", &array_size);
+  int var_length_array[array_size]; // declare the VLA
   printf("sizeof array = %zu\n", sizeof var_length_array);
 
   // Example:
@@ -205,7 +202,7 @@ int main (int argc, char** argv)
   11 % 3; // => 2
 
   // Comparison operators are probably familiar, but
-  // there is no Boolean type in c. We use ints instead.
+  // there is no Boolean type in C. We use ints instead.
   // (Or _Bool or bool in C99.)
   // 0 is false, anything else is true. (The comparison
   // operators always yield 0 or 1.)
@@ -239,11 +236,9 @@ int main (int argc, char** argv)
   z = (e > f) ? e : f; // => 10 "if e > f return e, else return f."
 
   // Increment and decrement operators:
-  char *s = "ILoveC";
   int j = 0;
-  s[j++]; // => "i". Returns the j-th item of s THEN increments value of j.
-  j = 0;
-  s[++j]; // => "L". Increments value of j THEN returns j-th value of s.
+  int s = j++; // Return j THEN increase j. (s = 0, j = 1)
+  s = ++j; // Increase j THEN return j. (s = 2, j = 2)
   // same with j-- and --j
 
   // Bitwise operators!
@@ -274,7 +269,7 @@ int main (int argc, char** argv)
 
   // While loops exist
   int ii = 0;
-  while (ii < 10) { //ANY value not zero is true.
+  while (ii < 10) { //ANY value less than ten is true.
     printf("%d, ", ii++); // ii++ increments ii AFTER using its current value.
   } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
 
@@ -347,7 +342,6 @@ int main (int argc, char** argv)
   this will print out "Error occured at i = 52 & j = 99."
   */
 
-
   ///////////////////////////////////////
   // Typecasting
   ///////////////////////////////////////
@@ -386,7 +380,6 @@ int main (int argc, char** argv)
   // (%p formats an object pointer of type void *)
   // => Prints some address in memory;
 
-
   // Pointers start with * in their declaration
   int *px, not_a_pointer; // px is a pointer to an int
   px = &x; // Stores the address of x in px
@@ -432,7 +425,6 @@ int main (int argc, char** argv)
   printf("%zu, %zu\n", sizeof arraythethird, sizeof ptr);
   // probably prints "40, 4" or "40, 8"
 
-
   // Pointers are incremented and decremented based on their type
   // (this is called pointer arithmetic)
   printf("%d\n", *(x_ptr + 1)); // => Prints 19
@@ -455,7 +447,8 @@ int main (int argc, char** argv)
   int size = 10;
   int *my_arr = malloc(sizeof(int) * size);
   // Add an element to the array
-  my_arr = realloc(my_arr, ++size);
+  size++;
+  my_arr = realloc(my_arr, sizeof(int) * size);
   my_arr[10] = 5;
 
   // Dereferencing memory that you haven't allocated gives
@@ -518,6 +511,7 @@ void str_reverse(char *str_in)
     str_in[len - ii - 1] = tmp;
   }
 }
+//NOTE: string.h header file needs to be included to use strlen()
 
 /*
 char c[] = "This is a test.";
@@ -578,8 +572,6 @@ void testFunc2() {
 }
 //**You may also declare functions as static to make them private**
 
-
-
 ///////////////////////////////////////
 // User-defined types and structs
 ///////////////////////////////////////
@@ -696,6 +688,7 @@ typedef void (*my_fnp_type)(char *);
 "%o";    // octal
 "%%";    // prints %
 */
+
 ///////////////////////////////////////
 // Order of Evaluation
 ///////////////////////////////////////
@@ -722,14 +715,14 @@ typedef void (*my_fnp_type)(char *);
 
 /******************************* Header Files **********************************
 
-Header files are an important part of c as they allow for the connection of c
-source files and can simplify code and definitions by seperating them into
-seperate files.
+Header files are an important part of C as they allow for the connection of C
+source files and can simplify code and definitions by separating them into
+separate files.
 
-Header files are syntactically similar to c source files but reside in ".h"
-files. They can be included in your c source file by using the precompiler
+Header files are syntactically similar to C source files but reside in ".h"
+files. They can be included in your C source file by using the precompiler
 command #include "example.h", given that example.h exists in the same directory
-as the c file.
+as the C file.
 */
 
 /* A safe guard to prevent the header from being defined too many times. This */
@@ -760,12 +753,12 @@ enum traffic_light_state {GREEN, YELLOW, RED};
 
 /* Function prototypes can also be defined here for use in multiple files,  */
 /* but it is bad practice to define the function in the header. Definitions */
-/* should instead be put in a c file.                                       */
+/* should instead be put in a C file.                                       */
 Node createLinkedList(int *vals, int len);
 
-/* Beyond the above elements, other definitions should be left to a c source */
-/* file. Excessive includeds or definitions should, also not be contained in */
-/* a header file but instead put into separate headers or a c file.          */
+/* Beyond the above elements, other definitions should be left to a C source */
+/* file. Excessive includes or definitions should, also not be contained in */
+/* a header file but instead put into separate headers or a C file.          */
 
 #endif /* End of the if precompiler directive. */
 
@@ -782,8 +775,8 @@ If you have a question, read the [compl.lang.c Frequently Asked Questions](http:
 
 It's very important to use proper spacing, indentation and to be consistent with your coding style in general.
 Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the
-[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
+[Linux kernel coding style](https://www.kernel.org/doc/Documentation/process/coding-style.rst).
 
 Other than that, Google is your friend.
 
-[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
+[1] [Why isn't sizeof for a struct equal to the sum of sizeof of each member?](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member)
diff --git a/ca-es/go-ca.html.markdown b/ca-es/go-ca.html.markdown
new file mode 100644
index 00000000..99f0d393
--- /dev/null
+++ b/ca-es/go-ca.html.markdown
@@ -0,0 +1,464 @@
+---
+name: Go
+category: language
+language: Go
+lang: ca-es
+filename: learngo-ca.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"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
+    - ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"]
+translators:
+    - ["Xavier Sala", "http://github.com/utrescu"]
+---
+
+Go es va crear degut a la necessitat de fer la feina ràpidament. No segueix
+la darrera tendència en informàtica, però és la nova forma i la més ràpida de
+resoldre problemes reals.
+
+Té conceptes familiars de llenguatges imperatius amb tipat estàtic. És ràpid
+compilant i ràpid al executar, afegeix una forma fàcil d'entedre de
+concurrència per CPUs de diferents núclis i té característiques que ajuden en
+la programació a gran escala.
+
+Go té una gran llibreria de funcions estàndard i una comunitat d'usuaris
+entusiasta.
+
+```go
+// Comentari d'una sola línia
+/* Comentari
+multilínia */
+
+// La clausula `package` apareix sempre a sobre de cada fitxer de codi font.
+// Quan es desenvolupa un executable en comptes d'una llibreria el nom que
+// s'ha de fer servir de `package` ha de ser 'main'.
+package main
+
+// `import` es fa servir per indicar quins paquets de llibreries fa servir
+// aquest fitxer.
+import (
+	"fmt"       // Un paquet de la llibreria estàndard de Go.
+	"io/ioutil" // Les funcions ioutil de io
+	m "math"    // La llibreria de matemàtiques que es referenciarà com a m.
+	"net/http"  // Si, un servidor web!
+	"os"        // funcions per treballar amb el sistema de fitxers
+	"strconv"   // Conversions de cadenes
+)
+
+// La definició d'una funció. `main` és especial. És el punt d'entrada per
+// l'executable. Tant si t'agrada com si no, Go fa servir corxets.
+func main() {
+	// Println imprimeix una línia al canal de sortida.
+	// Es qualifica amb el nom del paquet, fmt.
+	fmt.Println("Hola món!")
+
+	// Crida a una altra funció dins d'aquest paquet.
+	mesEnllaDeHola()
+}
+
+// Els paràmetres de les funcions es posen dins de parèntesis.
+// Els parèntesis fan falta encara que no hi hagi cap paràmetre.
+func mesEnllaDeHola() {
+	var x int // Declaració d'una variable.
+	          // S'han de declarar abans de fer-les servir.
+	x = 3     // Assignació d'una variable
+	// Hi ha una forma "Curta" amb :=
+	// Descobreix el tipus, declara la variable i li assigna valor.
+	y := 4
+	sum, prod := learnMultiple(x, y)        // La funció retorna dos valors.
+	fmt.Println("sum:", sum, "prod:", prod) // Sortida simple.
+	aprenTipus()                            // < y minuts, aprèn més!
+}
+
+/* <- comentari multilínia
+Les funcions poden tenir paràmetres i (multiples!) valors de retorn.
+Aquí `x`, `y` són els argumens i `sum` i `prod` són els valors retornats.
+Fixa't que `x` i `sum` reben el tipus `int`.
+*/
+func learnMultiple(x, y int) (sum, prod int) {
+	return x + y, x * y // Retorna dos valors.
+}
+
+// Alguns tipus incorporats i literals.
+func aprenTipus() {
+	// Normalment la declaració curta et dóna el que vols.
+	str := "Learn Go!" // tipus string
+
+	s2 := `Un tipus cadena "normal" pot tenir
+salts de línia.` // El mateix tipus
+
+	// literals Non-ASCII literal. El tipus de Go és UTF-8.
+	g := 'Σ' // El tipus rune, és un àlies de int32 conté un caràcter unicode.
+
+	f := 3.14195 // float64, un número de 64 bits amb coma flotant IEEE-754.
+	c := 3 + 4i  // complex128, representat internament amb dos float64.
+
+	// Sintaxi amb var i inicialitzadors.
+	var u uint = 7 // Sense signe, però depèn de la mida com els int.
+	var pi float32 = 22. / 7
+
+	// Conversió de tipus amb declaració curta.
+	n := byte('\n') // byte és un àlies de uint8.
+
+	// Les taules tenen mida fixa en temps de compilació.
+	var a4 [4]int           // Taula de 4 enters inicialitzats a zero.
+	a3 := [...]int{3, 1, 5} // Taula inicialitzada amb tres elements
+	// amb els valors 3, 1, i 5.
+
+	// Els "Slices" tenen mida dinàmica. Tant les taules com els "slices"
+	// tenen avantatges però és més habitual que es facin servir slices.
+	s3 := []int{4, 5, 9}    // Compara amb a3. Aquí no hi ha els tres punts
+	s4 := make([]int, 4)    // Crea un slice de 4 enters inicialitzats a zero.
+	var d2 [][]float64      // Només es declara però no hi ha valors.
+	bs := []byte("a slice") // Sintaxi de conversió de tipus.
+
+	// Com que són dinàmics es poden afegir valors nous als slices.
+	// Per afegir-hi elements es fa servir el mètode append().
+	// El primer argument és l'slice en el que s'afegeix.
+	// Sovint ell mateix com aquí sota.
+	s := []int{1, 2, 3}		// Un slice amb tres elements.
+	s = append(s, 4, 5, 6)	// Ara s tindrà tres elements més
+	fmt.Println(s) // El resultat serà [1 2 3 4 5 6]
+
+	// Per afegir un slice dins d'un altre en comptes de valors atòmics
+	// S'hi pot passar una referència a l'altre slice o un literal acabat
+	// amb tres punts, que vol dir que s'ha de desempaquetar els elements
+	// i afegir-los a "s"
+	s = append(s, []int{7, 8, 9}...) // El segon argument és un slice
+	fmt.Println(s)	// El resultat ara és [1 2 3 4 5 6 7 8 9]
+
+	p, q := aprenMemoria() // Declara p i q com a punters de int.
+	fmt.Println(*p, *q)   // * segueix el punter fins a trobar els valors
+
+	// Els "Mapes" són taules dinàmiques associatives com els hash o els
+	// diccionaris d'altres llenguatges.
+	m := map[string]int{"tres": 3, "quatre": 4}
+	m["un"] = 1
+
+	// En Go les variables que no es fan servir generen un error.
+	// El subratllat permet fer servir una variable i descartar-ne el valor.
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+	// És útil per descartar algun dels valors retornats per una funció
+	// Per exemple, es pot ignorar l'error retornat per os.Create amb la idea
+	// de que sempre es crearà.
+	file, _ := os.Create("output.txt")
+	fmt.Fprint(file, "Així es pot escriure en un fitxer")
+	file.Close()
+
+	// La sortida compta com a ús d'una variable.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	aprenControlDeFluxe() // Tornem.
+}
+
+// A diferència d'altres llenguatges les funcions poden retornar valors amb
+// nom. Assignant un nom al valor retornat en la declaració de la funció
+// permet retornar valors des de diferents llocs del programa a més de posar
+// el return sense valors
+func aprenRetornAmbNoms(x, y int) (z int) {
+	z = x * y
+	return // el retorn de z és implícit perquè ja té valor
+}
+
+// Go té un recollidor de basura.
+// Té punters però no té aritmetica de punters
+// Es poden cometre errors amb un punter a nil però no incrementant-lo.
+func aprenMemoria() (p, q *int) {
+	// Els valors retornats p i q són punters a un enter.
+	p = new(int) // Funció per reservar memòria
+	// A la memòria ja hi ha un 0 per defecte, no és nil.
+	s := make([]int, 20) // Reserva un bloc de memòria de 20 enters.
+	s[3] = 7             // Assigna un valor a un d'ells.
+	r := -2              // Declare una altra variable local.
+	return &s[3], &r     // & agafa l'adreça d'un objecte.
+}
+
+func expensiveComputation() float64 {
+	return m.Exp(10)
+}
+
+func aprenControlDeFluxe() {
+	// Els "If" necessiten corxets però no parèntesis.
+	if true {
+		fmt.Println("ja ho hem vist")
+	}
+	// El format del codi està estandaritzat amb la comanda "go fmt."
+	if false {
+		// Pout.
+	} else {
+		// Gloat.
+	}
+	// Si cal encadenar ifs és millor fer servir switch.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// Els case no "passen a través" no cal "break" per separar-los.
+		/*
+		Per fer-ho hi ha una comanda `fallthrough`, mireu:
+		  https://github.com/golang/go/wiki/Switch#fall-through
+		*/
+	case 43:
+		// No hi arriba.
+	default:
+		// La opció "default" és opcional
+	}
+	// El 'for' tampoc necessita parèntesis, com el 'if'.
+	// Les variables dins d'un bloc if o for són local del bloc.
+	for x := 0; x < 3; x++ { // ++ is a statement.
+		fmt.Println("iteració", x)
+	}
+	// x == 42.
+
+	// L'única forma de fer bucles en Go és el 'for' però té moltes variants.
+	for { // bucle infinit.
+		break    // És una broma!.
+		continue // No hi arriba mai.
+	}
+
+	// Es fa servir "range" per iterar a una taula, un slice, un mapa
+	// o un canal.
+	// range torna un valor (channel) o dos (array, slice, string o map).
+	for key, value := range map[string]int{"un": 1, "dos": 2, "tres": 3} {
+		// Per cada parell del mapa imprimeix la clau i el valor.
+		fmt.Printf("clau=%s, valor=%d\n", key, value)
+	}
+	// Si només cal el valor es pot fer servir _
+	for _, name := range []string{"Robert", "Bill", "Josep"} {
+		fmt.Printf("Hola, %s\n", name)
+	}
+
+	// Es pot usar := per declarar i assignar valors i després
+	// comprovar-lo y > x.
+	if y := expensiveComputation(); y > x {
+		x = y
+	}
+	// Les funcions literals són closures
+	xBig := func() bool {
+		return x > 10000 // Referencia a x declarada sobre el switch.
+	}
+	x = 99999
+	fmt.Println("xBig:", xBig()) // cert
+	x = 1.3e3                    //  x val 1300
+	fmt.Println("xBig:", xBig()) // fals.
+
+	// A més les funcions poden ser definides i cridades com a arguments per
+	// una funció sempre que:
+	// a) La funció es cridi inmediatament (),
+	// b) El tipus del resultat sigui del tipus esperat de l'argument.
+	fmt.Println("Suma i duplica dos números: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Es crida amb els arguments 10 i 2
+	// => Suma i duplica dos números: 24
+
+	// Quan el necessitis t'agradarà que hi sigui
+	goto love
+love:
+
+	aprenFabricaDeFuncions() // func que retorna func és divertit(3)(3)
+	aprenDefer()      // Revisió ràpida d'una paraula clau.
+	aprendreInterficies() // Bon material properament!
+}
+
+func aprenFabricaDeFuncions() {
+	// Les dues seguents són equivalents, però la segona és més pràctica
+	fmt.Println(sentenceFactory("dia")("Un bonic", "d'estiu!"))
+
+	d := sentenceFactory("dia")
+	fmt.Println(d("Un bonic", "d'estiu!"))
+	fmt.Println(d("Un tranquil", "de primavera!"))
+}
+
+// Els decoradors són habituals en altres llenguatges.
+// Es pot fer el mateix en Go amb funcions literals que accepten 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) // nou string
+	}
+}
+
+func aprenDefer() (ok bool) {
+	// Les comandes marcades amb defer s'executen després de que la funció
+	// hagi acabat.
+	defer fmt.Println("Les comandes defer s'executen en ordre invers (LIFO).")
+	defer fmt.Println("\nAquesta és la primera línia que s'imprimeix")
+	// Defer es fa servir gairebé sempre per tancar un fitxer, en el moment
+	// en que acaba el mètode.
+	return true
+}
+
+// Defineix Stringer com un tipus interfície amb el mètode String().
+type Stringer interface {
+	String() string
+}
+
+// Defineix una estrutura que conté un parell d'enters, x i y.
+type parell struct {
+	x, y int
+}
+
+// Defineix un mètode de l'estructura parell. Ara parell implementa Stringer.
+func (p parell) String() string { // p és anomenat el "receptor"
+	// Sprintf és una funció del paquet fmt.
+	// Fa referència als camps de p.
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func aprendreInterficies() {
+	// La sintaxi de claus es pot fer servir per inicialitzar un "struct".
+	// Gràcies a := defineix i inicialitza p com un struct 'parell'.
+	p := parell{3, 4}
+	fmt.Println(p.String()) // Es crida al mètode de p.
+	var i Stringer          // Declara i de tipus Stringer.
+	i = p                   // parell implementa Stringer per tant és vàlid.
+	// Es pot cridar el mètode String() igual que abans.
+	fmt.Println(i.String())
+
+	// Les funcions de fmt criden a String() per aconseguir una representació
+	// imprimible d'un objecte.
+	fmt.Println(p) // Treu el mateix d'abans. Println crida el mètode String.
+	fmt.Println(i) // Idèntic resultat
+
+	aprendreParamentesVariables("Aquí", "estem", "aprenent!")
+}
+
+// Les funcions poden tenir paràmetres variables.
+func aprendreParamentesVariables(myStrings ...interface{}) {
+	// Itera per cada un dels valors dels paràmetres
+	// Ignorant l'índex de la seva posició
+	for _, param := range myStrings {
+		fmt.Println("paràmetre:", param)
+	}
+
+	// Passa el valor de múltipes variables com a paràmetre.
+	fmt.Println("parametres:", fmt.Sprintln(myStrings...))
+
+	aprenControlErrors()
+}
+
+func aprenControlErrors() {
+	// ", ok" Es fa servir per saber si hi és o no.
+	m := map[int]string{3: "tres", 4: "quatre"}
+	if x, ok := m[1]; !ok { // ok serà fals perquè 1 no està en el mapa.
+		fmt.Println("no hi és")
+	} else {
+		fmt.Print(x) // x seria el valor, si no estés en el mapa.
+	}
+	// Un valor d'error donarà més informació sobre l'error.
+	if _, err := strconv.Atoi("no-int"); err != nil { // _ descarta el valor
+		// imprimeix 'strconv.ParseInt: intenta convertir "non-int":
+		// syntaxi invalida'
+		fmt.Println(err)
+	}
+	// Es tornarà a les interfícies més tard. Mentrestant,
+	aprenConcurrencia()
+}
+
+// c és un canal (channel), una forma segura de comunicar objectes.
+func inc(i int, c chan int) {
+	c <- i + 1 // <- és l'operador "envia" quan un canal està a l'esquerra.
+}
+
+// Es pot fer servir inc per incrementar un número de forma concurrent.
+func aprenConcurrencia() {
+	// La funció make es pot fer servir per crear slices, mapes i canals.
+	c := make(chan int)
+	// S'inicien tres goroutines.
+	// Els números s'incrementaran de forma concurrent, En paral·lel
+	// si la màquina on s'executa pot fer-ho i està correctament configurada.
+	// Tots tres envien al mateix canal.
+	go inc(0, c) // go és la comanda que inicia una nova goroutine.
+	go inc(10, c)
+	go inc(-805, c)
+	// Llegeix tres resultats del canal i els imprimeix.
+	// No es pot saber en quin ordre arribaran els resultats!
+	fmt.Println(<-c, <-c, <-c) // Canal a la dreta <- és l'operador "rebre"
+
+	cs := make(chan string)       // Un altre canal que processa strings.
+	ccs := make(chan chan string) // Un canal de canals string.
+	go func() { c <- 84 }()       // Inicia una goroutine i li envia un valor.
+	go func() { cs <- "paraula" }() // El mateix però amb cs.
+	// Select té una sintaxi semblant a switch però amb canals.
+	// Selecciona un cas aleatòriament dels que poden comunicar-se.
+	select {
+	case i := <-c: // El valor rebit pot ser assignat a una variable,
+		fmt.Printf("és un %T", i)
+	case <-cs: // O es pot descartar
+		fmt.Println("és un string")
+	case <-ccs: // Canal buit, no preparat per la comunicació.
+		fmt.Println("no ha passat.")
+	}
+	// Quan arribi aquí s'haurà agafat un valor de c o bé de cs. Una de les
+	// goroutines iniciades haurà acabat i l'altra romandrà bloquejada.
+
+	aprenProgramacioWeb() // Go ho fa. Tu vols fer-ho.
+}
+
+// Una funció del paquet http inicia un servidor web.
+func aprenProgramacioWeb() {
+
+	// El primer paràmetre de ListenAndServe és l'adreça on escoltar
+	// i el segon és una interfície http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", pair{})
+		fmt.Println(err) // no s'han d'ignorar els errors
+	}()
+
+	requestServer()
+}
+
+// Es converteix "parell" en un http.Handler només implementant el
+// mètode ServeHTTP.
+func (p parell) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Serveix dades en el http.ResponseWriter.
+	w.Write([]byte("Has après Go en Y minuts!"))
+}
+
+func requestServer() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nEl servidor diu: `%s`", string(body))
+}
+```
+
+## Més informació
+
+L'arrel de tot en Go és la web oficial [official Go web site]
+(http://golang.org/). Allà es pot seguir el tutorial, jugar interactivament
+i llegir molt més del que hem vist aquí.En el "tour",
+[the docs](https://golang.org/doc/) conté informació sobre com escriure codi
+net i efectiu en Go, comandes per empaquetar i generar documentació, i
+història de les versions.
+
+És altament recomanable llegir La definició del llenguatge. És fàcil de llegir
+i sorprenentment curta (com la definició del llenguatge en aquests dies).
+
+Es pot jugar amb codi a [Go playground](https://play.golang.org/p/tnWMjr16Mm).
+Prova de fer canvis en el codi i executar-lo des del navegador! Es pot fer
+servir [https://play.golang.org](https://play.golang.org) com a [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) per provar coses i codi
+en el navegador sense haver d'instal·lar Go.
+
+En la llista de lectures pels estudiants de Go hi ha
+[el codi font de la llibreria estàndard](http://golang.org/src/pkg/).
+Ampliament comentada, que demostra el fàcil que és de llegir i entendre els
+programes en Go, l'estil de programació, i les formes de treballar-hi. O es
+pot clicar en un nom de funció en [la documentació](http://golang.org/pkg/)
+i veure'n el codi!
+
+Un altre gran recurs per aprendre Go és
+[Go by example](https://gobyexample.com/).
+
+Go Mobile afegeix suport per plataformes mòbils (Android i iOS). Es poden
+escriure aplicacions mòbils o escriure llibreries de paquets de Go, que es
+poden cridar des de Java (android) i Objective-C (iOS).
+Comproveu la [Go Mobile page](https://github.com/golang/go/wiki/Mobile) per
+més informació.
diff --git a/ca-es/groovy-ca.html.markdown b/ca-es/groovy-ca.html.markdown
new file mode 100644
index 00000000..57674970
--- /dev/null
+++ b/ca-es/groovy-ca.html.markdown
@@ -0,0 +1,437 @@
+---
+name: Groovy
+category: language
+language: Groovy
+lang: ca-es
+filename: learngroovy-ca.groovy
+contributors:
+    - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
+translations:
+    - ["Xavier Sala Pujolar", "http://github.com/utrescu"]
+---
+
+Groovy - Un llenguatge dinàmic per la plataforma Java [Llegir-ne més.](http://www.groovy-lang.org/)
+
+```groovy
+
+/*
+  Posa'l en marxa tu mateix:
+
+  1) Instal.la SDKMAN - http://sdkman.io/
+  2) Instal.la Groovy: sdk install groovy
+  3) Inicia la consola groovy escrivint: groovyConsole
+
+*/
+
+//  Els comentaris d'una sola línia comencen amb dues barres inverses
+/*
+Els comentaris multilínia són com aquest.
+*/
+
+// Hola món
+println "Hola món!"
+
+/*
+  Variables:
+
+  Es poden assignar valors a les variables per fer-los servir més tard
+*/
+
+def x = 1
+println x
+
+x = new java.util.Date()
+println x
+
+x = -3.1499392
+println x
+
+x = false
+println x
+
+x = "Groovy!"
+println x
+
+/*
+  Col.leccions i mapes
+*/
+
+// Crear una llista buida
+def technologies = []
+
+/*** Afegir elements a la llista ***/
+
+// Com en Java
+technologies.add("Grails")
+
+// El shift a l'esquerra afegeix i retorna la llista
+technologies << "Groovy"
+
+// Afegir múltiples elements
+technologies.addAll(["Gradle","Griffon"])
+
+/*** Eliminar elements de la llista ***/
+
+// Com en Java
+technologies.remove("Griffon")
+
+// La resta també funciona
+technologies = technologies - 'Grails'
+
+/*** Iterar per les llistes ***/
+
+// Iterar per tots els elements de la llista
+technologies.each { println "Technology: $it"}
+technologies.eachWithIndex { it, i -> println "$i: $it"}
+
+/*** Comprovar el contingut de la llista ***/
+
+//Comprovar si la llista conté un o més elements (resultat boolea)
+contained = technologies.contains( 'Groovy' )
+
+// O
+contained = 'Groovy' in technologies
+
+// Comprovar diversos elements
+technologies.containsAll(['Groovy','Grails'])
+
+/*** Ordenar llistes ***/
+
+// Ordenar una llista (canvia la original)
+technologies.sort()
+
+// Per ordenar sense canviar la original es pot fer:
+sortedTechnologies = technologies.sort( false )
+
+/*** Manipular llistes ***/
+
+//Canvia tots els elements de la llista
+Collections.replaceAll(technologies, 'Gradle', 'gradle')
+
+// Desordena la llista
+Collections.shuffle(technologies, new Random())
+
+// Buida la llista
+technologies.clear()
+
+// Crear un mapa buit
+def devMap = [:]
+
+// Afegir valors al mapa
+devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+devMap.put('lastName','Perez')
+
+// Iterar per tots els elements del mapa
+devMap.each { println "$it.key: $it.value" }
+devMap.eachWithIndex { it, i -> println "$i: $it"}
+
+// Comprovar si la clau hi és
+assert devMap.containsKey('name')
+
+// Comprova si el mapa conté un valor concret
+assert devMap.containsValue('Roberto')
+
+// Obtenir les claus del mapa
+println devMap.keySet()
+
+// Obtenir els valors del mapa
+println devMap.values()
+
+/*
+  Groovy Beans
+
+  Els GroovyBeans són JavaBeans però amb una sintaxi molt més senzilla
+
+  Quan Groovy es compila a bytecode es fan servir les regles següents.
+
+    * Si el nom és declarat amb un modificador (public, private o protected)
+      es genera el camp
+
+    * Un nom declarat sense modificadors genera un camp privat amb un getter
+      i un setter públics (per exemple una propietat)
+
+    * Si la propietat és declarada final el camp privat es crea i no es
+      genera cap setter.
+
+    * Es pot declarar una propietat i també declarar un getter i un setter.
+
+    * Es pot declarar una propietat i un camp amb el mateix nom, la propietat
+      farà servir el camp.
+
+    * Si es vol una propietat private o protected s'ha de definir el getter i
+      el setter que s'han de declarar private o protected.
+
+    * Si s'accedeix a una propietat de la classe que està definida en temps
+      de compilació amb un this implícit o explícit (per exemple this.foo, o
+      bé només foo), Groovy accedirà al camp directament en comptes de fer-ho
+      a través del getter i el setter.
+
+    * Si s'accedeix a una propietat que no existeix tant implícita com
+      explicitament, llavors Groovy accedirà a la propietat a través de la
+      meta classe, que pot fer que falli en temps d'execució.
+
+*/
+
+class Foo {
+    // Propietat només de lectura
+    final String name = "Roberto"
+
+    // Propietat de només lectura amb getter públic i un setter protected
+    String language
+    protected void setLanguage(String language) { this.language = language }
+
+    // Propietat amb el tipus definit dinàmicament
+    def lastName
+}
+
+/*
+  Bucles i estructres de control
+*/
+
+//Groovy té el format tradicional de if -else
+def x = 3
+
+if(x==1) {
+    println "One"
+} else if(x==2) {
+    println "Two"
+} else {
+    println "X greater than Two"
+}
+
+// Groovy també té l'operador ternari
+def y = 10
+def x = (y > 1) ? "worked" : "failed"
+assert x == "worked"
+
+//I també té 'l'Operador Elvis'!
+//En comptes de fer servir l'operador ternari:
+displayName = user.name ? user.name : 'Anonymous'
+
+// Es pot escriure d'aquesta forma:
+displayName = user.name ?: 'Anonymous'
+
+//Bucle for
+//Itera en un rang
+def x = 0
+for (i in 0 .. 30) {
+    x += i
+}
+
+//Itera per una llista
+x = 0
+for( i in [5,3,2,1] ) {
+    x += i
+}
+
+//Itera per un array
+array = (0..20).toArray()
+x = 0
+for (i in array) {
+    x += i
+}
+
+//Itera per un mapa
+def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+x = 0
+for ( e in map ) {
+    x += e.value
+}
+
+/*
+  Operadors
+
+  Hi ha una llista d'operadors que poden ser sobreescrits en Groovy:
+  http://www.groovy-lang.org/operators.html#Operator-Overloading
+
+  Operadors útils de Groovy
+*/
+//Spread operator:  Invoca una acció en tots els ítems d'un grup d'objectes.
+def technologies = ['Groovy','Grails','Gradle']
+technologies*.toUpperCase() // = a technologies.collect { it?.toUpperCase() }
+
+//Safe navigation operator: fet servir per evitar el NullPointerException.
+def user = User.get(1)
+def username = user?.username
+
+
+/*
+  Closures
+  Un Closure és com un "bloc de codi" o un punter a un mètode. És un troç de
+  codi que està definit i que s podrà executar més tard.
+
+  Més informació a: http://www.groovy-lang.org/closures.html
+*/
+//Exemple:
+def clos = { println "Hola món!" }
+
+println "Executant el Closure:"
+clos()
+
+// Passar paràmetres a un Closure
+def sum = { a, b -> println a+b }
+sum(2,4)
+
+//Els Closures poden fer referència a variables que no formen part de la
+// llista dels seus paràmetres.
+def x = 5
+def multiplyBy = { num -> num * x }
+println multiplyBy(10)
+
+// Si es té un Closure que agafa un element com a argument, se'n pot ignorar
+// la definició
+def clos = { print it }
+clos( "hi" )
+
+/*
+  Groovy pot recordar els resultats dels Closures [1][2][3]
+*/
+def cl = {a, b ->
+    sleep(3000) // simula un procés llarg
+    a + b
+}
+
+mem = cl.memoize()
+
+def callClosure(a, b) {
+    def start = System.currentTimeMillis()
+    mem(a, b)
+    println "(a = $a, b = $b) - en ${System.currentTimeMillis() - start} ms"
+}
+
+callClosure(1, 2)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(2, 3)
+callClosure(3, 4)
+callClosure(3, 4)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(3, 4)
+
+/*
+  Expando
+
+  La classe Expando és un bean dinàmic al que se li poden afegir propietats i
+  closures com a mètodes d'una instància d'aquesta classe.
+
+http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+*/
+  def user = new Expando(name:"Roberto")
+  assert 'Roberto' == user.name
+
+  user.lastName = 'Pérez'
+  assert 'Pérez' == user.lastName
+
+  user.showInfo = { out ->
+      out << "Name: $name"
+      out << ", Last name: $lastName"
+  }
+
+  def sw = new StringWriter()
+  println user.showInfo(sw)
+
+
+/*
+  Metaprogrammació (MOP)
+*/
+
+// Fent servir ExpandoMetaClass per afegir comportament
+String.metaClass.testAdd = {
+    println "he afegit això"
+}
+
+String x = "test"
+x?.testAdd()
+
+//Intercepting method calls
+class Test implements GroovyInterceptable {
+    def sum(Integer x, Integer y) { x + y }
+
+    def invokeMethod(String name, args) {
+        System.out.println "Invoca el mètode $name amb arguments: $args"
+    }
+}
+
+def test = new Test()
+test?.sum(2,3)
+test?.multiply(2,3)
+
+//Groovy supporta propertyMissing per gestionar la resolució de propietats
+class Foo {
+   def propertyMissing(String name) { name }
+}
+def f = new Foo()
+
+assertEquals "boo", f.boo
+
+/*
+  TypeChecked i CompileStatic
+  Groovy, by nature, és i sempre serà un llenguatge dinàmic però també té
+  comprovació de tipus i definicions estàtiques
+
+  More info: http://www.infoq.com/articles/new-groovy-20
+*/
+//TypeChecked
+import groovy.transform.TypeChecked
+
+void testMethod() {}
+
+@TypeChecked
+void test() {
+    testMeethod()
+
+    def name = "Roberto"
+
+    println naameee
+
+}
+
+//Un altre exemple:
+import groovy.transform.TypeChecked
+
+@TypeChecked
+Integer test() {
+    Integer num = "1"
+
+    Integer[] numbers = [1,2,3,4]
+
+    Date date = numbers[1]
+
+    return "Test"
+
+}
+
+//exemple de CompileStatic
+import groovy.transform.CompileStatic
+
+@CompileStatic
+int sum(int x, int y) {
+    x + y
+}
+
+assert sum(2,5) == 7
+
+
+```
+
+## Per aprendre'n més
+
+[documentació de Groovy](http://www.groovy-lang.org/documentation.html)
+
+[Cònsola de Groovy](http://groovyconsole.appspot.com/)
+
+Uneix-te a un [grup d'usuaris Groovy]
+(http://www.groovy-lang.org/usergroups.html)
+
+## Llibres
+
+* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook)
+
+* [Groovy in Action] (http://manning.com/koenig2/)
+
+* [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
diff --git a/ca-es/kotlin-ca.html.markdown b/ca-es/kotlin-ca.html.markdown
new file mode 100644
index 00000000..cd05a808
--- /dev/null
+++ b/ca-es/kotlin-ca.html.markdown
@@ -0,0 +1,389 @@
+---
+language: kotlin
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators:
+    - ["Xavier Sala", "https://github.com/utrescu"] 
+lang: ca-es
+filename: LearnKotlin-ca.kt
+---
+
+Kotlin és un llenguatge estàtic tipat per la JVM, Android i el navegador.
+És interoperable al 100% amb Java.
+[Llegir-ne més aquí.](https://kotlinlang.org/)
+
+```kotlin
+// Els comentaris d'una línia comencen amb //
+/*
+Els comentaris multilínia són com aquest
+*/
+
+// La paraula clau "package" funciona de la mateixa forma que en Java
+
+package com.learnxinyminutes.kotlin
+
+/*
+El punt d'entrada dels programes en Kotlin és una funció anomenada "main".
+La funció rep un array que té els arguments fets servir al executar-lo.
+*/
+fun main(args: Array<String>) {
+    /*
+    La declaració de variables es pot fer tant amb "var" com amb "val".
+    A les declarades amb "val" no se'ls hi pot canviar el valor
+    en canvi a les declarades amb "var" si.
+    */
+    val fooVal = 10 // no es podrà canviar el valor de fooVal
+    var fooVar = 10
+    fooVar = 20 // fooVar si que es pot canviar
+
+    /*
+    Gairebé sempre, Kotlin pot determinar el tipus d'una variable,
+    de manera que no caldrà definir-lo cada vegada.
+    Però es pot definir el tipus d'una variable explícitament d'aquesta forma:
+    */
+    val foo: Int = 7
+
+    /*
+    Els "strings" es poden representar igual que com es fa en Java.
+    Es poden escapar caràcters amb la barra inversa.
+    */
+    val fooString = "Aquí està la meva cadena!"
+    val barString = "Imprimir en dues línies?\nCap problema!"
+    val bazString = "Es poden posar tabuladors?\tI tant!"
+    println(fooString)
+    println(barString)
+    println(bazString)
+
+    /*
+    Es poden definir strings literals envoltant-los amb les triples cometes 
+    (""").
+    Dins hi poden haver tant salts de línies com d'altres caràcters.
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Hola món!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    Els strings poden contenir expressions de plantilla.
+    Les expressions de plantilla comencen amb el símbol ($).
+    */
+    val fooTemplateString = "$fooString té ${fooString.length} caràcters"
+    println(fooTemplateString)
+
+    /*
+    Perquè una variable pugui contenir null ha de ser declarada específicament
+    com a nullable afengint-li ? al seu tipus.
+    Es pot accedir a una variable nulable fent servir l'operador ?.
+    L'operador ?: permet especificar un valor alternatiu en cas de que la
+    variable sigui null.
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    Les funcions es declaren amb la paraula "fun".
+    Els arguments s'especifiquen entre corxets després del nom de la funció.
+    Els arguments poden tenir un valor per defecte.
+    El retorn de les funcions, si cal, es posa després de l'argument.
+    */
+    fun hello(name: String = "món"): String {
+        return "Hola, $name!"
+    }
+    println(hello("foo")) // => Hola, foo!
+    println(hello(name = "bar")) // => Hola, bar!
+    println(hello()) // => Hola, món!
+
+    /*
+    Un dels paràmetres d'una funció pot ser marcat amb la paraula clau
+    "vararg" que permet que una funció accepti un número variable
+    d'arguments.
+    */
+    fun varargExample(vararg names: Int) {
+        println("S'han rebut ${names.size} arguments")
+    }
+    varargExample() // => S'han rebut 0 elements
+    varargExample(1) // => S'ha rebut 1 element
+    varargExample(1, 2, 3) // => S'han rebut 3 elements
+
+    /*
+    Quan una funció consisteix en una sola expressió no calen els corxets
+    El cos de la funció es posa rere el símbol =.
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // Si el tipus retornat es pot determinar no cal especificar-lo.
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // Les funcions poden tenir altres funcions com arguments i
+    // fins i tot retornar-ne.
+    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // Les funcions amb nom es poden especificar quan fan d'arguments amb ::
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // Les expressions lambda es poden posar com arguments.
+    val notZero = not {n -> n == 0}
+    /*
+    Si la lambda només té un paràmetre es pot ometre la seva declaració.
+    El seu valor serà "it".
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // Les classes es defineixen amb "class".
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int): Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    Per crear una nova instància es crida al constructor.
+    Tingueu en compte que Kotlin no té l'operador "new".
+    */
+    val fooExampleClass = ExampleClass(7)
+    // Els mètodes es poden cridar amb la notació .
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    Si una funció ha estat marcada amb "infix" es pot cridar amb la
+    notació infix.
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    Les classes "data" són classes que només contenen dades.
+    Es creen automàticament els mètodes "hashCode","equals" i "toString"
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // Les classes data tenen un mètode "copy".
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // Els objectes es poden desestructurar amb múltiples variables
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+
+    // desestructurat en un bucle "for"
+    for ((a, b, c) in listOf(fooData)) {
+        println("$a $b $c") // => 1 100 4
+    }
+
+    val mapData = mapOf("a" to 1, "b" to 2)
+    // Els mapes també
+    for ((key, value) in mapData) {
+        println("$key -> $value")
+    }
+
+    // La funció "with" és similar a la de JavaScript.
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    Es pot crear una llista amb la funció "listOf".
+    La llista serà immutable - no s'hi poden afegir o treure elements.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // Es pot accedir als elements a partir del seu índex.
+    println(fooList[1]) // => b
+
+    // Es poden crear llistes mutables amb la funció "mutableListOf".
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // Es poden crear conjunts amb la funció "setOf".
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // Es poden crear mapes amb la funció "mapOf".
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // S'accedeix als valors del mapa a partir del seu índex.
+    println(fooMap["a"]) // => 8
+
+    /*
+    Les sequències representen col·leccions evaluades quan fan falta.
+    Podem crear una seqüencia amb la funció "generateSequence".
+    */
+    val fooSequence = generateSequence(1, { it + 1 })
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // Per exemple amb aquesta seqüència es creen els números de Fibonacci:
+    fun fibonacciSequence(): Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next(): Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin proporciona funcions de primer ordre per treballar amb
+    // col·leccions.
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "parell" else "senar"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // Es pot fer servir el bucle "for" amb qualsevol cosa que proporcioni
+    // un iterador.
+    for (c in "hello") {
+        println(c)
+    }
+
+    // els bucles "while" funcionen com en altres llenguatges.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    "if" es pot fer servir com una expressió que retorna un valor.
+    Per això no cal l'operador ternari ?: en Kotlin.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "parell" else "senar"
+    println("$num is $message") // => 5 is odd
+
+    // "when" es pot fer servir com alternativa a les cadenes "if-else if".
+    val i = 10
+    when {
+        i < 7 -> println("primer bloc")
+        fooString.startsWith("hola") -> println("segon bloc")
+        else -> println("bloc else")
+    }
+
+    // "when" es pot fer servir amb un argument.
+    when (i) {
+        0, 21 -> println("0 o 21")
+        in 1..20 -> println("en el rang 1 a 20")
+        else -> println("cap dels anteriors")
+    }
+
+    // "when" es pot fer servir com una funció que retorna valors.
+    var result = when (i) {
+        0, 21 -> "0 o 21"
+        in 1..20 -> "en el rang 1 a 20"
+        else -> "cap dels anteriors"
+    }
+    println(result)
+
+    /*
+    Es pot comprovar el tipus d'un objecte fent servir l'operador "is".
+    Si un objecte passa una comprovació es pot fer servir sense posar-hi
+    cap casting.
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x es converteix automàticament a Booleà
+            return x
+        } else if (x is Int) {
+            // x es converteix automàticament a int
+            return x > 0
+        } else if (x is String) {
+            // x es converteix a string automàticament
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hola món!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    // També es pot cridar smarcast en un bloc when
+    fun smartCastWhenExample(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    Les extensions són una forma d'afegir noves funcionalitats a una classe.
+    És semblant a les extensions de C#.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hola món!".remove('l')) // => Hoa, món!
+
+    println(EnumExample.A) // => A
+    println(ObjectExample.hello()) // => hola
+}
+
+// Les classes enumerades són semblants a les de Java
+enum class EnumExample {
+    A, B, C
+}
+
+/*
+El paràmetre "object" es pot fer servir per crear objectes singleton.
+No es poden instanciar però es pot fer referència a la seva única instància
+amb el seu nom.
+Són similars als singletons d'Scala.
+*/
+object ObjectExample {
+    fun hello(): String {
+        return "hola"
+    }
+}
+
+fun useObject() {
+    ObjectExample.hello()
+    val someRef: Any = ObjectExample // podem fer servir el nom de l'objecte
+}
+
+```
+
+### Per llegir més
+
+* [tutorials de Kotlin](https://kotlinlang.org/docs/tutorials/)
+* [Provar Kotlin en el navegador](http://try.kotlinlang.org/)
+* [Llista de recursos de Kotlin](http://kotlin.link/)
diff --git a/chapel.html.markdown b/chapel.html.markdown
index 866e92d2..68ce49cd 100644
--- a/chapel.html.markdown
+++ b/chapel.html.markdown
@@ -3,89 +3,113 @@ language: chapel
 filename: learnchapel.chpl
 contributors:
     - ["Ian J. Bertolacci", "http://www.cs.colostate.edu/~ibertola/"]
+    - ["Ben Harshbarger", "http://github.com/benharsh/"]
 ---
 
 You can read all about Chapel at [Cray's official Chapel website](http://chapel.cray.com).
-In short, Chapel is an open-source, high-productivity, parallel-programming language in development at Cray Inc., and is designed to run on multi-core PCs as well as multi-kilocore supercomputers.
+In short, Chapel is an open-source, high-productivity, parallel-programming
+language in development at Cray Inc., and is designed to run on multi-core PCs
+as well as multi-kilocore supercomputers.
 
 More information and support can be found at the bottom of this document.
 
-```c
+```chapel
 // Comments are C-family style
+
 // one line comment
 /*
-  multi-line comment
+ multi-line comment
 */
 
 // Basic printing
-write( "Hello, " );
-writeln( "World!" );
+
+write("Hello, ");
+writeln("World!");
+
 // write and writeln can take a list of things to print.
-// each thing is printed right next to each other, so include your spacing!
-writeln( "There are ", 3, " commas (\",\") in this line of code" );
-// Different output channels
-stdout.writeln( "This goes to standard output, just like plain writeln() does");
-stderr.writeln( "This goes to standard error" );
+// Each thing is printed right next to the others, so include your spacing!
+writeln("There are ", 3, " commas (\",\") in this line of code");
+
+// Different output channels:
+stdout.writeln("This goes to standard output, just like plain writeln() does");
+stderr.writeln("This goes to standard error");
+
 
 // Variables don't have to be explicitly typed as long as
 // the compiler can figure out the type that it will hold.
-var myVar = 10; // 10 is an int, so myVar is implicitly an int
+// 10 is an int, so myVar is implicitly an int
+var myVar = 10;
 myVar = -10;
 var mySecondVar = myVar;
-// var anError; // this would be a compile-time error.
+// var anError; would be a compile-time error.
 
-// We can (and should) explicitly type things
+// We can (and should) explicitly type things.
 var myThirdVar: real;
 var myFourthVar: real = -1.234;
 myThirdVar = myFourthVar;
 
+// Types
+
 // There are a number of basic types.
 var myInt: int = -1000; // Signed ints
 var myUint: uint = 1234; // Unsigned ints
 var myReal: real = 9.876; // Floating point numbers
 var myImag: imag = 5.0i; // Imaginary numbers
 var myCplx: complex = 10 + 9i; // Complex numbers
-myCplx = myInt + myImag ; // Another way to form complex numbers
+myCplx = myInt + myImag; // Another way to form complex numbers
 var myBool: bool = false; // Booleans
 var myStr: string = "Some string..."; // Strings
+var singleQuoteStr = 'Another string...'; // String literal with single quotes
 
-// Some types can have sizes
+// Some types can have sizes.
 var my8Int: int(8) = 10; // 8 bit (one byte) sized int;
 var my64Real: real(64) = 1.516; // 64 bit (8 bytes) sized real
 
-// Typecasting
+// Typecasting.
 var intFromReal = myReal : int;
 var intFromReal2: int = myReal : int;
 
-// consts are constants, they cannot be changed after set in runtime.
+// Type aliasing.
+type chroma = int;        // Type of a single hue
+type RGBColor = 3*chroma; // Type representing a full color
+var black: RGBColor = (0,0,0);
+var white: RGBColor = (255, 255, 255);
+
+// Constants and Parameters
+
+// A const is a constant, and cannot be changed after set in runtime.
 const almostPi: real = 22.0/7.0;
 
-// params are constants whose value must be known statically at compile-time
-// Their value cannot be changed.
+// A param is a constant whose value must be known statically at
+// compile-time.
 param compileTimeConst: int = 16;
 
-// The config modifier allows values to be set at the command line
-// and is much easier than the usual getOpts debacle
-// config vars and consts can be changed through the command line at run time
+// The config modifier allows values to be set at the command line.
+// Set with --varCmdLineArg=Value or --varCmdLineArg Value at runtime.
 config var varCmdLineArg: int = -123;
 config const constCmdLineArg: int = 777;
-// Set with --VarName=Value or --VarName Value at run time
 
-// config params can be set/changed at compile-time
+// config param can be set at compile-time.
+// Set with --set paramCmdLineArg=value at compile-time.
 config param paramCmdLineArg: bool = false;
-// Set config with --set paramCmdLineArg=value at compile-time
-writeln( varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg );
+writeln(varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg);
 
-// refs operate much like a reference in C++
+// References
+
+// ref operates much like a reference in C++. In Chapel, a ref cannot
+// be made to alias a variable other than the variable it is initialized with.
+// Here, refToActual refers to actual.
 var actual = 10;
-ref refToActual = actual; // refToActual refers to actual
-writeln( actual, " == ", refToActual ); // prints the same value
+ref refToActual = actual; 
+writeln(actual, " == ", refToActual); // prints the same value
 actual = -123; // modify actual (which refToActual refers to)
-writeln( actual, " == ", refToActual ); // prints the same value
+writeln(actual, " == ", refToActual); // prints the same value
 refToActual = 99999999; // modify what refToActual refers to (which is actual)
-writeln( actual, " == ", refToActual ); // prints the same value
+writeln(actual, " == ", refToActual); // prints the same value
+
+// Operators
 
-// Math operators
+// Math operators:
 var a: int, thisInt = 1234, thatInt = 5678;
 a = thisInt + thatInt;  // Addition
 a = thisInt * thatInt;  // Multiplication
@@ -94,252 +118,259 @@ a = thisInt / thatInt;  // Division
 a = thisInt ** thatInt; // Exponentiation
 a = thisInt % thatInt;  // Remainder (modulo)
 
-// Logical Operators
+// Logical operators:
 var b: bool, thisBool = false, thatBool = true;
 b = thisBool && thatBool; // Logical and
 b = thisBool || thatBool; // Logical or
 b = !thisBool;            // Logical negation
 
-// Relational Operators
+// Relational operators:
 b = thisInt > thatInt;           // Greater-than
 b = thisInt >= thatInt;          // Greater-than-or-equal-to
 b = thisInt < a && a <= thatInt; // Less-than, and, less-than-or-equal-to
 b = thisInt != thatInt;          // Not-equal-to
 b = thisInt == thatInt;          // Equal-to
 
-// Bitwise operations
+// Bitwise operators:
 a = thisInt << 10;     // Left-bit-shift by 10 bits;
 a = thatInt >> 5;      // Right-bit-shift by 5 bits;
 a = ~thisInt;          // Bitwise-negation
 a = thisInt ^ thatInt; // Bitwise exclusive-or
 
-// Compound assignment operations
-a += thisInt;          // Addition-equals ( a = a + thisInt;)
-a *= thatInt;          // Times-equals ( a = a * thatInt; )
-b &&= thatBool;        // Logical-and-equals ( b = b && thatBool; )
-a <<= 3;               // Left-bit-shift-equals ( a = a << 10; )
-// and many, many more.
-// Unlike other C family languages there are no
-// pre/post-increment/decrement operators like
-//  ++j, --j, j++, j--
-
-// Swap operator
+// Compound assignment operators:
+a += thisInt;          // Addition-equals (a = a + thisInt;)
+a *= thatInt;          // Times-equals (a = a * thatInt;)
+b &&= thatBool;        // Logical-and-equals (b = b && thatBool;)
+a <<= 3;               // Left-bit-shift-equals (a = a << 10;)
+
+// Unlike other C family languages, there are no
+// pre/post-increment/decrement operators, such as:
+//
+// ++j, --j, j++, j--
+
+// Swap operator:
 var old_this = thisInt;
 var old_that = thatInt;
 thisInt <=> thatInt; // Swap the values of thisInt and thatInt
-writeln( (old_this == thatInt) && (old_that == thisInt) );
+writeln((old_this == thatInt) && (old_that == thisInt));
+
+// Operator overloads can also be defined, as we'll see with procedures.
 
-// Operator overloads can also be defined, as we'll see with procedures
+// Tuples
 
-// Tuples can be of the same type
-var sameTup: 2*int = (10,-1);
+// Tuples can be of the same type or different types.
+var sameTup: 2*int = (10, -1);
 var sameTup2 = (11, -6);
-// or different types
 var diffTup: (int,real,complex) = (5, 1.928, myCplx);
-var diffTupe2 = ( 7, 5.64, 6.0+1.5i );
+var diffTupe2 = (7, 5.64, 6.0+1.5i);
 
-// Accessed using array bracket notation
-// However, tuples are all 1-indexed
-writeln( "(", sameTup[1], ",", sameTup[2], ")" );
-writeln( diffTup );
+// Tuples can be accessed using square brackets or parentheses, and are
+// 1-indexed.
+writeln("(", sameTup[1], ",", sameTup(2), ")");
+writeln(diffTup);
 
 // Tuples can also be written into.
-diffTup[1] = -1;
+diffTup(1) = -1;
 
-// Can expand tuple values into their own variables
+// Tuple values can be expanded into their own variables.
 var (tupInt, tupReal, tupCplx) = diffTup;
-writeln( diffTup == (tupInt, tupReal, tupCplx) );
+writeln(diffTup == (tupInt, tupReal, tupCplx));
 
-// Useful for writing a list of variables ( as is common in debugging)
-writeln( (a,b,thisInt,thatInt,thisBool,thatBool) );
+// They are also useful for writing a list of variables, as is common in debugging.
+writeln((a,b,thisInt,thatInt,thisBool,thatBool));
 
-// Type aliasing
-type chroma = int;        // Type of a single hue
-type RGBColor = 3*chroma; // Type representing a full color
-var black: RGBColor = ( 0,0,0 );
-var white: RGBColor = ( 255, 255, 255 );
+// Control Flow
 
-// If-then-else works just like any other C-family language
+// if - then - else works just like any other C-family language.
 if 10 < 100 then
-  writeln( "All is well" );
+  writeln("All is well");
 
 if -1 < 1 then
-  writeln( "Continuing to believe reality" );
+  writeln("Continuing to believe reality");
 else
-  writeln( "Send mathematician, something's wrong" );
+  writeln("Send mathematician, something's wrong");
 
-if ( 10 > 100 ) {
-  writeln( "Universe broken. Please reboot universe." );
+// You can use parentheses if you prefer.
+if (10 > 100) {
+  writeln("Universe broken. Please reboot universe.");
 }
 
-if ( a % 2 == 0 ) {
-  writeln( a, " is even." );
+if a % 2 == 0 {
+  writeln(a, " is even.");
 } else {
-  writeln( a, " is odd." );
+  writeln(a, " is odd.");
 }
 
-if ( a % 3 == 0 ) {
-  writeln( a, " is even divisible by 3." );
-} else if ( a % 3 == 1 ){
-  writeln( a, " is divided by 3 with a remainder of 1." );
+if a % 3 == 0 {
+  writeln(a, " is even divisible by 3.");
+} else if a % 3 == 1 {
+  writeln(a, " is divided by 3 with a remainder of 1.");
 } else {
-  writeln( b, " is divided by 3 with a remainder of 2." );
+  writeln(b, " is divided by 3 with a remainder of 2.");
 }
 
-// Ternary: if-then-else in a statement
-var maximum = if ( thisInt < thatInt ) then thatInt else thisInt;
+// Ternary: if - then - else in a statement.
+var maximum = if thisInt < thatInt then thatInt else thisInt;
 
-// Select statements are much like switch statements in other languages
-// However, Select statements don't cascade like in C or Java
+// select statements are much like switch statements in other languages.
+// However, select statements don't cascade like in C or Java.
 var inputOption = "anOption";
-select( inputOption ){
-  when "anOption" do writeln( "Chose 'anOption'" );
+select inputOption {
+  when "anOption" do writeln("Chose 'anOption'");
   when "otherOption" {
-    writeln( "Chose 'otherOption'" );
-    writeln( "Which has a body" );
+    writeln("Chose 'otherOption'");
+    writeln("Which has a body");
   }
   otherwise {
-    writeln( "Any other Input" );
-    writeln( "the otherwise case doesn't need a do if the body is one line" );
+    writeln("Any other Input");
+    writeln("the otherwise case doesn't need a do if the body is one line");
   }
 }
 
-// While and Do-While loops are basically the same in every language.
+// while and do-while loops also behave like their C counterparts.
 var j: int = 1;
 var jSum: int = 0;
-while( j <= 1000 ){
+while (j <= 1000) {
   jSum += j;
   j += 1;
 }
-writeln( jSum );
+writeln(jSum);
 
-// Do-While loop
-do{
+do {
   jSum += j;
   j += 1;
-}while( j <= 10000 );
-writeln( jSum );
+} while (j <= 10000);
+writeln(jSum);
 
-// For loops are much like those in python in that they iterate over a range.
-// Ranges themselves are types, and can be stuffed into variables
-// (more about that later)
-for i in 1..10 do write( i , ", ") ;
-writeln( );
+// for loops are much like those in python in that they iterate over a
+// range. Ranges (like the 1..10 expression below) are a first-class object
+// in Chapel, and as such can be stored in variables.
+for i in 1..10 do write(i, ", ");
+writeln();
 
 var iSum: int = 0;
 for i in 1..1000 {
   iSum += i;
 }
-writeln( iSum );
+writeln(iSum);
 
 for x in 1..10 {
   for y in 1..10 {
-    write( (x,y), "\t" );
+    write((x,y), "\t");
   }
-  writeln( );
+  writeln();
 }
 
 // Ranges and Domains
-// For-loops and arrays both use ranges and domains to
-// define an index set that can be iterated over.
-// Ranges are single dimensional
-// Domains can be multi-dimensional and can
-// represent indices of different types as well.
-// They are first-class citizen types, and can be assigned into variables
+
+// For-loops and arrays both use ranges and domains to define an index set that
+// can be iterated over. Ranges are single dimensional integer indices, while
+// domains can be multi-dimensional and represent indices of different types.
+
+// They are first-class citizen types, and can be assigned into variables.
 var range1to10: range = 1..10;  // 1, 2, 3, ..., 10
 var range2to11 = 2..11; // 2, 3, 4, ..., 11
-var rangeThistoThat: range = thisInt..thatInt; // using variables
-var rangeEmpty: range = 100..-100 ; // this is valid but contains no indices
+var rangeThisToThat: range = thisInt..thatInt; // using variables
+var rangeEmpty: range = 100..-100; // this is valid but contains no indices
 
-// Ranges can be unbounded
-var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ;
-// 1, 2, 3, 4, 5, ...
-// Note: the range(boundedType= ... ) is only
-// necessary if we explicitly type the variable
+// Ranges can be unbounded.
+var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ; // 1, 2, 3, 4, 5, ...
+var rangeNegInfTo1 = ..1; // ..., -4, -3, -2, -1, 0, 1
 
-var rangeNegInfto1 = ..1; // ..., -4, -3, -2, -1, 0, 1
-
-// Ranges can be strided using the 'by' operator.
+// Ranges can be strided (and reversed) using the by operator.
 var range2to10by2: range(stridable=true) = 2..10 by 2; // 2, 4, 6, 8, 10
-// Note: the range(stridable=true) is only
-// necessary if we explicitly type the variable
+var reverse2to10by2 = 2..10 by -2; // 10, 8, 6, 4, 2
+
+var trapRange = 10..1 by -1; // Do not be fooled, this is still an empty range
+writeln("Size of range '", trapRange, "' = ", trapRange.length);
 
-// Use by to create a reverse range
-var reverse2to10by2 = 10..2 by -2; // 10, 8, 6, 4, 2
+// Note: range(boundedType= ...) and range(stridable= ...) are only
+// necessary if we explicitly type the variable.
 
-// The end point of a range can be determined using the count (#) operator
+// The end point of a range can be determined using the count (#) operator.
 var rangeCount: range = -5..#12; // range from -5 to 6
 
-// Can mix operators
+// Operators can be mixed.
 var rangeCountBy: range(stridable=true) = -5..#12 by 2; // -5, -3, -1, 1, 3, 5
-writeln( rangeCountBy );
+writeln(rangeCountBy);
 
-// Can query properties of the range
-// Print the first index, last index, number of indices,
-// stride, and ask if 2 is include in the range
-writeln( ( rangeCountBy.first, rangeCountBy.last, rangeCountBy.length,
-           rangeCountBy.stride, rangeCountBy.member( 2 ) ) );
+// Properties of the range can be queried.
+// In this example, printing the first index, last index, number of indices,
+// stride, and if 2 is include in the range.
+writeln((rangeCountBy.first, rangeCountBy.last, rangeCountBy.length,
+           rangeCountBy.stride, rangeCountBy.member(2)));
 
-for i in rangeCountBy{
-  write( i, if i == rangeCountBy.last then "\n" else ", " );
+for i in rangeCountBy {
+  write(i, if i == rangeCountBy.last then "\n" else ", ");
 }
 
-// Rectangular domains are defined using the same range syntax
-// However they are required to be bounded (unlike ranges)
+// Rectangular domains are defined using the same range syntax,
+// but they are required to be bounded (unlike ranges).
 var domain1to10: domain(1) = {1..10};        // 1D domain from 1..10;
 var twoDimensions: domain(2) = {-2..2,0..2}; // 2D domain over product of ranges
 var thirdDim: range = 1..16;
 var threeDims: domain(3) = {thirdDim, 1..10, 5..10}; // using a range variable
 
-// Can iterate over the indices as tuples
+// Domains can also be resized
+var resizedDom = {1..10};
+writeln("before, resizedDom = ", resizedDom);
+resizedDom = {-10..#10};
+writeln("after, resizedDom = ", resizedDom);
+
+// Indices can be iterated over as tuples.
 for idx in twoDimensions do
-  write( idx , ", ");
-writeln( );
+  write(idx, ", ");
+writeln();
 
-// or can deconstruct the tuple
+// These tuples can also be deconstructed.
 for (x,y) in twoDimensions {
-  write( "(", x, ", ", y, ")", ", " );
+  write("(", x, ", ", y, ")", ", ");
 }
-writeln( );
+writeln();
 
-// Associative domains act like sets
+// Associative domains act like sets.
 var stringSet: domain(string); // empty set of strings
 stringSet += "a";
 stringSet += "b";
 stringSet += "c";
 stringSet += "a"; // Redundant add "a"
 stringSet -= "c"; // Remove "c"
-writeln( stringSet );
+writeln(stringSet.sorted());
+
+// Associative domains can also have a literal syntax
+var intSet = {1, 2, 4, 5, 100};
 
 // Both ranges and domains can be sliced to produce a range or domain with the
-// intersection of indices
+// intersection of indices.
 var rangeA = 1.. ; // range from 1 to infinity
 var rangeB =  ..5; // range from negative infinity to 5
 var rangeC = rangeA[rangeB]; // resulting range is 1..5
-writeln( (rangeA, rangeB, rangeC ) );
+writeln((rangeA, rangeB, rangeC));
 
 var domainA = {1..10, 5..20};
 var domainB = {-5..5, 1..10};
 var domainC = domainA[domainB];
-writeln( (domainA, domainB, domainC) );
+writeln((domainA, domainB, domainC));
+
+// Arrays
 
-// Array are similar to those of other languages.
-// Their sizes are defined using domains that represent their indices
+// Arrays are similar to those of other languages.
+// Their sizes are defined using domains that represent their indices.
 var intArray: [1..10] int;
-var intArray2: [{1..10}] int; //equivalent
+var intArray2: [{1..10}] int; // equivalent
 
-// Accessed using bracket notation
+// They can be accessed using either brackets or parentheses
 for i in 1..10 do
   intArray[i] = -i;
-writeln( intArray );
+writeln(intArray);
+
 // We cannot access intArray[0] because it exists outside
 // of the index set, {1..10}, we defined it to have.
 // intArray[11] is illegal for the same reason.
-
 var realDomain: domain(2) = {1..5,1..7};
 var realArray: [realDomain] real;
-var realArray2: [1..5,1..7] real;   // Equivalent
-var realArray3: [{1..5,1..7}] real; // Equivalent
+var realArray2: [1..5,1..7] real;   // equivalent
+var realArray3: [{1..5,1..7}] real; // equivalent
 
 for i in 1..5 {
   for j in realDomain.dim(2) {   // Only use the 2nd dimension of the domain
@@ -349,357 +380,390 @@ for i in 1..5 {
   }
 }
 
-// Arrays have domains as members that we can iterate over
+// Arrays have domains as members, and can be iterated over as normal.
 for idx in realArray.domain {  // Again, idx is a 2*int tuple
-  realArray[idx] = 1 / realArray[idx[1],idx[2]]; // Access by tuple and list
+  realArray[idx] = 1 / realArray[idx[1], idx[2]]; // Access by tuple and list
 }
 
-writeln( realArray );
+writeln(realArray);
 
-// Can also iterate over the values of an array
+// The values of an array can also be iterated directly.
 var rSum: real = 0;
 for value in realArray {
   rSum += value; // Read a value
   value = rSum;  // Write a value
 }
-writeln( rSum, "\n", realArray );
+writeln(rSum, "\n", realArray);
 
-// Using associative domains we can create associative arrays (dictionaries)
+// Associative arrays (dictionaries) can be created using associative domains.
 var dictDomain: domain(string) = { "one", "two" };
-var dict: [dictDomain] int = [ "one" => 1, "two" => 2 ];
-dict["three"] = 3;
-for key in dictDomain do writeln( dict[key] );
+var dict: [dictDomain] int = ["one" => 1, "two" => 2];
+dict["three"] = 3; // Adds 'three' to 'dictDomain' implicitly
+for key in dictDomain.sorted() do
+  writeln(dict[key]);
+
+// Arrays can be assigned to each other in a few different ways.
+// These arrays will be used in the example.
+var thisArray : [0..5] int = [0,1,2,3,4,5];
+var thatArray : [0..5] int;
 
-// Arrays can be assigned to each other in different ways
-var thisArray : [{0..5}] int = [0,1,2,3,4,5];
-var thatArray : [{0..5}] int;
+// First, simply assign one to the other. This copies thisArray into
+// thatArray, instead of just creating a reference. Therefore, modifying
+// thisArray does not also modify thatArray.
 
-// Simply assign one to the other.
-// This copies thisArray into thatArray, instead of just creating a reference.
-// Modifying thisArray does not also modify thatArray.
 thatArray = thisArray;
 thatArray[1] = -1;
-writeln( (thisArray, thatArray) );
+writeln((thisArray, thatArray));
 
-// Assign a slice one array to a slice (of the same size) of the other.
-thatArray[{4..5}] = thisArray[{1..2}];
-writeln( (thisArray, thatArray) );
+// Assign a slice from one array to a slice (of the same size) in the other.
+thatArray[4..5] = thisArray[1..2];
+writeln((thisArray, thatArray));
 
-// Operation can also be promoted to work on arrays.
+// Operations can also be promoted to work on arrays. 'thisPlusThat' is also
+// an array.
 var thisPlusThat = thisArray + thatArray;
-writeln( thisPlusThat );
+writeln(thisPlusThat);
 
-// Arrays and loops can also be expressions, where loop
+// Moving on, arrays and loops can also be expressions, where the loop
 // body's expression is the result of each iteration.
 var arrayFromLoop = for i in 1..10 do i;
-writeln( arrayFromLoop );
+writeln(arrayFromLoop);
 
-// An expression can result in nothing,
-// such as when filtering with an if-expression
+// An expression can result in nothing, such as when filtering with an if-expression.
 var evensOrFives = for i in 1..10 do if (i % 2 == 0 || i % 5 == 0) then i;
 
-writeln( arrayFromLoop );
+writeln(arrayFromLoop);
 
-// Or could be written with a bracket notation
-// Note: this syntax uses the 'forall' parallel concept discussed later.
-var evensOrFivesAgain = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i;
+// Array expressions can also be written with a bracket notation.
+// Note: this syntax uses the forall parallel concept discussed later.
+var evensOrFivesAgain = [i in 1..10] if (i % 2 == 0 || i % 5 == 0) then i;
 
-// Or over the values of the array
-arrayFromLoop = [ value in arrayFromLoop ] value + 1;
+// They can also be written over the values of the array.
+arrayFromLoop = [value in arrayFromLoop] value + 1;
 
-// Note: this notation can get somewhat tricky. For example:
-// evensOrFives = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i;
-// would break.
-// The reasons for this are explained in depth when discussing zipped iterators.
 
-// Chapel procedures have similar syntax to other languages functions.
-proc fibonacci( n : int ) : int {
-  if ( n <= 1 ) then return n;
-  return fibonacci( n-1 ) + fibonacci( n-2 );
+// Procedures
+
+// Chapel procedures have similar syntax functions in other languages. 
+proc fibonacci(n : int) : int {
+  if n <= 1 then return n;
+  return fibonacci(n-1) + fibonacci(n-2);
 }
 
-// Input parameters can be untyped (a generic procedure)
-proc doublePrint( thing ): void {
-  write( thing, " ", thing, "\n");
+// Input parameters can be untyped to create a generic procedure.
+proc doublePrint(thing): void {
+  write(thing, " ", thing, "\n");
 }
 
-// Return type can be inferred (as long as the compiler can figure it out)
-proc addThree( n ) {
+// The return type can be inferred, as long as the compiler can figure it out.
+proc addThree(n) {
   return n + 3;
 }
 
-doublePrint( addThree( fibonacci( 20 ) ) );
+doublePrint(addThree(fibonacci(20)));
 
-// Can also take 'unlimited' number of parameters
-proc maxOf( x ...?k ) {
+// It is also possible to take a variable number of parameters.
+proc maxOf(x ...?k) {
   // x refers to a tuple of one type, with k elements
   var maximum = x[1];
-  for i in 2..k do maximum = if (maximum < x[i]) then x[i] else maximum;
+  for i in 2..k do maximum = if maximum < x[i] then x[i] else maximum;
   return maximum;
 }
-writeln( maxOf( 1, -10, 189, -9071982, 5, 17, 20001, 42 ) );
+writeln(maxOf(1, -10, 189, -9071982, 5, 17, 20001, 42));
 
-// The ? operator is called the query operator, and is used to take
-// undetermined values (like tuple or array sizes, and generic types).
+// Procedures can have default parameter values, and
+// the parameters can be named in the call, even out of order.
+proc defaultsProc(x: int, y: real = 1.2634): (int,real) {
+  return (x,y);
+}
 
-// Taking arrays as parameters.
-// The query operator is used to determine the domain of A.
-// This is important to define the return type (if you wanted to)
-proc invertArray( A: [?D] int ): [D] int{
+writeln(defaultsProc(10));
+writeln(defaultsProc(x=11));
+writeln(defaultsProc(x=12, y=5.432));
+writeln(defaultsProc(y=9.876, x=13));
+
+// The ? operator is called the query operator, and is used to take
+// undetermined values like tuple or array sizes and generic types.
+// For example, taking arrays as parameters. The query operator is used to
+// determine the domain of A. This is uesful for defining the return type,
+// though it's not required.
+proc invertArray(A: [?D] int): [D] int{
   for a in A do a = -a;
   return A;
 }
 
-writeln( invertArray( intArray ) );
+writeln(invertArray(intArray));
 
-// Procedures can have default parameter values, and
-// the parameters can be named in the call, even out of order
-proc defaultsProc( x: int, y: real = 1.2634 ): (int,real){
-  return (x,y);
+// We can query the type of arguments to generic procedures.
+// Here we define a procedure that takes two arguments of
+// the same type, yet we don't define what that type is.
+proc genericProc(arg1 : ?valueType, arg2 : valueType): void {
+  select(valueType) {
+    when int do writeln(arg1, " and ", arg2, " are ints");
+    when real do writeln(arg1, " and ", arg2, " are reals");
+    otherwise writeln(arg1, " and ", arg2, " are somethings!");
+  }
+}
+
+genericProc(1, 2);
+genericProc(1.2, 2.3);
+genericProc(1.0+2.0i, 3.0+4.0i);
+
+// We can also enforce a form of polymorphism with the where clause
+// This allows the compiler to decide which function to use.
+// Note: That means that all information needs to be known at compile-time.
+// The param modifier on the arg is used to enforce this constraint.
+proc whereProc(param N : int): void
+ where (N > 0) {
+  writeln("N is greater than 0");
 }
 
-writeln( defaultsProc( 10 ) );
-writeln( defaultsProc( x=11 ) );
-writeln( defaultsProc( x=12, y=5.432 ) );
-writeln( defaultsProc( y=9.876, x=13 ) );
-
-// Intent modifiers on the arguments convey how
-// those arguments are passed to the procedure
-// in: copy arg in, but not out
-// out: copy arg out, but not in
-// inout: copy arg in, copy arg out
-// ref: pass arg by reference
-proc intentsProc( in inarg, out outarg, inout inoutarg, ref refarg ){
-  writeln( "Inside Before: ", (inarg, outarg, inoutarg, refarg) );
+proc whereProc(param N : int): void
+ where (N < 0) {
+  writeln("N is less than 0");
+}
+
+whereProc(10);
+whereProc(-1);
+
+// whereProc(0) would result in a compiler error because there
+// are no functions that satisfy the where clause's condition.
+// We could have defined a whereProc without a where clause
+// that would then have served as a catch all for all the other cases
+// (of which there is only one).
+
+// where clauses can also be used to constrain based on argument type.
+proc whereType(x: ?t) where t == int {
+  writeln("Inside 'int' version of 'whereType': ", x);
+}
+
+proc whereType(x: ?t) {
+  writeln("Inside general version of 'whereType': ", x);
+}
+
+whereType(42);
+whereType("hello");
+
+// Intents
+
+/* Intent modifiers on the arguments convey how those arguments are passed to the procedure.
+
+     * in: copy arg in, but not out
+     * out: copy arg out, but not in
+     * inout: copy arg in, copy arg out
+     * ref: pass arg by reference
+*/
+proc intentsProc(in inarg, out outarg, inout inoutarg, ref refarg) {
+  writeln("Inside Before: ", (inarg, outarg, inoutarg, refarg));
   inarg = inarg + 100;
   outarg = outarg + 100;
   inoutarg = inoutarg + 100;
   refarg = refarg + 100;
-  writeln( "Inside After: ", (inarg, outarg, inoutarg, refarg) );
+  writeln("Inside After: ", (inarg, outarg, inoutarg, refarg));
 }
 
 var inVar: int = 1;
 var outVar: int = 2;
 var inoutVar: int = 3;
 var refVar: int = 4;
-writeln( "Outside Before: ", (inVar, outVar, inoutVar, refVar) );
-intentsProc( inVar, outVar, inoutVar, refVar );
-writeln( "Outside After: ", (inVar, outVar, inoutVar, refVar) );
-
-// Similarly we can define intents on the return type
-// refElement returns a reference to an element of array
-proc refElement( array : [?D] ?T, idx ) ref : T {
-  return array[ idx ]; // returns a reference to
-}
+writeln("Outside Before: ", (inVar, outVar, inoutVar, refVar));
+intentsProc(inVar, outVar, inoutVar, refVar);
+writeln("Outside After: ", (inVar, outVar, inoutVar, refVar));
 
-var myChangingArray : [1..5] int = [1,2,3,4,5];
-writeln( myChangingArray );
-// Store reference to element in ref variable
-ref refToElem = refElement( myChangingArray, 5 );
-writeln( refToElem );
-refToElem = -2; // modify reference which modifies actual value in array
-writeln( refToElem );
-writeln( myChangingArray );
+// Similarly, we can define intents on the return type.
+// refElement returns a reference to an element of array.
 // This makes more practical sense for class methods where references to
-// elements in a data-structure are returned via a method or iterator
-
-// We can query the type of arguments to generic procedures
-// Here we define a procedure that takes two arguments of
-// the same type, yet we don't define what that type is.
-proc genericProc( arg1 : ?valueType, arg2 : valueType ): void {
-  select( valueType ){
-    when int do writeln( arg1, " and ", arg2, " are ints" );
-    when real do writeln( arg1, " and ", arg2, " are reals" );
-    otherwise writeln( arg1, " and ", arg2, " are somethings!" );
-  }
-}
-
-genericProc( 1, 2 );
-genericProc( 1.2, 2.3 );
-genericProc( 1.0+2.0i, 3.0+4.0i );
-
-// We can also enforce a form of polymorphism with the 'where' clause
-// This allows the compiler to decide which function to use.
-// Note: that means that all information needs to be known at compile-time.
-// The param modifier on the arg is used to enforce this constraint.
-proc whereProc( param N : int ): void
- where ( N > 0 ) {
-  writeln( "N is greater than 0" );
+// elements in a data-structure are returned via a method or iterator.
+proc refElement(array : [?D] ?T, idx) ref : T {
+  return array[idx];
 }
 
-proc whereProc( param N : int ): void
- where ( N < 0 ) {
-  writeln( "N is less than 0" );
-}
+var myChangingArray : [1..5] int = [1,2,3,4,5];
+writeln(myChangingArray);
+ref refToElem = refElement(myChangingArray, 5); // store reference to element in ref variable
+writeln(refToElem);
+refToElem = -2; // modify reference which modifies actual value in array
+writeln(refToElem);
+writeln(myChangingArray);
 
-whereProc( 10 );
-whereProc( -1 );
-// whereProc( 0 ) would result in a compiler error because there
-// are no functions that satisfy the where clause's condition.
-// We could have defined a whereProc without a where clause that would then have
-// served as a catch all for all the other cases (of which there is only one).
+// Operator Definitions
 
-// Operator definitions are through procedures as well.
+// Chapel allows for operators to be overloaded.
 // We can define the unary operators:
 // + - ! ~
 // and the binary operators:
 // + - * / % ** == <= >= < > << >> & | ˆ by
 // += -= *= /= %= **= &= |= ˆ= <<= >>= <=>
 
-// Boolean exclusive or operator
-proc ^( left : bool, right : bool ): bool {
-  return (left || right) && !( left && right );
+// Boolean exclusive or operator.
+proc ^(left : bool, right : bool): bool {
+  return (left || right) && !(left && right);
 }
 
-writeln( true  ^ true  );
-writeln( false ^ true  );
-writeln( true  ^ false );
-writeln( false ^ false );
+writeln(true  ^ true);
+writeln(false ^ true);
+writeln(true  ^ false);
+writeln(false ^ false);
 
-// Define a * operator on any two types that returns a tuple of those types
-proc *( left : ?ltype, right : ?rtype): ( ltype, rtype ){
-  return (left, right );
+// Define a * operator on any two types that returns a tuple of those types.
+proc *(left : ?ltype, right : ?rtype): (ltype, rtype) {
+  writeln("\tIn our '*' overload!");
+  return (left, right);
 }
 
-writeln( 1 * "a" ); // Uses our * operator
-writeln( 1 * 2 );   // Uses the default * operator
+writeln(1 * "a"); // Uses our * operator.
+writeln(1 * 2);   // Uses the default * operator.
+
+//  Note: You could break everything if you get careless with your overloads.
+//  This here will break everything. Don't do it.
 
 /*
-Note: You could break everything if you get careless with your overloads.
-This here will break everything. Don't do it.
-proc +( left: int, right: int ): int{
-  return left - right;
-}
+    proc +(left: int, right: int): int {
+      return left - right;
+    }
 */
 
-// Iterators are a sisters to the procedure, and almost
-// everything about procedures also applies to iterators
-// However, instead of returning a single value,
-// iterators yield many values to a loop.
-// This is useful when a complicated set or order of iterations is needed but
-// allows the code defining the iterations to be separate from the loop body.
-iter oddsThenEvens( N: int ): int {
+// Iterators
+
+// Iterators are sisters to the procedure, and almost everything about
+// procedures also applies to iterators. However, instead of returning a single
+// value, iterators may yield multiple values to a loop.
+//
+// This is useful when a complicated set or order of iterations is needed, as
+// it allows the code defining the iterations to be separate from the loop
+// body.
+iter oddsThenEvens(N: int): int {
   for i in 1..N by 2 do
     yield i; // yield values instead of returning.
   for i in 2..N by 2 do
     yield i;
 }
 
-for i in oddsThenEvens( 10 ) do write( i, ", " );
-writeln( );
+for i in oddsThenEvens(10) do write(i, ", ");
+writeln();
 
 // Iterators can also yield conditionally, the result of which can be nothing
-iter absolutelyNothing( N ): int {
+iter absolutelyNothing(N): int {
   for i in 1..N {
-    if ( N < i ) { // Always false
+    if N < i { // Always false
       yield i;     // Yield statement never happens
     }
   }
 }
 
-for i in absolutelyNothing( 10 ){
-  writeln( "Woa there! absolutelyNothing yielded ", i );
+for i in absolutelyNothing(10) {
+  writeln("Woa there! absolutelyNothing yielded ", i);
 }
 
 // We can zipper together two or more iterators (who have the same number
-// of iterations)  using zip() to create a single zipped iterator, where each
+// of iterations) using zip() to create a single zipped iterator, where each
 // iteration of the zipped iterator yields a tuple of one value yielded
 // from each iterator.
-                                 // Ranges have implicit iterators
-for (positive, negative) in zip( 1..5, -5..-1) do
-  writeln( (positive, negative) );
+for (positive, negative) in zip(1..5, -5..-1) do
+  writeln((positive, negative));
 
 // Zipper iteration is quite important in the assignment of arrays,
 // slices of arrays, and array/loop expressions.
 var fromThatArray : [1..#5] int = [1,2,3,4,5];
 var toThisArray : [100..#5] int;
 
-// The operation
+// Some zipper operations implement other operations.
+// The first statement and the loop are equivalent.
 toThisArray = fromThatArray;
-// is produced through
-for (i,j) in zip( toThisArray.domain, fromThatArray.domain) {
-  toThisArray[ i ] = fromThatArray[ j ];
+for (i,j) in zip(toThisArray.domain, fromThatArray.domain) {
+  toThisArray[i] = fromThatArray[j];
 }
 
-toThisArray = [ j in -100..#5 ] j;
-writeln( toThisArray );
-// is produced through
-for (i, j) in zip( toThisArray.domain, -100..#5 ){
+// These two chunks are also equivalent.
+toThisArray = [j in -100..#5] j;
+writeln(toThisArray);
+
+for (i, j) in zip(toThisArray.domain, -100..#5) {
   toThisArray[i] = j;
 }
-writeln( toThisArray );
+writeln(toThisArray);
+
+// This is very important in understanding why this statement exhibits a
+// runtime error.
+
+/*
+  var iterArray : [1..10] int = [i in 1..10] if (i % 2 == 1) then i;
+*/
 
-// This is all very important in understanding why the statement
-// var iterArray : [1..10] int = [ i in 1..10 ] if ( i % 2 == 1 ) then j;
-// exhibits a runtime error.
 // Even though the domain of the array and the loop-expression are
 // the same size, the body of the expression can be thought of as an iterator.
 // Because iterators can yield nothing, that iterator yields a different number
 // of things than the domain of the array or loop, which is not allowed.
 
-// Classes are similar to those in C++ and Java.
-// They currently lack privatization
+// Classes
+
+// Classes are similar to those in C++ and Java, allocated on the heap.
 class MyClass {
-  // Member variables
+
+// Member variables
   var memberInt : int;
   var memberBool : bool = true;
 
-  // Classes have default constructors that don't need to be coded (see below)
-  // Our explicitly defined constructor
-  proc MyClass( val : real ){
-    this.memberInt = ceil( val ): int;
+// Explicitly defined initializer.
+// We also get the compiler-generated initializer, with one argument per field.
+// Note that soon there will be no compiler-generated initializer when we
+// define any initializer(s) explicitly.
+  proc MyClass(val : real) {
+    this.memberInt = ceil(val): int;
   }
 
-  // Our explicitly defined destructor
-  proc ~MyClass( ){
-    writeln( "MyClass Destructor called ", (this.memberInt, this.memberBool) );
+// Explicitly defined deinitializer.
+// If we did not write one, we would get the compiler-generated deinitializer,
+// which has an empty body.
+  proc deinit() {
+    writeln("MyClass deinitializer called ", (this.memberInt, this.memberBool));
   }
 
-  // Class methods
-  proc setMemberInt( val: int ){
+// Class methods.
+  proc setMemberInt(val: int) {
     this.memberInt = val;
   }
 
-  proc setMemberBool( val: bool ){
+  proc setMemberBool(val: bool) {
     this.memberBool = val;
   }
 
-  proc getMemberInt( ): int{
+  proc getMemberInt(): int{
     return this.memberInt;
   }
 
-  proc getMemberBool( ): bool {
+  proc getMemberBool(): bool {
     return this.memberBool;
   }
-
-}
-
-// Construct using default constructor, using default values
-var myObject = new MyClass( 10 );
-    myObject = new MyClass( memberInt = 10 ); // Equivalent
-writeln( myObject.getMemberInt( ) );
-// ... using our values
-var myDiffObject = new MyClass( -1, true );
-    myDiffObject = new MyClass( memberInt = -1,
-                                memberBool = true ); // Equivalent
-writeln( myDiffObject );
-
-// Construct using written constructor
-var myOtherObject = new MyClass( 1.95 );
-    myOtherObject = new MyClass( val = 1.95 ); // Equivalent
-writeln( myOtherObject.getMemberInt( ) );
-
-// We can define an operator on our class as well but
-// the definition has to be outside the class definition
-proc +( A : MyClass, B : MyClass) : MyClass {
-  return new MyClass( memberInt = A.getMemberInt( ) + B.getMemberInt( ),
-                      memberBool = A.getMemberBool( ) || B.getMemberBool( ) );
+} // end MyClass
+
+// Call compiler-generated initializer, using default value for memberBool.
+var myObject = new MyClass(10);
+    myObject = new MyClass(memberInt = 10); // Equivalent
+writeln(myObject.getMemberInt());
+
+// Same, but provide a memberBool value explicitly.
+var myDiffObject = new MyClass(-1, true);
+    myDiffObject = new MyClass(memberInt = -1,
+                                memberBool = true); // Equivalent
+writeln(myDiffObject);
+
+// Call the initializer we wrote.
+var myOtherObject = new MyClass(1.95);
+    myOtherObject = new MyClass(val = 1.95); // Equivalent
+writeln(myOtherObject.getMemberInt());
+
+// We can define an operator on our class as well, but
+// the definition has to be outside the class definition.
+proc +(A : MyClass, B : MyClass) : MyClass {
+  return new MyClass(memberInt = A.getMemberInt() + B.getMemberInt(),
+                      memberBool = A.getMemberBool() || B.getMemberBool());
 }
 
 var plusObject = myObject + myDiffObject;
-writeln( plusObject );
+writeln(plusObject);
 
-// Destruction
+// Destruction.
 delete myObject;
 delete myDiffObject;
 delete myOtherObject;
@@ -710,346 +774,362 @@ class MyChildClass : MyClass {
   var memberComplex: complex;
 }
 
-// Generic Classes
+// Here's an example of generic classes.
 class GenericClass {
   type classType;
   var classDomain: domain(1);
   var classArray: [classDomain] classType;
 
-  // Explicit constructor
-  proc GenericClass( type classType, elements : int ){
+// Explicit constructor.
+  proc GenericClass(type classType, elements : int) {
     this.classDomain = {1..#elements};
   }
 
-  // Copy constructor
-  // Note: We still have to put the type as an argument, but we can
-  // default to the type of the other object using the query (?) operator
-  // Further, we can take advantage of this to allow our copy constructor
-  // to copy classes of different types and cast on the fly
-  proc GenericClass( other : GenericClass(?otherType),
-                     type classType = otherType ) {
+// Copy constructor.
+// Note: We still have to put the type as an argument, but we can
+// default to the type of the other object using the query (?) operator.
+// Further, we can take advantage of this to allow our copy constructor
+// to copy classes of different types and cast on the fly.
+  proc GenericClass(other : GenericClass(?otherType),
+                     type classType = otherType) {
     this.classDomain = other.classDomain;
     // Copy and cast
-    for idx in this.classDomain do this[ idx ] = other[ idx ] : classType;
+    for idx in this.classDomain do this[idx] = other[idx] : classType;
   }
 
-  // Define bracket notation on a GenericClass
-  // object so it can behave like a normal array
-  // i.e. objVar[ i ] or objVar( i )
-  proc this( i : int ) ref : classType {
-    return this.classArray[ i ];
+// Define bracket notation on a GenericClass
+// object so it can behave like a normal array
+// i.e. objVar[i] or objVar(i)
+  proc this(i : int) ref : classType {
+    return this.classArray[i];
   }
 
-  // Define an implicit iterator for the class
-  // to yield values from the array to a loop
-  // i.e. for i in objVar do ....
-  iter these( ) ref : classType {
+// Define an implicit iterator for the class
+// to yield values from the array to a loop
+// i.e. for i in objVar do ...
+  iter these() ref : classType {
     for i in this.classDomain do
       yield this[i];
   }
+} // end GenericClass
 
-}
-
-var realList = new GenericClass( real, 10 );
 // We can assign to the member array of the object using the bracket
-// notation that we defined ( proc this( i: int ){ ... }  )
+// notation that we defined.
+var realList = new GenericClass(real, 10);
 for i in realList.classDomain do realList[i] = i + 1.0;
+
 // We can iterate over the values in our list with the iterator
-// we defined ( iter these( ){ ... } )
-for value in realList do write( value, ", " );
-writeln( );
+// we defined.
+for value in realList do write(value, ", ");
+writeln();
 
-// Make a copy of realList using the copy constructor
-var copyList = new GenericClass( realList );
-for value in copyList do write( value, ", " );
-writeln( );
+// Make a copy of realList using the copy constructor.
+var copyList = new GenericClass(realList);
+for value in copyList do write(value, ", ");
+writeln();
 
-// Make a copy of realList and change the type, also using the copy constructor
-var copyNewTypeList = new GenericClass( realList, int );
-for value in copyNewTypeList do write( value, ", " );
-writeln( );
+// Make a copy of realList and change the type, also using the copy constructor.
+var copyNewTypeList = new GenericClass(realList, int);
+for value in copyNewTypeList do write(value, ", ");
+writeln();
+
+
+// Modules
 
 // Modules are Chapel's way of managing name spaces.
 // The files containing these modules do not need to be named after the modules
 // (as in Java), but files implicitly name modules.
-// In this case, this file implicitly names the 'learnchapel' module
+// For example, this file implicitly names the learnChapelInYMinutes module
 
 module OurModule {
-  // We can use modules inside of other modules.
-  use Time; // Time is one of the standard modules.
 
-  // We'll use this procedure in the parallelism section.
-  proc countdown( seconds: int ){
+// We can use modules inside of other modules.
+// Time is one of the standard modules.
+  use Time;
+
+// We'll use this procedure in the parallelism section.
+  proc countdown(seconds: int) {
     for i in 1..seconds by -1 {
-      writeln( i );
-      sleep( 1 );
+      writeln(i);
+      sleep(1);
     }
   }
 
-  // Submodules of OurModule
-  // It is possible to create arbitrarily deep module nests.
+// It is possible to create arbitrarily deep module nests.
+// i.e. submodules of OurModule
   module ChildModule {
-    proc foo(){
-      writeln( "ChildModule.foo()");
+    proc foo() {
+      writeln("ChildModule.foo()");
     }
   }
 
   module SiblingModule {
-    proc foo(){
-      writeln( "SiblingModule.foo()" );
+    proc foo() {
+      writeln("SiblingModule.foo()");
     }
   }
 } // end OurModule
 
 // Using OurModule also uses all the modules it uses.
-// Since OurModule uses Time, we also use time.
+// Since OurModule uses Time, we also use Time.
 use OurModule;
 
-// At this point we have not used ChildModule or SiblingModule so their symbols
-// (i.e. foo ) are not available to us.
-// However, the module names are, and we can explicitly call foo() through them.
-SiblingModule.foo();         // Calls SiblingModule.foo()
-
-// Super explicit naming.
-OurModule.ChildModule.foo(); // Calls ChildModule.foo()
+// At this point we have not used ChildModule or SiblingModule so
+// their symbols (i.e. foo) are not available to us. However, the module
+// names are available, and we can explicitly call foo() through them.
+SiblingModule.foo();
+OurModule.ChildModule.foo();
 
+// Now we use ChildModule, enabling unqualified calls.
 use ChildModule;
-foo();   // Less explicit call on ChildModule.foo()
+foo();
+
+// Parallelism
+
+// In other languages, parallelism is typically done with
+// complicated libraries and strange class structure hierarchies.
+// Chapel has it baked right into the language.
 
-// We can declare a main procedure
-// Note: all the code above main still gets executed.
-proc main(){
+// We can declare a main procedure, but all the code above main still gets
+// executed.
+proc main() {
+  writeln("PARALLELISM START");
 
-  // Parallelism
-  // In other languages, parallelism is typically done with
-  // complicated libraries and strange class structure hierarchies.
-  // Chapel has it baked right into the language.
+// A begin statement will spin the body of that statement off
+// into one new task.
+// A sync statement will ensure that the progress of the main
+// task will not progress until the children have synced back up.
 
-  // A begin statement will spin the body of that statement off
-  // into one new task.
-  // A sync statement will ensure that the progress of the main
-  // task will not progress until the children have synced back up.
   sync {
     begin { // Start of new task's body
       var a = 0;
       for i in 1..1000 do a += 1;
-      writeln( "Done: ", a);
+      writeln("Done: ", a);
     } // End of new tasks body
-    writeln( "spun off a task!");
+    writeln("spun off a task!");
   }
-  writeln( "Back together" );
+  writeln("Back together");
 
-  proc printFibb( n: int ){
-    writeln( "fibonacci(",n,") = ", fibonacci( n ) );
+  proc printFibb(n: int) {
+    writeln("fibonacci(",n,") = ", fibonacci(n));
   }
 
-  // A cobegin statement will spin each statement of the body into one new task
+// A cobegin statement will spin each statement of the body into one new
+// task. Notice here that the prints from each statement may happen in any
+// order.
   cobegin {
-    printFibb( 20 ); // new task
-    printFibb( 10 ); // new task
-    printFibb( 5 );  // new task
+    printFibb(20); // new task
+    printFibb(10); // new task
+    printFibb(5);  // new task
     {
       // This is a nested statement body and thus is a single statement
-      // to the parent statement and is executed by a single task
-      writeln( "this gets" );
-      writeln( "executed as" );
-      writeln( "a whole" );
+      // to the parent statement, executed by a single task.
+      writeln("this gets");
+      writeln("executed as");
+      writeln("a whole");
     }
   }
-  // Notice here that the prints from each statement may happen in any order.
 
-  // Coforall loop will create a new task for EACH iteration
+// A coforall loop will create a new task for EACH iteration.
+// Again we see that prints happen in any order.
+// NOTE: coforall should be used only for creating tasks!
+// Using it to iterating over a structure is very a bad idea!
   var num_tasks = 10; // Number of tasks we want
   coforall taskID in 1..#num_tasks {
-    writeln( "Hello from task# ", taskID );
+    writeln("Hello from task# ", taskID);
   }
-  // Again we see that prints happen in any order.
-  // NOTE! coforall should be used only for creating tasks!
-  // Using it to iterating over a structure is very a bad idea!
 
-  // forall loops are another parallel loop, but only create a smaller number
-  // of tasks, specifically --dataParTasksPerLocale=number of task
+// forall loops are another parallel loop, but only create a smaller number
+// of tasks, specifically --dataParTasksPerLocale= number of tasks.
   forall i in 1..100 {
-    write( i, ", ");
+    write(i, ", ");
   }
-  writeln( );
-  // Here we see that there are sections that are in order, followed by
-  // a section that would not follow ( e.g. 1, 2, 3, 7, 8, 9, 4, 5, 6, ).
-  // This is because each task is taking on a chunk of the range 1..10
-  // (1..3, 4..6, or 7..9) doing that chunk serially, but each task happens
-  // in parallel.
-  // Your results may depend on your machine and configuration
-
-  // For both the forall and coforall loops, the execution of the
-  // parent task will not continue until all the children sync up.
-
-  // forall loops are particularly useful for parallel iteration over arrays.
-  // Lets run an experiment to see how much faster a parallel loop is
+  writeln();
+
+// Here we see that there are sections that are in order, followed by
+// a section that would not follow (e.g. 1, 2, 3, 7, 8, 9, 4, 5, 6,).
+// This is because each task is taking on a chunk of the range 1..10
+// (1..3, 4..6, or 7..9) doing that chunk serially, but each task happens
+// in parallel. Your results may depend on your machine and configuration
+
+// For both the forall and coforall loops, the execution of the
+// parent task will not continue until all the children sync up.
+
+// forall loops are particularly useful for parallel iteration over arrays.
+// Lets run an experiment to see how much faster a parallel loop is
   use Time; // Import the Time module to use Timer objects
   var timer: Timer;
   var myBigArray: [{1..4000,1..4000}] real; // Large array we will write into
 
-  // Serial Experiment
-  timer.start( ); // Start timer
+// Serial Experiment:
+  timer.start(); // Start timer
   for (x,y) in myBigArray.domain { // Serial iteration
     myBigArray[x,y] = (x:real) / (y:real);
   }
-  timer.stop( ); // Stop timer
-  writeln( "Serial: ", timer.elapsed( ) ); // Print elapsed time
-  timer.clear( ); // Clear timer for parallel loop
+  timer.stop(); // Stop timer
+  writeln("Serial: ", timer.elapsed()); // Print elapsed time
+  timer.clear(); // Clear timer for parallel loop
 
-  // Parallel Experiment
-  timer.start( ); // start timer
+// Parallel Experiment:
+  timer.start(); // start timer
   forall (x,y) in myBigArray.domain { // Parallel iteration
     myBigArray[x,y] = (x:real) / (y:real);
   }
-  timer.stop( ); // Stop timer
-  writeln( "Parallel: ", timer.elapsed( ) ); // Print elapsed time
-  timer.clear( );
-  // You may have noticed that (depending on how many cores you have)
-  // that the parallel loop went faster than the serial loop
-
-  // The bracket style loop-expression described
-  // much earlier implicitly uses a forall loop.
-  [ val in myBigArray ] val = 1 / val; // Parallel operation
-
-  // Atomic variables, common to many languages, are ones whose operations
-  // occur uninterrupted. Multiple threads can both modify atomic variables
-  // and can know that their values are safe.
-  // Chapel atomic variables can be of type bool, int, uint, and real.
+  timer.stop(); // Stop timer
+  writeln("Parallel: ", timer.elapsed()); // Print elapsed time
+  timer.clear();
+
+// You may have noticed that (depending on how many cores you have)
+// the parallel loop went faster than the serial loop.
+
+// The bracket style loop-expression described
+// much earlier implicitly uses a forall loop.
+  [val in myBigArray] val = 1 / val; // Parallel operation
+
+// Atomic variables, common to many languages, are ones whose operations
+// occur uninterrupted. Multiple threads can therefore modify atomic
+// variables and can know that their values are safe.
+// Chapel atomic variables can be of type bool, int,
+// uint, and real.
   var uranium: atomic int;
-  uranium.write( 238 );      // atomically write a variable
-  writeln( uranium.read() ); // atomically read a variable
+  uranium.write(238);      // atomically write a variable
+  writeln(uranium.read()); // atomically read a variable
 
-  // operations are described as functions, you could define your own operators.
-  uranium.sub( 3 ); // atomically subtract a variable
-  writeln( uranium.read() );
+// Atomic operations are described as functions, so you can define your own.
+  uranium.sub(3); // atomically subtract a variable
+  writeln(uranium.read());
 
   var replaceWith = 239;
-  var was = uranium.exchange( replaceWith );
-  writeln( "uranium was ", was, " but is now ", replaceWith );
+  var was = uranium.exchange(replaceWith);
+  writeln("uranium was ", was, " but is now ", replaceWith);
 
   var isEqualTo = 235;
-  if ( uranium.compareExchange( isEqualTo, replaceWith ) ) {
-    writeln( "uranium was equal to ", isEqualTo,
-             " so replaced value with ", replaceWith );
+  if uranium.compareExchange(isEqualTo, replaceWith) {
+    writeln("uranium was equal to ", isEqualTo,
+             " so replaced value with ", replaceWith);
   } else {
-    writeln( "uranium was not equal to ", isEqualTo,
-             " so value stays the same...  whatever it was" );
+    writeln("uranium was not equal to ", isEqualTo,
+             " so value stays the same...  whatever it was");
   }
 
   sync {
     begin { // Reader task
-      writeln( "Reader: waiting for uranium to be ", isEqualTo );
-      uranium.waitFor( isEqualTo );
-      writeln( "Reader: uranium was set (by someone) to ", isEqualTo );
+      writeln("Reader: waiting for uranium to be ", isEqualTo);
+      uranium.waitFor(isEqualTo);
+      writeln("Reader: uranium was set (by someone) to ", isEqualTo);
     }
 
     begin { // Writer task
-      writeln( "Writer: will set uranium to the value ", isEqualTo, " in..." );
-      countdown( 3 );
-      uranium.write( isEqualTo );
+      writeln("Writer: will set uranium to the value ", isEqualTo, " in...");
+      countdown(3);
+      uranium.write(isEqualTo);
     }
   }
 
-  // sync vars have two states: empty and full.
-  // If you read an empty variable or write a full variable, you are waited
-  // until the variable is full or empty again
+// sync variables have two states: empty and full.
+// If you read an empty variable or write a full variable, you are waited
+// until the variable is full or empty again.
   var someSyncVar$: sync int; // varName$ is a convention not a law.
   sync {
     begin { // Reader task
-      writeln( "Reader: waiting to read." );
+      writeln("Reader: waiting to read.");
       var read_sync = someSyncVar$;
-      writeln( "Reader: value is ", read_sync );
+      writeln("Reader: value is ", read_sync);
     }
 
     begin { // Writer task
-      writeln( "Writer: will write in..." );
-      countdown( 3 );
+      writeln("Writer: will write in...");
+      countdown(3);
       someSyncVar$ = 123;
     }
   }
 
-  // single vars can only be written once. A read on an unwritten single results
-  // in a wait, but when the variable has a value it can be read indefinitely
+// single vars can only be written once. A read on an unwritten single
+// results in a wait, but when the variable has a value it can be read
+// indefinitely.
   var someSingleVar$: single int; // varName$ is a convention not a law.
   sync {
     begin { // Reader task
-      writeln( "Reader: waiting to read." );
+      writeln("Reader: waiting to read.");
       for i in 1..5 {
         var read_single = someSingleVar$;
-        writeln( "Reader: iteration ", i,", and the value is ", read_single );
+        writeln("Reader: iteration ", i,", and the value is ", read_single);
       }
     }
 
     begin { // Writer task
-      writeln( "Writer: will write in..." );
-      countdown( 3 );
+      writeln("Writer: will write in...");
+      countdown(3);
       someSingleVar$ = 5; // first and only write ever.
     }
   }
 
-  // Heres an example of using atomics and a synch variable to create a
-  // count-down mutex (also known as a multiplexer)
+// Heres an example using atomics and a sync variable to create a
+// count-down mutex (also known as a multiplexer).
   var count: atomic int; // our counter
   var lock$: sync bool;   // the mutex lock
 
-  count.write( 2 );       // Only let two tasks in at a time.
-  lock$.writeXF( true );  // Set lock$ to full (unlocked)
+  count.write(2);       // Only let two tasks in at a time.
+  lock$.writeXF(true);  // Set lock$ to full (unlocked)
   // Note: The value doesnt actually matter, just the state
   // (full:unlocked / empty:locked)
   // Also, writeXF() fills (F) the sync var regardless of its state (X)
 
   coforall task in 1..#5 { // Generate tasks
     // Create a barrier
-    do{
+    do {
       lock$;                 // Read lock$ (wait)
-    }while ( count.read() < 1 ); // Keep waiting until a spot opens up
+    } while (count.read() < 1); // Keep waiting until a spot opens up
 
     count.sub(1);          // decrement the counter
-    lock$.writeXF( true ); // Set lock$ to full (signal)
+    lock$.writeXF(true); // Set lock$ to full (signal)
 
     // Actual 'work'
-    writeln( "Task #", task, " doing work." );
-    sleep( 2 );
+    writeln("Task #", task, " doing work.");
+    sleep(2);
 
-    count.add( 1 );        // Increment the counter
-    lock$.writeXF( true ); // Set lock$ to full (signal)
+    count.add(1);        // Increment the counter
+    lock$.writeXF(true); // Set lock$ to full (signal)
   }
 
-  // we can define the operations + * & | ^ && || min max minloc maxloc
-  // over an entire array using scans and reductions
-  // Reductions apply the operation over the entire array and
-  // result in a single value
+// We can define the operations + * & | ^ && || min max minloc maxloc
+// over an entire array using scans and reductions.
+// Reductions apply the operation over the entire array and
+// result in a scalar value.
   var listOfValues: [1..10] int = [15,57,354,36,45,15,456,8,678,2];
   var sumOfValues = + reduce listOfValues;
   var maxValue = max reduce listOfValues; // 'max' give just max value
 
-  // 'maxloc' gives max value and index of the max value
-  // Note: We have to zip the array and domain together with the zip iterator
+// maxloc gives max value and index of the max value.
+// Note: We have to zip the array and domain together with the zip iterator.
   var (theMaxValue, idxOfMax) = maxloc reduce zip(listOfValues,
                                                   listOfValues.domain);
 
-  writeln( (sumOfValues, maxValue, idxOfMax, listOfValues[ idxOfMax ] ) );
+  writeln((sumOfValues, maxValue, idxOfMax, listOfValues[idxOfMax]));
 
-  // Scans apply the operation incrementally and return an array of the
-  // value of the operation at that index as it progressed through the
-  // array from array.domain.low to array.domain.high
+// Scans apply the operation incrementally and return an array with the
+// values of the operation at that index as it progressed through the
+// array from array.domain.low to array.domain.high.
   var runningSumOfValues = + scan listOfValues;
   var maxScan = max scan listOfValues;
-  writeln( runningSumOfValues );
-  writeln( maxScan );
+  writeln(runningSumOfValues);
+  writeln(maxScan);
 } // end main()
 ```
 
 Who is this tutorial for?
 -------------------------
 
-This tutorial is for people who want to learn the ropes of chapel without having to hear about what fiber mixture the ropes are, or how they were braided, or how the braid configurations differ between one another.
-It won't teach you how to develop amazingly performant code, and it's not exhaustive.
-Refer to the [language specification](http://chapel.cray.com/language.html) and the [module documentation](http://chapel.cray.com/docs/latest/) for more details.
+This tutorial is for people who want to learn the ropes of chapel without
+having to hear about what fiber mixture the ropes are, or how they were
+braided, or how the braid configurations differ between one another. It won't
+teach you how to develop amazingly performant code, and it's not exhaustive.
+Refer to the [language specification](http://chapel.cray.com/language.html) and
+the [module documentation](http://chapel.cray.com/docs/latest/) for more
+details.
 
-Occasionally check back here and on the [Chapel site](http://chapel.cray.com) to see if more topics have been added or more tutorials created.
+Occasionally check back here and on the [Chapel site](http://chapel.cray.com)
+to see if more topics have been added or more tutorials created.
 
 ### What this tutorial is lacking:
 
@@ -1061,12 +1141,14 @@ Occasionally check back here and on the [Chapel site](http://chapel.cray.com) to
 Your input, questions, and discoveries are important to the developers!
 -----------------------------------------------------------------------
 
-The Chapel language is still in-development (version 1.12.0), so there are occasional hiccups with performance and language features.
-The more information you give the Chapel development team about issues you encounter or features you would like to see, the better the language becomes.
-Feel free to email the team and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman).
+The Chapel language is still in-development (version 1.15.0), so there are
+occasional hiccups with performance and language features. The more information
+you give the Chapel development team about issues you encounter or features you
+would like to see, the better the language becomes. Feel free to email the team
+and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman).
 
-If you're really interested in the development of the compiler or contributing to the project,
-[check out the master Github repository](https://github.com/chapel-lang/chapel).
+If you're really interested in the development of the compiler or contributing
+to the project, [check out the master GitHub repository](https://github.com/chapel-lang/chapel).
 It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).
 
 Installing the Compiler
@@ -1076,12 +1158,15 @@ Chapel can be built and installed on your average 'nix machine (and cygwin).
 [Download the latest release version](https://github.com/chapel-lang/chapel/releases/)
 and it's as easy as
 
- 1. `tar -xvf chapel-1.12.0.tar.gz`
- 2. `cd chapel-1.12.0`
- 3. `make`
- 4. `source util/setchplenv.bash # or .sh or .csh or .fish`
+ 1. `tar -xvf chapel-1.15.0.tar.gz`
+ 2. `cd chapel-1.15.0`
+ 3. `source util/setchplenv.bash # or .sh or .csh or .fish`
+ 4. `make`
+ 5. `make check # optional`
 
-You will need to `source util/setchplenv.EXT` from within the Chapel directory (`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop that command in a script that will get executed on startup (like .bashrc).
+You will need to `source util/setchplenv.EXT` from within the Chapel directory
+(`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop
+that command in a script that will get executed on startup (like .bashrc).
 
 Chapel is easily installed with Brew for OS X
 
@@ -1097,7 +1182,10 @@ Builds like other compilers:
 
 Notable arguments:
 
- * `--fast`: enables a number of optimizations and disables array bounds checks. Should only enable when application is stable.
- * `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>` at compile-time.
- * `--main-module <Module Name>`: use the main() procedure found in the module `<Module Name>` as the executable's main.
+ * `--fast`: enables a number of optimizations and disables array bounds
+   checks. Should only enable when application is stable.
+ * `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>`
+   at compile-time.
+ * `--main-module <Module Name>`: use the main() procedure found in the module
+   `<Module Name>` as the executable's main.
  * `--module-dir <Directory>`: includes `<Directory>` in the module search path.
diff --git a/clojure-macros.html.markdown b/clojure-macros.html.markdown
index d74f77cf..89066faf 100644
--- a/clojure-macros.html.markdown
+++ b/clojure-macros.html.markdown
@@ -99,13 +99,13 @@ You'll want to be familiar with Clojure. Make sure you understand everything in
 (list x) ; -> (4)
 
 ;; You can use # within ` to produce a gensym for each symbol automatically
-(defmacro define-x-hygenically []
+(defmacro define-x-hygienically []
   `(do
      (def x# 2)
      (list x#)))
 
 (def x 4)
-(define-x-hygenically) ; -> (2)
+(define-x-hygienically) ; -> (2)
 (list x) ; -> (4)
 
 ;; It's typical to use helper functions with macros. Let's create a few to
diff --git a/clojure.html.markdown b/clojure.html.markdown
index 58e835c9..7830f228 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -289,6 +289,19 @@ keymap ; => {:a 1, :b 2, :c 3}
    (into []))    ;=> (into [] (filter odd? (map inc (range 10)))
                  ; Result: [1 3 5 7 9]
 
+; When you are in a situation where you want more freedom as where to
+; put the result of previous data transformations in an 
+; expression, you can use the as-> macro. With it, you can assign a
+; specific name to transformations' output and use it as a
+; placeholder in your chained expressions:
+
+(as-> [1 2 3] input
+  (map inc input);=> You can use last transform's output at the last position
+  (nth input 2) ;=>  and at the second position, in the same expression
+  (conj [4 5 6] input [8 9 10])) ;=> or in the middle !
+
+
+
 ; Modules
 ;;;;;;;;;;;;;;;
 
diff --git a/cmake.html.markdown b/cmake.html.markdown
new file mode 100644
index 00000000..45cf0585
--- /dev/null
+++ b/cmake.html.markdown
@@ -0,0 +1,176 @@
+---
+language: cmake
+contributors:
+    - ["Bruno Alano", "https://github.com/brunoalano"]
+filename: CMake
+---
+
+CMake is a cross-platform, open-source build system. This tool will allow you
+to test, compile and create packages of your source code.
+
+The problem that CMake tries to solve is the problem of Makefiles and
+Autoconfigure on cross-platforms (different make interpreters have different
+command) and the ease-of-use on linking 3rd party libraries.
+
+CMake is an extensible, open-source system that manages the build process in
+an operating system and compiler-independent manner. Unlike many
+cross-platform systems, CMake is designed to be used in conjunction with the
+native build environment. Simple configuration files placed in each source 
+directory (called CMakeLists.txt files) are used to generate standard build
+files (e.g., makefiles on Unix and projects/workspaces in Windows MSVC) which
+are used in the usual way.
+
+```cmake
+# In CMake, this is a comment
+
+# To run our code, we will use these steps:
+#  - mkdir build && cd build
+#  - cmake ..
+#  - make
+# 
+# With those steps, we will follow the best pratice to compile into a subdir
+# and the second line will request to CMake to generate a new OS-dependant
+# Makefile. Finally, run the native Make command.
+
+#------------------------------------------------------------------------------
+# Basic
+#------------------------------------------------------------------------------
+#
+# The CMake file MUST be named as "CMakeLists.txt".
+
+# Setup the minimum version required of CMake to generate the Makefile
+cmake_minimum_required (VERSION 2.8)
+
+# Raises a FATAL_ERROR if version < 2.8
+cmake_minimum_required (VERSION 2.8 FATAL_ERROR)
+
+# We setup the name for our project. After we do that, this will change some
+# directories naming convention generated by CMake. We can send the LANG of
+# code as second param
+project (learncmake C)
+
+# Set the project source dir (just convention)
+set( LEARN_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+set( LEARN_CMAKE_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} )
+
+# It's useful to setup the current version of our code in the build system
+# using a `semver` style
+set (LEARN_CMAKE_VERSION_MAJOR 1)
+set (LEARN_CMAKE_VERSION_MINOR 0)
+set (LEARN_CMAKE_VERSION_PATCH 0)
+
+# Send the variables (version number) to source code header
+configure_file (
+  "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
+  "${PROJECT_BINARY_DIR}/TutorialConfig.h"
+)
+
+# Include Directories
+# In GCC, this will invoke the "-I" command
+include_directories( include )
+
+# Where are the additional libraries installed? Note: provide includes
+# path here, subsequent checks will resolve everything else
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Conditions
+if ( CONDITION )
+  # Output!
+
+  # Incidental information
+  message(STATUS "My message")
+
+  # CMake Warning, continue processing
+  message(WARNING "My message")
+
+  # CMake Warning (dev), continue processing
+  message(AUTHOR_WARNING "My message")
+
+  # CMake Error, continue processing, but skip generation
+  message(SEND_ERROR "My message")
+
+  # CMake Error, stop processing and generation
+  message(FATAL_ERROR "My message")
+endif()
+
+if( CONDITION )
+
+elseif( CONDITION )
+
+else( CONDITION )
+
+endif( CONDITION )
+
+# Loops
+foreach(loop_var arg1 arg2 ...)
+  COMMAND1(ARGS ...)
+  COMMAND2(ARGS ...)
+  ...
+endforeach(loop_var)
+
+foreach(loop_var RANGE total)
+foreach(loop_var RANGE start stop [step])
+
+foreach(loop_var IN [LISTS [list1 [...]]]
+                    [ITEMS [item1 [...]]])
+
+while(condition)
+  COMMAND1(ARGS ...)
+  COMMAND2(ARGS ...)
+  ...
+endwhile(condition)
+
+
+# Logic Operations
+if(FALSE AND (FALSE OR TRUE))
+  message("Don't display!")
+endif()
+
+# Set a normal, cache, or environment variable to a given value.
+# If the PARENT_SCOPE option is given the variable will be set in the scope
+# above the current scope.
+# `set(<variable> <value>... [PARENT_SCOPE])`
+
+# How to reference variables inside quoted and unquoted arguments
+# A variable reference is replaced by the value of the variable, or by the
+# empty string if the variable is not set
+${variable_name}
+
+# Lists
+# Setup the list of source files
+set( LEARN_CMAKE_SOURCES 
+  src/main.c
+  src/imagem.c
+  src/pather.c
+)
+
+# Calls the compiler
+#
+# ${PROJECT_NAME} refers to Learn_CMake 
+add_executable( ${PROJECT_NAME} ${LEARN_CMAKE_SOURCES} )
+
+# Link the libraries
+target_link_libraries( ${PROJECT_NAME} ${LIBS} m )
+
+# Where are the additional libraries installed? Note: provide includes
+# path here, subsequent checks will resolve everything else
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Compiler Condition (gcc ; g++)
+if ( "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" )
+  message( STATUS "Setting the flags for ${CMAKE_C_COMPILER_ID} compiler" )
+  add_definitions( --std=c99 )
+endif()
+
+# Check for OS
+if( UNIX )
+    set( LEARN_CMAKE_DEFINITIONS
+        "${LEARN_CMAKE_DEFINITIONS} -Wall -Wextra -Werror -Wno-deprecated-declarations -Wno-unused-parameter -Wno-comment" )
+endif()
+```
+
+### More Resources
+
++ [cmake tutorial](https://cmake.org/cmake-tutorial/)
++ [cmake documentation](https://cmake.org/documentation/)
++ [mastering cmake](http://amzn.com/1930934319/)
diff --git a/coffeescript.html.markdown b/coffeescript.html.markdown
index 89a29677..2aae6966 100644
--- a/coffeescript.html.markdown
+++ b/coffeescript.html.markdown
@@ -6,15 +6,17 @@ contributors:
 filename: coffeescript.coffee
 ---
 
-CoffeeScript is a little language that compiles one-to-one into the equivalent JavaScript, and there is no interpretation at runtime.
-As one of the successors to JavaScript, CoffeeScript tries its best to output readable, pretty-printed and smooth-running JavaScript code, which works well in every JavaScript runtime.
+CoffeeScript is a little language that compiles one-to-one into the equivalent
+JavaScript, and there is no interpretation at runtime. As one of the successors
+to JavaScript, CoffeeScript tries its best to output readable, pretty-printed
+and smooth-running JavaScript code, which works well in every JavaScript runtime.
+It also attempts to try and make JavaScript more in line with the trends of many
+modern languages.
 
 See also [the CoffeeScript website](http://coffeescript.org/), which has a complete tutorial on CoffeeScript.
 
 ```coffeescript
-# CoffeeScript is a hipster language.
-# It goes with the trends of many modern languages.
-# So comments are like Ruby and Python, they use number symbols.
+# Comments are similar to Ruby and Python, using the hash symbol `#`
 
 ###
 Block comments are like these, and they translate directly to '/ *'s and '* /'s
diff --git a/coldfusion.html.markdown b/coldfusion.html.markdown
index 482612fe..97259f56 100644
--- a/coldfusion.html.markdown
+++ b/coldfusion.html.markdown
@@ -13,7 +13,7 @@ ColdFusion is a scripting language for web development.
 _**C**old**F**usion **M**arkup **L**anguage_  
 ColdFusion started as a tag-based language. Almost all functionality is available using tags.
 
-```html
+```cfm
 <em>HTML tags have been provided for output readability</em>
 
 <!--- Comments start with "<!---" and end with "--->" --->
@@ -232,7 +232,8 @@ ColdFusion started as a tag-based language. Almost all functionality is availabl
 <h1>Components</h1>
 
 <em>Code for reference (Functions must return something to support IE)</em>
-
+```
+```cfs
 <cfcomponent>
 	<cfset this.hello = "Hello" />
 	<cfset this.world = "world" />
diff --git a/crystal.html.markdown b/crystal.html.markdown
new file mode 100644
index 00000000..1449ff81
--- /dev/null
+++ b/crystal.html.markdown
@@ -0,0 +1,553 @@
+---
+language: crystal
+filename: learncrystal.cr
+contributors:
+    - ["Vitalii Elenhaupt", "http://veelenga.com"]
+    - ["Arnaud Fernandés", "https://github.com/TechMagister/"]
+
+---
+
+```crystal
+
+# This is a comment
+
+# Everything is an object
+nil.class  #=> Nil
+100.class  #=> Int32
+true.class #=> Bool
+
+# Falsey values are: nil, false and null pointers
+!nil   #=> true  : Bool
+!false #=> true  : Bool
+!0     #=> false : Bool
+
+# Integers
+
+1.class #=> Int32
+
+# Four signed integer types
+1_i8.class  #=> Int8
+1_i16.class #=> Int16
+1_i32.class #=> Int32
+1_i64.class #=> Int64
+
+# Four unsigned integer types
+1_u8.class  #=> UInt8
+1_u16.class #=> UInt16
+1_u32.class #=> UInt32
+1_u64.class #=> UInt64
+
+2147483648.class          #=> Int64
+9223372036854775808.class #=> UInt64
+
+# Binary numbers
+0b1101 #=> 13 : Int32
+
+# Octal numbers
+0o123 #=> 83 : Int32
+
+# Hexadecimal numbers
+0xFE012D #=> 16646445 : Int32
+0xfe012d #=> 16646445 : Int32
+
+# Floats
+
+1.0.class #=> Float64
+
+# There are two floating point types
+1.0_f32.class #=> Float32
+1_f32.class   #=> Float32
+
+1e10.class    #=> Float64
+1.5e10.class  #=> Float64
+1.5e-7.class  #=> Float64
+
+# Chars
+
+'a'.class #=> Char
+
+# Octal codepoint
+'\101' #=> 'A' : Char
+
+# Unicode codepoint
+'\u0041' #=> 'A' : Char
+
+# Strings
+
+"s".class #=> String
+
+# Strings are immutable
+s = "hello, "  #=> "hello, "        : String
+s.object_id    #=> 134667712        : UInt64
+s += "Crystal" #=> "hello, Crystal" : String
+s.object_id    #=> 142528472        : UInt64
+
+# Supports interpolation
+"sum = #{1 + 2}" #=> "sum = 3" : String
+
+# Multiline string
+"This is
+   multiline string"
+
+# String with double quotes
+%(hello "world") #=> "hello \"world\""
+
+# Symbols
+# Immutable, reusable constants represented internally as Int32 integer value.
+# They're often used instead of strings to efficiently convey specific,
+# meaningful values
+
+:symbol.class #=> Symbol
+
+sentence = :question?     # :"question?" : Symbol
+
+sentence == :question?    #=> true  : Bool
+sentence == :exclamation! #=> false : Bool
+sentence == "question?"   #=> false : Bool
+
+# Arrays
+
+[1, 2, 3].class         #=> Array(Int32)
+[1, "hello", 'x'].class #=> Array(Int32 | String | Char)
+
+# Empty arrays should specify a type
+[]               # Syntax error: for empty arrays use '[] of ElementType'
+[] of Int32      #=> [] : Array(Int32)
+Array(Int32).new #=> [] : Array(Int32)
+
+# Arrays can be indexed
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] : Array(Int32)
+array[0]                #=> 1               : Int32
+array[10]               # raises IndexError
+array[-6]               # raises IndexError
+array[10]?              #=> nil             : (Int32 | Nil)
+array[-6]?              #=> nil             : (Int32 | Nil)
+
+# From the end
+array[-1] #=> 5
+
+# With a start index and size
+array[2, 3] #=> [3, 4, 5]
+
+# Or with range
+array[1..3] #=> [2, 3, 4]
+
+# Add to an array
+array << 6  #=> [1, 2, 3, 4, 5, 6]
+
+# Remove from the end of the array
+array.pop #=> 6
+array     #=> [1, 2, 3, 4, 5]
+
+# Remove from the beginning of the array
+array.shift #=> 1
+array       #=> [2, 3, 4, 5]
+
+# Check if an item exists in an array
+array.includes? 3 #=> true
+
+# Special syntax for an array of string and an array of symbols
+%w(one two three) #=> ["one", "two", "three"] : Array(String)
+%i(one two three) #=> [:one, :two, :three]    : Array(Symbol)
+
+# There is a special array syntax with other types too, as long as
+# they define a .new and a #<< method
+set = Set{1, 2, 3} #=> [1, 2, 3]
+set.class          #=> Set(Int32)
+
+# The above is equivalent to
+set = Set(typeof(1, 2, 3)).new
+set << 1
+set << 2
+set << 3
+
+# Hashes
+
+{1 => 2, 3 => 4}.class   #=> Hash(Int32, Int32)
+{1 => 2, 'a' => 3}.class #=> Hash(Int32 | Char, Int32)
+
+# Empty hashes should specify a type
+{}                     # Syntax error
+{} of Int32 => Int32   # {}
+Hash(Int32, Int32).new # {}
+
+# Hashes can be quickly looked up by key
+hash = {"color" => "green", "number" => 5}
+hash["color"]        #=> "green"
+hash["no_such_key"]  #=> Missing hash key: "no_such_key" (KeyError)
+hash["no_such_key"]? #=> nil
+
+# Check existence of keys hash
+hash.has_key? "color" #=> true
+
+# Special notation for symbol and string keys
+{key1: 'a', key2: 'b'}     # {:key1 => 'a', :key2 => 'b'}
+{"key1": 'a', "key2": 'b'} # {"key1" => 'a', "key2" => 'b'}
+
+# Special hash literal syntax with other types too, as long as
+# they define a .new and a #[]= methods
+class MyType
+  def []=(key, value)
+    puts "do stuff"
+  end
+end
+
+MyType{"foo" => "bar"}
+
+# The above is equivalent to
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+# Ranges
+
+1..10                  #=> Range(Int32, Int32)
+Range.new(1, 10).class #=> Range(Int32, Int32)
+
+# Can be inclusive or exclusive
+(3..5).to_a  #=> [3, 4, 5]
+(3...5).to_a #=> [3, 4]
+
+# Check whether range includes the given value or not
+(1..8).includes? 2 #=> true
+
+# Tuples are a fixed-size, immutable, stack-allocated sequence of values of
+# possibly different types.
+{1, "hello", 'x'}.class #=> Tuple(Int32, String, Char)
+
+# Acces tuple's value by its index
+tuple = {:key1, :key2}
+tuple[1] #=> :key2
+tuple[2] #=> syntax error : Index out of bound
+
+# Can be expanded into multiple variables
+a, b, c = {:a, 'b', "c"}
+a #=> :a
+b #=> 'b'
+c #=> "c"
+
+# Procs represent a function pointer with an optional context (the closure data)
+# It is typically created with a proc litteral
+proc = ->(x : Int32) { x.to_s }
+proc.class # Proc(Int32, String)
+# Or using the new method
+Proc(Int32, String).new { |x| x.to_s }
+
+# Invoke proc with call method
+proc.call 10 #=> "10"
+
+# Control statements
+
+if true
+  "if statement"
+elsif false
+  "else-if, optional"
+else
+  "else, also optional"
+end
+
+puts "if as a suffix" if true
+
+# If as an expression
+a = if 2 > 1
+      3
+    else
+      4
+    end
+
+a #=> 3
+
+# Ternary if
+a = 1 > 2 ? 3 : 4 #=> 4
+
+# Case statement
+cmd = "move"
+
+action = case cmd
+  when "create"
+    "Creating..."
+  when "copy"
+    "Copying..."
+  when "move"
+    "Moving..."
+  when "delete"
+    "Deleting..."
+end
+
+action #=> "Moving..."
+
+# Loops
+index = 0
+while index <= 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+index = 0
+until index > 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# But the preferable way is to use each
+(1..3).each do |index|
+  puts "Index: #{index}"
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Variable's type depends on the type of the expression
+# in control statements
+if a < 3
+  a = "hello"
+else
+  a = true
+end
+typeof a #=> (Bool | String)
+
+if a && b
+  # here both a and b are guaranteed not to be Nil
+end
+
+if a.is_a? String
+  a.class #=> String
+end
+
+# Functions
+
+def double(x)
+  x * 2
+end
+
+# Functions (and all blocks) implicitly return the value of the last statement
+double(2) #=> 4
+
+# Parentheses are optional where the call is unambiguous
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Method arguments are separated by a comma
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# All methods have an implicit, optional block parameter
+# it can be called with the 'yield' keyword
+
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts "hello world" }
+
+# {
+# hello world
+# }
+
+
+# You can pass a block to a function
+# "&" marks a reference to a passed block
+def guests(&block)
+  block.call "some_argument"
+end
+
+# You can pass a list of arguments, which will be converted into an array
+# That's what splat operator ("*") is for
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# If a method returns an array, you can use destructuring assignment
+def foods
+    ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast #=> "pancake"
+dinner    #=> "quesadilla"
+
+# By convention, all methods that return booleans end with a question mark
+5.even? # false
+5.odd?  # true
+
+# And if a method ends with an exclamation mark, it does something destructive
+# like mutate the receiver. Some methods have a ! version to make a change, and
+# a non-! version to just return a new changed version
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald"  #=> "Donald Mifflin"
+company_name  #=> "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name  #=> "Donald Mifflin"
+
+
+# Define a class with the class keyword
+class Human
+
+  # A class variable. It is shared by all instances of this class.
+  @@species = "H. sapiens"
+
+  # type of name is String
+  @name : String
+
+  # Basic initializer
+  # Assign the argument to the "name" instance variable for the instance
+  # If no age given, we will fall back to the default in the arguments list.
+  def initialize(@name, @age = 0)
+  end
+
+  # Basic setter method
+  def name=(name)
+    @name = name
+  end
+
+  # Basic getter method
+  def name
+    @name
+  end
+
+  # The above functionality can be encapsulated using the attr_accessor method as follows
+  property :name
+
+  # Getter/setter methods can also be created individually like this
+  getter :name
+  setter :name
+
+  # A class method uses self to distinguish from instance methods.
+  # It can only be called on the class, not an instance.
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# Instantiate a class
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Let's call a couple of methods
+jim.species #=> "H. sapiens"
+jim.name #=> "Jim Halpert"
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.name #=> "Jim Halpert II"
+dwight.species #=> "H. sapiens"
+dwight.name #=> "Dwight K. Schrute"
+
+# Call the class method
+Human.say("Hi") #=> print Hi and returns nil
+
+# Variables that start with @ have instance scope
+class TestClass
+  @var = "I'm an instance var"
+end
+
+# Variables that start with @@ have class scope
+class TestClass
+  @@var = "I'm a class var"
+end
+# Variables that start with a capital letter are constants
+Var = "I'm a constant"
+Var = "can't be updated" # Already initialized constant Var
+
+# Class is also an object in crystal. So class can have instance variables.
+# Class variable is shared among the class and all of its descendants.
+
+# base class
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# derived class
+class Worker < Human
+end
+
+Human.foo   #=> 0
+Worker.foo  #=> 0
+
+Human.foo = 2 #=> 2
+Worker.foo    #=> 0
+
+Worker.foo = 3 #=> 3
+Human.foo   #=> 2
+Worker.foo  #=> 3
+
+module ModuleExample
+  def foo
+    "foo"
+  end
+end
+
+# Including modules binds their methods to the class instances
+# Extending modules binds their methods to the class itself
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => undefined method 'foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => undefined method 'foo' for Book
+
+
+# Exception handling
+
+# Define new exception
+class MyException < Exception
+end
+
+# Define another exception
+class MyAnotherException < Exception; end
+
+ex = begin
+   raise MyException.new
+rescue ex1 : IndexError
+  "ex1"
+rescue ex2 : MyException | MyAnotherException
+  "ex2"
+rescue ex3 : Exception
+  "ex3"
+rescue ex4 # catch any kind of exception
+  "ex4"
+end
+
+ex #=> "ex2"
+
+```
+
+## Additional resources
+
+- [Official Documentation](http://crystal-lang.org/)
diff --git a/cs-cz/brainfuck.html.markdown b/cs-cz/brainfuck.html.markdown
new file mode 100644
index 00000000..29abc21f
--- /dev/null
+++ b/cs-cz/brainfuck.html.markdown
@@ -0,0 +1,87 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnbrainfuck-cz.bf
+lang: cs-cz
+---
+
+Brainfuck (psaný bez kapitálek s vyjímkou začátku věty) je extrémně minimální 
+Turingovsky kompletní (ekvivalentní) programovací jazyk a má pouze 8 příkazů.
+
+Můžete si ho vyzkoušet přímo v prohlížeči s [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Jakýkoliv znak mimo "><+-.,[]" (bez uvozovek) je ignorován.
+
+Brainfuck je reprezentován jako pole, které má 30.000 buněk s počátkem v nule 
+a datovým ukazatelem na aktuální buňce.
+
+Můžeme využít těchto osm příkazů:
++ : Přičte k aktuální buňce jedničku.
+- : Odečte od aktuální buňky jedničku.
+> : Posune datový ukazatel na další buňku, která je napravo.
+< : Posune datový ukazatel na předchozí buňku, která je nalevo.
+. : Vytiskne ASCII hodnotu aktuální buňky (například 65 = 'A').
+, : Načte jeden znak do aktuální buňky.
+[ : Pokud je hodnota aktuální buňky nulová, přeskočí na buňku odpovídající ] .
+    Jinak skočí na další instrukci.
+] : Pokud je hodnota aktuální buňky nulova, přeskočí na další instrukci.
+    Jinak skočí zpět na instrukci odpovídající [ .
+
+[ a ] tak tvoří 'while' smyčku a tyto symboly musí tak být v páru.
+
+Pojďme se mrknout na některé brainfuck programy.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Tento program vypíše písmeno 'A' (v ASCII je to číslo 65). Nejdříve navýší 
+buňku #1 na hodnotu 6. Buňka #1 bude použita pro smyčku. Potom program vstoupí 
+do smyčky ([) a sníží hodnotu buňky #1 o jedničku. Ve smyčce zvýší hodnotu 
+buňky #2 desetkrát, vrátí ze zpět na buňku #1 a sníží její hodnotu o jedničku.
+Toto se stane šestkrát (je potřeba šestkrát snížit hodnotu buňky #1, aby byla 
+nulová a program přeskočil na konec cyklu označený znakem ].
+
+Na konci smyčky, kdy jsme na buňce #1 (která má hodnotu 0), tak má buňka #2 
+hodnotu 60. Přesuneme se na buňku #2 a pětkrát zvýšíme její hodnotu o jedničku 
+na hodnotu 65. Na konci vypíšeme hodnotu buňky #2 - 65, což je v ASCII znak 'A' 
+na terminálu.
+
+
+, [ > + < - ] > .
+
+Tento program přečte znak z uživatelského vstupu a zkopíruje ho do buňky #1.
+Poté začne smyčka - přesun na buňku #2, zvýšení hodnoty buňky #2 o jedničku,
+přesun zpět na buňku #1 a snížení její hodnoty o jedničku. Takto smyčka pokračuje
+do té doby, než je buňka #1 nulová a buňka #2 nabyde původní hodnotu buňky #1. 
+Protože jsme na buňce #1, přesuneme se na buňku #2 a vytiskneme její hodnotu 
+v ASCII.
+
+Je dobré vědět, že mezery jsou v programu uvedené pouze z důvodu čitelnosti. 
+Program je možné klidně zapsat i takto:
+
+,[>+<-]>.
+
+
+Nyní se podívejte na tento program a zkuste zjistit co dělá: 
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Tento program vezme dvě čísla ze vstupu a vynásobí je.
+
+Program nejdříve načte dvě vstupní hodnoty. Poté začíná smyčka řízená hodnotou
+v buňce #1 - přesun na buňku #2 a start druhé vnořené smyčky, která je řízená 
+hodnotou v buňce #2 a zvyšuje hodnotu v buňce #3. Nicméně je zde problém 
+kdy na konci vnitřní smyčky je v buňce #2 nula a smyčka by tak znovu 
+napokračovala. Vyřešíme to tak, že zvyšujeme o jedničku i buňku #4 a její 
+hodnotu poté překopírujeme do buňky #2. Na konci programu je v buňce #3 
+výsledek.
+```
+
+A to je brainbuck. Zase tak složitý není, co? Zkuste si nyní napsat nějaký
+vlastní brainfuck program a nebo interpretr v jiném jazyce, což není zase
+tak složité, ale pokud jste opravdový masochista, zkuste si naprogramovat
+interpretr jazyka brainfuck v jazyce... brainfuck :)
diff --git a/cs-cz/css.html.markdown b/cs-cz/css.html.markdown
new file mode 100644
index 00000000..54a0a08e
--- /dev/null
+++ b/cs-cz/css.html.markdown
@@ -0,0 +1,253 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+lang: cs-cz
+filename: learncss-cz.css
+---
+
+V ranných dobách webu se nevyskytovaly žádné vizuální elementy, pouze čistý text, ale s vývojem webových browserů se staly stránky plné grafických prvků běžné.
+
+A právě proto vzniklo CSS, aby oddělilo obsah (HTML) od vzhledu webové stránky.
+
+Pomocí CSS můžete označit různé elementy na HTML stránce a přiřadit jim různé vzhledové vlastnosti.
+
+Tento návod byl napsán pro CSS 2, avšak CSS 3 se stalo velmi oblíbené a v dnešní době už běžné.
+
+**POZNÁMKA** Protože CSS produkuje vizuální výsledky, je nutné k jeho naučení všechno zkoušet třeba na [dabbletu](http://dabblet.com/).
+Tento článek se zaměřuje hlavně na syntaxi a poskytue také pár obecných tipů.
+
+```css
+/* komentáře jsou ohraničeny lomítkem s hvězdičkou, přesně jako tyto dva
+   řádky, v CSS není nic jako jednořádkový komentář, pouze tenhle zápis   */
+
+/* ################
+   ## SELEKTORY
+   ################ */
+
+/* Selektor se používá pro vybrání elementu na stránce:
+selektor { vlastnost: hodnota; /* více vlastností...  }*/
+
+/*
+Toto je náš element:
+<div trida='trida1 trida2' id='nejakeID' attr='hodnota' otherAttr='cs-cz co neco' />
+*/
+
+/* Můžeme vybrat tento element třeba podle jeho třídy */
+.trida1 { }
+
+/* nebo obou tříd! */
+.trida1.trida2 { }
+
+/* nebo jeho jména */
+div { }
+
+/* nebo jeho id */
+#nejakeID { }
+
+/* nebo podle toho, že má atribut! */
+[attr] { font-size:smaller; }
+
+/* nebo že argument nabývá specifické hodnoty*/
+[attr='hodnota'] { font-size:smaller; }
+
+/* začíná nějakou hodnotou (CSS 3) */
+[attr^='ho'] { font-size:smaller; }
+
+/* nebo končí něčím (CSS 3) */
+[attr$='ta'] { font-size:smaller; }
+
+/* nebo obsahuje nějakou hodnotu, která je v atributu oddělená mezerami */
+[otherAttr~='co'] { }
+[otherAttr~='neco'] { }
+
+/* nebo obsahuje hodnotu oddělenou pomlčkou - "-" (U+002D) */
+[otherAttr|='cs'] { font-size:smaller; }
+
+
+/* Můžeme spojit různé selektory, abychom získali specifičtější selektor.
+   Pozor, nedávejte mezi ně mezery! */
+div.nejaka-trida[attr$='ta'] { }
+
+/* Můžeme vybrat element, který je potomek jineho */
+div.vnejsi-element > .jmeno-tridy { }
+
+/* nebo zanořen ještě hlouběji. Potomci jsou přímo pod vnější třídou, pouze 1
+   úroveň pod rodičem. Tento selektor bude fungovat na jakékoliv úrovni pod
+   rodičem */
+div.rodic .jmeno-tridy { }
+
+/* Varování: stejný selektor bez mezery má úplně jiný význam
+   Vzpomínáte si jaký? */
+div.rodic.jmeno-tridy { }
+
+/* Možná budete chtít vybrat element, který leží přímo vedle */
+.jsem-primo-pred + .timto-elementem { }
+
+/* nebo kdekoliv na stejné úrovni stromu */
+.jsem-kdekoliv-pred ~ .timto-elementem { }
+
+/* Existují selektory nazvané pseudo třídy, kterými můžeme vybrat elementy,
+   když jsou v určitém stavu */
+
+/* na příklad, když kurzor najede na element */
+selektor:hover { }
+
+/* nebo již navštívený odkaz */
+selektor:visited { }
+
+/* nebo nebyl navštíven */
+selektor:link { }
+
+/* nebo když je vybrán, např kliknutím do inputu*/
+selektor:focus { }
+
+/* element, ktery je prvni potomek rodiče */
+selektor:first-child {}
+
+/* element, který je poslední potomek rodiče */
+selektor:last-child {}
+
+/* Stejně jako pseudo třídy, umožňují pseudo elementy stylizovat určité
+   části dokumentu */
+
+/* odpovídá virtuálnímu prvnímu potomku */
+selektor::before {}
+
+/* odpovídá virtuálnímu poslednímu potomku */
+selektor::after {}
+
+/* Na vhodném místě, může být použitá hvězdička jako žolík, který vybere každý element */
+* { } /* všechny elementy */
+.rodic * { } /* všechny vnořené elementy */
+.rodic > * { } /* všichni potomci */
+
+/* ####################
+   ## VLASTNOSTI
+   #################### */
+
+selektor {
+
+    /* Jednotky délky můžou být relativní nebo absolutní */
+
+    /* Relativní jednotky */
+    width: 50%;       /* počet procent šířky rodičovského elementu */
+    font-size: 2em;   /* násobek puvodní velikosti fontu elementu */
+    font-size: 2rem;  /* nebo kořenového elementu */
+    font-size: 2vw;   /* násobek 1% šířky zařízení (viewport) (CSS 3) */
+    font-size: 2vh;   /* nebo jeho výšky */
+    font-size: 2vmin; /* násobek 1% výšky nebo šířky, dle toho, co je menší */
+    font-size: 2vmax; /* nebo větší */
+
+    /* Absolutní jednotky */
+    width: 200px;     /* pixely */
+    font-size: 20pt;  /* body */
+    width: 5cm;       /* centimetry */
+    min-width: 50mm;  /* milimetry */
+    max-width: 5in;   /* palce */
+
+    /* Barvy */
+    color: #F6E;                 /* krátký hexadecimální formát */
+    color: #FF66EE;              /* dlouhý hexadecimální formát */
+    color: tomato;               /* pojmenovaná barva */
+    color: rgb(255, 255, 255);   /* hodnoty rgb */
+    color: rgb(10%, 20%, 50%);   /* procenta rgb */
+    color: rgba(255, 0, 0, 0.3); /* hodnoty rgba (CSS 3) Poznámka: 0 < a < 1 */
+    color: transparent;          /* ekvivalentní jako nastavení alfy 0 */
+    color: hsl(0, 100%, 50%);    /* procenta hsl (CSS 3) */
+    color: hsla(0, 100%, 50%, 0.3); /* procenta hsl s alfou */
+
+    /* Obrázky jako pozadí elementu */
+    background-image: url(/cesta/k/obrazku.jpg); /* uvozovky jsou dobrovolné */
+
+    /* Fonty */
+    font-family: Arial;
+    /* když název fontu obsahuje mezeru, tak musí být v uvozovkách */
+    font-family: "Courier New";
+    /* když se první nenaleze, použije se další atd. */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+}
+```
+
+## Použití
+
+Uložte CSS soubor s příponou `.css`.
+
+```xml
+<!-- Musíte vložit css soubor do hlavičky vaší stránky. Toto je
+     doporučená metoda. Viz http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='cesta/k/stylu.css' />
+
+<!-- Také lze vložit CSS přímo do HTML. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Nebo přímo nastavit vlasnost elementu -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Priorita nebo kaskáda
+
+Element může být vybrán více selektory a jeho vlastnosti můžou být nastaveny více než jednou. V těchto případech, má jedno zadání vlastnosti prioritu před druhým. Obecně platí, že více specifické selektory mají přednost před těmi méně specifickými.
+
+Tento proces se nazývá kaskáda, proto i název kaskádové styly(Cascading Style Sheets).
+
+Máme následující CSS
+
+```css
+/* A */
+p.trida1[attr='hodnota']
+
+/* B */
+p.trida1 { }
+
+/* C */
+p.trida2 { }
+
+/* D */
+p { }
+
+/* E */
+p { vlastnost: hodnota !important; }
+```
+
+a tento element
+```xml
+<p style='/*F*/ vlastnost:hodnota;' trida='trida1 trida2' attr='hodnota' />
+```
+Priorita stylu je následující. Pamatujte, priorita pro každou **vlastnost**, ne pro celý blok.
+
+* `E` má nejvyšší prioritu kvůli slůvku `!important`. Je doporučováno se úplně vyhnout jeho použití.
+* `F` je další, kvůli stylu zadanému přimo do elementu
+* `A` je další, protože je více specifické, než cokoliv dalšího. Má 3 selektory: jméno elementu `p`, jeho třídu `trida1`, atribut `attr='hodnota'`.
+* `C` je další, i když je stejně specifický jako `B`, protože je uveden až po něm.
+* `B` je další
+* `D` je poslední
+
+## Kompatibilita
+
+Většina z možností v CSS 2 (a spousta v CSS 3) je dostupná napříč všemi browsery a zařízeními. Ale pořád je dobrá praxe, zkontrolovat dostupnost, před užitím nové vlastnosti/fičury.
+
+## Zdroje
+
+* Přehled dostupnosti [CanIUse](http://caniuse.com).
+* CSS hřiště [Dabblet](http://dabblet.com/).
+* [Mozilla Developer Network - CSS dokumentace](https://developer.mozilla.org/en-US/docs/Web/CSS)
+* [Codrops](http://tympanus.net/codrops/css_reference/)
+
+## Další čtení
+
+* [Pochopení priority v CSS: specifičnost, děditelnost a kaskáda](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [Vybírání elementů pomocí atributů](https://css-tricks.com/almanac/selectors/a/attribute/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - překrývání obsahu](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+* [SASS](http://sass-lang.com/) a [LESS](http://lesscss.org/) pro CSS pre-processing
+* [CSS-Triky](https://css-tricks.com)
diff --git a/cs-cz/elm.html.markdown b/cs-cz/elm.html.markdown
new file mode 100644
index 00000000..f19f9e8b
--- /dev/null
+++ b/cs-cz/elm.html.markdown
@@ -0,0 +1,373 @@
+---
+language: Elm
+contributors:
+    - ["Max Goldstein", "http://maxgoldste.in/"]
+translators:
+    - ["Robin Pokorný", "http://robinpokorny.com/"]
+filename: learnelm-cz.elm
+lang: cs-cz
+---
+
+Elm je funkcionální reaktivní jazyk, který se kompiluje do (klientského) JavaScriptu.
+Elm je silně typovaný, díky tomu je překladač schopen zachytit většinu chyb okamžitě a
+vypsat snadno srozumitelná chybová hlášení.
+Elm se hodí k tvorbě webových uživatelských rozhraní a her.
+
+
+```haskell
+-- Jednořádkové komentáře začínají dvěma pomlčkami.
+{- Víceřádkové komentáře mohou být takto uzavřeny do bloku.
+{- Mohou být i zanořeny. -}
+-}
+
+{-- Základy --}
+
+-- Aritmetika
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+
+-- Každé číslo bez desetinné tečky je typu Int nebo Float.
+33 / 2 -- 16.5 s reálným dělením
+33 // 2 -- 16 s celočíselným dělením
+
+-- Umocňování
+5 ^ 2 -- 25
+
+-- Pravdivostní proměnné
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Řetězce a znaky
+"Toto je textový řetězec, protože používá dvojité uvozovky."
+'a' -- znak v jednoduchých uvozovkách
+
+-- Řetězce lze spojovat.
+"Ahoj " ++ "světe!" -- "Ahoj světe!"
+
+{-- Seznamy (List), n-tice (Tuple) a Záznamy (Record) --}
+
+-- Každá položka seznamu musí být stejného typu.
+["příliš", "žluťoučký", "kůň", "úpěl"]
+[1, 2, 3, 4, 5]
+-- Druhý příklad lze zapsat také pomocí dvou teček.
+List.range 1 5
+
+-- Spojovat seznamy lze stejně jako řetězce.
+List.range 1 5 ++ List.range 6 10 == List.range 1 10 -- True
+
+-- K přidání položky do seznamu použijte funkci "cons".
+0 :: List.range 1 5 -- [0, 1, 2, 3, 4, 5]
+
+-- Funkce "head" pro získání první položky seznamu i funkce "tail" pro získání následujích položek
+-- vrací typ Maybe. Místo zjišťování, jestli nějaká položka není null,
+-- se s chybějcími hodnotami vypořádáme explicitně.
+List.head (List.range 1 5) -- Just 1
+List.tail (List.range 1 5) -- Just [2, 3, 4, 5]
+List.head [] -- Nothing
+-- List.nazevFunkce odkazuje na funkci, která žije v modulu List.
+
+-- Každý prvek v n-tici může být jiného typu, ale n-tice má pevný počet prvků.
+("elm", 42)
+
+-- K získání hodnot z dvojice použijte funkce first a second.
+-- (Toto je pouze zkratka. Brzy si ukážeme, jak na to "správně".)
+fst ("elm", 42) -- "elm"
+snd ("elm", 42) -- 42
+
+-- Prázná n-tice, neboli "unit", se občas používá jako zástupný symbol.
+-- Je to jediná hodnota svého typu, který se také nazývá "Unit".
+()
+
+-- Záznamy jsou podobné n-ticím, ale prvky jsou pojmenovány. Na pořadí nezáleží.
+-- Povšimněte si, že hodnoty vlastností se přiřazují rovnítky, ne dvojtečkami.
+{ x = 3, y = 7 }
+
+-- K hodnotám se přistupuje pomocí tečky a názvu vlastnosti.
+{ x = 3, y = 7 }.x -- 3
+
+-- Nebo využitím přístupové funkce, což je jen tečka a název vlastnosti.
+.y { x = 3, y = 7 } -- 7
+
+-- Změna hodnoty vlastnosti v záznamu. (Záznam tuto vlastnost už musí mít.)
+{ osoba |
+  jmeno = "Jiří" }
+
+-- Změna více vlastností s využitím aktuálních hodnot.
+{ hmotnyBod |
+  poloha = hmotnyBod.poloha + hmotnyBod.rychlost,
+  rychlost = hmotnyBod.rychlost + hmotnyBod.zrychleni }
+
+{-- Řídicí struktury --}
+
+-- Podmínky vždy musí mít větev "else" a obě větve musí být stejného typu.
+if powerLevel > 9000 then
+  "PÁNI!"
+else
+  "hmm"
+
+-- Podmínky lze skládat za sebe.
+if n < 0 then
+  "n je záporné"
+else if n > 0 then
+  "n je kladné"
+else
+  "n je nula"
+
+-- Použíjte příkaz "case" k nalezení shody vzoru a různých možností.
+case seznam of
+  [] -> "odpovídá práznému seznamu"
+  [x]-> "odpovídá seznamu o právě jedné položce, " ++ toString x
+  x::xs -> "odpovídá seznamu o alespoň jedné položce, jehož prvním prvkem je " ++ toString x
+-- Shody se vyhodnocují v zapsaném pořadí. Kdybychom umístili [x] poslední, nikdy by nenastala shoda,
+-- protože x::xs také odpovídá  (xs by byl prázdný seznam). Shody "nepropadají".
+-- Překladač vždy upozorní na chybějící nebo přebývající větve.
+
+-- Větvení typu Maybe.
+case List.head seznam of
+  Just x -> "První položka je " ++ toString x
+  Nothing -> "Seznam byl prázdný."
+
+{-- Funkce --}
+
+-- Syntaxe funkcí je v Elmu velmi úsporná, založená spíše na mezerách
+-- než na závorkách. Neexistuje tu klíčové slovo "return".
+
+-- Funkci definujeme jejím jménem, parametry, rovnítkem a tělem.
+vynasob a b =
+  a * b
+
+-- Funkci voláme předáním parametrů (bez oddělujících čárek).
+vynasob 7 6 -- 42
+
+-- Částečně aplikované funkci předáme pouze některé parametry.
+-- Poté zvolíme nové jméno.
+zdvoj =
+  vynasob 2
+
+-- Konstanty jsou podobné, ale nepřijímají žádné parametry.
+odpoved =
+  42
+
+-- Předejte funkci jako parametr jiným funkcím.
+List.map zdvoj (List.range 1 4) -- [2, 4, 6, 8]
+
+-- Nebo použijte anonymní funkci.
+List.map (\a -> a * 2) (List.range 1 4) -- [2, 4, 6, 8]
+
+-- V definici funkce lze zapsat vzor, může-li nastat pouze jeden případ.
+-- Tato funkce přijímá jednu dvojici místo dvou parametrů.
+obsah (sirka, delka) =
+  sirka * delka
+
+obsah (6, 7) -- 42
+
+-- Složenými závorkami vytvořte vzor pro názvy vlastností v záznamu.
+-- Použijte "let" k definici lokálních proměnných.
+objem {sirka, delka, hloubka} =
+  let
+    obsah = sirka * delka
+  in
+    obsah * hloubka
+
+objem { sirka = 3, delka = 2, hloubka = 7 } -- 42
+
+-- Funkce mohou být rekurzivní.
+fib n =
+  if n < 2 then
+    1
+  else
+    fib (n - 1) + fib (n - 2)
+
+List.map fib (List.range 0 8) -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+-- Jiná rekurzivní funkce (v praxi použijte List.length).
+delkaSeznamu seznam =
+  case seznam of
+    [] -> 0
+    x::xs -> 1 + delkaSeznamu xs
+
+-- Funkce se volají před jakýmkoli infixovým operátorem. Závorky určují prioritu.
+cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
+-- Nejprve se aplikuje "degrees" na číslo 30, výsledek je pak předán trigonometrickým
+-- funkcím, které jsou následně umocněny na druhou, na závěr proběhne sčítání.
+
+{-- Typy a typové anotace --}
+
+-- Překladač odvodí typ každé hodnoty ve vašem programu.
+-- Typy vždy začínají velkým písmenem. Čtete x : T jako "x je typu T".
+-- Některé běžné typy, které můžete videt v Elmovém REPLu.
+5 : Int
+6.7 : Float
+"ahoj" : String
+True : Bool
+
+-- Funkce mají také typy. Čtěte "->" jako "vrací".
+-- O typu na konci uvažujte jako návratovém typu, o ostatních jako typech argumentů.
+not : Bool -> Bool
+round : Float -> Int
+
+-- Když definujete hodnotu, je dobrým zvykem zapsat nad ni její typ.
+-- Anotace je formou dokumentace, která je ověřována překladačem.
+zdvoj : Int -> Int
+zdvoj x = x * 2
+
+-- Funkce jako parametr je uzavřena v závorkách.
+-- Typy s malým počátečním písmenem jsou typové proměnné:
+-- mohou být libovolného typu, ale v každém volání musí být stejné.
+List.map : (a -> b) -> List a -> List b
+-- "List tečka map je typu a-vrací-b, vrací seznam-položek-typu-a, vrací seznam-položek-typu-b."
+
+-- Existují tři speciální typové proměnné:
+-- číslo (number), porovnatelné (comparable), and spojitelné (appendable).
+-- Čísla dovolují použít aritmetiku na Int a Float.
+-- Porovnatelné dovolují uspořádat čísla a řetězce, např. a < b.
+-- Spojitelné lze zřetězit pomocí a ++ b.
+
+{-- Typové aliasy a výčtové typy --}
+
+-- Pro záznamy a n-tice již typy automaticky existují.
+-- (Povšimněte si, že typ vlatnosti záznamu přiřazujeme dvojtečkou a hodnotu rovnítkem.)
+pocatek : { x : Float, y : Float, z : Float }
+pocatek =
+  { x = 0, y = 0, z = 0 }
+
+-- Stávajícím typům lze dávat jména využitím aliasů.
+type alias Bod3D =
+  { x : Float, y : Float, z : Float }
+
+-- Alias pro záznam funguje také jako jeho konstruktor.
+jinyPocatek : Bod3D
+jinyPocatek =
+  Bod3D 0 0 0
+
+-- Jedná se stále o stejný typ, lze je tedy porovnat.
+pocatek == jinyPocatek -- True
+
+-- Oproti tomu výčtový (union) typ definuje zcela nový typ.
+-- Výčtový typ se takto jmenuje, protože může být jedním z několika vybraných možností.
+-- Každá možnost je reprezentována jako "tag".
+type Smer =
+  Sever | Jih | Vychod | Zapad
+
+-- Tagy mohou obsahovat další hodnoty známých typů. Lze využít i rekurze.
+type IntStrom =
+  Vrchol | Uzel Int IntStrom IntStrom
+-- "Vrchol" i "Uzel" jsou tagy. Vše, co následuje za tagem, je typ.
+
+-- Tagy lze použít jako hodnoty funkcí.
+koren : IntStrom
+koren =
+  Vrchol 7 List List
+
+-- Výčtové typy (a typové aliasy) mohou obsahovat typové proměnné.
+type Strom a =
+  Vrchol | Uzel a (Strom a) (Strom a)
+-- "Typ strom-prvků-a je vrchol, nebo uzel obsahující a, strom-prvků-a a strom-prvků-a."
+
+-- Vzory se shodují s tagy. Tagy s velkým počátečním písmenem odpovídají přesně.
+-- Proměnné malým písmem odpovídají čemukoli. Podtržítko také odpovídá čemukoli,
+-- ale určuje, že tuto hodnotu dále nechceme používat.
+nejviceVlevo : Strom a -> Maybe a
+nejviceVlevo strom =
+  case strom of
+    Vrchol -> Nothing
+    Uzel x Vrchol _ -> Just x
+    Uzel _ podstrom _ -> nejviceVlevo podstrom
+
+-- To je víceméně vše o jazyku samotném.
+-- Podívejme se nyní, jak organizovat a spouštět náš kód.
+
+{-- Moduly a importování --}
+
+-- Standardní knihovny jsou organizovány do modulů, stejně jako knihovny třetích stran,
+-- které můžete využívat. Ve větších projektech můžete definovat vlastní moduly.
+
+-- Vložte toto na začátek souboru. Pokud nic neuvedete, předpokládá se "Main".
+module Jmeno where
+
+-- Výchozím chováním je, že se exportuje vše.
+-- Případně můžete definovat exportované vlastnosti explicitně.
+module Jmeno (MujTyp, mojeHodnota) where
+
+-- Běžný návrhový vzor je expotovat pouze výčtový typ bez jeho tagů.
+-- Tento vzor je znám jako krycí typ a často se využívá v knihovnách.
+
+-- Z jiných modulů lze importovat kód a použít jej v aktuálním modulu.
+-- Nasledující umístí Dict do aktuálního scope, takže lze volat Dict.insert.
+import Dict
+
+-- Importuje modul Dict a typ Dict, takže v anotacích není nutné psát Dict.Dict.
+-- Stále lze volat Dict.insert.
+import Dict exposing (Dict)
+
+-- Přejmenování importu.
+import Graphics.Collage as C
+
+{-- Porty --}
+
+-- Port oznamuje, že budete komunikovat s vnějším světem.
+-- Porty jsou dovoleny pouze v modulu Main.
+
+-- Příchozí port je jen typová anotace.
+port idKlienta : Int
+
+-- Odchozí port má definici.
+port objednavkaKlienta : List String
+port objednavkaKlienta = ["Knihy", "Potraviny", "Nábytek"]
+
+-- Nebudeme zacházet do detailů, ale v JavaScriptu se dají nastavit
+-- callbacky pro zasílání na příchozí porty a čtení z odchozích portů.
+
+{-- Nástroje pro příkazovou řádku --}
+
+-- Kompilace souboru.
+$ elm make MujSoubor.elm
+
+-- Při prvním spuštění nainstaluje Elm standardní knihovny a vytvoří soubor
+-- elm-package.json, kde jsou uloženy informace o vašem projektu.
+
+-- Elm reactor je server, který překládá a spouští vaše soubory.
+-- Kliknutím na klíč vedle názvu souboru spustíte debugger s cestovám v čase!
+$ elm reactor
+
+-- Zkoušejte si jednoduché příkazy v Read-Eval-Print Loop.
+$ elm repl
+
+-- Balíčky jsou určeny uživatelským jménem na GitHubu a názvem repozitáře.
+-- Nainstalujte nový balíček a uložte jej v souboru elm-package.json.
+$ elm package install evancz/elm-lang/html
+
+-- Porovnejte změny mezi verzemi jednoho balíčku.
+$ elm package diff elm-lang/html 1.1.0 2.0.0
+-- Správce balíčků v Elmu vyžaduje sémantické verzování,
+-- takže minor verze nikdy nerozbije váš build.
+```
+
+Jazyk Elm je překvapivě malý. Nyní se můžete podívat do skoro jakéhokoli zdrojového kódu
+v Elmu a budete mít zběžnou představu o jeho fungování.
+Ovšem možnosti, jak psát kód, který je odolný vůči chybám a snadno se refaktoruje, jsou neomezené!
+
+Zde jsou některé užitečné zdroje (v angličtině).
+
+* [Hlavní stránka Elmu](http://elm-lang.org/). Obsahuje:
+  * Odkazy na [instalátory](http://elm-lang.org/install)
+  * [Documentaci](http://elm-lang.org/docs), včetně [popisu syntaxe](http://elm-lang.org/docs/syntax)
+  * Spoustu nápomocných [příkladů](http://elm-lang.org/examples)
+
+* Documentace pro [standardní knihovny Elmu](http://package.elm-lang.org/packages/elm-lang/core/latest/). Povšimněte si:
+  * [Základy](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), které jsou automaticky importovány
+  * Typ [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) a jeho bratranec typ [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), které se běžně používají pro chybějící hodnoty a ošetření chyb.
+  * Datové struktury jako [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) a [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set)
+  * JSON [enkódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) a [dekódování](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode)
+
+* [Architektura Elmu](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Esej od tvůrce Elmu s příklady, jak organizovat kód do komponent.
+
+* [Elm mailing list](https://groups.google.com/forum/#!forum/elm-discuss). Všichni jsou přátelští a nápomocní.
+
+* [Scope v Elmu](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) a [Jak číst typové anotace](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Další komunitní návody o základech Elmu, psáno pro JavaScriptové vývojáře.
+
+Běžte si zkusit něco napsat v Elmu!
diff --git a/cs-cz/go.html.markdown b/cs-cz/go.html.markdown
new file mode 100644
index 00000000..36217414
--- /dev/null
+++ b/cs-cz/go.html.markdown
@@ -0,0 +1,431 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo-cs.go
+lang: cs-cz
+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"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
+translators:
+    - ["Ondra Linek", "https://github.com/defectus/"]
+---
+
+Jazyk Go byl vytvořen, jelikož bylo potřeba dokončit práci. Není to poslední 
+trend ve světě počítačové vědy, ale je to nejrychlejší a nejnovější způsob,
+jak řešit realné problémy.
+
+Go používá známé koncepty imperativních jazyků se statickým typováním.
+Rychle se kompiluje a také rychle běží. Přidává snadno pochopitelnou
+podporu konkurenčnosti, což umožňuje využít výhody multi-core procesorů a
+jazyk také obsahuje utility, které pomáhají se škálovatelným programováním.
+
+Go má již v základu vynikající knihovnu a je s ním spojená nadšená komunita.
+
+```go
+// Jednořádkový komentář
+/* Několika
+ řádkový komentář */
+
+// Každý zdroják začíná deklarací balíčku (package)
+// Main je vyhrazené jméno, které označuje spustitelný soubor,
+// narozdíl od knihovny
+package main
+
+// Importní deklarace říkají, které knihovny budou použity v tomto souboru.
+import (
+	"fmt"       // Obsahuje formátovací funkce a tisk na konzolu
+	"io/ioutil" // Vstupně/výstupní funkce
+	m "math"    // Odkaz na knihovnu math (matematické funkce) pod zkratkou m
+	"net/http"  // Podpora http protokolu, klient i server.
+	"strconv"   // Konverze řetězců, např. na čísla a zpět.
+)
+
+// Definice funkce. Funkce main je zvláštní, je to vstupní bod do programu.
+// Ať se vám to líbí, nebo ne, Go používá složené závorky
+func main() {
+	// Println vypisuje na stdout.
+	// Musí být kvalifikováno jménem svého balíčko, ftm.
+	fmt.Println("Hello world!")
+
+	// Zavoláme další funkci
+	svetPoHello()
+}
+
+// Funkce mají své parametry v závorkách
+// Pokud funkce nemá parametry, tak musíme stejně závorky uvést.
+func svetPoHello() {
+	var x int // Deklarace proměnné. Proměnné musí být před použitím deklarované
+	x = 3     // Přiřazení hodnoty do proměnné
+	// Existuje "krátká" deklarace := kde se typ proměnné odvodí, 
+	// proměnná vytvoří a přiřadí se jí hodnota
+	y := 4
+	sum, prod := naucSeNasobit(x, y)        // Funkce mohou vracet více hodnot
+	fmt.Println("sum:", sum, "prod:", prod) // Jednoduchý výstup
+	naucSeTypy()                            // < y minut je za námi, je čas učit se víc!
+}
+
+/* <- začátek mnohořádkového komentáře
+Funkce mohou mít parametry a (několik) návratových hodnot.
+V tomto případě jsou `x`, `y` parametry a `sum`, `prod` jsou návratové hodnoty.
+Všiměte si, že `x` a `sum` jsou typu `int`.
+*/
+func naucSeNasobit(x, y int) (sum, prod int) {
+	return x + y, x * y // Vracíme dvě hodnoty
+}
+
+// zabudované typy a literáty.
+func naucSeTypy() {
+	// Krátká deklarace většinou funguje
+	str := "Learn Go!" // typ řetězec.
+
+	s2 := `"surový" literát řetězce
+může obsahovat nové řádky` // Opět typ řetězec.
+
+	// Můžeme použít ne ASCII znaky, Go používá UTF-8.
+	g := 'Σ' // type runa, což je alias na int32 a ukládá se do něj znak UTF-8
+
+	f := 3.14195 // float64, je IEEE-754 64-bit číslem s plovoucí čárkou.
+	c := 3 + 4i  // complex128, interně uložené jako dva float64.
+
+	// takhle vypadá var s inicializací
+	var u uint = 7 // Číslo bez znaménka, jehož velikost záleží na implementaci,
+	               // stejně jako int
+	var pi float32 = 22. / 7
+
+	// takto se převádí typy za pomoci krátké syntaxe
+	n := byte('\n') // byte je jiné jméno pro uint8.
+
+	// Pole mají fixní délku, které se určuje v době kompilace.
+	var a4 [4]int           // Pole 4 intů, všechny nastaveny na 0.
+	a3 := [...]int{3, 1, 5} // Pole nastaveno na tři hodnoty
+	// elementy mají hodntu 3, 1 a 5
+
+	// Slicy mají dynamickou velikost. Pole i slacy mají své výhody,
+	// ale většinou se používají slicy.
+	s3 := []int{4, 5, 9}    // Podobně jako a3, ale není tu výpustka.
+	s4 := make([]int, 4)    // Alokuj slice 4 intů, všechny nastaveny na 0.
+	var d2 [][]float64      // Deklarace slicu, nic se nealokuje.
+	bs := []byte("a slice") // Přetypování na slice
+
+	// Protože jsou dynamické, můžeme ke slicům přidávat za běhu
+	// Přidat ke slicu můžeme pomocí zabudované funkce append().
+	// Prvním parametrem je slice, návratová hodnota je aktualizovaný slice.
+	s := []int{1, 2, 3}		// Výsledkem je slice se 3 elementy.
+	s = append(s, 4, 5, 6)	// Přidány další 3 elementy. Slice má teď velikost 6.
+	fmt.Println(s) // Slice má hodnoty [1 2 3 4 5 6]
+
+	// Pokud chceme k poli přičíst jiné pole, můžeme předat referenci na slice,
+	// nebo jeho literát a přidat výpustku, čímž se slicu "rozbalí" a přidá se k
+	// původnímu slicu.
+	s = append(s, []int{7, 8, 9}...) // druhým parametrem je literát slicu.
+	fmt.Println(s)	// slice má teď hodnoty [1 2 3 4 5 6 7 8 9]
+
+	p, q := naucSePraciSPameti() // Deklarujeme p a q jako typ pointer na int.
+	fmt.Println(*p, *q)   // * dereferencuje pointer. Tím se vypíší dva inty.
+
+	// Mapy jsou dynamické rostoucí asociativní pole, jako hashmapa, nebo slovník
+	// (dictionary) v jiných jazycích
+	m := map[string]int{"tri": 3, "ctyri": 4}
+	m["jedna"] = 1
+
+	// Napoužité proměnné jsou v Go chybou.
+	// Použijte podtržítko, abychom proměnno "použili".
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+	// Výpis promenné se počítá jako použití.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	naucSeVetveníProgramu() // Zpátky do běhu.
+}
+
+// narozdíl od jiných jazyků, v Go je možné mít pojmenované návratové hodnoty.
+// Tak můžeme vracet hodnoty z mnoha míst funkce, aniž bychom uváděli hodnoty v
+// return.
+func naucSePojmenovaneNavraty(x, y int) (z int) {
+	z = x * y
+	return // z je zde implicitní, jelikož bylo pojmenováno.
+}
+
+// Go má garbage collector. Používá pointery, ale neumožňuje jejich aritmetiku.
+// Můžete tedy udělat chybu použitím nil odkazu, ale ne jeho posunutím.
+func naucSePraciSPameti() (p, q *int) {
+	// Pojmenované parametry p a q mají typ odkaz na int.
+	p = new(int) // Zabudované funkce new alokuje paměť.
+	// Alokované místo pro int má hodnotu 0 a p už není nil.
+	s := make([]int, 20) // Alokujeme paměť pro 20 intů.
+	s[3] = 7             // Jednu z nich nastavíme.
+	r := -2              // Deklarujeme další lokální proměnnou.
+	return &s[3], &r     // a vezmeme si jejich odkaz pomocí &.
+}
+
+func narocnyVypocet() float64 {
+	return m.Exp(10)
+}
+
+func naucSeVetveníProgramu() {
+	// Výraz if vyžaduje složené závorky, ale podmínka nemusí být v závorkách.
+	if true {
+		fmt.Println("říkal jsme ti to")
+	}
+	// Formátování je standardizované pomocí utility "go fmt".
+	if false {
+		// posměšek.
+	} else {
+		// úšklebek.
+	}
+	// Použij switch, když chceš zřetězit if.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// jednotlivé case nepropadávají. není potřeba "break"
+	case 43:
+		// nedosažitelné, jelikož už bylo ošetřeno.
+	default:
+		// implicitní větev je nepovinná.
+	}
+	// Stejně jako if, for (smyčka) nepoužívá závorky.
+	// Proměnné definované ve for jsou lokální vůči smyčce.
+	for x := 0; x < 3; x++ { // ++ je výrazem.
+		fmt.Println("iterace", x)
+	}
+	// zde je x == 42.
+
+	// For je jediná smyčka v Go, ale má několik tvarů.
+	for { // Nekonečná smyčka
+		break    // Dělám si legraci
+		continue // Sem se nedostaneme
+	}
+
+	// Můžete použít klíčové slovo range pro iteraci nad mapami, poli, slicy,
+	// řetězci a kanály.
+	// range vrací jednu (kanál) nebo dvě hodnoty (pole, slice, řetězec a mapa).
+	for key, value := range map[string]int{"jedna": 1, "dva": 2, "tri": 3} {
+		// pro každý pár (klíč a hodnota) je vypiš
+		fmt.Printf("klíč=%s, hodnota=%d\n", key, value)
+	}
+
+	// stejně jako for, := v podmínce if přiřazuje hodnotu
+	// nejříve nastavíme y a pak otestujeme, jestli je y větší než x.
+	if y := narocnyVypocet(); y > x {
+		x = y
+	}
+	// Funkční literáty jsou tzv. uzávěry (closure)
+	xBig := func() bool {
+		return x > 10000 // odkazuje na x deklarované ve příkladu použití switch
+	}
+	x = 99999
+	fmt.Println("xBig:", xBig()) // true
+	x = 1.3e3                    // To udělá z x == 1300
+	fmt.Println("xBig:", xBig()) // teď už false.
+
+	// Dále je možné funkční literáty definovat a volat na místě jako parametr
+	// funkce, dokavaď:
+	// a) funkční literát je okamžitě volán pomocí (),
+	// b) výsledek se shoduje s očekávaným typem.
+	fmt.Println("Sečte + vynásobí dvě čísla: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Voláno s parametry 10 a 2
+	// => Sečti a vynásob dvě čísla. 24
+
+	// Když to potřebujete, tak to milujete
+	goto miluji
+miluji:
+
+	naučteSeFunkčníFactory() // funkce vracející funkce je zábava(3)(3)
+	naučteSeDefer()      // malá zajížďka k důležitému klíčovému slovu.
+	naučteSeInterfacy() // Přichází dobré věci!
+}
+
+func naučteSeFunkčníFactory() {
+	// Následující dvě varianty jsou stejné, ale ta druhá je praktičtější
+	fmt.Println(větaFactory("létní")("Hezký", "den!"))
+
+	d := větaFactory("letní")
+	fmt.Println(d("Hezký", "den!"))
+	fmt.Println(d("Líný", "odpoledne!"))
+}
+
+// Dekorátory jsou běžné v jiných jazycích. To samé můžete udělat v Go
+// pomocí parameterizovatelných funkčních literátů.
+func větaFactory(můjŘetězec string) func(před, po string) string {
+	return func(před, po string) string {
+		return fmt.Sprintf("%s %s %s", před, můjŘetězec, po) // nový řetězec
+	}
+}
+
+func naučteSeDefer() (ok bool) {
+	// Odloží (defer) příkazy na okamžik těsně před opuštěním funkce.
+	// tedy poslední se provede první
+	defer fmt.Println("odložené příkazy jsou zpravovaná v LIFO pořadí.")
+	defer fmt.Println("\nProto je tato řádka vytištěna první")
+	// Defer se běžně používá k zavírání souborů a tím se zajistí, že soubor
+	// bude po ukončení funkce zavřen.
+	return true
+}
+
+// definuje typ interfacu s jednou metodou String()
+type Stringer interface {
+	String() string
+}
+
+// Definuje pár jako strukturu se dvěma poli typu int x a y.
+type pár struct {
+	x, y int
+}
+
+// Definuje method pár. Pár tedy implementuje interface Stringer.
+func (p pár) String() string { // p je tu nazýváno "Receiver" - přijímač
+	// Sprintf je další veřejná funkce z balíčku fmt.
+	// Pomocí tečky přistupujeme k polím proměnné p
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func naučteSeInterfacy() {
+	// Složené závorky jsou "strukturální literáty. Vyhodnotí a inicializuje
+	// strukturu. Syntaxe := deklaruje a inicializuje strukturu.
+	p := pár{3, 4}
+	fmt.Println(p.String()) // Volá metodu String na p typu pár.
+	var i Stringer          // Deklaruje i jako proměnné typu Stringer.
+	i = p                   // Toto je možné, jelikož oba implementují Stringer
+	// zavolá metodu String(( typu Stringer a vytiskne to samé jako předchozí.
+	fmt.Println(i.String())
+
+	// Funkce ve balíčku fmt volají metodu String, když zjišťují, jak se má typ
+	// vytisknout.
+	fmt.Println(p) // Vytiskne to samé, jelikož Println volá String().
+	fmt.Println(i) // Ten samý výstup.
+
+	naučSeVariabilníParametry("super", "učit se", "tady!")
+}
+
+// Funcke mohou mít proměnlivé množství parametrů.
+func naučSeVariabilníParametry(mojeŘetězce ...interface{}) {
+	// Iterujeme přes všechny parametry
+	// Potržítku tu slouží k ignorování indexu v poli.
+	for _, param := range mojeŘetězce {
+		fmt.Println("parameter:", param)
+	}
+
+	// Použít variadický parametr jako variadický parametr, nikoliv pole.
+	fmt.Println("parametery:", fmt.Sprintln(mojeŘetězce...))
+
+	naučSeOšetřovatChyby()
+}
+
+func naučSeOšetřovatChyby() {
+	// ", ok" je metodou na zjištění, jestli něco fungovalo, nebo ne.
+	m := map[int]string{3: "tri", 4: "ctyri"}
+	if x, ok := m[1]; !ok { // ok bude false, jelikož 1 není v mapě.
+		fmt.Println("není tu jedna")
+	} else {
+		fmt.Print(x) // x by bylo tou hodnotou, pokud by bylo v mapě.
+	}
+	// hodnota error není jen znamením OK, ale může říct více o chybě.
+	if _, err := strconv.Atoi("ne-int"); err != nil { // _ hodnotu zahodíme
+		// vytiskne 'strconv.ParseInt: parsing "non-int": invalid syntax'
+		fmt.Println(err)
+	}
+	// Znovu si povíme o interfacech, zatím se podíváme na
+	naučSeKonkurenčnost()
+}
+
+// c je kanál, způsob, jak bezpečně komunikovat v konkurenčním prostředí.
+func zvyš(i int, c chan int) {
+	c <- i + 1 // <- znamená "pošli" a posílá data do kanálu na levé straně.
+}
+
+// Použijeme funkci zvyš a konkurečně budeme zvyšovat čísla.
+func naučSeKonkurenčnost() {
+	// funkci make jsme již použili na slicy. make alokuje a inicializuje slidy,
+	// mapy a kanály.
+	c := make(chan int)
+	// nastartuj tři konkurenční go-rutiny. Čísla se budou zvyšovat
+	// pravděpodobně paralelně pokud je počítač takto nakonfigurován.
+	// Všechny tři zapisují do toho samého kanálu.
+	go zvyš(0, c) // go je výraz pro start nové go-rutiny.
+	go zvyš(10, c)
+	go zvyš(-805, c)
+	// Přečteme si tři výsledky a vytiskeneme je..
+	// Nemůžeme říct, v jakém pořadí výsledky přijdou!
+	fmt.Println(<-c, <-c, <-c) // pokud je kanál na pravo, jedná se o "přijmi".
+
+	cs := make(chan string)       // Další kanál, tentokrát pro řetězce.
+	ccs := make(chan chan string) // Kanál kanálu řetězců.
+	go func() { c <- 84 }()       // Start nové go-rutiny na posílání hodnot.
+	go func() { cs <- "wordy" }() // To samé s cs.
+	// Select má syntaxi jako switch, ale vztahuje se k operacím nad kanály.
+	// Náhodně vybere jeden case, který je připraven na komunikaci.
+	select {
+        case i := <-c: // Přijatá hodnota může být přiřazena proměnné.
+            fmt.Printf("je to typ %T", i)
+        case <-cs: // nebo může být zahozena
+            fmt.Println("je to řetězec")
+        case <-ccs: // prázdný kanál, nepřipraven ke komunikaci.
+      		fmt.Println("to se nestane.")
+	}
+	// V tomto okamžiku máme hodnotu buď z kanálu c nabo cs. Jedna nebo druhá
+	// nastartovaná go-rutina skončila a další zůstane blokovaná.
+
+	naučSeProgramovatWeb() // Go to umí. A vy to chcete taky.
+}
+
+// jen jedna funkce z balíčku http spustí web server.
+func naučSeProgramovatWeb() {
+
+	// První parametr ListenAndServe je TCP adresa, kde poslouchat.
+	// Druhý parametr je handler, implementující interace http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", pár{})
+		fmt.Println(err) // neignoruj chyby
+	}()
+
+	requestServer()
+}
+
+// Umožní typ pár stát se http tím, že implementuje její jedinou metodu
+// ServeHTTP.
+func (p pár) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Servíruj data metodou http.ResponseWriter
+	w.Write([]byte("Naučil ses Go za y minut!"))
+}
+
+func requestServer() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nWebserver řekl: `%s`", string(body))
+}
+```
+
+## Kam dále
+
+Vše hlavní o Go se nachází na [oficiálních stránkách go](http://golang.org/).
+Tam najdete tutoriály, interaktivní konzolu a mnoho materiálu ke čtení.
+Kromě úvodu, [dokumenty](https://golang.org/doc/) tam obsahují jak psát čistý kód v Go
+popis balíčků (package), dokumentaci příkazové řádky a historii releasů.
+
+Také doporučujeme přečíst si definici jazyka. Je čtivá a překvapivě krátká. Tedy alespoň proti
+jiným současným jazyků.
+
+Pokud si chcete pohrát s Go, tak navštivte [hřiště Go](https://play.golang.org/p/r46YvCu-XX).
+Můžete tam spouštět programy s prohlížeče. Také můžete [https://play.golang.org](https://play.golang.org) použít jako
+[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop), kde si v rychlosti vyzkoušíte věci, bez instalace Go.
+
+Na vašem knižním seznamu, by neměly chybět [zdrojáky stadardní knihovny](http://golang.org/src/pkg/).
+Důkladně popisuje a dokumentuje Go, styl zápisu Go a Go idiomy. Pokud kliknete na [dokumentaci](http://golang.org/pkg/)
+tak se podíváte na dokumentaci.
+
+Dalším dobrým zdrojem informací je [Go v ukázkách](https://gobyexample.com/).
+
+Go mobile přidává podporu pro Android a iOS. Můžete s ním psát nativní mobilní aplikace nebo knihovny, které půjdou
+spustit přes Javu (pro Android), nebo Objective-C (pro iOS). Navštivte [web Go Mobile](https://github.com/golang/go/wiki/Mobile)
+pro více informací.
diff --git a/cs-cz/hack.html.markdown b/cs-cz/hack.html.markdown
new file mode 100644
index 00000000..736ad7e0
--- /dev/null
+++ b/cs-cz/hack.html.markdown
@@ -0,0 +1,309 @@
+---
+language: Hack
+filename: learnhack-cs.hh
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+lang: cs-cz
+---
+
+Hack je nadmnožinou PHP a běží v rámci virtuálního stroje zvaného HHVM. Hack 
+dokáže skoro plně spolupracovat s existujícím PHP a přidává několik vylepšení, 
+které známe ze staticky typovaných jazyků.
+
+Níže jsou popsané pouze vlastnosti jazyka Hack. Detaily ohledně jazyka PHP a jeho
+syntaxe pak najdete na těchto stránkách v samostatném 
+[článku o PHP](http://learnxinyminutes.com/docs/php/).
+
+```php
+<?hh
+
+// Hack je aktivní pouze pro soubory, které začínají <?hh.
+// TODO <?hh soubory nemohou být jendoduše přeloženy v HTML tak jako <?php.
+// Použitím značky <?hh //strict zapnete striktní mód typové kontroly.
+
+
+// Typování skalární parametrů
+function repeat(string $word, int $count)
+{
+    $word = trim($word);
+    return str_repeat($word . ' ', $count);
+}
+
+// Typování návratových hodnot
+function add(...$numbers) : int
+{
+    return array_sum($numbers);
+}
+
+// Funkce které nic nevrací jsou typované jako "void"
+function truncate(resource $handle) : void
+{
+    // ...
+}
+
+// U typování musíme explicitně povolit prázdné (null) hodnoty
+function identity(?string $stringOrNull) : ?string
+{
+    return $stringOrNull;
+}
+
+// Typování může být použito i na proměnné třídy
+class TypeHintedProperties
+{
+    public ?string $name;
+    
+    protected int $id;
+
+    private float $score = 100.0;
+
+    // Typ proměnné si můžeme zadat přímo u definice proměnné v rámci třídy,
+    // ale pak ho snadně přetížit v konstruktoru metody.
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Stručné anonymní funkce (lambda funkce)
+$multiplier = 5;
+array_map($y ==> $y * $multiplier, [1, 2, 3]);
+
+
+// Generika (generické funkce)
+class Box<T>
+{
+    protected T $data;
+
+    public function __construct(T $data) {
+        $this->data = $data;
+    }
+
+    public function getData(): T {
+        return $this->data;
+    }
+}
+
+function openBox(Box<int> $box) : int
+{
+    return $box->getData();
+}
+
+
+// Tvary
+// 
+// Hack zavádí koncept tvaru pro definování strukturovaných polí s garantovanou
+// typovou kontrolou pro klíče.
+type Point2D = shape('x' => int, 'y' => int);
+
+function distance(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distance(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Type aliasing
+// 
+// Hack přidává několik vylepšení pro lepší čitelnost komplexních typů
+newtype VectorArray = array<int, Vector<int>>;
+
+// Množina obsahující čísla
+newtype Point = (int, int);
+
+function addPoints(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+addPoints(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// Výčtový typ
+enum RoadType : int
+{
+    Road = 0;
+    Street = 1;
+    Avenue = 2;
+    Boulevard = 3;
+}
+
+function getRoadType() : RoadType
+{
+    return RoadType::Avenue;
+}
+
+
+// Automatické nastavení proměnných třídy
+// 
+// Aby se nemuseli definovat proměnné třídy a její konstruktor,
+// který pouze nastavuje třídní proměnné, můžeme v Hacku vše 
+// definovat najednou.
+class ArgumentPromotion
+{
+    public function __construct(public string $name,
+                                protected int $age,
+                                private bool $isAwesome) {}
+}
+
+// Takto by to vypadalo bez automatického nastavení proměnných
+class WithoutArugmentPromotion
+{
+    public string $name;
+
+    protected int $age;
+
+    private bool $isAwesome;
+
+    public function __construct(string $name, int $age, bool $isAwesome)
+    {
+        $this->name = $name;
+        $this->age = $age;
+        $this->isAwesome = $isAwesome;
+    }
+}
+
+
+// Ko-operativní multi-tasking
+// 
+// Nová klíčová slova "async" and "await" mohou být použité pro spuštění mutli-taskingu
+// Tato vlastnost ovšem zahrnuje vícevláknové zpracování, pouze povolí řízení přenosu
+async function cooperativePrint(int $start, int $end) : Awaitable<void>
+{
+    for ($i = $start; $i <= $end; $i++) { 
+        echo "$i ";
+
+        // Dává ostatním úlohám šanci něco udělat
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Toto vypíše "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    cooperativePrint(1, 3),
+    cooperativePrint(4, 6),
+    cooperativePrint(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributy
+// 
+// Atributy jsou určitou formou metadat pro funkce. Hack přidává některé vestavěné 
+// atributy které aktivnují uživatečné chování funkcí.
+
+// Speciální atribut __Memoize způsobí, že výsledek funkce je uložen do cache
+<<__Memoize>>
+function doExpensiveTask() : ?string
+{
+    return file_get_contents('http://example.com');
+}
+
+// Tělo funkce je v tomto případě vykonáno pouze jednou:
+doExpensiveTask();
+doExpensiveTask();
+
+
+// Speciální atribut __ConsistentConstruct signalizuje typové kontrole Hacku, že
+// zápis __construct bude stejný pro všechny podtřídy.
+<<__ConsistentConstruct>>
+class ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class ConsistentBar extends ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // Typová kontrola Hacku zajistí volání konstruktoru rodičovské třídy
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // Anotace __Override je volitelný signál pro typovou kontrolu Hacku, že
+    // tato metoda přetěžuje metodu rodičovské třídy, nebo traitu. Bez uvedení
+    // této anotace vyhodí typová kontrola chybu.
+    <<__Override>>
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class InvalidFooSubclass extends ConsistentFoo
+{
+    // Nedodržení zápisu dle rodičovského konstruktoru způsobí syntaktickou chybu:
+    //  
+    //  "Tento objekt je typu ConsistentBaz a není kompatibilní v tímto objektem,
+    //   který je typu ConsistentFoo protože některé jeho metody nejsou kompatibilní."
+    //
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Použitím anotace __Override na nepřetíženou metodu způsobí chybu typové kontroly:
+    //  
+    //  "InvalidFooSubclass::otherMethod() je označená jako přetížená, ale nebyla nalezena
+    //   taková rodičovská metoda, nebo rodič kterého přetěžujete není zapsán v <?hh kódu"
+    //
+    <<__Override>>
+    public function otherMethod()
+    {
+        // ...
+    }
+}
+
+
+// Traity mohou implementovat rozhraní, což standardní PHP neumí
+interface KittenInterface
+{
+    public function play() : void;
+}
+
+trait CatTrait implements KittenInterface
+{
+    public function play() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use CatTrait;
+}
+
+
+$cat = new Samuel();
+$cat instanceof KittenInterface === true; // True
+
+```
+
+## Více informací
+
+Pro více informací navštivte [referenční příručku jazyka Hack](http://docs.hhvm.com/manual/en/hacklangref.php), 
+kde se dozvíte více detailu a vylepšení, které jazyk Hack přidává do PHP, a nebo navštivte [oficiální stránky jazyka Hack](http://hacklang.org/)
+pro obecné informace.
+
+Pro instrukce k instalaci jazyka Hack navštivte [oficiální HHVM stránky](http://hhvm.com/).
+
+Pro více informací ohledně zpětné kompatibility s PHP navštivte článek o [nepodporovaných PHP vlastnostech Hacku](http://docs.hhvm.com/manual/en/hack.unsupported.php).
diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
new file mode 100644
index 00000000..cbf7687e
--- /dev/null
+++ b/cs-cz/javascript.html.markdown
@@ -0,0 +1,574 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+    - ["Michal Martinek", "https://github.com/MichalMartinek"]
+lang: cs-cz
+filename: javascript-cz.js
+---
+
+JavaScript byl vytvořen Brendan Eichem v roce 1995 pro Netscape. Byl původně
+zamýšlen jako jednoduchý skriptovací jazyk pro webové stránky, jako doplněk Javy,
+která byla zamýšlena pro více komplexní webové aplikace, ale jeho úzké propojení
+s webovými stránkami a vestavěná podpora v prohlížečích způsobila, že se stala
+více běžná ve webovém frontendu než Java.
+
+
+JavaScript není omezen pouze na webové prohlížeče, např. projekt Node.js,
+který zprostředkovává samostatně běžící prostředí V8 JavaScriptového enginu z
+Google Chrome se stává více a více oblíbený pro serverovou část webových aplikací.
+
+Zpětná vazba je velmi ceněná. Autora článku můžete kontaktovat (anglicky) na
+[@adambrenecki](https://twitter.com/adambrenecki), nebo
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au), nebo mě, jakožto překladatele,
+na [martinek@ludis.me](mailto:martinek@ludis.me).
+
+```js
+// Komentáře jsou jako v zayku C. Jednořádkové komentáře začínájí dvojitým lomítkem,
+/* a víceřádkové komentáře začínají lomítkem s hvězdičkou
+   a končí hvězdičkou s lomítkem */
+
+// Vyrazu můžou být spuštěny pomocí ;
+delejNeco();
+
+// ... ale nemusí, středníky jsou automaticky vloženy kdekoliv,
+// kde končí řádka, kromě pár speciálních případů
+delejNeco()
+
+// Protože tyto případy můžou způsobit neočekávané výsledky, budeme
+// středníky v našem návodu používat.
+
+/////////////////////////////////
+// 1. Čísla, řetězce a operátory
+
+// JavaScript má jeden číselný typ (čímž je 64-bitový IEEE 754 double).
+// Double má 52-bit přesnost, což je dostatečně přesné pro ukládání celých čísel
+// do 9✕10¹⁵.
+3; // = 3
+1.5; // = 1.5
+
+// Základní matematické operace fungují, jak byste očekávali
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Včetně dělení
+5 / 2; // = 2.5
+
+// A také dělení modulo
+10 % 2; // = 0
+30 % 4; // = 2
+18.5 % 7; // = 4.5
+
+// Bitové operace také fungují; když provádíte bitové operace, desetinné číslo  
+// (float) se převede na celé číslo (int) se znaménkem *do* 32 bitů
+1 << 2; // = 4
+
+// Přednost se vynucuje závorkami.
+(1 + 3) * 2; // = 8
+
+// Existují 3 hodnoty mimo obor reálných čísel
+Infinity; // + nekonečno; výsledek např. 1/0
+-Infinity; // - nekonečno; výsledek např. -1/0
+NaN; // výsledek např. 0/0, znamená, že výsledek není číslo ('Not a Number')
+
+// Také existují hodnoty typu bool
+true; // pravda
+false; // nepravda
+
+// Řetězce znaků jsou obaleny  ' nebo ".
+'abc';
+"Ahoj světe!";
+
+// Negace se tvoří pomocí !
+!true; // = false
+!false; // = true
+
+// Rovnost se porovnává ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Nerovnost zase pomocí !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Další srovnávání
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Řetězce znaků se spojují pomocí +
+"Ahoj " + "světe!"; // = "Ahoj světe!"
+
+// ... což funguje nejenom s řetězci
+"1, 2, " + 3; // = "1, 2, 3"
+"Ahoj " + ["světe", "!"] // = "Ahoj světe,!"
+
+// a porovnávají se pomocí < nebo >
+"a" < "b"; // = true
+
+// Rovnost s převodem typů se dělá pomocí == ...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...dokud nepoužijete ===
+"5" === 5; // = false
+null === undefined; // = false
+
+// ...což může občas způsobit divné chování...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Můžeme přistupovat k jednotlivým znakům v řetězci pomocí charAt`
+"Toto je řetězec".charAt(0);  // = 'T'
+
+// ...nebo použít `substring` k získání podřetězce
+"Ahoj světe".substring(0, 4); // = "Ahoj"
+
+// `length` znamená délka a je to vlastnost, takže nepoužívejte ()
+"Ahoj".length; // = 4
+
+// Existují také typy `null` a `undefined`.
+null;      // značí, že žádnou hodnotu
+undefined; // značí, že hodnota nebyla definovaná (ikdyž
+           // `undefined` je hodnota sama o sobě)
+
+// false, null, undefined, NaN, 0 and "" vrací nepravdu (false). Všechno ostatní
+// vrací pravdu (true)..
+// Všimněte si, že 0 vrací nepravdu, ale "0" vrací pravdu, ikdyž 0 == "0"
+// vrací pravdu
+
+///////////////////////////////////
+// 2. Proměnné, pole a objekty
+
+// Proměnné jsou deklarovány pomocí slůvka `var`. JavaScript je dynamicky
+// typovaný, takže nemusíme specifikovat typ. K přiřazení hodnoty se používá
+// znak `=`.
+var promenna = 5;
+
+// když vynecháte slůvko 'var' nedostanete chybovou hlášku...
+jinaPromenna = 10;
+
+// ...ale vaše proměnná bude vytvořena globálně, bude vytvořena  v globálním
+// oblasti působnosti, ne jenom v lokálním tam, kde jste ji vytvořili
+
+// Proměnné vytvořené bez přiřazení obsahují hodnotu undefined.
+var dalsiPromenna; // = undefined
+
+// Pokud chcete vytvořit několik proměnných najednou, můžete je oddělit čárkou
+var someFourthVar = 2, someFifthVar = 4;
+
+// Existuje kratší forma pro matematické operace na proměnné
+promenna += 5; // se provede stejně jako promenna = promenna + 5;
+// promenna je ted 10
+promenna *= 10; // teď je promenna rovna 100
+
+// a tohle je způsob, jak přičítat a odečítat 1
+promenna++; // teď je promenna 101
+promenna--; // zpět na 100
+
+// Pole jsou uspořádané seznamy hodnot jakéhokoliv typu
+var mojePole = ["Ahoj", 45, true];
+
+// Jednotlivé hodnoty jsou přístupné přes hranaté závorky.
+// Členové pole se začínají počítat na nule.
+myArray[1]; // = 45
+
+// Pole je proměnlivé délky a členové se můžou měnit
+myArray.push("Světe");
+myArray.length; // = 4
+
+// Přidání/změna na specifickém indexu
+myArray[3] = "Hello";
+
+// JavaScriptové objekty jsou stejné jako asociativní pole v jinných programovacích
+// jazycích: je to neuspořádaná množina páru hodnot - klíč:hodnota.
+var mujObjekt = {klic1: "Ahoj", klic2: "světe"};
+
+// Klíče jsou řetězce, ale nejsou povinné uvozovky, pokud jsou validní
+// JavaScriptové identifikátory. Hodnoty můžou být jakéhokoliv typu-
+var mujObjekt = {klic: "mojeHodnota", "muj jiny klic": 4};
+
+// K hodnotám můžeme přistupovat opět pomocí hranatých závorek
+myObj["muj jiny klic"]; // = 4
+
+// ... nebo pokud je klíč platným identifikátorem, můžeme přistupovat k
+// hodnotám i přes tečku
+mujObjekt.klic; // = "mojeHodnota"
+
+// Objekty jsou měnitelné, můžeme upravit hodnoty, nebo přidat nové klíče.
+myObj.mujDalsiKlic = true;
+
+// Pokud se snažíte přistoupit ke klíči, který není nastaven, dostanete undefined
+myObj.dalsiKlic; // = undefined
+
+///////////////////////////////////
+// 3. Řízení toku programu
+
+// Syntaxe pro tuto sekci je prakticky stejná jako pro Javu
+
+// `if` (když) funguje, jak byste čekali.
+var pocet = 1;
+if (pocet == 3){
+    // provede, když se pocet rovná 3
+} else if (pocet == 4){
+    // provede, když se pocet rovná 4
+} else {
+    // provede, když je pocet cokoliv jinného
+}
+
+// Stejně tak cyklus while
+while (true){
+    // nekonečný cyklus
+}
+
+// Do-while cyklus je stejný jako while, akorát se vždy provede aspoň jednou
+var vstup;
+do {
+    vstup = nactiVstup();
+} while (!jeValidni(vstup))
+
+// Cyklus for je stejný jako v Javě nebo jazyku C
+// inicializace; podmínka pro pokračování; iterace.
+for (var i = 0; i < 3; i++){
+    // provede třikrát
+}
+
+// Cyklus For-in iteruje přes každo vlastnost prototypu
+var popis = "";
+var osoba = {prijmeni:"Paul", jmeno:"Ken", vek:18};
+for (var x in osoba){
+    popis += osoba[x] + " ";
+}
+
+//Když chcete iterovat přes vlastnosti, které jsou přímo na objektu a nejsou
+//zděněné z prototypů, kontrolujte vlastnosti přes hasOwnProperty()
+var popis = "";
+var osoba = {prijmeni:"Jan", jmeno:"Novák", vek:18};
+for (var x in osoba){
+    if (osoba.hasOwnProperty(x)){
+        popis += osoba[x] + " ";
+    }
+}
+
+// for-in by neměl být použit pro pole, pokud záleží na pořadí indexů.
+// Neexistuje jistota, že for-in je vrátí ve správném pořadí.
+
+// && je logické a, || je logické nebo
+if (dum.velikost == "velký" && dum.barva == "modrá"){
+    dum.obsahuje = "medvěd";
+}
+if (barva == "červená" || barva == "modrá"){
+    // barva je červená nebo modtrá
+}
+
+// && a || jsou praktické i pro nastavení základních hodnot
+var jmeno = nejakeJmeno || "default";
+
+
+// `switch` zkoumá přesnou rovnost (===)
+// Používejte 'break;' po každé možnosti, jinak se provede i možnost za ní.
+znamka = 'B';
+switch (znamka) {
+  case 'A':
+    console.log("Výborná práce");
+    break;
+  case 'B':
+    console.log("Dobrá práce");
+    break;
+  case 'C':
+    console.log("Dokážeš to i lépe");
+    break;
+  default:
+    console.log("Ale ne");
+    break;
+}
+
+////////////////////////////////////////////////////////
+// 4. Funckce, Oblast platnosti (scope) a Vnitřní funkce
+
+// JavaScriptové funkce jsou definovány slůvkem `function`.
+function funkce(text){
+    return text.toUpperCase();
+}
+funkce("něco"); // = "NĚCO"
+
+// Dávejte si pozor na to, že hodnota k vrácení musí začínat na stejné řádce
+// jako slůvko return, jinak se vrátí 'undefined', kvůli automatickému vkládání
+// středníků. Platí to zejména pro Allmanův styl zápisu.
+
+function funkce()
+{
+    return // <- zde je automaticky vložen středník
+    {
+        tohleJe: "vlastnost objektu"
+    }
+}
+funkce(); // = undefined
+
+// JavaScriptové funkce jsou objekty, takže můžou být přiřazeny různým proměnným
+// a předány dalším funkcím jako argumenty, na příklad:
+function funkce(){
+    // tento kód bude zavolán za 5 vteřin
+}
+setTimeout(funkce, 5000);
+// Poznámka: setTimeout není část JS jazyka, ale funkce poskytována
+// prohlížeči a NodeJS
+
+// Další funkce poskytovaná prohlížeči je je setInterval
+function myFunction(){
+    // tento kód bude volán každých 5 vteřin
+}
+setInterval(myFunction, 5000);
+
+// Objekty funkcí nemusíme ani deklarovat pomocí jména, můžeme je napsat jako
+// ananymní funkci přímo vloženou jako argument
+setTimeout(function(){
+  // tento kód bude zavolán za 5 vteřin    
+}, 5000);
+
+// JavaScript má oblast platnosti funkce, funkce ho mají, ale jiné bloky ne
+if (true){
+    var i = 5;
+}
+i; // = 5 - ne undefined, jak byste očekávali v jazyku, kde mají bloky svůj
+// rámec působnosti
+
+// Toto je běžný model,který chrání před únikem dočasných proměnných do
+//globální oblasti
+(function(){
+    var docasna = 5;
+    // Můžeme přistupovat k globálního oblasti přes přiřazování globalním
+    // objektům. Ve webovém prohlížeči je to vždy 'window`. Globální objekt
+    // může mít v jiných prostředích jako Node.js jinné jméno.
+    window.trvala = 10;
+})();
+docasna; // způsobí ReferenceError
+trvala; // = 10
+
+// Jedna z nejvice mocných vlastnosti JavaScriptu je vnitřní funkce. Je to funkce
+// definovaná v jinné funkci, vnitřní funkce má přístup ke všem proměnným ve
+// vnější funkci, dokonce i poté, co funkce skončí
+function ahojPoPetiVterinach(jmeno){
+    var prompt = "Ahoj, " + jmeno + "!";
+    // Vnitřní funkce je dána do lokální oblasti platnosti, jako kdyby byla
+    // deklarovaná slůvkem 'var'
+    function vnitrni(){
+        alert(prompt);
+    }
+    setTimeout(vnitrni, 5000);
+    // setTimeout je asynchronní, takže funkce ahojPoPetiVterinach se ukončí
+    // okamžitě, ale setTimeout zavolá funkci vnitrni až poté. Avšak protože
+    // vnitrni je definována přes ahojPoPetiVterinach, má pořád přístup k
+    // proměnné prompt, když je konečně zavolána.
+}
+ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
+
+///////////////////////////////////////////////////
+// 5. Více o objektech, konstuktorech a prototypech
+
+// Objekty můžou obsahovat funkce
+var mujObjekt = {
+    mojeFunkce: function(){
+        return "Ahoj světe!";
+    }
+};
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Když jsou funkce z objektu zavolány, můžou přistupovat k objektu přes slůvko
+// 'this''
+var mujObjekt = {
+    text: "Ahoj světe!",
+    mojeFunkce: function(){
+        return this.text;
+    }
+};
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Slůvko this je nastaveno k tomu, kde je voláno, ne k tomu, kde je definováno
+// Takže naše funkce nebude fungovat, když nebude v kontextu objektu.
+var mojeFunkce = mujObjekt.mojeFunkce;
+mojeFunkce(); // = undefined
+
+// Opačně, funkce může být přiřazena objektu a může přistupovat k objektu přes
+// this, i když nebyla přímo v definici-
+var mojeDalsiFunkce = function(){
+    return this.text.toUpperCase();
+}
+mujObjekt.mojeDalsiFunkce = mojeDalsiFunkce;
+mujObjekt.mojeDalsiFunkce(); // = "AHOJ SVĚTE!"
+
+// Můžeme také specifikovat, v jakém kontextu má být funkce volána pomocí
+// `call` nebo `apply`.
+
+var dalsiFunkce = function(s){
+    return this.text + s;
+}
+dalsiFunkce.call(mujObjekt, " A ahoj měsíci!"); // = "Ahoj světe! A ahoj měsíci!"
+
+// Funkce `apply`je velmi podobná, akorát bere jako druhý argument pole argumentů
+dalsiFunkce.apply(mujObjekt, [" A ahoj slunce!"]); // = "Ahoj světe! A ahoj slunce!"
+
+// To je praktické, když pracujete s funkcí, která bere sekvenci argumentů a
+// chcete předat pole.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Ale `call` a `apply` jsou pouze dočasné. Pokud je chcete připojit trvale
+// použijte `bind`.
+
+var pripojenaFunkce = dalsiFunkce.bind(mujObjekt);
+pripojenaFunkce(" A ahoj Saturne!"); // = "Ahoj světe! A ahoj Saturne!"
+
+// `bind` může být použito čatečně částečně i k používání
+
+var nasobeni = function(a, b){ return a * b; }
+var zdvojeni = nasobeni.bind(this, 2);
+zdvojeni(8); // = 16
+
+// Když zavoláte funkci se slůvkem 'new', vytvoří se nový objekt a
+// a udělá se dostupný funkcím skrz slůvko 'this'. Funkcím volaným takto se říká
+// konstruktory
+
+var MujKonstruktor = function(){
+    this.mojeCislo = 5;
+}
+mujObjekt = new MujKonstruktor(); // = {mojeCislo: 5}
+mujObjekt.mojeCislo; // = 5
+
+// Každý JsavaScriptový objekt má prototyp. Když budete přistupovat k vlasnosti
+// objektu, který neexistuje na objektu, tak se JS koukne do prototypu.
+
+// Některé JS implementace vám umožní přistupovat k prototypu přes magickou
+// vlastnost '__proto__'. I když je toto užitečné k vysvětlování prototypů, není
+// to součást standardu, ke standartní způsobu k používání prototypu se dostaneme
+// později.
+var mujObjekt = {
+    mujText: "Ahoj svete!"
+};
+var mujPrototyp = {
+    smyslZivota: 42,
+    mojeFunkce: function(){
+        return this.mujText.toLowerCase()
+    }
+};
+
+mujObjekt.__proto__ = mujPrototyp;
+mujObjekt.smyslZivota; // = 42
+
+// Toto funguje i pro funkce
+mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+
+// Samozřejmě, pokud není vlastnost na vašem prototypu, tak se hledá na
+// prototypu od prototypu atd.
+mujPrototyp.__proto__ = {
+    mujBoolean: true
+};
+mujObjekt.mujBoolean; // = true
+
+
+// Zde neni žádné kopírování; každý objekt ukládá referenci na svůj prototyp
+// Toto znamená, že můžeme měnit prototyp a změny se projeví všude
+mujPrototyp.smyslZivota = 43;
+mujObjekt.smyslZivota // = 43
+
+// Zmínili jsme již předtím, že '__proto__' není ve standardu a není cesta, jak
+// měnit prototyp existujícího objektu. Avšak existují možnosti, jak vytvořit
+// nový objekt s daným prototypem
+
+// První je Object.create, což je nedávný přídavek do JS a není dostupný zatím
+// ve všech implementacích.
+var mujObjekt = Object.create(mujPrototyp);
+mujObjekt.smyslZivota // = 43
+
+// Druhý způsob, který funguje všude je pomocí konstuktoru. Konstruktor má
+// vlastnost jménem prototype. Toto *není* prototyp samotného konstruktoru, ale
+// prototyp nového objektu.
+MujKonstruktor.prototype = {
+    mojeCislo: 5,
+    ziskejMojeCislo: function(){
+        return this.mojeCislo;
+    }
+};
+var mujObjekt2 = new MujKonstruktor();
+mujObjekt2.ziskejMojeCislo(); // = 5
+mujObjekt2.mojeCislo = 6
+mujObjekt2.ziskejMojeCislo(); // = 6
+
+// Vestavěnné typy jako čísla nebo řetězce mají také konstruktory, které vytváří
+// ekvivalentní obalovací objekty (wrappery).
+var mojeCislo = 12;
+var mojeCisloObj = new Number(12);
+mojeCislo == mojeCisloObj; // = true
+
+// Avšak nejsou úplně přesně stejné
+typeof mojeCislo; // = 'number'
+typeof mojeCisloObj; // = 'object'
+mojeCislo === mojeCisloObj; // = false
+if (0){
+    // Tento kód se nespustí, protože 0 je nepravdivá (false)
+}
+
+if (new Number(0)){
+   // Tento kód se spustí, protože obalená čísla jsou objekty,
+   // a objekty jsou vždy pravdivé
+}
+
+// Avšak, obalovací objekty a normální vestavěnné typy sdílejí prototyp, takže
+// můžete přidat funkcionalitu k řetězci
+String.prototype.prvniZnak = function(){
+    return this.charAt(0);
+}
+"abc".prvniZnak(); // = "a"
+
+// Tento fakt je často používán v polyfillech, což je implementace novějších
+// vlastností JavaScriptu do starších variant, takže je můžete používat třeba
+// ve starých prohlížečích
+
+// Pro příkklad, zmínili jsme, že Object.create není dostupný ve všech
+// implementacích, můžeme si avšak přidat pomocí polyfillu
+if (Object.create === undefined){ // nebudeme ho přepisovat, když existuje
+    Object.create = function(proto){
+        // vytvoříme dočasný konstruktor
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // ten použijeme k vytvoření nového s prototypem
+        return new Constructor();
+    }
+}
+```
+
+## Kam dál
+
+[Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) obsahuje
+perfektní dokumentaci pro JavaScript, který je používaný v prohlížečích. Navíc
+je to i wiki, takže jakmile se naučíte více, můžete pomoci ostatním, tím, že
+přispějete svými znalostmi.
+
+MDN's [A re-introduction to
+JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+pojednává o konceptech vysvětlených zde v mnohem větší hloubce. Tento návod
+pokrývá hlavně JavaScript sám o sobě. Pokud se chcete naučit více, jak se používá
+na webových stránkách, začněte tím, že se kouknete na [DOM](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) je varianta tohoto
+návodu i s úkoly-
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) je sbírka
+příkladů těch nejvíce nepředvídatelných částí tohoto jazyka.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/)
+je klasická výuková kniha.
+
+Jako dodatek k přímým autorům tohoto článku, některý obsah byl přizpůsoben z
+Pythoního tutoriálu od Louie Dinh na této stráce, a z [JS
+Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+z Mozilla Developer Network.
diff --git a/cs-cz/json.html.markdown b/cs-cz/json.html.markdown
new file mode 100644
index 00000000..5972da5e
--- /dev/null
+++ b/cs-cz/json.html.markdown
@@ -0,0 +1,62 @@
+---
+language: json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+    - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnjson-cz.json
+lang: cs-cz
+---
+
+JSON je exterémně jednoduchý datově nezávislý formát a bude asi jeden z 
+nejjednodušších 'Learn X in Y Minutes' ze všech.
+
+JSON nemá ve své nejzákladnější podobě žádné komentáře, ale většina parserů 
+umí pracovat s komentáři ve stylu jazyka C (`//`, `/* */`). Pro tyto účely 
+však budeme používat 100% validní JSON bez komentářů. Pojďme se podívat na 
+syntaxi formátu JSON:
+
+```json
+{
+  "klic": "value",
+  
+  "hodnoty": "Musí být vždy uvozený v dvojitých uvozovkách",
+  "cisla": 0,
+  "retezce": "Hellø, wørld. Všechny unicode znaky jsou povolené, společně s \"escapováním\".",
+  "pravdivostni_hodnota": true,
+  "prazdna_hodnota": null,
+
+  "velke_cislo": 1.2e+100,
+
+  "objekt": {
+    "komentar": "Most of your structure will come from objects.",
+
+    "pole": [0, 1, 2, 3, "Pole nemusí být pouze homogenní.", 5],
+
+    "jiny_objekt": {
+      "comment": "Je povolené jakkoli hluboké zanoření."
+    }
+  },
+
+  "cokoli": [
+    {
+      "zdroje_drasliku": ["banány"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "alternativni_styl_zapisu": {
+    "komentar": "Mrkni se na toto!"
+  , "pozice_carky": "Na pozici čárky nezáleží - pokud je před hodnotou, ať už je kdekoli, tak je validní."
+  , "dalsi_komentar": "To je skvělé."
+  },
+
+  "to_bylo_rychle": "A tím jsme hotový. Nyní již víte vše, co může formát JSON nabídnout!"
+}
+```
diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index b5e5894f..568e4343 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Michal Martinek", "https://github.com/MichalMartinek"]
-filename: markdown.md
+filename: markdown-cz.md
 lang: cs-cz
 ---
 
@@ -53,7 +53,7 @@ __Stejně jako tento.__
 **_Jako tento!_**
 *__A tento!__*
 
-<!-- Ve verzi Markdownu od Githubu, máme k dispozici taky prošktrnutí: -->
+<!-- Ve verzi Markdownu od GitHubu, máme k dispozici taky prošktrnutí: -->
 
 ~~Tento text je prošktrnutý.~~
 
@@ -152,7 +152,7 @@ Tento box bude zašktrnutý
 
 Jan nevědel, jak se dělá `go_to()` funkce!
 
-<!-- V Markdownu od Githubu , můžete použít speciální syntaxi pro kód -->
+<!-- V Markdownu od GitHubu , můžete použít speciální syntaxi pro kód -->
 
 \`\`\`ruby <!-- vyjma zpětných lomítek, jenom ```ruby ! -->
 def neco
@@ -160,7 +160,7 @@ def neco
 end
 \`\`\` <!-- zde taky, žádné zpětná lomítka, pouze ``` -->
 
-<!-- Text výše nepotřebuje odsazení a navíc Github použije zvýraznění označeného
+<!-- Text výše nepotřebuje odsazení a navíc GitHub použije zvýraznění označeného
  jazyka. -->
 
 <!-- Horizontální čára (<hr />) -->
@@ -232,13 +232,13 @@ Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a j
 Chci napsat *tento text obklopený hvězdičkami*, ale nechci aby to bylo kurzívou, tak udělám: \*tento text obklopený hvězdičkami\*.
 
 <!-- Klávesové zkratky -->
-<!-- V Markdownu od Githubu, můžete použít tag <kbd> k reprezentování klaves na počítači -->
+<!-- V Markdownu od GitHubu, můžete použít tag <kbd> k reprezentování klaves na počítači -->
 
 Váš počítač přestal pracovat? Zkuste
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 
 <!-- Tabulky -->
-<!-- Tabulky jsou povolené pouze v Markdownu od Githubu a jsou trochu podivně,
+<!-- Tabulky jsou povolené pouze v Markdownu od GitHubu a jsou trochu podivně,
      ale když je opravdu chcete: -->
 
 | Sloupec1     | Sloupec2 | Sloupec3      |
diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index b498046a..581ed3a3 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -7,7 +7,7 @@ contributors:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
 translators:
     - ["Tomáš Bedřich", "http://tbedrich.cz"]
-filename: learnpython3.py
+filename: learnpython3-cz.py
 lang: cs-cz
 ---
 
diff --git a/csharp.html.markdown b/csharp.html.markdown
index 7d7f4340..cca99fb0 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -8,6 +8,7 @@ contributors:
     - ["Wouter Van Schandevijl", "http://github.com/laoujin"]
     - ["Jo Pearce", "http://github.com/jdpearce"]
     - ["Chris Zimmerman", "https://github.com/chriszimmerman"]
+    - ["Shawn McGuire", "https://github.com/bigbash"]
 filename: LearnCSharp.cs
 ---
 
@@ -24,10 +25,12 @@ Multi-line comments look like this
 /// This is an XML documentation comment which can be used to generate external
 /// documentation or provide context help within an IDE
 /// </summary>
-//public void MethodOrClassOrOtherWithParsableHelp() {}
+/// <param name="firstParam">This is some parameter documentation for firstParam</param>
+/// <returns>Information on the returned value of a function</returns>
+//public void MethodOrClassOrOtherWithParsableHelp(string firstParam) {}
 
 // Specify the namespaces this source code will be using
-// The namespaces below are all part of the standard .NET Framework Class Libary
+// The namespaces below are all part of the standard .NET Framework Class Library
 using System;
 using System.Collections.Generic;
 using System.Dynamic;
@@ -210,10 +213,10 @@ on a new line! ""Wow!"", the masses cried";
             // Incrementations
             int i = 0;
             Console.WriteLine("\n->Inc/Dec-rementation");
-            Console.WriteLine(i++); //i = 1. Post-Incrementation
-            Console.WriteLine(++i); //i = 2. Pre-Incrementation
-            Console.WriteLine(i--); //i = 1. Post-Decrementation
-            Console.WriteLine(--i); //i = 0. Pre-Decrementation
+            Console.WriteLine(i++); //Prints "0", i = 1. Post-Incrementation
+            Console.WriteLine(++i); //Prints "2", i = 2. Pre-Incrementation
+            Console.WriteLine(i--); //Prints "2", i = 1. Post-Decrementation
+            Console.WriteLine(--i); //Prints "0", i = 0. Pre-Decrementation
 
             ///////////////////////////////////////
             // Control Structures
@@ -421,7 +424,7 @@ on a new line! ""Wow!"", the masses cried";
                 // Item is an int
                 Console.WriteLine(item.ToString());
         }
-        
+
         // YIELD
         // Usage of the "yield" keyword indicates that the method it appears in is an Iterator
         // (this means you can use it in a foreach loop)
@@ -437,7 +440,7 @@ on a new line! ""Wow!"", the masses cried";
             foreach (var counter in YieldCounter())
                 Console.WriteLine(counter);
         }
-        
+
         // you can use more than one "yield return" in a method
         public static IEnumerable<int> ManyYieldCounter()
         {
@@ -446,7 +449,7 @@ on a new line! ""Wow!"", the masses cried";
             yield return 2;
             yield return 3;
         }
-        
+
         // you can also use "yield break" to stop the Iterator
         // this method would only return half of the values from 0 to limit.
         public static IEnumerable<int> YieldCounterWithBreak(int limit = 10)
@@ -456,7 +459,7 @@ on a new line! ""Wow!"", the masses cried";
                 if (i > limit/2) yield break;
                 yield return i;
             }
-        }             
+        }
 
         public static void OtherInterestingFeatures()
         {
@@ -482,7 +485,7 @@ on a new line! ""Wow!"", the masses cried";
             // ?? is syntactic sugar for specifying default value (coalesce)
             // in case variable is null
             int notNullable = nullable ?? 0; // 0
-            
+
             // ?. is an operator for null-propagation - a shorthand way of checking for null
             nullable?.Print(); // Use the Print() extension method if nullable isn't null
 
@@ -544,28 +547,22 @@ on a new line! ""Wow!"", the masses cried";
 
             // PARALLEL FRAMEWORK
             // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
-            var websites = new string[] {
-                "http://www.google.com", "http://www.reddit.com",
-                "http://www.shaunmccarthy.com"
-            };
-            var responses = new Dictionary<string, string>();
 
-            // Will spin up separate threads for each request, and join on them
-            // before going to the next step!
-            Parallel.ForEach(websites,
-                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
-                website =>
-            {
-                // Do something that takes a long time on the file
-                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+            var words = new List<string> {"dog", "cat", "horse", "pony"};
+
+            Parallel.ForEach(words,
+                new ParallelOptions() { MaxDegreeOfParallelism = 4 },
+                word =>
                 {
-                    responses[website] = r.ContentType;
+                    Console.WriteLine(word);
                 }
-            });
+            );
 
-            // This won't happen till after all requests have been completed
-            foreach (var key in responses.Keys)
-                Console.WriteLine("{0}:{1}", key, responses[key]);
+            //Running this will produce different outputs
+            //since each thread finishes at different times.
+            //Some example outputs are:
+            //cat dog horse pony
+            //dog horse pony cat
 
             // DYNAMIC OBJECTS (great for working with other languages)
             dynamic student = new ExpandoObject();
@@ -674,6 +671,10 @@ on a new line! ""Wow!"", the masses cried";
         int _speed; // Everything is private by default: Only accessible from within this class.
                     // can also use keyword private
         public string Name { get; set; }
+        
+        // Properties also have a special syntax for when you want a readonly property
+        // that simply returns the result of an expression
+        public string LongName => Name + " " + _speed + " speed"; 
 
         // Enum is a value type that consists of a set of named constants
         // It is really just mapping a name to a value (an int, unless specified otherwise).
@@ -692,7 +693,10 @@ on a new line! ""Wow!"", the masses cried";
         public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
 
         // Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on
-        [Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc
+        // Any class derived from Attribute can be used to decorate types, methods, parameters etc
+        // Bitwise operators & and | can be used to perform and/or operations
+
+        [Flags]
         public enum BikeAccessories
         {
             None = 0,
@@ -820,7 +824,7 @@ on a new line! ""Wow!"", the masses cried";
         }
 
         // Methods can also be static. It can be useful for helper methods
-        public static bool DidWeCreateEnoughBycles()
+        public static bool DidWeCreateEnoughBicycles()
         {
             // Within a static method, we only can reference static class members
             return BicyclesCreated > 9000;
@@ -879,8 +883,8 @@ on a new line! ""Wow!"", the masses cried";
         bool Broken { get; } // interfaces can contain properties as well as methods & events
     }
 
-    // Class can inherit only one other class, but can implement any amount of interfaces, however
-    // the base class name must be the first in the list and all interfaces follow
+    // Classes can inherit only one other class, but can implement any amount of interfaces,
+    // however the base class name must be the first in the list and all interfaces follow
     class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
@@ -913,17 +917,17 @@ on a new line! ""Wow!"", the masses cried";
 
         public DbSet<Bicycle> Bikes { get; set; }
     }
-    
+
     // Classes can be split across multiple .cs files
     // A1.cs
-    public partial class A 
+    public partial class A
     {
         public static void A1()
         {
             Console.WriteLine("Method A1 in class A");
         }
     }
-    
+
     // A2.cs
     public partial class A
     {
@@ -932,9 +936,9 @@ on a new line! ""Wow!"", the masses cried";
             Console.WriteLine("Method A2 in class A");
         }
     }
-    
+
     // Program using the partial class "A"
-    public class Program 
+    public class Program
     {
         static void Main()
         {
@@ -942,13 +946,161 @@ on a new line! ""Wow!"", the masses cried";
             A.A2();
         }
     }
+
+    // String interpolation by prefixing the string with $
+    // and wrapping the expression you want to interpolate with { braces }
+    public class Rectangle
+    {
+        public int Length { get; set; }
+        public int Width { get; set; }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Rectangle rect = new Rectangle { Length = 5, Width = 3 };
+            Console.WriteLine($"The length is {rect.Length} and the width is {rect.Width}");
+        }
+    }
+
+    // New C# 6 features
+    class GlassBall : IJumpable, IBreakable
+    {
+        // Autoproperty initializers
+        public int Damage { get; private set; } = 0;
+
+        // Autoproperty initializers on getter-only properties
+        public string Name { get; } = "Glass ball";
+
+        // Getter-only autoproperty that is initialized in constructor
+        public string GenieName { get; }
+
+        public GlassBall(string genieName = null)
+        {
+            GenieName = genieName;
+        }
+
+        public void Jump(int meters)
+        {
+            if (meters < 0)
+                // New nameof() expression; compiler will check that the identifier exists
+                // nameof(x) == "x"
+                // Prevents e.g. parameter names changing but not updated in error messages
+                throw new ArgumentException("Cannot jump negative amount!", nameof(meters));
+
+            Damage += meters;
+        }
+
+        // Expression-bodied properties ...
+        public bool Broken
+            => Damage > 100;
+
+        // ... and methods
+        public override string ToString()
+            // Interpolated string
+            => $"{Name}. Damage taken: {Damage}";
+
+        public string SummonGenie()
+            // Null-conditional operators
+            // x?.y will return null immediately if x is null; y is not evaluated
+            => GenieName?.ToUpper();
+    }
+
+    static class MagicService
+    {
+        private static bool LogException(Exception ex)
+        {
+            /* log exception somewhere */
+            return false;
+        }
+
+        public static bool CastSpell(string spell)
+        {
+            try
+            {
+                // Pretend we call API here
+                throw new MagicServiceException("Spell failed", 42);
+
+                // Spell succeeded
+                return true;
+            }
+            // Only catch if Code is 42 i.e. spell failed
+            catch(MagicServiceException ex) when (ex.Code == 42)
+            {
+                // Spell failed
+                return false;
+            }
+            // Other exceptions, or MagicServiceException where Code is not 42 
+            catch(Exception ex) when (LogException(ex))
+            {
+                // Execution never reaches this block
+                // The stack is not unwound
+            }
+            return false;
+            // Note that catching a MagicServiceException and rethrowing if Code
+            // is not 42 or 117 is different, as then the final catch-all block
+            // will not catch the rethrown exception
+        }
+    }
+
+    public class MagicServiceException : Exception
+    {
+        public int Code { get; }
+
+        public MagicServiceException(string message, int code) : base(message)
+        {
+            Code = code;
+        }
+    }
+
+    public static class PragmaWarning {
+        // Obsolete attribute
+        [Obsolete("Use NewMethod instead", false)]
+        public static void ObsoleteMethod()
+        {
+            /* obsolete code */
+        }
+
+        public static void NewMethod()
+        {
+            /* new code */
+        }
+
+        public static void Main()
+        {
+            ObsoleteMethod(); // CS0618: 'ObsoleteMethod is obsolete: Use NewMethod instead'
+#pragma warning disable CS0618
+            ObsoleteMethod(); // no warning
+#pragma warning restore CS0618
+            ObsoleteMethod(); // CS0618: 'ObsoleteMethod is obsolete: Use NewMethod instead'
+        }
+    }
 } // End Namespace
+
+using System;
+// C# 6, static using
+using static System.Math;
+
+namespace Learning.More.CSharp
+{
+    class StaticUsing
+    {
+        static void Main()
+        {
+            // Without a static using statement..
+            Console.WriteLine("The square root of 4 is {}.", Math.Sqrt(4));
+            // With one
+            Console.WriteLine("The square root of 4 is {}.", Sqrt(4));
+        }
+    }
+}
 ```
 
 ## Topics Not Covered
 
  * Attributes
- * async/await, pragma directives
+ * async/await
  * Web Development
  	* ASP.NET MVC & WebApi (new)
  	* ASP.NET Web Forms (old)
diff --git a/css.html.markdown b/css.html.markdown
index 8ee4f4b9..3b378d44 100644
--- a/css.html.markdown
+++ b/css.html.markdown
@@ -6,17 +6,24 @@ contributors:
     - ["Geoffrey Liu", "https://github.com/g-liu"]
     - ["Connor Shea", "https://github.com/connorshea"]
     - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+    - ["Brett Taylor", "https://github.com/glutnix"]
     - ["Tyler Mumford", "https://tylermumford.com"]
 filename: learncss.css
 ---
 
-Web pages are built with HTML, which specifies the content of a page. CSS (Cascading Style Sheets) is a separate language which specifies a page's **appearance**.
+Web pages are built with HTML, which specifies the content of a page.
+CSS (Cascading Style Sheets) is a separate language which specifies
+a page's **appearance**.
 
-CSS code is made of static *rules*. Each rule takes one or more *selectors* and gives specific *values* to a number of visual *properties*. Those properties are then applied to the page elements indicated by the selectors.
+CSS code is made of static *rules*. Each rule takes one or more *selectors* and
+gives specific *values* to a number of visual *properties*. Those properties are
+then applied to the page elements indicated by the selectors.
 
-This guide has been written with CSS 2 in mind, which is extended by the new features of CSS 3.
+This guide has been written with CSS 2 in mind, which is extended by the new
+features of CSS 3.
 
-**NOTE:** Because CSS produces visual results, in order to learn it, you need to try everything in a CSS playground like [dabblet](http://dabblet.com/).
+**NOTE:** Because CSS produces visual results, in order to learn it, you need to
+try everything in a CSS playground like [dabblet](http://dabblet.com/).
 The main focus of this article is on the syntax and some general tips.
 
 ## Syntax
@@ -66,7 +73,7 @@ div { }
 [otherAttr~='foo'] { }
 [otherAttr~='bar'] { }
 
-/* or contains a value in a dash-separated list, ie, "-" (U+002D) */
+/* or contains a value in a dash-separated list, e.g., "-" (U+002D) */
 [otherAttr|='en'] { font-size:smaller; }
 
 
@@ -113,7 +120,8 @@ selector:first-child {}
 /* any element that is the last child of its parent */
 selector:last-child {}
 
-/* Just like pseudo classes, pseudo elements allow you to style certain parts of a document  */
+/* Just like pseudo classes, pseudo elements allow you to style certain parts of
+    a document  */
 
 /* matches a virtual first child of the selected element */
 selector::before {}
@@ -132,9 +140,9 @@ selector::after {}
    #################### */
 
 selector {
-    
+
     /* Units of length can be absolute or relative. */
-    
+
     /* Relative units */
     width: 50%;       /* percentage of parent element width */
     font-size: 2em;   /* multiples of element's original font-size */
@@ -143,14 +151,14 @@ selector {
     font-size: 2vh;   /* or its height */
     font-size: 2vmin; /* whichever of a vh or a vw is smaller */
     font-size: 2vmax; /* or greater */
-    
+
     /* Absolute units */
     width: 200px;     /* pixels */
     font-size: 20pt;  /* points */
     width: 5cm;       /* centimeters */
     min-width: 50mm;  /* millimeters */
     max-width: 5in;   /* inches */
-    
+
     /* Colors */
     color: #F6E;                 /* short hex format */
     color: #FF66EE;              /* long hex format */
@@ -161,10 +169,17 @@ selector {
     color: transparent;          /* equivalent to setting the alpha to 0 */
     color: hsl(0, 100%, 50%);    /* as hsl percentages (CSS 3) */
     color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */
-    
+
+    /* Borders */
+    border-width:5px;
+    border-style:solid;
+    border-color:red;      /* similar to how background-color is set */
+    border: 5px solid red; /* this is a short hand approach for the same */
+    border-radius:20px;    /* this is a CSS3 property */    
+
     /* Images as backgrounds of elements */
     background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
-    
+
     /* Fonts */
     font-family: Arial;
     /* if the font family name has a space, it must be quoted */
@@ -178,10 +193,10 @@ selector {
 
 Save a CSS stylesheet with the extension `.css`.
 
-```xml
+```html
 <!-- You need to include the css file in your page's <head>. This is the
      recommended method. Refer to http://stackoverflow.com/questions/8284365 -->
-<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+<link rel='stylesheet' type='text/css' href='path/to/style.css'>
 
 <!-- You can also include some CSS inline in your markup. -->
 <style>
@@ -195,7 +210,13 @@ Save a CSS stylesheet with the extension `.css`.
 
 ## Precedence or Cascade
 
-An element may be targeted by multiple selectors and may have a property set on it in more than once. In these cases, one of the rules takes precedence over others. Rules with a more specific selector take precedence over a less specific one, and a rule occuring later in the stylesheet overwrites a previous one.
+An element may be targeted by multiple selectors and may have a property set on
+it in more than once. In these cases, one of the rules takes precedence over
+others. Rules with a more specific selector take precedence over a less specific
+one, and a rule occurring later in the stylesheet overwrites a previous one
+(which also means that if two different linked stylesheets contain rules for an
+element and if the rules are of the same specificity, then order of linking
+would take precedence and the sheet linked latest would govern styling) .
 
 This process is called cascading, hence the name Cascading Style Sheets.
 
@@ -220,22 +241,71 @@ p { property: value !important; }
 
 and the following markup:
 
-```xml
-<p style='/*F*/ property:value;' class='class1 class2' attr='value' />
+```html
+<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
 ```
 
-The precedence of style is as follows. Remember, the precedence is for each **property**, not for the entire block.
+The precedence of style is as follows. Remember, the precedence is for each
+**property**, not for the entire block.
 
-* `E` has the highest precedence because of the keyword `!important`. It is recommended that you avoid its usage.
+* `E` has the highest precedence because of the keyword `!important`. It is
+recommended that you avoid its usage.
 * `F` is next, because it is an inline style.
-* `A` is next, because it is more "specific" than anything else. It has 3 specifiers: The name of the element `p`, its class `class1`, an attribute `attr='value'`.
-* `C` is next, even though it has the same specificity as `B`. This is because it appears after `B`.
+* `A` is next, because it is more "specific" than anything else. It has 3
+    specifiers: The name of the element `p`, its class `class1`, an attribute
+    `attr='value'`.
+* `C` is next, even though it has the same specificity as `B`.
+    This is because it appears after `B`.
 * `B` is next.
 * `D` is the last one.
 
+## Media Queries
+
+CSS Media Queries are a feature in CSS 3 which allows you to specify when certain CSS rules should be applied, such as when printed, or when on a screen with certain dimensions or pixel density. They do not add to the selector's specificity.
+
+```css
+/* A rule that will be used on all devices */
+h1 {
+  font-size: 2em;
+  color: white;
+  background-color: black;
+}
+
+/* change the h1 to use less ink on a printer */
+@media print {
+  h1 {
+    color: black;
+    background-color: white;
+  }
+}
+
+/* make the font bigger when shown on a screen at least 480px wide */
+@media screen and (min-width: 480px) {
+  h1 {
+    font-size: 3em;
+    font-weight: normal;
+  }
+}
+```
+
+Media queries can include these features:
+`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Most of these features can be prefixed with `min-` or `max-`.
+
+The `resolution` feature is not supported by older devices, instead use `device-pixel-ratio`.
+
+Many smartphones and tablets will attempt to render the page as if it were on a desktop unless you provide a `viewport` meta-tag.
+
+```html
+<head>
+  <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
 ## Compatibility
 
-Most of the features in CSS 2 (and many in CSS 3) are available across all browsers and devices. But it's always good practice to check before using a new feature.
+Most of the features in CSS 2 (and many in CSS 3) are available across all
+browsers and devices. But it's always good practice to check before using
+a new feature.
 
 ## Resources
 
diff --git a/cypher.html.markdown b/cypher.html.markdown
new file mode 100644
index 00000000..44db26ae
--- /dev/null
+++ b/cypher.html.markdown
@@ -0,0 +1,249 @@
+---
+language: cypher
+filename: LearnCypher.cql
+contributors:
+    - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
+---
+
+Cypher is the Neo4j’s query language to manipulate graphs easily. It reuses syntax from SQL and mixes it with kind of ascii-art to represent graphs.
+This tutorial assumes that you already know graph concepts like nodes and relationships.
+
+[Read more here.](https://neo4j.com/developer/cypher-query-language/)
+
+
+Nodes
+---
+
+**Represents a record in a graph.**
+
+```()```
+It's an empty *node*, to indicate that there is a *node*, but it's not relevant for the query.
+
+```(n)```
+It's a *node* refered by the variable **n**, reusable in the query. It begins with lowercase and uses camelCase.
+
+```(p:Person)```
+You can add a *label* to your node, here **Person**. It's like a type / a class / a category. It begins with uppercase and uses camelCase.
+
+```(p:Person:Manager)```
+A node can have many *labels*.
+
+```(p:Person {name : 'Théo Gauchoux', age : 22})```
+A node can have some *properties*, here **name** and **age**. It begins with lowercase and uses camelCase.
+
+The types allowed in properties :
+
+ - Numeric
+ - Boolean
+ - String
+ - List of previous primitive types
+
+*Warning : there isn't datetime property in Cypher ! You can use String with a specific pattern or a Numeric from a specific date.*
+
+```p.name```
+You can access to a property with the dot style.
+
+
+Relationships (or Edges)
+---
+
+**Connects two nodes**
+
+```[:KNOWS]```
+It's a *relationship* with the *label* **KNOWS**. It's a *label* as the node's label. It begins with uppercase and use UPPER_SNAKE_CASE.
+
+```[k:KNOWS]```
+The same *relationship*, refered by the variable **k**, reusable in the query, but it's not necessary.
+
+```[k:KNOWS {since:2017}]```
+The same *relationship*, with *properties* (like *node*), here **since**.
+
+```[k:KNOWS*..4]```
+It's a structural information to use in a *path* (seen later). Here, **\*..4** says "Match the pattern, with the relationship **k** which be repeated between 1 and 4 times.
+
+
+Paths
+---
+
+**The way to mix nodes and relationships.**
+
+```(a:Person)-[:KNOWS]-(b:Person)```
+A path describing that **a** and **b** know each other.
+
+```(a:Person)-[:MANAGES]->(b:Person)```
+A path can be directed. This path describes that **a** is the manager of **b**.
+
+```(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)```
+You can chain multiple relationships. This path describes the friend of a friend.
+
+```(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)```
+A chain can also be directed. This path describes that **a** is the boss of **b** and the big boss of **c**.
+
+Patterns often used (from Neo4j doc) :
+
+```
+// Friend-of-a-friend 
+(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
+
+// Shortest path
+path = shortestPath( (user)-[:KNOWS*..5]-(other) )
+
+// Collaborative filtering
+(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
+
+// Tree navigation 
+(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
+
+```
+
+
+Create queries
+---
+
+Create a new node
+```
+CREATE (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+*`RETURN` allows to have a result after the query. It can be multiple, as `RETURN a, b`.*
+
+Create a new relationship (with 2 new nodes)
+```
+CREATE (a:Person)-[k:KNOWS]-(b:Person)
+RETURN a,k,b
+```
+
+Match queries
+---
+
+Match all nodes
+```
+MATCH (n)
+RETURN n
+```
+
+Match nodes by label
+```
+MATCH (a:Person)
+RETURN a
+```
+
+Match nodes by label and property
+```
+MATCH (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+
+Match nodes according to relationships (undirected)
+```
+MATCH (a)-[:KNOWS]-(b)
+RETURN a,b
+```
+
+Match nodes according to relationships (directed)
+```
+MATCH (a)-[:MANAGES]->(b)
+RETURN a,b
+```
+
+Match nodes with a `WHERE` clause
+```
+MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
+WHERE s.since = 2015
+RETURN p,state
+```
+
+You can use `MATCH WHERE` clause with `CREATE` clause
+```
+MATCH (a), (b)
+WHERE a.name = "Jacquie" AND b.name = "Michel"
+CREATE (a)-[:KNOWS]-(b)
+```
+
+
+Update queries
+---
+
+Update a specific property of a node
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p.age = 23
+```
+
+Replace all properties of a node
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p = {name: "Michel", age: 23}
+```
+
+Add new property to a node
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p + = {studies: "IT Engineering"}
+```
+
+Add a label to a node
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p:Internship
+```
+
+
+Delete queries
+---
+
+Delete a specific node (linked relationships must be deleted before)
+```
+MATCH (p:Person)-[relationship]-()
+WHERE p.name = "Théo Gauchoux"
+DELETE relationship, p
+```
+
+Remove a property in a specific node
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+REMOVE p.age
+```
+*Pay attention to the `REMOVE`keyword, it's not `DELETE` !*
+
+Remove a label from a specific node
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+DELETE p:Person
+```
+
+Delete entire database
+```
+MATCH (n)
+OPTIONAL MATCH (n)-[r]-()
+DELETE n, r
+```
+*Seriously, it's the `rm -rf /` of Cypher !*
+
+
+Other useful clauses
+---
+
+```PROFILE```
+Before a query, show the execution plan of it.
+
+```COUNT(e)```
+Count entities (nodes or relationships) matching **e**.
+
+```LIMIT x```
+Limit the result to the x first results.
+
+
+Special hints
+---
+
+- There is just single-line comments in Cypher, with double-slash : // Comments
+- You can execute a Cypher script stored in a **.cql** file directly in Neo4j (it's an import). However, you can't have multiple statements in this file (separed by **;**).
+- Use the Neo4j shell to write Cypher, it's really awesome.
+- The Cypher will be the standard query language for all graph databases (known as **OpenCypher**).
diff --git a/d.html.markdown b/d.html.markdown
index edb3bff5..c682cfb5 100644
--- a/d.html.markdown
+++ b/d.html.markdown
@@ -6,7 +6,7 @@ contributors:
 lang: en
 ---
 
-```c
+```d
 // You know what's coming...
 module hello;
 
@@ -28,7 +28,7 @@ D is actively developed by a large group of super-smart people and is spearheade
 [Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
 With all that out of the way, let's look at some examples!
 
-```c
+```d
 import std.stdio;
 
 void main() {
@@ -73,7 +73,7 @@ We can define new types with `struct`, `class`, `union`, and `enum`. Structs and
 are passed to functions by value (i.e. copied) and classes are passed by reference. Furthermore,
 we can use templates to parameterize all of these on both types and values!
 
-```c
+```d
 // Here, 'T' is a type parameter. Think '<T>' from C++/C#/Java.
 struct LinkedList(T) {
     T data = null;
@@ -136,7 +136,7 @@ is roughly a function that may act like an lvalue, so we can
 have the syntax of POD structures (`structure.x = 7`) with the semantics of
 getter and setter methods (`object.setX(7)`)!
 
-```c
+```d
 // Consider a class parameterized on types 'T' & 'U'.
 class MyClass(T, U) {
     T _data;
@@ -209,7 +209,7 @@ functions, and immutable data. In addition, all of your favorite
 functional algorithms (map, filter, reduce and friends) can be
 found in the wonderful `std.algorithm` module!
 
-```c
+```d
 import std.algorithm : map, filter, reduce;
 import std.range : iota; // builds an end-exclusive range
 
@@ -237,7 +237,7 @@ is of some type A on any expression of type A as a method.
 
 I like parallelism. Anyone else like parallelism? Sure you do. Let's do some!
 
-```c
+```d
 // Let's say we want to populate a large array with the square root of all
 // consecutive integers starting from 1 (up until the size of the array), and we
 // want to do this concurrently taking advantage of as many cores as we have
diff --git a/dart.html.markdown b/dart.html.markdown
index fc7b220e..5027dc3e 100644
--- a/dart.html.markdown
+++ b/dart.html.markdown
@@ -11,7 +11,7 @@ its JavaScript sibling. Like JavaScript, Dart aims for great browser integration
 
 Dart's most controversial feature must be its Optional Typing.
 
-```javascript
+```dart
 import "dart:collection";
 import "dart:math" as DM;
 
diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown
new file mode 100644
index 00000000..1a8cdd5a
--- /dev/null
+++ b/de-de/asciidoc-de.html.markdown
@@ -0,0 +1,125 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+translators:
+  - ["Dennis Keller", "https://github.com/denniskeller"]
+filename: asciidoc-de.md
+lang: de-de
+---
+
+AsciiDoc ist eine Auszeichnungssprache ähnlich zu Markdown. Sie kann für alles verwendet werden von Büchern zu Blogs. Erfunden wurde sie 2002 von Stuart Rackham. Die Sprache ist simpel aber sie ermöglicht eine große Anzahl an Anpassungen.
+
+Kopfzeile des Dokuments
+
+Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen mindestens eine Leerzeile vom Inhalt versetzt sein.
+
+Nur Titel
+
+```
+= Dokumententitel
+
+Erster Satz des Dokuments.
+```
+
+Titel und Autor
+
+```
+= Dokumententitel
+Vorname Nachname <Vorname.Nachname@learnxinyminutes.com>
+
+Start des Dokuments.
+```
+
+Mehrere Autoren
+
+```
+= Dokumententitel
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Starte ein Dokument mit mehreren Autoren.
+```
+
+Revisionszeile (benötigt eine Autorzeile)
+
+```
+= Dokumententitel V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+Dieser Artikel über Chips wird Spaß machen.
+```
+
+Absätze
+
+```
+Du musst nichts besonderes machen für Absätze.
+
+Füge eine Leerzeile zwischen zwei Absätze, um sie zu trennen.
+
+Um eine Leerzeile zu erhalten musst du ein +
+ergänzen und du erhälst einen Umbruch!
+```
+
+Textformatierung
+
+```
+_Unterstriche erstellt Kursivschrift_
+*Sternchen für Fett gedruckt*
+*_Kombinieren für extra Spaß_*
+`Benutze Ticks um Monospace zu signalisieren`
+`*Fett gedruckter Monospace*`
+```
+
+Abteilungstitel
+
+```
+= Level 0 (sollte nur in der Kopfzeile verwendet werden)
+
+== Level 1 <h2>
+
+=== Level 2 <h3>
+
+==== Level 3 <h4>
+
+===== Level 4 <h5>
+
+====== Level 5 <h6>
+
+======= Level 6  <h7>
+
+```
+
+Listen
+
+Um eine Aufzählung zu erstellen verwendest du Sternchen.
+
+```
+* foo
+* bar
+* baz
+```
+
+Um eine nummerierte Liste zu erstellen verwendest du Punkte.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+Um Listen zu verschachteln musst du zusätzliche Sternchen und Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index 541d28bb..7928b136 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -92,12 +92,12 @@ echo "immer ausgeführt" || echo "Nur ausgeführt wenn der erste Befehl fehlschl
 echo "immer ausgeführt" && echo "Nur ausgeführt wenn der erste Befehl Erfolg hat"
 
 # Um && und || mit if statements zu verwenden, braucht man mehrfache Paare eckiger Klammern:
-if [ $NAME == "Steve" ] && [ $Alter -eq 15 ]
+if [ "$NAME" == "Steve" ] && [ "$Alter" -eq 15 ]
 then
     echo "Wird ausgeführt wenn $NAME gleich 'Steve' UND $Alter gleich 15."
 fi
 
-if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
+if [ "$Name" == "Daniya" ] || [ "$Name" == "Zach" ]
 then
     echo "Wird ausgeführt wenn $NAME gleich 'Daniya' ODER $NAME gleich 'Zach'."
 fi
@@ -175,7 +175,7 @@ in
     # Liste der Fälle, die unterschieden werden sollen
     0) echo "Hier ist eine Null."
     1) echo "Hier ist eine Eins."
-    *) echo "Das ist nicht Null."
+    *) echo "Das ist etwas anderes."
 esac
 
 # 'for' Schleifen iterieren über die angegebene Zahl von Argumenten:
diff --git a/de-de/brainfuck-de.html.markdown b/de-de/brainfuck-de.html.markdown
new file mode 100644
index 00000000..dd62dd67
--- /dev/null
+++ b/de-de/brainfuck-de.html.markdown
@@ -0,0 +1,89 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["urfuchs", "https://github.com/urfuchs"]
+filename: brainfuck-de
+lang: de-de
+
+---
+
+Brainfuck ist eine extrem minimalistische Turing-vollständige Programmiersprache
+mit lediglich 8 Befehlen.
+
+Mit dem [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/) kann
+Brainfuck im Browser ausprobiert werden.
+
+```
+Alle Zeichen außer "><+-.,[]" (ohne die Klammern) werden ignoriert.
+
+Brainfuck besteht aus einem Array mit unendlich vielen Elementen, die alle mit Null initalisiert
+sind und einem Datenzeiger auf das aktuelle Element.
+
+Es gibt acht Befehle:
++ : Erhöht den Wert an der aktuellen Stelle um Eins.
+- : Verringert den Wert an der aktuellen Stelle um Eins.
+> : Bewegt den Zeiger um eine Stelle weiter.
+< : Bewegt den Zeiger um eine Stelle zurück.
+. : Gibt den Wert der aktuellen Zelle als ASCII Wert aus (z.B. 65 = 'A').
+, : Liest ein einzelnes Zeichen von der Standardeingabe und speichert dessen ASCII Wert in der aktuellen Zelle.
+[ : Wenn der Wert des aktuellen Elements Null ist, bewege des Zeiger hinter den
+    zugehörigen ]-Befehl.
+    Ansonsten, bewege den Zeiger ein Element weiter.
+] : Wenn der Wert des aktuellen Elements Null ist, bewege des Zeiger um eine Stelle
+    weiter.
+    Ansonsten, bewege den Zeiger hinter den zugehörigen [-Befehl.
+
+[ und ] bilden eine while-Schleife. Offensichtlich müssen sie paarweise vorkommen.
+
+Schauen wir uns einige grundlegende Programme an.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Dieses Programm gibt den Buchstaben 'A' aus. Zunächst erhöht es den Wert der 1. Zelle auf 6.
+Diese erste Zelle wird für die Schleife verwendet. Danach beginnt das Programm
+die Schleife ([) und geht vor zu Zelle #2. Es erhöht den Zellwert inkrementell 10 Mal, geht dann zurück
+zu Zelle #1, und verringert Zelle #1. Diese Schleife wird 6 Mal durchlaufen (nach 6
+Durchläufen ist der Wert der Zelle #1 auf 0 reduziert, dadurch wird die Schleife abgebrochen
+und das Programm hinter dem korrespondierenden ] fortgesetzt).
+
+An dieser Stelle befinden wir uns an Zelle #1, die jetzt den Wert 0 hat, während Zelle #2
+den Wert 60 hat. Wir gehen vor zu Zelle #2, inkrementieren 5 Mal, bis zum Wert 65,
+und geben dann den Wert der Zelle #2 aus. 65 ist ein 'A' im ASCII Zeichensatz,
+daher wird 'A' am Terminal ausgegeben..
+
+
+, [ > + < - ] > .
+
+Dieses Programm liest ein Zeichen von der Benutzereingabe und schreibt dessen Wert
+in Zelle #1. Danach beginnt eine Schleife. Rücke vor auf Zelle #2, erhöhe den Wert der Zelle #2,
+gehe zurück auf Zelle #1, verringere den Wert der Zelle #1. Dies geht solange bis
+Zelle #1 den Wert 0 und Zelle #2 den alten Wert aus #1 hat. Da wir am Ende der Schleife
+bie Zelle #1 sind, gehe vor zu Zelle #2 und gibt denb Wert als ASCII Zeichen aus.
+
+Beachte biite, dass die Leerzeichen nur aus Gründen der Lesbarkeit geschrieben werden.
+Man könnte genauso schreiben:
+
+,[>+<-]>.
+
+Versuche herauszufinden, was dieses Programm macht:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Dieses Programm nimmt zwei Zahlen als Eingabe und multipliziert sie.
+
+Im Wesentlichen liest es zunächst zwei Werte ein. Dann beginnt die äußere Schleife
+mit Zelle #1 als Zähler. Danach geht das Programm zu Zelle #2 vor und startet die innere Schleife
+mit Zelle #2 als Zähler. Diese zählt Zelle #3 hoch. Es gibt jedoch ein Problem:
+Am Ende der inneren Schleife hat Zelle #2 den Wert Null. Daher würde die innere
+Schleife beim nächsten Durchgang nicht mehr funktionieren. Daher wird auch Zelle #4
+erhöht und anschließend in Zelle #2 zurückkopiert.
+Am Ende steht in Zelle #3 das Ergebnis.
+```
+
+Das ist Brainfuck. Nicht so schwierig, oder? Zum Spaß kannst du dein eigenes Brainfuck
+Programm schreiben oder du schreibst einen Brainfuck Interpreter in einer anderen
+Programmiersprache. Der Interpreter lässt sich ziemlich einfach implementieren.
+Falls du Masochist bist, kannst du auch versuchen, einen Brainfuck Interpreter in Brainfuck zu implementieren.
diff --git a/de-de/css-de.html.markdown b/de-de/css-de.html.markdown
index 23c1df94..c31e73d2 100644
--- a/de-de/css-de.html.markdown
+++ b/de-de/css-de.html.markdown
@@ -149,10 +149,10 @@ selector {
 
 ## Benutzung
 
-Speichere das CSS, das du benutzen willst mit der endung '.css'.
+Speichere das CSS, das du benutzen willst, mit der Endung '.css'.
 
 ```xml
-<!-- du musst die CSS-Datei im <head>-bereich der seite einbinden -->
+<!-- du musst die CSS-Datei im <head>-bereich der Seite einbinden -->
 <link rel='stylesheet' type='text/css' href='filepath/filename.css' />
 
 <!-- Einbindung funktioniert auch inline, wobei diese Methode nicht
@@ -203,9 +203,9 @@ und das folgende Markup:
 Die Spezifität der Stile ist wie folgt:
 (die Spezifität gilt nur für **einzelne Eigenschaften**, nicht für ganze Blöcke)
 
-* `E` hat die größte Spezifität wegen dem Schlüsselwort `!important`.
+* `E` hat die größte Spezifität wegen des Schlüsselworts `!important`.
 	man sollte diese Form aber vermeiden.
-* `F` ist als nächstes dran, da es direkt an dem element definiert ist.
+* `F` ist als nächstes dran, da es direkt an dem Element definiert ist.
 * Dann folgt `A`, da es "spezifischer" als alle anderen ist.
 	spezifischer = mehr Zuweisungen: 1 Tagname `p` +
 	Klassenname `klasse1` + 1 Attribut `attr='value'`
diff --git a/de-de/d-de.html.markdown b/de-de/d-de.html.markdown
new file mode 100644
index 00000000..2b0b38dd
--- /dev/null
+++ b/de-de/d-de.html.markdown
@@ -0,0 +1,252 @@
+---
+language: D 
+filename: learnd-de.d 
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
+    - ["Dominik Süß", "www.thesuess.me"]
+lang: de-de
+---
+
+```c
+// Es war klar dass das kommt...
+module hello;
+
+import std.stdio;
+
+// argumente sind optional
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+Wenn du so wie ich bist und viel zeit im Internet verbringst stehen die Chancen gut
+das du schonmal über [D](http://dlang.org/) gehört hast.
+Die D-Sprache ist eine moderne, überall einsetzbare programmiersprache die von Low bis
+High Level verwendet werden kann und dabei viele Stile anbietet.
+
+D wird aktiv von Walter Bright und Andrei Alexandrescu entwickelt, zwei super schlaue,
+richtig coole leute. Da das jetzt alles aus dem weg ist - auf zu den Beispielen!
+
+```c
+import std.stdio;
+
+void main() {
+
+    // Logische Ausdrücke und Schleifen funktionieren wie erwartet
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    auto n = 1; // auto um den typ vom Compiler bestimmen zu lassen
+    
+    // Zahlenliterale können _ verwenden für lesbarkeit
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+
+    // For und while sind ja schön und gut aber D bevorzugt foreach
+    // Die '..' erstellen eine Spanne von Zahlen, inklusive dem ersten Wert
+    // jedoch ohne dem letzten
+    foreach(i; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(i);
+    }
+
+    // Es gibt auch ein 'foreach_reverse' wenn du rückwerts gehen willst.
+    foreach_reverse(i; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(i);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+Neue Typen können mit `struct`, `class`, `union`, und `enum` definiert werden. Structs und unions
+werden as-value (koppiert) an methoden übergeben wogegen Klassen als Referenz übergeben werden.
+Templates können verwendet werden um alle typen zu parameterisieren.
+
+```c
+// Hier, T ist ein Type-Parameter, Er funktioniert wie Generics in C#/Java/C++
+struct LinkedList(T) {
+    T data = null;
+    LinkedList!(T)* next; // Das ! wird verwendet um T zu übergeben. (<T> in C#/Java/C++)
+}
+
+class BinTree(T) {
+    T data = null;
+    
+    // Wenn es nur einen T parameter gibt können die Klammern um ihn weggelassen werden
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// Aliase können verwendet werden um die Entwicklung zu erleichtern
+
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+// Funktionen können genau so Templates beinhalten
+
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// Steht ref vor einem Parameter wird sichergestellt das er als Referenz übergeben wird.
+// Selbst bei werten wird es immer eine Referenz sein.
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// Templates können ebenso werte parameterisieren.
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3); // Standardmäßig ist T vom typ Integer
+
+```
+
+Wo wir schon bei Klassen sind - Wie wäre es mit Properties! Eine Property
+ist eine Funktion die wie ein Wert agiert. Das gibt uns viel klarere Syntax
+im Stil von `structure.x = 7` was gleichgültig wäre zu `structure.setX(7)`
+
+```c
+// Diese Klasse ist parameterisiert mit T, U
+
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+}
+
+// Ihre Getter und Setter Methoden sehen so aus
+class MyClass(T, U) {
+    T _data;
+    U _other;
+    
+    // Konstruktoren heißen immer `this`
+    this(T t, U u) {
+        data = t;
+        other = u;
+    }
+    
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters    
+	// @property kann genauso gut am ende der Methodensignatur stehen
+    void data(T t) @property {
+        _data = t;
+    }
+
+    void other(U u) @property {
+        _other = u;
+    }
+}
+// Und so kann man sie dann verwenden
+
+void main() {
+    auto mc = MyClass!(int, string);
+
+    mc.data = 7;
+    mc.other = "seven";
+    
+    writeln(mc.data);
+    writeln(mc.other);
+}
+```
+
+Mit properties können wir sehr viel logik hinter unseren gettern
+und settern hinter einer schönen syntax verstecken
+
+Other object-oriented goodies at our disposal
+Andere Objektorientierte features sind beispielsweise
+`interface`s, `abstract class` und `override`.
+Vererbung funktioniert in D wie in Java:
+Erben von einer Klasse, so viele interfaces wie man will.
+
+Jetzt haben wir Objektorientierung in D gesehen aber schauen
+wir uns noch was anderes an.
+D bietet funktionale programmierung mit _first-class functions_
+puren funktionen und unveränderbare daten.
+Zusätzlich können viele funktionale Algorithmen wie z.B
+map, filter, reduce und friends im `std.algorithm` Modul gefunden werden!
+
+```c
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // builds an end-exclusive range
+
+void main() {
+    // Wir wollen die summe aller quadratzahlen zwischen
+    // 1 und 100 ausgeben. Nichts leichter als das!
+ 
+    // Einfach eine lambda funktion als template parameter übergeben
+    // Es ist genau so gut möglich eine normale funktion hier zu übergeben
+	// Lambdas bieten sich hier aber an.
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+Ist dir aufgefallen wie wir eine Haskell-Style pipeline gebaut haben
+um num zu berechnen?
+Das war möglich durch die Uniform Function Call Syntax.
+Mit UFCS können wir auswählen ob wir eine Funktion als Methode oder
+als freie Funktion aufrufen. Walters artikel dazu findet ihr
+[hier.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) 
+Kurzgesagt kann man Funktionen deren erster parameter vom typ A ist, als
+Methode auf A anwenden.
+
+Parrallel Computing ist eine Tolle sache, findest du nicht auch?
+
+```c
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+    // Wir wollen die Wurzel von jeder Zahl in unserem Array berechnen
+    // und dabei alle Kerne verwenden die wir zur verfügung haben
+    auto arr = new double[1_000_000];
+
+    // Wir verwenden den index und das element als referenz
+    // und rufen einfach parallel auf!
+    foreach(i, ref elem; parallel(arr)) {
+        ref = sqrt(i + 1.0);
+    }
+}
+
+```
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index dea329d5..61f7bb67 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -33,6 +33,7 @@ Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichn
 * Ist offline einsetzbar.
 * Einfache Kollaboration!
 * Branching ist einfach!
+* Branching ist schnell!
 * Merging ist einfach!
 * Git ist schnell.
 * Git ist flexibel.
@@ -53,11 +54,11 @@ Das .git-Verzeichnis enthält alle Einstellung, Logs, Branches, den HEAD und meh
 
 ### Arbeitsverzeichnis (Teil des Repositorys)
 
-Dies sind die Verzeichnisse und Dateien in deinem Repository.
+Dies sind die Verzeichnisse und Dateien in deinem Repository, also z.B. dein Programmcode.
 
 ### Index (Teil des .git-Verzeichnisses)
 
-Der Index ist die die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
+Der Index ist die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
 
 ### Commit
 
@@ -84,7 +85,7 @@ Ein *head* ist ein Pointer, der auf einen beliebigen Commit zeigt.  Ein Reposito
 
 ### init
 
-Erstelle ein leeres Git-Repository. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
+Erstelle ein leeres Git-Repository im aktuellen Verzeichnis. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
 
 ```bash
 $ git init
@@ -180,6 +181,8 @@ Bringt alle Dateien im Arbeitsverzeichnis auf den Stand des Index oder des angeg
 ```bash
 # Ein Repo auschecken - wenn nicht anders angegeben ist das der master
 $ git checkout
+# Eine Datei auschecken - sie befindet sich dann auf dem aktuellen Stand im Repository
+$ git checkout /path/to/file
 # Einen bestimmten Branch auschecken
 $ git checkout branchName
 # Erstelle einen neuen Branch und wechsle zu ihm. Wie: "git branch <name>; git checkout <name>"
@@ -217,6 +220,9 @@ $ git diff --cached
 
 # Unterschiede zwischen deinem Arbeitsverzeichnis und dem aktuellsten Commit anzeigen
 $ git diff HEAD
+
+# Unterschiede zwischen dem Index und dem aktuellsten Commit (betrifft nur Dateien im Index)
+$ git diff --staged
 ```
 
 ### grep
@@ -374,3 +380,5 @@ $ 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/)
+
+* [gitflow - Ein Modell um mit Branches zu arbeiten](http://nvie.com/posts/a-successful-git-branching-model/)
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 94f48e65..817cb4ae 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -4,13 +4,14 @@ filename: learngo-de.go
 contributors:
     - ["Joseph Adams", "https://github.com/jcla1"]
     - ["Dennis Keller", "https://github.com/denniskeller"]
+translators:
     - ["Jerome Meinke", "https://github.com/jmeinke"]
 lang: de-de
 ---
 Die Sprache Go (auch golang) wurde von Google entwickelt und wird seit 2007
 benutzt. Go ähnelt in der Syntax der Sprache C, bietet darüber hinaus aber viele
-Vorteile. Einerseits verzichtet Gp auf Speicherarithmetik und
-benutzt einen Garbabe Collector. Andererseits enthält Go native Sprachelemente
+Vorteile. Einerseits verzichtet Go auf Speicherarithmetik und
+benutzt einen Garbage Collector. Andererseits enthält Go native Sprachelemente
 für die Unterstützung von Nebenläufigkeit. Durch den Fokus auf einen schnellen
 Kompilierprozess wird außerdem die Softwareentwicklung in Großprojekten
 erleichtert.
diff --git a/de-de/hack-de.html.markdown b/de-de/hack-de.html.markdown
new file mode 100644
index 00000000..42428130
--- /dev/null
+++ b/de-de/hack-de.html.markdown
@@ -0,0 +1,322 @@
+---
+language: Hack
+lang: de-de
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+    - ["David Lima", "https://github.com/davelima"]
+translators:
+    - ["Jerome Meinke", "https://github.com/jmeinke"]
+filename: learnhack-de.hh
+---
+
+Hack ist eine von Facebook neu entwickelte Programmiersprache auf Basis von PHP.
+Sie wird von der HipHop Virtual Machine (HHVM) ausgeführt. Die HHVM kann
+aufgrund der Ähnlichkeit der Programmiersprachen nicht nur Hack, sondern auch
+PHP-Code ausführen. Der wesentliche Unterschied zu PHP besteht in der statischen
+Typisierung der Sprache, die eine wesentlich höhere Performance erlaubt.
+
+
+Hier werden nur Hack-spezifische Eigenschaften beschrieben. Details über PHP's
+Syntax findet man im [PHP Artikel](http://learnxinyminutes.com/docs/php/) dieser
+Seite.
+
+```php
+<?hh
+
+// Hack-Syntax ist nur für Dateien aktiv, die mit dem <?hh Prefix starten.
+// Der <?hh Prefix kann nicht wie <?php mit HTML gemischt werden.
+// Benutzung von "<?hh //strict" aktiviert den Strikt-Modus des Type-Checkers.
+
+
+// Typisierung für Funktions-Argumente
+function repeat(string $word, int $count)
+{
+    $word = trim($word);
+    return str_repeat($word . ' ', $count);
+}
+
+// Typisierung für Rückgabewerte
+function add(...$numbers) : int
+{
+    return array_sum($numbers);
+}
+
+// Funktionen ohne Rückgabewert, werden mit "void" typisiert
+function truncate(resource $handle) : void
+{
+    // ...
+}
+
+// Typisierung unterstützt die explizit optionale Ein- / Ausgabe von "null"
+function identity(?string $stringOrNull) : ?string
+{
+    return $stringOrNull;
+}
+
+// Typisierung von Klassen-Eigenschaften
+class TypeHintedProperties
+{
+    public ?string $name;
+
+    protected int $id;
+
+    private float $score = 100.0;
+
+    // Hack erfordert es, dass typisierte Eigenschaften (also "non-null")
+    // einen Default-Wert haben oder im Konstruktor initialisiert werden.
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Kurzgefasste anonyme Funktionen (lambdas)
+$multiplier = 5;
+array_map($y ==> $y * $multiplier, [1, 2, 3]);
+
+
+// Weitere, spezielle Felder (Generics)
+// Diese kann man sich als ein zugreifbares Interface vorstellen
+class Box<T>
+{
+    protected T $data;
+
+    public function __construct(T $data) {
+        $this->data = $data;
+    }
+
+    public function getData(): T {
+        return $this->data;
+    }
+}
+
+function openBox(Box<int> $box) : int
+{
+    return $box->getData();
+}
+
+
+// Formen
+//
+// Hack fügt das Konzept von Formen hinzu, wie struct-ähnliche arrays
+// mit einer typ-geprüften Menge von Schlüsseln
+type Point2D = shape('x' => int, 'y' => int);
+
+function distance(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distance(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Typen-Definition bzw. Aliasing
+//
+// Hack erlaubt es Typen zu definieren und sorgt somit für bessere Lesbarkeit
+newtype VectorArray = array<int, Vector<int>>;
+
+// Ein Tupel mit zwei Integern
+newtype Point = (int, int);
+
+function addPoints(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+addPoints(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// Erstklassige Aufzählungen (enums)
+enum RoadType : int
+{
+    Road = 0;
+    Street = 1;
+    Avenue = 2;
+    Boulevard = 3;
+}
+
+function getRoadType() : RoadType
+{
+    return RoadType::Avenue;
+}
+
+
+// Automatische Erstellung von Klassen-Eigenschaften durch Konstruktor-Argumente
+//
+// Wiederkehrende Definitionen von Klassen-Eigenschaften können durch die Hack-
+// Syntax vermieden werden. Hack erlaubt es die Klassen-Eigenschaften über
+// Argumente des Konstruktors zu definieren.
+class ArgumentPromotion
+{
+    public function __construct(public string $name,
+                                protected int $age,
+                                private bool $isAwesome) {}
+}
+
+class WithoutArgumentPromotion
+{
+    public string $name;
+
+    protected int $age;
+
+    private bool $isAwesome;
+
+    public function __construct(string $name, int $age, bool $isAwesome)
+    {
+        $this->name = $name;
+        $this->age = $age;
+        $this->isAwesome = $isAwesome;
+    }
+}
+
+
+// Kooperatives Multitasking
+//
+// Die Schlüsselworte "async" and "await" führen Multitasking ein.
+// Achtung, hier werden keine Threads benutzt, sondern nur Aktivität getauscht.
+async function cooperativePrint(int $start, int $end) : Awaitable<void>
+{
+    for ($i = $start; $i <= $end; $i++) {
+        echo "$i ";
+
+        // Geben anderen Tasks die Möglichkeit aktiv zu werden
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Die Ausgabe von folgendem Code ist "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    cooperativePrint(1, 3),
+    cooperativePrint(4, 6),
+    cooperativePrint(7, 9)
+])->getWaitHandle()->join();
+
+
+// Attribute
+//
+// Attribute repräsentieren eine Form von Metadaten für Funktionen.
+// Hack bietet Spezial-Attribute, die nützliche Eigenschaften mit sich bringen.
+
+// Das __Memoize Attribut erlaubt es die Ausgabe einer Funktion zu cachen.
+<<__Memoize>>
+function doExpensiveTask() : ?string
+{
+    return file_get_contents('http://example.com');
+}
+
+// Der Funktionsrumpf wird im Folgenden nur ein einziges mal ausgeführt:
+doExpensiveTask();
+doExpensiveTask();
+
+
+// Das __ConsistentConstruct Attribut signalisiert dem type-checker, dass
+// die Funktionsdeklaration von __construct für alle Unterklassen dieselbe ist.
+<<__ConsistentConstruct>>
+class ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class ConsistentBar extends ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // Der Type-checker erzwingt den Aufruf des Eltern-Klassen-Konstruktors
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // Das __Override Attribut ist ein optionales Signal an den Type-Checker,
+    // das erzwingt, dass die annotierte Methode die Methode der Eltern-Klasse
+    // oder des Traits verändert.
+    <<__Override>>
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class InvalidFooSubclass extends ConsistentFoo
+{
+    // Wenn der Konstruktor der Eltern-Klasse nicht übernommen wird,
+    // wird der Type-Checker einen Fehler ausgeben:
+    //
+    //  "This object is of type ConsistentBaz. It is incompatible with this object
+    //   of type ConsistentFoo because some of their methods are incompatible"
+    //
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Auch bei der Benutzung des __Override Attributs für eine nicht veränderte
+    // Methode wird vom Type-Checker eine Fehler ausgegeben:
+    //
+    //  "InvalidFooSubclass::otherMethod() is marked as override; no non-private
+    //   parent definition found or overridden parent is defined in non-<?hh code"
+    //
+    <<__Override>>
+    public function otherMethod()
+    {
+        // ...
+    }
+}
+
+// Ein Trait ist ein Begriff aus der objektorientierten Programmierung und
+// beschreibt eine wiederverwendbare Sammlung von Methoden und Attributen,
+// ähnlich einer Klasse.
+
+// Anders als in PHP können Traits auch als Schnittstellen (Interfaces)
+// implementiert werden und selbst Schnittstellen implementieren.
+interface KittenInterface
+{
+    public function play() : void;
+}
+
+trait CatTrait implements KittenInterface
+{
+    public function play() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use CatTrait;
+}
+
+
+$cat = new Samuel();
+$cat instanceof KittenInterface === true; // True
+
+```
+
+## Weitere Informationen
+
+Die Hack [Programmiersprachen-Referenz](http://docs.hhvm.com/manual/de/hacklangref.php)
+erklärt die neuen Eigenschaften der Sprache detailliert auf Englisch. Für
+allgemeine Informationen kann man auch die offizielle Webseite [hacklang.org](http://hacklang.org/)
+besuchen.
+
+Die offizielle Webseite [hhvm.com](http://hhvm.com/) bietet Infos zum Download
+und zur Installation der HHVM.
+
+Hack's [nicht-untersützte PHP Syntax-Elemente](http://docs.hhvm.com/manual/en/hack.unsupported.php)
+werden im offiziellen Handbuch beschrieben.
diff --git a/de-de/haml-de.html.markdown b/de-de/haml-de.html.markdown
new file mode 100644
index 00000000..7272b365
--- /dev/null
+++ b/de-de/haml-de.html.markdown
@@ -0,0 +1,156 @@
+---
+language: haml
+filename: learnhaml-de.haml
+contributors:
+  - ["Simon Neveu", "https://github.com/sneveu"]
+  - ["Sol Bekic", "https://github.com/S0lll0s"]
+lang: de-de
+---
+
+Haml ist eine Markup- und Templatingsprache, aufgesetzt auf Ruby, mit der HTML Dokumente einfach beschrieben werden können.
+
+Haml vermindert Wiederholung und Fehleranfälligkeit, indem es Tags basierend auf der Markup-Struktur schließt und schachtelt.
+Dadurch ergibt sich kurzes, präzises und logisches Markup.
+
+Haml kann außerhalb eines Ruby-projekts verwendet werden. Mit dem installierten Haml gem kann man das Terminal benutzen um Haml zu HTML umzuwandeln:
+
+$ haml input_file.haml output_file.html
+
+
+```haml
+/ -------------------------------------------
+/ Einrückung
+/ -------------------------------------------
+
+/
+  Einrückung ist ein wichtiges Element des Haml Syntax, deswegen ist es
+  wichtig ein konsequentes Schema zu verwenden. Meistens werden zwei spaces
+  verwendet, solange die Einrückungen das gleiche Schema verfolgen können
+  aber auch andere Breiten und Tabs verwendet werden
+
+
+/ -------------------------------------------
+/ Kommentare
+/ -------------------------------------------
+
+/ Kommentare beginnen mit einem Slash
+
+/
+  Mehrzeilige Kommentare werden eingerückt und mit einem Slash
+  eingeführt
+
+-# Diese Zeile ist ein "stummes" Kommentar, es wird nicht mitgerendert
+
+
+/ -------------------------------------------
+/ HTML Elemente
+/ -------------------------------------------
+
+/ Tags werden durch ein Prozentzeichen und den Tagnamen erzeugt
+%body
+  %header
+    %nav
+
+/ Die Zeilen oben würden folgendes ergeben:
+  <body>
+    <header>
+      <nav></nav>
+    </header>
+  </body>
+
+/ Text kann direkt nach dem Tagnamen eingefügt werden:
+%h1 Headline copy
+
+/ Mehrzeilige Inhalte müssen stattdessen eingerückt werden:
+%p 
+  This is a lot of content that we could probably split onto two
+  separate lines.
+
+/ 
+  HTML kann mit &= escaped werden. So werden HTML-sensitive Zeichen
+  enkodiert. Zum Beispiel:
+
+%p
+  &= "Ja & Nein"
+
+/ würde 'Ja &amp; Nein' ergeben
+
+/ HTML kann mit != dekodiert werden:
+%p
+  != "so schreibt man ein Paragraph-Tag: <p></p>"
+
+/ ...was 'This is how you write a paragraph tag <p></p>' ergeben würde
+
+/ CSS Klassen können mit '.classname' an Tags angehängt werden:
+%div.foo.bar
+
+/ oder über einen Ruby Hash:
+%div{:class => 'foo bar'}
+
+/ Das div Tag wird standardmäßig verwendet, divs können also verkürzt werden:
+.foo
+
+/ andere Attribute können über den Hash angegeben werden:
+%a{:href => '#', :class => 'bar', :title => 'Bar'}
+
+/ Booleesche Attribute können mit 'true' gesetzt werden:
+%input{:selected => true}
+
+/ data-Attribute können in einem eigenen Hash im :data key angegeben werden:
+%div{:data => {:attribute => 'foo'}}
+
+
+/ -------------------------------------------
+/ Verwendung von Ruby
+/ -------------------------------------------
+
+/ Mit dem = Zeichen können Ruby-werte evaluiert und als Tag-text verwendet werden:
+
+%h1= book.name
+
+%p
+  = book.author
+  = book.publisher
+
+
+/ Code nach einem Bindestrich wird ausgeführt aber nicht gerendert:
+- books = ['book 1', 'book 2', 'book 3']
+
+/ So können zum Beispiel auch Blöcke verwendet werden:
+- books.shuffle.each_with_index do |book, index|
+  %h1= book
+
+  if book do
+    %p This is a book
+
+/
+  Auch hier werden wieder keine End-Tags benötigt!
+  Diese ergeben sich aus der Einrückung.
+
+
+/ -------------------------------------------
+/ Inline Ruby / Ruby Interpolation
+/ -------------------------------------------
+
+/ Ruby variablen können mit #{} in Text interpoliert werden:
+%p dein bestes Spiel ist #{best_game}
+
+
+/ -------------------------------------------
+/ Filter
+/ -------------------------------------------
+
+/
+  Mit dem Doppelpinkt können Haml Filter benutzt werden.
+  Zum Beispiel gibt es den :javascript Filter, mit dem inline JS
+  geschrieben werden kann:
+
+:javascript
+  console.log('Dies ist ein <script>');
+
+```
+
+## Weitere Resourcen
+
+- [What is HAML?](http://haml.info/) - Eine gute Einleitung auf der Haml homepage (englisch)
+- [Official Docs](http://haml.info/docs/yardoc/file.REFERENCE.html) - Die offizielle Haml Referenz (englisch)
diff --git a/de-de/haskell-de.html.markdown b/de-de/haskell-de.html.markdown
index d1a0008e..5d17ccc7 100644
--- a/de-de/haskell-de.html.markdown
+++ b/de-de/haskell-de.html.markdown
@@ -100,7 +100,7 @@ not False -- True
 [1..] !! 999 -- 1000
 
 -- Haskell evaluiert nun die ersten 1 - 1000 Elemente, aber der Rest der Liste
--- bleibt unangetastet. Haskell wird sie solange nicht weiterevalieren
+-- bleibt unangetastet. Haskell wird sie solange nicht weiterevaluieren
 -- bis es muss.
 
 -- Zwei Listen konkatenieren
@@ -115,7 +115,7 @@ tail [1..5] -- [2, 3, 4, 5]
 init [1..5] -- [1, 2, 3, 4]
 last [1..5] -- 5
 
--- list comprehensions | Listen erschaffen
+-- Listen erschaffen ("list comprehensions")
 [x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
 
 -- Mit Bedingungen
@@ -179,7 +179,7 @@ myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
 
 -- Fold (`inject` in einigen Sprachen)
 -- Foldl1 bedeutet: fold von links nach rechts und nehme den ersten
--- Wert der Liste als Basiswert f[r den Akkumulator.
+-- Wert der Liste als Basiswert für den Akkumulator.
 foldl1 (\acc x -> acc + x) [1..5] -- 15
 
 ----------------------------------------------------
@@ -201,7 +201,7 @@ foo 5 -- 15
 
 -- Funktionskomposition
 -- Die (.) Funktion verkettet Funktionen.
--- Zum Beispiel, die Funktion Foo nimmt ein Argument addiert 10 dazu und
+-- Zum Beispiel, die Funktion Foo nimmt ein Argument, addiert 10 dazu und
 -- multipliziert dieses Ergebnis mit 4.
 foo = (*4) . (+10)
 
@@ -212,7 +212,7 @@ foo 5 -- 60
 -- Haskell hat einen Operator `$`, welcher Funktionsapplikation durchführt.
 -- Im Gegenzug zu der Standard-Funktionsapplikation, welche linksassoziativ ist
 -- und die höchstmögliche Priorität von "10" hat, ist der `$`-Operator
--- rechtsassoziativ und hat die Priorität 0. Dieses hat (idr.) den Effekt,
+-- rechtsassoziativ und hat die Priorität 0. Dieses hat (i.d.R.) den Effekt,
 -- dass der `komplette` Ausdruck auf der rechten Seite als Parameter für die
 -- Funktion auf der linken Seite verwendet wird.
 -- Mit `.` und `$` kann man sich so viele Klammern ersparen.
@@ -283,7 +283,7 @@ for [0..5] $ \i -> show i
 for [0..5] show
 
 -- foldl oder foldr reduziren Listen auf einen Wert.
--- foldl <fn> <initial value> <list>
+-- foldl <Funktion> <initialer Wert> <Liste>
 foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
 
 -- die Abarbeitung sieht so aus:
@@ -435,7 +435,7 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
 ```
 
 Haskell ist sehr einfach zu installieren.
-Hohl es dir von [hier](http://www.haskell.org/platform/).
+Hol es dir von [hier](http://www.haskell.org/platform/).
 
 Eine sehr viele langsamere Einführung findest du unter:
 [Learn you a Haskell](http://learnyouahaskell.com/) oder
diff --git a/de-de/html-de.html.markdown b/de-de/html-de.html.markdown
new file mode 100644
index 00000000..2ee18129
--- /dev/null
+++ b/de-de/html-de.html.markdown
@@ -0,0 +1,120 @@
+---
+language: html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+filename: learnhtml-de.html
+lang: de-de
+---
+
+HTML steht für HyperText Markup Language (Hypertext-Auszeichnungssprache).
+Sie ist eine Sprache, um Seiten für das World Wide Web zu schreiben..
+Es ist eine Auszeichnugssprache, die es uns ermöglicht Webseiten mithilfe des Codes zu schreiben, der kennzeichnet  wie Text und Daten angezeigt werden sollen. Eigentlich sind HTML Dateien nur einfache Textdateien.
+Was sind das für Auszeichnungen? Es ist eine Methode, um die Daten der Website zu organisieren mithilfe von Start- und Endtags.
+Diese Auszeichnung dient dazu dem Text Bedeutung zu geben, welchen sie umschließt.
+Wie viele andere Computersprachen auch, besitzt HTML viele Versionen. Wir werden hier über HTML5 reden.
+
+**NOTE :**  Du kannst die unterschiedlichen Tags und Elemente, während des Tutorials auf Seiten, wie [codepen](http://codepen.io/pen/) testen, um deren Effekte zu sehen und wie diese funktionieren. Auch kannst du dich damit besser mit der Sprache vertraut machen.
+Dieser Artikel ist bedacht darauf, nur HTML Syntax und nützliche Tipps zu geben.
+
+
+```html
+<!-- Kommentare werden wie in dieser Zeile geschrieben -->
+
+<!-- #################### Die Tags #################### -->
+
+<!-- Hier ist eine Beispiel HTML Datei, die wir analysieren werden -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Meine Website</title>
+		</head>
+		<body>
+			<h1>Hallo Welt!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">Komm schau was das hier anzeigt</a>
+			<p>Das ist ein Paragraf.</p>
+			<p>Das ist ein weiterer Paragraf.</p>
+			<ul>
+				<li>Das ist eine Item mit einer nicht-nummerierten Liste (Aufzählungsliste)</li>
+				<li>Das ist ein weiteres Item</li>
+				<li>Und das ist das letzte Item in der Liste</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- Jede HTML Datei startet damit dem Browser zu sagen, dass die Seite aus HTML besteht. -->
+<!doctype html>
+
+<!-- Danach startet sie mit einem Öffnungtag <html>. -->
+<html>
+
+<!-- Dieser wird am Ende der Datei mit</html> geschlossen. -->
+</html>
+
+<!-- Nichts sollte nach diesen finalen Tag erscheinen. -->
+
+<!-- Dazwischen (Zwischen dem Öffnungs- und Schließungstag <html></html>) finden wir: -->
+
+<!-- Ein Kopf wird definiert mit <head> (er muss mit </head> geschlossen werden). -->
+<!-- Der Header beinhaltet Beschreibungen und zusätzliche Informationen, welche nicht dargestellt werden. Das sind Metadaten. -->
+
+<head>
+	<title>Meine Seite</title><!-- Der <title> kennzeichnet dem Browser den Titel im Browserfenster und im Tabnamen anzuzeigen. -->
+</head>
+
+<!-- Nach dem <head> Bereich findet sich der <body> Tag -->
+<!-- Bis zu diesen Punkt wird nichts im Browerfenster angezeigt. -->
+<!-- Wir müssen den Body mit dem Inhalt füllen der angezeigt werden soll. -->
+
+<body>
+	<h1>Hallo, Welt!</h1> <!-- Der h1 Tag erstellt einen Titel. -->
+	<!-- Es gibt auch Untertitel für <h1> von den wichtigsten <h2> zu den Unwichtigsten (h6). -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">Komm, schaue was das zeigt</a> <!-- Eine URL wird zum Hyperlink, wenn es das Attribut href=""  -->
+	<p>Das ist ein Absatz.</p> <!-- Der Tag <p> lässt uns Text auf die HTML Seite hinzufügen. -->
+	<p>Das ist ein anderer Absatz.</p>
+	<ul> <!-- Der <ul> Tag erstellt eine Aufzählungsliste. -->
+	<!-- Für eine nummerierte Liste sollten wir stattdessen <ol> verwenden. Das erste Element bekommt 1., das zweite 2. usw. -->
+		<li>Das ist ein Element in einer nicht Aufzählungsliste</li>
+		<li>Das ist ein anderes Item</li>
+		<li>Und das ist das letzte Element in der List</li>
+	</ul>
+</body>
+
+<!-- Und das war es. Eine HTML Datei kann so simpel sein. -->
+
+<!-- Aber es ist möglich viele weitere zusätzliche HTML tags hinzuzufügen. -->
+
+<!-- Um ein Bild hinzuzufügen. -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- Die Quelle des Bildes wird gezeigt durch das Attribut src="" -->
+<!-- Die Quelle kann eine URL sein oder ein Pfad zu deinem Computer. -->
+
+<!-- Es ist ebenso möglich eine Tabelle zu erstellen. -->
+
+<table> <!-- Wir öffnen ein <table> Element. -->
+	<tr> <!-- <tr> erlaubt es uns Reihe zu erstellen. -->
+		<th>Erster Tabellenkopf</th> <!-- <th> erlaubt es uns der Tabelle einen Titel zu geben. -->
+		<th>Zweiter Tabllenkopf</th>
+	</tr>
+	<tr>
+		<td>Erste Zeile, erste Spalte</td> <!-- <td> erlaubt es eine Tabellenzelle zu erstellen. -->
+		<td>Erste Zeile, zweite Spalte</td>
+	</tr>
+	<tr>
+		<td>Zweite Zeile, erste Spalte</td>
+		<td>Zweite Zeile, zweite Spalte</td>
+	</tr>
+</table>
+
+```
+
+## Verwendung
+
+HTML Dateien enden mit `.html`.
+
+## Um mehr zu lernen
+
+* [wikipedia (EN)](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial (EN)](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School (EN)](http://www.w3schools.com/html/html_intro.asp)
diff --git a/de-de/java-de.html.markdown b/de-de/java-de.html.markdown
new file mode 100644
index 00000000..934819f9
--- /dev/null
+++ b/de-de/java-de.html.markdown
@@ -0,0 +1,497 @@
+---
+language: java
+filename: LearnJavaDe.java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
+translators:
+    - ["Michael Dähnert", "http://github.com/JaXt0r"]
+lang: de-de
+---
+
+Java ist eine Programmiersprache für vielfältige Aufgaben. Sie ist imperative und objektorientiert.
+Oftmals wird sie für Desktop- Webapplikationen sowie als Programmiersprache im Betriebssystem Android verwendet.
+[Weitere Informationen \(Englisch\)](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Einzeilige Kommentare starten mit //
+/*
+Mehrzeilige Kommentare sehen so aus.
+*/
+/**
+JavaDoc Kommentare haben dieses Format. Sie werden verwendet um Klassen, Attribute sowie Methoden zu beschreiben.
+*/
+
+// Importieren der Klasse ArrayList aus dem Paket java.util
+import java.util.ArrayList;
+// Importieren aller Klassen innerhalb des Paketes java.security
+import java.security.*;
+
+// Jede .java Datei besteht aus einer äußeren öffentlichen (public) Klasse.
+// Der Name der Klasse muss identisch des Dateinamens sein.
+public class LearnJavaDe {
+
+    // Ein Programm muss eine main Methode als Eintrittspunkt besitzen.
+    public static void main (String[] args) {
+
+        // System.out.println() wird zum Schreiben von zeilenweisen Ausgaben verwendet.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Zum Schreiben von Ausgaben ohne Zeilenumbruch wird System.out.print() verwendet.
+        System.out.print("Hello ");
+        System.out.print("World");
+
+
+        ///////////////////////////////////////
+        // Typen & Variablen
+        ///////////////////////////////////////
+
+        // Zum Deklarieren einer Variable nutze <type> <name>
+        // Byte - 8-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - 16-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - 64-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L wird verwendet um zu kennzeichnen, dass ein Variablenwert vom Typ long ist.
+        // Ohne diesen Buchstaben wird die Zahl automatisch als Integer behandelt.
+
+        // Hinweis: Java besitzt keine vorzeichenlosen (unsigned) Typen.
+
+        // Float - Typ mit einfacher Genauigkeit (Single-precision), 32-bit IEEE 754 Fließkommazahl
+        float fooFloat = 234.5f;
+        // f wird verwendet um zu kennzeichnen, dass ein Variablenwert vom Typ float ist;
+        // Ohne diesen Buchstaben wird die Zahl automatisch als Integer behandelt.
+
+        // Double - Typ mit doppelter Genauigkeit (Double-precision), 64-bit IEEE 754 Fließkommazahl
+        double fooDouble = 123.4;
+
+        // Boolean - Wahr & Falsch (true & false)
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - Ein einfacher 16-bit Unicode Buchstabe
+        char fooChar = 'A';
+
+        // final Variablen können von einem anderen Objekt nicht erneut zugeordnet werden.
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+
+        // Zeichenketten (Strings)
+        String fooString = "My String Is Here!";
+
+        // \n ist ein Escape Zeichen welcher eine neue Zeile startet.
+        String barString = "Schreiben auf einer neuen Zeile?\nKein Problem!";
+        // \t ist ein Escape Zeichen welcher einen Tab-Zeichen anhängt.
+        String bazString = "Möchtest du einen Tabulator anhängen?\tKein Problem!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Arrays
+        // Die Arraygröße muss bei Instanziierung entschieden werden.
+        // Das folgende Format funktioniert bei Deklaration eines Arrays
+        // <datentyp>[] <variablenname> = new <datentyp>[<arraygröße>];
+        // <datentyp> <variablenname>[] = new <datentyp>[<arraygröße>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Eine weitere Möglichkeit ein Array zu deklarieren & initialisieren.
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Indexierung eines Arrays - Zugriff auf ein Element
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Arrays sind 0-indexiert und veränderbar.
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Weitere nennenswerte Typen
+        // ArrayLists - Ähnlich Arrays, allerdings werden mehr Funktionen geboten,
+        //            ebenso ist die Arraygröße verwänderbar
+        // LinkedLists - Implementierung einer doppelt verlinkten Liste.
+        //            Alle Operationen funktioneren so, wie es von einer doppelt verlinkten Liste erwartet wird.
+        //            Weitere Informationen: https://de.wikipedia.org/wiki/Liste_(Datenstruktur)#Doppelt_.28mehrfach.29_verkettete_Liste
+        // Maps - Eine Sammlung von Objekten, welche eine Verknüpfung von Schlüsseln zu Werten (key => value) vornimmt.
+        //            Eine Map kann keine Duplikate enthalten; Jeder Schlüssel kann genau einen Wert beinhalten.
+        // HashMaps - Diese Klasse nutzt eine Hashtabelle zur Implementierung eines Map Interfaces.
+        //            Dies erlaubt es zur Laufzeit Standardoperationen wie gib (get) und einfügen (insert)
+        //            selbst für große Mengen in einer konstanten Zeit auszuführen (Laufzeitverhalten O(n)).
+
+        ///////////////////////////////////////
+        // Operatoren
+        ///////////////////////////////////////
+        System.out.println("\n->Operatoren");
+
+        int i1 = 1, i2 = 2; // Kurform zur Deklaration mehrerer Variablen.
+
+        // Arithmetische Operationen sind einfach nutzbar.
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 Nachkommazahl abgeschnitten)
+
+        // Modulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Vergleichsoperationen
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Bitwise Operatoren!
+        /*
+        ~      Unäres (unary) bitweise Komplement
+        <<     Vorzeichenbehaftete (signed) linke Verschiebung
+        >>     Vorzeichenbehaftete (signed) rechte Verschiebung
+        >>>    Vorzeichenlose (unsigned) linke Verschiebung
+        &      Bitweise UND (AND)
+        ^      Bitweise exklusive ODER (OR)
+        |      Bitweise inklusive ODER (OR)
+        */
+
+        // Inkrementierungen
+        int i = 0;
+        System.out.println("\n->Inc/Dec-rementierung");
+        // Die ++ und -- operatoren inkrementieren und dekrementieren jeweils um 1.
+        // Werden sie vor die Variable gesetzt, ink-/dekrementieren sie und geben anschließend ihren Wert zurück.
+        // Hinter der Variable geben sie ihren Wert zurück und ändern ihn anschließend.
+        System.out.println(i++); // i = 1, schreibt 0 (post-increment)
+        System.out.println(++i); // i = 2, schreibt 2 (pre-increment)
+        System.out.println(i--); // i = 1, schreibt 2 (post-decrement)
+        System.out.println(--i); // i = 0, schreibt 0 (pre-decrement)
+
+        ///////////////////////////////////////
+        // Kontrollstrukturen
+        ///////////////////////////////////////
+        System.out.println("\n->Kontrollstrukturen");
+
+        // If Bedingungen sind wie in den C-Sprachen aufgebaut
+        int j = 10;
+        if (j == 10){
+            System.out.println("Ich wurde geprinted");
+        } else if (j > 10) {
+            System.out.println("Ich nicht");
+        } else {
+            System.out.println("Ich auch nicht");
+        }
+
+        // While Schleife
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Den Zähler inkrementieren
+            // 100x iterieren, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("fooWhile Wert: " + fooWhile);
+
+        // Do While Schleife
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Den Zähler inkrementieren
+            // 99x iterieren, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("fooDoWhile Wert: " + fooDoWhile);
+
+        // For Schleife
+        int fooFor;
+        // for Schleifenstruktur => for(<start_statement>; <Bedingung>; <Schritt>)
+        for (fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // 10x iterieren, fooFor 0->9
+        }
+        System.out.println("fooFor Wert: " + fooFor);
+
+        // For Each Schleife
+        // The for Schleife kann verwendet werden um über Arrays ebenso wie Objekte,
+        // welche das Interface Iterable implementieren zu iterieren.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // for each Schleifenstruktur => for (<Objekt> : <iterable>)
+        // Wird gelesen als: Iteriere für jedes Element im Iterable
+        // Hinweis: Der Objekttyp muss dem Elementtyp des Iterable entsprechen.
+
+        for (int bar : fooList) {
+            System.out.println(bar);
+            //9x iterieren und die Werte 1-9 auf jeweils einer neuen Zeile schreiben
+        }
+
+        // Switch Case
+        // A Schalter (switch) funktioniert mit den Datentypen byte, short, char und int.
+        // Ebenso kann er für Aufzählungen (Enums) verwendet werden (Enum Typen folgen weiter unten)
+        // der String Klasse (ab Java SE7) und ein paar spezielle Klassen, welche die primitiven Typen ummanteln (wrap):
+        // Character, Byte, Short, and Integer.
+        int monat = 3;
+        String monatsString;
+        switch (monat) {
+            case 1: monatsString = "Januar";
+                    break;
+            case 2: monatsString = "Februar";
+                    break;
+            case 3: monatsString = "März";
+                    break;
+            default: monatsString = "Ein anderer Monat";
+                     break;
+        }
+        System.out.println("Switch Case Ergebnis: " + monatsString);
+
+        // Bedingungsoperator (Conditional Shorthand)
+        // Der Operator '?' kann für schnelle Zuweisungen oder logische Verzweigungen genutzt werden.
+        // Er ist wie folgt zu lesen: Wenn die Bedingung wahr ist, nutze <erster Wert>
+        // ansonsten nutze <zweiter Wert>
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Schreibt A, denn die Bedingung ist wahr.
+
+
+        ////////////////////////////////////////
+        // Typkonvertierung und Type-Casting
+        ////////////////////////////////////////
+
+        // Konvertierung von Daten
+
+        // Konvertiere String nach Integer
+        Integer.parseInt("123");// Gibt die Integer Repräsentation von "123" zurück
+
+        // Konvertiere String nach Integer
+        Integer.toString(123);// Gibt die String Repräsentation von 123 zurück
+
+        // Für andere Konvertierungen sind die folgenden Klassen zu betrachten:
+        // Double
+        // Long
+        // String
+
+        // Tpe-Casting
+        // Java Objekte können benfalls konvertiert werden, hierbei gibt es vielfältige Konzepte.
+        // Weitere Informationen finden sich hier (englisch):
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Klassen und Funktionen
+        ///////////////////////////////////////
+
+        System.out.println("\n->Klassen & Funktionen");
+
+        // (Die Definition der Klasse Fahrrad folgt)
+
+        // Verwendung einer neuen Klasseninstanz
+        Fahrrad trek = new Fahrrad();
+
+        // Aufruf von Methoden des Objektes
+        trek.erhöheGeschwindigkeit(3); // Es sollten immer getter- und setter- Methoden verwendet werden
+        trek.setTrittfrequenz(100);
+
+        // toString gibt die StringRepräsentation des Objektes zurück.
+        System.out.println("trek info: " + trek.toString());
+
+    } // Ende der Main Methode
+} // Ende der LearnJavaDe Klasse
+
+
+// In einer .java-Datei können zusätzliche nicht öffentliche (non-public) äüßere Klassen vorhanden sein.
+
+
+// Syntax der Klassendeklaration:
+// <public/private/protected> class <Klassenname> {
+//    // Es folgen Datenfelder, Konstruktoren, Funktionen.
+//    // Funktionen werden in Java Methoden genannt.
+// }
+
+class Fahrrad {
+
+    // Felder/Variablen der Klasse Fahrrad
+    public int trittfrequenz; // Public: Kann von überall her angesprochen werden
+    private int geschwindigkeit;  // Private: Nur innerhalb der Klasse sichtbar
+    protected int gang; // Protected: Erreichbar innerhalb der Klasse oder Subklassen (sub classes)
+    String name; // default: Nur innerhalb des Paketes verwendbar
+
+    // Eine Klasse kann mittelst Konstruktoren erstellt werden.
+    // Das ist ein Konstruktor
+    public Fahrrad() {
+        gang = 1;
+        trittfrequenz = 50;
+        geschwindigkeit = 5;
+        name = "Bontrager";
+    }
+
+    // Das ist ein Konstruktor mit Argumenten
+    public Bicycle(int initialTrittfrequenz, int initialGeschwindigkeit, int initialGang,
+        String name) {
+        this.gang = initialGang;
+        this.trittfrequenz = initialTrittfrequenz;
+        this.geschwindigkeit = initialGeschwindigkeit;
+        this.name = name;
+    }
+
+    // Syntax von Methoden (Funktionen):
+    // <public/private/protected> <Rückgabetyp> <Funktionsname>(<Argumente>)
+
+    // Java Klassen implementieren oftmals getter- und setter-Methoden ihrer Felder
+
+    // Syntax von Methodendeklarationen:
+    // <Sichtbarkeit> <Rückgabetyp> <Methodenname>(<Argumente>)
+    public int getTrittfrequenz() {
+        return tri;
+    }
+
+    // void Methoden benötigen kein return Statement.
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+
+    public void erhöheGeschwindigkeit(int increment) {
+        speed += increment;
+    }
+
+    public void verringereGeschwindigkeit(int decrement) {
+        speed -= decrement;
+    }
+
+    public void setName(String newName) {
+        name = newName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    //Methode zur Darstellung der Attributwerte des Objektes.
+    @Override
+    public String toString() {
+        return "Gang: " + gang + " Trittfrequenz: " + trittfrequenz + " Geschwindigkeit: " + geschwindigkeit +
+            " name: " + name;
+    }
+} // Ende der Klasse Fahrrad
+
+// Hochrad ist eine Subklasse von Fahrrad
+class Hochrad extends Fahrrad {
+    // (Hochräder sind Fahrräder mit einem extrem großen Vorderrad.
+    // Sie haben keine Gänge.)
+
+    public Hochrad(int initialTrittfrequenz, int initialGeschwindigkeit){
+        // Aufruf des Vater-Konstruktors (parent constructor) mit dem Wort super.
+        super(initialTrittfrequenz, initialGeschwindigkeit, 0, "Hochrad");
+    }
+
+    // Überschriebene Methoden sollten die Annotation @Override besitzen.
+    // Mehr zu Annotationen und deren Verwendungszwecken kann hier nachgelesen werden:
+    // (englisch) http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGang(int gang) {
+        gang = 0;
+    }
+}
+
+// Schnittstellen (Interfaces)
+// Interface Deklaration
+// <Zugriffsrecht> interface <Name> extends <super-Interface> {
+//     // Konstanten
+//     // Methodendeklarationen
+// }
+
+// Beispiel - Nahrung:
+public interface Essbar {
+	public void essen(); // Jede Klasse, die dieses Interface implementiert
+                       // muss auch diese Methode implementieren.
+}                       
+
+
+public interface Verdaulich {
+	public void verdauen();
+}
+
+
+// Nun können wir eine Klasse erstellen, die beide Interfaces implementiert.
+public class Frucht implements Essbar, Verdaulich {
+    @Override
+	public void essen() {
+		// ...
+	}
+
+    @Override
+	public void verdauen() {
+		// ...
+	}
+}
+
+// Mit Java kann man nur eine Klasse erweitern (extends) jedoch mehrere Interfaces implementieren.
+// z.B.:
+public class BeispielKlasse extends ParentBeispielKlasse implements InterfaceEins,
+    InterfaceZwei {
+    @Override
+	public void methodeInterfaceEins() {
+	}
+
+    @Override
+	public void methodeInterfaceZwei() {
+	}
+}
+```
+
+## Weitere Informationen (in englisch)
+
+Die folgenden Links dienen lediglich dazu Verständnis für die Kapitel aufzubauen.
+Für tiefergreifende Fragen ist Google der beste Startpunkt.
+
+**Offizielle Oracle Guides**:
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)
+
+**Online Tutorials**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Bücher**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
diff --git a/de-de/lua-de.html.markdown b/de-de/lua-de.html.markdown
new file mode 100644
index 00000000..83f8506c
--- /dev/null
+++ b/de-de/lua-de.html.markdown
@@ -0,0 +1,426 @@
+---
+language: Lua
+contributors:
+    - ["Tyler Neylon", "http://tylerneylon.com/"]
+translators:
+    - ["Martin Schimandl", "https://github.com/Git-Jiro"]
+filename: learnlua-de.lua
+lang: de-de
+---
+
+```lua
+-- Zwei Gedankenstriche starten ein einzeiliges Kommentar.
+
+--[[
+     Fügt man zwei '[' und ']' hinzu,
+     erzeugt man einen mehrzeiligen Kommentar.
+--]]
+--------------------------------------------------------------------------------
+-- 1. Variablen und Fluß-Kontrolle.
+--------------------------------------------------------------------------------
+
+num = 42  -- Alle Nummern sind vom Typ: Double.
+-- Werd nicht nervös, 64-Bit Double haben 52 Bits zum Speichern von exakten
+-- Ganzzahlen; Maschinen-Genauigkeit ist kein Problem für Ganzzahlen kleiner als 
+-- 52 Bit.
+
+s = 'walternate'  -- Zeichenketten sind unveränderlich, wie bei Python.
+t = "Doppelte Anführungszeichen sind auch OK"
+u = [[ Doppelte eckige Klammern
+       beginnen und beenden
+       mehrzeilige Zeichenketten.]]
+t = nil  -- Undefineren von t; Lua hat einen Garbage Collection.
+
+-- Blöcke werden durch Schlüsselwörter wie do/end markiert:
+while num < 50 do
+  num = num + 1  -- Es gibt Keine Operatoren wie ++ oder +=
+end
+
+-- If Bedingungen:
+if num > 40 then
+  print('over 40')
+elseif s ~= 'walternate' then  -- ~= bedeutet ungleich
+  -- Gleichheits-Check == wie bei Python; OK für Zeichenketten.
+  io.write('not over 40\n')  -- Standard ist stdout.
+else
+  -- Variablen sind standardmäßig global.
+  thisIsGlobal = 5  -- Camel case ist üblich.
+
+  -- So macht man eine Variable lokal:
+  local line = io.read()  -- Lies die nächste Zeile von stdin.
+
+  -- Zeichenketten zusammenführen mit dem .. Operator:
+  print('Winter is coming, ' .. line)
+end
+
+-- Undefinierte Variablen geben nil zurück.
+-- Das ist kein Fehler:
+foo = anUnknownVariable  -- Nun ist foo = nil.
+
+aBoolValue = false
+
+-- Nur nil und false sind unwahr; 0 and '' sind wahr!
+if not aBoolValue then print('was false') end
+
+-- 'or' und 'and' sind "kurz-geschlossen". Das ist so ähnlich wie der a?b:c
+-- operator in C/js:
+-- in C/js:
+ans = aBoolValue and 'yes' or 'no'  --> 'no'
+
+karlSum = 0
+for i = 1, 100 do  -- Ein Bereich inkludiert beide Enden.
+  karlSum = karlSum + i
+end
+
+-- Verwende "100, 1, -1" als Breich für Countdowns:
+fredSum = 0
+for j = 100, 1, -1 do fredSum = fredSum + j end
+
+-- Im Allgemeinen besteht ein Bereich aus: Anfang, Ende, [, Schrittweite].
+
+-- Ein anderes Schleifen-Konstrukt:
+repeat
+  print('Der Weg der Zukunft')
+  num = num - 1
+until num == 0
+
+--------------------------------------------------------------------------------
+-- 2. Funktionen.
+--------------------------------------------------------------------------------
+
+function fib(n)
+  if n < 2 then return n end
+  return fib(n - 2) + fib(n - 1)
+end
+
+-- Closures und anonyme Funktionen sind ok:
+function adder(x)
+  -- Die zurückgegebene Funktion wird erzeugt wenn addr aufgerufen wird und merkt
+  -- sich den Wert von x:
+  return function (y) return x + y end
+end
+a1 = adder(9)
+a2 = adder(36)
+print(a1(16))  --> 25
+print(a2(64))  --> 100
+
+-- Rückgabewerte, Funktions-Aufrufe und Zuweisungen funktionieren alle mit
+-- Listen die nicht immer gleich lang sein müssen. Überzählige Empfänger
+-- bekommen nil; überzählige Sender werden ignoriert.
+
+x, y, z = 1, 2, 3, 4
+-- Nun ist x = 1, y = 2, z = 3, und 4 wird ignoriert.
+
+function bar(a, b, c)
+  print(a, b, c)
+  return 4, 8, 15, 16, 23, 42
+end
+
+x, y = bar('zaphod')  --> prints "zaphod  nil nil"
+-- Nun ist x = 4, y = 8, die Werte 15..42 werden ignoriert.
+
+-- Funktionen sind erste Klasse, und können lokal oder global sein.
+-- Das ist alles das Gleiche:
+function f(x) return x * x end
+f = function (x) return x * x end
+
+-- Das auch:
+local function g(x) return math.sin(x) end
+local g = function(x) return math.sin(x) end
+-- Äquivalent zu local function g(x)..., außer das Referenzen auf g im
+-- Funktions-Körper nicht wie erwartet funktionieren.
+local g; g  = function (x) return math.sin(x) end
+-- Die Deklaration 'local g' macht Selbst-Referenzen auf g OK.
+
+-- Nebenbei gesagt, Trigonometrie-Funktionen verwenden Radianten.
+
+-- Funktionsaufrufe mit nur einem Zeichenketten-Parameter brauch keine runden
+-- Klammern.
+print 'hello'  -- Funktioniert wunderbar.
+
+-- Funktionsaufrufe mit einem Tabellen-Parameter brauchen auch keine runden
+-- Klammern. Mehr zu Tabellen kommt später.
+print {} -- Funktioniert auch wunderbar.
+
+--------------------------------------------------------------------------------
+-- 3. Tabellen.
+--------------------------------------------------------------------------------
+
+-- Tabellen sind die einzige zusammengesetzte Struktur in Lua. Sie sind
+-- assoziative Arrays. Sie sind so ähnlich wie PHP arrays oder JavaScript
+-- Objekte. Sie sind Hash-Lookup-Dictionaries die auch als Listen verwendet
+-- werden können.
+
+-- Verwenden von Tabellen als Dictionaries oder Maps:
+
+-- Dict-Literale haben standardmäßig Zeichenketten als Schlüssel:
+t = {key1 = 'value1', key2 = false}
+
+-- Zeichenketten-Schlüssel verwenden eine JavaScript ähnliche Punkt-Notation.
+print(t.key1)  -- Ausgabe 'value1'.
+t.newKey = {}  -- Neues Schlüssel/Wert-Paar hinzufügen.
+t.key2 = nil   -- key2 aus der Tabelle entfernen.
+
+-- Literale notation für jeden (nicht-nil) Wert als Schlüssel:
+u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
+print(u[6.28])  -- Ausgabe "tau"
+
+-- Schlüssel-Vergleiche funktionieren per Wert für Nummern und Zeichenketten,
+-- aber über die Identität bei Tabellen.
+a = u['@!#']  -- Nun ist a = 'qbert'.
+b = u[{}]     -- Wir würden 1729 erwarten, aber es ist nil:
+-- b = nil weil der Lookup fehlschlägt. Er schlägt Fehl, weil der Schlüssel
+-- den wir verwendet haben nicht das gleiche Objekt ist das wir verwendet
+-- haben um den original Wert zu speichern. Zahlen und Zeichnkette sind daher
+-- die praktischeren Schlüssel.
+
+-- Eine Funktion mit nur einem Tabellen-Parameter benötigt keine Klammern.
+function h(x) print(x.key1) end
+h{key1 = 'Sonmi~451'}  -- Ausgabe 'Sonmi~451'.
+
+for key, val in pairs(u) do  -- Tabellen-Iteration.
+  print(key, val)
+end
+
+-- _G ist eine spezielle Tabelle die alles Globale enthält.
+print(_G['_G'] == _G)  -- Ausgabe 'true'.
+
+-- Verwenden von Tabellen als Listen/Arrays:
+
+-- Listen-Literale verwenden implizit Ganzzahlen als Schlüssel:
+v = {'value1', 'value2', 1.21, 'gigawatts'}
+for i = 1, #v do  -- #v ist die Größe von v für Listen.
+  print(v[i])  -- Indices beginnen mit 1 !! SO VERRÜCKT!
+end
+-- Eine 'Liste' ist kein echter Typ. v ist nur eine Tabelle mit fortlaufenden
+-- Ganzzahlen als Schlüssel, die behandelt wird wie eine Liste.
+
+--------------------------------------------------------------------------------
+-- 3.1 Metatabellen und Metamethoden
+--------------------------------------------------------------------------------
+
+-- Eine Tabelle kann eine Metatabelle haben. Diese verleiht ihr so etwas wie
+-- Tabellen-Operator-Überladungs-Verhalten. Später sehen wir wie
+-- Metatabellen js-prototypen artiges Verhalten unterstützen.
+
+f1 = {a = 1, b = 2}  -- Repräsentiert den Bruch a/b.
+f2 = {a = 2, b = 3}
+
+-- Dies würde Fehlschlagen:
+-- s = f1 + f2
+
+metafraction = {}
+function metafraction.__add(f1, f2)
+  local sum = {}
+  sum.b = f1.b * f2.b
+  sum.a = f1.a * f2.b + f2.a * f1.b
+  return sum
+end
+
+setmetatable(f1, metafraction)
+setmetatable(f2, metafraction)
+
+s = f1 + f2  -- Rufe __add(f1, f2) vom der Metatabelle von f1 auf.
+
+-- f1 und f2 haben keine Schlüssel für ihre Metatabellen, anders als bei js
+-- Prototypen. Daher muss mithilfe von getmetatable(f1) darauf zugegriffen
+-- werden. Eine Metatabelle ist wie eine normale Tabelle mit Schlüsseln die
+-- Lua bekannt sind, so wie __add.
+
+
+-- Die nächste Zeile schlägt fehl weil s keine Metatabelle hat:
+-- t = s + s
+-- Mihilfe von Klassen ähnlichen Mustern kann das gelöst werden.
+-- Siehe weiter unten.
+
+-- Ein __index einer Metatabelle überlädt Punkt-Lookups:
+defaultFavs = {animal = 'gru', food = 'donuts'}
+myFavs = {food = 'pizza'}
+setmetatable(myFavs, {__index = defaultFavs})
+eatenBy = myFavs.animal  -- Funktioniert dank Metatabelle!
+
+--------------------------------------------------------------------------------
+-- Direkte Tabellen-Lookups die fehlschlagen werden mithilfe von __index der
+-- Metatabelle wiederholt. Das geschieht rekursiv.
+
+-- __index kann auch eine Funktion mit der Form function(tbl, key) sein.
+-- Damit kann man Lookups weiter anpassen.
+
+-- Werte wie __index,add, .. werden Metamethoden genannt.
+-- HIer eine vollständige Liste aller Metamethoden.
+
+-- __add(a, b)                     für a + b
+-- __sub(a, b)                     für a - b
+-- __mul(a, b)                     für a * b
+-- __div(a, b)                     für a / b
+-- __mod(a, b)                     für a % b
+-- __pow(a, b)                     für a ^ b
+-- __unm(a)                        für -a
+-- __concat(a, b)                  für a .. b
+-- __len(a)                        für #a
+-- __eq(a, b)                      für a == b
+-- __lt(a, b)                      für a < b
+-- __le(a, b)                      für a <= b
+-- __index(a, b)  <fn or a table>  für a.b
+-- __newindex(a, b, c)             für a.b = c
+-- __call(a, ...)                  für a(...)
+
+--------------------------------------------------------------------------------
+-- 3.2 Klassen-Artige Tabellen und Vererbung.
+--------------------------------------------------------------------------------
+
+-- Klassen sind in Lua nicht eingebaut. Es gibt verschieden Wege sie mithilfe
+-- von Tabellen und Metatabellen zu erzeugen.
+
+-- Die Erklärund des Beispiels erfolgt unterhalb.
+
+Dog = {}                                   -- 1.
+
+function Dog:new()                         -- 2.
+  local newObj = {sound = 'woof'}          -- 3.
+  self.__index = self                      -- 4.
+  return setmetatable(newObj, self)        -- 5.
+end
+
+function Dog:makeSound()                   -- 6.
+  print('I say ' .. self.sound)
+end
+
+mrDog = Dog:new()                          -- 7.
+mrDog:makeSound()  -- 'I say woof'         -- 8.
+
+-- 1. Dog verhält sich wie eine Klasse; Ist aber eine Tabelle.
+-- 2. "function tablename:fn(...)" ist das gleiche wie
+--    "function tablename.fn(self, ...)", Der : fügt nur ein Argument namens
+--    self hinzu. Siehe 7 & 8 um zu sehen wie self seinen Wert bekommt.
+-- 3. newObj wird eine Instanz von Dog.
+-- 4. "self" ist die zu Instanzierende Klasse. Meistern ist self = Dog, aber
+--    dies kann durch Vererbung geändert werden. newObj bekommt die Funktionen
+--    von self wenn wir die Metatabelle von newObj und __index von self auf
+--    self setzen.
+-- 5. Zur Erinnerung: setmetatable gibt sein erstes Argument zurück.
+-- 6. Der Doppelpunkt funktioniert wie bei 2, aber dieses Mal erwarten wir das
+--    self eine Instanz ist und keine Klasse.
+-- 7. Das Selbe wie Dog.new(Dog), also self = Dog in new().
+-- 8. Das Selbe wie mrDog.makeSound(mrDog); self = mrDog.
+
+--------------------------------------------------------------------------------
+
+-- Vererbungs-Beispiel:
+
+LoudDog = Dog:new()                           -- 1.
+
+function LoudDog:makeSound()
+  local s = self.sound .. ' '                 -- 2.
+  print(s .. s .. s)
+end
+
+seymour = LoudDog:new()                       -- 3.
+seymour:makeSound()  -- 'woof woof woof'      -- 4.
+
+--------------------------------------------------------------------------------
+-- 1. LoudDog bekommt die Methoden und Variablen von Dog.
+-- 2. self hat einen 'sound' Schlüssel von new(), siehe 3.
+-- 3. Das Gleiche wie "LoudDog.new(LoudDog)", und umgewandelt zu "Dog.new(LoudDog)"
+--    denn LoudDog hat keinen 'new' Schlüssel, aber "__index = Dog" steht in der
+--    Metatabelle.
+--    Ergebnis: Die Metatabelle von seymour ist LoudDog und "LoudDog.__index = Dog".
+--    Daher ist seymour.key gleich seymour.key, LoudDog.key, Dog.key, je nachdem
+--    welche Tabelle als erstes einen passenden Schlüssel hat.
+-- 4. Der 'makeSound' Schlüssel wird in LoudDog gefunden: Das ist das Gleiche
+--    wie "LoudDog.makeSound(seymour)".
+
+-- Wenn nötig, sieht new() einer Sub-Klasse genau so aus wie new() der
+-- Basis-Klasse:
+function LoudDog:new()
+  local newObj = {}
+  -- set up newObj
+  self.__index = self
+  return setmetatable(newObj, self)
+end
+
+--------------------------------------------------------------------------------
+-- 4. Module.
+--------------------------------------------------------------------------------
+
+
+--[[ Dieser Abschnitt ist auskommentiert damit der Rest des Skripts lauffähig
+--   bleibt.
+```
+
+```lua
+-- Angenommen mod.lua sieht so aus:
+local M = {}
+
+local function sayMyName()
+  print('Hrunkner')
+end
+
+function M.sayHello()
+  print('Why hello there')
+  sayMyName()
+end
+
+return M
+
+-- Eine andere Datei könnte die Funktionen in mod.lua so verwenden:
+local mod = require('mod')  -- Führe mod.lua aus.
+
+-- require ist der Standard-Weg um Module zu inkludieren.
+-- require verhält sich wie: (Wenn nicht gecached wird; siehe später)
+local mod = (function ()
+  <Inhalt von mod.lua>
+end)()
+-- Es ist als ob mod.lua eine Funktion wäre, sodass lokale Variablen in
+-- mod.lua ausserhalb unsichtbar sind.
+
+-- Das funktioniert weil mod hier das Gleiche wie M in mod.lua ist:
+mod.sayHello()  -- Says hello to Hrunkner.
+
+-- Das ist Falsch: sayMyName existiert nur in mod.lua:
+mod.sayMyName()  -- Fehler
+
+-- Der Rückgabe-Wert von require wird zwischengespeichert. Sodass Module nur
+-- einmal abgearbeitet werden, auch wenn sie mit require öfters eingebunden
+-- werden.
+
+-- Nehmen wir an mod2.lua enthält "print('Hi!')".
+local a = require('mod2')  -- Ausgabe Hi!
+local b = require('mod2')  -- Keine Ausgabe; a=b.
+
+-- dofile ist wie require aber ohne Zwischenspeichern.
+dofile('mod2')  --> Hi!
+dofile('mod2')  --> Hi! (läuft nochmal, nicht wie require)
+
+-- loadfile ladet eine lua Datei aber die Datei wird noch nicht abgearbeitet.
+f = loadfile('mod2')  -- Sobald f() aufgerufen wird läuft mod2.lua.
+
+-- loadstring ist loadfile für Zeichenketten
+g = loadstring('print(343)')  -- Gibt eine Funktion zurück..
+g()  -- Ausgabe 343; Vorher kam keine Ausgabe.
+
+--]]
+
+```
+## Referenzen
+
+Ich war so begeistert Lua zu lernen, damit ich Spiele mit <a href="http://love2d.org/">Love 2D game engine</a> programmieren konnte.
+
+Ich habe angefangen mit <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>.
+Danach habe ich das offizielle Lua Buch gelesen: <a href="http://www.lua.org/pil/contents.html">Programming in Lua</a>
+
+Es kann auch hilfreich sein hier vorbeizuschauen: <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Lua short
+reference</a>
+
+Wichtige Themen die hier nicht angesprochen wurden; die Standard-Bibliotheken:
+
+* <a href="http://lua-users.org/wiki/StringLibraryTutorial">string library</a>
+* <a href="http://lua-users.org/wiki/TableLibraryTutorial">table library</a>
+* <a href="http://lua-users.org/wiki/MathLibraryTutorial">math library</a>
+* <a href="http://lua-users.org/wiki/IoLibraryTutorial">io library</a>
+* <a href="http://lua-users.org/wiki/OsLibraryTutorial">os library</a>
+
+Übrigends, die gesamte Datei ist gültiges Lua. Speichere sie als learn.lua und
+starte sie als "lua learn.lua" !
+
+Die Erstfassung ist von tylerneylon.com, und ist auch hier verfügbar: <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. Viel Spaß mit Lua!
diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
new file mode 100644
index 00000000..22c14a69
--- /dev/null
+++ b/de-de/make-de.html.markdown
@@ -0,0 +1,260 @@
+---

+language: make

+contributors:

+    - ["Robert Steed", "https://github.com/robochat"]

+translators:

+  - ["Martin Schimandl", "https://github.com/Git-Jiro"]

+filename: Makefile-de

+lang: de-de

+---

+

+Eine Makefile definiert einen Graphen von Regeln um ein Ziel (oder Ziele)

+zu erzeugen. Es dient dazu die geringste Menge an Arbeit zu verrichten um

+ein Ziel in einklang mit dem Quellcode zu bringen. Make wurde berühmterweise

+von Stuart Feldman 1976 übers Wochenende geschrieben. Make ist noch immer

+sehr verbreitet (vorallem im Unix umfeld) obwohl es bereits sehr viel

+Konkurrenz und Kritik zu Make gibt.

+

+Es gibt eine vielzahl an Varianten von Make, dieser Artikel beschäftig sich

+mit der Version GNU Make. Diese Version ist standard auf Linux.

+

+```make

+

+# Kommentare können so geschrieben werden.

+

+# Dateien sollten Makefile heißen, denn dann können sie als `make <ziel>`

+# aufgerufen werden. Ansonsten muss `make -f "dateiname" <ziel>` verwendet

+# werden.

+

+# Warnung - Es sollten nur TABULATOREN zur Einrückung im Makefile verwendet

+# werden. Niemals Leerzeichen!

+

+#-----------------------------------------------------------------------

+# Grundlagen

+#-----------------------------------------------------------------------

+

+# Eine Regel - Diese Regel wird nur abgearbeitet wenn die Datei file0.txt

+# nicht existiert.

+file0.txt:

+	echo "foo" > file0.txt

+	# Selbst Kommentare in der 'Rezept' Sektion werden an die Shell

+	# weitergegeben. Versuche `make file0.txt` oder einfach `make`

+	# die erste Regel ist die Standard-Regel.

+

+

+# Diese Regel wird nur abgearbeitet wenn file0.txt aktueller als file1.txt ist.

+file1.txt: file0.txt

+	cat file0.txt > file1.txt

+	# Verwende die selben Quoting-Regeln wie die Shell

+	@cat file0.txt >> file1.txt

+	# @ unterdrückt die Ausgabe des Befehls an stdout.

+	-@echo 'hello'

+	# - bedeutet das Make die Abarbeitung fortsetzt auch wenn Fehler passieren.

+	# Versuche `make file1.txt` auf der Kommandozeile.

+

+# Eine Regel kann mehrere Ziele und mehrere Voraussetzungen haben.

+file2.txt file3.txt: file0.txt file1.txt

+	touch file2.txt

+	touch file3.txt

+

+# Make wird sich beschweren wenn es mehrere Rezepte für die gleiche Regel gibt.

+# Leere Rezepte zählen nicht und können dazu verwendet werden weitere 

+# Voraussetzungen hinzuzufügen.

+

+#-----------------------------------------------------------------------

+# Phony-Ziele

+#-----------------------------------------------------------------------

+

+# Ein Phony-Ziel ist ein Ziel das keine Datei ist.

+# Es wird nie aktuell sein, daher wird Make immer versuchen es abzuarbeiten

+all: maker process

+

+# Es ist erlaubt Dinge ausserhalb der Reihenfolge zu deklarieren.

+maker:

+	touch ex0.txt ex1.txt

+

+# Um das Fehlschlagen von Phony-Regeln zu vermeiden wenn eine echte Datei den

+# selben namen wie ein Phony-Ziel hat:

+.PHONY: all maker process

+# Das ist ein spezielles Ziel. Es gibt noch ein paar mehr davon.

+

+# Eine Regel mit einem Phony-Ziel als Voraussetzung wird immer abgearbeitet

+ex0.txt ex1.txt: maker

+

+# Häufige Phony-Ziele sind: all make clean install ...

+

+#-----------------------------------------------------------------------

+# Automatische Variablen & Wildcards

+#-----------------------------------------------------------------------

+

+process: file*.txt	# Eine Wildcard um Dateinamen zu Vergleichen

+	@echo $^	# $^ ist eine Variable die eine Liste aller

+			# Voraussetzungen enthält.

+	@echo $@	# Namen des Ziels ausgeben.

+	#(Bei mehreren Ziel-Regeln enthält $@ den Verursacher der Abarbeitung

+	#der Regel.)

+	@echo $<	# Die erste Voraussetzung aus der Liste

+	@echo $?	# Nur die Voraussetzungen die nicht aktuell sind.

+	@echo $+	# Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich)

+	#@echo $|	# Alle 'order only' Voraussetzungen

+

+# Selbst wenn wir die Voraussetzungen der Regel aufteilen, $^ wird sie finden.

+process: ex1.txt file0.txt

+# ex1.txt wird gefunden werden, aber file0.txt wird dedupliziert.

+

+#-----------------------------------------------------------------------

+# Muster

+#-----------------------------------------------------------------------

+

+# Mit Mustern kann man make beibringen wie Dateien in andere Dateien

+# umgewandelt werden.

+

+%.png: %.svg

+	inkscape --export-png $^

+

+# Muster-Vergleichs-Regeln werden nur abgearbeitet wenn make entscheidet das Ziel zu

+# erzeugen

+

+# Verzeichnis-Pfade werden normalerweise bei Muster-Vergleichs-Regeln ignoriert.

+# Aber make wird versuchen die am besten passende Regel zu verwenden.

+small/%.png: %.svg

+	inkscape --export-png --export-dpi 30 $^

+

+# Make wird die letzte Version einer Muster-Vergleichs-Regel verwenden die es

+# findet.

+%.png: %.svg

+	@echo this rule is chosen

+

+# Allerdings wird make die erste Muster-Vergleicher-Regel verwenden die das

+# Ziel erzeugen kann.

+%.png: %.ps

+	@echo this rule is not chosen if *.svg and *.ps are both present

+

+# Make hat bereits ein paar eingebaute Muster-Vergleichs-Regelen. Zum Beispiel

+# weiß Make wie man aus *.c Dateien *.o Dateien erzeugt.

+

+# Ältere Versionen von Make verwenden möglicherweise Suffix-Regeln anstatt

+# Muster-Vergleichs-Regeln.

+.png.ps:

+	@echo this rule is similar to a pattern rule.

+

+# Aktivieren der Suffix-Regel

+.SUFFIXES: .png

+

+#-----------------------------------------------------------------------

+# Variablen

+#-----------------------------------------------------------------------

+# auch Makros genannt.

+

+# Variablen sind im Grunde genommen Zeichenketten-Typen.

+

+name = Ted

+name2="Sarah"

+

+echo:

+	@echo $(name)

+	@echo ${name2}

+	@echo $name    # Das funktioniert nicht, wird als $(n)ame behandelt.

+	@echo $(name3) # Unbekannte Variablen werden als leere Zeichenketten behandelt.

+

+# Es git 4 Stellen um Variablen zu setzen.

+# In Reihenfolge der Priorität von höchster zu niedrigster:

+# 1: Befehls-Zeilen Argumente

+# 2: Makefile

+# 3: Shell Umbebungs-Variablen - Make importiert diese automatisch.

+# 3: MAke hat einige vordefinierte Variablen.

+

+name4 ?= Jean

+# Setze die Variable nur wenn es eine gleichnamige Umgebungs-Variable noch

+# nicht gibt.

+

+override name5 = David

+# Verhindert das Kommando-Zeilen Argumente diese Variable ändern können.

+

+name4 +=grey

+# Werte an eine Variable anhängen (inkludiert Leerzeichen).

+

+# Muster-Spezifische Variablen Werte (GNU Erweiterung).

+echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb

+	# rekursiver Voraussetzungen (ausser wenn es den Graphen zerstören

+	# kann wenn es zu kompilizert wird!)

+

+# Ein paar Variablen die von Make automatisch definiert werden.

+echo_inbuilt:

+	echo $(CC)

+	echo ${CXX)}

+	echo $(FC)

+	echo ${CFLAGS)}

+	echo $(CPPFLAGS)

+	echo ${CXXFLAGS}

+	echo $(LDFLAGS)

+	echo ${LDLIBS}

+

+#-----------------------------------------------------------------------

+# Variablen 2

+#-----------------------------------------------------------------------

+

+# Der erste Typ von Variablen wird bei jeder verwendung ausgewertet.

+# Das kann aufwendig sein, daher exisitert ein zweiter Typ von Variablen.

+# Diese werden nur einmal ausgewertet. (Das ist eine GNU make Erweiterung)

+

+var := hello

+var2 ::=  $(var) hello

+#:= und ::= sind äquivalent.

+

+# Diese Variablen werden prozedural ausgwertet (in der Reihenfolge in der sie

+# auftauchen), die stehen daher im wiederspruch zum Rest der Sprache!

+

+# Das funktioniert nicht

+var3 ::= $(var4) and good luck

+var4 ::= good night

+

+#-----------------------------------------------------------------------

+# Funktionen

+#-----------------------------------------------------------------------

+

+# Make verfügt über eine vielzahl von Funktionen.

+

+sourcefiles = $(wildcard *.c */*.c)

+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))

+

+# Das Format ist $(func arg0,arg1,arg2...)

+

+# Ein paar Beispiele

+ls:	* src/*

+	@echo $(filter %.txt, $^)

+	@echo $(notdir $^)

+	@echo $(join $(dir $^),$(notdir $^))

+

+#-----------------------------------------------------------------------

+# Direktiven

+#-----------------------------------------------------------------------

+

+# Inkludiere andere Makefile, sehr praktisch für platformspezifischen Code

+include foo.mk

+

+sport = tennis

+# Konditionale kompiliereung

+report:

+ifeq ($(sport),tennis)

+	@echo 'game, set, match'

+else

+	@echo "They think it's all over; it is now"

+endif

+

+# Es gibt auch ifneq, ifdef, ifndef

+

+foo = true

+

+ifdef $(foo)

+bar = 'hello'

+endif

+```

+

+

+### Mehr Resourcen

+

++ [gnu make documentation](https://www.gnu.org/software/make/manual/)

++ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/)

++ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)

+

diff --git a/de-de/markdown-de.html.markdown b/de-de/markdown-de.html.markdown
index 6a90980b..2c838660 100644
--- a/de-de/markdown-de.html.markdown
+++ b/de-de/markdown-de.html.markdown
@@ -56,7 +56,7 @@ __Genau wie dieser.__
 **_Dieser auch!_**
 *__Und dieser genau so!__*
 
-<!-- In "Github Flavored Markdown", dem von Github verwendeten Dialekt / Parser,
+<!-- In "GitHub Flavored Markdown", dem von GitHub verwendeten Dialekt / Parser,
 gibt es auch noch durchgestrichenen Text: -->
 
 ~~Dieser Text wird durchgestrichen dargestellt.~~
@@ -148,7 +148,7 @@ indem du eine Zeile mit vier Leerzeichen oder einem Tabulator einrückst -->
 
 Hermann hatte nicht die leiseste Ahnung, was dieses `go_to()` bedeuten könnte!
 
-<!-- In "Github Flavored Markdown" gibt es für Code nocheinmal eine
+<!-- In "GitHub Flavored Markdown" gibt es für Code nocheinmal eine
 besondere Syntax -->
 
 \`\`\`ruby <!-- in "echt" musst du die Backslashes entfernen: ```ruby ! -->
@@ -157,7 +157,7 @@ def foobar
 end
 \`\`\` <!-- hier auch keine Backslashes, nur ``` -->
 
-<-- der obige Block muss nicht extra eingerückt werden, außerdem fügt Github
+<-- der obige Block muss nicht extra eingerückt werden, außerdem fügt GitHub
 Syntax-Highlighting für die nach dem ``` angegebene Sprache hinzu -->
 
 <!-- Horizontale Linie (<hr />) -->
@@ -233,7 +233,7 @@ Ich würde *diesen Teil gerne mit Sternen umschließen*, doch ohne dass er kursi
 wird. Also mache ich folgendes: \*Ich umschließe diesen Text mit Sternen\*!
 
 <!-- Tabellen -->
-<!-- Tabellen gibt es bis jetzt nur in "Github Flavored Markdown".
+<!-- Tabellen gibt es bis jetzt nur in "GitHub Flavored Markdown".
 Zudem sind sie ziemlich mühselig, aber wenn du es wirklich wissen willst: -->
 
 | Spalte1      | Spalte2  | Spalte3       |
@@ -253,4 +253,4 @@ Ganz schön hässlich | vielleicht doch lieber | wieder aufhören
 
 Mehr Informationen gibt es in [John Gruber's offiziellem Blog-Post](http://daringfireball.net/projects/markdown/syntax)
 und bei Adam Pritchards [grandiosem Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-Infos zu Github Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).
\ No newline at end of file
+Infos zu GitHub Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).
\ No newline at end of file
diff --git a/de-de/perl-de.html.markdown b/de-de/perl-de.html.markdown
new file mode 100644
index 00000000..fd8fb3c4
--- /dev/null
+++ b/de-de/perl-de.html.markdown
@@ -0,0 +1,169 @@
+---
+language: perl
+filename: learnperl-de.pl
+contributors:
+    - ["Korjavin Ivan", "http://github.com/korjavin"]
+translators:
+    - ["Martin Schimandl", "http://github.com/Git-Jiro"]
+lang: de-de
+---
+
+Perl 5 ist eine sehr mächtige, funktionsreiche Programmiersprache mit über 25 Jahren Entwicklungsgeschichte.
+
+Perl 5 läuft auf über 100 Platformen von portablen Geräten bis hin zu Mainframes. Perl 5 ist geeignet für Rapid-Prototyping und auch groß angelegte Entwicklungs-Projekte.
+
+```perl
+# Einzeilige Kommentare beginnen mit dem # Symbol.
+
+
+#### Perl Variablen Typen
+
+#  Variablen beginnen mit einem Sigil, das ist ein Symbol das den Typ anzeigt.
+#  Ein erlaubter Variablen-Name beginnt mit einem Buchstaben oder einem
+#  Unterstrich, gefolgt von beliebig vielen weiteren Buchstaben, Zahlen und
+#  Unterstrichen.
+
+### Perl hat drei Haupt-Typen von Variablen: $scalar, @array, und %hash.
+
+## Scalare
+#  Ein Scalar repräsentiert einen einzelnen Wert:
+my $animal = "camel";
+my $answer = 42;
+
+# Scalare Werte könnne Zeichenketten, Ganzzahlen und Gleitkomma-Zahlen sein.
+# Perl convertiert automatisch zwischen diesen Werten wenn nötig.
+
+## Arrays
+#  Ein Array repräsentiert eine Liste von Werten:
+my @animals = ("camel", "llama", "owl");
+my @numbers = (23, 42, 69);
+my @mixed   = ("camel", 42, 1.23);
+
+
+
+## Hashes
+#   Ein Hash representiert ein Set von Schlüssel/Wert Paaren:
+
+my %fruit_color = ("apple", "red", "banana", "yellow");
+
+#  Man kann Leerzeichen und den "=>" Operator verwenden um sie schön darzustellen:
+
+my %fruit_color = (
+  apple  => "red",
+  banana => "yellow",
+);
+# Scalare, Arrays und Hashes sind in perldata sehr genau dokumentiert.
+# (perldoc perldata)
+
+# Komplexere Daten-Typen können mit hilfe von Referenzen konstruiert werden.
+# Dies erlaubt das erstellen von Listen und Hashes in Listen und Hashes.
+
+#### Bedingte Ausführungs- und Schleifen-Konstrukte.
+
+# Perl besitzt die üblichen Bedingte Ausführung- und Schleifen-Konstrukte
+
+if ($var) {
+  ...
+} elsif ($var eq 'bar') {
+  ...
+} else {
+  ...
+}
+
+unless (condition) {
+  ...
+}
+# Dies ist die etwas leserliche Version von "if (!Bedingung)"
+
+# Die Perl-Eigene Post-Bedingungs-Schreibweise
+print "Yow!" if $zippy;
+print "We have no bananas" unless $bananas;
+
+#  while
+while (condition) {
+  ...
+}
+
+
+# Für Schleifen und Iterationen
+for (my $i = 0; $i < $max; $i++) {
+  print "index is $i";
+}
+
+for (my $i = 0; $i < @elements; $i++) {
+  print "Current element is " . $elements[$i];
+}
+
+for my $element (@elements) {
+  print $element;
+}
+
+# Implizite Iteration
+for (@elements) {
+  print;
+}
+
+# Die Perl-Eigene Post-Bedingungs-Schreibweise nochmals
+print for @elements;
+
+#### Reguläre Ausdrücke
+
+# Die Unterstützung von Perl für reguläre Ausdrücke ist weit und tiefgreifend.
+# Sie ist ausführlich in perlrequick, perlretut und sonstwo dokumentiert.
+# Die Kurzfassung:
+
+# Einfaches Vergleichen
+if (/foo/)       { ... }  # Wahr wenn "foo" in $_ enthalten ist
+if ($a =~ /foo/) { ... }  # Wahr wenn "foo" in $a enthalten ist
+
+# Einfache Substitution
+
+$a =~ s/foo/bar/;         # Ersetzt foo mit bar in $a
+$a =~ s/foo/bar/g;        # Ersetzt ALLE VORKOMMNISSE von foo mit bar in $a
+
+
+#### Dateien und Ein-/Ausgabe
+
+# Dateien werden mit der "open()" Funktion zur Ein- oder Ausgabe geöffnet.
+
+open(my $in,  "<",  "input.txt")  or die "Can't open input.txt: $!";
+open(my $out, ">",  "output.txt") or die "Can't open output.txt: $!";
+open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";
+
+# Von einem geöffneten Datei-Handle kann mit dem "<>" Operator gelesen werden.
+# In einem Scalaren-Kontext liest man damit eine einzelnen Zeile vom Datei-Handle.
+# In einem Listen-Kontext wird damit die komplette Datei eingelesen. Dabei
+# entspricht jede Zeile einem Element der Liste:
+
+my $line  = <$in>;
+my @lines = <$in>;
+
+#### Schreiben von Subroutinen
+
+# Subroutinen schreiben ist einfach:
+
+sub logger {
+  my $logmessage = shift;
+
+  open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
+
+  print $logfile $logmessage;
+}
+
+# Nun können wir die Subroutine genau wie eine eingebaute Funktion verwenden:
+
+logger("We have a logger subroutine!");
+```
+
+#### Verwenden von Perl Modulen
+
+Perl Module liefern eine Menge an Funktionen die dabei Helfen das Rad nicht neu erfinden zu müssen. Perl Module können von CPAN (http://www.cpan.org/) heruntergeladen werden. Einige populäre Module sind in der Perl Distribution selbst bereits enthalten.
+
+Perlfaq enthält Fragen und Antworten zu häufig vorkommenden Aufgaben. Sehr oft sind auch Vorschläge enthalten welches CPAN module am besten geeignet ist.
+
+#### Weiterführende Literatur
+
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Learn at www.perl.com](http://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - in Perl eingebaut : `perldoc perlintro`
diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown
new file mode 100644
index 00000000..ef1786c8
--- /dev/null
+++ b/de-de/python3-de.html.markdown
@@ -0,0 +1,655 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["kultprok", "http:/www.kulturproktologie.de"]
+    - ["matthiaskern", "https://github.com/matthiaskern"]
+filename: learnpython3-de.py
+lang: de-de
+---
+
+Anmerkungen des ursprünglichen Autors:
+Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode.
+
+Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service].
+
+Hinweis: Dieser Beitrag bezieht sich insplizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter.
+
+```python
+
+# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz)
+
+""" Mehrzeilige Strings werden mit
+    drei '-Zeichen geschrieben und werden
+    oft als Kommentare genutzt.
+"""
+
+####################################################
+## 1. Primitive Datentypen und Operatoren
+####################################################
+
+# Die Zahlen
+3 #=> 3
+
+# Mathematik funktioniert so, wie man das erwartet
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+
+# Außer Division, welche automatisch Gleitkommazahlen zurückgibt
+35 / 5  # => 7.0
+
+# Eine Division kann mit "//" für positive sowie negative Werte abgerundet werden.
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # works on floats too
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# Benutzt man eine Gleitkommazahl, ist auch das Ergebnis eine solche
+3 * 2.0 # => 6.0
+
+# Der Rest einer Division
+7 % 3 # => 1
+
+# Potenz
+2**4 # => 16
+
+# Rangfolge wird mit Klammern erzwungen
+(1 + 3) * 2 #=> 8
+
+# Boolesche Ausdrücke sind primitive Datentypen
+True
+False
+
+# Mit not wird negiert
+not True #=> False
+not False #=> True
+
+# Boolesche Operatoren
+# Hinweis: "and" und "or" müssen klein geschrieben werden
+True and False #=> False
+False or True #=> True
+
+# Für die Benutzung von Booleschen Operatoren und ganzen Zahlen
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# Gleichheit ist ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Ungleichheit ist !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Ein paar weitere Vergleiche
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# Vergleiche können verknüpft werden!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Strings werden mit " oder ' gebildet
+"Das ist ein String."
+'Das ist auch ein String.'
+
+# Strings können auch addiert werden! Vermeide dies aber lieber.
+"Hallo " + "Welt!" #=> "Hallo Welt!"
+# Strings können ohne "+" addiert werden
+"Hallo " "welt!"  # => "Hallo Welt!"
+
+# Ein String kann wie eine Liste von Zeichen verwendet werden
+"Das ist ein String"[0] #=> 'D'
+
+# .format kann Strings formatieren
+"{} können {} werden".format("Strings", "formatiert")
+
+# Schneller geht das mit Wiederholungen
+"{0} mag Spagetthi, {0} liebt es zu Schwimmen und ganz besonders mag {0} {1}".format("Hans", "Blattsalat")
+#=> "Hans mag Spagetthi, Hans liebt es zu Schwimmen und ganz besonders mag Hans Blattsalat"
+
+# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen.
+"{name} will {food} essen".format(name="Bob", food="Lasagne")
+#=> "Bob will Lasagne kochen"
+
+#Falls dein Python 3 Code auch unter Python 2.5 oder darunter laufen soll, kann das alte Format benutzt werden:
+"%s können %s werden" % ("Strings", "interpoliert")
+
+
+# None ist ein Objekt
+None #=> None
+
+# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen
+# Benutzt stattdessen `is`. Dieser Operator testet Objektidentität
+"etc" is None #=> False
+None is None  #=> True
+
+
+
+# None, 0, und leere Strings/Listen werden alle als False bewertet.
+# Alle anderen Werte sind True
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Variablen und Collections
+####################################################
+
+# Textausgabe ist sehr einfach
+print "Ich bin Python. Schön, dich kennenzulernen!"
+
+# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren.
+some_var = 5    # kleinschreibung_mit_unterstrichen entspricht der Norm
+some_var #=> 5
+
+# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus.
+# Unter "Kontrollstruktur" kann noch mehr über
+# Ausnahmebehandlung erfahren werden.
+some_unknown_var  # Löst einen NameError aus
+
+# Listen speichern Sequenzen
+li = []
+# Wir können mit einer bereits gefüllten Liste anfangen
+other_li = [4, 5, 6]
+
+# append fügt Daten am Ende der Liste ein
+li.append(1)    #li ist jetzt [1]
+li.append(2)    #li ist jetzt [1, 2]
+li.append(4)    #li ist jetzt [1, 2, 4]
+li.append(3)    #li ist jetzt [1, 2, 4, 3]
+# Vom Ende der Liste mit pop entfernen
+li.pop()        #=> 3 und li ist jetzt [1, 2, 4]
+# und dann wieder hinzufügen
+li.append(3)    # li ist jetzt wieder [1, 2, 4, 3].
+
+# Greife auf Listen wie auf Arrays zu
+li[0] #=> 1
+# Das letzte Element ansehen
+li[-1] #=> 3
+
+# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError
+li[4] # Verursacht einen IndexError
+
+# Wir können uns Ranges mit Slice-Syntax ansehen
+li[1:3] #=> [2, 4]
+# Den Anfang auslassen
+li[2:] #=> [4, 3]
+# Das Ende auslassen
+li[:3] #=> [1, 2, 4]
+# Jeden Zweiten Eintrag auswählen
+li[::2]   # =>[1, 4]
+# Eine umgekehrte Kopie zurückgeben
+li[::-1]   # => [3, 4, 2, 1]
+# Jegliche Kombination dieser Syntax machen fortgeschrittene Slices möglich
+# li[Start:Ende:Schritt]
+
+# Ein bestimmtes Element mit del aus der Liste entfernen
+del li[2] # li ist jetzt [1, 2, 3]
+
+# Listen können addiert werden
+li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen
+
+# Listen mit extend verknüpfen
+li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6]
+
+# Mit in auf Existenz eines Elements prüfen
+1 in li #=> True
+
+# Die Länge der Liste mit len ermitteln
+len(li) #=> 6
+
+
+# Tupel sind wie Listen, nur unveränderlich.
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Löst einen TypeError aus
+
+# Wir können all diese Listen-Dinge auch mit Tupeln anstellen
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# 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
+# 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
+
+
+# Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare
+empty_dict = {}
+# Hier ein gefülltes Wörterbuch
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Wir können Einträge mit [] nachschlagen
+filled_dict["one"] #=> 1
+
+# So holen wir alle Keys (Schlüssel) als Liste
+list(filled_dict.keys()) #=> ["three", "two", "one"]
+# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert.
+# Einzelne Resultate können anders angeordnet sein.
+
+# Alle Values (Werte) als Liste
+list(filled_dict.values()) #=> [3, 2, 1]
+# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln.
+
+# Das Vorhandensein eines Schlüssels im Wörterbuch mit "in" prüfen
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus
+filled_dict["four"] # KeyError
+
+# Mit der get-Methode verhindern wir das
+filled_dict.get("one") #=> 1
+filled_dict.get("four") #=> None
+# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt
+filled_dict.get("one", 4) #=> 1
+filled_dict.get("four", 4) #=> 4
+
+# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen
+filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt
+filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5
+
+# Einträge zu einem Wörterbuch hinzufügen
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  # noch ein Weg, Werte hinzuzufügen
+
+# Schlüssel von einem Wörterbuch entfernen
+del filled_dict["one"]  # Entfert den Schlüssel "one"
+
+
+# Sets speichern Mengen
+empty_set = set()
+# Initialisieren wir ein Set mit ein paar Werten
+some_set = {1, 1, 2, 2, 3, 4} # some_set ist jetzt {1, 2, 3, 4}
+
+# Neue Variablen können einer Menge gleichgesetzt werden
+filled_set = some_set
+
+# Mehr Elemente hinzufügen
+filled_set.add(5) # filled_set ist jetzt {1, 2, 3, 4, 5}
+
+# Schnittmengen werden mit & gebildet
+other_set = {3, 4, 5, 6}
+filled_set & other_set #=> {3, 4, 5}
+
+# Mengen werden mit | vereinigt
+filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+
+# Die Differenz einer Menge mit - bilden
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Auf Vorhandensein von Elementen mit in prüfen
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+####################################################
+## 3. Kontrollstruktur und Iteratoren
+####################################################
+
+# Erstellen wir mal eine Variable
+some_var = 5
+
+# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig!
+# gibt "some_var ist kleiner als 10" aus
+if some_var > 10:
+    print "some_var ist viel größer als 10."
+elif some_var < 10:    # Dieser elif-Absatz ist optional.
+    print "some_var ist kleiner als 10."
+else:           # Das hier ist auch optional.
+    print "some_var ist tatsächlich 10."
+
+
+"""
+For-Schleifen iterieren über Listen
+Ausgabe:
+    hund ist ein Säugetier
+    katze ist ein Säugetier
+    maus ist ein Säugetier
+"""
+for animal in ["hund", "katze", "maus"]:
+    # Wir können Strings mit format() formatieren
+    print("{}  ist ein Säugetier".format(animal))
+
+"""
+`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder
+Ausgabe:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+"range(unten, oben)" gibt eine Liste von der unteren Zahl bis zur oberen Zahl aus
+Ausgabe:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+While-Schleifen laufen, bis eine Bedingung erfüllt ist.
+Ausgabe:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Kurzform für x = x + 1
+
+# Ausnahmebehandlung mit einem try/except-Block
+try:
+    # Mit raise wird ein Fehler ausgegeben
+    raise IndexError("Das hier ist ein Index-Fehler")
+except IndexError as e:
+    pass    # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären.
+except (TypeError, NameError):
+    pass    # Mehrere Fehler können zusammen geklärt werden, falls erforderlich.
+else:   # Optional, hinter allen except-Blöcken
+    print("Keine Probleme!")   # Wird nur ausgeführt, wenn keine Ausnahmen aufgetreten sind
+finally: #  Wird immer ausgeführt
+    print("Hier können wir Ressourcen aufräumen")
+
+# alternativ zu einem try/finally Block um Aufzuräumen:
+with open("meineDatei.txt") as f:
+    for line in f:
+        print(line)
+
+# Python bietet ein fundamentales Konzept der Iteration.
+# Das Objekt, auf das die Interation, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
+# Die range Method gibt ein solches Objekt aus.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). Dies ist ein "iterable" Objekt.
+
+# Über dieses können  wir auch iterieren
+for i in our_iterable:
+    print(i)    # Gibt one, two, three aus
+
+# Allerdings können wir die einzelnen Elemente nicht mit ihrem index ausgeben
+our_iterable[1]  # TypeError
+
+# Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft.
+our_iterator = iter(our_iterable)
+
+# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es geraden hat während wir durch es gehen.
+# Das jeweeils nächste Objekt bekommen wir mit "next()"
+next(our_iterator)  #=> "one"
+
+# Es hält den vorherigen Status
+next(our_iterator)  #=> "two"
+next(our_iterator)  #=> "three"
+
+# Nachdem alle Daten ausgegeben worden sind, kommt eine StopIterator Ausnahme zurück
+next(our_iterator) # Gibt StopIteration aus
+
+# Alle Elemente können mit "list()" ausgegeben werden
+list(filled_dict.keys())  #=> ["one", "two", "three"]
+
+
+
+####################################################
+## 4. Funktionen
+####################################################
+
+# Mit def neue Funktionen erstellen
+def add(x, y):
+    print "x ist %s und y ist %s" % (x, y)
+    return x + y    # Werte werden mit return zurückgegeben
+
+# Funktionen mit Parametern aufrufen
+add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück
+
+# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente
+add(y=6, x=5)   # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden.
+
+# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Wir können auch Funktionen mit beliebiger Anzahl
+# Schlüsselwort-Argumenten definieren
+def keyword_args(**kwargs):
+    return kwargs
+
+# Rufen wir es mal auf, um zu sehen, was passiert
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# Wir können beides gleichzeitig machem, wenn wir wollen
+def all_the_args(*args, **kwargs):
+    print args
+    print kwargs
+"""
+all_the_args(1, 2, a=3, b=4) Ausgabe:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen!
+# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4)
+all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4)
+all_the_args(*args, **kwargs) # äquivalent zu  foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Anwendungsbereich von Funktionen
+x = 5
+
+def setX(num):
+    # lokale Variable x ist nicht die globale Variable x
+    x = num # => 43
+    print (x) # => 43
+
+def setGlobalX(num):
+    global x
+    print (x) # => 5
+    x = num # globale Variable x ist jetzt 6
+    print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python hat First-Class-Funktionen
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Es gibt auch anonyme Funktionen
+(lambda x: x > 2)(3) #=> True
+
+# Es gibt auch Funktionen höherer Ordnung als Built-Ins
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Klassen
+####################################################
+
+# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten.
+class Human(object):
+
+    # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt
+    species = "H. sapiens"
+
+    # Ein simpler Konstruktor
+    def __init__(self, name):
+        # Wir weisen das Argument name dem name-Attribut der Instanz zu
+        self.name = name
+
+    # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument.
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # Eine Klassenmethode wird von allen Instanzen geteilt.
+    # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Eine Instanz einer Klasse erstellen
+i = Human(name="Ian")
+print i.say("hi")     # gibt "Ian: hi" aus
+
+j = Human("Joel")
+print j.say("hello")  #gibt "Joel: hello" aus
+
+# Rufen wir mal unsere Klassenmethode auf
+i.get_species() #=> "H. sapiens"
+
+# Ändern wir mal das gemeinsame Attribut
+Human.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Aufruf der statischen Methode
+Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Module
+####################################################
+
+# Wir können Module importieren
+import math
+print math.sqrt(16) #=> 4
+
+# Wir können auch nur spezielle Funktionen eines Moduls importieren
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Wir können auch alle Funktionen eines Moduls importieren
+# Warnung: Dies wird nicht empfohlen
+from math import *
+
+# Wir können Modulnamen abkürzen
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Module sind in Python nur gewöhnliche Dateien. Wir
+# können unsere eigenen schreiben und importieren. Der Name des
+# Moduls ist der Dateiname.
+
+# Wir können auch die Funktionen und Attribute eines
+# Moduls herausfinden.
+import math
+dir(math)
+
+
+####################################################
+## 7. Fortgeschritten
+####################################################
+
+# Generatoren helfen um Code schnell und einfach zu schreiben
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Ein Generator erschafft Werte spontan
+# Statt alle Werte auf einmal, wird bei jeder Iteration einer erschaffen.
+# iteration.  Das heißt, Werte größer als 15 werden nicht behandelt.
+# Die range-Methode ist auch ein Generator. Im Fall einer Liste von 1-900000000
+# würde das sehr viel Zeit in Anspruch nehmen.
+# Wenn wir eine variable mit einem Namen erschaffen wollen, das
+# normalerweise mit einem Python - Schlüsselwort kollidieren würde,
+# benutzen wir einen Unterstrich nach dem Wort.
+range_ = range(1, 900000000)
+# Alle Nummern bis zu einem Ergebnis von >=30 werden verdoppelt
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Dekoratoren
+# In diesem Beispiel die Methode beg umwickelt say
+# Beim Aufruf von beg, say wird aufgerufen
+# Falls say_please true ist, ändert sich die ausgegebene Nachricht
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())  # Can you buy me a beer?
+print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+
+```
+
+## Lust auf mehr?
+
+### Kostenlos online (Englisch)
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [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)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+
+### Totholz (Englisch)
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown
index bdeaa30b..e14603cd 100644
--- a/de-de/ruby-de.html.markdown
+++ b/de-de/ruby-de.html.markdown
@@ -13,6 +13,7 @@ contributors:
   - ["Rahil Momin", "https://github.com/iamrahil"]
 translators:
   - ["Christian Albrecht", "https://github.com/coastalchief"]
+  - ["Dennis Keller", "https://github.com/denniskeller"]
 filename: ruby-de.rb
 lang: de-de
 ---
@@ -143,7 +144,7 @@ x #=> 10
 y #=> 10
 ```
 ## Benennung
-### Konvention ist snake_case 
+### Konvention ist snake_case
 ```
 snake_case = true
 ```
@@ -153,9 +154,9 @@ path_to_project_root = '/good/name/'
 path = '/bad/name/'
 ```
 # Symbols (sind auch Objekte)
-Symbols sind unveränderliche, wiederverwendbare Konstanten, welche intern  
-als integer repräsentiert werden. Sie werden häufig anstelle von Strings  
-verwendet, um sinnvoll Werte zu übermitteln.  
+Symbols sind unveränderliche, wiederverwendbare Konstanten, welche intern
+als integer repräsentiert werden. Sie werden häufig anstelle von Strings
+verwendet, um sinnvoll Werte zu übermitteln.
 Symbols werden mit dem Doppelpunkt gekennzeichnet.
 
 ```
@@ -195,7 +196,7 @@ array[12] #=> nil
 array[-1] #=> 5
 ```
 
-## Arrays können mit Stard Index und Länge indiziert werden
+## Arrays können mit Start Index und Länge indiziert werden
 ```
 array[2, 3] #=> [3, 4, 5]
 ```
@@ -216,11 +217,9 @@ array.push(6) #=> [1, 2, 3, 4, 5, 6]
 array.include?(1) #=> true
 ```
 
-# Hashes 
+# Hashes
 Hashes sind das Hauptfeature um Key/Values zu speichern
 
-```
-
 ## Ein Hash anlegen
 ```
 hash = { 'color' => 'green', 'number' => 5 }
@@ -231,8 +230,8 @@ hash.keys #=> ['color', 'number']
 ```
 hash['color'] #=> 'green'
 hash['number'] #=> 5
-hash['nothing here'] #=> nil 
-// Asking a hash for a key that doesn't exist returns nil:
+hash['nothing here'] #=> nil
+// Fragen an einen Hash nach einem Schlüssel, der nicht existiert, ruft nil hervor:
 ```
 
 ##  Symbols können auch keys sein
@@ -247,7 +246,7 @@ new_hash.has_key?(:defcon) #=> true
 new_hash.has_value?(3) #=> true
 ```
 
-### Tip:  Arrays und Hashes sind Enumerable
+### Tipp:  Arrays und Hashes sind Enumerable
 ### Und haben gemeinsame, hilfreiche Methoden wie:
 ### each, map, count, and more
 
@@ -269,8 +268,8 @@ for counter in 1..5
 end
 ```
 ## Stattdessen: "each" Methode und einen Bloch übergeben
-Ein Block ist ein Codeteil, den man einer Methode übergeben kann  
-Ähnelt stark lambdas, anonymen Funktionen oder Closures in anderen  
+Ein Block ist ein Codeteil, den man einer Methode übergeben kann
+Ähnelt stark lambdas, anonymen Funktionen oder Closures in anderen
 Programmiersprachen.
 
 ```
@@ -339,7 +338,7 @@ end
 => "OK job"
 ```
 
-# exception handling:
+# Exception handling:
 ```
 begin
   # code here that might raise an exception
@@ -360,13 +359,13 @@ def double(x)
   x * 2
 end
 ```
-## Funktionen (und Blocks) 
+## Funktionen (und Blocks)
 ## geben implizit den Wert des letzten Statements zurück
 ```
 double(2) #=> 4
 ```
 
-### Klammern sind optional wenn das Ergebnis nicht mehdeutig ist
+### Klammern sind optional wenn das Ergebnis nicht mehrdeutig ist
 ```
 double 3 #=> 6
 double double 3 #=> 12
@@ -604,7 +603,7 @@ Something.new.qux # => 'qux'
 
 ## Weiterführende Hinweise
 
-//EN  
+//EN
 
 - [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
 - [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
diff --git a/de-de/rust-de.html.markdown b/de-de/rust-de.html.markdown
new file mode 100644
index 00000000..faa4ec2b
--- /dev/null
+++ b/de-de/rust-de.html.markdown
@@ -0,0 +1,352 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+    - ["Christian Albrecht", "https://github.com/coastalchief"]
+lang: de-de
+filename: lernerust-de.rs
+---
+
+Rust ist eine Programmiersprache von Mozilla Research.  
+Rust vereint Sicherheit, Nebenläufigkeit und eine hohe Praxistauglichkeit.  
+  
+Sicherheit bedeuted, dass Programmierfehler ausgeschlossen werden, die zu  
+Speicherzugriffsfehlern führen könnten. Das funktioniert u.a. dadurch, dass  
+es keinen Garbage Collector gibt, sondern ein besonderes Typsystem.  
+  
+Das erste Release von Rust, 0.1, wurde im Januar 2012 veröffentlicht.  
+In den nächsten drei Jahren wurde die Sprache so schnell und aktiv weiter-  
+entwickelt, dass es einfach keine stabile gab und geraten wurde den  
+nightly build zu nutzen.  
+  
+Am 15. Mai 2015 wurde Rust 1.0 freigegeben, und zwar mit der Garantie einer  
+Abwärtskompatabilität. Verbesserungen der Kompilierzeit und andere Compiler  
+verbesserungen finden im Moment im nightly build statt. Von Rust gibt es im  
+Moment ungefähr alle sechs Wochen ein Release. Rust 1.1 beta wurde zusammen  
+mit dem 1.0 Release zur Verfügung gestellt.  
+  
+Obwohl Rust eine ziemlich low-level Sprache ist, vereint sie Ansätze aus  
+der Welt der funktionalen, der objektorientierten und der nebenläufigen  
+Programmierung. Dadurch kann in Rust nicht nur schnell, sondern auch sehr  
+effizient entwickelt werden.  
+  
+  
+```rust
+// Dies ist ein Kommentar. Ein einzeiliger...
+/* ...und multi-zeilen Kommentare sehe so aus */
+
+/////////////////////
+// 0. Installation //
+/////////////////////
+// Stabile binaries gibt es unter https://www.rust-lang.org/downloads.html
+
+// Programme werden in .rs Dateien geschrieben also zum Beispiel  
+// "main.rs" und dann kompiliert "rustc main.rs"  
+// Herauskommt eine ausführbare Datei "main"  
+// Für dieses Tutorial reicht das vollkommen aus. Für größere Projekte  
+// sollte das unten beschriebene Cargo angeschaut werden.  
+
+// Cargo  
+// Ein gängiges Tool um Rust Projekte zu verwalten ist Cargo. Es macht im  
+// wesentlichen drei Dinge: Code bauen, Dependencies laden und  
+// Dependencies bauen.  
+// Um ein vorhandenes Projekt zu cargo-ifyen müssen drei Dinge gemacht werden  
+// * Erstelle eine Cargo.toml Konfigurationsdatei  
+// * Verschiebe Source Code in ein src Verzeichnis  
+// * Lösche das alte Executable  
+//
+// 'cargo build' baut den Code  
+// 'cargo run' baut und führt das Programm aus  
+
+///////////////
+// 1. Basics //
+///////////////
+
+// Funktionen
+// `i32` ist der Typ für einen 32-bit signed Integer
+fn add2(x: i32, y: i32) -> i32 {
+    // Impliziter return (kein Semikolon)
+    x + y
+}
+
+// Main Funktion
+fn main() {
+    // Zahlen //
+
+    // Unveränderliche Variable
+    let x: i32 = 1;
+
+    // Integer/float Suffixe
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Type inference
+    Meistens kann der Rust Compiler selbst schlussfolgern, von welchem
+    Typ eine Variable ist, so dass man den Typ nicht explizit angeben muss.
+    In diesem Tutorial werden Typen explizit angegeben, um zu demonstrieren,
+    welche Möglichkeiten es gibt. Wenn man damit vertraut ist, kann man die
+    Typen auch weglassen und die Type Inference hilft dann im Hintergrund.
+
+    let implicit_x = 1;
+    let implicit_f = 1.3;
+
+    // Arithmetik
+    let sum = x + y + 13;
+
+    // Veränderliche Variable
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Strings //
+    // Strings gibt es in zwei Typen: &str und String
+
+    // Zunächst &str
+    let x: &str = "hello world!";
+
+    // Ausgabe
+    println!("{} {}", f, x); // 1.3 hello world
+
+    // Ein `String` – heap-allokierter String
+    let s: String = "hello world".to_string();
+
+    // Ein string slice – ist eigentlich ein unveränderlicher Pointer
+    // auf einen String – er enthält nicht den Inhalt den String, sondern
+    // eben nur den Pointer auf etwas, dass den Inhalt kennt:
+    // (In diesem Fall, `s`)
+    let s_slice: &str = &s;
+
+    // Ausgabe
+    println!("{} {}", s, s_slice); // hello world hello world
+
+    // Vektoren/Arrays //
+
+    // Ein Array mit fester Größe
+    let vier_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Ein dynamisches Array (Vektorentor)
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Ein slice – eine unveränderliche Ansicht, oder Pointer auf einen
+    // Vektor oder ein Array. Wie bei Strings, nur eben bei Vektoren
+    let slice: &[i32] = &vector;
+
+    // Benutze `{:?}` um eine debug Ausgabe zu erzeugen
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuples //
+
+    // Ein Tuple ist eine Liste mit fester Größe und kann Werte
+    // von unterschiedlichen Typen enthalten
+    let x: (i32, &str, f64) = (1, "hello", 3.4);
+
+    // Werte aus Vektor mit `let` destrukturieren
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 hello 3.4
+
+    // Vektor Indizes
+    println!("{}", x.1); // hello
+
+    //////////////
+    // 2. Typen //
+    //////////////
+
+    // Struct
+    struct Punkt {
+        x: i32,
+        y: i32,
+    }
+
+    let anfang: Punkt = Punkt { x: 0, y: 0 };
+
+    // Ein struct mit unbenannten Felder heisst ‘tuple struct’
+    struct Punkt2(i32, i32);
+
+    let anfang2 = Punkt2(0, 0);
+
+    // Einfache enum, so ähnlich wie in C
+    enum Richtung {
+        Links,
+        Rechts,
+        Hoch,
+        Runter,
+    }
+
+    let hoch = Richtung::Hoch;
+
+    // Enum mit Feldern
+    enum OptionalI32 {
+        EinI32(i32),
+        Nix,
+    }
+
+    let zwei: OptionalI32 = OptionalI32::EinI32(2);
+    let nix = OptionalI32::Nix;
+
+    // Generics //
+
+    struct Foo<T> { bar: T }
+
+    // In der Standard Bibliothek heisst das hier `Option`
+    enum Optional<T> {
+        EinWert(T),
+        KeinWert,
+    }
+
+    // Methoden //
+
+    impl<T> Foo<T> {
+        // Methoden erwarten einen `self` Parameter
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Traits (vergleichbar mit Interfaces oder Typklassen in anderen Sprachen)
+    // In Traits werden nur Method Signaturen erstellt.
+    // Die Implementierung findet im impl statt.
+
+    trait MacheIrgendwas<T> {
+        fn macheIrgendwas(self) -> Option<T>;
+    }
+
+    impl<T> MacheIrgendwas<T> for Foo<T> {
+        fn macheIrgendwas(self) -> Option<T> {
+            mache(self.bar)
+        }
+    }
+
+    let anderes_foo = Foo { bar: 1 };
+    println!("{:?}", anderes_foo.macheIrgendwas()); // mache(1)
+
+    /////////////////////////
+    // 3. Pattern matching //
+    /////////////////////////
+
+    let foo = OptionalI32::AnI32(1);
+    match foo {
+        OptionalI32::EinI32(n) => println!("hier ist ein i32: {}", n),
+        OptionalI32::Nix  => println!("hier ist nix!"),
+    }
+
+    // Advanced pattern matching
+    struct FooBar { x: i32, y: OptionalI32 }
+    let bar = FooBar { x: 15, y: OptionalI32::EinI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionalI32::EinI32(0) } =>
+            println!("Beide Zahlen sind 0!"),
+        FooBar { x: n, y: OptionalI32::EinI32(m) } if n == m =>
+            println!("Beide Zahlen sind gleich"),
+        FooBar { x: n, y: OptionalI32::EinI32(m) } =>
+            println!("Zahlen sind unterschiedlich: {} {}", n, m),
+        FooBar { x: _, y: OptionalI32::Nix } =>
+            println!("Die zweite Zahl ist leer!"),
+    }
+
+    /////////////////////
+    // 4. Control      //
+    /////////////////////
+
+    // `for` Schleife/Iterationen
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Ranges
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // gibt aus: `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Mathe ist klappt!");
+    } else {
+        println!("Oh nein...");
+    }
+
+    // `if` als Ausdruck
+    let wert = if true {
+        "gut"
+    } else {
+        "schlecht"
+    };
+
+    // `while` Schleife
+    while 1 == 1 {
+        println!("Läuft...");
+    }
+
+    // Unendliche Schleifen
+    loop {
+        println!("Hello!");
+    }
+
+    /////////////////////////////////////
+    // 5. Speichersicherheit & Pointer //
+    /////////////////////////////////////
+
+    // Owned pointer – nur eine Sache kann einen Pointer 'besitzen'.
+    // Das heisst, wenn das Objekt `Box` seinen scope verlässt oder verliert,
+    // wird es automatisch im Speicher de-allokiert.
+    let mut mine: Box<i32> = Box::new(3);
+    // Jetzt wird die Box dereferenziert
+    *mine = 5; 
+    // Jetzt geht `mine` in den Besitz von `now_its_mine` über. 
+    // `mine` wird verschoben.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // ergibt 7
+
+    // Das würde nicht kompilieren, da `now_its_mine` jetzt den Pointer besitzt
+    // println!("{}", mine); 
+
+    // Reference – ein unveränderlicher Pointer der fremde Daten referenziert
+    // Wenn eine Referenz auf einen Wert gesetzt wird, heisst das, dass man den
+    // Wert ausleiht (‘borrowed’).
+    // Ein ausgeliehener Wert ist unveränderlich und lebt solange wie der
+    // Scope existiert, in dem er erstellt wurde.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // Anders als `mine`, `var` kann hier weiter verwendet werden
+    println!("{}", *ref_var);
+    // var = 5; // das kompiliert nicht, da `var` ausgeliehen ist
+    // *ref_var = 6; // das kompiliert auch nicht, da `ref_var` eine unveränderliche Referenz ist
+
+    // Veränderliche Referenzen
+    // Solange ein Wert veränderlich geliehen wurde, kann man nicht darauf zugreifen
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;         // '*' wird benutzt um auf den veränderlich geliehenen Wert var2 zu zeigen
+
+    println!("{}", *ref_var2); // 6 , //var2 würde nicht kompilieren. //ref_var2 ist vom Typ &mut i32, also                                                      //stores a reference to an i32 not the value.
+    // var2 = 2; // würde das nicht kompilieren, da `var2` geliehen wurde.
+}
+```
+
+## Weitere Informationen
+
+Es gibt eine ganze Reihe mehr über Rust zu sagen. Dieser Text gibt nur einen  
+Einblick in die wichtigsten Sprachmerkmale.  
+Um mehr über Rust zu erfahren, sollte man mit den folgenden Stellen starten:
+
+1. Englisch:  
+  * [Die offizielle Rust Webseite](http://rust-lang.org)
+  * [The Rust Programming Language](https://doc.rust-lang.org/stable/book/README.html)
+  * [/r/rust](http://reddit.com/r/rust)
+  * the #rust channel on irc.mozilla.org 
+  
+2. Deutsch
+  * [Rust Wikipedia](https://de.wikipedia.org/wiki/Rust_(Programmiersprache))
+  * [Artikel im LinuxMagazin](http://www.linux-magazin.de/Ausgaben/2015/08/Rust)
diff --git a/de-de/sass-de.html.markdown b/de-de/sass-de.html.markdown
new file mode 100644
index 00000000..0c14e249
--- /dev/null
+++ b/de-de/sass-de.html.markdown
@@ -0,0 +1,450 @@
+---
+language: sass
+filename: learnsass-de.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+  - ["Kyle Mendes", "https://github.com/pink401k"]
+translators:
+    - ["Philipp Bochmann", "https://github.com/phbo85"]  
+lang: de-de
+---
+Sass ist eine CSS-erweiternde Sprache, welche Features wie Variablen, Verschachtelung, Mixins und mehr hinzufügt.
+Sass (und andere Präprozessoren wie [Less](http://lesscss.org/)) helfen Entwicklern dabei ihren Code wartbar und DRY (Don't Repeat Yourself - wiederhole dich nicht) zu schreiben.
+
+Sass hat zwei verschiedene Syntax-Optionen. SCSS, mit der gleichen Syntax wie CSS aber mit den zusätzlichen Features von Sass. Oder Sass (die originale Syntax), welche Einrückung statt geschweiften Klammern und Semikolons benutzt.
+Dieses Tutorial wurde mit SCSS geschrieben.
+
+Wenn du bereits mit CSS3 vertraut bist, wirst du dir Sass relativ schnell aneignen. Es bietet keine neuen Styling-Eigenschaft, sondern Werkzeuge mit denen du dein CSS effizienter schreiben kannst und die Wartung viel einfacher machst.
+
+
+```scss
+
+
+//Einzeilige Kommentare werden entfernt, wenn Sass zu CSS kompiliert wird.
+
+/* Mehrzeilige Kommentare bleiben bestehen. */
+
+
+
+/* Variablen
+============================== */
+
+
+
+/* Du kannst einen CSS-Wert (wie eine Farbe) in einer Variable speichern.
+Benutze das '$'-Zeichen um eine Variable zu erstellen. */
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Du kannst die Variablen überall in deinem Stylesheet verwenden.
+Wenn du nun eine Farbe ändern willst, musst du das nur einmal tun. */
+
+body {
+	background-color: $primary-color;
+	color: $secondary-color;
+	font-family: $body-font;
+}
+
+/* Das wird kompiliert zu: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* Dies ist viel besser wartbar als die Farbe
+an jeder Stelle im Stylesheet einzeln ändern zu müssen. */
+
+
+
+/* Mixins
+============================== */
+
+
+
+/* Wenn du merkst, dass du den gleichen Code für mehr als ein
+Element schreiben musst, kannst du ihn in einem mixin speichern.
+
+Dazu benutzt du '@mixin' plus einem Namen für dein mixin. */
+
+@mixin center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Du kannst das mixin mit '@include' und dem Namen des mixin benutzen. */
+
+div {
+	@include center;
+	background-color: $primary-color;
+}
+
+/* Das kompiliert zu: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+
+/* Du kannst Mixins benutzen, um shorthand Eigenschaften zu erstellen. */
+
+@mixin size($width, $height) {
+	width: $width;
+	height: $height;
+}
+
+/* Diese kannst du aufrufen und width und height als Parameter übergeben. */
+
+.rectangle {
+	@include size(100px, 60px);
+}
+
+.square {
+	@include size(40px, 40px);
+}
+
+/* Compiles to: */
+.rectangle {
+  width: 100px;
+  height: 60px;
+}
+
+.square {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+/* Funktionen
+============================== */
+
+
+
+/* Sass bietet Funktionen, welche benutzt werden können um eine Reihe
+   von Aufgaben zu bewältigen. Berücksichtige das Folgende: */
+
+/* Funktionen können aufgerufen werden indem du ihren Namen benutzt
+   und die benötigten Parameter übergibst. */
+body {
+  width: round(10.25px);
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25)
+}
+
+/* Kompiliert: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Du kannst auch deine eigenen Funktionen definieren. Funktionen ähneln
+   Mixins. Wenn du zwischen Funktionen und Mixins auswählen musst, denke
+   daran, dass Mixins am besten zur Generierung von CSS eignen, während
+   Funktionen besser für Logik in deinem Sass Code genutzt werden. Die
+   Beispiele mit in der Sektion "Mathematische Operatoren" sind ideale
+   Kandidaten für wiederverwendbare Funktionen. */
+
+/* Diese Funktion errechnet den Prozentwert aus target-size und parent-size
+   und gibt diesen zurück. */
+
+@function calculate-percentage($target-size, $parent-size) {
+  @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+  width: $main-content;
+}
+
+.sidebar {
+  width: calculate-percentage(300px, 960px);
+}
+
+/* Kompiliert: */
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+
+
+/* Extend (Vererbung)
+============================== */
+
+
+
+/* Extend ist ein Weg um Eigenschaften eines Selektoren mit einem anderem
+   zu teilen. */
+
+.display {
+	@include size(5em, 5em);
+	border: 5px solid $secondary-color;
+}
+
+.display-success {
+	@extend .display;
+	border-color: #22df56;
+}
+
+/* Kompiliert: */
+.display, .display-success {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.display-success {
+  border-color: #22df56;
+}
+
+/* Aufgrund der Art wie Sass die Klassen zusammen gruppiert, welche
+   alle das gleiche Grund-Styling haben, ist Extend der Erstellung
+   eines Mixins vorzuziehen. Wenn dies mit einem Mixin gemacht worden
+   wäre, würden width, height und border für jedes Element dupliziert
+   werden, welches das Mixin aufruft. Dies beeinflusst zwar nicht
+   deinen Workflow, bläht aber die vom Sass-Compiler erzeugten Dateien
+   unnötige auf. */
+
+
+
+/* Nesting (Verschachtelung)
+============================== */
+
+
+
+/* Sass erlaubt es Selektoren in Selektoren zu verschachteln. */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;
+	}
+}
+
+/* '&' wird durch den übergeordneten Selektor ersetzt. */
+/* Du kannst auch Pseudo-Klassen verschachteln. */
+/* Denk daran, dass zu viel Verschachtelung deinen Code schlechter
+   wartbar macht.
+   Die Best Practices empfehlen nicht mehr als 3 Ebenen zu verschachteln.
+   Zum Beispiel: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Kompiliert: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* Partials und Imports
+============================== */
+
+
+
+/* Sass erlaubt dir das Erstellen partieller Dateien (partials).
+   Das hilft dir modularisierten Sass Code zu schreiben.
+   Partielle Dateien fangen mit einem '_' an, z.B. _reset.css.
+   Partielle Dateien werden nicht zu CSS generiert. */
+
+/* Schau dir folgendes CSS an, was wir in einer Datei namens _reset.css haben */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Mit @import kannst du in Sass partielle Dateien importieren.
+   Dies unterscheidet sich vom traditionellen CSS @import Statement
+   welches einen neuen HTTP Request macht, um die zu importierende Datei
+   zu holen. Sass nimmt die importierte Datei und kombiniert sie mit
+   dem kompilierten Code. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Kompiliert: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Platzhalter Selektoren
+============================== */
+
+
+
+/* Platzhalter sind nützlich, um ein CSS Statement zum Erweitern zu
+   erstellen. Wenn du ein CSS Statement erstellst, welches du ausschließlich
+   zur Verwendung mit @extend nutzen willst, kannst du das mit einem
+   Platzhalter tun. Platzhalter fangen mit einem '%' statt einem '.'
+   oder '#' an und erscheinen nicht im kompilierten CSS. */
+
+%content-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  @extend %content-window;
+  background-color: #0000ff;
+}
+
+/* Kompiliert: */
+
+.message-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  background-color: #0000ff;
+}
+
+
+
+/* Mathematische Operationen
+============================== */
+
+
+
+/* Sass bietet die folgenden Operatoren: +, -, *, /, und %. Diese können
+   nützlich sein, wenn du Werte direkt in Sass berechnen willst, anstatt
+   vorher manuell errechnete Werte zu verwenden. Unten folgt ein Beispiel
+   für ein einfaches zweispaltiges Design. */
+
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: $main-size;
+}
+
+.sidebar {
+  width: $sidebar-size;
+}
+
+.gutter {
+  width: $gutter;
+}
+
+/* Compiles to: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+```
+
+## SASS oder Sass?
+Hast du dich jemals gefragt, ob Sass ein Akronym ist oder nicht? Hast du wahrscheinlich nicht, aber ich sage es dir trotzdem. Der Name der Sprache ist ein Wort, "Sass", und kein Akronym.
+Da die Leute durchgehend "SASS" geschrieben haben, hat der Ersteller der Sprache es scherzhaft "Syntactically Awesome StyleSheets" genannt.
+
+## Sass üben
+Wenn du mit Sass in deinem Browser spielen willst, schau dir [SassMeister](http://sassmeister.com/) an.
+Du kannst beide Syntax-Optionen benutzen, gehe einfach in die Einstellungen und wähle entweder Sass oder SCSS.
+
+## Kompatibilität
+Sass kann in jedem Projekt verwendet werden, solange du ein Programm hast, um es in CSS zu kompilieren.
+Du solltest verifizieren, dass das CSS, was du verwendest, mit deinen Ziel-Browsern kompatibel ist.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) und [CanIUse](http://caniuse.com) sind gute Resourcen um die Kompatibilät zu überpüfen.
+
+
+## Literaturhinweise
+* [Offizielle Dokumentation](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) bietet Tutorials (Anfänger bis Fortgeschritten) und Artikel.
diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index 456403a2..ddadcd8e 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -538,8 +538,9 @@ res2: Boolean = true
 scala> b.beissen  
 res3: Boolean = false  
 
-
-// Traits können auch via Mixins (Schlüsselwort "with") eingebunden werden  
+// Ein Trait kann auch als Mixin eingebunden werden. Die Klasse erbt vom
+// ersten Trait mit dem Schlüsselwort "extends", während weitere Traits
+// mit "with" verwendet werden können.
 
 trait Bellen {
 	def bellen: String = "Woof"
diff --git a/de-de/swift-de.html.markdown b/de-de/swift-de.html.markdown
new file mode 100644
index 00000000..b58a72d3
--- /dev/null
+++ b/de-de/swift-de.html.markdown
@@ -0,0 +1,591 @@
+---
+language: swift
+contributors:
+  - ["Grant Timmerman", "http://github.com/grant"]
+  - ["Christopher Bess", "http://github.com/cbess"]
+  - ["Joey Huang", "http://github.com/kamidox"]  
+  - ["Anthony Nguyen", "http://github.com/anthonyn60"]
+translators:
+    - ["Jonas Wippermann", "http://vfuc.co"]
+filename: learnswift-de.swift
+lang: de-de
+---
+
+Swift ist eine Programmiersprache von Apple für die Entwicklung von iOS und OS X Applikationen. Swift wurde 2014 zu Apples WWDC Entwicklerkonferenz vorgestellt und wurde mit dem Ziel entwickelt, fehlerträchtigen Code zu vermeiden sowie mit Objective-C zu koexistieren. Es wird mit dem LLVM Compiler gebaut und ist ab Xcode 6+ verfügbar.
+
+Das offizielle [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) Buch von Apple ist kostenlos via iBooks verfügbar.
+
+Außerdem hilfreich ist Apples [Getting Started Guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), ein guter Einstiegspunkt mit komplettem Swift-Tutorial.
+
+```swift
+// importiere ein Modul
+import UIKit
+
+//
+// MARK: Grundlagen
+//
+
+// Xcode unterstützt "Landmarks" um Code zu gliedern, sie werden in der Jump Bar aufgelistet
+// MARK: Abschnitts-Markierung
+// TODO: Zu erledigen
+// FIXME: Zu beheben
+
+// In Swift 2 wurden println und print zusammengefasst in eine print-Methode. Es wird automatisch ein Zeilenumbruch angehängt.
+print("Hello, world!") // println ist jetzt print
+print("Hello, world!", appendNewLine: false) // printen ohne Zeilenumbruch am Ende
+
+// Variablen (var) können nach der Initialisierung verändert werden 
+// Konstanten (let) können nach der Initialisierung NICHT verändert werden 
+
+var myVariable = 42
+let øπΩ = "value" // Unicode-Variablennamen
+let π = 3.1415926
+let convenience = "keyword" // Kontext-abhängiger Variablenname
+let weak = "keyword"; let override = "another keyword" // Instruktionen können durch ein Semikolon aufgeteilt werden
+let `class` = "keyword" // Nutze "Backticks" um Schlüsselwörter als Variablennamen zu verwenden
+let explicitDouble: Double = 70 // Typ explizit festgelegt
+let intValue = 0007 // 7
+let largeIntValue = 77_000 // 77000
+let label = "some text " + String(myVariable) // Casting
+let piText = "Pi = \(π), Pi 2 = \(π * 2)" // String Interpolation
+
+// Build-spezifische Werte
+// benutzt -D build configuration
+#if false
+    print("not printed")
+    let buildValue = 3
+#else
+    let buildValue = 7
+#endif
+print("Build value: \(buildValue)") // Build value: 7
+
+/*
+    Optionals ist ein Swift-Feature, welches ermöglicht, dass eine Variable entweder einen (`Some`) oder keinen (`None`) Wert hat
+
+    Da Swift von jeder property einen Wert erwartet, muss sogar nil explizit als Optional festgelegt werden.
+
+    Optional<T> ist ein Enum.
+*/
+var someOptionalString: String? = "optional" // Kann nil sein
+// Genau wie oben, aber ? ist ein postfix operator (Syntax Candy)
+var someOptionalString2: Optional<String> = "optional"
+
+if someOptionalString != nil {
+    // Ich bin nicht nil
+    if someOptionalString!.hasPrefix("opt") {
+        print("has the prefix")
+    }
+    
+    let empty = someOptionalString?.isEmpty
+}
+someOptionalString = nil
+
+// Implizit entpackter Optionalwert
+var unwrappedString: String! = "Value is expected."
+// Genau wie oben, aber ! ist ein postfix operator (noch mehr Syntax Candy)
+var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected."
+
+if let someOptionalStringConstant = someOptionalString {
+    // hat einen (`Some`) Wert, nicht nil
+    if !someOptionalStringConstant.hasPrefix("ok") {
+        // hat keinen "ok"-Prefix
+    }
+}
+
+// Swift unterstützt das festlegen von Werten eines beliebigen Typens
+// AnyObject == id
+// Im Gegensatz zum Objective-C `id`, funktioniert AnyObject mit jeglichen Werten (Class, Int, struct, etc)
+var anyObjectVar: AnyObject = 7
+anyObjectVar = "Changed value to a string, not good practice, but possible."
+
+/*
+    Ein Kommentar
+    
+    /*
+        Verschachtelte Kommentare sind ebenfalls unterstützt
+    */
+*/
+
+//
+// MARK: Collections
+//
+
+/*
+    Array und Dictionary-Typen sind structs. 
+    Deswegen implizieren `let` und `var` bei der Initialisierung auch ob sie änderbar (var) oder unveränderlich (let) sind.
+*/
+
+// Array
+var shoppingList = ["catfish", "water", "lemons"]
+shoppingList[1] = "bottle of water"
+let emptyArray = [String]() // let == unveränderlich
+let emptyArray2 = Array<String>() // genau wie oben
+var emptyMutableArray = [String]() // var == änderbar
+
+
+// Dictionary
+var occupations = [
+    "Malcolm": "Captain",
+    "kaylee": "Mechanic"
+]
+occupations["Jayne"] = "Public Relations"
+let emptyDictionary = [String: Float]() // let == unveränderlich
+let emptyDictionary2 = Dictionary<String, Float>() // genau wie oben
+var emptyMutableDictionary = [String: Float]() // var == änderbar
+
+
+//
+// MARK: Kontrollstruktur
+//
+
+// for-Schleife (array)
+let myArray = [1, 1, 2, 3, 5]
+for value in myArray {
+    if value == 1 {
+        print("One!")
+    } else {
+        print("Not one!")
+    }
+}
+
+// for-Schleife mit Indizes (array)
+for index in myArray.indices {
+    print("Value with index \(index) is \(myArray[index])")
+}
+
+// for-Schleife (dictionary)
+var dict = ["one": 1, "two": 2]
+for (key, value) in dict {
+    print("\(key): \(value)")
+}
+
+// for-Schleife (range)
+for i in -1...shoppingList.count {
+    print(i)
+}
+shoppingList[1...2] = ["steak", "peacons"]
+// ..< schließt letzte Nummer aus
+
+// while-Schleife
+var i = 1
+while i < 1000 {
+    i *= 2
+}
+
+// do-while-Schleife
+do {
+    print("hello")
+} while 1 == 2
+
+// Switch
+// Sehr mächtig, wie `if` statement mit Syntax Candy
+// Unterstützt Strings, Objekt-Instanzen und primitive Typen (Int, Double, etc)
+let vegetable = "red pepper"
+switch vegetable {
+case "celery":
+    let vegetableComment = "Add some raisins and make ants on a log."
+case "cucumber", "watercress":
+    let vegetableComment = "That would make a good tea sandwich."
+case let localScopeValue where localScopeValue.hasSuffix("pepper"):
+    let vegetableComment = "Is it a spicy \(localScopeValue)?"
+default: // notwendig (um alle möglichen Eingaben zu verarbeiten)
+    let vegetableComment = "Everything tastes good in soup."
+}
+
+
+//
+// MARK: Funktionen
+//
+
+// Funktionen sind ein sogenannter "first-class" Typ, was bedeutet, dass sie
+// in Funktionen geschachtelt werden und "herumgereicht" werden können
+
+// Funktion mit Swift header Dokumentation
+
+/**
+    Eine Grüß-Funktion
+
+    - Ein Aufzählungspunkt
+    - Ein weiterer Aufzählungspunkt in der Dokumentation
+
+    :param: name Ein Name
+    :param: day Ein Tag
+    :returns: Ein String, der Name und Tag beinhält.
+*/
+func greet(name: String, day: String) -> String {
+    return "Hello \(name), today is \(day)."
+}
+greet("Bob", "Tuesday")
+
+// Ähnlich wie oben, bloß anderes Funktions-Parameter-Verhalten
+func greet2(#requiredName: String, externalParamName localParamName: String) -> String {
+    return "Hello \(requiredName), the day is \(localParamName)"
+}
+greet2(requiredName:"John", externalParamName: "Sunday")
+
+
+// Funktion, welche mehrere Werte in einem Tupel zurückgibt
+func getGasPrices() -> (Double, Double, Double) {
+    return (3.59, 3.69, 3.79)
+}
+let pricesTuple = getGasPrices()
+let price = pricesTuple.2 // 3.79
+// Ignoriere Tupel-(oder andere)Werte mit _ (Unterstrich)
+let (_, price1, _) = pricesTuple // price1 == 3.69
+print(price1 == pricesTuple.1) // true
+print("Gas price: \(price)")
+
+// Variierende Argumente..
+func setup(numbers: Int...) {
+    // .. liegen als Array vor
+    let number = numbers[0]
+    let argCount = numbers.count
+}
+
+// Funktionen übergeben und zurückgeben
+func makeIncrementer() -> (Int -> Int) {
+    func addOne(number: Int) -> Int {
+        return 1 + number
+    }
+    return addOne
+}
+var increment = makeIncrementer()
+increment(7)
+
+// Übergabe via Referenz ("Pass by reference")
+func swapTwoInts(inout a: Int, inout b: Int) {
+    let tempA = a
+    a = b
+    b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+swapTwoInts(&someIntA, &someIntB)
+print(someIntB) // 7
+
+
+//
+// MARK: Closures
+//
+var numbers = [1, 2, 6]
+
+// Funktionen sind besondere Closures ({})
+
+// Closure Beispiel
+// `->` teilt Parameter und Rückgabe-Typ
+// `in` teilt den Closure Header vom Body
+numbers.map({
+    (number: Int) -> Int in
+    let result = 3 * number
+    return result
+})
+
+
+// Wenn der Typ bekannt ist, wie oben, kann folgendes getan werden
+numbers = numbers.map({ number in 3 * number })
+// oder sogar dies
+//numbers = numbers.map({ $0 * 3 })
+
+print(numbers) // [3, 6, 18]
+
+// "Schleppende Closure" (Trailing Closure)
+numbers = sorted(numbers) { $0 > $1 }
+
+print(numbers) // [18, 6, 3]
+
+// Sehr verkürzt, da sich der Typ durch den < Operator ableiten lässt
+
+numbers = sorted(numbers, < )
+
+print(numbers) // [3, 6, 18]
+
+//
+// MARK: Strukturen
+// (häufig einfach structs)
+//
+
+// Structures und Klassen haben sehr ähnliche Fähigkeiten
+struct NamesTable {
+    let names = [String]()
+    
+    // Eigendefiniertes subscript
+    subscript(index: Int) -> String {
+        return names[index]
+    }
+}
+
+
+// Strukturen haben eine automatisch generierte, designierte Initialisierungsfunktion
+let namesTable = NamesTable(names: ["Me", "Them"])
+let name = namesTable[1]
+print("Name is \(name)") // Name is Them
+
+//
+// MARK: Klassen
+//
+
+// Klassen, Strukturen und deren Member haben drei Ebenen der Zugriffskontrolle
+// Es gibt: internal (default), public, private
+
+public class Shape {
+    public func getArea() -> Int {
+        return 0;
+    }
+}
+
+// Alle Methoden und Properties einer Klasse sind public
+// Wenn das einfache Ziel ist, Daten in einem strukturierten Objekt zu halten,
+// sollte ein `struct` verwendet werden
+
+internal class Rect: Shape {
+    var sideLength: Int = 1
+    
+    // Eigendefinierte Getter und Setter für die Property
+    private var perimeter: Int {
+        get {
+            return 4 * sideLength
+        }
+        set {
+            // `newValue` ist eine implizite Variable, welche in Settern verfügbar ist
+            sideLength = newValue / 4
+        }
+    }
+    
+    // "Lazy" (faules) Laden einer Property, sie bleibt uninitialisiert (nil),
+    // bis sie aufgerufen wird
+    lazy var subShape = Rect(sideLength: 4)
+    
+    // Wenn kein eigendefinierter Getter/Setter notwendig ist,
+    // aber trotzdem Code vor und nach dem Setzen eines Variablenwertes laufen soll,
+    // kann "willSet" und "didSet" benutzt werden
+    var identifier: String = "defaultID" {
+        // der `willSet` Parameter wird der Variablenname für den neuen Wert sein 
+        willSet(someIdentifier) {
+            print(someIdentifier)
+        }
+    }
+    
+    init(sideLength: Int) {
+        self.sideLength = sideLength
+        // super.init muss immer aufgerufen werden, wenn eigene Properties initialisiert werden
+        super.init()
+    }
+    
+    func shrink() {
+        if sideLength > 0 {
+            sideLength -= 1
+        }
+    }
+    
+    override func getArea() -> Int {
+        return sideLength * sideLength
+    }
+}
+
+// Eine simple `Square`-Klasse erbt von/erweitert `Rect`
+class Square: Rect {
+    convenience init() {
+        self.init(sideLength: 5)
+    }
+}
+
+var mySquare = Square()
+print(mySquare.getArea()) // 25
+mySquare.shrink()
+print(mySquare.sideLength) // 4
+
+// Casten der Instanz
+let aShape = mySquare as Shape
+
+// Vergleiche Instanzen, nicht äquivalent zum == , welches Objekte vergleicht ("equal to") 
+if mySquare === mySquare {
+    print("Yep, it's mySquare")
+}
+
+// Optionale Initialisierung
+class Circle: Shape {
+    var radius: Int
+    override func getArea() -> Int {
+        return 3 * radius * radius
+    }
+    
+    // Ein Fragezeichen nach `init` ist eine optionale Initialisierung,
+    // welche nil zurückgeben kann
+    init?(radius: Int) {
+        self.radius = radius
+        super.init()
+        
+        if radius <= 0 {
+            return nil
+        }
+    }
+}
+
+var myCircle = Circle(radius: 1)
+print(myCircle?.getArea())    // Optional(3)
+print(myCircle!.getArea())    // 3
+var myEmptyCircle = Circle(radius: -1)
+print(myEmptyCircle?.getArea())    // "nil"
+if let circle = myEmptyCircle {
+    // wird nicht ausgeführt, da myEmptyCircle nil ist
+    print("circle is not nil")
+}
+
+
+//
+// MARK: Enums
+//
+
+// Enums können optional einen eigenen Typen haben
+// Wie Klassen auch können sie Methoden haben
+
+enum Suit {
+    case Spades, Hearts, Diamonds, Clubs
+    func getIcon() -> String {
+        switch self {
+        case .Spades: return "♤"
+        case .Hearts: return "♡"
+        case .Diamonds: return "♢"
+        case .Clubs: return "♧"
+        }
+    }
+}
+
+
+// Enum-Werte können vereinfacht geschrieben werden, es muss nicht der Enum-Typ
+// genannt werden, wenn die Variable explizit deklariert wurde
+
+var suitValue: Suit = .Hearts
+
+// Nicht-Integer-Enums brauchen direkt zugewiesene "Rohwerte"
+enum BookName: String {
+    case John = "John"
+    case Luke = "Luke"
+}
+print("Name: \(BookName.John.rawValue)")
+
+// Enum mit assoziierten Werten
+enum Furniture {
+    // mit Int assoziiert
+    case Desk(height: Int)
+    // mit String und Int assoziiert
+    case Chair(String, Int)
+    
+    func description() -> String {
+        switch self {
+        case .Desk(let height):
+            return "Desk with \(height) cm"
+        case .Chair(let brand, let height):
+            return "Chair of \(brand) with \(height) cm"
+        }
+    }
+}
+
+var desk: Furniture = .Desk(height: 80)
+print(desk.description())     // "Desk with 80 cm"
+var chair = Furniture.Chair("Foo", 40)
+print(chair.description())    // "Chair of Foo with 40 cm"
+
+
+//
+// MARK: Protokolle
+//
+
+// Protokolle (`protocol`s) können verlangen, dass entsprechende
+// Typen spezifische Instanz-Properties, Instanz/Klassen-Methoden,
+// Operatoren oder Subscripts implementieren/haben
+
+protocol ShapeGenerator {
+    var enabled: Bool { get set }
+    func buildShape() -> Shape
+}
+
+// Protocols mit @objc deklariert ermöglichen optionale Funktionen,
+// welche es ermöglichen, abzufragen ob ein Typ einem Protokoll entspricht
+@objc protocol TransformShape {
+    optional func reshaped()
+    optional func canReshape() -> Bool
+}
+
+class MyShape: Rect {
+    var delegate: TransformShape?
+    
+    func grow() {
+        sideLength += 2
+
+        // Ein Fragezeichen nach einer optionalen Property, Methode oder Subscript
+        // ignoriert elegant Nil-Werte und geben nil zurück, anstatt einen Laufzeitfehler zu werfen
+        // Dies wird "optional Chaining" (optionale Verkettung) genannt
+        if let allow = self.delegate?.canReshape?() {
+            // frage erst nach delegate, dann nach Methode
+            self.delegate?.reshaped?()
+        }
+    }
+}
+
+
+//
+// MARK: Sonstiges
+//
+
+// `extension`s: (Erweiterungen), erweitere Typen um zusätzliche Funktionalität
+
+// Square entspricht jetzt dem `Printable` Protokoll
+extension Square: Printable {
+    var description: String {
+        return "Area: \(self.getArea()) - ID: \(self.identifier)"
+    }
+}
+
+print("Square: \(mySquare)")
+
+// Standardtypen können ebenfalls erweitert werden
+extension Int {
+    var customProperty: String {
+        return "This is \(self)"
+    }
+    
+    func multiplyBy(num: Int) -> Int {
+        return num * self
+    }
+}
+
+print(7.customProperty) // "This is 7"
+print(14.multiplyBy(3)) // 42
+
+
+//Generics: Ähnlich zu Java und C#. Nutze das `where` keyword um die Bedingung
+// des Generics festzulegen
+
+func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
+        }
+    }
+    return nil
+}
+let foundAtIndex = findIndex([1, 2, 3, 4], 3)
+print(foundAtIndex == 2) // true
+
+// Operatoren:
+// Eigendefinierte Operatoren können mit diesen Zeichen beginnen:
+//      / = - + * % < > ! & | ^ . ~
+// oder
+// Unicode Mathematik, Symbole, Pfeile, Dingbat, und Linien/Box - Zeichen
+prefix operator !!! {}
+
+
+// Ein Prefix-Operator, welcher die Seitenlänge verdreifacht
+prefix func !!! (inout shape: Square) -> Square {
+    shape.sideLength *= 3
+    return shape
+}
+
+// Aktueller Wert
+print(mySquare.sideLength) // 4
+
+// Wert nach verwendung des eigenen Operators
+!!!mySquare
+print(mySquare.sideLength) // 12
+```
diff --git a/de-de/tcl-de.html.markdown b/de-de/tcl-de.html.markdown
new file mode 100644
index 00000000..4f3b8820
--- /dev/null
+++ b/de-de/tcl-de.html.markdown
@@ -0,0 +1,475 @@
+---
+language: Tcl
+contributors:
+    - ["Poor Yorick", "http://pooryorick.com/"]
+translators:
+    - ["Martin Schimandl", "https://github.com/Git-Jiro"]
+filename: learntcl-de.tcl
+lang: de-de
+---
+
+Tcl wurde kreiert von [John Ousterhout](http://wiki.tcl.tk/John Ousterout) als
+eine wiederverwendbare Script-Sprache für Chip-Design Werkzeuge die er kreiert
+hat. Im Jahre 1997 wurde er mit dem [ACM Software System
+Award](http://en.wikipedia.org/wiki/ACM_Software_System_Award) für Tcl
+ausgezeichnet. Tcl kann sowohl als eingebettete Scipt-Sprache als auch als
+allgemeine Programmier-Sprache verwendet werden. Tcl kann auch als portable
+C-Bibliothek verwendet werden. Sogar in Fällen in denen die Script-Fähigkeiten
+nicht nötig sind. Denn Tcl stellt Daten-Strukturen wie dynamische Zeichenketten,
+Listen und Hash-Tabellen bereit. Die C-Bilbiothek stellt auch portable
+Funktionen zur Verfügung: Laden von dynamischen Bibliotheken, Zeichenketten
+formatierung und Code Konversion, Dateisystem Operationen, Netzwerk Operationen
+und mehr.
+
+
+Verschiedenste herausragende Fähigkeiten von Tcl:
+
+* Praktische Cross-Platform Netzwerk-API
+
+* Vollständig virtualisiertes Dateisystem
+
+* Stapelbare I/O Kanäle
+
+* Asynchron bis zum Kern
+
+* Vollständige Ko-Routinen
+
+* Robustes und einfach zu verwendendes Thread-Modell
+
+
+Wenn Lisp ein Listen-Prozessor ist, dann ist TCl ein Zeichenketten-Prozessor.
+Alle Werte sind Zeichenketten. Eine Liste ist ein Zeichenketten-Format. Eine
+Prozedur-Definition ist ein Zeichenketten-Format. Um leistungsfähig zu sein,
+werden Tcl-intern diese Zeichenketten in Strukutierter-Form gepuffert. Ein
+Beispiel: Der "list" Befehl arbeitet mit diesen internen gepufferten 
+Repräsentationen. Tcl kümmert sich selbständig darum die String-Repräsentationen
+zu aktualisieren, falls dies im Skript benötigt werden sollten. Das Kopieren-
+beim-Schreiben-Design von Tcl erlaubt es Skript-Authoren mit großen Daten-
+Strukturen zu arbeiten ohne zuätzlichen Speicher-Overhead. Prozeduren werden
+automatisch byte-kompiliert außer sie verwenden dynamsiche Befehle wie zum
+Beispiel "uplevel", "upvar und "trace".
+
+Es ist eine freude in Tcl zu programmieren. Hacker-Typen werden gefallen daran
+finden, wenn sie Lisp, Forth oder Smalltalk interessant finden. Tcl wird auch
+Ingenieuren und Wissenshaftlern gefallen die nur den Job erledigen wollen,
+und zwar mit Werkzeugen die sich ihrem Willen anpassen. Bei Tcl ist jegliche
+funktionalität in Befehlen ausgeführt, selbst Dinge wie Schleifen und
+Mathematische-Funktionen die bei anderen Sprachen normalerweise Teil der Syntax
+sind. Das erlaubt Tcl in den Hintergrund von Domänen spezischen Sprachen zu
+treten die das jeweilige Projekt gerade benötigt. Die Tcl-Syntax ist sehr
+leichtgewichtig. Sie ist selbst leichtgewichtiger als die Syntax von Lisp.
+Tcl steht dir einfach nicht im Weg.
+
+
+```tcl
+#! /bin/env tclsh
+
+################################################################################
+## 1. Richtlinien 
+################################################################################
+
+# Tcl ist nicht Bash oder C! Das muss gesagt werden, denn standard Shell-Quoting
+# funktioniert fast mit Tcl. Daher glauben viele sie können diese Syntax für
+# Tcl übernehmen. Am Beginn funktioniert das meist, führt aber schnell zu 
+# Frustrationen wenn die Skripte komplexer werden.
+
+# Eckige-Klammern sind nur Quoting-Mechanismen, keine Code-Block-Konstruktoren
+# und auch keine Listen-Konstruktoren. In Tcl gibt es diese beiden Dinge nicht.
+# Eckige-Klammern werden verwendet um Spezial-Zeichen in Prozeduren zu escapen
+# und in Zeichenketten die als Listen formattiert sind.
+
+################################################################################
+## 2. Syntax 
+################################################################################
+
+# Jede Zeile ist ein Befehl. Das erste Wort ist der Name des Befehls, jedes
+# weitere Wort ist ein Argument des Befehls. Wörter sind begrenzt durch
+# Leerzeichen. Da jedes Wort auch ein String ist, sind keine speziellen
+# auszeichnungen wie Anführungs-Zeichen, Klammern oder Backslashes nötig.
+# Selbst wenn Anführungs-Zeichen verwendet werden, denn sie sind ja keine
+# String-Konstruktoren, sondern nur Escape-Zeichen.
+
+set greeting1 Sal 
+set greeting2 ut
+set greeting3 ations
+
+
+# Strichpunkte begrenzen auch Befehle
+set greeting1 Sal; set greeting2 ut; set greeting3 ations 
+
+
+# Das Dollar-Zeichen zeigt eine Variablen-Substitution an.
+set greeting $greeting1$greeting2$greeting3
+
+
+# Eckige-Klammern zeigen Befehls-Substitionen an. Das Ergebnis des Befehls wird an
+# Stelle des Klammern-Ausdrucks eingefügt. Wenn man dem "set" Befehl nur den
+# Namen einer Variablen übergibt, gibt er den Wert der Variablen zurück.
+set greeting $greeting1$greeting2[set greeting3]
+
+
+# Befehls-Substitution sollte eigentlich Script-Substitution heißen, denn ein
+# komplettes Script, und nicht nur ein Befehl, kann zwischen die Eckigen-Klammern
+# geschrieben werden. Der "incr" Befehl erhöht den Wert einer Variable um 1
+# und gibt den neuen Wert der Variable zurück.
+set greeting $greeting[
+	incr i
+	incr i
+	incr i
+]
+
+
+# Der Backslash unterdrück die Bedeutung von Sonderzeichen
+set amount \$16.42
+
+
+# Der Backslash macht bestimmte Zeichen zu Sonderzeichen
+puts lots\nof\n\n\n\n\n\nnewlines
+
+# Ein Wort das in geschweiften Klammern eingeschlossen wurde ist von jeglichen
+# speziellen Interpretationen ausgeschlossen. Eine Ausnahme bilden Backslashes
+# vor geschweiften Klammern, hiermit wird die geschweifte Klammer von der Suche
+# nach der schließenden geschweiften Klammer ausgeschlossen.
+set somevar {
+    Das ist ein literales $ Zeichen, diese geschweifte Klammer \} wird nicht
+    als Ende interpretiert.
+} 
+
+
+# Bei einem Wort das in doppelten Anführungszeichen steht verlieren Leerzeichen
+# ihre spezielle Bedeutung.
+set name Neo
+set greeting "Hallo, $name"
+
+
+#Variablen-Namen können irgend eine Zeichenkette sein.
+set {first name} New
+
+
+# Die Geschweifte-Klammern-Form der Variablen-Substitution kann sehr komplexe
+# Variblen-Namen handhaben.
+set greeting "Hello, ${first name}"
+
+
+# Der "set" Befehl kann immer anstatt einer Variablen-Substition verwendet
+# werden.
+set greeting "Hello, [set {first name}]"
+
+
+# Mit dem Expansions-Operator "{*}" werden Wörter innerhalb eines Wortes wieder
+# individuell als Teile des aktuellen Befehls behandelt.
+set {*}{name Neo}
+
+# Ist Äquivalent zu
+set name Neo
+
+
+# Ein Array ist eine spezielle Varible die also Kontainer für andere Variablen
+# dient.
+set person(name) Neo
+set person(gender) male
+set greeting "Hello, $person(name)"
+
+
+# Ein Namensraum enthält Befehle und Variablen
+namespace eval people {
+    namespace eval person1 {
+        variable name Neo
+    }
+}
+
+
+#Der volle Name einer Variablen beihaltet den/die umschließenden
+# Namensraum/Namensräume begrenzt durch zwei Doppelpunkte.
+set greeting "Hello $people::person1::name"
+```
+
+```tcl
+################################################################################
+## 3. Einige Notizen 
+################################################################################
+
+# Jede weitere Funktion ist über Befehle implementiert. Von nun an kommt keine
+# neue Syntax hinzu. Alles weitere das es über Tcl zu lernen gibt ist das
+# Verhalten individueller Befehle und die bedeutung ihrer Argumente.
+
+
+# Um einen Interpreter zu bekommen mit dem man nichts mehr machen kann, lösche
+# einfach den globalen Namensraum. Das ist nicht sehr sinnvoll, zeigt aber die
+# Natur von Tcl.
+namespace delete ::
+
+
+# Wegen des Verhaltens der Namens-Auflösung ist es sicherer den "variable"
+# Befehl zu verwenden um in einem Namensraum einen Wert zu deklarieren oder
+# zuzuweisen. Wenn eine Variable mit dem namen "name" bereits im globalen
+# Namensraum existiert, bewirkt der "set" Befehl das der globalen Variable ein
+# Wert zugewiesen wird, anstatt eine Variable im lokalen Namensraum zu erzeugen
+namespace eval people {
+    namespace eval person1 {
+        variable name Neo
+    }
+}
+
+
+# Es kann immer der vollständige Name einer Variable verwendet werden, falls
+# gewünscht.
+set people::person1::name Neo
+
+
+
+################################################################################
+## 4. Befehle 
+################################################################################
+
+# Berechnungen werde mit dem "expr" Befehl durchgeführt.
+set a 3
+set b 4
+set c [expr {$a + $b}]
+
+# Since "expr" performs variable substitution on its own, brace the expression
+# to prevent Tcl from performing variable substitution first.  See
+
+# Da der "expr" Befehl eigene Variablen-Substitutionen durchführt, setze den
+# zu berechnenden Ausdruck in Eckige-Klammern. Das hindert Tcl daran Variablen-
+# Substitutionen durchzuführen. Für Details siehe:
+# "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions"
+
+
+# Der "expr" Befehl versteht Variablen- und Befehls-Substitutionen
+set c [expr {$a + [set b]}]
+
+
+# Der "expr" Befehl stellt Mathematische-Funktionen zur Verfügung.
+set c [expr {pow($a,$b)}]
+
+
+# Mathematische Operatoren sind als Befehle auch im Namensraum 
+# ::tcl::mathop verfügbar.
+::tcl::mathop::+ 5 3
+
+# Befehle können aus anderen Namensräumen importiert werden.
+namespace import ::tcl::mathop::+
+set result [+ 5 3]
+
+
+# Neu Befehle werden mit dem "proc" Befehl gebildet.
+proc greet name {
+    return "Hello, $name!"
+}
+
+#Es können mehrere Parameter spezifiziert werden.
+proc greet {greeting name} {
+    return "$greeting, $name!"
+}
+
+
+# Wie bereits erwähnt, geschwungene Klammern erzeugen keinen Code-Block.
+# Jeder Wert, sogar das dritte Argument für den "proc" Befehl ist eine
+# Zeichenkette. Der vorherige Befehl kann daher auch ohne
+# geschwungene Klammern geschrieben werden:
+proc greet greeting\ name return\ \"Hello,\ \$name!
+
+
+
+# Wenn der letzte Parameter der literale Wert "args" ist, sammelt dieser Wert
+# alle übrigen Argumente des Befehls ein wenn dieser aufgerufen wird.
+proc fold {cmd args} {
+    set res 0
+    foreach arg $args {
+        set res [$cmd $res $arg]
+    }
+}
+fold ::tcl::mathop::* 5 3 3 ;# ->  45
+
+
+# Bedingte Ausführung ist auch als Befehl implementiert
+if {3 > 4} {
+    puts {This will never happen}
+} elseif {4 > 4} {
+    puts {This will also never happen}
+} else {
+    puts {This will always happen}
+}
+
+
+# Auch Schleifen sind Befehle. Das erste, zweite und dritte Argument des "for"
+# Befehls wird als mathematischer Ausdruck behandelt.
+for {set i 0} {$i < 10} {incr i} {
+    set res [expr {$res + $i}]
+}
+
+
+# Das erste Argument des "while" Befehls wird auch als mathematischer Ausdruck
+# behandelt.
+set i 0
+while {$i < 10} {
+    incr i 2
+}
+
+
+# Eine Liste ist eine speziell formatierte Zeichenkette. Im einfachsten Fall
+# genügen Leerzeichen als Trennzeichen zwischen den einzelnen Werten.
+set amounts 10\ 33\ 18 
+set amount [lindex $amounts 1]
+
+
+# Geschwungene Klammern und Backslashes können verwendet werden um komplexe
+# Werte in einer Liste zu formatieren. Eine Liste sieht aus wie ein Skript,
+# allerdings verlieren verlieren Zeilenumbrüche und Doppelüunkte ihre 
+# besondere Bedeutung. Diese Funktionalität macht Tcl homoikonisch. Die
+# folgende Liste enhtält drei Elemente.
+set values {
+
+    one\ two
+
+    {three four}
+
+    five\{six
+
+}
+
+
+# Da Listen auch Zeichenketten sind, kann man Zeichenketten-Operationen auf
+# ihnen anwenden. Allerdings mit dem Risiko die Formatierung der Liste zu
+# beschädigen.
+set values {one two three four}
+set values [string map {two \{} $values] ;# $values is no-longer a \
+    properly-formatted listwell-formed list
+
+
+# Der sicherste Weg korrekt formatierte Liste zu erzeugen, ist den "list"
+# Befehl zu verwenden.
+set values [list one \{ three four]
+lappend values { } ;# Ein Leerzeichen als Element der Liste hinzufügen
+
+
+# Mit "eval" können Werte als Skripts evaluiert weden.
+eval {
+    set name Neo
+    set greeting "Hello, $name"
+}
+
+
+# Eine Liste kann immer an "eval" übergeben werden, solange die Liste einen
+# einzigen Befehl entält.
+eval {set name Neo}
+eval [list set greeting "Hello, $name"]
+
+
+# Daher: Wenn "eval" verwendet wird, verwende [list] um den gewünschten Befehl
+# aufzubauen.
+set command {set name}
+lappend command {Archibald Sorbisol}
+eval $command
+
+
+# Es ist ein häufiger Fehler die Listen funktionen beim Aufbauen von Listen
+# nicht zu verwenden.
+set command {set name}
+append command { Archibald Sorbisol}
+eval $command ;# Hier passiert eine Fehler, denn der "set" Befehl hat nun zu \
+    viele Argumente {set name Archibald Sorbisol}
+
+
+# Dieser Fehler kann auch leicht beim "subst" Befehl passieren.
+set replacement {Archibald Sorbisol}
+set command {set name $replacement}
+set command [subst $command] 
+eval $command ;# The same error as before: too many arguments to "set" in \
+    {set name Archibald Sorbisol}
+
+
+# Die korrekte Vorgangsweise ist es den substituierten Wert mit dem "list"
+# Befehl zu formatieren.
+set replacement [list {Archibald Sorbisol}]
+set command {set name $replacement}
+set command [subst $command] 
+eval $command
+
+
+# Der "list" Befehl wird sehr häufig verwendet um Werte zu formatieren die
+# in Tcl Skript Vorlagen substituiert werden. Es gibt dazu viele Beispiele,
+# siehe unterhalb.
+
+
+# Der "apply" Befehl evaluiert eine Zeichenkette als Befehl.
+set cmd {{greeting name} {
+    return "$greeting, $name!"
+}}
+apply $cmd Whaddup Neo
+
+
+# Der "uplevel" Befehl evaluiert ein Skript in einem höher liegenden
+Gültigkeitsbereich.
+proc greet {} {
+	uplevel {puts "$greeting, $name"}
+}
+
+proc set_double {varname value} {
+	if {[string is double $value]} {
+		uplevel [list variable $varname $value]
+	} else {
+		error [list {not a double} $value]
+	}
+}
+
+
+# Der "upvar" Befehl verknüpft eine Variable im aktuellen Gültigkeitsbereich
+# mit einer Variable in einem höher liegenden Gültigkeitsbereich.
+proc set_double {varname value} {
+	if {[string is double $value]} {
+		upvar 1 $varname var
+		set var $value
+	} else {
+		error [list {not a double} $value]
+	}
+}
+
+
+# Werde den eingebauten "while" Befehl los.
+rename ::while {}
+
+
+# Definieren einen neuen "while" Befehl mit hilfe des "proc" Befehls.
+# Ausführlichere Fehler-Behandlung wird dem Leser als Übung überlassen.
+proc while {condition script} {
+    if {[uplevel 1 [list expr $condition]]} {
+        uplevel 1 $script
+        tailcall [namespace which while] $condition $script
+    }
+}
+
+
+# Der "coroutine" Befehl erzeugt einen separaten Call-Stack, zusammen mit einem
+# Befehl um diesem Call-Stack zu verwenden. Der "yield" Befehl unterbricht
+# die Ausführung des aktuellen Call-Stacks.
+proc countdown {} {
+	#send something back to the initial "coroutine" command
+	yield
+
+	set count 3 
+	while {$count > 1} {
+		yield [incr count -1]
+	}
+	return 0
+}
+coroutine countdown1 countdown
+coroutine countdown2 countdown
+puts [countdown 1] ;# -> 2 
+puts [countdown 2] ;# -> 2 
+puts [countdown 1] ;# -> 1 
+puts [countdown 1] ;# -> 0 
+puts [coundown 1] ;# -> invalid command name "countdown1"
+puts [countdown 2] ;# -> 1 
+
+
+```
+
+## Referenzen
+
+[Official Tcl Documentation](http://www.tcl.tk/man/tcl/)
+
+[Tcl Wiki](http://wiki.tcl.tk)
+
+[Tcl Subreddit](http://www.reddit.com/r/Tcl)
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
index a46c30f6..25f2edc4 100644
--- a/de-de/yaml-de.html.markdown
+++ b/de-de/yaml-de.html.markdown
@@ -10,7 +10,7 @@ lang: de-de
 
 YAML ist eine Sprache zur Datenserialisierung, die sofort von Menschenhand geschrieben und gelesen werden kann.
 
-YAML ist eine Erweiterung von JSON, mit der Erweiterung von syntaktisch wichtigen Zeilenumbrüche und Einrückung sowie in Python. Anders als in Python erlaubt YAML keine Tabulator-Zeichen.
+YAML ist ein Erweiterung von von JSON mit der Erweiterung um syntaktisch wichtige Zeilenumbrüche und Einrückungen, ähnlich wie auch in Python. Anders als in Python allerdings erlaubt YAML keine Tabulator-Zeichen.
 
 ```yaml
 # Kommentare in YAML schauen so aus.
diff --git a/dynamic-programming.html.markdown b/dynamic-programming.html.markdown
new file mode 100644
index 00000000..7df367e7
--- /dev/null
+++ b/dynamic-programming.html.markdown
@@ -0,0 +1,51 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+---
+
+# Dynamic Programming
+
+## Introduction
+
+Dynamic Programming is a powerful technique used for solving a particular class of problems as we will see. The idea is very simple, If you have solved a problem with the given input, then save the result for future reference, so as to avoid solving the same problem again.
+
+Always remember!
+"Those who can't remember the past are condemned to repeat it"
+
+## Ways of solving such Problems
+
+1. *Top-Down* : Start solving the given problem by breaking it down. If you see that the problem has been solved already, then just return the saved answer. If it has not been solved, solve it and save the answer. This is usually easy to think of and very intuitive. This is referred to as Memoization.
+
+2. *Bottom-Up* : Analyze the problem and see the order in which the sub-problems are solved and start solving from the trivial subproblem, up towards the given problem. In this process, it is guaranteed that the subproblems are solved before solving the problem. This is referred to as Dynamic Programming.
+
+## Example of Dynamic Programming
+
+The Longest Increasing Subsequence problem is to find the longest increasing subsequence of a given sequence. Given a sequence `S= {a1 , a2 , a3, a4, ............., an-1, an }` we have to find a longest subset such that for all `j` and `i`,  `j<i` in the subset `aj<ai`.
+First of all we have to find the value of the longest subsequences(LSi) at every index i with last element of sequence being ai. Then largest LSi would be the longest subsequence in the given sequence. To begin LSi is assigned to be one since ai is element of the sequence(Last element). Then for all `j` such that `j<i` and `aj<ai`, we find Largest LSj and add it to LSi. Then algorithm take *O(n2)* time.
+
+Pseudo-code for finding the length of the longest increasing subsequence:
+This algorithms complexity could be reduced by using better data structure rather than array. Storing predecessor array and variable like largest_sequences_so_far and its index would save a lot time.
+
+Similar concept could be applied in finding longest path in Directed acyclic graph.
+
+```python
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (largest < LS[i])
+```
+
+### Some Famous DP Problems
+
+- Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code 
+- Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem 
+- Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence 
+
+## Online Resources
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/edn.html.markdown b/edn.html.markdown
index d0bdddfc..ca04df89 100644
--- a/edn.html.markdown
+++ b/edn.html.markdown
@@ -14,7 +14,7 @@ Clojure, there are implementations of EDN for many other languages.
 The main benefit of EDN over JSON and YAML is that it is extensible. We
 will see how it is extended later on.
 
-```Clojure
+```clojure
 ; Comments start with a semicolon.
 ; Anything after the semicolon is ignored.
 
diff --git a/el-gr/css-gr.html.markdown b/el-gr/css-gr.html.markdown
index 327dc1a0..31b30479 100644
--- a/el-gr/css-gr.html.markdown
+++ b/el-gr/css-gr.html.markdown
@@ -6,28 +6,27 @@ filename: css-gr.html.markdown
 lang: el-gr
 ---
 
-Η αρχική μορφή του Παγκόσμιου Ιστού αποτελούταν απο καθαρό κείμενο, χωρίς οπτικά αντικείμενα. Με το πέρας 
+Η αρχική μορφή του Παγκόσμιου Ιστού αποτελείτο απο καθαρό κείμενο, χωρίς οπτικά αντικείμενα. Με το πέρας 
 του χρόνου και την εξέλιξη των Φυλλομετρητών, οι πλούσιες σελίδες, σε οπτικά και πολυμεσικά αντικείμενα, 
-γίναν καθημερινότητα.
+έγιναν καθημερινότητα.
 
 Η CSS μας βοηθάει να διαχωρήσουμε το περιεχόμενο της σελίδας μας (HTML) απο την οπτική της περιγραφή.
 
 Με την CSS ορίζουμε οπτικές ιδιότητες (χρώμα, μέγεθος, κλπ) σε HTML αντικείμενα (H1, div, κλπ).
 
 ```css
-/* Σχόλια εμφανίζονται εντός καθέτου-αστερίσκου, όπως εδώ. 
+/* Τα σχόλια εμφανίζονται εντός καθέτου-αστερίσκου, όπως εδώ. 
    Δεν υπάρχουν σχόλια μια γραμμής και πολλών. */
 
 /* ####################
    ## ΚΑΝΟΝΕΣ
    #################### */
 
-/* ένας κανόνας χρησιμοποιείτε για να στοχεύσουμε ένα αντικείμενο (selector).
+/* ένας κανόνας χρησιμοποιείται για να στοχεύσουμε ένα αντικείμενο (selector). */
 selector { property: value; /* περισσότερες ιδιότητες...*/ }
 
 /*
-Αυτό είναι ενα παράδειγμα αντικειμένου¨
-
+Αυτό είναι ενα παράδειγμα αντικειμένου
 <div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
 */
 
diff --git a/el-gr/java-gr.html.markdown b/el-gr/java-gr.html.markdown
new file mode 100644
index 00000000..5dad4a60
--- /dev/null
+++ b/el-gr/java-gr.html.markdown
@@ -0,0 +1,858 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+filename: LearnJava-gr.java
+translators:
+  - ["Andreas Loizou" , "https://github.com/lack3r/"]
+lang: el-gr
+---
+
+H Java είναι μία γενικού-σκοπού, συντρέχων (concurrent), βασισμένη σε κλάσεις, 
+αντικειμενοστρεφής (object oriented) γλώσσα προγραμματισμού.
+[Διαβάστε περισσότερα εδώ.](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Τα σχόλια μονής γραμμής ξεκινούν με //
+/*
+Τα σχόλια πολλών γραμμών μοιάζουν κάπως έτσι.
+*/
+/**
+Τα σχόλια JavaDoc μοιάζουν κάπως έτσι. Χρησιμοποιούνται για να περιγράψουν την 
+Κλάση ή διάφορα χαρακτηριστικά της Κλάσης.
+*/
+
+// Εισαγωγή της κλάσης ArrayList η οποία βρίσκεται εντός του πακέτου java.util
+import java.util.ArrayList;
+// Εισαγωγή όλων των κλάσεων που βρίσκονται εντός του πακέτου java.security
+import java.security.*;
+
+// Κάθε αρχείο .java περιέχει μία δημόσια(public) κλάση εξωτερικού-επιπέδου 
+// (outer-level), η οποία έχει το ίδιο ονομα με το αρχείο.
+public class LearnJava {
+
+    // Για να τρέξει ένα πρόγραμμα java, πρέπει να έχει μία κύρια μέθοδο (main 
+    // method) ως αρχικό σημείο.
+    public static void main (String[] args) {
+
+        // Χρησιμοποιούμε τη μέθοδο System.out.println() για να τυπώσουμε 
+        // γραμμές.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Για να τυπώσουμε χωρίς να τυπωθεί αλλαγή γραμμής (newline), 
+        // χρησιμοποιούμε System.out.print().
+        System.out.print("Hello ");
+        System.out.print("World");
+
+        // Χρησιμοποιούμε τη μέθοδο System.out.printf() για έυκολη μορφοποίηση 
+        // της εκτύπωσης.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        ///////////////////////////////////////
+        // Μεταβλητές(Variables)
+        ///////////////////////////////////////
+
+        /*
+        *  Δήλωση Μεταβλητών
+        */
+        // Δηλώνουμε μία μεταβλητή χρησιμοποιώντας τη μορφή 
+        // <Τύπος Μεταβλητής> <Όνομα Μεταβλητής>
+        int fooInt;
+        // Δηλώνουμε πολλαπλές μεταβλητές ίδιου τύπου χρησιμοποιώντας τη μορφή 
+        // <Τύπος> <Όνομα1>, <Όνομα2>, <Όνομα3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Αρχικοποίηση Μεταβλητών
+        */
+
+        // Αρχικοποιούμε μια μεταβλητή χρησιμοποιώντας τη μορφή 
+        // <τύπος> <όνομα> = <τιμή>
+        int fooInt = 1;
+        // Αρχικοποιούμε πολλαπλές μεταβλητές ιδίου τύπου με την ίδια τιμή 
+        // χρησιμοποιώντας <τύπος> <Όνομα1>, <Όνομα2>, <Όνομα3> = <τιμή>
+        int fooInt1, fooInt2, fooInt3;
+        fooInt1 = fooInt2 = fooInt3 = 1;
+
+        /*
+        *  Τύποι μεταβλητών
+        */
+        // Byte - 8-bit signed two's complement integer
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - 16-bit signed two's complement integer
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-bit signed two's complement integer
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - 64-bit signed two's complement integer
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // Το L χρησιμοποιείται για να δηλώσει ότι η συγκεκριμένη τιμή της 
+        // μεταβλητής είναι τύπου Long;
+        // Ό,τιδήποτε χρησιμοποιείται χωρίς αυτό τυχαίνει μεταχείρισης όπως 
+        // μία τιμή μεταβλητής integer by default.
+
+        // Σημείωση: Η Java δεν έχει unsigned τύπους.
+
+        // Float - Single-precision 32-bit IEEE 754 Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127 
+        float fooFloat = 234.5f;
+        // f or F χρησιμοποιείται για να δηλώσει ότι η συγκεκριμένη τιμή 
+        // μεταβλητής είναι τύπου float;
+        // αλλιώς τυγχαίνει μεταχείρισης όπως μία τιμή μεταβλητής double.
+
+        // Double - Double-precision 64-bit IEEE 754 Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double fooDouble = 123.4;
+
+        // Boolean - Αληθής και Ψευδής (true & false)
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - Ένας μόνο χαρακτήρας 16-bit Unicode
+        char fooChar = 'A';
+
+        // Οι μεταβλητές final δεν μπορούν να πάρουν άλλη τιμή 
+        // μετά την αρχικοποίηση τους,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // αλλά μπορούν να αρχικοποιηθούν αργότερα.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger - Immutable αυθαίρετης-ακρίβειας ακέραιος
+        //
+        // Ο BigInteger είναι ένας τύπος δεδομένων ο οποίος επιτρέπει στους 
+        // προγραμματιστές να χειρίζονται ακέραιους μεγαλύτερους από 64-bits. 
+        // Οι ακέραιοι αποθηκεύονται ως πίνακας από bytes και τυχαίνουν 
+        // επεξεργασίας χρησιμοποιώντας συναρτήσεις εσωματωμένες στην κλάση 
+        // BigInteger
+        // Ένας BigInteger μπορεί να αρχικοποιηθεί χρησιμοποιώντας ένα πίνακα 
+        // από bytes ή γραμματοσειρά (string).
+        
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+
+        // BigDecimal - Immutable, αυθαίρετης-ακρίβειας, εμπρόσημος (signed)
+        // δεκαδικός αριθμός
+        //
+        // Ένας BigDecimal παίρνει δύο μέρη: Μία αυθαίρετης ακρίβειας, 
+        // ακέραια, unscaled τιμή και μία κλιμάκωση(scale) ως ένα 32-bit 
+        // ακέραιο (integer).
+        //
+        // Ο BigDecimal επιτρέπει στον προγραμματιστή να έχει πλήρη έλεγχο 
+        // όσον αφορά τη δεκαδική στρογγυλοποίηση (rounding). Προτείνεται η 
+        // χρήση του BigDecimal με τιμές νομισμάτων και όπου απαιτείται η 
+        // ακριβής δεκαδική ακρίβεια.
+        //
+        // Ο BigDecimal μπορεί να αρχικοποιηθεί με int, long, double ή String
+        // ή με την αρχικοποίηση της unscaled τιμής (BigInteger) και της 
+        // κλίμακας (scale) (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+        
+        // Χρειάζεται να είμαστε προσεκτικοί με τον κατασκευαστή (constructor) 
+        // ο οποίος παίρνει float ή double καθώς η ανακρίβεια του float/double 
+        // θα αντιγραφεί στον BigDecimal.
+        // Είναι προτιμότερο να χρησιμοποιείται ο κατασκευαστής String (String 
+        // constructor) όταν χρειάζεται ακριβής τιμή.
+        
+        BigDecimal tenCents = new BigDecimal("0.1");
+
+        // Strings - Γραμματοσειρές
+        String fooString = "My String Is Here!";
+
+        // Ο χαρακτήρας \n είναι ένας χαρακτήρας διαφυγής (escaped character) 
+        // ο οποίος ξεκινά μία νέα γραμμή
+        String barString = "Printing on a new line?\nNo Problem!";
+        // Ο χαρακτήρας \t είναι ένας χαρακτήρας διαφυγής (escaped character)
+        // ο οποίος προσθέτει ένα χαρακτήρα tab
+        String bazString = "Do you want to add a tab?\tNo Problem!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Πίνακες (Arrays)
+        // Το μέγεθος του πίνακα πρέπει να αποφασιστεί με την αρχικοποίηση του
+        // πίνακα
+        // Οι ακόλουθες μορφές μπορούν να χρησιμοποιηθούν για την δήλωση ενός 
+        // πίνακα 
+        // <Τυπος δεδομένων>[] <Όνομα Μεταβλητής> = new <Τύπος Δεδομένων>[<μέγεθος πίνακα>];
+        // <Τυπος δεδομένων> <Όνομα Μεταβλητής>[] = new <Τυπος δεδομένων>[<μέγεθος πίνακα>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Ακόμη ένας τρόπος για να δηλώσεις (to declare) και να 
+        // αρχικοποιήσεις ένα πίνακα
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Ευρετηρίαση (indexing) ενός πίνακα - Πρόσβαση (accessing) ενός 
+        // στοιχείου
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Οι πίνακες ξεκινούν από το μηδέν (zero-indexed) και είναι ευμετάβλητοι (mutable).
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Παρόμοια
+        // ArrayLists - Παρόμοιοι με τους πίνακες με τη διαφορά ότι προσφέρουν 
+        // περισσότερη λειτουργικότητα και το μέγεθος είναι ευμετάβλητο 
+        // (mutable).
+        // LinkedLists - Υλοποίηση διπλά-συνδεδεμένης λίστας(doubly-linked 
+        // list). Όλες οι λειτουργίες εκτελώνται όπως αναμένεται σε μία διπλά 
+        // συνδεδεμένη (doubly-linked) λίστα.
+        // Maps - Ένα σύνολο αντικειμένων τα οποία συνδέου (map) κλειδιά (keys)
+        // σε τιμές (values). Ο Map είναι διεπαφή (interface) και συνεπώς δεν 
+        // μπορεί να συγκεκριμενοποίηθεί (instantiated).
+        // Ο τύπος των κλειδιών και των τιμών τα οποία συμπεριλαμβάνονται σε 
+        // ένα Map πρέπει να καθοριστεί κατά τη διάρκεια της 
+        // συγκεκριμενοποίησης (instantiation) της κλάσης που υλοποιεί τη 
+        // διεπαφή Map. Κάθε κλειδί (key) μπορεί να συνδεθεί (map) σε μόνο μία 
+        // αντίστοιχη τιμή και κάθε κλειδί μπορεί να εμφανιστεί μόνο μία φορά 
+        // (no duplicates).
+        // HashMaps - Η κλάση αυτή χρησιμοποιεί ένα πίνακα-κατακερματισμού 
+        // (hashtable) για να υλοποιήσει τη διεπαφή Map. Αυτό επιτρέπει το 
+        // χρόνο εκτέλεσης βασικών λειτουργιών, όπως της get και insert 
+        // στοιχείου να παραμείνει σταθερός (constant) ακόμη και για μεγάλα 
+        // σύνολα (sets.)
+
+
+        ///////////////////////////////////////
+        // Τελεστές (Operators)
+        ///////////////////////////////////////
+        System.out.println("\n->Operators");
+
+        int i1 = 1, i2 = 2; // Συντομογραφία για πολλαπλές δηλώσεις
+
+        // Οι αριθμητικοί τελεστές είναι απλοί
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+        // Υπόλοιπο (Modulo)
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Τελεστές σύγκρισης
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Λογικοί Τελεστές (Boolean)
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Τελεστές πράξεων με bits (Bitwise)!
+        /*
+        ~      bitwise τελεστής μοναδιαίου συμπληρώματος (Unary bitwise complement)
+        <<     Προσημασμένη ολίσθηση αριστερά (Signed left shift)
+        >>     Προσημασμένη/Αριθμητική ολίσθηση Δεξιά (Signed/Arithmetic right shift)
+        >>>    Μη προσημασμένη/Λογική ολίσθηση δεξιά (Unsigned/Logical right shift)
+        &      Διαδικός τελεστής AND (Bitwise AND)
+        ^      Διαδικός τελεστής XOR (Bitwise exclusive OR)
+        |      Διαδικός τελεστής OR (Bitwise inclusive OR)
+        */
+
+        // Αυξητικοί τελεστές
+        int i = 0;
+        System.out.println("\n->Inc/Dec-rementation");
+        // Οι τελεστές ++ και -- μειώνουν και αυξάνουν κατά 1 αντίστοιχα.
+        // Εάν τοποθετητούν πριν τη μεταβλητή, αυξάνουν και μετά επιστρέφουν.
+        // Μετά τη μεταβλητή επιστρέφουν και μετά αυξάνουν.
+        System.out.println(i++); // i = 1, τυπώνει 0 (post-increment)
+        System.out.println(++i); // i = 2, τυπώνει 2 (pre-increment)
+        System.out.println(i--); // i = 1, τυπώνει 2 (post-decrement)
+        System.out.println(--i); // i = 0, τυπώνει 0 (pre-decrement)
+
+        ///////////////////////////////////////
+        // Δομές ελέγχου (Control Structures)
+        ///////////////////////////////////////
+        System.out.println("\n->Control Structures");
+
+        // Οι δηλώσεις If είναι c-like
+        int j = 10;
+        if (j == 10) {
+            System.out.println("I get printed");
+        } else if (j > 10) {
+            System.out.println("I don't");
+        } else {
+            System.out.println("I also don't");
+        }
+
+        // Επανάληψη While (While loop)
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Άυξησε τον μετρητή
+            // Επανάλαβε 100 φορές, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("fooWhile Value: " + fooWhile);
+
+        // Επανάληψη Do While (Do While Loop)
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Άυξησε το μετρητή(counter)
+            // Επανάλαβε 99 times, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("fooDoWhile Value: " + fooDoWhile);
+
+        // Επανάληψη For (For Loop)
+        // Δομή επανάληψης for => 
+        // for(<Αρχική Δήλωση>; <προυπόθεση (conditional)>; <βήμα (step)>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Iterated 10 times, fooFor 0->9
+        }
+        System.out.println("fooFor Value: " + fooFor);
+        
+        // Έξοδος από εμφωλευμένη (nested) επανάληψη For με ετικέττα (Label)
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // δραπετεύει εκτός της εξωτερικής(outer) επανάληψης αντί μόνο της εσωτερικής
+            }
+          }
+        }
+        
+        // Επανάληψη For Each
+        // Η επανάληψη for είναι επίσης ικανή να επαναλαμβάνεται τόσο σε 
+        // πίνακες όσο και σε αντικείμενα τα οποία υλοποιούν τη διεπαφή 
+        // Iterable.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // Σύνταξη της επανάληψης for each => for (<αντικείμενο> : <iterable>)
+        // Διαβάζεται ως: Για κάθε αντικείμενο στο iterable
+        // Σημείωση: ο τύπος του αντικειμένου πρέπει να τεριάζει με τον τύπο του στοιχείου του iterable.
+
+        for (int bar : fooList) {
+            System.out.println(bar);
+            //Επαναλαμβάνεται 9 φορές και τυπώνει 1-9 σε καινούριες γραμμές
+        }
+
+        // Switch Case
+        // Ένα switch δουλέυει με byte, short, char, και int τύπους δεδομένων.
+        // Δουλέυει επίσης με τύπους enumerated (Συζήτηση στους τύπους Enum), 
+        // τη κλάση String, και μερικές ειδικές περιπτώσεις οι οποίες 
+        // περιλαμβάνουν primitive τύπους: Character, Byte, Short, and Integer.
+        int month = 3;
+        String monthString;
+        switch (month) {
+            case 1: monthString = "January";
+                    break;
+            case 2: monthString = "February";
+                    break;
+            case 3: monthString = "March";
+                    break;
+            default: monthString = "Some other month";
+                     break;
+        }
+        System.out.println("Switch Case Result: " + monthString);
+        
+        // Αρχίζοντας από τη Java 7, switching για Strings δουλεύει έτσι:
+        String myAnswer = "maybe";
+        switch(myAnswer) {
+            case "yes":
+                System.out.println("You answered yes.");
+                break;
+            case "no":
+                System.out.println("You answered no.");
+                break;
+            case "maybe":
+                System.out.println("You answered maybe.");
+                break;
+            default:
+                System.out.println("You answered " + myAnswer);
+                break;
+        }
+
+        // Συντομογραφία του Conditional
+        // Μπορείς να χρησιμοποιήσεις τον τελεστή '?' για γρήγορες αναθέσεις ή 
+        // logic forks. Διαβάζεται ως "Αν η (πρόταση) είναι αληθής, 
+        // χρησιμοποίησε <την πρώτη τιμή>, αλλιώς, χρησιμοποία <την δεύτερη 
+        // τιμή>"
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Prints A, because the statement is true
+
+
+        ////////////////////////////////////////
+        // Μετατροπή Τύπων Δεδομένων και Typecasting
+        ////////////////////////////////////////
+
+        // Μετατροπή δεδομένων
+
+        // Μετατροπή από String σε Integer
+        Integer.parseInt("123");//returns an integer version of "123"
+
+        // Μετατροπή από Integer σε String
+        Integer.toString(123);//returns a string version of 123
+
+        // Για άλλες μετατροπές δες τις ακόλουθες κλάσεις:
+        // Double
+        // Long
+        // String
+
+        // Typecasting
+        // Μπορείς επίσης να κάνεις cast αντικείμενα Java. Υπάρχουν πολλές 
+        // λεπτομέρειες και μερικές πραγματεύονται κάποιες πιο προχωρημένες 
+        // ένοιες. Για δες εδώ:
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Κλάσεις και Συναρτήσεις
+        ///////////////////////////////////////
+
+        System.out.println("\n->Classes & Functions");
+
+        // (Ο ορισμός της κλάσης Bicycle ακολουθεί)
+
+        // Χρησιμοποία το new για να δημιουργήσεις ένα αντικείμενο μίας κλάσης
+        Bicycle trek = new Bicycle();
+
+        // Κλήση μεθόδων του αντικειμένου
+        trek.speedUp(3); // Πάντοτε πρέπει να χρησιμοποιείς μεθόδους setter 
+        // και getter
+        trek.setCadence(100);
+
+        // Το toString επιστρέφει την αναπαράσταση σε String μορφή του 
+        // αντικειμένου αυτού.
+        System.out.println("trek info: " + trek.toString());
+
+        // Double Brace Initialization
+        // Η Γλώσσα Java δεν έχει σύνταξη για το πως να δημιουργήσεις static 
+        // Collections με κάποιο εύκολο τρόπο. Συνήθως θα το κάνεις αυτό με 
+        // τον παρακάτω τρόπο:
+
+        private static final Set<String> COUNTRIES = new HashSet<String>();
+        static {
+           validCodes.add("DENMARK");
+           validCodes.add("SWEDEN");
+           validCodes.add("FINLAND");
+        }
+
+        // Αλλά υπάρχει ένας κομψός τρόπος να επιτύχεις το ίδιο πράγμα
+        // ευκολότερα, χρησιμοποιώντας κάτι το οποίο λέγεται Double Brace
+        // Initialization.
+
+        private static final Set<String> COUNTRIES = new HashSet<String>() {{
+            add("DENMARK");
+            add("SWEDEN");
+            add("FINLAND");
+        }}
+
+        // Η πρώτη αγκύλη δημιουργεί μία νέα AnonymousInnerClass και η
+        // δεύτερη δηλώνει ένα instance initializer block. Το block
+        // καλείται όταν η ανώνυμη εσωτερική κλάση δημιουργηθεί.
+        // Η μέθοδος αύτή δεν δουλεύει μόνο για τις Collections, αλλά για όλες 
+        // τις non-final κλάσεις.
+
+    } // Τέλος μεθόδου main
+} // Τέλος κλάσης LearnJava
+
+
+// Μπορείς να κάνεις include άλλες, όχι-δημόσιες (non-public) 
+// εξωτερικού-επιπέδου (outer-level) κλάσεις σε ένα αρχείο .java, αλλά δεν 
+// είναι καλή πρακτική. Αντί αυτού, διαχώρησε τις κλάσεις σε ξεχωριστά αρχεία.
+
+// Σύνταξη Δήλωσης Κλάσης (Class Declaration Syntax):
+// <public/private/protected> class <class name> {
+//    // Συμπεριλαμβάνονται πεδία δεδομένων (data fields), κατασκευαστές (constructors), συναρτήσεις (functions) .
+//    // Οι συναρτήσεις ονομάζονται "μεθόδοι" στη Java.
+// }
+
+class Bicycle {
+
+    // Πεδία/μεταβλητές της Κλάσης Bicycle
+    // Public(Δημόσιες): Μπορούν να γίνουν προσβάσιμες από παντού
+    public int cadence; 
+    // Private(Ιδιωτικές): Προσβάσιμες μόνο εντός της κλάσης
+    private int speed;  
+    // Protected(Προστατευμένες): Προσβάσιμες από την κλάση και τις υποκλάσεις (subclasses) της
+    protected int gear; 
+    String name; // Προκαθορισμένο: Προσβάσιμη μόνο εντός του πακέτου
+
+    static String className; // Static μεταβλητή κλάσης
+
+    // Static block 
+    // H Java δεν υποστηρίζει υλοποίησεις στατικών κατασκευαστών (static 
+    // constructors), αλλά έχει ένα static block το οποίο μπορεί να 
+    // χρησιμοποιηθεί για να αρχικοποιήσει στατικές μεταβλητές (static 
+    // variables). Το block αυτό θα καλεσθεί όταν η κλάση φορτωθεί.
+    static {
+        className = "Bicycle";
+    }
+
+    // Οι κατασκευαστές (constructors) είναι ένας τρόπος για δημιουργία κλάσεων
+    // Αυτός είναι ένας κατασκευαστής (constructor)
+    public Bicycle() {
+        // Μπορείς επίσης να καλέσεις άλλο κατασκευαστή:
+        // this(1, 50, 5, "Bontrager");
+        gear = 1;
+        cadence = 50;
+        speed = 5;
+        name = "Bontrager";
+    }
+
+    // Αυτός είναι ένας κατασκευαστής ο οποίος δέχεται arguments
+    public Bicycle(int startCadence, int startSpeed, int startGear,
+        String name) {
+        this.gear = startGear;
+        this.cadence = startCadence;
+        this.speed = startSpeed;
+        this.name = name;
+    }
+
+    // Οι μεθόδοι (Methods) συντάσσονται ως ακολούθως:
+    // <public/private/protected> <return type> <όνομα μεθόδου>(<args>)
+
+    // Οι κλάσεις Java συχνά υλοποιούν getters and setters for their fields
+
+    // Σύνταξη δήλωσης μεθόδου:
+    // <Προσδιοριστές πρόσβασης> <τύπος επιστροφής> <όνομα μεθόδου>(<args>)
+    public int getCadence() {
+        return cadence;
+    }
+
+    // Οι μεθόδοι void δεν απαιτούν return statement
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+
+    public void speedUp(int increment) {
+        speed += increment;
+    }
+
+    public void slowDown(int decrement) {
+        speed -= decrement;
+    }
+
+    public void setName(String newName) {
+        name = newName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    //Μέθοδος η οποία επιστρέφει ως String τις τιμές των χαρακτηριστικών του 
+    // αντικειμένου.
+    @Override // Χρησιμοποιείται, καθώς η συγκεκριμένη μέθοδος κληρονομήθηκε από τη κλάση Object.
+    public String toString() {
+        return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+            " name: " + name;
+    }
+} // Τέλος κλάσης Bicycle
+
+// Η PennyFarthing είναι υποκλάση της Bicycle
+class PennyFarthing extends Bicycle {
+    // (Tα Penny Farthings είναι τα ποδήλατα με τον μεγάλο μπροστινό τροχό.
+    // Δεν έχουν ταχύτητες.)
+
+    public PennyFarthing(int startCadence, int startSpeed) {
+        // Κάλεσε τον parent constructor χρησιμοποιώντας το super
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // Χρειάζεται να μαρκάρεις τη μέθοδο την οποία κάνεις overriding 
+    // χρησιμοποιώντας ένα @annotation.
+    // Για να μάθεις περισσότερα σχετικά με το τι είναι οι επισημάνσεις 
+    // (annotations) και τον σκοπό τους δες αυτό: 
+    // http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGear(int gear) {
+        gear = 0;
+    }
+}
+
+// Διεπαφές (Interfaces)
+// Σύνταξη δήλωσης διεπαφής
+// <access-level> interface <interface-name> extends <super-interfaces> {
+//     // Σταθερές (Constants)
+//     // Δηλώσεις Μεθόδων (Method declarations)
+// }
+
+// Παράδειγμα - Food:
+public interface Edible {
+    public void eat(); // Κάθε κλάση η οποία υλοποιεί τη διεπαφή αυτή πρέπει 
+    // να υλοποιήσει τη συγκεκριμένη μέθοδο.
+}
+
+public interface Digestible {
+    public void digest();
+}
+
+
+// Μπορούμε να δημιουργήσουμε μία κλάση η οποία υλοποιεί και τις δύο αυτές διεπαφές.
+public class Fruit implements Edible, Digestible {
+  
+    @Override
+    public void eat() {
+        // ...
+    }
+
+    @Override
+    public void digest() {
+        // ...
+    }
+}
+
+// Στην Java, μπορείς να κληρονομήσεις (extend) από μόνο μία κλάση,
+// αλλά μπορείς να υλοποιήσεις πολλές διεπαφές. Για παράδειγμα:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+    InterfaceTwo {
+
+    @Override
+    public void InterfaceOneMethod() {
+    }
+
+    @Override
+    public void InterfaceTwoMethod() {
+    }
+
+}
+
+// Abstract (Αφηρημένες) Κλάσεις
+
+// Σύνταξη Δήλωσης Abstract Κλάσης
+// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
+//     // Σταθερές και μεταβλητές
+//     // Δηλώσεις μεθόδων
+// }
+
+// Μαρκάροντας μία κλάση ως abstract σημαίνει ότι περιέχει abstract μεθόδους
+// οι οποίες πρέπει να οριστούν σε μία κλάση παιδί (child class).
+// Παρόμοια με τις διεπαφές (interfaces), οι abstract κλάσεις δεν μπορούν να
+// γίνουν instantiated, αλλά αντί αυτού πρέπει να γίνει extend και οι abstract
+// μεθόδοι πρέπει να οριστούν. Διαφορετικά από τις Διεπαφές, οι abstract 
+// κλάσεις μπορούν να περιέχουν τόσο υλοποιημένες όσο και abstract μεθόδους.
+// Οι μεθόδοι σε μια Διεπαφή δεν μπορούν να έχουν σώμα (δεν είναι υλοποιημένες 
+// δηλαδή εκτός εάν η μέθοδος είναι στατική και οι μεταβλητές είναι final by 
+// default αντίθετα απο μία abstract κλάση. Επίσης, οι abstract κλάσεις 
+// ΜΠΟΡΟΥΝ να έχουν την μέθοδο "main".
+
+public abstract class Animal
+{
+    public abstract void makeSound();
+
+    // Οι μεθόδοι μπορούν να έχουν σώμα (body)
+    public void eat()
+    {
+        System.out.println("I am an animal and I am Eating.");  
+        // Σημείωση: Μπορούμε να έχουμε πρόσβαση σε ιδιωτικές (private) μεταβλητές εδώ.
+        age = 30;
+    }
+
+    // Δεν χρειάζεται να αρχικοποιηθεί, εντούτοις σε ένα interface μία 
+    // μεταβλητή είναι implicitly final και έτσι χρειάζεται να αρχικοποιηθεί
+    protected int age;
+
+    public void printAge()
+    {
+        System.out.println(age);  
+    }
+
+    // Οι Abstract κλάσεις μπορούν να έχουν συνάρτηση main.
+    public static void main(String[] args)
+    {
+        System.out.println("I am abstract");
+    }
+}
+
+class Dog extends Animal
+{
+    // Σημείωση ότι χρειάζεται να κάνουμε override τις abstract μεθόδους στην
+    // abstract κλάση.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Bark");
+        // age = 30;	==> ERROR!	Το πεδίο age είναι private στο Animal
+    }
+
+    // ΣΗΜΕΙΩΣΗ: Θα πάρεις error εάν χρησιμοποίησεις το
+    // @Override annotation εδώ, καθώς η java δεν επιτρέπει
+    // να γίνονται override οι static μεθόδοι.
+    // Αυτό που γίνεται εδώ ονομάζεται METHOD HIDING.
+    // Για δες αυτό το εξαιρετικό ποστ στο SO (Stack Overflow): http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// Κλάσεις Final
+
+// Σύνταξη δήλωσης μίας Final κλάσης
+// <access-level> final <final-class-name> {
+//     // Σταθερές και μεταβλητές
+//     // Δήλωση μεθόδων
+// }
+
+// Οι κλάσεις Final είναι κλάσεις οι οποίες δεν μπορούν να κληρονομηθούν και 
+// συνεπώς είναι final child. In a way, final classes are the opposite of 
+// abstract classes because abstract classes must be extended, but final 
+// classes cannot be extended.
+public final class SaberToothedCat extends Animal
+{
+    // Σημείωση ότι χρειάζεται και πάλι να κάνουμε override τις abstract 
+    // μεθόδους στην abstract κλάση.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Τελικές (Final) μεθόδοι
+public abstract class Mammal()
+{
+    // Σύνταξη μίας Final μεθόδου:
+    // <Προσδιοριστής πρόσβασης (access modifier)> final <τύπος επιστροφής> <Όνομα μεθόδου>(<args>)
+
+    // Οι Final μεθόδοι, όπως και οι final κλάσεις δεν μπορούν να γίνουν 
+    // overridden από κλάση παιδί,
+    // και είναι συνεπώς η τελική υλοποίηση της μεθόδου.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
+}
+
+
+// Τύποι Enum
+//
+// Ένας τύπος enum είναι ένας ειδικός τύπος δεδομένων, ο οποίος επιτρέπει σε 
+// μια μεταβλητή να είναι ένα σύνολο από προκαθορισμένες σταθερές. Η μεταβλητή 
+// πρέπει να είναι ίση με μία από τις τιμές αυτές που έχουν προκαθοριστεί. 
+// Επειδή είναι σταθερές, τα ονόματα ενός enum πεδίου γράφονται με κεφαλαίους 
+// χαρακτήρες. Στην γλώσσα προγραμματισμού Java, ορίζεις ένα τύπο enum 
+// χρησιμοποιώντας τη δεσμευμένη λέξη enum. Για παράδειγμα, θα μπορούσες να 
+// καθορίσεις ένα τύπο enum με όνομα days-of-the-week ως:
+
+public enum Day {
+    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+    THURSDAY, FRIDAY, SATURDAY 
+}
+
+// Μπορούμε να χρησιμοποιήσουμε τον enum Day όπως παρακάτω:
+
+public class EnumTest {
+    
+    // Μεταβλητή Enum
+    Day day;
+    
+    public EnumTest(Day day) {
+        this.day = day;
+    }
+    
+    public void tellItLikeItIs() {
+        switch (day) {
+            case MONDAY:
+                System.out.println("Mondays are bad.");
+                break;
+                    
+            case FRIDAY:
+                System.out.println("Fridays are better.");
+                break;
+                         
+            case SATURDAY: 
+            case SUNDAY:
+                System.out.println("Weekends are best.");
+                break;
+                        
+            default:
+                System.out.println("Midweek days are so-so.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        EnumTest firstDay = new EnumTest(Day.MONDAY);
+        firstDay.tellItLikeItIs(); // => Mondays are bad.
+        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
+        thirdDay.tellItLikeItIs(); // => Midweek days are so-so.
+    }
+}
+
+// Οι τύποι Enum είναι πολύ πιο δυνατοί από όσο έχουμε δείξει πιο πάνω. 
+// Το σώμα του enum (enum body) μπορεί να περιέχει μεθόδους και άλλα πεδία.
+// Μπορείς να δεις περισσότερα στο 
+// https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## Επιπλέων διάβασμα
+
+Οι σύνδεσμοι που παρέχονται εδώ είναι απλά για να κατανοήσεις περισσότερο το θέμα.
+Σε προτρύνουμε να ψάξεις στο Google και να βρεις συγκεκριμένα παραδείγματα.
+
+**Eπίσημοι Οδηγοί της Oracle**:
+
+* [Φροντιστήριο εκμάθησης Java από τη Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Τροποποιητές επιπέδου πρόσβασης(Access level modifiers) Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Έννοιες αντικειμενοστραφούς (Object-Oriented) προγραμματισμού](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Κληρονομικότητα (Inheritance)](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Πολυμορφισμός (Polymorphism)](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Αφαιρετικότητα (Abstraction)](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Εξαιρέσεις (Exceptions)](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Διεπαφές (Interfaces)](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Συμβάσεις κώδικα Java (Code Conventions)](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+**Πρακτικές και Φροντιστήρια Online**
+
+* [Learneroo.com - Μάθε Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Βιβλία**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
diff --git a/elisp.html.markdown b/elisp.html.markdown
index da86cab3..518ad985 100644
--- a/elisp.html.markdown
+++ b/elisp.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: elisp
 contributors:
-    - ["Bastien Guerry", "http://bzg.fr"]
+    - ["Bastien Guerry", "https://bzg.fr"]
     - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
 filename: learn-emacs-lisp.el
 ---
@@ -9,8 +9,6 @@ filename: learn-emacs-lisp.el
 ```scheme
 ;; This gives an introduction to Emacs Lisp in 15 minutes (v0.2d)
 ;;
-;; Author: Bastien / @bzg2 / http://bzg.fr
-;;
 ;; First make sure you read this text by Peter Norvig:
 ;; http://norvig.com/21-days.html
 ;;
@@ -194,7 +192,7 @@ filename: learn-emacs-lisp.el
 ;; And evaluate it:
 (greeting "you")
 
-;; Some function are interactive:
+;; Some functions are interactive:
 (read-from-minibuffer "Enter your name: ")
 
 ;; Evaluating this function returns what you entered at the prompt.
@@ -225,6 +223,8 @@ filename: learn-emacs-lisp.el
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; Let's store a list of names:
+;; If you want to create a literal list of data, use ' to stop it from
+;; being evaluated - literally, "quote" the data.
 (setq list-of-names '("Sarah" "Chloe" "Mathilde"))
 
 ;; Get the first element of this list with `car':
@@ -301,7 +301,7 @@ filename: learn-emacs-lisp.el
 
 (hello-to-bonjour)
 
-;; Let's colorize the names:
+;; Let's boldify the names:
 
 (defun boldify-names ()
     (switch-to-buffer-other-window "*test*")
@@ -342,13 +342,4 @@ filename: learn-emacs-lisp.el
 ;;
 ;; To read an online introduction to Emacs Lisp:
 ;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
-
-;; Thanks to these people for their feedback and suggestions:
-;; - Wes Hardaker
-;; - notbob
-;; - Kevin Montuori
-;; - Arne Babenhauserheide
-;; - Alan Schmitt
-;; - LinXitoW
-;; - Aaron Meurer
 ```
diff --git a/elixir.html.markdown b/elixir.html.markdown
index 720e080c..9dfffc41 100644
--- a/elixir.html.markdown
+++ b/elixir.html.markdown
@@ -3,6 +3,7 @@ language: elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
 filename: learnelixir.ex
 ---
 
@@ -96,6 +97,14 @@ string.
 lower..upper = 1..10 # Can use pattern matching on ranges as well
 [lower, upper] #=> [1, 10]
 
+# Maps are key-value pairs
+genders = %{"david" => "male", "gillian" => "female"}
+genders["david"] #=> "male"
+
+# Maps with atom keys can be used like this
+genders = %{david: "male", gillian: "female"}
+genders.gillian #=> "female"
+
 ## ---------------------------
 ## -- Operators
 ## ---------------------------
@@ -170,7 +179,7 @@ case {:one, :two} do
   {:four, :five} ->
     "This won't match"
   {:one, x} ->
-    "This will match and bind `x` to `:two`"
+    "This will match and bind `x` to `:two` in this clause"
   _ ->
     "This will match any value"
 end
@@ -316,6 +325,14 @@ defmodule MyMod do
   IO.inspect(@my_data) #=> 100
 end
 
+# The pipe operator |> allows you to pass the output of an expression
+# as the first parameter into a function. 
+
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
 ## ---------------------------
 ## -- Structs and Exceptions
 ## ---------------------------
@@ -407,11 +424,28 @@ send pid, {:circle, 2}
 
 # The shell is also a process, you can use `self` to get the current pid
 self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agents
+## ---------------------------
+
+# An agent is a process that keeps track of some changing value
+
+# Create an agent with `Agent.start_link`, passing in a function
+# The initial state of the agent will be whatever that function returns
+{ok, my_agent} = Agent.start_link(fn -> ["red", "green"] end)
+
+# `Agent.get` takes an agent name and a `fn` that gets passed the current state
+# Whatever that `fn` returns is what you'll get back
+Agent.get(my_agent, fn colors -> colors end) #=> ["red", "green"]
+
+# Update the agent's state the same way
+Agent.update(my_agent, fn colors -> ["blue" | colors] end)
 ```
 
 ## References
 
-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) from [elixir webpage](http://elixir-lang.org)
+* [Getting started guide](http://elixir-lang.org/getting-started/introduction.html) from the [Elixir website](http://elixir-lang.org)
 * [Elixir Documentation](http://elixir-lang.org/docs/master/)
 * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) by Dave Thomas
 * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
diff --git a/elm.html.markdown b/elm.html.markdown
index 944ab770..99c23980 100644
--- a/elm.html.markdown
+++ b/elm.html.markdown
@@ -2,6 +2,7 @@
 language: Elm
 contributors:
     - ["Max Goldstein", "http://maxgoldste.in/"]
+filename: learnelm.elm
 ---
 
 Elm is a functional reactive programming language that compiles to (client-side)
@@ -50,18 +51,18 @@ not False -- True
 ["the", "quick", "brown", "fox"]
 [1, 2, 3, 4, 5]
 -- The second example can also be written with two dots.
-[1..5]
+List.range 1 5
 
 -- Append lists just like strings.
-[1..5] ++ [6..10] == [1..10] -- True
+List.range 1 5 ++ List.range 6 10 == List.range 1 10 -- True
 
 -- To add one item, use "cons".
-0 :: [1..5] -- [0, 1, 2, 3, 4, 5]
+0 :: List.range 1 5 -- [0, 1, 2, 3, 4, 5]
 
 -- The head and tail of a list are returned as a Maybe. Instead of checking
 -- every value to see if it's null, you deal with missing values explicitly.
-List.head [1..5] -- Just 1
-List.tail [1..5] -- Just [2, 3, 4, 5]
+List.head (List.range 1 5) -- Just 1
+List.tail (List.range 1 5) -- Just [2, 3, 4, 5]
 List.head [] -- Nothing
 -- List.functionName means the function lives in the List module.
 
@@ -85,7 +86,7 @@ snd ("elm", 42) -- 42
 -- Access a field with a dot and the field name.
 { x = 3, y = 7 }.x -- 3
 
--- Or with an accessor fuction, which is a dot and the field name on its own.
+-- Or with an accessor function, which is a dot and the field name on its own.
 .y { x = 3, y = 7 } -- 7
 
 -- Update the fields of a record. (It must have the fields already.)
@@ -149,13 +150,14 @@ answer =
   42
 
 -- Pass functions as arguments to other functions.
-List.map double [1..4] -- [2, 4, 6, 8]
+List.map double (List.range 1 4) -- [2, 4, 6, 8]
 
 -- Or write an anonymous function.
-List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8]
+List.map (\a -> a * 2) (List.range 1 4) -- [2, 4, 6, 8]
 
 -- You can pattern match in function definitions when there's only one case.
 -- This function takes one tuple rather than two arguments.
+-- This is the way you'll usually unpack/extract values from tuples.
 area (width, height) =
   width * height
 
@@ -178,7 +180,7 @@ fib n =
   else
     fib (n - 1) + fib (n - 2)
 
-List.map fib [0..8] -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
+List.map fib (List.range 0 8) -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
 
 -- Another recursive function (use List.length in real code).
 listLength aList =
@@ -309,7 +311,7 @@ import Graphics.Collage as C
 -- An incoming port is just a type signature.
 port clientID : Int
 
--- An outgoing port has a defintion.
+-- An outgoing port has a definition.
 port clientOrders : List String
 port clientOrders = ["Books", "Groceries", "Furniture"]
 
@@ -333,16 +335,16 @@ $ elm repl
 
 -- Packages are identified by GitHub username and repo name.
 -- Install a new package, and record it in elm-package.json.
-$ elm package install evancz/elm-html
+$ elm package install elm-lang/html
 
 -- See what changed between versions of a package.
-$ elm package diff evancz/elm-html 3.0.0 4.0.2
+$ elm package diff elm-lang/html 1.1.0 2.0.0
 -- Elm's package manager enforces semantic versioning, so minor version bumps
 -- will never break your build!
 ```
 
 The Elm language is surprisingly small. You can now look through almost any Elm
-source code and have a rough idea of what is going on. However, the possibilties
+source code and have a rough idea of what is going on. However, the possibilities
 for error-resistant and easy-to-refactor code are endless!
 
 Here are some useful resources.
diff --git a/erlang.html.markdown b/erlang.html.markdown
index a57f295f..a9d280d7 100644
--- a/erlang.html.markdown
+++ b/erlang.html.markdown
@@ -183,9 +183,10 @@ is_pet(A)                                             -> false.
 % Warning: not all valid Erlang expressions can be used as guard expressions;
 % in particular, our `is_cat` and `is_dog` functions cannot be used within the
 % guard sequence in `is_pet`'s definition. For a description of the
-% expressions allowed in guard sequences, refer to this
-% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912)
-% of the Erlang reference manual.
+% expressions allowed in guard sequences, refer to the specific section
+% in the Erlang reference manual:
+% http://erlang.org/doc/reference_manual/expressions.html#guards
+
 
 % Records provide a method for associating a name with a particular element in a
 % tuple.
diff --git a/es-es/amd-es.html.markdown b/es-es/amd-es.html.markdown
index 7a59ddd6..40aa6647 100644
--- a/es-es/amd-es.html.markdown
+++ b/es-es/amd-es.html.markdown
@@ -190,7 +190,7 @@ Para usar el fichero creado en producción, simplemente intercambia `data-main`:
 
 Un increíblemente detallado [resumen de opciones de generación](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponible en el repositorio de GitHub.
 
-### Tópicos no cubiertos en este tutorial
+### Temas no cubiertos en este tutorial
 * [Cargador de plugins / transformaciones](http://requirejs.org/docs/plugins.html)
 * [Cargando y exportando estilos CommonJS](http://requirejs.org/docs/commonjs.html)
 * [Configuración avanzada](http://requirejs.org/docs/api.html#config)
diff --git a/es-es/asymptotic-notation-es.html.markdown b/es-es/asymptotic-notation-es.html.markdown
new file mode 100644
index 00000000..3507429c
--- /dev/null
+++ b/es-es/asymptotic-notation-es.html.markdown
@@ -0,0 +1,171 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+    - ["Gerson Lázaro", "https://gersonlazaro.com"]
+lang: es-es
+---
+
+# Notaciones asintóticas
+
+## ¿Qué son?
+
+Las notaciones asintóticas son lenguajes que nos permitan analizar el tiempo de 
+ejecución de un algoritmo identificando su comportamiento si el tamaño de 
+entrada para el algoritmo aumenta. Esto también se conoce como la tasa de 
+crecimiento de un algoritmo. ¿El algoritmo de repente se vuelve increíblemente 
+lento cuando el tamaño de entrada crece? ¿Tiende a mantener un rápido tiempo de 
+ejecución a medida que el tamaño de entrada aumenta? La notación asintótica nos 
+da la capacidad para responder a estas preguntas.
+
+## ¿Hay alternativas que respondan a estas preguntas?
+
+Una manera sería contar el número de operaciones primitivas en diferentes 
+tamaños de entrada. Aunque esta es una solución válida, la cantidad de trabajo 
+que esto conlleva, incluso para los algoritmos simples, no justifica su uso.
+
+Otra manera es medir físicamente la cantidad de tiempo que un algoritmo toma 
+para completar su ejecución dados diferentes tamaños de entrada. Sin embargo, 
+la exactitud y la relatividad (los tiempos obtenidos sólo serían relativos a la 
+máquina sobre la cual se calcularon) de este método está ligado a variables 
+ambientales tales como especificaciones de hardware, capacidad de procesamiento,
+etc.
+
+## Tipos de Notación Asintótica
+
+En la primera sección de este documento hemos descrito cómo una notación 
+asintótica identifica el comportamiento de un algoritmo ante los cambios en el 
+tamaño de la entrada. Imaginemos un algoritmo como una función f, con tamaño de 
+entrada n, y f(n) siendo el tiempo de ejecución. Así que para un algoritmo f 
+dado, con el tamaño de entrada n obtenemos algún tiempo de ejecución resultante 
+f(n). Esto resulta en un gráfico donde el eje Y es el tiempo de ejecución, el 
+eje X es el tamaño de la entrada y los puntos en el gráfico son los resultantes 
+de la cantidad de tiempo para un tamaño de entrada dado.
+
+Puedes etiquetar una función, o un algoritmo, con una notación asintótica de 
+muchas maneras diferentes. Algunos ejemplos son describir un algoritmo por su 
+mejor caso, su peor caso, o el caso promedio. Lo más común es analizar un 
+algoritmo por su peor caso. Por lo general, no se evalúa el mejor caso, porque 
+no planeas el algoritmo para estas condiciones. Un muy buen ejemplo de esto son
+los algoritmos de ordenamiento; específicamente, añadir elementos a un árbol. 
+El mejor caso para la mayoría de los algoritmos podría ser tan bajo como una 
+sola operación. Sin embargo, en la mayoría de los casos, el elemento que está 
+añadiendo tendrá que ser ordenado adecuadamente a través del árbol, lo que 
+podría significar examinar toda una rama. Este es el peor de los casos, y 
+para estos casos es que planeamos el algoritmo.
+
+
+### Tipos de funciones, límites, y simplificación
+
+```
+Función logarítmica - log n
+Función lineal - an + b
+Función cuadrática - an^2 + bn + c
+Función polinomicas - an^z + . . . + an^2 + a*n^1 + a*n^0, donde z es constante
+Función exponencial - a^n, donde a es constante
+```
+
+Estas son algunas clasificaciones de funciones de crecimiento básicos utilizados
+en varias notaciones. La lista comienza en la función de crecimiento menor
+(logarítmica, el tiempo de ejecución mas rápido) y pasa a la de mayor 
+crecimiento  (exponencial, el tiempo de ejecución mas lento). Observe como al 
+crecer 'n', o la entrada, en cada una de estas funciones, el resultado aumenta 
+claramente mucho más rápido en las cuadráticas, polinómicas y exponenciales, 
+en comparación con las logarítmicas y lineales.
+
+Una anotación muy importante es que en las notaciones que se discutirán debes 
+hacer tu mejor esfuerzo por utilizar los términos más simples. Esto significa 
+hacer caso omiso de las constantes y terminos de orden inferior, porque a medida
+que el tamaño de entrada (o n en f(n)) aumenta hacia el infinito (límites 
+matemáticos), los términos y constantes de orden inferior se vuelven de poca o 
+ninguna importancia. Dicho esto, si tienes constantes que son 2^9001, 
+o alguna otra cantidad ridícula, inimaginable, te daras cuenta de que la 
+simplificación sesgará la exactitud de la notación.
+
+Como queremos algo simplificado, vamos a modificarlo un poco...
+
+```
+Logarítmico - log n
+Lineal - n
+Cuandrático - n^2
+Polinómico - n^z, donde z es constante
+Exponencial - a^n, donde a es constante
+```
+
+### O-grande (Big-O)
+O-grande (Big-O), comúnmente escrito como O, es una notación asintótica para el 
+peor caso, o el techo de crecimiento para una función determinada. Si `f (n)` 
+es el tiempo de ejecución del algoritmo, y `g (n)` es un tiempo de complejidad 
+arbitraria que relacionas con el algoritmo, entonces `f (n)` es O(g(n)), si por 
+cualquier constante real c (c > 0), `f (n)` <= `c g(n)` para cada tamaño de 
+entrada n (n > 0 ).
+
+
+*Ejemplo 1*  
+
+```
+f(n) = 3log n + 100  
+g(n) = log n
+```
+
+`f(n)` es O(g(n))?  
+`3 log n + 100` es O(log n)?  
+Echemos un vistazo a la definición de O-grande.
+
+```
+3log n + 100 <= c * log n  
+```
+¿Hay alguna constante c que satisface esto para todo n? 
+
+```
+3log n + 100 <= 150 * log n, n > 2 (indefinido en n = 1)  
+```
+
+¡Sí! La definición de O-grande se cumple, por lo tanto `f (n)` es O(g(n)).
+
+*Ejemplo 2*  
+
+```
+f(n) = 3*n^2  
+g(n) = n
+```
+
+`f(n)` es O(g(n))?  
+`3 * n^2` es O(n)?  
+Echemos un vistazo a la definición de O-grande.
+
+```
+3 * n^2 <= c * n  
+```
+
+¿Hay alguna constante c que satisface esto para todo n? 
+No, no la hay. `f(n)` no es O(g(n)).
+
+### Big-Omega
+Big-Omega, comunmente escrito como Ω, es una notación asintótica para el mejor
+caso, o el piso en el crecimiento para una función dada.
+
+`f(n)` es Ω(g(n)), si para cualquier constante real c (c > 0), 
+`f(n)` es >= `c g(n)` para cualquier tamaño de entrada n (n > 0).
+
+No dudes en dirigirte a los recursos adicionales para ejemplos sobre esto. 
+O-grande es la notación principal utilizada para la complejidad general de
+tiempo algoritmico.
+
+### Notas finales
+Es difícil mantener este tipo de tema corto, y sin duda deberias revisar los 
+libros y recursos en línea en la lista. Entran en mucha mayor profundidad con 
+definiciones y ejemplos. 
+
+## Libros
+
+* [Algoritmos (Algorithms)](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Diseño de algoritmos (Algorithm Design)](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Recursos Online
+
+* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf)
+* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
+* [Apuntes Facultad de Ingeniería](https://www.scribd.com/document/317979564/Apuntes-Sobre-Analisis-de-Algoritmos)
diff --git a/es-es/brainfuck-es.html.markdown b/es-es/bf-es.html.markdown
index 550511da..c93b8c3a 100644
--- a/es-es/brainfuck-es.html.markdown
+++ b/es-es/bf-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/es-es/binary-search-es.html.markdown b/es-es/binary-search-es.html.markdown
new file mode 100644
index 00000000..a1b42d21
--- /dev/null
+++ b/es-es/binary-search-es.html.markdown
@@ -0,0 +1,68 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+    - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+    - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es    
+---
+
+# Búsqueda Binaria
+
+## Por qué Búsqueda Binaria?
+
+La búsqueda es uno de los problemas principales en el dominio de la ciencia de la computación. Hoy en dia hay mas de 1 billon de búsquedas por año, y necesitamos tener algoritmos que puedan hacer esto muy rápido. La búsqueda binaria es uno de los algoritmos fundamentales en la ciencia de la computación. Con el fin de explorarlo, vamos a construir por primera vez un esqueleto teórico y lo utilizaremos para implementar el algoritmo apropiadamente.
+
+## Introducción
+
+Un método sencillo para poner en práctica la búsqueda es hacer una búsqueda lineal, pero este método requiere mucho tiempo y este crece linealmente con la cantidad o el número de datos. es decir, empezar desde el elemento a la izquierda de la matriz [] y uno por uno compara x con cada elemento de la matriz [], si x coincide con un elemento, devuelve el índice. Si x no coincide con ninguno de los elementos, devuelve -1.
+
+```
+Búsqueda Lineal: O (n)               Tiempo lineal
+
+Búsqueda Binaria: O ( log(n) )		   Tiempo logarítmico
+
+```
+```
+def search(arr, x):
+ 
+    for i in range(len(arr)):
+ 
+        if arr[i] == x:
+            return i
+ 
+    return -1
+
+```
+## Algoritmo de Búsqueda Binaria 
+
+El requisito básico para que la búsqueda binaria funcione es que los datos a buscar deben estar ordenados (en cualquier orden).
+
+
+### Algo
+
+```
+La idea de la búsqueda binaria es usar la información de que la matriz está ordenada y así reducir la complejidad del tiempo a O(Logn). Básicamente ignoramos la mitad de los elementos después de la primera comparación.
+1) Compare x con el elemento del medio.
+2) si x coincide con el elemento del medio , retornamos el índice del elemento del medio.
+3) Si no coincide, si x es mayor que el elemento del medio, entonces x solo puede estar en la mitad derecha justo después del elemento del medio. Así que recurrimos a la mitad derecha. 
+4) Si no (x es más pequeño) recurrimos a la mitad izquierda.
+Siguiendo la implementación recursiva de búsqueda binaria.
+
+```
+
+### Notas finales 
+
+Hay otra forma de búsqueda binaria que es muy útil.
+
+## Libros
+
+* [CLRS EN](https://mitpress.mit.edu/books/introduction-algorithms)
+* [Algoritmos EN](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Diseño de Algoritmos EN](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Recursos en línea 
+
+* [GeeksforGeeks EN](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)
+* [Topcoder Tutorial EN](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/)
diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown
index bcc775e5..bd1ad07c 100644
--- a/es-es/c++-es.html.markdown
+++ b/es-es/c++-es.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: c++
-filename: learncpp.cpp
+filename: learncpp-es.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Matt Kline", "https://github.com/mrkline"]
@@ -20,11 +20,11 @@ fue diseñado para
 - soportar programación orientada a objetos
 - soportar programación genérica
 
-Aunque su sintaxis puede ser más difícil o compleja que los nuevos lenguajes, 
-es ampliamente utilizado, ya que compila instrucciones nativas que pueden ser 
-directamente ejecutadas por el procesador y ofrece un estricto control sobre 
-el hardware (como C), mientras ofrece características de alto nivel como 
-genericidad, excepciones, y clases. Esta combinación de velocidad y 
+Aunque su sintaxis puede ser más difícil o compleja que los nuevos lenguajes,
+es ampliamente utilizado, ya que compila instrucciones nativas que pueden ser
+directamente ejecutadas por el procesador y ofrece un estricto control sobre
+el hardware (como C), mientras ofrece características de alto nivel como
+genericidad, excepciones, y clases. Esta combinación de velocidad y
 funcionalidad hace de C ++ uno de los lenguajes de programación más utilizados.
 
 ```c++
@@ -32,22 +32,22 @@ funcionalidad hace de C ++ uno de los lenguajes de programación más utilizados
 // Comparación con C
 ////////////////////
 
-// C ++ es _casi_ un superconjunto de C y comparte su sintaxis básica para las 
+// C ++ es _casi_ un superconjunto de C y comparte su sintaxis básica para las
 // declaraciones de variables, tipos primitivos y funciones.
 
-// Al igual que en C, el punto de entrada de tu programa es una función llamada 
-// main con un retorno de tipo entero. 
+// Al igual que en C, el punto de entrada de tu programa es una función llamada
+// main con un retorno de tipo entero.
 // Este valor sirve como código de salida del programa.
 // Mira http://en.wikipedia.org/wiki/Exit_status para mayor información.
 int main(int argc, char** argv)
 {
-	// Los argumentos de la línea de comandos se pasan por argc y argv de la 
+	// Los argumentos de la línea de comandos se pasan por argc y argv de la
 	// misma manera que en C.
-	// argc indica el número de argumentos, 
-	// y argv es un arreglo de strings de estilo C (char*) 
+	// argc indica el número de argumentos,
+	// y argv es un arreglo de strings de estilo C (char*)
 	// representando los argumentos.
 	// El primer argumento es el nombre con el que el programa es llamado.
-	// argc y argv pueden omitirse si no te preocupan los argumentos, 
+	// argc y argv pueden omitirse si no te preocupan los argumentos,
 	// dejando la definición de la función como int main ()
 
 	// Un estado de salida 0 indica éxito.
@@ -72,7 +72,7 @@ void func(); // función que puede aceptar cualquier número de argumentos
 // Use nullptr en lugar de NULL en C++
 int* ip = nullptr;
 
-// Las cabeceras (headers) estándar de C están disponibles en C ++, 
+// Las cabeceras (headers) estándar de C están disponibles en C ++,
 // pero tienen el prefijo "c" y no tienen sufijo .h.
 #include <cstdio>
 
@@ -109,7 +109,7 @@ int main()
 // Argumentos de función por defecto
 ////////////////////////////////////
 
-// Puedes proporcionar argumentos por defecto para una función si no son 
+// Puedes proporcionar argumentos por defecto para una función si no son
 // proporcionados por quien la llama.
 
 void doSomethingWithInts(int a = 1, int b = 4)
@@ -134,7 +134,7 @@ void invalidDeclaration(int a = 1, int b) // Error!
 // Espacios de nombre
 /////////////////////
 
-// Espacios de nombres proporcionan ámbitos separados para variable, función y 
+// Espacios de nombres proporcionan ámbitos separados para variable, función y
 // otras declaraciones.
 // Los espacios de nombres se pueden anidar.
 
@@ -162,8 +162,8 @@ void foo()
 int main()
 {
 
-	// Incluye todos los símbolos del espacio de nombre Second en el ámbito 
-	// actual. Tenga en cuenta que simplemente foo() no funciona, ya que ahora 
+	// Incluye todos los símbolos del espacio de nombre Second en el ámbito
+	// actual. Tenga en cuenta que simplemente foo() no funciona, ya que ahora
 	// es ambigua si estamos llamando a foo en espacio de nombres Second o en
 	// el nivel superior.
     using namespace Second;
@@ -254,7 +254,7 @@ const string& barRef = bar; // Crea una referencia constante a bar.
 // modificados.
 barRef += ". Hola!"; // Error, referencia constante no puede ser modificada.
 
-// Sidetrack: Antes de hablar más sobre referencias, hay que introducir un 
+// Sidetrack: Antes de hablar más sobre referencias, hay que introducir un
 // concepto llamado objeto temporal. Supongamos que tenemos el siguiente código:
 string tempObjectFun() { ... }
 string retVal = tempObjectFun();
@@ -267,16 +267,16 @@ string retVal = tempObjectFun();
 // El objeto devuelto se llama objeto temporal. Objetos temporales son
 // creados cada vez que una función devuelve un objeto, y es destruido en el
 // fin de la evaluación de la expresión que encierra (Bueno, esto es lo que la
-// norma dice, pero los compiladores están autorizados a cambiar este 
-// comportamiento. Busca "return value optimization" para ver mas detalles). 
+// norma dice, pero los compiladores están autorizados a cambiar este
+// comportamiento. Busca "return value optimization" para ver mas detalles).
 // Así que en este código:
 foo(bar(tempObjectFun()))
 
 // Suponiendo que foo y bar existen, el objeto retornado de tempObjectFun es
 // pasado al bar, y se destruye antes de llamar foo.
 
-// Ahora, de vuelta a las referencias. La excepción a la regla "en el extremo 
-// de la expresión encerrada" es si un objeto temporal se une a una 
+// Ahora, de vuelta a las referencias. La excepción a la regla "en el extremo
+// de la expresión encerrada" es si un objeto temporal se une a una
 // referencia constante, en cuyo caso su vida se extiende al ámbito actual:
 
 void constReferenceTempObjectFun() {
@@ -287,7 +287,7 @@ void constReferenceTempObjectFun() {
 }
 
 // Otro tipo de referencia introducida en C ++ 11 es específicamente para
-// objetos temporales. No se puede tener una variable de este tipo, pero tiene 
+// objetos temporales. No se puede tener una variable de este tipo, pero tiene
 // prioridad en resolución de sobrecarga:
 
 void someFun(string& s) { ... }  // Referencia regular
@@ -302,7 +302,7 @@ someFun(tempObjectFun());  // Llama la versión con referencia temporal
 basic_string(const basic_string& other);
 basic_string(basic_string&& other);
 
-// La idea es que si estamos construyendo una nueva cadena de un objeto temporal 
+// La idea es que si estamos construyendo una nueva cadena de un objeto temporal
 // (que va a ser destruido pronto de todos modos), podemos tener un constructor
 // mas eficiente que "rescata" partes de esa cadena temporal. Usted verá este
 // Concepto denominado "movimiento semántico".
@@ -341,13 +341,13 @@ public:
 	// Funciones que no modifican el estado del objeto
 	// Deben marcarse como const.
 	// Esto le permite llamarlas si se envia una referencia constante al objeto.
-	// También tenga en cuenta que las funciones deben ser declaradas 
-	// explícitamente como _virtual_ para que sea reemplazada en las clases 
+	// También tenga en cuenta que las funciones deben ser declaradas
+	// explícitamente como _virtual_ para que sea reemplazada en las clases
 	// derivadas.
-	// Las funciones no son virtuales por defecto por razones de rendimiento.	
+	// Las funciones no son virtuales por defecto por razones de rendimiento.
     virtual void print() const;
 
-    // Las funciones también se pueden definir en el interior 
+    // Las funciones también se pueden definir en el interior
     // del cuerpo de la clase.
 	// Funciones definidas como tales están entre líneas automáticamente.
     void bark() const { std::cout << name << " barks!\n"; }
@@ -358,7 +358,7 @@ public:
 	// (mira abajo)
 	// El destructor debe ser virtual si una clase es dervada desde el;
 	// Si no es virtual, entonces la clase derivada destructor
-	// No será llamada si el objeto se destruye a través de una referencia de 
+	// No será llamada si el objeto se destruye a través de una referencia de
 	// la clase base o puntero.
     virtual ~Dog();
 
@@ -392,7 +392,7 @@ void Dog::print() const
 
 Dog::~Dog()
 {
-    cout << "Adiós " << name << "\n";
+    std::cout << "Adiós " << name << "\n";
 }
 
 int main() {
@@ -410,7 +410,7 @@ class OwnedDog : public Dog {
 
     void setOwner(const std::string& dogsOwner);
 
-	// Reemplaza el comportamiento de la función de impresión 
+	// Reemplaza el comportamiento de la función de impresión
 	// de todos los OwnedDogs. Mira
 	// http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
 	// Para una introducción más general si no está familiarizado con el
@@ -442,7 +442,7 @@ void OwnedDog::print() const
 // Inicialización y sobrecarga de operadores
 ////////////////////////////////////////////
 
-// En C ++ se puede sobrecargar el comportamiento 
+// En C ++ se puede sobrecargar el comportamiento
 // de los operadores como +, -, *, /, etc.
 // Esto se hace mediante la definición de una función que es llamada
 // cada vez que se utiliza el operador.
@@ -505,14 +505,14 @@ int main () {
 // Plantillas (Templates)
 /////////////////////////
 
-// Las plantillas en C++ se utilizan sobre todo en la programación genérica, 
-// a pesar de que son mucho más poderoso que los constructores genéricos 
-// en otros lenguajes. Ellos también soportan especialización explícita y 
-// parcial y clases de tipo estilo funcional; de hecho, son un lenguaje 
+// Las plantillas en C++ se utilizan sobre todo en la programación genérica,
+// a pesar de que son mucho más poderoso que los constructores genéricos
+// en otros lenguajes. Ellos también soportan especialización explícita y
+// parcial y clases de tipo estilo funcional; de hecho, son un lenguaje
 // funcional Turing-completo incrustado en C ++!
 
-// Empezamos con el tipo de programación genérica que podría estar 
-// familiarizado. 
+// Empezamos con el tipo de programación genérica que podría estar
+// familiarizado.
 // Para definir una clase o función que toma un parámetro de tipo:
 template<class T>
 class Box {
@@ -521,9 +521,9 @@ public:
     void insert(const T&) { ... }
 };
 
-// Durante la compilación, el compilador realmente genera copias de cada 
-// plantilla con parámetros sustituidos, por lo que la definición completa 
-// de la clase debe estar presente en cada invocación. 
+// Durante la compilación, el compilador realmente genera copias de cada
+// plantilla con parámetros sustituidos, por lo que la definición completa
+// de la clase debe estar presente en cada invocación.
 // Es por esto que usted verá clases de plantilla definidas
 // Enteramente en archivos de cabecera.
 
@@ -537,8 +537,8 @@ intBox.insert(123);
 Box<Box<int> > boxOfBox;
 boxOfBox.insert(intBox);
 
-// Hasta C++11, había que colocar un espacio entre los dos '>'s, 
-// de lo contrario '>>' serían analizados como el operador de desplazamiento 
+// Hasta C++11, había que colocar un espacio entre los dos '>'s,
+// de lo contrario '>>' serían analizados como el operador de desplazamiento
 // a la derecha.
 
 
@@ -558,9 +558,9 @@ void barkThreeTimes(const T& input)
     input.bark();
 }
 
-// Observe que no se especifica nada acerca de los tipos de parámetros aquí. 
-// El compilador generará y comprobará cada invocación de la plantilla, 
-// por lo que la función anterior funciona con cualquier tipo "T" 
+// Observe que no se especifica nada acerca de los tipos de parámetros aquí.
+// El compilador generará y comprobará cada invocación de la plantilla,
+// por lo que la función anterior funciona con cualquier tipo "T"
 // que tenga un método 'bark' constante!
 
 
@@ -574,12 +574,12 @@ void printMessage() {
   cout << "Aprende C++ en " << Y << " minutos!" << endl;
 }
 
-// Y usted puede especializar explícitamente plantillas 
-// para código más eficiente. 
-// Por supuesto, la mayor parte del mundo real que utiliza una especialización 
+// Y usted puede especializar explícitamente plantillas
+// para código más eficiente.
+// Por supuesto, la mayor parte del mundo real que utiliza una especialización
 // no son tan triviales como esta.
-// Tenga en cuenta que usted todavía tiene que declarar la función (o clase) 
-// como plantilla incluso si ha especificado de forma explícita todos 
+// Tenga en cuenta que usted todavía tiene que declarar la función (o clase)
+// como plantilla incluso si ha especificado de forma explícita todos
 // los parámetros.
 
 template<>
@@ -601,7 +601,7 @@ printMessage<10>();  // Prints "Aprende C++ rapido en solo 10 minutos!"
 #include <exception>
 #include <stdexcept>
 
-//Todas las excepciones lanzadas dentro del bloque _try_ pueden ser 
+//Todas las excepciones lanzadas dentro del bloque _try_ pueden ser
 // capturados por los siguientes manejadores _catch_.
 try {
     // No asignar excepciones en el heap usando _new_.
@@ -651,7 +651,7 @@ void doSomethingWithAFile(const char* filename)
 // 	(Excepciones son la mejor forma de manejar los fallos,
 // 	 pero algunos programadores, especialmente los que tienen un fondo C,
 // 	 estan en desacuerdo sobre la utilidad de las excepciones).
-// Ahora tenemos que comprobar cada llamado por fallos y cerrar el manejador 
+// Ahora tenemos que comprobar cada llamado por fallos y cerrar el manejador
 // del archivo si se ha producido un problema.
 bool doSomethingWithAFile(const char* filename)
 {
@@ -716,7 +716,7 @@ void doSomethingWithAFile(const char* filename)
 
 // Compare esto con el uso de la clase de flujo de archivos de C++ (fstream)
 // fstream utiliza su destructor para cerrar el archivo.
-// Los destructores son llamados automáticamente 
+// Los destructores son llamados automáticamente
 // cuando un objeto queda fuera del ámbito.
 void doSomethingWithAFile(const std::string& filename)
 {
@@ -734,7 +734,7 @@ void doSomethingWithAFile(const std::string& filename)
 // 1. No importa lo que pase,
 //    El recurso (en este caso el manejador de archivo) será limpiado.
 //    Una vez que escribes el destructor correctamente,
-//    Es _imposible_ olvidar cerrar el identificador y permitir 
+//    Es _imposible_ olvidar cerrar el identificador y permitir
 //    fugas del recurso.
 // 2. Tenga en cuenta que el código es mucho más limpio.
 //    El destructor se encarga de cerrar el archivo detrás de cámaras
@@ -743,13 +743,13 @@ void doSomethingWithAFile(const std::string& filename)
 //    Una excepción puede ser lanzado en cualquier lugar de la función
 //    y la limpieza ocurrirá.
 
-// Todo el código idiomático C++ utiliza RAII ampliamente para todos los 
+// Todo el código idiomático C++ utiliza RAII ampliamente para todos los
 // recursos.
 // Otros ejemplos incluyen
 // - Memoria usando unique_ptr y shared_ptr
 // - Contenedores (Containers) - la biblioteca estándar linked list,
 //   vector (es decir, array con auto-cambio de tamaño), hash maps, etc.
-//   Destruimos todos sus contenidos de forma automática 
+//   Destruimos todos sus contenidos de forma automática
 //   cuando quedan fuera del ámbito.
 // - Mutex utilizando lock_guard y unique_lock
 
@@ -758,9 +758,9 @@ void doSomethingWithAFile(const std::string& filename)
 // Cosas divertidas
 /////////////////////
 
-// Aspectos de C ++ que pueden sorprender a los recién llegados 
+// Aspectos de C ++ que pueden sorprender a los recién llegados
 // (e incluso algunos veteranos).
-// Esta sección es, por desgracia, salvajemente incompleta; 
+// Esta sección es, por desgracia, salvajemente incompleta;
 // C++ es uno de los lenguajes con los que mas facil te disparas en el pie.
 
 // Tu puedes sobreescribir métodos privados!
@@ -788,13 +788,13 @@ pt2 = nullptr;  // Establece pt2 como null.
 *pt = nullptr;  // Esto todavía compila, a pesar de que '*pt' es un bool!
 
 // '=' != '=' != '='!
-// Llama Foo::Foo(const Foo&) o alguna variante (mira movimientos semanticos) 
+// Llama Foo::Foo(const Foo&) o alguna variante (mira movimientos semanticos)
 // copia del constructor.
 Foo f2;
 Foo f1 = f2;
 
 // Llama Foo::Foo(const Foo&) o variante, pero solo copia el 'Foo' parte de
-// 'fooSub'. Cualquier miembro extra de 'fooSub' se descarta. Este 
+// 'fooSub'. Cualquier miembro extra de 'fooSub' se descarta. Este
 // comportamiento horrible se llama "Corte de objetos."
 FooSub fooSub;
 Foo f1 = fooSub;
@@ -809,13 +809,13 @@ class Foo { ... };
 vector<Foo> v;
 for (int i = 0; i < 10; ++i)
   v.push_back(Foo());
-// La siguiente línea establece el tamaño de v en 0, 
+// La siguiente línea establece el tamaño de v en 0,
 // pero los destructores no son llamados y los recursos no se liberan!
 
 v.empty();
 v.push_back(Foo());  // Nuevo valor se copia en el primer Foo que insertamos
 
-// En verdad destruye todos los valores en v. 
+// En verdad destruye todos los valores en v.
 // Consulta la sección acerca de los objetos temporales para la
 // explicación de por qué esto funciona.
 v.swap(vector<Foo>());
diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
index 5d3aae0c..8bc1eabb 100644
--- a/es-es/c-es.html.markdown
+++ b/es-es/c-es.html.markdown
@@ -418,8 +418,18 @@ typedef void (*my_fnp_type)(char *);
 
 ## Otras lecturas
 
-Lo mejor que puedes en contrar es una copia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)
+Lo mejor que puedes encontrar es una copia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language). Es *el*
+libro de C, escrito por Dennis Ritchie, creador de C y Brian Kernighan. Aún así,
+se cuidadoso, es antiguo, contiene algunas inexactitudes, y algunas prácticas 
+han cambiado.
 
-Otro buen recurso es [Learn C the hard way](http://c.learncodethehardway.org/book/)
+Otro buen recurso es [Learn C the hard way](http://c.learncodethehardway.org/book/).
+
+Si tienes una pregunta, lee [compl.lang.c Frequently Asked Questions](http://c-faq.com).
+
+Es muy importante utilizar el espaciado y la sangría apropiados y ser coherente 
+con su estilo de codificación en general. El código legible es mejor que el 
+código rápido. Para adoptar un buen estilo de codificación, vea el
+[Estilo de codificación del kernel Linux] (https://www.kernel.org/doc/Documentation/CodingStyle).
 
 Aparte de eso, Google es tu amigo.
diff --git a/es-es/css-es.html b/es-es/css-es.html
new file mode 100644
index 00000000..506a9467
--- /dev/null
+++ b/es-es/css-es.html
@@ -0,0 +1,327 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+    - ["Brett Taylor", "https://github.com/glutnix"]
+    - ["Tyler Mumford", "https://tylermumford.com"]
+translators:
+    - ["miky ackerman", "https://github.com/mikyackerman"]
+lang: es-es
+filename: learncss-es.css
+---
+
+Paginas web estan contruidas en HTML, lo cual especifica el contenido de una pagina
+CSS(Hoja de Estilos en Cascada) es un lenguaje separado el cual especifica
+la **apariencia** de una pagina.
+
+codigo CSS esta hecho de *reglas* estaticas. Cada regla toma uno o mas *selectores* y da *valores* especificos a un numero de *propiedades* visuales. Esas propiedades estan entonces aplicadas a los elementos indicados en una pagina por los selectores
+
+Esta guia ha sido escrita con CSS 2 en mente, la cual es extendida por una nueva caracterica de CSS 3.
+
+**NOTA:** Debido a que CSS produce resultados visuales, para aprenderlo, necesitas
+Probar todo en un patio de juegos CSS como [dabblet] (http://dabblet.com/).
+El objetivo principal de este artículo es la sintaxis y algunos consejos generales.
+
+## Sintaxis
+
+```css
+/* Los comentarios aparecen dentro  de un diagonal-asterisco, justo como esta linea
+   no hay "comentarios en una linea"; este es el unico estilo de comentario.*/
+ 
+
+/* ####################
+   ## SELECTORS
+   #################### */
+
+/* el selector es usado para apuntar a un elemento de la pagina. */
+selector { property: value; /* more properties...*/ }
+
+/*
+Here is an example element:
+
+<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
+*/
+
+/* You can target it using one of its CSS classes */
+.class1 { }
+
+/* or both classes! */
+.class1.class2 { }
+
+/* or its name */
+div { }
+
+/* or its id */
+#anID { }
+
+/* or using the fact that it has an attribute! */
+[attr] { font-size:smaller; }
+
+/* or that the attribute has a specific value */
+[attr='value'] { font-size:smaller; }
+
+/* starts with a value (CSS 3) */
+[attr^='val'] { font-size:smaller; }
+
+/* or ends with a value (CSS 3) */
+[attr$='ue'] { font-size:smaller; }
+
+/* or contains a value in a space-separated list */
+[otherAttr~='foo'] { }
+[otherAttr~='bar'] { }
+
+/* or contains a value in a dash-separated list, e.g., "-" (U+002D) */
+[otherAttr|='en'] { font-size:smaller; }
+
+
+/* You can combine different selectors to create a more focused selector. Don't
+   put spaces between them. */
+div.some-class[attr$='ue'] { }
+
+/* You can select an element which is a child of another element */
+div.some-parent > .class-name { }
+
+/* or a descendant of another element. Children are the direct descendants of
+   their parent element, only one level down the tree. Descendants can be any
+   level down the tree. */
+div.some-parent .class-name { }
+
+/* Warning: the same selector without a space has another meaning.
+   Can you guess what? */
+div.some-parent.class-name { }
+
+/* You may also select an element based on its adjacent sibling */
+.i-am-just-before + .this-element { }
+
+/* or any sibling preceding it */
+.i-am-any-element-before ~ .this-element { }
+
+/* There are some selectors called pseudo classes that can be used to select an
+   element only when it is in a particular state */
+
+/* for example, when the cursor hovers over an element */
+selector:hover { }
+
+/* or a link has been visited */
+selector:visited { }
+
+/* or hasn't been visited */
+selected:link { }
+
+/* or an element is in focus */
+selected:focus { }
+
+/* any element that is the first child of its parent */
+selector:first-child {}
+
+/* any element that is the last child of its parent */
+selector:last-child {}
+
+/* Just like pseudo classes, pseudo elements allow you to style certain parts of
+    a document  */
+
+/* matches a virtual first child of the selected element */
+selector::before {}
+
+/* matches a virtual last child of the selected element */
+selector::after {}
+
+/* At appropriate places, an asterisk may be used as a wildcard to select every
+   element */
+* { } /* all elements */
+.parent * { } /* all descendants */
+.parent > * { } /* all children */
+
+/* ####################
+   ## PROPERTIES
+   #################### */
+
+selector {
+
+    /* Units of length can be absolute or relative. */
+
+    /* Relative units */
+    width: 50%;       /* percentage of parent element width */
+    font-size: 2em;   /* multiples of element's original font-size */
+    font-size: 2rem;  /* or the root element's font-size */
+    font-size: 2vw;   /* multiples of 1% of the viewport's width (CSS 3) */
+    font-size: 2vh;   /* or its height */
+    font-size: 2vmin; /* whichever of a vh or a vw is smaller */
+    font-size: 2vmax; /* or greater */
+
+    /* Absolute units */
+    width: 200px;     /* pixels */
+    font-size: 20pt;  /* points */
+    width: 5cm;       /* centimeters */
+    min-width: 50mm;  /* millimeters */
+    max-width: 5in;   /* inches */
+
+    /* Colors */
+    color: #F6E;                 /* short hex format */
+    color: #FF66EE;              /* long hex format */
+    color: tomato;               /* a named color */
+    color: rgb(255, 255, 255);   /* as rgb values */
+    color: rgb(10%, 20%, 50%);   /* as rgb percentages */
+    color: rgba(255, 0, 0, 0.3); /* as rgba values (CSS 3) Note: 0 <= a <= 1 */
+    color: transparent;          /* equivalent to setting the alpha to 0 */
+    color: hsl(0, 100%, 50%);    /* as hsl percentages (CSS 3) */
+    color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */
+
+    /* Borders */
+    border-width:5px;
+    border-style:solid;
+    border-color:red;      /* similar to how background-color is set */
+    border: 5px solid red; /* this is a short hand approach for the same */
+    border-radius:20px;    /* this is a CSS3 property */    
+
+    /* Images as backgrounds of elements */
+    background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
+
+    /* Fonts */
+    font-family: Arial;
+    /* if the font family name has a space, it must be quoted */
+    font-family: "Courier New";
+    /* if the first one is not found, the browser uses the next, and so on */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+}
+```
+
+## Usage
+
+Save a CSS stylesheet with the extension `.css`.
+
+```html
+<!-- You need to include the css file in your page's <head>. This is the
+     recommended method. Refer to http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css'>
+
+<!-- You can also include some CSS inline in your markup. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Or directly set CSS properties on the element. -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Precedence or Cascade
+
+An element may be targeted by multiple selectors and may have a property set on
+it in more than once. In these cases, one of the rules takes precedence over
+others. Rules with a more specific selector take precedence over a less specific
+one, and a rule occurring later in the stylesheet overwrites a previous one
+(which also means that if two different linked stylesheets contain rules for an
+element and if the rules are of the same specificity, then order of linking
+would take precedence and the sheet linked latest would govern styling) .
+
+This process is called cascading, hence the name Cascading Style Sheets.
+
+Given the following CSS:
+
+```css
+/* A */
+p.class1[attr='value']
+
+/* B */
+p.class1 { }
+
+/* C */
+p.class2 { }
+
+/* D */
+p { }
+
+/* E */
+p { property: value !important; }
+```
+
+and the following markup:
+
+```html
+<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
+```
+
+The precedence of style is as follows. Remember, the precedence is for each
+**property**, not for the entire block.
+
+* `E` has the highest precedence because of the keyword `!important`. It is
+recommended that you avoid its usage.
+* `F` is next, because it is an inline style.
+* `A` is next, because it is more "specific" than anything else. It has 3
+    specifiers: The name of the element `p`, its class `class1`, an attribute
+    `attr='value'`.
+* `C` is next, even though it has the same specificity as `B`.
+    This is because it appears after `B`.
+* `B` is next.
+* `D` is the last one.
+
+## Media Queries
+
+CSS Media Queries are a feature in CSS 3 which allows you to specify when certain CSS rules should be applied, such as when printed, or when on a screen with certain dimensions or pixel density. They do not add to the selector's specificity.
+
+```css
+/* A rule that will be used on all devices */
+h1 {
+  font-size: 2em;
+  color: white;
+  background-color: black;
+}
+
+/* change the h1 to use less ink on a printer */
+@media print {
+  h1 {
+    color: black;
+    background-color: white;
+  }
+}
+
+/* make the font bigger when shown on a screen at least 480px wide */
+@media screen and (min-width: 480px) {
+  h1 {
+    font-size: 3em;
+    font-weight: normal;
+  }
+}
+```
+
+Media queries can include these features:
+`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Most of these features can be prefixed with `min-` or `max-`.
+
+The `resolution` feature is not supported by older devices, instead use `device-pixel-ratio`.
+
+Many smartphones and tablets will attempt to render the page as if it were on a desktop unless you provide a `viewport` meta-tag.
+
+```html
+<head>
+  <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
+## Compatibility
+
+Most of the features in CSS 2 (and many in CSS 3) are available across all
+browsers and devices. But it's always good practice to check before using
+a new feature.
+
+## Resources
+
+* [CanIUse](http://caniuse.com) (Detailed compatibility info)
+* [Dabblet](http://dabblet.com/) (CSS playground)
+* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS) (Tutorials and reference)
+* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/) (Reference)
+
+## Further Reading
+
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [Selecting elements using attributes](https://css-tricks.com/almanac/selectors/a/attribute/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+* [SASS](http://sass-lang.com/) and [LESS](http://lesscss.org/) for CSS pre-processing
+* [CSS-Tricks](https://css-tricks.com)
+
+
diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown
index 31000785..6395f5fd 100644
--- a/es-es/css-es.html.markdown
+++ b/es-es/css-es.html.markdown
@@ -233,12 +233,21 @@ en todos los navegadores y dispositivos. Pero siempre es vital tener en mente la
 compatibilidad y disponibilidad del CSS que uses con respecto a los navegadores
 y dispositivos para los que desarrolles.
 
-
 [QuirksMode CSS](http://www.quirksmode.org/css/) es una excelente referencia para esto.
 
-## Referencias
+## Recursos
+
+* Para ejecutar un test de compatibilidad, revisa [CanIUse](http://caniuse.com).
+* CSS Playground [Dabblet](http://dabblet.com/).
+* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS).
+* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/).
+
+## Otras lecturas
 
-* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
-* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/).
+* [Selecting elements using attributes](https://css-tricks.com/almanac/selectors/a/attribute/).
+* [QuirksMode CSS](http://www.quirksmode.org/css/).
 * [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+* [SASS](http://sass-lang.com/) y [LESS](http://lesscss.org/) para preprocesamiento CSS.
+* [CSS-Tricks](https://css-tricks.com).
 
diff --git a/es-es/dynamic-programming-es.html.markdown b/es-es/dynamic-programming-es.html.markdown
new file mode 100644
index 00000000..11930653
--- /dev/null
+++ b/es-es/dynamic-programming-es.html.markdown
@@ -0,0 +1,54 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es 
+---
+
+# programación dinámica
+
+## Introducción
+
+La programación dinámica es una técnica poderosa usada para resolver una clase particular de problemas como veremos más adelante. La idea es muy simple, si usted ha solucionado un problema con la entrada dada, entonces , guardaremos el resultado para una futura referencia, con el fin de evitar la solución del mismo problema de nuevo.
+
+
+Recuerde siempre!!
+"Aquellos que no pueden recordar el pasado están condenados a repetirlo"
+
+## Formas de resolver este tipo de problemas
+
+1.) De arriba hacia abajo : Empezamos resolviendo el problema dado descomponiendolo. Si ves que el problema fue resuelto, entonces retorna la respuesta guardada. si no se ha resuelto, resuélvelo y guarda la respuesta. Esto suele ser fácil pensar y muy intuitivo. Esto se conoce como memorización.
+
+2.) De abajo hacia arriba : Analiza el problema y mira el orden en que los subproblemas deben ser resueltos y empieza resolviendo el subproblema más trivial, hacia el problema dado.En este proceso, se garantiza que los subproblemas se resuelven antes de resolver el problema. Esto se conoce como programación dinámica.
+
+## Ejemplo de Programación Dinámica
+
+El problema de la subsecuencia creciente máxima consiste en encontrar la subsecuencia creciente máxima en una secuencia dada . Dada la secuencia S= {a1 , a2 , a3, a4, ............., an-1, an } tenemos que encontrar un subconjunto más largo tal que para todo j y i, j <i en el subconjunto aj <ai.
+En primer lugar tenemos que encontrar el valor de las subsecuencias más largas (LSI) en cada índice con el último elemento de la secuencia que es ai. El mayor LSi sería la subsecuencia más larga de la secuencia dada. Para empezar LSI es asignado a uno ya que ai es un elemento de la secuencia(El último elemento).Entonces, para todo j tal que j <i aj <ai, nos encontramos con Lsj más grande y lo agregamos a la LSI. A continuación, el algoritmo toma un tiempo de O (n2).
+Pseudocódigo para encontrar la longitud de la más larga subsecuencia creciente:
+La complejidad de este algoritmos podría reducirse mediante el uso de una mejor estructura de datos en lugar de una array. Almacenamiento de una matriz predecesora y una variable como Secuencia_mas_Grande_hasta_ahora y su índice podría ahorrar mucho tiempo.
+concepto similar se podría aplicar en encontrar el camino más largo de grafo acíclico dirigido.
+---------------------------------------------------------------------------
+ for i=0 to n-1
+            LS[i]=1
+            for j=0 to i-1
+                        if (a[i] >  a[j] and LS[i]<LS[j])
+                                    LS[i] = LS[j]+1
+ for i=0 to n-1
+            if (largest < LS[i])
+
+### Algunos problemas famosos de Programación Dinámica (DP).
+```
+Algoritmo Floyd Warshall(EN) - Tutorial y código fuente del programa en C:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code 
+
+Problema de la Mochila(EN) - Tutorial y código fuente del programa en C: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem 
+
+
+Problema de Subsecuencia Común mas Larga(EN) - Tutorial y código fuente del programa en C : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence 
+
+## Recursos en línea
+
+* [codechef EN](https://www.codechef.com/wiki/tutorial-dynamic-programming)
\ No newline at end of file
diff --git a/es-es/edn-es.html.markdown b/es-es/edn-es.html.markdown
new file mode 100644
index 00000000..32bba37d
--- /dev/null
+++ b/es-es/edn-es.html.markdown
@@ -0,0 +1,111 @@
+---
+language: edn
+filename: learnedn-es.edn
+contributors:
+  - ["Jason Yeo", "https://github.com/jsyeo"]
+translators:
+    - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es 
+---
+
+La notación de datos extensible (Extensible Data Notation (EDN)) es un formato para serializar los datos.
+
+La notación se utiliza internamente por Clojure para representar programas. También es
+utilizado como un formato de transferencia de datos como JSON. A pesar de que se utiliza más comúnmente en
+Clojure, existen implementaciones de EDN para muchos otros lenguajes.
+
+El principal beneficio de EDN sobre JSON y YAML es que es extensible. 
+Vamos a ver cómo se extiende más adelante.
+
+```clojure
+; Los comentarios comienzan con un punto y coma.
+; Cualquier cosa después del punto y coma es ignorado.
+
+;;;;;;;;;;;;;;;;;;;
+;;;Tipos Básicos;;;
+;;;;;;;;;;;;;;;;;;;
+
+nil         ; También conocido en otros lenguajes como nulo (null).
+
+; Booleanos
+true
+false
+
+; Las cadenas se encierran entre comillas dobles
+"desayuno húngaro"
+"tortilla de queso del granjero"
+
+; Los caracteres están precedidos por barras invertidas
+\g \r \a \c \e
+
+; Las palabras claves comienzan con dos puntos.Se comportan como las enumeraciones. Más o menos
+; Como símbolos en Ruby
+:huevos
+:queso
+:aceitunas
+
+; Los símbolos se utilizan para representar los identificadores.Estos empiezan con #.
+; puedes tener espacios usando el símbolo /. cualquier cosa precedida / es
+; un espacio en el nombre.
+#cuchara
+#cocina/cuchara ; no es lo mismo que #spoon
+#cocina/tenedor
+#github/tenedor   ; no se puede comer con este.
+
+; Números enteros y flotantes
+42
+3.14159
+
+; Las listas son secuencias de valores.
+(:bollo :empanada-de-res 9 "yum!")
+
+; Vectores permiten acceso aleatorio
+[:helado 1 2 -2]
+
+; Los mapas son estructuras de datos asociativos que se asocian con la clave de su valor.
+{:huevos        2
+ :jugo-de-limon 3.5
+ :mantequilla     1}
+
+; Usted no está restringido a usar palabras clave como claves.
+{[1 2 3 4] "decirle a la gente lo que llevaba",
+ [5 6 7 8] "Entre mas tu ves, mas lo odias"}
+
+; Puede usar comas para facilitar la lectura. Se tratan como espacios en blanco.
+
+; Los conjuntos son colecciones que contienen elementos únicos.
+#{:a :b 88 "huat"}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;Elementos de etiqueta ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; EDN puede ser extendido por elementos de etiqueta con el símbolo #.
+
+#MyYelpClone/MenuItem {:nombre "huevos-Benedict" :clasificacion 10}
+
+; Permíteme explicar esto con un ejemplo en colujre. Supongamos que quiero
+; transformar ese pedazo de EDN en un registro del Menú.
+
+(defrecord MenuItem [nombre clasificacion])
+
+; Para transformar EDN en valores clojure, necesitaremos usar el constructor en EDN
+; lectura, edn/read-string
+
+(edn/read-string "{:huevos 2 :mantequilla 1 :harina 5}")
+; -> {:huevos 2 :mantequilla 1 :harina 5}
+
+; Para transformar los elementos de etiqueta, definir la función de lectura y pasar un mapa
+; que asigna etiquetas a funciones del lector de edn/read-string al igual que.
+
+(edn/read-string {:lectores {'MyYelpClone/MenuItem map->menu-item}}
+                 "#MyYelpClone/MenuItem {:nombre \"huevos-benedict\" :clasificacion 10}")
+; -> #user.MenuItem{:nombre "huevos-benedict", :clasificacion 10}
+
+```
+
+# Referencias
+
+- [EDN spec (EN)](https://github.com/edn-format/edn)
+- [Implementations (EN)](https://github.com/edn-format/edn/wiki/Implementations)
+- [Tagged Elements (EN)](http://www.compoundtheory.com/clojure-edn-walkthrough/)
diff --git a/es-es/elixir-es.html.markdown b/es-es/elixir-es.html.markdown
new file mode 100644
index 00000000..885165a6
--- /dev/null
+++ b/es-es/elixir-es.html.markdown
@@ -0,0 +1,457 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+translator:
+    - ["Adrian Carrascal", "https://github.com/acarrascalgarcia"]
+filename: learnelixir-es.ex
+lang: es-es
+
+---
+
+Elixir es un lenguaje funcional moderno construido sobre la máquina virtual de Erlang.
+Es completamente compatibe con Erlang, sin embargo, ofrece una sintaxis más estandar
+y otras características más.
+
+```elixir
+
+# Los comentarios de única línea
+# comienzan con un símbolo numérico.
+
+# No hay comentarios multilinea,
+# pero se pueden apilar varios comentarios.
+
+# Para usar el shell de elixir se usa el comando `iex`.
+# Los módulos se compilan con el comando `elixirc`.
+
+# Ambos deberían estar en la ruta si elixir se instaló correctamente.
+
+## ---------------------------
+## -- Tipos básicos
+## ---------------------------
+
+# Hay números
+3    # integer
+0x1F # integer
+3.0  # float
+
+# Átomos, que son literales, una constante con nombre. Comienzan con `:`.
+:hello # atom
+
+# Tuples that are stored contiguously in memory.
+# Tuplas que se almacenan contiguamente en memoria.
+{1,2,3} # tuple
+
+# Se puede acceder a un elemento de una tupla con la función `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Listas que se implementan como listas enlazadas.
+[1,2,3] # list
+
+# Se puede acceder al primer y último elemento de la lista como:
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# En elixir, solo como Erlang, el `=` denota la coincidencia de patrones y
+# no una asignación.
+#
+# This is how the above example of accessing the head and tail of a list works.
+# Así es como el ejemplo anterior de acceder al
+# primer y último elemento de una lista trabaja.
+
+# Una coincidencia de patrón errará cuando los lados no coincidan, en este ejemplo
+# las tuplas tienen diferentes tamaños.
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# También hay binarios
+<<1,2,3>> # binary
+
+# Cadenas y listas de caracteres
+"hello" # string
+'hello' # char list
+
+# Cadenas de varias lineas
+"""
+I'm a multi-line
+string.
+"""
+#=> "I'm a multi-line\nstring.\n"
+
+# Todas las cadenas se codifican en UTF-8:
+"héllò" #=> "héllò"
+
+# Las cadenas son solo binarios realmente, y la lista de caracteres solo listas.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` en elixir devuelve el valor ASCII para el caracter `a`
+?a #=> 97
+
+# Para concatenar listas se usa `++`, para binarios `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+# Los rangos se representan como `start..end` (Es inclusivo)
+1..10 #=> 1..10
+lower..upper = 1..10 # Se puede usar la coincidencia de patrones en los rangos también
+[lower, upper] #=> [1, 10]
+
+# Los mapas son pares de llave-valor
+genders = %{"david" => "male", "gillian" => "female"}
+genders["david"] #=> "male"
+
+# Los mapas con llaves de tipo átomo se pueden usar como esto
+genders = %{david: "male", gillian: "female"}
+genders.gillian #=> "female"
+
+## ---------------------------
+## -- Opetadores
+## ---------------------------
+
+# Aritméticos
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# En elixir el operador `/` siempre devuelve un número flotante
+
+# Para hacer la división de número entero se debe usar `div`
+div(10, 2) #=> 5
+
+# Para obtener el residuo de la división se debe usar `rem`
+rem(10, 3) #=> 1
+
+# También hay operadores lógicos: `or`, `and` y `not`.
+# Estos operadores esperan un boolean como su primer argumento.
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir también provee `||`, `&&` y `!` donde acepta argumentos de cualquier tipo.
+# Todos los valores excepto `false` y `nil` se evaluarán como verdadero.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Para comparaciones se tiene: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` y `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` y `!==` son más estrictos cuando comparan números:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# También se puede comparar dos tipos de datos diferentes:
+1 < :hello #=> true
+
+# No se necesita memorizar el orden pero es importante tenerlo en cuenta:
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+## ---------------------------
+## -- Control de flujo
+## ---------------------------
+
+# Expresión `if`
+if false do
+  "This will never be seen"
+else
+  "This will"
+end
+
+# También está la expresión `unless`
+unless true do
+  "This will never be seen"
+else
+  "This will"
+end
+
+# Se acuerda de la coincidencia de patrones?
+# Muchas estructuras de control de flujo en elixir confían en ella.
+
+# `case` permite comparar un valor con muchos patrones:
+case {:one, :two} do
+  {:four, :five} ->
+    "This won't match"
+  {:one, x} ->
+    "This will match and bind `x` to `:two` in this clause"
+  _ ->
+    "This will match any value"
+end
+
+# Es común vincular el valor a `_` si no se necesita.
+# Por ejemplo, si unicamente el primer elemento de la lista es importante:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Para una mejor lectura se puede hace lo siguiente:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` permite comprobar muchas condiciones al mismo tiempo.
+# Usar `cond` en vez de muchas expresiones `if` anidadas.
+cond do
+  1 + 1 == 3 ->
+    "I will never be seen"
+  2 * 5 == 12 ->
+    "Me neither"
+  1 + 2 == 3 ->
+    "But I will"
+end
+
+# Es común estabecer la última condición como `true`, donde siempre va a coincidir.
+cond do
+  1 + 1 == 3 ->
+    "I will never be seen"
+  2 * 5 == 12 ->
+    "Me neither"
+  true ->
+    "But I will (this is essentially an else)"
+end
+
+# `try/catch` se usa para atrapar valores que se lanzan, también soporta una
+# clausula `after` que se invoca sin importar si un valor se atrapó o no.
+try do
+  throw(:hello)
+catch
+  message -> "Got #{message}."
+after
+  IO.puts("I'm the after clause.")
+end
+#=> I'm the after clause
+# "Got :hello"
+
+## ---------------------------
+## -- Módulos y Funciones
+## ---------------------------
+
+# Anonymous functions (notice the dot)
+# Funciones anónimas (Ver el punto `.`)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# También aceptan muchas cláusulas y guards.
+# Los guards permiten afinar las coincidencias de patrones,
+# se indican por la palabra reservada `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir también provee muchas funciones incorporadas.
+# Esas están disponibles en el ámbito actual.
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Se pueden agrupar varias funciones en un módulo. Dentro de un módulo
+# se usa `def` para definir las funciones.
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Para compilar el módulo simple de Math se guarda como `math.ex` y se usa `elixirc`
+# en la terminal: elixirc math.ex
+
+# Dentro de un módulo se puede definir funciones con `def` y funciones privadas con `defp`.
+# Una función definida con `def` está disponible para ser invocada desde otros módulos,
+# una función privada se puede solo invocar localmente.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# La declaración de funciones también soportan guards y múltiples cláusulas:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Debido a la inmutabilidad, la recursión es una gran parte de elixir
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Los módulos de Elixir soportan atributos, hay atributos incorporados y
+# se pueden agregar otros personalizados.
+defmodule MyMod do
+  @moduledoc """
+  This is a built-in attribute on a example module.
+  """
+
+  @my_data 100 # This is a custom attribute.
+  IO.inspect(@my_data) #=> 100
+end
+
+# El operador pipe |> permite que se pase la salida de una expresión
+# como el primer parámetro en una función. 
+
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Structs and Excepciones
+## ---------------------------
+
+# Los Structs son extensiones de los mapas que traen valores por defecto,
+# garantes en tiempo de compilación y polimorfismo en Elixir.
+defmodule Person do
+  defstruct name: nil, age: 0, height: 0
+end
+
+joe_info = %Person{ name: "Joe", age: 30, height: 180 }
+#=> %Person{age: 30, height: 180, name: "Joe"}
+
+# Acceder al valor de name
+joe_info.name #=> "Joe"
+
+# Actualizar el valor de age
+older_joe_info = %{ joe_info | age: 31 }
+#=> %Person{age: 31, height: 180, name: "Joe"}
+
+# El bloque `try` con la palabra reservada `rescue` se usa para manejar excepciones
+try do
+  raise "some error"
+rescue
+  RuntimeError -> "rescued a runtime error"
+  _error -> "this will rescue any error"
+end
+#=> "rescued a runtime error"
+
+# Todas las excepciones tienen un mensaje
+try do
+  raise "some error"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "some error"
+
+## ---------------------------
+## -- Concurrencia
+## ---------------------------
+
+# Elixir confía en el modelo actor para la concurrencia. Todo lo que se necesita para escribir
+# programas concurrentes en elixir son tres primitivas: procesos de desove,
+# envío de mensajes y recepción de mensajes.
+
+# Para empezar un nuevo proceso se usa la función `spawn`,
+# donde toma una función como argumento.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` devuelve un pid (identificador de proceso), se puede usar este pid para enviar
+# mensajes para el proceso. Para hacer que un mensaje pase se usa el operador `send`.
+# Para que todo esto se útil se necesita estar disponibles para recibir mensajes. Esto se
+# alcanza con el mecanismo `receive`:
+
+# El bloque `receive do` se usa para escuchar los mensajes y procesarlos
+# cuando se reciben. Un bloque `receive do` solo procesará
+# un mensaje recibido. Para procesar múltiples mensajes,
+# una función con un bloque `receive do` tiene que llamarse recursivamente
+# para entrar en el bloque `receive do` otra vez.
+
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Compilar el módulo y crear un proceso que evalue `area_loop` en el shell
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# Como alternativa
+pid = spawn(Geometry, :area_loop, [])
+
+# Enviar un mensaje al `pid` que coincidirá con un patrón en el que recibe una sentencia
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# El shell también es un proceso, se puede usar `self` para obtener el pid actual
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agentes
+## ---------------------------
+
+# Un agente es un proceso que mantiene el seguimiento de algún valor cambiante
+
+# Un agente se crea con `Agent.start_link`, introducuendole una función
+# El estado inicial del agente será lo que sea que la función devuelva
+{ok, my_agent} = Agent.start_link(fn -> ["red, green"] end)
+
+# `Agent.get` toma un nombre de agente y un `fn` que se pasa como el estado actual
+# Lo que sea que este `fn` devuelva es lo que se obtendrá de vuelta
+Agent.get(my_agent, fn colors -> colors end) #=> ["red, "green"]
+
+# El estado del agente se actualiza de la misma manera
+Agent.update(my_agent, fn colors -> ["blue" | colors] end)
+```
+
+## Referencias
+
+* [Getting started guide](http://elixir-lang.org/getting-started/introduction.html) from the [Elixir website](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) by Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) by Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) by Joe Armstrong
diff --git a/es-es/forth-es.html.markdown b/es-es/forth-es.html.markdown
new file mode 100644
index 00000000..edc5d38c
--- /dev/null
+++ b/es-es/forth-es.html.markdown
@@ -0,0 +1,226 @@
+---
+language: forth
+contributors:
+    - ["Horse M.D.", "http://github.com/HorseMD/"]
+translators:
+    - ["Zach Larsen", "http://zachariahlarsen.com/"]
+lang: es-es
+filename: learnforth-es.fs
+---
+
+Forth fue criado por Charles H. Moore en los 70s. Forth es un lenguaje imperativo, basado en pila y entorno de programación, siendo usado en proyectos como Open Firmware. También esta usado por NASA.
+
+Nota: Este articulo enfoca predominantemente en la Gforth implementación de Forth, pero casi todo 
+de lo que esta escrito aquí debe funcionar en otro sitio.
+
+```
+\ Este es un comentario
+( Este es un comentario también pero solo esta usado cuando definiendo palabras. )
+
+\ --------------------------------- Precursor ----------------------------------
+
+\ Todo programación en Forth se hace manipulando el parámetro pila (mas
+\ común se refiere como "el pila").
+5 2 3 56 76 23 65    \ ok
+
+\ estos números se añadieron al pila desde izquierda a derecho.
+.s    \ <7> 5 2 3 56 76 23 65 ok
+
+\ En Forth, todo es o una palabra o un numero.
+
+\ ------------------------------ Básico Aritmética ------------------------------
+
+\ Aritmética (de hecho casi todas palabras que requieren datos) funciona manipulando datos
+\ en el pila.
+5 4 +    \ ok
+
+\ `.` saca lo alto resulto desde el pila:
+.    \ 9 ok
+
+\ Mas ejemplos de aritmética:
+6 7 * .        \ 42 ok
+1360 23 - .    \ 1337 ok
+12 12 / .      \ 1 ok
+13 2 mod .     \ 1 ok
+
+99 negate .    \ -99 ok
+-99 abs .      \ 99 ok
+52 23 max .    \ 52 ok
+52 23 min .    \ 23 ok
+
+\ ----------------------------- Pila Manipulación -----------------------------
+
+\ Naturalmente, cuando trabajaremos con el pila, querremos algunos metidos útiles:
+
+3 dup -          \ duplicar el primero articulo (1ra ahora igual a 2da): 3 - 3
+2 5 swap /       \ intercambiar la primera con la segunda elemento:        5 / 2
+6 4 5 rot .s     \ rotar los tres primero elementos:                   4 5 6
+4 0 drop 2 /     \ sacar el primero articulo (no imprima a la pantalla):  4 / 2
+1 2 3 nip .s     \ sacar el segundo articulo (similar a drop):    1 3
+
+\ ---------------------- Mas Avanzado Pila Manipulación ----------------------
+
+1 2 3 4 tuck   \ duplicar el primero articulo en el segundo hueco:      1 2 4 3 4 ok
+1 2 3 4 over   \ duplicar el segundo articulo a la primera del pila:      1 2 3 4 3 ok
+1 2 3 4 2 roll \ *mover* el articulo en este posición a la primera del pila:      1 3 4 2 ok
+1 2 3 4 2 pick \ *duplicar* el articulo en este posición a la primera del pila: 1 2 3 4 2 ok
+
+\ Cuando refiere a pila indices, ellos son basado en cero.
+
+\ ------------------------------ Creando Palabras --------------------------------
+
+\ La `:` palabra hace que Forth entra modo de compilar hasta que se ve la `;` palabra.
+: cuadrado ( n -- n ) dup * ;    \ ok
+5 cuadrado .                     \ 25 ok
+
+\ Podemos ver lo que hace una palabra también.:
+see cuadrado     \ : cuadrado dup * ; ok
+
+\ -------------------------------- Condicionales --------------------------------
+
+\ -1 == cierto, 0 == falso. No obstante, valores que no son cero es usualmente tratado como
+\ siendo cierto:
+42 42 =    \ -1 ok
+12 53 =    \ 0 ok
+
+\ `if` es una palabra que solamente compila. `if` <cosas para hacer> `then` <los de mas del programa>.
+: ?>64 ( n -- n ) dup 64 > if ." Mas que 64!" then ; \ ok
+100 ?>64                                                  \ Mas que 64! ok
+
+\ Else:
+: ?>64 ( n -- n ) dup 64 > if ." Mas que 64!" else ." Menos que 64!" then ;
+100 ?>64    \ Mas que 64! ok
+20 ?>64     \ Menos que 64! ok 
+
+\ ------------------------------------ Loops -----------------------------------
+
+\ `do` también es una palabra que solamente compila.
+: miloop ( -- ) 5 0 do cr ." Hola!" loop ; \ ok
+miloop
+\ Hola!
+\ Hola!
+\ Hola!
+\ Hola!
+\ Hola! ok
+
+\ `do` espera dos números en el pila: el último numero y el primero numero.
+
+\ Podemos recibir el valor del indice mientras damos vuelta con `i`:
+: uno-a-12 ( -- ) 12 0 do i . loop ;     \ ok
+uno-a-12                                 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 ok
+
+\ `?do` funciona similarmente, pero salta el loop si el último y primero
+\ números son iguales.
+: cuadrados ( n -- ) 0 ?do i cuadrado . loop ;   \ ok
+10 cuadrado                              \ 0 1 4 9 16 25 36 49 64 81 ok
+
+\ cambiar el "paso" con `+loop`:
+: treces ( n n -- ) ?do i . 3 +loop ;    \ ok
+15 0 treces                             \ 0 3 6 9 12 ok
+
+\ Indefinido loops empiezan `begin` <cosas para hacer> <bandera> `until`:
+: death ( -- ) begin ." Ya hemos llegado?" 0 until ;    \ ok
+
+\ ---------------------------- Variables y Memoria ----------------------------
+
+\ Use `variable` declarar `edad` ser un variable.
+variable edad    \ ok
+
+\ Ahora escribimos 21 a edad con la palabra `!`.
+21 edad !    \ ok
+
+\ Por fin podemos imprimir nuestro variable usando la "leer" palabra `@`, que agregue el
+\ valor a la pila, or usa `?` que lee y imprime todo juntos.
+edad @ .    \ 21 ok
+edad ?      \ 21 ok
+
+\ Constantes son muy similar, pero no nos importa los direcciones de memoria:
+100 constant PUNTA-QUE-AQUA-HIERVA   \ ok
+PUNTA-QUE-AQUA-HIERVA .               \ 100 ok
+
+\ ----------------------------------- Arrays -----------------------------------
+
+\ Creando arrays es similar a variables, pero necesitamos alocar mas
+\ memoria a ellos.
+
+\ Puede usar `2 cells allot` para crear un array que es sea 3 cédulas de tamaño:
+variable minumeros 2 cells allot    \ ok
+
+\ Inicializar todos los valores a 0
+minumeros 3 cells erase    \ ok
+
+\ Alternativamente podemos usar `fill`:
+minumeros 3 cells 0 fill
+
+\ o podemos saltar todo arriba y inicializar con valores específicos:
+create minumeros 64 , 9001 , 1337 , \ ok (el último `,` es importante!)
+
+\ ...que es equivalente a:
+
+\ Manualmente escribiendo valores a cada indice:
+64 minumeros 0 cells + !      \ ok
+9001 minumeros 1 cells + !    \ ok
+1337 minumeros 2 cells + !    \ ok
+
+\ Leyendo valores en particular array indices:
+0 cells minumeros + ?    \ 64 ok
+1 cells minumeros + ?    \ 9001 ok
+
+\ Podemos simplificar un poco cuando hacemos una palabra que ayuda cuando manipulando arrays:
+: de-arr ( n n -- n ) cells + ;    \ ok
+minumeros 2 de-arr ?               \ 1337 ok
+
+\ Que podemos usar cuando escribimos también:
+20 minumeros 1 de-arr !    \ ok
+minumeros 1 de-arr ?       \ 20 ok
+
+\ ------------------------------ El Pila de Regreso ------------------------------
+
+\ El pila de regreso se usa para retener punteros a cosas cuando palabras están
+\ ejecutando otras palabras como loops.
+
+\ Ya hemos visto un uso de esto: `i`, que duplica el primero del pila
+\ de regreso. `i` es equivalente a `r@`.
+: miloop ( -- ) 5 0 do r@ . loop ;    \ ok
+
+\ También como leyendo, podemos agregar al pila de regreso y sacarlo:
+5 6 4 >r swap r> .s    \ 6 5 4 ok
+
+\ NOTA: Porque Forth usa el pila de regreso por punteros de palabras,  `>r` debe
+\ siempre ser seguido por un `r>`.
+
+\ ------------------------- Flotante Punto Operaciones --------------------------
+
+\ La mayoría Forths evitan el uso de flotante punto operaciones.
+8.3e 0.8e f+ f.    \ 9.1 ok
+
+\ Usualmente agregamos al frente palabras con 'f' cuando usando flotantes:
+variable miflotantevar    \ ok
+4.4e miflotantevar f!     \ ok
+miflotantevar f@ f.       \ 4.4 ok
+
+\ --------------------------------- Notas al Final --------------------------------
+
+\ Usando una palabra que no existe vaciara el pila. No obstante, también hay una palabra
+\ específicamente por esto:
+clearstack
+
+\ vaciar la pantalla:
+page
+
+\ Cargando Forth archivos:
+\ s" archivodeforth.fs" included
+
+\ Puede listar cada palabra en el diccionario de Forth (pero es una lista gigante!):
+\ words
+
+\ Terminando Gforth:
+\ bye
+
+```
+
+##Listo Para Mas?
+
+* [Starting Forth](http://www.forth.com/starting-forth/)
+* [Simple Forth](http://www.murphywong.net/hello/simple.htm)
+* [Thinking Forth](http://thinking-forth.sourceforge.net/)
diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 4e1e68ba..1a8e275a 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -398,6 +398,10 @@ $ git rm /directorio/del/archivo/FooBar.c
 
 * [tryGit - Una forma entretenida y rapida de aprender Git.](http://try.github.io/levels/1/challenges/1)
 
+* [Udemy tutorial de Git: Una guía completa](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
+
+* [Inmersión Git - Una visita guiada caminando a través de los fundamentos de git](http://gitimmersion.com/)
+
 * [git-scm - Video-tutoriales](http://git-scm.com/videos)
 
 * [git-scm - Documentacion](http://git-scm.com/book/es)
@@ -407,3 +411,9 @@ $ git rm /directorio/del/archivo/FooBar.c
 * [SalesForce Chuleta](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
 
 * [GitGuys](http://www.gitguys.com/)
+
+* [Git - La guía simple](http://rogerdudler.github.io/git-guide/index.html)
+
+* [Pro Git](http://www.git-scm.com/book/en/v2)
+
+* [Una introducción a Git y Github para principiantes (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/es-es/groovy-es.html.markdown b/es-es/groovy-es.html.markdown
new file mode 100644
index 00000000..799fc609
--- /dev/null
+++ b/es-es/groovy-es.html.markdown
@@ -0,0 +1,434 @@
+---
+language: Groovy
+contributors:
+    - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
+translators:
+    - ["Jhoon Saravia", "https://github.com/jhoon"]
+lang: es-es
+filename: groovy-es.html
+---
+
+Groovy - Un lenguaje dinámico para la plataforma Java [Leer más aquí.](http://www.groovy-lang.org/)
+
+```groovy
+
+/*
+  Hora de configurar:
+
+  1) Instala GVM - http://gvmtool.net/
+  2) Instala Groovy: gvm install groovy
+  3) Inicia la consola de groovy escribiendo: groovyConsole
+
+*/
+
+//  Los comentarios de una sola línea inician con dos barras inclinadas
+/*
+Los comentarios multilínea se ven así.
+*/
+
+// Hola Mundo
+println "Hola mundo!"
+
+/*
+  Variables:
+
+  Puedes asignar valores a variables para usarlas después
+*/
+
+def x = 1
+println x
+
+x = new java.util.Date()
+println x
+
+x = -3.1499392
+println x
+
+x = false
+println x
+
+x = "Groovy!"
+println x
+
+/*
+  Mapas y Colecciones
+*/
+
+// Creando una lista vacía
+def technologies = []
+
+/*** Agregando elementos a la lista ***/
+
+// Como si fuera Java
+technologies.add("Grails")
+
+// Doble símbolo de menor agrega un elemento y, además, retorna la lista
+technologies << "Groovy"
+
+// Agregando múltiples elementos
+technologies.addAll(["Gradle","Griffon"])
+
+/*** Quitando elementos de la lista ***/
+
+// Como si fuera Java
+technologies.remove("Griffon")
+
+// La resta también funciona
+technologies = technologies - 'Grails'
+
+/*** Iterando Listas ***/
+
+// Para iterar sobre los elementos de una Lista
+technologies.each { println "Technology: $it"}
+technologies.eachWithIndex { it, i -> println "$i: $it"}
+
+/*** Revisando los contenidos de una Lista ***/
+
+// Evaluar si la lista contiene elemento(s) (boolean)
+contained = technologies.contains( 'Groovy' )
+
+// O
+contained = 'Groovy' in technologies
+
+// Evaluar por múltiples contenidos
+technologies.containsAll(['Groovy','Grails'])
+
+/*** Ordenando Listas ***/
+
+// Para ordenar una Lista (modifica la lista original)
+technologies.sort()
+
+// Para ordenarla sin modificar la original, se puede hacer:
+sortedTechnologies = technologies.sort( false )
+
+/*** Manipulando Listas ***/
+
+// Reemplazar todos los elementos en la lista
+Collections.replaceAll(technologies, 'Gradle', 'gradle')
+
+// Mezclar una lista
+Collections.shuffle(technologies, new Random())
+
+// Limpiar una lista
+technologies.clear()
+
+// Creando un mapa vacío
+def devMap = [:]
+
+// Agregando valores
+devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+devMap.put('lastName','Perez')
+
+// Iterar sobre los elementos del mapa
+devMap.each { println "$it.key: $it.value" }
+devMap.eachWithIndex { it, i -> println "$i: $it"}
+
+// Evaluar si el mapa contiene una llave
+assert devMap.containsKey('name')
+
+// Evaluar si el mapa contiene un valor
+assert devMap.containsValue('Roberto')
+
+// Para obtener las llaves del mapa
+println devMap.keySet()
+
+// Para obtener los valores del mapa
+println devMap.values()
+
+/*
+  Groovy Beans
+
+  GroovyBeans son JavaBeans pero usando una sintaxis mucho más simple
+
+  Cuando Groovy es compilado a código de bytes, las siguientes reglas son usadas:
+
+    * Si el nombre es declarado con un modificador de acceso (public, private o
+      protected), entonces se genera un campo.
+
+    * Un nombre declarado sin modificador de acceso genera un campo privado con
+      un getter y un setter públicos (ej: una propiedad)
+
+    * Si una propiedad es declarada como final, entonces el campo privado es creado
+      como final y no se genera un setter.
+
+    * Puedes declarar una propiedad y también sus propios getter y setter.
+
+    * Puedes declarar una propiedad y un campo del mismo nombre, en ese caso, la
+      propiedad usará ese campo.
+
+    * Si quieres una propiedad private o proteceted, tienes que proveer tus propios
+      getter y setter, los cuales deben ser declarados private o protected.
+
+    * Si accedes a una propiedad desde dentro de la clase, la propiedad es definida
+      en tiempo de compilación con this implícito o explícito (por ejemplo, this.foo
+      o simplemente foo), Groovy accederá al campo directamente en vez de usar el 
+      getter y setter.
+
+    * Si accedes a una propiedad que no existe usando foo explícito o implícito, entonces
+      Groovy accederá a la propiedad a través de la clase meta, que puede fallar en
+      tiempo de ejecución.
+
+*/
+
+class Foo {
+    // propiedad de solo lectura
+    final String name = "Roberto"
+
+    // propiedad de solo lectura, con getter público y setter como protected
+    String language
+    protected void setLanguage(String language) { this.language = language }
+
+    // propiedad de tipo dinámico
+    def lastName
+}
+
+/*
+  Derivación Lógica e Iteraciones
+*/
+
+// Groovy soporta la clásica sintaxis de if - else
+def x = 3
+
+if(x==1) {
+    println "One"
+} else if(x==2) {
+    println "Two"
+} else {
+    println "X greater than Two"
+}
+
+// Groovy también soporta el uso del operador ternario:
+def y = 10
+def x = (y > 1) ? "worked" : "failed"
+assert x == "worked"
+
+// ¡Groovy también soporta 'El Operador Elvis'!
+// En lugar de usar el operador ternario:
+
+displayName = user.name ? user.name : 'Anonymous'
+
+// Podemos escribirlo así:
+displayName = user.name ?: 'Anonymous'
+
+// Iteración con For
+// Iterando en un rango numérico
+def x = 0
+for (i in 0 .. 30) {
+    x += i
+}
+
+// Iterando sobre una lista
+x = 0
+for( i in [5,3,2,1] ) {
+    x += i
+}
+
+// Iterando sobre un arreglo
+array = (0..20).toArray()
+x = 0
+for (i in array) {
+    x += i
+}
+
+// Iterando sobre un mapa
+def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+x = 0
+for ( e in map ) {
+    x += e.value
+}
+
+/*
+  Operadores
+
+  Para la lista de los operadores que Groovy soporta, visita:
+  http://www.groovy-lang.org/operators.html#Operator-Overloading
+
+  Operadores Groovy útiles
+*/
+// Operador de propagación:  invocar una acción en todos los elementos de un objeto agregado.
+def technologies = ['Groovy','Grails','Gradle']
+technologies*.toUpperCase() // equivale a: technologies.collect { it?.toUpperCase() }
+
+// Operador de navegación segura: usado para evitar un NullPointerException.
+def user = User.get(1)
+def username = user?.username
+
+
+/*
+  Closures
+  Un Closure en Groovy es como un "bloque de código" o un puntero a un método. Es una 
+  porci´øn de código que es definida y ejecutada en un punto futuro en el tiempo.
+
+  Más información en: http://www.groovy-lang.org/closures.html
+*/
+// Ejemplo:
+def clos = { println "Hello World!" }
+
+println "Executing the Closure:"
+clos()
+
+// Pasando parámetros a un closure
+def sum = { a, b -> println a+b }
+sum(2,4)
+
+// Los Closures pueden referir a variables no listadas en sus listas de parámetros
+def x = 5
+def multiplyBy = { num -> num * x }
+println multiplyBy(10)
+
+// Si tienes un Closure que toma un solo argumento, puedes omitir la
+// definición del parámetro en el Closure
+def clos = { print it }
+clos( "hi" )
+
+/*
+  Groovy puede memorizar los resultados de un Closure [1][2][3]
+*/
+def cl = {a, b ->
+    sleep(3000) // simula algún proceso que consume tiempo
+    a + b
+}
+
+mem = cl.memoize()
+
+def callClosure(a, b) {
+    def start = System.currentTimeMillis()
+    mem(a, b)
+    println "Inputs(a = $a, b = $b) - took ${System.currentTimeMillis() - start} msecs."
+}
+
+callClosure(1, 2)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(2, 3)
+callClosure(3, 4)
+callClosure(3, 4)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(3, 4)
+
+/*
+  Expando
+
+  La clase Expando es un bean dinámico para que podamos agregar propiedades y closures
+  como métodos a una instancia de esta clase
+
+  http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+*/
+  def user = new Expando(name:"Roberto")
+  assert 'Roberto' == user.name
+
+  user.lastName = 'Pérez'
+  assert 'Pérez' == user.lastName
+
+  user.showInfo = { out ->
+      out << "Name: $name"
+      out << ", Last name: $lastName"
+  }
+
+  def sw = new StringWriter()
+  println user.showInfo(sw)
+
+
+/*
+  Metaprogramación (MOP)
+*/
+
+// Usando ExpandoMetaClass para agregar comportamiento
+String.metaClass.testAdd = {
+    println "we added this"
+}
+
+String x = "test"
+x?.testAdd()
+
+// Interceptando llamadas a métodos
+class Test implements GroovyInterceptable {
+    def sum(Integer x, Integer y) { x + y }
+
+    def invokeMethod(String name, args) {
+        System.out.println "Invoke method $name with args: $args"
+    }
+}
+
+def test = new Test()
+test?.sum(2,3)
+test?.multiply(2,3)
+
+// Groovy soporta propertyMissing para lidiar con intentos de resolución de propiedades.
+class Foo {
+   def propertyMissing(String name) { name }
+}
+def f = new Foo()
+
+assertEquals "boo", f.boo
+
+/*
+  TypeChecked y CompileStatic
+  Groovy, por naturaleza, es y siempre será un lenguaje dinámico pero soporta
+  typechecked y compilestatic
+
+  Más información: http://www.infoq.com/articles/new-groovy-20
+*/
+// TypeChecked
+import groovy.transform.TypeChecked
+
+void testMethod() {}
+
+@TypeChecked
+void test() {
+    testMeethod()
+
+    def name = "Roberto"
+
+    println naameee
+
+}
+
+// Otro ejemplo:
+import groovy.transform.TypeChecked
+
+@TypeChecked
+Integer test() {
+    Integer num = "1"
+
+    Integer[] numbers = [1,2,3,4]
+
+    Date date = numbers[1]
+
+    return "Test"
+
+}
+
+// ejemplo de CompileStatic:
+import groovy.transform.CompileStatic
+
+@CompileStatic
+int sum(int x, int y) {
+    x + y
+}
+
+assert sum(2,5) == 7
+
+
+```
+
+## Más recursos
+
+[Documentación de Groovy](http://www.groovy-lang.org/documentation.html)
+
+[Consola Web de Groovy](http://groovyconsole.appspot.com/)
+
+Únete a un [Groovy user group](http://www.groovy-lang.org/usergroups.html)
+
+## Libros
+
+* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook)
+
+* [Groovy in Action] (http://manning.com/koenig2/)
+
+* [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
diff --git a/es-es/hack-es.html.markdown b/es-es/hack-es.html.markdown
new file mode 100644
index 00000000..1059117a
--- /dev/null
+++ b/es-es/hack-es.html.markdown
@@ -0,0 +1,307 @@
+---
+language: Hack
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+    - ["David Lima", "https://github.com/davelima"]
+translators:
+    - ["César Suárez", "https://github.com/csuarez"]
+lang: es-es
+filename: learnhack-es.hh
+---
+
+Hack es un superconjunto de PHP que se ejecuta en una máquina virtual llamada HHVM. Hack es casi totalmente compatible con código PHP ya existente y añade varias características típicas de los lenguajes de programación estáticamente tipados.
+
+En este artículo sólo se cubren las características específicas de Hack. Los detalles sobre la sintaxis de PHP están en el [artículo sobre PHP](http://learnxinyminutes.com/docs/php/) de esta misma web.
+
+```php
+<?hh
+
+// La sintaxis de Hack sólo se habilita para los ficheros que comienzan con
+// un marcador <?hh. Estos marcadores no pueden intercalarse con código HTML,
+// tal como se puede hacer con <?php. Al usar el marcador "<?hh //strict" el
+// comprobador de tipado en modo estricto se pone en modo estricto.
+
+// Indicando el tipo de parámetros escalares
+function repeat(string $word, int $count)
+{
+    $word = trim($word);
+    return str_repeat($word . ' ', $count);
+}
+
+// Indicando el tipo que devuelve una función
+function add(...$numbers) : int
+{
+    return array_sum($numbers);
+}
+
+// Las funciones que no devuelven nada usan el tipo "void"
+function truncate(resource $handle) : void
+{
+    // ...
+}
+
+// Al determinar un tipo, hay que indicar explícitamente si permite el valor 
+// NULL
+function identity(?string $stringOrNull) : ?string
+{
+    return $stringOrNull;
+}
+
+// Se puede especificar el tipo de las propiedades de una clase
+class TypeHintedProperties
+{
+    public ?string $name;
+    
+    protected int $id;
+
+    private float $score = 100.0;
+
+	// El comprobador de tipos de Hack fuerza que las propiedades tipadas
+	// tengan un valor por defecto o que estén asignadas en el constructor
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Funciones anónimas concisas (lambdas)
+$multiplier = 5;
+array_map($y ==> $y * $multiplier, [1, 2, 3]);
+
+
+// Genéricos
+class Box<T>
+{
+    protected T $data;
+
+    public function __construct(T $data) {
+        $this->data = $data;
+    }
+
+    public function getData(): T {
+        return $this->data;
+    }
+}
+
+function openBox(Box<int> $box) : int
+{
+    return $box->getData();
+}
+
+
+// Shapes
+//
+// Hack añade el concepto de shape para definir estructuras similares a
+// vectores, pero con un conjunto de claves garantizado y tipado
+type Point2D = shape('x' => int, 'y' => int);
+
+function distance(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distance(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Alias de tipos
+//
+// Hack permite crear alias para hacer que los tipos complejos sean más legibles
+newtype VectorArray = array<int, Vector<int>>;
+
+// Una tupla que contiene dos enteros
+newtype Point = (int, int);
+
+function addPoints(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+addPoints(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// Enumerados de primera clase
+enum RoadType : int
+{
+    Road = 0;
+    Street = 1;
+    Avenue = 2;
+    Boulevard = 3;
+}
+
+function getRoadType() : RoadType
+{
+    return RoadType::Avenue;
+}
+
+
+// Promoción de argumentos en constructores
+//
+// Para evitar repetir una y otra vez la definición de constructores que
+// sólo asignan propiedades, Hack añade una sintaxis concisa para definir
+// propiedades junto al constructor.
+class ArgumentPromotion
+{
+    public function __construct(public string $name,
+                                protected int $age,
+                                private bool $isAwesome) {}
+}
+
+class WithoutArgumentPromotion
+{
+    public string $name;
+
+    protected int $age;
+
+    private bool $isAwesome;
+
+    public function __construct(string $name, int $age, bool $isAwesome)
+    {
+        $this->name = $name;
+        $this->age = $age;
+        $this->isAwesome = $isAwesome;
+    }
+}
+
+
+// Multitarea cooperativa
+//
+// "async" y "await" son dos palabras claves nuevas para realizar multi-tarea.
+// Esto no implica que se usen hilos, sólo permiten transferir el control de la 
+// ejecución.
+{
+    for ($i = $start; $i <= $end; $i++) { 
+        echo "$i ";
+
+        // Da a otras tareas la oportunidad de hacer algo
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Esto imprime "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    cooperativePrint(1, 3),
+    cooperativePrint(4, 6),
+    cooperativePrint(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributos
+//
+// Los atributos son una especie de metadatos para funciones. Hack implementa
+// algunos atributos especiales para introducir esta característica.
+
+// El atributo especial __Memoize hace que el resultado de la función se cacheé.
+<<__Memoize>>
+function doExpensiveTask() : ?string
+{
+    return file_get_contents('http://example.com');
+}
+
+// Esta función se va a ejecutar sólo una vez:
+doExpensiveTask();
+doExpensiveTask();
+
+
+// El atributo __ConsistentConstruct indica al comprobador de tipos de Hack que
+// asegure que la signatura de __construct sea la misma para todas las
+// subclases.
+<<__ConsistentConstruct>>
+class ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class ConsistentBar extends ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+		 // El comprobador de tipos de Hack fuerza que los constructores de 
+		 // los padres sean llamados.
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // La anotación __Override es un atributo opcional para que el comprobador
+    // de tipos fuerce que ese método esté sobrecargando un método de un padre
+    // o de un trait. Sino, fallará.
+    <<__Override>>
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class InvalidFooSubclass extends ConsistentFoo
+{
+	// Este constructor no coincide con el padre y causará el siguiente error:
+	//
+	//  "This object is of type ConsistentBaz. It is incompatible with this 
+	//   object of type ConsistentFoo because some of their methods are 
+	//   incompatible"
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Usando la anotación __Override en un método que no sobrecarga nada se
+    // producirá el siguiente error:
+    //
+    //  "InvalidFooSubclass::otherMethod() is marked as override; no non-private
+    //   parent definition found or overridden parent is defined in non-<?hh 
+    //   code"
+    <<__Override>>
+    public function otherMethod()
+    {
+        // ...
+    }
+}
+
+
+// Los traits pueden implementar interfaces (PHP no soporta esto).
+interface KittenInterface
+{
+    public function play() : void;
+}
+
+trait CatTrait implements KittenInterface
+{
+    public function play() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use CatTrait;
+}
+
+
+$cat = new Samuel();
+$cat instanceof KittenInterface === true; // True
+
+```
+
+## Más información
+
+Para obtener una explicación más detallada de las características que añade Hack a PHP visita la página de [referencia de Hack](http://docs.hhvm.com/manual/en/hacklangref.php) o la [página oficial de Hack](http://hacklang.org/) para información de caracter más general.
+
+Visita la [página oficial de HHVM](http://hhvm.com/) para ver las instrucciones de su instalación.
+
+También puedes visitar la [sección de características de PHP no soportadas por Hack](http://docs.hhvm.com/manual/en/hack.unsupported.php) para más detalles sobre la retrocompatibilidad entre Hack y PHP.
diff --git a/es-es/haskell-es.html.markdown b/es-es/haskell-es.html.markdown
new file mode 100644
index 00000000..66ce109d
--- /dev/null
+++ b/es-es/haskell-es.html.markdown
@@ -0,0 +1,437 @@
+---
+language: Haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+translators:
+    - ["Jorge Antonio Atempa", "http://www.twitter.com/atempa09"]
+filename: haskell-es.md
+lang: es-es
+---
+
+Haskell fue diseñado como lenguaje de programación funcional práctico y puro. Es famoso por sus mónadas y su sistema de tipos, pero siempre regreso a él debido a su elegancia. Haskell hace la codificación una verdadera alegría para mí.
+
+```haskell
+-- Para comentar una sola línea utiliza dos guiones.
+{- Para comentar múltiples líneas puedes encerrarlas
+en un bloque como este.
+-}
+
+----------------------------------------------------
+-- 1. Tipos de datos primitivos y Operadores
+----------------------------------------------------
+
+-- Tienes números a tu disposición
+3 -- 3
+
+-- Matématicas, es lo que esperas
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- Por defecto la división no devuelve un entero
+35 / 4 -- 8.75
+
+-- Para la división entera utiliza
+35 `div` 4 -- 8
+
+-- Valores booleanos
+True
+False
+
+-- Operaciones booleanas
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- En los ejemplos superiores, `not` es una función que toma un valor.
+-- Haskell no necesita paréntisis para las llamadas a funciones...todos los argumentos
+-- son enlistados después de la función. Entonces el patrón general es:
+-- func arg1 arg2 arg3...
+-- Observa la sección de funciones para obtener información de como escribir tu propia función.
+
+-- Cadenas y caracteres
+"Esto es una cadena."
+'a' -- caracter
+'No puedes utilizar comillas simples para cadenas.' -- ¡error!
+
+-- Concatenación de cadenas
+"¡Hola " ++ "mundo!" -- "¡Hola mundo!"
+
+-- Una cadena es una lista de caracteres
+['H', 'o', 'l', 'a'] -- "Hola"
+"Esto es una cadena" !! 0 -- 'E'
+
+
+----------------------------------------------------
+-- 2. Listas y Tuplas
+----------------------------------------------------
+
+-- Cada elemento en una lista debe ser del mismo tipo.
+-- Estas dos listas son iguales:
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Los rangos son versátiles.
+['A'..'F'] -- "ABCDEF"
+
+-- Puedes crear un paso en un rango.
+[0,2..10] -- [0, 2, 4, 6, 8, 10]
+[5..1] -- Esto no funciona debido a que Haskell incrementa por defecto.
+[5,4..1] -- [5, 4, 3, 2, 1]
+
+-- indexación en una lista
+[0..] !! 5 -- 5
+
+-- También tienes listas infinitas en Haskell!
+[1..] -- una lista de todos los números naturales
+
+-- Las listas infinitas funcionan porque Haskell tiene "lazy evaluation". Esto significa
+-- que Haskell solo evalúa las cosas cuando lo necesita. Así que puedes pedir
+-- el elemento 1000 de tú lista y Haskell te devolverá:
+
+[1..] !! 999 -- 1000
+
+-- Y ahora Haskell ha evaluado elementos 1 - 1000 de esta lista...pero el
+-- resto de los elementos de esta lista "infinita" ¡no existen todavía! Haskell no lo hará
+-- en realidad los evalúa hasta que los necesita.
+
+-- uniendo dos listas
+[1..5] ++ [6..10]
+
+-- añadiendo a la cabeza de la lista
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- más operaciones con listas
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- Listas por comprensión
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- Listas por comprensión utilizando condicionales
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Cada elemento en una tupla puede ser de diferente tipo, pero una tupla tiene
+-- longitud fija.
+-- Ejemplo de una tupla:
+("haskell", 1)
+
+-- acceder a los elementos (por ejemplo una tupla de longitud 2)
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Funciones
+----------------------------------------------------
+-- Una función simple que recibe dos variables
+add a b = a + b
+
+-- Nota: Si estas utilizando ghci (el interprete de Haskell)
+-- Necesitas utilizar `let`, por ejemplo
+-- let add a b = a + b
+
+-- Utilizando la función
+add 1 2 -- 3
+
+-- También puedes llamar a la función enmedio de dos argumentos
+-- con acentos abiertos:
+1 `add` 2 -- 3
+
+-- ¡También puedes definir funciones sin tener que utilizar letras! De este modo
+-- ¡Tú defines tus propios operadores! Aquí esta un operador que realiza
+-- una división entera
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Guardas: son una manera fácil para ramificar funciones
+fib x
+  | x < 2 = 1
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- La coincidencia de patrones es similar. Aquí hemos dado tres diferentes
+-- definiciones para fib. Haskell llamará automáticamente la primer
+-- función que coincide con el patrón del valor.
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Coincidencia de patrones en tuplas:
+foo (x, y) = (x + 1, y + 2)
+
+-- Coincidencia de patrones en listas. Aquí `x` es el primer elemento
+-- en una lista, y `xs` es el resto de la lista. Podemos escribir
+-- nuestra propia función map:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Funciones anónimas son creadas con una diagonal invertida seguido de
+-- todos los argumentos.
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- utilizando pliegues (llamado `inject` en algunos lenguajes) con una función
+-- anónima. foldl1 significa pliegue por la izquierda, y usa el primer valor 
+-- en la lista como el valor inicial para el acumulador.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Más funciones
+----------------------------------------------------
+
+-- aplicación parcial: si no quieres pasar todos los argumentos a una función,
+-- esta es "parcialmente aplicada". Esto significa que retorna una función que toma
+-- el resto de los argumentos.
+
+add a b = a + b
+foo = add 10 -- foo es actualmente una función que toma un número y suma 10 a esta
+foo 5 -- 15
+
+-- Otra manera de escribir los mismo
+foo = (+10)
+foo 5 -- 15
+
+-- composición de funciones
+-- el (.) encadena funciones.
+-- Por ejemplo, aquí foo es una función que toma un valor. Y se le suma 10,
+-- posteriormente multiplica el resultado por 5, y devuelve el resultado final.
+foo = (*5) . (+10)
+
+-- (5 + 10) * 5 = 75
+foo 5 -- 75
+
+-- fijación de precedencia 
+-- Haskell tiene otro operador llamado `$`. Este operador aplica a una función 
+-- para un parámetro dado. En contraste a la aplicación de función estándar,  
+-- la cúal tiene prioridad más alta posible de 10 y es asociativa por la izquierda, 
+-- el operador `$` tiene prioridad de 0 y es asociativa por la derecha. Tal que
+-- una baja prioridad significa que la expresión a su derecha es aplicada como parámetro a la función a su izquierda.
+
+-- antes
+even (fib 7) -- false
+
+-- equivalentemente
+even $ fib 7 -- false
+
+-- composición de funciones
+even . fib $ 7 -- false
+
+
+----------------------------------------------------
+-- 5. Firma de tipos
+----------------------------------------------------
+
+-- Haskell tiene un fuerte sistema de tipado, y cada cosa tiene una firma de tipo.
+
+-- Algunos tipos básicos:
+5 :: Integer
+"hola" :: String
+True :: Bool
+
+-- Las funciones tienen muchos tipos.
+-- `not` toma un booleano y devuelve un booleano:
+-- not :: Bool -> Bool
+
+-- Aquí, esta función toma dos argumentos:
+-- add :: Integer -> Integer -> Integer
+
+-- Cuando defines un valor, es una buena práctica escribir su tipo en una línea superior:
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Control de flujo y Expresiones If
+----------------------------------------------------
+
+-- expressiones if en una sola línea
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- expressiones if en múltiples líneas, la identación es importante
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- expressiones case: Aquí se muestra como analizar los argumentos 
+-- desde línea de comandos
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+-- Haskell no tiene ciclos; en lugar de esto utiliza recursión.
+-- map aplica una función sobre cada elemento en un arreglo
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- tú puedes crear una función utilizando map
+for array func = map func array
+
+-- y entonces utilizarla
+for [0..5] $ \i -> show i
+
+-- también podríamos haberlo escrito de esta manera:
+for [0..5] show
+
+-- Puedes utilizar foldl o foldr para reducir una lista
+-- foldl <fn> <valor inicial> <lista>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- Esto es lo mismo que
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl es izquierda, foldr es derecha
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- Esto es los mismo que
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
+
+----------------------------------------------------
+-- 7. Tipos de datos
+----------------------------------------------------
+
+-- Por ejemplo, para crear tu propio tipo de dato en Haskell
+
+data Color = Rojo | Azul | Verde
+
+-- Ahora puedes utilizarlo en una función:
+
+
+say :: Color -> String
+say Rojo = "¡Es Rojo!"
+say Azul = "¡Es Azul!"
+say Verde =  "¡Es Verde!"
+
+-- Tus tipos de datos pueden tener parámetros también:
+
+data Maybe a = Nothing | Just a
+
+-- Estos son todos de tipo Maybe
+Just "hello"    -- de tipo `Maybe String`
+Just 1          -- de tipo `Maybe Int`
+Nothing         -- de tipo `Maybe a` para cualquier `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Mientras que IO no puede ser explicado plenamente sin explicar las mónadas,
+-- no es difícil explicar lo suficiente para ponerse en marcha.
+
+-- Cuando un programa en Haskell se ejecuta, `main` es
+-- llamado. Este debe devolver un valor de tipo `IO ()`. Por ejemplo:
+
+main :: IO ()
+main = putStrLn $ "¡Hola, cielo! " ++ (say Blue)
+-- putStrLn tiene tipo String -> IO ()
+
+-- Es más fácil de hacer IO si puedes implementar tu programa como
+-- una función de String a String. La función
+--    interact :: (String -> String) -> IO ()
+-- recibe como entrada un texto,  ejecuta una función e imprime
+-- una salida.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Puedes pensar en el valor de tipo `IO ()` como la representación 
+-- de una secuencia de acciones que la computadora hace, al igual que
+-- un programa escrito en un lenguaje imperativo. Podemos utilizar
+-- la notación `do` para encadenar acciones. Por ejemplo:
+
+sayHello :: IO ()
+sayHello = do
+   putStrLn "¿Cual es tu nombre?"
+   name <- getLine -- obtenemos un valor y lo proporcionamos a "name"
+   putStrLn $ "Hola, " ++ name
+
+-- Ejercicio: escribe tu propia version de `interact` que solo lea 
+--           una linea como entrada.
+
+-- Nunca se ejecuta el código en `sayHello`, sin embargo. La única
+-- acción que siempre se ejecuta es el valor de `main`.
+-- Para ejecutar `sayHello` comenta la definición anterior de `main`
+-- y sustituyela por:
+--   main = sayHello
+
+-- Vamos a entender mejor como funciona la función `getLine` cuando
+-- la utilizamos. Su tipo es:
+--    getLine :: IO String
+-- Puedes pensar en el valor de tipo `IO a` como la representación
+-- programa que generará un valor de tipo `a`
+-- cuando es ejecutado (además de cualquier otra cosa que haga). Podemos
+-- almacenar y reutilizar el valor usando `<-`. También podemos
+-- crear nuestra propia acción de tipo `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "Esta es una linea."
+   input1 <- getLine
+   input2 <- getLine
+   -- El tipo de la sentencia `do` es la de su última línea.
+   -- `return` no es una palabra clave, sino simplemente una función
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- Podemos usar esto sólo como usabamos `getLine`:
+
+main'' = do
+    putStrLn "¡Volveré a repetir dos líneas!"
+    result <- action
+    putStrLn result
+    putStrLn "Esto es todo, ¡amigos!"
+
+-- El tipo `IO` es un ejemplo de una "mónada". La forma en que Haskell utiliza una monada
+-- permite que sea un lenguaje puramente funcional. Cualquier función que
+-- interactue con el mundo exterior (por ejemplo usar IO) obtiene una marca `IO`
+-- como su firma de tipo. Esto nos permite pensar qué funciones son "puras"
+-- (que no interactuan con el mundo exterior o modifican el estado) y que funciones no lo son.
+
+-- Esta es una poderosa característica, porque es una manera fácil de ejecutar funciones puras
+-- concurrentemente; entonces, la concurrencia en Haskell es muy fácil.
+
+
+----------------------------------------------------
+-- 9. El interprete de comandos de Haskell
+----------------------------------------------------
+
+-- Para comenzar escribe desde la terminal `ghci`.
+-- Ahora puede escribir código en Haskell. Para cualquier valor nuevo
+-- que necesites crear utiliza `let`:
+
+let foo = 5
+
+-- Puedes inspeccionar el tipo de cualquier valor con `:t`:
+
+>:t foo
+foo :: Integer
+
+-- Puedes ejecutar acciones de tipo `IO ()`
+
+> sayHello
+¿Cual es tu nombre?
+Amigo
+Hola, Amigo
+
+```
+
+Existe mucho más de Haskell, incluyendo clases de tipos y mónadas. Estas son
+las grandes ideas que hacen a Haskell divertido. Te dejamos un ejemplo final
+de Haskell: una implementación del algoritmo QuickSort:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell es fácil de instalar. Obtenlo [aquí](http://www.haskell.org/platform/).
+
+Usted puede encontrar más información en:
+[Learn you a Haskell](http://learnyouahaskell.com/) o
+[Real World Haskell](http://book.realworldhaskell.org/) o
+[Aprende Haskell por el bien de todos](http://aprendehaskell.es/)
diff --git a/es-es/html-es.html.markdown b/es-es/html-es.html.markdown
new file mode 100644
index 00000000..e4623131
--- /dev/null
+++ b/es-es/html-es.html.markdown
@@ -0,0 +1,122 @@
+---
+language: html
+filename: learnhtml-es.html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es
+---
+
+HTML significa Lenguaje de marcado de hipertexto (HyperText Markup Language).
+Este es un lenguaje usado para escribir páginas en la web (WWW). 
+Este es un lenguaje de marcado, es usado para escribir páginas web usando código para indicar cómo se debe mostrar el texto y los datos.
+En efecto, los archivos html son simples archivos de texto.
+Qué es esto de marcado? es un método para organizar los datos de la página encerrandolos con etiquetas de apertura y cierre.
+Este marcado sirve para darle significancia al texto que éste encierra.
+Como en otros lenguajes computacionales, HTML tiene varias versiones. Aquí hablaremos acerca de HTML5.
+
+**Nota :**  Puedes probrar las diferentes etiquetas y elementos a medida que progresas en un tutorial en un sitio como  [codepen](http://codepen.io/pen/) con el fin de ver sus efectos, entender como funcionan y familiarizarse con el lenguaje.
+Este artículo está centrado principalmente en la sintaxis HTML y algunos tips de importancia.
+
+
+```html
+<!-- los comentarios están encerrados como en esta línea! -->
+
+<!-- #################### Las Etiquetas #################### -->
+   
+<!-- Este es un ejemplo de un archivo HTML que analizaremos! -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Mi Sitio</title>
+		</head>
+		<body>
+			<h1>Hola, Mundo!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">ven mira lo que esto muestra. </a>
+			<p>Esto es un párrafo</p>
+			<p>Este es otro párrafo</p>
+			<ul>
+				<li>Este es un elemento de una lista no numerada (lista de viñetas)</li>
+				<li>Este es otro ítem</li>
+				<li>Y este es el último ítem de la lista</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- En un archivo HTML siempre inicia indicando le al buscador que esta es una página HTML. -->
+<!doctype html>
+
+<!-- Después de esto, iniciamos abriendo una etiqueta html <html> -->
+<html>
+
+<!-- Cuando termine el archivo cerraremos la etiqueta así </html>. -->
+</html>
+
+<!-- Después de la etiqueta final nada aparecerá o podrá aparecer -->
+
+<!-- Dentro (Entre las etiquetas de apertura y cierre <html></html>), encontraremos: -->
+
+<!-- Un encabezado definido por <head> (Este debe ser cerrado por </head>). -->
+
+<!-- El encabezado contiene alguna descripción y información adicional que no se muestra; estos son los metadatos. -->
+
+<head>
+	<title>Mi Sitio</title><!-- La etiqueta <title> Indica al buscador el título a mostrar en la ventana del buscador en la barra de título y en el nombre de la pestaña. -->
+</head>
+
+<!-- Después de la sección del encabezado <head> , Encontraremos la etiqueta de cuerpo - <body> -->
+<!-- Hasta este punto. no hay nada descrito para que se muestre en la ventana del navegador -->
+<!-- Debemos llenar el cuerpo con el contenido que se mostrará -->
+
+<body>
+	<h1>Hola, Mundo!</h1> <!-- La etiqueta <h1> crea un título. -->
+	<!-- También tenemos subtítulos para <h1> desde la más importante <h2> a la más precisa <h6> -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">ven mira lo que esto muestra.</a> <!-- Un hipervínculo a la URL dada por el atributo href="" -->
+	<p>Esto es un párrafo.</p> <!-- La etiqueta <p> nos permite incluir texto en nuestra página HTML -->
+	<p>Este es otro párrafo.</p>
+	<ul> <!-- La etiqueta <ul> crea una lista de viñetas -->
+	<!-- Para tener una lista numerada usamos la etiqueta <ol> dando 1. para el primer elemento, 2. para el segundo, etc. -->
+		<li>Este es un elemento de una lista no numerada (lista de viñetas)</li>
+		<li>Este es otro ítem</li>
+		<li>Y este es el último ítem de la lista</li>
+	</ul>
+</body>
+
+<!-- Y esto es todo, la creación de un archivo HTML puede ser muy simple. -->
+
+<!-- Sin embargo, es posible añadir muchos otros tipos de etiquetas HTML  -->
+
+<!-- Para insertar una imagen -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- La fuente donde se localiza la imagen se indica utilizando el atributo src=""-->
+<!-- La fuente puede ser una URL o incluso una ruta a una archivo en tu computador. -->
+
+<!-- También es posible crear una tabla -->
+
+<table> <!-- Abrimos una etiqueta o elemento tabla <table> -->
+	<tr> <!-- <tr> Nos permite crear una fila. -->
+		<th>Primer encabezado</th> <!-- <th> Nos permite dar un título a una columna de una tabla -->
+		<th>Segundo encabezado</th>
+	</tr>
+	<tr>
+		<td>Primera fila, primera columna</td> <!-- <td> nos permite crear una celda  -->
+		<td>Primera fila, segunda columna</td>
+	</tr>
+	<tr>
+		<td>Segunda fila, primera columna</td>
+		<td>Segunda fila, segunda columna</td>
+	</tr>
+</table>
+
+```
+
+## Uso
+
+HTML es escrito en archivos que terminan con (extensión) `.html`.
+
+## Para aprender más! 
+
+* [wikipedia](https://es.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/es/docs/Web/HTML)
+* [W3School (EN)](http://www.w3schools.com/html/html_intro.asp)
diff --git a/es-es/java-es.html.markdown b/es-es/java-es.html.markdown
index b34dca8d..e48a3b73 100644
--- a/es-es/java-es.html.markdown
+++ b/es-es/java-es.html.markdown
@@ -279,6 +279,19 @@ public class AprendeJava {
         // 'toString' es una convención para mostrar los valores de este objeto.
         System.out.println("informacion de la excursion: " + excursion.toString());
 
+        ///////////////////////////////////////
+        // Genéricos
+        ///////////////////////////////////////
+
+        // Utilizando genéricos (a partir de Java 1.5) es posible detectar en tiempo de
+        // compilación errores de tipado (en versiones anteriores se detectarían como error
+        // de ejecución)
+
+        List<String> v = new ArrayList<String>();
+        v.add("test");
+        String s = v.get(0); // Si intentamos recuperar s como otro tipo diferente a String
+                             // (por ejemplo, un Integer) obtendríamos un error de compilación
+
     } // Fin del método 'main'
 } // Fin de la clase AprendeJava
 
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index 9ef0c63e..31512dc4 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -16,14 +16,16 @@ con Java para aplicaciones más complejas. Debido a su integracion estrecha con
 web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común 
 para front-end que Java.
 
-Aunque JavaScript no sólo se limita a los navegadores web: Node.js, Un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
+Sin embargo, JavaScript no sólo se limita a los navegadores web: Node.js, un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
 
 ¡La retroalimentación es bienvenida! Puedes encontrarme en: 
 [@adambrenecki](https://twitter.com/adambrenecki), o
 [adam@brenecki.id.au](mailto:adam@brenecki.id.au).
 
 ```js
-// Los comentarios son como en C. Los comentarios de una sola línea comienzan con //,
+// Los comentarios en JavaScript son los mismos como comentarios en C. 
+
+//Los comentarios de una sola línea comienzan con //,
 /* y los comentarios multilínea comienzan
    y terminan con */
 
@@ -80,13 +82,13 @@ false;
 !true; // = false
 !false; // = true
 
-// Para comprobar una igualdad se usa ==
-1 == 1; // = true
-2 == 1; // = false
+// Para comprobar una igualdad se usa ===
+1 === 1; // = true
+2 === 1; // = false
 
-// Para comprobar una desigualdad se usa !=
-1 != 1; // = false
-2 != 1; // = true
+// Para comprobar una desigualdad se usa !==
+1 !== 1; // = false
+2 !== 1; // = true
 
 // Más comparaciones
 1 < 10; // = true
diff --git a/es-es/jquery-es.html.markdown b/es-es/jquery-es.html.markdown
new file mode 100644
index 00000000..27ad48bb
--- /dev/null
+++ b/es-es/jquery-es.html.markdown
@@ -0,0 +1,141 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: jquery-es.js
+---
+
+jQuery es una librería de JavaScript que le ayuda a "hacer más y escribir menos". Esto hace que muchas de las tareas comunes de JavaScript sean más fáciles de escribir. jQuery es utilizado por muchas de las grandes empresas y desarrolladores de todo el mundo. Hace que AJAX, la gestión de eventos, la manipulación de documentos, y mucho más, sea más fácil y rápido.
+
+Debido a que jQuery es una librería de JavaScript debes [aprender JavaScript primero](https://learnxinyminutes.com/docs/es-es/javascript-es/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Selectores
+
+// Los selectores en jQuery son usados para seleccionar un elemento
+var page = $(window); // Selecciona toda la ventana gráfica
+
+// Los selectores también pueden ser selectores CSS
+var paragraph = $('p'); // Selecciona todos los elementos de párrafo
+var table1 = $('#table1'); // Selecciona el elemento con id 'tabla1'
+var squares = $('.square'); // Selecciona todos los elementos con la clase "square"
+var square_p = $('p.square') // Selecciona los párrafos con la clase "square"
+
+
+///////////////////////////////////
+// 2. Eventos y efectos
+
+// Un evento muy común que se utiliza es el evento 'ready' en el documento
+// Se puede utilizar el método de 'ready' para esperar hasta que el elemento haya terminado de cargar
+$(document).ready(function(){
+  // El código no se ejecutará hasta que el documento haya terminado de cargar
+});
+
+// jQuery es muy bueno activando eventos
+// Y también en el manejo de lo que ocurre cuando se activa un evento
+$('#button').click(); // Dispara un evento click en $ ('# botón')
+$('#button').click(function(){
+  // El código es ejecutado cuando se hace clic en el elemento de botón #
+});
+
+function onAction() {
+ // Esto se ejecuta cuando se activa el evento
+}
+
+// Algunos otros eventos comunes son:
+$('#btn').dblclick(onAction); //Doble clic
+$('#btn').hover(onAction); // Pasar el cursor por encima
+$('#btn').focus(onAction); // Enfocado
+$('#btn').blur(onAction); // Pierde enfoque
+$('#btn').submit(onAction); // Enviado
+$('#btn').select(onAction); // Cuando se selecciona un elemento
+$('#btn').keydown(onAction); // Cuando una tecla es empujada hacia abajo
+$('#btn').keyup(onAction); // Cuando se suelta una tecla
+$('#btn').keypress(onAction); // Cuando se pulsa una tecla
+$('#btn').mousemove(onAction); // Cuando se mueve el mouse
+$('#btn').mouseenter(onAction); // El mouse entra en el elemento
+$('#btn').mouseleave(onAction); // El mouse sale en el elemento
+
+// También se puede utilizar una función anónima
+$('#btn').hover(function(){
+  // Se ejecuta al pasar por encima
+});
+
+// Todos estos pueden también desencadenar el evento en lugar de manejarlo
+// Simplemente no pasando ningún parámetro
+$('#btn').dblclick(); // Dispara el evento de doble clic sobre el elemento
+
+// Se puede manejar múltiples eventos, usando el selector una vez
+$('#btn').on(
+  {dblclick: myFunction1} // Activado con doble clic
+  {blur: myFunction1} // Activo en la perdida de enfoque
+);
+
+// Puede mover y ocultar elementos con algunos métodos de efecto
+$('.table').hide(); // Oculta el(los) elemento(s)
+
+// Nota: llamar a una función en estos métodos aún oculta el elemento
+$('.table').hide(function(){
+    // El elemento se oculta entonces función ejecutada
+});
+
+// Puedes almacenar los selectores en las variables
+var tables = $('.table');
+
+// Algunos métodos básicos de manipulación de documento son:
+tables.hide(); // Oculta elemento(s)
+tables.show(); // Muestra elemento(s)
+tables.toggle(); // Cambia el estado de ocultar / mostrar
+tables.fadeOut(); // Desvanece
+tables.fadeIn(); // Fundirse
+tables.fadeToggle(); // Desvanece dentro o fuera
+tables.fadeTo(0.5); // Desvanece a una opacidad (entre 0 y 1)
+tables.slideUp(); // Desliza hacia arriba
+tables.slideDown(); // Desliza hacia abajo
+tables.slideToggle(); // Desliza hacia arriba o hacia abajo
+
+// Todo lo anterior toma una velocidad (milisegundos) y la función de devolución de llamada
+tables.hide(1000, myFunction); // Animación de ocultar elemento a 1 segundo y luego la funcion de devolución
+
+// 'fadeTo' requiere de una opacidad como su segundo parámetro
+tables.fadeTo(2000, 0.1, myFunction); // 2 segundos. decolorar a opacidad de 0.1 luego la función
+
+// Puede conseguir un efecto un poco más avanzado con el método 'animate'
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// El método 'animate' toma un objeto de CSS y los valores finales,
+// Parámetro opcional de opciones para afinar la animación,
+// Y por supuesto la función de devolución de llamada
+
+///////////////////////////////////
+// 3. Manipulación
+
+// Estos son similares a los efectos, pero pueden hacer más
+$('div').addClass('div') // Añade la clase div a todos los divs
+
+// Métodos comunes de manipulación 
+$('p').append('Hola mundo'); // Añade al final del elemento
+$('p').attr('class'); // Obtiene atributo
+$('p').attr('class', 'content'); // Configura atributos
+$('p').hasClass('div'); //Devuelve verdadero si tiene la clase
+$('p').height(); // Obtiene la altura del elemento o define la altura
+
+
+// Para muchos métodos de manipulación, obtener información sobre un elemento
+// consigue solamente el primer elemento coincidente
+$('p').height(); // Obtiene sólo la altura de la primera etiqueta 'p'
+
+// Puedes utilizar 'each' para recorrer todos los elementos
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Añade todas las alturas "p" de la etiqueta a la matriz
+});
+
+
+```
\ No newline at end of file
diff --git a/es-es/kotlin-es.html.markdown b/es-es/kotlin-es.html.markdown
new file mode 100644
index 00000000..045f92d1
--- /dev/null
+++ b/es-es/kotlin-es.html.markdown
@@ -0,0 +1,361 @@
+---
+language: kotlin
+contributors:
+- ["S Webber", "https://github.com/s-webber"]
+translators:
+- ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: LearnKotlin-es.kt
+---
+
+Kotlin es un lenguaje estático tipado para la JVM, Android y el navegador. Es
+100% interoperable con Java.
+[Leer mas aqui.](https://kotlinlang.org/)
+
+```java
+// Los comentarios de una sóla línea comienzan con //
+
+/*
+ Los comentarios multilínea lucen así
+*/
+
+// La palabra clave "package" funciona de la misma manera que Java.
+
+/*
+El punto de entrada para un programa de Kotlin es una función llamada "main".
+A dicha función se le pasa un arreglo que contiene los argumentos de la linea de comando.
+*/
+fun main(args: Array<String>) {
+    /*
+    La declaración de valores se realiza utilizando tanto "var" como "val".
+    Las declaraciones "val" no pueden ser reasignadas, mientras que "var" sí.
+    */
+    val fooVal = 10 // más adelante no podremos reasignar fooVal con un valor distinto.
+    var fooVar = 10
+    fooVar = 20 // fooVar puede ser reasignado
+
+    /*
+    En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable,
+    de tal manera que no tenemos que especificarlo explícitamente cada vez.
+    Podemos declarar explícitamente el tipo de una variable así:
+    */
+    val foo: Int = 7
+
+    /*
+    Las cadenas pueden ser representadas de la misma manera que Java.
+    El escape de caracteres se realiza con una barra invertida.
+    */
+    val fooString = "Mi Cadena está aquí!";
+    val barString = "¿Imprimiendo en una nueva línea?\nNo hay problema!";
+    val bazString = "¿Quíeres agregar una tabulación?\tNo hay problema!";
+    println(fooString);
+    println(barString);
+    println(bazString);
+
+    /*
+    Una cadena está delimitada por comillas triple (""").
+    Estas cadenas pueden contener saltos de línea y otros caracteres.
+    */
+    val fooRawString = """
+    fun helloWorld(val name : String) {
+       println("Hola, mundo!")
+    }
+    """
+    println(fooRawString)
+
+    /*
+    Las cadenas pueden contener interpolación de cadenas.
+    La interpolación de cadenas comienza con un signo de dólar ($).
+    */
+    val fooTemplateString = "$fooString tiene ${fooString.length} caracteres"
+    println(fooTemplateString)
+
+    /*
+    Para que una variable pueda aceptar valor nulo se debe especificar
+    explícitamente como anulable añadiendole ? a su tipo.
+    Podemos acceder a una variable anulable mediante el uso del operador ?.
+    Podemos utilizar el operador ?: para especificar un valor alternativo
+    a usar si una variable es nula.
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+
+    /*
+    Las funciones pueden ser declaras usando la palabra clave "fun".
+    Los argumentos de las funciones son especificados entre corchetes despues del nombre de la función.
+    Los argumentos de las funciones pueden tener opcionalmente un valor por defecto.
+    El tipo de retorno de las funciones, de ser requerido, es especificado despues del argumento.
+    */
+    fun hello(name: String = "mundo") : String {
+        return "Hola, $name!"
+    }
+    println(hello("foo")) // => Hola, foo!
+    println(hello(name = "bar")) // => Hola, bar!
+    println(hello()) // => Hola, mundo!
+
+    /*
+    Un parametro de la función puede ser marcado con la palabra clave "vararg"
+    que permite que una función acepte un numero variable de argumentos.
+    */
+    fun varargExample(vararg names: Int) {
+        println("Argument tiene ${names.size} elementos")
+    }
+    varargExample() // => Argument tiene 0 elementos
+    varargExample(1) // => Argument tiene 1 elementos
+    varargExample(1, 2, 3) // => Argument tiene 3 elementos
+
+    /*
+    Cuando una función consiste de una sola expresión entonces las llaves
+    pueden ser omitidas. El cuerpo es especificado despues del símbolo =
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // Si el tipo de retorno puede ser inferido entonces no se necesita
+    // especificarlo.
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // Las funciones pueden tomar funciones como argumentos y 
+    // retornar funciones.
+    fun not(f: (Int) -> Boolean) : (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+
+    // Las funciones con nombre pueden ser especificadas como argumentos
+    // utilizando el operador ::.
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // Las funciones anónimas pueden ser especificadas como argumentos.
+    val notZero = not {n -> n == 0}
+    /*
+    Si una función anónima tiene un solo parametro entonces la declaración
+    puede ser omitida (junto con ->). El nombre del único parametro será "it".
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // La palabra clave "class" es usada para declarar clases.
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int) : Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int) : Int {
+            return x * y
+        }
+    }
+    /*
+    Para crear una nueva instancia llamamos al constructor.
+    Nótese que Kotlin no usa la palabra clave "new".
+    */
+    val fooExampleClass = ExampleClass(7)
+    // Las funciones miembros pueden ser llamadas usando la notación de punto (.)
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    Si una función ha sido marcada con la palabra clave "infix" entonces
+    esta puede ser invocada usando la notación infija.
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    Las clases "data" son una manera concisa de crear clases que solo contengan datos.
+    Los metodos "hashCode"/"equals" y "toString" son generados automáticamente.
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // las clases de datos tienen una función "copy".
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // Los objetos pueden ser estructurados en múltiples variables.
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+
+    // La función "with" es similar a la expresión de JavaScript "with".
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    Podemos crear una lista utilizando la función "listOf".
+    La lista será inmutable - los elementos no pueden ser añadidos o eliminados.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // Los elementos de una lista se pueden acceder a través de su índice.
+    println(fooList[1]) // => b
+
+    // Una lista mutable puede ser creada usando la función "mutableListOf".
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // Podemos crear un set usando la función "setOf".
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // Podemos crear un mapa usando la función "mapOf".
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // Se puede acceder a los valores del mapa por su llave.
+    println(fooMap["a"]) // => 8
+
+    /*
+    Las secuencias representan colecciones evaluadas diferidamente.
+    Podemos crear una secuencia con la función "generateSequence".
+    */
+    val fooSequence = generateSequence(1, {it + 1})
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // Un ejemplo usando las secuencias para generar los números de Fibonacci:
+    fun fibonacciSequence() : Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next() : Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin provee funciones de Orden-Mayor para trabajar con colecciones.
+    val z = (1..9).map {it * 3}
+            .filter {it < 20}
+            .groupBy {it % 2 == 0}
+            .mapKeys {if (it.key) "even" else "odd"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // Un bucle "for" puede ser usado con cualquier cosa que provea un iterador.
+    for (c in "hello") {
+        println(c)
+    }
+
+    // El bucle "while" funciona de la misma manera que en los demás lenguajes.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    "if" puede ser usado como una expresión que retorna un valor.
+    Por esta razón el operador ternario ?: no es necesario en Kotlin.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "even" else "odd"
+    println("$num is $message") // => 5 is odd
+
+    // "when" puede ser usado como alternativa a cadenas de "if-else if".
+    val i = 10
+    when {
+        i < 7 -> println("primer bloque")
+        fooString.startsWith("hello") -> println("segundo bloque")
+        else -> println("else bloque")
+    }
+
+    // "when" puede ser usado con argumentos.
+    when (i) {
+        0, 21 -> println("0 or 21")
+        in 1..20 -> println("in the range 1 to 20")
+        else -> println("none of the above")
+    }
+
+    // "when" puede ser usado como una función que retorna un valor.
+    var result = when (i) {
+        0, 21 -> "0 or 21"
+        in 1..20 -> "in the range 1 to 20"
+        else -> "none of the above"
+    }
+    println(result)
+
+    /*
+    Podemos analizar si un objeto es de un tipo particular usando el operador "is".
+    Si un objeto pasa un chequeo de tipo entonces éste se puede utilizar como
+    ese tipo sin convertido de forma explícita.
+     */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x es automaticamente convertido a Boolean
+            return x
+        } else if (x is Int) {
+            // x es automaticamente convertido a Int
+            return x > 0
+        } else if (x is String) {
+            // x  es automaticamente convertido a String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hola, mundo!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    /*
+    Las extensiones son una manera de añadir nuevas funcionalidades a una clase.
+    Estas son similares a la extensión de métodos en C#.
+     */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hola, mundo!".remove('l')) // => Hoa, mundo!
+
+    println(EnumExample.A) // => A
+    println(ObjectExample.hello()) // => hola
+}
+
+// Las clases "enum" son similares a los tipos "enum" de Java.
+enum class EnumExample {
+    A, B, C
+}
+
+/*
+La palabra clave "object" se puede utilizar para crear objetos únicos.
+No podemos asignarlo a una variable, pero podemos hacer referencia a ella por su nombre.
+Esto es similar a los objetos únicos de Scala
+*/
+object ObjectExample {
+    fun hello() : String {
+        return "hola"
+    }
+}
+```
+
+### Lectura Adicional
+
+* [Kotlin tutorials (EN)](https://kotlinlang.org/docs/tutorials/)
+* [Try Kotlin in your browser (EN)](http://try.kotlinlang.org/)
+* [A list of Kotlin resources (EN)](http://kotlin.link/)
diff --git a/es-es/less-es.html.markdown b/es-es/less-es.html.markdown
new file mode 100644
index 00000000..fa09db9f
--- /dev/null
+++ b/es-es/less-es.html.markdown
@@ -0,0 +1,393 @@
+---
+language: less
+filename: learnless-es.less
+lang: es-es
+contributors:
+  - ["Saravanan Ganesh", "http://srrvnn.me"]
+translators:
+  - ["César Suárez", "https://github.com/csuarez"]
+---
+
+Less es un pre-procesador CSS, que añade características como variables, anidación, mixins y más.
+Less (y otros pre-procesadores como [Sass](http://sass-lang.com/) ayudan a los desarrolladores a escribir código mantenible y DRY (Don't Repeat Yourself).
+
+```css
+
+
+//Los comentarios de una línea son borrados cuando Less es compilado a CSS.
+
+/* Los comentarios multi-línea se mantienen. */
+
+
+
+/*Variables
+==============================*/
+
+
+/* Puedes almacenar un valor CSS (como un color) en una variable.
+Usa el símbolo '@' para crear una variable. */
+
+@primary-color: #a3a4ff;
+@secondary-color: #51527f;
+@body-font: 'Roboto', sans-serif;
+
+/* Puedes usar las variables por toda tu hoja de estilos.
+Ahora, si quieres cambiar un color, sólo lo tienes que hacer una vez.*/
+
+body {
+	background-color: @primary-color;
+	color: @secondary-color;
+	font-family: @body-font;
+}
+
+/* Esto compilará en: */
+
+body {
+	background-color: #a3a4ff;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* Esto es mucho más mantenible que tener que cambiar el color
+   cada vez que aparece en tu hoja de estilos. */
+
+
+
+/* Mixins
+==============================*/
+
+
+/* Si tienes el mismo código para más de un elemento, puede que
+   quieras reutilizarlo fácilmente. */
+
+.center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Puedes usar un mixin simplemente añadiendo el selector como un estilo. */
+
+div {
+	.center;
+	background-color: @primary-color;
+}
+
+/* Esto compilará en: */
+
+.center {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #a3a4ff;
+}
+
+/* Puedes omitir que se compile el código del mixin añadiendo un
+   paréntesis después del selector. */
+
+.center() {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+
+div {
+  .center;
+  background-color: @primary-color;
+}
+
+/* Esto compilará en: */
+div {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+  background-color: #a3a4ff;
+}
+
+
+
+/* Anidación
+==============================*/
+
+
+/* Less te permite anidar selectores dentro de otros selectores. */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #f00;
+	}
+}
+
+/* '&' es replazado por el selector padre. */
+/* También se pueden anidar seudo clases. */
+/* Ten en cuenta que anidar demasiado puede hacer tu código menos
+   mantenible. Las buenas prácticas recomiendan no tener más de 3 niveles de
+	 anidación. Por ejemplo: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Compila en: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* Funciones
+==============================*/
+
+
+/* Less ofrece funciones que pueden ser usadas para cumplir una gran variedad
+   de tareas. Considera lo siguiente: */
+
+/* Las funciones pueden ser llamadas usando su nombre y pasándole los argumentos
+   requeridos. */
+
+body {
+  width: round(10.25px);
+}
+
+.header {
+	background-color: lighten(#000, 0.5);
+}
+
+.footer {
+  background-color: fadeout(#000, 0.25)
+}
+
+/* Compila en: */
+
+body {
+  width: 10px;
+}
+
+.header {
+  background-color: #010101;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Puedes definir tus propias funciones. Las funciones son muy similares a
+   los mixins. Cuando tengas que elegir entre una función y un mixin, recuerda
+   que los mixins son mejores para generar CSS, mientras que las funciones son
+   mejores para la lógica que puedas necesitar en tu código Sass. Los ejemplos
+   de la sección 'Operadores matemáticos' son candidatos ideales para ser
+   usados como una función reusable. */
+
+/* Esta función calcula la media de dos números. */
+
+.average(@x, @y) {
+  @average-result: ((@x + @y) / 2);
+}
+
+div {
+  .average(16px, 50px);        // aquí se llama a la función
+  padding: @average-result;    // y aquí se usa el valor "devuelto"
+}
+
+/* Compila en: */
+
+div {
+  padding: 33px;
+}
+
+
+
+/* Extender (Herencia)
+==============================*/
+
+
+/* Extend es una manera de compartir propiedades de un selector con otro. */
+
+.display {
+  height: 50px;
+}
+
+.display-success {
+  &:extend(.display);
+	border-color: #22df56;
+}
+
+/* Compila en: */
+.display,
+.display-success {
+  height: 50px;
+}
+.display-success {
+  border-color: #22df56;
+}
+
+/* Extender una declaración CSS es preferible a crear un mixin
+   debido a la manera en la que Sass agrupa las clases que comparten
+   los mismos estilos base. Si esto fuese hecho con un mixin, el ancho,
+   alto y el borden aparecerían duplicados para cada una de las declaraciones
+   que usasen el mixin. Esto no afectará a tu workflow, pero infla
+   innecesariamente los ficheros generados por el compilador Less. */
+
+
+/*Partials and Imports
+==============================*/
+
+
+
+/* Less allows you to create partial files. This can help keep your Less
+   code modularized. Partial files conventionally begin with an '_',
+   e.g. _reset.less. and are imported into a main less file that gets
+   compiled into CSS */
+
+/* Consider the following CSS which we'll put in a file called _reset.less */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+ /* Less ofrece @import para poder importar parciales a un fichero. Esto se
+ 		diferencia del @import de CSS en que no hace otra petición HTTP para
+		importar el fichero, sino que combina el código importado en el código
+		compilado. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compila en: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Operaciones matemáticas
+==============================*/
+
+
+/* Less ofrece los siguientes operadores: +, -, *, / y %. Estos son útiles
+   para calcular valores directamente en tu código Less en vez de usar valores
+   calculados a mano. Mira el siguiente ejemplo que prepara un sencillo diseño
+   de dos columnas. */
+
+@content-area: 960px;
+@main-content: 600px;
+@sidebar-content: 300px;
+
+@main-size: @main-content / @content-area * 100%;
+@sidebar-size: @sidebar-content / @content-area * 100%;
+@gutter: 100% - (@main-size + @sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: @main-size;
+}
+
+.sidebar {
+  width: @sidebar-size;
+}
+
+.gutter {
+  width: @gutter;
+}
+
+/* Compila en: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+## Practica Less
+
+Si quieres probar Less en tu navegador, prueba:
+* [Codepen](http://codepen.io/)
+* [LESS2CSS](http://lesscss.org/less-preview/)
+
+## Compatibilidad
+
+Sass puede ser usado en cualquier proyecto mientras tengas un programa que lo compile en CSS. Quizás quieras comprobar si el CSS que estás usando es compatible con tus navegadores objetivo.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) y [CanIUse](http://caniuse.com) son buenos recursos para comprobar la compatibilidad de navegadores.
+
+## Más información
+* [Documentación oficial (EN)](http://lesscss.org/features/)
+* [Less CSS - Guía para principiantes (EN)](http://www.hongkiat.com/blog/less-basic/)
diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index bc481df7..0505b4cb 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -57,8 +57,8 @@ __Al igual que este texto.__
 **_Al igual que este!_**
 *__¡Y este!__*
 
-<!-- En Github Flavored Markdown, el cual es usado para mostrar archivos 
-Markdown en Github, también tenemos: -->
+<!-- En GitHub Flavored Markdown, el cual es usado para mostrar archivos 
+Markdown en GitHub, también tenemos: -->
 
 ~~Este texto está tachado.~~
 
@@ -150,7 +150,7 @@ para indentar dentro del código -->
 
 ¡John no sabía lo que la función `go_to()` hacía!
 
-<!-- Con Github Flavored Markdown, puedes usar una sintaxis especial para código -->
+<!-- Con GitHub Flavored Markdown, puedes usar una sintaxis especial para código -->
 
 \`\`\`ruby <!-- quita esas comillas cuando lo hagas, deja sólo ```ruby ! -->
 def foobar
@@ -158,7 +158,7 @@ def foobar
 end
 \`\`\` <!-- aquí también, sin comillas, sólo ``` -->
 
-<!-- El texto de arriba no necesita indentación, aparte Github usará
+<!-- El texto de arriba no necesita indentación, aparte GitHub usará
 resaltará la sintaxis del lenguaje que especifiques después de ``` -->
 
 <!-- Regla horizontal (<hr />) -->
@@ -231,7 +231,7 @@ Quiero escribir *este texto rodeado por asteriscos* pero no quiero que esté en
 así que hago esto: \*Este texto está rodeado de asteriscos\*.
 
 <!-- Tablas -->
-<!-- Las tablas sólo están disponibles en Github Flavored Markdown y son un poco pesadas,
+<!-- Las tablas sólo están disponibles en GitHub Flavored Markdown y son un poco pesadas,
 pero si de verdad las quieres: -->
 
 | Col1         | Col2     | Col3          |
diff --git a/es-es/objective-c-es.html.markdown b/es-es/objective-c-es.html.markdown
new file mode 100644
index 00000000..bdbce524
--- /dev/null
+++ b/es-es/objective-c-es.html.markdown
@@ -0,0 +1,851 @@
+---
+language: Objective-C
+contributors:
+    - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
+    - ["Yannick Loriot", "https://github.com/YannickL"]
+    - ["Levi Bostian", "https://github.com/levibostian"]
+translators:
+    - ["David Hsieh", "http://github.com/deivuh"]
+lang: es-es
+filename: LearnObjectiveC-es.m
+---
+Objective C es el lenguaje de programación principal utilizado por Apple para los sistemas operativos OS X y iOS y sus respectivos frameworks, Cocoa y Cocoa Touch.
+Es un lenguaje de programación para propósito general que le agrega al lenguaje de programación C una mensajería estilo "Smalltalk".
+
+
+```objective_c
+// Los comentarios de una sola línea inician con //
+
+/*
+Los comentarios de múltiples líneas se ven así.
+*/
+
+// Importa los encabezados de Foundation con #import
+// Utiliza <> para importar archivos globales (generalmente frameworks)
+// Utiliza "" para importar archivos locales (del proyecto)
+#import <Foundation/Foundation.h>
+#import "MyClass.h"
+
+// Si habilitas módulos para proyectos de iOS >= 7.0 u OS X >= 10.9 en
+// Xcode 5, puedes importarlos de la siguiente manera:
+@import Foundation;
+
+// El punto de entrada de tu programa es una función llamada 
+// main con un tipo de retorno entero. 
+int main (int argc, const char * argv[])
+{
+    // Crear un autorelease pool para manejar la memoria al programa
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+    // Si se utiliza el conteo automático de referencias (ARC), 
+    // utiliza @autoreleasepool:    
+    @autoreleasepool {
+
+    // Utiliza NSLog para imprimir líneas a la consola
+    NSLog(@"Hello World!"); // Imprimir el string "Hello World!"
+ 
+    ///////////////////////////////////////
+    // Tipos y variables
+    ///////////////////////////////////////
+    
+    // Declaraciones de primitivos
+    int myPrimitive1  = 1;
+    long myPrimitive2 = 234554664565;
+    
+    // Declaraciones de objetos
+    // Pon el * como prefijo de los nombre de las variables para declaraciones
+    // de objetos de tipos fuertes 
+    MyClass *myObject1 = nil;  // Tipo fuerte
+    id       myObject2 = nil;  // Tipo débil
+    // %@ es un objeto
+    // 'description' es una convención para mostrar el valor de los objetos
+    NSLog(@"%@ and %@", myObject1, [myObject2 description]); 
+    // imprime => "(null) and (null)"
+    
+    // String
+    NSString *worldString = @"World";
+    NSLog(@"Hello %@!", worldString); // imprime => "Hello World!" 
+    // NSMutableString es una versión mutable del objeto NSString
+    NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];
+    [mutableString appendString:@" World!"];
+    NSLog(@"%@", mutableString); // imprime => "Hello World!"
+    
+    // Literales de caracteres
+    NSNumber *theLetterZNumber = @'Z';
+    char theLetterZ            = [theLetterZNumber charValue]; // o 'Z'
+    NSLog(@"%c", theLetterZ);
+
+    // Literales de enteros
+    NSNumber *fortyTwoNumber = @42;
+    int fortyTwo             = [fortyTwoNumber intValue]; // o 42
+    NSLog(@"%i", fortyTwo);
+    
+    NSNumber *fortyTwoUnsignedNumber = @42U;
+    unsigned int fortyTwoUnsigned    = [fortyTwoUnsignedNumber unsignedIntValue]; // o 42
+    NSLog(@"%u", fortyTwoUnsigned);
+    
+    NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
+    short fortyTwoShort           = [fortyTwoShortNumber shortValue]; // o 42
+    NSLog(@"%hi", fortyTwoShort);
+
+    NSNumber *fortyOneShortNumber   = [NSNumber numberWithShort:41];
+    unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // o 41
+    NSLog(@"%u", fortyOneUnsigned);
+    
+    NSNumber *fortyTwoLongNumber = @42L;
+    long fortyTwoLong            = [fortyTwoLongNumber longValue]; // o 42
+    NSLog(@"%li", fortyTwoLong);
+
+    NSNumber *fiftyThreeLongNumber   = @53L;
+    unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // o 53
+    NSLog(@"%lu", fiftyThreeUnsigned);
+
+    // Literales de punto flotante
+    NSNumber *piFloatNumber = @3.141592654F;
+    float piFloat           = [piFloatNumber floatValue]; // o 3.141592654f
+    NSLog(@"%f", piFloat); // imprime => 3.141592654
+    NSLog(@"%5.2f", piFloat); // imprime => " 3.14"
+    
+    NSNumber *piDoubleNumber = @3.1415926535;
+    double piDouble          = [piDoubleNumber doubleValue]; // o 3.1415926535
+    NSLog(@"%f", piDouble);
+    NSLog(@"%4.2f", piDouble); // imprime => "3.14"
+
+    // NSDecimalNumber es una clase de punto-fijo que es más preciso que float o double    
+    NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
+    NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
+    // NSDecimalNumber no tiene la capacidad de utilizar los operadores estándares 
+    // +, -, * , /, por lo que cuenta con sus propios operadores:    
+    [oneDecNum decimalNumberByAdding:twoDecNum]; 
+    [oneDecNum decimalNumberBySubtracting:twoDecNum];
+    [oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
+    [oneDecNum decimalNumberByDividingBy:twoDecNum];
+    NSLog(@"%@", oneDecNum); // imprime => 10.99 como NSDecimalNumber es inmutable
+
+    // Literales BOOL
+    NSNumber *yesNumber = @YES;
+    NSNumber *noNumber  = @NO;
+    // o
+    BOOL yesBool = YES;
+    BOOL noBool  = NO;
+    NSLog(@"%i", yesBool); // prints => 1
+
+    // Objecto arreglo
+    // Puede contener diferentes tipos de datos, pero deben de ser un objeto de
+    // Objective-C    
+    NSArray *anArray      = @[@1, @2, @3, @4];
+    NSNumber *thirdNumber = anArray[2];
+    NSLog(@"Third number = %@", thirdNumber); // imprime => "Third number = 3"
+    // NSMutableArray es una versión mutable de NSArray, permitiendo el cambio
+    // de los elementos del arreglo y el agrandado o encojimiento del objeto arreglo.
+    // Conveniente, pero no tan eficiente como NSArray en cuanto a rendimiento. 
+    NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
+    [mutableArray addObject:@"Hello"];
+    [mutableArray addObject:@"World"];
+    [mutableArray removeObjectAtIndex:0];
+    NSLog(@"%@", [mutableArray objectAtIndex:0]); // imprime => "World"
+
+    // Objecto Diccionario
+    NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
+    NSObject *valueObject     = aDictionary[@"A Key"];
+    NSLog(@"Object = %@", valueObject); // imprime => "Object = (null)"
+    // NSMutableDictionary también está disponible como un objeto mutable
+    NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
+    [mutableDictionary setObject:@"value1" forKey:@"key1"];
+    [mutableDictionary setObject:@"value2" forKey:@"key2"];
+    [mutableDictionary removeObjectForKey:@"key1"];
+
+    // Objeto de Set
+    NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
+    NSLog(@"%@", set); // imprime => {(Hello, World)} (el orden puede variar)
+    // NSMutableSet también está disponible como un objeto mutable
+    NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
+    [mutableSet addObject:@"Hello"];
+    [mutableSet addObject:@"Hello"];
+    NSLog(@"%@", mutableSet); // prints => {(Hello)}
+
+    ///////////////////////////////////////
+    // Operadores
+    ///////////////////////////////////////
+    
+    // Los operadores funcionan como en el lenguaje C
+    // Por ejemplo:
+    2 + 5; // => 7
+    4.2f + 5.1f; // => 9.3f
+    3 == 2; // => 0 (NO)
+    3 != 2; // => 1 (YES)
+    1 && 1; // => 1 (and lógico)
+    0 || 1; // => 1 (or lógico)
+    ~0x0F; // => 0xF0 (negación bitwise)
+    0x0F & 0xF0; // => 0x00 (AND bitwise)
+    0x01 << 1; // => 0x02 (acarreamiento a la izquierda bitwise (por 1))
+
+    ///////////////////////////////////////
+    // Estructuras de control
+    ///////////////////////////////////////
+
+    // Declaraciones If-Else
+    if (NO)
+    {
+        NSLog(@"I am never run");
+    } else if (0)
+    {
+        NSLog(@"I am also never run");
+    } else
+    {
+        NSLog(@"I print");
+    }
+
+    // Declaración Switch
+    switch (2)
+    {
+        case 0:
+        {
+            NSLog(@"I am never run");
+        } break;
+        case 1:
+        {
+            NSLog(@"I am also never run");
+        } break;
+        default:
+        {
+            NSLog(@"I print");
+        } break;
+    }
+    
+    // Declaración de ciclos While
+    int ii = 0;
+    while (ii < 4)
+    {
+        NSLog(@"%d,", ii++); // ii++ incrementa ii en la misma línea, luego de 
+                             // utilizar su valor
+    } // imprime => "0," 
+      //           "1,"
+      //           "2,"
+      //           "3,"
+
+    // Declaración de ciclos For
+    int jj;
+    for (jj=0; jj < 4; jj++)
+    {
+        NSLog(@"%d,", jj);
+    } // imprime => "0," 
+      //           "1,"
+      //           "2,"
+      //           "3,"
+     
+    // Declaraciones foreach
+    NSArray *values = @[@0, @1, @2, @3];
+    for (NSNumber *value in values)
+    {
+        NSLog(@"%@,", value);
+    } // imprime => "0," 
+      //           "1,"
+      //           "2,"
+      //           "3,"
+
+    // Objeto de ciclos For. Puede ser utilizado con cualquier tipo de objecto de 
+    // Objective-C
+    for (id item in values) { 
+        NSLog(@"%@,", item); 
+    } // imprime => "0," 
+      //           "1,"
+      //           "2,"
+      //           "3,"
+
+    // Declaraciones Try-Catch-Finally
+    @try
+    {
+        // Tus declaraciones aquí
+        @throw [NSException exceptionWithName:@"FileNotFoundException"
+                            reason:@"File Not Found on System" userInfo:nil];
+    } @catch (NSException * e) // utiliza: @catch (id exceptionName) para atrapar 
+                               // todos los objetos
+    {
+        NSLog(@"Exception: %@", e);
+    } @finally
+    {
+        NSLog(@"Finally. Time to clean up.");
+    } // imprime => "Exception: File Not Found on System"
+      //           "Finally. Time to clean up."
+
+    // Los objetos NSError son útiles para argumentos de función para los 
+    // errores de usuario.    
+    NSError *error = [NSError errorWithDomain:@"Invalid email." code:4 userInfo:nil];
+ 
+    ///////////////////////////////////////
+    // Objetos
+    ///////////////////////////////////////
+    
+    // Crea una instancia de objeto alocando memoria e inicializándola
+    // Un objeto no es completamente funcional hasta que ambos pasos hayan sido
+    // completados
+    MyClass *myObject = [[MyClass alloc] init];
+        
+    // El modelo de programación orientada a objetos de Objective-C es basada en
+    // el envío de mensajes a instancias de objetos
+    // En Objective-C no se llama a un método; se envía un mensaje    
+    [myObject instanceMethodWithParameter:@"Steve Jobs"];
+
+    // Limpiar la memoria que se utilizó en el programa    
+    [pool drain];
+
+    // Fin de @autoreleasepool
+    }
+    
+    // Fin del programa
+    return 0;
+}
+
+///////////////////////////////////////
+// Clases y funciones
+///////////////////////////////////////
+
+// Declara tu clase en archivo de encabezado (MyClass.h)
+// Sintaxis de declaración de clase:
+// @interface NombreDeClase : NombreDeClasePadre <ProtocolosImplementados>
+// {
+//    type nombre; <= declaraciones de variables;
+// }
+// @property tipo nombre; <= declaración de propiedades
+// -/+ (tipo) Declaración de método; <= Declaración de método
+// @end
+@interface MyClass : NSObject <MyProtocol> // NSObject es la clase de objeto 
+                                           // base de  Objective-C.
+{
+    // Declaraciones de variables de instancia (puede existir en el archivo de 
+    // interfaz o de implementación)    
+    int count; // Acceso protegido por defecto. 
+    @private id data; // Acceso privado (Más conveniente de declarar en el 
+                      // archivo de implementación)
+    NSString *name; 
+}
+// Notación conveneinte para acceso público de las variables para generar un 
+// método setter
+// Por defecto, el nombre del método setter 'set' seguido del nombre de 
+// variable @property
+@property int propInt; // Nombre del método 'setter' = 'setPropInt'
+@property (copy) id copyId; // (copy) => Copia el objeto durante la asignación
+// (readonly) => No se le puede asignar un valor fuera de @interface
+@property (readonly) NSString *roString; // utiliza @synthesize en 
+                                         // @implementation para crear un accesor
+// Puedes personalizar el nombre del getter y del setter en lugar de utilizar
+// el nombre por defecto "set".
+@property (getter=lengthGet, setter=lengthSet:) int length;
+ 
+// Métodos
++/- (return type)methodSignature:(Parameter Type *)parameterName;
+
+// + Para métodos de clase:
++ (NSString *)classMethod;
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight;
+
+// - Para métodos de instancia:
+- (NSString *)instanceMethodWithParameter:(NSString *)string;
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
+
+// Métodos de constructor con argumentos
+- (id)initWithDistance:(int)defaultDistance;
+// Los nombres de los métodos de Objective-C son muy descriptivos. 
+// Siempre nombra los métodos de acuerdo con sus argumentos
+
+@end // Define el final de la interfaz
+
+
+// Para acceder a las variables públicas desde el archivo de implementación, 
+// @property genera un método setter automáticamente. El nombre del método 
+// es 'set' seguido de un nombre de variable @property:
+MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia del objeto MyClass 
+[myClass setCount:10]; 
+NSLog(@"%d", [myClass count]); // imprime => 10
+// O utilizando los métodos getter y setter personalizados en @interface:
+[myClass lengthSet:32];
+NSLog(@"%i", [myClass lengthGet]); // imprime => 32
+// Por conveniencia, puedes utilizar la notación de punto para asignar y 
+// acceder a las variables de una instancia de objeto.
+myClass.count = 45;
+NSLog(@"%i", myClass.count); // imprime => 45
+
+// Llama a métodos de clase:
+NSString *classMethodString = [MyClass classMethod];
+MyClass *classFromName = [MyClass myClassFromName:@"Hello"];
+
+// Llama a métodos de instancia:
+MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia de objeto Myclass
+NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Hello"];
+
+// Selectors
+// Una forma dinámica de representar métodos. Utilizados para llamar métodos 
+// de una clase, pasar métodos a través de funciones para avisar a otras clases 
+// para que lo llamen, y para guardar métodos como una variable.
+// SEL es el tipo de dato. @selector() devuelve un selector del nombre de 
+// método proveído methodAparameterAsString:andAParameterAsNumber: es un nombre 
+// para un método en MyClass
+SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:); 
+if ([myClass respondsToSelector:selectorVar]) { // Revisa si la clase contiene el método
+    // Debe de poner todos los argumentos de método en un solo objeto para mandar una 
+    // función performSelector.    
+    NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
+    [myClass performSelector:selectorVar withObject:arguments]; // Calls the method
+} else {
+    // NSStringFromSelector() devuelve un NSString del nombre de método de un selector dado
+    NSLog(@"MyClass does not have method: %@", NSStringFromSelector(selectedVar));
+}
+
+// Implementa los métodos de un archivo de implementación (MyClass.m):
+@implementation MyClass {
+    long distance; // Variable de instancia de acceso privado
+    NSNumber height;
+}
+
+// Para acceder a una variable pública del archivo de interfaz, utiliza '_' seguido del
+// nombre de la variable:
+_count = 5; // Hace referencia a "int count" de la interfaz de MyClass
+// Accede variables definidas en el archivo de implementación:
+distance = 18; // Hace referencia a "long distance" de la implementación de MyClass
+// Para utilizar una variable @property en el archivo de implementación, utiliza 
+// @synthesize para crear una variable de acceso:
+@synthesize roString = _roString; // _roString ahora está disponible en @implementation
+
+// Lamado antes de llamar algún método o instanciar cualquier objeto
++ (void)initialize 
+{
+    if (self == [MyClass class]) {
+        distance = 0;
+    }
+}
+
+// Contraparte para inicializar un método. Llamado cuando el contador de referencias
+// del objeto es cero
+- (void)dealloc
+{
+    [height release]; // Si no utilizas ARC, asegúrate de liberar las variables de 
+                      // objeto de las clases
+    [super dealloc];  // y llama el método dealloc de la clase padre
+}
+
+// Los constructores son una manera de crear instancias de una clase
+// Este es el constructor por defecto que es llamado cuando el objeto es inicializado.
+- (id)init
+{
+    if ((self = [super init])) // 'super' es utilizado para acceder a los 
+                               // métodos de la clase padre.
+    {
+        self.count = 1; // 'self' es utilizado para que el objeto se llame a sí mismo.
+    }
+    return self;
+}
+// Se pueden crear constructores que contiene argumentos
+- (id)initWithDistance:(int)defaultDistance 
+{
+    distance = defaultDistance;
+    return self;
+}
+
++ (NSString *)classMethod
+{
+    return @"Some string";
+}
+
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight 
+{
+    height = defaultHeight;
+    return [[self alloc] init];
+}
+
+- (NSString *)instanceMethodWithParameter:(NSString *)string
+{
+    return @"New string";
+}
+
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
+{
+    return @42;
+}
+
+// Objective-C no tiene declaraciones de métodos privados, pero pueden ser simulados.
+// Para simular un método privado, crea un método en @implementation pero no en @interface.
+- (NSNumber *)secretPrivateMethod {
+    return @72;
+}
+[self secretPrivateMethod]; // Calls private method
+
+// Métodos declarados dentro de MyProtocol
+- (void)myProtocolMethod
+{
+    // statements
+}
+
+@end // Declara el final de la implementación
+
+///////////////////////////////////////
+// Categorías
+///////////////////////////////////////
+// Una categoría es un grupo de métodos diseñados para extender una clase. 
+// Te permiten agregar nuevos métodos a una clase existente por propósitos 
+// de organización. Éstos no deben de serconfundidos con subclases. 
+// Las subclases existen para CAMBIAR la funcionalidad de un objeto mientras 
+// que las categoríasle AGREGAN funcionalidad de un objeto.
+// Las categorías te permiten:
+// -- Agregar métodos a una clase existente por propósitos de oganización.
+// -- Extender clases de objetos de Objective-C (ejemplo: NSString) para 
+//    agregar tus propios métodos.
+// -- Agregar la habilidad de crear métodos protegidos y privados para las clases.
+// NOTA: No sobreescribas los métodos de las clases base en una categoría 
+// aunque tengas la habilidad de poder hacerlo. Sobreescribir métodos puede 
+// causar errores en la compilación después entre diferentes categorías y 
+// puede arruinar el propósito de las categorías de solo AGREGAR funcionalidad. 
+// Utiliza subclass para sobreescribir métodos.
+
+// Aquí una clase base simple, Car.
+@interface Car : NSObject
+
+@property NSString *make;
+@property NSString *color;
+
+- (void)turnOn;
+- (void)accelerate;
+
+@end
+
+// Y la implementación de la clase simple, Car
+#import "Car.h"
+
+@implementation Car
+
+@synthesize make = _make;
+@synthesize color = _color;
+
+- (void)turnOn {
+    NSLog(@"Car is on.");
+}
+- (void)accelerate {
+    NSLog(@"Accelerating.");
+}
+
+@end
+
+// Ahora, si quisieramos crear un objeto Truck (Camión), crearíamos una 
+// subclase de Car (Carro) como si le cambiaramos de funcionalidad de Car 
+// para que se comporte como un camión. Pero digamos que únicamente queremos 
+// agregar funcionalidad al Car (Carro) existente. Un buen ejemplo sería 
+// limpiar el carro. Así que crearíamos una cateog®iea para agregar los 
+// métodos de limpieza: 
+// Archivo @interface: Car+Clean.h (NombreBaseDeClase+NombreDeCategoria.h)
+#import "Car.h" // Asegúrate de improtar la clase que deseas extener.
+
+@interface Car (Clean) // El nombre de la categoría está dentro de (), 
+                       // seguido del nombre de la clase base
+
+- (void)washWindows; // Nombres de los nuevos métodos que le agregamos 
+                     // a nuestro objeto Car
+- (void)wax;
+
+@end
+
+// Archivo @implementation: Car+Clean.m (NombreBaseDeClase+NombreDeCategoria.m)
+#import "Car+Clean.h" // Importa el archivo de @interface de la categoría Clean
+
+@implementation Car (Clean)
+
+- (void)washWindows {
+    NSLog(@"Windows washed.");
+}
+- (void)wax {
+    NSLog(@"Waxed.");
+}
+
+@end 
+
+// Cualquier instancia del objeto Car tiene la habilidad de utilizar una 
+// categoría. Todo lo que necesitan es importarlo: 
+#import "Car+Clean.h" // Importa todas las diferentes categorías que 
+                      // necesites utilizar
+#import "Car.h" // También debes de importar la clase base para su 
+                // funcionalidad original 
+
+int main (int argc, const char * argv[]) {
+    @autoreleasepool {
+        Car *mustang = [[Car alloc] init];
+        mustang.color = @"Red";
+        mustang.make = @"Ford";
+
+        [mustang turnOn]; // Utiliza métodos de la clase base Car.
+        [mustang washWindows]; // Utiliza métodos de la categoría Clean de Car.
+    }
+    return 0; 
+}
+
+// Objective-C no tiene declaraciones para métodos protegidos, pero los puedes
+// simular. Crea una categoría conteniendo todos los métodos protegidos, 
+// luego importa ÚNICAMENTE al archivo @implementation de una clase que 
+// pertenece a la clase Car.
+@interface Car (Protected) // Nombrando la categoría 'Protected' para 
+                           // recordar que los métodos están protegidos
+    
+- (void)lockCar; // Los métodos enlistados aquí solo puedens ser creados 
+                 // por objetos Car
+
+@end
+// Para utilizar los métodos protegidos, importa la categoría, 
+// luego implementa sus métodos:
+#import "Car+Protected.h" // Recuerda, importa únicamente el archivo 
+                          // de @implementation
+
+@implementation Car 
+
+- (void)lockCar {
+    NSLog(@"Car locked."); // Las instancias de Car no puede utilizar 
+                           // lockCar porque no se encuentra en @interface
+}
+
+@end
+
+///////////////////////////////////////
+// Extensiones
+///////////////////////////////////////
+// Las Extensions te permiten sobreescribir atributos de propiedades de 
+// acceso público y métodos de un @interface
+// Archivo @interface: Shape.h
+@interface Shape : NSObject 
+
+@property (readonly) NSNumber *numOfSides;
+
+- (int)getNumOfSides;
+
+@end
+// Puedes sobreescribir la variable numOfSides o el métodos getNumOfSlides 
+// para modificarlos con una extensión:
+// Archivo @implementation: Shape.m
+#import "Shape.h"
+// Las extensiones se encuentran en el mismo archivo que el archivo 
+// de @implementation
+@interface Shape () // () después del nombre de la clase base declara 
+                    // una extensión
+
+@property (copy) NSNumber *numOfSides; // Hacer numOfSlides copy en lugar
+                                       // de readonly.
+-(NSNumber)getNumOfSides; // Hacer que getNumOfSides devuelva un NSNumber 
+                          // en lugar de un int.
+-(void)privateMethod; // También puedes crear una nuevos métodos privados 
+                      // dentro de las extensiones
+
+@end
+// @implementation principal:
+@implementation Shape 
+
+@synthesize numOfSides = _numOfSides;
+
+-(NSNumber)getNumOfSides { // Todas las declaraciones dentro de extensions 
+                           // deben de ser dentro de @implementation
+    return _numOfSides;
+}
+-(void)privateMethod {
+    NSLog(@"Private method created by extension. Shape instances cannot call me.");
+}
+
+@end
+
+///////////////////////////////////////
+// Protocolos
+///////////////////////////////////////
+// Un protocolo declara métodos que pueden ser implementados por cualquier otra
+// clase. Los protocolos no son clases. Simplementen define una interfaz que 
+// otros objetos deben de implementar.
+// Archivo @protocol: "CarUtilities.h"
+@protocol CarUtilities <NSObject> // <NSObject> => Nombre de otro protocolo 
+                                  // que se incluye en éste
+    @property BOOL engineOn; // La clase que lo adopta debe de utilizar 
+                            // @synthesize para todas las @properties definidas 
+    - (void)turnOnEngine; // y todos los métodos definidos
+@end
+// A continuación una clase ejemplo que implementa el protcolo
+#import "CarUtilities.h" // Importar el archivo @protocol.
+
+@interface Car : NSObject <CarUtilities> // El nombre del protocolo dentro de <>
+    // No necesitas los nombres de @property o métodos aquí para CarUtilities.
+    // Estos solo es requerido por @implementation.
+- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // También Puedes 
+                                                          // utilizar protocolos 
+                                                          // como datos.
+@end
+// El @implementation necesita que se implementen @properties y métodos 
+// del protocolo.
+@implementation Car : NSObject <CarUtilities>
+
+@synthesize engineOn = _engineOn; // Crear una declaración @synthesize para el 
+                                  // @property engineOn.
+
+- (void)turnOnEngine { // Implementa turnOnEngine como quieras. Los 
+                       // protocolos no definen
+    _engineOn = YES;   // cómo implementas un método, con tal de que lo implementes.
+}
+// Puedes utilizar un protocolo como data mientras sepas quee métodos y variables 
+// tiene implementado.
+- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind { 
+    [objectOfSomeKind engineOn]; // Tienes acceso a las variables 
+    [objectOfSomeKind turnOnEngine]; // y los métodos del objeto
+    [objectOfSomeKind engineOn]; // Puede o no puede ser YES. La clase lo 
+                                 // implementa como se quiera.
+}
+
+@end
+// Las instancias de Car ahora tienen acceso al protocolo.
+Car *carInstance = [[Car alloc] init];
+[carInstance setEngineOn:NO];
+[carInstance turnOnEngine];
+if ([carInstance engineOn]) {
+    NSLog(@"Car engine is on."); // imprime => "Car engine is on."
+}
+// Asegúrate de revisar si un objeto de tipo 'id' implementa un protocolo antes
+// de llamar a sus métodos:
+if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
+    NSLog(@"This does not run as the MyClass class does not implement the CarUtilities protocol.");
+} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) {
+    NSLog(@"This does run as the Car class implements the CarUtilities protocol.");
+}
+// Las categorías también pueden implementar protcolos: @interface Car 
+// (CarCategory) <CarUtilities>
+// Puedes implementar varios protocolos: 
+// @interface Car : NSObject <CarUtilities, CarCleaning>
+// NOTA: Si dos o más protocolos dependen entre sí, asegúrate de declararlos 
+// de manera adelantada:
+#import "Brother.h"
+
+@protocol Brother; // Declaración adelantada. Sin ésto, el compilador 
+                   // tira un error.
+
+@protocol Sister <NSObject>
+
+- (void)beNiceToBrother:(id <Brother>)brother;
+
+@end
+
+// Ver si el problema es que Sister depende de Brother, 
+// y Brother dependa de Sister.
+#import "Sister.h"
+
+@protocol Sister; // Estas líneas detienen la recursión, resolviendo el problema.
+
+@protocol Brother <NSObject>
+ 
+- (void)beNiceToSister:(id <Sister>)sister;
+
+@end
+
+
+///////////////////////////////////////
+// Bloques
+///////////////////////////////////////
+// Los bloques son declaraciones de código, tal como una función, pueden 
+// ser utilizados como data.
+// A continuación un bloque simple con un argumento entero que devuelve 
+// un el argumento más 4.
+int (^addUp)(int n); // Declarar una variable para almacenar el bloque.
+void (^noParameterBlockVar)(void); // Ejemplo de una declaración de variable 
+                                   // de bloque sin argumentos.
+// Los bloques tienen acceso a variables del mismo ámbito. Pero las variables 
+// son solo readonly y el valor pasado al bloque es el valor de la variable 
+// cuando el bloque es creado.
+int outsideVar = 17; // Si modificamos outsideVar después de declarar addUp,
+                     // outsideVar AÚN es 17.
+__block long mutableVar = 3; // __block hace que las variables se puedan 
+                             // escribir en bloques.
+addUp = ^(int n) { // Remueve (int n) para tener un bloque que no recibe 
+                   // ningún parámetro
+    NSLog(@"You may have as many lines in a block as you would like.");
+    NSSet *blockSet; // También puedes declarar variables locales.
+    mutableVar = 32; // Asignar un nuevo valor a la variable __block.
+    return n + outsideVar; // Declaraciones de retorno son opcionales.
+}
+int addUp = add(10 + 16); // Llama al bloque de código con argumentos.
+// Los bloques son usualmente utilizados como argumentos a funciones que 
+// son llamados más adelante o para callbacks.
+@implementation BlockExample : NSObject 
+ 
+ - (void)runBlock:(void (^)(NSString))block {
+    NSLog(@"Block argument returns nothing and takes in a NSString object.");
+    block(@"Argument given to block to execute."); // Calling block.
+ }
+
+ @end
+
+
+///////////////////////////////////////
+// Manejo de memoria
+///////////////////////////////////////
+/* 
+Para cada objeto utilizado en una aplicación, la memoria debe de ser alocada 
+para ese objeto. Cuando la aplicación termina de utilizar ese objeto, la 
+memoria debe de ser desalocada para asegurar la  eficiencia de la aplicación.
+Objetive-C no utiliza garbage collection, y en lugar de eso utiliza conteos 
+de referencias. Mientras haya al menos una referencia del objeto (también 
+conocido como tener un objeto de adueñado), entonces el objeto estará 
+disponible para su uso.
+
+Cuando una instancia es dueña un objeto, su contador de referencia incrementa
+por uno. Cuando el objeto es liberado, el contador de referencia decrementa uno. 
+Cuando el conteo de referencia es cero, el objeto es removido de la memoria.
+
+Con todas las interacciones de los objetos, sigue el patrón de:
+(1) Crear e lobjeto, (2) utiliza el objeto, (3) libera el objeto de la memoria.
+*/
+
+MyClass *classVar = [MyClass alloc]; // 'alloc' asigna uno al conteo de 
+                                     // referencias de classVar. Devuelve un 
+                                     // puntero al objeto
+[classVar release]; // Decrementa el conteo de referencias de classVar's
+// 'retain'
+// 'retain' adueña la instancia de objeto existente e incrementa el conteo de 
+// referencia por uno. Devuelve un puntero al objeto.
+MyClass *newVar = [classVar retain]; // Si classVar es liberado, el objeto 
+                                     // aún se queda en memoria porque newVar
+                                     // es el dueño.
+[classVar autorelease]; // Remueve el adueñamiento de un objeto al final del 
+                        // bloque @autoreleasepool. Devuelve un puntero al objeto.
+
+// @property puede utilizar 'retain' y 'assign' también para pequeñas 
+// definiciones convenientes
+@property (retain) MyClass *instance; // Libera el valor viejo y retiene 
+                                      // uno nuevo (referencia fuerte)
+@property (assign) NSSet *set; // Apunta a un nuevo valor sin retener/liberar 
+                               // una referencia vieja (débil)
+
+// Conteo Automático de Referencias (ARC)
+// Debido a que el manejo de memoria puede ser un dolor, en Xcode 4.2 y iOS 4 
+// se introdujo el Conteo Automático de Referencias (ARC).
+// ARC es una funcionalidad del compilador que agrega retain, release y
+// autorealase automáticamente, así que al
+// utilizar ARC, no se debe de utilizar retain, release o autorelease.
+MyClass *arcMyClass = [[MyClass alloc] init]; 
+// ... código utilizando arcMyClass
+// Sin ARC, necesitarás llamar: [arcMyClass release] luego de terminar de 
+// utilizar arcMyClass. Pero con ARC, no hay necesidad. Insertará 
+// automáticamente la declaración de liberación.
+
+// Mientras que para los atributos de @property 'assign' y 'retain', con ARC 
+// utilizarás 'weak' y 'strong'
+@property (weak) MyClass *weakVar; // 'weak' no adueña el objeto. El conteo de 
+                                   // referencias de la instancia original
+// es fijado a ceor, weakVar automáticamente recibe el valor de  nil para 
+// evitar cualquier 'crashing'.
+@property (strong) MyClass *strongVar; // 'strong' se adueña del objeto. 
+                                       // Asegura que el objeto se quede en memoria.
+
+// Para variables regulares (no variables de @property), utiliza lo siguiente:
+__strong NSString *strongString; // Por defecto. La variables de retenida en 
+                                 // memoria hasta que se salga del ámbito.
+__weak NSSet *weakSet; // Referencia débil a un objeto existente. Cuando el 
+                       // objeto existente es liberado, weakSet le es asginado
+                       // un valor nil
+__unsafe_unretained NSArray *unsafeArray; // Como __weak, pero unsafeArray no 
+                                          // es asginado a nil cuando el objeto
+                                          // existente es liberado.
+
+```
+## Lecturas sugeridas
+
+[Wikipedia Objective-C](http://es.wikipedia.org/wiki/Objective-C)
+
+[Programming with Objective-C. Libro PDF de Apple](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
+
+[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
diff --git a/es-es/php-composer-es.html.markdown b/es-es/php-composer-es.html.markdown
new file mode 100644
index 00000000..3add3e31
--- /dev/null
+++ b/es-es/php-composer-es.html.markdown
@@ -0,0 +1,176 @@
+---
+category: tool
+tool: composer
+contributors:
+    - ["Brett Taylor", "https://github.com/glutnix"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: LearnComposer-es.sh
+---
+
+[Composer](https://getcomposer.org/) es una herramienta para manejar las dependencias en PHP. Nos permite declarar las librerías de las cuales el proyecto depende y las maneja automáticamente (instala/actualiza) por ti.
+
+# Instalando
+
+```sh
+# Instala el binario 'composer.phar' en el directorio actual
+curl -sS https://getcomposer.org/installer | php
+# Si utiliza este método, tendrá que invocar a 'composer' de esta manera:
+php composer.phar about
+
+# Instala el binario en ~/bin/composer
+# Nota: asegúrese de que ~/bin está en la variable de entorno PATH del shell
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Los usuarios de Windows deben seguir las [instrucciones de instalación de Windows (EN)](https://getcomposer.org/doc/00-intro.md#installation-windows)
+
+## Confirmación de la instalación
+
+```sh
+# Comprobar la versión y lista las opciones
+composer
+
+# Obtener más ayuda para las opciones
+composer help require
+
+# Comprueba si composer es capaz hacer las cosas que necesita y si está actualizado
+composer diagnose
+composer diag # versión corta
+
+# Actualiza el binario composer a la última versión
+composer self-update
+composer self # versión corta
+```
+
+# Uso
+
+Composer almacena sus dependencias del proyecto en `composer.json`. Usted puede editar este archivo, pero lo mejor es dejar que composer lo gestione por usted.
+
+```sh
+# Crear un nuevo proyecto en la carpeta actual
+composer init
+# Este corre un cuestionario interactivo que le pide detalles sobre su proyecto. 
+# Dejándolos en blanco está bien a menos que usted está haciendo otros proyectos que dependen de éste.
+
+# Si un archivo 'composer.json' ya existe, descargar las dependencias
+composer install
+
+# Para descargar solo las dependencias de producción, es decir, excluyendo las 
+# dependencias de desarrollo
+composer install --no-dev
+
+# Añadir una dependencia de producción a este proyecto
+composer require guzzlehttp/guzzle
+# Composer buscará cuál es la última versión de guzzlehttp/Guzzle, lo descarga,
+# y finalmente añade la nueva dependencia al campo requerido en 'composer.json'.
+
+composer require guzzlehttp/guzzle:6.0.*
+# Composer descargará la versión más reciente que coincida con el patrón 
+# (ej 6.0.2) y añade la dependencia al campo requerido en 'composer.json'.
+
+composer require --dev phpunit/phpunit:~4.5.0
+# Se requerirá como una dependencia de desarrollo. Se usará la última 
+# versión >= 4.5.0 y < 4.6.0
+
+composer require-dev phpunit/phpunit:^4.5.0
+# Se requerirá como una dependencia de desarrollo. Se usará la última versión >= 4.5.0 y <  5.0
+
+# Para obtener más información sobre las coincidencias de versiones de Composer, 
+ver [La Documentación de Composer\'s Sobre Versiones (EN)](https://getcomposer.org/doc/articles/versions.md)
+
+# Para ver qué opciones están disponibles para instalar y los paquetes instalados actualmente  
+composer show
+
+# Para ver qué paquetes están instalados actualmente
+composer show --installed
+
+# Para encontrar un paquete con 'mailgun' en su nombre o descripción
+composer search mailgun
+```
+
+[Packagist.org (EN)](https://packagist.org/) es el repositorio principal de paquetes de Composer. Busca allí para paquetes existentes de terceros.
+
+## `composer.json` vs `composer.lock`
+
+El archivo `composer.json` almacena las preferencias de versión flotantes de su proyecto para cada dependencia, junto con otra información.
+
+El archivo `composer.lock` almacena exactamente cuál es la versión que ha descargado para cada dependencia. Nunca editar este archivo.
+
+Si se incluye el archivo `composer.lock` en su repositorio git, todos los desarrolladores instalarán la versión utilizada actualmente de la dependencia. Incluso cuando se libera una nueva versión de una dependencia, Composer continuará para descargar la versión grabada en el archivo '.lock'.
+
+```sh
+# Si desea actualizar todas las dependencias a su versión más reciente aún que coincidan con sus preferencias versión
+composer update
+
+# Si desea la nueva versión de una dependencia particular:
+composer update phpunit/phpunit
+
+# Si desea migrar la preferencia de un paquete a una versión más reciente, puede que tenga que quitar primero el paquete de más antiguo y sus dependencias.
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+
+```
+
+## Autocargador
+
+Composer crea una clase de cargador automático que puede requerir su aplicación. Se puede hacer instancias de clases a través de su espacio de nombres.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### PSR-4 Autocargador
+
+Usted puede añadir sus propios espacios de nombres para el cargador automático.
+
+En `composer.json`, añadir el campo 'autoload':
+
+```json
+{
+  "autoload": {
+    "psr-4": {"Acme\\": "src/"}
+  }
+}
+```
+Esto le indicará al cargador automático que busque cualquier cosa en el espacio de nombres `\Acme\` dentro de la carpeta src`.
+
+También puedes usar [usar PSR-0, un mapa de clase o simplemente una lista de archivos para incluir (EN)](https://getcomposer.org/doc/04-schema.md#autoload). También está el campo `autoload-dev` para espacios de nombres de sólo desarrollo.
+
+Al añadir o modificar la clave de carga automática, tendrá que reconstruir el cargador automático:
+
+```sh
+composer dump-autoload
+composer dump # shorthand
+
+# Optimiza los paquetes PSR0 y PSR4 a ser cargados con classmaps también. Es lento para correr, pero mejora el rendimiento en producción.
+composer dump-autoload --optimize --no-dev
+```
+
+# El Cache de Composer
+
+```sh
+# Composer retendrá los paquetes descargados para su uso en el futuro. Puede removerlos con:
+composer clear-cache
+```
+
+# Solución de problemas
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Temas (todavía) no cubiertos en este tutorial
+
+* Crear y distribuir tus propios paquetes en Packagist.org o en otra parte
+* Pre- y post- script: ejecutar tareas cuando ciertos eventos tienen lugar composer
+
+### Referencias
+
+* [Composer - Dependency Manager for PHP (EN)](https://getcomposer.org/)
+* [Packagist.org (EN)](https://packagist.org/)
\ No newline at end of file
diff --git a/es-es/powershell-es.html.markdown b/es-es/powershell-es.html.markdown
new file mode 100644
index 00000000..9eb35967
--- /dev/null
+++ b/es-es/powershell-es.html.markdown
@@ -0,0 +1,329 @@
+---
+category: tool
+tool: powershell
+contributors:
+    - ["Wouter Van Schandevijl", "https://github.com/laoujin"]
+translators:
+    - ["Alexander Salamanca", "https://github.com/alexitosrv"]
+filename: LearnPowershell-es.ps1
+lang: es-es
+---
+
+PowerShell es el lenguaje de automatización y gestión de configuraciones de Windows hecho por Microsoft basado en .NET Framework. Desde Windows 7 en adelante, esos sistemas operativos incluyen un intérprete de PowerShell.
+Casi todos los ejemplos a continuación pueden ser parte de un script o ejecutados directamente en la consola de PowerShell.
+
+Una diferencia clave con respecto a Bash es que en PowerShell casi todo son manipulaciones de objetos en vez de análisis sobre flujos de texto plano.
+
+[Leer más acá.](https://technet.microsoft.com/en-us/library/bb978526.aspx) (EN)
+
+Si no está seguro sobre el ambiente de ejecución en su sistema:
+
+```powershell
+Get-ExecutionPolicy -List
+Set-ExecutionPolicy AllSigned
+# Otras opciones de políticas de ejecución son:
+# - Restricted: Los scripts no correrán.
+# - RemoteSigned: Los scripts que se hayan descargado sólo correrán si han sido firmados por un editor de confianza. 
+# - AllSigned: Los scripts requieren ser firmados por un editor de confianza.
+# - Unrestricted: Ejecuta cualquier script.
+help about_Execution_Policies # para obtener más ayuda sobre políticas de ejecución.
+
+# Versión instalada de PowerShell:
+$PSVersionTable
+```
+
+Para obtener ayuda:
+
+```
+# Si necesita encontrar algún comando
+Get-Command about_* # tiene por abreviación (o alias): gcm
+Get-Command -Verb Add # lista todos los comandos que tienen por verbo 'Add'
+Get-Alias ps
+Get-Alias -Definition Get-Process
+
+Get-Help ps | less # alias: help
+ps | Get-Member # alias: gm
+
+Show-Command Get-EventLog # Muestra un formulario para llenar los parámetros del comando Get-EventLog
+
+Update-Help # Actualiza la ayuda (debe ser ejecutado en una consola elevada como admin)
+```
+
+Acá inicia el tutorial:
+
+```
+# Como ya lo notó, los comentarios empiezan con #
+
+# Ejemplo de un simple hola mundo:
+echo Hola mundo!
+# echo es el alias del comando Write-Output (a los comandos también se les dice cmdlets)
+# La mayoría de los cmdlets y funciones siguen la convención de llamarse de la forma: Verbo-Sustantivo
+
+# Cada comando inicia en una nueva línea, o después de un punto y coma:
+echo 'Esta es la primer línea'; echo 'Esta es la segunda'
+
+# La declaración de una variable se ve así:
+$unaCadena ="Algún texto"
+# O así:
+$unNumero = 5 -as [double] 
+$unaLista = 1,2,3,4,5
+$unaCadena = $unaLista -join '--' # también existe el parámetro -split 
+$unaTablaHash = @{nom1='val1'; nom2='val2'}
+
+# Uso de variables:
+echo $unaCadena
+echo "Interpolación: $unaCadena"
+echo "`$unaCadena tiene longitud de $($unaCadena.Length)"  
+echo '$unaCadena'
+echo @"
+Esta es una Here-String
+$otraVariable
+"@
+# Note que una ' (comilla simple) no expande las variables!
+# Las Here-Strings también funcionan con comilla simple
+
+# Variables Automáticas:
+# Hay algunas variables previamente definidas en el ambiente que le pueden servir, tales como
+echo "Booleanos: $TRUE y $FALSE"
+echo "Valor vacío: $NULL"
+echo "Valor de retorno del último programa: $?"
+echo "Código de salida del último programa en Windows: $LastExitCode"
+echo "El último token en la última línea de la sesión activa: $$"
+echo "El primer token: $^"
+echo "PID del script: $PID"
+echo "Ruta completa del directorio dónde está el script actual: $PSScriptRoot"
+echo 'Ruta completa de script actual: ' + $MyInvocation.MyCommand.Path
+echo "Ruta completa de directorio actual: $Pwd"
+echo "Argumentos pasados a la invocación de una función, script o bloque de código: $PSBoundParameters"
+echo "Argumentos no predefinidos: $($Args -join ', ')."
+# Para saber más sobre variables automáticas: `help about_Automatic_Variables`
+
+# Para enlazar otro archivo (operador punto)
+. .\otroNombreDeScript.ps1
+
+
+### Control de Flujo
+# Tenemos la estructura de if como es usual:
+if ($Edad -is [string]) {
+	echo 'Pero... si $Edad no puede ser una cadena de texto!'
+} elseif ($Edad -lt 12 -and $Edad -gt 0) {
+	echo 'Niño (Menor de 12. Mayor que 0)'
+} else {
+	echo 'Adulto'
+}
+
+# Sentencias switch de PS son más poderosas comparadas con otros lenguajes
+$val = "20"
+switch($val) {
+  { $_ -eq 42 }           { "La respuesta es 42"; break }
+  '20'                    { "Exactamente 20"; break }
+  { $_ -like 's*' }       { "No distingue entre mayúsculas/minúsculas"; break }
+  { $_ -clike 's*'}       { "clike, ceq, cne para ser diferenciar el caso entre mayúsculas/minúsculas"; break }
+  { $_ -notmatch '^.*$'}  { "Emparejamiento de expresiones regulares. cnotmatch, cnotlike, ..."; break }
+  { 'x' -contains 'x'}    { "FALSO! -contains es para listas!"; break }
+  default                 { "Otros" }
+}
+
+# El for clásico
+for($i = 1; $i -le 10; $i++) {
+  "Número de ciclo $i"
+}
+# O más corto
+1..10 | % { "Número de ciclo $_" }
+
+# PowerShell también incluye
+foreach ($var in 'valor1','valor2','valor3') { echo $var }
+# while () {}
+# do {} while ()
+# do {} until ()
+
+# Manejo de excepciones
+try {} catch {} finally {}
+try {} catch [System.NullReferenceException] {
+	echo $_.Exception | Format-List -Force
+}
+
+
+### Proveedores
+# Lista de archivos y directorios en la ubicación actual
+ls # o el alias `dir`
+cd ~ # ir al directorio principal del usuario
+
+Get-Alias ls # -> Get-ChildItem
+# ¿¡Eh!? Estos cmdlets tienen nombres genéricos porque a diferencia de otros lenguajes de scripting,
+# PowerShell no opera únicamente en el directorio actual.
+cd HKCU: # se dirige a la rama HKEY_CURRENT_USER del registro de Windows
+
+# Para hacer un listado de todos los proveedores disponibles
+Get-PSProvider
+
+
+### Tuberías
+# Los Cmdlets tienen parámetros que controlan su ejecución:
+Get-ChildItem -Filter *.txt -Name # Se obtiene sólo el nombre de todos los archivos txt
+# Sólo se necesita escribir caracteres de un parámetro hasta que deja de ser ambiguo
+ls -fi *.txt -n # -f no se puede porque también existe -Force 
+# Use `Get-Help Get-ChildItem -Full` para un tratado más completo
+
+# Los results del cmdlet anterior se le pueden pasar como entrada al siguiente.
+# `$_` representa el objeto actual en el objeto de tubería.
+ls | Where-Object { $_.Name -match 'c' } | Export-CSV exportado.txt
+ls | ? { $_.Name -match 'c' } | ConvertTo-HTML | Out-File exportado.html
+
+# Si se confunde con la tubería use `Get-Member` para revisar
+# los métodos y propiedades de los objetos de la tubería:
+ls | Get-Member
+Get-Date | gm
+
+# ` es el caracter de continuación de línea. O termine la línea con un |
+Get-Process | Sort-Object ID -Descending | Select-Object -First 10 Name,ID,VM `
+	| Stop-Process -WhatIf
+
+Get-EventLog Application -After (Get-Date).AddHours(-2) | Format-List
+
+# Use % como una abreviación de ForEach-Object
+(a,b,c) | ForEach-Object `
+	-Begin { "Iniciando"; $counter = 0 } `
+	-Process { "Procesando $_"; $counter++ } `
+	-End { "Terminando: $counter" }
+
+# El siguiente comando ps (alias de Get-Process) devuelve una tabla con 3 columnas
+# La tercera columan es el valor de memoria virtual en MB y usando 2 dígitos decimales
+# Las columnas calculadas pueden escribirse más extensamente como:
+# `@{name='lbl';expression={$_}`
+ps | Format-Table ID,Name,@{n='VM(MB)';e={'{0:n2}' -f ($_.VM / 1MB)}} -autoSize
+
+
+### Funciones
+# El atributo [string] es opcional.
+function foo([string]$nombre) {
+	echo "Hey $nombre, aquí tiene una función"
+}
+
+# Llamando una función
+foo "Diga mi nombre"
+
+# Funciones con parámetros nombrados, atributos de parámetros y documentación analizable
+<#
+.SYNOPSIS
+Establecer un nuevo sitio web
+.DESCRIPTION
+Crea todo lo que su sitio necesite
+.PARAMETER siteName
+El nombre para el nuevo sitio web
+.EXAMPLE
+Crear-SitioWeb -Nombre SitioBonito -Po 5000
+Crear-SitioWeb SiteWithDefaultPort
+Crear-SitioWeb nombreSitio 2000 # ERROR! No se pudo validar arguemento de puerto
+('nombre1','nombre2') | Crear-SitioWeb -Verbose
+#>
+function Crear-SitioWeb() {
+	[CmdletBinding()]
+	param (
+		[Parameter(ValueFromPipeline=$true, Mandatory=$true)]
+		[Alias('nombre')]
+		[string]$nombreSitio,
+		[ValidateSet(3000,5000,8000)]
+		[int]$puerto = 3000
+	)
+	BEGIN { Write-Verbose 'Creando nuevo(s) sitio(s) web' }
+	PROCESS { echo "nombre: $nombreSitio, puerto: $puerto" }
+	END { Write-Verbose 'Sitio(s) web creado(s)' }
+}
+
+
+### Todo es .NET
+# Una cadena PS es, de hecho, una cadena tipo System.String de .NET 
+# Todos los métodos y propiedades de .NET están disponibles
+'cadena'.ToUpper().Replace('E', 'eee')
+# O más powershellezco
+'cadena'.ToUpper() -replace 'E', 'eee'
+
+# ¿No recuerda cómo es que se llama cierto método .NET?
+'cadena' | gm
+
+# Sintaxis para ejecutar métodos .NET estáticos
+[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic')
+
+# Nótese que cualquier función que proviene de .NET Framework REQUIERE paréntesis para ser invocada
+# al contrario de las funciones definidas desde PS, las cuales NO PUEDEN ser invocadas con paréntesis.
+# Si se invoca una función/cmdlet de PS usando paréntesis,
+# es equivalente a que le estuviera pasando un parámetro de tipo lista
+$writer = New-Object System.IO.StreamWriter($ruta, $true)
+$writer.Write([Environment]::NewLine)
+$writer.Dispose()
+
+### Entrada/Salida
+# Leyendo una variable 
+$Nombre = Read-Host "¿Cómo se llama?"
+echo "¡Hola $Nombre!"
+[int]$Edad = Read-Host "¿Cuál es su edad?"
+
+# Test-Path, Split-Path, Join-Path, Resolve-Path
+# Get-Content filename # devuelve un string[]
+# Set-Content, Add-Content, Clear-Content
+Get-Command ConvertTo-*,ConvertFrom-*
+
+
+### Material útil
+# Actualizar la ruta de ejecuciones (PATH)
+$env:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + 
+	";" + [System.Environment]::GetEnvironmentVariable("Path", "User")
+
+# Encontrar Python en el path
+$env:PATH.Split(";") | Where-Object { $_ -like "*python*"}
+
+# Cambiar el directorio de trabajo sin tener que memorizar la ruta anterior
+Push-Location c:\temp # se cambia el directorio de trabajo a c:\temp
+Pop-Location # revierte el cambio y se devuelve a donde estaba al principio
+# Los aliases son : pushd y popd
+
+# Desbloquear un archivo después de descargarlo de Internet
+Get-ChildItem -Recurse | Unblock-File
+
+# Abre Windows Explorer en la ruta actual (usando el alias ii de Invoke-Item)
+ii .
+
+# Pulse cualquier tecla para salir
+$host.UI.RawUI.ReadKey()
+return
+
+# Para crear un acceso directo
+$WshShell = New-Object -comObject WScript.Shell
+$Shortcut = $WshShell.CreateShortcut($link)
+$Shortcut.TargetPath = $file
+$Shortcut.WorkingDirectory = Split-Path $file
+$Shortcut.Save()
+```
+
+
+Configurando el shell
+
+```
+# $Profile es la ruta completa para su `Microsoft.PowerShell_profile.ps1`
+# Todo el código alojado allí será ejecutado cuando se ejecuta una nueva sesión de PS 
+if (-not (Test-Path $Profile)) {
+	New-Item -Type file -Path $Profile -Force
+	notepad $Profile
+}
+# Más información en: `help about_profiles`
+# Para un shell más productivo, asegúrese de verifivar el proyecto PSReadLine descrito abajo
+```
+
+Proyectos interesantes (EN)
+
+* [Channel9](https://channel9.msdn.com/Search?term=powershell%20pipeline#ch9Search&lang-en=en) Tutoriales de PowerShell
+* [PSGet](https://github.com/psget/psget) NuGet para PowerShell
+* [PSReadLine](https://github.com/lzybkr/PSReadLine/) Una implementación inspirada en bash para PowerShell (¡Es tan buena que ahora viene con Windows10 por defecto!)
+* [Posh-Git](https://github.com/dahlbyk/posh-git/) Un intérprete bonito de Git (¡Recomendado!)
+* [PSake](https://github.com/psake/psake) Herramienta de automatización de compilaciones
+* [Pester](https://github.com/pester/Pester) Framework de pruebas BDD
+* [Jump-Location](https://github.com/tkellogg/Jump-Location) Powershell `cd` que lee su mente
+
+
+Material no cubierto en esta guía  
+
+* WMI: Windows Management Intrumentation (Get-CimInstance)  
+* Multitarea: Start-Job -scriptBlock {...}, 
+* Firmas de código
+* Remoting (Enter-PSSession/Exit-PSSession; Invoke-Command)
diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index 4930eebc..a27203d1 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -9,8 +9,8 @@ lang: es-es
 filename: learnpython-es.py
 ---
 
-Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
-de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica.
+Python fue creado por Guido Van Rossum en el principio de los 90. Ahora es uno
+de los lenguajes más populares que existen. Me enamoré de Python por su claridad sintáctica.
 Es básicamente pseudocódigo ejecutable.
 
 ¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
@@ -19,8 +19,8 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
 
 ```python
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
-""" Strings multilinea pueden escribirse
-    usando tres "'s, y comunmente son usados
+""" Strings multilínea pueden escribirse
+    usando tres "'s, y comúnmente son usados
     como comentarios.
 """
 
@@ -48,7 +48,7 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
 
 # Resultado de la división de enteros truncada para positivos y negativos
 5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # funciona con números en coma flotante
+5.0 // 3.0 # => 1.0 # funciona con números de coma flotante
 -5 // 3  # => -2
 -5.0 // 3.0 # => -2.0
 
@@ -436,7 +436,7 @@ class Humano(object):
     def get_especie(cls):
         return cls.especie
 
-    # Un metodo estatico es llamado sin la clase o instancia como referencia
+    # Un metodo estático es llamado sin la clase o instancia como referencia
     @staticmethod
     def roncar():
         return "*roncar*"
@@ -507,7 +507,7 @@ def duplicar_numeros(iterable):
 # Nota: xrange es un generador que hace lo mismo que range.
 # Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio.
 # xrange crea un generador, mientras que range crea toda la lista.
-# Añadimos un guion bajo a los nombres de variable que coinciden con palabras 
+# Añadimos un guión bajo a los nombres de variable que coinciden con palabras
 # reservadas de python.
 xrange_ = xrange(1, 900000000)
 
diff --git a/es-es/pythonstatcomp-es.html.markdown b/es-es/pythonstatcomp-es.html.markdown
new file mode 100644
index 00000000..0130b72a
--- /dev/null
+++ b/es-es/pythonstatcomp-es.html.markdown
@@ -0,0 +1,238 @@
+---
+language: Statistical computing with Python
+contributors:
+    - ["e99n09", "https://github.com/e99n09"]
+filename: pythonstatcomp-es.py
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+Este es un tutorial de como realizar tareas típicas de programación estadística usando Python. Está destinado a personas con cierta familiaridad con Python y con experiencia en programación estadística en lenguajes como R, Stata, SAS, SPSS, or MATLAB.
+
+```python
+
+# 0. Cómo configurar ====
+
+""" Configurar con IPython y pip install lo siguiente: numpy, scipy, pandas,
+    matplotlib, seaborn, requests.
+        Asegúrese de realizar este tutorial con el IPython notebook para tener fácil
+    acceso a las ayudas en tiempo real y la documentación respectiva.
+"""
+
+# 1. Captura de datos ====
+
+""" Muchos prefieren Python sobre R ya que quieren interactuar mucho
+    con la web, bien sea haciendo webscraping o solicitando datos mediante
+    un API. Esto se puede hacer en R, pero en el contexto de un proyecto
+    que ya usa Python, existen beneficios al mantener un solo lenguaje.
+"""
+
+import requests # para llamados HTTP (webscraping, APIs)
+import os
+
+# webscraping
+r = requests.get("https://github.com/adambard/learnxinyminutes-docs")
+r.status_code # si es 200, el llamado ha sido exitoso
+r.text # código fuente de la página
+print(r.text) # formateado y embellecido
+# graba el código fuente en un fichero:
+os.getcwd() # verifica cual es el directorio de trabajo
+f = open("learnxinyminutes.html","wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+# descargando un csv
+fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/"
+fn = "pets.csv"
+r = requests.get(fp + fn)
+print(r.text)
+f = open(fn,"wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+""" para saber más del módulo de peticiones, incluyendo APIs, ver
+    http://docs.python-requests.org/en/latest/user/quickstart/
+"""
+
+# 2. Leyendo un fichero CSV ====
+
+""" El paquete pandas de Wes McKinney brinda objetos 'DataFrame' en Python. Si
+    has usado R, ya estarás familiarizado con la idea de "data.frame".
+"""
+
+import pandas as pd, numpy as np, scipy as sp
+pets = pd.read_csv(fn)
+pets
+#       nombre edad  peso especies
+# 0    fluffy     3    14      cat
+# 1  vesuvius     6    23     fish
+# 2       rex     5    34      dog
+
+""" Usuarios de R: notar que Python, al igual que otros lenguajes de programación
+    normales, comienza indexando desde 0. R de forma inusual comienza desde 1.
+"""
+
+# dos formas distintas de imprimir una columna
+pets.age
+pets["age"]
+
+pets.head(2) # imprime las primeras dos filas
+pets.tail(1) # imprime la última fila
+
+pets.name[1] # 'vesuvius'
+pets.species[0] # 'cat'
+pets["weight"][2] # 34
+
+# en R, puedes esperar obtener 3 filas haciendo esto, pero aquí obtienes 2:
+pets.age[0:2]
+# 0    3
+# 1    6
+
+sum(pets.age)*2 # 28
+max(pets.weight) - min(pets.weight) # 20
+
+""" Si estás procesando grandes cantidades de cálculos de álgebra lineal, podrías
+    querer usar matrices, no DataFrames. Los DataFrames son ideales para combinar
+    columnas de diferentes tipos.
+"""
+
+# 3. Gráficas ====
+
+import matplotlib as mpl, matplotlib.pyplot as plt
+%matplotlib inline
+
+# Para hacer virtualización de datos en Python, usa matplotlib
+
+plt.hist(pets.age);
+
+plt.boxplot(pets.weight);
+
+plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");
+
+# seaborn está por encima de matplotlib y logra mejores gráficos
+
+import seaborn as sns
+
+plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");
+
+# también hay algunas funciones gráficas específicas de seaborn
+# nota como seaborn etiqueta automáticamente el eje x en este gráfico de barras
+sns.barplot(pets["age"])
+
+# los veteranos de R pueden seguir usando ggplot
+from ggplot import *
+ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
+# fuente: https://pypi.python.org/pypi/ggplot
+
+# incluso hay un porteo d3.js: https://github.com/mikedewar/d3py
+
+# 4. Limpieza simple de datos y análisis exploratorio ====
+
+""" Tenemos ahora un ejemplo más complicado que demuestra un flujo básico para
+    limpieza de datos que lleva a la creación de algunos gráficos exploratorios
+    y la ejecución de una regresión lineal.
+        El conjunto de datos fue transcrito de Wikipedia a mano. Contiene
+    todos los Emperadores Romanos Sagrados y fechas claves en sus vidas
+    (nacimiento, muerte, coronación, etc.).
+        El objetivo del análisis es explorar si existe alguna relación
+    entre el año de nacimiento del Emperador y su tiempo de vida.
+    fuente de datos: https://en.wikipedia.org/wiki/Holy_Roman_Emperor
+"""
+
+# cargar algunos datos de los Emperadores Romanos Sagrados
+url = "https://raw.githubusercontent.com/e99n09/R-notes/master/data/hre.csv"
+r = requests.get(url)
+fp = "hre.csv"
+f = open(fp,"wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+hre = pd.read_csv(fp)
+
+hre.head()
+"""
+   Ix      Dynasty        Name        Birth             Death Election 1  
+0 NaN  Carolingian   Charles I  2 April 742    28 January 814        NaN   
+1 NaN  Carolingian     Louis I          778       20 June 840        NaN   
+2 NaN  Carolingian   Lothair I          795  29 September 855        NaN   
+3 NaN  Carolingian    Louis II          825     12 August 875        NaN   
+4 NaN  Carolingian  Charles II  13 June 823     6 October 877        NaN   
+
+  Election 2      Coronation 1   Coronation 2 Ceased to be Emperor  
+0        NaN   25 December 800            NaN       28 January 814   
+1        NaN  11 September 813  5 October 816          20 June 840   
+2        NaN       5 April 823            NaN     29 September 855   
+3        NaN        Easter 850     18 May 872        12 August 875   
+4        NaN   29 December 875            NaN        6 October 877   
+
+  Descent from whom 1 Descent how 1 Descent from whom 2 Descent how 2  
+0                 NaN           NaN                 NaN           NaN  
+1           Charles I           son                 NaN           NaN  
+2             Louis I           son                 NaN           NaN  
+3           Lothair I           son                 NaN           NaN  
+4             Louis I           son                 NaN           NaN  
+"""
+
+# limpiar las columnas de Nacimiento y Muerte
+
+import re # módulo para expresiones regulares
+
+rx = re.compile(r'\d+$') # coincidencia de últimos dígitos
+
+""" Esta función aplica una expresión regular a una columna de entrada (Birth,
+    Death), nivela la lista resultante, la convierte en un objeto Series, y
+    finalmente convierte el tipo del objeto Series de string a entero. Para
+    más información sobre que hace cada parte del código, ver:
+      - https://docs.python.org/2/howto/regex.html
+      - http://stackoverflow.com/questions/11860476/how-to-unlist-a-python-list
+      - http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html
+"""
+def extractYear(v):
+    return(pd.Series(reduce(lambda x,y: x+y,map(rx.findall,v),[])).astype(int))
+
+hre["BirthY"] = extractYear(hre.Birth)
+hre["DeathY"] = extractYear(hre.Death)
+
+# hacer una columna decir la edad estimada
+hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int)
+
+# gráfica de dispersión simple, sin línea de tendencia, el color representa dinastía
+sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False);
+
+# usa scipy para hacer regresiones lineales
+from scipy import stats
+(slope,intercept,rval,pval,stderr)=stats.linregress(hre.BirthY,hre.EstAge)
+# código fuente: http://wiki.scipy.org/Cookbook/LinearRegression
+
+# verifica la pendiente (slope)
+slope # 0.0057672618839073328
+
+# verifica el valor R^2 :
+rval**2 # 0.020363950027333586
+
+# verifica el valor p
+pval # 0.34971812581498452
+
+# usa seaborn para hacer un gráfico de dispersión y dibujar una regresión lineal
+# de la tendencia
+sns.lmplot("BirthY", "EstAge", data=hre);
+
+""" Para más información sobre seaborn, ver
+      - http://web.stanford.edu/~mwaskom/software/seaborn/
+      - https://github.com/mwaskom/seaborn
+    Para más información sobre SciPy, ver
+      - http://wiki.scipy.org/SciPy
+      - http://wiki.scipy.org/Cookbook/
+    Para ver una versión del análisis de los Emperadores Romanos usando R, ver
+      - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
+"""
+```
+
+Si quieres aprender más, obtén _Python for Data Analysis_ por Wes McKinney. Es un extraordinario recurso usado como referencia para escribir este tutorial.
+
+También puedes encontrar gran cantidad de tutoriales interactivos de IPython en temas específicos a tus intereses, como Pilon de Cam Davidson <a href="http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/" Title="Probabilistic Programming and Bayesian Methods for Hackers">Probabilistic Programming and Bayesian Methods for Hackers</a>.
+
+Ver más módulos para investigar:
+   - análisis de texto y procesamiento natural del lenguaje: nltk, http://www.nltk.org
+   - análisis de redes sociales: igraph, http://igraph.org/python/
diff --git a/es-es/r-es.html.markdown b/es-es/r-es.html.markdown
new file mode 100644
index 00000000..2b710b27
--- /dev/null
+++ b/es-es/r-es.html.markdown
@@ -0,0 +1,717 @@
+---
+language: R
+contributors:
+    - ["e99n09", "http://github.com/e99n09"]
+    - ["isomorphismes", "http://twitter.com/isomorphisms"]
+translators:
+    - ["David Hsieh", "http://github.com/deivuh"]
+lang: es-es    
+filename: learnr-es.r
+---
+
+R es un lenguaje de computación estadística. Tiene muchas librerías para cargar
+y limpiar sets de datos, ejecutar procedimientos estadísticos y generar
+gráficas. También puedes ejecutar comandos `R` dentro de un documento de
+LaTeX.
+
+```r
+
+# Los comentariso inician con símbolos numéricos.
+
+# No puedes hacer comentarios de múltiples líneas
+# pero puedes agrupar múltiples comentarios de esta manera. 
+
+# En Windows puedes utilizar CTRL-ENTER para ejecutar una línea.
+# En Mac utilizas COMMAND-ENTER
+
+
+#############################################################################
+# Cosas que puedes hacer sin entender nada acerca de programación
+#############################################################################
+
+# En esta sección, mostramos algunas cosas chileras / cool que puedes hacer en
+# R sin entender nada de programación. No te preocupes en entender nada 
+# de lo que hace este código. Solo disfruta!
+
+data()	        # Examinar sets de datos pre-cargados
+data(rivers)	# Obtiene este: Lengths of Major North American Rivers"
+ls()	        # Fijarse que "rivers" ahora aparece en el workspace
+head(rivers)	# Echarle un ojo al set de datos
+# 735 320 325 392 524 450
+
+length(rivers)	# ¿Cuántos ríos fueron medidos?
+# 141
+summary(rivers) # ¿Cuáles son algunas estadísticas generales?
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#  135.0   310.0   425.0   591.2   680.0  3710.0
+
+# Generar una gráfica tallo-y-hoja (Visualización de datos tipo histograma)
+stem(rivers)
+
+# El punto decimal son 2 dígitos a la derecha de | 
+#
+#   0 | 4
+#   2 | 011223334555566667778888899900001111223333344455555666688888999
+#   4 | 111222333445566779001233344567
+#   6 | 000112233578012234468
+#   8 | 045790018
+#  10 | 04507
+#  12 | 1471
+#  14 | 56
+#  16 | 7
+#  18 | 9
+#  20 |
+#  22 | 25
+#  24 | 3
+#  26 |
+#  28 |
+#  30 |
+#  32 |
+#  34 |
+#  36 | 1
+
+stem(log(rivers)) # Fijarse que la data no es normal ni log-normal!
+# Toma eso, fundamentalistas de la curva de campana!
+
+# El punto decimal está a 1 dígito a la izquierda del |
+#
+#  48 | 1
+#  50 |
+#  52 | 15578
+#  54 | 44571222466689
+#  56 | 023334677000124455789
+#  58 | 00122366666999933445777
+#  60 | 122445567800133459
+#  62 | 112666799035
+#  64 | 00011334581257889
+#  66 | 003683579
+#  68 | 0019156
+#  70 | 079357
+#  72 | 89
+#  74 | 84
+#  76 | 56
+#  78 | 4
+#  80 |
+#  82 | 2
+
+# Generar un histograma:
+hist(rivers, col="#333333", border="white", breaks=25) # Juega con los estos parámetros
+hist(log(rivers), col="#333333", border="white", breaks=25) # Generarás más gráficas después
+
+# Aquí hay otro set de datos pre-cargado. R tiene bastantes de éstos.
+data(discoveries)
+plot(discoveries, col="#333333", lwd=3, xlab="Year",
+     main="Number of important discoveries per year")
+plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Year",
+     main="Number of important discoveries per year")
+
+# En lugar de dejar el orden por defecto (por año),
+# podemos ordenar de tal manera que muestre qué es típico:
+sort(discoveries)
+#  [1]  0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  1  1  1  1  1  1  2  2  2  2
+# [26]  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  2  3  3  3
+# [51]  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  3  4  4  4  4  4  4  4  4
+# [76]  4  4  4  4  5  5  5  5  5  5  5  6  6  6  6  6  6  7  7  7  7  8  9 10 12
+
+stem(discoveries, scale=2)
+#
+#  El punto decimal se encuentra en |
+#
+#   0 | 000000000
+#   1 | 000000000000
+#   2 | 00000000000000000000000000
+#   3 | 00000000000000000000
+#   4 | 000000000000
+#   5 | 0000000
+#   6 | 000000
+#   7 | 0000
+#   8 | 0
+#   9 | 0
+#  10 | 0
+#  11 |
+#  12 | 0
+
+max(discoveries)
+# 12
+summary(discoveries)
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#    0.0     2.0     3.0     3.1     4.0    12.0
+
+# Tirar los dados varias veces
+round(runif(7, min=.5, max=6.5))
+# 1 4 6 1 4 6 4
+# Tus números será diferente de los míos, a menos que tengamos el mismo valor 
+# de random.seed(31337)
+
+# Dibuja de un Gaussian 9 veces
+rnorm(9)
+# [1]  0.07528471  1.03499859  1.34809556 -0.82356087  0.61638975 -1.88757271
+# [7] -0.59975593  0.57629164  1.08455362
+
+
+
+##################################################
+# Tipos de datos y aritmética básica
+##################################################
+
+# Ahora para la parte de programación orientada a objetos del tutorial.
+# En esta sección conocerás los tipos de datos importantes de R:
+# Enteros, numéricos, caracteres, lógicos, y factores.
+# Hay otros, pero esos son los que menos necesitas para empezar.
+
+# ENTEROS
+# Enteros de almacenamiento largo son escritos con L
+5L # 5
+class(5L) # "integer"
+# (Try ?class para más información en la función class().)
+# En R, cada valor único, como 5L, es considerado un vector de logitud 1
+length(5L) # 1
+# También puedes tener un vector de enteros con longitud > 1:
+c(4L, 5L, 8L, 3L) # 4 5 8 3
+length(c(4L, 5L, 8L, 3L)) # 4
+class(c(4L, 5L, 8L, 3L)) # "integer"
+
+# NUMÉRICOS
+# Un "numérico" es un número de punto flotante de doble precisión.
+5 # 5
+class(5) # "numeric"
+# Nuevamente, todo en R es un vector;
+# puedes hacer un vector numérico con más de un elemento
+c(3,3,3,2,2,1) # 3 3 3 2 2 1
+# También puedes utilizar el notación científica
+5e4 # 50000
+6.02e23 # Número de Avogadro
+1.6e-35 # Logintud Planck 
+# También puedes tener números infinitamente grandes o pequeños
+class(Inf)	# "numeric"
+class(-Inf)	# "numeric"
+# Puede que uses "Inf", por ejemplo, en integrate(dnorm, 3, Inf);
+# esto obvia las tablas de puntos Z.
+
+# ARITMÉTICA BÁSICA
+# Puedes hacer aritmética con números
+# Haciendo aritmética en un mix de enteros y numéricos, te da otro numérico
+10L + 66L # 76      # entero mas entero da entero
+53.2 - 4  # 49.2    # entero menos entero da numérico
+2.0 * 2L  # 4       # numérico veces entero da numérico
+3L / 4    # 0.75    # entero sobre numérico da numérico
+3 %% 2	  # 1       # el residuo de dos numéricos es otro numérico
+# La aritmética ilegal rinde un "not-a-number"
+0 / 0 # NaN
+class(NaN) # "numeric"
+# Puedes hacer aritmética con dos vectores con longitud mayor a 1,
+# siempre que la longitud del vector mayor es un entero múltiplo del menor.
+c(1,2,3) + c(1,2,3) # 2 4 6
+
+# CARACTERES
+# No hay diferencia entre strings y caracteres en R
+"Horatio" # "Horatio"
+class("Horatio") # "character"
+class('H') # "character"
+# Ambos eran vectores de caracteres de longitud 1
+# Aquí hay uno más largo:
+c('alef', 'bet', 'gimmel', 'dalet', 'he')
+# =>
+# "alef"   "bet"    "gimmel" "dalet"  "he"
+length(c("Call","me","Ishmael")) # 3
+# Puedes hacer operaciones regex en vectores de caracteres:
+substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis "
+gsub('u', 'ø', "Fortuna multis dat nimis, nulli satis.") # "Fortøna møltis dat nimis, nølli satis."
+# R tiene varios vectores predefinidos de caracteres 
+letters
+# =>
+#  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
+# [20] "t" "u" "v" "w" "x" "y" "z"
+month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
+
+# LÓGICOS
+# En R, un "logical" es un boolean
+class(TRUE)	# "logical"
+class(FALSE)	# "logical"
+# Ese comportamiento es normal
+TRUE == TRUE	# TRUE
+TRUE == FALSE	# FALSE
+FALSE != FALSE	# FALSE
+FALSE != TRUE	# TRUE
+# El dato faltante (NA) es lógico también
+class(NA)	# "logical"
+# Utiliza | y & para operaciones lógicas
+# OR
+TRUE | FALSE	# TRUE
+# AND
+TRUE & FALSE	# FALSE
+# Puedes probar si x es TRUE (verdadero)
+isTRUE(TRUE)	# TRUE
+# Aquí tenemos un vector lógico con varios elementos:
+c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
+c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
+
+# FACTORES
+# La clase factor es para datos de categoría
+# Los factores pueden ser ordenados (como las calificaciones de los niños) 
+# o sin orden (como el género)
+factor(c("female", "female", "male", NA, "female"))
+#  female female male   <NA>   female
+# Levels: female male
+# Los "levels" son los valores que los datos categóricos pueden tener
+# Tomar nota que los datos faltantes no entran a los niveles
+levels(factor(c("male", "male", "female", NA, "female"))) # "female" "male"
+# Si un vector de factores tiene longitud 1, sus niveles también tendrán
+# una longitud de 1 también
+
+length(factor("male")) # 1
+length(levels(factor("male"))) # 1
+# Los factores son comúnmente vistos en marcos de dato, y una estructura de 
+# datos que cubriremos después
+data(infert) # "Infertility after Spontaneous and Induced Abortion"
+levels(infert$education) # "0-5yrs"  "6-11yrs" "12+ yrs"
+
+# NULL
+# "NULL" es uno raro; utilízalo para "limpiar" un vector
+class(NULL)	# NULL
+parakeet = c("beak", "feathers", "wings", "eyes")
+parakeet
+# =>
+# [1] "beak"     "feathers" "wings"    "eyes"
+parakeet <- NULL
+parakeet
+# =>
+# NULL
+
+# COERCIÓN DE TIPO
+# La coerción de tipos es cuando forzas un valor diferente tipo al que puede tomar.
+as.character(c(6, 8)) # "6" "8"
+as.logical(c(1,0,1,1)) # TRUE FALSE  TRUE  TRUE
+# Si pones elementos de diferentes tipos en un vector, coerciones raras pasan:
+c(TRUE, 4) # 1 4
+c("dog", TRUE, 4) # "dog"  "TRUE" "4"
+as.numeric("Bilbo")
+# =>
+# [1] NA
+# Warning message:
+# NAs introduced by coercion
+
+# También tomar nota: Esos solo eran datos de tipos básicos
+# Hay mucho más tipos de datos, como las fechas, series de tiempo, etc.
+
+
+##################################################
+# Variables, ciclos, condiciones (if/else)
+##################################################
+
+# A variable is like a box you store a value in for later use.
+# We call this "assigning" the value to the variable.
+# Having variables lets us write loops, functions, and if/else statements
+
+# VARIABLES
+# Muchas maneras de asignar valores:
+x = 5 # esto es posible
+y <- "1" # esto es preferido
+TRUE -> z # estos funciona pero es raro
+
+# CICLOS
+# Tenemos ciclos 'for'
+for (i in 1:4) {
+  print(i)
+}
+# Tenemos ciclos 'while'
+a <- 10
+while (a > 4) {
+	cat(a, "...", sep = "")
+	a <- a - 1
+}
+# Ten en mente que los ciclos 'for' y 'while' son lentos en R
+# Operaciones con vectores enteros (i.e. una fila o columna completa)
+# o tipos de función apply() (que discutiremos después) son preferidos
+
+# CONDICIONES (IF/ELSE)
+# De nuevo, bastante normal
+if (4 > 3) {
+	print("4 is greater than 3")
+} else {
+	print("4 is not greater than 3")
+}
+# =>
+# [1] "4 is greater than 3"
+
+# FUNCIONES
+# Definidos de la siguiente manera:
+jiggle <- function(x) {
+	x = x + rnorm(1, sd=.1)	#agregar un poco de ruido (controlado)
+	return(x)
+}
+# Llamados como cualquier otra función de R
+jiggle(5)	# 5±ε. luego de set.seed(2716057), jiggle(5)==5.005043
+
+
+
+###########################################################################
+# Estructura de datos: Vectores, matrices, marcos da datos y arreglos
+###########################################################################
+
+# UNIDIMENSIONAL
+
+# Empecemos desde el principio, y con algo que ya conoces: vectores.
+vec <- c(8, 9, 10, 11)
+vec	#  8  9 10 11
+# Preguntamos por elementos específicos poniendo un subconjunto en corchetes
+# (Toma nota de que R empieza los conteos desde 1)
+vec[1]		# 8
+letters[18]	# "r"
+LETTERS[13]	# "M"
+month.name[9]	# "September"
+c(6, 8, 7, 5, 3, 0, 9)[3]	# 7
+# También podes buscar por los índices de componentes específicos,
+which(vec %% 2 == 0)	# 1 3
+# obtener la primera o las últimas entradas de un vector,
+head(vec, 1)	# 8
+tail(vec, 2)	# 10 11
+# o averiguar si cierto valor se encuentra dentro de un vector
+any(vec == 10) # TRUE
+# Si un índice "se pasa", obtendrás un NA:
+vec[6]	# NA
+# Puedes encontrar la longitud de un vector con length()
+length(vec)	# 4
+# Puedes realizar operaciones con vectores enteros o con subconjuntos de vectores
+vec * 4	# 16 20 24 28
+vec[2:3] * 5	# 25 30
+any(vec[2:3] == 8) # FALSE
+# y R tiene muchas funciones pre-definidas para resumir vectores
+mean(vec)	# 9.5
+var(vec)	# 1.666667
+sd(vec)		# 1.290994
+max(vec)	# 11
+min(vec)	# 8
+sum(vec)	# 38
+# Otras funciones pre-definidas:
+5:15	# 5  6  7  8  9 10 11 12 13 14 15
+seq(from=0, to=31337, by=1337)
+# =>
+#  [1]     0  1337  2674  4011  5348  6685  8022  9359 10696 12033 13370 14707
+# [13] 16044 17381 18718 20055 21392 22729 24066 25403 26740 28077 29414 30751
+
+# BIDIMENCIONAL (TODO EN UNA CLASE)
+
+# Puedes hacer una matriz de las entradas todos de un mismo tipo como:
+mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6))
+mat
+# =>
+#      [,1] [,2]
+# [1,]    1    4
+# [2,]    2    5
+# [3,]    3    6
+# A diferencia de un vector, una clase matriz es una 'matriz', 
+# sin importar qué contiene
+class(mat) # => "matrix"
+# Consulta la primera fila
+mat[1,]	# 1 4
+# Realiza una operación en la primera columna
+3 * mat[,1]	# 3 6 9
+# Consulta por una celda específica
+mat[3,2]	# 6
+
+# Transpone una matriz entera
+t(mat)
+# =>
+#      [,1] [,2] [,3]
+# [1,]    1    2    3
+# [2,]    4    5    6
+
+# Multiplicación de matrices
+mat %*% t(mat)
+# =>
+#      [,1] [,2] [,3]
+# [1,]   17   22   27
+# [2,]   22   29   36
+# [3,]   27   36   45
+
+# cbind() une vectores como columnas para hacer una matriz
+mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog"))
+mat2
+# =>
+#      [,1] [,2]
+# [1,] "1"  "dog"
+# [2,] "2"  "cat"
+# [3,] "3"  "bird"
+# [4,] "4"  "dog"
+class(mat2)	# matrix
+# De nuevo, ten en cuenta lo que sucedió
+# Debido a que las matrices deben de contener todas las entradas del mismo tipo,
+# todo fue convertido a la clase caracter
+c(class(mat2[,1]), class(mat2[,2]))
+
+# rbind() une vectores como filas para hacer una matriz
+mat3 <- rbind(c(1,2,4,5), c(6,7,0,4))
+mat3
+# =>
+#      [,1] [,2] [,3] [,4]
+# [1,]    1    2    4    5
+# [2,]    6    7    0    4
+# Ah, todo es de la misma clase. No hay coerciones. Mucho mejor.
+
+# BIDIMENSIONAL (DIFERENTES CLASES)
+
+# Para columnas de tipos diferentes, utiliza un data frame
+# Esta estructura de datos es muy útil para programación estadística,
+# una versión de ésta fue agregada a Python en el paquete "pandas".
+
+students <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"),
+                       c(3,2,2,1,0,-1),
+                       c("H", "G", "G", "R", "S", "G"))
+names(students) <- c("name", "year", "house") # name the columns
+class(students)	# "data.frame"
+students
+# =>
+#     name year house
+# 1 Cedric    3     H
+# 2   Fred    2     G
+# 3 George    2     G
+# 4    Cho    1     R
+# 5  Draco    0     S
+# 6  Ginny   -1     G
+class(students$year)	# "numeric"
+class(students[,3])	# "factor"
+# encontrar las dimensiones
+nrow(students)	# 6
+ncol(students)	# 3
+dim(students)	# 6 3
+# La función data.frame() convierte vectores de caracteres en vectores 
+# de factores por defecto; deshabilita este atributo
+# stringsAsFactors = FALSE cuando vayas a crear el data.frame
+?data.frame
+
+# Hay otras formas de hacer subconjuntos de data frames
+students$year	# 3  2  2  1  0 -1
+students[,2]	# 3  2  2  1  0 -1
+students[,"year"]	# 3  2  2  1  0 -1
+
+# Una versión aumentada de la estructura data.frame es el data.table
+# Si estás trabajando huge o panel data, o necesitas unificar algunos 
+# subconjuntos de datos, data.table puede ser una buena elección.
+# Aquí un tour:
+install.packages("data.table") # Descarga el paquete de CRAN
+require(data.table) # Cárgalo
+students <- as.data.table(students)
+students # Tomar en cuenta la diferencia de la impresión
+# =>
+#      name year house
+# 1: Cedric    3     H
+# 2:   Fred    2     G
+# 3: George    2     G
+# 4:    Cho    1     R
+# 5:  Draco    0     S
+# 6:  Ginny   -1     G
+students[name=="Ginny"] # obtener filas con name == "Ginny"
+# =>
+#     name year house
+# 1: Ginny   -1     G
+students[year==2] # obtener filas con year == 2
+# =>
+#      name year house
+# 1:   Fred    2     G
+# 2: George    2     G
+# data.table hace que la unificación de dos sets de datos sea fácil
+# Hagamos otro data.table para unifiar a los estudiantes
+founders <- data.table(house=c("G","H","R","S"),
+                       founder=c("Godric","Helga","Rowena","Salazar"))
+founders
+# =>
+#    house founder
+# 1:     G  Godric
+# 2:     H   Helga
+# 3:     R  Rowena
+# 4:     S Salazar
+setkey(students, house)
+setkey(founders, house)
+students <- founders[students] # Unifica los dos sets de datos comparando "house"
+setnames(students, c("house","houseFounderName","studentName","year"))
+students[,order(c("name","year","house","houseFounderName")), with=F]
+# =>
+#    studentName year house houseFounderName
+# 1:        Fred    2     G           Godric
+# 2:      George    2     G           Godric
+# 3:       Ginny   -1     G           Godric
+# 4:      Cedric    3     H            Helga
+# 5:         Cho    1     R           Rowena
+# 6:       Draco    0     S          Salazar
+
+# data.table hace que sea fácil obtener resúmenes de las tablas
+students[,sum(year),by=house]
+# =>
+#    house V1
+# 1:     G  3
+# 2:     H  3
+# 3:     R  1
+# 4:     S  0
+
+# Para eliminar una columna de un data.frame o data.table, 
+# asignarle el valor NULL.
+students$houseFounderName <- NULL
+students
+# =>
+#    studentName year house
+# 1:        Fred    2     G
+# 2:      George    2     G
+# 3:       Ginny   -1     G
+# 4:      Cedric    3     H
+# 5:         Cho    1     R
+# 6:       Draco    0     S
+
+# Elimina una fila poniendo un subconjunto
+# Usando data.table:
+students[studentName != "Draco"]
+# =>
+#    house studentName year
+# 1:     G        Fred    2
+# 2:     G      George    2
+# 3:     G       Ginny   -1
+# 4:     H      Cedric    3
+# 5:     R         Cho    1
+# Usando data.frame:
+students <- as.data.frame(students)
+students[students$house != "G",]
+# =>
+#   house houseFounderName studentName year
+# 4     H            Helga      Cedric    3
+# 5     R           Rowena         Cho    1
+# 6     S          Salazar       Draco    0
+
+# MULTI-DIMENSIONAL (TODOS LOS ELEMENTOS DE UN TIPO)
+
+# Arreglos crean una tabla de dimensión n
+# Todos los elementos deben de ser del mismo tipo
+# Puedes hacer una tabla bi-dimensional (como una matriz)
+array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4))
+# =>
+#      [,1] [,2] [,3] [,4]
+# [1,]    1    4    8    3
+# [2,]    2    5    9    6
+# Puedes utilizar un arreglo para hacer una matriz tri-dimensional también
+array(c(c(c(2,300,4),c(8,9,0)),c(c(5,60,0),c(66,7,847))), dim=c(3,2,2))
+# =>
+# , , 1
+#
+#      [,1] [,2]
+# [1,]    2    8
+# [2,]  300    9
+# [3,]    4    0
+#
+# , , 2
+#
+#      [,1] [,2]
+# [1,]    5   66
+# [2,]   60    7
+# [3,]    0  847
+
+# LISTAS (MULTI-DIMENSIONAL, POSIBLEMENTE DESIGUALES, DE DIFERENTES TIPOS)
+
+# Finalmente, R tiene listas (de vectores)
+list1 <- list(time = 1:40)
+list1$price = c(rnorm(40,.5*list1$time,4)) # aleatorio
+list1
+# Puedes obtener elementos de una lista de la siguiente manera
+list1$time # Una manera
+list1[["time"]] # Otra manera
+list1[[1]] # Y otra manera
+# =>
+#  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
+# [34] 34 35 36 37 38 39 40
+# Puedes crear una lista de subconjuntos como cualquier otro vector
+list1$price[4]
+
+# Las listas no son la estructura de datos más eficiente para trabajar en R;
+# a menos de que tengas una buena razón, deberías de quedarte con data.frames
+# Las listas son usualmente devueltas por funciones que realizan regresiones 
+# lineales
+
+##################################################
+# La familia de funciones apply()
+##################################################
+
+# Te recuerdas de mat?
+mat
+# =>
+#      [,1] [,2]
+# [1,]    1    4
+# [2,]    2    5
+# [3,]    3    6
+# Utiliza apply(X, MARGIN, FUN) paraaplicar una función FUN a la matriz X
+# sobre las filas (MAR = 1) o las columnas (MAR = 2)
+# Eso es, R aplica FUN sobre cada fila (o columna) de X, mucho más rápido que
+# lo que haría un ciclo 'for' o 'loop'
+apply(mat, MAR = 2, jiggle)
+# =>
+#      [,1] [,2]
+# [1,]    3   15
+# [2,]    7   19
+# [3,]   11   23
+# Otras funciones: ?lapply, ?sapply
+
+# No te sientas muy intimidado; todos están de acuerdo que son confusas
+
+# El paquete plyr busca reemplazar (y mejorar) la familiar *apply()
+install.packages("plyr")
+require(plyr)
+?plyr
+
+
+
+#########################
+# Carga de datos
+#########################
+
+# "pets.csv" es un archivo en internet
+# (pero puede ser tan fácil como tener el archivo en tu computadora)
+pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv")
+pets
+head(pets, 2) # primeras dos filas
+tail(pets, 1) # última fila
+
+# Para guardar un data frame o una matriz como un archivo .csv
+write.csv(pets, "pets2.csv") # para hacer un nuevo archivo .csv
+# definir el directorio de trabajo con setwd(), búscalo con getwd()
+
+# Prueba ?read.csv ?write.csv para más información
+
+
+#########################
+# Gráficas
+#########################
+
+# FUNCIONES PREDEFINIDAS DE GRAFICACIÓN
+# Gráficos de dispersión!
+plot(list1$time, list1$price, main = "fake data")
+# Regresiones!
+linearModel <- lm(price  ~ time, data = list1)
+linearModel # Muestra el resultado de la regresión
+# Grafica la línea de regresión
+abline(linearModel, col = "red")
+# Obtiene una veridad de diagnósticos
+plot(linearModel)
+# Histogramas!
+hist(rpois(n = 10000, lambda = 5), col = "thistle")
+# Barras!
+barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
+
+# GGPLOT2
+# Pero éstas no son las gráficas más bonitas de R
+# Prueba el paquete ggplot2 para mayor variedad y mejores gráficas
+install.packages("ggplot2")
+require(ggplot2)
+?ggplot2
+pp <- ggplot(students, aes(x=house))
+pp + geom_histogram()
+ll <- as.data.table(list1)
+pp <- ggplot(ll, aes(x=time,price))
+pp + geom_point()
+# ggplot2 tiene una excelente documentación 
+# (disponible en http://docs.ggplot2.org/current/)
+
+
+
+```
+
+## ¿Cómo obtengo R?
+
+* Obtén R y R GUI de [http://www.r-project.org/](http://www.r-project.org/)
+* [RStudio](http://www.rstudio.com/ide/) es otro GUI
diff --git a/es-es/racket-es.html.markdown b/es-es/racket-es.html.markdown
new file mode 100644
index 00000000..a49509c7
--- /dev/null
+++ b/es-es/racket-es.html.markdown
@@ -0,0 +1,683 @@
+---
+language: racket
+filename: learnracket-es.rkt
+contributors:
+  - ["th3rac25", "https://github.com/voila"]
+  - ["Eli Barzilay", "https://github.com/elibarzilay"]
+  - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"]
+  - ["Duong H. Nguyen", "https://github.com/cmpitg"]
+  - ["Keyan Zhang", "https://github.com/keyanzhang"]
+translators:
+    - ["Carlos Roman", "https://github.com/carlochess"]
+lang: es-es
+---
+Racket es un lenguaje de propósito general, multiparadigma que hace parte de la familia Lisp/Scheme.
+
+```racket
+#lang racket ; Define el lenguaje que usas
+
+;;; Comentarios
+
+;; Los comentarios de una sola línea inician con un punto y coma
+
+#| Un bloque de comentarios
+   puede distribuirse en varias líneas...
+    #|
+       ¡Incluso puede estar anidado!
+    |#
+|#
+
+;; Los comentarios descartan la siguiente expresión,
+;; pero son útiles para comentar expresiones al momento de depurar el código
+#; (Esta expresión es descartada)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Tipos de datos primitivos y operadores
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Numeros
+9999999999999999999999 ; Enteros
+#b111                  ; binario => 7
+#o111                  ; octal => 73
+#x111                  ; hexadecimal => 273
+3.14                   ; reales
+6.02e+23
+1/2                    ; racionaless
+1+2i                   ; numeros complejos
+
+;; La aplicación de funciones es escrita de la siguiente forma: (f x y z ...)
+;; donde f es una función y “x, y, z” son sus operandos 
+;; Si quieres crear una lista de literales debes agregar ' al inicio
+;; para que no sean evaluados
+'(+ 1 2) ; => (+ 1 2)
+;; Ahora algunas operaciones aritméticas
+(+ 1 1)  ; => 2
+(- 8 1)  ; => 7
+(* 10 2) ; => 20
+(expt 2 3) ; => 8
+(quotient 5 2) ; => 2
+(remainder 5 2) ; => 1
+(/ 35 5) ; => 7
+(/ 1 3) ; => 1/3
+(exact->inexact 1/3) ; => 0.3333333333333333
+(+ 1+2i  2-3i) ; => 3-1i
+
+;;; Booleanos
+#t ; Para verdadero (true)
+#f ; Para falso (false) -- cualquier valor distinto de #f es verdadero
+(not #t) ; => #f
+(and 0 #f (error "No entra aquí")) ; => #f
+(or #f 0 (error "No entra aquí"))  ; => 0
+
+;;; Caracteres
+#\A ; => #\A
+#\λ ; => #\λ
+#\u03BB ; => #\λ
+
+;;; Los Strings tienen una longitud fija
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel"   ; backslash es un caracter de escape
+"Foo\tbar\41\x21\u0021\a\r\n" ; incluye escape para C, Unicode
+"λx:(μα.α→α).xx"              ; Puedes incluir caracteres Unicode
+
+;; ¡Los tipos de dato Strings pueden unirse tambien!
+(string-append "Hello " "world!") ; => "Hello world!"
+
+;; Un string puede ser tratado como una lista de caracteres
+(string-ref "Apple" 0) ; => #\A
+
+;; la función format puede usarse para darle formato a un string:
+(format "~a can be ~a" "strings" "formatted")
+
+;; Imprimir en consola es muy simple
+(printf "I'm Racket. Nice to meet you!\n")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variables
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Puedes crear una variable usando define
+;; el nombre de una variable puede contener cualquier nombre excepto: ()[]{}",'`;#|\
+(define some-var 5)
+some-var ; => 5
+
+;; También puedes usar caracteres unicode
+(define ⊆ subset?)
+(⊆ (set 3 2) (set 1 2 3)) ; => #t
+
+;; Acceder a una variable no definida con anterioridad resulta en una excepción
+; x ; => x: undefined ...
+
+;; Local binding: La variable 'me' esta limitada a tomar el valor "Bob" dentro del ambiente (let ...)
+(let ([me "Bob"])
+  "Alice"
+  me) ; => "Bob"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Estructuras y colecciones
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Estructuras
+(struct dog (name breed age))
+(define my-pet
+  (dog "lassie" "collie" 5))
+my-pet ; => #<dog>
+(dog? my-pet) ; => #t
+(dog-name my-pet) ; => "lassie"
+
+;;; Parejas (Inmutables)
+;; 'cons' construye parejas, 'car' y 'cdr' extraen el primer
+;; y segundo elemento respectivamente de una pareja
+(cons 1 2) ; => '(1 . 2)
+(car (cons 1 2)) ; => 1
+(cdr (cons 1 2)) ; => 2
+
+;;; Listas
+
+;; Las Listas son estructuras secuenciales no indexadas, hechas con ‘cons’ y
+;; con un 'null' (o '()) para denotar el final de la lista
+(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
+;; 'list' es otro constructor apropiado para las listas
+(list 1 2 3) ; => '(1 2 3)
+;; y el simbolo comilla (') puede ser usado en una lista de valores literales
+'(1 2 3) ; => '(1 2 3)
+
+;; Aquí aun se puede usar 'cons' para agregar un elemento al comienzo de la lista
+(cons 4 '(1 2 3)) ; => '(4 1 2 3)
+
+;; El uso de 'append' para unir un par de listas
+(append '(1 2) '(3 4)) ; => '(1 2 3 4)
+
+;; Las listas son un tipo de dato básico, por lo cual proveen numerosas funcionalidades;
+;; algunos ejemplos son:
+(map add1 '(1 2 3))          ; => '(2 3 4)
+(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33)
+(filter even? '(1 2 3 4))    ; => '(2 4)
+(count even? '(1 2 3 4))     ; => 2
+(take '(1 2 3 4) 2)          ; => '(1 2)
+(drop '(1 2 3 4) 2)          ; => '(3 4)
+
+;;; Vectores
+
+;; Los Vectores son arreglos de longitud fija
+#(1 2 3) ; => '#(1 2 3)
+
+;; Se usa 'vector-append' para unir dos vectores
+(vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
+
+;;; Conjuntos
+
+;; Crear un conjunto a partir de una lista
+(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3)
+
+;; Agregar/Asignar un nuevo elemento 'set-add'
+;; (Funcional: retorna un conjunto extendido en vez de una mutar la entrada)
+(set-add (set 1 2 3) 4) ; => (set 1 2 3 4)
+
+;; Remueve el elemento agregado anteriormente 'set-remove'
+(set-remove (set 1 2 3) 1) ; => (set 2 3)
+
+;; Prueba la existencia de un elemento con la funcion 'set-member?'
+(set-member? (set 1 2 3) 1) ; => #t
+(set-member? (set 1 2 3) 4) ; => #f
+
+;;; Tablas Hashs
+
+;; Crea una tabla hash inmutable (Abajo presentamos un ejemplo)
+(define m (hash 'a 1 'b 2 'c 3))
+
+;; Conseguir un valor
+(hash-ref m 'a) ; => 1
+
+;; Conseguir un valor que no está presente es una excepción
+; (hash-ref m 'd) => no value found
+
+;; Puedes proveer un valor por defecto si el valor para la llave no se encuentra
+(hash-ref m 'd 0) ; => 0
+
+;; Usa 'hash-set' para ampliar un tabla hash “inmutable”
+;; (Retorna la tabla hash extendida en vez de una mutarla)
+(define m2 (hash-set m 'd 4))
+m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3))
+
+;; ¡Recuerde que estas tablas hash son inmutables!
+m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no 'd'
+
+;; Usa 'hash-remove' para quitar las llaves de la tabla hash (functional tambien)
+(hash-remove m 'a) ; => '#hash((b . 2) (c . 3))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Funciones
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Usa 'lambda' para crear funciones.
+;; Una función siempre retorna el valor de su última expresión
+(lambda () "Hello World") ; => #<procedure>
+;; También se puede usar el caracter Unicode 'λ'
+(λ () "Hello World")     ; => same function
+
+;; Usa los paréntesis exteriores para llamar la función
+((lambda () "Hello World")) ; => "Hello World"
+((λ () "Hello World"))      ; => "Hello World"
+
+;; Asigna una función a una variable
+(define hello-world (lambda () "Hello World"))
+(hello-world) ; => "Hello World"
+
+;; Puede acortar esto usando el azúcar sintáctico para la definición de una función:
+(define (hello-world2) "Hello World")
+
+;; El paréntesis () del ejemplo anterior denota la lista de argumentos para la función
+(define hello
+  (lambda (name)
+    (string-append "Hello " name)))
+(hello "Steve") ; => "Hello Steve"
+;; ... O de forma similar, usando el azúcar sintáctico para una definición:
+(define (hello2 name)
+  (string-append "Hello " name))
+
+;; Puedes tener una función con parametros variables, using 'case-lambda'
+(define hello3
+  (case-lambda
+    [() "Hello World"]
+    [(name) (string-append "Hello " name)]))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+;; ... o especificar los argumentos opcionales junto con su valor por defecto
+(define (hello4 [name "World"])
+  (string-append "Hello " name))
+
+;; Las funciones pueden tener argumentos extra empaquetados como una lista
+(define (count-args . args)
+  (format "You passed ~a args: ~a" (length args) args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+;; ... o sin usar el azúcar sintáctico:
+(define count-args2
+  (lambda args
+    (format "You passed ~a args: ~a" (length args) args)))
+
+;; Puedes combinar argumentos regulares y empaquetados
+(define (hello-count name . args)
+  (format "Hello ~a, you passed ~a extra args" name (length args)))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+;; ... Sin usar azúcar sintáctica:
+(define hello-count2
+  (lambda (name . args)
+    (format "Hello ~a, you passed ~a extra args" name (length args))))
+
+;; Y con keywords
+(define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args)
+  (format "~a ~a, ~a extra args" g name (length args)))
+(hello-k)                 ; => "Hello World, 0 extra args"
+(hello-k 1 2 3)           ; => "Hello World, 3 extra args"
+(hello-k #:greeting "Hi") ; => "Hi World, 0 extra args"
+(hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args"
+(hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6)
+                                         ; => "Hi Finn, 6 extra args"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Comparando
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Para números usa '='
+(= 3 3.0) ; => #t
+(= 2 1)   ; => #f
+
+;; 'eq?' retorna #t si 2 argumentos refieren al mismo objeto en memoria 
+;; #f de lo contrario.
+;; En otras palabras, es una simple comparación de punteros.
+(eq? '() '()) ; => #t, Debido a que existe solo una lista vacia en memoria
+(let ([x '()] [y '()])
+  (eq? x y))  ; => #t, igual que arriba
+
+(eq? (list 3) (list 3)) ; => #f
+(let ([x (list 3)] [y (list 3)])
+  (eq? x y))            ; => #f — ¡No es la misma lista en memoria!
+
+(let* ([x (list 3)] [y x])
+  (eq? x y)) ; => #t, debido a que ‘x’ y ‘y’ ahora apuntan a la misma posición en memoria
+
+(eq? 'yes 'yes) ; => #t
+(eq? 'yes 'no)  ; => #f
+
+(eq? 3 3)   ; => #t — Te cuidado aqui
+            ; es mejor usar '=' para comparacion de numeros.
+(eq? 3 3.0) ; => #f
+
+(eq? (expt 2 100) (expt 2 100))               ; => #f
+(eq? (integer->char 955) (integer->char 955)) ; => #f
+
+(eq? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f
+
+;; 'eqv?' permite comparar números y caracteres..
+;; for other datatypes, 'eqv?' and 'eq?' return the same result.
+(eqv? 3 3.0)                                   ; => #f
+(eqv? (expt 2 100) (expt 2 100))               ; => #t
+(eqv? (integer->char 955) (integer->char 955)) ; => #t
+
+(eqv? (string-append "foo" "bar") (string-append "foo" "bar"))   ; => #f
+
+;; 'equal?' permite comparar los siguientes tipos de datos:
+;; strings, byte strings, pairs, mutable pairs, vectors, boxes, 
+;; hash tables, and inspectable estructuras.
+;; para otros tipos de datos, 'equal?' y 'eqv?' devuelven el mismo resultado.
+(equal? 3 3.0)                                                   ; => #f
+(equal? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #t
+(equal? (list 3) (list 3))                                       ; => #t
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Control de flujo
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Condicionales
+
+(if #t               ; expresión de prueba
+    "this is true"   ; expresión si la expresión de prueba es verdadera
+    "this is false") ; de lo contrario expression
+; => "this is true"
+
+;; En condicionales, todos los valores que no son #f son tratados como verdadero
+(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo)
+(if (member 'Groucho '(Harpo Groucho Zeppo))
+    'yep
+    'nope)
+; => 'yep
+
+;; Las expresiones 'cond' son una serie de pruebas para seleccionar el resultado
+(cond [(> 2 2) (error "wrong!")]
+      [(< 2 2) (error "wrong again!")]
+      [else 'ok]) ; => 'ok
+
+;;; Coincidencia de patrones (Pattern Matching)
+
+(define (fizzbuzz? n)
+  (match (list (remainder n 3) (remainder n 5))
+    [(list 0 0) 'fizzbuzz]
+    [(list 0 _) 'fizz]
+    [(list _ 0) 'buzz]
+    [_          #f]))
+
+(fizzbuzz? 15) ; => 'fizzbuzz
+(fizzbuzz? 37) ; => #f
+
+;;; Ciclos
+
+;; Los ciclos pueden expresarse a través de recursión (de cola)
+(define (loop i)
+  (when (< i 10)
+    (printf "i=~a\n" i)
+    (loop (add1 i))))
+(loop 5) ; => i=5, i=6, ...
+
+;; De igual forma, con un let
+(let loop ((i 0))
+  (when (< i 10)
+    (printf "i=~a\n" i)
+    (loop (add1 i)))) ; => i=0, i=1, ...
+
+;; El siguiente ejemplo muestra cómo expresar un ciclo for, pero Racket tiene
+;; otra forma aún más flexible de expresarlos:
+(for ([i 10])
+  (printf "i=~a\n" i)) ; => i=0, i=1, ...
+(for ([i (in-range 5 10)])
+  (printf "i=~a\n" i)) ; => i=5, i=6, ...
+
+;;; Iterando sobre otras secuencias
+;; 'for' permite iterar sobre varios tipos de secuencias:
+;; lists, vectors, strings, sets, hash tables, etc...
+
+(for ([i (in-list '(l i s t))])
+  (displayln i))
+
+(for ([i (in-vector #(v e c t o r))])
+  (displayln i))
+
+(for ([i (in-string "string")])
+  (displayln i))
+
+(for ([i (in-set (set 'x 'y 'z))])
+  (displayln i))
+
+(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))])
+  (printf "key:~a value:~a\n" k v))
+
+;;; Iteradores mas sofisticados
+
+;; Escaneo paralelo de múltiples secuencias (se detiene en la más pequeña)
+(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j))
+; => 0:x 1:y 2:z
+
+;; Loops anidados
+(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j))
+; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z
+
+;; Condicionales
+(for ([i 1000]
+      #:when (> i 5)
+      #:unless (odd? i)
+      #:break (> i 10))
+  (printf "i=~a\n" i))
+; => i=6, i=8, i=10
+
+;;; Secuncias por compresión
+;; Muy similar a los ciclos 'for' -- solo recolectando los resultados
+
+(for/list ([i '(1 2 3)])
+  (add1 i)) ; => '(2 3 4)
+
+(for/list ([i '(1 2 3)] #:when (even? i))
+  i) ; => '(2)
+
+(for/list ([i 10] [j '(x y z)])
+  (list i j)) ; => '((0 x) (1 y) (2 z))
+
+(for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10))
+  i) ; => '(6 8 10)
+
+(for/hash ([i '(1 2 3)])
+  (values i (number->string i)))
+; => '#hash((1 . "1") (2 . "2") (3 . "3"))
+
+;; Existen otras formas de recolectar los valores usando otras expresiones:
+(for/sum ([i 10]) (* i i)) ; => 285
+(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000
+(for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t
+(for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t
+;; Y para usar cualquier combinación arbitraria, use 'for/fold'
+(for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10
+;; (Esto frecuentemente reemplaza los ciclos en los lenguajes imperativos)
+
+;;; Excepciones
+
+;; Para atrapar excepciones, usa las funciones 'with-handlers'
+(with-handlers ([exn:fail? (lambda (exn) 999)])
+  (+ 1 "2")) ; => 999
+(with-handlers ([exn:break? (lambda (exn) "no time")])
+  (sleep 3)
+  "phew") ; => "phew", pero si usa un break => "no time"
+
+;; Usa 'raise' para lanzar una excepción o cualquier otro valor
+(with-handlers ([number?    ; atrapa valores numericos lanzados
+                 identity]) ; los retorna como valores
+  (+ 1 (raise 2))) ; => 2
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutación
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Usa 'set!' para asignar un nuevo valor a una variable existente
+(define n 5)
+(set! n (add1 n))
+n ; => 6
+
+;; Usa boxes para valores explícitamente mutables (similar a punteros o
+;; referencias en otros lenguajes)
+(define n* (box 5))
+(set-box! n* (add1 (unbox n*)))
+(unbox n*) ; => 6
+
+;; Muchos tipos de datos en Racket son inmutables (pairs, lists, etc), algunos poseen
+;; ambos sabores mutable e immutable (strings, vectors, hash tables,
+;; etc...)
+
+;; Usa 'vector' o 'make-vector' para crear vectores mutables
+(define vec (vector 2 2 3 4))
+(define wall (make-vector 100 'bottle-of-beer))
+;; Usa vector-set! para actualizar una posición
+(vector-set! vec 0 1)
+(vector-set! wall 99 'down)
+vec ; => #(1 2 3 4)
+
+;; Crea una tabla hash vacía  y manipulata
+(define m3 (make-hash))
+(hash-set! m3 'a 1)
+(hash-set! m3 'b 2)
+(hash-set! m3 'c 3)
+(hash-ref m3 'a)   ; => 1
+(hash-ref m3 'd 0) ; => 0
+(hash-remove! m3 'a)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Modulos
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Los Modulos permiten organizar el código en multiples archivos para reusarlos
+;; en bibliotecas; Aquí usamos sub-modules, anidados en todo el modulo que
+;; este texto hace (empezando desde la línea "#lang")
+
+(module cake racket/base ; definimos un modulo llamado 'cake' basado en racket/base
+
+  (provide print-cake) ; function exportada por el modulo
+
+  (define (print-cake n)
+    (show "   ~a   " n #\.)
+    (show " .-~a-. " n #\|)
+    (show " | ~a | " n #\space)
+    (show "---~a---" n #\-))
+
+  (define (show fmt n ch) ; función interna 
+    (printf fmt (make-string n ch))
+    (newline)))
+
+;; Usa 'require' para obtener todos los nombre que provee un modulo
+(require 'cake) ; el apostrofe ' indica que es un submódulo local
+(print-cake 3)
+; (show "~a" 1 #\A) ; => error, la función 'show' no fue exportada
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 8. Clases y objectos
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Crea una clase llamada fish% (-% Es un una forma de indicar los límites de la clase)
+(define fish%
+  (class object%
+    (init size) ; inicialización del argumento
+    (super-new) ; inicialización de la superclase
+    ;; Campo
+    (define current-size size)
+    ;; Metodos públicos
+    (define/public (get-size)
+      current-size)
+    (define/public (grow amt)
+      (set! current-size (+ amt current-size)))
+    (define/public (eat other-fish)
+      (grow (send other-fish get-size)))))
+
+;; Crea una instancia de la clase fish%
+(define charlie
+  (new fish% [size 10]))
+
+;; Usa 'send' para llamar un método de un objeto
+(send charlie get-size) ; => 10
+(send charlie grow 6)
+(send charlie get-size) ; => 16
+
+;; 'fish%' is a plain "first class" value, which can get us mixins
+(define (add-color c%)
+  (class c%
+    (init color)
+    (super-new)
+    (define my-color color)
+    (define/public (get-color) my-color)))
+(define colored-fish% (add-color fish%))
+(define charlie2 (new colored-fish% [size 10] [color 'red]))
+(send charlie2 get-color)
+;; o, sin nombres:
+(send (new (add-color fish%) [size 10] [color 'red]) get-color)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 9. Macros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Las Macros te permite extender la sintaxis del lenguaje
+
+;; Agreguemos un ciclo while
+(define-syntax-rule (while condition body ...)
+  (let loop ()
+    (when condition
+      body ...
+      (loop))))
+
+(let ([i 0])
+  (while (< i  10)
+    (displayln i)
+    (set! i (add1 i))))
+
+;; Las Macros son higienicas, ¡no puedes aplastar las variables existentes!
+(define-syntax-rule (swap! x y) ; -! es un caracter que indica mutación
+  (let ([tmp x])
+    (set! x y)
+    (set! y tmp)))
+
+(define tmp 2)
+(define other 3)
+(swap! tmp other)
+(printf "tmp = ~a; other = ~a\n" tmp other)
+;; La variable 'tmp' es renombrada a 'tmp_1'
+;; Para evitar el conflicto de nombres
+;; (let ([tmp_1 tmp])
+;;   (set! tmp other)
+;;   (set! other tmp_1))
+
+;; Pero aun hay algunas transfromaciones de código, por ejemplo:
+(define-syntax-rule (bad-while condition body ...)
+  (when condition
+    body ...
+    (bad-while condition body ...)))
+;; Esta macro es incorrecta: genera código infinitamente, si tratas de usarla
+;; el compilador entrará en un ciclo infinito
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 10. Contratos
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Los Contratos imponen restricciones a los valores exportados desde los módulos
+
+(module bank-account racket
+  (provide (contract-out
+            [deposit (-> positive? any)] ; Los montos siempre son positivos
+            [balance (-> positive?)]))
+
+  (define amount 0)
+  (define (deposit a) (set! amount (+ amount a)))
+  (define (balance) amount)
+  )
+
+(require 'bank-account)
+(deposit 5)
+
+(balance) ; => 5
+
+;; El cliente intenta depositar un monto negativo por lo cual es rechazado
+;; (deposit -5) ; => depósito: violación del contrato
+;; expected: positive?
+;; given: -5
+;; more details....
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 11. Entrada y salida
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Racket tiene el concepto de "port", el cual es muy similar al de descriptores
+;; de ficheros en otros lenguajes
+
+;; Abre "/tmp/tmp.txt" y escribe "Hello World"
+;; Esto lanzará un error si el archivo existe
+(define out-port (open-output-file "/tmp/tmp.txt"))
+(displayln "Hello World" out-port)
+(close-output-port out-port)
+
+;; Agregar información a "/tmp/tmp.txt" (incluso si el archivo existe)
+(define out-port (open-output-file "/tmp/tmp.txt"
+                                   #:exists 'append))
+(displayln "Hola mundo" out-port)
+(close-output-port out-port)
+
+;; Lee del archivo de nuevo
+(define in-port (open-input-file "/tmp/tmp.txt"))
+(displayln (read-line in-port))
+; => "Hello World"
+(displayln (read-line in-port))
+; => "Hola mundo"
+(close-input-port in-port)
+
+;; Alternativamente, haciendo uso de call-with-output-file no necesitas expresamente
+;; cerrar el archivo
+(call-with-output-file "/tmp/tmp.txt"
+  #:exists 'update ; Rewrite the content
+  (λ (out-port)
+    (displayln "World Hello!" out-port)))
+
+;; Y usar la función call-with-input-file hace lo mismo para la entrada
+(call-with-input-file "/tmp/tmp.txt"
+  (λ (in-port)
+    (displayln (read-line in-port))))
+```
+
+## Mas información
+
+¿Quieres saber mas? Prueba en [Empezando con Racket](http://docs.racket-lang.org/getting-started/)
+
+
+
+
diff --git a/es-es/ruby-ecosystem-es.html.markdown b/es-es/ruby-ecosystem-es.html.markdown
new file mode 100644
index 00000000..9ce62ef5
--- /dev/null
+++ b/es-es/ruby-ecosystem-es.html.markdown
@@ -0,0 +1,157 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+    - ["Jon Smock", "http://github.com/jonsmock"]
+    - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+    - ["Ale Mohamad", "http://twitter.com/alemohamad"]
+lang: es-es
+---
+
+Las personas que usan Ruby en general tienen una tendencia a instalar diferentes
+versiones de Ruby, administrar sus paquetes (o gemas), y gestionar las
+dependencias de sus gemas.
+
+## Gestores de Ruby
+
+Algunas plataformas ya tienen Ruby pre-instalado o disponible como un paquete
+propio. Muchos rubystas no utilizan estas versiones, o si lo hacen, solo lo
+utilizan para preparar otra instalación o implementación de Ruby. En lugar de
+eso, los rubystas tienden a instalar un gestor de Ruby para poder instalar
+diferentes versiones y poder cambiar dependiendo del entorno de cada proyecto.
+
+Los siguientes son gestores populares de entorno de Ruby:
+
+* [RVM](https://rvm.io/) - Instala y cambia versiones de Ruby. Además RVM tiene
+  el concepto de gemsets para aislar complemtante entornos de proyectos.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Solo instala
+  versiones de Ruby. Se utiliza para tener un control más fino sobre las
+  versiones instaladas de Ruby.
+* [rbenv](https://github.com/sstephenson/rbenv) - Solo se utiliza para cambiar
+  la versión de Ruby. Se utiliza junto con ruby-build. Se utiliza para tener un
+  control más fino sobre cómo se carga Ruby en el sistema.
+* [chruby](https://github.com/postmodern/chruby) - Solo se utiliza para cambiar
+  la versión de Ruby. En espíritu es similar a rbenv. No le es tan importante
+  como son instaladas las versiones de Ruby.
+
+## Versiones de Ruby
+
+Ruby fue creado por Yukihiro "Matz" Matsumoto, quien se mantiene como una
+especie de [BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life),
+aunque recientemente está cambiando. Como resultado, la implementación de
+referencia de Ruby es llamada MRI (Matz' Reference Implementation), y cuando se
+habla de una versión de Ruby, se está haciendo referencia a la versión inicial
+de MRI.
+
+Las tres versiones mayores en uso de Ruby son:
+
+* 2.0.0 - Lanzada en Febrero de 2013. La mayoría de las librerías importantes y
+  frameworks soportan 2.0.0.
+* 1.9.3 - Lanzada en Octubre de 2011. Es la versión que actualmente usan más
+  rubystas. Además fue
+  [retirada](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
+* 1.8.7 - Ruby 1.8.7 fue
+  [retirada](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+El cambio de 1.8.7 a 1.9.x es un cambio mucho mayor que de 1.9.3 a 2.0.0. Por
+ejemplo, la serie 1.9 presentó codificaciones (encodings) y un bytecode VM.
+Todavía hay proyectos que utilizan 1.8.7, pero se están convirtiendo en una
+pequeña minoría, debido a que la mayor parte de la comunidad está utilizando
+como mínimo 1.9.2 o 1.9.3.
+
+## Implementaciones de Ruby
+
+El ecosistema de Ruby disfruta de muchas diferentes implementaciones de Ruby,
+cada una con fortalezas únicas y estados de compatibilidad. Para ser claros, las
+diferentes implementaciones están escritas en diferentes lenguajes, pero *todas
+son Ruby*. Cada implementación tiene hooks especiales y características extra,
+pero todas interpretan archivos Ruby de forma normal. Por ejemplo, JRuby está
+escrito en Java, pero no necesitás saber de Java para poder utilizarla.
+
+Muy maduras/compatibles:
+
+* [MRI](https://github.com/ruby/ruby) - Escrita en C, es la implementación de
+  referencia de Ruby. Por definición es 100% compatible (consigo misma). Las
+  otras implementaciones de Ruby mantienen compatibilidad con MRI (ver
+  [RubySpec](#rubyspec) más abajo).
+* [JRuby](http://jruby.org/) - Escrita en Java y Ruby, esta implementación es
+  robusta y bastante veloz. Más importante, la fortaleza de JRuby reside en la
+  interoperabilidad con JVM/Java, pudiendo utilizar herramientas, proyectos y
+  lenguajes ya existentes en JVM.
+* [Rubinius](http://rubini.us/) - Escrita principalmente en Ruby junto con un
+  bytecode VM de C++. Además es bastante madura y veloz. Debido a que está
+  implementada de forma directa en Ruby, expone varias funcionalidades de VM en
+  rubyland.
+
+Medianamente maduras/compatibles:
+
+* [Maglev](http://maglev.github.io/) - Construida sobre Gemstone, una VM de
+  Smalltalk. Smalltalk tiene herramientas que son impresionantes, y este
+  proyecto intenta llevar eso dentro del desarrollo con Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Lleva Ruby al desarrollo en iOS.
+
+No tan maduras/compatibles:
+
+* [Topaz](http://topazruby.com/) - Escrito en RPython (usando el intérprete
+  PyPy), Topaz es bastante joven y no tan compatible. Se muestra prometedor para
+  ser una implementación de Ruby de alta performance.
+* [IronRuby](http://ironruby.net/) - Escrita en C#, apuntando a la plataforma
+  .NET. El trabajo en IronRuby parece haberse detenido desde que Microsoft
+  retiró su soporte.
+
+Las implementaciones de Ruby pueden tener su propio número de versión de
+release, pero siempre apuntan a una versión específica de MRI para poder tener
+compatibilidad. Muchas implementaciones tienen la habilidad de trabajar en
+diferentes modos (por ejemplo, modo 1.8 o 1.9) para especificar a qué versión de
+MRI están apuntando.
+
+## RubySpec
+
+Muchas implementaciones de Ruby dependen en gran medida de
+[RubySpec](http://rubyspec.org/). Ruby no tiene una especificación oficial, por
+lo que la comunidad ha escrito especificaciones ejecutables en Ruby para poder
+testear la compatibilidad de sus implementaciones con MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) es un manejador de paquetes/comunidad de Ruby.
+RubyGems viene incluido con Ruby, por lo que no hay necesidad de instalarlo por
+separado.
+
+Los paquetes de Ruby son llamados "gemas" ("gems"), y pueden ser alojados por la
+comunidad en RubyGems.org. Cada gema contiene su código fuente y algo de
+metadata, incluyendo cosas como la versión, dependencias, autor(es), y
+licencia(s).
+
+## Bundler
+
+[Bundler](http://bundler.io/) es una herramienta para resolución de dependencias
+de gemas. Utiliza un archivo llamado Gemfile en cada proyecto para poder
+organizar sus dependencias, y luego poder agregar dichas dependencias y sus
+dependencias de forma recursiva. Hace esta acción hasta que resuelve y descarga
+todas las dependencias, o se detiene si es que un conflicto aparece.
+
+Bundler eleva un error si encuentra dependencias conflictivas. Por ejemplo, si
+la gema A requiere la versión 3 o mayor de la gema Z, pero la gema B requiere la
+versión 2, Bundler va a notificarte sobre dicho conflicto. Esto es
+extremadamente útil ya que varias gemas hacen referencia a otras gemas (de las
+cuales puede referenciar a otras gemas), lo cual puede formar un gran grafo de
+dependencias para resolver.
+
+# Testing
+
+Testing es una parte grande dentro de la cultura de Ruby. Ruby incluye su propio
+framework de testing llamado minitest (o TestUnit para la versión 1.8.x de
+Ruby). Hay varias librerías de testing con diferentes objetivos.
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Framework de testing de Ruby 1.8
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Framework de testing de Ruby 1.9/2.0
+* [RSpec](http://rspec.info/) - Un framework de testing que se focaliza en expresividad
+* [Cucumber](http://cukes.info/) - Un framework de testing que utiliza BDD, que parsea tests con formato Gherkin
+
+## Se Amable
+
+La comunidad de Ruby se enorgullece de ser una comunidad abierta, diversa y
+acogedora. Matz mismo es extremadamente amigable, y en general la generosidad de
+los rubystas es increíble.
diff --git a/es-es/rust-es.html.markdown b/es-es/rust-es.html.markdown
new file mode 100644
index 00000000..b43cb815
--- /dev/null
+++ b/es-es/rust-es.html.markdown
@@ -0,0 +1,324 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+    - ["Razican", "https://www.razican.com/"]
+filename: learnrust-es.rs
+lang: es-es
+---
+
+Rust es un lenguaje de programación desarrollado por Mozzilla Research. Rust
+combina el control del rendimiento a bajo nivel con la comodidad del alto nivel
+y garantías de seguridad.
+
+Consigue cumplir estos objetivos sin necesidad de un recolector de basura o
+runtime, haciendo posible usar las librerías de Rust como sustituto de C.
+
+La primera versión de Rust, la 0.1, fue lanzada en enero de 2012, y durante 3
+años el desarrollo fue tan rápido que hasta hace poco el uso de las versiones
+estables no era recomendable, y se aconsejaba usar las compilaciones nocturnas.
+
+El 15 de mayo de 2015 se lanzó Rust 1.0, con una garantía completa de
+retrocompatibilidad. A día de hoy los tiempos de compilación han mejorado mucho
+desde ese lanzamiento, así como otros aspectos del lenguaje y el compilador.
+Rust ha adoptado un modelo de desarrollo por series de publicaciones periódicas,
+con lanzamientos cada 6 semanas. Junto con cada lanzamiento, se lanza la beta de
+la siguiente versión.
+
+A pesar de que Rust es un lenguaje relativamente de bajo nivel, tiene conceptos
+funcionales que generalmente se encuentran en lenguajes de más alto nivel. Esto
+hace que Rust sea rápido y al mismo tiempo fácil y eficiente a la hora de
+programar.
+
+```rust
+// Esto es un comentario. Los comentarios de una sola línea se hacen así...
+/* ...y los de múltiples líneas así */
+
+//////////////////////////
+// 1. Conceptos básicos //
+//////////////////////////
+
+// Funciones
+// `i32` es el tipo para enteros de 32 bits con signo
+fn suma2(x: i32, y: i32) -> i32 {
+    // Retorno implícito (sin punto y coma)
+    x + y
+}
+
+// Función principal
+fn main() {
+    // N;umeros //
+
+    // Bindings (variables) inmutables
+    let x: i32 = 1;
+
+    // Sufijos para enteros / floats
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inferencia de tipos
+    // La mayor parte del tiempo, el compilador de Rust puede inferir el tipo de
+    // una variable, por lo que no necesitas escribir una anotación de tipo
+    // explícita. A lo largo de este tutorial, los tipos están anotados
+    // explícitamente en varios sitios, pero solo con propósito demostrativo. La
+    // inferencia de tipos puede manejar esto por ti la mayor parte del tiempo.
+    let x_implicita = 1;
+    let f_implicita = 1.3;
+
+    // Aritmética
+    let sum = x + y + 13;
+
+    // Variable mutable
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Strings (cadenas de caracteres) //
+
+    // Strings literales
+    let x: &str = "hola mundo!";
+
+    // Impresión por consola
+    println!("{} {}", f, x); // 1.3 hola mundo!
+
+    // Un `String` – una cadena en memoria dinámica (heap)
+    let s: String = "hola mundo".to_string();
+
+    // Una porión de cadena (slice) – una vista inmutable a otra cadena
+    // Esto es básicamente un puntero inmutable a un string string – en realidad
+    // no contiene los caracteres de la cadena, solo un puntero a algo que los
+    // tiene (en este caso, `s`)
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // hola mundo hola mundo
+
+    // Vectores/arrays //
+
+    // A fixed-size array
+    let cuatro_enteros: [i32; 4] = [1, 2, 3, 4];
+
+    // Un array dinámico (vector)
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Una porción (slice) – una vista inmutable a un vector o array
+    // Esto es parecido a un slice de un string, pero para vectores
+    let slice: &[i32] = &vector;
+
+    // Usa `{:?}` para imprimir algo en estilo debug
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuplas //
+
+    // Una tupla es un conjunto de tamaño fijo de valores. Pueden ser de diferente tipo.
+    let x: (i32, &str, f64) = (1, "hola", 3.4);
+
+    // Desestructurando `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 hola 3.4
+
+    // Indexando
+    println!("{}", x.1); // hola
+
+    //////////////
+    // 2. Tipos //
+    //////////////
+
+    // Estructuras
+    struct Punto {
+        x: i32,
+        y: i32,
+    }
+
+    let origen: Punto = Punto { x: 0, y: 0 };
+
+    // Una estructura con campos sin nombre, una ‘estructura de tupla’
+    struct Punto2(i32, i32);
+
+    let origen2 = Punto2(0, 0);
+
+    // Enums básicos como en C
+    enum Direccion {
+        Izquierda,
+        Derecha,
+        Arriba,
+        Abajo,
+    }
+
+    let arriba = Direccion::Arriba;
+
+    // Enum con campos
+    enum OpcionalI32 {
+        UnI32(i32),
+        Nada,
+    }
+
+    let dos: OpcionalI32 = OpcionalI32::UnI32(2);
+    let nada = OpcionalI32::Nada;
+
+    // Genéricos //
+
+    struct Foo<T> { bar: T }
+
+    // Esto está definido en la librería estándar como `Option`
+    enum Opcional<T> {
+        AlgunVal(T),
+        SinVal,
+    }
+
+    // Métodos //
+
+    impl<T> Foo<T> {
+        // Los métodos reciben un parámetro explícito `self`
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let un_foo = Foo { bar: 1 };
+    println!("{}", un_foo.get_bar()); // 1
+
+    // Traits (conocidos como interfaces o typeclasses en otros lenguajes) //
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let otro_foo = Foo { bar: 1 };
+    println!("{:?}", otro_foo.frobnicate()); // Some(1)
+
+    /////////////////////////////////
+    // 3. Comparación con patrones //
+    /////////////////////////////////
+
+    let foo = OpcionalI32::UnI32(1);
+    match foo {
+        OpcionalI32::UnI32(n) => println!("es un i32: {}", n),
+        OpcionalI32::Nada  => println!("no es nada!"),
+    }
+
+    // comparación de patrones avanzada
+    struct FooBar { x: i32, y: OpcionalI32 }
+    let bar = FooBar { x: 15, y: OpcionalI32::UnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OpcionalI32::UnI32(0) } =>
+            println!("Los números son cero!"),
+        FooBar { x: n, y: OpcionalI32::UnI32(m) } if n == m =>
+            println!("Los números son iguales"),
+        FooBar { x: n, y: OpcionalI32::UnI32(m) } =>
+            println!("Números diferentes: {} {}", n, m),
+        FooBar { x: _, y: OpcionalI32::Nada } =>
+            println!("El segudo número no es nada!"),
+    }
+
+    /////////////////////////
+    // 4. Flujo de control //
+    /////////////////////////
+
+    // bucles `for`
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Rangos
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // imprime `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Las matemáticas funcionan!");
+    } else {
+        println!("Oh no...");
+    }
+
+    // `if` como una expresión
+    let valor = if true {
+        "bueno"
+    } else {
+        "malo"
+    };
+
+    // bucle `while`
+    while 1 == 1 {
+        println!("El universo está funcionando correctamente.");
+    }
+
+    // Bucle infinito
+    loop {
+        println!("Hola!");
+    }
+
+    ////////////////////////////////////////
+    // 5. Seguridad de memoria y punteros //
+    ////////////////////////////////////////
+
+    // Posesión de punteros – solo uno puede ‘poseer’ un puntero en cada momento
+    // Esto significa que cuando la `Box` queda fuera del ámbito, puede ser
+    // liberada automáticamente de manera segura.
+    let mut mio: Box<i32> = Box::new(3);
+    *mio = 5; // dereferenciar
+    // Aquí, `ahora_es_mio`, toma posesión de `mio`. En otras palabras, `mio` se
+    // mueve.
+    let mut ahora_es_mio = mio;
+    *ahora_es_mio += 2;
+
+    println!("{}", ahora_es_mio); // 7
+    // println!("{}", mio); // esto no compilaría, porque `now_its_mine` es el
+    // que posee el puntero
+
+    // Referencia – un puntero inmutable que referencia a otro dato
+    // Cuando se crea una referencia a un valor, decimos que el valor ha sido
+    // ‘tomado prestado’.
+    // Mientras un valor está prestado como inmutable, no puede ser modificado o
+    // movido.
+    // Una prestación dura hasta el fin del ámbito en el que se creó.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // A diferencia de `mio`, `var` se puede seguir usando
+    println!("{}", *ref_var);
+    // var = 5; // esto no compilaría, porque `var` está prestada
+    // *ref_var = 6; // esto tampoco, porque `ref_var` es una referencia
+    // inmutable
+
+    // Referencia mutable
+    // Mientras que un valor está prestado como mutable, no puede ser accedido
+    // desde ningún otro sitio.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2; // '*' se usa para apuntar al var2 prestado como mutable
+
+    println!("{}", *ref_var2); // 6 , //var2 no compilaría. //ref_var2 es de
+                               // tipo &mut i32, por lo que guarda una
+                               // referencia a un i32 no el valor.
+    // var2 = 2; // esto no compilaría porque `var2` está prestado
+}
+```
+
+## Lectura adicional
+
+Rust es mucho más que esto. Esto es solo lo más básico para que puedas entender
+las cosas más importantes. Para aprender más sobre Rust, lee [The Rust
+Programming Language](http://doc.rust-lang.org/book/index.html) y echa un
+vistazo al subreddit [/r/rust](http://reddit.com/r/rust). Los compañeros en el
+canal #rust en irc.mozilla.org también son muy buenos con los recien llegados.
+También puedes acceder a [Rust users](https://users.rust-lang.org/) a pedir
+ayuda o a [Rust internals](https://internals.rust-lang.org/) para aprender más
+sobre el lenguaje y colaborar en su desarrollo.
+
+También puedes probar Rust con un compilador online en el oficial [Rust
+playpen](http://play.rust-lang.org) o en la [web principal de
+Rust](http://rust-lang.org).
diff --git a/es-es/sass-es.html.markdown b/es-es/sass-es.html.markdown
new file mode 100644
index 00000000..89e56ba5
--- /dev/null
+++ b/es-es/sass-es.html.markdown
@@ -0,0 +1,585 @@
+---
+language: sass
+filename: learnsass.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+  - ["Kyle Mendes", "https://github.com/pink401k"]
+  - ["Keith Miyake", "https://github.com/kaymmm"]
+translators:
+  - ["César Suárez", "https://github.com/csuarez"]
+lang: es-es
+---
+
+Sass es un lenguaje que extiende CSS y que añade características tales como variables, anidación, mixins y más. Sass (y otros preprocesadores tales como [Less](http://lesscess.org/)) ayudan a los desarrolladores a escribir código mantenible y DRY (Don't Repeat Yourself).
+
+Sass tiene dos sintaxis para elegir: SCSS, que usa la misma que CSS pero con las características añadidas de Sass, y Sass (la sintaxis original) que usa identación en vez de llaves y puntos y comas. Este tutorial está escrito en SCSS.
+
+Si ya estás familiarizado con CSS3, vas a entender Sass relativamente rápido. Sass no ofrece nuevas propiedades de estilo, si no que añade herramientas para escribir tus CSS de manera más eficiente, haciendo su mantenimiento mucho más sencillo.
+
+```scss
+
+
+//Los comentarios en una sola línea son eliminados cuando Sass es compilado a CSS.
+
+/* Los comentarios multi-línea se mantienen. */
+
+
+
+/* Variables
+============================== */
+
+
+/* Puedes almacenar valores CSS (como un color) en una variable.
+Usa el símbolo '$' para crear una variable */
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Puedes usar las variables a lo largo de tu hoja de estilos.
+Ahora, si quieres cambiar el color, sólo lo tienes que hacer una vez. */
+
+body {
+	background-color: $primary-color;
+	color: $secondary-color;
+	font-family: $body-font;
+}
+
+/* Este código compilará en: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+/* El resultado es mucho más mantenible que tener que cambiar el color
+cada vez que aparece en la hoja de estilos. */
+
+
+
+/* Directivas de control
+============================== */
+
+
+/* Sass permite usar @if, @else, @for, @while, y @each para controlar la
+   compilación de tu código en CSS. */
+
+/* Los bloques @if/@else se comportan tal como es de esperar */
+
+$debug: true !default;
+
+@mixin debugmode {
+	@if $debug {
+		@debug "Modo debug activado";
+
+		display: inline-block;
+	}
+	@else {
+		display: none;
+	}
+}
+
+.info {
+	@include debugmode;
+}
+
+/* Si $debug es true, .info es mostrado; si es false entonces
+no se muestra.
+
+Nota: @debug mostrará información de depuración en la consola.
+Es muy útil para ver el contenido de tus variables cuando estás depurando. */
+
+.info {
+	display: inline-block;
+}
+
+/* @for es un bucle que itera un conjunto de valores.
+Es particularmente útil para dar estilos a una colección de objetos.
+Hay dos formas "through" y "to". El primero incluye el último valor
+mientras que el segundo para antes del último valor. */
+
+@for $c from 1 to 4 {
+	div:nth-of-type(#{$c}) {
+		left: ($c - 1) * 900 / 3;
+	}
+}
+
+@for $c from 1 through 3 {
+	.myclass-#{$c} {
+		color: rgb($c * 255 / 3, $c * 255 / 3, $c * 255 / 3);
+	}
+}
+
+/* Esto compila en: */
+
+div:nth-of-type(1) {
+	left: 0;
+}
+
+div:nth-of-type(2) {
+	left: 300;
+}
+
+div:nth-of-type(3) {
+	left: 600;
+}
+
+.myclass-1 {
+	color: #555555;
+}
+
+.myclass-2 {
+	color: #aaaaaa;
+}
+
+.myclass-3 {
+	color: white;
+// SASS convierte automáticamente #FFFFFF a white
+}
+
+/* @while es bastante sencillo: */
+
+$columns: 4;
+$column-width: 80px;
+
+@while $columns > 0 {
+	.col-#{$columns} {
+		width: $column-width;
+		left: $column-width * ($columns - 1);
+	}
+
+	$columns: $columns - 1;
+}
+
+/* Esto se convierte en el siguiente CSS: */
+
+.col-4 {
+	width: 80px;
+	left: 240px;
+}
+
+.col-3 {
+	width: 80px;
+	left: 160px;
+}
+
+.col-2 {
+	width: 80px;
+	left: 80px;
+}
+
+.col-1 {
+	width: 80px;
+	left: 0px;
+}
+
+/* @each funciona parecido a @for, pero usa una lista en ver del valor ordinal
+Nota: puedes especificar listas como cualquier otra variable usando espacios
+como delimitadores. */
+
+$social-links: facebook twitter linkedin reddit;
+
+.social-links {
+	@each $sm in $social-links {
+		.icon-#{$sm} {
+			background-image: url("images/#{$sm}.png");
+		}
+	}
+}
+
+/* Esto resultará en: */
+
+.social-links .icon-facebook {
+	background-image: url("images/facebook.png");
+}
+
+.social-links .icon-twitter {
+	background-image: url("images/twitter.png");
+}
+
+.social-links .icon-linkedin {
+	background-image: url("images/linkedin.png");
+}
+
+.social-links .icon-reddit {
+	background-image: url("images/reddit.png");
+}
+
+
+
+/* Mixins
+==============================*/
+
+
+/* Si te encuentras con que estás escribiendo el mismo código en más de un
+elemento, puede que quieras almacenarlo en un mixin.
+
+Usa la directiva '@mixin', más un nombre para tu mixin. */
+
+@mixin center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Puedes usarlo con '@include' y el nombre del mixin. */
+
+div {
+	@include center;
+	background-color: $primary-color;
+}
+
+/* Esto compilará en: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+/* Puedes usar mixins para crear una propiedad shorthand. */
+
+@mixin size($width, $height) {
+	width: $width;
+	height: $height;
+}
+
+/* La que puedes invocar pasándole los argumentos width y height. */
+
+.rectangle {
+	@include size(100px, 60px);
+}
+
+.square {
+	@include size(40px, 40px);
+}
+
+/* Compila en: */
+.rectangle {
+  width: 100px;
+  height: 60px;
+}
+
+.square {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+/* Funciones
+============================== */
+
+
+/* Sass ofrece funciones que pueden ser usadas para realizar una gran variedad
+   de tareas. Por ejemplo: */
+
+/* Se pueden invocar funciones usando su nombre y pasándole los
+   argumentos requeridos. */
+body {
+  width: round(10.25px);
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25);
+}
+
+/* Compila en: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Puedes definir tus propias funciones. Las funciones son muy similares a
+   los mixins. Cuando tengas que elegir entre una función y un mixin, recuerda
+   que los mixins son mejores para generar CSS, mientras que las funciones son
+   mejores para la lógica que puedas necesitar en tu código Sass. Los ejemplos
+   de la sección 'Operadores matemáticos' son candidatos ideales para ser
+   usados como una función reusable. */
+
+/* Esta función toma un tamaño objetivo y el tamaño de un padre y
+  devuelve el porcentaje. */
+
+@function calculate-percentage($target-size, $parent-size) {
+  @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+  width: $main-content;
+}
+
+.sidebar {
+  width: calculate-percentage(300px, 960px);
+}
+
+/* Compila en: */
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+
+
+/* Extender (Herencia)
+============================== */
+
+
+/* Extend es una manera de compartir propiedades de un selector con otro. */
+
+.display {
+	@include size(5em, 5em);
+	border: 5px solid $secondary-color;
+}
+
+.display-success {
+	@extend .display;
+	border-color: #22df56;
+}
+
+/* Compila en: */
+.display, .display-success {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.display-success {
+  border-color: #22df56;
+}
+
+/* Extender una declaración CSS es preferible a crear un mixin
+   debido a la manera en la que Sass agrupa las clases que comparten
+   los mismos estilos base. Si esto fuese hecho con un mixin, el ancho,
+   alto y el borden aparecerían duplicados para cada una de las declaraciones
+   que usasen el mixin. Esto no afectará a tu workflow, pero infla
+   innecesariamente los ficheros generados por el compilador Sass. */
+
+
+
+/* Anidación
+============================== */
+
+
+/* Sass permite anidar selectores dentro de otros selectores. */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;
+	}
+}
+
+/* '&' será reemplazado por el selector del padre. */
+
+/* También puedes anidar seudo clases. */
+
+/* Ten en cuenta que anidar demasiado hará tu código menos mantenible.
+Como buena práctica, se recomienda no tener más de 3 niveles de anidación.
+Por ejemplo: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Compila en: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* Parciales e importaciones
+============================== */
+
+
+/* Sass permite que crees ficheros parciales. Esto te puede ayudar a mantener
+   tu código Sass modularizado. Los ficheros parciales deben comenzar por '_',
+   p.e. _reset.css.
+   Los parciales no son convertidos en CSS. */
+
+/* Mira este al que vamos a añadir un fichero llamado _reset.css */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Con @import puedes importar parciales a un fichero. Este se diferencia del
+   @import de CSS en que no hace otra petición HTTP para importar el fichero.
+   Sass, sino que combina el código importado en el código compilado. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compila en: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Placeholders
+============================== */
+
+
+/* Los placeholders son útiles cuando estás creando una declaración CSS a
+   extender. Si quieres crear una declaración que sólo va a ser usada con @extend,
+   puedes hacerlo mediante un placeholder. Los placeholders comienzan con '%'
+   en vez de '.' o '#'. Esto no aparecen en el código CSS compilado. */
+
+%content-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  @extend %content-window;
+  background-color: #0000ff;
+}
+
+/* Compila en: */
+
+.message-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  background-color: #0000ff;
+}
+
+
+
+/* Operaciones matemáticas
+============================== */
+
+
+/* Sass provee los siguientes operadores: +, -, *, / y %. Estos son útiles
+   para calcular valores directamente en tu código Sass en vez de usar valores
+   calculados a mano. Mira el siguiente ejemplo que prepara un sencillo diseño
+   de dos columnas. */
+
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: $main-size;
+}
+
+.sidebar {
+  width: $sidebar-size;
+}
+
+.gutter {
+  width: $gutter;
+}
+
+/* Compila en: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+```
+
+## ¿SASS o Sass?
+¿Alguna vez has pensado si Sass es un acrónimo o no? Seguramente no, pero te lo vamos a explicar de todas maneras. "Sass" es una palabra, no un acrónimo.
+Como todo el mundo lo escribe como "SASS", el creador del lenguaje lo ha llamado de broma "Syntactically Awesome StyleSheets" (Hojas de estilo sintácticamente increíbles).
+
+
+## Practica Sass
+Si quieres probar Sass en tu navegador, prueba  [SassMeister](http://sassmeister.com/).
+Puedes usar cualquier sintaxis, o elegir en la configuración entre Sass y SCSS.
+
+## Compatibilidad
+Sass puede ser usado en cualquier proyecto mientras tengas un programa que lo compile en CSS. Quizás quieras comprobar si el CSS que estás usando es compatible con tus navegadores objetivo.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) y [CanIUse](http://caniuse.com) son buenos recursos para comprobar la compatibilidad de navegadores.
+
+
+## Más información
+* [Documentación oficial (EN)](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way (EN)](http://thesassway.com/) tiene tutoriales (para principiantes y avanzandos) and artículos.
diff --git a/es-es/self-es.html.markdown b/es-es/self-es.html.markdown
new file mode 100644
index 00000000..11972214
--- /dev/null
+++ b/es-es/self-es.html.markdown
@@ -0,0 +1,163 @@
+---
+language: self
+contributors:
+    - ["Russell Allen", "http://github.com/russellallen"]
+filename: learnself-es.self
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+Self es un lenguaje OO basado en prototipo rápido que corre en su propio vm JIT. La mayoría del desarrollo se hace a través de la interacción con objetos vivos en un entorno de desarrollo visual llamado *morphic* que tiene integrado navegador y depurador.
+
+Todo en Self es un objeto. Todos los cómputos son hechos enviando mensajes a los objetos. En Self se puede entender por Objetos a los conjuntos de pares clave-valor.
+
+# Construyendo objetos
+
+El intérprete incorporado de Self puede construir objetos, incluyendo objetos-métodos.
+
+```
+"Esto es un comentario"
+
+"Una cadena de caracteres (string):"
+'Esto es un string con \'caracteres\' escapados.\n'
+
+"Un entero de 30 bits"
+23
+
+"Un decimal de 30 bits"
+3.2
+
+"-20"
+-14r16
+
+"Un objeto que solo entiende un mensaje, 'x' que regresa 20"
+(|
+  x = 20.
+|)
+
+"Un objeto que además entiende 'x:' que establece la posición x"
+(|
+  x <- 20.
+|)
+
+"Un objeto que entiende el método 'doubleX' el cual
+duplica el valor de x y luego regresa el objeto"
+(|
+  x <- 20.
+  doubleX = (x: x * 2. self)
+|)
+
+"Un objeto que entiende todos los mensajes
+que 'traits point' entiende". El intérprete
+mira a 'traits point' enviando los mensajes
+'traits' y luego 'point' a un objeto conocido llamado
+el 'lobby'. El mira el objeto 'true' enviando
+también el mensaje 'true' al lobby."
+(|     parent* = traits point.
+       x = 7.
+       y <- 5.
+       isNice = true.
+|)
+```
+
+# Enviando mensajes a los objetos
+
+Los mensajes pueden ser unarios, binarios o palabras clave. La precedencia es en ese orden. A diferencia de Smalltalk, la precedencia de los mensajes binarios debe ser especificada, y todas las palabras clave después de la primera deben comenzar con una letra mayúscula. Los mensajes se separan de sus destinos mediante espacios en blanco.
+
+```
+"mensaje unario, envía 'printLine' al objeto '23'
+que imprime el string '23' en stdout y regresa el objeto recibido (ejem 23)"
+23 printLine
+
+"envía el mensaje '+' con '7' para '23', luego el mensaje '*' con '8' para el resultado"
+(23 + 7) * 8
+
+"envía 'power:' para '2' con '8' regresa 256"
+2 power: 8
+
+"envía 'keyOf:IfAbsent:' para 'hello' con los argumentos 'e' y '-1'.
+Regresa 1, el índice de 'e' en 'hello'."
+'hello' keyOf: 'e' IfAbsent: -1
+```
+
+# Bloques
+
+Self define el control de flujo como Smalltalk y Ruby mediante bloques Los bloques son cómputos demorados de la forma.:
+
+```
+[|:x. localVar| x doSomething with: localVar]
+```
+
+Ejemplos del uso de bloques:
+
+```
+"regresa 'HELLO'"
+'hello' copyMutable mapBy: [|:c| c capitalize]
+
+"regresa 'Nah'"
+'hello' size > 5 ifTrue: ['Yay'] False: ['Nah']
+
+"regresa 'HaLLO'"
+'hello' copyMutable mapBy: [|:c|
+   c = 'e' ifTrue: [c capitalize]
+            False: ['a']]
+```
+
+Las expresiones múltiples son separadas por un punto. ^ retorna inmediatamente.
+
+```
+"returns An 'E'! How icky!"
+'hello' copyMutable mapBy: [|:c. tmp <- ''|
+   tmp: c capitalize.
+   tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!'].
+   c capitalize
+   ]
+```
+
+Los bloques son ejecutados al enviales el mensaje 'value' y son inherentes (delegados a) sus contextos:
+```
+"returns 0"
+[|x|
+    x: 15.
+    "Envía repetidamente 'value' al primer bloque mientras el resultado de enviar 'value' al segundo bloque es el objeto 'true'"
+    [x > 0] whileTrue: [x: x - 1].
+    x
+] value
+```
+
+# Métodos
+
+Los métodos son como los bloques pero no están dentro de un contexto sino que son almacenados como valores de ranuras. A diferencia de Smalltalk, los métodos no regresan por defecto 'self' sino su valor final.
+
+```
+"Aquí tenemos un objeto con una ranura asignable 'x' y un método 'reduceXTo: y'.
+Enviando el mensaje 'reduceXTo: 10' a este objeto pondrá
+el objeto '10' en la ranura 'x' y regresará el objeto original"
+(|
+    x <- 50.
+    reduceXTo: y = (
+        [x > y] whileTrue: [x: x - 1].
+        self)
+|)
+.
+```
+
+# Prototipos
+
+Self no posee clases. La forma de acceder a un objeto es encontrando un prototipo y copiándolo.
+
+```
+| d |
+d: dictionary copy.
+d at: 'hello' Put: 23 + 8.
+d at: 'goodbye' Put: 'No!.
+"Prints No!"
+( d at: 'goodbye' IfAbsent: 'Yes! ) printLine.
+"Prints 31"
+( d at: 'hello' IfAbsent: -1 ) printLine.
+```
+
+# Para mayor información
+
+El [Manual de Self](http://handbook.selflanguage.org) tiene mucha más información, y nada mejor que experiencia de primera mano con Self descargándolo de su [página web](http://www.selflanguage.org).
diff --git a/es-es/swift-es.html.markdown b/es-es/swift-es.html.markdown
index c04ab02b..8f63517a 100644
--- a/es-es/swift-es.html.markdown
+++ b/es-es/swift-es.html.markdown
@@ -12,7 +12,7 @@ filename: learnswift-es.swift
 ---
 
 Swift es un lenguaje de programación para el desarrollo en iOS y OS X creado
-por Apple. Diseñado para coexistir con Objective-C y ser más resistente contra 
+por Apple. Diseñado para coexistir con Objective-C y ser más resistente contra
 el código erroneo, Swift fue introducido en el 2014 en el WWDC, la conferencia
 de desarrolladores de Apple.
 
@@ -27,13 +27,13 @@ import UIKit
 // MARK: Básicos
 //
 
-// XCode soporta referencias para anotar tu código y agregarlos a lista de la 
+// XCode soporta referencias para anotar tu código y agregarlos a lista de la
 // barra de saltos.
 // MARK: Marca de sección
 // TODO: Hacer algo pronto
 // FIXME: Arreglar este código
 
-// En Swift 2, println y print fueron combinados en un solo método print. 
+// En Swift 2, println y print fueron combinados en un solo método print.
 // Print añade una nueva línea automáticamente.
 print("Hola, mundo") // println ahora es print
 print("Hola, mundo", appendNewLine: false) // print sin agregar nueva línea
@@ -46,18 +46,18 @@ let øπΩ = "value" // nombres de variable unicode
 let π = 3.1415926
 let convenience = "keyword" // nombre de variable contextual
 // Las declaraciones pueden ser separadas por punto y coma (;)
-let weak = "keyword"; let override = "another keyword" 
-// Los acentos abiertos (``) permiten utilizar palabras clave como nombres de 
+let weak = "keyword"; let override = "another keyword"
+// Los acentos abiertos (``) permiten utilizar palabras clave como nombres de
 // variable
-let `class` = "keyword" 
+let `class` = "keyword"
 let explicitDouble: Double = 70
 let intValue = 0007 // 7
 let largeIntValue = 77_000 // 77000
 let label = "some text " + String(myVariable) // Conversión (casting)
-let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolación de string 
+let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolación de string
 
 // Valores específicos de la compilación (build)
-// utiliza la configuración -D 
+// utiliza la configuración -D
 #if false
     print("No impreso")
     let buildValue = 3
@@ -67,13 +67,13 @@ let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolación de string
 print("Build value: \(buildValue)") // Build value: 7
 
 /*
-    Las opcionales son un aspecto del lenguaje Swift que permite el 
+    Las opcionales son un aspecto del lenguaje Swift que permite el
     almacenamiento de un valor `Some` (algo) o `None` (nada).
-    
-    Debido a que Swift requiere que cada propiedad tenga un valor, 
-    hasta un valor 'nil' debe de ser explicitamente almacenado como un 
+
+    Debido a que Swift requiere que cada propiedad tenga un valor,
+    hasta un valor 'nil' debe de ser explicitamente almacenado como un
     valor opcional.
-    
+
     Optional<T> es un enum.
 */
 var someOptionalString: String? = "opcional" // Puede ser nil
@@ -85,7 +85,7 @@ if someOptionalString != nil {
     if someOptionalString!.hasPrefix("opt") {
         print("Tiene el prefijo")
     }
-    
+
     let empty = someOptionalString?.isEmpty
 }
 someOptionalString = nil
@@ -104,14 +104,14 @@ if let someOptionalStringConstant = someOptionalString {
 
 // Swift tiene soporte de almacenamiento para cualquier tipo de valor.
 // AnyObject == id
-// A diferencia de Objective-C `id`, AnyObject funciona con cualquier 
+// A diferencia de Objective-C `id`, AnyObject funciona con cualquier
 // valor (Class, Int, struct, etc)
 var anyObjectVar: AnyObject = 7
 anyObjectVar = "Cambiado a un valor string, no es buena práctica, pero posible."
 
 /*
     Comentar aquí
-    
+
     /*
         Comentarios anidados también son soportados
     */
@@ -122,8 +122,8 @@ anyObjectVar = "Cambiado a un valor string, no es buena práctica, pero posible.
 //
 
 /*
-    Tipos Array (arreglo) y Dictionary (diccionario) son structs (estructuras). 
-    Así que `let` y `var` también indican si son mudables (var) o 
+    Tipos Array (arreglo) y Dictionary (diccionario) son structs (estructuras).
+    Así que `let` y `var` también indican si son mudables (var) o
     inmutables (let) durante la declaración de sus tipos.    
 */
 
@@ -173,7 +173,7 @@ for i in -1...shoppingList.count {
 shoppingList[1...2] = ["steak", "peacons"]
 // Utilizar ..< para excluir el último valor
 
-// Ciclo while 
+// Ciclo while
 var i = 1
 while i < 1000 {
     i *= 2
@@ -224,7 +224,7 @@ func greet(name: String, day: String) -> String {
 }
 greet("Bob", "Martes")
 
-// Similar a lo anterior, a excepción del compartamiento de los parámetros 
+// Similar a lo anterior, a excepción del compartamiento de los parámetros
 // de la función
 func greet2(requiredName: String, externalParamName localParamName: String) -> String {
     return "Hola \(requiredName), hoy es el día \(localParamName)"
@@ -312,7 +312,7 @@ print(numbers) // [3, 6, 18]
 // Las estructuras y las clases tienen capacidades similares
 struct NamesTable {
     let names = [String]()
-    
+
     // Subscript personalizado
     subscript(index: Int) -> String {
         return names[index]
@@ -343,7 +343,7 @@ public class Shape {
 
 internal class Rect: Shape {
     var sideLength: Int = 1
-    
+
     // Getter y setter personalizado
     private var perimeter: Int {
         get {
@@ -354,13 +354,13 @@ internal class Rect: Shape {
             sideLength = newValue / 4
         }
     }
-    
-    // Lazily loading (inicialización bajo demanda) a una propiedad 
+
+    // Lazily loading (inicialización bajo demanda) a una propiedad
     // subShape queda como nil (sin inicializar) hasta que getter es llamado
     lazy var subShape = Rect(sideLength: 4)
-    
+
     // Si no necesitas un getter y setter personalizado
-    // pero aún quieres ejecutar código antes y después de hacer get o set 
+    // pero aún quieres ejecutar código antes y después de hacer get o set
     // a una propiedad, puedes utilizar `willSet` y `didSet`    
     var identifier: String = "defaultID" {
         // El argumento `willSet` será el nombre de variable para el nuevo valor
@@ -368,20 +368,20 @@ internal class Rect: Shape {
             print(someIdentifier)
         }
     }
-    
+
     init(sideLength: Int) {
         self.sideLength = sideLength
-        // Siempre poner super.init de último al momento de inicializar propiedades 
+        // Siempre poner super.init de último al momento de inicializar propiedades
         // personalizadas
         super.init()
     }
-    
+
     func shrink() {
         if sideLength > 0 {
-            --sideLength
+            sideLength -= 1
         }
     }
-    
+
     override func getArea() -> Int {
         return sideLength * sideLength
     }
@@ -413,13 +413,13 @@ class Circle: Shape {
     override func getArea() -> Int {
         return 3 * radius * radius
     }
-    
+
     // Un signo de interrogación como sufijo después de `init` es un init opcional
     // que puede devolver nil    
     init?(radius: Int) {
         self.radius = radius
         super.init()
-        
+
         if radius <= 0 {
             return nil
         }
@@ -457,11 +457,11 @@ enum Suit {
     }
 }
 
-// Los valores de enum permite la sintaxis corta, sin necesidad de poner 
+// Los valores de enum permite la sintaxis corta, sin necesidad de poner
 // el tipo del enum cuando la variable es declarada de manera explícita
 var suitValue: Suit = .Hearts
 
-// Enums de tipo no-entero requiere asignaciones de valores crudas directas 
+// Enums de tipo no-entero requiere asignaciones de valores crudas directas
 enum BookName: String {
     case John = "John"
     case Luke = "Luke"
@@ -474,7 +474,7 @@ enum Furniture {
     case Desk(height: Int)
     // Asociación con String e Int
     case Chair(String, Int)
-    
+
     func description() -> String {
         switch self {
         case .Desk(let height):
@@ -496,7 +496,7 @@ print(chair.description())    // "Chair of Foo with 40 cm"
 //
 
 // `protocol` puede requerir que los tipos tengan propiedades
-// de instancia específicas, métodos de instancia, métodos de tipo, 
+// de instancia específicas, métodos de instancia, métodos de tipo,
 // operadores, y subscripts
 
 
@@ -514,13 +514,13 @@ protocol ShapeGenerator {
 
 class MyShape: Rect {
     var delegate: TransformShape?
-    
+
     func grow() {
         sideLength += 2
 
-        // Pon un signo de interrogación después de la propiedad opcional, 
-        // método, o subscript para ignorar un valor nil y devolver nil 
-        // en lugar de  tirar un error de tiempo de ejecución 
+        // Pon un signo de interrogación después de la propiedad opcional,
+        // método, o subscript para ignorar un valor nil y devolver nil
+        // en lugar de  tirar un error de tiempo de ejecución
         // ("optional chaining")        
         if let allow = self.delegate?.canReshape?() {
             // test for delegate then for method
@@ -536,7 +536,7 @@ class MyShape: Rect {
 
 // `extension`: Agrega funcionalidades a tipos existentes
 
-// Square ahora se "conforma" al protocolo `Printable` 
+// Square ahora se "conforma" al protocolo `Printable`
 extension Square: Printable {
     var description: String {
         return "Area: \(self.getArea()) - ID: \(self.identifier)"
@@ -550,7 +550,7 @@ extension Int {
     var customProperty: String {
         return "This is \(self)"
     }
-    
+
     func multiplyBy(num: Int) -> Int {
         return num * self
     }
@@ -589,7 +589,7 @@ prefix func !!! (inout shape: Square) -> Square {
 // Valor actual
 print(mySquare.sideLength) // 4
 
-// Cambiar la longitud del lado utilizando el operador !!!, 
+// Cambiar la longitud del lado utilizando el operador !!!,
 // incrementa el tamaño por 3
 !!!mySquare
 print(mySquare.sideLength) // 12
diff --git a/es-es/tmux.html.markdown b/es-es/tmux.html.markdown
new file mode 100644
index 00000000..aaa4cb59
--- /dev/null
+++ b/es-es/tmux.html.markdown
@@ -0,0 +1,242 @@
+---
+category: tool
+tool: tmux
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+translators:
+    - ["Ferran Pelayo", "https://github.com/ferranpm"]
+filename: LearnTmux-es.txt
+lang: es-es
+---
+
+[tmux](http://tmux.sourceforge.net) permite crear, controlar y acceder a
+multiples terminales desde una sola ventana.  Puede desconectarse una sesión de
+la ventana, seguir corriendo en segundo plano y volver a conectar otra ventana
+más tarde.
+
+
+```
+
+  tmux [command]     # Correr un comando de tmux
+                     # 'tmux' sin comando crea una nueva sesión.
+
+    new              # Crear una nueva sesión
+     -s "Session"    # Crear una sesión con nombre
+     -n "Window"     # Crear una ventana con nombre
+     -c "/dir"       # Empezar en el directorio "/dir"
+
+    attach           # Atar la ventana a la ultima sesión iniciada
+     -t "#"          # Atar la ventana a la sesión "#"
+     -d              # Desatar la ventana de la sesión
+
+    ls               # Listar las sesiones abiertas
+     -a              # Listar todas las sesiones abiertas
+
+    lsw              # Listar ventanas
+     -a              # Listar todas las ventanas
+     -s              # Listar todas las ventanas de la sesión
+
+    lsp              # Listar paneles
+     -a              # Listar todos los paneles
+     -s              # Listar todos los paneles de la sesión
+     -t              # Listar paneles de la aplicación en el target
+
+    kill-window      # Eliminar la ventana actual
+     -t "#"          # Eliminar la ventana "#"
+     -a              # Eliminar todas las ventanas
+     -a -t "#"       # Eliminar todas las ventanas menos la "#"
+
+    kill-session     # Eliminar la sesión actual
+     -t "#"          # Eliminar la sesión "#"
+     -a              # Eliminar todas las sessiones
+     -a -t "#"       # Eliminar todas las sessiones menos la "#"
+
+```
+
+
+### Atajos de teclado
+
+Para controlar una sesión atada se usa la combinación llamada 'Prefijo' + atajo.
+
+```
+----------------------------------------------------------------------
+  (C-b) = Ctrl + b    # 'Prefijo' por defecto requerido para usar los atajos
+
+  (M-1) = Meta + 1 -o- Alt + 1
+----------------------------------------------------------------------
+
+  ?                  # Listar todos los atajos de teclado
+  :                  # Insertar un comando de tmux
+  r                  # Forzar refresco gráfico del cliente
+  c                  # Crear una nueva ventana
+
+  !                  # Quitar el panel actual de la ventana
+  %                  # Dividir el panel actual en dos (derecha e izquierda)
+  "                  # Dividir el panel actual en dos (arriba y abajo)
+
+  n                  # Cambiar a la siguiente ventana
+  p                  # Cambiar a la ventana anterior
+  {                  # Cambiar el panel por el panel anterior
+  }                  # Cambiar el panel por el siguiente panel
+
+  s                  # Seleccionar y atar el cliente a una sesión distinta
+                     de forma interactiva
+  w                  # Seleccionar una ventana de forma interactiva
+  0 to 9             # Seleccionar una ventana (del 0 al 9)
+
+  d                  # Desatar el cliente actual de la sesión
+  D                  # Escojer un cliente a desatar
+
+  &                  # Eliminar la ventana actual
+  x                  # Eliminar el panel actual
+
+  Up, Down           # Cambiar al panel de arriba, debajo, izquierda o derecha
+  Left, Right
+
+  M-1 to M-5         # Ordenar los paneles
+
+  C-Up, C-Down       # Dimensionar el panel actual en pasos de una celda
+  C-Left, C-Right
+
+  M-Up, M-Down       # Dimensionar el panel actual en pasos de cinco celdas
+  M-Left, M-Right
+
+```
+
+
+### Configurar ~/.tmux.conf
+
+El fichero tmux.conf se puede configurar para establecer unas opciones por
+defecto, igual que .vimrc o init.el para vim o emacs.
+
+```
+# Ejemplo tmux.conf
+# 2014.10
+
+
+### General
+###########################################################################
+
+# Activar UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Limite del historico de comandos
+set -g history-limit 2048
+
+# Index Start
+set -g base-index 1
+
+# Ratón
+set-option -g mouse-select-pane on
+
+# Forzar volver a cargar el fichero de configuración
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Atajos de teclado
+###########################################################################
+
+# Quitar C-b como prefijo por defecto
+unbind C-b
+
+# Establecer ` como nuevo prefijo
+set-option -g prefix `
+
+# Volver a la ventana anterior cuando el prefijo se pulsa dos veces
+bind C-a last-window
+bind ` last-window
+
+# Intercambiar entre C-a y ` como prefijo pulsando F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Preferencias de los atajos
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Mover entre paneles con atajos de vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Cambiar/Saltar de ventana
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Divisiones de paneles
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+### Tema de colores
+###########################################################################
+
+# Barra de estado
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Bordes de paneles
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Color de los mensajes
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Colores del estado de las ventanas
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notificaciones
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Titulos de las ventanas
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Formato de la barra de estado
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Mostrar estadisticas de rendimiento en la barra de estado
+# Requiere https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Referencias
+
+[Tmux | Home](http://tmux.sourceforge.net)
+
+[Tmux Manual page](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Display CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
diff --git a/es-es/typescript-es.html.markdown b/es-es/typescript-es.html.markdown
new file mode 100644
index 00000000..c42da4a4
--- /dev/null
+++ b/es-es/typescript-es.html.markdown
@@ -0,0 +1,172 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+filename: learntypescript-es.ts
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+TypeScript es un lenguaje cuyo objetivo es facilitar el desarrollo de aplicaciones a gran escala escritas en JavaScript.
+TypeScript añade conceptos comunes como clases, módulos, interfaces, genéricos y (opcionalmente) tipeo estático a JavaScript.
+Es un superset de JavaScript: todo el código JavaScript es código válido en TypeScript de manera que se puede integrar fácilmente a cualquier proyecto . El compilador TypeScript emite JavaScript.
+
+Este artículo se enfocará solo en la sintáxis extra de TypeScript, y no en [JavaScript] (../javascript/).
+
+Para probar el compilador de TypeScript, diríjase al [Área de Pruebas] (http://www.typescriptlang.org/Playground) donde podrá tipear código, y ver como se auto-completa al tiempo que ve el código emitido JavaScript.
+
+```js
+// Existen 3 tipos básicos en TypeScript
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Cuando es imposible de saber, tenemos el tipo "Any"
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // okey, definitivamente un boolean
+
+// Para colecciones, hay matrices de tipos y matrices genéricas
+var list: number[] = [1, 2, 3];
+// Alternativamente, usando la matriz genérica
+var list: Array<number> = [1, 2, 3];
+
+// Para enumeradores:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Finalmente, "void" es usado para el caso especial de una función que no retorna nada
+function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!");
+}
+
+// Las funciones son ciudadanos de primera clase, soportan la sintáxis lambda "fat arrow" y
+// usan el tipo inferencia
+
+// Lo siguiente es equivalante, la misma firma será inferida por el
+// compilador, y el mismo JavaScript será emitido
+var f1 = function(i: number): number { return i * i; }
+// Retorna tipo inferido
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Retorna tipo inferido
+var f4 = (i: number) => { return i * i; }
+// Retorna tipo inferido, one-liner significa que no es necesario que regresen palabras claves
+var f5 = (i: number) =>  i * i;
+
+// Las interfaces son estructurales, todo lo que tenga las propiedades cumple con
+// la interfase
+interface Person {
+  name: string;
+  // Propiedades opcionales, marcadas con un "?"
+  age?: number;
+  // Y por supuesto funciones
+  move(): void;
+}
+
+// Objeto que implementa la interfase "Persona"
+// Puede ser tratada como Persona ya que posee las propiedades name y move
+var p: Persona = { name: "Bobby", move: () => {} };
+// Objetos que tienen propiedades opcionales:
+var validPersona: Persona = { name: "Bobby", age: 42, move: () => {} };
+// No es una persona porque su edad no es un número
+var invalidPersona: Persona = { name: "Bobby", age: true };
+
+// Las interfases también pueden describir un tipo de función
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Solo los tipos de parámetros son importantes, los nombres no son importantes.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Clases - los miembros son públicos por defecto
+class Point {
+  // Properties
+    x: number;
+
+    // Constructor - las palabras clave public/private en este contexto generarán
+    // un código boiler plate para la propiedad y la inicialización en el
+    // constructor.
+    // En este ejemplo, "y" debe ser definida al igual que "x" lo es, pero con menos código
+    // También son soportados valores por defecto
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Funciones
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Miembros estáticos
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y será 0
+
+// Herencia
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Un llamado explícito al constructor de la super clase es indispensable
+    }
+
+    // Sobrescribir
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Módulos, los "." pueden ser usados como separadores para los submódulos
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Un alias local para referirse a un módulo
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Genéricos
+// Clases
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfases
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// Y funciones
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Incluyendo referencias a un archivo de definición:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Para mayor información
+ * [Sitio Oficial de TypeScript] (http://www.typescriptlang.org/)
+ * [Especificaciones del lenguaje TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introduciendo TypeScript en Canal 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Código fuente en GitHub] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - repositorio para definiciones de tipo] (http://definitelytyped.org/)
diff --git a/es-es/vim-es.html.markdown b/es-es/vim-es.html.markdown
new file mode 100644
index 00000000..df97aa3d
--- /dev/null
+++ b/es-es/vim-es.html.markdown
@@ -0,0 +1,242 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: LearnVim-es.txt
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) es un clón del popular editor vi para UNIX. Es un editor de texto
+diseñado para ser veloz e incrementar la productividad, es ubicuo en la mayoría
+de los sistemas basados en UNIX. Cuenta con numerosas combinaciones de teclas 
+para la navegación rápida a puntos especificos en un archivo y para rápida edición.
+
+
+
+## Fundamentos de la navegación en Vim
+
+```
+    vim <archivo>    # Abre <archivo> en vim
+    :q               # Salir de vim
+    :w               # Guardar archivo actual
+    :wq              # Guardar archivo y salir de vim
+    :q!              # Salir de vim sin guardar el archivo
+                     # ! *forza* :q a ejecutarse, por lo tanto sale de vim sin guardar
+    :x               # Guardar el archivo y salir de vim, versión corta de :wq
+
+    u                # Deshacer
+    CTRL+R           # Rehacer
+
+    h                # Desplazarse un carácter hacía la izquierda
+    j                # Desplazarse una línea hacía abajo
+    k                # Desplazarse una línea hacía arriba
+    l                # Desplazarse un carácter hacía la derecha
+
+    # Desplazarse dentro de la línea 
+
+    0                # Desplazarse hacia el inicio de la línea
+    $                # Desplazarse al final de la línea
+    ^                # Desplazarse al primer carácter no blanco en la línea
+
+    # Buscando en el texto
+
+    /word            # Resalta todas las ocurrencias de la palabra después del cursor
+    ?word            # Resalta todas las ocurrencias de la palabra antes del cursor
+    n                # Desplaza el cursor a la siguiente ocurrencia de la palabra después de una búsqueda
+    N                # Desplaza el cursor a la anterior ocurrencia de la palabra
+
+    :%s/foo/bar/g    # Cambia 'foo' a 'bar' en cada línea en el archivo
+    :s/foo/bar/g     # Cambia 'foo' a 'bar' en la línea actual
+
+    # Saltando caracteres
+
+    f<carácter>     # Salta adelante y aterriza en <carácter>
+    t<carácter>     # Salta adelante y aterriza antes de <carácter>
+
+    # Por ejemplo,
+    f<               # Salta adelante y aterriza en <
+    t<               # Salta adelante y aterriza justo antes de <
+    
+    # Desplazarse por palabras
+
+    w                # Desplazarse hacia adelante por una palabra
+    b                # Desplazarse hacia atrás por una palabra
+    e                # Desplazarse al final de la palabra actual
+
+    # Otros caracteres para desplazarse
+
+    gg               # Ir al principio del archivo
+    G                # Ir al final del archivo
+    :NUM             # Ir a la línea número NUM (NUM es cualquier número)
+    H                # Desplazarse al principio de la pantalla
+    M                # Desplazarse a la mitad de la pantalla
+    L                # Desplazarse al final de la pantalla
+```
+
+## Modos:
+
+Vim se basa en el concepto de **modos**.
+
+
+Modo Comando    - Vim se pone en marcha en éste modo, se usa para navegar y escribir comandos    
+Modo Inserción  - Utilizado para realizar cambios en el archivo    
+Modo Visual     - Utilizado para resaltar texto y operar en ellos    
+Modo Ex         - Utilizado para ir hacia la parte inferior con ':' para introducir comandos
+
+
+```
+    i                # Pone a Vim en modo de inserción, antes de la posición del cursor
+    a                # Pone a Vim en modo de inserción, después de la posición del cursor
+    v                # Pone a Vim en modo de visual
+    :                # Pone a Vim en modo Ex
+    <esc>            # Sale de cualquier modo en que se encuentre, al modo comando
+
+    # Copiando y pegando texto
+
+    y                # Copia lo que se encuentre seleccionado
+    yy               # Copia la linea actual
+    d                # Elimina lo que se encuentre seleccionado
+    dd               # Elimina la linea actual
+    p                # Pega el texto copiado después de la posición del cursor
+    P                # Pega el texto copiado antes de la posición del cursor
+    x                # Elimina el carácter debajo de la posición del cursor
+```
+
+## La "Gramática" de vim
+
+Vim puede ser pensado como un conjunto de comandos en un
+formato "verbo-sustantivo-modificador ', donde:
+
+Verbo       - La acción a realizar    
+Modificador - Como vas hacer la acción    
+Sustantivo  - el objeto al que se le va a aplicar la acción
+
+Algunos ejemplos importantes de "Verbos", "Modificadores" y "Sustantivos":
+
+```
+    # 'Verbos'
+ 
+    d                # Eliminar
+    c                # Cambiar
+    y                # Copiar
+    v                # Seleccionar visualmente
+
+    # 'Modificadores'
+
+    i                # Dentro
+    a                # Alrededor
+    NUM              # Número (NUM es cualquier número)
+    f                # Busca algo y aterriza sobre el
+    t                # Busca algo y se detiene antes de
+    /                # Encuentra una cadena desde el cursor en adelante
+    ?                # Encuentra una cadena antes del cursor
+
+    # 'Sustantivos'
+
+    w                # Palabra
+    s                # Oración
+    p                # Párrafo
+    b                # Bloque
+    
+    # "Frases" de ejemplo o comandos
+
+    d2w              # Elimina 2 palabras
+    cis              # Cambia dentro de una oración
+    yip              # Copia dentro de un párrafo (copia el párrafo donde estás)
+    ct<              # Cambia para abrir un paréntesis
+                     # Cambie el texto desde donde está a la siguiente paréntesis abierto
+    d$               # Eliminar hasta el final de la línea
+```
+
+## Algunos accesos directos y trucos
+
+```
+    >                # Sangrar la selección por un bloque
+    <                # Desangrar la selección por un bloque
+    :earlier 15m     # Devuelve el documento de nuevo a como era hace 15 minutos
+    :later 15m       # Deshace el comando anterior
+    ddp              # Intercambia la posición de las lineas consecutivas, dd después p
+    .                # Repite la acción previa
+```
+
+## Macros
+
+Las macros son, básicamente, las acciones que se pueden grabar.
+Cuando comienzas a grabar un macro, registra **todas** las acciones y comandos
+que se utilizan hasta que detenga la grabación. En la invocación de un macro,
+se aplica exactamente la misma secuencia de acciones y comandos de nuevo
+en la selección de texto.
+
+```
+    qa               # Comienza a grabar un macro llamada 'a'
+    q                # Detiene la grabación
+    @a               # Comienza la reproducción del macro
+```
+
+### Configurando ~/.vimrc
+
+El archivo .vimrc puede ser usado para configurar Vim en el arranque.
+
+Aquí está un ejemplo de un archivo ~ / .vimrc:
+
+```
+" Ejemplo ~/.vimrc
+" 2015.10 
+
+" Se requiere para que vim sea 'mejor'
+set nocompatible
+
+" Determina la extensión del archivo por el nombre para permitir el auto-indentado inteligente, etc...
+filetype indent plugin on
+
+" Habilita el resaltado de sintaxis
+syntax on
+
+" Mejor terminación de línea de comandos
+set wildmenu
+
+" Usa búsqueda sensible a mayúsculas excepto cuando se utilizan letras mayúsculas
+set ignorecase
+set smartcase
+
+" Al abrir una nueva línea, si la sangría especifica del archivo no está habilitada,
+" mantén la misma sangría que la línea que estás actualmente
+set autoindent
+
+" Despliega el número de línea a la izquierda
+set number
+
+" Opciones de sangría, cambialas de acuerdo a tus preferencias personales
+
+" Número de espacios visuales por tabulación
+set tabstop=4
+
+" Número de espacios de las tabulaciones al editar
+set softtabstop=4
+
+" Número de espacios sangrados cuando las operaciones de resangrado (>> y <<) son usadas
+set shiftwidth=4
+
+" Convertir tabulaciones en espacios
+set expandtab
+
+" Habilitar la tabulación inteligente y el espaciamiento para el sangrado y la alineación
+set smarttab
+```
+
+### Referencias
+
+[Vim | Home (EN)](http://www.vim.org/index.php)
+
+`$ vimtutor` Command
+
+[A vim Tutorial and Primer (EN)](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread) (EN)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki (EN)](https://wiki.archlinux.org/index.php/Vim)
\ No newline at end of file
diff --git a/es-es/wolfram-es.html.markdown b/es-es/wolfram-es.html.markdown
new file mode 100644
index 00000000..44ec9e09
--- /dev/null
+++ b/es-es/wolfram-es.html.markdown
@@ -0,0 +1,138 @@
+---
+language: wolfram
+lang: es-es
+contributors:
+    - ["Daniel Caballero", "http://github.com/danielcaballero796/"]
+filename: learnwolfram-es.md
+---
+
+Wolfram es un lenguaje subyacente originalmente utilizado en Mathematica, pero ahora esta disponible para su uso en múltiples contextos.
+
+El lenguaje de Wolfram tiene varias interfaces:
+* La interfaz de línea de comandos kernel de Raspberry Pi (recién llamada _The Wolfram Language_) que se ejecuta interactivamente y no puede producir entrada gráfica.
+* _Mathematica_ que es un texto rico / editor de matemáticas con Wolfram interactivo construido: presionando shift + Return en una "celda de código" crea una celda de salida con el resultado, que no es dinámica
+* _Wolfram Workbench_ la cual es la interfaz de Eclipse del lenguaje Wolfram
+
+El código de este ejemplo se puede escribir en cualquier interfaz y editarlo con Wolfram Workbench. Cargar directamente en Matematica puede resultar incómodo porque el archivo no contiene información de formato de celda (lo que haría que el archivo sea un desastre enorme para ser leído como texto) - puede ser visto / editado pero tal vez requerira algún ajuste.
+
+```
+(* Esto es un comentario *)
+
+(* En Mathematica en lugar de utilizar estos comentarios, puede crear una celda de texto
+   Y anotar su código con texto e imágenes bien escritas *)
+
+(* Escribe una expresión devuelve el resultado *)
+2*2              (* 4 *)
+5+8              (* 13 *)
+
+(* Llamada de función *)
+(* Nota, los nombres de funciones (y todo lo demás) distingue entre mayúsculas y minúsculas *)
+Sin[Pi/2]        (* 1 *)
+
+(* Sintaxis alternativa para la Llamada de una función con un parámetro *)
+Sin@(Pi/2)       (* 1 *)
+(Pi/2) // Sin    (* 1 *)
+
+(* Cada sintaxis en WL tiene algún equivalente como una llamada de función *)
+Veces[2, 2]      (* 4 *)
+Mas[5, 8]       (* 13 *)
+
+(* El uso de una variable por primera vez lo define y lo hace global *)
+x = 5             (* 5 *)
+x == 5            (* verdadero, Estilo-C asignación y pruebas de igualdad *)
+x                 (* 5 *)
+x = x + 5         (* 10 *)
+x                 (* 10 *)
+Modifique[x, 20]  (* No estaba bromeando cuando dije que TODO tiene una función equivalente *)
+x                 (* 20 *)
+
+(* Debido a que WL se basa en un sistema de álgebra computacional, *)
+(* El uso de variables indefinidas está bien, simplemente obstruyen la evaluación *)
+cow + 5          (* 5 + cow, cow es indefinido por lo que no puede evaluar más *)
+cow + 5 + 10     (* 15 + cow, Va a evaluar lo que puede *)
+%                (* 15 + cow, % Busca el último retorno *)
+% - cow          (* 15, cow variable indefinida cancelada *)
+moo = cow + 5    (* Cuidado, moo ahora tiene una expresión, no un número! *)
+
+(* Definición de una función *)
+Double[x_] := x * 2    (* Nota: = para evitar la evaluación inmediata del RHS
+                          y después de x para indicar que no hay restricciones de concordancia de patrones *)
+Double[10]             (* 20 *)
+Double[Sin[Pi/2]]      (* 2 *)
+Double @ Sin @ (Pi/2)  (* 2, @-Sintaxis evita colas de paréntesis *)
+(Pi/2) // Sin // Double(* 2, //-Sintaxis lista las funciones en orden de ejecución *)
+
+(* Para un uso de programación de estilo imperativo; Para separar declaraciones *)
+(* Descarta cualquier salida de LHS y ejecuta RHS *)
+miPrimero[] := (Print@"Hola"; Print@"Mundo")  (* Tenga en cuenta que los padres externos son críticos
+                                                ; La precedencia es menor que := *)
+miPrimero[]                                    (* Hola Mundo *)
+
+(* Estilo-C para bucle *)
+PrintTo[x_] := For[y=0, y<x, y++, (Print[y])]  (* Start, test, incr, body *)
+PrintTo[5]                                     (* 0 1 2 3 4 *)
+
+(* bucle *)
+x = 0; While[x < 2, (Print@x; x++)]     (* Ciclo con prueba y cuerpo *)
+
+(* Si y condicionales *)
+x = 8; If[x==8, Print@"Yes", Print@"No"]   (* Condición, Caso verdadero, Caso distinto*)
+Switch[x, 2, Print@"Two", 8, Print@"Yes"]  (* Interruptor de estilo de coincidencia de valor *)
+Which[x==2, Print@"No", x==8, Print@"Yes"] (* estilo de caso distinto *)
+
+(* Las variables distintas de los parámetros son globales por defecto, incluso dentro de las funciones *)
+y = 10             (* 10, Variable global y *)
+PrintTo[5]         (* 0 1 2 3 4 *)
+y                  (* 5, Global por contador de bucle dentro de PrintTo *)
+x = 20             (* 20, Variable global x *)
+PrintTo[5]         (* 0 1 2 3 4 *)
+x                  (* 20, x en PrintTo Es un parámetro y automáticamente local *)
+
+(* Las variables locales se declaran utilizando la metafunción del módulo *)
+(* Version con variable local*)
+BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
+y = 20             (* Variable global y *)
+BetterPrintTo[5]   (* 0 1 2 3 4 *)
+y                  (* 20, eso es mejor *)
+
+(* El módulo realmente nos permite declarar cualquier ámbito que nos guste *)
+Module[{count}, count=0;        (* Declare el alcance de este recuento de variables *)
+  (IncCount[] := ++count);      (* Estas funciones están dentro de ese ámbito *)
+  (DecCount[] := --count)]
+count              (* count - Variable global count no esta definida *)
+IncCount[]         (* 1, usando count variable dentro del alcance *)
+IncCount[]         (* 2, incCount lo actualiza *)
+DecCount[]         (* 1, decCount tambien lo hace *)
+count              (* count - Aún ninguna variable global con ese nombre*)
+
+(* listas *)
+miLista = {1, 2, 3, 4}     (* {1, 2, 3, 4} *)
+miLista[[1]]               (* 1 - Los índices de la lista de notas comienzan en 1, no 0 *)
+Map[Double, miLista]       (* {2, 4, 6, 8} - Lista de estilo funcional mapa función *)
+Double /@ miLista          (* {2, 4, 6, 8} - Sintaxis abreviada para arriba *)
+Scan[Print, miLista]       (* 1 2 3 4 - Lista de bucle sobre estilo imperativo *)
+Fold[Plus, 0, miLista]     (* 10 (0+1+2+3+4) *)
+FoldList[Plus, 0, miLista] (* {0, 1, 3, 6, 10} - Guardar los resultados intermedios *)
+Append[miLista, 5]         (* {1, 2, 3, 4, 5} - Note que miLista no está actualizada *)
+Prepend[miLista, 5]        (* {5, 1, 2, 3, 4} - añada "miLista = " Si quieres que lo sea *)
+Join[miLista, {3, 4}]      (* {1, 2, 3, 4, 3, 4} *)
+miLista[[2]] = 5          (* {1, 5, 3, 4} - Esto actualiza miLista *)
+
+(* Asociaciones, aka Diccionarios /Hashes *)
+miHash = <|"Green" -> 2, "Red" -> 1|>   (* crea una asociación *)
+miHash[["Green"]]                       (* 2, uselo *)
+miHash[["Green"]] := 5                  (* 5, actualizalo *)
+miHash[["Puce"]] := 3.5                 (* 3.5, extiendalo *)
+KeyDropFrom[miHash, "Verde"]            (* Limpia la llave Verde *)
+Claves[miHash]                            (* {Rojo} *)
+Valores[miHash]                          (* {1} *)
+
+(* Y no puedes hacer ninguna demo de Wolfram sin mostrar esto *)
+Manipular[y^2, {y, 0, 20}] (* Devuelve una interfaz de usuario reactiva que muestra y ^ 2
+                               Y permite ajustar y entre 0-20 con un deslizador.
+                               Sólo funciona en interfaces gráficas *)
+```
+
+##Listo para mas?
+
+* [Centro de Documentación](http://reference.wolfram.com/language/)
diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown
index a5157b5d..cd3143fb 100644
--- a/es-es/yaml-es.html.markdown
+++ b/es-es/yaml-es.html.markdown
@@ -4,6 +4,7 @@ lang: es-es
 filename: learnyaml-es.yaml
 contributors:
   - ["Adam Brenecki", "https://github.com/adambrenecki"]
+  - ["Everardo Medina","https://github.com/everblut"]
 translators:
   - ["Daniel Zendejas","https://github.com/DanielZendejas"]
 ---
@@ -14,7 +15,7 @@ leído y escrito por humanos.
 
 Basa su funcionalidad en JSON, con la adición de líneas nuevas
 e indentación inspirada en Python. A diferencia de Python, YAML
-no permite tabs literales.
+no permite tabulaciones literales.
 
 ```yaml
 # Los comentarios en YAML se ven así.
@@ -38,97 +39,177 @@ llave con espacios: valor
 llave: "Un string, entre comillas."
 "Las llaves tambien pueden estar entre comillas.": "valor entre comillas"
 
-# Los strings de líneas múltiples pueden ser escritos 
+# Los strings de líneas múltiples pueden ser escritos
 # como un 'bloque literal' (usando pipes |)
 # o como un 'bloque doblado' (usando >)
 
 bloque_literal: |
 	Este bloque completo de texto será preservado como el valor de la llave
 	'bloque_literal', incluyendo los saltos de línea.
-	
-	Se continúa guardando la literal hasta que se cese la indentación. 
+
+	Se continúa guardando la literal hasta que se cese la indentación.
 		Cualquier línea que tenga más indentación, mantendrá los espacios dados
 		(por ejemplo, estas líneas se guardarán con cuatro espacios)
 
-nloque_doblado: >
+bloque_doblado: >
 	De la misma forma que el valor de 'bloque_literal', todas estas
 	líneas se guardarán como una sola literal, pero en esta ocasión todos los
 	saltos de línea serán reemplazados por espacio.
 
-	Las líneas en blanco, como la anterior, son convertidos a un salto de línea.
+	Las líneas en blanco, como la anterior, son convertidas a un salto de línea.
 
         Las líneas con mayor indentación guardan sus saltos de línea.
         Esta literal ocuparán dos líneas.
 
-########################
-# TIPOS DE COLECCIONES #
-########################
-
-# La indentación se usa para anidar.
+# La indentación se usa para anidar elementos
 un_mapa_indentado:
     llave: valor
     otra_llave: otro valor
     otro_mapa_indentado:
         llave_interna: valor_interno
 
-# Las llaves de los mapas no deben ser strings necesariamente
+# Las llaves de los mapas no requieren ser strings necesariamente
 0.25: una llave numérica
 
-# Las llaves también pueden ser objetos de multi línea, usando ? para indicar
-# el inicio de una llave
+# Las llaves también pueden ser objetos de multiples líneas,
+# usando ? para indicar el inicio de una llave
 ? |
     Esto es una llave
     que tiene múltiples líneas
 : y este es su valor
 
-# YAML tambien permite colecciones como llaves, pero muchos lenguajes de 
+########################
+# TIPOS DE COLECCIONES #
+########################
+
+# Las colecciones en YAML usan la indentación para delimitar el alcance
+# y cada elemento de la colección inicia en su propia línea.
+# YAML tambien permite colecciones como llaves, pero muchos lenguajes de
 # programación se quejarán.
 
 # Las secuencias (equivalentes a listas o arreglos) se ven así:
-una_secuencia:
-    - Item 1
-    - Item 2
-    - 0.5 # las secuencias pueden tener distintos tipos en su contenido.
-    - Item 4
-    - llave: valor
-      otra_llave: otro_valor
+- Amarillo
+- Verde
+- Azul
+
+# Se puede usar una secuencia como valor para una llave.
+secuencia:
+    - Elemento 1
+    - Elemento 2
+    - Elemento 3
+    - Elemento 4
+
+# Las secuencias pueden contener secuencias como elementos.
+- [Uno, Dos, Tres]
+- [Domingo, Lunes, Martes]
+- [Luna, Marte, Tierra]
+
+# Las secuencias pueden tener distintos tipos en su contenido.
+secuencia_combinada:
+    - texto
+    - 5
+    - 0.6
+    - llave: valor # se convierte en un json dentro de la secuencia
     -
         - Esta es una secuencia
         - ...dentro de otra secuencia
 
-# Dado que todo JSON está incluído dentro de YAML, también puedes escribir 
-# mapas con la sintaxis de JSON y secuencias: 
-mapa_de_json: {"llave": "valor"}
-secuencia_de_json: [3, 2, 1, "despegue"]
+# Dado que todo JSON está incluído dentro de YAML, también puedes escribir
+# mapas con la sintaxis de JSON y secuencias:
+mapa_de_json_1: {"llave": "valor"}
+mapa_de_json_2:
+  llave: valor
+
+# Las secuencias tambien se pueden escribir como un arreglo al estilo JSON
+secuencia_de_json_1: [3, 2, 1, "despegue"]
+secuencia_de_json_2:
+  - 3
+  - 2
+  - 1
+  - "despegue"
+
+# YAML también soporta conjuntos usando el simbolo ?
+# y se ven de la siguiente forma:
+set:
+    ? item1
+    ? item2
+    ? item3
+
+# Se puede usar el tag !!set
+# Al igual que Python, los conjuntos sólo son mapas con valores nulos.
+# El ejemplo de arriba es equivalente a:
+set2:
+    item1: null
+    item2: null
+    item3: null
 
 ##################################
 # CARACTERÍSTICAS EXTRAS DE YAML #
 ##################################
 
+# YAML usa tres guiones (---) para diferenciar entre directivas
+# y contenido del documento.
+# Por otra parte, tres puntos (...) se utilizan para indicar
+# el final del documento en casos especiales.
+
 # YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten
-# duplicar fácilmente contenido a lo largo de tu documento. En el ejemplo
-# a continuación, ambas llaves tendrán el mismo valor:
-contenido_anclado: &nombre_del_ancla Este string será el valor de las llaves
-otra_ancla: *nombre_del_ancla
-
-# YAML también tiene tags, que puedes usar para declarar tipos explícitamente.
-string_explícito: !!str 0.5
-# Algunos parseadores implementar tags específicas del lenguaje, como el 
+# duplicar fácilmente contenido a lo largo de tu documento.
+# El ampersand indica la declaración del ancla,
+declara_ancla: &texto texto de la llave
+# el asterisco indica el uso de dicha ancla.
+usa_ancla: *texto # tendrá el valor "texto de la llave"
+
+################
+# TAGS EN YAML #
+################
+
+# En YAML, los nodos que no tienen un tag obtienen su tipo
+# según la aplicación que los use, al usar un tag
+# se pueden declarar tipos explícitamente.
+string_explicito: !!str 0.5 # !!str para declarar un string
+integer_explicito: !!int 5 # !!int para declarar un integer
+float_explicito: !!float 1.2 # !!float para declarar un float
+conjunto_explicito: !!set # !!set para declarar un conjunto
+  ? Uno
+  ? Dos
+  ? Tres
+mapa_ordenado_explicito: !!omap # !!omap para declarar un mapa ordenado
+- Primero: 1
+- Segundo: 2
+- Tercero: 3
+- Cuarto: 4
+
+# Tags para los numeros enteros
+llave_canonica: 5222
+llave_decimal: +5222
+llave_octal: 010
+llave_hexadecimal: 0xC
+
+#Tags para los numeros flotantes
+llave_canonica: 1.215e+3
+llave_exponencial: 12.3555e+02
+llave_fija: 12.15
+llave_negativa_infinita: -.inf
+llave_numero_invalido: .NaN
+
+# Tags para las fechas y horas
+llave_canonica: 2001-12-15T02:59:43.1Z
+llave_iso8601: 2001-12-14t21:59:43.10-05:00
+llave_con_espacios: 2001-12-14 21:59:43.10 -5
+llave_fecha: 2002-12-14
+
+# Además existen tags para
+null: #valor nulo
+booleans: [ true, false ] # Valores booleanos
+string: '012345' # Valor en string
+
+
+# Algunos parseadores implementan tags específicas del lenguaje, como el
 # que se muestra a continuación, encargado de manejar números complejos en
 # Python:
 numero_complejo_python: !!python/complex 1+2j
 
-########################
-# TIPOS EXTRAS EN YAML #
-########################
-
-# Stirngs y números no son los únicos escalares que YAML puede entener.
-# YAML también puede parsear fechas en formato ISO .
-fechaHora: 2001-12-15T02:59:43.1Z
-fechaHora_con_espacios: 2001-12-14 21:59:43.10 -5
-fecha: 2002-12-14
-
-# La tag !!binary indica que un string es, en realidad, un blob
+# El tag !!binary indica que un string es en realidad un blob
 # representado en base-64.
 archivo_gif: !!binary |
     R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
@@ -136,16 +217,10 @@ archivo_gif: !!binary |
     +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
     AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
 
-# YAML también tiene un tipo set, que se ve de la siguiente forma:
-set:
-    ? item1
-    ? item2
-    ? item3
-
-# Al igual que Python, los sets sólo son mapas con valores nulos.
-# El ejemplo de arriba es equivalente a: 
-set2:
-    item1: null
-    item2: null
-    item3: null
 ```
+
+### Recursos adicionales
+
++ [Sitio oficial de YAML](http://yaml.org/)
++ [Parser en línea de de YAML](http://yaml-online-parser.appspot.com/)
++ [Validador en línea de YAML](http://codebeautify.org/yaml-validator)
diff --git a/fa-ir/brainfuck-fa.html.markdown b/fa-ir/bf-fa.html.markdown
index ef2bcba3..bc5d8dc4 100644
--- a/fa-ir/brainfuck-fa.html.markdown
+++ b/fa-ir/bf-fa.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Mohammad Valipour", "https://github.com/mvalipour"]
 lang: fa-ir
diff --git a/fa-ir/css-fa.html.markdown b/fa-ir/css-fa.html.markdown
new file mode 100644
index 00000000..4e222eb2
--- /dev/null
+++ b/fa-ir/css-fa.html.markdown
@@ -0,0 +1,307 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+    - ["Tyler Mumford", "https://tylermumford.com"]
+translators:
+    - ["Arashk", "https://github.com/Arashk-A"]
+lang: fa-ir
+filename: learncss-fa.css
+---
+
+<p dir='rtl'>در روزهای آغازین وب هیچگونه عنصر بصری مشاهده نمیشد و محتوا به صورت متن خالی بود. </p>
+<p dir='rtl'>اما با توسعه بیشتر مرورگرها صفحات وب کاملاً تصویری نیز رایج شد</p>
+<p dir='rtl'>CSS زبان استانداردی که موجودیت آن برای حفظ جدایی بین محتوا (HTML) و نگاه و احساس از</p>
+<p dir='rtl'>صفحات وب است.</p>
+
+<p dir='rtl'>به طور خلاصه, کاری که CSS انجام میدهد ارائه نحوه ایست که شما را قادر به هدف قرار دادن</p>
+<p dir='rtl'>عناصر مختلف در یک صفحه HTML کرده و امکان اختصاص خواص متفاوت بصری به آنها را میدهد.</p>
+
+
+<p dir='rtl'>مانند هر زبانی, CSS نسخه های زیادی دارد که در اینجا توجه ما روی CSS2.0 است. با وجودی که این نسخه جدیدترین نسخه نمیباشد اما بیشترین پشتیبانی و سازگاری را در میان نسخه های مختلف را دارد</p>
+
+<p dir='rtl'><strong>توجه: </strong> برای مشاهده برخی از نتایج جلوه های تصویری CSS به منظور یادگیری بیشتر شما باید چیزهای گوناگونی در محیطی مثل [dabblet](http://dabblet.com/) امتحان کنید. توجه اصلی این مقاله روی دستورات و برخی از نکات عمومی است.</p>
+
+
+<p dir='rtl'>در CSS همه توضیحات داخل ستاره-بروم نوشته میشوند زیرا CSS دستوری برای توضیحات تک خطی مثل C ندارد</p>
+
+```CSS
+/* comments appear inside slash-asterisk, just like this line!
+   there are no "one-line comments"; this is the only comment style */
+```
+
+<p dir='rtl'>به طور کلی دستورات CSS بسیار ساده هستند که در آن یک انتخابگر (selector) عنصری را در  روی صفحه هدف قرار میدهد.</p>
+
+```CSS
+selector { property: value; /* more properties...*/ }
+```
+
+<p dir='rtl'>با استفاده از ستاره می توان برای همه عناصر روی صفحه استایل تعریف کرد</p>
+
+
+```CSS
+* { color:red; }
+```
+
+<p dir='rtl'>فرض کنید عنصری مثل این بر روی صفحه قرار دارد</p>
+
+```html
+<div class='some-class class2' id='someId' attr='value' otherAttr='en-us foo bar' />
+```
+<p dir='rtl'>شما میتوانید با استفاده از نام کلاس آنرا انتخاب کنید</p>
+
+
+```CSS
+.some-class { }
+```
+
+<p dir='rtl'>یا با استفاده از نام دو کلاس</p>
+
+```CSS
+.some-class.class2 { }
+```
+
+<p dir='rtl'>یا با استفاده از نام id</p>
+
+```CSS
+#someId { }
+```
+
+<p dir='rtl'>یا با استفاده از نام خود عنصر</p>
+
+```CSS
+div { }
+```
+
+<p dir='rtl'>یا با استفاده از `attr`</p>
+
+```CSS
+[attr] { font-size:smaller; }
+```
+
+<p dir='rtl'>یا با استفاده از ارزشی که برای `attr` مشخص شده</p>
+
+```CSS
+[attr='value'] { font-size:smaller; }
+```
+
+<p dir='rtl'>با استفاده از ارزشی که برای `attr` مشخص شده و آن ارزش با `val` شروع میشود در CSS3</p>
+
+```CSS
+[attr^='val'] { font-size:smaller; }
+```
+
+<p dir='rtl'>با استفاده از ارزشی که برای `attr` مشخص شده و آن ارزش با `ue` به پایان میرسد در CSS3</p>
+
+```CSS
+[attr$='ue'] { font-size:smaller; }
+```
+
+<p dir='rtl'>یا با انتخاب بوسیله یکی از ارزشهایی که در لیست `otherAttr` بوسیله فاصله از هم جدا شده اند در CSS3</p>
+
+```CSS
+[attr$='ue'] { font-size:smaller; }
+```
+
+<p dir='rtl'>یا ارزش(`value`) دقیقاً خود ارزش(`value`) یا بوسیله `-` که یونیکد (U+002D) از حرف بعدی جدا شود</p>
+
+```CSS
+[otherAttr|='en'] { font-size:smaller; }
+```
+
+<p dir='rtl'>و مهمتر از همه اینکه میتوان آنها را ترکیب کرد. نکته مهمی که در اینجا باید مد نظر داشته باشید این است که هنگام ترکیب نباید هیچگونه فاصله ای بین آنها قرار گیرد زیرا در این حالت معنای دستور تغییر میکند</p>
+
+```CSS
+div.some-class[attr$='ue'] { }
+```
+
+<p dir='rtl'>CSS این امکان را به شما میدهد که یک عنصر را بوسیله والدین آن انتخاب کنید</p>
+<p dir='rtl'>برای مثال دستور زیر همه عناصری را که نام کلاس آنها <span dir="ltr">`.class-name`</span> و دارای پدر و مادری با این مشخصه <span dir="ltr">`div.some-parent`</span> هستند را انتخاب میکند.</p>
+
+```CSS
+div.some-parent > .class-name {}
+```
+
+
+<p dir='rtl'>یا دستور زیر که همه عناصری را که نام کلاس آنها <span dir="ltr">`.class-name`</span> و داخل عنصری با مشخصه <span dir="ltr">`div.some-parent`</span> هستند را در هر عمقی که باشند (یعنی فرزندی از فرزندان <span dir="ltr">`div.some-parent`</span><span dir="ltr"> باشند) انتخاب میکند.</p>
+
+```CSS
+div.some-parent .class-name {}
+```
+
+<p dir='rtl'>نکته ای که در اینجا باید به آن توجه کنید این است که این رستور با فاصله ای بین نام دو کلاس همراه است و با مثال زیر که در بالا هم ذکر شد تفاوت دارد.</p>
+
+```CSS
+div.some-parent.class-name {}
+```
+
+<p dir='rtl'>دستور زیر همه عناصری را که نام کلاس آنها <span dir="ltr">`.this-element`</span> و بلافاصله بعد از عنصری با مشخصه <span dir="ltr">`.i-am-before`</span> قرار دارد را انتخاب میکند.</p>
+
+```CSS
+.i-am-before + .this-element { }
+```
+
+<p dir='rtl'>هر خواهر یا برادری که بعد از <span dir="ltr">`.i-am-before`</span> بیاید در اینجا لازم نیست بلافاصله بعد از هم قرار بگیرند ولی باید دارای پدر و مادری یکسان باشند.</p>
+
+```CSS
+.i-am-any-before ~ .this-element {}
+```
+<p dir='rtl'>در زیر چند نمونه از شبه کلاسها را معرفی میکنیم که به شما اجازه میدهد عناصر را بر اساس رفتار آنها در صفحه انتخاب کنید.</p>
+<p dir='rtl'>برای مثال زمانی که اشاره گر ماوس روی عنصری بر روی صفحه قرار دارد.</p>
+
+```CSS
+selector:hover {}
+```
+
+<p dir='rtl'>یا زمانی از یک لینک بازید کردید.</p>
+
+```CSS
+selected:visited {}
+```
+
+<p dir='rtl'>یا زمانی از لینکی بازید نشده است.</p>
+
+```CSS
+selected:link {}
+```
+
+<p dir='rtl'>یا زمانی که روی یک عنصر ورودی متمرکز شده.</p>
+
+```CSS
+selected:focus {}
+```
+
+<h3 dir='rtl'>واحدها</h3>
+
+```CSS
+selector {
+
+    /* واحدها اندازه */
+    width: 50%; /* در اساس درصد */
+    font-size: 2em; /* بر اساس اندازه font-size یعنی دو برابر اندازه فونت فعلی */
+    width: 200px; /* بر اساس پیکسل */
+    font-size: 20pt; /* بر اساس points (نکات) */
+    width: 5cm; /* بر اساس سانتیمتر */
+    min-width: 50mm; /* بر اساس میلیمتر */
+    max-width: 5in; /* بر اساس اینچ. max-(width|height) */
+    height: 0.2vh; /* بر اساس ارتفاع دید `vh = نسبت به 1٪ از ارتفاع دید` (CSS3) */
+    width: 0.4vw; /* بر اساس عرض دید `vw = نسبت به 1٪ از عرض دید` (CSS3) */
+    min-height: 0.1vmin; /* بر اساس کوچکترین مقدار از ارتفاع یا عرض دید (CSS3) */
+    max-width: 0.3vmax; /* مانند مثال بالا برای بیشترین مقدار (CSS3) */
+
+    /* رنگها */
+    background-color: #F6E;  /* بر اساس short hex */
+    background-color: #F262E2; /* بر اساس long hex format */
+    background-color: tomato; /* بر اساس نام رنگ */
+    background-color: rgb(255, 255, 255); /* بر اساس rgb */
+    background-color: rgb(10%, 20%, 50%); /* بر اساس درصد rgb , (rgb percent) */
+    background-color: rgba(255, 0, 0, 0.3); /* بر اساس rgba (نیمه شفاف) , (semi-transparent rgb) (CSS3) */
+    background-color: transparent; /* شفاف */
+    background-color: hsl(0, 100%, 50%); /* بر اساس hsl format (CSS3). */
+    background-color: hsla(0, 100%, 50%, 0.3); /* بر اساس hsla ,مثل RGBAکه میتوان شفافیت را در آخر انتخاب کرد (CSS3) */
+
+
+    /* عکسها */
+    background-image: url(/path-to-image/image.jpg); /* گذاشتن نقل قول داخل url() اختیاری است*/
+
+    /* فونتها */
+    font-family: Arial;
+    font-family: "Courier New"; /* اگر اسم فونت با فاصله همراه باشد باید داخل نقل قول یک یا دو نوشته شود */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif; /* اگر فونت اولی پیدا نشد مرورگر به سراغ نام بعدی میرود */
+}
+```
+
+<h2 dir='rtl'>نحوه استفاده</h2>
+
+<p dir='rtl'>هر دستور CSS را که می خواهید در فایلی با پسوند <span dir="ltr">.css</span> ذخیره کنید </p>
+<p dir='rtl'>حالا با استفاده از کد زیر آنرا در قسمت `head` داخل فایل html خود تعریف کنید </p>
+
+```html
+<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+```
+
+<p dir='rtl'>یا میتوان با استفاده از تگ `style` درون `head` دستورات CSS را به صورت درون برنامه ای تعریف کرد اما توسیه میشود تا جای ممکن از این کار اجتناب کنید. </p>
+
+```html
+<style>
+   a { color: purple; }
+</style>
+```
+
+<p dir='rtl'>همچنین شما میتوانید دستورات CSS را به عنوان یک مشخصه برای عنصر تعریف کنید ولی تا جای ممکن باید از این کار اجتناب کنید.</p>
+
+```html
+<div style="border: 1px solid red;">
+</div>
+```
+
+<h2 dir='rtl'>حق تقدم یا اولویت</h2>
+
+<p dir='rtl'>همانگونه که مشاهده کردید یک مشخصه می تواند به وسیله چندین انتخابگر انتخاب گردد.</p>
+<p dir='rtl'>و همچنین یک ویژگی میتواند چندین بار برای یک عنصر تعریف شود.</p>
+<p dir='rtl'>در این صورت یک دستور میتواند بر دستورات دیگر حق تقدم یا اولویت پیدا کند.</p>
+
+<p dir='rtl'>به مثال زیر توجه کنید:</p>
+
+```CSS
+/*A*/
+p.class1[attr='value']
+
+/*B*/
+p.class1 {}
+
+/*C*/
+p.class2 {}
+
+/*D*/
+p {}
+
+/*E*/
+p { property: value !important; }
+
+```
+
+<p dir='rtl'>و همچنین به کد زیر:</p>
+
+```html
+<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
+</p>
+
+```
+‍‍
+<p dir='rtl'>حق تقدم یا اولویت برای مثال بالا به این صورت است:</p>
+<p dir='rtl'>توجه داشته باشید که حق تقدم برای هر کدام از ویژگیها است نه برای کل مجموعه.</p>
+
+<p dir='rtl'>E دارای بیشترین الویت برای اینکه از <span dir="ltr">`!important`</span> استفاده کرده.</p>
+<p dir='rtl'>اما توصیه میشود تا جای ممکن از این کار اجتناب کنید مگر اینکه اینکار ضرورت داشته باشد</p>
+<p dir='rtl'>اولویت بعدی با F است زیرا که از روش درون برنامه ای استفاده کرده </p>
+<p dir='rtl'>اولویت بعدی با A است زیرا که بیشتر از بقیه مشخص تر تعریف شپه </p>
+<p dir='rtl'>مشخص تر = مشخص کننده بیشتر. دارای ۳ مشخص کننده: ۱ تگ <span dir="ltr">`p`</span> + ۱ کلاس با نام <span dir="ltr">`class1`</span> + ۱ خاصیت <span dir="ltr">`attr="value"`</span></p>
+<p dir='rtl'>اولویت بعدی با C است که مشخصه یکسانی با B دارد ولی بعد از آن تعریف شده است.</p>
+<p dir='rtl'>اولویت بعدی با B</p>
+<p dir='rtl'>و در آخر D</p>
+
+<h2 dir='rtl'>سازگاری</h2>
+
+<p dir='rtl'>بسیار از ویژگیهای CSS2 (و به تدریج CSS3) بر روی تمام مرورگرها و دستگاه ها سازگارند.اما همیشه حیاتی است که سازگاری CSS مورد استفاده خود را با مرورگر هدف چک کنید.</p>
+
+<p dir='rtl'> یک منبع خوب برای این کار است</p>
+[QuirksMode CSS](http://www.quirksmode.org/css/)
+
+<p dir='rtl'>برای یک تست سازگاری سریع, منبع زیر میتواند کمک بزرگی برای این کار باشد.</p>
+[CanIUse](http://caniuse.com/)
+
+<h2 dir='rtl'> منابع دیگر </h2>
+
+
+[Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+
+[QuirksMode CSS](http://www.quirksmode.org/css/)
+
+[Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+
+
diff --git a/fa-ir/java-fa.html.markdown b/fa-ir/java-fa.html.markdown
new file mode 100644
index 00000000..e8182e81
--- /dev/null
+++ b/fa-ir/java-fa.html.markdown
@@ -0,0 +1,902 @@
+---
+language: java
+lang: fa-ir
+contributors:
+    - ["Jake Prather", "https://github.com/JakeHP"]
+    - ["Jakukyo Friel", "https://weakish.github.io"]
+    - ["Madison Dickson", "https://github.com/mix3d"]
+    - ["Simon Morgan", "https://sjm.io/"]
+    - ["Zachary Ferguson", "https://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "https://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+    - ["Michael Dähnert", "https://github.com/JaXt0r"]
+    - ["Rob Rose", "https://github.com/RobRoseKnows"]
+    - ["Sean Nam", "https://github.com/seannam"]
+translators:
+    - ["ghaseminya", "https://github.com/ghaseminya"]
+filename: LearnJava-fa.java
+---
+
+جاوا یک زبان برنامه نویسی کامپیوتری چند منظوره، با قابلیت همزمانی، برپایه کلاس و شی گرایی می باشد.
+[مطالعه بیشتر.](https://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Single-line comments start with //
+
+/*
+Multi-line comments look like this.
+*/
+
+/**
+ * JavaDoc comments look like this. Used to describe the Class or various
+ * attributes of a Class.
+ * Main attributes:
+ *
+ * @author         @ghaseminya
+ * @version     v1.0
+*/
+
+// Import ArrayList class inside of the java.util package
+import java.util.ArrayList;
+// Import all classes inside of java.security package
+import java.security.*;
+
+// Each .java file contains one outer-level public class, with the same name
+// as the file.
+public class LearnJava {
+
+    // In order to run a java program, it must have a main method as an entry 
+    // point.
+    public static void main (String[] args) {
+
+    ///////////////////////////////////////
+    // Input/Output
+    ///////////////////////////////////////
+
+        /*
+        * Ouput
+        */
+
+        // Use System.out.println() to print lines.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // To print without a newline, use System.out.print().
+        System.out.print("Hello ");
+        System.out.print("World");
+
+        // Use System.out.printf() for easy formatted printing.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        /*
+         * Input
+         */
+
+        // use Scanner to read input
+        // must import java.util.Scanner;
+        Scanner scanner = new Scanner(System.in);
+
+        // read string input
+        String name = scanner.next();
+
+        // read byte input
+        byte numByte = scanner.nextByte();
+
+        // read int input
+        int numInt = scanner.nextInt();
+
+        // read long input
+        float numFloat - scanner.nextFloat();
+
+        // read double input
+        double numDouble = scanner.nextDouble();
+
+        // read boolean input
+        boolean bool = scanner.nextBoolean();
+
+        ///////////////////////////////////////
+        // Variables
+        ///////////////////////////////////////
+
+        /*
+        *  Variable Declaration
+        */
+        // Declare a variable using <type> <name>
+        int fooInt;
+        // Declare multiple variables of the same 
+        // type <type> <name1>, <name2>, <name3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Variable Initialization
+        */
+
+        // Initialize a variable using <type> <name> = <val>
+        int barInt = 1;
+        // Initialize multiple variables of same type with same 
+        // value <type> <name1>, <name2>, <name3> = <val>
+        int barInt1, barInt2, barInt3;
+        barInt1 = barInt2 = barInt3 = 1;
+
+        /*
+        *  Variable types
+        */
+        // Byte - 8-bit signed two's complement integer
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+        
+        // If you would like to interpret a byte as an unsigned integer
+        // then this simple operation can help
+        int unsignedIntLessThan256 = 0xff & fooByte;
+        // this contrasts a cast which can be negative.
+        int signedInt = (int) fooByte;
+
+        // Short - 16-bit signed two's complement integer
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-bit signed two's complement integer
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int bazInt = 1;
+
+        // Long - 64-bit signed two's complement integer
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L is used to denote that this variable value is of type Long;
+        // anything without is treated as integer by default.
+
+        // Note: byte, short, int and long are signed. They can have positive and negative values.
+        // There are no unsigned variants.
+        // char, however, is 16-bit unsigned.
+
+        // Float - Single-precision 32-bit IEEE 754 Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127
+        float fooFloat = 234.5f;
+        // f or F is used to denote that this variable value is of type float;
+        // otherwise it is treated as double.
+
+        // Double - Double-precision 64-bit IEEE 754 Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double fooDouble = 123.4;
+
+        // Boolean - true & false
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - A single 16-bit Unicode character
+        char fooChar = 'A';
+
+        // final variables can't be reassigned to another object,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // but they can be initialized later.
+        final double E;
+        E = 2.71828;
+
+        // BigInteger - Immutable arbitrary-precision integers
+        //
+        // BigInteger is a data type that allows programmers to manipulate
+        // integers longer than 64-bits. Integers are stored as an array of
+        // of bytes and are manipulated using functions built into BigInteger
+        //
+        // BigInteger can be initialized using an array of bytes or a string.        
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+        // BigDecimal - Immutable, arbitrary-precision signed decimal number
+        //
+        // A BigDecimal takes two parts: an arbitrary precision integer 
+        // unscaled value and a 32-bit integer scale
+        //
+        // BigDecimal allows the programmer complete control over decimal
+        // rounding. It is recommended to use BigDecimal with currency values
+        // and where exact decimal precision is required.
+        //
+        // BigDecimal can be initialized with an int, long, double or String
+        // or by initializing the unscaled value (BigInteger) and scale (int).
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+        
+        // Be wary of the constructor that takes a float or double as
+        // the inaccuracy of the float/double will be copied in BigDecimal.
+        // Prefer the String constructor when you need an exact value.
+        BigDecimal tenCents = new BigDecimal("0.1");
+
+        // Strings
+        String fooString = "My String Is Here!";
+
+        // \n is an escaped character that starts a new line
+        String barString = "Printing on a new line?\nNo Problem!";
+        // \t is an escaped character that adds a tab character
+        String bazString = "Do you want to add a tab?\tNo Problem!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // String Building
+        // #1 - with plus operator
+        // That's the basic way to do it (optimized under the hood)
+        String plusConcatenated = "Strings can " + "be concatenated " + "via + operator.";
+        System.out.println(plusConcatenated);
+        // Output: Strings can be concatenated via + operator.
+
+        // #2 - with StringBuilder
+        // This way doesn't create any intermediate strings. It just stores the string pieces, and ties them together
+        // when toString() is called.
+        // Hint: This class is not thread safe. A thread-safe alternative (with some impact on performance) is StringBuffer.
+        StringBuilder builderConcatenated = new StringBuilder();
+        builderConcatenated.append("You ");
+        builderConcatenated.append("can use ");
+        builderConcatenated.append("the StringBuilder class.");
+        System.out.println(builderConcatenated.toString()); // only now is the string built 
+        // Output: You can use the StringBuilder class.
+        
+        // StringBuilder is efficient when the fully constructed String is not required until the end of some processing.
+        StringBuilder stringBuilder = new StringBuilder();
+        String inefficientString = "";
+        for(int i = 0 ; i < 10; i++){
+            stringBuilder.append(i).append(" ");
+            inefficientString += i + " ";
+        }
+        System.out.println(inefficientString);
+        System.out.println(stringBuilder.toString());
+        // inefficientString requires a lot more work to produce, as it generates a String on every loop iteration.
+        // Simple concatenation with + is compiled to a StringBuilder and toString()
+        // Avoid string concatenation in loops.
+        
+        // #3 - with String formatter
+        // Another alternative way to create strings. Fast and readable.
+        String.format("%s may prefer %s.", "Or you", "String.format()");
+        // Output: Or you may prefer String.format().
+ 
+        // 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>];
+        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"};
+        boolean bools[] = {true, false, false};
+
+        // Indexing an array - Accessing an element
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Arrays are zero-indexed and mutable.
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Other data types worth checking out
+        // ArrayLists - Like arrays except more functionality is offered, and
+        //              the size is mutable.
+        // LinkedLists - Implementation of doubly-linked list. All of the
+        //               operations perform as could be expected for a
+        //               doubly-linked list.
+        // Maps - A set of objects that map keys to values. Map is
+        //        an interface and therefore cannot be instantiated.
+        //        The type of keys and values contained in a Map must
+        //        be specified upon instantiation of the implementing
+        //        class. Each key may map to only one corresponding value,
+        //        and each key may appear only once (no duplicates).
+        // HashMaps - This class uses a hashtable to implement the Map
+        //            interface. This allows the execution time of basic
+        //            operations, such as get and insert element, to remain
+        //            constant even for large sets.
+        // TreeMap - This class is a sorted tree structure. It implements a red
+        //           black tree and sorts the entries based on the key value or
+        //           the comparator provided while creating the object
+
+        ///////////////////////////////////////
+        // Operators
+        ///////////////////////////////////////
+        System.out.println("\n->Operators");
+
+        int i1 = 1, i2 = 2; // Shorthand for multiple declarations
+
+        // Arithmetic is straightforward
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+        // Modulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Comparison operators
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Boolean operators
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Bitwise operators!
+        /*
+        ~      Unary bitwise complement
+        <<     Signed left shift
+        >>     Signed/Arithmetic right shift
+        >>>    Unsigned/Logical right shift
+        &      Bitwise AND
+        ^      Bitwise exclusive OR
+        |      Bitwise inclusive OR
+        */
+
+        // Increment operators
+        int i = 0;
+        System.out.println("\n->Inc/Dec-rementation");
+        // The ++ and -- operators increment and decrement by 1 respectively.
+        // If they are placed before the variable, they increment then return;
+        // after the variable they return then increment.
+        System.out.println(i++); // i = 1, prints 0 (post-increment)
+        System.out.println(++i); // i = 2, prints 2 (pre-increment)
+        System.out.println(i--); // i = 1, prints 2 (post-decrement)
+        System.out.println(--i); // i = 0, prints 0 (pre-decrement)
+
+        ///////////////////////////////////////
+        // Control Structures
+        ///////////////////////////////////////
+        System.out.println("\n->Control Structures");
+
+        // If statements are c-like
+        int j = 10;
+        if (j == 10) {
+            System.out.println("I get printed");
+        } else if (j > 10) {
+            System.out.println("I don't");
+        } else {
+            System.out.println("I also don't");
+        }
+
+        // While loop
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Increment the counter
+            // Iterated 100 times, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("fooWhile Value: " + fooWhile);
+
+        // Do While Loop
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Increment the counter
+            // Iterated 99 times, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("fooDoWhile Value: " + fooDoWhile);
+
+        // For Loop
+        // for loop structure => for(<start_statement>; <conditional>; <step>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Iterated 10 times, fooFor 0->9
+        }
+        System.out.println("fooFor Value: " + fooFor);
+        
+        // Nested For Loop Exit with Label
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // breaks out of outer loop instead of only the inner one
+            }
+          }
+        }
+        
+        // For Each Loop
+        // The for loop is also able to iterate over arrays as well as objects
+        // that implement the Iterable interface.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // for each loop structure => for (<object> : <iterable>)
+        // reads as: for each element in the iterable
+        // note: the object type must match the element type of the iterable.
+        for (int bar : fooList) {
+            System.out.println(bar);
+            //Iterates 9 times and prints 1-9 on new lines
+        }
+
+        // Switch Case
+        // A switch works with the byte, short, char, and int data types.
+        // It also works with enumerated types (discussed in Enum Types), the
+        // String class, and a few special classes that wrap primitive types:
+        // Character, Byte, Short, and Integer.
+        int month = 3;
+        String monthString;
+        switch (month) {
+            case 1: monthString = "January";
+                    break;
+            case 2: monthString = "February";
+                    break;
+            case 3: monthString = "March";
+                    break;
+            default: monthString = "Some other month";
+                     break;
+        }
+        System.out.println("Switch Case Result: " + monthString);
+        
+        // Starting in Java 7 and above, switching Strings works like this:
+        String myAnswer = "maybe";
+        switch(myAnswer) {
+            case "yes":
+                System.out.println("You answered yes.");
+                break;
+            case "no":
+                System.out.println("You answered no.");
+                break;
+            case "maybe":
+                System.out.println("You answered maybe.");
+                break;
+            default:
+                System.out.println("You answered " + myAnswer);
+                break;
+        }
+        
+        
+        // Try-with-resources (Java 7+)
+        // Try-catch-finally statements work as expected in Java but in Java 7+
+        // the try-with-resources statement is also available. Try-with-resources
+        // simplifies try-catch-finally statements be closing resources
+        // automatically.
+        
+        // In order to use a try-with-resources, include a an instance of a class
+        // in the try statement. The class must implement java.lang.AutoCloseable.
+        try(BufferedReader br = new BufferedReader(new FileReader("foo.txt"))) {
+            // You can attempt to do something that could throw an exception.
+            System.out.println(br.readLine());
+            // In Java 7, the resource will always be closed, even if it throws
+            // an Exception. 
+        } catch (Exception ex) {
+            //The resource will be closed before the catch statement executes.
+            System.out.println("readLine() failed.");
+        }
+        // No need for a finally statement in this case, the BufferedReader is
+        // already closed. This can be used to avoid certain edge cases where
+        // a finally statement might not be called.
+        // To learn more:
+        // https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
+        
+        
+        // Conditional Shorthand
+        // You can use the '?' operator for quick assignments or logic forks.
+        // Reads as "If (statement) is true, use <first value>, otherwise, use
+        // <second value>"
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Prints A, because the statement is true
+
+        ////////////////////////////////////////
+        // Converting Data Types And Typecasting
+        ////////////////////////////////////////
+
+        // Converting data
+
+        // Convert String To Integer
+        Integer.parseInt("123");//returns an integer version of "123"
+
+        // Convert Integer To String
+        Integer.toString(123);//returns a string version of 123
+
+        // For other conversions check out the following classes:
+        // Double
+        // Long
+        // String
+
+        // Typecasting
+        // You can also cast Java objects, there's a lot of details and deals
+        // with some more intermediate concepts. Feel free to check it out here:
+        // https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+        ///////////////////////////////////////
+        // Classes And Functions
+        ///////////////////////////////////////
+
+        System.out.println("\n->Classes & Functions");
+
+        // (definition of the Bicycle class follows)
+
+        // Use new to instantiate a class
+        Bicycle trek = new Bicycle();
+
+        // Call object methods
+        trek.speedUp(3); // You should always use setter and getter methods
+        trek.setCadence(100);
+
+        // toString returns this Object's string representation.
+        System.out.println("trek info: " + trek.toString());
+
+        // Double Brace Initialization
+        // The Java Language has no syntax for how to create static Collections
+        // in an easy way. Usually you end up in the following way:
+        private static final Set<String> COUNTRIES = new HashSet<String>();
+        static {
+           COUNTRIES.add("DENMARK");
+           COUNTRIES.add("SWEDEN");
+           COUNTRIES.add("FINLAND");
+        }
+
+        // But there's a nifty way to achieve the same thing in an
+        // easier way, by using something that is called Double Brace
+        // Initialization.
+        private static final Set<String> COUNTRIES = new HashSet<String>() {{
+            add("DENMARK");
+            add("SWEDEN");
+            add("FINLAND");
+        }}
+
+        // The first brace is creating a new AnonymousInnerClass and the
+        // second one declares an instance initializer block. This block
+        // is called when the anonymous inner class is created.
+        // This does not only work for Collections, it works for all
+        // non-final classes.
+
+    } // End main method
+} // End LearnJava class
+
+// You can include other, non-public outer-level classes in a .java file,
+// but it is not good practice. Instead split classes into separate files.
+
+// Class Declaration Syntax:
+// <public/private/protected> class <class name> {
+//    // data fields, constructors, functions all inside.
+//    // functions are called as methods in Java.
+// }
+
+class Bicycle {
+
+    // Bicycle's Fields/Variables
+    public int cadence; // Public: Can be accessed from anywhere
+    private int speed;  // Private: Only accessible from within the class
+    protected int gear; // Protected: Accessible from the class and subclasses
+    String name; // default: Only accessible from within this package
+    static String className; // Static class variable
+
+    // Static block 
+    // Java has no implementation of static constructors, but
+    // has a static block that can be used to initialize class variables 
+    // (static variables). 
+    // This block will be called when the class is loaded.
+    static {
+        className = "Bicycle";
+    }
+
+    // Constructors are a way of creating classes
+    // This is a constructor
+    public Bicycle() {
+        // You can also call another constructor:
+        // this(1, 50, 5, "Bontrager");
+        gear = 1;
+        cadence = 50;
+        speed = 5;
+        name = "Bontrager";
+    }
+    // This is a constructor that takes arguments
+    public Bicycle(int startCadence, int startSpeed, int startGear,
+        String name) {
+        this.gear = startGear;
+        this.cadence = startCadence;
+        this.speed = startSpeed;
+        this.name = name;
+    }
+
+    // Method Syntax:
+    // <public/private/protected> <return type> <function name>(<args>)
+
+    // Java classes often implement getters and setters for their fields
+
+    // Method declaration syntax:
+    // <access modifier> <return type> <method name>(<args>)
+    public int getCadence() {
+        return cadence;
+    }
+
+    // void methods require no return statement
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+    public void speedUp(int increment) {
+        speed += increment;
+    }
+    public void slowDown(int decrement) {
+        speed -= decrement;
+    }
+    public void setName(String newName) {
+        name = newName;
+    }
+    public String getName() {
+        return name;
+    }
+
+    //Method to display the attribute values of this Object.
+    @Override // Inherited from the Object class.
+    public String toString() {
+        return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+            " name: " + name;
+    }
+} // end class Bicycle
+
+// PennyFarthing is a subclass of Bicycle
+class PennyFarthing extends Bicycle {
+    // (Penny Farthings are those bicycles with the big front wheel.
+    // They have no gears.)
+
+    public PennyFarthing(int startCadence, int startSpeed) {
+        // Call the parent constructor with super
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // You should mark a method you're overriding with an @annotation.
+    // To learn more about what annotations are and their purpose check this
+    // out: http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGear(int gear) {
+        this.gear = 0;
+    }
+}
+
+// Interfaces
+// Interface declaration syntax
+// <access-level> interface <interface-name> extends <super-interfaces> {
+//     // Constants
+//     // Method declarations
+// }
+
+// Example - Food:
+public interface Edible {
+    public void eat(); // Any class that implements this interface, must
+                       // implement this method.
+}
+
+public interface Digestible {
+    public void digest();
+    // In Java 8, interfaces can have default method.
+    // public void digest() {
+    //     System.out.println("digesting ...");
+    // }
+}
+
+// We can now create a class that implements both of these interfaces.
+public class Fruit implements Edible, Digestible {
+    @Override
+    public void eat() {
+        // ...
+    }
+
+    @Override
+    public void digest() {
+        // ...
+    }
+}
+
+// In Java, you can extend only one class, but you can implement many
+// interfaces. For example:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+    InterfaceTwo {
+    @Override
+    public void InterfaceOneMethod() {
+    }
+
+    @Override
+    public void InterfaceTwoMethod() {
+    }
+
+}
+
+// Abstract Classes
+
+// Abstract Class declaration syntax
+// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
+//     // Constants and variables
+//     // Method declarations
+// }
+
+// Marking a class as abstract means that it contains abstract methods that
+// must be defined in a child class. Similar to interfaces, abstract classes
+// cannot be instantiated, but instead must be extended and the abstract
+// methods defined. Different from interfaces, abstract classes can contain a
+// concrete and abstract methods. Methods in an interface cannot have a body,
+// mixture of unless the method is static, and variables are final by default,
+// unlike an abstract class. Also abstract classes CAN have the "main" method.
+public abstract class Animal
+{
+    public abstract void makeSound();
+
+    // Method can have a body
+    public void eat()
+    {
+        System.out.println("I am an animal and I am Eating.");
+        // Note: We can access private variable here.
+        age = 30;
+    }
+
+    // No need to initialize, however in an interface
+    // a variable is implicitly final and hence has
+    // to be initialized.
+    protected int age;
+
+    public void printAge()
+    {
+        System.out.println(age);  
+    }
+
+    // Abstract classes can have main function.
+    public static void main(String[] args)
+    {
+        System.out.println("I am abstract");
+    }
+}
+
+class Dog extends Animal
+{
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Bark");
+        // age = 30;    ==> ERROR!    age is private to Animal
+    }
+
+    // NOTE: You will get an error if you used the
+    // @Override annotation here, since java doesn't allow
+    // overriding of static methods.
+    // What is happening here is called METHOD HIDING.
+    // Check out this SO post: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// Final Classes
+
+// Final Class declaration syntax
+// <access-level> final <final-class-name> {
+//     // Constants and variables
+//     // Method declarations
+// }
+
+// Final classes are classes that cannot be inherited from and are therefore a
+// final child. In a way, final classes are the opposite of abstract classes
+// because abstract classes must be extended, but final classes cannot be
+// extended.
+public final class SaberToothedCat extends Animal
+{
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Final Methods
+public abstract class Mammal()
+{
+    // Final Method Syntax:
+    // <access modifier> final <return type> <function name>(<args>)
+
+    // Final methods, like, final classes cannot be overridden by a child
+    // class, and are therefore the final implementation of the method.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
+}
+
+// Enum Type
+//
+// An enum type is a special data type that enables for a variable to be a set
+// of predefined constants. The variable must be equal to one of the values
+// that have been predefined for it. Because they are constants, the names of
+// an enum type's fields are in uppercase letters. In the Java programming
+// language, you define an enum type by using the enum keyword. For example,
+// you would specify a days-of-the-week enum type as:
+public enum Day {
+    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+    THURSDAY, FRIDAY, SATURDAY 
+}
+
+// We can use our enum Day like that:
+public class EnumTest {
+    // Variable Enum
+    Day day;
+    
+    public EnumTest(Day day) {
+        this.day = day;
+    }
+    
+    public void tellItLikeItIs() {
+        switch (day) {
+            case MONDAY:
+                System.out.println("Mondays are bad.");
+                break;
+            case FRIDAY:
+                System.out.println("Fridays are better.");
+                break;   
+            case SATURDAY: 
+            case SUNDAY:
+                System.out.println("Weekends are best.");
+                break;     
+            default:
+                System.out.println("Midweek days are so-so.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        EnumTest firstDay = new EnumTest(Day.MONDAY);
+        firstDay.tellItLikeItIs(); // => Mondays are bad.
+        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
+        thirdDay.tellItLikeItIs(); // => Midweek days are so-so.
+    }
+}
+
+// Enum types are much more powerful than we show above. 
+// The enum body can include methods and other fields.
+// You can see more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## مطالب بیشتر
+
+لینکهای زیر را می توانید برای پیگیرهای بیشتر استفاده کنید.
+البته همیشه گوگل را در کنار دستتان داشته باشید!
+
+**سایت های راهنمای اصلی**:
+
+* [Java Tutorial Trail from Sun / Oracle](https://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](https://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](https://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](https://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+* New features in Java 8:
+    * [Lambda expressions (functional programming)](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
+    * [Date and time API (java.time package)](http://www.oracle.com/technetwork/articles/java/jf14-date-time-2125367.html)
+
+**راهنما و سایت های آموزشی**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+**کتاب‌ها**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](https://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](https://www.amazon.com/gp/product/0071606300)
diff --git a/factor.html.markdown b/factor.html.markdown
index a0726420..79596d83 100644
--- a/factor.html.markdown
+++ b/factor.html.markdown
@@ -24,33 +24,33 @@ Code in this file can be typed into Factor, but not directly imported because th
 5 4 +    ! No output
 
 ! `.` pops the top result from the stack and prints it.
-.    ! 9 
+.    ! 9
 
 ! More examples of arithmetic:
-6 7 * .        ! 42 
-1360 23 - .    ! 1337 
-12 12 / .      ! 1 
-13 2 mod .     ! 1 
+6 7 * .        ! 42
+1360 23 - .    ! 1337
+12 12 / .      ! 1
+13 2 mod .     ! 1
 
-99 neg .       ! -99 
--99 abs .      ! 99 
-52 23 max .    ! 52 
-52 23 min .    ! 23 
+99 neg .       ! -99
+-99 abs .      ! 99
+52 23 max .    ! 52
+52 23 min .    ! 23
 
 ! A number of words are provided to manipulate the stack, collectively known as shuffle words.
 
 3 dup -          ! duplicate the top item (1st now equals 2nd): 3 - 3
 2 5 swap /       ! swap the top with the second element:        5 / 2
-4 0 drop 2 /     ! remove the top item (dont print to screen):  4 / 2
+4 0 drop 2 /     ! remove the top item (don't print to screen):  4 / 2
 1 2 3 nip .s     ! remove the second item (similar to drop):    1 3
 1 2 clear .s     ! wipe out the entire stack
-1 2 3 4 over .s  ! duplicate the second item to the top: 1 2 3 4 3 
+1 2 3 4 over .s  ! duplicate the second item to the top: 1 2 3 4 3
 1 2 3 4 2 pick .s ! duplicate the third item to the top: 1 2 3 4 2 3
 
-! Creating Words 
+! Creating Words
 ! The `:` word sets Factor into compile mode until it sees the `;` word.
 : square ( n -- n ) dup * ;    ! No output
-5 square .                     ! 25 
+5 square .                     ! 25
 
 ! We can view what a word does too.
 ! \ suppresses evaluation of a word and pushes its identifier on the stack instead.
@@ -88,9 +88,9 @@ Code in this file can be typed into Factor, but not directly imported because th
 0 [ "Zero is true" . ] when                     ! Zero is true
 f [ "F is true" . ] when                        ! No output
 f [ "F is false" . ] unless                     ! F is false
-2 [ "Two is true" . ] [ "Two is false" . ] if   ! Two is true 
+2 [ "Two is true" . ] [ "Two is false" . ] if   ! Two is true
 
-! By default the conditionals consume the value under test, but starred variants 
+! By default the conditionals consume the value under test, but starred variants
 ! leave it alone if it's true:
 
 5 [ . ] when*      ! 5
@@ -100,7 +100,7 @@ f [ . ] when*      ! No output, empty stack, f is consumed because it's false
 ! Loops
 ! You've guessed it.. these are higher order words too.
 
-5 [ . ] each-integer               ! 0 1 2 3 4 
+5 [ . ] each-integer               ! 0 1 2 3 4
 4 3 2 1 0 5 [ + . ] each-integer   ! 0 2 4 6 8
 5 [ "Hello" . ] times              ! Hello Hello Hello Hello Hello
 
@@ -114,7 +114,7 @@ f [ . ] when*      ! No output, empty stack, f is consumed because it's false
 ! Loop reducing or building lists:
 { 1 2 3 4 5 } [ 2 mod 0 = ] filter  ! Keeps only list members for which quotation yields true: { 2 4 }  
 { 2 4 6 8 } 0 [ + ] reduce .        ! Like "fold" in functional languages: prints 20 (0+2+4+6+8)
-{ 2 4 6 8 } 0 [ + ] accumulate . .  ! Like reduce but keeps the intermediate values in a list: prints { 0 2 6 12 } then 20 
+{ 2 4 6 8 } 0 [ + ] accumulate . .  ! Like reduce but keeps the intermediate values in a list: prints { 0 2 6 12 } then 20
 1 5 [ 2 * dup ] replicate .         ! Loops the quotation 5 times and collects the results in a list: { 2 4 8 16 32 }
 1 [ dup 100 < ] [ 2 * dup ] produce ! Loops the second quotation until the first returns false and collects the results: { 2 4 8 16 32 64 128 }
 
@@ -142,7 +142,7 @@ name get-global .       ! "Bob"
    2 :> c                 ! Declares immutable variable c to hold 2
    c . ;                  ! Print it out
 
-! In a word declared this way,  the input side of the stack declaration 
+! In a word declared this way,  the input side of the stack declaration
 ! becomes meaningful and gives the variable names stack values are captured into
 :: double ( a -- result ) a 2 * ;
 
@@ -150,7 +150,7 @@ name get-global .       ! "Bob"
 :: mword2 ( a! -- x y )   ! Capture top of stack in mutable variable a
    a                      ! Push a
    a 2 * a!               ! Multiply a by 2 and store result back in a
-   a ;                    ! Push new value of a 
+   a ;                    ! Push new value of a
 5 mword2                  ! Stack: 5 10
 
 ! Lists and Sequences
@@ -167,7 +167,7 @@ name get-global .       ! "Bob"
 "Concat" "enate" append                       ! "Concatenate" - strings are sequences too
 "Concatenate" "Reverse " prepend              ! "Reverse Concatenate"
 { "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs"
-{ "Connect" "subseqs" "with" "separators" } " " join  ! "Connect subseqs with separators" 
+{ "Connect" "subseqs" "with" "separators" } " " join  ! "Connect subseqs with separators"
 
 ! And if you want to get meta, quotations are sequences and can be dismantled..
 0 [ 2 + ] nth                              ! 2
diff --git a/fi-fi/markdown-fi.html.markdown b/fi-fi/markdown-fi.html.markdown
index 14b0f1d9..c5ee52b0 100644
--- a/fi-fi/markdown-fi.html.markdown
+++ b/fi-fi/markdown-fi.html.markdown
@@ -50,8 +50,8 @@ __Kuten on tämäkin teksti.__
 **_Kuten tämäkin!_**
 *__Kuten tämäkin!__*
 
-<!-- Github-tyylisessä Markdownissa, jota käytetään tiedostojen esittämiseksi
-Githubissa, meillä on käytössämme myös yliviivaus: -->
+<!-- GitHub-tyylisessä Markdownissa, jota käytetään tiedostojen esittämiseksi
+GitHubissa, meillä on käytössämme myös yliviivaus: -->
 
 ~~Tämä teksti on yliviivattua.~~
 
@@ -150,7 +150,7 @@ rivin neljällä välilyönnillä tai tabulaattorilla. -->
 
 John ei tiennyt edes mitä `go_to()` -funktio teki!
 
-<!-- Githubin Markdownissa voit käyttää erityissyntaksia koodille. -->
+<!-- GitHubin Markdownissa voit käyttää erityissyntaksia koodille. -->
 
 \`\`\`ruby <!-- paitsi että poista nuo kenoviivat, vain ```ruby ! -->
 def foobar
@@ -158,7 +158,7 @@ def foobar
 end
 \`\`\` <!-- tästä myös, ei kenoviivoja, vain ``` -->
 
-<!-- Yllä oleva teksti ei vaadi sisennystä. Lisäksi Github käyttää ``` jälkeen
+<!-- Yllä oleva teksti ei vaadi sisennystä. Lisäksi GitHub käyttää ``` jälkeen
 mainitsemasi kielen syntaksin korostusta  -->
 
 <!-- Vaakaviiva (<hr />) -->
@@ -231,13 +231,13 @@ haluan kirjoittaa *tämän tekstin jonka ympärillä on asteriskit* mutta en hal
 sen kursivoituvan, joten teen näin: \*tämän tekstin ympärillä on asteriskit\*.
 
 <!-- Näppäimistön näppäimet -->
-<!-- Githubin Markdownissa, voit käyttää <kbd> -tagia esittämään näppäimiä -->
+<!-- GitHubin Markdownissa, voit käyttää <kbd> -tagia esittämään näppäimiä -->
 
 Tietokoneesi kaatui? Kokeile painaa
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 
 <!-- Taulukot -->
-<!-- Taulukot ovat saatavilla vain Githubin markdownissa ja ne ovat melko
+<!-- Taulukot ovat saatavilla vain GitHubin markdownissa ja ne ovat melko
 vaivalloisia käyttää, mutta jos todella haluat: -->
 
 | Kolumni1     | Kolumni2 | Kolumni3      |
diff --git a/fi-fi/ruby-fi.html.markdown b/fi-fi/ruby-fi.html.markdown
new file mode 100644
index 00000000..52c60182
--- /dev/null
+++ b/fi-fi/ruby-fi.html.markdown
@@ -0,0 +1,608 @@
+---
+language: ruby
+filename: learnruby-fi.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+translators:
+  - ["Oliver Vartiainen", "https://github.com/firoxer"]
+lang: fi-fi
+---
+
+```ruby
+# Tässä yhden rivin kommentti
+
+=begin
+Tässä usean rivin kommentti
+Näitä ei kylläkään käytetä
+Joten käytetään vastedes vain yksirivisiä
+=end
+
+# Tärkeintä on muistaa, että Rubyssa kaikki pohjautuu olioihin.
+
+# Luvutkin ovat olioita:
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+# Peruslaskutoimituksia:
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+
+# Bittioperaatioita:
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# Laskutoimitukset ovat vain syntaksisokeria lukuolion laskumetodin kutsulle:
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Erityisarvotkin ovat olioita:
+
+nil # vastaa joidenkin kielten "null"-arvoa
+true # tosi
+false # epätosi
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Samanvertaisuuden testaus:
+1 == 1 #=> true
+2 == 1 #=> false
+
+# ...ja sama eriarvoisuudelle:
+1 != 1 #=> false
+2 != 1 #=> true
+
+# "nil" ja "false" ovat ainoat epätodet arvot; kaikki muu ymmärretään todeksi:
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Lisää vertailuoperaatioita:
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Kahdensuuntainen vertailuoperaattori:
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Logiikkaoperaattorit:
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Merkkipohjaisten logiikkaoperaattorien vaihtoehtona on sanalliset muodot,
+# joilla on hyvin matala presedenssi. Niillä voi muokata ohjelman kulkua
+# esimerkiksi väitelausekkeita ketjuttaen.
+
+# Metodia `do_something_else` kutsutaan vain, jos `do_something` onnistuu:
+do_something() and do_something_else()
+# Metodia `log_error` kutsutaan vain, jos `do_something` epäonnistuu:
+do_something() or log_error()
+
+# Merkkijonot ovat olioita:
+
+'Tässä on merkkijono'.class #=> String
+"Rajaavat lainausmerkit voivat olla yksin- tai kaksinkertaisia".class #=> String
+
+täyte = 'sisällyttää muita merkkijonoja'
+"Kaksinkertaisilla lainausmerkeillä voi #{täyte}"
+#=> "Kaksinkertaisilla lainausmerkeillä voi sisällyttää muita merkkijonoja"
+
+# Yksinkertaisia lainausmerkkejä kannattaa silti suosia, sillä kaksinkertaiset
+# merkit saattavat aiheuttaa turhia kielensisäisiä tarkistuksia.
+
+# Merkkijonoja voi yhdistellä toisiinsa:
+'hello ' + 'world'  #=> "hello world"
+
+# ...mutta luvut vaativat ensin tyyppimuunnoksen:
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+
+# Merkkijonoja voi soveltaa laskutoimituksiin... odotettavin seurauksin:
+'hello ' * 3 #=> "hello hello hello "
+
+# Merkkijonoa voi jatkaa toisella:
+'hello' << ' world' #=> "hello world"
+
+# Tulosteen luonti kera rivinvaihdon:
+puts "I'm printing!"
+#=> I'm printing!
+#=> nil
+
+# ...ja ilman rivinvaihtoa:
+print "I'm printing!"
+#=> I'm printing! => nil
+
+# Muuttujien määrittely:
+x = 25 #=> 25
+x #=> 25
+
+# Arvon asettaminen palauttaa arvon itsensä, joten usean muuttujan arvon
+# yhtäaikainen määrittely käy vaivatta:
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Muuttujien sanaerottimena käytetään alaviivaa:
+snake_case = true
+
+# Lisäksi Rubyssa suositaan ytimekkäitä nimiä:
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+
+# Symbolit
+
+# Symbolit ovat muuttumattomia, uudelleenkäytettäviä vakioita.
+# Niitä käytetään merkkijonojen sijaan, kun tarkoitus on viitata arvoon,
+# jolla on tietty, pysyvä merkitys:
+
+:pending.class #=> Symbol
+
+status = :pending
+
+status == :pending #=> true
+
+status == 'pending' #=> false
+
+status == :approved #=> false
+
+# Taulukot
+
+# Tässä taulukko:
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Taulukko saa koostua erityyppisistä arvoista:
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Taulukon alkioihin voi viitata järjestysnumerolla nollasta alkaen:
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+# Kuten laskutoimituksissa nähty syntaksisokeri on myös taulukon alkioiden haku
+# pohjimmiltaan vain taulukko-olioon kuuluvan "[]"-metodin kutsu:
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Haku käy myös lopustapäin:
+array[-1] #=> 5
+array.last #=> 5
+
+# Alitaulukon haku käy indeksiparilla...
+array[2, 3] #=> [3, 4, 5]
+
+# ...tai määrittelemällä väli:
+array[1..3] #=> [2, 3, 4]
+
+# Taulukon voi kääntää:
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Ja sitä voi jatkaa näin...
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# ...tai näin:
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Alkion olemassaolon tarkistus:
+array.include?(1) #=> true
+
+# Hashit eli assosiaatiotaulut ovat Rubyn tärkein avain-/arvoparirakenne.
+# Hash luodaan aaltosulkeilla:
+hash = { 'color' => 'green', 'number' => 5 }
+
+hash.keys #=> ['color', 'number']
+
+# Hash toimii erityisen nopeasti, kun haetaan arvoa avaimen perusteella:
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+
+# Jos hashistä ei löyty avainta vastaavaa arvoa, palautetaan nil-arvo:
+hash['nothing here'] #=> nil
+
+# Symbolihashin määrittelylle on oma syntaksinsa (alkaen Rubyn versiosta 1.9):
+new_hash = { defcon: 3, action: true }
+new_hash.keys #=> [:defcon, :action]
+
+# Hashin avaimen ja arvon olemassaolon tarkistus:
+new_hash.key?(:defcon) #=> true
+new_hash.value?(3) #=> true
+
+# Vinkki! Sekä taulukot että hashit sisältävät Enumerable-moduulin,
+# johon kuuluu useita hyödyllisiä iterointimetodeja kuten .each, .map,
+# .reduce ja .count
+
+# Rakenteita
+
+if true
+  'if statement'
+elsif false
+  'else if, optional'
+else
+  'else, also optional'
+end
+
+for counter in 1..5
+  puts "iteration #{counter}"
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+# HUOMAA, että for-rakennetta kannattaa välttää, sillä Rubyssa suosittu
+# each-metodi ajaa saman asian idiomaattisemmin. Each-metodi ottaa ainoana
+# argumenttinaan lohkon. Lohkot toimivat pitkälti samoin kuin muiden kielten
+# anonyymit funktiot, lambdat tai sulkeumat.
+
+# Lukuvälit vastaavat each-metodiin, jolloin sille annettu lohko ajetaan
+# kerran jokaiselle välin kokonaisluvulle.
+# Lukuvälin each-rakenne lohkoineen näyttää tältä:
+
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+# Lohkoa ympäröivät do/end-avainsanat voi korvata myös aaltosulkeilla:
+(1..5).each { |counter| puts "iteration #{counter}" }
+
+# Lukuvälien lisäksi myös tietorakenteita voidaan iteroida each-metodilla:
+array.each do |element|
+  puts "#{element} is part of the array"
+end
+hash.each do |key, value|
+  puts "#{key} is #{value}"
+end
+
+# Taulukoita voi iteroida metodilla each_with_index, jolloin lohko saa
+# argumenteikseen sekä alkion että indeksin:
+array.each_with_index do |element, index|
+  puts "#{element} is number #{index} in the array"
+end
+
+counter = 1
+while counter <= 5 do
+  puts "iteration #{counter}"
+  counter += 1
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+# Each-metodin lisäksi Rubyssa on useita muita iterointimetodeja kuten
+# "map" ja "reduce". Näistä "map" kutsuttuna taulukolla ottaa argumentikseen
+# lohkon, suorittaa sen kerran jokaiselle rakenteen jäsenelle, ja lopuksi
+# palauttaa uuden taulukon, jonka jäsenet ovat lohkon suorituksen tuloksia.
+
+array = [1, 2, 3, 4, 5]
+doubled = array.map do |element|
+  element * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+# Case-rakenne siirtää ohjelman kulun yhdelle monista määritellyistä poluista:
+
+grade = 'B'
+
+case grade
+when 'A'
+  puts 'Way to go kiddo'
+when 'B'
+  puts 'Better luck next time'
+when 'C'
+  puts 'You can do better'
+when 'D'
+  puts 'Scraping through'
+when 'F'
+  puts 'You failed!'
+else
+  puts 'Alternative grading system, eh?'
+end
+#=> "Better luck next time"
+
+# Case-rakenteessa voidaan hyödyntää lukuvälejä:
+grade = 82
+case grade
+when 90..100
+  puts 'Hooray!'
+when 80...90
+  puts 'OK job'
+else
+  puts 'You failed!'
+end
+#=> "OK job"
+
+# Virheidenkäsittely:
+begin
+  # Seuraava koodinpätkä aiheuttaa NoMemoryError-poikkeuksen
+  raise NoMemoryError, 'You ran out of memory.'
+rescue NoMemoryError => exception_variable
+  puts 'NoMemoryError was raised', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'RuntimeError was raised now'
+else
+  puts 'This runs if no exceptions were thrown at all'
+ensure
+  puts 'This code always runs no matter what'
+end
+
+# Ylimmän näkyvyysalueen metodi näyttää itsenäiseltä funktiolta:
+def double(x)
+  x * 2
+end
+
+# Funktiot (ja lohkot) palauttavat implisiittisesti
+# viimeiseksi ajamansa lausekkeen arvon:
+double(2) #=> 4
+
+# Metodikutsun argumentteja ympäröivät kaarisulkeet voi jättää pois,
+# kunhan koodi ei muutu monitulkintaiseksi:
+
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Argumentit erotetaan pilkuilla:
+
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# Kaikilla metodeilla on implisiittinen lohkoparametri,
+# joka voidaan suorittaa yield-avainsanalla:
+
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts 'hello world' }
+
+# {
+# hello world
+# }
+
+# Metodille annetun lohkon voi nimetä parametrilistassa &-merkin avulla,
+# minkä jälkeen se suoritetaan call-metodilla:
+def guests(&block)
+  block.call 'some_argument'
+end
+
+# Metodille voi antaa vaihtelevan määrän muuttujia. Ne siirretään taulukkoon,
+# jolle annetaan parametrilistassa nimi \*-merkin avulla
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Luokan määritys aloitetaan class-avainsanalla:
+
+class Human
+
+  # Tässä luokkamuuttuja, joka on yhteinen kaikille luokan olioille:
+  @@species = 'H. sapiens'
+
+  # Alustusmetodin määrittely:
+  def initialize(name, age = 0)
+	# name-oliomuuttujan arvon asetus metodille annetun name-muuttujan mukaan:
+    @name = name
+
+	# Jos tätä metodia kutsuessa jätetään toinen argumentti (age) antamatta,
+	# saa se parametriluettelossa määritetyn arvon 0:
+    @age = age
+  end
+
+  # Tyypillinen oliomuuttujan arvon asettava metodi:
+  def name=(name)
+    @name = name
+  end
+
+  # Tyypillinen oliomuuttujan arvon palauttava metodi:
+  def name
+    @name
+  end
+
+  # Edelliset kaksi metodia voi ilmaista idiomaattisemmin myös näin:
+  attr_accessor :name
+
+  # Lisäksi arvon palauttavan ja asettavan metodin voi määritellä erikseen:
+  attr_reader :name
+  attr_writer :name
+
+  # Luokkametodeissa käytetään avainsanaa self erotuksena oliometodeista.
+  # Luokkametodia voi kutsua vain luokalla itsellään, ei olioilla:
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+# Olion luonti:
+
+jim = Human.new('Jim Halpert')
+
+dwight = Human.new('Dwight K. Schrute')
+
+# Olion metodien kutsuja:
+jim.species #=> "H. sapiens"
+jim.name #=> "Jim Halpert"
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.name #=> "Jim Halpert II"
+dwight.species #=> "H. sapiens"
+dwight.name #=> "Dwight K. Schrute"
+
+# Luokkametodin kutsu:
+Human.say('Hi') #=> "Hi"
+
+# Muuttujan näkyvyysalueen voi määritellä etuliitteellä.
+
+# $-alkuiset muuttujat ovat globaaleja:
+$var = "I'm a global var"
+defined? $var #=> "global-variable"
+
+# @-alkuiset muuttujat kuuluvat oliolle,
+# jonka näkyvyysalueella määrittely tehdään:
+@var = "I'm an instance var"
+defined? @var #=> "instance-variable"
+
+# @@-alkuiset muuttujat kuuluvat vastaavasti näkyvyysalueensa luokalle:
+@@var = "I'm a class var"
+defined? @@var #=> "class variable"
+
+# Isolla alkukirjaimella nimetyt muuttujat ovatkin vakioita:
+Var = "I'm a constant"
+defined? Var #=> "constant"
+
+# Kuten odottaa saattaa, myös luokat itsessään ovat olioita.
+# Siksi niille voi määritellä muuttujia, jotka ovat yhteisiä kaikille
+# luokan ilmentymille ja perillisille.
+
+# Tavallisen luokan määrittely:
+
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Perillisluokan määrittely:
+
+class Worker < Human
+end
+
+Human.foo # 0
+Worker.foo # 0
+
+Human.foo = 2 # 2
+Worker.foo # 2
+
+# Oliomuuttuja on kuitenkin olion oma eikä periydy:
+
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+Human.bar # 0
+Doctor.bar # nil
+
+module ModuleExample
+  def foo
+    'foo'
+  end
+end
+
+# Moduulien lisääminen luokkaan "include"-avainsanalla siirtää moduulin metodit
+# luokan ilmentymille, kun taas "extend" avainsana siirtää metodit
+# luokalle itselleen:
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => NoMethodError: undefined method `foo'
+
+# Callback-tyyppiset metodit suoritetaan moduulia sisällyttäessä:
+
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     # => 'bar'
+Something.qux     # => NoMethodError: undefined method `qux'
+Something.new.bar # => NoMethodError: undefined method `bar'
+Something.new.qux # => 'qux'
+```
+
+## Lisämateriaalia englanniksi
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Selaimessa tehtäviä harjoituksia tämän dokumentin hengessä
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/)
+- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/) - Virallinen dokumentaatio
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Vanhempi, mutta [ilmainen painos](http://ruby-doc.com/docs/ProgrammingRuby/) on luettavissa netissä
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Yhteisön luoma Ruby-tyyliopas
+- [Try Ruby](http://tryruby.org) - Rubyn perusteet interaktiivisesti
diff --git a/forth.html.markdown b/forth.html.markdown
index b4a5581b..09f3beb0 100644
--- a/forth.html.markdown
+++ b/forth.html.markdown
@@ -12,7 +12,7 @@ such as Open Firmware. It's also used by NASA.
 Note: This article focuses predominantly on the Gforth implementation of
 Forth, but most of what is written here should work elsewhere.
 
-```
+```forth
 \ This is a comment
 ( This is also a comment but it's only used when defining words )
 
@@ -54,7 +54,7 @@ Forth, but most of what is written here should work elsewhere.
 3 dup -          \ duplicate the top item (1st now equals 2nd): 3 - 3
 2 5 swap /       \ swap the top with the second element:        5 / 2
 6 4 5 rot .s     \ rotate the top 3 elements:                   4 5 6
-4 0 drop 2 /     \ remove the top item (dont print to screen):  4 / 2
+4 0 drop 2 /     \ remove the top item (don't print to screen):  4 / 2
 1 2 3 nip .s     \ remove the second item (similar to drop):    1 3
 
 \ ---------------------- More Advanced Stack Manipulation ----------------------
diff --git a/fortran95.html.markdown b/fortran95.html.markdown
new file mode 100644
index 00000000..8479fef8
--- /dev/null
+++ b/fortran95.html.markdown
@@ -0,0 +1,452 @@
+---
+language: Fortran
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+filename: learnfortran.f95
+---
+
+Fortran is one of the oldest computer languages. It was developed in the 1950s 
+by IBM for numeric calculations (Fortran is an abreviation of "Formula 
+Translation"). Despite its age, it is still used for high-performance computing
+such as weather prediction. However, the language has changed considerably over
+the years, although mostly maintaining backwards compatibility; well known
+versions are FORTRAN 77, Fortran 90, Fortran 95, Fortran 2003, Fortran 2008 and
+Fortran 2015.
+
+This overview will discuss the features of Fortran 95 since it is the most
+widely implemented of the more recent specifications and the later versions are
+largely similar (by comparison FORTRAN 77 is a very different language).
+
+```fortran
+
+! This is a comment.
+
+
+program example   !declare a program called example.
+
+    ! Code can only exist inside programs, functions, subroutines or modules.
+    ! Using indentation is not required but it is recommended.
+
+
+    ! Declaring Variables
+    ! ===================
+    
+    ! All declarations must come before statements and expressions.
+    
+    implicit none    !prevents dynamic declaration of variables (recommended!)
+    ! Implicit none must be redeclared in every function/program/module...
+    
+    ! IMPORTANT - Fortran is case insensitive.
+    real z
+    REAL Z2
+
+    real :: v,x    ! WARNING: default initial values are compiler dependent!    
+    real :: a = 3, b=2E12, c = 0.01
+    integer :: i, j, k=1, m
+    real, parameter :: PI = 3.1415926535897931    !declare a constant.
+    logical :: y = .TRUE. , n = .FALSE.    !boolean type.
+    complex :: w = (0,1)    !sqrt(-1)
+    character (len=3) :: month    !string of 3 characters.
+    
+    real :: array(6)     !declare an array of 6 reals.
+    real, dimension(4) :: arrayb    !another way to declare an array.
+    integer :: arrayc(-10:10)   !an array with a custom index.
+    real :: array2d(3,2)    !multidimensional array.
+    
+    ! The '::' separators are not always necessary but are recommended.
+
+    ! many other variable attributes also exist:
+    real, pointer :: p    !declare a pointer.
+
+    integer, parameter :: LP = selected_real_kind(20)
+    real (kind = LP) :: d    !long precision variable.
+
+    ! WARNING: initialising variables during declaration causes problems
+    ! in functions since this automatically implies the 'save' attribute
+    ! whereby values are saved between function calls. In general, separate
+    ! declaration and initialisation code except for constants!
+    
+    
+    ! Strings
+    ! =======
+
+    character :: a_char = 'i'
+    character (len = 6) :: a_str = "qwerty"
+    character (len = 30) :: str_b
+    character (len = *), parameter :: a_long_str = "This is a long string."
+    !can have automatic counting of length using (len=*) but only for constants.
+    
+    str_b = a_str // " keyboard"    !concatenate strings using // operator.
+
+
+    ! Assignment & Arithmetic
+    ! =======================
+
+    Z = 1    !assign to variable z declared above (case insensitive).
+    j = 10 + 2 - 3
+    a = 11.54  /  (2.3 * 3.1)
+    b = 2**3    !exponentiation
+
+
+    ! Control Flow Statements & Operators
+    ! ===================================
+
+    ! Single-line if statement
+    if (z == a) b = 4  !condition always need surrounding parentheses.
+
+    if (z /= a) then !z not equal to a
+    ! Other symbolic comparisons are < > <= >= == /=
+      b = 4
+    else if (z .GT. a) then !z greater than a
+    ! Text equivalents to symbol operators are .LT. .GT. .LE. .GE. .EQ. .NE.  
+      b = 6
+    else if (z < a) then !'then' must be on this line.
+      b = 5 !execution block must be on a new line.
+    else
+      b = 10
+    end if !end statement needs the 'if' (or can use 'endif').
+
+
+    if (.NOT. (x < c .AND. v >= a .OR. z == z)) then   !boolean operators.
+      inner: if (.TRUE.) then    !can name if-construct.
+        b = 1
+      endif inner    !then must name endif statement.
+    endif
+
+
+    i = 20
+    select case (i)
+      case (0)    !case i == 0
+        j=0
+      case (1:10)    !cases i is 1 to 10 inclusive.
+        j=1
+      case (11:)    !all cases where i>=11
+        j=2
+      case default
+        j=3
+    end select
+
+
+    month = 'jan'
+    ! Condition can be integer, logical or character type.
+    ! Select constructions can also be named.
+    monthly: select case (month)
+      case ("jan")
+         j = 0
+      case default
+         j = -1
+    end select monthly
+
+
+    do i=2,10,2    !loops from 2 to 10 (inclusive) in increments of 2.
+      innerloop: do j=1,3    !loops can be named too.
+        exit    !quits the loop.
+      end do innerloop
+    cycle    !jump to next loop iteration.
+    enddo
+
+    
+    ! Goto statement exists but it is heavily discouraged though.
+    goto 10    
+    stop 1    !stops code immediately (returning specified condition code).
+10  j = 201    !this line is labeled as line 10
+    
+    
+    ! Arrays
+    ! ======
+    array = (/1,2,3,4,5,6/)
+    array = [1,2,3,4,5,6]    !using Fortran 2003 notation.
+    arrayb = [10.2,3e3,0.41,4e-5]
+    array2d =  reshape([1.0,2.0,3.0,4.0,5.0,6.0], [3,2])
+    
+    ! Fortran array indexing starts from 1.
+    ! (by default but can be defined differently for specific arrays).
+    v = array(1)    !take first element of array.
+    v = array2d(2,2)
+    
+    print *, array(3:5)    !print all elements from 3rd to 5th (inclusive).
+    print *, array2d(1,:)    !print first column of 2d array.
+    
+    array = array*3 + 2    !can apply mathematical expressions to arrays.
+    array = array*array    !array operations occur element-wise.
+    !array = array*array2d    !these arrays would not be compatible.
+    
+    ! There are many built-in functions that operate on arrays.
+    c = dot_product(array,array)    !this is the dot product.
+    ! Use matmul() for matrix maths.
+    c = sum(array)
+    c = maxval(array)
+    print *, minloc(array)
+    c = size(array)
+    print *, shape(array)
+    m = count(array > 0)
+    
+    ! Loop over an array (could have used Product() function normally).
+    v = 1
+    do i = 1, size(array)
+        v = v*array(i)
+    end do
+    
+    ! Conditionally execute element-wise assignments.
+    array = [1,2,3,4,5,6]
+    where (array > 3)
+        array = array + 1
+    elsewhere (array == 2)
+        array = 1
+    elsewhere
+        array = 0
+    end where
+    
+    ! Implied-DO loops are a compact way to create arrays.
+    array = [ (i, i = 1,6) ]    !creates an array of [1,2,3,4,5,6]
+    array = [ (i, i = 1,12,2) ]    !creates an array of [1,3,5,7,9,11]
+    array = [ (i**2, i = 1,6) ]    !creates an array of  [1,4,9,16,25,36]
+    array = [ (4,5, i = 1,3) ]    !creates an array of [4,5,4,5,4,5]
+    
+
+    ! Input/Output
+    ! ============
+    
+    print *, b    !print the variable 'b' to the command line
+
+    ! We can format our printed output.
+    print "(I6)", 320    !prints '   320'
+    print "(I6.4)", 3    !prints '  0003' 
+    print "(F6.3)", 4.32    !prints ' 4.320'
+    
+    ! The letter indicates the expected type and the number afterwards gives 
+    ! the number of characters to use for printing the value.
+    ! Letters can be I (integer), F (real), E (engineering format), 
+    ! L (logical), A (characters) ...
+    print "(I3)", 3200    !print '***' since the number doesn't fit.
+    
+    ! we can have multiple format specifications.
+    print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
+    print "(3I5)", 10, 20, 30    !3 repeats of integers (field width = 5).
+    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3   !repeated grouping of formats.
+
+    ! We can also read input from the terminal.
+    read *, v
+    read "(2F6.2)", v, x    !read two numbers
+
+    ! To read a file.
+    open(unit=11, file="records.txt", status="old") 
+    ! The file is referred to by a 'unit number', an integer that you pick in
+    ! the range 9:99. Status can be one of {'old','replace','new'}.
+    read(unit=11, fmt="(3F10.2)") a, b, c
+    close(11)
+
+    ! To write a file.
+    open(unit=12, file="records.txt", status="replace")
+    write(12, "(F10.2,F10.2,F10.2)") c, b, a
+    close(12)
+
+    ! There are more features available than discussed here and alternative 
+    ! variants due to backwards compatability with older Fortran versions.  
+    
+    
+    ! Built-in Functions
+    ! ==================
+
+    ! Fortran has around 200 functions/subroutines intrinsic to the language.
+    ! Examples - 
+    call cpu_time(v)    !sets 'v' to a time in seconds.
+    k = ior(i,j)    !bitwise OR of 2 integers.
+    v = log10(x)    !log base 10.
+    i = floor(b)    !returns the closest integer less than or equal to x.
+    v = aimag(w)    !imaginary part of a complex number.
+    
+
+    ! Functions & Subroutines
+    ! =======================
+    
+    ! A subroutine runs some code on some input values and can cause
+    ! side-effects or modify the input values.
+    
+    call routine(a,c,v)    !subroutine call.
+    
+    ! A function takes a list of input parameters and returns a single value.
+    ! However the input parameters may still be modified and side effects 
+    ! executed.
+    
+    m = func(3,2,k)  !function call.
+    
+    ! Function calls can also be evoked within expressions.
+    Print *, func2(3,2,k) 
+    
+    ! A pure function is a function that doesn't modify its input parameters
+    ! or cause any side-effects.
+    m = func3(3,2,k)
+
+
+contains ! Zone for defining sub-programs internal to the program.
+
+    ! Fortran has a couple of slightly different ways to define functions.
+
+    integer function func(a,b,c)    !a function returning an integer value.
+        implicit none   !best to use implicit none in function definitions too.
+        integer :: a,b,c !type of input parameters defined inside the function.
+        if (a >= 2) then
+            func = a + b + c !the return variable defaults to the function name.
+            return !can return the current value from the function at any time.
+        endif
+        func = a + c
+        ! Don't need a return statement at the end of a function.
+    end function func
+
+
+    function func2(a,b,c) result(f)    !return variable declared to be 'f'.
+        implicit none
+        integer, intent(in) :: a,b    !can declare and enforce that variables 
+                                      !are not modified by the function.
+        integer, intent(inout) :: c
+        integer :: f     !function return type declared inside the function.
+        integer :: cnt = 0    !GOTCHA - initialisation implies variable is
+                              !saved between function calls.
+        f = a + b - c
+        c = 4    !altering the value of an input variable.
+        cnt  = cnt + 1    !count number of function calls.
+    end function func2
+
+
+    pure function func3(a,b,c)  !a pure function can have no side-effects.
+        implicit none
+        integer, intent(in) :: a,b,c
+        integer :: func3
+        func3 = a*b*c
+    end function func3
+
+
+    subroutine routine(d,e,f)
+        implicit none
+        real, intent(inout) :: f
+        real, intent(in) :: d,e
+        f = 2*d + 3*e + f
+    end subroutine routine
+
+
+end program example   ! End of Program Definition -----------------------
+
+
+! Functions and Subroutines declared externally to the program listing need 
+! to be declared to the program using an Interface declaration (even if they
+! are in the same source file!) (see below). It is easier to define them within
+! the 'contains' section of a module or program.
+
+elemental real function func4(a) result(res)
+! An elemental function is a Pure function that takes a scalar input variable
+! but can also be used on an array where it will be separately applied to all 
+! of the elements of an array and return a new array.
+    real, intent(in) :: a
+    res = a**2 + 1.0
+end function func4
+
+
+! Modules
+! =======
+
+! A module is a useful way to collect related declarations, functions and 
+! subroutines together for reusability.
+
+module fruit
+    real :: apple
+    real :: pear
+    real :: orange
+end module fruit
+
+
+module fruity
+    ! Declarations must be in the order: modules, interfaces, variables.
+    ! (can declare modules and interfaces in programs too).
+    
+    use fruit, only: apple, pear    ! use apple and pear from fruit module.
+    implicit none    !comes after module imports.
+
+    private    !make things private to the module (default is public).
+    ! Declare some variables/functions explicitly public.
+    public :: apple,mycar,create_mycar
+    ! Declare some variables/functions private to the module (redundant here).
+    private :: func4
+    
+    ! Interfaces
+    ! ==========
+    ! Explicitly declare an external function/procedure within the module
+    ! (better in general to put functions/procedures in the 'contains' section).
+    interface
+        elemental real function func4(a) result(res)
+            real, intent(in) :: a
+        end function func4
+    end interface
+    
+    ! Overloaded functions can be defined using named interfaces.
+    interface myabs
+        ! Can use 'module procedure' keyword to include functions already
+        ! defined within the module.
+        module procedure real_abs, complex_abs
+    end interface 
+        
+    ! Derived Data Types
+    ! ==================
+    ! Can create custom structured data collections.
+    type car
+        character (len=100) :: model
+        real :: weight    !(kg)
+        real :: dimensions(3)    !i.e. length-width-height (metres).
+        character :: colour
+    end type car
+    
+    type(car) :: mycar    !declare a variable of your custom type.
+    ! See create_mycar() routine for usage.
+    
+    ! Note: There are no executable statements in modules.
+    
+contains
+
+    subroutine create_mycar(mycar)
+        ! Demonstrates usage of a derived data type.
+        implicit none
+        type(car),intent(out) :: mycar
+        
+        ! Access type elements using '%' operator.
+        mycar%model = "Ford Prefect"
+        mycar%colour = 'r'
+        mycar%weight = 1400
+        mycar%dimensions(1) = 5.0    !default indexing starts from 1!
+        mycar%dimensions(2) = 3.0
+        mycar%dimensions(3) = 1.5
+        
+    end subroutine
+
+    real function real_abs(x)
+        real :: x
+        if (x<0) then
+            real_abs = -x
+        else
+            real_abs = x
+        end if
+    end function real_abs
+    
+    real function complex_abs(z)
+        complex :: z
+        ! long lines can be continued using the continuation character '&'
+        complex_abs = sqrt(real(z)**2 + &
+                                         aimag(z)**2)
+    end function complex_abs
+
+
+end module fruity
+
+```
+
+### More Resources
+
+For more information on Fortran:
+
++ [wikipedia](https://en.wikipedia.org/wiki/Fortran)
++ [Fortran_95_language_features](https://en.wikipedia.org/wiki/Fortran_95_language_features)
++ [fortranwiki.org](http://fortranwiki.org)
++ [www.fortran90.org/](http://www.fortran90.org)
++ [list of Fortran 95 tutorials](http://www.dmoz.org/Computers/Programming/Languages/Fortran/FAQs%2C_Help%2C_and_Tutorials/Fortran_90_and_95/)
++ [Fortran wikibook](https://en.wikibooks.org/wiki/Fortran)
++ [Fortran resources](http://www.fortranplus.co.uk/resources/fortran_resources.pdf)
++ [Mistakes in Fortran 90 Programs That Might Surprise You](http://www.cs.rpi.edu/~szymansk/OOF90/bugs.html)
diff --git a/fr-fr/HTML-fr.html.markdown b/fr-fr/HTML-fr.html.markdown
index fdde9107..b52fd34a 100644
--- a/fr-fr/HTML-fr.html.markdown
+++ b/fr-fr/HTML-fr.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 lang: fr-fr
 ---
+
 HTML signifie HyperText Markup Language. 
 C'est un langage (format de fichiers) qui permet d'écrire des pages internet.
 C’est un langage de balisage, il nous permet d'écrire des pages HTML au moyen de balises (Markup, en anglais).
@@ -17,7 +18,7 @@ Comme tous les autres langages, HTML a plusieurs versions. Ici, nous allons parl
 Cet article porte principalement sur la syntaxe et quelques astuces.
 
 
-```HTML
+```html
 <!-- Les commentaires sont entouré comme cette ligne! -->
 
 <!-- #################### Les balises #################### -->
@@ -105,6 +106,8 @@ Cet article porte principalement sur la syntaxe et quelques astuces.
 	</tr>
 </table>
 
+```
+
 ## Utilisation
 
 Le HTML s'écrit dans des fichiers `.html`.
diff --git a/fr-fr/brainfuck-fr.html.markdown b/fr-fr/bf-fr.html.markdown
index 545e407e..0fae6032 100644
--- a/fr-fr/brainfuck-fr.html.markdown
+++ b/fr-fr/bf-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 filename: learnbrainfuck-fr.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
diff --git a/fr-fr/binary-search-fr.html.markdown b/fr-fr/binary-search-fr.html.markdown
new file mode 100644
index 00000000..4c34da0f
--- /dev/null
+++ b/fr-fr/binary-search-fr.html.markdown
@@ -0,0 +1,67 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+    - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+    - ["Hughes Perreault", "https://github.com/hperreault"]
+lang: fr-fr
+---
+
+# Recherche Binaire
+
+## Pourquoi la Recherche Binaire ?
+
+La recherche est un des principaux problèmes dans le domaine de l'informatique. De nos jours, il y a plus de 1 milliard de recherches par année, et nous avons besoin d'algorithmes pour faire cela rapidement. La recherche binaire est un des algorithmes les plus fondamentaux en informatique. Pour pouvoir l'explorer en détail, nous allons d'abord établir une base théorique, puis nous allons utiliser cette base pour implémenter l'algorithme en soi.
+
+## Introduction
+
+Une façon simple d'implémenter la recherche est de faire une recherche linéaire. Cependant, cette approche prend beaucoup de temps, et ce temps augmente linéairement avec la quantité de données. Par exemple, partons du premier élément d'un tableau t[], et un par un, comparons x avec chaque élément de t[]. Si x est égal à un élément, nous retournons l'index, si x n'égale aucun élément, nous retournons -1.
+
+```
+Recherche Linéaire: O (n)               Temps Linéaire
+
+Recherche Binaire:  O ( log(n) )        Temps Logarithmique
+
+```
+```
+def search(arr, x):
+
+    for i in range(len(arr)):
+
+        if arr[i] == x:
+            return i
+
+    return -1
+
+```
+## L'Algorithme de Recherche Binaire
+
+Le prérequis fondamental de la recherche binaire est que les éléments soient triés.
+
+### Algo
+
+```
+L'idée derrière la recherche binaire est d'utiliser le fait que le tableau est trié afin de réduire la complexité à O(Log(n)). Nous pouvons ignorer la moitié des éléments après la première comparaison.
+1) Comparons x avec l'élément du milieu.
+2) Si x est égal à cet élément, nous retournons l'index du milieu.
+3) Sinon, si x est plus grand que l'élément du milieu, alors x peut seulement être dans la dernière moitié du tableau. Donc, nous recommençons la procédure avec cette dernière moitié.
+4) Sinon (x est plus petit), nous recommençons la procédure avec la première moitié du tableau.
+Ensuite nous avons une implémentation récursive de la recherche binaire.
+
+```
+
+### Note de la fin
+
+Partie en construction.
+
+## Livre
+
+* [CLRS EN](https://mitpress.mit.edu/books/introduction-algorithms)
+* [Algorithmes EN](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Design d'Algorithmes EN](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Ressources en ligne
+
+* [GeeksforGeeks EN](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)
+* [Topcoder Tutorial EN](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/)
diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown
new file mode 100644
index 00000000..acbaed58
--- /dev/null
+++ b/fr-fr/c++-fr.html.markdown
@@ -0,0 +1,916 @@
+---
+language: c++
+filename: learncpp-fr.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+translators:
+    - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"]
+lang: fr-fr
+---
+
+C++ est un langage de programmation système qui,
+[selon son créateur Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+fut créé pour
+
+- être un "C amélioré"
+- gérer l'abstraction des données
+- gérer la programmation orienté objet
+- gérer la programmation générique
+
+Bien que sa syntaxe puisse être plus difficile ou complexe que des langages
+récents, il est largement utilisé car il compile en instructions natives qui
+peuvent être directement exécutées par le processeur et offre un contrôle
+rigoureux du matériel (comme le C) tout en fournissant des caractéristiques de
+haut niveau telles que la généricité, les exceptions et les classes.
+Cette combinaison de vitesse et de fonctionnalités rend le C++ un des langages
+de programmation les plus utilisés au monde.
+
+```c++
+/////////////////////////////////
+// Comparaison avec le C
+/////////////////////////////////
+
+// C++ est _presque_ un sur-ensemble du C et partage sa syntaxe basique pour les
+// déclarations de variables, les types primitifs et les fonctions.
+
+// Tout comme en C, le point d'entrée de votre programme est une fonction
+// appelée main, avec un integer comme type de retour.
+// Cette valeur constitue l'état de fin d'exécution du programme.
+// Voir http://en.wikipedia.org/wiki/Exit_status pour plus d'informations.
+int main(int argc, char** argv)
+{
+    // Les arguments de ligne de commande sont passés avec argc et argv de la
+    // même manière qu'en C.
+    // argc indique le nombre d'arguments,
+    // et argv est un tableau de chaînes façon C (char*)
+    // représentant les arguments.
+    // Le premier argument est le nom par lequel le programme est appelé.
+    // argc et argv peuvent être omis si vous ne vous souciez pas des
+    // arguments, nous donnant comme signature de fonction int main()
+
+    // Un état de fin d'exécution 0 indique le succès.
+    return 0;
+}
+
+// Cependant, C++ varie du C selon certains éléments:
+
+// En C++, les caractères littéraux sont des chars
+sizeof('c') == sizeof(char) == 1
+
+// En C, les caractères littéraux sont des ints
+sizeof('c') == sizeof(int)
+
+// C++ a un prototypage strict
+void func(); // fonction qui ne prend aucun argument
+
+// En C
+void func(); // fonction qui peut prendre n'importe quel nombre d'arguments
+
+// Utilise nullptr au lieu de NULL in C++
+int* ip = nullptr;
+
+// Les en-têtes standards du C sont disponibles en C++,
+// mais son préfixés avec "c" et n'ont pas de suffixe .h
+#include <cstdio>
+
+int main()
+{
+    printf("Bonjour tout le monde!\n");
+    return 0;
+}
+
+/////////////////////////////////
+// Surchage de fonctions
+/////////////////////////////////
+
+// C++ gère la surchage de fonctions
+// Chaque fonction fournie prend différents paramètres.
+
+void print(char const* maChaine)
+{
+    printf("Chaîne %s\n", maChaine);
+}
+
+void print(int monEntier)
+{
+    printf("Mon entier est %d", monEntier);
+}
+
+int main()
+{
+    print("Bonjour"); // Utilise void print(const char*)
+    print(15); // Utilise void print(int)
+}
+
+/////////////////////////////////////////////
+// Arguments par défaut de fonctions
+/////////////////////////////////////////////
+
+// Vous pouvez fournir des arguments par défaut pour une fonction s'ils ne sont
+// pas fournis par l'appelant.
+
+void faitDesChosesAvecDesEntiers(int a = 1, int b = 4)
+{
+    // Do something with the ints here
+}
+
+int main()
+{
+    faitDesChosesAvecDesEntiers();      // a = 1,  b = 4
+    faitDesChosesAvecDesEntiers(20);    // a = 20, b = 4
+    faitDesChosesAvecDesEntiers(20, 5); // a = 20, b = 5
+}
+
+// Les arguments par défaut doivent être à la fin de la liste des arguments.
+
+void invalidDeclaration(int a = 1, int b) // Erreur !
+{
+}
+
+
+//////////////////////////
+// Espaces de nom
+//////////////////////////
+
+// Les espaces de nom fournissent une séparation des portées pour les
+// variables, fonctions, et autres déclarations.
+// Les espaces de nom peuvent être imbriqués.
+
+namespace Premier {
+    namespace Imbrique {
+        void foo()
+        {
+            printf("Ceci est le Premier::Imbrique::foo\n");
+        }
+    } // fin de l'espace de nom Imbrique
+} // fin de l'espace de nom Premier
+
+namespace Second {
+    void foo()
+    {
+        printf("Ceci est le Second::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("Ceci est un foo global\n");
+}
+
+int main()
+{
+    // Inclut tous les symboles de l'espace de nom Second dans la portée
+    // actuelle. Notez que le foo() simple ne marche plus, car l'appel est
+    // ambigu entre le foo de l'espace de nom Second et celui de premier
+    // niveau.
+    using namespace Second;
+
+    Second::foo(); // imprime "Ceci est le Second::foo"
+    Premier::Imbrique::foo(); // imprime "Ceci est le Premier::Imbrique::foo"
+    ::foo(); // imprime "Ceci est un foo global"
+}
+
+/////////////////////////
+// Entrée/Sortie
+/////////////////////////
+
+// Les entrées et sorties en C++ utilisent des flux (streams)
+// cin, cout et cerr représentent stdin, stdout et stderr.
+// << est l'opérateur d'insertion et >> est l'opérateur d'extraction.
+
+#include <iostream> // Inclusion pour les flux d'entrée/sortie
+
+// Les flux sont dans l'espace de nom std (librairie standard)
+using namespace std;
+
+int main()
+{
+   int monEntier;
+
+   // Affiche sur stdout (ou le terminal/l'écran)
+   cout << "Entrez votre chiffre favori:\n";
+   // Prend l'entrée clavier
+   cin >> monEntier;
+
+   // cout peut également être formaté
+   cout << "Votre chiffre favori est " << monEntier << "\n";
+   // imprime "Votre chiffre favori est <monEntier>"
+
+    cerr << "Utilisé pour les messages d'erreurs";
+}
+
+/////////////////////////////////
+// Chaînes de caractères
+/////////////////////////////////
+
+// Les chaînes de caractères en C++ sont des objets et ont plusieurs fonctions
+// membres
+#include <string>
+
+// Les chaînes de caractères sont aussi dans l'espace de
+// nom std (librairie standard)
+using namespace std;
+
+string maChaine = "Bonjour";
+string monAutreChaine = " tout le monde !";
+
+// + est utilisé pour la concaténation.
+cout << maChaine + monAutreChaine; // Bonjour tout le monde !"
+
+cout << maChaine + " toi !"; // "Bonjour toi !"
+
+// Les chaînes de caractères C++ sont mutables.
+maChaine.append(" le chien !");
+cout << maChaine; // "Bonjour le chien !"
+
+
+//////////////////////
+// Références
+//////////////////////
+
+// En plus des pointeurs comme ceux en C,
+// C++ possède des _références_.
+// Ce sont des types de pointeurs qui ne peuvent pas être réassignés
+// une fois initialisés, et ne peuvent pas être nulles.
+// Ils partagent la même syntaxe que les variables elles-mêmes:
+// les * ne sont pas nécessaires pour les déréférencer et
+// & (addresse de) n'est pas utilisé pour l'assignement.
+
+using namespace std;
+
+string foo = "Je suis foo";
+string bar = "Je suis bar";
+
+
+string& fooRef = foo; // Ceci créé une référence à foo
+fooRef += ". Salut!"; // Modifie foo à travers la référence
+cout << fooRef; // Affiche "Je suis foo. Salut!"
+
+// Ne réassigne pas "fooRef". Ceci revient à faire "foo = bar", et
+// foo == "I am bar"
+// après cette ligne.
+cout << &fooRef << endl; // Affiche l'adresse de foo
+fooRef = bar;
+cout << &fooRef << endl; // Affiche toujours l'adresse de foo
+cout << fooRef;  // Affiche "Je suis bar"
+
+// L'adresse de fooRef reste la même, c.-à-d. référence toujours foo.
+
+
+const string& barRef = bar; // Créé une référence constante de bar.
+// Comme en C, les valeurs constantes (et pointeurs et références) ne peuvent
+// être modifiées.
+
+// Erreur, les valeurs constantes ne peuvent être modifiées.
+barRef += ". Salut!";
+
+// Parenthèse: avant de développer le sujet des références, nous devons
+// introduire un concept appelé un objet temporaire. Supposons que nous ayons
+// le code suivant :
+string objetTemporaireFun() { ... }
+string valeurRetenu = objetTemporaireFun();
+
+// Les différents événements se déroulant à la seconde ligne sont :
+//   - un objet chaîne de caractères est retourné de objetTemporaireFun
+//   - une nouvelle chaîne de caractères est construite avec la valeur
+//     retournée comme argument du constructeur
+//   - l'objet retourné est détruit.
+// L'objet retourné est appelé un objet temporaire. Les objets temporaires sont
+// créés chaque fois qu'une fonction retourne un objet, et sont détruits à la
+// fin de l'évaluation de l'expression fermante (c'est ce que le standard
+// énonce, mais les compilateurs sont autorisés à changer ce comportement.
+// Cherchez "optimisation valeur de retour" si vous êtes intéressé par ce genre
+// de détails).
+// Dans cette ligne de code :
+foo(bar(objetTemporaireFun()))
+
+// en supposant que foo et bar existent, l'objet retourné de objetTemporaireFun
+// est passé à bar, et est détruit avant que foo soit appelé.
+
+// Revenons maintenant aux références. L'exception à la règle "objet détruit à
+// la fin de l'expression fermante" s'applique dans le cas d'un objet
+// temporaire lié à une référence constante, où sa durée de vie se voit
+// prolongée à la portée courante :
+
+void referenceConstanteObjetTemporaireFun() {
+  // referenceConst prend l'objet temporaire, et est valide jusqu'à la fin de
+  // la fonction.
+  const string& referenceConst = objetTemporaireFun();
+  ...
+}
+
+// Un autre type de référence introduit en C++11 est spécifiquement pour les
+// objets temporaires. Vous ne pouvez pas avoir de variable de ce type, mais
+// il prime dans la résolution de surcharge :
+
+void fonctionFun(string& s) { ... }  // Référence régulière
+void fonctionFun(string&& s) { ... }  // Référence un objet temporaire
+
+string foo;
+// Appelle la version avec référence régulière
+fonctionFun(foo);
+
+// Appelle la version avec référence temporaire
+fonctionFun(objetTemporaireFun());
+
+// Par exemple, vous aurez ces deux versions de constructeurs pour
+// std::basic_string :
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// L'idéal étant de construire une nouvelle chaîne de caractères avec un objet
+// temporaire (qui sera détruit de toute façon), nous pouvons ainsi avoir un
+// constructeur qui "sauve" des parties de cette chaîne de caractères
+// temporaire. Vous verrez ce concept sous le nom de "sémantique de mouvement".
+
+////////////////////////
+// Enumérations
+////////////////////////
+
+// Les énumérations sont un moyen d'assigner une valeur à une constante
+// fréquemment utilisée pour une meilleure visualisation et lecture du code.
+enum ETypesDeVoitures
+{
+  Berline,
+  Hayon,
+  4x4,
+  Break
+};
+
+ETypesDeVoitures ObtenirVoiturePreferee()
+{
+	return ETypesDeVoitures::Hayon;
+}
+
+// En C++11, il existe une manière simple d'assigner un type à une énumération,
+// ce qui peut-être utile en sérialisation de données et conversion
+// d'énumérations entre le type voulu et ses constantes respectives.
+enum ETypesDeVoitures : uint8_t
+{
+  Berline, // 0
+  Hayon, // 1
+  4x4 = 254, // 254
+  Hybride // 255
+};
+
+void EcrireOctetDansLeFichier(uint8_t ValeurEntree)
+{
+	// Sérialise la valeur d'entrée dans un fichier
+}
+
+void EcrireTypeVoiturePrefereDansLeFichier(ETypesDeVoitures TypeVoitureEntree)
+{
+	// L'énumération est implicitement convertie en uint8_t du à la déclaration
+    // de son type d'énumération
+	EcrireOctetDansLeFichier(TypeVoitureEntree);
+}
+
+// D'autre part, vous pourriez ne pas vouloir que des énumérations soient
+// accidentellement converties en entiers ou en d'autres énumérations. Il est
+// donc possible de créer une classe d'énumération qui ne sera pas
+// implicitement convertie.
+enum class ETypesDeVoitures : uint8_t
+{
+  Berline, // 0
+  Hayon, // 1
+  4x4 = 254, // 254
+  Hybride // 255
+};
+
+void EcrireOctetDansLeFichier(uint8_t ValeurEntree)
+{
+	// Sérialise la valeur d'entrée dans un fichier
+}
+
+void EcrireTypeVoiturePrefereDansLeFichier(ETypesDeVoitures TypeVoitureEntree)
+{
+	// Ne compilera pas même si ETypesDeVoitures est un uint8_t car
+	// l'énumération est déclarée en tant que "classe d'énumération" !
+	EcrireOctetDansLeFichier(TypeVoitureEntree);
+}
+
+///////////////////////////////////////////////////
+// Classes et programmation orientée objet
+///////////////////////////////////////////////////
+
+#include <iostream>
+
+// Déclare une classe.
+// Les classes sont habituellement déclarées dans les fichiers d'en-tête (.h ou .hpp).
+class Chien {
+    // Les variables et fonctions membres sont privées par défaut.
+    std::string nom;
+    int poids;
+
+// Tous les membres suivants sont publiques jusqu'à ce que "private:" ou
+// "protected:" soit trouvé
+public:
+
+    // Constructeur par défaut
+    Chien();
+
+    // Déclaractions de fonctions membres (implémentations à suivre)
+    // Notez que nous utilisons std::string ici au lieu de placer
+    // using namespace std;
+    // au-dessus.
+    // Ne jamais utiliser une instruction "using namespace" dans l'en-tête.
+    void initialiserNom(const std::string& nomDuChien);
+
+    void initialiserPoids(int poidsDuChien);
+
+    // Les fonctions qui ne modifient pas l'état de l'objet devraient être
+    // marquées en constantes avec const.
+    // Ceci vous permet de les appeler avec une référence constante vers l'objet.
+    // Notez aussi que les fonctions devant être surchargées dans des classes
+    // dérivées doivent être explicitement déclarées avec _virtual_.
+    // Les fonctions ne sont pas virtuelles par défault pour des raisons de
+    // performances.
+    virtual void imprimer() const;
+
+    // Les fonctions peuvent également être définies à l'intérieur du corps de
+    // la classe. Ces fonctions sont automatiquement "inline".
+    void aboyer() const { std::cout << nom << " fait ouaf !\n"; }
+
+    // En plus des constructeurs, C++ fournit des destructeurs.
+    // Ils sont appelés quand l'objet est supprimé ou dépasse le cadre de sa
+    // portée. Ceci permet de puissants paradigmes tels que RAII
+    // (voir plus loin)
+    // Le destructeur devrait être virtuel si la classe est abstraite;
+    // s'il n'est pas virtuel, alors le destructeur de la classe dérivée ne
+    // sera pas appelé si l'objet est détruit par le biais d'une référence à la
+    // classe de base ou d'un pointeur.
+    virtual ~Chien();
+
+}; // Un point virgule doit clôre la définition de la classe.
+
+// Les fonctions membres de la classe sont habituellement implémentées dans des
+// fichiers .cpp.
+Chien::Chien()
+{
+    std::cout << "Un chien a été construit\n";
+}
+
+// Les objets (comme les chaînes de caractères) devraient être passés par
+// référence si vous les modifiez ou par référence constante si vous ne les
+// modifiez pas.
+void Chien::initialiserNom(const std::string& nomDuChien)
+{
+    nom = nomDuChien;
+}
+
+void Chien::initialiserPoids(int poidsDuChien)
+{
+    poids = poidsDuChien;
+}
+
+// Notez que le mot-clé "virtual" est nécessaire uniquement à la déclaration,
+// et non à la définition.
+void Chien::imprimer() const
+{
+    std::cout << "Le chien s'appelle " << nom << " et pèse " << poids << "kg\n";
+}
+
+Chien::~Chien()
+{
+    cout << "Au revoir " << nom << " !\n";
+}
+
+int main() {
+    Chien monChien; // imprime "Un chien a été construit"
+    monChien.initialiserNom("Barkley");
+    monChien.initialiserPoids(10);
+    monChien.imprime(); // imprime "Le chien s'appelle Barkley et pèse 10 kg"
+    return 0;
+} // prints "Au revoir Barkley !"
+
+// Héritage :
+
+// Cette classe hérite de toutes les propriétés publiques et protégées de la
+// classe Chien ainsi que celles privées, mais n'ont pas accès direct aux
+// membres et méthodes privés sans l'aide d'une méthode publique ou protégée
+class ChienDomestique : public ChienDomestique {
+
+    void definirProprietaire(const std::string& proprietaireDuChien);
+
+    // Surcharge le comportement de la fonction d'impression pour tous les
+    // ChienDomestiques.
+    // Voir https://fr.wikipedia.org/wiki/Polymorphisme_(informatique)#Polymorphisme_par_sous-typage
+    // pour une introduction plus générale si vous n'êtes pas familier avec le
+    // concept de polymorphisme par sous-typage (appelé aussi polymorphisme
+    // d'inclusion).
+    // Le mot-clé "override" est optionnel mais assure que vous surchargez bien
+    // la méthode de la classe de base.
+    void imprimer() const override;
+
+private:
+    std::string proprietaire;
+};
+
+// Pendant ce temps, dans le fichier .cpp correspondant :
+
+void ChienDomestique::definirProprietaire(const std::string& proprietaireDuChien)
+{
+    proprietaire = proprietaireDuChien;
+}
+
+void ChienDomestique::imprimer() const
+{
+    // Appelle la fonction "imprimer" dans la classe de base Chien
+    Chien::imprimer();
+    std::cout << "Le chien appartient à " << proprietaire << "\n";
+    // Affiche "Le chien est <nom> et pèse <poids>"
+    //         "Le chien appartient à <proprietaire>"
+}
+
+////////////////////////////////////////////////////
+// Initialisation et opérateur de surcharge
+////////////////////////////////////////////////////
+
+// En C++, vous pouvez surcharger le comportement d'opérateurs tels
+// que +, -, *, /, etc.
+// La surcharge se fait en définissant une fonction qui sera appelée à chaque
+// fois que l'opérateur sera utilisé.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Les variables membres peuvent avoir des valeurs par défaut
+    double x = 0;
+    double y = 0;
+
+    // Définit un constructeur par défaut qui ne fait rien
+    // mais initialise le Point à la valeur par défaut (0, 0)
+    Point() { };
+
+    // La syntaxe suivante s'appelle une liste d'initialisation et est
+    // la façon correcte d'initialiser les valeurs des membres d'une classe.
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* Ne fait rien à part initialiser les valeurs */ }
+
+    // Surcharge l'opérateur +
+    Point operator+(const Point& rhs) const;
+
+    // Surcharge l'opérateur +=
+    Point& operator+=(const Point& rhs);
+
+    // Il serait également logique d'ajouter les opérateurs - et -=,
+    // mais nous les éclipsons par soucis de concision.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Créé un nouveau point qui est la somme de celui-ci de rhs.
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point haut (0,1);
+    Point droite (1,0);
+    // Appelle l'opérateur + du Point
+    // Le point "haut" appelle la fonction + avec "droite" comme paramètre
+    Point resultat = haut + droite;
+    // Affiche "Le résultat est haut-droite (1,1)"
+    cout << "Le résultat est haut-droite (" << resultat.x << ','
+         << resultat.y << ")\n";
+    return 0;
+}
+
+////////////////////////////////
+// Patrons (templates)
+////////////////////////////////
+
+// Les templates (patrons) en C++ sont majoritairement
+// utilisés pour la programmation générique, bien qu'ils soient bien plus
+// puissants que les constructeurs génériques dans d'autres langages.
+// Ils gèrent également la spécialisation explicite et partielle ainsi que
+// les classes fonctionnelles; en fait, ils sont un langage fonctionnelles
+// Turing-complete embedded in C++ !
+
+// Nous commencons avec le genre de programmation générique auquel vous êtes
+// peut-être familier. Pour définir une classe ou fonction qui prend un type de
+// paramètre particulier :
+template<class T>
+class Boite {
+public:
+    // Dans cette classe, T représente n'importe quel type possible.
+    void inserer(const T&) { ... }
+};
+
+// Pendant la compilation, le compilateur génère des copies de chaque template
+// avec les paramètres substitués; ainsi, la définition complète de chaque
+// classe doit être présente à chaque appel. C'est pourquoi vous verrez les
+// classes de templates définies entièrement dans les fichiers d'en-tête.
+
+// Pour instancier une classe de template sur la pile ("stack") :
+Boite<int> boiteDEntiers;
+
+// et vous pouvez l'utiliser comme prévu :
+boiteDEntiers.inserer(123);
+
+// Vous pouvez, bien sûr, imbriquer les templates :
+Boite<Boite<int> > boiteDeBoites;
+boiteDeBoites.inserer(boiteDEntiers);
+
+// Jusqu'à C++11, il était nécessaire de placer un espace entre les deux '>'s,
+// sinon '>>' était parsé en tant qu'opérateur de décalage vers la droite.
+
+// Vous croiserez peut-être cette syntaxe
+//   template<typename T>
+// à la place. Les mot-clé 'class' et 'typename' sont _généralement_
+// interchangeables. Pour plus d'explications, allez à
+//   http://en.wikipedia.org/wiki/Typename
+// ou
+// https://fr.wikibooks.org/wiki/Programmation_C-C%2B%2B/Les_templates/Mot-cl%C3%A9_typename
+// (oui, ce mot-clé a sa propre page Wikipedia).
+
+// De manière similaire, un patron de fonction :
+template<class T>
+void aboyerTroisFois(const T& entree)
+{
+    entree.aboyer();
+    entree.aboyer();
+    entree.aboyer();
+}
+
+// Remarquez ici que rien n'est spécifié à propos du type du paramètre. Le
+// compilateur va générer et vérifier le type à chaque appel du patron, c'est
+// pourquoi l'appel de fonction suivant marche pour n'importe quel type 'T' qui
+// a une méthode constante 'aboyer' !
+
+Chien docile;
+docile.initialiserNom("Docile")
+aboyerTroisFois(docile); // Affiche "Docile fait ouaf !" trois fois.
+
+// Les paramètres génériques (ou paramètres template) ne sont pas forcément des
+// classes :
+template<int Y>
+void imprimerMessage() {
+  cout << "Apprenez le C++ en " << Y << " minutes !" << endl;
+}
+
+// Vous pouvez explicitement spécialiser les templates pour un code plus
+// optimisé. Bien sûr, les utilisations effectives de la spécialisation ne sont
+// pas aussi triviales que celle-ci.
+// Notez que vous avez toujours besoin de déclarer la fonction (ou classe)
+// comme template, même si vous spécifiez explicitement tous les paramètres.
+template<>
+void imprimerMessage<10>() {
+  cout << "Apprenez le C++ plus vite en seulement 10 minutes !" << endl;
+}
+
+// Affiche "Apprenez le C++ en 20 minutes !"
+imprimerMessage<20>();
+// Affiche "Apprenez le C++ plus vite en seulement 10 minutes !"
+imprimerMessage<10>();
+
+//////////////////////////////////
+// Gestion des exceptions
+//////////////////////////////////
+
+// La bibliothèque standard fournit quelques types d'exception
+// (voir http://en.cppreference.com/w/cpp/error/exception)
+// mais n'importe quel type peut être lancé en tant qu'exception.
+#include <exception>
+#include <stdexcept>
+
+// Toutes les exceptions lancées à l'intérieur d'un block _try_ peuvent être
+// attrapées par les blocs de traitement d'erreurs (_catch_ handlers).
+try {
+    // N'allouez pas des exceptions sur le tas (heap) en utilisant _new_.
+    throw std::runtime_error("Un problème s'est produit");
+}
+
+// Attrapez les exceptions avec des références constantes si ce sont des objets
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Attrape n'importe quelle exception non attrapée par les blocs _catch_
+// précédents
+catch (...)
+{
+    std::cout << "Exception inconnue attrapée";
+    throw; // Re-lance l'exception
+}
+
+////////////////
+// RAII
+////////////////
+
+// RAII signifie "Resource Acquisition Is Initialization", soit l'Acquisition
+// d'une Ressource est une Initialisation en français.
+// Il est souvent considéré comme le paradigme le plus puissant en C++ et
+// est le concept simple qu'un constructeur d'un objet acquiert les ressources
+// d'un objet et que le destructeur les libère.
+
+// Afin de comprendre son utilité, considérons une fonction qui utilise la
+// gestion d'un fichier C :
+void faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    // Pour commencer, supposns que rien ne peut échouer.
+
+    FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en lecture
+
+    faireQuelqueChoseAvecLeFichier(fh);
+    faireAutreChoseAvec(fh);
+
+    fclose(fh); // Ferme la gestion du fichier.
+}
+
+// Malheureusement, les choses deviennent compliquées avec la gestion
+// d'erreurs. Supposons que fopen échoue, et que faireQuelqueChoseAvecLeFichier
+// et faireAutreChoseAvec retournent des codes d'erreur si elles échouent.
+//  (Les exceptions sont le meilleur moyen de gérer l'échec, mais des
+//   programmeurs, surtout avec un passif en C,
+//   sont en désaccord avec l'utilité des exceptions).
+// Nous devons maintenant vérifier chaque appel en cas d'échec et fermer la
+// gestion du fichier si un problème se produit.
+bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en mode lecture.
+    if (fh == nullptr) // Le pointeur retourné est null à un échec.
+        return false; // Signale cet échec à l'appelant.
+
+    // Suppose que chaque fonction retourne faux si elle échoue
+    if (!faireQuelqueChoseAvecLeFichier(fh)) {
+        fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
+        return false; // Propage l'erreur
+    }
+    if (!faireAutreChoseAvec(fh)) {
+        fclose(fh);
+        return false;
+    }
+
+    fclose(fh);
+    return true;
+}
+
+// Les programmeurs en C clarifient souvent tout cela en utilisant goto :
+bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    FILE* fh = fopen(nomDuFichier, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!faireQuelqueChoseAvecLeFichier(fh))
+        goto echec;
+
+    if (!faireAutreChoseAvec(fh))
+        goto echec;
+
+    fclose(fh); // Ferme la gestion du fichier
+    return true; // Indique le succès
+
+echec:
+    fclose(fh);
+    return false; // Propage l'erreur
+}
+
+// Si les fonctions indiquent des erreurs en utilisant des exceptions,
+// les choses sont un peu plus claires, mais toujours sous-optimales.
+void faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
+{
+    FILE* fh = fopen(nomDuFichier, "r"); // Ouvre le fichier en lecture
+    if (fh == nullptr)
+        throw std::runtime_error("Ouverture du fichier impossible.");
+
+    try {
+        faireQuelqueChoseAvecLeFichier(fh);
+        faireAutreChoseAvec(fh);
+    }
+    catch (...) {
+        // Assurez-vous de bien fermer le fichier si une erreur arrive
+        fclose(fh);
+        throw; // Puis re-lancer l'exception
+    }
+
+    fclose(fh); // Ferme le fichier
+    // Tout s'est déroulé correctement
+}
+
+// Comparez ceci à l'utilisation de la classe de flux de fichier
+// en C++ (fstream).
+// fstream utilise son destructeur pour fermer le fichier.
+// Pour rappel, les destructeurs sont automatiquement appelée dès qu'un objet
+// sort du cadre de sa portée.
+void faireQuelqueChoseAvecUnFichier(const std::string& nomDuFichier)
+{
+    // ifstream is short for input file stream
+    std::ifstream fh(nomDuFichier); // Ouvre le fichier
+
+    // Faire des choses avec le fichier
+    faireQuelqueChoseAvecLeFichier(fh);
+    faireAutreChoseAvec(fh);
+
+} // Le fichier est automatiquement fermé ici par le destructeur
+
+// Ceci a des avantages _énormes_ :
+// 1. Peu importe la situation, la ressource (dans ce cas précis la gestion
+//    de fichier) sera libérée. Si le destructeur est écrit correctement,
+//    il est _impossible_ d'oublier de fermer la gestion et d'entraîner une
+//    une fuite de ressources (si l'objet est sur la pile).
+// 2. Remarquez que le code est beaucoup plus clair.
+//    Le destructeur gère la fermeture du fichier discrètement sans avoir
+//    besoin de s'en préoccuper.
+// 3. Le code est fiable par rapport aux exceptions.
+//    Une exception peut être lancée n'importe où dans la fonction, le
+//    nettoyage se fera toujours.
+
+// Tout code C++ idiomatique utilise considérablement RAII pour toutes les
+// ressources.
+// Des exemples additionnels inclus :
+// - La mémoire utilisant unique_ptr et shared_ptr
+// - Des conteneurs (containers) - la liste chaînée de la librairie standard,
+//   des vecteurs (c.-à-d. tableaux auto-redimensionnés), tables de hachage, et
+//   ainsi de suite. Tous détruisent leur contenu quand ils sortent du cadre
+//   de leur portée.
+// - Les mutex utilisant lock_guard et unique_lock
+
+
+//////////////////
+// Divers
+//////////////////
+
+// Ici sont regroupés des aspects du C++ qui peuvent être surprenants aux
+// novices (et même à quelques habitués).
+// Cette section est, malheureusement, grandement incomplète; C++ est un des
+// langages où il est très facile de se tirer soi-même dans le pied.
+
+// Vous pouvez surcharger des méthodes privées !
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Surcharge Foo::bar!
+};
+
+// 0 == false == NULL (la plupart du temps) !
+bool* pt = new bool;
+*pt = 0; // Affecte false à la valeur de la variable pointée par 'pt'.
+pt = 0;  // Affecte le pointeur null à 'pt'.
+// Les deux lignes compilent sans avertissement.
+
+// nullptr est supposé régler un peu ce problème :
+int* pt2 = new int;
+*pt2 = nullptr; // Ne compile pas
+pt2 = nullptr;  // Affecte null à pt2
+
+// Il y a une exception faite pour les booléens.
+// Ceci vous permet de tester les pointeurs null avec if(!ptr),
+// mais par conséquent, vous pouvez assigner nullptr à un booléen directement !
+*pt = nullptr;  // Ceci compile toujours, même si '*pt' est un booléen !
+
+// '=' != '=' != '='!
+// Appelle Foo::Foo(const Foo&) ou une variante du (voir sémantiques de mouvement)
+// constructeur par copie.
+Foo f2;
+Foo f1 = f2;
+
+// Appelle Foo::Foo(const Foo&) ou une variante, mais copie seulement la partie
+// 'Foo' de 'fooSub'. Tout membre extra de 'fooSub' est ignoré.
+// Ce comportement parfois horrifiant est appelé "object slicing".
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Appelle Foo::operator=(Foo&) ou une variante.
+Foo f1;
+f1 = f2;
+
+// Comment vraiment nettoyer un conteneur :
+class Foo { ... };
+vector<Foo> v;
+for (int i = 0; i < 10; ++i)
+  v.push_back(Foo());
+
+// La ligne suivante affecte la taille de v à 0, mais les destructeurs ne sont
+// appelés et les ressources ne sont pas libérées !
+v.empty();
+// La nouvelle valeur est copiée dans le premier Foo que nous avons inséré
+v.push_back(Foo());
+
+// Ceci nettoie toutes les valeurs de v. Voir la section à propos des objets
+// temporaires pour comprendre pourquoi cela fonctionne.
+v.swap(vector<Foo>());
+
+```
+Lecture complémentaire :
+
+Une référence à jour du langage est disponible à
+<http://cppreference.com/w/cpp>
+
+Des ressources supplémentaires sont disponibles à <http://cplusplus.com>
diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index 63bc25b5..65747c0d 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -275,7 +275,7 @@ ressemblent à toutes les autres formes:
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
-  
+
 ; Utilisez les Threading Macros (-> et ->>) pour exprimer plus
 ; clairement vos transformations, en y pensant de manière multi-niveaux.
 
@@ -284,10 +284,10 @@ ressemblent à toutes les autres formes:
 ; de la forme suivante, constituant à chaque fois un nouvel étage
 ; de transformation. Par exemple:
 (->  
-   {:a 1 :b 2} 
+   {:a 1 :b 2}
    (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3)
    (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b)
-   
+
 ; Cette expression est ré-écrite en:
 ; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
 ; et est évaluée en : {:a 1 :c 3}
@@ -302,6 +302,14 @@ ressemblent à toutes les autres formes:
    (into []))    ;=> Génère ici (into [] (filter odd? (map inc (range 10))), ce qui est évalué au final à;
                  ; [1 3 5 7 9]
 
+; Quand vous êtes dans une situation où vous voulez plus de liberté pour choisir 
+; où mettre le résultat des étages précédents, vous pouvez utiliser la
+; macro as->. Avec cette macro, donnez un nom spécifique au résultat de la transformation
+; précédente pour le placer, à votre guise, où bon vous semble dans l'étage courant:
+(as-> [1 2 3] input
+  (map inc input);=> Utilisation du résultat en dernière position
+  (nth input 4) ;=> et en deuxième position, dans la même expression
+  (conj [4 5 6] input [8 9 10])) ;=> ou au milieu !
 
 ; Modules
 ;;;;;;;;;;;;;;;
@@ -370,7 +378,7 @@ ressemblent à toutes les autres formes:
 ; STM
 ;;;;;;;;;;;;;;;;;
 
-; La mémoire logiciel transactionnelle ("Software Transactional Memory") 
+; La mémoire logiciel transactionnelle ("Software Transactional Memory")
 ; est le mécanisme que Clojure utilise pour gérer les états persistents.
 ; Il y a plusieurs formes en Clojure qui utilisent cela.
 
@@ -384,7 +392,7 @@ ressemblent à toutes les autres formes:
 (swap! my-atom assoc :a 1) ; Définit my-atom comme le résultat de (assoc {} :a 1)
 (swap! my-atom assoc :b 2) ; Définit my-atom comme le résultat de (assoc {:a 1} :b 2)
 
-; Use '@' to dereference the atom and get the value 
+; Use '@' to dereference the atom and get the value
 my-atom  ;=> Atom<#...> (Renvoie l'objet Atom)
 @my-atom ; => {:a 1 :b 2}
 
diff --git a/fr-fr/crystal-fr.html.markdown b/fr-fr/crystal-fr.html.markdown
new file mode 100644
index 00000000..2c4e3dad
--- /dev/null
+++ b/fr-fr/crystal-fr.html.markdown
@@ -0,0 +1,555 @@
+---
+language: crystal
+filename: learncrystal-fr.cr
+contributors:
+    - ["Vitalii Elenhaupt", "http://veelenga.com"]
+    - ["Arnaud Fernandés", "https://github.com/TechMagister/"]
+translators:
+    - ["Arnaud Fernandés", "http://github.com/TechMagister/"]
+lang: fr-fr
+---
+
+```crystal
+
+# Ceci est un commentaire
+
+# Tout est objet
+nil.class  #=> Nil
+100.class  #=> Int32
+true.class #=> Bool
+
+# Les valeurs fausses sont : nil, false et les pointeurs null
+!nil   #=> true  : Bool
+!false #=> true  : Bool
+!0     #=> false : Bool
+
+# Entiers
+
+1.class #=> Int32
+
+# Quatre types d'entiers signés
+1_i8.class  #=> Int8
+1_i16.class #=> Int16
+1_i32.class #=> Int32
+1_i64.class #=> Int64
+
+# Quatre types d'entiers non signés
+1_u8.class  #=> UInt8
+1_u16.class #=> UInt16
+1_u32.class #=> UInt32
+1_u64.class #=> UInt64
+
+2147483648.class          #=> Int64
+9223372036854775808.class #=> UInt64
+
+# Nombre en base binaire
+0b1101 #=> 13 : Int32
+
+# Nombre en base octale
+0o123 #=> 83 : Int32
+
+# Nombres hexadécimaux
+0xFE012D #=> 16646445 : Int32
+0xfe012d #=> 16646445 : Int32
+
+# Nombres à virgule
+
+1.0.class #=> Float64
+
+# Il y a deux types de nombres à virgule
+1.0_f32.class #=> Float32
+1_f32.class   #=> Float32
+
+1e10.class    #=> Float64
+1.5e10.class  #=> Float64
+1.5e-7.class  #=> Float64
+
+# Caractères
+
+'a'.class #=> Char
+
+# Notation octale des caractères
+'\101' #=> 'A' : Char
+
+# Notation unicode
+'\u0041' #=> 'A' : Char
+
+# Chaînes de caratères
+
+"s".class #=> String
+
+# Les chaînes de caractères sont immuables
+s = "hello, "  #=> "hello, "        : String
+s.object_id    #=> 134667712        : UInt64
+s += "Crystal" #=> "hello, Crystal" : String
+s.object_id    #=> 142528472        : UInt64
+
+# Interpolation
+"sum = #{1 + 2}" #=> "sum = 3" : String
+
+# Chaînes multilignes
+"Ceci est une chaine sur
+plusieurs lignes"
+
+# Une autre notation pour les chaînes de caratères
+# qui permet d'insérer des guillemets
+%(hello "world") #=> "hello \"world\""
+
+# Symboles
+# Ils sont immuables et réutilisables, ils sont représentés en interne par
+# un Int32. Ils sont souvent utilisés à la place des chaînes de caractères
+# quand l'identité est plus importante que le contenu
+
+:symbol.class #=> Symbol
+
+sentence = :question?     # :"question?" : Symbol
+
+sentence == :question?    #=> true  : Bool
+sentence == :exclamation! #=> false : Bool
+sentence == "question?"   #=> false : Bool
+
+# Tableaux
+
+[1, 2, 3].class         #=> Array(Int32)
+[1, "hello", 'x'].class #=> Array(Int32 | String | Char)
+
+# Un type doit être spécifié pour les tableaux vides
+[]               # Syntax error: for empty arrays use '[] of ElementType'
+[] of Int32      #=> [] : Array(Int32)
+Array(Int32).new #=> [] : Array(Int32)
+
+# Les tableaux peuvent être indexés
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] : Array(Int32)
+array[0]                #=> 1               : Int32
+array[10]               # lève l'exception IndexError
+array[-6]               # lève l'exception IndexError
+array[10]?              #=> nil             : (Int32 | Nil)
+array[-6]?              #=> nil             : (Int32 | Nil)
+
+# À partir de la fin
+array[-1] #=> 5
+
+# Avec un index de début et la taille
+array[2, 3] #=> [3, 4, 5]
+
+# Ou avec un intervalle
+array[1..3] #=> [2, 3, 4]
+
+# L'ajout à un tableau peut se faire avec l'opérateur <<
+array << 6  #=> [1, 2, 3, 4, 5, 6]
+
+# Enlève la dernière entrée
+array.pop #=> 6
+array     #=> [1, 2, 3, 4, 5]
+
+# Enlève la première entrée
+array.shift #=> 1
+array       #=> [2, 3, 4, 5]
+
+# Vérifie si un élément est présent dans le tableau
+array.includes? 3 #=> true
+
+# Syntaxe spéciale pour un tableau de chaîne de caractères ou de symboles
+%w(one two three) #=> ["one", "two", "three"] : Array(String)
+%i(one two three) #=> [:one, :two, :three]    : Array(Symbol)
+
+# Il y a une syntaxe spéciale pour les tableaux et autres types
+# du moment qu'ils définissent une méthode .new et #<<
+set = Set{1, 2, 3} #=> [1, 2, 3]
+set.class          #=> Set(Int32)
+
+# Ce qui est ci dessus est équivalent à :
+set = Set(typeof(1, 2, 3)).new
+set << 1
+set << 2
+set << 3
+
+# Tableaux associatifs
+
+{1 => 2, 3 => 4}.class   #=> Hash(Int32, Int32)
+{1 => 2, 'a' => 3}.class #=> Hash(Int32 | Char, Int32)
+
+# Un type doit être spécifié pour les tableaux associatifs vides
+{}                     # Syntax error
+{} of Int32 => Int32   # {}
+Hash(Int32, Int32).new # {}
+
+# L'accès se fait via une clé
+hash = {"color" => "green", "number" => 5}
+hash["color"]        #=> "green"
+hash["no_such_key"]  #=> Missing hash key: "no_such_key" (KeyError)
+hash["no_such_key"]? #=> nil
+
+# Vérifie l'existence d'une clé
+hash.has_key? "color" #=> true
+
+# Notation spéciale pour les clés si ce sont des symboles
+# ou chaînes de caractères
+{key1: 'a', key2: 'b'}     # {:key1 => 'a', :key2 => 'b'}
+{"key1": 'a', "key2": 'b'} # {"key1" => 'a', "key2" => 'b'}
+
+# De même que pour les tableaux simples, une syntaxe spéciale
+# existe du moment que le type définit une méthode .new et #[]=
+class MyType
+  def []=(key, value)
+    puts "do stuff"
+  end
+end
+
+MyType{"foo" => "bar"}
+
+# Ce qui est équivalent à :
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+# Intervalle
+
+1..10                  #=> Range(Int32, Int32)
+Range.new(1, 10).class #=> Range(Int32, Int32)
+
+# Ils peuvent être inclusifs ou exclusifs
+(3..5).to_a  #=> [3, 4, 5]
+(3...5).to_a #=> [3, 4]
+
+# Vérifie si un intervalle contient une valeur
+(1..8).includes? 2 #=> true
+
+# les tuples sont fixés en taille, immuables et alloués sur la pile
+{1, "hello", 'x'}.class #=> Tuple(Int32, String, Char)
+
+# L'accès peut se faire en utilisant un index
+tuple = {:key1, :key2}
+tuple[1] #=> :key2
+tuple[2] #=> syntax error : Index out of bound
+
+# Ils peuvent être scindés en plusieurs variables
+a, b, c = {:a, 'b', "c"}
+a #=> :a
+b #=> 'b'
+c #=> "c"
+
+# Les procédures ( Proc ) sont des pointeurs de fonction
+# avec un contexte optionel. Ils sont généralement créés avec
+# cette notation :
+proc = ->(x : Int32) { x.to_s }
+proc.class # Proc(Int32, String)
+# Ou en utilisant la méthode new
+Proc(Int32, String).new { |x| x.to_s }
+
+# On les invoque avec la méthode call
+proc.call 10 #=> "10"
+
+# Contrôle de flux
+
+if true
+  "if statement"
+elsif false
+  "else-if, optional"
+else
+  "else, also optional"
+end
+
+puts "if as a suffix" if true
+
+# Le si ( if ) peut être utilisé pour une déclaration
+a = if 2 > 1
+      3
+    else
+      4
+    end
+
+a #=> 3
+
+# Opérateur ternaire
+a = 1 > 2 ? 3 : 4 #=> 4
+
+# Aiguillage à l'aide du mot clé "case"
+cmd = "move"
+
+action = case cmd
+  when "create"
+    "Creating..."
+  when "copy"
+    "Copying..."
+  when "move"
+    "Moving..."
+  when "delete"
+    "Deleting..."
+end
+
+action #=> "Moving..."
+
+# Boucle
+index = 0
+while index <= 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+index = 0
+until index > 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Mais il est préférable d'utiliser #each
+(1..3).each do |index|
+  puts "Index: #{index}"
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Le type d'une variable dépend du type de l'expression
+# dans la déclaration du if
+if a < 3
+  a = "hello"
+else
+  a = true
+end
+typeof a #=> (Bool | String)
+
+if a && b
+  # ici a et b ne sont pas null
+end
+
+if a.is_a? String
+  a.class #=> String
+end
+
+# Fonctions
+
+def double(x)
+  x * 2
+end
+
+# Les fonctions et tous les blocs retournent la valeur de la dernière évaluation
+double(2) #=> 4
+
+# Les parenthèses sont optionnelle quand l'appel n'est pas ambigü
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Les arguments sont séparés par une virgule
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Toutes les méthodes on un paramètre optionel et implicite de type bloc
+# il peut être appelé avec le mot clé 'yield'
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts "hello world" }
+
+# {
+# hello world
+# }
+
+# Un bloc peut être passé à une fonction
+# Le "&" marque une référence à un bloc
+def guests(&block)
+  block.call "some_argument"
+end
+
+# Une liste d'arguments peut être donnée, qui sera convertie en tableau
+# Pour cela, utilisez l'opérateur "*"
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Si une méthode retourne un tableau, il peut être scindé
+def foods
+    ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast #=> "pancake"
+dinner    #=> "quesadilla"
+
+# Par convention, toutes les méthodes qui retournent un booléen
+# finissent par un point d'interrogation
+5.even? # false
+5.odd?  # true
+
+# Si une méthode finit avec un point d'exclamation, c'est qu'elle fait une
+# opération destructrice. Quelques méthodes ont une version "!" pour faire
+# des changements et une version non-"!" pour retourner une nouvelle version
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald"  #=> "Donald Mifflin"
+company_name  #=> "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name  #=> "Donald Mifflin"
+
+
+# Les classes se définissent avec le mot clé "class"
+class Human
+
+  # Une variable de classe, partagée par toutes les instances
+  @@species = "H. sapiens"
+
+  # "name" est une chaine de caratère ( String )
+  @name : String
+
+  # Constructeur basique, assigne l'argument à la variable "name"
+  # si l'age n'est pas donné, sa valeur sera de 0
+  def initialize(@name, @age = 0)
+  end
+
+  # Mutateur
+  def name=(name)
+    @name = name
+  end
+
+  # Accesseur
+  def name
+    @name
+  end
+
+  # La macro "property" va générer les deux précédentes méthodes
+  property :name
+
+  # Les accesseurs/mutateurs peuvent aussi être créés individuellement
+  getter :name
+  setter :name
+
+  # Une méthode de classe utilise "self" pour se distinguer d'une
+  # méthode d'instance. Elle ne peut être appelée qu'à partir de la classe
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# Instantie une classe
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Appelons quelques méthodes
+jim.species #=> "H. sapiens"
+jim.name #=> "Jim Halpert"
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.name #=> "Jim Halpert II"
+dwight.species #=> "H. sapiens"
+dwight.name #=> "Dwight K. Schrute"
+
+# Appel de la méthode de classe
+Human.say("Hi") #=> Affiche "Hi" et retourne nil
+
+# Les variables qui commencent par @ ont une portée d'instance
+class TestClass
+  @var = "Je suis une variable d'instance"
+end
+
+# Les variables qui commencent par @@ ont une portée de classe
+class TestClass
+  @@var = "Je suis une variable de classe"
+end
+# Les constantes commencent par une lettre majuscule
+Var = "Je suis constante"
+Var = "impossible" # Already initialized constant Var
+
+# La classe est aussi un objet
+# Les variables de classe sont partagées avec les descendants
+
+# Classe de base
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Classe dérivée
+class Worker < Human
+end
+
+Human.foo   #=> 0
+Worker.foo  #=> 0
+
+Human.foo = 2 #=> 2
+Worker.foo    #=> 0
+
+Worker.foo = 3 #=> 3
+Human.foo   #=> 2
+Worker.foo  #=> 3
+
+module ModuleExample
+  def foo
+    "foo"
+  end
+end
+
+# Inclure (include) des modules ajoute leurs méthodes aux instances
+# Étendre (extend) ajoute les méthodes à la classe
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => undefined method 'foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => undefined method 'foo' for Book
+
+
+# Gestion des exceptions
+
+# Définit un type d'exeption
+class MyException < Exception
+end
+
+# Définit une autre exception
+class MyAnotherException < Exception; end
+
+ex = begin
+   raise MyException.new
+rescue ex1 : IndexError
+  "ex1"
+rescue ex2 : MyException | MyAnotherException
+  "ex2"
+rescue ex3 : Exception
+  "ex3"
+rescue ex4 # attrape toutes les autres exceptions
+  "ex4"
+end
+
+ex #=> "ex2"
+
+```
+
+## Ressources additionnelles
+
+- [Documentation Officielle (EN)](http://crystal-lang.org/)
diff --git a/fr-fr/d.html.markdown b/fr-fr/d.html.markdown
index d9bd9b48..8d98f9dc 100644
--- a/fr-fr/d.html.markdown
+++ b/fr-fr/d.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: fr-fr
 ---
 
-```d
+```c
 // Commençons par un classique
 module hello;
 
@@ -30,7 +30,7 @@ D est activement développé par de nombreuses personnes très intelligents, gui
 [Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
 Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
 
-```d
+```c
 import std.stdio;
 
 void main() {
@@ -54,7 +54,7 @@ void main() {
     } while(n > 0);
 
     // For et while sont très utiles, mais en D, on préfère foreach.
-    // Les deux points : '..', créent un intervalle continue de valeurs
+    // Les deux points : '..', créent un intervalle continu de valeurs
     // incluant la première mais excluant la dernière.
     foreach(i; 1..1_000_000) {
         if(n % 2 == 0)
@@ -72,10 +72,10 @@ void main() {
 }
 ```
 On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
-`union` et `enum`. Ces types sont passés au fonction par valeur (ils sont copiés)
+`union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés)
 De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
 
-```d
+```c
 // Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
 struct LinkedList(T) {
     T data = null;
@@ -88,7 +88,7 @@ struct LinkedList(T) {
 class BinTree(T) {
     T data = null;
 
-    // Si il n'y a qu'un seul paramètre de template,
+    // S'il n'y a qu'un seul paramètre de template,
     // on peut s'abstenir de mettre des parenthèses.
     BinTree!T left;
     BinTree!T right;
@@ -140,7 +140,7 @@ une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
 la syntaxe des structures classiques (`struct.x = 7`) comme si il
 s'agissait de méthodes getter ou setter.
 
-```d
+```c
 // Considérons une classe paramétrée avec les types 'T' et 'U'
 class MyClass(T, U) {
     T _data;
@@ -152,7 +152,7 @@ class MyClass(T, U) {
     T _data;
     U _other;
 
-	// Les constructeurs s'apellent toujours 'this'.
+	// Les constructeurs s'appellent toujours 'this'.
     this(T t, U u) {
 		// Ceci va appeller les setters ci-dessous.
         data = t;
@@ -197,8 +197,8 @@ void main() {
     writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
-Avec les propriétés, on peut constuire nos setters et nos getters
-comme on le souhaite, tout en gardant un syntaxe très propre,
+Avec les propriétés, on peut construire nos setters et nos getters
+comme on le souhaite, tout en gardant une syntaxe très propre,
 comme si on accédait directement à des membres de la classe.
 
 Les autres fonctionnalités orientées objets à notre disposition
@@ -208,20 +208,20 @@ d'une seule classe et implémenter autant d'interface que voulu.
 
 Nous venons d'explorer les fonctionnalités objet du D, mais changeons
 un peu de domaine. D permet la programmation fonctionelle, avec les fonctions
-de premier ordre, les fonctions `pure` et les données immuables.
-De plus, tout vos algorithmes fonctionelles favoris (map, reduce, filter)
+de premier ordre, les fonctions `pures` et les données immuables.
+De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter)
 sont disponibles dans le module `std.algorithm`.
 
-```d
+```c
 import std.algorithm : map, filter, reduce;
 import std.range : iota; // construit un intervalle excluant la dernière valeur.
 
 void main() {
-	// On veut un algorithm qui affiche la somme de la listes des carrés
+	// On veut un algorithme qui affiche la somme de la liste des carrés
 	// des entiers paires de 1 à 100. Un jeu d'enfant !
 
-	// On se content de passer des expressions lambda en paramètre à des templates.
-	// On peut fournier au template n'importe quelle fonction, mais dans notre
+	// On se contente de passer des expressions lambda en paramètre à des templates.
+	// On peut fournir au template n'importe quelle fonction, mais dans notre
 	// cas, les lambdas sont pratiques.
     auto num = iota(1, 101).filter!(x => x % 2 == 0)
                            .map!(y => y ^^ 2)
@@ -231,24 +231,24 @@ void main() {
 }
 ```
 
-Vous voyez comme on a calculé `num` comme on le ferait en haskell par exemple ?
-C'est grâce à une innvoation de D qu'on appelle "Uniform Function Call Syntax".
-Avec l'UFCS, on peut choisir d'écrire un appelle à une fonction de manière
-classique, ou comme un appelle à une méthode. Walter Brighter a écrit un
+Vous voyez qu'on a calculé `num` comme on le ferait en haskell par exemple ?
+C'est grâce à une innovation de D qu'on appelle "Uniform Function Call Syntax".
+Avec l'UFCS, on peut choisir d'écrire un appel à une fonction de manière
+classique, ou comme un appel à une méthode. Walter Brighter a écrit un
 article en anglais sur l'UFCS [ici.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
 Pour faire court, on peut appeller une fonction dont le premier paramètre
 est de type A, comme si c'était une méthode de A.
 
-J'aime le parallélisme. Vous aimez les parallélisme ? Bien sur que vous aimez ça
+J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça.
 Voyons comment on le fait en D !
 
-```d
+```c
 import std.stdio;
 import std.parallelism : parallel;
 import std.math : sqrt;
 
 void main() {
-    // On veut calculer la racine carré de tous les nombres
+    // On veut calculer la racine carrée de tous les nombres
     // dans notre tableau, et profiter de tous les coeurs
     // à notre disposition.
     auto arr = new double[1_000_000];
diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
new file mode 100644
index 00000000..24e8c95f
--- /dev/null
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Hughes Perreault", "https://github.com/hperreault"]
+lang: fr-fr
+---
+
+
+# Programmation dynamique
+
+## Introduction
+
+La programmation dynamique est une technique très efficace pour résoudre une certaine classe de problèmes, comme nous allons le voir. L'idée est très simple, si nous avons résolu un problème avec une certaine entrée, alors nous sauvons le résultat pour pouvoir y accéder plus tard, pour éviter d'avoir à le calculer à nouveau.
+
+## Moyens de résoudre ces problèmes
+
+1.) *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation.
+
+2.) *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique.
+
+## Exemple de Programmation Dynamique
+
+Le problème de la plus grande sous-chaîne croissante est de trouver la plus grande sous-chaîne croissante dans une chaîne. Soit la chaîne `S = {a1, a2, a3, a4, ............., an-1, an}`, nous avons à trouver la plus grande chaîne telle que pour tout `j` et `i`, `j<i` dans la chaîne `aj<ai`.
+Premièrement, nous avons à trouver la valeur de la plus grande sous-chaîne (LSi) à chaque index `i`, avec le dernier élément de la sous-chaîne étant ai. Alors, la plus grande sous-chaîne sera le plus gros LSi. Pour commencer, LSi est égal à 1, car ai est le seul élément de la chaîne (le dernier). Ensuite, pour chaque `j` tel que `j<i` et `aj<ai`, nous trouvons le plus grand LSj et ajoutons le à LSi. L'algorithme fonctionne en temps *O(n2)*.   
+
+Pseudo-code pour trouver la longueur de la plus grande sous-chaîne croissante :
+La complexité de cet algorithme peut être réduite en utilisant une meilleure structure de données qu'un tableau. Par exemple, si nous sauvegardions le tableau d'origine, ou une variable comme plus_grande_chaîne_jusqu'à_maintenant et son index, nous pourrions sauver beaucoup de temps. 
+
+Le même concept peut être appliqué pour trouver le chemin le plus long dans un graphe acyclique orienté.  
+
+```python
+ for i=0 to n-1
+            LS[i]=1
+            for j=0 to i-1
+                        if (a[i] >  a[j] and LS[i]<LS[j])
+                                    LS[i] = LS[j]+1
+ for i=0 to n-1
+            if (largest < LS[i])
+```
+
+### Problèmes classiques de programmation dynamique
+
+L'algorithme de Floyd Warshall(EN)) - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
+
+Problème du sac à dos(EN) - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
+
+
+Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+
+## Online Resources
+
+* [codechef EN](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/fr-fr/elisp-fr.html.markdown b/fr-fr/elisp-fr.html.markdown
new file mode 100644
index 00000000..2e0a9408
--- /dev/null
+++ b/fr-fr/elisp-fr.html.markdown
@@ -0,0 +1,372 @@
+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "https://bzg.fr"]
+    - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
+translators:
+    - ["Bastien Guerry", "https://bzg.fr"]
+filename: learn-emacs-lisp-fr.el
+lang: fr-fr
+---
+
+```scheme
+;; Ceci est une introduction à Emacs Lisp en 15 minutes (v0.2d)
+;;
+;; Auteur : Bastien / @bzg2 / https://bzg.fr
+;;
+;; Prenez d'abord le temps de lire ce texte en anglais de Peter Norvig :
+;; http://norvig.com/21-days.html
+;;
+;; Ensuite installez GNU Emacs 24.3 (ou une version ultérieure) :
+;;
+;; Debian : apt-get install emacs (voir les instructions pour votre distribution)
+;; MacOSX : http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg
+;; Windows : http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip
+;;
+;; Vous trouverez plus d'informations sur l'installation :
+;; http://www.gnu.org/software/emacs/#Obtaining
+
+;; Avertissement important :
+;;
+;; Suivre ce tutoriel ne risque pas d'endommager votre ordinateur,
+;; sauf si vous vous énervez au point de le jeter par terre. En tout
+;; cas, je décline toute responsabilité en cas de problème.
+;; Amusez-vous bien !
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Lancez Emacs.
+;;
+;; Tapez la touche "q" pour enlever le message d'accueil.
+;;
+;; Maintenant regardez la ligne grise au pied de la fenêtre :
+;;
+;; "*scratch*" est le nom de l'espace d'édition dans lequel vous vous
+;; trouvez. Cet espace d'édition est appelé un "buffer".
+;;
+;; Le buffer scratch est le buffer par défaut quand on ouvre Emacs.
+;; Vous n'éditez jamais de fichier directement : vous éditez des
+;; buffers que vous pouvez sauvegarder dans des fichiers.
+;;
+;; "Lisp interaction" désigne le jeu de commandes disponible ici.
+;;
+;; Emacs a un jeu de commandes par défaut pour chaque buffer, et
+;; plusieurs autres jeux de commandes disponibles quand vous activez
+;; un mode particulier.  Ici nous utilisons `lisp-interaction-mode',
+;; qui propose des commandes pour évaluer et naviguer dans du code
+;; Elisp.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Le point-virgule commence un commentaire partout sur une ligne.
+;;
+;; Les programmes Elisp sont composés d'expressions symboliques aussi
+;; appelées "sexps" :
+(+ 2 2)
+
+;; Cette expression symbolique se lit "Ajouter 2 à 2".
+
+;; Les sexps sont placées entre parenthèses, possiblement sur
+;; plusieurs niveaux :
+(+ 2 (+ 1 1))
+
+;; Une expression symbolique contient des atomes ou d'autres
+;; expressions symboliques. Dans les exemples ci-dessus, 1 et 2 sont
+;; des atomes et (+ 2 (+ 1 1)) et (+ 1 1) des expressions symboliques.
+
+;; Dans le mode `lisp-interaction-mode' vous pouvez évaluer les sexps.
+;; Placez le curseur juste après la parenthèse fermante, tenez la
+;; touche "Control" enfoncée et appuyez sur la touche "j" (soit le
+;; raccourci "C-j").
+
+(+ 3 (+ 1 2))
+;;           ^ curseur ici
+;; `C-j' => 6
+
+;; `C-j' insère le résultat de l'évaluation dans le buffer.
+
+;; `C-x C-e' affiche le même résultat dans la ligne tout en bas
+;; d'Emacs, appelée le "minibuffer". On utilise en général `C-x C-e',
+;; pour ne pas encombrer le buffer avec du texte inutile.
+
+;; `setq' assigne une valeur à une variable :
+(setq my-name "Bastien")
+;; `C-x C-e' => "Bastien" (affiché dans le minibuffer)
+
+;; `insert' va insérer "Hello!" là où se trouve le curseur :
+(insert "Hello!")
+;; `C-x C-e' => "Hello!"
+
+;; Nous utilisons `insert' avec un seul argument "Hello!", mais
+;; nous pouvons passer plus d'arguments - ici nous en passons deux :
+
+(insert "Hello" " world!")
+;; `C-x C-e' => "Hello world!"
+
+;; Vous pouvez utiliser des variables au lieu de chaînes de caractères :
+(insert "Hello, I am " my-name)
+;; `C-x C-e' => "Hello, I am Bastien"
+
+;; Vous pouvez combiner les sexps en fonctions :
+(defun hello () (insert "Hello, I am " my-name))
+;; `C-x C-e' => hello
+
+;; Vous pouvez évaluer les fonctions :
+(hello)
+;; `C-x C-e' => Hello, I am Bastien
+
+;; Les parenthèses vides dans la définition de la fonction signifient
+;; qu'elle ne prend pas d'argument. Mais toujours utiliser `my-name'
+;; est ennuyant, demandons à la fonction d'accepter un argument (ici
+;; l'argument est appelé "name") :
+
+(defun hello (name) (insert "Hello " name))
+;; `C-x C-e' => hello
+
+;; Maintenant appelons la fonction avec la chaîne de caractères "you"
+;; comme valeur de son unique argument :
+(hello "you")
+;; `C-x C-e' => "Hello you"
+
+;; Youpi!
+
+;; Faites une pause.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Maintenant ouvrez un nouveau buffer appelé "*test*" dans une
+;; nouvelle fenêtre :
+
+(switch-to-buffer-other-window "*test*")
+;; `C-x C-e'
+;; => [l'écran a deux fenêtres et le curseur est dans le buffer *test*]
+
+;; Placez la souris sur la fenêtre du haut et cliquez-gauche pour
+;; retourner dans cette fenêtre. Ou bien utilisez `C-x o' (i.e. tenez
+;; control-x appuyé et appuyez sur o) pour aller dans l'autre fenêtre
+;; interactivement.
+
+;; Vous pouvez combiner plusieurs sexps avec `progn' :
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (hello "you"))
+;; `C-x C-e'
+;; => [L'écran a deux fenêtres et le curseur est dans le buffer *test*]
+
+;; Maintenant si ça ne vous dérange pas, je vais arrêter de vous
+;; demander de faire `C-x C-e' : faites-le pour chaque sexp qui suit.
+
+;; Retournez toujours dans le buffer *scratch* avec la souris ou `C-x o'.
+
+;; Il est souvent utile d'effacer le contenu du buffer :
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "there"))
+
+;; Ou d'aller à l'autre fenêtre :
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "you")
+  (other-window 1))
+
+;; Vous pouvez associer une valeur à une variable locale avec `let' :
+(let ((local-name "you"))
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello local-name)
+  (other-window 1))
+
+;; Dans ce cas pas besoin d'utiliser `progn' puisque `let' combine
+;; aussi plusieurs sexps.
+
+;; Mettons en forme une chaîne de caractères :
+(format "Hello %s!\n" "visitor")
+
+;; %s désigne l'emplacement de la chaîne, remplacé par "visitor".
+;; \n est le caractère de saut de ligne.
+
+;; Améliorons notre fonction en utilisant "format" :
+(defun hello (name)
+  (insert (format "Hello %s!\n" name)))
+
+(hello "you")
+
+;; Créons une autre fonction qui utilise `let' :
+(defun greeting (name)
+  (let ((your-name "Bastien"))
+    (insert (format "Hello %s!\n\nI am %s."
+                    name       ; l'argument de la fonction
+                    your-name  ; la variable "let-bindée" "Bastien"
+                    ))))
+
+;; Et évaluons-la :
+(greeting "you")
+
+;; Certaines fonctions sont interactives :
+(read-from-minibuffer "Enter your name: ")
+
+;; Évaluer cette fonction va renvoyer ce que vous avez saisi dans le
+;; minibuffer.
+
+;; Faisons que notre fonction `greeting' vous demande votre nom :
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (insert (format "Hello!\n\nI am %s and you are %s."
+                    from-name ; l'argument de la fonction
+                    your-name ; la variable "let-bindée", entrée dans le minibuffer
+                    ))))
+
+(greeting "Bastien")
+
+;; Complétons la fonction pour qu'elle affiche le résultat dans
+;; l'autre fenêtre :
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (insert (format "Hello %s!\n\nI am %s." your-name from-name))
+    (other-window 1)))
+
+;; Maintenant testons :
+(greeting "Bastien")
+
+;; Faites une pause.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Stockons une liste de noms :
+(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
+
+;; Récupérez le premier élément de la liste avec `car' :
+(car list-of-names)
+
+;; Récupérez tous les élements sauf le premier avec `cdr' :
+(cdr list-of-names)
+
+;; Ajoutez un élément au début avec `push' :
+(push "Stephanie" list-of-names)
+
+;; Note : `car' et `cdr' ne modifient pas la liste, mais `push' oui.
+;; C'est une différence importante : certaines fonctions n'ont pas
+;; d'effets de bord (comme `car') et d'autres oui (comme `push').
+
+;; Évaluons `hello' pour tous les éléments dans `list-of-names' :
+(mapcar 'hello list-of-names)
+
+;; Améliorons `greeting' pour dire hello aux noms de `list-of-names' :
+(defun greeting ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (mapcar 'hello list-of-names)
+    (other-window 1))
+
+(greeting)
+
+;; Vous vous souvenez de la fonction `hello' définie ci-dessus ?  Elle
+;; prend seulement un argument, un nom.  `mapcar' appelle `hello' en
+;; utilisant successivement chaque élément de `list-of-names' comme
+;; argument de `hello'.
+
+;; Maintenant arrangeons un peu ce qui est affiché dans le buffer :
+
+(defun replace-hello-by-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (search-forward "Hello")
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+;; (goto-char (point-min)) va au début du buffer.
+;; (search-forward "Hello") cherche la chaîne "Hello".
+;; (while x y) évalue la sexp(s) y tant que x renvoie quelque chose.
+;; Si x renvoie `nil' (rien), nous sortons de la boucle.
+
+(replace-hello-by-bonjour)
+
+;; Vous devriez voir toutes les occurrences de "Hello" dans le buffer
+;; *test* remplacées par "Bonjour".
+
+;; Vous devriez aussi avoir une erreur : "Search failed: Hello".
+;;
+;; Pour éviter cette erreur, il faut dire à `search-forward' si la
+;; recherche doit s'arrêter à un certain point du buffer, et si elle
+;; doit s'arrêter silencieusement si aucune chaîne n'est trouvée.
+
+;; (search-forward "Hello" nil t) fait ça :
+
+;; L'argument `nil' indique que la recherche n'est pas limitée à une
+;; position.  L'argument `t' indique de s'arrêter silencieusement si
+;; rien n'est trouvé.
+
+;; Nous utilisons cette sexp dans la fonction ci-dessous, qui ne
+;; renvoie pas d'erreur :
+
+(defun hello-to-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    ;; Dit hello aux noms de `list-of-names'
+    (mapcar 'hello list-of-names)
+    (goto-char (point-min))
+    ;; Remplace "Hello" par "Bonjour"
+    (while (search-forward "Hello" nil t)
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+(hello-to-bonjour)
+
+;; Mettons les noms en gras :
+
+(defun boldify-names ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (re-search-forward "Bonjour \\(.+\\)!" nil t)
+      (add-text-properties (match-beginning 1)
+                           (match-end 1)
+                           (list 'face 'bold)))
+    (other-window 1))
+
+;; Cette fonction introduit `re-search-forward' : au lieu de chercher
+;; la chaîne "Bonjour", nous cherchons un "pattern" en utilisant une
+;; "expression régulière" (le préfixe "re-" signifie "regular
+;; expression").
+
+;; L'expression régulière est "Bonjour \\(.+\\)!" et se lit :
+;; la chaîne "Bonjour ", et
+;; un groupe de                | c'est la syntaxe \\( ... \\)
+;;   n'importe quel caractère  | c'est le .
+;;   une ou plusieurs fois     | c'est le +
+;; et la chaîne "!".
+
+;; Prêt ?  Testons !
+
+(boldify-names)
+
+;; `add-text-properties' ajoute des propriétés textuelles telle que
+;; des "faces" (une "face" définit la fonte, la couleur, la taille et
+;; d'autres propriétés du texte.)
+
+;; Et voilà, c'est fini.  Happy hacking!
+
+;; Si vous voulez en savoir plus sur une variable ou une fonction :
+;;
+;; C-h v une-variable RET
+;; C-h f une-fonction RET
+;;
+;; Pour lire le manuel Emacs Lisp avec Emacs :
+;;
+;; C-h i m elisp RET
+;;
+;; Pour lire en ligne une introduction à Emacs Lisp :
+;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
+
+;; Merci à ces personnes pour leurs retours et suggetions :
+;; - Wes Hardaker
+;; - notbob
+;; - Kevin Montuori
+;; - Arne Babenhauserheide
+;; - Alan Schmitt
+;; - LinXitoW
+;; - Aaron Meurer
+```
diff --git a/fr-fr/fsharp-fr.html.markdown b/fr-fr/fsharp-fr.html.markdown
new file mode 100644
index 00000000..3fd41676
--- /dev/null
+++ b/fr-fr/fsharp-fr.html.markdown
@@ -0,0 +1,631 @@
+---
+language: F#
+lang: fr-fr
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
+translators:
+    - ["Alois de Gouvello", "https://github.com/aloisdg"]
+filename: learnfsharp-fr.fs
+---
+
+F# est un langage de programmation fonctionnel et orienté objet. Il est gratuit et son code source est ouvert. Il tourne sur Linux, Mac, Windows et plus.
+
+Il possède un puissant système de type qui piège de nombreuses erreurs à la compilation, mais il utilise l'inférence de type ce qui lui permet d'être lu comme un langage dynamique.
+
+La syntaxe de F# est différente des langages héritant de C.
+
+* Les accolades ne sont pas utilisées pour délimiter les blocs de code. À la place, l'indentation est utilisée (à la manière de Python).
+* Les espaces sont utilisés pour séparer les paramètres à la place des virgules.
+
+Si vous voulez essayer le code ci-dessous, vous pouvez vous rendre sur [tryfsharp.org](http://www.tryfsharp.org/Create) et le coller dans le [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop).
+
+```fsharp
+
+// Les commentaires d'une seule ligne commencent par un double slash
+(* Les commentaires multilignes utilise les paires (* . . . *)
+
+-fin du commentaire multilignes- *)
+
+// ================================================
+// Syntaxe de base
+// ================================================
+
+// ------ "Variables" (mais pas vraiment) ------
+// Le mot clé "let" définit une valeur (immutable)
+let myInt = 5
+let myFloat = 3.14
+let myString = "hello"           // Notons qu'aucun type n'est nécessaire
+
+// ------ Listes ------
+let twoToFive = [2;3;4;5]        // Les crochets créent une liste avec
+                                 // des point-virgules pour délimiteurs.
+let oneToFive = 1 :: twoToFive   // :: crée une liste avec un nouvel élément
+// Le résultat est [1;2;3;4;5]
+let zeroToFive = [0;1] @ twoToFive   // @ concatène deux listes
+
+// IMPORTANT: les virgules ne sont jamais utilisées pour délimiter,
+// seulement les point-virgules !
+
+// ------ Fonctions ------
+// Le mot clé "let" définit aussi le nom d'une fonction.
+let square x = x * x          // Notons qu'aucune parenthèse n'est utilisée.
+square 3                      // Maitenant, exécutons la fonction.
+                              // Encore une fois, aucune parenthèse.
+
+let add x y = x + y           // N'utilisez pas add (x,y) ! Cela signifie
+                              // quelque chose de complètement différent.
+add 2 3                       // À présent, exécutons la fonction.
+
+// Pour définir une fonction sur plusieurs lignes, utilisons l'indentation.
+// Les point-virgules ne sont pas nécessaires.
+let evens list =
+   let isEven x = x%2 = 0     // Définit "isEven" comme une fonction imbriquée
+   List.filter isEven list    // List.filter est une fonction de la librairie
+                              // à deux paramètres: un fonction retournant un
+                              // booléen et une liste sur laquelle travailler
+
+evens oneToFive               // À présent, exécutons la fonction.
+
+// Vous pouvez utilisez les parenthèses pour clarifier.
+// Dans cet exemple, "map" est exécutée en première, avec deux arguments,
+// ensuite "sum" est exécutée sur le résultat.
+// Sans les parenthèses, "List.map" serait passé en argument à List.sum.
+let sumOfSquaresTo100 =
+   List.sum ( List.map square [1..100] )
+
+// Vous pouvez rediriger la sortie d'une fonction vers une autre avec "|>"
+// Rediriger des données est très commun en F#, comme avec les pipes UNIX.
+
+// Voici la même fonction sumOfSquares écrite en utilisant des pipes
+let sumOfSquaresTo100piped =
+   [1..100] |> List.map square |> List.sum  // "square" est déclaré avant
+
+// Vous pouvez définir des lambdas (fonctions anonymes) grâce au mot clé "fun"
+let sumOfSquaresTo100withFun =
+   [1..100] |> List.map (fun x -> x*x) |> List.sum
+
+// En F#, il n'y a pas de mot clé "return". Une fonction retourne toujours
+// la valeur de la dernière expression utilisée.
+
+// ------ Pattern Matching ------
+// Match..with.. est une surcharge de la condition case/switch.
+let simplePatternMatch =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x is a"
+    | "b" -> printfn "x is b"
+    | _ -> printfn "x is something else"   // underscore correspond à tout le reste
+
+// F# n'autorise pas la valeur null par défaut -- vous devez utiliser le type Option
+// et ensuite faire correspondre le pattern.
+// Some(..) et None sont approximativement analogue à des wrappers de Nullable
+let validValue = Some(99)
+let invalidValue = None
+
+// Dans cet exemple, match..with trouve une correspondance à "Some" et à "None",
+// et affiche la valeur du "Some" en même temps.
+let optionPatternMatch input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionPatternMatch validValue
+optionPatternMatch invalidValue
+
+// ------ Affichage ------
+// Les fonctions printf/printfn sont similaires aux fonctions
+// Console.Write/WriteLine de C#.
+printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
+printfn "A string %s, and something generic %A" "hello" [1;2;3;4]
+
+// Il y a aussi les fonctions printf/sprintfn pour formater des données
+// en string. C'est similaire au String.Format de C#.
+
+// ================================================
+// Plus sur les fonctions
+// ================================================
+
+// F# est un véritable langage fonctionel -- les fonctions sont des
+// entités de premier ordre et peuvent êtres combinées facilement
+// pour créer des constructions puissantes
+
+// Les modules sont utilisés pour grouper des fonctions ensemble.
+// L'indentation est nécessaire pour chaque module imbriqué.
+module FunctionExamples =
+
+    // définit un simple fonction d'addition
+    let add x y = x + y
+
+    // usage basique d'une fonction
+    let a = add 1 2
+    printfn "1+2 = %i" a
+
+    // partial application to "bake in" parameters (?)
+    let add42 = add 42
+    let b = add42 1
+    printfn "42+1 = %i" b
+
+    // composition pour combiner des fonctions
+    let add1 = add 1
+    let add2 = add 2
+    let add3 = add1 >> add2
+    let c = add3 7
+    printfn "3+7 = %i" c
+
+    // fonctions de premier ordre
+    [1..10] |> List.map add3 |> printfn "new list is %A"
+
+    // listes de fonction et plus
+    let add6 = [add1; add2; add3] |> List.reduce (>>)
+    let d = add6 7
+    printfn "1+2+3+7 = %i" d
+
+// ================================================
+// Listes et collections
+// ================================================
+
+// Il y a trois types de collection ordonnée :
+// * Les listes sont les collections immutables les plus basiques
+// * Les tableaux sont mutables et plus efficients
+// * Les séquences sont lazy et infinies (e.g. un enumerator)
+//
+// Des autres collections incluent des maps immutables et des sets
+// plus toutes les collections de .NET
+
+module ListExamples =
+
+    // les listes utilisent des crochets
+    let list1 = ["a";"b"]
+    let list2 = "c" :: list1    // :: pour un ajout au début
+    let list3 = list1 @ list2   // @ pour la concatenation
+
+    // Compréhensions des listes (aka générateurs)
+    let squares = [for i in 1..10 do yield i*i]
+
+    //  Générateur de nombre premier
+    let rec sieve = function
+        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primes = sieve [2..50]
+    printfn "%A" primes
+
+    // le pattern matching pour les listes
+    let listMatcher aList =
+        match aList with
+        | [] -> printfn "the list is empty"
+        | [first] -> printfn "the list has one element %A " first
+        | [first; second] -> printfn "list is %A and %A" first second
+        | _ -> printfn "the list has more than two elements"
+
+    listMatcher [1;2;3;4]
+    listMatcher [1;2]
+    listMatcher [1]
+    listMatcher []
+
+    // Récursion en utilisant les listes
+    let rec sum aList =
+        match aList with
+        | [] -> 0
+        | x::xs -> x + sum xs
+    sum [1..10]
+
+    // -----------------------------------------
+    // Fonctions de la librairie standard
+    // -----------------------------------------
+
+    // map
+    let add3 x = x + 3
+    [1..10] |> List.map add3
+
+    // filtre
+    let even x = x % 2 = 0
+    [1..10] |> List.filter even
+
+    // beaucoup plus -- se référer à la documentation
+
+module ArrayExamples =
+
+    // les tableaux utilisent les crochets avec des barres
+    let array1 = [| "a";"b" |]
+    let first = array1.[0]        // accès à l'index en utilisant un point
+
+    // le pattern matching des tableaux est le même que celui des listes
+    let arrayMatcher aList =
+        match aList with
+        | [| |] -> printfn "the array is empty"
+        | [| first |] -> printfn "the array has one element %A " first
+        | [| first; second |] -> printfn "array is %A and %A" first second
+        | _ -> printfn "the array has more than two elements"
+
+    arrayMatcher [| 1;2;3;4 |]
+
+    // Fonctions de la librairie standard comme celles des listes
+    [| 1..10 |]
+    |> Array.map (fun i -> i+3)
+    |> Array.filter (fun i -> i%2 = 0)
+    |> Array.iter (printfn "value is %i. ")
+
+module SequenceExamples =
+
+    // Les séquences utilisent des accolades
+    let seq1 = seq { yield "a"; yield "b" }
+
+    // Les séquences peuvent utiliser yield et
+    // peuvent contenir des sous-sequences
+    let strange = seq {
+        // "yield" ajoute un élément
+        yield 1; yield 2;
+
+        // "yield!" ajoute une sous-sequence complète
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i%2 = 0 then yield i }}
+    // test
+    strange |> Seq.toList
+
+    // Les séquences peuvent être créées en utilisant "unfold"
+    // Voici la suite de fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // test
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "first 10 fibs are %A" fib10
+
+// ================================================
+// Types de données
+// ================================================
+
+module DataTypeExamples =
+
+    // Toutes les données sont immutables par défaut
+
+    // Les tuples sont de simple et rapide types anonymes
+    // -- Utilisons une virgule pour créer un tuple
+    let twoTuple = 1,2
+    let threeTuple = "a",2,true
+
+    // Pattern match pour déballer
+    let x,y = twoTuple  // assigne x=1 y=2
+
+    // ------------------------------------
+    // Record types ont des champs nommés
+    // ------------------------------------
+
+    // On utilise "type" avec des accolades pour définir un type record
+    type Person = {First:string; Last:string}
+
+    // On utilise "let" avec des accolades pour créer un record (enregistrement)
+    let person1 = {First="John"; Last="Doe"}
+
+    // Pattern match pour déballer
+    let {First=first} = person1    // assigne first="john"
+
+    // ------------------------------------
+    // Union types (ou variants) ont un set (ensemble) de choix
+    // Un seul cas peut être valide à la fois.
+    // ------------------------------------
+
+    // On utilise "type" avec bar/pipe pour definir un union type
+    type Temp =
+        | DegreesC of float
+        | DegreesF of float
+
+    // On utilise un de ces choix pour en créér un
+    let temp1 = DegreesF 98.6
+    let temp2 = DegreesC 37.0
+
+    // Pattern match on all cases to unpack(?)
+    let printTemp = function
+       | DegreesC t -> printfn "%f degC" t
+       | DegreesF t -> printfn "%f degF" t
+
+    printTemp temp1
+    printTemp temp2
+
+    // ------------------------------------
+    // Types récursif
+    // ------------------------------------
+
+    // Les types peuvent être combinés récursivement de façon complexe
+    // sans avoir à créer des sous-classes
+    type Employee =
+      | Worker of Person
+      | Manager of Employee list
+
+    let jdoe = {First="John";Last="Doe"}
+    let worker = Worker jdoe
+
+    // ------------------------------------
+    // Modelling with types(?)
+    // ------------------------------------
+
+    // Les types union sont excellents pour modelling state without using flags(?)
+    type EmailAddress =
+        | ValidEmailAddress of string
+        | InvalidEmailAddress of string
+
+    let trySendEmail email =
+        match email with // utilisations du pattern matching
+        | ValidEmailAddress address -> ()   // envoyer
+        | InvalidEmailAddress address -> () // ne pas envoyer
+
+    // Combiner ensemble, les types union et les types record
+    // offrent une excellente fondation pour le domain driven design.
+    // Vous pouvez créer des centaines de petit types qui reflèteront fidèlement
+    // le domain.
+
+    type CartItem = { ProductCode: string; Qty: int }
+    type Payment = Payment of float
+    type ActiveCartData = { UnpaidItems: CartItem list }
+    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+
+    type ShoppingCart =
+        | EmptyCart  // aucune donnée
+        | ActiveCart of ActiveCartData
+        | PaidCart of PaidCartData
+
+    // ------------------------------------
+    // Comportement natif des types
+    // ------------------------------------
+
+    // Les types natifs ont un comportement "prêt-à-l'emploi" des plus utiles, sans code à ajouter.
+    // * Immutabilité
+    // * Pretty printing au debug
+    // * Egalité et comparaison
+    // * Sérialisation
+
+    // Le Pretty printing s'utilise avec %A
+    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
+             twoTuple person1 temp1 worker
+
+    // L'égalité et la comparaison sont innés
+    // Voici un exemple avec des cartes.
+    type Suit = Club | Diamond | Spade | Heart
+    type Rank = Two | Three | Four | Five | Six | Seven | Eight
+                | Nine | Ten | Jack | Queen | King | Ace
+
+    let hand = [ Club,Ace; Heart,Three; Heart,Ace;
+                 Spade,Jack; Diamond,Two; Diamond,Ace ]
+
+    // tri
+    List.sort hand |> printfn "sorted hand is (low to high) %A"
+    List.max hand |> printfn "high card is %A"
+    List.min hand |> printfn "low card is %A"
+
+// ================================================
+// Les Active patterns
+// ================================================
+
+module ActivePatternExamples =
+
+    // F# a un type particulier de pattern matching nommé "active patterns"
+    // où le pattern peut être parsé ou détecté dynamiquement.
+
+    // "banana clips" est la syntaxe pour l'active patterns
+
+    // par exemple, on définit un "active" pattern pour correspondre à des types "character"...
+    let (|Digit|Letter|Whitespace|Other|) ch =
+       if System.Char.IsDigit(ch) then Digit
+       else if System.Char.IsLetter(ch) then Letter
+       else if System.Char.IsWhiteSpace(ch) then Whitespace
+       else Other
+
+    // ... et ensuite on l'utilise pour rendre la logique de parsing plus claire
+    let printChar ch =
+      match ch with
+      | Digit -> printfn "%c is a Digit" ch
+      | Letter -> printfn "%c is a Letter" ch
+      | Whitespace -> printfn "%c is a Whitespace" ch
+      | _ -> printfn "%c is something else" ch
+
+    // afficher une liste
+    ['a';'b';'1';' ';'-';'c'] |> List.iter printChar
+
+    // -----------------------------------------
+    // FizzBuzz en utilisant les active patterns
+    // -----------------------------------------
+
+    // Vous pouvez créer un partial matching patterns également
+    // On utilise just un underscore dans la définition, et on retourne Some si ça correspond.
+    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+    // la fonction principale
+    let fizzBuzz i =
+      match i with
+      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+      | MultOf3 -> printf "Fizz, "
+      | MultOf5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // test
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Concision
+// ================================================
+
+module AlgorithmExamples =
+
+    // F# a un haut ratio signal/bruit, permettant au code de se lire
+    // presque comme un véritable algorithme
+
+    // ------ Exemple: definir une fonction sumOfSquares ------
+    let sumOfSquares n =
+       [1..n]              // 1) Prendre tous les nombres de 1 à n
+       |> List.map square  // 2) Elever chacun d'entre eux au carré
+       |> List.sum         // 3) Effectuer leur somme
+
+    // test
+    sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+    // ------ Exemple: definir un fonction de tri ------
+    let rec sort list =
+       match list with
+       // Si la liste est vide
+       | [] ->
+            []                            // on retourne une liste vide
+       // si la list n'est pas vide
+       | firstElem::otherElements ->      // on prend le premier élément
+            let smallerElements =         // on extrait les éléments plus petits
+                otherElements             // on prend les restants
+                |> List.filter (fun e -> e < firstElem)
+                |> sort                   // et on les trie
+            let largerElements =          // on extrait les plus grands
+                otherElements             // de ceux qui restent
+                |> List.filter (fun e -> e >= firstElem)
+                |> sort                   // et on les trie
+            // On combine les 3 morceaux dans une nouvelle liste que l'on retourne
+            List.concat [smallerElements; [firstElem]; largerElements]
+
+    // test
+    sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A"
+
+// ================================================
+// Code Asynchrone
+// ================================================
+
+module AsyncExample =
+
+    // F# inclus des fonctionnalités pour aider avec le code asynchrone
+    // sans rencontrer la "pyramid of doom"
+    //
+    // L'exemple suivant télécharge une séquence de page web en parallèle.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Récupérer le contenu d'une URL de manière asynchrone
+    let fetchUrlAsync url =
+        async {   // Le mot clé "async" et les accolades
+                  // créent un objet "asynchrone"
+            let req = WebRequest.Create(Uri(url))
+            use! resp = req.AsyncGetResponse()
+                // use! est un assignement asynchrone
+            use stream = resp.GetResponseStream()
+                // "use" déclenche automatiquement close()
+                // sur les ressources à la fin du scope
+            use reader = new IO.StreamReader(stream)
+            let html = reader.ReadToEnd()
+            printfn "finished downloading %s" url
+            }
+
+    // une liste des sites à rapporter
+    let sites = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // C'est parti!
+    sites
+    |> List.map fetchUrlAsync  // créez une liste de tâche asynchrone
+    |> Async.Parallel          // dites aux tâches de tourner en parallèle
+    |> Async.RunSynchronously  // démarrez les!
+
+// ================================================
+// .NET compatabilité
+// ================================================
+
+module NetCompatibilityExamples =
+
+    // F# peut réaliser presque tout ce que C# peut faire, et il s'intègre
+    // parfaitement avec les librairies .NET ou Mono.
+
+    // ------- Travaillez avec les fonctions des librairies existantes  -------
+
+    let (i1success,i1) = System.Int32.TryParse("123");
+    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+
+    // ------- Implémentez des interfaces à la volée! -------
+
+    // Créer un nouvel objet qui implémente IDisposable
+    let makeResource name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s disposed" name }
+
+    let useAndDisposeResources =
+        use r1 = makeResource "first resource"
+        printfn "using first resource"
+        for i in [1..3] do
+            let resourceName = sprintf "\tinner resource %d" i
+            use temp = makeResource resourceName
+            printfn "\tdo something with %s" resourceName
+        use r2 = makeResource "second resource"
+        printfn "using second resource"
+        printfn "done."
+
+    // ------- Code orienté objet -------
+
+    // F# est aussi un véritable language OO.
+    // Il supporte les classes, l'héritage, les méthodes virtuelles, etc.
+
+    // interface avec type générique
+    type IEnumerator<'a> =
+        abstract member Current : 'a
+        abstract MoveNext : unit -> bool
+
+    // Classe de base abstraite avec méthodes virtuelles
+    [<AbstractClass>]
+    type Shape() =
+        // propriétés en lecture seule
+        abstract member Width : int with get
+        abstract member Height : int with get
+        // méthode non-virtuelle
+        member this.BoundingArea = this.Height * this.Width
+        // méthode virtuelle avec implémentation de la classe de base
+        abstract member Print : unit -> unit
+        default this.Print () = printfn "I'm a shape"
+
+    // classe concrète qui hérite de sa classe de base et surcharge
+    type Rectangle(x:int, y:int) =
+        inherit Shape()
+        override this.Width = x
+        override this.Height = y
+        override this.Print ()  = printfn "I'm a Rectangle"
+
+    // test
+    let r = Rectangle(2,3)
+    printfn "The width is %i" r.Width
+    printfn "The area is %i" r.BoundingArea
+    r.Print()
+
+    // ------- extension de méthode  -------
+
+    // Juste comme en C#, F# peut étendre des classes existantes avec des extensions de méthode.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // test
+    let s = "Alice"
+    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
+    // ------- événements -------
+
+    type MyButton() =
+        let clickEvent = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = clickEvent.Publish
+
+        member this.TestEvent(arg) =
+            clickEvent.Trigger(this, arg)
+
+    // test
+    let myButton = new MyButton()
+    myButton.OnClick.Add(fun (sender, arg) ->
+            printfn "Click event with arg=%O" arg)
+
+    myButton.TestEvent("Hello World!")
+
+```
+
+## Plus d'information
+
+Pour plus de démonstration de F#, rendez-vous sur le site [Try F#](http://www.tryfsharp.org/Learn), ou suivez la série [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Apprenez en davantage à propose de F# sur [fsharp.org](http://fsharp.org/).
diff --git a/fr-fr/git-fr.html.markdown b/fr-fr/git-fr.html.markdown
new file mode 100644
index 00000000..510459fe
--- /dev/null
+++ b/fr-fr/git-fr.html.markdown
@@ -0,0 +1,583 @@
+---
+category: tool
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
+translators:
+    - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"]
+filename: LearnGit-fr.txt
+lang: fr-fr
+---
+
+Git est un logiciel de contrôle de versions distribué et un système de gestion
+du code source.
+
+Il effectue sa tâche via des séries d'instantanés (snapshots) du projet, et
+travaille avec ces instantanés afin de fournir les fonctionnalités de gestion
+de version et de code source.
+
+## Concepts du versionnage
+
+### Qu'est ce que le contrôle de version ?
+
+Le contrôle de version est un système qui enregistre les changements faits sur
+un ou plusieurs fichiers au fil du temps.
+
+### Versionnage centralisé VS Versionnage distribué
+
+* Le contrôle de version centralisé se concentre sur la synchronisation, le
+suivi et la sauvegarde des fichiers.
+* Le contrôle de version distribué se focalise sur l'échange des changements.
+Chaque changement a un identifiant unique.
+* Les systèmes distribués n'ont pas de structure définie. Vous pouvez aisément
+avoir un système centralisé de type SVN, avec Git.
+
+[Informations additionnelles](http://git-scm.com/book/fr/v1/D%C3%A9marrage-rapide-%C3%80-propos-de-la-gestion-de-version)
+
+### Pourquoi utiliser Git ?
+
+* Fonctionne hors ligne.
+* Travailler avec les autres devient facile !
+* Ramifier le travail (créer des branches différentes) est facile !
+* Fusionner le travail est facile !
+* Git est rapide.
+* Git est flexible.
+
+## Architecture Git
+
+
+### Dépôt ("repository")
+
+Un ensemble de fichiers, dossiers, historiques de modifications, commits
+(validations de changements) et de heads (état courant, "tête").
+Représentez-vous ceci comme une structure de données de code source, avec la
+particularité que chaque "élement" vous donne, entre autres, accès à son
+historique des révisions.
+
+Un dépôt Git comprend un répertoire .git et "l'arbre de travail" (working tree).
+
+### Répertoire .git (composant du dépôt)
+
+Le répertoire .git contient toutes les configurations, logs (journaux),
+branches, HEAD et plus.
+[Liste détaillée (EN)](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Arbre de travail (composant du dépôt)
+
+Il s'agit de l'ensemble des répertoires et fichiers de votre dépôt. Il est
+souvent qualifié de répertoire de travail ("working directory").
+
+### Index (composant du répertoire .git)
+
+L'index est la zone de transit ("staging area") dans Git. Il s'agit d'une couche
+séparant votre arbre de travail de votre dépôt Git. Ceci donne aux développeurs
+plus de pouvoir sur ce qu'ils envoient au dépôt.
+
+### Commit
+
+Un "commit" (validation de changements) est un instantané d'un ensemble de
+modifications de votre arbre de travail. Par exemple, si vous avez rajouté 5
+fichiers et enlevé 2 autres, ces changements seront contenus dans un commit
+(ou "snapshot", instantané). Ce commit peut ensuite être poussé ("pushed") dans
+d'autres dépôts, ou non !
+
+### Branches
+
+Une branche consiste essentiellement en un pointeur vers le dernier commit que
+vous avez fait. Au fur et à mesure de vos commits, ce pointeur se mettra
+automatiquement à jour pour pointer vers le dernier commit.
+
+### Etiquette ("tag")
+
+Une étiquette est une marque sur un point spécifique de l'historique.
+Typiquement, on utilise cette fonctionnalité pour marquer les états de
+publication (v1.0, et ainsi de suite).
+
+### HEAD and head (composant du répertoire .git)
+
+HEAD est un pointeur pointant vers la branche courante. Un dépôt ne peut avoir
+qu'un seul HEAD *actif*.
+head est un pointeur pouvant pointer sur n'importe quel commit. Un dépôt peut
+avoir un nombre illimité de heads.
+
+### Les états dans Git
+* Modifié - Des changements on été faits à un fichier mais ce dernier n'a pas
+encore été rajouté à l'ensemble des fichiers Git
+* Indexé ("staged") - Indique qu'un fichier modifié ira dans le prochain commit
+* Validé ("committed") - Les fichiers ont été validés dans l'ensemble de
+fichiers
+
+### Ressources conceptuelles
+
+* [Git pour les informaticiens (EN)](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git pour les designers (EN)](http://hoth.entp.com/output/git_for_designers.html)
+
+
+## Commandes
+
+
+### init
+
+Créé un dépôt Git vide. Les paramètres du dépôt Git, les informations stockées
+et plus sont dans un répertoire (un dossier) nommé ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+Configuration des paramètres. Que ce soit pour le dépôt, le système lui-même,
+ou la configuration globale (le fichier de configuration globale
+est `~/.gitconfig`).
+
+
+```bash
+# Lit et assigne quelques variables (globales) de configuration de base
+$ git config --global user.email "monEmail@foo.com"
+$ git config --global user.name "Mon nom"
+```
+
+[Apprenez-en plus à propos de git config.](https://git-scm.com/book/fr/v1/Personnalisation-de-Git-Configuration-de-Git)
+
+### help
+
+Vous donne un accès rapide à un guide extrêmement détaillé de chaque commande.
+Ou juste vous donner un rappel rapide de la sémantique.
+
+```bash
+# Vérifie rapidement les commandes disponibles
+$ git help
+
+# Vérifie toutes les commandes disponibles
+$ git help -a
+
+# Aide pour une commande spécifique - manuel utilisateur
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+# ou git <command_here> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### ignorer des fichiers
+
+Ne plus suivre certains fichiers et dossiers de Git.
+Habituellement fait pour les fichiers privés et temporaires qui seraient,
+autrement, partagés dans le dépôt.
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "cle_privee" >> .gitignore
+```
+
+### status
+
+Montre les différences entre le fichier indexé (typiquement votre copie/dépôt
+de travail) et le HEAD actuel.
+
+
+```bash
+# Affiche la branche, les fichiers non suivis, les changements et autres
+différences
+$ git status
+
+# Pour en apprendre plus sur git status
+$ git help status
+```
+
+### add
+
+Rajoute des fichiers à la zone d'index. Si vous ne faites pas `git add` sur les
+nouveaux fichiers, ils ne seront pas inclus dans les commits !
+
+```bash
+# rajoute un fichier dans votre répertoire de travail actuel
+$ git add HelloWorld.java
+
+# rajoute un fichier dans un répertoire imbriqué
+$ git add /path/to/file/HelloWorld.c
+
+# Gestion des expressions régulières !
+$ git add ./*.java
+```
+
+On ne fait que rajouter des fichiers dans la zone d'index, on ne valide pas
+les changements au répertoire/dépôt de travail.
+
+### branch
+
+Gère vos branches. Vous pouvez voir, éditer, créer et supprimer des branches en
+utilisant cette commande.
+
+```bash
+# Liste les branches existantes et distantes
+$ git branch -a
+
+# Créé une nouvelle branche
+$ git branch maNouvelleBranche
+
+# Supprime une branche
+$ git branch -d maBranche
+
+# Renomme une branche
+# git branch -m <anciennom> <nouveaunom>
+$ git branch -m nomDeMaBranche nouveauNomDeMaBranche
+
+# Edite la description d'une branche
+$ git branch nomDeMaBranche --edit-description
+```
+
+### tag
+
+Gère vos étiquettes
+
+```bash
+# Liste les étiquettes
+$ git tag
+
+# Créé une étiquette annotée
+# L'option -m spécifie un message qui sera stockée dans l'étiquette.
+# Si vous ne spécifiez pas de message pour une étiquette annotée,
+# Git lance votre éditeur pour que vous puissiez le saisir.
+$ git tag -a v2.0 -m 'ma version 2.0'
+
+# Affiche des informations à propos de l'étiquette
+# comprenant des informations sur l'auteur, la date du commit correspondant,
+# et le message d'annotation avant d'afficher les informations du commit.
+$ git show v2.0
+
+# Pousse une seule étiquette dans le dépôt distant
+$ git push origin v2.0
+
+# Pousse beaucoup d'étiquettes dans le dépôt distant
+$ git push origin --tags
+```
+
+### checkout
+
+Met à jour tous les fichiers dans l'arbre de travail afin de correspondre à la
+version de la zone d'index ou de l'arbre spécifié.
+
+```bash
+# Obtenir une copie de travail du dépôt - par défaut on prend la branche master
+$ git checkout
+
+# Bascule vers une branche spéficiée
+$ git checkout nomDeLaBranche
+
+# Créé une nouvelle branche et bascule sur celle-ci
+# Revient à faire "git branch <name>; git checkout <name>"
+$ git checkout -b nouvelleBranche
+```
+
+### clone
+
+Clone (ou copie) un dépôt existant dans un nouveau répertoire. Rajoute
+également les branches distantes pour chaque branche du dépôt clôné, ce qui
+vous permet de pousser vers une branche distante.
+
+```bash
+# Clone learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+
+# Clone superficiel ("shallow clone") - clone plus rapide qui récupère
+seulement le dernier instantané ("snapshot")
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+
+# Clone seulement une branche spécifique
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
+```
+
+### commit
+
+Conserve le contenu actuel de la zone d'index dans un nouveau "commit." Ce
+commit contient les changements faits, accompagnés d'un message écrit par son
+auteur.
+
+```bash
+# Commit avec un message
+$ git commit -m "Ajout de la fonction multiplierNombres() dans HelloWorld.c"
+
+# Rajoute automatiquement dans l'index les fichiers modifiés ou supprimés,
+# à l'exception des nouveaux fichiers, puis commit
+$ git commit -a -m "Modification de foo.php et suppression de bar.php"
+
+# Change le dernier commit (ceci supprime le commit précédent avec un
+# nouveau commit)
+$ git commit --amend -m "Message corrigé"
+```
+
+### diff
+
+Montre les différences entre un fichier dans le répertoire de travail, la zone
+d'index and les commits.
+
+```bash
+# Affiche les différences entre votre répertoire de travail et l'index
+$ git diff
+
+# Affiche les différences entre l'index et le plus récent commit.
+$ git diff --cached
+
+# Affiche les différences entre votre répertoire de travail et le plus récent
+# commit
+$ git diff HEAD
+```
+
+### grep
+
+Permet de faire une recherche rapide dans le dépôt.
+
+Configurations optionnelles :
+
+```bash
+# Merci à Travis Jeffery pour ce qui suit
+# Affiche les numéros des lignes dans les résultats de la recherche grep
+$ git config --global grep.lineNumber true
+
+# Rend les résultats de recherche plus lisibles, en incluant les groupements
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Recherche de "nomDeVariable" dans tous les fichiers java
+$ git grep 'nomDeVariable' -- '*.java'
+
+# Recherche une ligne contenant "nomDeTableau", et "rajouter" ou "enlever"
+$ git grep -e 'nomDeTableau' --and \( -e rajouter -e enlever \)
+```
+
+Google est votre ami; pour plus d'exemples :
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Affiche les commits d'un dépôt.
+
+```bash
+# Montre tous les commits
+$ git log
+
+# Montre seulement les messages de commits et leur référence
+$ git log --oneline
+
+# Montre seulement les commits commits des merges (fusions)
+$ git log --merges
+```
+
+### merge
+
+Fusionne les changements provenant de commits externes dans la branche
+courante.
+
+```bash
+# Fusionne la branche spécifiée dans la branche courante.
+$ git merge nomDeBranche
+
+# Génère toujours un commit quand on fusionne
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Renomme ou déplace un fichier
+
+```bash
+# Renomme un fichier
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Déplace un fichier
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Force le renommage ou le déplacement
+# Si "fichierExistant" existe déjà dans le répertoire, il sera écrasé
+$ git mv -f monFichier fichierExistant
+```
+
+### pull
+
+Récupère la version d'un dépôt et la fusionne avec une autre branche.
+
+```bash
+# Met à jour votre dépôt local en y intégrant les changements
+# depuis la branche "master" du dépôt distant "origin".
+# git pull <remote> <branch>
+$ git pull origin master
+
+# Par défaut, git pull mettra à jour votre branche actuelle
+# en y intégrant les nouveaux changements venant de sa branche distante suivie
+$ git pull
+
+# Intègre les changements de la branche distante et "rebase"
+# les commits de la branche dans votre dépôt local, comme ceci:
+#"git pull <remote> <branch>, git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Pousse et fusionne les changements d'une dépôt local vers une branche distante.
+
+```bash
+# Pousse et fusionne les changements d'un dépôt local vers la branche
+# appelée "master" du dépôt distant "master".
+# git push <remote> <branch>
+$ git push origin master
+
+# Par défaut, git push poussera et fusionnera les changements de la branche
+# courante vers sa branche distante suivie.
+$ git push
+
+# Pour faire le lien entre la branche locale courante et sa branche distante,
+# rajouter l'option -u :
+$ git push -u origin master
+# Dorénavant, à chaque fois que vous voulez pousser depuis cette même branche
+# locale, utilisez ce raccourci :
+$ git push
+```
+
+### stash
+
+Sauvegarde ("stash") l'état actuel de votre espace de travail et le garde dans
+pile de changements non finis que vous pouvez réappliquer n'importe quand.
+
+Supposons que vous avez effectué du travail dans votre dépôt git, mais que vous
+voulez récupérer la version de la branche distante. Depuis que vous avez des
+changements "malpropres" (non commités) à quelques fichiers, vous ne pouvez pas
+faire de `git pull`. A la place, vous pouvez utiliser `git stash` afin de
+sauvegarder votre travail dans la pile !
+
+```bash
+$ git stash
+Saved working directory and index state \
+  "WIP on master: 049d078 added the index file"
+  HEAD is now at 049d078 added the index file
+  (To restore them type "git stash apply")
+```
+
+Vous pouvez maintenant pull !
+
+```bash
+git pull
+```
+`...changes apply...`
+
+Vérifiez maintenant que tout est OK
+
+```bash
+$ git status
+# On branch master
+nothing to commit, working directory clean
+```
+
+Vous pouvez constater quels "morceaux" vous avez stash jusque là en
+utilisant `git stash list`.
+Puisque les changements sont gardés dans une pile Last-In-First-Out, notre
+changement le plus récent sera en premier.
+
+```bash
+$ git stash list
+stash@{0}: WIP on master: 049d078 rajout du fichier index
+stash@{1}: WIP on master: c264051 annulation de "rajout de la taille_fichier"
+stash@{2}: WIP on master: 21d80a5 ajout des chiffres aux logs
+```
+
+Appliquons maintenant les changements en les enlevant de notre pile.
+
+```bash
+$ git stash pop
+# On branch master
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   index.html
+#      modified:   lib/simplegit.rb
+#
+```
+
+`git stash apply` effectue le même travail
+
+Vous êtes maintenant prêt à retourner sur vos tâches de travail !
+
+[Lecture additionelle.](https://git-scm.com/book/fr/v1/Utilitaires-Git-Le-remisage)
+
+### rebase (attention)
+
+Prend tous les changements qui ont été commités sur une branche, et les
+ré-applique sur une autre branche.
+*Ne rebasez pas les commits que vous avez poussés sur un dépôt publique*.
+
+```bash
+# Expérimentation d'un rebase dans la branche "master"
+# git rebase <basebranch> <topicbranch>
+$ git rebase master brancheExperience
+```
+
+[Lecture additionelle.](https://git-scm.com/book/fr/v1/Les-branches-avec-Git-Rebaser)
+
+### reset (attention)
+
+Réinitialise le pointeur HEAD courant à l'état spécifié. Ceci vous permet
+d'annuler des fusions, des pulls, commits, ajouts et autres. C'est une commande
+puissante mais également dangereuse si vous ne savez pas ce que vous faites.
+
+```bash
+# Réinitialise la zone d'index afin de correspondre au dernier commit (laisse
+# le répertoire inchangé).
+$ git reset
+
+# Réinitialise la zone d'index afin de correspondre au dernier commit et
+# réécrit le répertoire de travail.
+$ git reset --hard
+
+# Déplace le pointeur de la branche courante au commit spécifié (laisse
+# le répertoire inchangé). Tous les changements existents toujours dans
+# le répertoire.
+$ git reset 31f2bb1
+
+# Déplace le pointeur de la branche courante en arrière, au commit spécifié
+# et fait correspondre le répertoire de travail (supprime les changements
+# non commités et tous les commits après le commit spécifié).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Le contraire de git add, git rm supprime les fichiers de l'arbre de travail
+courant.
+
+```bash
+# Supprime HelloWorld.c
+$ git rm HelloWorld.c
+
+# Enlève un fichier d'un répertoire imbriqué.
+$ git rm /chemin/vers/le/fichier/HelloWorld.c
+```
+
+## Informations complémentaires
+
+* [tryGit - A fun interactive way to learn Git (EN)](http://try.github.io/levels/1/challenges/1)
+
+* [Udemy Git Tutorial: A Comprehensive Guide (EN)](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
+
+* [git-scm - Tutoriaux vidéos](http://git-scm.com/videos)
+
+* [git-scm - Documentation](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutoriaux et Workflows](https://www.atlassian.com/git/)
+
+* [SalesForce Cheat Sheet (EN)](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys (EN)](http://www.gitguys.com/)
+
+* [Git - the simple guide (EN)](http://rogerdudler.github.io/git-guide/index.html)
+
+* [Livre Pro Git](http://www.git-scm.com/book/fr/v1)
+
+* [Une introduction à Git et GitHub pour les débutants (tutoriel) (EN)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/fr-fr/haskell.html.markdown b/fr-fr/haskell.html.markdown
index d9d3151f..a34dc098 100644
--- a/fr-fr/haskell.html.markdown
+++ b/fr-fr/haskell.html.markdown
@@ -66,7 +66,7 @@ not False -- True
 
 
 ----------------------------------------------------
--- Listes et tuples
+-- 2. Listes et tuples
 ----------------------------------------------------
 
 -- Tous les éléments d'une liste doit avoir le même type.
diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index f1977dac..faa22863 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -190,7 +190,7 @@ someNinthVar; // = 9
 
 // Il y a des raccourcis pour les opérations mathématiques:
 someVar += 5; // équivalent pour someVar = someVar + 5;
-someVar *= 10; // de même, someVar = someVar * 100;
+someVar *= 10; // de même, someVar = someVar * 10;
 someVar++;    // = someVar += 1;
 someVar--;  // = someVar -= 1;
 
diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown
new file mode 100644
index 00000000..1842e02b
--- /dev/null
+++ b/fr-fr/jquery-fr.html.markdown
@@ -0,0 +1,142 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+    - ["Sylvain Vaure", "https://github.com/Gnomino"]
+filename: jquery-fr.js
+lang: fr-fr
+---
+
+jQuery est une bibliothèque JavaScript dont le but est de permettre de "faire plus en écrivant moins" (do more, write less). Elle facilite l'écriture de nombreuses fonctions, notamment au niveau d'AJAX, de la gestion d'événements, ou encore de la manipulation de documents. 
+C'est pourquoi aujourd'hui, jQuery est utilisée par de nombreuses grandes entreprises et par des développeurs du monde entier.
+
+Étant donné que jQuery est une bibliothèque JavaScript, vous devriez d'abord [apprendre le JavaScript](https://learnxinyminutes.com/docs/fr-fr/javascript-fr/)
+```js
+
+
+///////////////////////////////////
+// 1. Les sélecteurs
+
+// On utilise les sélecteurs de jQuery pour sélectionner des éléments
+var page = $(window); // Sélectionne tout le viewport
+
+// On peut aussi utiliser des sélecteurs CSS
+var paragraph = $('p'); // Sélectionne tous les éléments paragraphes
+var table1 = $('#table1'); // Sélectionne l'élément qui a l'id 'table1'
+var squares = $('.square'); // Sélectionne tous les éléments avec la classe 'square'
+var square_p = $('p.square') // Sélectionne tous les paragraphes avec la classe 'square'
+
+
+///////////////////////////////////
+// 2. Événements et effets
+// jQuery gère très bien ce qui se passe lorsqu'un événement est déclenché
+// L'événement 'ready' est très souvent utilisé sur le document
+// On utilise la méthode 'ready' pour attendre que l'élément ait fini de se charger
+$(document).ready(function(){
+  // Ce code ne s'exécutera pas avant que le document soit chargé (prêt)
+});
+// On peut aussi utiliser des fonctions définies
+function onAction() {
+  // Ceci est exécuté quand l'événement est déclenché
+}
+$('#btn').click(onAction); // Appelle onAction à chaque clic
+
+function onAction() {
+  // Ceci est exécuté quand un évènement est déclenché
+}
+
+// D'autres évènements communs :
+$('#btn').dblclick(onAction); // Double clic
+$('#btn').hover(onAction); // Survol de la souris
+$('#btn').focus(onAction); // Gain du focus
+$('#btn').blur(onAction); // Perte du focus
+$('#btn').submit(onAction); // Envoi (d'un formulaire)
+$('#btn').select(onAction); // Quand un élement est sélectionné
+$('#btn').keydown(onAction); // Quand une touche est enfoncée
+$('#btn').keyup(onAction); // Quand une touche est relâchée
+$('#btn').keypress(onAction); // Quand on appuie sur un touche
+$('#btn').mousemove(onAction); // Quand la souris se déplace
+$('#btn').mouseenter(onAction); // La souris entre dans l'élément
+$('#btn').mouseleave(onAction); // La souris sort de l'élément
+
+// On peut aussi utiliser des fonctions lambdas
+$('#btn').hover(function(){
+  // exécuté lors d'un survol de la souris
+});
+
+// Il est possible de déclencher l'événement sans le gérer
+// simplement en ne passant aucun paramètre à la méthode
+$('#btn').dblclick(); // Simule un double clic sur l'élément
+
+// On peut gérer plusieurs événements en utilisant le sélecteur une seule fois
+$('#btn').on(
+  {dblclick: myFunction1} // Déclenché à chaque double clic
+  {blur: myFunction1} // Déclenché quand l'élément perd le focus
+);
+
+// On peut déplacer et cacher des éléments grâce à des fonctions d'effets
+$('.table').hide(); // Cache le(s) élément(s)
+
+// Note: même avec un appel à une fonction dans ces méthodes 
+// cache quand même l'élément
+$('.table').hide(function(){
+    // L'élément est caché, puis la fonction est exécutée
+});
+
+// On peut stocker des sélecteurs dans des variables
+var tables = $('.table');
+
+// Des méthodes basique de manipulation de document :
+tables.hide(); // Cache un(des) élément(s)
+tables.show(); // Montre (dé-cache) un(des) élément(s)
+tables.toggle(); // Change le statut le statut caché/montré
+tables.fadeOut(); // Fait disparaître l'élément
+tables.fadeIn(); // Fait apparaître l'élément
+tables.fadeToggle(); // Fait apparaître ou disparaître
+tables.fadeTo(0.5); // Fondu jusqu'à une certaine opacité (entre 0 et 1)
+tables.slideUp(); // Cache l'élément avec un effet de glissement vers le haut
+tables.slideDown(); // Fait apparaître l'élément avec un glissement vers le bas
+tables.slideToggle(); // Cache/Montre l'élément avec un effet de glissement
+
+// Les méthodes ci-dessus prennent en arguments 
+// une vitesse (millisecondes) et une function callback
+tables.hide(1000, myFunction); // Animation d'une seconde, puis appel à la fonction
+
+// fadeTo doit avoir une opacité entre 0 et 1 comme deuxième argument
+tables.fadeTo(2000, 0.1, myFunction); // 2 sec. fade to 0.1 opacity then function
+
+// La méthode animate permet des animations légèrement plus poussées
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// La méthode prend un objet de css et de valeurs finales,
+// des paramètres d'options facultatifs pour régler l'animation,
+// et bien sûr la fonction callback
+
+///////////////////////////////////
+// 3. Manipulation
+
+// Ces méthodes sont similaires aux effets mais permettent d'aller plus loin
+$('div').addClass('taming-slim-20'); // Ajoute la classe taming-slim-20 aux div 
+
+// Méthodes ordinaires de manipulation
+$('p').append('Hello world'); // Ajoute à la fin de l'élément
+$('p').attr('class'); // Renvoie la valeur de l'attribut
+$('p').attr('class', 'content'); // Change la valeur de l'attribut
+$('p').hasClass('taming-slim-20'); // Renvoie vrai si l'élément est de la classe
+$('p').height(); // Renvoie la hauteur de l'élément ou la change
+
+
+// Pour beaucoup de méthodes de manipulation, récupérer des informations
+// d'un élément renverra SEULEMENT ceelles du premier
+$('p').height(); // Renvoie SEULEMENT la hauteur du premier élément 'p'
+
+// On peut utiliser 'each' pour parcourir tous les éléments
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Ajoute la hauteur de tous les éléments 'p' à la liste
+});
+
+
+``
+
diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 5a1e03e7..48d24549 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,9 +1,9 @@
 ---
 language: make
 contributors:
-	- ["Robert Steed", "https://github.com/robochat"]
+    - ["Robert Steed", "https://github.com/robochat"]
 translators:
-	- ["altaris", "https://github.com/altaris"]
+    - ["altaris", "https://github.com/altaris"]
 filename: Makefile-fr
 lang: fr-fr
 ---
diff --git a/fr-fr/markdown.html.markdown b/fr-fr/markdown.html.markdown
index 66f0efbe..2e4e8461 100644
--- a/fr-fr/markdown.html.markdown
+++ b/fr-fr/markdown.html.markdown
@@ -62,8 +62,8 @@ __Celui-là aussi.__
 **_Pareil ici_**
 *__Et là!__*
 
-<!-- Dans le "Github Flavored Markdown", utilisé pour interpréter le Markdown 
-sur Github, on a également le strikethrough ( texte barré ) : -->
+<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown 
+sur GitHub, on a également le strikethrough ( texte barré ) : -->
 
 ~~Ce texte est barré avec strikethrough.~~
 
@@ -172,7 +172,7 @@ fonctionne aussi à l'intérieur du bloc de code -->
 
 La fonction `run()` ne vous oblige pas à aller courir!
 
-<!-- Via Github Flavored Markdown, vous pouvez utiliser 
+<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
 des syntaxes spécifiques -->
 
 \`\`\`ruby 
@@ -183,7 +183,7 @@ puts "Hello world!"
 end
 \`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
 
-<-- Pas besoin d'indentation pour le code juste au dessus, de plus, Github 
+<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
 va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
 
 <!-- Ligne Horizontale (<hr />) -->
@@ -264,7 +264,7 @@ Pour taper *ce texte* entouré d'astérisques mais pas en italique :
 Tapez \*ce texte\*.
 
 <!-- Tableaux -->
-<!-- les Tableaux ne sont disponibles que dans le Github Flavored Markdown
+<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
  et c'est ce n'est pas super agréable d'utilisation. 
  Mais si vous en avez besoin :
  -->
diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index 4e31c4bf..fbe1741e 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -1,5 +1,4 @@
 ---
-
 language: Objective-C
 contributors:
     - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
@@ -9,7 +8,6 @@ translators:
     - ["Yannick Loriot", "https://github.com/YannickL"]
 filename: LearnObjectiveC-fr.m
 lang: fr-fr
-
 ---
 
 L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
@@ -519,6 +517,7 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es
 // l'objet est supprimé
 
 ```
+
 ##  Lectures Complémentaires
 
 [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C)
diff --git a/fr-fr/ruby-ecosystem-fr.html.markdown b/fr-fr/ruby-ecosystem-fr.html.markdown
new file mode 100644
index 00000000..edc69068
--- /dev/null
+++ b/fr-fr/ruby-ecosystem-fr.html.markdown
@@ -0,0 +1,155 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+    - ["Jon Smock", "http://github.com/jonsmock"]
+    - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+    - ["Xuan-thi Nguyen", "http://github.com/mellenguyen"]
+    - ["Sylvain Abélard", "http://github.com/abelards"]
+lang: fr-fr
+
+---
+
+Les gens utilisant Ruby adoptent généralement un gestionnaire pour installer
+différentes versions de Ruby, gérer leurs paquets (ou gems), et gérer les
+dépendances des gems.
+
+## Ruby Managers
+
+Quelques plateformes possèdent Ruby pré-installé ou disponible en tant que
+paquet. La plupart des rubyistes ne les utilisent pas, ou si c'est le cas, ne
+les utilisent que pour faire démarrer un autre installateur ou implémentation de
+Ruby. Les rubyistes tendent plutôt à installer un gestionnaire en Ruby pour installer
+et changer entre les différentes et nombreuses versions de Ruby et les
+environnements de leurs projets Ruby.
+
+Les gestionnaires d'environnement Ruby les plus populaires sont :
+
+* [RVM](https://rvm.io/) - Installe et navigue entre les rubies. RVM possède
+  églement le concept des gemsets pour isoler les environnements de projets
+  complètement.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Installe seulement
+  les rubies. Utilisez-le pour un contrôle plus fin des installations des
+  rubies.
+* [rbenv](https://github.com/sstephenson/rbenv) - Navigue seulement entre les
+  rubies. Utilisé avec ruby-build. Utilisez-le pour un contrôle plus fin des
+  chargements des rubies.
+* [chruby](https://github.com/postmodern/chruby) - Navigue seulement entre les
+  rubies. Similaire à rbenv. Neutre sur comment les rubies sont installés.
+
+## Versions de Ruby
+
+Ruby a été créé par Yukihiro "Matz" Matsumoto, qui reste quelque peu un
+[BDFL](https://fr.wikipedia.org/wiki/Benevolent_Dictator_for_Life), bien que
+cela soit récemment en changement. Jusqu'à la standardisation du langage en
+2011, l'implémentation de référence de Ruby était appelé MRI (Matz' Reference
+Implementation).
+
+Les trois versions majeures de Ruby actuellement utilisées sont :
+
+* 2.0.0 - Sortie en février 2013. La plupart des bibliothèques et frameworks
+  gèrent la versions 2.0.0.
+* 1.9.3 - Sortie en octobre 2011. Il s'agit de la version que la majorité des
+  rubyists utilisent actuellement. [Fin de vie](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
+* 1.8.7 - Sortie en juin 2006. [Fin de vie](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+Les changements entre 1.8.7 et 1.9.x sont bien plus grands qu'entre 1.9.3
+et 2.0.0. Par exemple, les versions 1.9 ont introduit le support des
+encodages et d'une VM bytecode ([YARV](https://fr.wikipedia.org/wiki/YARV)).
+Il y a toujours des projets sur 1.8.7, mais ils deviennent minoritaires, étant
+donné que la majorité de la communauté a migré vers au moins 1.9.2 ou 1.9.3.
+
+## Implémentations Ruby
+
+L'écosystème Ruby comprend de nombreuses implémentations de Ruby, chacune avec
+des points forts uniques et différents degrés de compatibilité. Les différentes
+implémentations sont écrites dans différents languages.
+Chaque implémentation a des "hooks" et des fonctionnalités spécifiques, elles
+exécutent cependant très bien des fichiers Ruby classiques.
+Par exemple, JRuby est écrit en Java, mais vous n'avez pas besoin de connaître
+le Java pour l'utiliser.
+
+Très mature/compatible:
+
+* [MRI](https://github.com/ruby/ruby) - Ecrite en C, c'est l'implémentation de
+  référence de Ruby. Elle est par définition 100% compatible (avec elle-même).
+  Tous les autres rubies maintiennent la compatibilité avec MRI
+  (voir [RubySpec](#rubyspec) à la suite).
+* [JRuby](http://jruby.org/) - Écrite en Java et Ruby, cette robuste
+  implémentation est assez rapide.
+  La force de JRuby réside surtout sur l'interopérabilité JVM/Java, faisant
+  levier sur des outils JVM, des projets et des langages existants.
+* [Rubinius](http://rubini.us/) - Ecrite principalement en Ruby avec une VM
+  bytecode en C++. Egalement mature et rapide. Etant donné qu'elle est
+  implémentée en Ruby, elle couvre beaucoup de fonctionnalités de la
+  VM dans Ruby.
+
+Mpyennement mature/compatible:
+
+* [Maglev](http://maglev.github.io/) - Basée sur Gemstone, une VM Smalltalk.
+  Smalltalk possède quelques outils impressionnants, et ce projet tente
+  de les apporter dans le développement Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Ruby pour développement iOS et Android.
+* [Opal](http://opalrb.org/) - Compile le Ruby en Javascript
+
+Les implémentations de Ruby peuvent avoir leurs propres numéros de versions,
+mais elles ciblent toujours une versions spéficique de MRI pour la
+compatibilité.
+Beaucoup d'implémentations ont la capacité d'entrer dans différents modes
+(par exemple, la version 1.8 ou 1.9) afin de spécifier quelle version de MRI
+cibler.
+
+Une liste non exhaustive d'implémentations peut être trouvée [ici (EN)](https://github.com/cogitator/ruby-implementations/wiki/List-of-Ruby-implementations).
+
+## RubySpec
+
+La plupart des implémentations Ruby s'appuient fortement sur [RubySpec](http://rubyspec.org/).
+Ruby n'a pas de spécification officielle, c'est pourquoi la commaunité a écrit
+des spécifications exécutables en Ruby pour tester la compatibilité de leur
+implémentation avec MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) est un gestionnaire de paquets communautaire
+pour Ruby.
+RubyGems est livré avec Ruby, il n'y a donc pas besoin de le télécharger
+séparément.
+
+Les paquets Ruby sont appelés des "gems", et peuvent être hébergés par la
+communauté à RubyGems.org. Chaque gem contient son code source et quelques
+métadatas, includant des choses comme la version, les dépendances,
+l(es) auteur(s) et la/les licence(s).
+
+## Bundler
+
+[Bundler](http://bundler.io/) est un outil de résolution de dépendances des gems. Il
+utilise le Gemfile d'un projet pour en trouver les dépendances, et récupère
+ensuite les dépendances de ces dépendances récursivement. Il déroule cet
+algorithme jusqu'à ce que toutes les dépendances soient résolues et
+téléchargées, ou s'arrête si un conflit est trouvé.
+
+Bundler lèvera une erreur s'il trouve des conflits de dépendances. Par exemple,
+si la gem A recquiert la version 3 ou plus de gem Z, mais que gem B recquiert
+seulement la version 2 de la même gem Z, Bundler vous notifiera ce conflit. Cela devient
+extrêmement utile, étant donné que beaucoup de gems font référence à d'autres
+gems (qui se réfèrent à d'autres gems et ainsi de suite), ce qui peut former un large graphe de
+dépendance à résoudre.
+
+# Les tests
+
+Tester fait partie intégrante de la culture Ruby. Ruby fournit son propre
+framework de tests unitaires appelé minitest (ou TestUnit pour Ruby
+version 1.8.x). Il existe beaucoup de librairies de tests avec des buts
+différents.
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Framework de tests intégré de Ruby version 1.8 style "Unit"
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Framework de tests intégré de Ruby version 1.9/2.0
+* [RSpec](http://rspec.info/) - Un framework de tests qui se focalise sur l'expressivité
+* [Cucumber](http://cukes.info/) - Un framework de tests BDD ([behaviour-driven development](https://fr.wikipedia.org/wiki/Behavior_driven_development)) qui parse les tests formatés de Gherkin.
+
+## Soyez gentil
+
+La communauté Ruby est fière d'être une communauté ouverte, riche et
+accueillante. Matz lui-même est extrêmement sociable, et la générosité des
+rubyistes est généralement remarquable.
diff --git a/fr-fr/ruby-fr.html.markdown b/fr-fr/ruby-fr.html.markdown
index 1564d2b6..6b487a07 100644
--- a/fr-fr/ruby-fr.html.markdown
+++ b/fr-fr/ruby-fr.html.markdown
@@ -7,9 +7,11 @@ contributors:
   - ["Luke Holder", "http://twitter.com/lukeholder"]
   - ["Tristan Hume", "http://thume.ca/"]
   - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+
 translators:
   - ["Geoffrey Roguelon", "https://github.com/GRoguelon"]
   - ["Nami-Doc", "https://github.com/Nami-Doc"]
+  - ["Sylvain Abélard", "http://github.com/abelards"]
 lang: fr-fr
 ---
 
@@ -22,19 +24,23 @@ Personne ne les utilise
 Vous devriez en faire de même
 =end
 
-# Tout d'abord : Tout est un objet.
+# Tout d'abord : tout est un objet.
 
 # Les nombres sont des objets
 
-3.class #=> Fixnum
+3.class #=> Fixnum # on voit que c'est une classe Ruby et non un "type spécial"
 
-3.to_s #=> "3"
+3.to_s #=> "3" # on peut appeler des méthodes sur ces objets, comme `to_s` (transforme en texte)
 
 # Les opérateurs de base
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
-35 / 5 #=> 7
+22 / 7 #=> 3 # si les deux éléments sont entiers, c'est une division entière
+22.0 / 7 #=> 3.142857142857143
+22 / 7.0 #=> 3.142857142857143
+2**10 #=> 1024 # exposant
+1024 % 10 #=> 4 # modulo (reste de la division euclidienne)
 
 # Les opérateurs sont juste des raccourcis
 # pour appeler une méthode sur un objet
@@ -42,9 +48,9 @@ Vous devriez en faire de même
 10.* 5 #=> 50
 
 # Les valeurs spéciales sont des objets
-nil # Nul
-true # Vrai
-false # Faux
+nil # nul, vide ou indéfini
+true # vrai
+false # faux
 
 nil.class #=> NilClass
 true.class #=> TrueClass
@@ -60,8 +66,7 @@ false.class #=> FalseClass
 !true  #=> false
 !false #=> true
 
-# à part false lui-même, nil est la seule autre valeur 'false'
-
+# à part false lui-même, nil est la seule autre valeur "considérée comme fausse"
 !nil   #=> true
 !false #=> true
 !0     #=> false
@@ -73,7 +78,6 @@ false.class #=> FalseClass
 2 >= 2 #=> true
 
 # Les chaînes de caractères sont des objets
-
 'Je suis une chaîne de caractères'.class #=> String
 "Je suis également une chaîne de caractères".class #=> String
 
@@ -84,6 +88,15 @@ placeholder = "utiliser l'interpolation de chaîne de caractères"
 # Affichez un message
 puts "J'affiche à l'écran!"
 
+# Il y a quelques autres raccourcis pour les chaînes de caractères
+rb = "Ruby"
+interpolation = "Bonjour Ruby" # s'écrit aussi %Q[Bonjour #{rb}] %Q{Bonjour #{rb}} avec l'interpolation
+literal = "Bonjour \#{rb}" # avec le backslash, le dièse est un "vrai dièse" (le slash ne s'affiche que pour le debug)
+literal == %q[Bonjour #{rb}] # le Q majuscule fait l'interpolation, le q minuscule ne la fait pas
+multi = %Q[Cette chaîne
+est sur plusieurs
+lignes] # => "Cette chaîne\nest sur plusieurs\nlignes" # le caractère \n signifie retour à la ligne
+
 # Variables
 x = 25 #=> 25
 x #=> 25
@@ -131,7 +144,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 [1, "hello", false] #=> [1, "hello", false]
 
 # Les tableaux peuvent être indexés
-# Du début
+# Trouver la valeur en donnant la position en partant du début (le premier élément est à l'index 0)
 array[0] #=> 1
 array[12] #=> nil
 
@@ -140,13 +153,13 @@ array[12] #=> nil
 array.[] 0 #=> 1
 array.[] 12 #=> nil
 
-# Depuis la fin
+# On peut compter en partant de la fin avec un index négatif (le dernier élément est à l'index -1)
 array[-1] #=> 5
 
-# Avec un index de début et de fin
-array[2, 4] #=> [3, 4, 5]
+# Avec un index de début et un nombre d'éléments [position, nombre]
+array[1, 3] #=> [2, 3, 4]
 
-# Ou avec un intervalle
+# Ou avec un intervalle [index de début .. index de fin]
 array[1..3] #=> [2, 3, 4]
 
 # Ajoutez un élément au tableau comme ceci
@@ -180,11 +193,11 @@ new_hash.keys #=> [:defcon, :action]
 # Structures de contrôle
 
 if true
-  "si instruction"
+  "si l'instruction est vraie"
 elsif false
-  "autrement si, facultatif"
+  "si l'instruction de départ n'était pas vraie, et que cette nouvelle condition est vraie (facultatif)"
 else
-  "autrement, également facultatif"
+  "tous les autres cas (il est également facultatif de faire une clause else)"
 end
 
 for compteur in 1..5
diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown
new file mode 100644
index 00000000..b3675f5b
--- /dev/null
+++ b/fr-fr/rust-fr.html.markdown
@@ -0,0 +1,318 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+    - ["Ryan Rembert", "http://jrrembert.github.io"]
+filename: learnrust-fr.rs
+lang: fr-fr
+---
+
+Rust est un langage de programmation développé par Mozilla Research. Rust combine le contrôle de bas niveau sur la performance avec la commodité et la sécurité garanties de haut niveau.
+
+Il atteint ces objectifs sans avoir besoin d'un ramasse-miettes ou environnement d'exécution, ce qui rend possible l'utilisation de bibliothèques Rust comme une substitution directe pour C.
+
+La première version de Rust, 0.1, est sortie en janvier 2012 et a tellement évolué rapidement que jusqu'à récemment, l'utilisation de versions stables était déconseillée - à la place ce était conseillé d'utiliser les nightly builds.
+
+Le 15 mai 2015, Rust 1.0 a été libéré avec une garantie complète de compatibilité ascendante. Améliorations aux temps de compilation et d'autres aspects du compilateur sont actuellement disponibles dans la nightly builds. Rust a adopté un modèle de train de livraison avec les versions régulières toutes les six semaines. Rust 1.1 beta a été mis à disposition au moment de la livraison de Rust 1.0.
+
+Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts fonctionnels qui se trouvent généralement dans les langues de niveau supérieur. Cela rend Rust non seulement rapide, mais aussi efficace et facile à coder.
+
+```rust
+// Ceci est un commentaire. Les commentaires de ligne ressemblent à ceci...
+// et continuent sur plusieurs lignes comme cela.
+
+/// Les commentaires de documentation ressemblent à ça et supportent la
+/// syntaxe Markdown.
+/// # Exemples
+///
+/// ```
+/// let cinq = 5
+/// ```
+
+///////////////
+// 1. Basics //
+///////////////
+
+// Les fonctions
+// `I32` est le type 32 bits entiers signés
+fn add2(x: i32, y: i32) -> i32 {
+    // Retour implicite (pas de point virgule)
+    x + y
+}
+
+// Fonction principale
+fn main() {
+    // Nombres //
+
+    // Liaison immutable
+    let x: i32 = 1;
+
+    // Suffixes entiers et flottants
+    let y: I32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inférence de type
+    // La plupart du temps, le compilateur Rust peut déduire quel est le type 
+    // de variable, donc vous n'avez pas à écrire une annotation de type explicite.
+    // Tout au long de ce tutoriel, les types sont explicitement annotées dans
+    // de nombreux endroits, mais seulement à des fins de démonstration.
+    // L'inférence de type peut les générer pour vous la plupart du temps.
+    let implicit_x = 1;
+    let implicit_f = 1,3;
+
+    // Arithmétique
+    let somme = x + y + 13;
+
+    // Variable Mutable
+    let mut mutable = 1;
+    let mutable = 4;
+    let mutable += 2;
+
+    // Chaînes //
+
+    // Chaîne littérales
+    let x: &str = "Bonjour tout le monde !";
+
+    // Affichage
+    println!("{} {}", f, x); // 1.3 Bonjour tout le monde
+
+    // Une `Chaîne` - une chaîne de tas alloué
+    let s: String = "Bonjour tout le monde".to_string();
+
+    // Un morceau de chaîne - une vue immutable sur une autre chaîne.
+    // C'est essentiellement un pointeur immutable sur une chaîne - ça ne
+    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
+    // le début et la fin de la chaîne.
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
+
+    // Vecteurs/tableau //
+
+    // Un tableau de taille fixe
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Un tableau dynamique(vecteur)
+    let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
+    vecteur.push(5);
+
+    // Une tranche - une vue immutable sur un vecteur ou un tableau.
+    // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
+    let tranche: &[i32] = &vecteur;
+
+    // Utiliser `{:?}` pour afficher quelque chose en mode debug
+    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuples //
+
+    // Un tuple est un ensemble de valeurs qui peuvent être de différents types.
+    let x:(i32, &str, f64) = (1, "bonjour", 3.4);
+
+    // Déstructurer `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 bonjour 3.4
+
+    // indexation
+    println!("{}", x.1); // Bonjour
+
+    //////////////
+    // 2. Types //
+    //////////////
+
+    // Struct
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origine: Point = Point { x: 0, y: 0 };
+
+    // Un struct avec des champs sans nom, appelé 'tuple struct'.
+    struct Point2(i32, i32);
+
+    let origine2 = Point2(0, 0);
+
+    // Basic C-like enum
+    enum Direction {
+        Àgauche,
+        Droite,
+        En_Haut,
+        Vers_Le_Bas,
+    }
+
+    let en_haut = Direction::En_Haut;
+
+    // Enum avec des champs
+    enum OptionnelI32 {
+        AnI32(I32),
+        Rien,
+    }
+
+    let deux: OptionnelI32 = OptionnelI32::AnI32(2);
+    let rien = OptionnelI32::Rien;
+
+    // Generics //
+
+    struct Foo<T> { bar: T }
+
+    // Ceci est défini dans la bibliothèque standard comme `Option`.
+    enum Optionnel<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Méthodes //
+
+    impl<T> Foo<T> {
+        // Méthodes prennent un paramètre explicite `de self`.
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Traits (connu sous le nom des interfaces ou des classes de types dans
+    // d'autres langues).
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    /////////////////////////
+    // 3. Motif correspondant //
+    /////////////////////////
+
+    let foo = OptionnelI32::AnI32(1);
+    match foo {
+        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
+        OptionnelI32::Rien     => println!("Il n'y a rien!"),
+    }
+
+    // Motif avancé correspondant
+    struct FooBar { x: i32, y: OptionnelI32 }
+    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
+            println!("Les chiffres sont nuls!"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
+            println!("Les chiffres sont les mêmes"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
+            println!("Différents numéros: {} {}", n, m)!,
+        FooBar { x: _, y: OptionnelI32 :: Rien} =>
+            println!("Le deuxième numéro est rien!"),
+    }
+
+    /////////////////////
+    // 4. Flux de contrôle //
+    /////////////////////
+
+    // `for` boucles / itération
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Ranges
+    for i in 0u32..10 {
+        print!("{}", i);
+    }
+    println!("");
+    // imprime `0 1 2 3 4 5 6 7 8 9`
+
+    // `if`
+    if 1 == 1 {
+        println!("Maths est travaille!");
+    } else {
+        println!("Oh non ...!");
+    }
+
+    // `if` comme expression
+    let valeur = if true {
+        "bien"
+    } else {
+        "mal"
+    };
+
+    // `while` boucle
+    while 1 == 1 {
+        println!("L'univers fonctionne normalement.");
+    }
+
+    // Boucle infinie
+    loop {
+        println!("Bonjour!");
+    }
+
+    /////////////////////////////////
+    // 5. Sécurité & pointeurs mémoire //
+    /////////////////////////////////
+
+    // Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.
+    // Cela signifie que lorsque le `Box` laisse son champ d'application, il
+    // peut être automatiquement libérée en toute sécurité.
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // déréférencer
+    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
+    // `mine` est déplacé.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", now_its_mine); // Cela ne compile pas parce
+    // que `now_its_mine` possède maintenant le pointeur
+
+    // Référence - un pointeur immutable qui fait référence à d'autres données.
+    // Quand une référence est prise à une valeur, nous disons que la valeur
+    // a été "emprunté".
+    // Même si une valeur est emprunté immutablement, il ne peut pas être
+    // muté ou déplacé.
+    // Un emprunt dure jusqu'à la fin de la portée, il a été créé.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
+    println!("{}", *ref_var);
+    // Var = 5; // Cela ne compile pas parce que `var` est emprunté.
+    // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
+    // référence immutable.
+
+    // Référence Mutable
+    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être
+    // accessible à tous.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    // '*' est utilisé pour pointer vers le var2 mutably emprunté.
+    *ref_var2 += 2;
+
+    println!("{}", * ref_var2); // 6, // var2 ne compilerait pas.
+    // ref_var2 est de type &mut i32 donc stocke la référence à i32,
+    // pas la valeur.
+    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
+}
+```
+
+## Autres lectures
+
+Il y a beaucoup plus à Rust -- ce est juste l'essentiel de Rust afin que vous puissiez comprendre
+les choses les plus importantes. Pour en savoir plus sur Rust, lire [La Programmation Rust
+Langue](http://doc.rust-lang.org/book/index.html) et etudier la
+[/r/rust](http://reddit.com/r/rust) subreddit. Les gens sur le canal de #rust sur
+irc.mozilla.org sont aussi toujours prêts à aider les nouveaux arrivants.
+
+Vous pouvez également essayer caractéristiques de Rust avec un compilateur en ligne sur le fonctionnaire
+[Rust parc](http://play.rust-lang.org) ou sur la principale
+[Site Rust](http://rust-lang.org).
diff --git a/fr-fr/tmux-fr.html.markdown b/fr-fr/tmux-fr.html.markdown
new file mode 100644
index 00000000..d353af3b
--- /dev/null
+++ b/fr-fr/tmux-fr.html.markdown
@@ -0,0 +1,261 @@
+---
+category: tool
+tool: tmux
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+translators:
+    - ["Xuan-thi Nguyen", "https://github.com/mellenguyen"]
+filename: LearnTmux-fr.txt
+lang: fr-fr
+---
+
+
+[Tmux](http://tmux.sourceforge.net) est un multiplexeur de terminal: il permet
+de créer plusieurs terminaux, accédés et contrôlés depuis un seul écran. Tmux
+peut être détaché de l'écran tout en continuant de fonctionner en tâche de
+fond, puis rattaché de nouveau.
+
+
+```
+
+  tmux [command]     # Exécute une commande
+                     # 'tmux' sans commande créé une nouvelle session
+
+    new              # Créé une nouvelle session
+     -s "Session"    # Créé une session nommée "Session"
+     -n "Window"     # Créé une fenêtre nommée "Window"
+     -c "/dir"       # Démarre dans le dossier cible "/dir"
+
+    attach           # S'attache à la dernière session ou la session disponible
+     -t "#"          # S'attache à la session cible
+     -d              # Détache la session des autres instances
+
+    ls               # Liste les sessions ouvertes
+     -a              # Liste toutes les sessions ouvertes
+
+    lsw              # Liste les fenêtres de la session courante
+     -a              # Liste toutes les fenêtres
+     -s              # Liste toutes les fenêtres en session
+
+    lsp              # Liste les panels
+     -a              # Liste tous les panels
+     -s              # Liste tous les panels en session
+     -t              # Liste tous les panels dans la cible
+
+    kill-window      # Tue la fenêtre courante
+     -t "#"          # Tue la fenêtre cible
+     -a              # Tue toutes les fenêtres
+     -a -t "#"       # Tue toutes les fenêtres sauf la cible
+
+    kill-session     # Tue la session courante
+     -t "#"          # Tue la session cible
+     -a              # Tue toutes les sessions
+     -a -t "#"       # Tue toutes les sessions sauf la cible
+
+```
+
+
+### Raccourcis clavier
+
+Afin de contrôler une session tmux attachée, on utilise une combinaison de
+touches appelées 'Préfixe'. Elle doit être pressée afin d'utiliser les
+raccourcis.
+
+```
+--------------------------------------------------------------------------------
+  (C-b) = Ctrl + b  # Combinaison 'Préfixe' requise pour utiliser les raccourcis
+
+  (M-1) = Meta + 1 -ou- Alt + 1
+--------------------------------------------------------------------------------
+
+  ?                  # Liste tous les raccourcis
+  :                  # Entre dans l'invite de commande de tmux
+  r                  # Force la redéfinition du client attaché
+  c                  # Créé une nouvelle fenêtre
+
+  !                  # Sépare le panel courant de sa fenêtre
+  %                  # Sépare le panel courant en deux, gauche et droite
+  "                  # Sépare le panel courant en deux, haut et bas
+
+  n                  # Changer vers la fenêtre suivante
+  p                  # Changer vers la fenêtre précédente
+  {                  # Echange le panel courant avec le panel précédent
+  }                  # Echange le panel courant avec le panel suivant
+
+  s                  # Sélectionne une nouvelle session pour le client attaché
+                     # de manière interactive
+  w                  # Choisi la fenêtre courante de manière interactive
+  0 to 9             # Sélectionne la fenêtre de 0 à 9
+
+  d                  # Détache le client courant
+  D                  # Choisi un client à détacher
+
+  &                  # Tue la fenêtre courante
+  x                  # Tue le panel courant
+
+  Up, Down           # Change vers le panel au dessus, en dessous, à gauche
+  Left, Right        # ou à droite
+
+  M-1 to M-5         # Arrange les panels:
+                       # 1) égaliser sur l'horizontale
+                       # 2) égaliser sur la verticale
+                       # 3) panel principal en haut et le reste en bas
+                       #    de gauche à droite
+                       # 4) panel principal à gauche et le reste à droite
+                       #    de haut en bas
+                       # 5) "tiled" : égalise les panels
+                       #    sur la hauteur et la largeur
+
+  C-Up, C-Down       # Redimensionne le panel courant par pas de une cellule
+  C-Left, C-Right
+
+  M-Up, M-Down       # Redimensionne le panel courant par pas de cinq cellules
+  M-Left, M-Right
+
+```
+
+
+### Configuration de ~/.tmux.conf
+
+tmux.conf peut être utilisé pour fixer les options automatiquement au
+démarrage, comme .vimrc ou init.el.
+
+```
+# Exemple de tmux.conf
+# 2014.10
+
+
+### Général
+###########################################################################
+
+# Active UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Limite de l'historique
+set -g history-limit 2048
+
+# Indice de début du nombre de panels
+set -g base-index 1
+
+# Souris
+set-option -g mouse-select-pane on
+
+# Force le rechargement du fichier de configuration
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Raccourcis clavier
+###########################################################################
+
+# Annule C-b en tant que préfixe par défaut
+unbind C-b
+
+# Définit un nouveau préfixe par défaut
+set-option -g prefix `
+
+# Retourne à la fenêtre précédente quand le préfixe est pressé deux fois
+bind C-a last-window
+bind ` last-window
+
+# Permet d'échanger C-a et ` en utilisant F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Préférences de raccourcis clavier
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Navigue entre les panels avec les raccourcis clavier de vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Navigation entre les fenêtres
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Commandes simples de séparation des panels
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Active la session la plus imbriquée (en faisant de l'imbrication sous tmux)
+# pour envoyer des commandes
+bind a send-prefix
+
+
+### Thème
+###########################################################################
+
+# Palette de couleurs pour la barre de statuts
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Palette de couleurs pour les bordures des panels
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Palette de couleurs pour les messages
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Palette de couleurs pour les fenêtres
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notification
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Définir automatiquement des titres de fenêtres
+set-option -g set-titles on
+# Numéro de fenêtre, nom du programme, actif (ou non)
+set-option -g set-titles-string '#H:#S.#I.#P #W #T'
+
+# Réglages de la barre de statuts
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Présente des indicateurs de performance dans la barre de statuts
+# Recquiert https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Références
+
+[Tmux | Home](http://tmux.sourceforge.net)
+
+[Page du manuel Tmux](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Montrer le pourcentage CPU/MEM dans la barre de statuts](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
+
+[tmuxinator - Gère des sessions tmux complexes](https://github.com/tmuxinator/tmuxinator)
diff --git a/fr-fr/vim.html.markdown b/fr-fr/vim.html.markdown
new file mode 100644
index 00000000..54c00b26
--- /dev/null
+++ b/fr-fr/vim.html.markdown
@@ -0,0 +1,239 @@
+---
+category: tool
+tool: vim
+filename: LearnVim.txt
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Thibault", "https://github.com/napnac"]
+lang: fr-fr
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) est le clone le plus populaire de l'éditeur de texte vi sous Unix.
+Vim est un éditeur de texte omniprésent sur les systèmes de type Unix, et a pour
+objectif la rapidité ainsi que l'augmentation de la productivité. Il a de 
+nombreux raccourcis claviers pour une navigation et une édition plus rapide.
+
+## Navigation basique avec Vim
+
+```
+    vim <ficher>     # Ouvre <fichier> avec vim
+    :q               # Quitte vim
+    :w               # Sauvegarde le fichier actuel
+    :wq              # Sauvegarde le fichier actuel et quitte vim
+    :q!              # Quitte vim sans sauvegarder
+                     # ! *force* l'exécution de :q, ce qui par conséquent 
+                     # oblige vim à quitter sans sauvegarder
+    :x               # Sauvegarde le fichier et quitte vim (raccourcis de :wq)
+
+    u                # Annuler
+    CTRL+R           # Rétablir
+
+    h                # Déplace le curseur vers la gauche
+    j                # Déplace le curseur vers le bas
+    k                # Déplace le curseur vers le haut
+    l                # Déplace le curseur vers la droite
+
+    # Mouvements au sein d'une ligne
+
+    0                # Va au début de la ligne
+    $                # Va à la fin de la ligne
+    ^                # Va au premier caractère non blanc de la ligne
+
+    # Rechercher dans un texte
+
+    /mot             # Surligne toutes les occurrences du mot après le curseur
+    ?mot             # Surligne toutes les occurrences du mot avant le curseur
+    n                # Déplace le curseur sur la prochaine occurrence du mot recherché
+    N                # Déplace le curseur sur la précédente occurrence du mot recherché
+
+    :%s/abc/def/g    # Transforme les 'abc' en 'def' sur chaque ligne du texte
+    :s/abc/def/g     # Transforme les 'abc' en 'def' sur la ligne actuelle
+
+    # Se déplacer vers un caractère
+
+    f<caractère>     # Se déplace en avant jusqu'à <caractère>
+    t<caractère>     # Se déplace en avant juste avant <caractère>
+
+    # Par exemple
+    f<               # Se déplace en avant jusqu'à <
+    t<               # Se déplace en avant juste avant <
+    
+    # Se déplacer dans un mot
+
+    w                # Avance d'un mot
+    b                # Recule d'un mot
+    e                # Se déplace jusqu'à la fin du mot actuel
+
+    # D'autres raccourcis pour se déplacer
+
+    gg               # Va au début du fichier
+    G                # Va à la fin du fichier
+    :NB              # Va à la ligne numéro NB (où NB est un nombre)
+    H                # Se déplace jusqu'en haut de l'écran
+    M                # Se déplace jusqu'au milieu de l'écran
+    L                # Se déplace jusqu'en bas de l'écran
+```
+
+## Modes
+
+Vim est basé sur le concept de **modes**.
+
+Mode Commande  - pour se déplacer et exécuter des commandes (vim démarre dans ce mode)
+Mode Insertion - pour éditer le fichier
+Mode Visuel    - pour sélectionner du texte et réaliser des opérations dessus
+Mode Ex        - pour entrer des commandes avec ':'
+
+```
+    i                # Mode insertion, avant le curseur
+    a                # Mode insertion, après le curseur
+    v                # Mode visuel
+    :                # Mode ex
+    <esc>            # 'Echap' permet de revenir dans le mode commande
+
+    # Copier/Coller du texte
+
+    y                # Copie le texte sélectionné
+    yy               # Copie la ligne actuelle
+    d                # Supprime ce qui est sélectionné
+    dd               # Supprime la ligne actuelle
+    p                # Colle après le curseur
+    P                # Colle avant le curseur
+    x                # Supprime le caractère sous le curseur
+```
+
+## La "Grammaire" de Vim
+
+Vim peut être vu comme un ensemble de commande sous la forme
+'Verbe-Modificateur-Nom' :
+
+Verbe        - notre action
+Modificateur - la manière de faire l'action
+Nom          - l'objet désigné par l'action
+
+Quelques exemples importants de 'Verbes', 'Modificateurs', et de 'Noms' :
+
+```
+    # 'Verbes'
+ 
+    d                # Supprime
+    c                # Transforme
+    y                # Copie
+    v                # Sélectionne
+
+    # 'Modificateurs'
+
+    i                # A l'intérieur
+    a                # Autour
+    NB               # Nombre
+    f                # Cherche quelque chose et se déplace dessus
+    t                # Cherche quelque chose et se déplace juste avant
+    /                # Cherche une chaîne de caractères après le curseur
+    ?                # Cherche une chaîne de caractères avant le curseur
+
+    # 'Noms'
+
+    w                # Mot
+    s                # Phrase
+    p                # Paragraphe
+    b                # Bloc
+    
+    # Exemple de 'phrases' ou commandes
+
+    d2w              # Supprime 2 mots
+    cis              # Transforme l'intérieur de la phrase
+    yip              # Copie l'intérieur du paragraphe
+    ct<              # Transforme le texte du curseur jusqu'au caractère avant le <
+    d$               # Supprime jusqu'à la fin de la ligne
+```
+
+## Quelques raccourcis et astuces
+
+```
+    >                # Indente la sélection d'un bloc
+    <                # Dé-indente la sélection d'un bloc
+    :earlier 15m     # Retrouve le document comme il était il y a 15 minutes
+    :later 15m       # Inverse la commande précédente
+    ddp              # Echange la position de deux lignes consécutives (dd puis p)
+    .                # Répète la dernière action effectuée
+```
+
+## Macros
+
+Les macros sont des actions enregistrables.
+Quand on commence à enregistrer une macro, Vim enregistre **toutes** les actions
+et les commandes que vous utilisez, jusqu'à ce que vous arrêtiez d'enregistrer.
+Lorsque vous appelez une macro, elle applique exactement les mêmes actions et 
+commandes sur le texte sélectionné.
+
+```
+    qa               # Commence l'enregistrement de la macro 'a'
+    q                # Arrête l'enregistrement
+    @a               # Appelle la macro 'a'
+```
+
+### Configuration de ~/.vimrc
+
+Le fichier .vimrc est utilisé pour configurer Vim lors du démarrage.
+
+Voici un exemple de fichier ~/.vimrc :
+
+```
+" Exemple de ~/.vimrc
+" 2015.10 
+
+" Nécessaire à Vim pour être 'iMproved'
+set nocompatible
+
+" Détermine l'extension du fichier à partir du nom pour permettre une indentation
+" automatique intelligente, etc.
+filetype indent plugin on
+
+" Active la coloration syntaxique
+syntax on
+
+" Une meilleure complétion de la ligne de commande
+set wildmenu
+
+" Utilise une recherche insensible à la case sauf quand on utilise des majuscules
+set ignorecase
+set smartcase
+
+" Quand on commence une nouvelle ligne et qu'aucun type d'indentation n'est activé
+" on utilise la même indentation que sur la ligne précédente
+set autoindent
+
+" Affiche le numéro de la ligne sur la gauche de l'écran
+set number
+
+" Options d'indentation, à changer en fonction des préférences personnelles
+
+" Nombre d'espaces visuels par tabulation
+set tabstop=4
+
+" Nombre d'espaces par tabulation
+set softtabstop=4
+
+" Nombre d'espaces indentés avec les opérations d'indentations (>> et <<)
+set shiftwidth=4
+
+" Convertis les tabulations en espaces
+set expandtab
+
+" Active des tabulations et des espaces intelligents pour l'indentation et l'alignement
+set smarttab
+```
+
+### Références
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
diff --git a/fsharp.html.markdown b/fsharp.html.markdown
index 809a1da2..bbf477ba 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -175,7 +175,12 @@ module ListExamples =
     // list comprehensions (aka generators)
     let squares = [for i in 1..10 do yield i * i]
 
-    // prime number generator
+    // A prime number generator
+    // - this is using a short notation for the pattern matching syntax
+    // - (p::xs) is 'first :: tail' of the list, could also be written as p :: xs
+    //   this means this matches 'p' (the first item in the list), and xs is the rest of the list
+    //   this is called the 'cons pattern'
+    // - uses 'rec' keyword, which is necessary when using recursion
     let rec sieve = function
         | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
         | []      -> []
@@ -346,7 +351,7 @@ module DataTypeExamples =
     let trySendEmail email =
         match email with // use pattern matching
         | ValidEmailAddress address -> ()   // send
-        | InvalidEmailAddress address -> () // dont send
+        | InvalidEmailAddress address -> () // don't send
 
     // The combination of union types and record types together
     // provide a great foundation for domain driven design.
@@ -403,11 +408,14 @@ module ActivePatternExamples =
 
     // "banana clips" are the syntax for active patterns
 
+    // You can use "elif" instead of "else if" in conditional expressions.
+    // They are equivalent in F#
+
     // for example, define an "active" pattern to match character types...
     let (|Digit|Letter|Whitespace|Other|) ch =
        if System.Char.IsDigit(ch) then Digit
-       else if System.Char.IsLetter(ch) then Letter
-       else if System.Char.IsWhiteSpace(ch) then Whitespace
+       elif System.Char.IsLetter(ch) then Letter
+       elif System.Char.IsWhiteSpace(ch) then Whitespace
        else Other
 
     // ... and then use it to make parsing logic much clearer
@@ -426,7 +434,7 @@ module ActivePatternExamples =
     // -----------------------------------
 
     // You can create partial matching patterns as well
-    // Just use underscore in the defintion, and return Some if matched.
+    // Just use underscore in the definition, and return Some if matched.
     let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
     let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
 
@@ -627,7 +635,3 @@ module NetCompatibilityExamples =
 For more demonstrations of F#, go to the [Try F#](http://www.tryfsharp.org/Learn) site, or my [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) series.
 
 Read more about F# at [fsharp.org](http://fsharp.org/).
-
-
-
-
diff --git a/git.html.markdown b/git.html.markdown
index e7ca07d6..01dc92c1 100644
--- a/git.html.markdown
+++ b/git.html.markdown
@@ -7,6 +7,7 @@ contributors:
     - ["Betsy Lorton" , "http://github.com/schbetsy"]
     - ["Bruno Volcov", "http://github.com/volcov"]
     - ["Andrew Taylor", "http://github.com/andrewjt71"]
+    - ["Jason Stathopulos", "http://github.com/SpiritBreaker226"]
 filename: LearnGit.txt
 ---
 
@@ -24,9 +25,12 @@ Version control is a system that records changes to a file(s), over time.
 
 ### Centralized Versioning VS Distributed Versioning
 
-* Centralized version control focuses on synchronizing, tracking, and backing up files.
-* Distributed version control focuses on sharing changes. Every change has a unique id.
-* Distributed systems have no defined structure. You could easily have a SVN style, 		centralized system, with git.
+* Centralized version control focuses on synchronizing, tracking, and backing 
+up files.
+* Distributed version control focuses on sharing changes. Every change has a 
+unique id.
+* Distributed systems have no defined structure. You could easily have a SVN 
+style, centralized system, with git.
 
 [Additional Information](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
 
@@ -35,13 +39,13 @@ Version control is a system that records changes to a file(s), over time.
 * Can work offline.
 * Collaborating with others is easy!
 * Branching is easy!
+* Branching is fast!
 * Merging is easy!
 * Git is fast.
 * Git is flexible.
 
 ## Git Architecture
 
-
 ### Repository
 
 A set of files, directories, historical records, commits, and heads. Imagine it
@@ -52,7 +56,8 @@ A git repository is comprised of the .git directory & working tree.
 
 ### .git Directory (component of repository)
 
-The .git directory contains all the configurations, logs, branches, HEAD, and more.
+The .git directory contains all the configurations, logs, branches, HEAD, and 
+more.
 [Detailed List.](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
 
 ### Working Tree (component of repository)
@@ -62,16 +67,16 @@ referred to as your working directory.
 
 ### Index (component of .git dir)
 
-The Index is the staging area in git. It's basically a layer that separates your working tree
-from the Git repository. This gives developers more power over what gets sent
-to the Git repository.
+The Index is the staging area in git. It's basically a layer that separates 
+your working tree from the Git repository. This gives developers more power 
+over what gets sent to the Git repository.
 
 ### Commit
 
-A git commit is a snapshot of a set of changes, or manipulations to your Working
-Tree. For example, if you added 5 files, and removed 2 others, these changes
-will be contained in a commit (or snapshot). This commit can then be pushed to
-other repositories, or not!
+A git commit is a snapshot of a set of changes, or manipulations to your 
+Working Tree. For example, if you added 5 files, and removed 2 others, these 
+changes will be contained in a commit (or snapshot). This commit can then be 
+pushed to other repositories, or not!
 
 ### Branch
 
@@ -85,11 +90,14 @@ functionality to mark release points (v1.0, and so on)
 
 ### HEAD and head (component of .git dir)
 
-HEAD is a pointer that points to the current branch. A repository only has 1 *active* HEAD.
-head is a pointer that points to any commit. A repository can have any number of heads.
+HEAD is a pointer that points to the current branch. A repository only has 1 
+*active* HEAD.  
+head is a pointer that points to any commit. A repository can have any number 
+of heads.
 
 ### Stages of Git
-* Modified - Changes have been made to a file but file has not been committed to Git Database yet
+* Modified - Changes have been made to a file but file has not been committed 
+to Git Database yet
 * Staged - Marks a modified file to go into your next commit snapshot
 * Committed - Files have been committed to the Git Database
 
@@ -98,14 +106,12 @@ head is a pointer that points to any commit. A repository can have any number of
 * [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/)
 * [Git For Designers](http://hoth.entp.com/output/git_for_designers.html)
 
-
 ## Commands
 
-
 ### init
 
-Create an empty Git repository. The Git repository's settings, stored information,
-and more is stored in a directory (a folder) named ".git".
+Create an empty Git repository. The Git repository's settings, stored 
+information, and more is stored in a directory (a folder) named ".git".
 
 ```bash
 $ git init
@@ -116,7 +122,6 @@ $ git init
 To configure settings. Whether it be for the repository, the system itself,
 or global configurations ( global config file is `~/.gitconfig` ).
 
-
 ```bash
 # Print & Set Some Basic Config Variables (Global)
 $ git config --global user.email "MyEmail@Zoho.com"
@@ -157,13 +162,11 @@ $ echo "temp/" >> .gitignore
 $ echo "private_key" >> .gitignore
 ```
 
-
 ### status
 
 To show differences between the index file (basically your working copy/repo)
 and the current HEAD commit.
 
-
 ```bash
 # Will display the branch, untracked files, changes and other differences
 $ git status
@@ -174,8 +177,8 @@ $ git help status
 
 ### add
 
-To add files to the staging area/index. If you do not `git add` new files to the
-staging area/index, they will not be included in commits!
+To add files to the staging area/index. If you do not `git add` new files to 
+the staging area/index, they will not be included in commits!
 
 ```bash
 # add a file in your current working directory
@@ -193,7 +196,8 @@ working directory/repo.
 
 ### branch
 
-Manage your branches. You can view, edit, create, delete branches using this command.
+Manage your branches. You can view, edit, create, delete branches using this 
+command.
 
 ```bash
 # list existing branches & remotes
@@ -220,54 +224,64 @@ Manage your tags
 ```bash
 # List tags
 $ git tag
+
 # Create a annotated tag
 # The -m specifies a tagging message,which is stored with the tag.
 # If you don’t specify a message for an annotated tag,
 # Git launches your editor so you can type it in.
 $ git tag -a v2.0 -m 'my version 2.0'
+
 # Show info about tag
 # That shows the tagger information, the date the commit was tagged,
 # and the annotation message before showing the commit information.
 $ git show v2.0
+
 # Push a single tag to remote
 $ git push origin v2.0
+
 # Push a lot of tags to remote
 $ git push origin --tags
 ```
 
 ### checkout
 
-Updates all files in the working tree to match the version in the index, or specified tree.
+Updates all files in the working tree to match the version in the index, or 
+specified tree.
 
 ```bash
 # Checkout a repo - defaults to master branch
 $ git checkout
+
 # Checkout a specified branch
 $ git checkout branchName
+
 # Create a new branch & switch to it
 # equivalent to "git branch <name>; git checkout <name>"
+
 $ git checkout -b newBranch
 ```
 
 ### clone
 
 Clones, or copies, an existing repository into a new directory. It also adds
-remote-tracking branches for each branch in the cloned repo, which allows you to push
-to a remote branch.
+remote-tracking branches for each branch in the cloned repo, which allows you 
+to push to a remote branch.
 
 ```bash
 # Clone learnxinyminutes-docs
 $ git clone https://github.com/adambard/learnxinyminutes-docs.git
+
 # shallow clone - faster cloning that pulls only latest snapshot
 $ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+
 # clone only a specific branch
 $ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
 ```
 
 ### commit
 
-Stores the current contents of the index in a new "commit." This commit contains
-the changes made and a message created by the user.
+Stores the current contents of the index in a new "commit." This commit 
+contains the changes made and a message created by the user.
 
 ```bash
 # commit with a message
@@ -382,7 +396,8 @@ $ git pull origin master
 $ git pull
 
 # Merge in changes from remote branch and rebase
-# branch commits onto your local repo, like: "git pull <remote> <branch>, git rebase <branch>"
+# branch commits onto your local repo, like: "git fetch <remote> <branch>, git 
+# rebase <remote>/<branch>"
 $ git pull origin master --rebase
 ```
 
@@ -408,8 +423,8 @@ $ git push
 
 ### stash
 
-Stashing takes the dirty state of your working directory and saves it on a stack
-of unfinished changes that you can reapply at any time.
+Stashing takes the dirty state of your working directory and saves it on a 
+stack of unfinished changes that you can reapply at any time.
 
 Let's say you've been doing some work in your git repo, but you want to pull
 from the remote. Since you have dirty (uncommited) changes to some files, you
@@ -440,7 +455,8 @@ nothing to commit, working directory clean
 ```
 
 You can see what "hunks" you've stashed so far using `git stash list`.
-Since the "hunks" are stored in a Last-In-First-Out stack, our most recent change will be at top.
+Since the "hunks" are stored in a Last-In-First-Out stack, our most recent 
+change will be at top.
 
 ```bash
 $ git stash list
@@ -470,7 +486,8 @@ Now you're ready to get back to work on your stuff!
 
 ### rebase (caution)
 
-Take all changes that were committed on one branch, and replay them onto another branch.
+Take all changes that were committed on one branch, and replay them onto 
+another branch.
 *Do not rebase commits that you have pushed to a public repo*.
 
 ```bash
@@ -484,8 +501,8 @@ $ git rebase master experimentBranch
 ### reset (caution)
 
 Reset the current HEAD to the specified state. This allows you to undo merges,
-pulls, commits, adds, and more. It's a great command but also dangerous if you don't
-know what you are doing.
+pulls, commits, adds, and more. It's a great command but also dangerous if you 
+don't know what you are doing.
 
 ```bash
 # Reset the staging area, to match the latest commit (leaves dir unchanged)
@@ -503,11 +520,37 @@ $ git reset 31f2bb1
 # after the specified commit).
 $ git reset --hard 31f2bb1
 ```
+
+### reflog (caution)
+
+Reflog will list most of the git commands you have done for a given time period,
+default 90 days.
+
+This give you the a change to reverse any git commands that have gone wrong
+for instance if a rebase is has broken your application.
+
+You can do this:
+
+1. `git reflog` to list all of the git commands for the rebase
+```
+38b323f HEAD@{0}: rebase -i (finish): returning to refs/heads/feature/add_git_reflog
+38b323f HEAD@{1}: rebase -i (pick): Clarify inc/dec operators
+4fff859 HEAD@{2}: rebase -i (pick): Update java.html.markdown
+34ed963 HEAD@{3}: rebase -i (pick): [yaml/en] Add more resources (#1666)
+ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748)
+2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d
+```
+2. Select where to reset to, in our case its `2e6c386`, or `HEAD@{5}`
+3. 'git reset --hard HEAD@{5}' this will reset your repo to that head
+4. You can start the rebase again or leave it alone.
+
+[Additional Reading.](https://git-scm.com/docs/git-reflog)
+
 ### revert
 
-Revert can be used to undo a commit. It should not be confused with reset which restores
-the state of a project to a previous point. Revert will add a new commit which is the
-inverse of the specified commit, thus reverting it.
+Revert can be used to undo a commit. It should not be confused with reset which 
+restores the state of a project to a previous point. Revert will add a new 
+commit which is the inverse of the specified commit, thus reverting it.
 
 ```bash
 # Revert a specified commit
@@ -530,6 +573,8 @@ $ git rm /pather/to/the/file/HelloWorld.c
 
 * [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
 
+* [Learn Git Branching - the most visual and interactive way to learn Git on the web](http://learngitbranching.js.org/)
+
 * [Udemy Git Tutorial: A Comprehensive Guide](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
 
 * [Git Immersion - A Guided tour that walks through the fundamentals of git](http://gitimmersion.com/)
@@ -540,7 +585,7 @@ $ git rm /pather/to/the/file/HelloWorld.c
 
 * [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
 
-* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+* [SalesForce Cheat Sheet](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf)
 
 * [GitGuys](http://www.gitguys.com/)
 
@@ -549,4 +594,3 @@ $ git rm /pather/to/the/file/HelloWorld.c
 * [Pro Git](http://www.git-scm.com/book/en/v2)
 
 * [An introduction to Git and GitHub for Beginners (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
-
diff --git a/go.html.markdown b/go.html.markdown
index dc684227..50692f9c 100644
--- a/go.html.markdown
+++ b/go.html.markdown
@@ -11,6 +11,7 @@ contributors:
     - ["Jose Donizetti", "https://github.com/josedonizetti"]
     - ["Alexej Friesen", "https://github.com/heyalexej"]
     - ["Clayton Walker", "https://github.com/cwalk"]
+    - ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"]
 ---
 
 Go was created out of the need to get work done. It's not the latest trend
@@ -39,6 +40,7 @@ import (
 	"io/ioutil" // Implements some I/O utility functions.
 	m "math"    // Math library with local alias m.
 	"net/http"  // Yes, a web server!
+	"os"        // OS functions like working with the file system
 	"strconv"   // String conversions.
 )
 
@@ -97,12 +99,12 @@ can include line breaks.` // Same string type.
 
 	// Arrays have size fixed at compile time.
 	var a4 [4]int           // An array of 4 ints, initialized to all 0.
-	a3 := [...]int{3, 1, 5} // An array initialized with a fixed size of three
-	// elements, with values 3, 1, and 5.
+	a5 := [...]int{3, 1, 5, 10, 100} // An array initialized with a fixed size of fize
+	// elements, with values 3, 1, 5, 10, and 100.
 
 	// Slices have dynamic size. Arrays and slices each have advantages
 	// but use cases for slices are much more common.
-	s3 := []int{4, 5, 9}    // Compare to a3. No ellipsis here.
+	s3 := []int{4, 5, 9}    // Compare to a5. No ellipsis here.
 	s4 := make([]int, 4)    // Allocates slice of 4 ints, initialized to all 0.
 	var d2 [][]float64      // Declaration only, nothing allocated here.
 	bs := []byte("a slice") // Type conversion syntax.
@@ -132,7 +134,15 @@ can include line breaks.` // Same string type.
 
 	// Unused variables are an error in Go.
 	// The underscore lets you "use" a variable but discard its value.
-	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs
+	// Usually you use it to ignore one of the return values of a function
+	// For example, in a quick and dirty script you might ignore the
+	// error value returned from os.Create, and expect that the file
+	// will always be created.
+	file, _ := os.Create("output.txt")
+	fmt.Fprint(file, "This is how you write to a file, by the way")
+	file.Close()
+	
 	// Output of course counts as using a variable.
 	fmt.Println(s, c, a4, s3, d2, m)
 
@@ -211,6 +221,10 @@ func learnFlowControl() {
 		// for each pair in the map, print key and value
 		fmt.Printf("key=%s, value=%d\n", key, value)
 	}
+	// If you only need the value, use the underscore as the key
+	for _, name := range []string{"Bob", "Bill", "Joe"} {
+		fmt.Printf("Hello, %s\n", name)
+	}
 
 	// As with for, := in an if statement means to declare and assign
 	// y first, then test y > x.
@@ -221,7 +235,8 @@ func learnFlowControl() {
 	xBig := func() bool {
 		return x > 10000 // References x declared above switch statement.
 	}
-	fmt.Println("xBig:", xBig()) // true (we last assigned e^10 to x).
+	x = 99999
+	fmt.Println("xBig:", xBig()) // true
 	x = 1.3e3                    // This makes x == 1300
 	fmt.Println("xBig:", xBig()) // false now.
 
@@ -280,7 +295,7 @@ type pair struct {
 	x, y int
 }
 
-// Define a method on type pair. Pair now implements Stringer.
+// Define a method on type pair. Pair now implements Stringer because Pair has defined all the methods in the interface.
 func (p pair) String() string { // p is called the "receiver"
 	// Sprintf is another public function in package fmt.
 	// Dot syntax references fields of p.
diff --git a/groovy.html.markdown b/groovy.html.markdown
index ea575248..a3a45757 100644
--- a/groovy.html.markdown
+++ b/groovy.html.markdown
@@ -99,7 +99,7 @@ technologies.sort()
 // To sort without mutating original, you can do:
 sortedTechnologies = technologies.sort( false )
 
-/*** Manipulating Lists ***/e
+/*** Manipulating Lists ***/
 
 //Replace all elements in the list
 Collections.replaceAll(technologies, 'Gradle', 'gradle')
@@ -280,7 +280,7 @@ def clos = { print it }
 clos( "hi" )
 
 /*
-  Groovy can memorize closure results [1][2][3]
+  Groovy can memoize closure results [1][2][3]
 */
 def cl = {a, b ->
     sleep(3000) // simulate some time consuming processing
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 200e2538..4e254070 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -64,11 +64,11 @@ not False -- True
 
 
 ----------------------------------------------------
--- Lists and Tuples
+-- 2. Lists and Tuples
 ----------------------------------------------------
 
 -- Every element in a list must have the same type.
--- These two lists are the same:
+-- These two lists are equal:
 [1, 2, 3, 4, 5]
 [1..5]
 
@@ -77,11 +77,11 @@ not False -- True
 
 -- You can create a step in a range.
 [0,2..10] -- [0, 2, 4, 6, 8, 10]
-[5..1] -- This doesn't work because Haskell defaults to incrementing.
+[5..1] -- [] (Haskell defaults to incrementing)
 [5,4..1] -- [5, 4, 3, 2, 1]
 
 -- indexing into a list
-[1..10] !! 3 -- 4
+[1..10] !! 3 -- 4 (zero-based indexing)
 
 -- You can also have infinite lists in Haskell!
 [1..] -- a list of all the natural numbers
@@ -152,8 +152,8 @@ fib x
   | 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.
+-- equations that define fib. Haskell will automatically use the first
+-- equation whose left hand side pattern matches the value.
 fib 1 = 1
 fib 2 = 2
 fib x = fib (x - 1) + fib (x - 2)
@@ -189,20 +189,20 @@ foo = add 10 -- foo is now a function that takes a number and adds 10 to it
 foo 5 -- 15
 
 -- Another way to write the same thing
-foo = (+10)
+foo = (10+)
 foo 5 -- 15
 
 -- function composition
 -- the operator `.` chains functions together.
 -- For example, here foo is a function that takes a value. It adds 10 to it,
 -- multiplies the result of that by 4, and then returns the final value.
-foo = (*4) . (+10)
+foo = (4*) . (10+)
 
--- (5 + 10) * 4 = 60
+-- 4*(10+5) = 60
 foo 5 -- 60
 
 -- fixing precedence
--- Haskell has another operator called `$`. This operator applies a function 
+-- Haskell has an operator called `$`. This operator applies a function 
 -- to a given parameter. In contrast to standard function application, which 
 -- has highest possible priority of 10 and is left-associative, the `$` operator 
 -- has priority of 0 and is right-associative. Such a low priority means that
@@ -222,7 +222,7 @@ even . fib $ 7 -- false
 -- 5. Type signatures
 ----------------------------------------------------
 
--- Haskell has a very strong type system, and everything has a type signature.
+-- Haskell has a very strong type system, and every valid expression has a type. 
 
 -- Some basic types:
 5 :: Integer
@@ -244,10 +244,10 @@ double x = x * 2
 -- 6. Control Flow and If Expressions
 ----------------------------------------------------
 
--- if expressions
+-- if-expressions
 haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
 
--- if expressions can be on multiple lines too, indentation is important
+-- if-expressions can be on multiple lines too, indentation is important
 haskell = if 1 == 1
             then "awesome"
             else "awful"
@@ -259,7 +259,7 @@ case args of
   _ -> putStrLn "bad args"
 
 -- Haskell doesn't have loops; it uses recursion instead.
--- map applies a function over every element in an array
+-- map applies a function over every element in a list
 
 map (*2) [1..5] -- [2, 4, 6, 8, 10]
 
@@ -279,7 +279,7 @@ foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
 -- This is the same as
 (2 * (2 * (2 * 4 + 1) + 2) + 3)
 
--- foldl is left-handed, foldr is right-
+-- foldl is left-handed, foldr is right-handed
 foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
 
 -- This is now the same as
@@ -295,11 +295,10 @@ data Color = Red | Blue | Green
 
 -- Now you can use it in a function:
 
-
 say :: Color -> String
-say Red = "You are Red!"
-say Blue = "You are Blue!"
-say Green =  "You are Green!"
+say Red   = "You are Red!"
+say Blue  = "You are Blue!"
+say Green = "You are Green!"
 
 -- Your data types can have parameters too:
 
@@ -318,7 +317,7 @@ Nothing         -- of type `Maybe a` for any `a`
 -- it is not hard to explain enough to get going.
 
 -- When a Haskell program is executed, `main` is
--- called. It must return a value of type `IO ()`. For example:
+-- called. It must return a value of type `IO a` for some type `a`. For example:
 
 main :: IO ()
 main = putStrLn $ "Hello, sky! " ++ (say Blue)
@@ -361,7 +360,7 @@ sayHello = do
 -- You can think of a value of type `IO a` as representing 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
+-- name and reuse this value using `<-`. We can also
 -- make our own action of type `IO String`:
 
 action :: IO String
@@ -384,8 +383,8 @@ main'' = do
 -- The type `IO` is an example of a "monad". The way Haskell uses a monad to
 -- do IO allows it to be a purely functional language. Any function that
 -- interacts with the outside world (i.e. does IO) gets marked as `IO` in its
--- type signature. This lets us reason about what functions are "pure" (don't
--- interact with the outside world or modify state) and what functions aren't.
+-- type signature. This lets us reason about which functions are "pure" (don't
+-- interact with the outside world or modify state) and which functions aren't.
 
 -- This is a powerful feature, because it's easy to run pure functions
 -- concurrently; so, concurrency in Haskell is very easy.
@@ -432,7 +431,7 @@ Hello, Friend!
 
 There's a lot more to Haskell, including typeclasses and monads. These are the
 big ideas that make Haskell such fun to code in. I'll leave you with one final
-Haskell example: an implementation of quicksort in Haskell:
+Haskell example: an implementation of a quicksort variant in Haskell:
 
 ```haskell
 qsort [] = []
diff --git a/haxe.html.markdown b/haxe.html.markdown
index ee214540..03b3099e 100644
--- a/haxe.html.markdown
+++ b/haxe.html.markdown
@@ -380,7 +380,7 @@ class LearnHaxe3{
         // The "_" case above is a "wildcard" value
         // that will match anything.
 
-        trace("My dog's name is" + my_dog_name
+        trace("My dog's name is " + my_dog_name
                 + ", and his favorite thing is a: "
                 + favorite_thing);
 
@@ -406,7 +406,7 @@ class LearnHaxe3{
             default     : "some unknown treat";
         }
 
-        trace("My dog's name is" + my_dog_name
+        trace("My dog's name is " + my_dog_name
                 + ", and his other favorite thing is a: "
                 + other_favorite_thing);
 
diff --git a/hd-hd/amd.html.markdown b/hd-hd/amd.html.markdown
new file mode 100644
index 00000000..0a6581d6
--- /dev/null
+++ b/hd-hd/amd.html.markdown
@@ -0,0 +1,207 @@
+---
+category: tool
+tool: amd
+contributors:
+    - ["Frederik Ring", "https://github.com/m90"]
+filename: learnamd-hd.js
+lang: hd
+---
+## एएमडी के साथ प्रारंभ करना
+
+एपीआई को परिभाषित करने के लिए एक तंत्र को निर्दिष्ट ** ** अतुल्यकालिक मॉड्यूल परिभाषा
+जावास्क्रिप्ट मॉड्यूल ऐसे मॉड्यूल और इसकी अतुल्यकालिक निर्भरता से भरा हुआ है। यह ब्राउज़र पर्यावरण जहां के लिए विशेष रूप से अच्छी तरह से अनुकूल है, और प्रदर्शन , प्रयोज्य, डीबगिंग, और क्रॉस-डोमेन जैसे मॉड्यूल्स को जल्दी सिंक्रनाइज़ लोडिंग करता hai।
+
+### मूल अवधारणा
+```javascript
+// बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : ` define` और` require`
+// और सभी मॉड्यूल परिभाषा और खपत के बारे में है :
+// `define` एक मॉड्यूल को परिभाषित करता है
+// ` require` निर्भरता का एक सेट का आयात करता है और
+// पारित कर दिया कॉलबैक में उन्हें सेवन करती है
+
+// एक नया नाम देकर हम मॉड्यूल को परिभाषित करने का उपयोग करके शुरू करते हैं
+// जिसकी कोई निर्भरता है । हम एक नाम से गुजर रहा है ऐसा करेंगे
+// और एक कारखाने समारोह को परिभाषित करने के लिए :
+define('awesomeAMD', function(){
+  var isAMDAwesome = function(){
+    return true;
+  };
+// एक मॉड्यूल के कारखाने समारोह की मान है
+  // जब प्राप्त होगा क्या अन्य मॉड्यूल या आवश्यकता कॉल
+  // हमारे ` awesomeAMD` मॉड्यूल की आवश्यकता होती है ।
+  // निर्यात मूल्य कुछ भी हो सकता है, (निर्माता ) काम करता है,
+  // वस्तुओं, पुरातन, (जो कि बहुत ज्यादा मदद नहीं करेगा , हालांकि) भी अपरिभाषित ।
+  return isAMDAwesome;
+});
+
+// अब, हमारे ` awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं।
+// हमारे परिभाषित करने के लिए एक अतिरिक्त तर्क है कि नोटिस
+अब // मॉड्यूल की निर्भरता :
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+// निर्भरता कारखाने के तर्कों को पारित हो जाएगा
+  // क्रम में वे निर्दिष्ट कर रहे हैं
+  var tellEveryone = function(){
+    if (awesomeAMD()){
+      alert('This is sOoOo rad!');
+    } else {
+      alert('Pretty dull, isn\'t it?');
+    }
+  };
+  return tellEveryone;
+});
+
+// हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए ` require` का उपयोग करते हैं
+// हमारे कार्यक्रम बंद किक । ` require` के हस्ताक्षर है :(arrayOfDependencies, callback)`.
+require(['loudmouth'], function(loudmouth){
+  loudmouth();
+});
+
+// इस ट्यूटोरियल रन कोड बनाने के लिए है, चलो एक बहुत ही बुनियादी लागू करते हैं
+// (गैर अतुल्यकालिक ) की मौके पर यहीं एएमडी के संस्करण:
+function define(name, deps, factory){
+// निर्भरता के बिना मॉड्यूल नियंत्रित किया जाता है कैसे नोटिस
+  define[name] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+  var args = [];
+ // पहले की जरूरत है सभी निर्भरता पुनः प्राप्त करते हैं
+  // आवश्यकता कॉल द्वारा
+  for (var i = 0; i < deps.length; i++){
+    args[i] = define[deps[i]];
+  }
+// सभी कॉलबैक की निर्भरता को संतुष्ट
+  return callback.apply(null, args);
+}
+// आप यहाँ कार्रवाई में इस कोड को देख सकते हैं: http://jsfiddle.net/qap949pd/
+```
+
+### Require.js के साथ वास्तविक दुनिया के उपयोग
+
+परिचयात्मक उदाहरण के विपरीत, ` require.js` (सबसे लोकप्रिय एएमडी पुस्तकालय ) वास्तव में लागू करता है ** ** Amd ** में  *A * **, आप XHR के माध्यम से  मॉड्यूल और उनकी निर्भरता लोड करने के लिए सक्षम करने के लिए :
+```javascript
+/* file: app/main.js */
+require(['modules/someClass'], function(SomeClass){
+  // निर्भरता लोड होने तक कॉलबैक टाल दिया गया है
+  var thing = new SomeClass();
+});
+console.log('So here we are, waiting!'); // this will run first
+```
+
+परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । ` require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की ` baseUrl` के सापेक्ष ` modules` फ़ोल्डर में माना गया है :
+
+* app/
+  * main.js
+  * modules/
+    * someClass.js
+    * someHelpers.js
+    * ...
+  * daos/
+    * things.js
+    * ...
+
+इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना ` someClass` परिभाषित कर सकते हैं :
+
+```javascript
+/* file: app/modules/someClass.js */
+define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
+  // module definition, of course, will also happen asynchronously
+  function SomeClass(){
+    this.method = function(){/**/};
+    // ...
+  }
+  return SomeClass;
+});
+```
+अपने ` main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग ` requirejs.config ( configObj ) ` में परिवर्तन करने के लिए:
+
+```javascript
+/* file: main.js */
+requirejs.config({
+  baseUrl : 'app',
+  paths : {
+    // आप भी अन्य स्थानों से मॉड्यूल लोड कर सकते हैं
+    jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+});
+require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
+  //एक ` main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है,
+  // अन्यथा कोई कोड कभी चलेंगे
+  coolLib.doFancyStuffWith(helpers.transform($('#foo')));
+});
+```
+` require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में ` require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु (` main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा :
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>A hundred script tags? Never again!</title>
+</head>
+<body>
+  <script src="require.js" data-main="app/main"></script>
+</body>
+</html>
+```
+
+### R.js का उपयोग कर एक पूरी परियोजना का अनुकूलन
+
+कई लोगों को विकास के दौरान समझदार कोड संगठन के लिए एएमडी का उपयोग कर पसंद करते हैं, लेकिन अभी भी पेज लोड पर XHRs के सैकड़ों करने के बजाय उत्पादन में एक भी स्क्रिप्ट फ़ाइल जहाज करने के लिए चाहते हैं।
+
+(राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) ` require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि ` r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है।
+Install it using `npm`:
+```shell
+$ npm install requirejs -g
+```
+
+अब आप एक विन्यास फाइल के साथ फ़ीड कर सकते हैं:
+```shell
+$ r.js -o app.build.js
+```
+
+हमारे ऊपर के उदाहरण के लिए विन्यास की तरह लग सकता है:
+```javascript
+/* file : app.build.js */
+({
+  name : 'main', // प्रवेश बिंदु के नाम
+  out : 'main-built.js', // फ़ाइल का नाम करने के लिए उत्पादन में लिखने के लिए
+  baseUrl : 'app',
+  paths : {
+    // ` empty :` का उपयोग कर , यह अभी भी समन्वय से लोड किया जाना चाहिए कि r.js बताता है
+    // main.js में निर्दिष्ट स्थान
+    jquery : 'empty:',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+})
+```
+
+उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस ` Data-main` स्वैप:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन] (https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है।
+
+### विषय इस ट्यूटोरियल में शामिल नहीं
+* [लोडर प्लगइन्स / रूपांतरण] (http://requirejs.org/docs/plugins.html)
+* [CommonJS शैली लोड हो रहा है और निर्यात] (http://requirejs.org/docs/commonjs.html)
+* [उन्नत विन्यास] (http://requirejs.org/docs/api.html#config)
+* [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)] (http://requirejs.org/docs/api.html#config-shim)
+* [सीएसएस लदान और require.js साथ अनुकूलन] (http://requirejs.org/docs/optimization.html#onecss)
+* (Https://github.com/jrburke/almond) [बनाता है के लिए almond.js का प्रयोग]
+
+### अग्रिम पठन:
+
+* [सरकारी कल्पना] (https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [क्यों एएमडी?] (Http://requirejs.org/docs/whyamd.html)
+* [यूनिवर्सल मॉड्यूल परिभाषा] (https://github.com/umdjs/umd)
+
+### कार्यान्वयन:
+
+* [Require.js] (http://requirejs.org)
+* [डोजो टूलकिट] (http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [Cujo.js] (http://cujojs.com/)
+* [Curl.js] (https://github.com/cujojs/curl)
+* [Lsjs] (https://github.com/zazl/lsjs)
+* [एमडी] (https://github.com/alexlawrence/mmd)
diff --git a/hd-hd/d.html.markdown b/hd-hd/d.html.markdown
new file mode 100644
index 00000000..96274e2b
--- /dev/null
+++ b/hd-hd/d.html.markdown
@@ -0,0 +1,256 @@
+---
+language: D
+filename: learnd-hd.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+lang: hd
+---
+
+```c
+//क्या आ रहा है पता है ...
+module hello;
+
+import std.stdio;
+
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अधिक समय खर्च करते हैं, तो आप बाधाओं के बारे में सुना है
+के बारे में [डी ] ( http://dlang.org/ )। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
+सब कुछ के लिए समर्थन कम स्तर की सुविधाओं से करने के साथ बहु - प्रतिमान भाषा
+अर्थपूर्ण उच्च स्तरीय चीजें ।
+
+D सक्रिय रूप से सुपर स्मार्ट लोगों का एक बड़ा समूह द्वारा विकसित की है और नेतृत्व द्वारा किया जाता है
+[ वाल्टर ब्राइट ] ( https://en.wikipedia.org/wiki/Walter_Bright ) और
+[ आंद्रेई Alexandrescu ] ( https://en.wikipedia.org/wiki/Andrei_Alexandrescu )।
+जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं!
+
+
+```c
+import std.stdio;
+
+void main() {
+
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    // 'auto' can be used for inferring types.
+    auto n = 1;
+
+    // संख्यात्मक literals स्पष्टता के लिए एक अंकों विभाजक के रूप में '_' का उपयोग कर सकते हैं।
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
+    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
+    // लेकिन पिछले छोड़कर।
+    foreach(i; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(i);
+    }
+
+    // वहाँ भी 'foreach_reverse' आप पीछे की ओर पाश करना चाहते हैं।
+    foreach_reverse(i; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(i);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+हम ' struct`, `class`,` union`, और `` enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
+मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा,
+हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं!
+
+```c
+// इधर, 'T' एक प्रकार पैरामीटर है। लगता है कि '&lt;+T&gt;' C++ / C/ Java से।
+struct LinkedList(T) {
+    T data = null;
+
+    // '!'का प्रयोग करें , एक पैरामिट्रीकृत प्रकार इन्स्तांत । फिर, '<T >' लगता है।
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+// केवल एक टेम्पलेट पैरामीटर नहीं है, तो  , हम कोष्ठकों छोड़ सकते हैं।
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// उपयोग उर्फ प्रकार (alias) के लिए संक्षिप्त बनाने के लिए।
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+//हम के रूप में अच्छी तरह से कार्य टेम्पलेट्स बना सकते हैं!
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक ​​कि 'A' और 'B' , तो है
+//मान प्रकार वे हमेशा ' swap()' के संदर्भ द्वारा पारित हो जाएगा  हैं ।
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// टेम्पलेट्स के साथ, हम भी मूल्यों पर परमेटेराइज़  कर सकते हैं , न सिर्फ types.With टेम्पलेट्स, हम भी नहीं है, बस प्रकार , मूल्यों पर parameterize कर सकते हैं।
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3);
+
+```
+
+Classes की बात हो रही है , एक दूसरे के लिए गुणों के बारे में बात करते हैं। एक संपत्ति
+एक value की तरह कार्य कर सकते हैं कि एक समारोह में मोटे तौर पर है, इसलिए हम कर सकते हैं
+के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (` structure.x = 7` ) है
+मनुष्य और सेटर तरीकों ( ` object.setX (7) `) !
+
+```c
+// Consider a class parameterized on types 'T' & 'U'.
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// And "getter" and "setter" methods like so:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+    // भवन निर्माताओं हमेशा नामित कर रहे हैं 'this'.
+    this(T t, U u) {
+        //यह नीचे सेटर तरीकों से मुलाकात करेंगे।
+        data = t;
+        other = u;
+    }
+
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters
+    @property void data(T t) {
+        _data = t;
+    }
+
+    @property void other(U u) {
+        _other = u;
+    }
+}
+
+//और हम इस तरह से उन का उपयोग करें :
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+   करने के लिए लिखने के लिए मानक पुस्तकालय से
+   // आयात ' stdio ' मॉड्यूल
+    // सांत्वना (आयात एक गुंजाइश के लिए स्थानीय हो सकता है) ।
+    import std.stdio;
+
+    // Call the getters to fetch the values.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+    // Call the setters to assign new values.
+    mc.data = 8;
+    mc.other = "eight";
+
+    // Call the getters again to fetch the new values.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+
+गुणों के साथ, हम तर्क की किसी भी राशि को जोड़ सकते हैं
+हमारे मनुष्य और सेटर तरीकों, और की साफ वाक्य रचना रखना
+सीधे सदस्यों तक पहुँचने !
+
+हमारे निपटान पर अन्य वस्तु उन्मुख उपहार
+` interface`s , ` सार class`es शामिल
+और ` तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
+आप कृपया के रूप में कई इंटरफेस को लागू करने, एक वर्ग का विस्तार ।
+
+हम डी एस OOP सुविधाओं देखा , लेकिन स्विच गियर छोड़ दिया । डी प्रस्तावों
+प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, ` pure`
+काम करता है, और अपरिवर्तनीय डेटा । इसके अलावा, अपने पसंदीदा के सभी
+कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं)
+अद्भुत ` std.algorithm` मॉड्यूल में पाया!
+
+```c
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // builds an end-exclusive range
+
+void main() {
+    // हम भी ints के वर्गों की एक सूची का योग मुद्रित करना चाहते हैं
+    // 1 से 100 के लिए आसान करने के लिए!
+
+    // बस टेम्पलेट पैरामीटर के रूप में लैम्ब्डा भाव के पास!
+    // आप आप की तरह किसी भी पुराने समारोह पारित कर सकते हैं , लेकिन lambdas यहाँ सुविधाजनक हैं।
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+हम NUM गणना करने के लिए एक अच्छा Haskellian पाइपलाइन का निर्माण करने के लिए मिला सूचना कैसे ?
+यही कारण है कि एक डी नवाचार करने के लिए धन्यवाद वर्दी समारोह कॉल सिंटेक्स के रूप में जानते हैं।
+UFCS के साथ, हम एक विधि के रूप में एक समारोह कॉल लिखने के लिए चुन सकते हैं
+या मुफ्त समारोह कॉल ! वाल्टर इस पर एक अच्छा लेख लिखा था
+[यहाँ ।] ( http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 )
+संक्षेप में, आप जिनकी पहली पैरामीटर कार्यों कॉल कर सकते हैं
+एक विधि के रूप में ग्रुप ए की किसी भी अभिव्यक्ति पर कुछ प्रकार एक की है ।
+
+मैं समानता चाहते । समानता की तरह कोई और? ज़रूर तुम करना। चलो कुछ करते हैं!
+```c
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+ // हम हमारे सरणी में वर्गमूल हर नंबर ले जाना चाहता हूँ ,
+ // हम उपलब्ध है के रूप में और के रूप में कई कोर का लाभ ले।
+    auto arr = new double[1_000_000];
+
+   // संदर्भ के द्वारा एक सूचकांक , और एक सरणी तत्व का प्रयोग
+    // और सिर्फ सरणी पर समानांतर फोन!
+    foreach(i, ref elem; parallel(arr)) {
+        ref = sqrt(i + 1.0);
+    }
+}
+
+
+```
diff --git a/hq9+.html.markdown b/hq9+.html.markdown
new file mode 100644
index 00000000..3f0c5fba
--- /dev/null
+++ b/hq9+.html.markdown
@@ -0,0 +1,39 @@
+---
+language: HQ9+
+filename: hq9+.html
+contributors:
+    - ["Alexey Nazaroff", "https://github.com/rogaven"]
+---
+
+HQ9+ is a joke programming language created by Cliff Biffle. It has only four commands and it isn't Turing-complete.
+
+```
+There is only 4 commands, represented by next characters
+H: print "Hello, world!"
+Q: print the program's source code (a Quine)
+9: print the lyrics to "99 Bottles of Beer"
++: add one to the accumulator (the value of the accumulator cannot be accessed)
+Any other character is ignored.
+
+Ok. Let's write some program:
+  HQ9
+
+Result:
+  Hello world!
+  HQ9
+
+HQ9+ is very simple, but allows you to do some things that are very difficult
+in other languages. For example, here is a program that creates three copies of
+itself on the screen:
+  QQQ
+
+This produces:
+  QQQ
+  QQQ
+  QQQ
+```
+
+And that's all. There are a lot of interpreters for HQ9+. Below you can find one of them
+
++ [One of online interpreters](https://almnet.de/esolang/hq9plus.php)
++ [HQ9+ official website](http://cliffle.com/esoterica/hq9plus.html)
diff --git a/html.html.markdown b/html.html.markdown
new file mode 100644
index 00000000..3c855b5c
--- /dev/null
+++ b/html.html.markdown
@@ -0,0 +1,120 @@
+---
+language: html
+filename: learnhtml.html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Robert Steed", "https://github.com/robochat"]
+---
+
+HTML stands for HyperText Markup Language. 
+It is a language which allows us to write pages for the world wide web.
+It is a markup language, it enables us to write webpages using code to indicate how text and data should be displayed.
+In fact, html files are simple text files.
+What is this markup? It is a method of organising the page's data by surrounding it with opening tags and closing tags.
+This markup serves to give significance to the text that it encloses. 
+Like other computer languages, HTML has many versions. Here we will talk about HTML5.
+
+**NOTE :**  You can test the different tags and elements as you progress through the tutorial on a site like [codepen](http://codepen.io/pen/) in order to see their effects, understand how they work and familiarise yourself with the language.
+This article is concerned principally with HTML syntax and some useful tips.
+
+
+```html
+<!-- Comments are enclosed like this line! -->
+
+<!-- #################### The Tags #################### -->
+   
+<!-- Here is an example HTML file that we are going to analyse. -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>My Site</title>
+		</head>
+		<body>
+			<h1>Hello, world!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">Come look at what this shows</a>
+			<p>This is a paragraph.</p>
+			<p>This is another paragraph.</p>
+			<ul>
+				<li>This is an item in a non-enumerated list (bullet list)</li>
+				<li>This is another item</li>
+				<li>And this is the last item on the list</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- An HTML file always starts by indicating to the browser that the page is HTML. -->
+<!doctype html>
+
+<!-- After this, it starts by opening an <html> tag. -->
+<html>
+
+<!-- that will be closed at the end of the file with </html>. -->
+</html>
+
+<!-- Nothing should appear after this final tag. -->
+
+<!-- Inside (between the opening and closing tags <html></html>), we find: -->
+
+<!-- A header defined by <head> (it must be closed with </head>). -->
+<!-- The header contains some description and additional information which are not displayed; this is metadata. -->
+
+<head>
+	<title>My Site</title><!-- The tag <title> indicates to the browser the title to show in browser window's title bar and tab name. -->
+</head>
+
+<!-- After the <head> section, we find the tag - <body> -->
+<!-- Until this point, nothing described will show up in the browser window. -->
+<!-- We must fill the body with the content to be displayed. -->
+
+<body>
+	<h1>Hello, world!</h1> <!-- The h1 tag creates a title. -->
+	<!-- There are also subtitles to <h1> from the most important (h2) to the most precise (h6). -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">Come look at what this shows</a> <!-- a hyperlink to the url given by the attribute href="" -->
+	<p>This is a paragraph.</p> <!-- The tag <p> lets us include text in the html page. -->
+	<p>This is another paragraph.</p>
+	<ul> <!-- The tag <ul> creates a bullet list. -->
+	<!-- To have a numbered list instead we would use <ol> giving 1. for the first element, 2. for the second, etc. -->
+		<li>This is an item in a non-enumerated list (bullet list)</li>
+		<li>This is another item</li>
+		<li>And this is the last item on the list</li>
+	</ul>
+</body>
+
+<!-- And that's it, creating an HTML file can be simple. -->
+
+<!-- But it is possible to add many additional types of HTML tags. -->
+
+<!-- To insert an image. -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- The source of the image is indicated using the attribute src="" -->
+<!-- The source can be an URL or even path to a file on your computer. -->
+
+<!-- It is also possible to create a table. -->
+
+<table> <!-- We open a <table> element. -->
+	<tr> <!-- <tr> allows us to create a row. -->
+		<th>First Header</th> <!-- <th> allows us to give a title to a table column. -->
+		<th>Second Header</th>
+	</tr>
+	<tr>
+		<td>first row, first column</td> <!-- <td> allows us to create a table cell. -->
+		<td>first row, second column</td>
+	</tr>
+	<tr>
+		<td>second row, first column</td>
+		<td>second row, second column</td>
+	</tr>
+</table>
+
+```
+
+## Usage
+
+HTML is written in files ending with `.html`.
+
+## To Learn More 
+
+* [wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/hu-hu/ruby-hu.html.markdown b/hu-hu/ruby-hu.html.markdown
index 169f2b8e..f2fe4e5d 100644
--- a/hu-hu/ruby-hu.html.markdown
+++ b/hu-hu/ruby-hu.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: ruby
 lang: hu-hu
-filenev: learnruby.rb
+filename: learnruby-hu.rb
 contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
@@ -13,7 +13,7 @@ contributors:
   - ["Dzianis Dashkevich", "https://github.com/dskecse"]
   - ["Levi Bostian", "https://github.com/levibostian"]
   - ["Rahil Momin", "https://github.com/iamrahil"]
-  translators:
+translators:
   - ["Zsolt Prontvai", "https://github.com/prozsolt"]
 ---
 
diff --git a/hu-hu/typescript-hu.html.markdown b/hu-hu/typescript-hu.html.markdown
new file mode 100644
index 00000000..aedd5a64
--- /dev/null
+++ b/hu-hu/typescript-hu.html.markdown
@@ -0,0 +1,175 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Tamás Diószegi", "https://github.com/ditam"]
+filename: learntypescript-hu.ts
+lang: hu-hu
+---
+
+A TypeScript nyelv a JavaScript nyelven írt nagy méretű alkalmazások fejlesztését kívánja megkönnyíteni.
+A TypeScript olyan, más nyelvekből ismert gyakori fogalmakat ad hozzá a JavaScripthez, mint például osztályok, interfészek, generikusság, és (opcionális) statikus típusosság.
+A JavaScript egy befoglaló halmazát képzi: minden JavaScript kód érvényes TypeScript kód, így könnyen hozzáadható meglévő projektekhez. A TypeScript fordító kimenetként JavaScript kódot állít elő.
+
+Ez a dokumentum a TypeScript által hozzáadott új szintaxissal foglalkozik, nem pedig a [Javascripttel](../javascript/).
+
+Hogy kipróbáld a TypeScript fordítót, látogass el a [Játszótérre avagy Playground-ra](http://www.typescriptlang.org/Playground) ahol kódot írhatsz automatikus kódkiegészítéssel, és közvetlenül láthatod az előállított JavaScript kódot.
+
+```js
+// 3 alapvető típus létezik TypeScriptben
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Amikor nem lehet a típust előre tudni, használható az "Any" típus
+var notSure: any = 4;
+notSure = "talán mégis sztring lesz";
+notSure = false; // tévedtem, mégis boolean
+
+// Kollekciókból létezik típusos és generikus tömb
+var list: number[] = [1, 2, 3];
+// ugyanez a generikus típus használatával
+var list: Array<number> = [1, 2, 3];
+
+// Enumerált típusok:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Végül, "void" használható a visszatérési értékkel nem bíró függvényeknél
+function bigHorribleAlert(): void {
+  alert("Kis idegesítő doboz vagyok!");
+}
+
+// A függvények elsőrangú (first-class) típusok, használható a vastag nyilas
+// lambda szintaxis,
+// a compiler pedig kikövetkezteti a típusokat (inferred types)
+
+// A következők egyenértékűek, ugyanaz a szignatúra kerül kikövetkeztetésre, és
+// így ugyanaz a JavaScript kód lesz előállítva
+var f1 = function(i: number): number { return i * i; }
+// Következtetett visszatérési értékkel
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Következtetett visszatérési értékkel
+var f4 = (i: number) => { return i * i; }
+// Következtetett visszatérési értékkel, 
+// ebben az egysoros formában nem szükséges a return kulcsszó
+var f5 = (i: number) =>  i * i;
+
+// Az interfészek szerkezeti alapon működnek, vagyis minden objektum, ahol 
+// jelen vannak a megfelelő mezők kompatibilis az interfésszel
+interface Person {
+  name: string;
+  // Az opcionális tagokat "?" jelöli
+  age?: number;
+  // És persze függvények is:
+  move(): void;
+}
+
+// Egy objektum, ami megvalósítja a "Person" interfészt
+// Tekinthető Personnek, hiszen van name és move mezője
+var p: Person = { name: "Bobby", move: () => {} };
+// Egy objektum, ahol az opcionális mező is jelen van:
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// Ez viszont nem Person, mert az age mező típusa nem szám!
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Az interfészekkel függvény típusok is leírhatóak:
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Csak a paraméterek típusai számítanak, a neveik nem.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Osztályok - a mezők alapértelmezésben publikusak
+class Point {
+    // Mezők
+    x: number;
+
+    // Konstruktor - a public/private kulcsszavak ebben a kontextusban
+    // legenerálják a mezőkhöz szükséges kódot a konstruktorban.
+    // Ebben a példában az "y" ugyanúgy definiálva lesz, mint az "x", csak 
+    // kevesebb kóddal.
+    // Alapértelmezett (default) értékek is megadhatóak.
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Metódusok
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Statikus mezők
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y itt 0 lesz
+
+// Öröklés
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Szükséges az ősosztály konstruktorának explicit hívása
+    }
+
+    // Felülírás
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Modulok
+// ("." használható az almodulok számára)
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Új lokális név definiálása a module számára
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Generikus típusok
+// Osztályok
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfészek
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// és függvények
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// definíciós fájl hivatkozása:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## További források
+ * [TypeScript hivatalos weboldala] (http://www.typescriptlang.org/)
+ * [TypeScript nyelv specifikációja (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Forráskód GitHubon] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - típusdefiníciók gyűjteménye] (http://definitelytyped.org/)
diff --git a/hy.html.markdown b/hy.html.markdown
index 9beaff0c..79c16c23 100644
--- a/hy.html.markdown
+++ b/hy.html.markdown
@@ -3,13 +3,14 @@ language: hy
 filename: learnhy.hy
 contributors:
     - ["Abhishek L", "http://twitter.com/abhishekl"]
+    - ["Zirak", "http://zirak.me"]
 ---
 
 Hy is a lisp dialect built on top of python. This is achieved by
 converting hy code to python's abstract syntax tree (ast). This allows
 hy to call native python code or python to call native hy code as well
 
-This tutorial works for hy ≥ 0.9.12
+This tutorial works for hy ≥ 0.9.12, with some corrections for hy 0.11.
 
 ```clojure
 ;; this gives an gentle introduction to hy for a quick trial head to
@@ -89,6 +90,17 @@ True ; => True
 (foolists 3) ;=> [3 2]
 (foolists 10 3) ;=> [10 3]
 
+; you can use rest arguments and kwargs too:
+(defn something-fancy [wow &rest descriptions &kwargs props]
+  (print "Look at" wow)
+  (print "It's" descriptions)
+  (print "And it also has:" props))
+
+(something-fancy "My horse" "amazing" :mane "spectacular")
+  
+; you use apply instead of the splat operators:
+(apply something-fancy ["My horse" "amazing"] { "mane" "spectacular" })
+
 ; anonymous functions are created using `fn' or `lambda' constructs
 ; which are similiar to `defn'
 (map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
@@ -102,6 +114,8 @@ True ; => True
 
 ; slice lists using slice
 (slice mylist 1 3) ;=> [2 3]
+; or, in hy 0.11, use cut instead:
+(cut mylist 1 3) ;=> [2 3]
 
 ; get elements from a list or dict using `get'
 (get mylist 1) ;=> 2
@@ -122,6 +136,22 @@ True ; => True
 ; a.foo(arg) is called as (.foo a arg)
 (.split (.strip "hello world  ")) ;=> ["hello" "world"]
 
+; there is a shortcut for executing multiple functions on a value called the
+; "threading macro", denoted by an arrow:
+(-> "hello world  " (.strip) (.split)) ;=> ["hello" "world]
+; the arrow passes the value along the calls as the first argument, for instance:
+(-> 4 (* 3) (+ 2))
+; is the same as:
+(+ (* 4 3) 2)
+
+; there is also a "threading tail macro", which instead passes the value as the
+; second argument. compare:
+(-> 4 (- 2) (+ 1)) ;=> 3
+(+ (- 4 2) 1) ;=> 3
+; to:
+(->> 4 (- 2) (+ 1)) ;=> -1
+(+ 1 (- 2 4)) ;=> -1
+
 ;; Conditionals
 ; (if condition (body-if-true) (body-if-false)
 (if (= passcode "moria")
@@ -160,6 +190,14 @@ True ; => True
    [get-spell (fn [self]
               self.spell)]])
 
+; or, in hy 0.11:
+(defclass Wizard [object]
+  (defn --init-- [self spell]
+    (setv self.spell spell))
+
+  (defn get-spell [self]
+    self.spell))
+
 ;; do checkout hylang.org
 ```
 
@@ -169,6 +207,6 @@ This tutorial is just a very basic introduction to hy/lisp/python.
 
 Hy docs are here: [http://hy.readthedocs.org](http://hy.readthedocs.org)
 
-Hy's Github repo: [http://github.com/hylang/hy](http://github.com/hylang/hy)
+Hy's GitHub repo: [http://github.com/hylang/hy](http://github.com/hylang/hy)
 
 On freenode irc #hy, twitter hashtag #hylang
diff --git a/id-id/asciidoc-id.html.markdown b/id-id/asciidoc-id.html.markdown
new file mode 100644
index 00000000..8da8af38
--- /dev/null
+++ b/id-id/asciidoc-id.html.markdown
@@ -0,0 +1,125 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+translators:
+    - ["Rizky Luthfianto", "http://github.com/rilut"]
+filename: asciidoc-id.md
+lang: id-id
+---
+
+AsciiDoc adalah bahasa markup yang mirip dengan Markdown dan dapat digunakan untuk apa saja, untuk menulis buku maupun blog. Dibuat pada tahun 2002 oleh Stuart Rackham, bahasa ini sederhana tetapi memungkinkan sejumlah besar kustomisasi.
+
+Kepala Dokumen
+
+Kepala Dokumen adalah opsional dan tidak dapat berisi baris kosong. Harus diimbangi konten, setidaknya satu baris kosong.
+
+Hanya Judul 
+
+```
+= Judul Dokumen
+
+Kalimat pertama dokumen.
+```
+
+Judul dan Penulis
+
+```
+= Judul Dokumen
+Pertama terakhir <first.last@learnxinyminutes.com>
+
+Awal dokumen ini.
+```
+
+Banyak Penulis
+
+```
+= Judul Dokumen
+John Doe <john@go.com>; Jane Doe <jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Memulai dokumen dengan banyak penulis.
+```
+
+Garis Revisi (membutuhkan garis penulis)
+
+```
+= Judul Dokumen V1
+Manusia Kentang <keripik@renyah.com>
+v1.0, 2016/01/13
+
+Artikel tentang keripik ini akan menjadi menyenangkan.
+```
+
+Paragraf
+
+```
+Anda tidak perlu sesuatu yang istimewa untuk paragraf.
+
+Tambahkan baris kosong antara paragraf untuk memisahkan mereka.
+
+Untuk membuat baris kosong, tambahkan: +
+dan Anda akan mendapat satu baris kosong!
+```
+
+Memformat Teks
+
+```
+_underscore menciptakan miring_
+*Tanda bintang untuk tebal*
+*_Gabungkan biar makin asyik_*
+`Penggunaan tanda petik untuk menandakan monospace`
+`*Monospace tebal*`
+```
+
+Judul bagian
+
+```
+= Level 0 (hanya dapat digunakan dalam header dokumen)
+
+== Level 1 <h2>
+
+=== Level 2 <h3>
+
+==== Level 3 <h4>
+
+===== Level 4 <h5>
+
+====== Level 5 <h6>
+
+======= Level 6 <h7>
+
+```
+
+Daftar
+
+Untuk membuat daftar bullet, gunakan tanda bintang.
+
+```
+* foo
+* bar
+* baz
+```
+
+Untuk membuat daftar bernomor, gunakan titik.
+
+```
+. Item 1
+. item 2
+. Item 3
+```
+
+Anda bisa membuat daftar bersarang dengan menambahkan tanda bintang atau titik tambahan hingga lima kali.
+
+```
+* Foo 1
+** Foo 2
+*** Foo 3
+**** Foo 4
+***** Foo 5
+
+. foo 1
+.. Foo 2
+... Foo 3
+.... Foo 4
+..... Foo 5
+```
diff --git a/id-id/coffeescript-id.html.markdown b/id-id/coffeescript-id.html.markdown
new file mode 100644
index 00000000..7fa40bb6
--- /dev/null
+++ b/id-id/coffeescript-id.html.markdown
@@ -0,0 +1,106 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+filename: coffeescript-id.coffee
+translators:
+  - ["Rizky Luthfianto", "http://github.com/rilut"]
+lang: id-id
+---
+
+CoffeeScript adalah bahasa sederhana yang diterjemahkan saat kompilasi ke dalam JavaScript,
+dan bukan diterjemahkan pada saat *runtime*.  
+CoffeeScript mencoba agar kode JavaScript yang dihasilkan tetap mudah dibaca
+dan kompatibel dengan semua *runtime* JavaScript.
+
+Lihat juga [website CoffeeScript](http://coffeescript.org/) yang memiliki tutorial lengkap tentang CoffeeScript.
+
+```CoffeeScript
+# CoffeeScript adalah bahasa hipster.
+# Mengikuti tren bahasa modern lainnya.
+# Sehingga, seperti Ruby dan Python, untuk komentar digunakan tanda pagar.
+
+###
+Ini adalah contoh blok komentar, yang nanti diterjemahkan langsung ke '/ *' dan '* /'
+pada kode JavaScript yang dihasilkan.
+
+Anda diharapkan sedikit memahami semantik JavaScript sebelum melanjutkan tutorial ini.
+###
+
+# Pengisian nilai variabel:
+angka = 42 #=> var angka = 42;
+kebalikan = true #=> var kebalikan = true;
+
+# Kondisi:
+angka = -42 if kebalikan #=> if(kebalikan) { angka = -42; }
+
+# Fungsi:
+kuadrat = (x) -> x * x #=> var kuadrat = function(x) { return x * x; }
+
+isi = (wadah, cairan = "kopi") ->
+  "Mengisi #{wadah} dengan #{cairan}..."
+#=>var isi;
+#
+#isi = function(wadah, cairan) {
+#  if (cairan == null) {
+#    cairan = "kopi";
+#  }
+#  return "Mengisi " + wadah + " dengan " + cairan + "...";
+#};
+
+# Rentang:
+list = [1..5] # => var list = [1, 2, 3, 4, 5];
+
+# Objek:
+fungsi_matematika =
+  akar:   Math.sqrt
+  kuadrat: kuadrat
+  kubik:   (x) -> x * kuadrat x
+#=> var fungsi_matematika = {
+#    "akar": Math.sqrt,
+#    "kuadrat": kuadrat,
+#    "kubik": function(x) { return x * kuadrat(x); }
+#   };
+
+# *Splat*:
+balapan = (pemenang, pelari...) ->
+  print pemenang, pelari
+#=>balapan = function() {
+#    var pelari, pemenang;
+#    pemenang = arguments[0], pelari = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#    return print(pemenang, pelari);
+#  };
+
+# Cek keberadaan:
+alert "Elvis ada!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Elvis ada!"); }
+
+# Komprehensi *array*:
+kubik_kubik = (fungsi_matematika.kubik angka for angka in list)
+#=>kubik_kubik = (function() {
+#     var _i, _len, _hasil;
+#     _hasil = [];
+#     for (_i = 0, _len = list.length; _i < _len; _i++) {
+#         angka = list[_i];
+#         _hasil.push(fungsi_matematika.kubik(angka));
+#     }
+#     return _hasil;
+#})();
+
+sayur_sayuran = ['brokoli', 'bayam', 'kemangi']
+makan sayuran for sayuran in sayur_sayuran when sayuran isnt 'kemangi'
+#=>sayur_sayuran = ['brokoli', 'bayam', 'kemangi'];
+#
+#for (_k = 0, _len2 = sayur_sayuran.length; _k < _len2; _k++) {
+#  sayuran = sayur_sayuran[_k];
+#  if (sayuran !== 'kemangi') {
+#    makan(sayuran);
+#  }
+#}
+```
+
+## Referensi Tambahan
+
+- [Smooth CoffeeScript (EN)] (http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto (EN)] (https://leanpub.com/coffeescript-ristretto/read)
diff --git a/id-id/java-id.html.markdown b/id-id/java-id.html.markdown
new file mode 100644
index 00000000..a5455952
--- /dev/null
+++ b/id-id/java-id.html.markdown
@@ -0,0 +1,801 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+filename: LearnJava-id.java
+translators:
+  - ["Ahmad Zafrullah", "https://github.com/23Pstars"]
+lang: id-id
+---
+
+Java adalah bahasa pemrograman yang memiliki tujuan umum dan berorientasi kelas dan objek.
+[Baca lebih lanjut.](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Komentar satu baris diawali dengan // (dua garis miring)
+/*
+Ini adalah contoh komentar banyak-baris.
+*/
+/**
+Ini adalah contoh komentar JavaDoc. Digunakan untuk mendeskripsikan sebuah kelas,
+atau beberapa sifat dari kelas tersebut.
+*/
+
+// Menyertakan kelas ArrayList dalam paket java.util
+import java.util.ArrayList;
+// Menyertakan semua kelas yang ada dalam paket java.security
+import java.security.*;
+
+// Setiap dokumen .java sebuah kelas publik dengan nama yang sama dengan nama kelas.
+public class BelajarJava {
+
+    // Untuk menjalankan program java, program harus memiliki sebuah method utama (main) sebagai awalan.
+    public static void main (String[] args) {
+
+        // System.out.println() digunakan untuk menampilkan satu baris teks.
+        System.out.println("Halo Dunia!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // System.out.print() hanya menampilkan teks tanpa baris baru.
+        System.out.print("Halo ");
+        System.out.print("Dunia");
+
+        // System.out.printf() memudahkan dalam mengatur format penampilan.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        ///////////////////////////////////////
+        // Variabel
+        ///////////////////////////////////////
+
+        /*
+        *  Deklarasi Variabel
+        */
+        // Deklarasi variabel menggunakan format <tipe> <nama>
+        int nilai;
+        // Deklarasi banyak variabel menggunakan format yang sama <tipe> <nama1>, <tipe> <nama2>, <tipe> <nama3>
+        int nilai1, nilai2, nilai3;
+
+        /*
+        *  Inisialisasi Variabel
+        */
+
+        // Inisialisasi sebuah variabel menggunakan <tipe> <nama> = <nilai>
+        int nilai = 1;
+        // Inisialisasi banyak variabel menggunakan format yang sama <tipe> <nama1>, <nama2>, <nama3> = <nilai>
+        int nilai1, nilai2, nilai3;
+        nilai1 = nilai2 = nilai3 = 1;
+
+        /*
+        *  Tipe Variabel
+        */
+        // Byte - 8 bit signed untuk bilangan bulat komplemen 2
+        // (-128 <= byte <= 127)
+        byte nilaiByte = 100;
+
+        // Short - 8 bit signed untuk bilangan bulat komplemen 2
+        // (-32,768 <= short <= 32,767)
+        short nilaiShort = 10000;
+
+        // Integer - 32 bit signed untuk bilangan bulat komplemen 2
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int nilaiInt = 1;
+
+        // Long - 64 bit signed untuk bilangan bulat komplemen 2
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long nilaiLong = 100000L;
+        // Karakter "L" pada akhir nilai menyatakan tipe Long;
+        // selainnya akan dianggap sebagai nilai bilangan bulat.
+
+        // Catatan: Java tidak memiliki tipe unsigned.
+
+        // Float - Presisi-satu 32-bit standar IEEE 754 untuk Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127
+        float nilaiFloat = 234.5f;
+        // Karakter "f" atau "F" pada akhir nilai menyatakan tipe Float;
+        // selainnya akan dianggap sebagai nilai double.
+
+        // Double - Presisi-dua 64-bit standar IEEE 754 untuk Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double nilaiDouble = 123.4;
+
+        // Boolean - true & false
+        boolean nilaiBoolean = true;
+        boolean nilaiBoolean = false;
+
+        // Char - Sebuah karakter Unicode 16-bit
+        char nilaiChar = 'A';
+
+        // Variabel "final" tidak dapat di-set kembali nilainya pada objek lain,
+        final int WAKTU_SAYA_BEKERJA_TIAP_MINGGU = 9001;
+        // tapi dapat dilakukan inisialisasi diwaktu yang lain.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger - Bilangan bulat yang memiliki presisi dinamis
+        //
+        // BigInteger adalah tipe data yang memungkinkan pembuat program untuk memanipulasi
+        // bilangan bulat lebih panjang dari 64-bit. Bilangan bulat tersebut tersimpan dalam
+        // bentuk kumpulan byte (array) dan dimanipulasi menggunakan fungsi yang sudah tersedia
+        // pada BigInteger
+        //
+        // BigInteger dapat diinisialisasi menggunakan kumpulan byte atau teks.
+        
+        BigInteger nilaiBigInteger = new BigInteger(kumpulanByte);
+
+
+        // BigDecimal - Bilangan signed desimal yang memiliki presisi dinamis
+        //
+        // Tipe BigDecimal memiliki dua bagian: sebuah bilangan bulat dengan nilai presisi
+        // dinamis tanpa skala dan sebuah bilangan bulat skala 32-bit.
+
+        // BigDecimal memungkinkan pembuat program untuk memegang kontrol penuh
+        // terhadap batas desimal. BigDecimal baik digunakan untuk nilai tukar mata uang
+        // dimana sangat mementingkan presisi nilai desimal.
+        //
+        // BigDecimal dapat diinisialisasi dengan int, long, double, String,
+        // atau dengan melakukan inisialisasi nilai tanpa skala (BigInteger) 
+        // dan nilai dengan skala (int). 
+
+        BigDecimal nilaiBigDecimal = new BigDecimal(nilaiBigInteger, nilaiInt);
+        
+        // Perlu diperhatikan konstruktor yang digunakan apakah float atau double
+        // karena dapat mengakibatkan ketidak-akurasian float/double yang akan digunakan
+        // dalam BigDecimal. Sebaiknya gunakan nilai String pada konstruktor
+        // jika membutuhkan nilai pasti.
+        
+        BigDecimal sepuluhSen = new BigDecimal("0.1");
+
+
+        // Strings
+        String nilaiString1 = "Ini adalah contoh String!";
+
+        // Karakter \n berfungsi untuk membuat baris baru 
+        String nilaiString2 = "Menampilkan baris baru?\nTidak masalah!";
+        // Karakter \t berfungsi untuk membuat tab antar karakter
+        String nilaiString3 = "Ingin menambahkan sebuah tab?\tTidak masalah!";
+        System.out.println(nilaiString1);
+        System.out.println(nilaiString2);
+        System.out.println(nilaiString3);
+
+        // Larik (array)
+        // Ukuran array harus ditentukan ketika instansiasi
+        // Format berikut adalah beberapa cara deklarasi array
+        // <tipe data>[] <nama variabel> = new <tipe data>[<ukuran array>];
+        // <tipe data> <nama variabel>[] = new <tipe data>[<ukuran array>];
+        int[] barisAngka = new int[10];
+        String[] barisString = new String[1];
+        boolean barisBoolean[] = new boolean[100];
+
+        // Cara lain untuk mendeklarasikan dan menginisialisasi sebuah array
+        int[] y = {9000, 1000, 1337};
+        String nama[] = {"Andi", "Budi", "Agus"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Indeks sebuah array - Mengakses sebuah elemen
+        System.out.println("barisAngka @ 0: " + barisAngka[0]);
+
+        // Array menggunakan indeks 0 yang tetap.
+        barisAngka[1] = 1;
+        System.out.println("barisAngka @ 1: " + barisAngka[1]); // => 1
+
+        // Lainnya yang perlu diketahui
+        // ArrayLists - Sama seperti array biasa, namum penggunaannya sudah ditentukan,
+        //              dan ukurannya dapat berubah-ubah.
+        // LinkedLists - Implementasi dari doubly-linked list. Semua operasi yang digunakan
+        //               hampir sama dengan operasi yang dimiliki oleh sebuah doubly-linked list.
+        // Maps - Sebuah kumpulan objek yang menyatakan hubungan antara kunci dan nilai. Map merupakan
+        //        sebuah interface sehingga tidak dapat diinstansiasi. Jenis kunci dan nilai yang digunakan
+        //        pada Map harus spesifik pada saat instansiasi ketika diimplementasikan pada sebuah kelas.
+        //        Setiap kunci hanya memiliki sebuah nilai, dan hanya muncul sekali.
+        // HashMaps - Kelas ini menggunakan tabel-hash untuk mengimplementasikan interface Map.
+        //            Hal ini memungkinkan waktu eksekusi ketika melakukan operasi dasar (mengakses
+        //            dan menambahkan elemen) menjadi konstan, meskipun memiliki banyak set data.
+
+        ///////////////////////////////////////
+        // Operator
+        ///////////////////////////////////////
+        System.out.println("\n->Operator");
+
+        int i1 = 1, i2 = 2; // Cara singkat untuk deklarasi banyak nilai
+
+        // Kemudahan dalam artimatika
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int menghasilkan int juga)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+        // Modulus
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Operator Perbandingan
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Operator Boolean
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Operator Bitwise
+        /*
+        ~      Unary bitwise complement
+        <<     Signed left shift
+        >>     Signed/Arithmetic right shift
+        >>>    Unsigned/Logical right shift
+        &      Bitwise AND
+        ^      Bitwise exclusive OR
+        |      Bitwise inclusive OR
+        */
+
+        // Peningkatan
+        int i = 0;
+        System.out.println("\n->Pengurangan/Peningkatan");
+        // Operator ++ dan -- masing-masing melakukan peningkatan dan penurunan 1 nilai.
+        // Jika diletakkan sebelum variabel, maka akan di tambah/kurang 1 sebelum dilakukan perintah lainnya;
+        // jika setelah variabel, maka akan ditambah/kurang 1 setelah dilakukan perintah lainnya;
+        System.out.println(i++); // i = 1, prints 0 (peningkatan setelahnya)
+        System.out.println(++i); // i = 2, prints 2 (peningkatan sebelumnya)
+        System.out.println(i--); // i = 1, prints 2 (pengurangan setelahnya)
+        System.out.println(--i); // i = 0, prints 0 (pengurangan sebelumnya)
+
+        ///////////////////////////////////////
+        // Struktur Kontrol
+        ///////////////////////////////////////
+        System.out.println("\n->Struktur Kontrol");
+
+        // Perintah "if" hampir sama dengan bahasa C
+        int j = 10;
+        if (j == 10) {
+            System.out.println("Saya ditampilkan");
+        } else if (j > 10) {
+            System.out.println("Saya tidak ditampilkan");
+        } else {
+            System.out.println("Saya juga tidak ditampilkan");
+        }
+
+        // Perulangan "while"
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Tingkatkan penghitung
+            // 100 kali iterasi, fooWhile 0,1,3,...,99
+            fooWhile++;
+        }
+        System.out.println("Nilai fooWhile: " + fooWhile);
+
+        // Perulangan "do...while"
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Tingkatkan penghitung
+            // 99 kali iterasi, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("Nilai fooDoWhile: " + fooDoWhile);
+
+        // Perulangan "for"
+        // Struktur perulangan "for" => for(<awal_pernyataan>; <kondisi>; <langkah/tahapan>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // 10 kali iterasi, foofor 0-9
+        }
+        System.out.println("Nilai fooFor: " + fooFor);
+        
+        // Perulangan "for" bertingkat dengan label "exit"
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // Menghentikan semua perulangan, tidak hanya perulangan bagian dalam saja 
+            }
+          }
+        }
+        
+        // Perulangan "for each"
+        // Perulangan "for" juga dapat melakukan iterasi terhadap larik (array) dari objek
+        // yang mana mengimplementasikan interface Ieterable.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // Struktur perulangan "for each" => for (<objek> : <iterable>)
+        // dibaca: setiap elemen dalam iterable
+        // catatan: tipe objek harus sama dengan tipe iterable
+
+        for (int bar : fooList) {
+            System.out.println(bar);
+            // Melakukan interasi sebanyak 9 kali dan menampilkan 1-9 tiap baris
+        }
+
+        // "switch case"
+        // "switch" dapat digunakan pada byte, short, char, dan tipe data bilangan bulat (int).
+        // "switch" juga dapat digunakan pada tipe "enum" (dijelaskan nanti), kelas String,
+        // dan beberapa kelas khusus yang mengandung tipe data primitif:
+        // Character, Byte, Short, dan Integer.
+        int bulan = 3;
+        String bulanString;
+        switch (bulan) {
+            case 1: bulanString = "Januari";
+                    break;
+            case 2: bulanString = "Februari";
+                    break;
+            case 3: bulanString = "Maret";
+                    break;
+            default: bulanString = "Bulan lainnya";
+                     break;
+        }
+        System.out.println("Hasil switch case: " + bulanString);
+        
+        // Mulai dari Java 7 keatas, "switch" memiliki format:
+        String jawabanSaya = "mungkin";
+        switch(jawabanSaya) {
+            case "ya":
+                System.out.println("Anda menjawab ya.");
+                break;
+            case "tidak":
+                System.out.println("Anda menjawab tidak.");
+                break;
+            case "mungkin":
+                System.out.println("Anda menjawab mungkin.");
+                break;
+            default:
+                System.out.println("Anda menjawab " + jawabanSaya);
+                break;
+        }
+
+        // Pengkondisian dengan cara singkat
+        // Karakter '?' dapat digunakan untuk penilaian atau logika secara cepat antara dua pernyataan.
+        // Dibaca "Jika (pernyataan) adalah benar, gunakan <nilai pertama>, sisanya gunakan <nilai kedua>
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Menampilkan A, karena pernyataannya benar
+
+
+        ////////////////////////////////////////
+        // Konversi Data dan Tipe Data (Typecasting)
+        ////////////////////////////////////////
+
+        // Konversi Data
+
+        // Konversi String ke Integer
+        Integer.parseInt("123");    // menghasilkan nilai versi Integer dari "123"
+
+        // Konversi Integer ke String
+        Integer.toString(123);      // menghasilkan nilai versi String dari 123
+
+        // Untuk konversi lainnya silakan coba kelas berikut:
+        // Double
+        // Long
+        // String
+
+        // Typecasting
+        // Objek dalam Java juga dapat dikonversi, banyak penjelasan dan aturan
+        // dengan beberapa konsep sederhana. Silakan cek di alamat berikut:
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Kelas dan Fungsi
+        ///////////////////////////////////////
+
+        System.out.println("\n->Kelas & Fungsi");
+
+        // (penjelasan mengenai kelas "Sepeda" ada dibawah)
+
+        // Gunakan "new" untuk melakukan instansiasi pada kelas
+        Sepeda laju = new Sepeda();
+
+        // Memanggil method objek
+        laju.tambahKecepatan(3); // Dapat juga digunakan "setter" dan "getter" method
+        laju.setIrama(100);
+
+        // Method "toString()" menghasilkan representasi string dari objek.
+        System.out.println("informasi jalur: " + laju.toString());
+
+        // Dua Pasang Inisialisasi
+        // Bahasa Java tidak memiliki sintaks untuk membuat koleksi dari "static" sekaligus
+        // dengan mudah, kecuali dengan cara berikut:
+
+        private static final Set<String> NEGARA = new HashSet<String>();
+        static {
+           validCodes.add("INDONESIA");
+           validCodes.add("MALAYSIA");
+           validCodes.add("SINGAPURA");
+        }
+
+        // Terdapat cara yang baik untuk menulis skrip dengan mudah,
+        // dengan menggunakan Dua-Kurung Kurawal Inisialisasi (Double Brace Initialization)
+
+        private static final Set<String> NEGARA = new HashSet<String>() {{
+            add("INDONESIA");
+            add("MALAYSIA");
+            add("SINGAPURA");
+        }}
+
+        // Kurung kurawal yang pertama membuat sebuah AnonymousInnerClas
+        // dan kurung kurawal yang kedua mendeklarasikan instance dari blok
+        // inisialisasi. Blok ini kemudian dipanggil ketika InnerClass dibentuk.
+        // Cara ini tidak hanya berfungsi pada koleksi data, juga dapat digunakan
+        // pada semua kelas bukan-"final".
+
+    } // Akhir dari method utama
+} // Akhir dari kelas BelajarJava
+
+
+// Kelas bukan-"public" lainnya dapat dimasukkan kedalam satu dokumen .java,
+// namun tidak dianjurkan, sebaiknya memisahkan menjadi beberapa dokumen terpisah.
+
+// Sintaks pendeklarasian kelas:
+//<public/private/protected> class <nama kelas> {
+//    // isi data, konstruktor, dan fungsi.
+//    // dalam Java, fungsi biasa disebut juga "method"
+// }
+
+class Sepeda {
+
+    // Variabel dari kelas Sepeda
+    public int irama;       // Public: dapat diakses dari manapun
+    private int kecepatan;  // Private: hanya dapat diakses dari dalam kelas
+    protected int rodaGigi;     // Protected: dapat diakses dari dalam kelas dan turunan kelas
+    String nama;            // Default: hanya dapat diakses kelas yang berada dalam paket yang sama
+
+    static String namaKelas;    // Variabel "static"
+
+    // Blok Static
+    // Java tidak memiliki implementasi untuk konstruktor "static", namun
+    // memiliki blok status yang dapat digunakan untuk inisialisasi variabel
+    // dalam kelas (variabel "static").
+    // Blok ini akan dipanggil secara otomatis ketika kelas dijalankan.
+    static {
+        namaKelas = "Sepeda";
+    }
+
+    // Konstruktor adalah salah satu cara untuk membuat kelas
+    // Ini adalah bagian konstruktor
+    public Sepeda() {
+        // Dapat juga dipanggil konstruktor lainnya:
+        // this(1, 50, 5, "Bontrager");
+        rodaGigi = 1;
+        irama = 50;
+        kecepatan = 5;
+        nama = "Bontrager";
+    }
+
+    // Ini adalah bagian konstruktor yang menggunakan argumen (parameter)
+    public Sepeda(int iramaAwal, int kecepatanAwal, int rodaGigiAwal,
+        String nama) {
+        this.rodaGigi = rodaGigiAwal;
+        this.irama = iramaAwal;
+        this.kecepatan = kecepatanAwal;
+        this.nama = nama;
+    }
+
+    // Sintaks untuk method:
+    // <public/private/protected> <tipe kembalian> <nama fungsi>(<args>)
+
+    // Kelas Java terkadang mengimplementasikan "getters" dan "setters" untuk data.
+
+    // Sintaks untuk deklarasi method:
+    // <public/private/protected> <tipe kembalian> <nama fungsi>(<args>)
+    public int getIrama() {
+        return irama;
+    }
+
+    // Tipe "void" tidak memiliki kembalian (return) nilai
+    public void setIrama(int nilaiBaru) {
+        irama = nilaiBaru;
+    }
+
+    public void setRodaGigi(int nilaiBaru) {
+        rodaGigi = nilaiBaru;
+    }
+
+    public void tambahKecepatan(int nilaiTambahan) {
+        kecepatan += nilaiTambahan;
+    }
+
+    public void kurangiKecepatan(int nilaiPengurangan) {
+        kecepatan -= nilaiPengurangan;
+    }
+
+    public void setNama(String namaBaru) {
+        nama = namaBaru;
+    }
+
+    public String getNama() {
+        return nama;
+    }
+
+    // Method untuk menampilkan nilai dari tiap atribut yang dimiliki objek Sepeda.
+    @Override // Diturunkan dari kelas "Object" (Pustaka Java).
+    public String toString() {
+        return "roda gigi: " + rodaGigi + " irama: " + irama + " kecepatan: " + kecepatan +
+            " nama: " + nama;
+    }
+} // akhir dari kelas Sepeda
+
+// PennyFarthing adalah kelas turunan dari Sepeda
+class PennyFarthing extends Sepeda {
+    // (Penny Farthings adalah sepeda dengan roda depan yang besar,
+    // dan tidak memiliki roda gigi.)
+    // (Penny Farthings are those bicycles with the big front wheel.
+    // They have no gears.)
+
+    public PennyFarthing(int startCadence, int startSpeed) {
+        // Call the parent constructor with super
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // You should mark a method you're overriding with an @annotation.
+    // To learn more about what annotations are and their purpose check this
+    // out: http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setRodaGigi(int rodaGigi) {
+        roda rodaGigi = 0;
+    }
+}
+
+// Interfaces
+// Sintaks untuk deklarasi Interface
+// <level akses> interface <nama interface> extends <interface induk> {
+//     // Konstan
+//     // Deklarasi method
+// }
+
+// Contoh - Makanan:
+public interface dapatDimakan {
+    public void makan();    // Setiap kelas yang menggunakan interface "dapatDimakan",
+                            // harus mengimplementasikan method "makan".
+}
+
+public interface dapatDicerna {
+    public void cerna();
+}
+
+
+// Membuat kelas dengan mengimplementasikan dua interface dalam satu waktu.
+public class Buah implements dapatDimakan, dapatDicerna {
+  
+    @Override
+    public void makan() {
+        // ...
+    }
+
+    @Override
+    public void cerna() {
+        // ...
+    }
+}
+
+// Dalam Java, kelas hanya dapat diturunkan sekali, tapi dapat mengimplementasikan
+// banyak interface. Contoh:
+public class ContohKelas extends ContohKelasInduk implements InterfaceSatu,
+    InterfaceDua {
+
+    @Override
+    public void MethodInterfaceSatu() {
+    }
+
+    @Override
+    public void MethodInterfaceDua() {
+    }
+
+}
+
+// Kelas Abstrak (Abstract)
+// Sintaks untuk deklarasi kelas abstrak
+// Abstract Class declaration syntax
+// <level akses> abstract <nama kelas abstrak> extends <induk kelas abstrak> {
+//     // Konstan dan variabel
+//     // Deklarasi method
+
+// Menjadikan kelas sebagai abstrak adalah memungkinkan kelas berisi method abstrak
+// yang harus didefinisikan pada kelas turunannya. Mirip dengan Interface, kelas abstrak
+// tidak dapat dilakukan instansiasi, namun harus diturunkan pada kelas lain dan method abstrak
+// harus didefinisikan. Perbedaannya dengan Interface ialah kelas abstrak dapat berisi method
+// kongkrit dan method abstrak. Pada Interface method tidak dapat memiliki isi, artinya hanya
+// method statis, dan variabel langsung ditentukan menjadi final, tidak seperti kelas abstrak.
+// Kelas abstrak juga dapat memiliki method "main".
+
+public abstract class Hewan
+{
+    public abstract void bersuara();
+
+    // Method biasa dapat memiliki isi
+    public void makan()
+    {
+        System.out.println("Saya adalah hewan dan Saya makan.");
+        // Catatan: Kita dapat mengakses variabel private yang ada disini.
+        umur = 30;
+    }
+
+    // Tidak perlu dilakukan inisialisasi, berbeda dengan Interface
+    // sebuah variabel adalah final dan harus dilakukan inisialisasi. 
+    protected int umur;
+
+    public void tampilkanUmur()
+    {
+        System.out.println(umur);  
+    }
+
+    // Kelas abstrak dapat memiliki fungsi utama (main).
+    public static void main(String[] args)
+    {
+        System.out.println("Saya adalah kelas abstrak!");
+    }
+}
+
+class Kucing extends Hewan
+{
+    // Catatan: kelas ini harus melakukan override method abstrak
+    // yang ada pada kelas abstrak (induk).
+    @Override
+    public void bersuara()
+    {
+        System.out.println("Moe");
+        // umur = 30;	==> ERROR!	umur merupakan variabel private pada abstrak Hewan
+    }
+
+    // CATATAN: Akan muncul error jika menggunakan 
+    // keterangan @Override pada method utama (main),
+    // Java tidak mengizinkan hal tersebut.
+    // Kejadian ini sering disebut sebagai METHOD HIDING.
+    // Pertanyaan-jawaban yang menarik dapat dilihat: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Kucing moe = new Kucing();
+        noe.bersuara();
+        moe.makan();
+        moe.tampilkanUmur();
+    }
+}
+
+// Kelas Final
+
+// Sintaks untuk deklarasi kelas Final
+// <level akses> final <nama kelas final> {
+//     // Konstann dan variabel
+//     // Deklarasi method
+// }
+
+// Kelas Final merupakan kelas yang tidak dapat diturunkan sehingga menjadikan
+// method tersebut turunan method terakhir. Disisi lain, kelas final merupakan
+// lawan dari kelas abstrak karena kelas abstrak dapat diturunkan lagi, sedangkan
+// kelas final tidak dapat diturunkan lagi.
+public final class Serigala extends Hewan
+{
+    // Catatan: method abstrak harus di-override pada kelas abstrak.
+    @Override
+    public void bersuara()
+    {
+        System.out.println("Auuww");
+    }
+}
+
+// Method Final
+public abstract class Mamalia()
+{
+    // Sintaks untuk method final:
+    // <level akses> final <tipe kembalian> <nama fungsi>(<args>)
+
+    // Method final, seperti kelas final tidak dapat di-override oleh kelas turunan,
+    // sehingga menjadikannya implementasi terakhir dari method.
+    public final boolean apakahBerdarahDingin()
+    {
+        return true;
+    }
+}
+
+
+// Tipe Enum
+//
+// Tipe Enum merupakan tipe data spesial yang memungkinkan sebuah nilai dijadikan
+// konstan awal (predefined). Variabel setidaknya harus memiliki nilai yang sama
+// dengan salah satu dari enum-enum yang telah ditentukan. Karena nilainya merupakan
+// konstan, untuk itu penamaannya menggunakan huruf kapital (uppercase). Dalam Java,
+// Enum didefinisikan dengan kata kunci "enum". Contohnya nama-nama hari dalam semunggu:
+
+public enum Hari {
+    SENIN, SELASA, RABU, KAMIS,
+    JUMAT, SABTU, MUNGGU 
+}
+
+// Cara menggunakan Enum:
+public class CobaEnum {
+    
+    // Variabel Enum
+    Hari hari;
+    
+    // Konstruktor
+    public CobaEnum(Hari hari) {
+        this.hari = hari;
+    }
+    
+    public void tampilkanKeterangan() {
+        switch (day) {
+            case SENIN:
+                System.out.println("Senin adalah hari yang menyebalkan.");
+                break;
+                    
+            case JUMAT:
+                System.out.println("Jumat adalah hari yang singkat.");
+                break;
+                         
+            case SABTU: 
+            case MINGGU:
+                System.out.println("Akhir pekan adalah hari yang menyenangkan.");
+                break;
+                        
+            default:
+                System.out.println("Hari kerja yang biasa saja.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        CobaEnum hariPertama = new CobaEnum(Hari.SENIN);
+        hariPertama.tampilkanKeterangan();      // Senin adalah hari yang menyebalkan.
+        CobaEnum hariKetiga = new CobaEnum(Hari.RABU);
+        hariPertama.tampilkanKeterangan();      // Hari kerja yang biasa saja.
+    }
+}
+
+// Tipe enum memiliki banyak kegunaan selain yang dicontohkan diatas.
+// Tipe enum dapat memiliki isi seperti method dan variabel.
+// Penjelasan lebih detail di https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## Referensi Lainnya
+
+Link-link berikut hanya menyediakan pemahaman lebih lanjut mengenai topik diatas. 
+Tip, trik, dan contoh lainnya dapat melakukan pencarian melalui Google atau mesin pencari yang lain. 
+
+**Panduan resmi Oracle**
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+**Tutorial dan Praktik Online**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Buku**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
diff --git a/id-id/json-id.html.markdown b/id-id/json-id.html.markdown
index 52e61449..325e0ae2 100644
--- a/id-id/json-id.html.markdown
+++ b/id-id/json-id.html.markdown
@@ -1,19 +1,32 @@
 ---
 language: json
-filename: learnjson.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
-translators
+filename: learnjson-id.json
+translators:
   - ["Rizky Luthfianto", "https://github.com/rilut"]
+  - ["Ahmad Zafrullah", "https://github.com/23Pstars"]
+lang: id-id
 ---
 
-JSON adalah format pertukaran data yang sangat simpel, kemungkinan besar,
-ini adalah "Learn X in Y Minutes" yang paling singkat.
+JSON adalah format pertukaran data yang sangat sederhana. Sebagaimana dikutip dari [json.org](http://json.org), JSON mudah untuk dibaca atau ditulis oleh manusia, dan mudah diuraikan dan diproses oleh mesin.
 
-Murninya, JSON tidak mempunyai fitur komentar, tapi kebanyakan parser akan
-menerima komentar bergaya bahasa C (`//`, `/* */`). Namun, pada halaman ini,
-hanya dicontohkan JSON yang 100% valid.
+Sebuah format JSON setidaknya memiliki:
+* Sebuah pasangan nama atau nilai dinyatakan dengan karakter (`{ }`). Dibeberapa bahasa pemrograman, karakter ini sering digunakan sebagai object, record, struct, dictionary, hash table, keyed list, atau associative array.
+* Daftar nilai dinyatakan dengan karakter (`[ ]`). Dibeberapa bahasa pemrograman, karakter ini sering digunakan sebagai array, vector, list, atau sequence.
+
+Format JSON murni tidak memiliki komentar, namun beberapa pengurai (parser) dapat mengenali komentar seperti yang digunakan oleh bahasa C (`//`, `/**/`). Beberapa pengurai lainnya juga memiliki toleransi terhadap akhiran sisa koma (seperti koma yang terdapat pada akhir elemen dari larik atau properti terakhir dari objek), tapi koma tersebut memang seharusnya diabaikan untuk dukungan yang lebih baik.
+
+Dalam tutorial ini, semuanya menggunakan format JSON murni.
+
+Tipe data yang didukung oleh JSON:
+
+* Teks: `"halo"`, `"\"tanda petik.\""`, `"\u0abe"`, `"baris baru.\n"`
+* Angka: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Objek: `{ "kunci": "nilai" }`
+* Larik: `["nilai"]`
+* Lainnya: `true`, `false`, `null`
 
 ```json
 {
@@ -58,3 +71,7 @@ hanya dicontohkan JSON yang 100% valid.
   "singkat": "Dan Anda selesai! Sekarang Anda tahu apa saja yang disediakan oleh JSON."
 }
 ```
+
+## Referensi lebih labjut
+
+* [JSON.org](http://json.org/json-id.html) semua keindahan JSON dijelaskan dalam bentuk alur-grafis (bahasa indonesia).
diff --git a/id-id/markdown.html.markdown b/id-id/markdown.html.markdown
new file mode 100644
index 00000000..06ad1092
--- /dev/null
+++ b/id-id/markdown.html.markdown
@@ -0,0 +1,264 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Tasya Aditya Rukmana", "http://github.com/tadityar"]
+lang: id-id
+filename: markdown-id.md
+---
+
+Markdown dibuat oleh John Gruber pada tahun 2004. Tujuannya untuk menjadi syntax yang mudah dibaca dan ditulis yang dapat berubah menjadi HTML (dan sekarang berbagai format lainnya) dengan mudah.
+
+Beri masukan sebanyak-banyaknya! / Jangan sungkan untuk melakukan fork dan pull request!
+
+
+```markdown
+<!-- Markdown adalah superset dari HTML, jadi setiap berkas HTML adalah markdown yang
+valid, ini berarti kita dapat menggunakan elemen HTML dalam markdown, seperti elemen
+komentar, dan ia tidak akan terpengaruh parser markdown. Namun, jika Anda membuat
+elemen HTML di berkas markdown Anda, Anda tidak dapat menggunakan syntax markdown
+di dalam konten elemen tersebut. -->
+
+<!-- Markdown juga bervariasi dalam implementasinya dari berbagai parser. Panduan ini
+akan mencoba untuk mengklarifikasikan kapan suatu fitur universal atau spesifik
+terhadap parser tertentu -->
+
+<!-- Header -->
+<!-- Anda dapat membuat elemen HTML <h1> sampai <h6> dengan mudah dengan mendahului
+teks yang diinginkan untuk elemen tersebut oleh sejumlah tanda pagar (#) -->
+# Ini adalah <h1>
+## Ini adalah <h2>
+### Ini adalah <h3>
+#### Ini adalah <h4>
+##### Ini adalah <h5>
+###### Ini adalah <h6>
+
+<!-- Markdown juga menyediakan dua cara alternatif untuk menandai h1 and h2 -->
+Ini adalah h1
+=============
+
+Ini adalah h2
+-------------
+
+<!-- Ragam teks simpel -->
+<!-- Teks dapat diubah menjadi miring atau tebal dengan mudah menggunakan markdown -->
+
+*Ini adalah teks miring.*
+_Dan juga teks ini._
+
+**Ini adalah teks tebal.**
+__Dan juga teks ini.__
+
+***Ini adalah teks dengan keduanya.***
+**_Dan juga ini!_**
+*__Dan ini!__*
+
+<!-- Di markdown ala Github, yang digunakan untuk me-render berkas markdown pada
+Github, kita juga punya coretan: -->
+
+~~Teks ini dirender dengan coretan.~~
+
+<!-- Paragraf adalah satu atau beberapa baris teks yang dipisahkan oleh satu atau
+beberapa baris kosong. -->
+
+Ini adalah paragraf. Saya mengetik dalam paragraf, bukankah ini menyenangkan?
+
+Sekarang saya ada di paragraf 2.
+Saya juga masih ada dalam paragraf 2!
+
+
+Saya ada di paragraf 3!
+
+<!-- Jika Anda ingin memasukkan tag HTML <br />, Anda dapat mengakhiri sebuah
+paragraf dengan dua atau lebih spasi lalu memulai paragraf yang baru. -->
+
+Aku diakhiri dua spasi (soroti aku untuk melihatnya).
+
+Ada sebuah <br /> diatasku!
+
+<!-- Kutipan mudah dibuat dengan karakter >. -->
+
+> Ini adalah kutipan. Anda dapat
+> membungkusnya secara manual dan meletakkan `>` sebelum tiap baris atau Anda dapat membuat baris yang sangat panjang dan membuatnya membungkus secara otomatis.
+> Tidak ada masalah selama ia diawali dengan `>`.
+
+> Anda juga dapat menggunakan lebih dari satu level
+>> indentasi!
+> Sangat rapi bukan?
+
+<!-- Daftar -->
+<!-- Daftar tak beraturan dapat dibuat dengan bintang, plus, atau strip -->
+
+* Item
+* Item
+* Item lainnya
+
+atau
+
++ Item
++ Item
++ Satu lagi item
+
+or
+
+- Item
+- Item
+- Item terakhir
+
+<!-- List beraturan dibuat dengan angka diikuti titik -->
+
+1. Item satu
+2. Item dua
+3. Item tiga
+
+<!-- Anda tidak diharuskan melabeli item dengan benar dan markdown akan tetap
+me-render angka sesuai urutan, namun mungkin hal ini kurang baik -->
+
+1. Item satu
+1. Item dua
+1. Item tida
+<!-- (Ini dirender sama seperti contoh di atas) -->
+
+<!-- Anda juga dapat menggunakan sublist -->
+
+1. Item satu
+2. Item dua
+3. Item tiga
+    * Sub-item
+    * Sub-item
+4. Item empat
+
+<!-- Bahkan ada daftar tugas. Ini membuat kotak centang HTML. -->
+
+Kotak di bawah tanpa 'x' adalah kotak centang HTML yang belum diisi.
+- [ ] Tugas pertama selesai.
+- [ ] Tugas kedua yang harus diselesaikan
+Kotak centang HTML berikut telah diisi.
+- [x] Tugas ini telah diselesaikan
+
+<!-- Blok kode -->
+<!-- Anda dapat menandai blok kode (yang menggunakan elemen <code>) dengan mengindentasi
+sebuah garis dengan empat spasi atau tab -->
+
+    Ini adalah kode
+    Dan ini juga
+
+<!-- Anda juga dapat me-re-tab (atau menambahkan empat spasi tambahan) untuk indentasi
+di dalam kode Anda -->
+
+    array_ku.each do |item|
+        puts item
+    end
+
+<!-- Sebaris kode dapat dibuat dengan karakter backtick ` -->
+
+John bahkan tidak tahu apa fungsi dari `go_to()` !
+
+<!-- Di Markdown ala Github, Anda dapat menggunakan syntax spesial untuk kode -->
+
+\`\`\`ruby <!-- kecuali hapus backlash tersebut ketika melakukannya, hanya ```ruby ! -->
+def foobar
+    puts "Halo Dunia!"
+end
+\`\`\` <!-- Disini juga, tidak ada backslashes, hanya ``` -->
+
+<!-- Teks di atas tidak membutuhkan indentasi, plus Github akan menggunakan syntax
+highlighting dari bahasa yang digunakan setelah ``` -->
+
+<!-- Horizontal rule (<hr />) -->
+<!-- Horizontal rules ditambahkan dengan mudah oleh beberapa bintang atau strip,
+dengan atau tanpa spasi. -->
+
+***
+---
+- - -
+****************
+
+<!-- Tautan -->
+<!-- Salah satu hal terbaik dari markdown adalah mudahnya membuat tautan. Letakkan
+teks yang akan di tampilkan di dalam kurung siku [] diikuti oleh url-nya dalam kurung () -->
+
+[Klik aku!](http://test.com/)
+
+<!-- Anda juga dapat menambahkan judul link dengan tanda kutip di dalam kurung -->
+
+[Klik aku!](http://test.com/ "Link to Test.com")
+
+<!-- Path relatif juga bisa. -->
+
+[Pergi ke musik](/music/).
+
+<!-- Markdown juga mendukung tautan gara referal -->
+
+[Klik link ini][link1] untuk info lebih banyak!
+[Juga cek link ini][foobar] jika Anda mau.
+
+[link1]: http://test.com/ "Keren!"
+[foobar]: http://foobar.biz/ "OK!"
+
+<!-- Judulnya juga bisa dalam kutip satu atau kurung, atau dihilangkan sepenuhnya.
+Referensinya juga bisa di mana saja di dokumen anda dan IF referensinya bisa jadi
+apa saja selama ia unik. -->
+
+<!-- Ada juga "penamaan implisit" yang membuat Anda dapat menggunakan teks tautan sebagai id -->
+
+[Ini][] adalah tautan.
+
+[ini]: http://thisisalink.com/
+
+<!-- Tapi ia tidak lazim digunakan. -->
+
+<!-- Gambar -->
+<!-- Gambar digunakan sama seperti tautan namun dengan tanda seru di depannya! -->
+
+![Ini adalah atribut alt dari gambar saya](http://imgur.com/myimage.jpg "Judul opsional")
+
+<!-- Dan gaya referensi juga bekerja seperti yang diharapkan -->
+
+![Ini adalah atribut alt.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "jika Anda membutuhkan judul, disini"
+
+<!-- Lain-lain -->
+<!-- Tautan otomatis -->
+
+<http://testwebsite.com/> sama dengan
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Tautan otomatis untuk email -->
+
+<foo@bar.com>
+
+<!-- Melewati karakter -->
+
+Saya ingin mengetik *teks ini dikelilingi tanda bintang* tapi saya tidak mau teksnya menjadi
+miring, jadi saya melakukan: \*teks ini dikelilingi tanda bintang\*.
+
+<!-- Tombol keyboard -->
+<!-- Pada Markdown ala Github, Anda dapat menggunakan tag <kbd> untuk merepresentasikan tombol
+keyboard -->
+
+Komputer Anda hang? Coba kirim sebuah
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+
+<!-- Tabel -->
+<!-- Tabel hanya tersedia pada Markdown ala Github dan sedikit merepotkan, namun jika Anda
+sangat menginginkannya: -->
+
+| Kol1         | Kol2     | Kol3          |
+| :----------- | :------: | ------------: |
+| Rata-kiri    | Tengah   | Rata-Kanan    |
+| blah         | blah     | blah          |
+
+<!-- atau, untuk hasil yang sama -->
+
+Kol 1 | Kol2 | Kol3
+:-- | :-: | --:
+Ugh ini sangat jelek | buat ia | berhenti
+
+<!-- Selesai! -->
+
+```
+
+Untuk info lebih lanjut, cek post syntax resmi John Gruber [di sini](http://daringfireball.net/projects/markdown/syntax) dan contekan hebat Adam Pritchard's [di sini](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/id-id/pyqt-id.html.markdown b/id-id/pyqt-id.html.markdown
new file mode 100644
index 00000000..c4833d06
--- /dev/null
+++ b/id-id/pyqt-id.html.markdown
@@ -0,0 +1,83 @@
+---
+category: tool
+tool: PyQt
+language: Python
+filename: learnqt-id.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Rizky Luthfianto", "http://github.com/rilut"]
+lang: id-id
+---
+
+**Qt** adalah framework terkenal untuk pengembangan perangkat lunak *cross-platform* yang dapat dijalankan pada berbagai platform perangkat lunak dan perangkat keras dengan sedikit atau tanpa perubahan dalam kode, dengan tetap memiliki kekuatan dan kecepatan aplikasi *native*. **Qt** ditulis dalam bahasa C++.
+
+
+Tulisan ini diadaptasi dari **Intro Qt untuk C++** oleh [Aleksey Kholovchuk](https://github.com/vortexxx192). Kode-kode yang tertulis di sini akan menghasilkan fungsionalitas yang sama. Bedanya, versi ini dibangun menggunakan **PyQt**!
+
+```Python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+# Buat objek aplikasi
+    app = QtGui.QApplication(sys.argv)
+# Buat sebuah widget, sebagai tempat di mana label kita akan ditempatkan
+    w = QtGui.QWidget()
+# Tambahkan label untuk widget
+    b = QtGui.QLabel(w)
+# Set teks untuk label
+    b.setText("Halo, Dunia!")
+# Set parameter penempatan dan ukuran
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+# Set judul pada jendela
+    w.setWindowTitle("PyQt")
+# Tampilkan segalanya
+    w.show()
+# Jalankan apa yang telah kita atur. Setelah semua selesai kita atur.
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+```
+
+Untuk menunjukkan beberapa fitur yang lebih canggih di **PyQt**, kita akan membangun elemen tambahan.
+Di sini, kita akan membuat Kotak Popup Dialog, yang berguna untuk meminta pengguna untuk mengkonfirmasi keputusan atau untuk menampilkan informasi.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Buat tombol b dan tempelkan pada widget w
+    b = QPushButton(w)
+    b.setText("Tekan aku!")
+    b.move(50, 50)
+    # Perintahkan tombol b untuk memanggil fungsi ini ketika diklik
+    # Perhatikan bahwa kita tidak menggunakan simbol "()" pada pemanggilan fungsi kali ini
+    b.clicked.connect(ShowDialog)
+    w.setWindowTitle("Dialog PyQt")
+    w.show()
+    sys.exit(app.exec_())
+
+# Fungsi ini akan membuat jendela dialog dengan tombol
+# yang menunggu untuk diklik untuk keluar dari program
+def ShowDialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Modalitas ini memberitahu popup untuk memblokir induk saat ini aktif
+    d.setWindowModality(Qt.ApplicationModal)
+    # Pada klik, kita ingin seluruh proses untuk berhenti
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/id-id/ruby-id.html.markdown b/id-id/ruby-id.html.markdown
new file mode 100644
index 00000000..28135da1
--- /dev/null
+++ b/id-id/ruby-id.html.markdown
@@ -0,0 +1,622 @@
+---
+language: ruby
+filename: learnruby-id.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+translators:
+  - ["Ukaza Perdana", "https://github.com/ukazap"]
+lang: id-id
+---
+
+```ruby
+# Ini adalah sebuah komentar
+
+=begin
+Ini adalah komentar multibaris
+Tak seorang pun menggunakannya
+Kamu juga tidak perlu
+=end
+
+# Pertama-tama dan yang terpenting: Semuanya adalah objek.
+
+# Angka adalah objek
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Beberapa aritmetika dasar
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+
+# Operator-operator bitwise
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# Aritmetika tidak lain adalah pemanis sintaks (syntactic sugar)
+# untuk memanggil sebuah metode pada suatu objek
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Nilai-nilai khusus adalah objek
+nil # setara dengan "null" di bahasa-bahasa lain
+true # kebenaran
+false # ketidakbenaran
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Kesamaan
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Ketidaksamaan
+1 != 1 #=> false
+2 != 1 #=> true
+
+# selain false itu sendiri, nil adalah nilai lain yang "salah"
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Perbandingan lain
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Operator pembanding yang dikombinasikan ("spaceship operator")
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Operator-operator logika
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Terdapat versi-versi operator logika yang berbeda dengan lebih sedikit awalan.
+# Mereka digunakan sebagai kendali alur untuk merangkai beberapa pernyataan
+# hingga salah satunya mengembalikan (return) nilai true atau false.
+
+# `lakukan_suatu_lainnya` hanya dipanggil jika `lakukan_sesuatu` berhasil.
+lakukan_sesuatu() and lakukan_suatu_lainnya()
+# `catat_error` hanya dipanggil jika `lakukan_sesuatu` gagal.
+lakukan_sesuatu() or catat_error()
+
+
+# String adalah objek
+
+'Aku adalah string'.class #=> String
+"Aku juga adalah string".class #=> String
+
+wadah = 'menggunakan string interpolation'
+"Aku bisa #{wadah} ketika memakai tanda kutip ganda"
+#=> "Aku bisa menggunakan string interpolation ketika memakai tanda kutip ganda"
+
+# Gunakan tanda kutip tunggal daripada tanda kutip ganda jika memungkinkan
+# String bertanda kutip ganda melakukan kalkulasi tambahan di dalam
+
+# Kombinasikan string, tapi tidak dengan angka
+'halo ' + 'dunia'  #=> "halo dunia"
+'halo ' + 3 #=> TypeError: can't convert Fixnum into String
+'halo ' + 3.to_s #=> "halo 3"
+
+# Kombinasikan string dengan operator
+'halo ' * 3 #=> "halo halo halo "
+
+# Membubuhkan ke string
+'halo' << ' dunia' #=> "halo dunia"
+
+# cetak ke output dan buat baris baru (newline) di akhir
+puts "Aku mencetak!"
+#=> Aku mencetak!
+#=> nil
+
+# cetak ke output tanpa baris baru
+print "Aku mencetak!"
+#=> Aku mencetak! => nil
+
+# Variabel
+x = 25 #=> 25
+x #=> 25
+
+# Catat bahwa pemberian nilai mengembalikan nilai yang diberikan
+# Artinya kamu bisa melakukan pemberian nilai secara jamak:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Berdasarkan adat, gunakan gaya snake_case untuk menulis nama variabel
+snake_case = true
+
+# Gunakan nama variabel yang deskriptif
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+
+# Simbol (adalah objek)
+# Simbol adalah konstanta yang dapat didaur ulang yang tidak dapat diubah
+# (immutable), secara internal diwakili oleh nilai integer. Seringkali 
+# digunakan sebagai pengganti string untuk menyampaikan nilai yang mengandung
+# makna spesifik secara efisien.
+
+:menunggu.class #=> Symbol
+
+status = :menunggu
+
+status == :menunggu #=> true
+
+status == 'menunggu' #=> false
+
+status == :diterima #=> false
+
+# Array
+
+# Ini adalah sebuah array
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Array bisa menampung item dengan beragam tipe
+
+[1, 'halo', false] #=> [1, "halo", false]
+
+# Array bisa di-indeks-kan
+# Dari depan
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+# Sama dengan aritmetika, pengaksesan [var]
+# hanyalah pemanis sintaks
+# untuk memanggil metode [] pada suatu objek
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Dari belakang
+array[-1] #=> 5
+array.last #=> 5
+
+# Dengan indeks awal dan panjang (jumlah item)
+array[2, 3] #=> [3, 4, 5]
+
+# Membalik sebuah Array
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Atau menggunakan jangkauan (range)
+array[1..3] #=> [2, 3, 4]
+
+# Tambahkan ke array seperti ini
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# Atau seperti ini
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Periksa apakah suatu item ada dalam sebuah array
+array.include?(1) #=> true
+
+# Hash adalah kamus utama Ruby berupa pasangan kunci/nilai (key/value pair).
+# Hash ditandai dengan kurung kurawal:
+hash = { 'warna' => 'hijau', 'angka' => 5 }
+
+hash.keys #=> ['warna', 'angka']
+
+# Nilai dalam Hash bisa diperoleh menggunakan kunci:
+hash['warna'] #=> 'hijau'
+hash['angka'] #=> 5
+
+# Meminta hash untuk kunci yang tidak ada akan mengembalikan nil:
+hash['tidak ada di sini'] #=> nil
+
+# Sejak Ruby 1.9, ada sintaks khusus ketika menggunakan simbol sebagai kunci:
+
+hash_baru = { defcon: 3, action: true }
+
+hash_baru.keys #=> [:defcon, :action]
+
+# Periksa ada/atau tidaknya kunci dan nilai dalam hash
+hash_baru.key?(:defcon) #=> true
+hash_baru.value?(3) #=> true
+
+# Tip: Baik array maupun hash adalah Enumerable
+# Mereka berbagi banyak metode yang berguna diantaranya each, map, count, dll.
+
+# Struktur-struktur kendali
+
+if true
+  'pernyataan if'
+elsif false
+  'else if, opsional'
+else
+  'else, opsional juga'
+end
+
+for penghitung in 1..5
+  puts "iterasi #{penghitung}"
+end
+#=> iterasi 1
+#=> iterasi 2
+#=> iterasi 3
+#=> iterasi 4
+#=> iterasi 5
+
+# NAMUN, tidak ada orang yang menggunakan pengulangan for.
+# Sebagai ganti, gunakan metode "each" dan memberinya sebuah blok (block).
+# Blok adalah serangkaian kode yang bisa dimasukkan ke metode seperti "each".
+# Ia serupa dengan lambda, fungsi anonim atau closure di bahasa lainnya.
+#
+# Metode "each" dari range menjalankan blok untuk setiap elemen dari range.
+# Bloknya diberikan penghitung sebagai parameter.
+# Memanggil metode "each" dengan blok terlihat seperti ini:
+
+(1..5).each do |penghitung|
+  puts "iterasi #{penghitung}"
+end
+#=> iterasi 1
+#=> iterasi 2
+#=> iterasi 3
+#=> iterasi 4
+#=> iterasi 5
+
+# Kamu juga bisa mengurung blok dalam kurung kurawal:
+(1..5).each { |penghitung| puts "iterasi #{penghitung}" }
+
+# Isi dari struktur-struktur data juga bisa di-iterasi menggunakan each.
+array.each do |elemen|
+  puts "#{elemen} adalah bagian dari array"
+end
+hash.each do |kunci, nilai|
+  puts "#{kunci} adalah #{nilai}"
+end
+
+# Jika kamu masih membutuhkan indeks, bisa menggunakan "each_with_index"
+# dan definisikan variabel indeks
+array.each_with_index do |elemen, indeks|
+  puts "#{elemen} adalah nomor #{indeks} dalam array"
+end
+
+penghitung = 1
+while penghitung <= 5 do
+  puts "iterasi #{penghitung}"
+  penghitung += 1
+end
+#=> iterasi 1
+#=> iterasi 2
+#=> iterasi 3
+#=> iterasi 4
+#=> iterasi 5
+
+# Ada kumpulan fungsi pengulangan lainnya yang berguna di Ruby,
+# contohnya "map", "reduce", "inject", daftarnya sangat panjang. Map,
+# misalnya, mengambil array yang di-iterasi-nya, melakukan sesuatu pada
+# setiap elemen sesuai definisi pada blok, dan mengembalikan array baru.
+array = [1,2,3,4,5]
+berganda = array.map do |elemen|
+  elemen * 2
+end
+puts berganda
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+nilai = 'B'
+
+case nilai
+when 'A'
+  puts 'Pertahankan, nak'
+when 'B'
+  puts 'Semoga lebih beruntung di lain waktu'
+when 'C'
+  puts 'Kamu bisa lebih baik'
+when 'D'
+  puts 'Susah payah'
+when 'F'
+  puts 'Kamu gagal!'
+else
+  puts 'Sistem penilaian lainnya, heh?'
+end
+#=> "Semoga lebih beruntung di lain waktu"
+
+# case juga bisa menggunakan range
+nilai = 82
+case nilai
+when 90..100
+  puts 'Hore!'
+when 80...90
+  puts 'Cukup bagus'
+else
+  puts 'Kamu gagal!'
+end
+#=> "Cukup bagus"
+
+# penanganan kesalahan (exception handling):
+begin
+  # kode di sini yang mungkin membangkitkan exception
+  raise NoMemoryError, 'Kamu kehabisan memori.'
+rescue NoMemoryError => variabel_exception
+  puts 'NoMemoryError dibangkitkan', variabel_exception
+rescue RuntimeError => variabel_exception_lainnya
+  puts 'RuntimeError dibangkitkan sekarang'
+else
+  puts 'Ini dijalankan bila tidak ada exceptions sama sekali'
+ensure
+  puts 'Kode ini akan berjalan bagaimanapun juga'
+end
+
+# Fungsi (atau metode)
+
+def gandakan(x)
+  x * 2
+end
+
+# Fungsi dan semua blok secara tersirat mengembalikan nilai pernyataan terakhir
+gandakan(2) #=> 4
+
+# Tanda kurung bersifat optional, boleh ditiadakan jika tidak ambigu
+gandakan 3 #=> 6
+
+gandakan gandakan 3 #=> 12
+
+def jumlah(x, y)
+  x + y
+end
+
+# Argumen-argumen dari metode dipisahkan dengan koma
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Semua metode secara tersirat mempunyai parameter blok opsional
+# yang bisa dipanggil dengan kata kunci 'yield'
+
+def kurung
+  puts '{'
+  yield
+  puts '}'
+end
+
+kurung { puts 'halo dunia' }
+
+# {
+# halo dunia
+# }
+
+
+# Kamu bisa memasukkan blok ke sebuah fungsi
+# "&" adalah penanda blok yang masuk
+def tamu_tamu(&blok)
+  blok.call 'beberapa_argumen'
+end
+
+# Kamu bisa memasukkan daftar argumen yang akan dikonversi menjadi array
+# Itulah gunanya operator splat ("*")
+def tamu_tamu(*array)
+  array.each { |tamu| puts tamu }
+end
+
+# Bila metode mengembalikan array, bisa memberi nilai dengan destrukturisasi
+# (destructuring assignment):
+def makanan
+    ['tempe penyet', 'sayur asam', 'nasi goreng']
+end
+sarapan, makan_siang, makan_malam = makanan
+sarapan #=> 'tempe penyet'
+makan_malam #=> 'nasi goreng'
+
+# Menurut adat, nama metode yang mengembalikan boolean diakhiri tanda tanya
+5.even? # false
+5.odd? # true
+
+# Dan jika suatu metode berakhiran tanda seru, ia melakukan sesuatu yang merusak
+# seperti mengubah penerimanya. Banyak metode mempunyai versi ! untuk melakukan
+# perubahan dan versi non-! untuk sekedar mengembalikan perubahannya
+nama_perusahaan = "Putra Sejahtera"
+nama_perusahaan.upcase #=> "PUTRA SEJAHTERA"
+nama_perusahaan #=> "Putra Sejahtera"
+nama_perusahaan.upcase! # kali ini kita benar-benar mengubah nama_perusahaan!
+nama_perusahaan #=> "PUTRA SEJAHTERA"
+
+
+# Definisikan kelas menggunakan kata kunci class
+class Manusia
+
+  # Variabel kelas. Ini dibagi oleh semua instans (instance) dari kelas ini.
+  @@spesies = 'H. sapiens'
+
+  # Inisialisasi dasar
+  def initialize(nama, usia = 0)
+    # Berikan argumen ke variabel instans "nama" dalam instans ini
+    @nama = nama
+    # Jika tidak diberi usia, nilai default dalam daftar argumen digunakan.
+    @usia = usia
+  end
+
+  # Metode setter dasar
+  def nama=(nama)
+    @nama = nama
+  end
+
+  # Metode getter dasar
+  def nama
+    @nama
+  end
+
+  # Fungsi di atas bisa disingkat dengan metode attr_accessor sebagai berikut
+  attr_accessor :nama
+
+  # Metode getter/setter juga bisa dibuat secara terpisah seperti ini
+  attr_reader :nama
+  attr_writer :nama
+
+  # Metode kelas menggunakan self untuk membedakannya dari metode instans.
+  # Ia hanya bisa dipanggil pada kelas, bukan pada instans-nya.
+  def self.katakan(pesan)
+    puts pesan
+  end
+
+  def spesies
+    @@spesies
+  end
+end
+
+
+# Membuat instans kelas
+jim = Manusia.new('Jim Halpert')
+
+dwight = Manusia.new('Dwight K. Schrute')
+
+# Mari panggil beberapa metode
+jim.spesies #=> "H. sapiens"
+jim.nama #=> "Jim Halpert"
+jim.nama = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nama #=> "Jim Halpert II"
+dwight.spesies #=> "H. sapiens"
+dwight.nama #=> "Dwight K. Schrute"
+
+# Panggil metode kelas
+Manusia.katakan('Hai') #=> "Hai"
+
+# Lingkup variabel didefinisikan berdasarkan bagaimana kita memberikannya nama
+# Variabel yang berawalan $ memiliki lingkup global
+$var = "Aku adalah variabel global"
+defined? $var #=> "global-variable"
+
+# Variabel yang berawalan @ memiliki lingkup instans
+@var = "Aku adalah variabel instans"
+defined? @var #=> "instance-variable"
+
+# Variabel yang berawalan @@ memiliki lingkup kelas
+@@var = "Aku adalah variabel kelas"
+defined? @@var #=> "class variable"
+
+# Variabel yang berawalan huruf kapital adalah konstanta
+Var = "Aku adalah konstanta"
+defined? Var #=> "constant"
+
+# Kelas juga adalah objek sehingga kelas bisa memiliki variabel instans.
+# Variabel kelas dibagi diantara kelas dan semua pewarisnya.
+
+# kelas dasar
+class Manusia
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(nilai)
+    @@foo = nilai
+  end
+end
+
+# kelas turunan
+class Buruh < Manusia
+end
+
+Manusia.foo # 0
+Buruh.foo # 0
+
+Manusia.foo = 2 # 2
+Buruh.foo # 2
+
+# Variabel instans milik kelas tidak dibagikan dengan pewaris kelas tersebut.
+
+class Manusia
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(nilai)
+    @bar = nilai
+  end
+end
+
+class Dokter < Manusia
+end
+
+Manusia.bar # 0
+Dokter.bar # nil
+
+module ContohModul
+  def foo
+    'foo'
+  end
+end
+
+# Include modul mengikat metode-metodenya pada instans-instans kelas
+# Extend modul mengikat metode-metodenya pada kelas
+
+class Orang
+  include ContohModul
+end
+
+class Buku
+  extend ContohModul
+end
+
+Orang.foo     # => NoMethodError: undefined method `foo' for Orang:Class
+Orang.new.foo # => 'foo'
+Buku.foo       # => 'foo'
+Buku.new.foo   # => NoMethodError: undefined method `foo'
+
+# Callbacks dijalankan ketika meng-include dan meng-extend sebuah modul
+
+module ContohUrusan
+  def self.included(base)
+    base.extend(MetodeKelas)
+    base.send(:include, MetodeInstans)
+  end
+
+  module MetodeKelas
+    def bar
+      'bar'
+    end
+  end
+
+  module MetodeInstans
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Sesuatu
+  include ContohUrusan
+end
+
+Sesuatu.bar     # => 'bar'
+Sesuatu.qux     # => NoMethodError: undefined method `qux'
+Sesuatu.new.bar # => NoMethodError: undefined method `bar'
+Sesuatu.new.qux # => 'qux'
+```
+
+## Sumber tambahan
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Varian dari referensi ini dengan tantangan dalam browser.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Belajar Ruby melalui serangkaian tutorial interaktif.
+- [Dokumentasi resmi](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Edisi lama yang [gratis](http://ruby-doc.com/docs/ProgrammingRuby/) tersedia online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Panduan penulisan kode Ruby oleh komunitas.
+- [Try Ruby](http://tryruby.org) - Pelajari dasar bahasa pemrograman Ruby, secara interaktif di browser.
diff --git a/id-id/smallbasic-id.html.markdown b/id-id/smallbasic-id.html.markdown
new file mode 100644
index 00000000..d782c859
--- /dev/null
+++ b/id-id/smallbasic-id.html.markdown
@@ -0,0 +1,133 @@
+---
+language: SmallBASIC
+filename: learnsmallbasic-id.bas
+contributors:
+    - ["Chris Warren-Smith", "http://smallbasic.sourceforge.net"]
+translators:
+    - ["Rizky Luthfianto", "http://github.com/rilut"]
+lang: id-id
+---
+
+## Tentang
+
+SmallBASIC adalah *interpreter* bahasa BASIC yang mudah dan cepat dipelajari yang ideal untuk perhitungan sehari-hari, skrip dan prototipe. Fitur SmallBASIC termasuk trigonometri, matriks dan fungsi aljabar, yang dibangun di IDE, *library* string yang canggih, sistem, suara, dan perintah grafis bersama dengan sintaks pemrograman terstruktur.
+
+## Pengembangan
+
+SmallBASIC pada awalnya dikembangkan oleh Nicholas Christopoulos pada akhir tahun 1999 untuk Palm Pilot. pengembangan proyek telah dilanjutkan oleh Chris Warren-Smith sejak sekitar tahun 2005.
+
+Versi SmallBASIC telah dibuat untuk sejumlah perangkat genggam termasuk Franklin eBookman dan Nokia 770. Juga berbagai versi desktop yang telah dirilis berdasarkan berbagai GUI. Platform yang didukung saat ini adalah Linux dan Windows berbasis SDL2 dan Android berbasis NDK. Sebuah versi baris perintah pada desktop juga tersedia, meskipun tidak biasanya dirilis dalam bentuk biner.
+
+Sekitar tahun 2008, sebuah perusahaan merilis lingkungan pemrograman BASIC dengan nama yang mirip. SmallBASIC tidak berhubungan dengan itu.
+
+```
+REM ini adalah komentar
+'dan ini juga komentar
+
+REM mencetak kalimat
+print "halo"
+? "Tanda ? adalah singkatan dari PRINT"
+
+REM Struktur kontrol
+FOR index = 0 TO 10 STEP 2
+  ? "Ini adalah nomor baris"; indeks
+NEXT
+J=0
+REPEAT
+ J++
+UNTIL J=10
+WHILE J>0
+ J--
+WEND
+
+REM Pernyataan "Select case"
+Select Case "Cool"
+ Case "null", 1,2,3,4,5,6,7,8,"Cool","blah"
+ Case "Not cool"
+   PRINT "Epic fail"
+ Case Else
+   PRINT "Fail"
+End Select
+
+REM menangkap kesalahan dengan TRY / CATCH
+Try
+  fn = Freefile
+  Open filename For Input As #fn
+Catch err
+  Print "gagal membuka file"
+End Try
+
+REM Fungsi dan subrutin buatan pengguna
+func add2(x, y)
+  'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
+  local k
+  k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
+  add2 = x + y
+akhir
+Print add2(5,5)
+sub cetak_ini(ini)
+  print ini
+end
+cetak_ini "INI"
+
+REM Menampilkan garis dan piksel
+At 0,ymax/2+txth("Q")
+Color 1: ? "sin(x)":
+Color 8: ? "cos(x)":
+Color 12: ? "tan(x)"
+Line 0,ymax/2,xmax,ymax/2
+For i=0 to xmax
+  Pset i,ymax/2-sin(i*2*pi/ymax)*ymax/4 color 1
+  Pset i,ymax/2-cos(i*2*pi/ymax)*ymax/4 color 8
+  Pset i,ymax/2-tan(i*2*pi/ymax)*ymax/4 color 12
+Next
+showpage
+
+REM SmallBASIC cocok untuk bereksperimen dengan fraktal dan efek menarik lainnya
+Delay 3000
+Randomize
+ff = 440.03
+For j = 0 to 20
+  r = rnd * 1000 % 255
+  b = rnd * 1000 % 255
+  g = rnd * 1000 % 255
+  c = rgb(r,b,g)
+  ff += 9.444
+  for i=0 to 25000
+    f += ff
+    x = min(xmax, -x + cos(f*i))
+    y = min(ymax, -y + sin(f*i))
+    pset x, y color c
+    if (i%1000==0) then
+      showpage
+    fi
+  next
+Next j
+
+REM Untuk sejarawan komputer, SmallBASIC dapat menjalankan program
+REM dari buku dan majalah komputer lama, misalnya:
+10 LET A=9
+20 LET B=7
+30 PRINT A*B
+40 PRINT A/B
+
+REM SmallBASIC juga memiliki dukungan untuk beberapa konsep modern seperti JSON
+aa = array("{\"kucing\":{\"nama\":\"harry\"},\"peliharaan\":\"true\"}")
+If (ismap(aa) == false) Then
+  throw "bukan tipe data map"
+End If
+Print aa
+
+PAUSE
+
+```
+
+## Artikel
+
+* [Persiapan](http://smallbasic.sourceforge.net/?q=node/1573)
+* [Selamat Datang di SmallBASIC](http://smallbasic.sourceforge.net/?q=node/838)
+
+## GitHub
+
+* [Source code](https://github.com/smallbasic/SmallBASIC)
+* [Referensi snapshot](http://smallbasic.github.io/)
diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown
index af8823c4..efc47969 100644
--- a/it-it/bash-it.html.markdown
+++ b/it-it/bash-it.html.markdown
@@ -10,7 +10,12 @@ contributors:
     - ["Anton Strömkvist", "http://lutic.org/"]
     - ["Rahil Momin", "https://github.com/iamrahil"]
     - ["Gregrory Kielian", "https://github.com/gskielian"]
-filename: LearnBash.sh
+    - ["Etan Reisner", "https://github.com/deryni"]
+    - ["Jonathan Wang", "https://github.com/Jonathansw"]   
+    - ["Leo Rudberg", "https://github.com/LOZORD"]
+    - ["Betsy Lorton", "https://github.com/schbetsy"]
+    - ["John Detter", "https://github.com/jdetter"]
+filename: LearnBash-it.sh
 translators:
     - ["Robert Margelli", "http://github.com/sinkswim/"]
     - ["Tommaso Pifferi", "http://github.com/neslinesli93/"]
@@ -50,6 +55,13 @@ echo '$Variabile'
 # il suo nome senza $. Se vuoi usare il valore della variabile, devi usare $.
 # Nota che ' (singolo apice) non espande le variabili!
 
+# Espansione dei parametri ${ }:
+echo ${Variabile}
+# Questo è un esempio semplice dell'espansione dei parametri.
+# L'espansione dei parametri prende il valore di una variabile, ed appunto lo "espande" o lo stampa.
+# Durante l'espansione il valore o il parametro passato possono essere modificati.
+# Sotto ci sono altri esempi che analizzano l'uso dell'espansione dei parametri.
+
 # Sostituzione di stringhe nelle variabili
 echo ${Variabile/Una/A}
 # Questo sostituirà la prima occorrenza di "Una" con "La"
@@ -64,6 +76,12 @@ echo ${Foo:-"ValoreDiDefaultSeFooMancaOppureÈVuoto"}
 # Questo funziona per null (Foo=), stringa vuota (Foo=""), zero (Foo=0) ritorna 0
 # Nota: viene ritornato il valore di default, il contenuto della variabile pero' non cambia.
 
+# Espansione delle graffe { }
+# Viene usata per generare stringe in modo arbitrario
+echo {1..10}
+echo {a..z}
+# Con questi comandi viene stampato l'intervallo dal valore iniziale al valore finale (i numeri da 1 a 10, le lettere dell'alfabeto)
+
 # Variabili builtin:
 # Ci sono delle variabili builtin molto utili, come
 echo "Valore di ritorno dell'ultimo programma eseguito: $?"
@@ -72,6 +90,18 @@ echo "Numero di argomenti: $#"
 echo "Argomenti dello script: $@"
 echo "Argomenti dello script separati in variabili distinte: $1 $2..."
 
+# Adesso che sappiamo come stampare a schermo, e come usare le variabili, possiamo andare avanti con le basi di bash!
+# Per conoscere la directory su cui siamo posizionati, è sufficiente usare `pwd`.
+# `pwd` è l'acronimo di "print working directory", ovvero "stampa la directory corrente".
+# Possiamo anche usare la variabile builtin `$PWD`.
+# Prova questi due esempi, e vedi che il risultato è lo stesso:
+echo "Sono dentro $(pwd)" # esegue `pwd` ed interpola l'output
+echo "Sono dentro $PWD" # interpola direttamente la variabile builtin
+
+# Se c'è troppo testo nel terminale, ottenuto scrivendo comandi oppure eseguendo uno script, il comando `clear` pulisce lo schermo
+clear
+# Puoi utilizzare anche Ctrl-L al posto di clear
+
 # Leggere un valore di input:
 echo "Come ti chiami?"
 read Nome # Nota che non abbiamo dovuto dichiarare una nuova variabile
@@ -120,12 +150,52 @@ ls
 
 # Questi comandi hanno opzioni che controllano la loro esecuzione:
 ls -l # Elenca tutti i file e le cartelle su una riga separata
+ls -t # Ordina i contenuti della cartella in base all'ultima data di modifica (ordine decrescente)
+ls -R # Esegue `ls` in modo ricorsivo all'interno di questa cartella e tutte le sottocartelle
 
 # I risultati del comando precedente possono essere passati al comando successivo come input.
 # Il comando grep filtra l'input con il pattern passato. Ecco come possiamo elencare i
 # file .txt nella cartella corrente:
 ls -l | grep "\.txt"
 
+# Usa `cat` per stampare il contenuto dei file a schermo:
+cat file.txt
+
+# Possiamo leggere il contenuto di un file e memorizzarlo in una variabile, sempre usando `cat`:
+Contenuti=$(cat file.txt)
+echo "INIZIO DEL FILE\n$Contenuti\nFINE DEL FILE"
+
+# Usa `cp` per copiare file o cartelle da un punto all'altro del sistema.
+# `cp` crea NUOVE versioni dei file, quindi le modifiche della copia non hanno effetto sull'originale, e viceversa.
+# Nota che il file (o la cartella) di destinazione vengono sovrascritte se già esistono!
+cp fileSorgente.txt copia.txt
+cp -r cartellaSorgente/ destinazione/ # copia ricorsiva
+
+# Se hai bisogno di trasferire file tra computer, puoi usare `scp` o `sftp`.
+# `scp` ha una sintassi simile a `cp`.
+# `sftp` invece è più interattivo.
+
+# Usa `mv` per spostare file o cartella da un punto all'altro del sistema.
+# `mv` è simile a `cp`, ma cancella il file(o la cartella) sorgente.
+# `mv` è molto utile anche per rinominare i file!
+mv s0rg3nt3.txt dst.txt # mi spiace anonymous...
+
+# Dal momento che bash lavora nel contesto della cartella corrente, potresti voler eseguire il comando dentro a qualche altra cartella. Per fare questo si usa `cd`:
+cd ~ # va nella cartella Home
+cd .. # va nella cartella "padre"
+      # (ad esempio da /home/user/Download a /home/user)
+cd /home/user/Documenti # entra nella cartella specificata
+cd ~/Documenti/.. # siamo sempre nella cartella home... vero?
+
+# Usa le subshell per lavorare in cartelle diverse contemporaneamente
+(echo "All'inizio sono qua: $PWD") && (cd cartella; echo "Adesso invece sono qua: $PWD")
+pwd # siamo sempre nella prima cartella
+
+# Usa `mkdir` per creare nuove cartelle
+mkdir nuovaCartella
+# Il flag `-p` indica la creazione delle cartelle intermedie, se non esistono.
+mkdir nuovaCartella/con/tante/cartelle/intermedie
+
 # Puoi redirezionare l'input e l'output del comando (stdin, stdout, e stderr).
 # Leggi da stdin finchè ^EOF$ e sovrascrivi hello.py con le righe
 # comprese tra "EOF":
@@ -164,7 +234,9 @@ echo "#helloworld" | cat > output.out
 echo "#helloworld" | tee output.out >/dev/null
 
 # Pulisci i file temporanei verbosamente (aggiungi '-i' per la modalità interattiva)
+# Attenzione: il comando `rm` non può essere annullato!
 rm -v output.out error.err output-and-error.log
+rm -r cartellaTemporanea/ # cancella ricorsivamente
 
 # I comandi possono essere sostituiti con altri comandi usando $( ):
 # Il comando seguente mostra il numero di file e cartelle nella
@@ -255,10 +327,25 @@ sed -i 's/okay/great/g' file.txt
 grep "^foo.*bar$" file.txt
 # passa l'opzione "-c" per stampare invece il numero delle righe che soddisfano la regex
 grep -c "^foo.*bar$" file.txt
+# Altre opzioni utili possono essere:
+grep -r "^foo.*bar$" someDir/ # esegue `grep` ricorsivamente nella cartella
+grep -n "^foo.*bar$" file.txt # stampa il numero delle righe del file
+grep -rI "^foo.*bar$" someDir/ # esegue `grep` ricorsivamente nella cartella, ignorando i file non testuali
+# Esegue la stessa ricerca iniziale, ma filtrando solo le righe che contengono la stringa "baz"
+grep "^foo.*bar$" file.txt | grep -v "baz"
+
 # se vuoi letteralmente cercare la stringa,
 # e non la regex, usa fgrep (o grep -F)
-fgrep "^foo.*bar$" file.txt
+fgrep "foobar" file.txt
+
+# Il comando trap permette di eseguire un comando quando un segnale viene ricevuto dal tuo script.
+# In questo esempio, trap eseguirà rm se uno dei tre segnali (SIGHUP, SIGINT o SIGTERM) viene ricevuto.
+trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
 
+# `sudo` viene usato per eseguire comandi come superuser, ovvero come utente che ha maggiori privilegi all'interno del sistema
+$NOME1=$(whoami)
+$NOME2=$(sudo whoami)
+echo "Ero $NOME1, poi sono diventato più potente: $NOME2"
 
 # Leggi la documentazione dei builtin di bash con il builtin 'help' di bash:
 help
diff --git a/it-it/brainfuck-it.html.markdown b/it-it/bf-it.html.markdown
index 08d2ede9..a79710d0 100644
--- a/it-it/brainfuck-it.html.markdown
+++ b/it-it/bf-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index 92ebc165..b4f9c50e 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -8,6 +8,7 @@ contributors:
     - ["Connor Waters", "http://github.com/connorwaters"]
 translators:
     - ["Robert Margelli", "http://github.com/sinkswim/"]
+    - ["Tommaso Pifferi", "http://github.com/neslinesli93/"]
 lang: it-it
 ---
 
@@ -151,7 +152,7 @@ namespace Primo {
 namespace Secondo {
     void foo()
     {
-        printf("Questa è Secondo::foo\n")
+        printf("Questa è Secondo::foo\n");
     }
 }
 
@@ -460,7 +461,7 @@ void Cane::print() const
 
 Cane::~Cane()
 {
-    cout << "Ciao ciao " << nome << "\n";
+    std::cout << "Ciao ciao " << nome << "\n";
 }
 
 int main() {
@@ -646,7 +647,7 @@ void stampaMessaggio<10>() {
 
 printMessage<20>();  // Stampa "impara il C++ in 20 minuti!"
 printMessage<10>();  // Stampa "Impara il C++ più velocemente in soli 10 minuti!"                                   
-                                        
+
 ////////////////////////////
 // Gestione delle eccezioni
 ///////////////////////////
@@ -657,7 +658,7 @@ printMessage<10>();  // Stampa "Impara il C++ più velocemente in soli 10 minuti
 #include <exception>
 #include <stdexcept>
 
-// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi 
+// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi
 // handlers _catch_.
 try {
     // Non allocare eccezioni nello heap usando _new_.
@@ -805,6 +806,94 @@ void faiQualcosaConUnFile(const std::string& nomefile)
 //   sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità.
 // - I mutex usano lock_guard e unique_lock
 
+// I contenitori che utilizzano chiavi non-primitive (classi personalizzate)
+// richiedono la funzione di confronto nell'oggetto stesso, o tramite un puntatore a funzione.
+// Le chiavi primitive hanno funzioni di confronto già definite, ma puoi sovrascriverle.
+class Foo {
+public:
+    int j;
+    Foo(int a) : j(a) {}
+};
+struct funzioneDiConfronto {
+    bool operator()(const Foo& a, const Foo& b) const {
+        return a.j < b.j;
+    }
+};
+// Questo non è permesso, anche se qualche compilatore potrebbe non dare problemi
+//std::map<Foo, int> fooMap;
+std::map<Foo, int, funzioneDiConfronto> fooMap;
+fooMap[Foo(1)]  = 1;
+fooMap.find(Foo(1)); -- vero
+
+///////////////////////////////////////
+// Espressioni Lambda (C++11 e superiori)
+///////////////////////////////////////
+
+// Le espressioni lambda (più semplicemente "lambda") sono utilizzate
+// per definire una funzione anonima nel punto in cui viene invocata, o
+// dove viene passata come argomento ad una funzione
+
+// Ad esempio, consideriamo l'ordinamento di un vettore costituito da una
+// coppia di interi, utilizzando il secondo elemento per confrontare
+vector<pair<int, int> > tester;
+tester.push_back(make_pair(3, 6));
+tester.push_back(make_pair(1, 9));
+tester.push_back(make_pair(5, 0));
+
+// Passiamo una lambda come terzo argomento alla funzione di ordinamento
+// `sort` è contenuta nell'header <algorithm>
+sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
+    return lhs.second < rhs.second;
+});
+
+// Nota bene la sintassi utilizzata nelle lambda:
+// [] serve per "catturare" le variabili.
+// La "Lista di Cattura" definisce tutte le variabili esterne che devono essere disponibili
+// all'interno della funzione, e in che modo.
+// La lista può contenere:
+//     1. un valore: [x]
+//     2. un riferimento: [&x]
+//     3. qualunque variabile nello scope corrente, per riferimento [&]
+//     4. qualunque variabile nello scope corrente, per valore [=]
+// Esempio:
+
+vector<int> id_cani;
+// numero_cani = 3;
+for(int i = 0; i < 3; i++) {
+    id_cani.push_back(i);
+}
+
+int pesi[3] = {30, 50, 10};
+
+// Mettiamo che vuoi ordinare id_cani in base al peso dei cani
+// Alla fine, id_cani sarà: [2, 0, 1]
+
+// Le lambda vengono in aiuto
+
+sort(id_cani.begin(), id_cani.end(), [&pesi](const int &lhs, const int &rhs) {
+    return pesi[lhs] < pesi[rhs];
+});
+// Nota come abbiamo catturato "pesi" per riferimento nell'esempio.
+// Altre informazioni sulle lambda in C++: http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11
+
+///////////////////////////////
+// Ciclo For semplificato(C++11 e superiori)
+///////////////////////////////
+
+// Puoi usare un ciclo for per iterare su un tipo di dato contenitore
+int arr[] = {1, 10, 3};
+
+for(int elem: arr) {
+    cout << elem << endl;
+}
+
+// Puoi usare "auto" senza preoccuparti del tipo degli elementi nel contenitore
+// Ad esempio:
+
+for(auto elem: arr) {
+    // Fai qualcosa con `elem`
+}
+
 ///////////////////////
 // Roba divertente
 //////////////////////
@@ -855,20 +944,188 @@ Foo f1;
 f1 = f2;
 
 
-// Come deallocare realmente le risorse all'interno di un vettore:
-class Foo { ... };
-vector<Foo> v;
-for (int i = 0; i < 10; ++i)
-  v.push_back(Foo());
+///////////////////////////////////////
+// Tuple (C++11 e superiori)
+///////////////////////////////////////
+
+#include<tuple>
+
+// Concettualmente le tuple sono simili alle strutture del C, ma invece di avere
+// i membri rappresentati con dei nomi, l'accesso agli elementi avviene tramite
+// il loro ordine all'interno della tupla.
+
+// Cominciamo costruendo una tupla.
+// Inserire i valori in una tupla
+auto prima = make_tuple(10, 'A');
+const int maxN = 1e9;
+const int maxL = 15;
+auto seconda = make_tuple(maxN, maxL);
+
+// Vediamo gli elementi contenuti nella tupla "prima"
+cout << get<0>(prima) << " " << get<1>(prima) << "\n"; // stampa : 10 A
+
+// Vediamo gli elementi contenuti nella tupla "seconda"
+cout << get<0>(seconda) << " " << get<1>(seconda) << "\n"; // stampa: 1000000000 15
+
+// Estrarre i valori dalla tupla, salvandoli nelle variabili
+int primo_intero;
+char primo_char;
+tie(primo_intero, primo_char) = prima;
+cout << primo_intero << " " << primo_char << "\n";  // stampa : 10 A
+
+// E' possibile creare tuple anche in questo modo
+tuple<int, char, double> terza(11, 'A', 3.14141);
+
+// tuple_size ritorna il numero di elementi in una tupla (come constexpr)
+cout << tuple_size<decltype(terza)>::value << "\n"; // stampa: 3
+
+// tuple_cat concatena gli elementi di tutte le tuple, nell'esatto ordine
+// in cui sono posizionati all'interno delle tuple stesse
+auto tupla_concatenata = tuple_cat(prima, seconda, terza);
+// tupla_concatenata diventa = (10, 'A', 1e9, 15, 11, 'A' ,3.14141)
+
+cout << get<0>(tupla_concatenata) << "\n"; // stampa: 10
+cout << get<3>(tupla_concatenata) << "\n"; // stampa: 15
+cout << get<5>(tupla_concatenata) << "\n"; // stampa: 'A'
+
+
+/////////////////////
+// Contenitori
+/////////////////////
+
+// I Contenitori della "Standard Template Library", ovvero la libreria standard
+// dei template contenuti nel C++, sono template predefiniti.
+// I Contenitori si occupano di come allocare lo spazio per gli elementi contenuti,
+// e forniscono funzioni per accedervi e manipolarli
+
+// Vediamo alcuni tipi di contenitori:
+
+// Vector (array dinamici/vettori)
+// Permettono di definire un vettore, o una lista di oggetti, a runtime
+#include<vector>
+vector<Tipo_Dato> nome_vettore; // usato per inizializzare un vettore
+cin >> val;
+nome_vettore.push_back(val); // inserisce il valore di "val" nel vettore
+
+// Per iterare in un vettore, abbiamo due possibilità:
+// Ciclo normale
+for(int i=0; i<nome_vettore.size(); i++)
+// Cicla dall'indice zero fino all'ultimo
+
+// Iteratore
+vector<Tipo_Dato>::iterator it; // inizializza l'iteratore per il vettore
+for(it=nome_vettore.begin(); it!=nome_vettore.end();++it)
+// Nota che adesso non cicla più sugli indici, ma direttamente sugli elementi!
+
+// Per accedere agli elementi del vettore
+// Operatore []
+var = nome_vettore[indice]; // Assegna a "var" il valore del vettore all'indice dato
+
+
+// Set (insiemi)
+// Gli insiemi sono contenitori che memorizzano elementi secondo uno specifico ordine.
+// Gli insiemi vengono per lo più utilizzati per memorizzare valori unici, secondo
+// un ordine, senza scrivere ulteriore codice.
+
+#include<set>
+set<int> insieme;    // Inizializza un insieme di interi
+insieme.insert(30);  // Inserisce il valore 30 nell'insieme
+insieme.insert(10);  // Inserisce il valore 10 nell'insieme
+insieme.insert(20);  // Inserisce il valore 20 nell'insieme
+insieme.insert(30);  // Inserisce il valore 30 nell'insieme
+// Gli elementi dell'insieme sono:
+//  10 20 30
+
+// Per cancellare un elemento
+insieme.erase(20);  // Cancella l'elemento con valore 20
+// L'insieme contiene adesso: 10 30
+
+// Per iterare su un insieme, usiamo gli iteratori
+set<int>::iterator it;
+for(it=insieme.begin();it<insieme.end();it++) {
+    cout << *it << endl;
+}
+// Stampa:
+// 10
+// 30
+
+// Per svuotare il contenitore usiamo il metodo "clear"
+insieme.clear();
+cout << insieme.size();
+// Stampa: 0
+
+// Nota: per permettere elementi duplicati, possiamo usare "multiset"
+
+// Map (mappa/tabella di hash)
+// Le mappe servono per memorizzare un elemento, detto chiave, a cui viene
+// associato un valore, il tutto secondo uno specifico ordine.
+
+#include<map>
+map<char, int> mia_mappa;  // Inizializza una mappa che usa i char come chiave, e gli interi come valore
+
+mia_mappa.insert(pair<char,int>('A',1));
+// Inserisce il valore 1 per la chiave A
+mia_mappa.insert(pair<char,int>('Z',26));
+// Inserisce il valore 26 per la chiave Z
+
+// Per iterare
+map<char,int>::iterator it;
+for (it=mia_mappa.begin(); it!=mia_mappa.end(); ++it)
+    std::cout << it->first << "->" << it->second << '\n';
+// Stampa:
+// A->1
+// Z->26
+
+// Per trovare il valore corrispondente ad una data chiave
+it = mia_mappa.find('Z');
+cout << it->second;
+// Stampa: 26
+
+
+///////////////////////////////////
+// Operatori logici e bitwise(bit-a-bit)
+//////////////////////////////////
+
+// La maggior parte di questi operatori in C++ sono gli stessi degli altri linguaggi
+
+// Operatori logici
+
+// Il C++ usa la "Short-circuit evaluation" per le espressioni booleane. Cosa significa?
+// In pratica, in una condizione con due argomenti, il secondo viene considerato solo se
+// il primo non basta a determinate il valore finale dell'espresione.
+
+true && false // Effettua il **and logico** e ritorna falso
+true || false // Effettua il **or logico** e ritorna vero
+! true        // Effettua il **not logico** e ritorna falso
+
+// Invece di usare i simboli, si possono usare le keyword equivalenti
+true and false // Effettua il **and logico** e ritorna falso
+true or false  // Effettua il **or logico** e ritorna vero
+not true       // Effettua il **not logico** e ritorna falso
+
+// Operatori bitwise(bit-a-bit)
+
+// **<<** Operatore di Shift a Sinistra
+// << sposta i bit a sinistra
+4 << 1 // Sposta a sinistra di 1 i bit di 4, ottenendo 8
+// x << n in pratica realizza x * 2^n
+
+
+// **>>** Operatore di Shift a Destra
+// >> sposta i bit a destra
+4 >> 1 // Sposta a destra di 1 i bit di 4, ottenendo 2
+// x >> n in pratica realizza x / 2^n
 
-// La riga seguente riduce la dimensione di v a 0, ma il distruttore non
-// viene chiamato e dunque le risorse non sono deallocate!
-v.empty();
-v.push_back(Foo());  // Il nuovo valore viene copiato nel primo Foo che abbiamo inserito
+~4    // Effettua il NOT bit-a-bit
+4 | 3 // Effettua il OR bit-a-bit
+4 & 3 // Effettua il AND bit-a-bit
+4 ^ 3 // Effettua il XOR bit-a-bit
 
-// Distrugge realmente tutti i valori dentro v. Vedi la sezione riguardante gli
-// oggetti temporanei per capire come mai funziona così.
-v.swap(vector<Foo>());
+// Le keyword equivalenti sono
+compl 4    // Effettua il NOT bit-a-bit
+4 bitor 3  // Effettua il OR bit-a-bit
+4 bitand 3 // Effettua il AND bit-a-bit
+4 xor 3    // Effettua il XOR bit-a-bit
 
 ```
 Letture consigliate:
diff --git a/it-it/coffeescript-it.html.markdown b/it-it/coffeescript-it.html.markdown
index 31973369..d30ba819 100644
--- a/it-it/coffeescript-it.html.markdown
+++ b/it-it/coffeescript-it.html.markdown
@@ -4,8 +4,6 @@ contributors:
   - ["Luca 'Kino' Maroni", "http://github.com/kino90"]
   - ["Tenor Biel", "http://github.com/L8D"]
   - ["Xavier Yao", "http://github.com/xavieryao"]
-translators:
-    - ["Tommaso Pifferi","http://github.com/neslinesli93"]
 filename: coffeescript-it.coffee
 lang: it-it
 ---
diff --git a/it-it/git-it.html.markdown b/it-it/git-it.html.markdown
new file mode 100644
index 00000000..521538a1
--- /dev/null
+++ b/it-it/git-it.html.markdown
@@ -0,0 +1,498 @@
+---
+category: tool
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
+translators:
+    - ["Christian Grasso", "http://chris54721.net"]
+filename: LearnGit-it.txt
+lang: it-it
+---
+
+Git è un sistema di
+[controllo versione distribuito](https://it.wikipedia.org/wiki/Controllo_versione_distribuito)
+e di gestione del codice sorgente.
+
+Git esegue una serie di _snapshot_ per salvare lo stato di un progetto, così
+facendo può fornirti la possibilità di gestire il tuo codice e di salvarne lo
+stato assegnando delle versioni.
+
+## Basi del controllo versione
+
+### Cos'è il controllo versione?
+
+Il controllo versione (_Version Control_ o _Versioning_) è un sistema che
+registra le modifiche apportate a uno o più file nel tempo.
+
+### Controllo versione centralizzato e distribuito
+
+* Il controllo versione centralizzato si concentra sulla sincronizzazione, il
+  monitoraggio e il backup dei file.
+* Il controllo versione distribuito si concentra sulla condivisione delle
+  modifiche. Ogni modifica ha un identificatore univoco.
+* I sistemi distribuiti non hanno una struttura definita. Si potrebbe creare
+  ad esempio un sistema centralizzato simile a SVN utilizzando Git.
+
+[Ulteriori informazioni](http://git-scm.com/book/it/v1/Per-Iniziare-Il-Controllo-di-Versione)
+
+### Perchè usare Git?
+
+* Consente di lavorare offline.
+* Collaborare con altre persone è semplice!
+* Utilizzare i branch (rami di sviluppo) è semplice!
+* Git è veloce.
+* Git è flessibile.
+
+## Architettura di Git
+
+### Repository
+
+Un insieme di file, cartelle, registrazioni della cronologia e versioni.
+Immaginalo come una struttura dati del codice, con la caratteristica che ogni
+"elemento" del codice ti fornisce accesso alla sua cronologia delle revisioni,
+insieme ad altre cose.
+
+Un repository comprende la cartella .git e il working tree.
+
+### Cartella .git (componente del repository)
+
+La cartella .git contiene tutte le configurazioni, i log, i rami e altro.
+[Lista dettagliata](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Working Tree (componente del repository)
+
+Si tratta semplicemente delle cartelle e dei file presenti nel repository.
+Spesso viene indicato come "directory di lavoro" ("working directory").
+
+### Index (componente della cartella .git)
+
+L'Index è l'area di staging di Git. Si tratta di un livello che separa il
+working tree dal repository. Ciò fornisce agli sviluppatori più controllo su
+cosa viene inviato al repository.
+
+### Commit
+
+Un commit è uno snapshot di una serie di modifiche apportate al working tree.
+Ad esempio, se hai aggiunto 5 file e ne hai rimossi 2, ciò sarà registrato in
+un commit. Il commit può essere pushato (inviato) o meno ad altri repository.
+
+### Branch (ramo)
+
+Un branch (ramo) è essenzialmente un puntatore all'ultimo commit che hai
+effettuato. Effettuando altri commit, il puntatore verrà automaticamente
+aggiornato per puntare all'ultimo commit.
+
+### Tag
+
+Un tag è un contrassegno applicato a un punto specifico nella cronologia dei
+commit. Di solito i tag vengono utilizzati per contrassegnare le versioni
+rilasciate (v1.0, v1.1, etc.).
+
+### HEAD e head (componenti della cartella .git)
+
+HEAD (in maiuscolo) è un puntatore che punta al branch corrente. Un repository
+può avere solo 1 puntatore HEAD *attivo*.
+
+head (in minuscolo) è un puntatore che può puntare a qualsiasi commit. Un
+repository può avere un numero qualsiasi di puntatori head.
+
+### Stadi di Git
+* _Modified_ - Un file è stato modificato, ma non è ancora stato effettuato
+  un commit per registrare le modifiche nel database di Git
+* _Staged_ - Un file modificato è stato contrassegnato per essere incluso nel
+  prossimo commit
+* _Committed_ - È stato effettuato un commit e le modifiche sono state
+  registrate nel database di Git
+
+## Comandi
+
+### init
+
+Crea un repository Git vuoto. Le impostazioni e le informazioni del repository
+sono salvate nella cartella ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+Utilizzato per configurare le impostazioni, sia specifiche del repository, sia
+a livello globale. Le impostazioni globali sono salvate in `~/.gitconfig`.
+
+```bash
+$ git config --global user.email "email@example.com"
+$ git config --global user.name "Nome utente"
+```
+
+[Ulteriori informazioni su git config](http://git-scm.com/docs/git-config)
+
+### help
+
+Fornisce una documentazione molto dettagliata di ogni comando.
+
+```bash
+# Mostra i comandi più comuni
+$ git help
+
+# Mostra tutti i comandi disponibili
+$ git help -a
+
+# Documentazione di un comando specifico
+# git help <nome_comando>
+$ git help add
+$ git help commit
+$ git help init
+# oppure git <nome_comando> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### Ignorare file
+
+Per impedire intenzionalmente che file privati o temporanei vengano inviati
+al repository Git.
+
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "privato.txt" >> .gitignore
+```
+
+
+### status
+
+Mostra le differenza tra lo stato attuale del working tree e l'attuale commit
+HEAD.
+
+```bash
+$ git status
+```
+
+### add
+
+Aggiunge file alla staging area, ovvero li contrassegna per essere inclusi nel
+prossimo commit. Ricorda di aggiungere i nuovi file, altrimenti non saranno
+inclusi nei commit!
+
+```bash
+# Aggiunge un file nella directory attuale
+$ git add HelloWorld.java
+
+# Aggiunge un file in una sottocartella
+$ git add /path/to/file/HelloWorld.c
+
+# Il comando supporta le espressioni regolari
+$ git add ./*.java
+
+# Aggiunge tutti i file non ancora contrassegnati
+$ git add --all
+```
+
+Questo comando contrassegna soltanto i file, senza effettuare un commit.
+
+### branch
+
+Utilizzato per gestire i branch (rami). Puoi visualizzare, modificare, creare o
+eliminare branch utilizzando questo comando.
+
+```bash
+# Visualizza i branch e i remote
+$ git branch -a
+
+# Crea un nuovo branch
+$ git branch nuovoBranch
+
+# Elimina un branch
+$ git branch -d nomeBranch
+
+# Rinomina un branch
+$ git branch -m nomeBranch nuovoNomeBranch
+
+# Permette di modificare la descrizione di un branch
+$ git branch nomeBranch --edit-description
+```
+
+### tag
+
+Utilizzato per gestire i tag.
+
+```bash
+# Visualizza i tag esistenti
+$ git tag
+# Crea un nuovo tag
+# L'opzione -m consente di specificare una descrizione per il tag.
+# Se l'opzione -m non viene aggiunta, Git aprirà un editor per consentire
+# l'inserimento del messaggio.
+$ git tag -a v2.0 -m 'Versione 2.0'
+# Mostra informazioni relative a un tag
+# Include informazioni sul creatore del tag, la data di creazione, e il
+# messaggio assegnato al tag oltre alle informazioni sul commit.
+$ git show v2.0
+```
+
+### checkout
+
+Consente di cambiare branch o ripristinare i file a una revisione specifica.
+Tutti i file nel working tree vengono aggiornati per corrispondere alla versione
+presente nel branch o nel commit specificato.
+
+```bash
+# Effettua il checkout di un repository - il branch predefinito è 'master'
+$ git checkout
+# Effettua il checkout di un branch specifico
+$ git checkout nomeBranch
+# Crea un nuovo branch e ne effettua il checkout
+# Equivalente a "git branch <nomeBranch>; git checkout <nomeBranch>"
+$ git checkout -b nuovoBranch
+```
+
+### clone
+
+Clona, o copia, un repository esistente in una nuova directory. Inoltre,
+aggiunge dei branch _remote-tracking_, utilizzati per monitorare i branch
+remoti corrispondenti a quelli locali, e consentendo così di inviare le
+modifiche al repository remoto.
+
+```bash
+# Clona learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+# Clona solo l'ultima revisione di un repository
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+# Clona solo un branch specifico
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
+```
+
+### commit
+
+Effettua uno _snapshot_ dello stato attuale del working tree e registra le
+modifiche in un nuovo commit. Il commit contiene, oltre alle modifiche apportate,
+anche l'autore e una descrizione.
+
+```bash
+# Crea un nuovo commit con un messaggio
+$ git commit -m "Aggiunta la funzione multiplyNumbers() in HelloWorld.c"
+
+# Aggiunge (git add) automaticamente i file modificati o eliminati (ESCLUSI
+# i nuovi file) e quindi effettua il commit
+$ git commit -a -m "Modificato foo.php e rimosso bar.php"
+
+# Modifica l'ultimo commit (il comando elimina il commit precedente e lo
+# sostituisce con uno nuovo)
+$ git commit --amend -m "Messaggio corretto"
+```
+
+### diff
+
+Mostra la differenza tra un file nel working tree e la sua versione nell'index,
+in un branch o ad un commit specifico.
+
+```bash
+# Mostra la differenza tra il working tree e l'index
+$ git diff
+
+# Mostra la differenza tra l'index e il commit più recente
+$ git diff --cached
+
+# Mostra la differenza tra il working tree e un commit specifico
+$ git diff <commit>
+
+# Mostra la differenza tra due commit
+$ git diff <commit1> <commit2>
+```
+
+### grep
+
+Consente di effettuare una ricerca veloce nel repository.
+
+```bash
+# Cerca "variableName" nei file Java
+$ git grep 'variableName' -- '*.java'
+
+# Cerca una riga contenente "arrayListName" E "add" oppure "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Impostazioni relative a `git grep`:
+
+```bash
+# Mostra il numero delle righe
+$ git config --global grep.lineNumber true
+
+# Rende i risultati più leggibili
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+### log
+
+Mostra la cronologia dei commit inviati al repository.
+
+```bash
+# Mostra tutti i commit
+$ git log
+
+# Mostra ogni commit su una sola riga
+$ git log --oneline
+
+# Mostra solo i commit legati ai merge
+$ git log --merges
+```
+
+### merge
+
+Effettua un "merge", ovvero unisce le modifiche di un branch in quello attuale.
+
+```bash
+# Unisce il branch specificato a quello attuale
+$ git merge nomeBranch
+
+# Genera un commit in ogni caso dopo aver eseguito il merge
+$ git merge --no-ff nomeBranch
+```
+
+### mv
+
+Rinomina o sposta un file.
+
+```bash
+# Rinomina un file
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Sposta un file
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Forza l'esecuzione del comando
+# Se un file "nuovoNomeFile" esiste già nella directory, verrà sovrascritto
+$ git mv -f nomeFile nuovoNomeFile
+```
+
+### pull
+
+Aggiorna il repository effettuando il merge delle nuove modifiche.
+
+```bash
+# Aggiorna il branch attuale dal remote "origin"
+$ git pull
+
+# Di default, git pull aggiorna il branch attuale effettuando il merge
+# delle nuove modifiche presenti nel branch remote-tracking corrispondente
+$ git pull
+
+# Aggiorna le modifiche dal branch remoto, quindi effettua il rebase dei commit
+# nel branch locale
+# Equivalente a: "git pull <remote> <branch>; git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Invia ed effettua il merge delle modifiche da un branch locale ad uno remoto.
+
+```bash
+# Invia ed effettua il merge delle modifiche dal branch "master"
+# al remote "origin".
+# git push <remote> <branch>
+$ git push origin master
+
+# Di default, git push invia ed effettua il merge delle modifiche
+# dal branch attuale al branch remote-tracking corrispondente
+$ git push
+
+# Per collegare il branch attuale ad uno remoto, basta aggiungere l'opzione -u
+$ git push -u origin master
+```
+
+### stash
+
+Salva lo stato attuale del working tree in una lista di modifiche non ancora
+inviate al repository con un commit che possono essere applicate nuovamente
+in seguito.
+
+Questo comando può essere utile se, ad esempio, mentre stai effettuando delle
+modifiche non ancora completate, hai bisogno di aggiornare il repository locale
+con `git pull`. Poichè non hai ancora effettuato il commit di tutte le modifiche,
+non sarà possibile effettuare il pull. Tuttavia, puoi utilizzare `git stash` per
+salvare temporaneamente le modifiche e applicarle in seguito.
+
+```bash
+$ git stash
+```
+
+Ora puoi effettuare il pull:
+
+```bash
+$ git pull
+```
+
+A questo punto, come già suggerito dall'output del comando `git stash`, puoi
+applicare le modifiche:
+
+```bash
+$ git stash apply
+```
+
+Infine puoi controllare che tutto sia andato bene:
+
+```bash
+$ git status
+```
+
+Puoi visualizzare gli accantonamenti che hai effettuato finora utilizzando:
+
+```bash
+$ git stash list
+```
+
+### rebase (attenzione)
+
+Applica le modifiche effettuate su un branch su un altro branch.
+*Non effettuare il rebase di commit che hai già inviato a un repository pubblico!*
+
+```bash
+# Effettua il rebase di experimentBranch in master
+$ git rebase master experimentBranch
+```
+
+[Ulteriori informazioni](https://git-scm.com/book/it/v1/Diramazioni-in-Git-Rifondazione)
+
+### reset (attenzione)
+
+Effettua il reset del commit HEAD attuale ad uno stato specifico.
+Questo comando consente di annullare `merge`, `pull`, `commit`, `add` e altro.
+Tuttavia, può essere pericoloso se non si sa cosa si sta facendo.
+
+```bash
+# Effettua il reset della staging area (annullando le aggiunte e le rimozioni
+# di file dal repository, senza modificare il working tree)
+$ git reset
+
+# Effettua il reset completo della staging area, ovvero annulla qualsiasi
+# modifica al repository eliminando definitivamente anche tutte le modifiche
+# ai file non inviate e ripristinando il working tree
+$ git reset --hard
+
+# Effettua il reset del branch attuale al commit specificato (lasciando il
+# working tree intatto)
+$ git reset 31f2bb1
+
+# Effettua il reset completo del branch attuale al commit specificato,
+# eliminando qualsiasi modifica non inviata
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Consente di rimuovere un file dal working tree e dal repository.
+Per eliminare un file solo dal working tree ma non dal repository, è invece
+necessario utilizzare `/bin/rm`.
+
+```bash
+# Elimina un file nella directory attuale
+$ git rm HelloWorld.c
+
+# Elimina un file da una sottocartella
+$ git rm /pather/to/the/file/HelloWorld.c
+```
diff --git a/it-it/go-it.html.markdown b/it-it/go-it.html.markdown
new file mode 100644
index 00000000..e005f2dc
--- /dev/null
+++ b/it-it/go-it.html.markdown
@@ -0,0 +1,453 @@
+---
+name: Go
+language: Go
+filename: learngo-it.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"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
+translators:
+    - ["Tommaso Pifferi","http://github.com/neslinesli93"]
+lang: it-it
+---
+
+Go è stato creato per avere tra le mani uno strumento in grado di arrivare
+al punto, nel modo più veloce ed efficiente possibile. Non è all'ultima
+moda tra i linguaggi di programmazione, ma è una delle migliori soluzioni
+per risolvere in maniera efficace i problemi di tutti i giorni.
+
+Go presenta alcuni concetti già presenti nei linguaggi imperativi con
+tipizzazione statica. Compila velocemente ed esegue altrettanto veloce.
+Aggiunge la concorrenza in maniera diretta e semplice da capire, per far
+forza sulle CPU multi-core di oggigiorno. Presenta caratteristiche utili
+per la programmazione in larga scala.
+
+Go comes with a great standard library and an enthusiastic community.
+
+```go
+// Commento su riga singola
+/* Commento
+ su riga multipla */
+
+// In cima a ogni file è necessario specificare il package.
+// Main è un package speciale che identifica un eseguibile anziché una libreria.
+package main
+
+// Con import sono dichiarate tutte le librerie a cui si fa riferimento 
+// all'interno del file.
+import (
+	"fmt"       // Un package nella libreria standard di Go.
+	"io/ioutil" // Implementa alcune funzioni di utility per l'I/O.
+	m "math"    // Libreria matematica, con alias locale m
+	"net/http"  // Sì, un web server!
+	"strconv"   // Package per la conversione di stringhe.
+)
+
+// Una definizione di funzione. Il main è speciale: è il punto di ingresso
+// per il programma. Amalo o odialo, ma Go usa le parentesi graffe.
+func main() {
+    // Println stampa una riga a schermo.
+    // Questa funzione è all'interno del package fmt.
+	fmt.Println("Ciao mondo!")
+
+    // Chiama un'altra funzione all'interno di questo package.
+	oltreIlCiaoMondo()
+}
+
+// Le funzioni ricevono i parametri all'interno di parentesi tonde.
+// Se la funzione non riceve parametri, vanno comunque messe le parentesi (vuote).
+func oltreIlCiaoMondo() {
+	var x int // Dichiarazione di una variabile. Ricordati di dichiarare sempre le variabili prima di usarle!
+	x = 3     // Assegnazione di una variabile.
+    // E' possibile la dichiarazione "rapida" := per inferire il tipo, dichiarare e assegnare contemporaneamente.
+	y := 4
+    // Una funzione che ritorna due valori.
+	somma, prod := imparaMoltepliciValoriDiRitorno(x, y)
+	fmt.Println("somma:", somma, "prodotto:", prod)    // Semplice output.
+	imparaTipi()                                       // < y minuti, devi imparare ancora!
+}
+
+/* <- commento su righe multiple
+Le funzioni possono avere parametri e ritornare (molteplici!) valori.
+Qua, x e y sono gli argomenti, mentre somma e prod sono i valori ritornati.
+Da notare il fatto che x e somma vengono dichiarati come interi.
+*/
+func imparaMoltepliciValoriDiRitorno(x, y int) (somma, prod int) {
+	return x + y, x * y // Ritorna due valori.
+}
+
+// Ecco alcuni tipi presenti in Go
+func imparaTipi() {
+    // La dichiarazione rapida di solito fa il suo lavoro.
+	str := "Impara il Go!" // Tipo stringa.
+
+	s2 := `Una stringa letterale
+puo' includere andata a capo.` // Sempre di tipo stringa.
+
+    // Stringa letterale non ASCII. I sorgenti Go sono in UTF-8.
+	g := 'Σ' // Il tipo runa, alias per int32, è costituito da un code point unicode.
+
+	f := 3.14195 // float64, un numero in virgola mobile a 64-bit (IEEE-754)
+
+	c := 3 + 4i  // complex128, rappresentato internamente con due float64.
+
+    // Inizializzare le variabili con var.
+	var u uint = 7 // Senza segno, ma la dimensione dipende dall'implementazione (come l'int)
+	var pi float32 = 22. / 7 
+
+    // Sintassi per la conversione.
+	n := byte('\n') // Il tipo byte è un alias per uint8.
+
+    // I vettori hanno dimensione fissa, stabilita durante la compilazione.
+	var a4 [4]int           // Un vettore di 4 interi, tutti inizializzati a 0.
+	a3 := [...]int{3, 1, 5} // Un vettore inizializzato con una dimensione fissa pari a 3, i cui elementi sono 3, 1 e 5.
+
+    // Gli slice hanno dimensione variabile. Vettori e slice hanno pro e contro,
+    // ma generalmente si tende a usare più spesso gli slice.
+	s3 := []int{4, 5, 9}    // La differenza con a3 è che qua non ci sono i 3 punti all'interno delle parentesi quadre.
+	s4 := make([]int, 4)    // Alloca uno slice di 4 interi, tutti inizializzati a 0.
+	var d2 [][]float64      // Semplice dichiarazione, non vengono fatte allocazioni.
+	bs := []byte("uno slice") // Sintassi per la conversione.
+
+    // Poiché gli slice sono dinamici, è possibile aggiungere elementi
+    // quando è necessario. Per farlo, si usa la funzione append(). Il primo
+    // argomento è lo slice a cui stiamo aggiungendo elementi. Di solito
+    // lo slice viene aggiornato, senza fare una copia, come nell'esempio:
+	s := []int{1, 2, 3}		// Il risultato è uno slice di dimensione 3.
+	s = append(s, 4, 5, 6)	// Aggiunge 3 elementi: lo slice ha dimensione 6.
+	fmt.Println(s) // Lo slice aggiornato è [1 2 3 4 5 6]
+    // Per aggiungere un altro slice, invece che elencare gli elementi uno ad
+    // uno, è possibile passare alla funzione append un riferimento ad uno
+    // slice, oppure uno slice letterale: in questo caso si usano i tre punti,
+    // dopo lo slice, a significare "prendi ciascun elemento dello slice":
+	s = append(s, []int{7, 8, 9}...) // Il secondo argomento è uno slice letterale.
+	fmt.Println(s)	// Lo slice aggiornato è [1 2 3 4 5 6 7 8 9]
+
+	p, q := imparaLaMemoria() // Dichiara due puntatori a intero: p e q.
+	fmt.Println(*p, *q)   // * dereferenzia un puntatore. Questo stampa due interi.
+
+    // Una variabile di tipo map è un vettore associativo di dimensione variabile,
+    // e funzionano come le tabelle di hash o i dizionari in altri linguaggi.
+	m := map[string]int{"tre": 3, "quattro": 4}
+	m["uno"] = 1
+
+    // Le variabili dichiarate e non usate sono un errore in Go.
+    // L'underscore permette di "usare" una variabile, scartandone il valore.
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+	// Stampare a schermo ovviamente significa usare una variabile.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	imparaControlloDiFlusso() // Torniamo in carreggiata.
+}
+
+// In Go è possibile associare dei nomi ai valori di ritorno di una funzione.
+// Assegnare un nome al tipo di dato ritornato permette di fare return in vari
+// punti all'interno del corpo della funzione, ma anche di usare return senza
+// specificare in modo esplicito che cosa ritornare.
+func imparaValoriDiRitornoConNome(x, y int) (z int) {
+	z = x * y
+	return // z è implicito, perchè compare nella definizione di funzione.
+}
+
+// Go è dotato di garbage collection. Ha i puntatori, ma non l'aritmetica dei
+// puntatori. Puoi fare errori coi puntatori a nil, ma non puoi direttamente
+// incrementare un puntatore.
+func imparaLaMemoria() (p, q *int) {
+    // I valori di ritorno (con nome) p e q sono puntatori a int.
+	p = new(int) // La funzione new si occupa di allocare memoria.
+    // L'int allocato viene inizializzato a 0, dunque p non è più nil.
+	s := make([]int, 20) // Alloca 20 int come un singolo blocco di memoria.
+	s[3] = 7             // Ne assegna uno.
+	r := -2              // Dichiara un'altra variabile locale
+	return &s[3], &r     // & "prende" l'indirizzo di un oggetto.
+}
+
+func calcoloCostoso() float64 {
+	return m.Exp(10)
+}
+
+func imparaControlloDiFlusso() {
+    // L'istruzione if richiede parentesi graffe per il corpo, mentre non ha
+    // bisogno di parentesi tonde per la condizione.
+	if true {
+		fmt.Println("te l'ho detto")
+	}
+    // Eseguendo "go fmt" da riga di comando, il codice viene formattato
+    // in maniera standard.
+	if false {
+		// :(
+	} else {
+		// :D
+	}
+    // L'istruzione switch serve ad evitare tanti if messi in cascata.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// Quando è soddisfatta la condizione all'interno di un case, il
+        // programma esce dal switch senza che siano specificate istruzioni
+        // di tipo "break". In Go infatti di default non è presente il
+        // cosiddetto "fall through" all'interno dell'istruzione switch.
+        // Tuttavia, il linguaggio mette a disposizione la parola chiave
+        // fallthrough per permettere, in casi particolari, questo comportamento.
+	case 43:
+		// Non si arriva qua.
+	default:
+		// Il caso di default è opzionale.
+	}
+    // Come l'if, anche il for non usa parentesi tonde per la condizione.
+    // Le variabili dichiarate all'interno di if/for sono locali al loro scope.
+	for x := 0; x < 3; x++ { // ++ è un'istruzione!
+		fmt.Println("ciclo numero", x)
+	}
+	// x == 42 qua.
+
+    // Il for è l'unica istruzione per ciclare in Go, ma ha varie forme.
+	for { // Ciclo infinito.
+		break    // Scherzavo.
+		continue // Non si arriva qua.
+	}
+
+    // Puoi usare range per ciclare su un vettore, slice, stringa, mappa o canale.
+    // range ritorna uno (per i canali) o due valori (vettore, slice, stringa, mappa).
+	for chiave, valore := range map[string]int{"uno": 1, "due": 2, "tre": 3} {
+        // per ogni coppia dentro la mappa, stampa chiave e valore
+		fmt.Printf("chiave=%s, valore=%d\n", chiave, valore)
+	}
+
+    // Come nel for, := dentro la condizione dell'if è usato per dichiarare
+    // e assegnare y, poi testare se y > x.
+	if y := calcoloCostoso(); y > x {
+		x = y
+	}
+	// Le funzioni letterali sono closure.
+	xGrande := func() bool {
+		return x > 10000 // Si riferisce a x dichiarata sopra al switch (vedi sopra).
+	}
+	fmt.Println("xGrande:", xGrande()) // true (abbiamo assegnato e^10 a x).
+	x = 1.3e3                          // Adesso x == 1300
+	fmt.Println("xGrande:", xGrande()) // false ora.
+
+    // Inoltre le funzioni letterali possono essere definite e chiamate
+    // inline, col ruolo di parametri di funzione, a patto che:
+    // a) la funzione letterale venga chiamata subito (),
+    // b) il valore ritornato è in accordo con il tipo dell'argomento.
+	fmt.Println("Somma e raddoppia due numeri: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Chiamata con argomenti 10 e 2
+	// => Somma e raddoppia due numeri: 24
+
+	// Quando ti servirà, lo amerai.
+	goto amore
+amore:
+
+	imparaFabbricaDiFunzioni() // Una funzione che ritorna un'altra funzione è divertente!
+	imparaDefer()              // Un tour veloce di una parola chiave importante.
+	imparaInterfacce()         // Arriva la roba buona!
+}
+
+func imparaFabbricaDiFunzioni() {
+    // Questi due blocchi di istruzioni sono equivalenti, ma il secondo è più semplice da capire.
+	fmt.Println(fabbricaDiFrasi("estate")("Una bella giornata", "giornata!"))
+
+	d := fabbricaDiFrasi("estate")
+	fmt.Println(d("Una bella", "giornata!"))
+	fmt.Println(d("Un pigro", "pomeriggio!"))
+}
+
+// I decoratori sono comuni in alcuni linguaggi. Si può fare lo stesso in Go
+// con le funzioni letterali che accettano argomenti.
+func fabbricaDiFrasi(miaStringa string) func(prima, dopo string) string {
+	return func(prima, dopo string) string {
+		return fmt.Sprintf("%s %s %s", prima, miaStringa, dopo) // Nuova stringa
+	}
+}
+
+func imparaDefer() (ok bool) {
+    // Le istruzioni dette "deferred" (rinviate) sono eseguite
+    // appena prima che la funzione ritorni.
+	defer fmt.Println("le istruzioni 'deferred' sono eseguite in ordine inverso (LIFO).")
+	defer fmt.Println("\nQuesta riga viene stampata per prima perché")
+    // defer viene usato di solito per chiudere un file, così la funzione che
+    // chiude il file viene messa vicino a quella che lo apre.
+	return true
+}
+
+// Definisce Stringer come un'interfaccia con un metodo, String.
+type Stringer interface {
+	String() string
+}
+
+// Definisce coppia come una struct con due campi interi, chiamati x e y.
+type coppia struct {
+	x, y int
+}
+
+// Definisce un metodo sul tipo coppia, che adesso implementa Stringer.
+func (p coppia) String() string { // p viene definito "ricevente"
+    // Sprintf è un'altra funzione del package ftm.
+    // La notazione con il punto serve per richiamare i campi di p.
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func imparaInterfacce() {
+	// Brace syntax is a "struct literal". It evaluates to an initialized
+	// struct. The := syntax declares and initializes p to this struct.
+    // Le parentesi graffe sono usate per le cosiddette "struct letterali".
+    // Con :=, p viene dichiarata e inizializzata a questa struct.
+	p := coppia{3, 4}
+	fmt.Println(p.String()) // Chiama il metodo String di p, che è di tipo coppia.
+	var i Stringer          // Dichiara i come interfaccia Stringer.
+	i = p                   // Valido perchè coppia implementa Stringer.
+    // Chiama il metodo String di i, che è di tipo Stringer. Output uguale a sopra.
+	fmt.Println(i.String())
+
+	// Functions in the fmt package call the String method to ask an object
+	// for a printable representation of itself.
+    // Le funzioni dentro al package fmt chiamano il metodo String per
+    // chiedere ad un oggetto una rappresentazione in stringhe di sé stesso.
+	fmt.Println(p) // Output uguale a sopra. Println chiama il metodo String.
+	fmt.Println(i) // Output uguale a sopra.
+
+	imparaParametriVariadici("grande", "imparando", "qua!")
+}
+
+// Le funzioni possono avere parametri variadici (ovvero di lunghezza variabile).
+func imparaParametriVariadici(mieStringhe ...interface{}) {
+    // Cicla su ogni valore variadico.
+    // L'underscore serve a ignorare l'indice del vettore.
+	for _, param := range mieStringhe {
+		fmt.Println("parametro:", param)
+	}
+
+    // Passa un valore variadico come parametro variadico.
+	fmt.Println("parametri:", fmt.Sprintln(mieStringhe...))
+
+	imparaGestioneErrori()
+}
+
+func imparaGestioneErrori() {
+    // La sintassi ", ok" è usata per indicare se qualcosa ha funzionato o no.
+	m := map[int]string{3: "tre", 4: "quattro"}
+	if x, ok := m[1]; !ok { // ok sarà false perchè 1 non è dentro la mappa.
+		fmt.Println("qua non c'è nessuno!")
+	} else {
+		fmt.Print(x) // x sarebbe il valore che corrisponde alla chiave 1, se fosse nella mappa.
+	}
+    // Un errore non riporta soltanto "ok" ma è più specifico riguardo al problema.
+	if _, err := strconv.Atoi("non_intero"); err != nil { // _ scarta il valore
+		// stampa 'strconv.ParseInt: parsing "non_intero": invalid syntax'
+		fmt.Println(err)
+	}
+    // Approfondiremo le interfacce un'altra volta. Nel frattempo,
+	imparaConcorrenza()
+}
+
+// c è un canale, un oggetto per comunicare in modo concorrente e sicuro.
+func inc(i int, c chan int) {
+	c <- i + 1 // <- è l'operatore di "invio" quando un canale sta a sinistra.
+}
+
+// Useremo inc per incrementare alcuni numeri in modo concorrente.
+func imparaConcorrenza() {
+    // Stessa funzione usata prima per creare uno slice. Make alloca e
+    // inizializza slice, mappe e canali.
+	c := make(chan int)
+    // Lancia tre goroutine. I numeri saranno incrementati in modo concorrente,
+    // forse in parallelo se la macchina lo supporta. Tutti e tre inviano dati
+    // sullo stesso canale.
+	go inc(0, c) // go è un'istruzione che avvia una goroutine.
+	go inc(10, c)
+	go inc(-805, c)
+    // Legge tre risultati dal canale e li stampa a schermo.
+    // Non si conosce a priori l'ordine in cui i risultati arriveranno!
+	fmt.Println(<-c, <-c, <-c) // <- è l'operatore di "ricevuta" quando
+    // un canale sta a destra.
+
+	cs := make(chan string)       // Un altro canale, gestisce le stringhe.
+	ccs := make(chan chan string) // Un canale che gestisce canali di stringhe.
+	go func() { c <- 84 }()       // Lancia una goroutine, solo per inviare un valore.
+	go func() { cs <- "parolina" }() // Stessa cosa ma per cs.
+    // select è simile a switch, ma ogni case riguarda un'operazione su un
+    // canale. Seleziona, in modo random, uno tra i canali che sono pronti
+    // a comunicare.
+	select {
+	case i := <-c: // Il valore ricevuto può essere assegnato a una variabile,
+		fmt.Printf("E' un %T", i)
+	case <-cs: // oppure il valore ricevuto può essere scartato.
+		fmt.Println("E' una stringa.")
+	case <-ccs: // Canale vuoto, non pronto per comunicare.
+		fmt.Println("Non succede niente.")
+	}
+    // A questo punto un valore è stato preso da c o cs. Una delle tue goroutine
+    // cominciate sopra ha completato l'esecuzione, l'altra rimarrà bloccata.
+
+	imparaProgrammazioneWeb() // Se lo fa Go, lo puoi fare anche tu.
+}
+
+// Una funzione all'interno del package http avvia un webserver.
+func imparaProgrammazioneWeb() {
+
+    // Il primo parametro di ListenAndServe è l'indirizzo TCP su cui ascoltare.
+    // Il secondo parametro è un'interfaccia, precisamente http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", coppia{})
+		fmt.Println(err) // Non ignorare gli errori.
+	}()
+
+	richiediServer()
+}
+
+// Per rendere coppia un http.Handler basta implementare il metodo ServeHTTP.
+func (p coppia) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+    // Il server fornisce dati con un metodo di http.ResponseWriter.
+	w.Write([]byte("Hai imparato Go in Y minuti!"))
+}
+
+func richiediServer() {
+	risposta, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer risposta.Body.Close()
+	corpo, err := ioutil.ReadAll(risposta.Body)
+	fmt.Printf("\nIl webserver dice: `%s`", string(corpo))
+}
+```
+
+## Letture consigliate
+
+La risorsa più importante per imparare il Go è il [sito ufficiale di Go](http://golang.org/).
+Qui puoi seguire i tutorial, scrivere codice in modo interattivo, e leggere tutti i dettagli.
+Oltre al tour, [la documentazione](https://golang.org/doc/) contiene informazioni su
+come scrivere ottimo codice in Go, documentazione sui package e sui comandi, e
+la cronologia delle release.
+
+Anche il documento che definisce il linguaggio è un'ottima lettura. E' semplice
+da leggere e incredibilmente corto (rispetto ad altri documenti riguardanti
+la creazione di linguaggi).
+
+Puoi giocare con il codice visto finora nel [Go playground](https://play.golang.org/p/Am120Xe7qf).
+Prova a cambiarlo e ad eseguirlo dal browser!
+Osserva che puoi usare [https://play.golang.org](https://play.golang.org) come
+una [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) per scrivere
+codice all'interno del browser, senza neanche installare Go!
+
+Una lettura importante per capire Go in modo più profondo è il [codice 
+sorgente della libreria standard](http://golang.org/src/pkg/). Infatti è
+molto ben documentato e costituisce quanto più chiaro e conciso ci sia riguardo
+gli idiomi e le buone pratiche del Go. Inoltre, clickando sul nome di una
+funzione [nella documentazione](http://golang.org/pkg/) compare il relativo
+codice sorgente!
+
+Un'altra ottima risorsa per imparare è [Go by example](https://gobyexample.com/).
+
+Go Mobile aggiunge il supporto per lo sviluppo mobile (Android e iOS).
+In questo modo è possibile scrivere un'app mobile nativa in Go, oppure
+una libreria che contiene binding da un package scritto in Go, e che può
+essere richiamata da Java(Android) e Objective-C(iOS). Visita la pagina di
+[Go Mobile](https://github.com/golang/go/wiki/Mobile) per maggiori informazioni.
diff --git a/it-it/logtalk-it.html.markdown b/it-it/logtalk-it.html.markdown
new file mode 100644
index 00000000..7f1e9eeb
--- /dev/null
+++ b/it-it/logtalk-it.html.markdown
@@ -0,0 +1,550 @@
+---
+language: Logtalk
+filename: learnlogtalk-it.lgt
+contributors:
+    - ["Paulo Moura", "http://github.com/pmoura"]
+translators:
+    - ["Ugo Chirico", "https://github.com/ugochirico"]
+lang: it-it
+---
+
+Logtalk è un linguaggio di programmazione logica orientata agli oggetti che estende il linguaggio Prolog con le moderne tecniche di Object-Oriented Programming quali incapsulamento, ereditarietà e riutilizzo del codice, senza compromettere le caratteristiche di programmazione dichiarativa del Prolog. Logtalk è implementato in codice altamente portabile e utilizza i più moderni standard di conformità del Prolog rispetto al compilatore backend.
+
+Per mantenere una dimensione ragionevole, questo tutorial presuppone necessariamente che il lettore abbia una conoscenza del linguaggio Prolog ed è inoltre focalizzato esclusivamente sulla descrizione delle caratteristiche object-oriented di Logtalk.
+
+# Sintassi
+
+Logtalk utilizza la sintassi standard del linguaggio Prolog con l'aggiunta di un paio di operatori e di alcune direttive per una curva di apprendimento morbida e per assicurare ampia portabilità. Una conseguenza importante è che il codice Prolog può essere facilmente incapsulato in oggetti con poche o nessuna modifica. Inoltre, Logtalk può interpretare come oggetti Logtalk, in modo trasparente, la maggior parte dei moduli Prolog già esistenti.
+
+I principali operatori sono:
+
+* `::/2` - per inviare un messaggio ad un oggetto
+* `::/1` - per inviare un messaggio a se stesso _self_ (cioè all'oggetto che riceverà il messaggio)
+* `^^/1` - _super_ per chiamare un predicato ereditato o importato
+
+Alcune delle più importanti entità e direttive saranno introdotte nelle sezioni successive.
+
+# Entità e Ruoli
+
+Logtalk tratta gli oggetti, i protocolli e le categorie come entità di prima classe. I rapporti tra le entità definiscono i _patterns of code reuse_ ossia i modelli di riutilizzo del codice e i  _roles_ ossia i ruoli svolti da tali entità. Ad esempio, quando un oggetto istanzia un altro oggetto, il primo oggetto assume il ruolo di istanza e il secondo oggetto assume il ruolo di classe. Una relazione di tipo _extends_ tra due oggetti implica che entrambi gli oggetti svolgano il ruolo di prototipi, in cui uno di loro estende l'altro, che diventa quindi suo prototipo padre.
+
+# Definizione di un oggetto
+
+Un oggetto incapsula le dichiarazioni e le definizioni dei predicati. Gli oggetti possono essere creati in modo dinamico, ma di solito sono dichiarati come statici e definiti nel codice sorgente. Un singolo file sorgente può contenere un qualsiasi numero di definizioni di entità. Ecco un semplice oggetto `list` che definisce un membro pubblico `member/2`:
+
+```logtalk
+:- object(list).
+
+	:- public(member/2).
+	member(Head, [Head| _]).
+	member(Head, [_| Tail]) :-
+		member(Head, Tail).
+
+:- end_object.
+```
+
+# Compilazione dei file sorgenti
+
+Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file` list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):
+
+```logtalk
+?- {list}.
+yes
+```
+
+# Inviare un messaggio ad un oggetto
+
+L'operatore infisso `::/2` è usato per inviare messaggi ad un oggetto. Analogamente al Prolog, è possibile fare backtracking per le soluzioni alternative:
+
+```logtalk
+?- list::member(X, [1,2,3]).
+X = 1 ;
+X = 2 ;
+X = 3
+yes
+```
+
+Analogamente alla programmazione object-oriented, logtalk consente anche l'Incapsulamento. 
+Un predicato può essere dichiarata pubblico, protetto o privato. Può anche essere _local_ quando non esiste una direttiva specifica per esso all'interno dello scope. Per esempio:
+
+```logtalk
+:- object(scopes).
+
+	:- private(bar/0).
+	bar.
+
+	local.
+
+:- end_object.
+```
+
+Assumendo che l'oggetto è salvato nel file `scopes.lgt`:
+
+```logtalk
+?- {scopes}.
+yes
+
+?- catch(scopes::bar, Error, true).
+Error = error(
+	permission_error(access, private_predicate, bar/0),
+	logtalk(scopes::bar, user)
+)
+yes
+
+?- catch(scopes::local, Error, true).
+Error = error(
+	existence_error(predicate_declaration, local/0),
+	logtalk(scopes::local, user)
+)
+yes
+```
+
+Quando il predicato in un messaggio non è noto per l'oggetto (il ruolo dell'oggetto determina le procedure di ricerca), si ha un errore.
+Per esempio:
+
+```logtalk
+?- catch(scopes::unknown, Error, true).
+Error = error(
+	existence_error(predicate_declaration, unknown/0),
+	logtalk(scopes::unknown, user)
+)
+yes
+```
+
+Un punto fondamentale da capire è che le direttive che specificano il predicato nello scope specificano la semantica di chiamata (_calling_) del predicato, e non la semantica di definizione (_definition_). Ad esempio, se un oggetto ha il ruolo di una classe e dichiara un predicato privato, tale predicato può essere definito nelle sue sottoclassi e nelle istanze * ma * può essere chiamato solo nelle sue istanza (_from_) dalla classe.
+
+# Definizione e implementazione di un protocollo
+
+Un Protocollo contiene le dichiarazioni dei predicati che possono essere implementati da un qualsivoglia numero di oggetti e categorie:
+
+```logtalk
+:- protocol(listp).
+
+	:- public(member/2).
+
+:- end_protocol.
+
+:- object(list,
+	implements(listp)).
+
+	member(Head, [Head| _]).
+	member(Head, [_| Tail]) :-
+		member(Head, Tail).
+
+:- end_object.
+```
+
+Lo scope dei predicati di un protocollo può essere ristretto usando implementazioni protected e private. Ad esempio:
+
+```logtalk
+:- object(stack,
+	implements(private::listp)).
+
+:- end_object.
+```
+
+Difatti, tutte le relazioni tra entità (nella direttiva di apertura di un entità) possono essere definite come public (default), protected, o private.
+
+# Prototipi
+
+Un oggetto senza una istanza o senza una relazione di specializzazione con un altro oggetto interpreta il ruolo di prototipo. Un prototipo può estendere un altro oggetto, il suo prototipo genitore.
+
+```logtalk
+% clyde, our prototypical elephant
+:- object(clyde).
+
+	:- public(color/1).
+	color(grey).
+
+	:- public(number_of_legs/1).
+	number_of_legs(4).
+
+:- end_object.
+
+% fred, another elephant, is like clyde, except that he's white
+:- object(fred,
+	extends(clyde)).
+
+	color(white).
+
+:- end_object.
+```
+
+Per rispondere ad un messaggio inviato ad un oggetto che ha il ruolo di prototipo, si cerca prima una risposta nel prototipo stesso e se il prototipo non sa rispondere si passa all'eventuale prototipo genitore (se esiste):
+
+```logtalk
+?- fred::number_of_legs(N).
+N = 4
+yes
+
+?- fred::color(C).
+C = white
+yes
+```
+
+Un messaggio è valido se il relativo predicato è dichiarato in un oggetto (e se il mittente è nel campo di applicazione), ma fallirà, piuttosto che lanciare un errore, se il predicato non è definito. Questa è chiamata la _closed-world assumption_. Ad esempio, si consideri il seguente oggetto, salvato in un file `foo.lgt`:
+
+```logtalk
+:- object(foo).
+
+	:- public(bar/0).
+
+:- end_object.
+```
+
+Caricando il file e cercando di chiamare il predicato `bar/0` questo fallisce come previsto. Si noti che ciò è diverso dal chiamare un predicato sconosciuto _unknown_, che invece genera un errore:
+
+```logtalk
+?- {foo}.
+yes
+
+?- foo::bar.
+no
+
+?- catch(foo::baz, Error, true).
+Error = error(
+	existence_error(predicate_declaration, baz/0),
+	logtalk(foo::baz, user)
+)
+yes
+```
+
+# Classi e istanze
+
+Per definire gli oggetti nei ruoli di classi e/o istanze, un oggetto deve avere almeno un istanziazione o una relazione di specializzazione con un altro oggetto. Gli oggetti che hanno il ruolo di meta-classi possono essere utilizzati quando abbiamo bisogno di usare una classe come se fosse un'istanza. Il seguente esempio mostra come creare dinamicamente nuovi oggetti in fase di esecuzione:
+
+```logtalk
+% a simple, generic, metaclass defining a new/2 predicate for its instances
+:- object(metaclass,
+	instantiates(metaclass)).
+
+	:- public(new/2).
+	new(Instance, Clauses) :-
+		self(Class),
+		create_object(Instance, [instantiates(Class)], [], Clauses).
+
+:- end_object.
+
+% a simple class defining age/1 and name/1 predicate for its instances
+:- object(person,
+	instantiates(metaclass)).
+
+	:- public([
+		age/1, name/1
+	]).
+
+	% a default value for age/1
+	age(42).
+
+:- end_object.
+
+% a static instance of the class person
+:- object(john,
+	instantiates(person)).
+
+	name(john).
+	age(12).
+
+:- end_object.
+```
+
+Nel rispondere ad un messaggio inviato ad un oggetto ha assunto il ruolo di istanza, tal messaggio viene convalidato partendo dalla sua classe e andando a ritroso nella gerarchia, se necessario, fino alle sue superclassi. Supponendo che il messaggio sia valido, allora si cerca una risposta a partire dall'istanza stessa:
+
+```logtalk
+?- person::new(Instance, [name(paulo)]).
+Instance = o1
+yes
+
+?- o1::name(Name).
+Name = paulo
+yes
+
+?- o1::age(Age).
+Age = 42
+yes
+
+?- john::age(Age).
+Age = 12
+yes
+```
+
+# Categorie
+
+Una categoria è un'unità atomica di codice riutilizzabile. Una categoria è usata per incapsulare una insieme coesivo (_cohesive_) di dichiarazioni e di definizioni di predicato ed è atta ad implementare una singola (_single_) funzionalità che può essere importata in qualsiasi oggetto. Una categoria può quindi essere concepita come il concetto duale di protocollo. Nel seguente esempio, si definiscono prima le categorie che rappresentano i motori di auto e poi si importano tali categorie negli oggetti auto:
+
+```logtalk
+% a protocol describing engine characteristics
+:- protocol(carenginep).
+
+	:- public([
+		reference/1,
+		capacity/1,
+		cylinders/1,
+		horsepower_rpm/2,
+		bore_stroke/2,
+		fuel/1
+	]).
+
+:- end_protocol.
+
+% a typical engine defined as a category
+:- category(classic,
+	implements(carenginep)).
+
+	reference('M180.940').
+	capacity(2195).
+	cylinders(6).
+	horsepower_rpm(94, 4800).
+	bore_stroke(80, 72.8).
+	fuel(gasoline).
+
+:- end_category.
+
+% a souped up version of the previous engine
+:- category(sport,
+	extends(classic)).
+
+	reference('M180.941').
+	horsepower_rpm(HP, RPM) :-
+		^^horsepower_rpm(ClassicHP, ClassicRPM),	% "super" call
+		HP is truncate(ClassicHP*1.23),
+		RPM is truncate(ClassicRPM*0.762).
+
+:- end_category.
+
+% with engines (and other components), we may start "assembling" some cars
+:- object(sedan,
+	imports(classic)).
+
+:- end_object.
+
+:- object(coupe,
+	imports(sport)).
+
+:- end_object.
+```
+
+Le Categorie sono compilate in modo indipendente e, quindi, consentono l'importazione di oggetti da aggiornare mediante il semplice aggiornamento delle categorie importate, senza richiedere pertanto la ricompilazione dell'oggetto. Le Categorie forniscono anche la _runtime transparency_,  cioè il protocollo della categoria si aggiunge al protocollo degli oggetti che importano tale categoria:
+
+```logtalk
+?- sedan::current_predicate(Predicate).
+Predicate = reference/1 ;
+Predicate = capacity/1 ;
+Predicate = cylinders/1 ;
+Predicate = horsepower_rpm/2 ;
+Predicate = bore_stroke/2 ;
+Predicate = fuel/1
+yes
+```
+
+# Hot patching
+
+Le categorie possono essere anche usate per modificare gli oggetti al volo (_hot-patch_). Una categoria può aggiungere nuovi predicati ad un oggetto e/o sostituire le definizioni dei predicati dell'oggetto. Ad esempio, si consideri il seguente oggetto:
+
+```logtalk
+:- object(buggy).
+
+	:- public(p/0).
+	p :- write(foo).
+
+:- end_object.
+```
+
+Si supponga che l'oggetto stampi la stringa sbagliata quando riceve il messaggio `p/0`:
+
+```logtalk
+?- {buggy}.
+yes
+
+?- buggy::p.
+foo
+yes
+```
+
+Se il codice sorgente dell'oggetto non è disponibile e bisogna correggere l'applicazione che sta eseguendo il codice dell'oggetto, si può semplicemente definire una categoria che corregge il predicato non corretto:
+
+```logtalk
+:- category(patch,
+	complements(buggy)).
+
+	% fixed p/0 def
+	p :- write(bar).
+
+:- end_category.
+```
+
+Dopo la compilazione e il caricamento della categoria nell'applicazione in esecuzione si ottiene:
+
+```logtalk
+?- {patch}.
+yes
+
+?- buggy::p.
+bar
+yes
+```
+
+Poiché l'hot-patching pregiudica forzatamente l'incapsulamento, un apposito flag di compilazione `complementary` può essere impostato (a livello globale o per un singolo oggetto) per consentire, limitare o prevenire l'hot-patching.
+
+# Oggetti Parametrici e Categorie
+
+Gli oggetti e le categorie possono essere parametrizzati utilizzando come identificativo un compound-term al posto di un atomo. Oggetti e parametri di una categoria sono variabili logiche _logical variables_ condivise con tutti i predicati incapsulati. Ecco un esempio con cerchi geometrici:
+
+```logtalk
+:- object(circle(_Radius, _Color)).
+
+	:- public([
+		area/1, perimeter/1
+	]).
+
+	area(Area) :-
+		parameter(1, Radius),
+		Area is pi*Radius*Radius.
+
+	perimeter(Perimeter) :-
+		parameter(1, Radius),
+		Perimeter is 2*pi*Radius.
+
+:- end_object.
+```
+
+Oggetti parametrici possono essere utilizzati come qualsiasi altro oggetto e di solito forniscono i valori da assegnare ai parametri quando si invia un messaggio:
+
+```logtalk
+?- circle(1.23, blue)::area(Area).
+Area = 4.75291
+yes
+```
+
+Gli oggetti parametrici forniscono anche un modo semplice per associare un insieme di predicati con un semplice predicato Prolog. Fatti Prolog possono essere interpretati come oggetti proxy parametrici ( _parametric object proxies_) quando hanno lo stesso funtore e arietà degli identificatori di oggetti parametrici. Per lavorare con i proxy viene fornita una sintassi maneggevole. Per esempio, si prendano le seguenti clausole per il predicato `circle/2`:
+
+```logtalk
+circle(1.23, blue).
+circle(3.71, yellow).
+circle(0.39, green).
+circle(5.74, black).
+circle(8.32, cyan).
+```
+
+Con queste clausole, si può facilmente calcolare, ad esempio, un elenco con le aree di tutti i cerchi:
+
+```logtalk
+?- findall(Area, {circle(_, _)}::area(Area), Areas).
+Areas = [4.75291, 43.2412, 0.477836, 103.508, 217.468]
+yes
+```
+
+In pratica, il costrutto `{Goal}::Message` prova il goal `Goal`, instanziando le variabili interne e inviando un messaggio `Message` al termine risultante.
+
+# Eventi and monitor
+
+Logtalk supporta l'_event-driven programming_ mediante la definizione di eventi e di monitor. Un evento è semplicemente l'invio di un messaggio ad un oggetto. Un monitor è un gestore di un evento. L'evento (con l'invio di un messaggio) è un'attività atomica, ed è preceduta da un evento _before_ e da un evento _after_. Il monitor gestisce tali eventi mediante i predicati, `before/3` e `after/3`, che sono chiamati rispettivamente prima e dopo il verificarsi dell'evento. Un monitor può inoltre interrogare, registrare e cancellare un evento nel registro eventi a livello di sistema il quale che associa gli eventi con i monitor. Ad esempio, un semplice tracer per ogni messaggio inviato utilizzando il costrutto `::/2` può essere definito come:
+
+```logtalk
+:- object(tracer,
+	implements(monitoring)).    % built-in protocol for event handlers
+
+	:- initialization(define_events(_, _, _, _, tracer)).
+
+	before(Object, Message, Sender) :-
+		write('call: '), writeq(Object), write(' <-- '), writeq(Message),
+		write(' from '), writeq(Sender), nl.
+
+	after(Object, Message, Sender) :-
+		write('exit: '), writeq(Object), write(' <-- '), writeq(Message),
+		write(' from '), writeq(Sender), nl.
+
+:- end_object.
+```
+
+Supponendo che l'oggetto `tracer` e l'oggetto `list` definito in precedenza siano stati già compilati e caricati, si possono osservare i gestori di eventi in azione durante l'invio di un messaggio:
+
+```logtalk
+?- list::member(X, [1,2,3]).
+
+call: list <-- member(X, [1,2,3]) from user
+exit: list <-- member(1, [1,2,3]) from user
+X = 1 ;
+exit: list <-- member(2, [1,2,3]) from user
+X = 2 ;
+exit: list <-- member(3, [1,2,3]) from user
+X = 3
+yes
+```
+
+Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e` abolish_events/5` .
+
+La programmazione event-driven può essere vista come una forma di _computational reflection_. Si noti però che gli eventi sono generati solo quando si utilizza il costrutto di controllo per l'invio di messaggi `::/2`.
+
+# Espressioni lambda
+
+Logtalk supporta anche le espressioni lambda. I parametri della espressioni lambda sono rappresentati mediante una lista con l'operatore infisso `(>>)/2` che collega i parametri alla relativa lambda espressione. Ecco alcuni semplici esempi di che usano i meta-predicati.
+
+
+```logtalk
+?- {library(metapredicates_loader)}.
+yes
+
+?- meta::map([X,Y]>>(Y is 2*X), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Logtalk supporta anche il _currying_:
+
+```logtalk
+?- meta::map([X]>>([Y]>>(Y is 2*X)), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Infine, le variabili libere Lambda possono essere espresso usando la sintassi estesa `{Free1, ...}/[Parameter1, ...]>>Lambda`.
+
+# Macro
+
+I Termini e goal nel file sorgente possono essere _estesi_ al momento della compilazione specificando una hook ad un oggetto (_hook object_) che definisce le regole di riscrittura dei termini e riscrittura dei quesiti. Ad esempio, si consideri il seguente oggetto semplice, salvato nel file `source.lgt`:
+
+```logtalk
+:- object(source).
+
+	:- public(bar/1).
+	bar(X) :- foo(X).
+
+	foo(a). foo(b). foo(c).
+
+:- end_object.
+```
+
+Si supponga il seguente hook all'oggetto, salvato nel file `my_macros.lgt`, che estende le clausole e chiama il predicato locale  `foo/1`:
+
+```logtalk
+:- object(my_macros,
+	implements(expanding)).    % built-in protocol for expanding predicates
+
+	term_expansion(foo(Char), baz(Code)) :-
+		char_code(Char, Code). % standard built-in predicate
+
+	goal_expansion(foo(X), baz(X)).
+
+:- end_object.
+```
+
+Dopo aver caricato il file contenente la macro, si può espandere il nostro file sorgente usando il flag del compilatore `hook`:
+
+```logtalk
+?- logtalk_load(my_macros), logtalk_load(source, [hook(my_macros)]).
+yes
+
+?- source::bar(X).
+X = 97 ;
+X = 98 ;
+X = 99
+true
+```
+
+La libreria Logtalk fornisce infine il supporto per combinare hook agli oggetti utilizzando diversi modi (ad esempio, definendo una pipeline di espansioni).
+
+
+# Maggiori informazioni
+
+Visita il [Sito web di Logtalk (en)](http://logtalk.org) per maggiori informazioni.
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
new file mode 100644
index 00000000..b006dbb4
--- /dev/null
+++ b/it-it/markdown.html.markdown
@@ -0,0 +1,244 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Jacopo Andrea Giola", "http://geekpanda.net"]
+filename: markdown-it.md
+lang: it-it
+---
+
+Markdown è stato creato da John Gruber nel 2004. Il suo scopo è quello di essere una sintassi facile da leggere e scrivere, e che può essere convertita in HTML (ad oggi anche in molti altri formati).
+
+Mandate tutto il feedback che volete! / Sentitevi liberi di forkare o di mandare pull request!
+
+
+```markdown
+<!-- Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido. Questo significa che possiamo usare elementi di HTML in Markdown, come per esempio i commenti, e questi non saranno modificati dal parser di Markdown. State attenti però, se inserite un elemento HTML nel vostro file Markdown, non potrete usare la sua sintassi all'interno del contenuto dell'elemento. -->
+
+<!-- L'implementazione di Markdown inoltre cambia da parser a parser. In questa guida cercheremo di indicare quando una feature è universale e quando sono specifiche ad un certo parser. -->
+
+<!-- Titoli -->
+<!-- Potete creare gli elementi HTML da <h1> ad <h6> facilmente, basta che inseriate un egual numero di caratteri cancelletto (#) prima del testo che volete all'interno dell'elemento -->
+# Questo è un <h1>
+## Questo è un <h2>
+### Questo è un <h3>
+#### Questo è un <h4>
+##### Questo è un <h5>
+###### Questo è un <h6>
+
+<!-- Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2 -->
+Questo è un h1
+==============
+
+Questo è un h2
+--------------
+
+<!-- Stili di testo semplici -->
+<!-- Il testo può essere stilizzato in corsivo o grassetto usando markdown -->
+
+*Questo testo è in corsivo.*
+_Come pure questo._
+
+**Questo testo è in grassetto.**
+__Come pure questo.__
+
+***Questo testo è stilizzato in entrabmi i modi.***
+**_Come questo!_**
+*__E questo!__*
+
+<!-- In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su
+Github, è presente anche lo stile barrato -->
+
+~~Questo testo è barrato.~~
+
+<!-- I paragrafi sono uno o più linee di testo addiacenti separate da una o più righe vuote. -->
+
+Qeusto è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
+
+Ora sono nel paragrafo 2.
+Anche questa linea è nel paragrafo 2!
+
+
+Qui siamo nel paragrafo 3!
+
+<!-- Se volete inserire l'elemento HTML <br />, potete terminare la linea con due o più spazi e poi iniziare un nuovo paragrafo. -->
+
+Questa frase finisce con due spazi (evidenziatemi per vederli).  
+
+C'è un <br /> sopra di me!
+
+<!-- Le citazioni sono semplici da inserire, basta usare il carattere >. -->
+
+> Questa è una citazione. Potete
+> mandare a capo manualmente le linee e inserire un `>` prima di ognuna, oppure potete usare una sola linea e lasciare che vada a capo automaticamente.
+> Non c'è alcuna differenza, basta che iniziate ogni riga con `>`.
+
+> Potete utilizzare anche più di un livello
+>>  di indentazione!
+> Quanto è comodo?
+
+<!-- Liste -->
+<!-- Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini -->
+
+* Oggetto
+* Oggetto
+* Altro oggetto
+
+oppure
+
++ Oggetto
++ Oggetto
++ Un altro oggetto
+
+oppure
+
+- Oggetto
+- Oggetto
+- Un ultimo oggetto
+
+<!-- Le liste ordinate invece, sono inserite con un numero seguito da un punto. -->
+
+1. Primo oggetto
+2. Secondo oggetto
+3. Terzo oggetto
+
+<!-- Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea. -->
+
+1. Primo oggetto
+1. Secondo oggetto
+1. Terzo oggetto
+<!-- (Questa lista verrà visualizzata esattamente come quella dell'esempio prima) -->
+
+<!-- Potete inserire anche sotto liste -->
+
+1. Primo oggetto
+2. Secondo oggetto
+3. Terzo oggetto
+    * Sotto-oggetto
+    * Sotto-oggetto
+4. Quarto oggetto
+
+<!-- Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML. -->
+
+I box senza la 'x' sono checkbox HTML ancora da completare.
+- [ ] Primo task da completare.
+- [ ] Secondo task che deve essere completato.
+Il box subito sotto è una checkbox HTML spuntata.
+- [x] Questo task è stato completato.
+
+<!-- Estratti di codice -->
+<!-- Potete inserire un estratto di codice (che utilizza l'elemento <code>) indentando una linea con quattro spazi oppure con un carattere tab -->
+
+    Questa è una linea di codice
+    Come questa
+
+<!-- Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- Codice inline può essere inserito usando il carattere backtick ` -->
+
+Giovanni non sapeva neppure a cosa servisse la funzione `go_to()`!
+
+<!-- In Github Flavored Markdown, potete inoltre usare una sintassi speciale per il codice -->
+
+\`\`\`ruby <!-- In realtà dovete rimuovere i backslash, usate solo ```ruby ! -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- Anche qui, niente backslash, solamente ``` -->
+
+<!-- Se usate questa sintassi, il testo non richiederà di essere indentanto, inoltre Github userà la  syntax highlighting del linguaggio specificato dopo i ``` iniziali -->
+
+<!-- Linea orizzontale (<hr />) -->
+<!-- Le linee orizzontali sono inserite facilemtne usanto tre o più asterischi o trattini senza spazi consecutivi e senza spazi. -->
+
+***
+---
+- - -
+****************
+
+<!-- Link -->
+<!-- Una delle funzionalità migliori di markdown è la facilità con cui si possono inserire i link. Mettete il testo da visualizzare fra parentesi quadre [] seguite dall'url messo fra parentesi tonde () -->
+
+[Cliccami!](http://test.com/)
+
+<!-- Potete inoltre aggiungere al link un titolo mettendolo fra doppie apici dopo il link -->
+
+[Cliccami!](http://test.com/ "Link a Test.com")
+
+<!-- La sintassi funziona anche i path relativi. -->
+
+[Vai a musica](/music/).
+
+<!-- Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo -->
+
+[Apri questo link][link1] per più informazioni!
+[Guarda anche questo link][foobar] se ti va.
+
+[link1]: http://test.com/ "Bello!"
+[foobar]: http://foobar.biz/ "Va bene!"
+
+<!-- Il titolo può anche essere inserito in apici singoli o in parentesi, oppure omesso interamente. Il riferimento può essere inserito in un punto qualsiasi del vostro documento e l'identificativo del riferimento può essere lungo a piacere a patto che sia univoco. -->
+
+<!-- Esiste anche un "identificativo implicito" che vi permette di usare il testo del link come id -->
+
+[Questo][] è un link.
+
+[Questo]: http://thisisalink.com/
+
+<!-- Ma non è comunemente usato. -->
+
+<!-- Immagini -->
+<!-- Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre! -->
+
+![Qeusto è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
+
+<!-- E la modalità a riferimento funziona esattamente come ci si aspetta -->
+
+![Questo è il testo alternativo.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "Se vi serve un titolo, lo mettete qui"
+
+<!-- Miscellanea -->
+<!-- Auto link -->
+
+<http://testwebsite.com/> è equivalente ad
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Auto link per le email -->
+
+<foo@bar.com>
+
+<!-- Caratteri di escaping -->
+
+Voglio inserire *questo testo circondato da asterischi* ma non voglio che venga renderizzato in corsivo, quindi lo inserirò così: \*questo testo è circondato da asterischi\*.
+
+<!-- Combinazioni di tasti -->
+<!-- In Github Flavored Markdown, potete utilizzare il tag <kbd> per raffigurare i tasti della tastiera -->
+
+Il tuo computer è crashato? Prova a premere
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Canc</kbd>
+
+<!-- Tabelle -->
+<!-- Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue: -->
+
+| Col1                 | Col2     | Col3               |
+| :------------------- | :------: | -----------------: |
+| Allineato a sinistra | Centrato | Allineato a destra |
+| blah                 | blah     | blah               |
+
+<!-- oppure, per lo stesso risultato -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+È una cosa orrenda | fatela | finire in fretta
+
+<!-- Finito! -->
+
+```
+
+Per altre informazioni, leggete il post ufficiale di John Gruber sulla sintassi [qui](http://daringfireball.net/projects/markdown/syntax) e il magnifico cheatsheet di Adam Pritchard [qui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown
new file mode 100644
index 00000000..aeb42658
--- /dev/null
+++ b/it-it/matlab-it.html.markdown
@@ -0,0 +1,526 @@
+---
+language: Matlab
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+translators:
+    - ["Samuele Gallerani", "http://github.com/fontealpina"]
+lang: it-it
+filename: matlab-it.md
+---
+
+MATLAB sta per MATrix LABoratory ed è un potente linguaggio per il calcolo numerico comunemente usato in ingegneria e matematica.
+
+```matlab
+% I commenti iniziano con il segno percentuale.
+
+%{
+I commenti multilinea
+assomigliano a
+qualcosa
+del genere
+%}
+
+% i comandi possono essere spezzati su più linee, usando '...':
+ a = 1 + 2 + ...
+ + 4
+
+% i comandi possono essere passati al sistema operativo
+!ping google.com
+
+who % Mostra tutte le variabili in memoria
+whos % Mostra tutte le variabili in memoria, con i loro tipi
+clear % Cancella tutte le tue variabili dalla memoria
+clear('A') % Cancella una particolare variabile
+openvar('A') % Apre la variabile in un editor di variabile
+
+clc % Cancella il contenuto della Command Window
+diary % Attiva il log della Command Window su file
+ctrl-c % Interrompe il calcolo corrente
+
+edit('myfunction.m') % Apre la funzione/script nell'editor
+type('myfunction.m') % Stampa il codice della funzione/script sulla Command Window
+
+profile on 	% Attiva la profilazione del codice
+profile off 	% Disattiva la profilazione del codice
+profile viewer 	% Apre il profilatore
+
+help comando 	% Mostra la documentazione di comando sulla Command Window
+doc comando 	% Mostra la documentazione di comando sulla Help Window
+lookfor comando % Cerca comando nella prima linea di commento di tutte le funzioni
+lookfor comando -all % Cerca comando in tutte le funzioni
+
+
+% Formattazione dell'output
+format short 	% 4 decimali in un numero float
+format long 	% 15 decimali
+format bank 	% Solo due cifre decimali - per calcoli finaziari
+fprintf('text') % Stampa "text" a terminale
+disp('text') 	% Stampa "text" a terminale
+
+% Variabili ed espressioni
+miaVariabile = 4 % Il pannello Workspace mostra la nuova variabile creata
+miaVariabile = 4; % Il punto e virgola evita che l'output venga stampato sulla Command Window
+4 + 6  		% ans = 10
+8 * myVariable 	% ans = 32
+2 ^ 3 		% ans = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+% La chiamata di funzioni può essere fatta in due modi differenti:
+% Sintassi standard di una funzione:
+load('myFile.mat', 'y') % argomenti tra parentesi, separati da virgole
+% Sintassi di tipo comando:
+load myFile.mat y 	% Non ci sono parentesi e gli argometi sono separati da spazi
+% Notare la mancanza di apici nella sintassi di tipo comando: gli input sono sempre passati come
+% testo letterale - non è possibile passare valori di variabili. Inoltre non può ricevere output:
+[V,D] = eig(A);  % Questa non ha una forma equivalente con una sintassi di tipo comando
+[~,D] = eig(A);  % Se si vuole solo D e non V
+
+
+
+% Operatori logici
+1 > 5 % ans = 0
+10 >= 10 % ans = 1
+3 ~= 4 % Not equal to -> ans = 1
+3 == 3 % equal to -> ans = 1
+3 > 1 && 4 > 1 % AND -> ans = 1
+3 > 1 || 4 > 1 % OR -> ans = 1
+~1 % NOT -> ans = 0
+
+% Gli operatori logici possono essere applicati alle matrici:
+A > 5
+% Per ogni elemento, se la condizione è vera, quell'elemento vale 1 nella matrice risultante
+A( A > 5 )
+% Restituisce un vettore contenente gli elementi in A per cui la condizione è vera
+
+% Stringhe
+a = 'MyString'
+length(a) % ans = 8
+a(2) % ans = y
+[a,a] % ans = MyStringMyString
+
+
+% Celle
+a = {'one', 'two', 'three'}
+a(1) % ans = 'one' - ritorna una cella
+char(a(1)) % ans = one - ritorna una stringa
+
+% Strutture
+A.b = {'one','two'};
+A.c = [1 2];
+A.d.e = false;
+
+% Vettori
+x = [4 32 53 7 1]
+x(2) % ans = 32, gli indici in Matlab iniziano da 1, non da 0
+x(2:3) % ans = 32 53
+x(2:end) % ans = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % Vettore colonna
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+
+% Matrici
+A = [1 2 3; 4 5 6; 7 8 9]
+% Le righe sono separate da punto e virgola, mentre gli elementi sono separati da spazi
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % ans = 6, A(row, column)
+A(6) % ans = 8
+% (implicitamente concatena le colonne in un vettore, e quindi gli indici sono riferiti al vettore)
+
+
+A(2,3) = 42 % Aggiorna riga 2 colonna 3 con 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3) % Crea una nuova matrice a partire da quella precedente
+%ans =
+
+%     5     42
+%     8     9
+
+A(:,1) % Tutte le righe nella colonna 1
+%ans =
+
+%     1
+%     4
+%     7
+
+A(1,:) % Tutte le colonne in riga 1
+%ans =
+
+%     1     2     3
+
+[A ; A] % Concatenazione di matrici (verticalmente)
+%ans =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% è equivalente a
+vertcat(A,A);
+
+
+[A , A] % Concatenazione di matrici (orrizontalmente)
+
+%ans =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% è equivalente a
+horzcat(A,A);
+
+
+A(:, [3 1 2]) % Ripristina le colonne della matrice originale
+%ans =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A) % ans = 3 3
+
+A(1, :) =[] % Rimuove la prima riga della matrice
+A(:, 1) =[] % Rimuove la prima colonna della matrice
+
+transpose(A) % Traspone la matrice, equivale a:
+A one
+ctranspose(A) % Trasposizione hermitiana della matrice
+% (ovvero il complesso coniugato di ogni elemento della matrice trasposta)
+
+
+
+
+% Aritmetica Elemento per Elemento vs. Artimetica Matriciale
+% Gli operatori aritmetici da soli agliscono sull'intera matrice. Quando sono preceduti
+% da un punto, allora agiscono su ogni elemento. Per esempio:
+A * B % Moltiplicazione matriciale
+A .* B % Moltiplica ogni elemento di A per il corrispondente elemento di B
+
+% Ci sono diverse coppie di funzioni, in cui una agisce su ogni elemento, e
+% l'altra (il cui nome termina con m) agisce sull'intera matrice.
+exp(A) % Calcola l'esponenziale di ogni elemento
+expm(A) % Calcola la matrice esponenziale
+sqrt(A) % Calcola la radice quadrata di ogni elementotake the square root of each element
+sqrtm(A) % Trova la matrice di cui A nè è la matrice quadrata
+
+
+% Plot di grafici
+x = 0:.10:2*pi; % Crea un vettore che inizia a 0 e termina 2*pi con incrementi di .1
+y = sin(x);
+plot(x,y)
+xlabel('x axis')
+ylabel('y axis')
+title('Plot of y = sin(x)')
+axis([0 2*pi -1 1]) % x range da 0 a 2*pi, y range da -1 a 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % Per stampare più funzioni in unico plot
+legend('Line 1 label', 'Line 2 label') % Aggiunge un etichetta con il nome delle curve
+
+% Metodo alternativo per stampare funzioni multiple in un unico plot.
+% mentre 'hold' è on, i comandi sono aggiunti al grafico esistene invece di sostituirlo
+plot(x, y)
+hold on
+plot(x, z)
+hold off
+
+loglog(x, y) % Un plot di tipo log-log
+semilogx(x, y) % Un plot con asse x logaritmico
+semilogy(x, y) % Un plot con asse y logaritmico
+
+fplot (@(x) x^2, [2,5]) % Stampa la funzione x^2 da x=2 a x=5
+
+grid on % Mostra la griglia, disattivare con 'grid off'
+axis square % Rende quadrata la regione individuata dagli assi
+axis equal % Iposta l'aspetto del grafico in modo che le unità degli assi siano le stesse
+
+scatter(x, y); % Scatter-plot
+hist(x); % Istogramma
+
+z = sin(x);
+plot3(x,y,z); % Stampa una linea 3D
+
+pcolor(A) % Heat-map di una matrice: stampa una griglia di rettangoli, colorati in base al valore
+contour(A) % Contour plot di una matrice
+mesh(A) % Stampa come una superfice di mesh
+
+h = figure	% Crea un nuovo oggetto figura, con handle f
+figure(h) % Rende la figura corrispondente al handle h la figura corrente
+close(h) % Chiude la figura con handle h
+close all % Chiude tutte le figure
+close % Chiude la figura corrente
+
+shg % Riutilizza una finestra grafica già esistente, o se necessario ne crea una nuova
+clf clear % Pulisce la figura corrente, e resetta le proprietà della figura
+
+% Le proprietà possono essere impostate e modificate attraverso l'handle della figura.
+% Si può salvare l'handle della figura quando viene creata.
+% La funzione gcf restituisce un handle alla figura attuale.
+h = plot(x, y); % Si può salvare un handle della figura quando viene creata
+set(h, 'Color', 'r')
+% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
+set(h, 'LineStyle', '--')
+ % '--' linea continua, '---' tratteggiata, ':' puntini, '-.' trattino-punto, 'none' nessuna linea
+get(h, 'LineStyle')
+
+
+% La funzione gca restituisce un handle degli assi della figura corrente
+set(gca, 'XDir', 'reverse'); % Inverte la direzione dell'asse x
+
+% Per creare una figura che contiene diverse sottofigure, usare subplot
+subplot(2,3,1); % Seleziona la prima posizione in una griglia 2 per 3 di sottofigure
+plot(x1); title('First Plot') % Stampa qualcosa in questa posizione
+subplot(2,3,2); % Seleziona la seconda posizione nella griglia
+plot(x2); title('Second Plot') % Stampa qualcosa in questa posizione
+
+
+% Per usare funzioni o script, devono essere nel tuo path o nella directory corrente
+path % Mostra il path corrente
+addpath /path/to/dir % Aggiunge al path
+rmpath /path/to/dir % Rimuove dal path
+cd /path/to/move/into % Cambia directory
+
+
+% Le variabili possono essere salvate in file .mat
+save('myFileName.mat') % Salva le variabili nel tuo Workspace
+load('myFileName.mat') % Carica variabili salvate nel tuo Workspace
+
+% M-file Scripts
+% I file di script sono file esterni che contengono una sequenza di istruzioni.
+% Permettono di evitare di scrivere ripetutamente lo stesso codice nella Command Window
+% Hanno estensione .m
+
+% M-file Functions
+% Come gli script, hanno la stessa estensione .m
+% Ma possono accettare argomenti di input e restituire un output.
+% Inoltre, hanno un proprio workspace (differente scope delle variabili).
+% Il nome della funzione dovrebbe coincidere con il nome del file (quindi salva questo esempio come double_input.m).
+% 'help double_input.m' restituisce i commenti sotto alla linea iniziale della funzione
+function output = double_input(x)
+	%double_input(x) restituisce il doppio del valore di x
+	output = 2*x;
+end
+double_input(6) % ans = 12
+
+
+% Si possono anche avere sottofunzioni e funzioni annidate.
+% Le sottofunzioni sono nello stesso file della funzione primaria, e possono solo essere
+% chiamate da funzioni nello stesso file. Le funzioni annidate sono definite dentro ad altre
+% funzioni, e hanno accesso ad entrambi i workspace.
+
+% Se si vuole creare una funzione senza creare un nuovo file si può usare una
+% funzione anonima. Utile quando si vuole definire rapidamente una funzione da passare ad
+% un'altra funzione (es. stampa con fplot, valutare un integrale indefinito
+% con quad, trovare le radici con fzenzro, o trovare il minimo con fminsearch).
+% Esempio che restituisce il quadrato del proprio input, assegnato all'handle sqr:
+sqr = @(x) x.^2;
+sqr(10) % ans = 100
+doc function_handle % scopri di più
+
+% Input dell'utente
+a = input('Enter the value: ')
+
+% Ferma l'esecuzione del file e cede il controllo alla tastiera: l'utente può esaminare
+% o cambiare variabili. Digita 'return' per continuare l'esecuzione, o 'dbquit' per uscire
+keyboard
+
+% Importarare dati (anche xlsread/importdata/imread per excel/CSV/image file)
+fopen(filename)
+
+% Output
+disp(a) % Stampa il valore della variabile a
+disp('Hello World') % Stampa una stringa
+fprintf % Stampa sulla Command Window con più controllo
+
+% Istruzioni condizionali (le parentesi sono opzionali, ma un buon stile)
+if (a > 15)
+	disp('Maggiore di 15')
+elseif (a == 23)
+	disp('a è 23')
+else
+	disp('nessuna condizione verificata')
+end
+
+% Cicli
+% NB. Ciclare su elementi di vettori/matrici è lento!
+% Dove possibile, usa funzioni che agiscono sull'intero vettore/matrice
+for k = 1:5
+	disp(k)
+end
+
+k = 0;
+while (k < 5)
+	k = k + 1;
+end
+
+% Misurare la durata dell'esecuzione del codice: 'toc' stampa il tempo trascorso da quando 'tic' è stato chiamato
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+% Connessione a un Database MySQL
+dbname = 'database_name';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar');
+% xx dipende dalla versione, download disponibile all'indirizzo http://dev.mysql.com/downloads/connector/j/
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * from table_name where id = 22'] % Esempio istruzione sql
+a = fetch(conn, sql) % conterra i tuoi dati
+
+
+% Funzioni matematiche comuni
+sin(x)
+cos(x)
+tan(x)
+asin(x)
+acos(x)
+atan(x)
+exp(x)
+sqrt(x)
+log(x)
+log10(x)
+abs(x)
+min(x)
+max(x)
+ceil(x)
+floor(x)
+round(x)
+rem(x)
+rand % Numeri pseudocasuali uniformemente distribuiti
+randi % Numeri interi pseudocasuali uniformemente distrubuiti
+randn % Numeri pseudocasuali distrbuiti normalmente
+
+% Costanti comuni
+pi
+NaN
+inf
+
+% Risolvere equazioni matriciali
+% Gli operatori \ e / sono equivalenti alle funzioni mldivide e mrdivide
+x=A\b % Risolve Ax=b. Più veloce e più accurato numericamente rispetto ad usare inv(A)*b.
+x=b/A % Risolve xA=b
+
+inv(A) % Calcola la matrice inversa
+pinv(A) % Calcola la matrice pseudo-inversa
+
+% Funzioni comuni su matrici
+zeros(m,n) % Matrice m x n di zeri
+ones(m,n) % Matrice m x n di uni
+diag(A) % Estrae gli elementi della diagonale della matrice A
+diag(x) % Costruisce una matrice con elementi diagonali uguali agli elementi di x, e zero negli altri elementi
+eye(m,n) % Matrice identità
+linspace(x1, x2, n) % Ritorna n punti equamente distanziati, con minimo x1 e massimo x2
+inv(A) % Matrice inversa di A
+det(A) % Determinante di A
+eig(A) % Autovalori e autovettori di A
+trace(A) % Traccia della matrice -  equivalente a sum(diag(A))
+isempty(A) % Verifica se l'array è vuoto
+all(A) % Verifica se tutti gli elementi sono nonzero o veri
+any(A) % Verifica se almento un elemento è nonzero o vero
+isequal(A, B) % Verifica l'uguaglianza di due array
+numel(A) % Numero di elementi nella matrice
+triu(x) % Ritorna la parte triangolare superiore di x
+tril(x) % Ritorna la parte triangolare inferiore di x
+cross(A,B) %  Ritorna il prodotto vettoriale dei vettori A e B
+dot(A,B) % Ritorna il prodotto scalare di due vettori (devono avere la stessa lunghezza)
+transpose(A) % Ritorna la trasposta di A
+fliplr(A) % Capovolge la matrice da sinistra a destra
+flipud(A) % Capovolge la matrice da sopra a sotto
+
+% Fattorizzazione delle matrici
+[L, U, P] = lu(A) % Decomposizione LU: PA = LU, L è il triangolo inferiore, U è il triangolo superiore, P è la matrice di permutazione
+[P, D] = eig(A) % Auto-decomposizione: AP = PD, le colonne di P sono autovettori e gli elementi sulle diagonali di D sono autovalori
+[U,S,V] = svd(X) % SVD: XV = US, U e V sono matrici unitarie, S ha gli elementi della diagonale non negativi in ordine decrescente
+
+% Funzioni comuni su vettori
+max     % elemento più grande
+min     % elemento più piccolo
+length  % lunghezza del vettore
+sort    % ordina in modo crescente
+sum     % somma degli elementi
+prod    % prodotto degli elementi
+mode	% valore moda
+median  % valore mediano
+mean    % valore medio
+std     % deviazione standard
+perms(x) % lista tutte le permutazioni di elementi di x
+
+
+% Classi
+% Matlab supporta la programmazione orientata agli oggetti.
+% La classe deve essere messa in un file con lo stesso nome della classe e estensione .m
+% Per iniziare, creiamo una semplice classe per memorizzare waypoint GPS
+% Inizio WaypointClass.m
+classdef WaypointClass % Il nome della classe.
+  properties % Le proprietà della classe funzionano come Strutture
+    latitude
+    longitude
+  end
+  methods
+    % Questo metodo che ha lo stesso nome della classe è il costruttore
+    function obj = WaypointClass(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Altre funzioni che usano l'oggetto Waypoint
+    function r = multiplyLatBy(obj, n)
+      r = n*[obj.latitude];
+    end
+
+    % Se si vuole aggiungere due oggetti Waypoint insieme senza chiamare
+    % una funzione speciale si può sovradefinire una funzione aritmetica di Matlab come questa:
+    function r = plus(o1,o2)
+      r = WaypointClass([o1.latitude] +[o2.latitude], ...
+                        [o1.longitude]+[o2.longitude]);
+    end
+  end
+end
+% End WaypointClass.m
+
+% Si può creare un oggetto della classe usando un costruttore
+a = WaypointClass(45.0, 45.0)
+
+% Le proprietà della classe si comportano esattamente come una Struttura Matlab.
+a.latitude = 70.0
+a.longitude = 25.0
+
+% I metodi possono essere chiamati allo stesso modo delle funzioni
+ans = multiplyLatBy(a,3)
+
+% Il metodo può anche essere chiamato usando una notazione con punto. In questo caso, l'oggetto
+% non necessita di essere passato al metodo.
+ans = a.multiplyLatBy(a,1/3)
+
+% Le funzioni Matlab possono essere sovradefinite per gestire oggetti.
+% Nel metodo sopra, è stato sovradefinito come Matlab gestisce
+% l'addizione di due oggetti Waypoint.
+b = WaypointClass(15.0, 32.0)
+c = a + b
+
+```
+
+## Di più su Matlab
+
+* Sito ufficiale [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
+* Forum ufficiale di MATLAB: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
diff --git a/it-it/python-it.html.markdown b/it-it/python-it.html.markdown
index 3a4099e7..71f6dc1c 100644
--- a/it-it/python-it.html.markdown
+++ b/it-it/python-it.html.markdown
@@ -4,9 +4,11 @@ contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
     - ["Amin Bandali", "http://aminbandali.com"]
     - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["evuez", "http://github.com/evuez"]
 filename: learnpython.py
 translators:
     - ["Ale46", "http://github.com/Ale46/"]
+    - ["Tommaso Pifferi", "http://github.com/neslinesli93/"]
 lang: it-it
 ---
 Python è stato creato da Guido Van Rossum agli inizi degli anni 90. Oggi è uno dei più popolari
@@ -15,8 +17,15 @@ pseudocodice eseguibile.
 
 Feedback sono altamente apprezzati! Potete contattarmi su [@louiedinh](http://twitter.com/louiedinh) oppure [at] [google's email service]
 
-Nota: Questo articolo è valido solamente per Python 2.7, ma dovrebbe andar bene anche per
-Python 2.x. Per Python 3.x, dai un'occhiata a [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
+Nota: questo articolo è riferito a Python 2.7 in modo specifico, ma dovrebbe andar
+bene anche per Python 2.x. Python 2.7 sta raggiungendo il "fine vita", ovvero non sarà
+più supportato nel 2020. Quindi è consigliato imparare Python utilizzando Python 3.
+Per maggiori informazioni su Python 3.x, dai un'occhiata al [tutorial di Python 3](http://learnxinyminutes.com/docs/python3/).
+
+E' possibile anche scrivere codice compatibile sia con Python 2.7 che con Python 3.x,
+utilizzando [il modulo `__future__`](https://docs.python.org/2/library/__future__.html) di Python.
+Il modulo `__future__` permette di scrivere codice in Python 3, che può essere eseguito
+utilizzando Python 2: cosa aspetti a vedere il tutorial di Python 3?
 
 ```python
 
@@ -54,6 +63,12 @@ Python 2.x. Per Python 3.x, dai un'occhiata a [Python 3 tutorial](http://learnxi
 -5 // 3  # => -2
 -5.0 // 3.0 # => -2.0
 
+# E' possibile importare il modulo "division" (vedi la sezione 6 di questa guida, Moduli)
+# per effettuare la divisione normale usando solo '/'.
+from __future__ import division
+11/4    # => 2.75  ...divisione normale
+11//4   # => 2 ...divisione troncata
+
 # Operazione Modulo
 7 % 3 # => 1
 
@@ -112,11 +127,19 @@ not False  # => True
 # Una stringa può essere considerata come una lista di caratteri
 "Questa è una stringa"[0]  # => 'Q'
 
-# % può essere usato per formattare le stringhe, in questo modo:
-"%s possono essere %s" % ("le stringhe", "interpolate")
+# Per sapere la lunghezza di una stringa
+len("Questa è una stringa")  # => 20
+
+# Formattazione delle stringhe con %
+# Anche se l'operatore % per le stringe sarà deprecato con Python 3.1, e verrà rimosso
+# successivamente, può comunque essere utile sapere come funziona
+x = 'mela'
+y = 'limone'
+z = "La cesta contiene una %s e un %s" % (x,y)
 
 # Un nuovo modo per fomattare le stringhe è il metodo format.
 # Questo metodo è quello consigliato
+"{} è un {}".format("Questo", "test")
 "{0} possono essere {1}".format("le stringhe", "formattate")
 # Puoi usare delle parole chiave se non vuoi contare
 "{nome} vuole mangiare {cibo}".format(nome="Bob", cibo="lasagna")
@@ -132,9 +155,17 @@ None is None  # => True
 # L'operatore 'is' testa l'identità di un oggetto. Questo non è
 # molto utile quando non hai a che fare con valori primitivi, ma lo è
 # quando hai a che fare con oggetti.
-
-# None, 0, e stringhe/liste vuote sono tutte considerate a False.
-# Tutti gli altri valori sono True
+ 
+# Qualunque oggetto può essere usato nei test booleani
+# I seguenti valori sono considerati falsi:
+#     - None
+#     - Lo zero, come qualunque tipo numerico (quindi 0, 0L, 0.0, 0.j)
+#     - Sequenze vuote (come '', (), [])
+#     - Contenitori vuoti (tipo {}, set())
+#     - Istanze di classi definite dall'utente, che soddisfano certi criteri
+#       vedi: https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
+#       
+# Tutti gli altri valori sono considerati veri: la funzione bool() usata su di loro, ritorna True.
 bool(0)  # => False
 bool("")  # => False
 
@@ -144,7 +175,13 @@ bool("")  # => False
 ####################################################
 
 # Python ha una funzione di stampa
-print "Sono Python. Piacere di conoscerti!"
+print "Sono Python. Piacere di conoscerti!" # => Sono Python. Piacere di conoscerti!
+
+# Un modo semplice per ricevere dati in input dalla riga di comando
+variabile_stringa_input = raw_input("Inserisci del testo: ") # Ritorna i dati letti come stringa
+variabile_input = input("Inserisci del testo: ") # Interpreta i dati letti come codice python
+# Attenzione: bisogna stare attenti quando si usa input()
+# Nota: In python 3, input() è deprecato, e raw_input() si chiama input()
 
 # Non c'è bisogno di dichiarare una variabile per assegnarle un valore
 una_variabile = 5    # Convenzionalmente si usa caratteri_minuscoli_con_underscores
@@ -155,6 +192,7 @@ una_variabile  # => 5
 un_altra_variabile  # Genera un errore di nome
 
 # if può essere usato come un'espressione
+# E' l'equivalente dell'operatore ternario in C
 "yahoo!" if 3 > 2 else 2  # => "yahoo!"
 
 # Liste immagazzinano sequenze
@@ -207,6 +245,17 @@ li + altra_li   # => [1, 2, 3, 4, 5, 6]
 # Concatena liste con "extend()"
 li.extend(altra_li)   # Ora li è [1, 2, 3, 4, 5, 6]
 
+# Rimuove la prima occorrenza di un elemento
+li.remove(2)  # Ora li è [1, 3, 4, 5, 6]
+li.remove(2)  # Emette un ValueError, poichè 2 non è contenuto nella lista
+
+# Inserisce un elemento all'indice specificato
+li.insert(1, 2)  # li è di nuovo [1, 2, 3, 4, 5, 6]
+
+# Ritorna l'indice della prima occorrenza dell'elemento fornito
+li.index(2)  # => 1
+li.index(7)  # Emette un ValueError, poichè 7 non è contenuto nella lista
+
 # Controlla l'esistenza di un valore in una lista con "in"
 1 in li   # => True
 
@@ -227,8 +276,9 @@ tup[:2]   # => (1, 2)
 
 # Puoi scompattare le tuple (o liste) in variabili
 a, b, c = (1, 2, 3)     # a è ora 1, b è ora 2 and c è ora 3
+d, e, f = 4, 5, 6       # puoi anche omettere le parentesi
 # Le tuple sono create di default se non usi le parentesi
-d, e, f = 4, 5, 6
+g = 4, 5, 6             # => (4, 5, 6)
 # Guarda come è facile scambiare due valori
 e, d = d, e     # d è ora 5 ed e è ora 4
 
@@ -250,6 +300,9 @@ filled_dict.keys()   # => ["tre", "due", "uno"]
 filled_dict.values()   # => [3, 2, 1]
 # Nota - Come sopra riguardo l'ordinamento delle chiavi.
 
+# Ottieni tutte le coppie chiave-valore, sotto forma di lista di tuple, utilizzando "items()"
+filled_dicts.items()    # => [("uno", 1), ("due", 2), ("tre", 3)]
+
 # Controlla l'esistenza delle chiavi in un dizionario con "in"
 "uno" in filled_dict   # => True
 1 in filled_dict   # => False
@@ -298,6 +351,15 @@ filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
 # Fai differenze su set con -
 {1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
 
+# Effettua la differenza simmetrica con ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# Controlla se il set a sinistra contiene quello a destra
+{1, 2} >= {1, 2, 3} # => False
+
+# Controlla se il set a sinistra è un sottoinsieme di quello a destra
+{1, 2} <= {1, 2, 3} # => True
+
 # Controlla l'esistenza in un set con in
 2 in filled_set   # => True
 10 in filled_set   # => False
@@ -405,7 +467,7 @@ aggiungi(y=6, x=5)   # Le parole chiave come argomenti possono arrivare in ogni
 
 
 # Puoi definire funzioni che accettano un numero variabile di argomenti posizionali
-# che verranno interpretati come tuple se non usi il *
+# che verranno interpretati come tuple usando il *
 def varargs(*args):
     return args
 
@@ -413,7 +475,7 @@ varargs(1, 2, 3)   # => (1, 2, 3)
 
 
 # Puoi definire funzioni che accettano un numero variabile di parole chiave
-# come argomento, che saranno interpretati come un dizionario se non usi **
+# come argomento, che saranno interpretati come un dizionario usando **
 def keyword_args(**kwargs):
     return kwargs
 
@@ -449,19 +511,19 @@ def pass_all_the_args(*args, **kwargs):
 # Funzioni Scope
 x = 5
 
-def setX(num):
+def set_x(num):
     # La variabile locale x non è uguale alla variabile globale x
     x = num # => 43
     print x # => 43
 
-def setGlobalX(num):
+def set_global_x(num):
     global x
     print x # => 5
     x = num # la variabile globable x è ora 6
     print x # => 6
 
-setX(43)
-setGlobalX(6)
+set_x(43)
+set_global_x(6)
 
 # Python ha funzioni di prima classe
 def create_adder(x):
@@ -474,15 +536,22 @@ add_10(3)   # => 13
 
 # Ci sono anche funzioni anonime
 (lambda x: x > 2)(3)   # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
 
 # Esse sono incluse in funzioni di alto livello
 map(add_10, [1, 2, 3])   # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
+
 filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 
 # Possiamo usare la comprensione delle liste per mappe e filtri
 [add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
 [x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
 
+# Puoi fare anche la comprensione di set e dizionari
+{x for x in 'abcddeef' if x in 'abc'}  # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
 
 ####################################################
 ## 5. Classi
@@ -502,6 +571,9 @@ class Human(object):
         # Assegna l'argomento all'attributo name dell'istanza
         self.name = name
 
+        # Inizializza una proprietà
+        self.age = 0
+
     # Un metodo dell'istanza. Tutti i metodi prendo "self" come primo argomento
     def say(self, msg):
         return "{0}: {1}".format(self.name, msg)
@@ -517,6 +589,21 @@ class Human(object):
     def grunt():
         return "*grunt*"
 
+    # Una proprietà è come un metodo getter.
+    # Trasforma il metodo age() in un attributo in sola lettura, che ha lo stesso nome
+    @property
+    def age(self):
+        return self._age
+
+    # Questo metodo permette di modificare la proprietà
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # Questo metodo permette di cancellare la proprietà
+    @age.deleter
+    def age(self):
+        del self._age
 
 # Instanziare una classe
 i = Human(name="Ian")
@@ -536,6 +623,16 @@ j.get_species()   # => "H. neanderthalensis"
 # Chiamare il metodo condiviso
 Human.grunt()   # => "*grunt*"
 
+# Aggiorna la proprietà
+i.age = 42
+
+# Ritorna il valore della proprietà
+i.age # => 42
+
+# Cancella la proprietà
+del i.age
+i.age  # => Emette un AttributeError
+
 
 ####################################################
 ## 6. Moduli
@@ -570,34 +667,67 @@ math.sqrt == m.sqrt == sqrt  # => True
 import math
 dir(math)
 
+# Se nella cartella corrente hai uno script chiamato math.py,
+# Python caricherà quello invece del modulo math.
+# Questo succede perchè la cartella corrente ha priorità
+# sulle librerie standard di Python
+
 
 ####################################################
 ## 7. Avanzate
 ####################################################
 
-# I generatori ti aiutano a fare codice pigro
+# Generatori
+# Un generatore appunto "genera" valori solo quando vengono richiesti,
+# invece di memorizzarli tutti subito fin dall'inizio
+
+# Il metodo seguente (che NON è un generatore) raddoppia tutti i valori e li memorizza
+# dentro `double_arr`. Se gli oggetti iterabili sono grandi, il vettore risultato
+# potrebbe diventare enorme!
 def double_numbers(iterable):
+    double_arr = []
+    for i in iterable:
+        double_arr.append(i + i)
+
+# Eseguendo il seguente codice, noi andiamo a raddoppiare prima tutti i valori, e poi
+# li ritorniamo tutti e andiamo a controllare la condizione
+for value in double_numbers(range(1000000)):  # `test_senza_generatore`
+    print value
+    if value > 5:
+        break
+
+# Invece, potremmo usare un generatore per "generare" il valore raddoppiato non
+# appena viene richiesto
+def double_numbers_generator(iterable):
     for i in iterable:
         yield i + i
 
-# Un generatore crea valori al volo.
-# Invece di generare e ritornare tutti i valori in una volta ne crea uno in ciascuna
-# iterazione.  Ciò significa che i valori più grandi di 15 non saranno considerati in
-# double_numbers.
-# Nota xrange è un generatore che fa la stessa cosa di range.
-# Creare una lista  1-900000000 occuperebbe molto tempo e spazio.
-# xrange crea un oggetto generatore xrange  invece di creare l'intera lista
-# come fa range.
-# Usiamo un underscore finale nel nome delle variabile quando vogliamo usare un nome
-# che normalmente colliderebbe con una parola chiave di python
-xrange_ = xrange(1, 900000000)
-
-# raddoppierà tutti i numeri fino a che result >=30 non sarà trovato
-for i in double_numbers(xrange_):
-    print i
-    if i >= 30:
+# Utilizzando lo stesso test di prima, stavolta però con un generatore, ci permette
+# di iterare sui valori e raddoppiarli uno alla volta, non appena vengono richiesti dalla
+# logica del programma. Per questo, non appena troviamo un valore > 5, usciamo dal ciclo senza
+# bisogno di raddoppiare la maggior parte dei valori del range (MOLTO PIU VELOCE!)
+for value in double_numbers_generator(xrange(1000000)):  # `test_generatore`
+    print value
+    if value > 5:
         break
 
+# Nota: hai notato l'uso di `range` in `test_senza_generatore` e `xrange` in `test_generatore`?
+# Proprio come `double_numbers_generator` è la versione col generatore di `double_numbers`
+# Abbiamo `xrange` come versione col generatore di `range`
+# `range` ritorna un array di 1000000 elementi
+# `xrange` invece genera 1000000 valori quando lo richiediamo/iteriamo su di essi
+
+# Allo stesso modo della comprensione delle liste, puoi creare la comprensione
+# dei generatori.
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+    print(x)  # stampa -1 -2 -3 -4 -5
+
+# Puoi anche fare il cast diretto di una comprensione di generatori ad una lista.
+values = (-x for x in [1,2,3,4,5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
 
 # Decoratori
 # in questo esempio beg include say
@@ -605,7 +735,6 @@ for i in double_numbers(xrange_):
 # ritornato
 from functools import wraps
 
-
 def beg(target_function):
     @wraps(target_function)
     def wrapper(*args, **kwargs):
@@ -634,11 +763,13 @@ print say(say_please=True)  # Puoi comprarmi una birra? Per favore! Sono povero
 * [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2.6/)
+* [The Official Docs](http://docs.python.org/2/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
 * [Python Module of the Week](http://pymotw.com/2/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 * [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [LearnPython](http://www.learnpython.org/)
+* [Fullstack Python](https://www.fullstackpython.com/)
 
 ### Libri cartacei
 
diff --git a/it-it/ruby-ecosystem-it.html.markdown b/it-it/ruby-ecosystem-it.html.markdown
new file mode 100644
index 00000000..d745399b
--- /dev/null
+++ b/it-it/ruby-ecosystem-it.html.markdown
@@ -0,0 +1,145 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+    - ["Jon Smock", "http://github.com/jonsmock"]
+    - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+    - ["Cristian Achille", "http://github.com/blackdev1l/"]
+lang: it-it
+---
+
+Generalmente chi usa ruby ha l'esigenza di avere differenti versioni di Ruby
+installate, gestire le proprie gemme, e le loro dipendenze.
+
+## Manager Ruby
+
+Alcune piattaforme hanno Ruby pre-installato o disponibile come pacchetto.
+Molti sviluppatori Ruby non usano questi pacchetti, o se lo fanno, li usano solo
+per installare dei manager Ruby, i quali permettono di installare e gestire più
+versioni di Ruby in base al progetto su cui si lavora.
+
+Di seguito i più famosi manager Ruby:
+
+* [RVM](https://rvm.io/) - Installa e permette di utilizzare diverse versioni di
+  Ruby. RVM Ha anche il concetto di gemsets i quali isolano completamente l'ambiente di sviluppo del progetto.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Installa solamente
+  multiple versioni di ruby. Usa questo se vuoi maggior controllo sull'installazione di Ruby.
+* [rbenv](https://github.com/sstephenson/rbenv) -
+  Permette solo la scelta di quale versione Ruby utilizzare. Usato insieme a ruby-build.
+  Utilizza questo per un maggior controllo su quale versione di Ruby utilizzare.
+* [chruby](https://github.com/postmodern/chruby) -
+  Permette solo la scelta di quale Ruby utilizzare, simile a rbenv.
+
+## Ruby Versions
+
+Ruby fu creato da Yukihiro "Matz" Matsumoto, il [BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life),
+(acronimo inglese che sta per "Benevolo dittatore a vita") , seppur
+ultimamente non è più del tutto vera; l'implementazione di Ruby
+è detta  MRI (Matz' Reference Implementation), e dunque quando si legge di una
+versione Ruby, essa si riferisce sempre al rilascio di una MRI
+
+Le tre maggiori versioni di Ruby in uso sono:
+
+* 2.0.0 - Rilasciata nel febbraio 2013. La maggior parte delle librerie e
+  framework supportano la 2.0.0
+* 1.9.3 - Rilasciata nel ottobre 2011. QUesta è la versione che molti
+  svluppatori usano, il supporto è
+  [concluso](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
+* 1.8.7 - Il supporto per Ruby 1.8.7 è
+  [concluso](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+I cambiamenti tra la 1.8.7 a la 1.9.x sono maggiori di quelli tra la 1.9.3 a la
+2.0.0. Per esempio, nella 1.9 vengono introdotti encodings e bytecode VM.
+Esistono ancora dei progetti basati sulla 1.8.7, ma stanno diventando una
+minoranza man mano che la community si trasferisce alle versioni 1.92 e
+1.9.3
+
+## Ruby Implementations
+
+L'ecosistema Ruby gode di molte implementazioni differenti di Ruby, ognuna con
+particolari punti di forza, da chiarire che ogni implementazione è scritta con
+un linguaggio diverso, ma esse *sono tutte Ruby*. Ogni implementazione ha
+feature extra ma tutte esse possono eseguire file ruby. Per esempio, JRuby è
+scritto in Java, ma non devi conoscere java per usarlo.
+
+Implementazioni mature e compatibili:
+
+* [MRI](https://github.com/ruby/ruby) - Scritto in C, Questa è l'implementazione
+  standard di Ruby, per definizione è 100% compatibile (con se stessa). Tutte le
+  altre implemetazioni mantengono la compatibilità con MRI
+  (vedere [RubySpec](#rubyspec) sotto).
+* [JRuby](http://jruby.org/) - Scritto in Java e Ruby, Questa implementazione è
+  molto veloce e robusta, la forza di JRuby consiste nell'interoperabilità
+  tra JVM/Java, permettendo l'utilizzo di struemnti Java già esistenti, progetti
+  e linguaggi
+* [Rubinius](http://rubini.us/) - Scritto principalmente in Ruby con un
+  c++ bytecode VM, molto matura e veloce, permette alcune feature riguardo VM.
+
+Mediamente mature e compatibili:
+
+* [Maglev](http://maglev.github.io/) - Sviluppata sui Gemstone, è una Smalltalk
+VM, Smalltalk è degli strumenti molto utili, e questo progetto cerca di portare
+questi strumenti nello sviluppo Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Porta ruby nello sviluppo iOS.
+
+Poco mature e compatibili:
+
+* [Topaz](http://topazruby.com/) - Scritto in RPython (usando PyPy come
+  toolchain) Topaz è un progetto ancora giovane e non compatibile, ha le
+  possibilità di diventare una implementazione Ruby molto performante
+* [IronRuby](http://ironruby.net/) - Scritto in C# e prendendo di mira la
+  piattaforma .NET, lo sviluppo sembra fermo da quando Microsoft ha rimosso il
+  suo supporto.
+
+Le implementazioni Ruby possono avere una propria versione, ma hanno sempre come
+target una specifica versione di MRI. Molte implementazioni hanno l'abilità di
+selezionare una versione specifica di MRI.
+
+##RubySpec
+
+La maggior parte delle implementazioni Ruby dipendono pesantemente su
+[RubySpec](http://rubyspec.org/). Ruby non ha una specifica ufficiale, quindi la
+community ha scritto una specifica eseguibile in Ruby per testare la compatibilità
+con MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) è un package manager gestito dalla communtiy
+per Ruby. Rubygems viene installato con Ruby, quindi non c'è bisogno di
+scaricarlo separatamente.
+
+I pacchetti Ruby sono chiamate "gemme", e possono essere hostate dalla community
+su RubyGems.org . Ogni gemma contiene il codice sorgente e del metadata, tra cui
+la versione, le dipendenze, autor* e licenz*.
+
+## Bundler
+
+[Bundler](http://bundler.io/) è un risolvitore di dipendenze, Esso usa il Gemfile
+di un progetto per cercare le dipendenze, dopo di che ottiene le dipendenze delle
+dipendenze ricorsivamente, Questo procedimento viene eseguito finchè tutte le
+dipendenze sono state risolte e scaricate, o si fermerà se un conflitto verrà
+trovato.
+
+Bundler genererà un error se troverà dipendenze in conflitto, Per esempio,
+se la gemma A richiede la versione 3 o maggiore della gemma Z, ma la gemma B
+richiede la versione 2, Bundler ti notificherà del conflitto. Questo diventa
+di aiuto nel momento in cui si hanno molte gemme nel progetto, il che porta a
+un grande grafo di dipendenza da risolvere.
+
+# Testing
+
+Il testing è un pezzo fondamentale della cultura Ruby, Ruby viene installato con
+il proprio testing framework chiamato minitest (O TestUnit per ruby 1.8.x).
+Esistono molte librerie con obiettivi differenti
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Testing frameowrk rilasciato insieme a Ruby 1.8.x
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Testing frameowrk rilasciato insieme a Ruby 1.9/2.0
+* [RSpec](http://rspec.info/) - Un testing framework che si concentra nella chiarezza
+* [Cucumber](http://cukes.info/) - Un BDD testing framework che estrapola testo formattato in Gherkin
+
+## Sii cordiale
+
+La community Ruby è orgogliosa di essere una communtiy aperta, accogliente e
+variegata. Matz stesso è estremamente amichevole, e la generosità degli sviluppatori
+Ruby è fantastica.
diff --git a/it-it/rust-it.html.markdown b/it-it/rust-it.html.markdown
new file mode 100644
index 00000000..6b379f93
--- /dev/null
+++ b/it-it/rust-it.html.markdown
@@ -0,0 +1,322 @@
+---
+language: rust
+contributors:
+    - ["Carlo Milanesi", "http://github.com/carlomilanesi"]
+lang: it-it
+filename: rust-it.html.markdown
+---
+
+Rust è un linguaggio di programmazione sviluppato da Mozilla Research.
+Rust combina il controllo a basso livello sulle prestazioni con alcune comodità
+ad alto livello e stringenti garanzie di sicurezza.
+
+Rust raggiunge questi obiettivi senza richiedere la garbage collection né una grossa
+libreria di supporto run-time, rendendo così possibile l'uso di librerie scritte in Rust
+come rimpiazzo di librerie scritte in C.
+
+La prima versione pubblica di Rust, la 0.1, è stata rilasciata nel gennaio 2012, e per 3 anni
+lo sviluppo è proceduto così rapidamente che l'utilizzo delle versioni
+stabili veniva scoraggiato, e piuttosto si consigliava di utilizzare le versioni notturne
+(nightly build).
+
+Il 15 maggio 2015, la versione 1.0 di Rust è stata rilasciata con la garanzia
+che nelle successive versioni 1.x non ci sarebbero state modifiche che avrebbero reso
+incompatibile il codice scritto per tale versione.
+Nelle nightly build sono attualmente disponibili migliorie al tempo di compilazione
+e ad altri aspetti del compilatore. Rust ha adottato un modello di rilascio a scaglioni
+con rilasci regolari ogni sei settimane. Per esempio, la versione 1.1 beta è stata resa
+disponibile contestualmente al rilascio della versione stabile 1.0.
+
+Sebbene Rust sia un linguaggio di livello relativamente basso, Rust ha alcuni concetti
+di programmazione funzionale che solitamente si trovano solo nei linguaggi di livello più alto.
+Ciò rende Rust non solo veloce, ma anche facile ed comodo da usare.
+
+```rust
+// I commenti che stanno su una sola riga sono fatti così...
+/* ...mentre così sono fatti
+i commenti che richiedono
+più righe */
+
+///////////////////
+// 1. Fondamenti //
+///////////////////
+
+// Funzioni
+// `i32` è il tipo per gli interi a 32-bit con segno
+fn add2(x: i32, y: i32) -> i32 {
+    // return implicito (senza punto-e-virgola)
+    x + y
+}
+
+// Funzione "main"
+fn main() {
+    // Numeri //
+
+    // Binding (ossia "variabili") immutabili
+    let x: i32 = 1;
+
+    // Suffissi intero/virgola mobile
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inferenza di tipo
+    // La maggior parte delle volte, il compilatore Rust può inferire
+    // di quale tipo sia l'espressione usata per inizializzare un binding,
+    // e quindi non è necessario specificare esplicitamente il tipo.
+    // In tutto questo tutorial, i tipi vengono specificati esplicitamente in molti posti,
+    // ma solo a scopo dimostrativo. La maggior parte delle volte se ne potrebbe
+    // fare a meno, grazie all'inferenza di tipo.
+    let implicito_x = 1;
+    let implicito_f = 1.3;
+
+    // Aritmetica
+    let somma = x + y + 13;
+
+    // Variabile mutevole
+    let mut mutevole = 1;
+    mutevole = 4;
+    mutevole += 2;
+
+    // Stringhe //
+
+    // Letterali di stringa
+    let x: &str = "Ciao mondo!";
+
+    // Stampa
+    println!("{} {}", f, x); // 1.3 Ciao mondo!
+
+    // Una `String` – una stringa allocata nello heap
+    let s: String = "Ciao mondo".to_string();
+
+    // Uno slice (fetta) di stringa – una vista immutabile
+    // all'interno di un'altra stringa.
+    // Uno slice è una coppia immutabile di puntatori al buffer contenuto
+    // nella stringa - non contiene dei caratteri, solo dei puntatori a
+    // un buffer statico o a un buffer contenuto in un altro oggetto (in questo caso, `s`)
+    let s_slice: &str = &s;
+
+    println!("{} - {}", s, s_slice); // Ciao mondo - Ciao mondo
+
+    // Vettori/array //
+
+    // Un array di lunghezza fissa
+    let quattro_int: [i32; 4] = [1, 2, 3, 4];
+
+    // Un array dinamico (vettore)
+    let mut vettore: Vec<i32> = vec![1, 2, 3, 4];
+    vettore.push(5);
+
+    // Uno slice – una vista immutabile all'interno di un vettore o di un array
+    // E' molto simile a uno slice di stringa, ma per i vettori
+    let slice: &[i32] = &vettore;
+
+    // Usa `{:?}` per stampare qualcosa a scopo di debugging
+    println!("{:?} {:?}", vettore, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuple //
+
+    // Una tupla è un insieme ordinato di dimensione fissa di valori aventi tipi eventualmente diversi
+    let x: (i32, &str, f64) = (1, "ciao", 3.4);
+
+    // Il `let` che destruttura
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 ciao 3.4
+
+    // Indicizzazione
+    println!("{}", x.1); // ciao
+
+    /////////////
+    // 2. Tipi //
+    /////////////
+
+    // Strutture
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origine: Punto = Punto { x: 0, y: 0 };
+
+    // Ana struct con campi senza nome, chiamata ‘tuple struct’
+    struct Punto2(i32, i32);
+
+    let origine2 = Punto2(0, 0);
+
+    // Enum basilare, analoga a quelle del linguaggio C
+    enum Direzione {
+        Sinistra,
+        Destra,
+        Su,
+        Giu,
+    }
+
+    let su = Direzione::Su;
+
+    // Enum con campi
+    enum OpzionaleI32 {
+        UnI32(i32),
+        Niente,
+    }
+
+    let due: OpzionaleI32 = OpzionaleI32::UnI32(2);
+    let niente = OpzionaleI32::Niente;
+
+    // Generici //
+
+    struct Foo<T> { bar: T }
+
+    // Questo è definito nella libreria standard come `Option`
+    enum Opzionale<T> {
+        QualcheValore(T),
+        NessunValore,
+    }
+
+    // Metodi //
+
+    impl<T> Foo<T> {
+        // I metodi di oggetto prendono un parametro `self` esplicito
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // I trait (tratti), noti come "interfacce" o "mixin" in altri linguaggi
+
+    trait Maneggiamento<T> {
+        fn maneggia(self) -> Option<T>;
+    }
+
+    impl<T> Maneggiamento<T> for Foo<T> {
+        fn maneggia(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let altro_foo = Foo { bar: 1 };
+    println!("{:?}", altro_foo.maneggia()); // Some(1)
+
+    /////////////////////////
+    // 3. Pattern matching //
+    /////////////////////////
+
+    let foo = OpzionaleI32::UnI32(1);
+    match foo {
+        OpzionaleI32::UnI32(n) => println!("E' un i32: {}", n),
+        OpzionaleI32::Niente  => println!("Non vale niente!"),
+    }
+
+    // Pattern matching avanzato
+    struct FooBar { x: i32, y: OpzionaleI32 }
+    let bar = FooBar { x: 15, y: OpzionaleI32::UnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OpzionaleI32::UnI32(0) } =>
+            println!("I numeri valgono zero!"),
+        FooBar { x: n, y: OpzionaleI32::UnI32(m) } if n == m =>
+            println!("I numeri sono identici"),
+        FooBar { x: n, y: OpzionaleI32::UnI32(m) } =>
+            println!("Numeri diversi: {} {}", n, m),
+        FooBar { x: _, y: OpzionaleI32::Niente } =>
+            println!("Il secondo numbero non vale niente!"),
+    }
+
+    ///////////////////////////////////////////
+    // 4. Flusso di controllo (Control flow) //
+    ///////////////////////////////////////////
+
+    // Ciclo/iterazione con `for`
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Range
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // Stampa `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("La matematica funziona!");
+    } else {
+        println!("Oh no...");
+    }
+
+    // `if` come espressione
+    let value = if true {
+        "bene"
+    } else {
+        "male"
+    };
+
+    // Ciclo `while`
+    while 1 == 1 {
+        println!("L'universo sta funzionando regolarmente.");
+    }
+
+    // Ciclo infinito
+    loop {
+        println!("Ciao!");
+    }
+
+    /////////////////////////////////////////////////
+    // 5. La sicurezza della memoria e i puntatori //
+    /////////////////////////////////////////////////
+
+    // Puntatore posseduto (owned) – solamente una cosa sola per volta può ‘possedere’ questo puntatore
+    // Ciò significa che quando il `Box` abbandona il suo scope, verrà automaticamente deallocato in sicurezza.
+    let mut mio: Box<i32> = Box::new(3);
+    *mio = 5; // dereference
+    // Qui, `adesso_e_mio` acquisisce la proprietà di `mio`. In altre parole, `mio` viene spostato.
+    let mut adesso_e_mio = mio;
+    *adesso_e_mio += 2;
+
+    println!("{}", adesso_e_mio); // 7
+    // println!("{}", mio); // questo non compilerebbe perché `adesso_e_mio` adesso possiede il puntatore
+
+    // Riferimento (reference) – un puntatore immutabile che si riferisce ad altri dati
+    // Quando un riferimento viene preso a un valore, diciamo che quel valore
+    // è stato ‘preso in prestito’ (borrowed).
+    // Mentre un valore è preso in prestito immutabilmente, non può venire mutato né spostato.
+    // Un prestito dura fino alla fine dello scope in cui è stato creato.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // Diversamente da `mio`, `var` può ancora essere usato
+    println!("{}", *ref_var);
+    // var = 5; // questo non compilerebbe, perché `var` è stato preso in prestito
+    // *ref_var = 6; // neanche questo, perché `ref_var` è un riferimento immutabile
+
+    // Riferimento immutabile
+    // Mentre un valore è preso in presto mutevolmente, non può essere acceduto in nessun modo.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;         // '*' serve a puntare al binding var2, preso in presto mutevolmente
+
+    println!("{}", *ref_var2); // 6
+    // var2 non compilerebbe. ref_var2 è di tipo &mut i32, e quindi 
+    // immagazzina un riferimento a un i32, e non il valore stesso.
+    // var2 = 2; // questo non compilerebbe, perché `var2` è stato preso in prestito
+}
+```
+
+## Ulteriori letture
+
+C'è molto di più in Rust — questi sono solo i fondamenti di Rust, che servono a capire
+le cose più importanti.
+
+Purtroppo c'è pochissima documentazione in italiano, tra cui:
+(https://www.mozillaitalia.org/home/2015/05/30/primi-passi-con-rust/)
+
+Però ce n'è parecchia in inglese. Per saperne di più, leggi [The Rust Programming
+Language](http://doc.rust-lang.org/book/index.html) e tieni d'occhio l'area di interesse di Reddit (subreddit)
+[/r/rust](http://reddit.com/r/rust).
+
+Puoi anche provare a programmare in varie versioni di Rust usando il compilatore online al sito ufficiale
+[Rust playpen](http://play.rust-lang.org).
diff --git a/ja-jp/bash-jp.html.markdown b/ja-jp/bash-jp.html.markdown
index 88e5ff1c..ea8fa49f 100644
--- a/ja-jp/bash-jp.html.markdown
+++ b/ja-jp/bash-jp.html.markdown
@@ -66,7 +66,7 @@ echo "Last program return value: $?"
 echo "Script's PID: $$"
 echo "Number of arguments: $#"
 echo "Scripts arguments: $@"
-echo "Scripts arguments seperated in different variables: $1 $2..."
+echo "Scripts arguments separated in different variables: $1 $2..."
 
 # 入力値の読み込み
 echo "What's your name?"
@@ -117,7 +117,7 @@ echo "There are $(ls | wc -l) items here."
 echo "There are `ls | wc -l` items here."
 
 # BashはJavaやC++のように、case文による分岐ができます
-case "$VARIABLE" in 
+case "$VARIABLE" in
     #分岐条件として使いたいパターンを並べてください
     0) echo "There is a zero.";;
     1) echo "There is a one.";;
diff --git a/ja-jp/python3-jp.html.markdown b/ja-jp/python3-jp.html.markdown
new file mode 100644
index 00000000..3b1a0d73
--- /dev/null
+++ b/ja-jp/python3-jp.html.markdown
@@ -0,0 +1,898 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["evuez", "http://github.com/evuez"]
+translators:
+    - ["kakakaya", "https://github.com/kakakaya"]
+filename: learnpython3-jp.py
+lang: ja-jp
+---
+
+90年代の初め、Guido Van RossumによってPythonは作成されました。現在となっては、最も有名な言語の1つです。
+私は構文の明快さによって、Pythonと恋に落ちました。
+以下は基本的に実行可能な疑似コードです。
+
+フィードバッグは大歓迎です! [@louiedinh](http://twitter.com/louiedinh) または louiedinh [at] [google's email service] にご連絡下さい!
+
+Note: この記事はPython 3に内容を絞っています。もし古いPython 2.7を学習したいなら、 [こちら](http://learnxinyminutes.com/docs/python/) をご確認下さい。
+
+```python
+
+# 1行のコメントは番号記号(#)から始まります。
+
+""" 複数行の文字は、"を3つ繋げることで
+    書くことができます。
+    また、これはコメントとしてもよく使われます。
+"""
+
+####################################################
+# 1. プリミティブ型と演算子
+####################################################
+
+# 数字です
+3                               # => 3
+
+# 四則演算はあなたの期待通りに動きます。
+1 + 1                           # => 2
+8 - 1                           # => 7
+10 * 2                          # => 20
+35 / 5                          # => 7.0
+
+# 整数除算の結果は、正負に関わらず小数の切り捨てが行われます。
+5 // 3                          # => 1
+5.0 // 3.0                      # => 1.0 # 浮動小数点でも同様に動作します。
+-5 // 3                         # => -2
+-5.0 // 3.0                     # => -2.0
+
+# 除算の結果は常に浮動小数点になります。
+10.0 / 3                        # => 3.3333333333333335
+
+# 剰余の計算
+7 % 3                           # => 1
+
+# 冪乗 (x**y, x の y 乗)
+2**4                            # => 16
+
+# 括弧により、計算の順番を優先させられます。
+(1 + 3) * 2                     # => 8
+
+# 真偽値はプリミティブ型です(大文字から始まっていることに注意!)
+True
+False
+
+# not で真偽を反転させられます。
+not True                        # => False
+not False                       # => True
+
+# ブール演算
+# 注意: "and" と "or" は小文字です
+True and False                  # => False
+False or True                   # => True
+
+# 整数でブール演算をするときのメモ
+0 and 2                         # => 0
+-5 or 0                         # => -5
+0 == False                      # => True
+2 == True                       # => False
+1 == True                       # => True
+
+# 値が等しいか確認するには ==
+1 == 1                          # => True
+2 == 1                          # => False
+
+# 値が等しくないか確認するには !=
+1 != 1                          # => False
+2 != 1                          # => True
+
+# 他の比較方法
+1 < 10                          # => True
+1 > 10                          # => False
+2 <= 2                          # => True
+2 >= 2                          # => True
+
+# 比較は連結させられます!
+1 < 2 < 3                       # => True
+2 < 3 < 2                       # => False
+
+# (is vs. ==)
+# "is" は、2つの変数が同一のオブジェクトを参照しているか確認します。
+# 一方 "==" は、それぞれが参照する2つのオブジェクトが同じ値を持つか確認します。
+a = [1, 2, 3, 4]     # a は新しいリストの [1, 2, 3, 4] を指します。
+b = a                # b は a が指すリストを指します。
+b is a               # => True, a と b は同一のオブジェクトを参照しています。
+b == a               # => True, a と b が参照するオブジェクトの値は等しいです。
+b = [1, 2, 3, 4]     # b は新しいリストの [1, 2, 3, 4] を指します。
+b is a               # => False, a と b は別々のオブジェクトを参照しています。
+b == a               # => True, a と b が参照するオブジェクトの値は等しいです。
+
+# " または ' を使って文字列を作成します。
+"This is a string."
+'This is also a string.'
+
+# 文字列も加算をすることができます!でも、あまり行わないように。
+"Hello " + "world!"             # => "Hello world!"
+# '+' を使わなくても連結はできます。
+"Hello " "world!"               # => "Hello world!"
+
+# 文字列は文字のリストであるかのように扱うことができます。
+"This is a string"[0]           # => 'T'
+
+# 文字列の長さを得るにはこのようにします。
+len("This is a string")         # => 16
+
+# .format で文字列のフォーマットを行えます
+"{} can be {}".format("Strings", "interpolated")  # => "Strings can be interpolated"
+
+# 入力を減らすために、フォーマットするときに引数を繰り返し使うことができます。
+"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
+# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+
+# 引数の順番を数えるのがお嫌い？キーワード引数をどうぞ。
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")  # => "Bob wants to eat lasagna"
+
+# もし Python 3 のコードを Python 2.5以下でも使う必要があるなら、
+# 旧式のフォーマット方法を使うこともできます。
+"%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
+
+
+# None はオブジェクトです(大文字からです!)
+None                            # => None
+
+# オブジェクトがNoneであるか確認するのに "==" 演算子を使わないように。
+# 代わりに "is" を使いましょう。オブジェクトの素性を確認できます。
+"etc" is None                   # => False
+None is None                    # => True
+
+# None や 0 、空の 文字列/リスト/辞書/タプル は全て False として評価されます。
+# 他の全ての値は True になります。
+bool(0)                         # => False
+bool("")                        # => False
+bool([])                        # => False
+bool({})                        # => False
+bool(())                        # => False
+
+####################################################
+# 2. Variables and Collections
+####################################################
+
+# Python にはprint関数があります。
+print("I'm Python. Nice to meet you!")  # => I'm Python. Nice to meet you!
+
+# 標準では、print関数は最後に改行を出力します。
+# この動作を変更するためには、オプション引数を利用します。
+print("Hello, World", end="!")  # => Hello, World!
+
+# コンソールから入力を得るための簡単な例
+input_string_var = input("Enter some data: ")  # 入力を文字列として返します
+# Note: Python の初期のバージョンでは、 input() は raw_input() という名前で存在します。
+
+# 変数に代入する前に宣言する必要はありません。
+# 慣例的に、小文字でアンダースコア区切り ( lower_case_with_underscores ) の変数が使われます。
+some_var = 5
+some_var                        # => 5
+
+# 代入されていない変数へのアクセスは例外を引き起こします。
+# 例外の取り扱いについては、3章の制御の流れをご確認ください。
+some_unknown_var                # NameError を送出します
+
+# ifは式として使用できます。
+# C言語の「?:(三項演算子)」に対応する例:
+"yahoo!" if 3 > 2 else 2        # => "yahoo!"
+
+# リストは順序を保存します。
+li = []
+# 値の入っているリストも作成できます。
+other_li = [4, 5, 6]
+
+# append により、リストの末尾にものを入れられます。
+li.append(1)                    # li is now [1]
+li.append(2)                    # li is now [1, 2]
+li.append(4)                    # li is now [1, 2, 4]
+li.append(3)                    # li is now [1, 2, 4, 3]
+# pop でリストの末尾から取り除けます。
+li.pop()                        # => 3 and li is now [1, 2, 4]
+# 元に戻しましょう!
+li.append(3)                    # li is now [1, 2, 4, 3] again.
+
+# 配列のように、リストにアクセスできます。
+li[0]                           # => 1
+# 最後の要素を参照できます。
+li[-1]                          # => 3
+
+# 範囲外の要素を参照すると IndexError になります。
+li[4]                           # IndexError が発生します
+
+# スライス構文により範囲を参照できます。
+li[1:3]                         # => [2, 4]
+# 先端を取り除く
+li[2:]                          # => [4, 3]
+# 末尾を取り除く
+li[:3]                          # => [1, 2, 4]
+# 1つ飛ばしで選択する
+li[::2]                         # =>[1, 4]
+# 反転したリストを得る
+li[::-1]                        # => [3, 4, 2, 1]
+# これらの任意の組み合わせにより、より複雑なスライスを作ることができます。
+# li[start:end:step]
+
+# スライスにより、深いコピーを1階層分行うことができます。
+li2 = li[:]          # => li2 = [1, 2, 4, 3] だが、 (li2 is li) はFalseになる。
+
+# "del"によりリストから任意の要素を削除できます。
+del li[2]                       # li は [1, 2, 3] になりました。
+
+# "remove"で最初に出現する要素を削除できます。
+li.remove(2)                    # li は [1, 3] になりました。
+li.remove(2)                    # 2はリストの中に存在しないので、 ValueError が発生します。
+
+# 要素を好きなところに挿入できます。
+li.insert(1, 2)                 # li は [1, 2, 3] に戻りました。
+
+# "index"で引数の要素が最初に出現する場所のインデックスを得られます。
+li.index(2)                     # => 1
+li.index(4)                     # 4はリストの中に存在しないので、 ValueError が発生します。
+
+# リスト同士を足すこともできます。
+# Note: li と other_li の値は変更されません。
+li + other_li                   # => [1, 2, 3, 4, 5, 6]
+
+# "extend()"で他のリストを連結することができます。
+li.extend(other_li)             # li は [1, 2, 3, 4, 5, 6] になります。
+
+# リストの中に値が存在するか、 "in" で確認できます。
+1 in li                         # => True
+
+# 長さは "len()" で確認できます。
+len(li)                         # => 6
+
+
+# タプルはリストのようなものですが、不変であるという違いがあります。
+tup = (1, 2, 3)
+tup[0]                      # => 1
+tup[0] = 3                  # 内容を変更しようとすると TypeError が発生します。
+
+# 長さが1のタプルを作成するには、要素の後にカンマを付ける必要があります。
+# しかし、それ以外の長さなら、例え長さが0でもそのようにする必要はありません。
+type((1))                       # => <class 'int'>
+type((1,))                      # => <class 'tuple'>
+type(())                        # => <class 'tuple'>
+
+# 大抵のリスト操作はタプルでも行うことができます。
+len(tup)                        # => 3
+tup + (4, 5, 6)                 # => (1, 2, 3, 4, 5, 6)
+tup[:2]                         # => (1, 2)
+2 in tup                        # => True
+
+# タプルやリストから複数の変数に代入することができます。
+a, b, c = (1, 2, 3)             # a, b, c にはそれぞれ 1, 2, 3 が代入されました。
+# 拡張記法もあります。
+a, *b, c = (1, 2, 3, 4)         # a は 1 、 b は [2, 3] 、c は4 になります。
+# 括弧を作成しなくてもデフォルトでタプルが作成されます。
+d, e, f = 4, 5, 6
+# 2つの変数を交換するのがどれほど簡単か見てみましょう。
+e, d = d, e                     # d は 5 、 e は e になります。
+
+
+# 辞書はマップ(キーと値の組み合わせ)を保存できます。
+empty_dict = {}
+# 値が入っている辞書を直接作成することもできます。
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# キーは不変の型である必要があります。
+# これは、高速化のため、キーを定数のハッシュ値に変換できるようにするためです。
+# 不変の型の例として、int、float、string、tupleなどが上げられます。
+invalid_dict = {[1, 2, 3]: "123"}  # => list はハッシュ化できないので、 TypeError が発生します。
+valid_dict = {(1, 2, 3): [1, 2, 3]}  # 一方、キーに対応する値はどのような型でも利用できます。
+
+# [] で 値を取り出せます。
+filled_dict["one"]              # => 1
+
+# "keys()"により、全てのキーを反復可能な形式で取り出せます。
+# これをリストにするために、"list()"で囲んでいます。これについては後程解説します。
+# Note: 辞書のキーの順番は考慮されていません。実行した結果がこれと異なる場合があります。
+list(filled_dict.keys())        # => ["three", "two", "one"]
+
+# "values()"により、全ての値を反復可能な形式で取り出せます。
+# 前と同じように、これをリストにするために、"list()"で囲んでいます。
+# Note: 辞書の値の順番は考慮されていません。実行した結果がこれと異なる場合があります。
+list(filled_dict.values())      # => [3, 2, 1]
+
+
+# "in" により、辞書のキーが存在するか確認できます。
+"one" in filled_dict            # => True
+1 in filled_dict                # => False
+
+# 存在しないキーで辞書を参照すると KeyError になります。
+filled_dict["four"]             # KeyError
+
+# "get()" メソッドを使うことで KeyError を回避できます。
+filled_dict.get("one")          # => 1
+filled_dict.get("four")         # => None
+# get ではキーが存在しなかったときのデフォルト値を指定できます。
+filled_dict.get("one", 4)       # => 1
+filled_dict.get("four", 4)      # => 4
+
+# "setdefault()" で、キーが存在しなかった場合のみ、値を設定できます。
+filled_dict.setdefault("five", 5)  # filled_dict["five"] は 5 になりました。
+filled_dict.setdefault("five", 6)  # filled_dict["five"] は 5 のままです。
+
+# 辞書にマップを追加する
+filled_dict.update({"four": 4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
+# filled_dict["four"] = 4        # 辞書に追加する別の方法
+
+# del により辞書からキーを削除できます。
+del filled_dict["one"]          # "one" キーを辞書から削除します。
+
+# Python 3.5 以降では、追加の値を取り出す方法があります。
+{'a': 1, **{'b': 2}}            # => {'a': 1, 'b': 2}
+{'a': 1, **{'a': 2}}            # => {'a': 2}
+
+
+# set では集合を表現できます。
+empty_set = set()
+# 集合を一連の値で初期化する例です。辞書に似ていますね？ごめんなさい。
+some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
+
+# 辞書のキーのように、集合の値は不変である必要があります。
+invalid_set = {[1], 1}         # => list はハッシュ化できないので、 TypeError が送出されます。
+valid_set = {(1,), 1}
+
+# 新しい値を集合にセットできます。
+filled_set = some_set
+
+# 集合に新しい要素を追加できます。
+filled_set.add(5)               # filled_set は {1, 2, 3, 4, 5} になりました。
+
+# & により、集合同士の共通部分が得られます。
+other_set = {3, 4, 5, 6}
+filled_set & other_set          # => {3, 4, 5}
+
+# | により、集合同士の合併が得られます。
+filled_set | other_set          # => {1, 2, 3, 4, 5, 6}
+
+# - により、集合同士の差集合が得られます。
+{1, 2, 3, 4} - {2, 3, 5}        # => {1, 4}
+
+# ^ により、集合同士の対象差が得られます。
+{1, 2, 3, 4} ^ {2, 3, 5}        # => {1, 4, 5}
+
+# 左の集合が右の集合の上位集合であるか確認。
+{1, 2} >= {1, 2, 3}             # => False
+
+# 左の集合が右の集合の部分集合であるか確認。
+{1, 2} <= {1, 2, 3}             # => True
+
+# in により値が集合の中に存在するか確認できます。
+2 in filled_set                 # => True
+10 in filled_set                # => False
+
+
+####################################################
+# 3. 制御の流れとiterable
+####################################################
+
+# まずは変数を作りましょう。
+some_var = 5
+
+# これはif文です。インデントがPythonでは特徴的ですね!
+# 以下の例では"some_var is smaller than 10"と出力されます。
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:             # この elif 節はオプションです。
+    print("some_var is smaller than 10.")
+else:                           # この else 節もオプションです。
+    print("some_var is indeed 10.")
+
+
+"""
+for ループはリストの要素を反復することができます。
+出力:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # format() を使って文字列に変数を挿入して出力できます。
+    print("{} is a mammal".format(animal))
+
+"""
+"range(数値)" は、ゼロから与えられた数値までのiterableを返します。
+出力:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(lower, upper)" は、 lower の数値から upper の数値までのiterableを返します。
+upper の数値は含まれません。
+出力:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(lower, upper, step)" は、lower の数値から upper の数値までが、
+step 刻みで表現されるiterableを返します
+step が与えられない場合、デフォルトは1になります。
+出力:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+while によるループは条件が成立しなくなるまで実行されます。
+出力:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1                      # x = x + 1 の省略記法
+
+# try/except ブロックにより、例外を扱う
+try:
+    # "raise" により例外を発生させます。
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass  # pass は、何もしないという命令(no-op)に相当します。普通、ここで例外に対処します。
+except (TypeError, NameError):
+    pass                 # もし必要なら、複数の種類の例外を一緒に処理できます。
+else:  # try/except ブロックへのオプションの節。他の全てのexceptブロックより後に置かなければなりません。
+    print("All good!")        # tryで例外が発生しなかった場合のみ実行されます。
+finally:  # 例外が発生したか、しなかったか、どのような例外だったかに関らず実行されます。
+    print("We can clean up resources here")
+
+# try/finallyでリソースの始末をする代わりに、 with 文を使うこともできます。
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Pythonは、iterableと呼ばれる基本的な抽象化が提供しています。
+# iterableは、シーケンスとして取り扱えるオブジェクトです。
+# range関数で返されるオブジェクトもiterableの一種です。
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => dict_keys(['one', 'two', 'three']). これはiterableインタフェースを実装するオブジェクトです。
+
+# iterableでループを行うことができます。
+for i in our_iterable:
+    print(i)                    # Prints one, two, three
+
+# しかし、インデックスで要素を参照することはできません。
+our_iterable[1]                 # TypeError が発生します。
+
+# iterableは、iteratorの作り方がわかるオブジェクトです。
+our_iterator = iter(our_iterable)
+
+# iterator は、要素を取り出したときの状態を覚えるオブジェクトです。
+# "next()"により次の要素を取り出せます。
+next(our_iterator)              # => "one"
+
+# 反復(iterate)する度に、状態を更新します。
+next(our_iterator)              # => "two"
+next(our_iterator)              # => "three"
+
+# iteratorが自身の持つ全てのデータを返したあとは、 StopIteration 例外を発生させます。
+next(our_iterator)              # StopIteration が発生します。
+
+# "list()"を呼ぶことにより、iteratorの全ての要素を得られます。
+list(filled_dict.keys())        # => ["one", "two", "three"]
+
+
+####################################################
+# 4. 関数
+####################################################
+
+# 新しい関数を作成するには "def" を使います。
+def add(x, y):
+    print("x is {} and y is {}".format(x, y))
+    return x + y                # return 文で値を返します。
+
+# 引数付きで関数を呼んでみましょう。
+add(5, 6)                    # => "x is 5 and y is 6" と出力し、 11 を返します。
+
+# キーワード引数で関数を呼ぶこともできます。
+add(y=6, x=5)                   # キーワード引数を使うと任意の順番で引数を指定できます。
+
+
+# 可変数の位置引数を持つ関数を定義できます。
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)  # => (1, 2, 3)
+
+
+# 可変数のキーワード引数を持つ関数を定義できます。
+def keyword_args(**kwargs):
+    return kwargs
+
+# 何が起こるか、試してみましょう
+keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
+
+
+# お望みなら、両方一気にやることもできます。
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) prints:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# 関数を呼ぶとき、 args/kwargs の逆のことをすることができます!
+# * を使ってタプルを展開したり、 ** を使って辞書を展開できます。
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)             # foo(1, 2, 3, 4) に対応します。
+all_the_args(**kwargs)          # foo(a=3, b=4) に対応します。
+all_the_args(*args, **kwargs)   # foo(1, 2, 3, 4, a=3, b=4) に対応します。
+
+
+# タプルで複数の値を返す
+def swap(x, y):    # 括弧を使わずに、複数の値をタプルとして返すことができます。
+    return y, x    # (Note: 括弧は使わなくてもいいですが、使うこともできます。)
+
+
+x = 1
+y = 2
+x, y = swap(x, y)               # => x = 2, y = 1
+# (x, y) = swap(x,y)  # このように、括弧は使っても使わなくてもいいです。
+
+
+# 関数のスコープ
+x = 5
+
+
+def set_x(num):
+    # ローカル変数の x はグローバル変数の x とは異なります
+    x = num                     # => 43
+    print(x)                    # => 43
+
+
+def set_global_x(num):
+    global x
+    print(x)                    # => 5
+    x = num                     # グローバル変数の x に 6 が代入されました。
+    print(x)                    # => 6
+
+set_x(43)
+set_global_x(6)
+
+
+# Pythonは第一級関数をサポートします。
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)                       # => 13
+
+# 無名関数もサポートしています。
+(lambda x: x > 2)(3)                 # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# 高階関数も組込まれています。
+list(map(add_10, [1, 2, 3]))         # => [11, 12, 13]
+list(map(max, [1, 2, 3], [4, 2, 1]))  # => [4, 2, 3]
+
+list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]
+
+# map や filter の代わりに、リスト内包表記を使うことができます。
+# リスト内包表記は、出力を別のリスト内包表記にネストさせることができます。
+[add_10(i) for i in [1, 2, 3]]        # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
+
+# 集合(set)や辞書も内包表記ができます。
+{x for x in 'abcddeef' if x not in 'abc'}  # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)}                # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+# 5. モジュール
+####################################################
+
+# Pythonではモジュールをインポートできます。
+import math
+print(math.sqrt(16))            # => 4.0
+
+# モジュールの中から特定の関数をインポートすることもできます。
+from math import ceil, floor
+print(ceil(3.7))                # => 4.0
+print(floor(3.7))               # => 3.0
+
+# 全部の関数をモジュールからインポートすることができます。
+# Warning: この方法は推奨されません。
+from math import *
+
+# 短い名前でモジュールをインポートすることができます。
+import math as m
+math.sqrt(16) == m.sqrt(16)     # => True
+
+# Pythonのモジュールは実際には単なるPythonのファイルです。
+# 自分で書くことも、インポートすることもできます。
+# ファイル名がそのままモジュール名になります。
+
+# モジュールで定義されている関数と属性を調べることができます。
+import math
+dir(math)
+
+# もし、現在書いているスクリプトと同じフォルダに「math.py」という
+# Pythonのスクリプトが存在する場合、そのmath.pyが
+# 組み込みのPythonモジュールの代わりに読み込まれるでしょう。
+# これは、ローカルのフォルダはPythonの組み込みライブラリよりも
+# 優先度が高いため発生するのです。
+
+
+####################################################
+# 6. クラス
+####################################################
+
+# クラスを作成するために、"class"という演算子を使います。
+class Human:
+
+    # クラスの属性です。このクラスの全てのインスタンスで共有されます。
+    species = "H. sapiens"
+
+    # 標準的なイニシャライザで、このクラスがインスタンスを作成するときは毎回呼ばれます。
+    # 2つのアンダースコアがオブジェクトや属性の前後についているとき、これらはPythonによって利用され、
+    # ユーザーの名前空間には存在しないということに注意してください。
+    # __init__ や __str__ 、 __repr__ のようなメソッド(やオブジェクト、属性)は、
+    # magic methods (または dunder methods)と呼ばれます。
+    # このような名前を自分で発明しないほうがよいでしょう。
+    def __init__(self, name):
+        # 引数をインスタンスのname属性に設定します。
+        self.name = name
+
+        # プロパティの初期化
+        self.age = 0
+
+    # インスタンスメソッド。全てのメソッドは"self"を最初の引数に取ります。
+    def say(self, msg):
+        print("{name}: {message}".format(name=self.name, message=msg))
+
+    # 別のインスタンスメソッドの例。
+    def sing(self):
+        return 'yo... yo... microphone check... one two... one two...'
+
+    # クラスメソッドは全てのインスタンスで共有されます。
+    # クラスメソッドではクラスを最初の引数として呼ばれます。
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # スタティックメソッドはクラスやインスタンスを参照せずに呼ばれます。
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+    # プロパティはgetterのようなものです。
+    # age() メソッドを同名の読取専用属性に変換します。
+    @property
+    def age(self):
+        return self._age
+
+    # プロパティを設定できるようにします。
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # プロパティを削除できるようにします。
+    @age.deleter
+    def age(self):
+        del self._age
+
+
+# Pythonインタプリタがソースファイルを読み込んだとき、全てのコードを実行します。
+# この __name__ による確認により、このモジュールがメインのプログラムである場合にのみ、
+# このコードブロックが実行されるようにします。
+if __name__ == '__main__':
+    # クラスのインスタンスを作成します。
+    i = Human(name="Ian")
+    i.say("hi")                 # "Ian: hi"
+    j = Human("Joel")
+    j.say("hello")              # "Joel: hello"
+    # i と j はHumanのインスタンスです。別の言葉で言うなら、これらはHumanのオブジェクトです。
+
+    # クラスメソッドを呼んでみましょう。
+    i.say(i.get_species())      # "Ian: H. sapiens"
+    # 共有属性を変更してみましょう。
+    Human.species = "H. neanderthalensis"
+    i.say(i.get_species())      # => "Ian: H. neanderthalensis"
+    j.say(j.get_species())      # => "Joel: H. neanderthalensis"
+
+    # スタティックメソッドを呼んでみましょう。
+    print(Human.grunt())            # => "*grunt*"
+    print(i.grunt())                # => "*grunt*"
+
+    # インスタンスのプロパティを更新してみましょう。
+    i.age = 42
+    # プロパティを取得してみましょう。
+    i.say(i.age)                    # => 42
+    j.say(j.age)                    # => 0
+    # プロパティを削除してみましょう。
+    del i.age
+    # i.age                         # => AttributeError が発生します。
+
+
+####################################################
+# 6.1 多重継承
+####################################################
+
+# 別のクラスを定義します。
+class Bat:
+
+    species = 'Baty'
+
+    def __init__(self, can_fly=True):
+        self.fly = can_fly
+
+    # このクラスも say メソッドを持ちます。
+    def say(self, msg):
+        msg = '... ... ...'
+        return msg
+
+    # 同様に、独自のメソッドも与えましょう。
+    def sonar(self):
+        return '))) ... ((('
+
+if __name__ == '__main__':
+    b = Bat()
+    print(b.say('hello'))
+    print(b.fly)
+
+# ファイル単位のモジュール化を利用するために、上記のクラスを別々のファイルに配置することができます。
+# ここでは、human.pyとbat.pyを作成してみましょう。
+
+# 他のファイルから関数をインポートするために、次のような形式を利用してください。
+# from "拡張子無しのファイル名" import "関数またはクラス"
+
+# superhero.py
+from human import Human
+from bat import Bat
+
+
+# BatmanはHumanとBatの両方を継承します。
+class Batman(Human, Bat):
+
+    # Batmanは species のクラス属性に独自の値を持ちます。
+    species = 'Superhero'
+
+    def __init__(self, *args, **kwargs):
+        # 通常、属性を継承するにはsuper()を呼び出します。
+        #     super(Batman, self).__init__(*args, **kwargs)
+        # しかし、ここでは多重継承を行っているので、 super() はMRO(メソッド解決順序)の次の基本クラスにのみ動作します。
+        # なので、全ての祖先に対して明示的に __init__ を呼ぶことにします。
+        # *args と **kwargs を使うことで、それぞれの継承元が
+        # たまねぎの皮を剥がすごとく、引数を用いることができます。
+        Human.__init__(self, 'anonymous', *args, **kwargs)
+        Bat.__init__(self, *args, can_fly=False, **kwargs)
+        # 名前の属性の値を上書きします。
+        self.name = 'Sad Affleck'
+
+    def sing(self):
+        return 'nan nan nan nan nan batman!'
+
+
+if __name__ == '__main__':
+    sup = Batman()
+
+    # インスタンスの型を調べてみましょう。
+    if isinstance(sup, Human):
+        print('I am human')
+    if isinstance(sup, Bat):
+        print('I am bat')
+    if type(sup) is Batman:
+        print('I am Batman')
+
+    # getattr() や super() の両方で使われるMROを取得します。
+    # この属性は動的であり、更新が可能です。
+    print(Batman.__mro__)  # => (<class '__main__.Batman'>, <class 'human.Human'>, <class 'bat.Bat'>, <class 'object'>)
+
+    # 親メソッドを呼び出しますが、独自のクラス属性を参照します。
+    print(sup.get_species())    # => Superhero
+
+    # オーバーロードされたメソッドを呼び出します。
+    print(sup.sing())           # => nan nan nan nan nan batman!
+
+    # 継承順により、Humanから継承されたメソッドを呼び出します。
+    sup.say('I agree')          # => Sad Affleck: I agree
+
+    # 2番目の先祖にのみ存在するメソッドを呼び出してみます。
+    print(sup.sonar())          # => ))) ... (((
+
+    # 継承されたクラス属性
+    sup.age = 100
+    print(sup.age)
+
+    # デフォルト値が上書きされて、2番目の先祖から継承された属性
+    print('Can I fly? ' + str(sup.fly))
+
+
+####################################################
+# 7. 発展的内容
+####################################################
+
+# ジェネレータは遅延をするコードの作成に役立ちます。
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# 次の値を処理するのに必要なデータしか読み込まないので、ジェネレータはメモリをあまり消費しません。
+# この性質により、他の方法では非常に多くのメモリを消費するような操作が可能になります。
+for i in double_numbers(range(1, 900000000)):  # `range` もジェネレータの1つです。
+    print(i)
+    if i >= 30:
+        break
+
+# リスト内包表記のように、ジェネータ内包表記を作成することもできます。
+values = (-x for x in [1, 2, 3, 4, 5])
+for x in values:
+    print(x)                    # prints -1 -2 -3 -4 -5
+
+# ジェネレータ内包表記から直接リストを作成することもできます。
+values = (-x for x in [1, 2, 3, 4, 5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
+# デコレータ
+# この例では`beg` が `say` を `wraps`します。
+# もし say_please が True なら、出力が変更されます。
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())                 # Can you buy me a beer?
+print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+```
+
+## Ready For More?
+
+### Free Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
+* [Dive Into Python 3](http://www.diveintopython3.net/index.html)
+* [A Crash Course in Python for Scientists](http://nbviewer.jupyter.org/gist/anonymous/5924718)
diff --git a/java.html.markdown b/java.html.markdown
index 74140120..a27a68ca 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -1,28 +1,42 @@
 ---
 language: java
 contributors:
-    - ["Jake Prather", "http://github.com/JakeHP"]
-    - ["Jakukyo Friel", "http://weakish.github.io"]
-    - ["Madison Dickson", "http://github.com/mix3d"]
-    - ["Simon Morgan", "http://sjm.io/"]
-    - ["Zachary Ferguson", "http://github.com/zfergus2"]
-    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Jake Prather", "https://github.com/JakeHP"]
+    - ["Jakukyo Friel", "https://weakish.github.io"]
+    - ["Madison Dickson", "https://github.com/mix3d"]
+    - ["Simon Morgan", "https://sjm.io/"]
+    - ["Zachary Ferguson", "https://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "https://github.com/cschermerhorn"]
     - ["Rachel Stiyer", "https://github.com/rstiyer"]
+    - ["Michael Dähnert", "https://github.com/JaXt0r"]
+    - ["Rob Rose", "https://github.com/RobRoseKnows"]
+    - ["Sean Nam", "https://github.com/seannam"]
 filename: LearnJava.java
 ---
 
 Java is a general-purpose, concurrent, class-based, object-oriented computer
 programming language.
-[Read more here.](http://docs.oracle.com/javase/tutorial/java/)
+[Read more here.](https://docs.oracle.com/javase/tutorial/java/)
 
 ```java
 // Single-line comments start with //
+
 /*
 Multi-line comments look like this.
 */
+
 /**
-JavaDoc comments look like this. Used to describe the Class or various
-attributes of a Class.
+ * JavaDoc comments look like this. Used to describe the Class or various
+ * attributes of a Class.
+ * Main attributes:
+ *
+ * @author         Name (and contact information such as email) of author(s).
+ * @version     Current version of the program.
+ * @since        When this part of the program was first added.
+ * @param         For describing the different parameters for a method.
+ * @return        For describing what the method returns.
+ * @deprecated  For showing the code is outdated or shouldn't be used.
+ * @see         Links to another part of documentation.
 */
 
 // Import ArrayList class inside of the java.util package
@@ -30,12 +44,21 @@ import java.util.ArrayList;
 // Import all classes inside of java.security package
 import java.security.*;
 
-// Each .java file contains one outer-level public class, with the same name as
-// the file.
+// Each .java file contains one outer-level public class, with the same name
+// as the file.
 public class LearnJava {
 
-    // In order to run a java program, it must have a main method as an entry point.
-    public static void main (String[] args) {
+    // In order to run a java program, it must have a main method as an entry
+    // point.
+    public static void main(String[] args) {
+
+    ///////////////////////////////////////
+    // Input/Output
+    ///////////////////////////////////////
+
+        /*
+        * Ouput
+        */
 
         // Use System.out.println() to print lines.
         System.out.println("Hello World!");
@@ -51,6 +74,32 @@ public class LearnJava {
         // Use System.out.printf() for easy formatted printing.
         System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
 
+        /*
+         * Input
+         */
+
+        // use Scanner to read input
+        // must import java.util.Scanner;
+        Scanner scanner = new Scanner(System.in);
+
+        // read string input
+        String name = scanner.next();
+
+        // read byte input
+        byte numByte = scanner.nextByte();
+
+        // read int input
+        int numInt = scanner.nextInt();
+
+        // read long input
+        float numFloat = scanner.nextFloat();
+
+        // read double input
+        double numDouble = scanner.nextDouble();
+
+        // read boolean input
+        boolean bool = scanner.nextBoolean();
+
         ///////////////////////////////////////
         // Variables
         ///////////////////////////////////////
@@ -60,7 +109,8 @@ public class LearnJava {
         */
         // Declare a variable using <type> <name>
         int fooInt;
-        // Declare multiple variables of the same type <type> <name1>, <name2>, <name3>
+        // Declare multiple variables of the same
+        // type <type> <name1>, <name2>, <name3>
         int fooInt1, fooInt2, fooInt3;
 
         /*
@@ -68,10 +118,12 @@ public class LearnJava {
         */
 
         // Initialize a variable using <type> <name> = <val>
-        int fooInt = 1;
-        // Initialize multiple variables of same type with same value <type> <name1>, <name2>, <name3> = <val>
-        int fooInt1, fooInt2, fooInt3;
-        fooInt1 = fooInt2 = fooInt3 = 1;
+        int barInt = 1;
+        // Initialize multiple variables of same type with same
+        // value <type> <name1>, <name2>, <name3>
+        // <name1> = <name2> = <name3> = <val>
+        int barInt1, barInt2, barInt3;
+        barInt1 = barInt2 = barInt3 = 1;
 
         /*
         *  Variable types
@@ -80,13 +132,19 @@ public class LearnJava {
         // (-128 <= byte <= 127)
         byte fooByte = 100;
 
+        // If you would like to interpret a byte as an unsigned integer
+        // then this simple operation can help
+        int unsignedIntLessThan256 = 0xff & fooByte;
+        // this contrasts a cast which can be negative.
+        int signedInt = (int) fooByte;
+
         // Short - 16-bit signed two's complement integer
         // (-32,768 <= short <= 32,767)
         short fooShort = 10000;
 
         // Integer - 32-bit signed two's complement integer
         // (-2,147,483,648 <= int <= 2,147,483,647)
-        int fooInt = 1;
+        int bazInt = 1;
 
         // Long - 64-bit signed two's complement integer
         // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
@@ -94,7 +152,9 @@ public class LearnJava {
         // L is used to denote that this variable value is of type Long;
         // anything without is treated as integer by default.
 
-        // Note: Java has no unsigned types.
+        // Note: byte, short, int and long are signed. They can have positive and negative values.
+        // There are no unsigned variants.
+        // char, however, is 16-bit unsigned.
 
         // Float - Single-precision 32-bit IEEE 754 Floating Point
         // 2^-149 <= float <= (2-2^-23) * 2^127
@@ -119,7 +179,6 @@ public class LearnJava {
         final double E;
         E = 2.71828;
 
-
         // BigInteger - Immutable arbitrary-precision integers
         //
         // BigInteger is a data type that allows programmers to manipulate
@@ -127,13 +186,11 @@ public class LearnJava {
         // of bytes and are manipulated using functions built into BigInteger
         //
         // BigInteger can be initialized using an array of bytes or a string.
-        
         BigInteger fooBigInteger = new BigInteger(fooByteArray);
 
-
         // BigDecimal - Immutable, arbitrary-precision signed decimal number
         //
-        // A BigDecimal takes two parts: an arbitrary precision integer 
+        // A BigDecimal takes two parts: an arbitrary precision integer
         // unscaled value and a 32-bit integer scale
         //
         // BigDecimal allows the programmer complete control over decimal
@@ -142,16 +199,13 @@ public class LearnJava {
         //
         // BigDecimal can be initialized with an int, long, double or String
         // or by initializing the unscaled value (BigInteger) and scale (int).
-
         BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
-        
+
         // Be wary of the constructor that takes a float or double as
         // the inaccuracy of the float/double will be copied in BigDecimal.
         // Prefer the String constructor when you need an exact value.
-        
         BigDecimal tenCents = new BigDecimal("0.1");
 
-
         // Strings
         String fooString = "My String Is Here!";
 
@@ -163,6 +217,42 @@ public class LearnJava {
         System.out.println(barString);
         System.out.println(bazString);
 
+        // String Building
+        // #1 - with plus operator
+        // That's the basic way to do it (optimized under the hood)
+        String plusConcatenated = "Strings can " + "be concatenated " + "via + operator.";
+        System.out.println(plusConcatenated);
+        // Output: Strings can be concatenated via + operator.
+
+        // #2 - with StringBuilder
+        // This way doesn't create any intermediate strings. It just stores the string pieces, and ties them together
+        // when toString() is called.
+        // Hint: This class is not thread safe. A thread-safe alternative (with some impact on performance) is StringBuffer.
+        StringBuilder builderConcatenated = new StringBuilder();
+        builderConcatenated.append("You ");
+        builderConcatenated.append("can use ");
+        builderConcatenated.append("the StringBuilder class.");
+        System.out.println(builderConcatenated.toString()); // only now is the string built
+        // Output: You can use the StringBuilder class.
+
+        // StringBuilder is efficient when the fully constructed String is not required until the end of some processing.
+        StringBuilder stringBuilder = new StringBuilder();
+        String inefficientString = "";
+        for (int i = 0 ; i < 10; i++) {
+            stringBuilder.append(i).append(" ");
+            inefficientString += i + " ";
+        }
+        System.out.println(inefficientString);
+        System.out.println(stringBuilder.toString());
+        // inefficientString requires a lot more work to produce, as it generates a String on every loop iteration.
+        // Simple concatenation with + is compiled to a StringBuilder and toString()
+        // Avoid string concatenation in loops.
+
+        // #3 - with String formatter
+        // Another alternative way to create strings. Fast and readable.
+        String.format("%s may prefer %s.", "Or you", "String.format()");
+        // Output: Or you may prefer String.format().
+
         // Arrays
         // The array size must be decided upon instantiation
         // The following formats work for declaring an array
@@ -175,7 +265,7 @@ public class LearnJava {
         // Another way to declare & initialize an array
         int[] y = {9000, 1000, 1337};
         String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
-        boolean bools[] = new boolean[] {true, false, false};
+        boolean bools[] = {true, false, false};
 
         // Indexing an array - Accessing an element
         System.out.println("intArray @ 0: " + intArray[0]);
@@ -184,7 +274,7 @@ public class LearnJava {
         intArray[1] = 1;
         System.out.println("intArray @ 1: " + intArray[1]); // => 1
 
-        // Others to check out
+        // Other data types worth checking out
         // ArrayLists - Like arrays except more functionality is offered, and
         //              the size is mutable.
         // LinkedLists - Implementation of doubly-linked list. All of the
@@ -200,6 +290,9 @@ public class LearnJava {
         //            interface. This allows the execution time of basic
         //            operations, such as get and insert element, to remain
         //            constant even for large sets.
+        // TreeMap - This class is a sorted tree structure. It implements a red
+        //           black tree and sorts the entries based on the key value or
+        //           the comparator provided while creating the object
 
         ///////////////////////////////////////
         // Operators
@@ -212,7 +305,7 @@ public class LearnJava {
         System.out.println("1+2 = " + (i1 + i2)); // => 3
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
-        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns an int)
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int)
         System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
 
         // Modulo
@@ -242,7 +335,7 @@ public class LearnJava {
         |      Bitwise inclusive OR
         */
 
-        // Incrementations
+        // Increment operators
         int i = 0;
         System.out.println("\n->Inc/Dec-rementation");
         // The ++ and -- operators increment and decrement by 1 respectively.
@@ -295,7 +388,7 @@ public class LearnJava {
             // Iterated 10 times, fooFor 0->9
         }
         System.out.println("fooFor Value: " + fooFor);
-        
+
         // Nested For Loop Exit with Label
         outer:
         for (int i = 0; i < 10; i++) {
@@ -306,7 +399,7 @@ public class LearnJava {
             }
           }
         }
-        
+
         // For Each Loop
         // The for loop is also able to iterate over arrays as well as objects
         // that implement the Iterable interface.
@@ -314,7 +407,6 @@ public class LearnJava {
         // for each loop structure => for (<object> : <iterable>)
         // reads as: for each element in the iterable
         // note: the object type must match the element type of the iterable.
-
         for (int bar : fooList) {
             System.out.println(bar);
             //Iterates 9 times and prints 1-9 on new lines
@@ -325,6 +417,7 @@ public class LearnJava {
         // It also works with enumerated types (discussed in Enum Types), the
         // String class, and a few special classes that wrap primitive types:
         // Character, Byte, Short, and Integer.
+        // Starting in Java 7 and above, we can also use the String type.
         int month = 3;
         String monthString;
         switch (month) {
@@ -338,23 +431,31 @@ public class LearnJava {
                      break;
         }
         System.out.println("Switch Case Result: " + monthString);
-        
-        // Starting in Java 7 and above, switching Strings works like this:
-        String myAnswer = "maybe";
-        switch(myAnswer) {
-            case "yes":
-                System.out.println("You answered yes.");
-                break;
-            case "no":
-                System.out.println("You answered no.");
-                break;
-            case "maybe":
-                System.out.println("You answered maybe.");
-                break;
-            default:
-                System.out.println("You answered " + myAnswer);
-                break;
+
+
+        // Try-with-resources (Java 7+)
+        // Try-catch-finally statements work as expected in Java but in Java 7+
+        // the try-with-resources statement is also available. Try-with-resources
+        // simplifies try-catch-finally statements by closing resources
+        // automatically.
+
+        // In order to use a try-with-resources, include an instance of a class
+        // in the try statement. The class must implement java.lang.AutoCloseable.
+        try (BufferedReader br = new BufferedReader(new FileReader("foo.txt"))) {
+            // You can attempt to do something that could throw an exception.
+            System.out.println(br.readLine());
+            // In Java 7, the resource will always be closed, even if it throws
+            // an Exception.
+        } catch (Exception ex) {
+            //The resource will be closed before the catch statement executes.
+            System.out.println("readLine() failed.");
         }
+        // No need for a finally statement in this case, the BufferedReader is
+        // already closed. This can be used to avoid certain edge cases where
+        // a finally statement might not be called.
+        // To learn more:
+        // https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
+
 
         // Conditional Shorthand
         // You can use the '?' operator for quick assignments or logic forks.
@@ -362,11 +463,14 @@ public class LearnJava {
         // <second value>"
         int foo = 5;
         String bar = (foo < 10) ? "A" : "B";
-        System.out.println(bar); // Prints A, because the statement is true
-
+        System.out.println("bar : " + bar); // Prints "bar : A", because the 
+        // statement is true.
+        // Or simply
+        System.out.println("bar : " + (foo < 10 ? "A" : "B"));
+        
 
         ////////////////////////////////////////
-        // Converting Data Types And Typecasting
+        // Converting Data Types
         ////////////////////////////////////////
 
         // Converting data
@@ -382,12 +486,6 @@ public class LearnJava {
         // Long
         // String
 
-        // Typecasting
-        // You can also cast Java objects, there's a lot of details and deals
-        // with some more intermediate concepts. Feel free to check it out here:
-        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
-
-
         ///////////////////////////////////////
         // Classes And Functions
         ///////////////////////////////////////
@@ -409,18 +507,16 @@ public class LearnJava {
         // Double Brace Initialization
         // The Java Language has no syntax for how to create static Collections
         // in an easy way. Usually you end up in the following way:
-
         private static final Set<String> COUNTRIES = new HashSet<String>();
         static {
-           validCodes.add("DENMARK");
-           validCodes.add("SWEDEN");
-           validCodes.add("FINLAND");
+           COUNTRIES.add("DENMARK");
+           COUNTRIES.add("SWEDEN");
+           COUNTRIES.add("FINLAND");
         }
 
         // But there's a nifty way to achieve the same thing in an
         // easier way, by using something that is called Double Brace
         // Initialization.
-
         private static final Set<String> COUNTRIES = new HashSet<String>() {{
             add("DENMARK");
             add("SWEDEN");
@@ -436,10 +532,8 @@ public class LearnJava {
     } // End main method
 } // End LearnJava class
 
-
 // You can include other, non-public outer-level classes in a .java file,
-// but it is good practice. Instead split classes into separate files.
-
+// but it is not good practice. Instead split classes into separate files.
 
 // Class Declaration Syntax:
 // <public/private/protected> class <class name> {
@@ -454,13 +548,12 @@ class Bicycle {
     private int speed;  // Private: Only accessible from within the class
     protected int gear; // Protected: Accessible from the class and subclasses
     String name; // default: Only accessible from within this package
-
     static String className; // Static class variable
 
-    // Static block 
+    // Static block
     // Java has no implementation of static constructors, but
-    // has a static block that can be used to initialize class variables 
-    // (static variables). 
+    // has a static block that can be used to initialize class variables
+    // (static variables).
     // This block will be called when the class is loaded.
     static {
         className = "Bicycle";
@@ -476,7 +569,6 @@ class Bicycle {
         speed = 5;
         name = "Bontrager";
     }
-
     // This is a constructor that takes arguments
     public Bicycle(int startCadence, int startSpeed, int startGear,
         String name) {
@@ -501,23 +593,18 @@ class Bicycle {
     public void setCadence(int newValue) {
         cadence = newValue;
     }
-
     public void setGear(int newValue) {
         gear = newValue;
     }
-
     public void speedUp(int increment) {
         speed += increment;
     }
-
     public void slowDown(int decrement) {
         speed -= decrement;
     }
-
     public void setName(String newName) {
         name = newName;
     }
-
     public String getName() {
         return name;
     }
@@ -545,10 +632,18 @@ class PennyFarthing extends Bicycle {
     // out: http://docs.oracle.com/javase/tutorial/java/annotations/
     @Override
     public void setGear(int gear) {
-        gear = 0;
+        this.gear = 0;
     }
 }
 
+// Object casting
+// Since the PennyFarthing class is extending the Bicycle class, we can say
+// a PennyFarthing is a Bicycle and write :
+// Bicycle bicycle = new PennyFarthing();
+// This is called object casting where an object is taken for another one. There
+// are lots of details and deals with some more intermediate concepts here:
+// https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
 // Interfaces
 // Interface declaration syntax
 // <access-level> interface <interface-name> extends <super-interfaces> {
@@ -564,12 +659,14 @@ public interface Edible {
 
 public interface Digestible {
     public void digest();
+    // Since Java 8, interfaces can have default method.
+    public void defaultMethod() {
+        System.out.println("Hi from default method ...");
+    }
 }
 
-
 // We can now create a class that implements both of these interfaces.
 public class Fruit implements Edible, Digestible {
-  
     @Override
     public void eat() {
         // ...
@@ -585,7 +682,6 @@ public class Fruit implements Edible, Digestible {
 // interfaces. For example:
 public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     InterfaceTwo {
-
     @Override
     public void InterfaceOneMethod() {
     }
@@ -599,19 +695,19 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 // Abstract Classes
 
 // Abstract Class declaration syntax
-// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
+// <access-level> abstract class <abstract-class-name> extends
+// <super-abstract-classes> {
 //     // Constants and variables
 //     // Method declarations
 // }
 
-// Marking a class as abstract means that it contains abstract methods that must
-// be defined in a child class. Similar to interfaces, abstract classes cannot
-// be instantiated, but instead must be extended and the abstract methods
-// defined. Different from interfaces, abstract classes can contain a mixture of
-// concrete and abstract methods. Methods in an interface cannot have a body,
-// unless the method is static, and variables are final by default, unlike an
-// abstract class. Also abstract classes CAN have the "main" method.
-
+// Marking a class as abstract means that it contains at least one abstract
+// method that must be defined in a child class. Similar to interfaces, abstract
+// classes cannot be instantiated, but instead must be extended and the abstract
+// methods defined. Different from interfaces, abstract classes can contain a
+// mixture of concrete and abstract methods. Methods in an interface cannot
+// have a body, unless the method is static, and variables are final by default,
+// unlike an abstract class. Also abstract classes CAN have the "main" method.
 public abstract class Animal
 {
     public abstract void makeSound();
@@ -619,7 +715,7 @@ public abstract class Animal
     // Method can have a body
     public void eat()
     {
-        System.out.println("I am an animal and I am Eating.");  
+        System.out.println("I am an animal and I am Eating.");
         // Note: We can access private variable here.
         age = 30;
     }
@@ -627,11 +723,11 @@ public abstract class Animal
     // No need to initialize, however in an interface
     // a variable is implicitly final and hence has
     // to be initialized.
-    protected int age;
+    private int age;
 
     public void printAge()
     {
-        System.out.println(age);  
+        System.out.println(age);
     }
 
     // Abstract classes can have main function.
@@ -649,14 +745,14 @@ class Dog extends Animal
     public void makeSound()
     {
         System.out.println("Bark");
-        // age = 30;	==> ERROR!	age is private to Animal
+        // age = 30;    ==> ERROR!    age is private to Animal
     }
 
     // NOTE: You will get an error if you used the
     // @Override annotation here, since java doesn't allow
     // overriding of static methods.
     // What is happening here is called METHOD HIDING.
-    // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
+    // Check out this SO post: http://stackoverflow.com/questions/16313649/
     public static void main(String[] args)
     {
         Dog pluto = new Dog();
@@ -695,61 +791,54 @@ public abstract class Mammal()
     // Final Method Syntax:
     // <access modifier> final <return type> <function name>(<args>)
 
-    // Final methods, like, final classes cannot be overridden by a child class,
-    // and are therefore the final implementation of the method.
+    // Final methods, like, final classes cannot be overridden by a child
+    // class, and are therefore the final implementation of the method.
     public final boolean isWarmBlooded()
     {
         return true;
     }
 }
 
-
 // Enum Type
 //
 // An enum type is a special data type that enables for a variable to be a set
-// of predefined constants. The variable must be equal to one of the values that
-// have been predefined for it. Because they are constants, the names of an enum
-// type's fields are in uppercase letters. In the Java programming language, you
-// define an enum type by using the enum keyword. For example, you would specify
-// a days-of-the-week enum type as:
-
+// of predefined constants. The variable must be equal to one of the values
+// that have been predefined for it. Because they are constants, the names of
+// an enum type's fields are in uppercase letters. In the Java programming
+// language, you define an enum type by using the enum keyword. For example,
+// you would specify a days-of-the-week enum type as:
 public enum Day {
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
-    THURSDAY, FRIDAY, SATURDAY 
+    THURSDAY, FRIDAY, SATURDAY
 }
 
 // We can use our enum Day like that:
-
 public class EnumTest {
-    
     // Variable Enum
     Day day;
-    
+
     public EnumTest(Day day) {
         this.day = day;
     }
-    
+
     public void tellItLikeItIs() {
         switch (day) {
             case MONDAY:
                 System.out.println("Mondays are bad.");
                 break;
-                    
             case FRIDAY:
                 System.out.println("Fridays are better.");
                 break;
-                         
-            case SATURDAY: 
+            case SATURDAY:
             case SUNDAY:
                 System.out.println("Weekends are best.");
                 break;
-                        
             default:
                 System.out.println("Midweek days are so-so.");
                 break;
         }
     }
-    
+
     public static void main(String[] args) {
         EnumTest firstDay = new EnumTest(Day.MONDAY);
         firstDay.tellItLikeItIs(); // => Mondays are bad.
@@ -758,9 +847,9 @@ public class EnumTest {
     }
 }
 
-// Enum types are much more powerful than we show above. 
+// Enum types are much more powerful than we show above.
 // The enum body can include methods and other fields.
-// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+// You can see more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
 
 ```
 
@@ -770,22 +859,26 @@ The links provided here below are just to get an understanding of the topic, fee
 
 **Official Oracle Guides**:
 
-* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+* [Java Tutorial Trail from Sun / Oracle](https://docs.oracle.com/javase/tutorial/index.html)
 
-* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+* [Java Access level modifiers](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
 
-* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
-    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
-    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
-    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+* [Object-Oriented Programming Concepts](https://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
 
-* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+* [Exceptions](https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
 
-* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+* [Interfaces](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
 
-* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+* [Generics](https://docs.oracle.com/javase/tutorial/java/generics/index.html)
 
-* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+* [Java Code Conventions](https://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+* New features in Java 8:
+    * [Lambda expressions (functional programming)](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
+    * [Date and time API (java.time package)](http://www.oracle.com/technetwork/articles/java/jf14-date-time-2125367.html)
 
 **Online Practice and Tutorials**
 
@@ -793,13 +886,12 @@ The links provided here below are just to get an understanding of the topic, fee
 
 * [Codingbat.com](http://codingbat.com/java)
 
-
 **Books**:
 
 * [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
 
 * [Thinking in Java](http://www.mindview.net/Books/TIJ/)
 
-* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+* [Objects First with Java](https://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
 
-* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
+* [Java The Complete Reference](https://www.amazon.com/gp/product/0071606300)
diff --git a/javascript.html.markdown b/javascript.html.markdown
index 98261334..85c8a52d 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -225,31 +225,28 @@ do {
 } while (!isValid(input))
 
 // The `for` loop is the same as C and Java:
-// initialisation; continue condition; iteration.
+// initialization; continue condition; iteration.
 for (var i = 0; i < 5; i++){
     // will run 5 times
 }
 
-// The for/in statement iterates over every property across the entire prototype chain.
-var description = "";
-var person = {fname:"Paul", lname:"Ken", age:18};
-for (var x in person){
-    description += person[x] + " ";
+// Breaking out of labeled loops is similar to Java
+outer:
+for (var i = 0; i < 10; i++) {
+    for (var j = 0; j < 10; j++) {
+        if (i == 5 && j ==5) {
+            break outer;
+            // breaks out of outer loop instead of only the inner one
+        }
+    }
 }
 
-// To only consider properties attached to the object itself
-// and not its prototypes, use the `hasOwnProperty()` check.
+// The for/in statement allows iteration over properties of an object.
 var description = "";
 var person = {fname:"Paul", lname:"Ken", age:18};
 for (var x in person){
-    if (person.hasOwnProperty(x)){
-        description += person[x] + " ";
-    }
-}
-
-// For/in should not be used to iterate over an Array where the index order
-// is important, as there is no guarantee that for/in will return the indexes
-// in any particular order.
+    description += person[x] + " ";
+} // description = 'Paul Ken 18 '
 
 // && is logical and, || is logical or
 if (house.size == "big" && house.colour == "blue"){
@@ -262,7 +259,6 @@ if (colour == "red" || colour == "blue"){
 // && and || "short circuit", which is useful for setting default values.
 var name = otherName || "default";
 
-
 // The `switch` statement checks for equality with `===`.
 // Use 'break' after each case
 // or the cases after the correct one will be executed too.
@@ -438,6 +434,10 @@ var MyConstructor = function(){
 myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
+// Unlike most other popular object-oriented languages, JavaScript has no 
+// concept of 'instances' created from 'class' blueprints; instead, JavaScript
+// combines instantiation and inheritance into a single concept: a 'prototype'.
+
 // Every JavaScript object has a 'prototype'. When you go to access a property
 // on an object that doesn't exist on the actual object, the interpreter will
 // look at its prototype.
@@ -474,6 +474,26 @@ myObj.myBoolean; // = true
 myPrototype.meaningOfLife = 43;
 myObj.meaningOfLife; // = 43
 
+// The for/in statement allows iteration over properties of an object,
+// walking up the prototype chain until it sees a null prototype.
+for (var x in myObj){
+    console.log(myObj[x]);
+}
+///prints:
+// Hello world!
+// 43
+// [Function: myFunc]
+
+// To only consider properties attached to the object itself
+// and not its prototypes, use the `hasOwnProperty()` check.
+for (var x in myObj){
+    if (myObj.hasOwnProperty(x)){
+        console.log(myObj[x]);
+    }
+}
+///prints:
+// Hello world!
+
 // We mentioned that `__proto__` was non-standard, and there's no standard way to
 // change the prototype of an existing object. However, there are two ways to
 // create a new object with a given prototype.
@@ -559,12 +579,15 @@ of the language.
 
 [JavaScript: The Definitive Guide][6] is a classic guide and reference book.
 
-[Eloquent Javascript][8] by Marijn Haverbeke is an excellent JS book/ebook with attached terminal
-
-[Eloquent Javascript - The Annotated Version][9] by Gordon Zhu is also a great derivative of Eloquent Javascript with extra explanations and clarifications for some of the more complicated examples.
+[Eloquent Javascript][8] by Marijn Haverbeke is an excellent JS book/ebook with
+attached terminal
 
-[Javascript: The Right Way][10] is a guide intended to introduce new developers to JavaScript and help experienced developers learn more about its best practices.
+[Eloquent Javascript - The Annotated Version][9] by Gordon Zhu is also a great
+derivative of Eloquent Javascript with extra explanations and clarifications for
+some of the more complicated examples.
 
+[Javascript: The Right Way][10] is a guide intended to introduce new developers
+to JavaScript and help experienced developers learn more about its best practices.
 
 In addition to direct contributors to this article, some content is adapted from
 Louie Dinh's Python tutorial on this site, and the [JS Tutorial][7] on the
diff --git a/jquery.html.markdown b/jquery.html.markdown
new file mode 100644
index 00000000..9326c74b
--- /dev/null
+++ b/jquery.html.markdown
@@ -0,0 +1,128 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+filename: jquery.js
+---
+
+jQuery is a JavaScript library that helps you "do more, write less". It makes many common JavaScript tasks and makes them easier to write. jQuery is used by many big companies and developers everywhere. It makes AJAX, event handling, document manipulation, and much more, easier and faster.
+
+Because jQuery is a JavaScript library you should [learn JavaScript first](https://learnxinyminutes.com/docs/javascript/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Selectors
+
+// Selectors in jQuery are used to select an element
+var page = $(window); // Selects the whole viewport
+
+// Selectors can also be CSS selector
+var paragraph = $('p'); // Selects all paragraph elements
+var table1 = $('#table1'); // Selects element with id 'table1'
+var squares = $('.square'); // Selects all elements with the class 'square'
+var square_p = $('p.square') // Selects paragraphs with the 'square' class
+
+
+///////////////////////////////////
+// 2. Events and Effects
+// jQuery is very good at handling what happens when an event is triggered
+// A very common event used is the ready event on the document
+// You can use the 'ready' method to wait until the element has finished loading
+$(document).ready(function(){
+  // Code won't execute until the document is loaded
+});
+// You can also use defined functions
+function onAction() {
+  // This is executed when the event is triggered
+}
+$('#btn').click(onAction); // Invokes onAction on click
+
+// Some other common events are:
+$('#btn').dblclick(onAction); // Double click
+$('#btn').hover(onAction); // Hovering over
+$('#btn').focus(onAction); // On focus
+$('#btn').blur(onAction); // Losses focus
+$('#btn').submit(onAction); // On submit
+$('#btn').select(onAction); // When an element is selected
+$('#btn').keydown(onAction); // When a key is pushed down
+$('#btn').keyup(onAction); // When a key is released
+$('#btn').keypress(onAction); // When a key is pressed
+$('#btn').mousemove(onAction); // When the mouse is moved
+$('#btn').mouseenter(onAction); // Mouse enters the element
+$('#btn').mouseleave(onAction); // Mouse leaves the element
+
+
+// These can all also trigger the event instead of handling it
+// by simply not giving any parameters
+$('#btn').dblclick(); // Fires double click on the element
+
+// You can handle multiple events while only using the selector once
+$('#btn').on(
+  {dblclick: myFunction1} // Triggered on double click
+  {blur: myFunction1} // Triggered on blur
+);
+
+// You can move and hide elements with some effect methods
+$('.table').hide(); // Hides the element(s)
+
+// Note: calling a function in these methods will still hide the element
+$('.table').hide(function(){
+    // Element hidden then function executed
+});
+
+// You can store selectors in variables
+var tables = $('.table');
+
+// Some basic document manipulation methods are:
+tables.hide(); // Hides element(s)
+tables.show(); // Shows (un-hides) element(s)
+tables.toggle(); // Changes the hide/show state
+tables.fadeOut(); // Fades out
+tables.fadeIn(); // Fades in
+tables.fadeToggle(); // Fades in or out
+tables.fadeTo(0.5); // Fades to an opacity (between 0 and 1)
+tables.slideUp(); // Slides up
+tables.slideDown(); // Slides down
+tables.slideToggle(); // Slides up or down
+
+// All of the above take a speed (milliseconds) and callback function
+tables.hide(1000, myFunction); // 1 second hide animation then function
+
+// fadeTo has a required opacity as its second parameter
+tables.fadeTo(2000, 0.1, myFunction); // 2 sec. fade to 0.1 opacity then function
+
+// You can get slightly more advanced with the animate method
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// The animate method takes an object of css and values to end with,
+// optional options parameter to tune the animation,
+// and of course the callback function
+
+///////////////////////////////////
+// 3. Manipulation
+
+// These are similar to effects but can do more
+$('div').addClass('taming-slim-20'); // Adds class taming-slim-20 to all div 
+
+// Common manipulation methods
+$('p').append('Hello world'); // Adds to end of element
+$('p').attr('class'); // Gets attribute
+$('p').attr('class', 'content'); // Sets attribute
+$('p').hasClass('taming-slim-20'); // Returns true if it has the class
+$('p').height(); // Gets height of element or sets height
+
+
+// For many manipulation methods, getting info on an element
+// will ONLY get the first matching element
+$('p').height(); // Gets only the first 'p' tag's height
+
+// You can use each to loop through all the elements
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Adds all 'p' tag heights to array
+});
+
+
+```
diff --git a/julia.html.markdown b/julia.html.markdown
index 2810555e..85033aa6 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -9,7 +9,7 @@ filename: learnjulia.jl
 Julia is a new homoiconic functional language focused on technical computing.
 While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
 
-This is based on Julia 0.3.
+This is based on Julia 0.4.
 
 ```ruby
 
@@ -23,7 +23,7 @@ This is based on Julia 0.3.
 ## 1. Primitive Datatypes and Operators
 ####################################################
 
-# Everything in Julia is a expression.
+# Everything in Julia is an expression.
 
 # There are several basic types of numbers.
 3 # => 3 (Int64)
@@ -155,7 +155,7 @@ b = [4; 5; 6] # => 3-element Int64 Array: [4, 5, 6]
 b[1] # => 4
 b[end] # => 6
 
-# 2-dimentional arrays use space-separated values and semicolon-separated rows.
+# 2-dimensional arrays use space-separated values and semicolon-separated rows.
 matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
 
 # Arrays of a particular Type
@@ -255,7 +255,7 @@ e, d = d, e  # => (5,4) # d is now 5 and e is now 4
 empty_dict = Dict() # => Dict{Any,Any}()
 
 # You can create a dictionary using a literal
-filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+filled_dict = Dict("one"=> 1, "two"=> 2, "three"=> 3)
 # => Dict{ASCIIString,Int64}
 
 # Look up values with []
@@ -272,8 +272,8 @@ values(filled_dict)
 # Note - Same as above regarding key ordering.
 
 # Check for existence of keys in a dictionary with in, haskey
-in(("one", 1), filled_dict) # => true
-in(("two", 3), filled_dict) # => false
+in(("one" => 1), filled_dict) # => true
+in(("two" => 3), filled_dict) # => false
 haskey(filled_dict, "one") # => true
 haskey(filled_dict, 1) # => false
 
@@ -292,7 +292,7 @@ get(filled_dict,"four",4) # => 4
 # Use Sets to represent collections of unordered, unique values
 empty_set = Set() # => Set{Any}()
 # Initialize a set with values
-filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+filled_set = Set([1,2,2,3,4]) # => Set{Int64}(1,2,3,4)
 
 # Add more values to a set
 push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
@@ -302,10 +302,10 @@ in(2, filled_set) # => true
 in(10, filled_set) # => false
 
 # There are functions for set intersection, union, and difference.
-other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+other_set = Set([3, 4, 5, 6]) # => Set{Int64}(6,4,5,3)
 intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
 union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
-setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+setdiff(Set([1,2,3,4]),Set([2,3,5])) # => Set{Int64}(1,4)
 
 
 ####################################################
@@ -346,7 +346,7 @@ end
 #    cat is a mammal
 #    mouse is a mammal
 
-for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+for a in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
     println("$(a[1]) is a $(a[2])")
 end
 # prints:
@@ -354,7 +354,7 @@ end
 #    cat is a mammal
 #    mouse is a mammal
 
-for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+for (k,v) in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
     println("$k is a $v")
 end
 # prints:
@@ -420,14 +420,12 @@ varargs(1,2,3) # => (1,2,3)
 
 # The ... is called a splat.
 # We just used it in a function definition.
-# It can also be used in a fuction call,
+# It can also be used in a function call,
 # where it will splat an Array or Tuple's contents into the argument list.
-Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays
-Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3)
+add([5,6]...) # this is equivalent to add(5,6)
 
-x = (1,2,3)     # => (1,2,3)
-Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples
-Set(x...)       # => Set{Int64}(2,3,1)
+x = (5,6)     # => (5,6)
+add(x...)     # this is equivalent to add(5,6)
 
 
 # You can define functions with optional positional arguments
@@ -447,7 +445,7 @@ end
 
 # You can define functions that take keyword arguments
 function keyword_args(;k1=4,name2="hello") # note the ;
-    return ["k1"=>k1,"name2"=>name2]
+    return Dict("k1"=>k1,"name2"=>name2)
 end
 
 keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
@@ -549,12 +547,8 @@ abstract Cat # just a name and point in the type hierarchy
 
 # Abstract types cannot be instantiated, but can have subtypes.
 # For example, Number is an abstract type
-subtypes(Number) # => 6-element Array{Any,1}:
-                 #     Complex{Float16}
-                 #     Complex{Float32}
-                 #     Complex{Float64}
+subtypes(Number) # => 2-element Array{Any,1}:
                  #     Complex{T<:Real}
-                 #     ImaginaryUnit
                  #     Real
 subtypes(Cat) # => 0-element Array{Any,1}
 
@@ -572,10 +566,11 @@ subtypes(AbstractString)    # 8-element Array{Any,1}:
 # Every type has a super type; use the `super` function to get it.
 typeof(5) # => Int64
 super(Int64) # => Signed
-super(Signed) # => Real
+super(Signed) # => Integer
+super(Integer) # => Real
 super(Real) # => Number
 super(Number) # => Any
-super(super(Signed)) # => Number
+super(super(Signed)) # => Real
 super(Any) # => Any
 # All of these type, except for Int64, are abstract.
 typeof("fire") # => ASCIIString
@@ -778,6 +773,6 @@ code_native(circle_area, (Float64,))
 
 ## Further Reading
 
-You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
+You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/#Manual-1)
 
-The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users).
+The best place to get help with Julia is the (very friendly) [Discourse forum](https://discourse.julialang.org/).
diff --git a/kdb+.html.markdown b/kdb+.html.markdown
new file mode 100644
index 00000000..099d1529
--- /dev/null
+++ b/kdb+.html.markdown
@@ -0,0 +1,776 @@
+---
+language: kdb+
+contributors:
+    - ["Matt Doherty", "https://github.com/picodoc"]
+    - ["Jonny Press", "https://github.com/jonnypress"]
+filename: learnkdb.q
+---
+
+The q langauge and its database component kdb+ were developed by Arthur Whitney
+and released by Kx systems in 2003. q is a descendant of APL and as such is
+very terse and a little strange looking for anyone from a "C heritage" language
+background. Its expressiveness and vector oriented nature make it well suited
+to performing complex calculations on large amounts of data (while also
+encouraging some amount of [code
+golf](https://en.wikipedia.org/wiki/Code_golf)). The fundamental structure in
+the language is not the object but instead the list, and tables are built as
+collections of lists. This means - unlike most traditional RDBMS systems -
+tables are column oriented.  The language has both an in-memory and on-disk
+database built in, giving a large amount of flexibility. kdb+ is most widely
+used in the world of finance to store, analyze, process and retrieve large
+time-series data sets.
+
+The terms *q* and *kdb+* are usually used interchangeably, as the two are not
+separable so this distinction is not really useful.
+
+All Feedback welcome!  You can reach me at matt.doherty@aquaq.co.uk, or Jonny
+at jonny.press@aquaq.co.uk
+
+To learn more about kdb+ you can join the [Personal kdb+](https://groups.google.com/forum/#!forum/personal-kdbplus) or [TorQ kdb+](https://groups.google.com/forum/#!forum/kdbtorq) group.
+
+```
+/ Single line comments start with a forward-slash
+/ These can also be used in-line, so long as at least one whitespace character
+/ separates it from text to the left
+/
+  A forward-slash on a line by itself starts a multiline comment
+  and a backward-slash on a line by itself terminates it
+\
+
+/ Run this file in an empty directory
+
+
+////////////////////////////////////
+// Basic Operators and Datatypes  //
+////////////////////////////////////
+
+/ We have integers, which are 8 byte by default
+3 / => 3
+
+/ And floats, also 8 byte as standard.  Trailing f distinguishes from int
+3.0 / => 3f
+
+/ 4 byte numerical types can also be specified with trailing chars
+3i / => 3i
+3.0e / => 3e
+
+/ Math is mostly what you would expect
+1+1 / => 2
+8-1 / => 7
+10*2 / => 20
+/ Except division, which uses percent (%) instead of forward-slash (/)
+35%5 / => 7f  (the result of division is always a float)
+
+/ For integer division we have the keyword div
+4 div 3 / => 1
+
+/ Modulo also uses a keyword, since percent (%) is taken
+4 mod 3 / => 1
+
+/ And exponentiation...
+2 xexp 4 / => 16
+
+/ ...and truncating...
+floor 3.14159 / => 3
+
+/ ...getting the absolute value...
+abs -3.14159 / => 3.14159
+/ ...and many other things
+/ see http://code.kx.com/wiki/Reference for more
+
+/ q has no operator precedence, everything is evaluated right to left
+/ so results like this might take some getting used to
+2*1+1 / => 4 / (no operator precedence tables to remember!)
+
+/ Precedence can be modified with parentheses (restoring the 'normal' result)
+(2*1)+1 / => 3
+
+/ Assignment uses colon (:) instead of equals (=)
+/ No need to declare variables before assignment
+a:3
+a / => 3
+
+/ Variables can also be assigned in-line
+/ this does not affect the value passed on
+c:3+b:2+a:1 / (data "flows" from right to left)
+a / => 1
+b / => 3
+c / => 6
+
+/ In-place operations are also as you might expect
+a+:2
+a / => 3
+
+/ There are no "true" or "false" keywords in q
+/ boolean values are indicated by the bit value followed by b
+1b / => true value
+0b / => false value
+
+/ Equality comparisons use equals (=) (since we don't need it for assignment)
+1=1 / => 1b
+2=1 / => 0b
+
+/ Inequality uses <>
+1<>1 / => 0b
+2<>1 / => 1b
+
+/ The other comparisons are as you might expect
+1<2 / => 1b
+1>2 / => 0b
+2<=2 / => 1b
+2>=2 / => 1b
+
+/ Comparison is not strict with regard to types...
+42=42.0 / => 1b
+
+/ ...unless we use the match operator (~)
+/ which only returns true if entities are identical
+42~42.0 / => 0b
+
+/ The not operator returns true if the underlying value is zero
+not 0b / => 1b
+not 1b / => 0b
+not 42 / => 0b
+not 0.0 / => 1b
+
+/ The max operator (|) reduces to logical "or" for bools
+42|2.0 / => 42f
+1b|0b / => 1b
+
+/ The min operator (&) reduces to logical "and" for bools
+42&2.0 / => 2f
+1b&0b / => 0b
+
+/ q provides two ways to store character data
+/ Chars in q are stored in a single byte and use double-quotes (")
+ch:"a"
+/ Strings are simply lists of char (more on lists later)
+str:"This is a string"
+/ Escape characters work as normal
+str:"This is a string with \"quotes\""
+
+/ Char data can also be stored as symbols using backtick (`)
+symbol:`sym
+/ Symbols are NOT LISTS, they are an enumeration
+/ the q process stores internally a vector of strings
+/ symbols are enumerated against this vector
+/ this can be more space and speed efficient as these are constant width
+
+/ The string function converts to strings
+string `symbol / => "symbol"
+string 1.2345 / => "1.2345"
+
+/ q has a time type...
+t:01:00:00.000
+/ date type...
+d:2015.12.25
+/ and a datetime type (among other time types)
+dt:2015.12.25D12:00:00.000000000
+
+/ These support some arithmetic for easy manipulation
+dt + t / => 2015.12.25D13:00:00.000000000
+t - 00:10:00.000 / => 00:50:00.000
+/ and can be decomposed using dot notation
+d.year / => 2015i
+d.mm / => 12i
+d.dd / => 25i
+/ see http://code.kx.com/wiki/JB:QforMortals2/atoms#Temporal_Data for more
+
+/ q also has an infinity value so div by zero will not throw an error
+1%0 / => 0w
+-1%0 / => -0w
+
+/ And null types for representing missing values
+0N / => null int
+0n / => null float
+/ see http://code.kx.com/wiki/JB:QforMortals2/atoms#Null_Values for more
+
+/ q has standard control structures
+/ if is as you might expect (; separates the condition and instructions)
+if[1=1;a:"hi"]
+a / => "hi"
+/ if-else uses $ (and unlike if, returns a value)
+$[1=0;a:"hi";a:"bye"] / => "bye"
+a / => "bye"
+/ if-else can be extended to multiple clauses by adding args separated by ;
+$[1=0;a:"hi";0=1;a:"bye";a:"hello again"]
+a / => "hello again"
+
+
+////////////////////////////////////
+////      Data Structures       ////
+////////////////////////////////////
+
+/ q is not an object oriented language
+/ instead complexity is built through ordered lists
+/ and mapping them into higher order structures: dictionaries and tables
+
+/ Lists (or arrays if you prefer) are simple ordered collections
+/ they are defined using parentheses () and semi-colons (;)
+(1;2;3) / => 1 2 3
+(-10.0;3.14159e;1b;`abc;"c")
+/ => -10f
+/ => 3.14159e
+/ => 1b
+/ => `abc
+/ => "c"  (mixed type lists are displayed on multiple lines)
+((1;2;3);(4;5;6);(7;8;9))
+/ => 1 2 3
+/ => 4 5 6
+/ => 7 8 9
+
+/ Lists of uniform type can also be defined more concisely
+1 2 3 / => 1 2 3
+`list`of`syms / => `list`of`syms
+`list`of`syms ~ (`list;`of;`syms) / => 1b
+
+/ List length
+count (1;2;3) / => 3
+count "I am a string" / => 13 (string are lists of char)
+
+/ Empty lists are defined with parentheses
+l:()
+count l / => 0
+
+/ Simple variables and single item lists are not equivalent
+/ parentheses syntax cannot create a single item list (they indicate precedence)
+(1)~1 / => 1b
+/ single item lists can be created using enlist
+singleton:enlist 1
+/ or appending to an empty list
+singleton:(),1
+1~(),1 / => 0b
+
+/ Speaking of appending, comma (,) is used for this, not plus (+)
+1 2 3,4 5 6 / => 1 2 3 4 5 6
+"hello ","there" / => "hello there"
+
+/ Indexing uses square brackets []
+l:1 2 3 4
+l[0] / => 1
+l[1] / => 2
+/ indexing out of bounds returns a null value rather than an error
+l[5] / => 0N
+/ and indexed assignment
+l[0]:5
+l / => 5 2 3 4
+
+/ Lists can also be used for indexing and indexed assignment
+l[1 3] / => 2 4
+l[1 3]: 1 3
+l / => 5 1 3 3
+
+/ Lists can be untyped/mixed type
+l:(1;2;`hi)
+/ but once they are uniformly typed, q will enforce this
+l[2]:3
+l / => 1 2 3
+l[2]:`hi / throws a type error
+/ this makes sense in the context of lists as table columns (more later)
+
+/ For a nested list we can index at depth
+l:((1;2;3);(4;5;6);(7;8;9))
+l[1;1] / => 5
+
+/ We can elide the indexes to return entire rows or columns
+l[;1] / => 2 5 8
+l[1;] / => 4 5 6
+
+/ All the functions mentioned in the previous section work on lists natively
+1+(1;2;3) / => 2 3 4 (single variable and list)
+(1;2;3) - (3;2;1) / => -2 0 2 (list and list)
+
+/ And there are many more that are designed specifically for lists
+avg 1 2 3 / => 2f
+sum 1 2 3 / => 6
+sums 1 2 3 / => 1 3 6 (running sum)
+last 1 2 3 / => 3
+1 rotate 1 2 3 / => 2 3 1
+/ etc.
+/ Using and combining these functions to manipulate lists is where much of the
+/ power and expressiveness of the language comes from
+
+/ Take (#), drop (_) and find (?) are also useful working with lists
+l:1 2 3 4 5 6 7 8 9
+l:1+til 9 / til is a useful shortcut for generating ranges
+/ take the first 5 elements
+5#l / => 1 2 3 4 5
+/ drop the first 5
+5_l / => 6 7 8 9
+/ take the last 5
+-5#l / => 5 6 7 8 9
+/ drop the last 5
+-5_l / => 1 2 3 4
+/ find the first occurance of 4
+l?4 / => 3
+l[3] / => 4
+
+/ Dictionaries in q are a generalization of lists
+/ they map a list to another list (of equal length)
+/ the bang (!) symbol is used for defining a dictionary
+d:(`a;`b;`c)!(1;2;3)
+/ or more simply with concise list syntax
+d:`a`b`c!1 2 3
+/ the keyword key returns the first list
+key d / => `a`b`c
+/ and value the second
+value d / => 1 2 3
+
+/ Indexing is indentical to lists
+/ with the first list as a key instead of the position
+d[`a] / => 1
+d[`b] / => 2
+
+/ As is assignment
+d[`c]:4
+d
+/ => a| 1
+/ => b| 2
+/ => c| 4
+
+/ Arithmetic and comparison work natively, just like lists
+e:(`a;`b;`c)!(2;3;4)
+d+e
+/ => a| 3
+/ => b| 5
+/ => c| 8
+d-2
+/ => a| -1
+/ => b| 0
+/ => c| 2
+d > (1;1;1)
+/ => a| 0
+/ => b| 1
+/ => c| 1
+
+/ And the take, drop and find operators are remarkably similar too
+`a`b#d
+/ => a| 1
+/ => b| 2
+`a`b _ d
+/ => c| 4
+d?2
+/ => `b
+
+/ Tables in q are basically a subset of dictionaries
+/ a table is a dictionary where all values must be lists of the same length
+/ as such tables in q are column oriented (unlike most RDBMS)
+/ the flip keyword is used to convert a dictionary to a table
+/ i.e. flip the indices
+flip `c1`c2`c3!(1 2 3;4 5 6;7 8 9)
+/ => c1 c2 c3
+/ => --------
+/ => 1  4  7
+/ => 2  5  8
+/ => 3  6  9
+/ we can also define tables using this syntax
+t:([]c1:1 2 3;c2:4 5 6;c3:7 8 9)
+t
+/ => c1 c2 c3
+/ => --------
+/ => 1  4  7
+/ => 2  5  8
+/ => 3  6  9
+
+/ Tables can be indexed and manipulated in a similar way to dicts and lists
+t[`c1]
+/ => 1 2 3
+/ table rows are returned as dictionaries
+t[1]
+/ => c1| 2
+/ => c2| 5
+/ => c3| 8
+
+/ meta returns table type information
+meta t
+/ => c | t f a
+/ => --| -----
+/ => c1| j
+/ => c2| j
+/ => c3| j
+/ now we see why type is enforced in lists (to protect column types)
+t[1;`c1]:3
+t[1;`c1]:3.0 / throws a type error
+
+/ Most traditional databases have primary key columns
+/ in q we have keyed tables, where one table containing key columns
+/ is mapped to another table using bang (!)
+k:([]id:1 2 3)
+k!t
+/ => id| c1 c2 c3
+/ => --| --------
+/ => 1 | 1  4  7
+/ => 2 | 3  5  8
+/ => 3 | 3  6  9
+
+/ We can also use this shortcut for defining keyed tables
+kt:([id:1 2 3]c1:1 2 3;c2:4 5 6;c3:7 8 9)
+
+/ Records can then be retreived based on this key
+kt[1]
+/ => c1| 1
+/ => c2| 4
+/ => c3| 7
+kt[`id!1]
+/ => c1| 1
+/ => c2| 4
+/ => c3| 7
+
+
+////////////////////////////////////
+////////     Functions      ////////
+////////////////////////////////////
+
+/ In q the function is similar to a mathematical map, mapping inputs to outputs
+/ curly braces {} are used for function definition
+/ and square brackets [] for calling functions (just like list indexing)
+/ a very minimal function
+f:{x+x}
+f[2] / => 4
+
+/ Functions can be annonymous and called at point of definition
+{x+x}[2] / => 4
+
+/ By default the last expression is returned
+/ colon (:) can be used to specify return
+{x+x}[2] / => 4
+{:x+x}[2] / => 4
+/ semi-colon (;) separates expressions
+{r:x+x;:r}[2] / => 4
+
+/ Function arguments can be specified explicitly (separated by ;)
+{[arg1;arg2] arg1+arg2}[1;2] / => 3
+/ or if ommited will default to x, y and z
+{x+y+z}[1;2;3] / => 6
+
+/ Built in functions are no different, and can be called the same way (with [])
++[1;2] / => 3
+<[1;2] / => 1b
+
+/ Functions are first class in q, so can be returned, stored in lists etc.
+{:{x+y}}[] / => {x+y}
+(1;"hi";{x+y})
+/ => 1
+/ => "hi"
+/ => {x+y}
+
+/ There is no overloading and no keyword arguments for custom q functions
+/ however using a dictionary as a single argument can overcome this
+/ allows for optional arguments or differing functionality
+d:`arg1`arg2`arg3!(1.0;2;"my function argument")
+{x[`arg1]+x[`arg2]}[d] / => 3f
+
+/ Functions in q see the global scope
+a:1
+{:a}[] / => 1
+
+/ However local scope obscures this
+a:1
+{a:2;:a}[] / => 2
+a / => 1
+
+/ Functions cannot see nested scopes (only local and global)
+{local:1;{:local}[]}[] / throws error as local is not defined in inner function
+
+/ A function can have one or more of it's arguments fixed (projection)
+f:+[4]
+f[4] / => 8
+f[5] / => 9
+f[6] / => 10
+
+
+////////////////////////////////////
+//////////     q-sql      //////////
+////////////////////////////////////
+
+/ q has it's own syntax for manipulating tables, similar to standard SQL
+/ This contains the usual suspects of select, insert, update etc.
+/ and some new functionality not typically available
+/ q-sql has two significant differences (other than syntax) to normal SQL:
+/ - q tables have well defined record orders
+/ - tables are stored as a collection of columns
+/   (so vectorized column operations are fast)
+/ a full description of q-sql is a little beyond the scope of this intro
+/ so we will just cover enough of the basics to get you going
+
+/ First define ourselves a table
+t:([]name:`Arthur`Thomas`Polly;age:35 32 52;height:180 175 160;sex:`m`m`f)
+
+/ equivalent of SELECT * FROM t
+select from t / (must be lower case, and the wildcard is not necessary)
+/ => name   age height sex
+/ => ---------------------
+/ => Arthur 35  180    m
+/ => Thomas 32  175    m
+/ => Polly  52  160    f
+
+/ Select specific columns
+select name,age from t
+/ => name   age
+/ => ----------
+/ => Arthur 35
+/ => Thomas 32
+/ => Polly  52
+
+/ And name them (equivalent of using AS in standard SQL)
+select charactername:name, currentage:age from t
+/ => charactername currentage
+/ => ------------------------
+/ => Arthur        35
+/ => Thomas        32
+/ => Polly         52
+
+/ This SQL syntax is integrated with the q language
+/ so q can be used seamlessly in SQL statements
+select name, feet:floor height*0.032, inches:12*(height*0.032) mod 1 from t
+/ => name   feet inches
+/ => ------------------
+/ => Arthur 5    9.12
+/ => Thomas 5    7.2
+/ => Polly  5    1.44
+
+/ Including custom functions
+select name, growth:{[h;a]h%a}[height;age] from t
+/ => name   growth
+/ => ---------------
+/ => Arthur 5.142857
+/ => Thomas 5.46875
+/ => Polly  3.076923
+
+/ The where clause can contain multiple statements separated by commas
+select from t where age>33,height>175
+/ => name   age height sex
+/ => ---------------------
+/ => Arthur 35  180    m
+
+/ The where statements are executed sequentially (not the same as logical AND)
+select from t where age<40,height=min height
+/ => name   age height sex
+/ => ---------------------
+/ => Thomas 32  175    m
+select from t where (age<40)&(height=min height)
+/ => name age height sex
+/ => -------------------
+
+/ The by clause falls between select and from
+/ and is equivalent to SQL's GROUP BY
+select avg height by sex from t
+/ => sex| height
+/ => ---| ------
+/ => f  | 160
+/ => m  | 177.5
+
+/ If no aggreation function is specified, last is assumed
+select by sex from t
+/ => sex| name   age height
+/ => ---| -----------------
+/ => f  | Polly  52  160
+/ => m  | Thomas 32  175
+
+/ Update has the same basic form as select
+update sex:`male from t where sex=`m
+/ => name   age height sex
+/ => ----------------------
+/ => Arthur 35  180    male
+/ => Thomas 32  175    male
+/ => Polly  52  160    f
+
+/ As does delete
+delete from t where sex=`m
+/ => name  age height sex
+/ => --------------------
+/ => Polly 52  160    f
+
+/ None of these sql operations are carried out in place
+t
+/ => name   age height sex
+/ => ---------------------
+/ => Arthur 35  180    m
+/ => Thomas 32  175    m
+/ => Polly  52  160    f
+
+/ Insert however is in place, it takes a table name, and new data
+`t insert (`John;25;178;`m) / => ,3
+t
+/ => name   age height sex
+/ => ---------------------
+/ => Arthur 35  180    m
+/ => Thomas 32  175    m
+/ => Polly  52  160    f
+/ => John   25  178    m
+
+/ Upsert is similar (but doesn't have to be in-place)
+t upsert (`Chester;58;179;`m)
+/ => name    age height sex
+/ => ----------------------
+/ => Arthur  35  180    m
+/ => Thomas  32  175    m
+/ => Polly   52  160    f
+/ => John    25  178    m
+/ => Chester 58  179    m
+
+/ it will also upsert dicts or tables
+t upsert `name`age`height`sex!(`Chester;58;179;`m)
+t upsert (`Chester;58;179;`m)
+/ => name    age height sex
+/ => ----------------------
+/ => Arthur  35  180    m
+/ => Thomas  32  175    m
+/ => Polly   52  160    f
+/ => John    25  178    m
+/ => Chester 58  179    m
+
+/ And if our table is keyed
+kt:`name xkey t
+/ upsert will replace records where required
+kt upsert ([]name:`Thomas`Chester;age:33 58;height:175 179;sex:`f`m)
+/ => name   | age height sex
+/ => -------| --------------
+/ => Arthur | 35  180    m
+/ => Thomas | 33  175    f
+/ => Polly  | 52  160    f
+/ => John   | 25  178    m
+/ => Chester| 58  179    m
+
+/ There is no ORDER BY clause in q-sql, instead use xasc/xdesc
+`name xasc t
+/ => name   age height sex
+/ => ---------------------
+/ => Arthur 35  180    m
+/ => John   25  178    m
+/ => Polly  52  160    f
+/ => Thomas 32  175    m
+
+/ Most of the standard SQL joins are present in q-sql, plus a few new friends
+/ see http://code.kx.com/wiki/JB:QforMortals2/queries_q_sql#Joins
+/ the two most important (commonly used) are lj and aj
+
+/ lj is basically the same as SQL LEFT JOIN
+/ where the join is carried out on the key columns of the left table
+le:([sex:`m`f]lifeexpectancy:78 85)
+t lj le
+/ => name   age height sex lifeexpectancy
+/ => ------------------------------------
+/ => Arthur 35  180    m   78
+/ => Thomas 32  175    m   78
+/ => Polly  52  160    f   85
+/ => John   25  178    m   78
+
+/ aj is an asof join.  This is not a standard SQL join, and can be very powerful
+/ The canonical example of this is joining financial trades and quotes tables
+trades:([]time:10:01:01 10:01:03 10:01:04;sym:`msft`ibm`ge;qty:100 200 150)
+quotes:([]time:10:01:00 10:01:01 10:01:01 10:01:03;
+          sym:`ibm`msft`msft`ibm; px:100 99 101 98)
+aj[`time`sym;trades;quotes]
+/ => time     sym  qty px
+/ => ---------------------
+/ => 10:01:01 msft 100 101
+/ => 10:01:03 ibm  200 98
+/ => 10:01:04 ge   150
+/ for each row in the trade table, the last (prevailing) quote (px) for that sym
+/ is joined on.
+/ see http://code.kx.com/wiki/JB:QforMortals2/queries_q_sql#Asof_Join
+
+////////////////////////////////////
+/////     Extra/Advanced      //////
+////////////////////////////////////
+
+////// Adverbs //////
+/ You may have noticed the total lack of loops to this point
+/ This is not a mistake!
+/ q is a vector language so explicit loops (for, while etc.) are not encouraged
+/ where possible functionality should be vectorized (i.e. operations on lists)
+/ adverbs supplement this, modifying the behaviour of functions
+/ and providing loop type functionality when required
+/ (in q functions are sometimes refered to as verbs, hence adverbs)
+/ the "each" adverb modifies a function to treat a list as individual variables
+first each (1 2 3;4 5 6;7 8 9)
+/ => 1 4 7
+
+/ each-left (\:) and each-right (/:) modify a two-argument function
+/ to treat one of the arguments and individual variables instead of a list
+1 2 3 +\: 1 2 3
+/ => 2 3 4
+/ => 3 4 5
+/ => 4 5 6
+1 2 3 +/: 1 2 3
+/ => 2 3 4
+/ => 3 4 5
+/ => 4 5 6
+
+/ The true alternatives to loops in q are the adverbs scan (\) and over (/)
+/ their behaviour differs based on the number of arguments the function they
+/ are modifying receives.  Here I'll summarise some of the most useful cases
+/ a single argument function modified by scan given 2 args behaves like "do"
+{x * 2}\[5;1] / => 1 2 4 8 16 32 (i.e. multiply by 2, 5 times)
+{x * 2}/[5;1] / => 32 (using over only the final result is shown)
+
+/ If the first argument is a function, we have the equivalent of "while"
+{x * 2}\[{x<100};1] / => 1 2 4 8 16 32 64 128 (iterates until returns 0b)
+{x * 2}/[{x<100};1] / => 128 (again returns only the final result)
+
+/ If the function takes two arguments, and we pass a list, we have "for"
+/ where the result of the previous execution is passed back into the next loop
+/ along with the next member of the list
+{x + y}\[1 2 3 4 5] / => 1 3 6 10 15 (i.e. the running sum)
+{x + y}/[1 2 3 4 5] / => 15 (only the final result)
+
+/ There are other adverbs and uses, this is only intended as quick overview
+/ http://code.kx.com/wiki/JB:QforMortals2/functions#Adverbs
+
+////// Scripts //////
+/ q scripts can be loaded from a q session using the "\l" command
+/ for example "\l learnkdb.q" will load this script
+/ or from the command prompt passing the script as an argument
+/ for example "q learnkdb.q"
+
+////// On-disk data //////
+/ Tables can be persisted to disk in several formats
+/ the two most fundamental are serialized and splayed
+t:([]a:1 2 3;b:1 2 3f)
+`:serialized set t / saves the table as a single serialized file
+`:splayed/ set t / saves the table splayed into a directory
+
+/ the dir structure will now look something like:
+/ db/
+/ ├── serialized
+/ └── splayed
+/     ├── a
+/     └── b
+
+/ Loading this directory (as if it was as script, see above)
+/ loads these tables into the q session
+\l .
+/ the serialized table will be loaded into memory
+/ however the splayed table will only be mapped, not loaded
+/ both tables can be queried using q-sql
+select from serialized
+/ => a b
+/ => ---
+/ => 1 1
+/ => 2 2
+/ => 3 3
+select from splayed / (the columns are read from disk on request)
+/ => a b
+/ => ---
+/ => 1 1
+/ => 2 2
+/ => 3 3
+/ see http://code.kx.com/wiki/JB:KdbplusForMortals/contents for more
+
+////// Frameworks //////
+/ kdb+ is typically used for data capture and analysis.
+/ This involves using an architecture with multiple processes
+/ working together.  kdb+ frameworks are available to streamline the setup
+/ and configuration of this architecuture and add additional functionality
+/ such as disaster recovery, logging, access, load balancing etc.
+/ https://github.com/AquaQAnalytics/TorQ
+```
+
+## Want to know more?
+
+* [*q for mortals* q language tutorial](http://code.kx.com/wiki/JB:QforMortals2/contents)
+* [*kdb for mortals* on disk data tutorial](http://code.kx.com/wiki/JB:KdbplusForMortals/contents)
+* [q language reference](http://code.kx.com/wiki/Reference)
+* [Online training courses](http://training.aquaq.co.uk/)
+* [TorQ production framework](https://github.com/AquaQAnalytics/TorQ)
diff --git a/ko-kr/bash-kr.html.markdown b/ko-kr/bash-kr.html.markdown
new file mode 100644
index 00000000..8e271d1f
--- /dev/null
+++ b/ko-kr/bash-kr.html.markdown
@@ -0,0 +1,382 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Etan Reisner", "https://github.com/deryni"]
+    - ["Jonathan Wang", "https://github.com/Jonathansw"]   
+    - ["Leo Rudberg", "https://github.com/LOZORD"]
+    - ["Betsy Lorton", "https://github.com/schbetsy"]
+    - ["John Detter", "https://github.com/jdetter"]
+translators:
+    - ["Wooseop Kim", "https://github.com/linterpreteur"]
+filename: LearnBash-kr.sh
+lang: ko-kr
+---
+
+Bash는 유닉스 셸의 이름이며, 리눅스와 맥 OS X의 기본 셸로 그리고 GNU 운영체제를 위한 셸로서 배포되었습니다.
+이하의 거의 모든 예시들은 셸 스크립트의 일부이거나 셸에서 바로 실행할 수 있습니다.
+
+[(영어) 이곳에서 더 알아보세요.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# 스크립트의 첫 줄은 시스템에게 스크립트의 실행법을 알려주는 '셔뱅'입니다.
+# https://ko.wikipedia.org/wiki/%EC%85%94%EB%B1%85
+# 이미 보았듯이 주석은 #으로 시작합니다. 셔뱅 또한 주석입니다.
+
+# 간단한 헬로 월드
+echo 헬로 월드!
+
+# 각각의 명령어는 개행 혹은 세미콜론 이후에 시작됩니다.
+echo '첫번째 줄'; echo '두번째 줄'
+
+# 변수 선언은 다음과 같습니다.
+Variable="어떤 문자열"
+
+# 하지만 다음은 틀린 형태입니다.
+Variable = "어떤 문자열"
+# Bash는 Variable이 실행해야 하는 명령어라고 판단할 것이고, 해당 명령어를 찾을
+# 수 없기 때문에 에러를 발생시킬 것입니다.
+
+# 다음도 같습니다.
+Variable= '어떤 문자열'
+# Bash는 '어떤 문자열'이 실행해야 하는 명령어라고 판단하여 에러를 발생시킬 것입니다.
+# (이 경우에 'Variable=' 부분은 '어떤 문자열' 명령어의 스코프에서만 유효한
+# 변수 할당으로 해석됩니다.)
+
+# 변수 사용은 다음과 같습니다.
+echo $Variable
+echo "$Variable"
+echo '$Variable'
+# 할당, 내보내기 등 변수 자체를 사용할 때에는 $ 없이 이름을 적습니다.
+# 변수의 값을 사용할 때에는 $를 사용해야 합니다.
+# 작은 따옴표는 변수를 확장시키지 않는다는 사실에 주의하세요.
+# (역자 주: '$Variable'은 변수 Variable의 값이 아닌 문자열 "$Variable"입니다.)
+
+# 인수 확장은 ${ }입니다.
+echo ${Variable}
+# 이는 인수 확장의 간단한 예시입니다.
+# 인수 확장은 변수로부터 값을 받아 그 값을 "확장"하거나 출력합니다.
+# 확장을 통해 인수나 그 값이 변경될 수 있습니다.
+# 이하는 확장에 대한 다른 예시들입니다.
+
+# 변수에서의 문자열 치환
+echo ${Variable/Some/A}
+# 처음으로 나타나는 "Some"를 "A"로 치환합니다.
+
+# 변수의 부분열
+Length=7
+echo ${Variable:0:Length}
+# 변수 값에서 처음 7개 문자만을 반환합니다.
+
+# 변수의 기본값
+echo ${Foo:-"Foo가_없거나_비어_있을_때의_기본값"}
+# null(Foo=) 값이나 빈 문자열(Foo="")일 경우에만 작동합니다. 0은 (Foo=0)은 0입니다.
+# 기본값을 반환할 뿐 변수 값을 변경하지는 않는다는 사실에 주목하세요.
+
+# 중괄호 확장 { }
+# 임의의 문자열을 생성합니다.
+echo {1..10}
+echo {a..z}
+# 시작 값으로부터 끝 값까지의 범위를 출력합니다.
+
+# 내장 변수
+# 유용한 내장 변수들이 있습니다.
+echo "마지막 프로그램의 반환값: $?"
+echo "스크립트의 PID: $$"
+echo "스크립트에 넘겨진 인자의 개수: $#"
+echo "스크립트에 넘겨진 모든 인자: $@"
+echo "각각 변수로 쪼개진 스크립트 인자: $1 $2..."
+
+# echo와 변수의 사용법을 알게 되었으니,
+# bash의 기초를 조금 더 배워봅시다!
+
+# 현재 디렉토리는 `pwd` 명령어로 알 수 있습니다.
+# `pwd`는 "print working directory(작업 디렉토리 출력)"의 약자입니다.
+# 내장 변수`$PWD`를 사용할 수도 있습니다.
+# 이하는 모두 동일합니다.
+echo "I'm in $(pwd)" # `pwd`를 실행하여 문자열에 보간
+echo "I'm in $PWD" # 변수를 보간
+
+# 터미널이나 결과의 출력물이 너무 많다면
+# 명령어 `clear`를 이용해 화면을 지울 수 있습니다.
+clear
+# 컨트롤+L 또한 화면을 지울 수 있습니다.
+
+# 입력 값 읽기
+echo "이름이 뭐에요?"
+read Name # 변수 선언이 필요 없다는 데 주목하세요.
+echo $Name님, 안녕하세요!
+
+# 평범한 if 구조도 있습니다.
+# 'man test'로 조건문에 대해 더 알아보세요.
+if [ $Name != $USER ]
+then
+    echo "사용자가 아닙니다."
+else
+    echo "사용자입니다."
+fi
+
+# $Name이 비어 있다면, bash는 위의 조건을 다음과 같이 인식합니다.
+if [ != $USER ]
+# 이는 문법적으로 유효하지 않습니다.
+# 따라서 bash에서 비어 있을 수 있는 변수를 "안전하게" 사용하는 법은 다음과 같습니다.
+if [ "$Name" != $USER ] ...
+# $Name이 비어 있다면 bash는
+if [ "" != $USER ] ...
+# 와 같이 인식하여 예상한 대로 동작합니다.
+
+# 조건부 실행도 있습니다.
+echo "항상 실행" || echo "첫 명령어가 실패해야 실행"
+echo "항상 실행" && echo "첫 명령어가 실패하지 않아야 실행"
+
+# if문과 함께 &&와 ||을 사용하려면, 대괄호가 여러 쌍 필요합니다.
+if [ "$Name" == "철수" ] && [ "$Age" -eq 15 ]
+then
+    echo "$Name이 철수이고 $Age가 15일 때 실행"
+fi
+
+if [ "$Name" == "민희" ] || [ "$Name" == "상민" ]
+then
+    echo "$Name이 민희이거나 상민일 때 실행"
+fi
+
+# 표현식은 다음 형식으로 표기됩니다.
+echo $(( 10 + 5 ))
+
+# 다른 프로그래밍 언어와는 달리, bash는 셸이기 때문에 현재 디렉토리의 컨텍스트에서
+# 실행됩니다. 현재 디렉토리의 파일과 디렉토리를 ls 명령어로 나열할 수 있습니다.
+ls
+
+# 다음은 실행을 제어하는 옵션의 예시입니다.
+ls -l # 모든 파일과 디렉토리를 분리된 줄에 나열
+ls -t # 디렉토리 내용을 마지막으로 수정된 날짜(내림차순)에 따라 정렬
+ls -R # 이 디렉토리와 그 안의 모든 디렉토리에 대해 재귀적으로 `ls` 실행
+
+# 이전 명령어의 결과는 다음 명령어에 입력될 수 있습니다.
+# grep 명령어는 입력을 주어진 패턴에 따라 필터링합니다. 다음은 현재 디렉토리의
+# .txt 파일을 나열하는 방법입니다.
+ls -l | grep "\.txt"
+
+# `cat`을 이용해 stdout으로 파일을 출력합니다.
+cat file.txt
+
+# `cat`으로 파일을 읽을 수도 있습니다.
+Contents=$(cat file.txt)
+echo "파일 시작\n$Contents\n파일 끝"
+
+# `cp`를 이용해 파일이나 디렉토리를 다른 곳으로 복사할 수 있습니다.
+# `cp`는 원본의 새로운 버전을 생성하므로 사본을 편집하는 것은
+# 원본에 영향을 주지 않으며 그 반대도 마찬가지입니다.
+# 목표 위치에 이미 파일이 있다면 덮어쓰게 됩니다.
+cp srcFile.txt clone.txt
+cp -r srcDirectory/ dst/ # 재귀적으로 복사
+
+# 컴퓨터 간에 파일을 공유하려고 한다면 `scp` 혹은 `sftp`를 사용합니다.
+# `scp`는 `cp`와 매우 유사하게 동작하며
+# `sftp`는 더 상호작용적입니다.
+
+# `mv`로 파일 혹은 디렉토리를 다른 곳으로 이동합니다.
+# `mv`는 `cp`와 유사하지만 원본을 삭제합니다.
+# 또한 `mv`로 파일의 이름을 바꿀 수도 있습니다.
+mv s0urc3.txt dst.txt # sorry, l33t hackers...
+
+# bash는 현재 디렉토리의 컨텍스트에서 실행되기 때문에, 다른 디렉토리에서 명령어를
+# 실행하고 싶으실 수 있습니다. cd를 이용해 위치를 변경합니다.
+cd ~    # 홈 디렉토리로 변경
+cd ..   # 한 디렉토리 위로 이동
+        # (즉 /home/username/Downloads에서 /home/username로)
+cd /home/username/Documents   # 특정 디렉토리로 이동
+cd ~/Documents/..    # 아직도 홈 디렉토리... 아닌가??
+
+# 서브셸로 디렉토리를 넘어서 작업할 수도 있습니다.
+(echo "처음엔 여기 $PWD") && (cd 어딘가; echo "이제는 여기 $PWD")
+pwd # 아직도 첫 디렉토리에 있음
+
+# `mkdir`로 새 디렉토리를 만듭니다.
+mkdir myNewDir
+# `-p` 플래그는 필요하다면 해당 디렉토리의 경로 중간에 있는 디렉토리를 생성합니다.
+mkdir -p myNewDir/with/intermediate/directories
+
+# (stdin, stdout, stderr로) 명령어의 입출력을 리디렉션할 수 있습니다.
+# stdin의 내용을 ^EOF$까지 읽고 hello.py에 그 내용을 덮어씁니다.
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# stdin, stdoutk, stderr을 다양한 방법으로 리디렉션하여 hello.py를 실행합니다.
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# 출력 오류는 이미 파일이 있을 경우 덮어쓰지만,
+# 덮어쓰는 대신에 내용에 추가하고 싶다면 ">>"를 사용합니다.
+python hello.py >> "output.out" 2>> "error.err"
+
+# output.out에 덮어쓰고, error.err에 추가하고, 줄을 세기
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# 명령어를 실행하고 그 파일 디스크립터를 출력 (예: /dev/fd/123)
+# man fd 참고
+echo <(echo "#helloworld")
+
+# output.out을 "#helloworld"으로 덮어쓰기
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# 임시 파일을 지울 수 있습니다. ('-i'로 대화식 실행)
+# 경고: `rm` 명령어는 되돌릴 수 없습니다.
+rm -v output.out error.err output-and-error.log
+rm -r tempDir/ # 재귀적으로 삭제
+
+# 다른 명령어에서 $()을 이용해 명령어를 치환할 수도 있습니다.
+# 다음 명령어는 현재 디렉토리의 파일 및 디렉토리의 수를 표시합니다.
+echo "$(ls | wc -l)개 항목이 있습니다."
+
+# 백틱(``)을 이용할 수도 있지만 이 방식을 이용하면 중첩할 수 없기 때문에
+# $()을 사용하는 것이 더 좋습니다.
+echo "`ls | wc -l`개 항목이 있습니다."
+
+# 자바나 C++의 switch와 비슷하게 동작하는 case 문을 사용할 수 있습니다.
+case "$Variable" in
+    # 충족시킬 조건을 나열
+    0) echo "0입니다.";;
+    1) echo "1입니다.";;
+    *) echo "널이 아닌 값입니다.";;
+esac
+
+# for 반복문은 주어진 인자만큼 반복합니다.
+# 다음은 $Variable을 세 번 출력합니다.
+for Variable in {1..3}
+do
+    echo "$Variable"
+done
+
+# 혹은 "전통적인 for 반복문" 방식을 쓸 수도 있습니다.
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# 파일에도 적용될 수 있습니다.
+# 다음은 file1과 file2에 'cat' 명령어를 실행합니다.
+for Variable in file1 file2
+do
+    cat "$Variable"
+done
+
+# 혹은 명령어의 결과에도 이용할 수 있습니다.
+# 다음은 ls의 결과를 cat합니다.
+for Output in $(ls)
+do
+    cat "$Output"
+done
+
+# while 반복문
+while [ true ]
+do
+    echo "반복문 몸체"
+    break
+done
+
+# 함수를 정의할 수도 있습니다.
+# 정의:
+function foo ()
+{
+    echo "인자는 함수 인자처럼 작동합니다. $@"
+    echo "그리고 $1 $2..."
+    echo "함수입니다."
+    return 0
+}
+
+# 혹은 단순하게
+bar ()
+{
+    echo "함수를 선언하는 다른 방법"
+    return 0
+}
+
+# 함수 호출
+foo "My name is" $Name
+
+# 몇 가지 유용한 명령어를 알아두면 좋습니다.
+# file.txt의 마지막 10줄 출력
+tail -n 10 file.txt
+# file.txt의 첫 10줄 출력
+head -n 10 file.txt
+# file.txt 줄 별로 정렬
+sort file.txt
+# 중복되는 줄을 생략하거나 -d를 이용하여 보고
+uniq -d file.txt
+# ',' 문자 이전의 첫 열만 출력
+cut -d ',' -f 1 file.txt
+# file.txt에서 'okay'를 모두 'great'로 교체 (정규식 호환)
+sed -i 's/okay/great/g' file.txt
+# file.txt에서 정규식에 맞는 모든 줄을 stdin에 출력
+# 다음 예시는 "foo"로 시작해 "bar"로 끝나는 줄 출력
+grep "^foo.*bar$" file.txt
+# "-c" 옵션을 넘겨 줄 번호를 대신 출력
+grep -c "^foo.*bar$" file.txt
+# 다른 유용한 옵션
+grep -r "^foo.*bar$" someDir/ # 재귀적으로 `grep`
+grep -n "^foo.*bar$" file.txt # 줄 번호 매기기
+grep -rI "^foo.*bar$" someDir/ # 재귀적으로 `grep`하되 바이너리 파일은 무시
+# 같은 검색으로 시작하여 "baz"를 포함하는 줄만 필터
+grep "^foo.*bar$" file.txt | grep -v "baz"
+
+# 정규식이 아니라 문자열로 검색하고 싶다면
+# fgrep 혹은 grep -F
+fgrep "foobar" file.txt
+
+# trap 명령어로 스크립트에서 신호를 받을 때 명령어를 실행할 수 있습니다.
+# 다음 명령어는 셋 중 한 가지 신호를 받으면 rm 명령어를 실행합니다.
+trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
+
+# `sudo`를 통해 슈퍼이용자로 명령어를 실행합니다.
+NAME1=$(whoami)
+NAME2=$(sudo whoami)
+echo "$NAME1였다가 더 강한 $NAME2가 되었다"
+
+# 'help' 명령어로 내장 문서를 읽을 수 있습니다.
+help
+help help
+help for
+help return
+help source
+help .
+
+# man으로 매뉴얼을 읽을 수도 있습니다.
+apropos bash
+man 1 bash
+man bash
+
+# info 명령어로 문서를 읽습니다. (?로 도움말)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# bash의 info 문서를 읽어 보세요.
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/ko-kr/brainfuck-kr.html.markdown b/ko-kr/bf-kr.html.markdown
index c2e4341f..3d366d7c 100644
--- a/ko-kr/brainfuck-kr.html.markdown
+++ b/ko-kr/bf-kr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/ko-kr/erlang-kr.html.markdown b/ko-kr/erlang-kr.html.markdown
new file mode 100644
index 00000000..b0b1dd2a
--- /dev/null
+++ b/ko-kr/erlang-kr.html.markdown
@@ -0,0 +1,333 @@
+---
+language: erlang
+contributors:
+    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+filename: learnerlang-kr.erl
+translators:
+    - ["Taesung Jung", "https://github.com/tsj"]
+lang: ko-kr
+---
+
+```erlang
+% 퍼센트 기호는 한 줄 주석을 시작한다.
+
+%% 두 개의 퍼센트 문자는 함수의 주석에 사용된다.
+
+%%% 세 개의 퍼센트 문자는 모듈의 주석에 사용된다.
+
+% Erlang에선 3가지 유형의 문장 부호를 사용한다.
+% 쉼표(`,`)는 함수 호출에서 인수, 데이터 생성자(constructors), 패턴을 구분한다.
+% 마침표(`.`)(다음에 오는 공백)는 셸에서 함수 전체와 식을 구분한다.
+% 세미콜론(`;`)은 절을 구분한다. 몇 가지 문맥(contexts)에서 절이 발견된다:
+% 함수 정의와 `case`, `if`, `try..catch`, 그리고 `receive` 식
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 1. 변수와 패턴 매칭
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Erlang에서 새로운 변수는 `=` 문장에 의해 바인딩 된다.
+Num = 42.  % 모든 변수 이름은 반드시 대문자로 시작해야 한다.
+
+% Erlang은 단일 할당 변수(single-assignment variables)를 가진다;
+% 만약 다른 값을 `Num` 변수에 할당하려고 시도하면 오류가 발생한다.
+Num = 43. % ** 예외 오류: 우변의 값 43과 매칭되지 않음
+
+% 대부분 언어에서 `=`는 할당문을 나타낸다. 그러나 Erlang에서 
+% `=`는 패턴 매칭 연산자를 나타낸다. 비어 있는 변수가 `=` 연산자의 좌변에
+% 사용되면 바인드(할당) 된다, 그러나 바인드 변수가 좌변에 사용된 경우에
+% 다음 행동은 그 바인드 변수가 관측된다.
+% `Lhs = Rhs`의 진짜 의미: 우변(`Rhs`)을 평가하고, 그리고
+% 그 결과를 좌변(`Lhs`)의 패턴과 매치시켜라.
+Num = 7 * 6.
+
+% 부동 소수점 수.
+Pi = 3.14159.
+
+% Atom은 숫자가 아닌 서로 다른 상숫값을 표현하는 데 사용한다. Atom은
+% 소문자로 시작하고, 연속적인 영숫자(alphanumeric) 문자나 밑줄(`_`) 또는
+% 골뱅이(`@`) 기호가 따라온다.
+Hello = hello.
+OtherNode = example@node.
+
+% 영숫자 값이 아닌 Atom은 작은따옴표로 묶여서 작성될 수 있다.
+AtomWithSpace = 'some atom with space'.
+
+% Tuple은 C의 struct와 비슷하다.
+Point = {point, 10, 45}.
+
+% Tuple에서 어떤 값을 추출하려면, 패턴 매칭 연산자 `=`를 사용한다.
+{point, X, Y} = Point.  % X = 10, Y = 45
+
+% 관심 없는 변수를 위해 자리 표시자(placeholder) `_`를 사용할 수 있다.
+% 기호 `_`는 익명 변수(anonymous variable)라 부른다. 일반적인 변수들과
+% 다르게 같은 패턴에서 여러 번 나오더라도 동일한 값으로 바인드되지 않아도 된다.
+Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.
+{_, {_, {_, Who}, _}, _} = Person.  % Who = joe
+
+% List를 만들기 위해서 List의 원소는 대괄호([])로 둘러싸고 쉼표(,)로 구분한다.
+% List의 각각의 원소는 어떤 타입도 가능하다.
+% List의 첫 번째 원소는 List의 HEAD이다. 만약 List의 HEAD를 제거하면,
+% 남은 부분은 List의 TAIL이라 부른다.
+ThingsToBuy = [{apples, 10}, {pears, 6}, {milk, 3}].
+
+% 만약 `T`가 List이면, `[H|T]`도 HEAD가 `H`이고 TAIL이 `T`인 List이다.
+% 세로 막대(`|`)는 List의 HEAD와 TAIL을 분리한다. `[]`는 빈 List다.
+% List의 원소들은 패턴 매칭 연산으로 추출할 수 있다.
+% 만약 비어있지 않은 List `L`이 있을 때, `[X|Y] = L` 식의 `X`와 `Y`가
+% 바인드되지 않은 변수이면, List의 HEAD는 X에 그리고 TAIL은 Y로 추출된다.
+[FirstThing|OtherThingsToBuy] = ThingsToBuy.
+% FirstThing = {apples, 10}
+% OtherThingsToBuy = [{pears, 6}, {milk, 3}]
+
+% Erlang에는 문자열(String)이 없다. 문자열은 사실 정수의 List일 뿐이다.
+% 문자열은 큰따옴표(`"`)로 묶인다.
+Name = "Hello".
+[72, 101, 108, 108, 111] = "Hello".
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 2. 순차 프로그래밍
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Erlang에서 Module은 코드의 기본 단위이다. 우리가 작성한 모든 함수는
+% Module에 담긴다. Module은 확장자가 `.erl`인 파일에 저장된다.
+% 코드가 실행되기 전에 Module은 컴파일되어야 한다. 컴파일된 Module은
+% `.beam` 확장자를 가진다.
+-module(geometry).
+-export([area/1]). % Module로부터 내보내진(exported) 함수의 List
+
+% 함수 `area`는 두 개의 절로 구성된다. 절은 세미콜론(`;`)으로 구분되며,
+% 마지막 절은 마침표-공백(dot-whitespace)으로 끝난다.
+% 각 절은 서문(head)과 본문(body)을 가진다. 서문은 함수의 이름에 이어서
+% 패턴이(괄호 속에) 따라온다. 본문은 연속적인 식으로 구성되고,
+% 연속적인 식은 서문의 패턴과 호출한 인수가 성공적으로 매치되면 평가된다.
+% 패턴은 함수 정의가 나타나는 순서대로 매치된다.
+area({rectangle, Width, Ht}) -> Width * Ht;
+area({circle, R})            -> 3.14159 * R * R.
+
+% geometry.erl 파일의 코드 컴파일
+c(geometry).  % {ok,geometry}
+
+% 호출하려는 함수를 정확히 알아내기 위해 함수 이름을 Module 이름과 함께
+% 명시하는 것이 필요하다.
+geometry:area({rectangle, 10, 5}).  % 50
+geometry:area({circle, 1.4}).  % 6.15752
+
+% Erlang에서, 같은 Module에 이름이 같고 Arity(인수의 갯수)가 다른
+% 두 함수는 전혀 다른 함수를 나타낸다.
+-module(lib_misc).
+-export([sum/1]). % Arity가 1인 내보내진(export) 함수 `sum`
+                  % 하나의 인수만 받음: 정수의 List
+sum(L) -> sum(L, 0).
+sum([], N)    -> N;
+sum([H|T], N) -> sum(T, H+N).
+
+% Fun은 "익명(anonymous)" 함수다. 이름이 없어서 이렇게 부른다.
+% 그러나, 변수에 할당될 수 있다.
+Double = fun(X) -> 2 * X end. % `Double`은 익명 함수를 가리킨다:
+                              % #Fun<erl_eval.6.17052888>
+Double(2).  % 4
+
+% 함수는 인수로 Fun을 받거나, Fun을 반환할 수 있다.
+Mult = fun(Times) -> ( fun(X) -> X * Times end ) end.
+Triple = Mult(3).
+Triple(5).  % 15
+
+% List 해석(List comprehensions)은 Fun, Map, Filter 없이 List를 만드는 식이다.
+% 표기법 `[F(X) || X <- L]`은 `F(X)`의 List라는 의미이다.
+% 이때 `X`는 List `L`로부터 가져온다.
+L = [1,2,3,4,5].
+[2 * X || X <- L].  % [2,4,6,8,10]
+% List 해석은 Generator와 생성된 값들의 부분 집합을 선택하는 Filter를 가질 수 있다.
+EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]
+
+% Guard는 패턴 매칭의 능력을 향상시키는데 사용할 수 있는 구조다.
+% Guard를 사용하면, 패턴에 있는 변수에 대해 간단한 검사와 비교를 수행할 수 있다.
+% 함수 정의의 서문(head)에 `when` 키워드로 시작되는 Guard를 사용할 수도 있고,
+% 또는 식이 허용되는 언어의 어떤 곳에도 사용될 수 있다.
+max(X, Y) when X > Y -> X;
+max(X, Y) -> Y.
+
+% Guard는 쉼표(`,`)로 구분된 연속된 Guard 식이다.
+% 모든 Guard 식 `GuardExpr1`, `GuardExpr2`, ..., `GuardExprN`이
+% `true`로 평가된다면, Guard `GuardExpr1`, `GuardExpr2`, ..., `GuardExprN`는
+% 참이다.
+is_cat(A) when is_atom(A), A =:= cat -> true;
+is_cat(A) -> false.
+is_dog(A) when is_atom(A), A =:= dog -> true;
+is_dog(A) -> false.
+
+% `=:=` 연산자는 여기서 자세히 다루지 않을 것이다; 두 개의 Erlang 식의 값이 같고
+% *그리고* 같은 타입인지 검사하는 데 사용된다고만 알면 된다.
+% `==` 연산자의 작동과 대조할 것:
+1 + 2 =:= 3.   % true
+1 + 2 =:= 3.0. % false
+1 + 2 ==  3.0. % true
+
+% 연속적인 Guard는 단일 Guard 또는 세미콜론(`;`)으로 구분된 연속된 Guard다.
+% Guard `G1; G2; ...; Gn` 중에 적어도 하나의 Guard가 `true`로 평가된다면,
+% 연속적인 Guard `G1; G2; ...; Gn`는 참이다.
+is_pet(A) when is_atom(A), (A =:= dog);(A =:= cat) -> true;
+is_pet(A)                                          -> false.
+
+% 주의: 모든 유효한 Erlang 식이 Guard 식으로 사용될 수 있는 것은 아니다;
+% 특히, 함수 `is_cat`과 `is_dog`는 `is_pet`의 정의 안에 있는 
+% 연속적인 Guard 사이에 사용될 수 없다.
+% 연속적인 Guard에 허용되는 식의 자세한 설명은 Erlang 레퍼런스 메뉴얼
+% [section](http://erlang.org/doc/reference_manual/expressions.html#id81912)
+% 을 참조하라.
+
+% Record는 Tuple 안에 이름과 특정 요소를 연결하는 방법을 제공한다.
+% Record 정의는 Erlang 소스 코드 파일에 포함되거나 Erlang 소스 코드 파일에
+% 포함될 수 있는 확장자가 `.hrl`인 파일에 집어넣을 수 있다.
+-record(todo, {
+  status = reminder,  % 기본 값
+  who = joe,
+  text
+}).
+
+% Record를 사용할 수 있기 전에 Record 정의를 반드시 셸로 읽어 들여야 한다.
+% 셸로 읽어 들이기 위해 셸 함수 `rr`(read records의 약자)을 사용한다.
+rr("records.hrl").  % [todo]
+
+% Record 생성과 수정
+X = #todo{}.
+% #todo{status = reminder, who = joe, text = undefined}
+X1 = #todo{status = urgent, text = "Fix errata in book"}.
+% #todo{status = urgent, who = joe, text = "Fix errata in book"}
+X2 = X1#todo{status = done}.
+% #todo{status = done, who = joe, text = "Fix errata in book"}
+
+% `case` 식
+% `filter`는 List `L`의 원소 `X` 중에서 `P(X)`가 참인 모든 `X`의 List를 반환한다.
+filter(P, [H|T]) ->
+  case P(H) of
+    true -> [H|filter(P, T)];
+    false -> filter(P, T)
+  end;
+filter(P, []) -> [].
+filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]
+
+% `if` 식.
+max(X, Y) ->
+  if
+    X > Y -> X;
+    X < Y -> Y;
+    true -> nil
+  end.
+
+% 주의: 적어도 if 식의 Guard 중의 하나는 반드시 `true`로 평가되어야 한다. 
+% 그렇지 않으면 예외가 발생한다.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 3. 예외
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% 예외는 내부에 에러가 생겼거나 명시적으로 `throw(Exception)`,
+% `exit(Exception)` 또는 `erlang:error(Exception)`를 호출하면
+% 시스템에 의해 발생한다.
+generate_exception(1) -> a;
+generate_exception(2) -> throw(a);
+generate_exception(3) -> exit(a);
+generate_exception(4) -> {'EXIT', a};
+generate_exception(5) -> erlang:error(a).
+
+% Erlang은 예외를 잡는 두 가지 방법을 가지고 있다. 한 가지는
+% 예외를 발생시키는 함수의 호출 부분을 `try...catch` 식으로 감싸는 것이다.
+catcher(N) ->
+  try generate_exception(N) of
+    Val -> {N, normal, Val}
+  catch
+    throw:X -> {N, caught, thrown, X};
+    exit:X -> {N, caught, exited, X};
+    error:X -> {N, caught, error, X}
+  end.
+
+% 다른 방법은 그 호출 부분을 `catch` 식으로 감싸는 것이다.
+% 예외를 잡았을 때, 그 예외는 오류를 설명하는 Tuple로 변환된다.
+catcher(N) -> catch generate_exception(N).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 4. 병행성
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Erlang은 병행성을 위해 Actor 모델을 사용한다. Erlang에서 병행 프로그램을
+% 작성하는 데 필요한 모든 것은 3가지 기본 형식(primitivies)이다:
+% 프로세스 생성, 메시지 보내기, 메시지 받기
+
+% 새로운 프로세스를 시작하기 위해, 함수를 인수로 받는 `spawn` 함수를 사용한다.
+
+F = fun() -> 2 + 2 end. % #Fun<erl_eval.20.67289768>
+spawn(F). % <0.44.0>
+
+% `spawn`은 pid(프로세스 식별자)를 반환한다. 이 pid를 프로세스로
+% 메시지를 보내는 데 사용할 수 있다. 메시지 전달을 위해, `!` 연산자를 사용한다.
+% 위의 기능이 유용하려면, 메시지를 받을 수 있어야 한다. 메시지를 받는 것은
+% `receive` 메커니즘을 사용한다.
+
+-module(calculateGeometry).
+-compile(export_all).
+calculateArea() ->
+    receive
+      {rectangle, W, H} ->
+        W * H;
+      {circle, R} ->
+        3.14 * R * R;
+      _ ->
+        io:format("We can only calculate area of rectangles or circles.")
+    end.
+
+% Module을 컴파일하고 셸에서 `calculateArea`를 평가한 프로세스를 생성한다.
+c(calculateGeometry).
+CalculateArea = spawn(calculateGeometry, calculateArea, []).
+CalculateArea ! {circle, 2}. % 12.56000000000000049738
+
+% 셸도 마찬가지로 프로세스이다. 현재 pid를 얻기 위해서 `self`를 사용할 수 있다.
+self(). % <0.41.0>
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 5. EUnit과 테스트
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% EUnit의 테스트 생성기(generators)와 assert 매크로를 이용해
+% 단위 테스트를 작성할 수 있다.
+-module(fib).
+-export([fib/1]).
+-include_lib("eunit/include/eunit.hrl").
+
+fib(0) -> 1;
+fib(1) -> 1;
+fib(N) when N > 1 -> fib(N-1) + fib(N-2).
+
+fib_test_() ->
+    [?_assert(fib(0) =:= 1),
+     ?_assert(fib(1) =:= 1),
+     ?_assert(fib(2) =:= 2),
+     ?_assert(fib(3) =:= 3),
+     ?_assert(fib(4) =:= 5),
+     ?_assert(fib(5) =:= 8),
+     ?_assertException(error, function_clause, fib(-1)),
+     ?_assert(fib(31) =:= 2178309)
+    ].
+
+% EUnit은 Erlang 셸에서 테스트를 실행할 수 있게 
+% 자동으로 test() 함수를 내보낸다(export).
+fib:test()
+
+% Erlang의 유명한 빌드 툴인 Rebar는 EUnit과 호환된다.
+% ```
+% rebar eunit
+% ```
+
+```
+
+## 참조
+
+* ["Learn You Some Erlang for great good!"](http://learnyousomeerlang.com/)
+* ["Programming Erlang: Software for a Concurrent World" by Joe Armstrong](http://pragprog.com/book/jaerlang/programming-erlang)
+* [조 암스트롱, 김석준 역, "프로그래밍 얼랭: Software for a Concurrent World", 인사이트](http://ebook.insightbook.co.kr/book/23)
+* [Erlang/OTP Reference Documentation](http://www.erlang.org/doc/)
+* [Erlang - Programming Rules and Conventions](http://www.erlang.se/doc/programming_rules.shtml)
diff --git a/ko-kr/json-kr.html.markdown b/ko-kr/json-kr.html.markdown
new file mode 100644
index 00000000..462bf63a
--- /dev/null
+++ b/ko-kr/json-kr.html.markdown
@@ -0,0 +1,80 @@
+---
+language: json
+filename: learnjson-kr.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Michael Neth", "https://github.com/infernocloud"]
+translators:
+  - ["Wooseop Kim", "https://github.com/linterpreteur"]
+lang: ko-kr
+---
+
+JSON은 아주 간단한 데이터 교환 포맷입니다. [json.org](http://json.org/json-ko.html)에 의하면, 사람이 읽고 쓰기 쉬우며 기계가 분석하고 생성하기 쉽습니다.
+
+JSON 한 개는 반드시 이하의 둘 중 하나를 나타내야 합니다.
+* 이름과 값 쌍의 모임(`{ }`). 이는 다양한 언어에서 객체, 레코드, 구조체, 딕셔너리, 해시 테이블, 키 리스트, 혹은 연관 배열로 구현됩니다.
+* 값에 순서가 있는 리스트 (`[ ]`). 이는 다양한 언어에서 배열, 벡터, 리스트, 시퀀스로 구현됩니다.
+
+순수한 JSON은 사실 주석이 없지만 대부분의 파서는 C 스타일의 주석(`//`, `/* */`)도 받아들일 겁니다. 일부 파서는 꼬리에 오는 쉼표, 즉 배열의 마지막 원소 혹은 객체의 마지막 속성 다음에 오는 쉼표도 인정하겠지만, 호환성을 위해 쓰지 않는 것이 좋습니다.
+
+이 튜토리얼의 목적에 따라 모든 것은 100% 유효한 JSON입니다. 다행스럽게도 JSON은 다소 자기서술적입니다.
+
+지원하는 데이터 형:
+
+* 문자열: `"안녕"`, `"\"따옴표.\""`, `"\u0abe"`, `"개행 문자.\n"`
+* 수: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* 객체: `{ "키": "값" }`
+* 배열: `["값 값 값"]`
+* 기타: `true`, `false`, `null`
+
+```json
+{
+  "키": "값",
+
+  "키는": "반드시 큰따옴표 안에 있어야 합니다.",
+  "수": 0,
+  "문자열": "Hellø, wørld. 모든 유니코드와 \"탈출 문자\"가 지원됩니다.",
+  "부울도 있나?": true,
+  "아무 것도 없는 건": null,
+
+  "큰 수": 1.2e+100,
+
+  "객체": {
+    "주석": "문서 구조의 대부분은 객체가 될 것입니다.",
+
+    "배열": [0, 1, 2, 3, "배열 안에는 무엇이든 올 수 있습니다.", 5],
+
+    "다른 객체": {
+      "주석": "객체는 객체를 포함할 수 있습니다. 아주 유용하죠."
+    }
+  },
+
+  "장난이지롱": [
+    {
+      "칼륨이 풍부한": ["바나나"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "다른 방식": {
+    "주석": "여기 보세요!"
+  , "쉼표의 위치는": "상관 없습니다. 다음 키 전에만 온다면 유효합니다."
+  , "다른 주석": "참 좋죠"
+  },
+
+  "공백은": "상관이 없습니다.",
+
+  "짧았죠": "끝입니다. JSON의 모든 것을 터득하셨습니다."
+}
+```
+
+## 더 읽기
+
+* [JSON.org](http://json.org/json-ko.html) 플로우차트와 같은 그래픽을 이용해 설명한 JSON의 모든 것.
diff --git a/ko-kr/kotlin-kr.html.markdown b/ko-kr/kotlin-kr.html.markdown
new file mode 100644
index 00000000..2df4195d
--- /dev/null
+++ b/ko-kr/kotlin-kr.html.markdown
@@ -0,0 +1,376 @@
+---
+language: kotlin
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators: 
+    - ["Alan Jeon", "https://github.com/skyisle"]
+lang: ko-kr
+filename: LearnKotlin-kr.kt
+---
+
+Kotlin 은 정적 타입 프로그래밍 언어로 JVM, 안드로이드, 브라우져를 지원하며 Java 와 100% 상호 운용이 가능합니다.
+[자세한 내용은 다음을 참고하세요.](https://kotlinlang.org/)
+
+```kotlin
+// 한 줄짜리 주석은 // 로 시작합니다.
+/*
+여러 줄 주석은 이와 같이 표시합니다. 
+*/
+
+// "package" 예약어는 자바와 동일하게 사용됩니다.
+package com.learnxinyminutes.kotlin
+
+/*
+Kotlin 프로그램의 진입점은 main 이라는 함수명으로 지정됩니다. 
+이 함수에 명령행 인수가 배열로 전달됩니다.
+*/
+fun main(args: Array<String>) {
+    /*
+    값을 선언할때는 "var" 또는 "val"이 사용됩니다.
+    "var"와는 다르게 "val"로 선언된 변수에는 값을 재할당 할 수 없습니다.
+    */
+    val fooVal = 10 // fooVal 에 다른 값을 다시 할당 할 수 없습니다.
+    var fooVar = 10
+    fooVar = 20 // fooVar 에는 선언 이후에도 다른 값을 할당 할 수 있습니다
+
+    /*
+    대부분의 경우, Kotlin 에서는 변수 타입을 판단할 수 있기때문에 명시적으로 지정해 주지 않을 수 있습니다.
+    다음과 같이 변수의 타입을 명시적으로 지정할 수 있습니다.
+    */
+    val foo: Int = 7
+
+    /*
+    문자형은 Java와 비슷하게 표시될 수 있습니다.
+    이스케이핑에는 백슬래시를 사용합니다.
+    */
+    val fooString = "My String Is Here!"
+    val barString = "Printing on a new line?\nNo Problem!"
+    val bazString = "Do you want to add a tab?\tNo Problem!"
+    println(fooString)
+    println(barString)
+    println(bazString)
+
+    /*
+    Raw 문자열은 쌍따옴표 3개(""")로 표기합니다.
+    Raw 문자열에는 줄바꿈이나 모든 다른 문자들을 사용할 수 있습니다. 
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Hello, world!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    문자열은 템플릿 표현식을 포함할 수 있습니다.
+    템플릿은 달러 기호($)로 시작합니다. 
+    */
+    val fooTemplateString = "$fooString has ${fooString.length} characters"
+    println(fooTemplateString)
+
+    /*
+    변수가 null 값을 가지려면 이를 명시적으로 선언해야 합니다.
+    변수 선언시 타입에 ? 표시를 붙여 nullable 을 표시합니다.
+    ?. 연산자를 사용해 nullable 변수에 접근합니다.
+    ?: 연산자를 이용해서 변수 값이 null 일때 사용할 값을 지정합니다.
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    함수는 "fun" 예약어를 사용해 선언합니다.
+    함수명 이후 괄호 안에 인자를 기술합니다.
+    함수 인자에 기본 값을 지정할 수도 있습니다.
+    함수에 리턴값이 있을 때, 필요한 경우 인자 뒤에 타입을 명시합니다.
+    */
+    fun hello(name: String = "world"): String {
+        return "Hello, $name!"
+    }
+    println(hello("foo")) // => Hello, foo!
+    println(hello(name = "bar")) // => Hello, bar!
+    println(hello()) // => Hello, world!
+
+    /*
+    함수에 가변 인자를 넘기려면 인자에 "vararg" 예약어를 사용합니다. 
+    */
+    fun varargExample(vararg names: Int) {
+        println("Argument has ${names.size} elements")
+    }
+    varargExample() // => 인자가 0개 인 경우
+    varargExample(1) // => 인자가 1개인 경우
+    varargExample(1, 2, 3) // => 인자가 3개인 경우
+
+    /*
+    함수가 단일 표현식으로 이루어진 경우에 중괄호를 생략할 수 있습니다.
+    이때 함수 구현부는 = 기호 이후에 기술합니다.
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // 리턴 타입이 유추 가능한 경우 이를 명시하지 않아도 됩니다. 
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // 함수는 함수를 인자를 받을 수 있고 함수를 리턴할 수 있습니다. 
+    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // 함수는 :: 연산자를 사용해서 다른 함수에 인자로 넘길 수 있습니다. 
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // 람다식을 인자로 사용할 수 있습니다. 
+    val notZero = not {n -> n == 0}
+    /*
+    하나의 인자를 가지는 람다식의 선언부와 -> 연산자는 생략될 수 있습니다.
+    이때 그 인자명은 it로 지정됩니다.
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // "class" 예약어는 클래스를 선언할 때 사용됩니다. 
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int): Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    새로운 객체를 생성하기 위해서는 생성자를 바로 호출합니다.
+    Kotlin 에서는 new 예약어가 없다는 걸 기억하세요.
+    */
+    val fooExampleClass = ExampleClass(7)
+    // 맴버 함수는 dot 표기로 호출할 수 있습니다. 
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    함수 선언에 "infix" 예약어를 사용하면 이 함수를 중위 표현식(infix notation)으로 호출할 수 있습니다 
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    데이터 클래스로 데이터만을 가지고 있는 클래스를 손쉽게 선언할 수 있습니다.
+    "hashCode"/"equals" 와 "toString" 는 자동으로 생성됩니다.
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // 데이터 클래스는 copy 함수를 가지고 있습니다. 
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // 객체를 여러 변수로 분리할 수 있습니다. 
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+    
+    // "for" 루프에서 변수 분리 하기 
+    for ((a, b, c) in listOf(fooData)) {
+        println("$a $b $c") // => 1 100 4
+    }
+    
+    val mapData = mapOf("a" to 1, "b" to 2)
+    // Map.Entry 또한 키와 값으로 분리가 가능합니다. 
+    for ((key, value) in mapData) {
+        println("$key -> $value")
+    }
+
+    // "with" 함수는 JavaScript 의 "with" 구문과 비슷하게 사용됩니다. 
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    "listOf" 함수로 리스트를 만들 수 있습니다.
+    리스트는 변경 불가능(immutable)하게 만들어져 항목의 추가 삭제가 불가능합니다.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // 각 항목은 인덱스로 접근이 가능합니다. 
+    println(fooList[1]) // => b
+
+    // 변경가능한(mutable) 리스트는 "mutableListOf" 함수로 만들 수 있습니다. 
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // 집합(set)은 "setOf" 함수로 만들 수 있습니다.
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // 맵은 "mapOf" 함수로 만들 수 있습니다.
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // 맵은 키를 통해 그 값에 접근할 수 있습니다. Map values can be accessed by their key.
+    println(fooMap["a"]) // => 8
+
+    /*
+    시퀀스는 지연 평가되는 컬랙션을 말합니다. Sequences represent lazily-evaluated collections.
+    "generateSequence" 를 사용해 시퀀스를 만들 수 있습니다. We can create a sequence using the "generateSequence" function.
+    */
+    val fooSequence = generateSequence(1, { it + 1 })
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // 다음은 시퀀스를 사용해서 피보나치 수열을 생성하는 예입니다.
+    fun fibonacciSequence(): Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next(): Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin 은 컬랙션에서 사용할 수 있는 고차(higher-order)함수를 제공합니다.
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "even" else "odd"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // "for" 루프는 이터레이터를 제공하는 어떤 것과도 함께 사용할 수 있습니다.
+    for (c in "hello") {
+        println(c)
+    }
+
+    // "while" 루프는 다른 언어들과 동일하게 사용됩니다.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    "if"는 값을 리턴하는 표현으로 사용될 수 있습니다.
+    그래서 Kotlin 에서는 삼항 ?: 연산자가 필요하지 않습니다.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "even" else "odd"
+    println("$num is $message") // => 5 is odd
+
+    // "when"은 "if-else if" 를 대체할때 사용할 수 있습니다.
+    val i = 10
+    when {
+        i < 7 -> println("first block")
+        fooString.startsWith("hello") -> println("second block")
+        else -> println("else block")
+    }
+
+    // "when"은 인수와 함께 사용될 수 있습니다.
+    when (i) {
+        0, 21 -> println("0 or 21")
+        in 1..20 -> println("in the range 1 to 20")
+        else -> println("none of the above")
+    }
+
+    // "when"은 값을 리턴하는 함수처럼 사용될 수 있습니다.
+    var result = when (i) {
+        0, 21 -> "0 or 21"
+        in 1..20 -> "in the range 1 to 20"
+        else -> "none of the above"
+    }
+    println(result)
+
+    /*
+    객체가 어떤 타입인지를 확인하기 위해 "is" 연산자를 사용할 수 있습니다.
+    타입 체크를 통과하면 객체의 명시적인 형변환 없이도 그 타입 값으로 사용될 수 있습니다.
+    이를 스마트 변환(Smartcast)이라 부릅니다.
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x is automatically cast to Boolean
+            return x
+        } else if (x is Int) {
+            // x is automatically cast to Int
+            return x > 0
+        } else if (x is String) {
+            // x is automatically cast to String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hello, world!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    // 스마트 변환은 when 블럭과도 함께 사용됩니다.
+    fun smartCastWhenExample(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    확장(Extensions)을 이용해 클래스에 새로운 기능을 추가할 수 있습니다.
+    C#에서의 확장 매서드와 유사합니다.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hello, world!".remove('l')) // => Heo, word!
+
+    println(EnumExample.A) // => A
+    println(ObjectExample.hello()) // => hello
+}
+
+// Enum 클래스는 자바의 enum 타입과 유사합니다.
+enum class EnumExample {
+    A, B, C
+}
+
+/*
+"object" 예약어는 싱클톤 객체를 생성할 때 사용됩니다. 
+객체를 새로 생성할 수는 없지만 이름을 가지고 접근해 사용할 수 있습니다.
+이는 스칼라의 싱글톤 객체와 유사합니다.
+*/
+object ObjectExample {
+    fun hello(): String {
+        return "hello"
+    }
+}
+
+fun useObject() {
+    ObjectExample.hello()
+    val someRef: Any = ObjectExample // 객체의 이름을 그대로 사용합니다.
+}
+
+```
+
+### 더 알아보기
+
+* [Kotlin tutorials (EN)](https://kotlinlang.org/docs/tutorials/)
+* [Try Kotlin in your browser (EN)](http://try.kotlinlang.org/)
+* [A list of Kotlin resources (EN)](http://kotlin.link/)
diff --git a/ko-kr/lua-kr.html.markdown b/ko-kr/lua-kr.html.markdown
index b4a018ef..ce3b71cb 100644
--- a/ko-kr/lua-kr.html.markdown
+++ b/ko-kr/lua-kr.html.markdown
@@ -418,5 +418,5 @@ lua-users.org에 있는 <a href="http://lua-users.org/files/wiki_insecure/users/
 learn.lua로 저장한 후 "lua learn.lua"를 실행해 보세요!
 
 이 글은 tylerneylon.com에 처음으로 써본 글이며, 
-<a href="https://gist.github.com/tylerneylon/5853042">Github의 Gist</a>에서도 확인할 수 있습니다.
+<a href="https://gist.github.com/tylerneylon/5853042">GitHub의 Gist</a>에서도 확인할 수 있습니다.
 루아로 즐거운 시간을 보내세요!
diff --git a/ko-kr/markdown-kr.html.markdown b/ko-kr/markdown-kr.html.markdown
new file mode 100644
index 00000000..bfa2a877
--- /dev/null
+++ b/ko-kr/markdown-kr.html.markdown
@@ -0,0 +1,308 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+    - ["Jacob Ward", "http://github.com/JacobCWard/"]
+filename: markdown-kr.md
+lang: ko-kr
+---
+
+마크다운은 2004년에 존 그루버가 창시했습니다. HTML으로 (그리고 이제는 다른 다양한 형식으로도) 쉽게 변환되는 읽고 쓰기 쉬운 문법입니다.
+
+마크다운은 또한 파서마다 구현이 다양합니다. 본 문서는 어떤 기능이 보편적인지,
+혹은 어떤 기능이 특정 파서에 종속되어 있는지 명확히 하고자 합니다.
+
+- [HTML 요소](#html-elements)
+- [제목](#headings)
+- [간단한 텍스트 꾸미기](#simple-text-styles)
+- [문단](#paragraphs)
+- [목록](#lists)
+- [코드](#code-blocks)
+- [수평선](#horizontal-rule)
+- [링크](#links)
+- [이미지](#images)
+- [기타](#miscellany)
+
+## HTML 요소
+HTML은 마크다운의 수퍼셋입니다. 모든 HTML 파일은 유효한 마크다운이라는 것입니다.
+```markdown
+<!--따라서 주석과 같은 HTML 요소들을 마크다운에 사용할 수 있으며, 마크다운 파서에 영향을
+받지 않을 것입니다. 하지만 마크다운 파일에서 HTML 요소를 만든다면 그 요소의 안에서는
+마크다운 문법을 사용할 수 없습니다.-->
+```
+## 제목
+
+텍스트 앞에 붙이는 우물 정 기호(#)의 갯수에 따라 `<h1>`부터 `<h6>`까지의 HTML 요소를
+손쉽게 작성할 수 있습니다.
+```markdown
+# <h1>입니다.
+## <h2>입니다.
+### <h3>입니다.
+#### <h4>입니다.
+##### <h5>입니다.
+###### <h6>입니다.
+```
+또한 h1과 h2를 나타내는 다른 방법이 있습니다.
+```markdown
+h1입니다.
+=============
+
+h2입니다.
+-------------
+```
+## 간단한 텍스트 꾸미기
+
+마크다운으로 쉽게 텍스트를 기울이거나 굵게 할 수 있습니다.
+```markdown
+*기울인 텍스트입니다.*
+_이 텍스트도 같습니다._
+
+**굵은 텍스트입니다.**
+__이 텍스트도 같습니다.__
+
+***기울인 굵은 텍스트입니다.***
+**_이 텍스트도 같습니다._**
+*__이것도 같습니다.__*
+```
+깃헙 전용 마크다운에는 취소선도 있습니다.
+```markdown
+~~이 텍스트에는 취소선이 그려집니다.~~
+```
+## 문단
+
+문단은 하나 이상의 빈 줄로 구분되는, 한 줄 이상의 인접한 텍스트입니다.
+
+```markdown
+문단입니다. 문단에 글을 쓰다니 재밌지 않나요?
+
+이제 두 번째 문단입니다.
+아직도 두 번째 문단입니다.
+
+나는 세 번째 문단!
+```
+HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어쓰기로 문단을 끝내고
+새 문단을 시작할 수 있습니다.
+
+```markdown
+띄어쓰기 두 개로 끝나는 문단 (마우스로 긁어 보세요).  
+
+이 위에는 `<br />` 태그가 있습니다.
+```
+
+인용문은 > 문자로 쉽게 쓸 수 있습니다.
+
+```markdown
+> 인용문입니다. 수동으로 개행하고서
+> 줄마다 `>`를 칠 수도 있고 줄을 길게 쓴 다음에 저절로 개행되게 내버려 둘 수도 있습니다.
+> `>`로 시작하기만 한다면 차이가 없습니다.
+
+> 한 단계 이상의 들여쓰기를
+>> 사용할 수도 있습니다.
+> 깔끔하죠?
+```
+
+## 목록
+순서가 없는 목록은 별표, 더하기, 하이픈을 이용해 만들 수 있습니다.
+```markdown
+* 이거
+* 저거
+* 그거
+```
+
+또는
+
+```markdown
++ 이거
++ 저거
++ 그거
+```
+
+또는
+
+```markdown
+- 이거
+- 저거
+- 그거
+```
+
+순서가 있는 목록은 숫자와 마침표입니다.
+
+```markdown
+1. 하나
+2. 둘
+3. 셋
+```
+
+숫자를 정확히 붙이지 않더라도 제대로 된 순서로 보여주겠지만, 좋은 생각은 아닙니다.
+
+```markdown
+1. 하나
+1. 둘
+1. 셋
+```
+(위의 예시와 똑같이 나타납니다.)
+
+목록 안에 목록이 올 수도 있습니다.
+
+```markdown
+1. 하나
+2. 둘
+3. 셋
+    * 이거
+    * 저거
+4. 넷
+```
+
+심지어 할 일 목록도 있습니다. HTML 체크박스가 만들어집니다.
+
+```markdown
+x가 없는 박스들은 체크되지 않은 HTML 체크박스입니다.
+- [ ] 첫 번째 할 일
+- [ ] 두 번째 할 일
+이 체크박스는 체크된 HTML 체크박스입니다.
+- [x] 완료된 일
+```
+
+## 코드
+
+띄어쓰기 네 개 혹은 탭 한 개로 줄을 들여씀으로서 (`<code> 요소를 사용하여`) 코드를
+나타낼 수 있습니다.
+
+```markdown
+    puts "Hello, world!"
+```
+
+탭을 더 치거나 띄어쓰기를 네 번 더 함으로써 코드를 들여쓸 수 있습니다.
+
+```markdown
+    my_array.each do |item|
+        puts item
+    end
+```
+
+인라인 코드는 백틱 문자를 이용하여 나타냅니다. `
+
+```markdown
+철수는 `go_to()` 함수가 뭘 했는지도 몰랐어!
+```
+
+깃헙 전용 마크다운에서는 코드를 나타내기 위해 특별한 문법을 쓸 수 있습니다.
+
+<pre>
+<code class="highlight">&#x60;&#x60;&#x60;ruby
+def foobar
+    puts "Hello world!"
+end
+&#x60;&#x60;&#x60;</code></pre>
+
+위의 경우에 들여쓰기가 필요없을 뿐 아니라 \`\`\` 뒤에 특정해 준 언어의 문법에 따라
+색을 입혀줄 것입니다.
+
+## 수평선
+
+수평선(`<hr/>`)은 셋 이상의 별표나 하이픈을 이용해 쉽게 나타낼 수 있습니다.
+띄어쓰기가 포함될 수 있습니다.
+```markdown
+***
+---
+- - -
+****************
+```
+## 링크
+
+마크다운의 장점 중 하나는 링크를 만들기 쉽다는 것입니다. 대괄호 안에 나타낼 텍스트를 쓰고
+괄호 안에 URL을 쓰면 됩니다.
+
+```markdown
+[클릭](http://test.com/)
+```
+
+괄호 안에 따옴표를 이용해 링크에 제목을 달 수도 있습니다.
+
+```markdown
+[클릭](http://test.com/ "test.com으로 가기")
+```
+
+상대 경로도 유효합니다.
+
+```markdown
+[music으로 가기](/music/).
+```
+
+참조하는 식으로 링크를 걸 수도 있습니다.
+
+<pre><code class="highlight">&#x5b;<span class="nv">이 </span>][<span class="ss">링크</span>]에서 더 알아보세요!
+&#x5b;<span class="nv">원하신다면 </span>][<span class="ss">foobar</span>]도 참고하세요.
+
+&#x5b;<span class="nv">링크</span>]: <span class="sx">http://test.com/</span> <span class="nn">"좋아!"</span>
+&#x5b;<span class="nv">foobar</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"됐다!"</span></code></pre>
+
+제목은 작은 따옴표나 괄호에 들어갈 수도 있고, 완전히 생략할 수도 있습니다. 참조는 문서의
+어느 곳에든 올 수 있고 참조 ID는 유일하다면 무엇이든 될 수 있습니다.
+
+링크 텍스트를 ID로 사용하는 "묵시적 이름"도 있습니다.
+
+<pre><code class="highlight">&#x5b;<span class="nv">이것</span>][]은 링크입니다.
+
+&#x5b;<span class="nv">이것</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+
+하지만 보통 그렇게 추천하지는 않습니다.
+
+## 이미지
+이미지는 링크와 같지만 앞에 느낌표가 붙습니다.
+
+```markdown
+![이미지의 alt 속성](http://imgur.com/myimage.jpg "제목")
+```
+
+참조 방식도 가능합니다.
+
+<pre><code class="highlight">!&#x5b;<span class="nv">alt 속성</span>][<span class="ss">이미지</span>]
+
+&#x5b;<span class="nv">이미지</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"제목이 필요하다면 여기에"</span></code></pre>
+
+## 기타
+### 자동 링크
+
+```markdown
+<http://testwebsite.com/>와
+[http://testwebsite.com/](http://testwebsite.com/)는 동일합니다.
+```
+
+### 이메일 자동 링크
+```markdown
+<foo@bar.com>
+```
+### 탈출 문자
+
+```markdown
+*별표 사이에 이 텍스트*를 치고 싶지만 기울이고 싶지는 않다면
+이렇게 하시면 됩니다. \*별표 사이에 이 텍스트\*.
+```
+
+### 키보드 키
+
+깃헙 전용 마크다운에서는 `<kbd>` 태그를 이용해 키보드 키를 나타낼 수 있습니다.
+
+```markdown
+컴퓨터가 멈췄다면 눌러보세요.
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+
+### 표
+
+표는 깃헙 전용 마크다운에서만 쓸 수 있고 다소 복잡하지만, 정말 쓰고 싶으시다면
+```markdown
+| 1열      | 2열        | 3열       |
+| :--------| :-------: | --------: |
+| 왼쪽 정렬 | 가운데 정렬 | 오른쪽 정렬 |
+| 머시기    | 머시기     | 머시기     |
+```
+혹은
+```markdown
+1열 | 2열 | 3열
+:-- | :-: | --:
+으악 너무 못생겼어 | 그만 | 둬
+```
+---
+추가 정보를 위해, 존 그루버의 공식 문법 [(영어) 문서](http://daringfireball.net/projects/markdown/syntax)와 애덤 프릿차드의 훌륭한 [(영어) 치트싯](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)을 확인하세요.
diff --git a/ko-kr/vim-kr.html.markdown b/ko-kr/vim-kr.html.markdown
new file mode 100644
index 00000000..cd0fa236
--- /dev/null
+++ b/ko-kr/vim-kr.html.markdown
@@ -0,0 +1,235 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Wooseop Kim", "https://github.com/linterpreteur"]
+filename: LearnVim-kr.txt
+lang: ko-kr
+---
+
+[Vim](http://www.vim.org)
+(Vi IMproved)은 유닉스의 인기 있는 vi 에디터의 클론입니다. Vim은 속도와 생산성을 위해
+설계된 텍스트 에디터로, 대부분의 유닉스 기반 시스템에 내장되어 있습니다. 다양한 단축 키를 통해
+파일 안에서 빠르게 이동하고 편집할 수 있습니다.
+
+## Vim 조작의 기본
+
+```
+    vim <filename>   # vim으로 <filename> 열기
+    :q               # vim 종료
+    :w               # 현재 파일 저장
+    :wq              # 파일 저장 후 종료
+    :q!              # 저장하지 않고 종료
+                     # ! *강제로* :q를 실행하여, 저장 없이 종료
+    :x               # 파일 저장 후 종료 (짧은 :wq)
+
+    u                # 동작 취소
+    CTRL+R           # 되돌리기
+
+    h                # 한 글자 왼쪽으로 이동
+    j                # 아래로 한 줄 이동
+    k                # 위로 한 줄 이동
+    l                # 한 글자 오른쪽으로 이동
+
+    # 줄 안에서의 이동
+
+    0                # 줄 시작으로 이동
+    $                # 줄 끝으로 이동
+    ^                # 줄의 공백이 아닌 첫 문자로 이동
+
+    # 텍스트 검색
+
+    /word            # 커서 뒤에 나타나는 해당 단어를 모두 하이라이트
+    ?word            # 커서 앞에 나타나는 해당 단어를 모두 하이라이트
+    n                # 해당 단어를 검색 후 다음으로 나타나는 위치로 이동
+    N                # 이전에 나타나는 위치로 이동
+
+    :%s/foo/bar/g    # 파일 모든 줄에 있는 'foo'를 'bar'로 치환
+    :s/foo/bar/g     # 현재 줄에 있는 'foo'를 'bar'로 치환
+
+    # 문자로 이동
+
+    f<character>     # <character>로 건너뛰기
+    t<character>     # <character>의 바로 뒤로 건너뛰기 
+
+    # 예를 들어,  
+    f<               # <로 건너뛰기
+    t<               # <의 바로 뒤로 건너뛰기
+    
+    # 단어 단위로 이동
+
+    w                # 한 단어 오른쪽으로 이동
+    b                # 한 단어 왼쪽으로 이동
+    e                # 현재 단어의 끝으로 이동
+
+    # 기타 이동 명령어
+
+    gg               # 파일 맨 위로 이동
+    G                # 파일 맨 아래로 이동
+    :NUM             # 줄 수 NUM(숫자)로 가기
+    H                # 화면 꼭대기로 이동
+    M                # 화면 중간으로 이동
+    L                # 화면 바닥으로 이동
+```
+
+## 모드
+
+Vim은 **모드**의 개념에 기초를 두고 있습니다.
+
+명령어 모드   - vim을 시작하면 처음에 이 모드입니다. 이동과 명령어 입력에 사용합니다.
+삽입 모드     - 파일을 수정합니다.
+비주얼 모드   - 텍스트를 하이라이트하고 그 텍스트에 대한 작업을 합니다.
+실행 모드     - ':' 이후 명령어를 입력합니다.
+
+```
+    i                # 커서 위치 앞에서 삽입 모드로 변경
+    a                # 커서 위치 뒤에서 삽입 모드로 변경
+    v                # 비주얼 모드로 변경    
+    :                # 실행 모드로 변경
+    <esc>            # 현재 모드를 벗어나 명령어 모드로 변경
+
+    # 복사와 붙여넣기
+
+    y                # 선택한 객체 복사(Yank)
+    yy               # 현재 줄 복사
+    d                # 선택한 객체 삭제
+    dd               # 현재 줄 삭제
+    p                # 커서 위치 뒤에 복사한 텍스트 붙여넣기
+    P                # 커서 위치 뒤에 복사한 텍스트 붙여넣기
+    x                # 현재 커서 위치의 문자 삭제
+```
+
+## vim의 문법
+
+Vim의 명령어는 '서술어-수식어-목적어'로 생각할 수 있습니다.
+
+서술어     - 취할 동작 
+수식어     - 동작을 취할 방식
+목적어     - 동작을 취할 객체
+
+'서술어', '수식어', '목적어'의 예시는 다음과 같습니다.
+
+```
+    # '서술어'
+ 
+    d                # 지운다
+    c                # 바꾼다
+    y                # 복사한다
+    v                # 선택한다
+
+    # '수식어'
+
+    i                # 안에
+    a                # 근처에
+    NUM              # (숫자)
+    f                # 찾아서 그곳에
+    t                # 찾아서 그 앞에
+    /                # 문자열을 커서 뒤로 찾아서
+    ?                # 문자열을 커서 앞으로 찾아서
+
+    # '목적어'
+
+    w                # 단어를
+    s                # 문장을
+    p                # 문단을
+    b                # 블락을
+    
+    # 예시 '문장' (명령어)
+
+    d2w              # 단어 2개를 지운다
+    cis              # 문장 안을 바꾼다
+    yip              # 문단 안을 복사한다
+    ct<              # 여는 괄호까지 바꾼다
+                     # 현재 위치에서 다음 여는 괄호까지의 텍스트를 바꾼다
+    d$               # 줄 끝까지 지운다
+```
+
+## 몇 가지 트릭
+
+        <!--TODO: Add more!-->
+```
+    >                # 선택한 영역 한 칸 들여쓰기
+    <                # 선택한 영역 한 칸 내어쓰기
+    :earlier 15m     # 15분 전의 상태로 되돌리기
+    :later 15m       # 위의 명령어를 취소
+    ddp              # 이어지는 줄과 위치 맞바꾸기 (dd 후 p)
+    .                # 이전 동작 반복
+    :w !sudo tee %   # 현재 파일을 루트 권한으로 저장
+```
+
+## 매크로
+
+매크로는 기본적으로 녹화할 수 있는 동작을 말합니다.
+매크로를 녹화하기 시작하면, 끝날 때까지 **모든** 동작과 명령어가 녹화됩니다.
+매크로를 호출하면 선택한 텍스트에 대해 정확히 같은 순서의 동작과 명령어가 실행됩니다.
+
+```
+    qa               # 'a'라는 이름의 매크로 녹화 시작
+    q                # 녹화 중지
+    @a               # 매크로 실행
+```
+
+### ~/.vimrc 설정
+
+.vimrc 파일은 Vim이 시작할 때의 설정을 결정합니다.
+
+다음은 ~/.vimrc 파일의 예시입니다.
+
+```
+" ~/.vimrc 예시
+" 2015.10 
+
+" vim이 iMprove 되려면 필요
+set nocompatible
+
+" 자동 들여쓰기 등을 위해 파일 명으로부터 타입 결정
+filetype indent plugin on
+
+" 신택스 하이라이팅 켜기
+syntax on
+
+" 커맨드 라인 완성 향상
+set wildmenu
+
+" 대문자를 썼을 때가 아니면 대소문자 구분하지 않고 검색
+set ignorecase
+set smartcase
+
+" 줄넘김을 했을 때 파일에 따른 들여쓰기가 켜져 있지 않다면
+" 현재 줄과 같은 들여쓰기를 유지
+set autoindent
+
+" 좌측에 줄 번호 표시
+set number
+
+" 들여쓰기 설정 (개인 기호에 따라 변경)
+
+" 탭 하나와 시각적으로 같을 스페이스 개수
+set tabstop=4
+
+" 편집할 때 탭 하나에 들어갈 스페이스 수
+set softtabstop=4
+
+" 들여쓰기 혹은 내어쓰기 작업(>>, <<)을 했을 때 움직일 스페이스 개수
+set shiftwidth=4
+
+" 탭을 스페이스로 변환
+set expandtab
+
+" 들여쓰기와 정렬에 자동 탭 및 스페이스 사용
+set smarttab
+```
+
+### 참고 자료
+
+[(영어) Vim 홈페이지](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[(영어) vim 입문과 기초](https://danielmiessler.com/study/vim/)
+
+[(영어) 엄마가 말해주지 않은 Vim의 어두운 구석들 (Stack Overflow 게시물)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[(영어) 아치 리눅스 위키](https://wiki.archlinux.org/index.php/Vim)
diff --git a/ko-kr/xml-kr.html.markdown b/ko-kr/xml-kr.html.markdown
new file mode 100644
index 00000000..9beef581
--- /dev/null
+++ b/ko-kr/xml-kr.html.markdown
@@ -0,0 +1,168 @@
+---
+language: xml
+filename: learnxml-kr.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+  - ["Rachel Stiyer", "https://github.com/rstiyer"]
+  - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+  - ["Wooseop Kim", "https://github.com/linterpreteur"]
+lang: ko-kr
+---
+
+XML은 데이터를 저장하고 전송하기 위해 설계된 마크업 언어입니다. 인간과 기계 모두가 읽을 수 있도록 만들어졌습니다.
+
+XML은 HTML과는 달리 데이터를 보여주는 방법이나 그 형식을 특정하지 않습니다. 단지 데이터를 담을 뿐입니다.
+
+차이는 **내용**과 **마크업**에 있습니다. 내용은 무엇이든 될 수 있지만, 마크업은 정의되어 있습니다.
+
+## 기초 정의 및 도입
+
+XML 문서는 기본적으로 자신을 설명하는 *속성*을 가질 수 있으며 자식으로서 텍스트 혹은 다른 요소를 가질 수 있는 *요소*들로 이루어집니다. 모든 XML 문서는 반드시 루트 요소를 가져야 합니다. 루트 요소는 문서에 있는 모든 다른 요소들의 조상입니다.
+
+XML 파서는 매우 엄격하게 설계되어 있으므로 문서의 형식이 틀렸다면 파싱을 멈출 것입니다. 그러므로 모든 XML 문서는 [(영어) XML 문법 규칙](http://www.w3schools.com/xml/xml_syntax.asp)을 따른다고 보장할 수 있습니다.
+
+```xml
+<!-- 주석에는 두 개의 연속된 하이픈(-)이 들어갈 수 없습니다. -->
+<!-- 주석은 여러 줄로
+  이어질 수 있습니다. -->
+
+<!-- 요소 -->
+<!-- 요소는 XML의 기본적 구성품입니다. 요소에는 두 개의 유형이 있습니다. -->
+<element1 attribute="value" /> <!-- 빈 요소는 내용을 담지 않습니다. -->
+<!-- 그리고 비지 않은 요소가 있습니다. -->
+<element2 attribute="value">내용</element2>
+<!-- 요소 이름에는 알파벳과 숫자만이 허용됩니다. -->
+
+<empty /> <!-- 요소는 어떠한 내용도 없이 순수한 마크업인 -->
+<!-- 빈 요소 태그로 구성될 수 있습니다. -->
+
+<notempty> <!-- 혹은 여는 태그와 -->
+  <!-- 내용, -->
+</notempty> <!-- 그리고 닫는 태그로 구성될 수도 잇습니다. -->
+
+<!-- 요소 이름은 대소문자를 구별합니다. -->
+<element />
+<eLEMENT />
+<!-- 둘은 같지 않습니다. -->
+
+<!-- 속성 -->
+<!-- 속성은 요소 안에 존재하는 키와 값의 쌍입니다. -->
+<element attribute="value" another="anotherValue" many="space-separated list" />
+<!-- 속성은 원소에서 단 한 번만 나타날 수 있습니다. 속성은 단 하나의 값만 갖습니다.
+  이에 대한 흔한 해결책은 공백으로 구분된 리스트를 포함하는 것입니다. -->
+
+<!-- 중첩 요소 -->
+<!-- 한 요소의 내용은 다른 요소들을 포함할 수 있습니다. -->
+<parent>
+  <child>Text</child>
+  <emptysibling />
+</parent>
+<!-- 표준적인 트리 명칭이 사용됩니다. 각각의 요소는 노드라고 부릅니다.
+  한 단계 위의 조상은 부모이며, 한 단계 아래의 후손은 자식입니다.
+  같은 부모 요소를 가진 요소들은 자매입니다. -->
+
+<!-- XML은 공백을 보존합니다. -->
+<child>
+  Text
+</child>
+<child>Text</child>
+<!-- 둘은 같지 않습니다. -->
+```
+
+## XML 문서
+
+XML이 유용한 것은 인간도 읽을 수 있다는 것입니다. 다음의 문서는 에릭 레이의 XML 배우기를 포함해 세 권의 책을 파는 서점을 정의한다는 것을 알 수 있습니다. XML 파서 없이도 이렇게 쉽습니다.
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- XML 프롤로그라는 것입니다. 필수는 아니지만, 권장됩니다. -->
+<bookstore>
+  <book category="COOKING">
+    <title lang="ko">매일 이탈리아 요리</title>
+    <author>지아다 데 라우렌티스</author>
+    <year>2005</year>
+    <price>30.00</price>
+  </book>
+  <book category="CHILDREN">
+    <title lang="ko">해리 포터</title>
+    <author>J K 롤링</author>
+    <year>2005</year>
+    <price>29.99</price>
+  </book>
+  <book category="WEB">
+    <title lang="ko">XML 배우기</title>
+    <author>에릭 레이</author>
+    <year>2003</year>
+    <price>39.95</price>
+  </book>
+</bookstore>
+```
+
+## 적격성과 유효성
+
+XML 문서는 문법적으로 정확할 경우 *적격*합니다. 하지만 문서 유형 정의(DTD)를 이용하여 문서에 제약을 더 추가할 수 있습니다. 한 문서의 요소와 속성이 DTD 안에 정의되어 있고 그 파일에 특정된 문법을 따른다면 *적격*할 뿐만 아니라 그 DTD에 대하여 *유효*하다고 말합니다.
+
+```xml
+<!-- DTD를 외부에 선언: -->
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE bookstore SYSTEM "Bookstore.dtd">
+<!-- bookstore가 루트 요소이며 'Bookstore.dtd'가 DTD 파일의
+  경로임을 선언합니다. -->
+<bookstore>
+  <book category="COOKING">
+    <title lang="en">Everyday Italian</title>
+    <author>Giada De Laurentiis</author>
+    <year>2005</year>
+    <price>30.00</price>
+  </book>
+</bookstore>
+
+<!-- DTD 파일 -->
+<!ELEMENT bookstore (book+)>
+<!-- bookstore 요소는 하나 이상의 book 요소를 자식으로 가질 수 있습니다. -->
+<!ELEMENT book (title, price)>
+<!-- 각각의 book은 title과 price를 자식으로 반드시 갖습니다. -->
+<!ATTLIST book category CDATA "Literature">
+<!-- book은 category 속성을 가져야 합니다. 그렇지 않다면 그 기본값은 'Literature'입니다. -->
+<!ELEMENT title (#PCDATA)>
+<!-- title 요소는 반드시 PCDATA만 포함해야 합니다. 즉,
+  파서가 읽을 텍스트만을 포함해야 하며 자식을 포함할 수 없습니다.
+  CDATA와 비교해 보세요. -->
+<!ELEMENT price (#PCDATA)>
+]>
+
+<!-- DTD는 XML 파일 안에 선언될 수도 있습니다. -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE bookstore [
+<!ELEMENT bookstore (book+)>
+<!ELEMENT book (title, price)>
+<!ATTLIST book category CDATA "Literature">
+<!ELEMENT title (#PCDATA)>
+<!ELEMENT price (#PCDATA)>
+]>
+
+<bookstore>
+  <book category="COOKING">
+    <title>Everyday Italian</title>
+    <price>30.00</price>
+  </book>
+</bookstore>
+```
+
+## DTD 호환성과 XML 스키마 정의
+
+DTD는 오래되었기 때문에 지원이 광범위합니다. 불행히도 네임스페이스와 같은 현대적 XML 기능은 DTD에서 지원하지 않습니다. XML 스키마 정의(XSD)가 XML 문서의 문법을 정의하기 위한 DTD의 대체재입니다.
+
+## Resources
+
+* [(영어) Validate your XML](http://www.xmlvalidation.com)
+
+## Further Reading
+
+* [(영어) XML 스키마 정의 튜토리얼](http://www.w3schools.com/xml/xml_schema.asp)
+* [(영어) DTD 튜토리얼](http://www.w3schools.com/xml/xml_dtd_intro.asp)
+* [(영어) XML 튜토리얼](http://www.w3schools.com/xml/default.asp)
+* [(영어) XPath 쿼리로 XML 파싱하기](http://www.w3schools.com/xml/xml_xpath.asp)
diff --git a/ko-kr/yaml-kr.html.markdown b/ko-kr/yaml-kr.html.markdown
new file mode 100644
index 00000000..b6d1de41
--- /dev/null
+++ b/ko-kr/yaml-kr.html.markdown
@@ -0,0 +1,172 @@
+---
+language: yaml
+filename: learnyaml-kr.yaml
+contributors:
+  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+  - ["Suhas SG", "https://github.com/jargnar"]
+translators:
+  - ["Wooseop Kim", "https://github.com/linterpreteur"]
+lang: ko-kr
+---
+
+YAML은 인간이 직접 쓰고 읽을 수 있도록 설계된 데이터 직렬화 언어입니다.
+
+YAML은 마치 파이썬처럼 개행과 들여쓰기에 문법적으로 의미를 준 JSON의 엄격한 수퍼셋입니다.
+하지만 파이썬과는 달리 YAML은 탭 문자를 전혀 허용하지 않습니다.
+
+```yaml
+# YAML의 주석은 이런 식입니다.
+
+############
+# 스칼라 형 #
+############
+
+# 문서 내내 이어질 루트 객체는 맵입니다.
+# 맵은 다른 언어의 딕셔너리, 해시, 혹은 객체에 해당됩니다.
+키: 값
+다른_키: 다른 값이 여기 옵니다.
+숫자_값: 100
+# 숫자 1을 값으로 가지기 위해서는 따옴표에 담아야 합니다.
+# 그러지 않는다면 YAML 파서는 그것을 참 값을 가지는 불리언으로 해석할 것입니다.
+과학적_표기법: 1e+12
+불리언: true
+널_값: null
+띄어서 쓴 키: 값
+# 문자열에 따옴표를 칠 필요는 없습니다. 하지만 칠 수도 있습니다.
+하지만: "따옴표에 담은 문자열"
+"키도 따옴표에 담을 수 있습니다.": "키에 ':'을 넣고 싶다면 유용합니다."
+
+# 여러 줄의 문자열은 (|을 이용한) '리터럴 블락' 혹은 (>을 이용한) '접은 블락'으로
+# 쓸 수 있습니다.
+리터럴_블락: |
+    개행을 포함한 이 모든 덩어리가 '리터럴_블락' 키에 대응하는 값이 될 것입니다.
+    
+    리터럴 값은 들여쓰기가 끝날 때까지 계속되며 들여쓰기는 문자열에 포함되지
+    않습니다.
+    
+        '들여쓰기를 더 한' 줄은 나머지 들여쓰기를 유지합니다.
+        이 줄은 띄어쓰기 4개만큼 들여쓰기 됩니다.
+접는_방식: >
+    이 텍스트 덩어리가 전부 '접는_방식' 키의 값이 되지만, 이번에는 모든 개행 문자가
+    띄어쓰기 하나로 대체됩니다.
+
+    위와 같이 텅 빈 줄은 개행 문자로 바뀝니다.
+
+        '더 들여쓴' 줄 역시 개행 문자를 유지합니다.
+        이 텍스트는 두 줄에 걸쳐 나타날 것입니다.
+
+##########
+# 모임 형 #
+##########
+
+# 중첩은 들여쓰기로 가능합니다.
+중첩된_맵:
+    키: 값
+    다른_키: 다른 값
+    다른_중첩된_맵:
+        안녕: 안녕
+
+# 맵은 반드시 문자열 키를 가지는 것은 아닙니다.
+0.25: 실수형 키
+
+# 키는 여러 줄에 걸친 객체와 같이 복합적일 수도 있습니다.
+# ?와 그 뒤의 띄어쓰기로 복합 키의 시작을 나타냅니다.
+? |
+    여러 줄짜리
+    키
+: 그리고 그 값
+
+# YAML은 복합 키 문법으로 연속열 간의 매핑을 지원합니다.
+# 일부 파서는 지원하지 않을 수 있습니다.
+# 예시
+? - 맨체스터 유나이티드
+  - 레알 마드리드
+: [ 2001-01-01, 2002-02-02 ]
+
+# 리스트 혹은 배열에 대응되는 연속열은 다음과 같습니다.
+연속열:
+    - 하나
+    - 둘
+    - 0.5 # 연속열은 다른 형을 포함 가능
+    - 넷
+    - 키: 값
+      다른_키: 다른_값
+    -
+        - 연속열 안의
+        - 또 다른 연속열
+
+# YAML은 JSON의 수퍼셋이기 때문에, JSON식으로 맵과 연속열을 작성할 수도
+# 있습니다.
+제이슨_맵: {"키": "값"}
+제이슨_열: [3, 2, 1, "발사"]
+
+#################
+# 기타 YAML 기능 #
+#################
+
+# YAML은 '앵커'라는 편리한 기능이 있습니다. 앵커를 이용하면 문서에서
+# 손쉽게 내용을 복제할 수 있습니다. 이 키들은 같은 값을 갖습니다.
+앵커된_내용: &앵커_이름 이 문자열은 두 키의 값으로 나타납니다.
+다른_앵커: *앵커_이름
+
+# 앵커는 속성을 복제하거나 상속할 수 있습니다.
+기반: &기반
+    이름: 모두 이름이 같다
+
+멍멍: &멍멍
+    <<: *기반
+    나이: 10
+
+야옹: &야옹
+    <<: *기반
+    나이: 20
+
+# 멍멍이와 야옹이는 같은 이름, '모두 이름이 같다'를 같습니다.
+
+# 또한 YAML에는 명시적으로 형을 선언할 수 있는 태그가 있습니다.
+명시적_문자열: !!str 0.5
+# 파이썬의 복소수 형을 나타내는 다음 태그처럼, 일부 파서는 언어에 종속된 태그를
+# 구현합니다.
+파이썬_복소수: !!python/complex 1+2j
+
+# YAML 복합 키를 언어 종속 태그와 함께 사용할 수도 있습니다.
+? !!python/tuple [5, 7]
+: 오십칠
+# 파이썬에서의 {(5, 7): '오십칠'} 객체
+
+###############
+# 기타 YAML 형 #
+###############
+
+# Strings and numbers aren't the only scalars that YAML can understand.
+# YAML이 이해할 수 있는 스칼라는 문자열과 수만 있는 것은 아닙니다.
+# ISO 형식 날짜와 시간 리터럴 또한 해석됩니다.
+시간: 2001-12-15T02:59:43.1Z
+띄어쓰기_한_시간: 2001-12-14 21:59:43.10 -5
+날짜: 2002-12-14
+
+# !!binary 태그는 문자열이 실제로는 base64로 인코딩된
+# 이진수 객체(BLOB)라는 것을 나타냅니다.
+이미지_파일: !!binary |
+    R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+    OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+    +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+    AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML에는 다음과 같은 집합도 있습니다.
+집합:
+    ? 하나
+    ? 둘
+    ? 셋
+
+# 파이썬과 마찬가지로 집합은 단지 널 값을 갖는 맵입니다. 위는 다음과 같습니다.
+집합2:
+    하나: null
+    둘: null
+    셋: null
+```
+
+### 더 읽기
+
++ [(영어) YAML 공식 사이트](http://yaml.org/)
++ [(영어) 온라인 YAML 검사기](http://codebeautify.org/yaml-validator)
diff --git a/kotlin.html.markdown b/kotlin.html.markdown
new file mode 100644
index 00000000..ca11ee3c
--- /dev/null
+++ b/kotlin.html.markdown
@@ -0,0 +1,379 @@
+---
+language: kotlin
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+filename: LearnKotlin.kt
+---
+
+Kotlin is a statically typed programming language for the JVM, Android and the
+browser. It is 100% interoperable with Java.
+[Read more here.](https://kotlinlang.org/)
+
+```kotlin
+// Single-line comments start with //
+/*
+Multi-line comments look like this.
+*/
+
+// The "package" keyword works in the same way as in Java.
+package com.learnxinyminutes.kotlin
+
+/*
+The entry point to a Kotlin program is a function named "main".
+The function is passed an array containing any command line arguments.
+*/
+fun main(args: Array<String>) {
+    /*
+    Declaring values is done using either "var" or "val".
+    "val" declarations cannot be reassigned, whereas "vars" can.
+    */
+    val fooVal = 10 // we cannot later reassign fooVal to something else
+    var fooVar = 10
+    fooVar = 20 // fooVar can be reassigned
+
+    /*
+    In most cases, Kotlin can determine what the type of a variable is,
+    so we don't have to explicitly specify it every time.
+    We can explicitly declare the type of a variable like so:
+    */
+    val foo: Int = 7
+
+    /*
+    Strings can be represented in a similar way as in Java.
+    Escaping is done with a backslash.
+    */
+    val fooString = "My String Is Here!"
+    val barString = "Printing on a new line?\nNo Problem!"
+    val bazString = "Do you want to add a tab?\tNo Problem!"
+    println(fooString)
+    println(barString)
+    println(bazString)
+
+    /*
+    A raw string is delimited by a triple quote (""").
+    Raw strings can contain newlines and any other characters.
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Hello, world!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    Strings can contain template expressions.
+    A template expression starts with a dollar sign ($).
+    */
+    val fooTemplateString = "$fooString has ${fooString.length} characters"
+    println(fooTemplateString)
+
+    /*
+    For a variable to hold null it must be explicitly specified as nullable.
+    A variable can be specified as nullable by appending a ? to its type.
+    We can access a nullable variable by using the ?. operator.
+    We can use the ?: operator to specify an alternative value to use
+    if a variable is null.
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    Functions can be declared using the "fun" keyword.
+    Function arguments are specified in brackets after the function name.
+    Function arguments can optionally have a default value.
+    The function return type, if required, is specified after the arguments.
+    */
+    fun hello(name: String = "world"): String {
+        return "Hello, $name!"
+    }
+    println(hello("foo")) // => Hello, foo!
+    println(hello(name = "bar")) // => Hello, bar!
+    println(hello()) // => Hello, world!
+
+    /*
+    A function parameter may be marked with the "vararg" keyword
+    to allow a variable number of arguments to be passed to the function.
+    */
+    fun varargExample(vararg names: Int) {
+        println("Argument has ${names.size} elements")
+    }
+    varargExample() // => Argument has 0 elements
+    varargExample(1) // => Argument has 1 elements
+    varargExample(1, 2, 3) // => Argument has 3 elements
+
+    /*
+    When a function consists of a single expression then the curly brackets can
+    be omitted. The body is specified after a = symbol.
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // If the return type can be inferred then we don't need to specify it.
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // Functions can take functions as arguments and return functions.
+    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // Named functions can be specified as arguments using the :: operator.
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // Lambda expressions can be specified as arguments.
+    val notZero = not {n -> n == 0}
+    /*
+    If a lambda has only one parameter
+    then its declaration can be omitted (along with the ->).
+    The name of the single parameter will be "it".
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // The "class" keyword is used to declare classes.
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int): Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    To create a new instance we call the constructor.
+    Note that Kotlin does not have a "new" keyword.
+    */
+    val fooExampleClass = ExampleClass(7)
+    // Member functions can be called using dot notation.
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    If a function has been marked with the "infix" keyword then it can be
+    called using infix notation.
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    Data classes are a concise way to create classes that just hold data.
+    The "hashCode"/"equals" and "toString" methods are automatically generated.
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // Data classes have a "copy" function.
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // Objects can be destructured into multiple variables.
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+    
+    // destructuring in "for" loop
+    for ((a, b, c) in listOf(fooData)) {
+        println("$a $b $c") // => 1 100 4
+    }
+    
+    val mapData = mapOf("a" to 1, "b" to 2)
+    // Map.Entry is destructurable as well
+    for ((key, value) in mapData) {
+        println("$key -> $value")
+    }
+
+    // The "with" function is similar to the JavaScript "with" statement.
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    We can create a list using the "listOf" function.
+    The list will be immutable - elements cannot be added or removed.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // Elements of a list can be accessed by their index.
+    println(fooList[1]) // => b
+
+    // A mutable list can be created using the "mutableListOf" function.
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // We can create a set using the "setOf" function.
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // We can create a map using the "mapOf" function.
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // Map values can be accessed by their key.
+    println(fooMap["a"]) // => 8
+
+    /*
+    Sequences represent lazily-evaluated collections.
+    We can create a sequence using the "generateSequence" function.
+    */
+    val fooSequence = generateSequence(1, { it + 1 })
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // An example of using a sequence to generate Fibonacci numbers:
+    fun fibonacciSequence(): Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next(): Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin provides higher-order functions for working with collections.
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "even" else "odd"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // A "for" loop can be used with anything that provides an iterator.
+    for (c in "hello") {
+        println(c)
+    }
+
+    // "while" loops work in the same way as other languages.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    "if" can be used as an expression that returns a value.
+    For this reason the ternary ?: operator is not needed in Kotlin.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "even" else "odd"
+    println("$num is $message") // => 5 is odd
+
+    // "when" can be used as an alternative to "if-else if" chains.
+    val i = 10
+    when {
+        i < 7 -> println("first block")
+        fooString.startsWith("hello") -> println("second block")
+        else -> println("else block")
+    }
+
+    // "when" can be used with an argument.
+    when (i) {
+        0, 21 -> println("0 or 21")
+        in 1..20 -> println("in the range 1 to 20")
+        else -> println("none of the above")
+    }
+
+    // "when" can be used as a function that returns a value.
+    var result = when (i) {
+        0, 21 -> "0 or 21"
+        in 1..20 -> "in the range 1 to 20"
+        else -> "none of the above"
+    }
+    println(result)
+
+    /*
+    We can check if an object is a particular type by using the "is" operator.
+    If an object passes a type check then it can be used as that type without
+    explicitly casting it.
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x is automatically cast to Boolean
+            return x
+        } else if (x is Int) {
+            // x is automatically cast to Int
+            return x > 0
+        } else if (x is String) {
+            // x is automatically cast to String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hello, world!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    // Smartcast also works with when block
+    fun smartCastWhenExample(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    Extensions are a way to add new functionality to a class.
+    This is similar to C# extension methods.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hello, world!".remove('l')) // => Heo, word!
+
+    println(EnumExample.A) // => A
+    println(ObjectExample.hello()) // => hello
+}
+
+// Enum classes are similar to Java enum types.
+enum class EnumExample {
+    A, B, C
+}
+
+/*
+The "object" keyword can be used to create singleton objects.
+We cannot instantiate it but we can refer to its unique instance by its name.
+This is similar to Scala singleton objects.
+*/
+object ObjectExample {
+    fun hello(): String {
+        return "hello"
+    }
+}
+
+fun useObject() {
+    ObjectExample.hello()
+    val someRef: Any = ObjectExample // we use objects name just as is
+}
+
+```
+
+### Further Reading
+
+* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/)
+* [Try Kotlin in your browser](http://try.kotlinlang.org/)
+* [A list of Kotlin resources](http://kotlin.link/)
diff --git a/latex.html.markdown b/latex.html.markdown
index 2492f226..a3866892 100644
--- a/latex.html.markdown
+++ b/latex.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Colton Kohnke", "http://github.com/voltnor"]
     - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
     - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"]
+    - ["Svetlana Golubeva", "https://attillax.github.io/"]
 filename: learn-latex.tex
 ---
 
@@ -27,14 +28,17 @@ filename: learn-latex.tex
 % If you want to include graphics, colored text, or
 % source code from another language file into your document, 
 % you need to enhance the capabilities of LaTeX. This is done by adding packages. 
-% I'm going to include the float and caption packages for figures.
+% I'm going to include the float and caption packages for figures
+% and hyperref package for hyperlinks
 \usepackage{caption}
 \usepackage{float}
+\usepackage{hyperref}
 
 % We can define some other document properties too!
-\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
+\author{Chaitanya Krishna Ande, Colton Kohnke, Sricharan Chiruvolu \& \\
+Svetlana Golubeva}
 \date{\today}
-\title{Learn LaTeX in Y Minutes!}
+\title{Learn \LaTeX \hspace{1pt} in Y Minutes!}
 
 % Now we're ready to begin the document
 % Everything before this line is called "The Preamble"
@@ -43,18 +47,28 @@ filename: learn-latex.tex
 % create a title page for us.
 \maketitle
 
+% If we have sections, we can create table of contents. We have to compile our
+% document twice to make it appear in right order.
+% It is a good practice to separate the table of contents form the body of the 
+% document. To do so we use \newpage command
+\newpage
+\tableofcontents
+
+\newpage
+
 % Most research papers have abstract, you can use the predefined commands for this.
 % This should appear in its logical order, therefore, after the top matter,
 % but before the main sections of the body. 
 % This command is available in the document classes article and report.
 \begin{abstract}
- LaTeX documentation written as LaTeX! How novel and totally not my idea!
+ \LaTeX \hspace{1pt} documentation written as \LaTeX! How novel and totally not
+ my idea!
 \end{abstract}
 
 % Section commands are intuitive. 
 % All the titles of the sections are added automatically to the table of contents.
 \section{Introduction}
-Hello, my name is Colton and together we're going to explore LaTeX!
+Hello, my name is Colton and together we're going to explore \LaTeX!
 
 \section{Another section}
 This is the text for another section. I think it needs a subsection.
@@ -72,12 +86,14 @@ Much better now.
 However not all sections have to be numbered!
 
 \section{Some Text notes}
-LaTeX is generally pretty good about placing text where it should go. If 
-a line \\ needs \\ to \\ break \\ you add \textbackslash\textbackslash to 
-the source code. \\ 
+%\section{Spacing} % Need to add more information about space intervals
+\LaTeX \hspace{1pt} is generally pretty good about placing text where it should
+go. If 
+a line \\ needs \\ to \\ break \\ you add \textbackslash\textbackslash 
+\hspace{1pt} to the source code. \\ 
 
 \section{Lists}
-Lists are one of the easiest things to create in LaTeX! I need to go shopping
+Lists are one of the easiest things to create in \LaTeX! I need to go shopping
 tomorrow, so let's make a grocery list.
 \begin{enumerate} % This creates an "enumerate" environment.
   % \item tells the enumerate to increment
@@ -93,15 +109,15 @@ tomorrow, so let's make a grocery list.
 
 \section{Math}
 
-One of the primary uses for LaTeX is to produce academic articles or 
-technical papers. Usually in the realm of math and science. As such, 
+One of the primary uses for \LaTeX \hspace{1pt} is to produce academic articles
+or technical papers. Usually in the realm of math and science. As such, 
 we need to be able to add special symbols to our paper! \\
 
 Math has many symbols, far beyond what you can find on a keyboard;
 Set and relation symbols, arrows, operators, and Greek letters to name a few.\\
 
 Sets and relations play a vital role in many mathematical research papers.
-Here's how you state all y that belong to X, $\forall$ x $\in$ X. \\
+Here's how you state all x that belong to X, $\forall$ x $\in$ X. \\
 % Notice how I needed to add $ signs before and after the symbols. This is 
 % because when writing, we are in text-mode. 
 % However, the math symbols only exist in math-mode. 
@@ -112,27 +128,27 @@ Here's how you state all y that belong to X, $\forall$ x $\in$ X. \\
 \[a^2 + b^2 = c^2 \]
 
 My favorite Greek letter is $\xi$. I also like $\beta$, $\gamma$ and $\sigma$.
-I haven't found a Greek letter that yet that LaTeX doesn't know about!
+I haven't found a Greek letter yet that \LaTeX \hspace{1pt} doesn't know
+about! \\
 
 Operators are essential parts of a mathematical document: 
 trigonometric functions ($\sin$, $\cos$, $\tan$), 
 logarithms and exponentials ($\log$, $\exp$), 
 limits ($\lim$), etc. 
 have per-defined LaTeX commands. 
-Let's write an equation to see how it's done: \\
-
-$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
+Let's write an equation to see how it's done: 
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\
 
-Fractions(Numerator-denominators) can be written in these forms:
+Fractions (Numerator-denominators) can be written in these forms:
 
 % 10 / 7
-$^{10}/_{7}$ 
+$$ ^{10}/_{7} $$
 
 % Relatively complex fractions can be written as
 % \frac{numerator}{denominator}
-$\frac{n!}{k!(n - k)!}$ \\
+$$ \frac{n!}{k!(n - k)!} $$ \\
 
-We can also insert equations in an "equation environment". 
+We can also insert equations in an ``equation environment''.
 
 % Display math with the equation 'environment'
 \begin{equation} % enters math-mode
@@ -178,19 +194,17 @@ We can also insert Tables in the same way as figures.
   % the {} arguments below describe how each row of the table is drawn.
   % Again, I have to look these up. Each. And. Every. Time.
   \begin{tabular}{c|cc} 
-    Number &  Last Name & First Name \\ % Column rows are separated by $
+    Number &  Last Name & First Name \\ % Column rows are separated by &
     \hline % a horizontal line
     1 & Biggus & Dickus \\
     2 & Monty & Python
   \end{tabular}
 \end{table}
 
-% \section{Hyperlinks} % Coming soon
-
-\section{Getting LaTeX to not compile something (i.e. Source Code)}
-Let's say we want to include some code into our LaTeX document,
-we would then need LaTeX to not try and interpret that text and
-instead just print it to the document. We do this we a verbatim 
+\section{Getting \LaTeX \hspace{1pt} to not compile something (i.e. Source Code)}
+Let's say we want to include some code into our \LaTeX \hspace{1pt} document,
+we would then need \LaTeX \hspace{1pt} to not try and interpret that text and
+instead just print it to the document. We do this with a verbatim 
 environment. 
 
 % There are other packages that exist (i.e. minty, lstlisting, etc.)
@@ -204,26 +218,46 @@ environment.
 \section{Compiling} 
 
 By now you're probably wondering how to compile this fabulous document 
-and look at the glorious glory that is a LaTeX pdf.
-(yes, this document actually does compiles). \\
-Getting to the final document using LaTeX consists of the following steps:
+and look at the glorious glory that is a \LaTeX \hspace{1pt} pdf.
+(yes, this document actually does compile). \\
+Getting to the final document using \LaTeX \hspace{1pt} consists of the following 
+steps:
   \begin{enumerate}
-    \item Write the document in plain text (the "source code").
+    \item Write the document in plain text (the ``source code'').
     \item Compile source code to produce a pdf. 
-     The compilation step looks something like this (in Linux): \\
+     The compilation step looks like this (in Linux): \\
      \begin{verbatim} 
-        $pdflatex learn-latex.tex learn-latex.pdf 
+        > pdflatex learn-latex.tex
      \end{verbatim}
   \end{enumerate}
 
-A number of LaTeX editors combine both Step 1 and Step 2 in the same piece of
-software. So, you get to see Step 1, but not Step 2 completely.
-Step 2 is still happening behind the scenes.
+A number of \LaTeX \hspace{1pt}editors combine both Step 1 and Step 2 in the 
+same piece of software. So, you get to see Step 1, but not Step 2 completely.
+Step 2 is still happening behind the scenes\footnote{In cases, where you use
+references (like Eqn.~\ref{eq:pythagoras}), you may need to run Step 2
+multiple times, to generate an intermediary *.aux file.}.
+% Also, this is how you add footnotes to your document!
 
 You write all your formatting information in plain text in Step 1.
 The compilation part in Step 2 takes care of producing the document in the
 format you defined in Step 1.
 
+\section{Hyperlinks}
+We can also insert hyperlinks in our document. To do so we need to include the
+package hyperref into preamble with the command:
+\begin{verbatim} 
+    \usepackage{hyperref}
+\end{verbatim}
+
+There exists two main types of links: visible URL \\
+\url{https://learnxinyminutes.com/docs/latex/}, or  
+\href{https://learnxinyminutes.com/docs/latex/}{shadowed by text}
+% You can not add extra-spaces or special symbols into shadowing text since it 
+% will cause mistakes during the compilation
+
+This package also produces list of tumbnails in the output pdf document and 
+active links in the table of contents.
+
 \section{End}
 
 That's all for now!
@@ -233,7 +267,8 @@ That's all for now!
 \begin{thebibliography}{1}
   % similar to other lists, the \bibitem command can be used to list items
   % each entry can then be cited directly in the body of the text
-  \bibitem{latexwiki} The amazing LaTeX wikibook: {\em https://en.wikibooks.org/wiki/LaTeX}
+  \bibitem{latexwiki} The amazing \LaTeX \hspace{1pt} wikibook: {\em 
+https://en.wikibooks.org/wiki/LaTeX}
   \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
 \end{thebibliography}
 
diff --git a/less.html.markdown b/less.html.markdown
index 41d66a54..1b26eb99 100644
--- a/less.html.markdown
+++ b/less.html.markdown
@@ -6,9 +6,9 @@ contributors:
 ---
 
 Less is a CSS pre-processor, that adds features such as variables, nesting, mixins and more.
-Less (and other preprocessors, such as [Sass](http://sass-lang.com/) help developers to write maintainable and DRY (Don't Repeat Yourself) code.
+Less (and other preprocessors, such as [Sass](http://sass-lang.com/)) help developers to write maintainable and DRY (Don't Repeat Yourself) code.
 
-```less
+```css
 
 
 //Single line comments are removed when Less is compiled to CSS.
@@ -16,20 +16,20 @@ Less (and other preprocessors, such as [Sass](http://sass-lang.com/) help develo
 /*Multi line comments are preserved. */
 
 
-/*Variables
-==============================*/
 
+/* Variables
+==============================*/
 
 
 /* You can store a CSS value (such as a color) in a variable.
-Use the '@' symbol to create a variable. */
+   Use the '@' symbol to create a variable. */
 
-@primary-color: #A3A4FF;
-@secondary-color: #51527F;
+@primary-color: #a3a4ff;
+@secondary-color: #51527f;
 @body-font: 'Roboto', sans-serif;
 
 /* You can use the variables throughout your stylesheet.
-Now if you want to change a color, you only have to make the change once.*/
+   Now if you want to change a color, you only have to make the change once.*/
 
 body {
 	background-color: @primary-color;
@@ -38,24 +38,25 @@ body {
 }
 
 /* This would compile to: */
+
 body {
-	background-color: #A3A4FF;
+	background-color: #a3a4ff;
 	color: #51527F;
 	font-family: 'Roboto', sans-serif;
 }
 
 
 /* This is much more maintainable than having to change the color
-each time it appears throughout your stylesheet. */
+   each time it appears throughout your stylesheet. */
 
 
-/*Mixins
-==============================*/
 
+/* Mixins
+==============================*/
 
 
 /* If you find you are writing the same code for more than one
-element, you might want to reuse that easily.*/
+   element, you might want to reuse that easily.*/
 
 .center {
 	display: block;
@@ -72,7 +73,8 @@ div {
 	background-color: @primary-color;
 }
 
-/*Which would compile to: */
+/* Which would compile to: */
+
 .center {
   display: block;
   margin-left: auto;
@@ -86,10 +88,10 @@ div {
 	margin-right: auto;
 	left: 0;
 	right: 0;
-	background-color: #A3A4FF;
+	background-color: #a3a4ff;
 }
 
-/* You can omit the mixin code from being compiled by adding paranthesis
+/* You can omit the mixin code from being compiled by adding parenthesis
    after the selector */
 
 .center() {
@@ -105,33 +107,97 @@ div {
   background-color: @primary-color;
 }
 
-/*Which would compile to: */
+/* Which would compile to: */
 div {
   display: block;
   margin-left: auto;
   margin-right: auto;
   left: 0;
   right: 0;
-  background-color: #A3A4FF;
+  background-color: #a3a4ff;
 }
 
 
-/*Functions
+
+/* Nesting
 ==============================*/
 
 
+/* Less allows you to nest selectors within selectors */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #f00;
+	}
+}
+
+/* '&' will be replaced by the parent selector. */
+/* You can also nest pseudo-classes. */
+/* Keep in mind that over-nesting will make your code less maintainable.
+   Best practices recommend going no more than 3 levels deep when nesting.
+   For example: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Compiles to: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* Functions
+==============================*/
+
 
 /* Less provides functions that can be used to accomplish a variety of
-   tasks. Consider the following */
+   tasks. Consider the following: */
 
 /* Functions can be invoked by using their name and passing in the
-   required arguments */
+   required arguments. */
+
 body {
   width: round(10.25px);
 }
 
+.header {
+	background-color: lighten(#000, 0.5);
+}
+
 .footer {
-  background-color: fadeout(#000000, 0.25)
+  background-color: fadeout(#000, 0.25)
 }
 
 /* Compiles to: */
@@ -140,6 +206,10 @@ body {
   width: 10px;
 }
 
+.header {
+  background-color: #010101;
+}
+
 .footer {
   background-color: rgba(0, 0, 0, 0.75);
 }
@@ -148,19 +218,18 @@ body {
    mixins. When trying to choose between a function or a mixin, remember
    that mixins are best for generating CSS while functions are better for
    logic that might be used throughout your Less code. The examples in
-   the Math Operators' section are ideal candidates for becoming a reusable
+   the 'Math Operators' section are ideal candidates for becoming a reusable
    function. */
 
-/* This function will take a target size and the parent size and calculate
-   and return the percentage */
+/* This function calculates the average of two numbers: */
 
 .average(@x, @y) {
-  @average_result: ((@x + @y) / 2);
+  @average-result: ((@x + @y) / 2);
 }
 
 div {
   .average(16px, 50px); // "call" the mixin
-  padding: @average_result;    // use its "return" value
+  padding: @average-result;    // use its "return" value
 }
 
 /* Compiles to: */
@@ -169,11 +238,12 @@ div {
   padding: 33px;
 }
 
+
+
 /*Extend (Inheritance)
 ==============================*/
 
 
-
 /*Extend is a way to share the properties of one selector with another. */
 
 .display {
@@ -203,71 +273,10 @@ div {
 
 
 
-/*Nesting
-==============================*/
-
-
-
-/*Less allows you to nest selectors within selectors */
-
-ul {
-	list-style-type: none;
-	margin-top: 2em;
-
-	li {
-		background-color: #FF0000;
-	}
-}
-
-/* '&' will be replaced by the parent selector. */
-/* You can also nest pseudo-classes. */
-/* Keep in mind that over-nesting will make your code less maintainable.
-Best practices recommend going no more than 3 levels deep when nesting.
-For example: */
-
-ul {
-	list-style-type: none;
-	margin-top: 2em;
-
-	li {
-		background-color: red;
-
-		&:hover {
-		  background-color: blue;
-		}
-
-		a {
-		  color: white;
-		}
-	}
-}
-
-/* Compiles to: */
-
-ul {
-  list-style-type: none;
-  margin-top: 2em;
-}
-
-ul li {
-  background-color: red;
-}
-
-ul li:hover {
-  background-color: blue;
-}
-
-ul li a {
-  color: white;
-}
-
-
-
 /*Partials and Imports
 ==============================*/
 
 
-
 /* Less allows you to create partial files. This can help keep your Less
    code modularized. Partial files conventionally begin with an '_',
    e.g. _reset.less. and are imported into a main less file that gets
@@ -308,9 +317,9 @@ body {
 }
 
 
-/*Math Operations
-==============================*/
 
+/* Math Operations
+==============================*/
 
 
 /* Less provides the following operators: +, -, *, /, and %. These can
@@ -365,15 +374,16 @@ body {
 
 ## Practice Less
 
-If you want to play with Less in your browser, check out [LESS2CSS](http://lesscss.org/less-preview/).
+If you want to play with Less in your browser, check out:
+* [Codepen](http://codepen.io/)
+* [LESS2CSS](http://lesscss.org/less-preview/)
 
 ## Compatibility
 
-Less can be used in any project as long as you have a program to compile it
-into CSS. You'll want to verify that the CSS you're using is compatible
-with your target browsers.
+Less can be used in any project as long as you have a program to compile it into CSS. You'll want to verify that the CSS you're using is compatible with your target browsers.
 
 [QuirksMode CSS](http://www.quirksmode.org/css/) and [CanIUse](http://caniuse.com) are great resources for checking compatibility.
 
 ## Further reading
 * [Official Documentation](http://lesscss.org/features/)
+* [Less CSS - Beginner's Guide](http://www.hongkiat.com/blog/less-basic/)
diff --git a/logtalk.html.markdown b/logtalk.html.markdown
new file mode 100644
index 00000000..5a52bd3c
--- /dev/null
+++ b/logtalk.html.markdown
@@ -0,0 +1,543 @@
+---
+language: Logtalk
+contributors:
+    - ["Paulo Moura", "http://github.com/pmoura"]
+filename: learnlogtalk.lgt
+---
+
+Logtalk is an object-oriented logic programming language that extends and leverages Prolog with modern code encapsulation and code reuse mechanisms without compromising its declarative programming features. Logtalk is implemented in highly portable code and can use most modern and standards compliant Prolog implementations as a back-end compiler.
+
+To keep its size reasonable, this tutorial necessarily assumes that the reader have a working knowledge of Prolog and is biased towards describing Logtalk object-oriented features.
+
+# Syntax
+
+Logtalk uses standard Prolog syntax with the addition of a few operators and directives for a smooth learning curve and wide portability. One important consequence is that Prolog code can be easily encapsulated in objects with little or no changes. Moreover, Logtalk can transparently interpret most Prolog modules as Logtalk objects.
+
+The main operators are:
+
+* `::/2` - sending a message to an object
+* `::/1` - sending a message to _self_ (i.e. to the object that received the message being processed)
+* `^^/1` - _super_ call (of an inherited or imported predicate)
+
+Some of the most important entity and predicate directives will be introduced in the next sections.
+
+# Entities and roles
+
+Logtalk provides _objects_, _protocols_, and _categories_ as first-class entities. Relations between entities define _patterns of code reuse_ and the _roles_ played by the entities. For example, when an object _instantiates_ another object, the first object plays the role of an instance and the second object plays the role of a class. An _extends_ relation between two objects implies that both objects play the role of prototypes, with one of them extending the other, its parent prototype.
+
+# Defining an object
+
+An object encapsulates predicate declarations and definitions. Objects can be created dynamically but are usually static and defined in source files. A single source file can contain any number of entity definitions. A simple object, defining a list member public predicate:
+
+```logtalk
+:- object(list).
+
+	:- public(member/2).
+	member(Head, [Head| _]).
+	member(Head, [_| Tail]) :-
+		member(Head, Tail).
+
+:- end_object.
+```
+
+# Compiling source files
+
+Assuming that the code above for the `list` object is saved in a `list.lgt` file, it can be compiled and loaded using the `logtalk_load/1` built-in predicate or its abbreviation, `{}/1`, with the file path as argument (the extension can be omitted):
+
+```logtalk
+?- {list}.
+yes
+```
+
+# Sending a message to an object
+
+The `::/2` infix operator is used to send a message to an object. As in Prolog, we can backtrack for alternative solutions:
+
+```logtalk
+?- list::member(X, [1,2,3]).
+X = 1 ;
+X = 2 ;
+X = 3
+yes
+```
+
+Encapsulation is enforced. A predicate can be declared _public_, _protected_, or _private_. It can also be _local_ when there is no scope directive for it. For example:
+
+```logtalk
+:- object(scopes).
+
+	:- private(bar/0).
+	bar.
+
+	local.
+
+:- end_object.
+```
+
+Assuming the object is saved in a `scopes.lgt` file:
+
+```logtalk
+?- {scopes}.
+yes
+
+?- catch(scopes::bar, Error, true).
+Error = error(
+	permission_error(access, private_predicate, bar/0),
+	logtalk(scopes::bar, user)
+)
+yes
+
+?- catch(scopes::local, Error, true).
+Error = error(
+	existence_error(predicate_declaration, local/0),
+	logtalk(scopes::local, user)
+)
+yes
+```
+
+When the predicate in a message is unknown for the object (the role it plays determines the lookup procedures), we also get an error. For example:
+
+```logtalk
+?- catch(scopes::unknown, Error, true).
+Error = error(
+	existence_error(predicate_declaration, unknown/0),
+	logtalk(scopes::unknown, user)
+)
+yes
+```
+
+A subtle point is that predicate scope directives specify predicate _calling_ semantics, not _definition_ semantics. For example, if an object playing the role of a class declares a predicate private, the predicate can be defined in subclasses and instances *but* can only be called in its instances _from_ the class.
+
+# Defining and implementing a protocol
+
+Protocols contain predicate declarations that can be implemented by any number of objects and categories:
+
+```logtalk
+:- protocol(listp).
+
+	:- public(member/2).
+
+:- end_protocol.
+
+:- object(list,
+	implements(listp)).
+
+	member(Head, [Head| _]).
+	member(Head, [_| Tail]) :-
+		member(Head, Tail).
+
+:- end_object.
+```
+
+The scope of the protocol predicates can be restricted using protected or private implementation. For example:
+
+```logtalk
+:- object(stack,
+	implements(private::listp)).
+
+:- end_object.
+```
+
+In fact, all entity relations (in an entity opening directive) can be qualified as public (the default), protected, or private.
+
+# Prototypes
+
+An object without an _instantiation_ or _specialization_ relation with another object plays the role of a prototype. A prototype can _extend_ another object, its parent prototype.
+
+```logtalk
+% clyde, our prototypical elephant
+:- object(clyde).
+
+	:- public(color/1).
+	color(grey).
+
+	:- public(number_of_legs/1).
+	number_of_legs(4).
+
+:- end_object.
+
+% fred, another elephant, is like clyde, except that he's white
+:- object(fred,
+	extends(clyde)).
+
+	color(white).
+
+:- end_object.
+```
+
+When answering a message sent to an object playing the role of a prototype, we validate the message and look for an answer first in the prototype itself and, if not found, we delegate to the prototype parents if any:
+
+```logtalk
+?- fred::number_of_legs(N).
+N = 4
+yes
+
+?- fred::color(C).
+C = white
+yes
+```
+
+A message is valid if the corresponding predicate is declared (and the sender is within scope) but it will fail, rather then throwing an error, if the predicate is not defined. This is called the _closed-world assumption_. For example, consider the following object, saved in a `foo.lgt` file:
+
+```logtalk
+:- object(foo).
+
+	:- public(bar/0).
+
+:- end_object.
+```
+
+Loading the file and trying to call the `bar/0` predicate fails as expected. Note that this is different from calling an _unknown_ predicate, which results in an error:
+
+```logtalk
+?- {foo}.
+yes
+
+?- foo::bar.
+no
+
+?- catch(foo::baz, Error, true).
+Error = error(
+	existence_error(predicate_declaration, baz/0),
+	logtalk(foo::baz, user)
+)
+yes
+```
+
+# Classes and instances
+
+In order to define objects playing the role of classes and/or instances, an object must have at least an instantiation or a specialization relation with another object. Objects playing the role of meta-classes can be used when we need to see a class also as an instance. We use the following example to also illustrate how to dynamically create new objects at runtime:
+
+```logtalk
+% a simple, generic, metaclass defining a new/2 predicate for its instances
+:- object(metaclass,
+	instantiates(metaclass)).
+
+	:- public(new/2).
+	new(Instance, Clauses) :-
+		self(Class),
+		create_object(Instance, [instantiates(Class)], [], Clauses).
+
+:- end_object.
+
+% a simple class defining age/1 and name/1 predicate for its instances
+:- object(person,
+	instantiates(metaclass)).
+
+	:- public([
+		age/1, name/1
+	]).
+
+	% a default value for age/1
+	age(42).
+
+:- end_object.
+
+% a static instance of the class person
+:- object(john,
+	instantiates(person)).
+
+	name(john).
+	age(12).
+
+:- end_object.
+```
+
+When answering a message sent to an object playing the role of an instance, we validate the message by starting in its class and going up to its class superclasses if necessary. Assuming that the message is valid, then we look for an answer starting in the instance itself:
+
+```logtalk
+?- person::new(Instance, [name(paulo)]).
+Instance = o1
+yes
+
+?- o1::name(Name).
+Name = paulo
+yes
+
+?- o1::age(Age).
+Age = 42
+yes
+
+?- john::age(Age).
+Age = 12
+yes
+```
+
+# Categories
+
+A category is a fine grained unit of code reuse, used to encapsulate a _cohesive_ set of predicate declarations and definitions, implementing a _single_ functionality, that can be imported into any object. A category can thus be seen as the dual concept of a protocol. In the following example, we define categories representing car engines and then import them into car objects:
+
+```logtalk
+% a protocol describing engine characteristics
+:- protocol(carenginep).
+
+	:- public([
+		reference/1,
+		capacity/1,
+		cylinders/1,
+		horsepower_rpm/2,
+		bore_stroke/2,
+		fuel/1
+	]).
+
+:- end_protocol.
+
+% a typical engine defined as a category
+:- category(classic,
+	implements(carenginep)).
+
+	reference('M180.940').
+	capacity(2195).
+	cylinders(6).
+	horsepower_rpm(94, 4800).
+	bore_stroke(80, 72.8).
+	fuel(gasoline).
+
+:- end_category.
+
+% a souped up version of the previous engine
+:- category(sport,
+	extends(classic)).
+
+	reference('M180.941').
+	horsepower_rpm(HP, RPM) :-
+		^^horsepower_rpm(ClassicHP, ClassicRPM),	% "super" call
+		HP is truncate(ClassicHP*1.23),
+		RPM is truncate(ClassicRPM*0.762).
+
+:- end_category.
+
+% with engines (and other components), we may start "assembling" some cars
+:- object(sedan,
+	imports(classic)).
+
+:- end_object.
+
+:- object(coupe,
+	imports(sport)).
+
+:- end_object.
+```
+
+Categories are independently compiled and thus allow importing objects to be updated by simple updating the imported categories without requiring object recompilation. Categories also provide _runtime transparency_. I.e. the category protocol adds to the protocol of the objects importing the category:
+
+```logtalk
+?- sedan::current_predicate(Predicate).
+Predicate = reference/1 ;
+Predicate = capacity/1 ;
+Predicate = cylinders/1 ;
+Predicate = horsepower_rpm/2 ;
+Predicate = bore_stroke/2 ;
+Predicate = fuel/1
+yes
+```
+
+# Hot patching
+
+Categories can be also be used for hot-patching objects. A category can add new predicates to an object and/or replace object predicate definitions. For example, consider the following object:
+
+```logtalk
+:- object(buggy).
+
+	:- public(p/0).
+	p :- write(foo).
+
+:- end_object.
+```
+
+Assume that the object prints the wrong string when sent the message `p/0`:
+
+```logtalk
+?- {buggy}.
+yes
+
+?- buggy::p.
+foo
+yes
+```
+
+If the object source code is not available and we need to fix an application running the object code, we can simply define a category that fixes the buggy predicate:
+
+```logtalk
+:- category(patch,
+	complements(buggy)).
+
+	% fixed p/0 def
+	p :- write(bar).
+
+:- end_category.
+```
+
+After compiling and loading the category into the running application we will now get:
+
+```logtalk
+?- {patch}.
+yes
+
+?- buggy::p.
+bar
+yes
+```
+
+As hot-patching forcefully breaks encapsulation, there is a `complements` compiler flag that can be set (globally or on a per-object basis) to allow, restrict, or prevent it.
+
+# Parametric objects and categories
+
+Objects and categories can be parameterized by using as identifier a compound term instead of an atom. Object and category parameters are _logical variables_ shared with all encapsulated predicates. An example with geometric circles:
+
+```logtalk
+:- object(circle(_Radius, _Color)).
+
+	:- public([
+		area/1, perimeter/1
+	]).
+
+	area(Area) :-
+		parameter(1, Radius),
+		Area is pi*Radius*Radius.
+
+	perimeter(Perimeter) :-
+		parameter(1, Radius),
+		Perimeter is 2*pi*Radius.
+
+:- end_object.
+```
+
+Parametric objects are used just as any other object, usually providing values for the parameters when sending a message:
+
+```logtalk
+?- circle(1.23, blue)::area(Area).
+Area = 4.75291
+yes
+```
+
+Parametric objects also provide a simple way of associating a set of predicates with a plain Prolog predicate. Prolog facts can be interpreted as _parametric object proxies_ when they have the same functor and arity as the identifiers of parametric objects. Handy syntax is provided to for working with proxies. For example, assuming the following clauses for a `circle/2` predicate:
+
+```logtalk
+circle(1.23, blue).
+circle(3.71, yellow).
+circle(0.39, green).
+circle(5.74, black).
+circle(8.32, cyan).
+```
+
+With these clauses loaded, we can easily compute for example a list with the areas of all the circles:
+
+```logtalk
+?- findall(Area, {circle(_, _)}::area(Area), Areas).
+Areas = [4.75291, 43.2412, 0.477836, 103.508, 217.468]
+yes
+```
+
+The `{Goal}::Message` construct proves `Goal`, possibly instantiating any variables in it, and sends `Message` to the resulting term.
+
+# Events and monitors
+
+Logtalk supports _event-driven programming_ by allowing defining events and monitors for those events. An event is simply the sending of a message to an object. Interpreting message sending as an atomic activity, a _before_ event and an _after_ event are recognized. Event monitors define event handler predicates, `before/3` and `after/3`, and can query, register, and delete a system-wide event registry that associates events with monitors. For example, a simple tracer for any message being sent using the `::/2` control construct can be defined as:
+
+```logtalk
+:- object(tracer,
+	implements(monitoring)).    % built-in protocol for event handlers
+
+	:- initialization(define_events(_, _, _, _, tracer)).
+
+	before(Object, Message, Sender) :-
+		write('call: '), writeq(Object), write(' <-- '), writeq(Message),
+		write(' from '), writeq(Sender), nl.
+
+	after(Object, Message, Sender) :-
+		write('exit: '), writeq(Object), write(' <-- '), writeq(Message),
+		write(' from '), writeq(Sender), nl.
+
+:- end_object.
+```
+
+Assuming that the `tracer` object and the `list` object defined earlier are compiled and loaded, we can observe the event handlers in action by sending a message:
+
+```logtalk
+?- list::member(X, [1,2,3]).
+
+call: list <-- member(X, [1,2,3]) from user
+exit: list <-- member(1, [1,2,3]) from user
+X = 1 ;
+exit: list <-- member(2, [1,2,3]) from user
+X = 2 ;
+exit: list <-- member(3, [1,2,3]) from user
+X = 3
+yes
+```
+
+Events can be set and deleted dynamically at runtime by calling the `define_events/5` and `abolish_events/5` built-in predicates.
+
+Event-driven programming can be seen as a form of _computational reflection_. But note that events are only generated when using the `::/2` message-sending control construct.
+
+# Lambda expressions
+
+Logtalk supports lambda expressions. Lambda parameters are represented using a list with the `(>>)/2` infix operator connecting them to the lambda. Some simple examples using library meta-predicates:
+
+```logtalk
+?- {library(metapredicates_loader)}.
+yes
+
+?- meta::map([X,Y]>>(Y is 2*X), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Currying is also supported:
+
+```logtalk
+?- meta::map([X]>>([Y]>>(Y is 2*X)), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Lambda free variables can be expressed using the extended syntax `{Free1, ...}/[Parameter1, ...]>>Lambda`.
+
+# Macros
+
+Terms and goals in source files can be _expanded_ at compile time by specifying a _hook object_ that defines term-expansion and goal-expansion rules. For example, consider the following simple object, saved in a `source.lgt` file:
+
+```logtalk
+:- object(source).
+
+	:- public(bar/1).
+	bar(X) :- foo(X).
+
+	foo(a). foo(b). foo(c).
+
+:- end_object.
+```
+
+Assume the following hook object, saved in a `my_macros.lgt` file, that expands clauses and calls to the `foo/1` local predicate:
+
+```logtalk
+:- object(my_macros,
+	implements(expanding)).    % built-in protocol for expanding predicates
+
+	term_expansion(foo(Char), baz(Code)) :-
+		char_code(Char, Code). % standard built-in predicate
+
+	goal_expansion(foo(X), baz(X)).
+
+:- end_object.
+```
+
+After loading the macros file, we can then expand our source file with it using the `hook` compiler flag:
+
+```logtalk
+?- logtalk_load(my_macros), logtalk_load(source, [hook(my_macros)]).
+yes
+
+?- source::bar(X).
+X = 97 ;
+X = 98 ;
+X = 99
+true
+```
+
+The Logtalk library provides support for combining hook objects using different workflows (for example, defining a pipeline of expansions).
+
+# Further information
+
+Visit the [Logtalk website](http://logtalk.org) for more information.
diff --git a/lt-lt/json-lt.html.markdown b/lt-lt/json-lt.html.markdown
index 8c97e598..50e52a7a 100644
--- a/lt-lt/json-lt.html.markdown
+++ b/lt-lt/json-lt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: json
-filename: learnjson.json
+filename: learnjson-lt.json
 lang: lt-lt
 contributors:
   - ["Zygimantus", "https://github.com/zygimantus"]
diff --git a/lt-lt/tmux-lt.html.markdown b/lt-lt/tmux-lt.html.markdown
new file mode 100644
index 00000000..b5b3de05
--- /dev/null
+++ b/lt-lt/tmux-lt.html.markdown
@@ -0,0 +1,254 @@
+---
+category: tool
+tool: tmux
+filename: tmux.json
+lang: lt-lt
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+translators:
+    - ["Zygimantus", "https://github.com/zygimantus"]
+---
+
+
+[tmux](http://tmux.sourceforge.net)
+yra terminalo daugintuvas: jis leidžia vienu metu sukurti, turėti
+ir valdyti kelis terminalus viename ekrane. tmux gali būti atjungtas
+nuo ekrano ir veikti fone, o vėliau gali būti vėl prijungtas.
+
+
+```
+
+  tmux [komanda]     # Vykdyti komandą
+                     # 'tmux' be komandų sukurs naują sesiją
+
+    new              # Sukurti naują sesiją
+     -s "Session"    # Sukurti pavadintą sesiją
+     -n "Window"     # Sukurti pavadintą langą
+     -c "/dir"       # Pradėti nurodytoje direktorijoje
+
+    attach           # Priskirti paskutinę/prienamą sesiją
+     -t "#"          # Priskirti nurodytą sesiją
+     -d              # Atjungti sesiją nuo kitų langų
+
+    ls               # Aktyvių sesijų sąrašas
+     -a              # Visų aktyvių sesijų sąrašas
+
+    lsw              # Langų sąrašas
+     -a              # Visų langų sąrašas
+     -s              # Visų langų sesijoje sąrašas
+
+    lsp              # Skydelių sąrašas
+     -a              # Visų skydelių sąrašas
+     -s              # Visų skydelių sesijoje sąrašas
+     -t              # Visų skydelių taikinyje sąrašas
+
+    kill-window      # Užbaigti dabartinį langą
+     -t "#"          # Užbaigti nurodytą langą
+     -a              # Užbaigti visus langus
+     -a -t "#"       # Užbaigti visus langus, bet ne taikinį
+
+    kill-session     # Užbaigti dabartinę sesiją
+     -t "#"          # Užbaigti nurodytą sesiją
+     -a              # Užbaigti visas sesijas
+     -a -t "#"       # Užbaigti visas sesijas, bet ne taikinį
+
+```
+
+
+### Klavišai
+
+Priskirta tmux sesija yra valdoma klavišų kompinacijomis.
+
+```
+----------------------------------------------------------------------
+  (C-b) = Ctrl + b    # Kombinacija reikalinga norint naudoti klavišus
+
+  (M-1) = Meta + 1 -or- Alt + 1
+----------------------------------------------------------------------
+
+  ?                  # Rodo visų klavišų kombinacijų sąrašą
+  :                  # Įjungiama tmux komandinė eilutė
+  r                  # Priverstinai perpiešiamas prijungtas klientas
+  c                  # Sukurti naują langą
+
+  !                  # Iškelia esamą skydelį iš lango.
+  %                  # Perskelia esamą skydelį į du, kairįjį ir dešinį
+  "                  # Perskelia esamą skydelį į du, viršutinį ir apatinį
+
+  n                  # Pakeičia į kitą langą
+  p                  # Pakeičia į buvusį langą
+  {                  # Apkeičia dabartinį skydėlį su buvusiu
+  }                  # Apkeičia dabartinį skydėlį su sekančiu
+
+  s                  # Pasirinkti naują sesiją prijungtam klientui interaktyviai
+  w                  # Pasirinkti dabartinį langą interaktyviai
+  0 to 9             # Pasirinkti langą nuo 0 iki 9
+
+  d                  # Atjungti dabartinį klientą
+  D                  # Pasirinkti klientą, kurį atjungti
+
+  &                  # Užbaigti dabartinį langą
+  x                  # Užbaigti dabartinį skydelį
+
+  Up, Down           # Pakeisti į skydelį viršuje, apačioje, kairėje arba
+                     dešinėje
+  Left, Right
+
+  M-1 to M-5         # Rikiuoti skydelius:
+                       # 1) even-horizontal
+                       # 2) even-vertical
+                       # 3) main-horizontal
+                       # 4) main-vertical
+                       # 5) tiled
+
+  C-Up, C-Down       # Keisti esamo skydelio dydį vienos ląstelės žingsniu
+  C-Left, C-Right
+
+  M-Up, M-Down       # Keisti esamo skydelio dydį penkių ląstelių žingsniu
+  M-Left, M-Right
+
+```
+
+
+### Configuring ~/.tmux.conf
+
+tmux.conf gali būti nustatytas automatiškai paleidimo metu, panašiai kaip ir
+.vimrc arba init.el.
+
+```
+# Pavyzdys tmux.conf
+# 2014.10
+
+
+### General
+###########################################################################
+
+# Enable UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Scrollback/History limit
+set -g history-limit 2048
+
+# Index Start
+set -g base-index 1
+
+# Mouse
+set-option -g mouse-select-pane on
+
+# Force reload of config file
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Keybinds
+###########################################################################
+
+# Unbind C-b as the default prefix
+unbind C-b
+
+# Set new default prefix
+set-option -g prefix `
+
+# Return to previous window when prefix is pressed twice
+bind C-a last-window
+bind ` last-window
+
+# Allow swapping C-a and ` using F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Keybind preference
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Moving between panes with vim movement keys
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Window Cycle/Swap
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Easy split pane commands
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Activate inner-most session (when nesting tmux) to send commands
+bind a send-prefix
+
+
+### Theme
+###########################################################################
+
+# Statusbar Color Palatte
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Pane Border Color Palette
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Message Color Palette
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Window Status Color Palette
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notification
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Automatically set window titles
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Statusbar Adjustments
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Show performance counters in statusbar
+# Requires https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Šaltiniai
+
+[Tmux | Home](http://tmux.sourceforge.net)
+
+[Tmux Manual page](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Display CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
+
+[tmuxinator - Manage complex tmux sessions](https://github.com/tmuxinator/tmuxinator)
diff --git a/lua.html.markdown b/lua.html.markdown
index 2cd4d7bb..1e2d4366 100644
--- a/lua.html.markdown
+++ b/lua.html.markdown
@@ -190,7 +190,7 @@ end
 --------------------------------------------------------------------------------
 
 -- A table can have a metatable that gives the table operator-overloadish
--- behaviour. Later we'll see how metatables support js-prototypey behaviour.
+-- behaviour. Later we'll see how metatables support js-prototype behaviour.
 
 f1 = {a = 1, b = 2}  -- Represents the fraction a/b.
 f2 = {a = 2, b = 3}
diff --git a/make.html.markdown b/make.html.markdown
index e8cfd2b5..ab128475 100644
--- a/make.html.markdown
+++ b/make.html.markdown
@@ -9,16 +9,16 @@ A Makefile defines a graph of rules for creating a target (or targets).
 Its purpose is to do the minimum amount of work needed to update a

 target to the most recent version of the source. Famously written over a

 weekend by Stuart Feldman in 1976, it is still widely used (particularly

-on Unix) despite many competitors and criticisms.

+on Unix and Linux) despite many competitors and criticisms.

 

-There are many varieties of make in existance, this article assumes that

-we are using GNU make which is the standard on Linux.

+There are many varieties of make in existence, however this article 

+assumes that we are using GNU make which is the standard on Linux.

 

 ```make

 

 # Comments can be written like this.

 

-# Files should be named Makefile and then be can run as `make <target>`.

+# File should be named Makefile and then can be run as `make <target>`.

 # Otherwise we use `make -f "filename" <target>`.

 

 # Warning - only use TABS to indent in Makefiles, never spaces!

@@ -27,13 +27,16 @@ we are using GNU make which is the standard on Linux.
 # Basics

 #-----------------------------------------------------------------------

 

+# Rules are of the format

+# target: <prerequisite>

+# where prerequisites are optional.

+

 # A rule - this rule will only run if file0.txt doesn't exist.

 file0.txt:

 	echo "foo" > file0.txt

 	# Even comments in these 'recipe' sections get passed to the shell.

 	# Try `make file0.txt` or simply `make` - first rule is the default.

 

-

 # This rule will only run if file0.txt is newer than file1.txt.

 file1.txt: file0.txt

 	cat file0.txt > file1.txt

@@ -99,8 +102,8 @@ process: ex1.txt file0.txt
 %.png: %.svg

 	inkscape --export-png $^

 

-# Pattern rules will only do anything if make decides to create the \

-target.

+# Pattern rules will only do anything if make decides to create the

+# target.

 

 # Directory paths are normally ignored when matching pattern rules. But

 # make will try to use the most appropriate rule available.

@@ -145,11 +148,11 @@ echo:
 # In order of priority from highest to lowest:

 # 1: commandline arguments

 # 2: Makefile

-# 3: shell enviroment variables - make imports these automatically.

+# 3: shell environment variables - make imports these automatically.

 # 4: make has some predefined variables

 

 name4 ?= Jean

-# Only set the variable if enviroment variable is not already defined.

+# Only set the variable if environment variable is not already defined.

 

 override name5 = David

 # Stops commandline arguments from changing this variable.

@@ -185,7 +188,7 @@ var := hello
 var2 ::=  $(var) hello

 #:= and ::= are equivalent.

 

-# These variables are evaluated procedurely (in the order that they

+# These variables are evaluated procedurally (in the order that they

 # appear), thus breaking with the rest of the language !

 

 # This doesn't work

diff --git a/markdown.html.markdown b/markdown.html.markdown
index 05eeecbe..a1f5173b 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -7,7 +7,9 @@ filename: markdown.md
 ---
 
 
-Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well).
+Markdown was created by John Gruber in 2004. It's meant to be an easy to read 
+and write syntax which converts easily to HTML (and now many other formats as 
+well).
 
 Markdown also varies in implementation from one parser to a next. This
 guide will attempt to clarify when features are universal or when they are
@@ -28,9 +30,10 @@ specific to a certain parser.
 Markdown is a superset of HTML, so any HTML file is valid Markdown.
 
 ```markdown
-<!--This means we can use HTML elements in Markdown, such as the comment element,
-and they won't be affected by a markdown parser. However, if you create an HTML element
-in your markdown file, you cannot use markdown syntax within that element's contents.-->
+<!--This means we can use HTML elements in Markdown, such as the comment 
+element, and they won't be affected by a markdown parser. However, if you 
+create an HTML element in your markdown file, you cannot use markdown syntax 
+within that element's contents.-->
 ```
 
 ## Headings
@@ -72,8 +75,8 @@ __And so is this text.__
 *__And this!__*
 ```
 
-In Github Flavored Markdown, which is used to render markdown files on
-Github, we also have strikethrough:
+In GitHub Flavored Markdown, which is used to render markdown files on
+GitHub, we also have strikethrough:
 
 ```markdown
 ~~This text is rendered with strikethrough.~~
@@ -93,7 +96,7 @@ I'm still in paragraph 2 too!
 I'm in paragraph three!
 ```
 
-Should you ever want to insert an HTML <br /> tag, you can end a paragraph
+Should you ever want to insert an HTML `<br />` tag, you can end a paragraph
 with two or more spaces and then begin a new paragraph.
 
 ```markdown
@@ -144,7 +147,7 @@ Ordered lists are done with a number followed by a period.
 3. Item three
 ```
 
-You don't even have to label the items correctly and markdown will still
+You don't even have to label the items correctly and Markdown will still
 render the numbers in order, but this may not be a good idea.
 
 ```markdown
@@ -200,7 +203,7 @@ Inline code can be created using the backtick character `
 John didn't even know what the `go_to()` function did!
 ```
 
-In Github Flavored Markdown, you can use a special syntax for code
+In GitHub Flavored Markdown, you can use a special syntax for code
 
 <pre>
 <code class="highlight">&#x60;&#x60;&#x60;ruby
@@ -209,13 +212,13 @@ def foobar
 end
 &#x60;&#x60;&#x60;</code></pre>
 
-The above text doesn't require indenting, plus Github will use syntax
+The above text doesn't require indenting, plus GitHub will use syntax
 highlighting of the language you specify after the \`\`\`
 
 ## Horizontal rule
 
-Horizontal rules (`<hr/>`) are easily added with three or more asterisks or hyphens,
-with or without spaces.
+Horizontal rules (`<hr/>`) are easily added with three or more asterisks or 
+hyphens, with or without spaces.
 
 ```markdown
 ***
@@ -298,7 +301,8 @@ in italics, so I do this: \*this text surrounded by asterisks\*.
 
 ### Keyboard keys
 
-In Github Flavored Markdown, you can use a `<kbd>` tag to represent keyboard keys.
+In GitHub Flavored Markdown, you can use a `<kbd>` tag to represent keyboard 
+keys.
 
 ```markdown
 Your computer crashed? Try sending a
@@ -306,7 +310,7 @@ Your computer crashed? Try sending a
 ```
 ### Tables
 
-Tables are only available in Github Flavored Markdown and are slightly
+Tables are only available in GitHub Flavored Markdown and are slightly
 cumbersome, but if you really want it:
 
 ```markdown
diff --git a/matlab.html.markdown b/matlab.html.markdown
index ddc0cb40..86b116c6 100644
--- a/matlab.html.markdown
+++ b/matlab.html.markdown
@@ -25,6 +25,23 @@ like
 this
 %}
 
+% Two percent signs denote the start of a new code section
+% Individual code sections can be run by moving the cursor to the section followed by
+% either clicking the "Run Section" button
+% or     using Ctrl+Shift+Enter (Windows) or Cmd+Shift+Return (OS X)
+
+%% This is the start of a code section
+%  One way of using sections is to separate expensive but unchanging start-up code like loading data
+load myFile.mat y
+
+%% This is another code section
+%  This section can be edited and run repeatedly on its own, and is helpful for exploratory programming and demos
+A = A * 2;
+plot(A);
+
+%% Code sections are also known as code cells or cell mode (not to be confused with cell arrays)
+
+
 % commands can span multiple lines, using '...':
  a = 1 + 2 + ...
  + 4
@@ -540,6 +557,8 @@ c = a + b
 
 ## More on Matlab
 
-* The official website [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
-* The official MATLAB Answers forum: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
+* [The official website](http://www.mathworks.com/products/matlab/)
+* [The official MATLAB Answers forum](http://www.mathworks.com/matlabcentral/answers/)
+* [Loren on the Art of MATLAB](http://blogs.mathworks.com/loren/)
+* [Cleve's Corner](http://blogs.mathworks.com/cleve/)
 
diff --git a/messagepack.html.markdown b/messagepack.html.markdown
new file mode 100644
index 00000000..9234332f
--- /dev/null
+++ b/messagepack.html.markdown
@@ -0,0 +1,172 @@
+---
+category: tool
+tool: messagepack
+filename: learnmessagepack.mpac
+contributors:
+  - ["Gabriel Chuan", "https://github.com/gczh"]
+---
+
+MessagePack is an efficient binary serialization format. It lets you exchange data among multiple languages like JSON. The benefits over other formats is that it's faster and smaller. 
+
+In MessagePack, small integers are encoded into a single byte, and typical short strings require only one extra byte in addition to the strings themselves. This makes MessagePack useful for efficient transmission over wire.
+
+```
+
+# 0. Understanding The Structure ====
+
+JSON, 40 Bytes UTF-8
+	
+----------------------------------------------
+| {"name":"John Doe","age":12}		         |
+----------------------------------------------
+|  {"         | 7B 22                        |
+|    name     | 6E 61 6D 65                  |
+|  ":"        | 22 3A 22                     |
+|    John Doe | 4A 6F 68 6E 20 44 6F 65      |
+|  ","        | 22 2C 22                     |
+|    age      | 61 67 65                     |
+|  ":         | 22 3A 20                     |
+|    12       | 31 32                        |
+|  }          | 7D                           |
+----------------------------------------------
+
+
+MessagePack, 27 Bytes UTF-8
+	
+----------------------------------------------
+| ‚¤name¨John Doe£age.12                     |
+----------------------------------------------
+|  ‚¤         | 82 84                        |
+|    name     | 6E 61 6D 65                  |
+|  ¨          | A8                           |
+|    John Doe | 4A 6F 68 6E 20 44 6F 65      |
+|  £          | A3                           |
+|    age      | 61 67 65                     |
+|  .          | 0C                           |
+|    12       | 31 32                        |
+----------------------------------------------
+
+# 1. JAVA ====
+
+""" Installing with Maven
+"""
+
+<dependencies>
+  ...
+  <dependency>
+    <groupId>org.msgpack</groupId>
+    <artifactId>msgpack</artifactId>
+    <version>${msgpack.version}</version>
+  </dependency>
+  ...
+</dependencies>
+
+
+""" Simple Serialization/Deserialization
+"""
+
+// Create serialize objects.
+List<String> src = new ArrayList<String>();
+src.add("msgpack");
+src.add("kumofs");
+
+MessagePack msgpack = new MessagePack();
+// Serialize
+byte[] raw = msgpack.write(src);
+
+// Deserialize directly using a template
+List<String> dst1 = msgpack.read(raw, Templates.tList(Templates.TString));
+System.out.println(dst1.get(0));
+System.out.println(dst1.get(1));
+
+// Or, Deserialze to Value then convert type.
+Value dynamic = msgpack.read(raw);
+List<String> dst2 = new Converter(dynamic)
+    .read(Templates.tList(Templates.TString));
+System.out.println(dst2.get(0));
+System.out.println(dst2.get(1));
+
+
+# 2. RUBY ====
+
+""" Installing the Gem
+"""
+
+gem install msgpack
+
+""" Streaming API
+"""
+
+# serialize a 2-element array [e1, e2]
+pk = MessagePack::Packer.new(io)
+pk.write_array_header(2).write(e1).write(e2).flush
+
+# deserialize objects from an IO
+u = MessagePack::Unpacker.new(io)
+u.each { |obj| ... }
+
+# event-driven deserialization
+def on_read(data)
+  @u ||= MessagePack::Unpacker.new
+  @u.feed_each(data) { |obj| ... }
+end
+
+# 3. NODE.JS ====
+
+""" Installing with NPM
+"""
+
+npm install msgpack5 --save
+
+""" Using in Node
+"""
+
+var msgpack = require('msgpack5')() // namespace our extensions
+  , a       = new MyType(2, 'a')
+  , encode  = msgpack.encode
+  , decode  = msgpack.decode
+
+msgpack.register(0x42, MyType, mytipeEncode, mytipeDecode)
+
+console.log(encode({ 'hello': 'world' }).toString('hex'))
+// 81a568656c6c6fa5776f726c64
+console.log(decode(encode({ 'hello': 'world' })))
+// { hello: 'world' }
+console.log(encode(a).toString('hex'))
+// d5426161
+console.log(decode(encode(a)) instanceof MyType)
+// true
+console.log(decode(encode(a)))
+// { value: 'a', size: 2 }
+
+function MyType(size, value) {
+  this.value = value
+  this.size  = size
+}
+
+function mytipeEncode(obj) {
+  var buf = new Buffer(obj.size)
+  buf.fill(obj.value)
+  return buf
+}
+
+function mytipeDecode(data) {
+  var result = new MyType(data.length, data.toString('utf8', 0, 1))
+    , i
+
+  for (i = 0; i < data.length; i++) {
+    if (data.readUInt8(0) != data.readUInt8(i)) {
+      throw new Error('should all be the same')
+    }
+  }
+
+  return result
+}
+
+```
+
+
+# References
+
+- [MessagePack](http://msgpack.org/index.html)
+- [MsgPack vs. JSON: Cut your client-server exchange traffic by 50% with one line of code](http://indiegamr.com/cut-your-data-exchange-traffic-by-up-to-50-with-one-line-of-code-msgpack-vs-json/)
diff --git a/ms-my/bash-my.html.markdown b/ms-my/bash-my.html.markdown
new file mode 100644
index 00000000..e4e55b2c
--- /dev/null
+++ b/ms-my/bash-my.html.markdown
@@ -0,0 +1,284 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Etan Reisner", "https://github.com/deryni"]
+filename: LearnBash-ms.sh
+translators:
+    - ["hack1m", "https://github.com/hack1m"]
+lang: ms-my   
+---
+
+Bash adalah nama daripada unix shell, yang mana telah diagihkan sebagai shell untuk sistem operasi GNU dan sebagai shell lalai pada Linux dan Mac OS X. Hampir semua contoh di bawah boleh menjadi sebahagian daripada skrip shell atau dijalankan terus dalam shell.
+
+[Baca lebih lanjut di sini.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# Baris pertama daripada skrip ialah shebang yang mana memberitahu sistem bagaimana untuk melaksana
+# skrip: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Seperti yang anda sudah gambarkan, komen bermula dengan #. Shebang juga ialah komen.
+
+# Contoh mudah hello world:
+echo Hello world!
+
+# Setiap arahan bermula pada baris baru, atau selepas semikolon:
+echo 'This is the first line'; echo 'This is the second line'
+
+# Mengisytihar pembolehubah kelihatan seperti ini:
+Variable="Some string"
+
+# Tetapi bukan seperti ini:
+Variable = "Some string"
+# Bash akan memutuskan yang pembolehubah adalah arahan ia mesti laksanakan dan memberi ralat
+# kerana ia tidak boleh dijumpai.
+
+# Atau seperti ini:
+Variable= 'Some string'
+# Bash akan memutuskan yang ‘Beberapa rentetan’ adalah arahan ia mesti laksanakan dan memberi
+# ralat kerana ia tidak dijumpai. (Dalam kes ini ‘Variable=' sebahagian dilihat
+# sebagai penetapan pembolehubah sah hanya untuk skop ‘Beberapa rentetan’
+# arahan.)
+
+# Menggunakan pembolehubah:
+echo $Variable
+echo "$Variable"
+echo '$Variable'
+# Apabila anda guna pembolehubah itu sendiri - menetapkan, mengeksport, atau lain-lain - anda menulis
+# nama ia tanpa $. Atau anda ingin menggunakan nilai pembolehubah, anda mesti guna $.
+# Perlu diingatkan ‘(Petikan tunggal) tidak akan memperluaskan pembolehubah!
+
+# Penggantian rentetan dalam pembolehubah
+echo ${Variable/Some/A}
+# Ini akan menukarkan sebutan pertama bagi "Some" dengan "A"
+
+# Subrentetan daripada pembolehubah
+Length=7
+echo ${Variable:0:Length}
+# Ini akan kembalikan hanya 7 aksara pertama pada nilai
+
+# Nilai lalai untuk pembolehubah
+echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
+# Ini berfungsi untuk null (Foo=) dan rentetan kosong (Foo=“”); sifar (Foo=0) kembali 0.
+# Perlu diingatkan ia hanya kembalikan nilai lalai dan tidak mengubah nilai pembolehubah.
+
+# Pembolehubah terbina:
+# Terdapat beberapa pembolehubah terbina berguna, seperti
+echo "Last program's return value: $?"
+echo "Script's PID: $$"
+echo "Number of arguments passed to script: $#"
+echo "All arguments passed to script: $@"
+echo "Script's arguments separated into different variables: $1 $2..."
+
+# Membaca nilai dari input:
+echo "What's your name?"
+read Name # Perlu diingatkan kita tidak perlu isytihar pembolehubah baru
+echo Hello, $Name!
+
+# Kita ada yang biasa jika struktur:
+# guna 'man test' untuk maklumat lanjut tentang bersyarat
+if [ $Name -ne $USER ]
+then
+    echo "Your name isn't your username"
+else
+    echo "Your name is your username"
+fi
+
+# Terdapat juga pelaksanaan bersyarat
+echo "Always executed" || echo "Only executed if first command fails"
+echo "Always executed" && echo "Only executed if first command does NOT fail"
+
+# Untuk guna && dan || bersama kenyataan ‘if’, anda perlu beberapa pasang daripada tanda kurung siku:
+if [ $Name == "Steve" ] && [ $Age -eq 15 ]
+then
+    echo "This will run if $Name is Steve AND $Age is 15."
+fi
+
+if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
+then
+    echo "This will run if $Name is Daniya OR Zach."
+fi
+
+# Eskspresi ia ditandai dengan format berikut:
+echo $(( 10 + 5 ))
+
+# Tidak seperti bahasa pengaturcaraan lain, bash adalah shell jadi ia berfungsi dalam konteks
+# daripada direktori semasa. Anda boleh menyenaraikan fail dan direktori dalam direktori
+# semasa dengan arahan ini:
+ls
+
+# Arahan ini mempunyai opsyen yang mengawal perlaksanaannya:
+ls -l # Senarai setiap fail dan direktori pada baris yang berbeza
+
+# Keputusan arahan sebelum boleh diberikan kepada arahan selepas sebagai input.
+# arahan grep menapis input dengan memberi paten. Ini bagaimana kita boleh senaraikan
+# fail .txt di dalam direktori semasa:
+ls -l | grep "\.txt"
+
+# Anda boleh mengubah hala arahan input dan output (stdin, stdout, dan stderr).
+# Baca dari stdin sampai ^EOF$ dan menulis ganti hello.py dengan baris
+# antara “EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Jalankan hello.py dengan pelbagai penghantaran semula stdin, stdout, dan stderr:
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Output ralat akan menulis ganti fail jika ia wujud,
+# jika anda ingin menambah sebaliknya, guna ‘>>”:
+python hello.py >> "output.out" 2>> "error.err"
+
+# Menulis ganti output.out, menambah ke error.err, dan mengira baris:
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# Jalankan arahan dan cetak fail Deskriptor (e.g. /dev/fd/123)
+# lihat: man fd
+echo <(echo "#helloworld")
+
+# Menulis ganti output.out dengan “#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# Membersihkan fail semantara keseluruhan (tambah ‘-i’ untuk interaktif)
+rm -v output.out error.err output-and-error.log
+
+# Arahan boleh digantikan dalam arahan lain menggunakan $():
+# Arahan berikut memaparkan jumlah fail dan direktori dalam
+# direktori semasa.
+echo "There are $(ls | wc -l) items here."
+
+# Perkara yang sama boleh dilakukan dengan menggunakan backticks `` tetapi ia tidak boleh bersarang - cara yang terbaik
+# ialah menggunakan $( ).
+echo "There are `ls | wc -l` items here."
+
+# Bash menggunakan penyataan case yang berfungsi sama seperti ‘switch’ pada Java dan C++:
+case "$Variable" in
+    # Senarai paten untuk syarat yang ada ingin ketemui
+    0) echo "There is a zero.";;
+    1) echo "There is a one.";;
+    *) echo "It is not null.";;
+esac
+
+# ‘for loops iterate' untuk sebanyak mana argumen yang ditetapkan:
+# Kandungan dari $Variable dicetakan sebanyak tiga kali.
+for Variable in {1..3}
+do
+    echo "$Variable"
+done
+
+# Atau tulis ia cara "traditional for loop":
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Ia juga boleh digunakan untuk bertindak ke atas fail..
+# Ini akan menjalankan arahan 'cat' pada file1 dan file2
+for Variable in file1 file2
+do
+    cat "$Variable"
+done
+
+# ..atau output daripada arahan
+# Ini akan 'cat' output dari ls.
+for Output in $(ls)
+do
+    cat "$Output"
+done
+
+# while loop:
+while [ true ]
+do
+    echo "loop body here..."
+    break
+done
+
+# Anda juga boleh mendefinasikan fungsi
+# Definasi:
+function foo ()
+{
+    echo "Arguments work just like script arguments: $@"
+    echo "And: $1 $2..."
+    echo "This is a function"
+    return 0
+}
+
+# atau lebih mudah
+bar ()
+{
+    echo "Another way to declare functions!"
+    return 0
+}
+
+# Memanggil fungsi
+foo "My name is" $Name
+
+# Terdapat banyak arahan yang berguna yang perlu anda belajar:
+# cetak 10 baris terakhir dalam file.txt
+tail -n 10 file.txt
+# cetak 10 baris pertama dalam file.txt
+head -n 10 file.txt
+# menyusun baris fail.txt
+sort file.txt
+# laporan atau meninggalkan garisan berulang, dengan -d ia melaporkan
+uniq -d file.txt
+# cetak hanya kolum pertama sebelum aksara ','
+cut -d ',' -f 1 file.txt
+# menggantikan setiap kewujudan 'okay' dengan 'great' dalam file.txt, (serasi regex)
+sed -i 's/okay/great/g' file.txt
+# cetak ke stdoout semua baris dalam file.txt yang mana sepadan beberapa regex
+# contoh cetak baris yang mana bermula dengan “foo” dan berakhir dengan “bar”
+grep "^foo.*bar$" file.txt
+# beri opsyen “-c” untuk sebaliknya mencetak jumlah baris sepadan regex
+grep -c "^foo.*bar$" file.txt
+# jika anda secara literal mahu untuk mencari rentetan,
+# dan bukannya regex, guna fgrep (atau grep -F)
+fgrep "^foo.*bar$" file.txt
+
+
+# Baca dokumentasi Bash shell terbina dengan 'help' terbina:
+help
+help help
+help for
+help return
+help source
+help .
+
+# Baca dokumentasi Bash manpage dengan man
+apropos bash
+man 1 bash
+man bash
+
+# Baca dokumentasi info dengan info (? for help)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Baca dokumentasi bash info:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/ms-my/clojure-my.html.markdown b/ms-my/clojure-my.html.markdown
new file mode 100644
index 00000000..e199c8f4
--- /dev/null
+++ b/ms-my/clojure-my.html.markdown
@@ -0,0 +1,419 @@
+---
+language: clojure
+filename: learnclojure-ms.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Burhanuddin Baharuddin", "https://github.com/burhanloey"]
+lang: ms-my
+---
+
+Clojure ialah salah satu bahasa pengaturcaraan dalam keluarga Lisp yang dibangunkan untuk Java Virtual Machine. Ia lebih
+menekankan kepada konsep [functional programming](https://en.wikipedia.org/wiki/Functional_programming) jika dibandingkan
+dengan Common Lisp, tetapi juga menyediakan kemudahan [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) 
+untuk mengendalikan *state* apabila diperlukan.
+
+Gabungan tersebut membolehkan Clojure untuk mengendalikan beberapa proses serentak (*concurrency*) dengan mudah,
+dan kebiasaannya secara automatik.
+
+(Anda perlukan Clojure versi 1.2 ke atas)
+
+
+```clojure
+; Komen bermula dengan koma bertitik (semicolon).
+
+; Clojure ditulis dalam bentuk yang seragam, iaitu
+; senarai perkataan di dalam kurungan (parentheses), dipisahkan dengan ruang kosong (whitespace).
+;
+; Pembaca Clojure akan menganggap bahawa perkataan pertama dalam senarai tersebut
+; sebagai `function` atau `macro` untuk digunakan, dan yang selebihnya sebagai arguments.
+
+; Panggilan pertama di dalam fail Clojure mestilah bermula dengan ns, untuk menentukan `namespace`
+(ns learnclojure)
+
+; Contoh-contoh asas yang lain:
+
+; str akan mewujudkan sebuah string daripada beberapa `argument`
+(str "Hello" " " "World") ; => "Hello World"
+
+; Operasi matematik pun mudah
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; Tanda = boleh digunakan untuk membuat perbandingan yang sama
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; Gunakan not untuk mengubah lojik
+(not true) ; => false
+
+; Bentuk `nested` berfungsi seperti yang dijangkakan
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Type (Jenis Data)
+;;;;;;;;;;;;;
+
+; Clojure menggunakan jenis `object` dari Java untuk `boolean`, `string` dan nombor.
+; Gunakan `class` untuk memeriksa jenis sesebuah data.
+(class 1) ; Secara default jenis data untuk `Integer` ialah java.lang.Long
+(class 1.); Jenis data untuk Float pula ialah java.lang.Double
+(class ""); `String` sentiasa berada dalam tanda petikan (quotation mark), dan merupakan java.lang.String
+(class false) ; `Boolean` ialah java.lang.Boolean
+(class nil); Nilai "null" dipanggil nil
+
+; Jika mahu membuat senarai data secara harfiah, gunakan ' untuk elakkan senarai tersebut
+; daripada terus berfungsi
+'(+ 1 2) ; => (+ 1 2)
+; (singkatan untuk (quote (+ 1 2)))
+
+; Senarai data secara harfiah boleh berfungsi menggunakan eval
+(eval '(+ 1 2)) ; => 3
+
+; Collection & Sequence (Koleksi & Urutan)
+;;;;;;;;;;;;;;;;;;;
+
+; `List` ialah struktur data `linked-list`, manakala `Vector` pula berasaskan `array`.
+; `Vector` dan `List` juga merupakan class dari Java!
+(class [1 2 3]); => clojure.lang.PersistentVector
+(class '(1 2 3)); => clojure.lang.PersistentList
+
+; Sesebuah list boleh ditulis seperti (1 2 3), tetapi kita perlu meletakkan '
+; untuk mengelakkannya daripada berfungsi.
+; Juga, (list 1 2 3) adalah sama dengan '(1 2 3)
+
+; "Collections" hanyalah kumpulan data
+; Kedua-dua list dan vector ialah collection:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; "Sequences" (seq) ialah kriteria untuk sesebuah senarai data.
+; Hanya list yang dikira sebagai seq.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Sesebuah seq hanya perlukan satu kemasukan data untuk diakses.
+; Jadi, seq yang boleh jadi `lazy` (malas) -- boleh menjadi tidak terkira (infinite):
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (tiada penghujung)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Gunakan cons untuk menambah sesuatu di awal sesebuah list atau vector
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; Conj akan menambah sesuatu ke dalam collection dengan paling berkesan.
+; Untuk list, data tersebut dimasukkan di permulaan. Untuk vector, dimasukkan di pengakhiran.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; Gunakan concat untuk menggabungkan list atau vector
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; Gunakan filter dan map untuk berinteraksi dengan data di dalam collection
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Gunakan reduce untuk dikecilkan (kepada satu nilai)
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; Reduce boleh diberi nilai permulaan
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Function
+;;;;;;;;;;;;;;;;;;;;;
+
+; Gunakan fn untuk membuat `function`. Sesebuah function pasti memulangkan semula
+; hasil daripada barisan yang terakhir.
+(fn [] "Hello World") ; => fn
+
+; (Anda perlukan satu lagi kurungan supaya function tersebut dikira)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Anda boleh membuat var menggunakan def
+(def x 1)
+x ; => 1
+
+; Tetapkan sebuah function ke dalam var
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Proses di atas boleh diringkaskan menggunakan defn
+(defn hello-world [] "Hello World")
+
+; Tanda [] merupakan senarai argument untuk function tersebut.
+(defn hello [name]
+  (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Cara ini juga boleh digunakan untuk membuat function dengan lebih ringkas:
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; Anda juga boleh membuat satu function yang mempunyai beberapa bilangan argument
+(defn hello3
+  ([] "Hello World")
+  ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Function boleh diberi argument ekstra dalam bentuk seq
+(defn count-args [& args]
+  (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+
+; Anda boleh letakkan sekali argument biasa dan argument ekstra
+(defn hello-count [name & args]
+  (str "Hello " name ", you passed " (count args) " extra args"))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+
+
+; Map
+;;;;;;;;;;
+
+; Hash map dan array map menggunakan `interface` yang sama. Hash map lebih laju untuk diakses
+; tetapi tidak mengekalkan urutan.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Arraymap akan bertukar menjadi hashmap secara automatik untuk kebanyakan operasi
+; apabila mereka menjadi semakin besar, jadi anda tidak perlu bimbang.
+
+; Map boleh menggunakan apa-apa sahaja jenis data sebagai key, tetapi kebiasaannya keyword adalah yang terbaik
+; Keyword adalah sama seperti string cuma lebih efisyen
+(class :a) ; => clojure.lang.Keyword
+
+(def stringmap {"a" 1, "b" 2, "c" 3})
+stringmap  ; => {"a" 1, "b" 2, "c" 3}
+
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
+
+; Oh, sebelum terlupa, tanda koma di atas hanya dianggap seperti whitespace, tak buat apa-apa.
+; Dapatkan nilai daripada map dengan menggunakannya seperti function
+(stringmap "a") ; => 1
+(keymap :a) ; => 1
+
+; Keyword juga boleh digunakan untuk mendapatkan nilai daripada map tersebut!
+(:b keymap) ; => 2
+
+; Jangan cuba teknik di atas menggunakan string, tak jadi.
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Apabila key yang digunakan tidak wujud, map akan memberi nil
+(stringmap "d") ; => nil
+
+; Gunakan assoc untuk menambah key yang baru ke dalam hash-map
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Tetapi ingat, data dalam clojure adalah `immutable` (tidak berubah)!
+keymap ; => {:a 1, :b 2, :c 3}
+
+; Gunakan dissoc untuk membuang key
+(dissoc keymap :a :b) ; => {:c 3}
+
+; Set
+;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; Tambah data menggunakan conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Buang data menggunakan disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Periksa kewujudan data dengan menggunakan set tersebut sebagai function:
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; Ada pelbagai lagi function untuk set di namespace clojure.sets.
+
+; Form yang berguna
+;;;;;;;;;;;;;;;;;
+
+; Lojik dalam clojure hanyalah sebuah macro, dan kelihatan seperti
+; yang lain
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Gunakan let untuk membuat binding sementara
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; Kumpulkan beberapa statement sekali menggunakan do
+(do
+  (print "Hello")
+  "World") ; => "World" (prints "Hello")
+
+; Function sebenarnya ada do secara tersirat
+(defn print-and-say-hello [name]
+  (print "Saying hello to " name)
+  (str "Hello " name))
+(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+
+; Let pun sama
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+
+; Gunakan `threading macro` (-> dan ->>) untuk menulis penggubahan data
+; dengan lebih jelas.
+
+; Macro "thread-first" (->) memasukkan hasil perkiraan ke setiap form
+; yang selepasnya, sebagai argument pertama (item yang kedua)
+(->  
+   {:a 1 :b 2} 
+   (assoc :c 3) ;=> (assoc {:a 1 :b 2} :c 3)
+   (dissoc :b)) ;=> (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+
+; Code di atas boleh ditulis seperti ini:
+; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; dan hasilnya ialah {:a 1 :c 3}
+
+; Yang dua anak panah pula membuat benda yang sama, tetapi memasukkan hasil perkiraan 
+; setiap baris ke pengakhiran form selepasnya. Cara ini berguna untuk operasi 
+; yang melibatkan collection:
+(->>
+   (range 10)
+   (map inc)     ;=> (map inc (range 10)
+   (filter odd?) ;=> (filter odd? (map inc (range 10))
+   (into []))    ;=> (into [] (filter odd? (map inc (range 10)))
+                 ; Result: [1 3 5 7 9]
+
+; Jika anda mahu lebih fleksibel untuk meletakkan hasil perkiraan,
+; anda boleh menggunakan macro `as->`. Dengan menggunakan macro tersebut,
+; anda boleh menentukan nama untuk output dan menggunakannya semula
+; ke dalam operasi berangkai:
+
+(as-> [1 2 3] input
+  (map inc input);=> You can use last transform's output at the last position
+  (nth input 2) ;=>  and at the second position, in the same expression
+  (conj [4 5 6] input [8 9 10])) ;=> or in the middle !
+
+
+
+; Module
+;;;;;;;;;;;;;;;
+
+; Gunakan "use" untuk mendapatkan semua function daripada sesebuah module
+(use 'clojure.set)
+
+; Sekarang kita boleh menggunakan operasi untuk set
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Anda juga boleh memilih sebahagian daripada function untuk diimport
+(use '[clojure.set :only [intersection]])
+
+; Gunakan require untuk mengimport sesebuah module
+(require 'clojure.string)
+
+; Gunakan / untuk menggunakan function daripada module
+; Di sini, nama module tersebut ialah clojure.string dan function-nya ialah blank?
+(clojure.string/blank? "") ; => true
+
+; Anda juga boleh memberi nama yang lebih ringkas untuk module semasa import
+(require '[clojure.string :as str])
+(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
+; (#"" ialah ungkapan untuk regular expression, regex)
+
+; Anda boleh menggunakan require (dan use, tetapi elakkan) daripada namespace menggunakan :require.
+; Anda tidak perlu menulis semula nama module dengan cara ini.
+(ns test
+  (:require
+    [clojure.string :as str]
+    [clojure.set :as set]))
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java mengandungi banyak standard library yang kita boleh manfaatkan, jadi
+; anda patut tahu bagaimana untuk menggunakannya.
+
+; Gunakan import untuk load module java
+(import java.util.Date)
+
+; Anda juga boleh import menggunakan ns.
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+
+; Gunakan nama class berserta "." di hujungnya untuk membuat object baru
+(Date.) ; <object date>
+
+; Gunakan . untuk menggunakan method. Atau gunakan shortcut seperti ".method"
+(. (Date.) getTime) ; <sebuah timestamp>
+(.getTime (Date.)) ; sama sahaja.
+
+; Gunakan / untuk menggunakan static method
+(System/currentTimeMillis) ; <sebuah timestamp> (System sentiasa wujud dalam Java)
+
+; Gunakan doto untuk menjadikan proses yang melibatkan class mutable (boleh berubah) lebih mudah
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0)
+  .getTime) ; => Sebuah Date. yang ditetapkan kepada 2000-01-01 00:00:00
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; Software Transactional Memory ialah mekanisme dalam Clojure untuk mengendalikan
+; state yang kekal berterusan. Ada beberapa kaedah dalam Clojure yang menggunakan teknik tersebut.
+
+; Atom adalah yang paling mudah. Letakkannya sewaktu meletakkan nilai permulaan.
+(def my-atom (atom {}))
+
+; Kemas kini sebuah atom menggunakan swap!.
+; swap! mengambil satu function dan menggunakannya menggunakan nilai asal atom
+; sebagai argument pertama, dan argument selebihnya sebagai argument kedua
+(swap! my-atom assoc :a 1) ; Tetapkan my-atom kepada hasil perkiraan (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Tetapkan my-atom kepada hasil perkiraan (assoc {:a 1} :b 2)
+
+; Gunakan '@' untuk mendapatkan nilai daripada atom
+my-atom  ;=> Atom<#...> (memberi object atom itu sendiri)
+@my-atom ; => {:a 1 :b 2}
+
+; Ini adalah contoh untuk mengira menggunakan atom
+(def counter (atom 0))
+(defn inc-counter []
+  (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Kaedah lain yang menggunakan STM ialah ref dan agent.
+; Ref: http://clojure.org/refs
+; Agent: http://clojure.org/agents
+```
+
+### Bacaan Lanjut
+
+Ini masih belum lengkap, tetapi harap-harap cukup untuk membuatkan anda lebih bersedia.
+
+Clojure.org mempunyai banyak artikel:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org mempunyai dokumentasi berserta contoh untuk menggunakan kebanyakan function teras:
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure ialah cara yang baik untuk mengasah skill Clojure dan functional programming:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org (yup, serius) juga mengandungi beberapa artikel sebagai permulaan:
+[http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/ms-my/sass-my.html.markdown b/ms-my/sass-my.html.markdown
new file mode 100644
index 00000000..68ce4ab3
--- /dev/null
+++ b/ms-my/sass-my.html.markdown
@@ -0,0 +1,232 @@
+---
+language: sass
+filename: learnsass-ms.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+translators:
+  - ["hack1m", "https://github.com/hack1m"]
+lang: ms-my
+---
+
+Sass ialah bahasa sambungan CSS yang menambah ciri-ciri seperti pembolehubah, bersarang, mixins dan banyak lagi.
+Sass (dan prapemproses lain, seperti [Less](http://lesscss.org/)) membantu pembangun untuk menulis kod mampu diselenggara dan DRY (Don't Repeat Yourself).
+
+Sass mempunyai dua perbezaan pilihan sintaks untuk dipilih. SCSS, yang mana mempunyai sintaks yang sama seperti CSS tetapi dengan ditambah ciri-ciri Sass. Atau Sass (sintaks asal), yang menggunakan indentasi bukannya tanda kurung dakap dan semikolon.
+Tutorial ini ditulis menggunakan SCSS.
+
+```scss
+
+//Komen baris tunggal dikeluarkan apabila Sass dikompil ke CSS.
+
+/*Komen multi dikekalkan. */
+
+
+
+/*Pembolehubah
+==============================*/
+
+
+
+/* Anda boleh menyimpan nilai CSS (seperti warna) dalam pembolehubah.
+Guna simbol '$' untuk membuat pembolehubah. */
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Anda boleh mengguna pembolehubah diseluruh lembaran gaya anda.
+Kini jika anda ingin mengubah warna, anda hanya perlu membuat perubahan sekali.*/
+
+body {
+	background-color: $primary-color;
+	color: $secondary-color;
+	font-family: $body-font;
+}
+
+/* Ia akan dikompil kepada: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* Ini jauh lebih mampu diselenggara daripada perlu menukar warna
+setiap yang ada diseluruh lembaran gaya anda. */
+
+
+
+/*Mixins
+==============================*/
+
+
+
+/* Jika anda jumpa yang anda menulis kod yang sama pada lebih dari satu
+elemen, anda mungkin ingin menyimpan kod itu di dalam mixin.
+
+Guna arahan '@mixin', tambah dengan nama untuk mixin anda.*/
+
+@mixin center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Anda boleh guna mixin bersama '@include' dan nama mixin. */
+
+div {
+	@include center;
+	background-color: $primary-color;
+}
+
+/*Ia akan dikompil kepada: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+
+/* Anda boleh guna mixins untuk membuat singkatan property. */
+
+@mixin size($width, $height) {
+	width: $width;
+	height: $height;
+}
+
+/*Yang mana anda boleh seru dengan memberi argumen lebar dan tinggi. */
+
+.rectangle {
+	@include size(100px, 60px);
+}
+
+.square {
+	@include size(40px, 40px);
+}
+
+/* Ia dikompil kepada: */
+.rectangle {
+  width: 100px;
+  height: 60px;
+}
+
+.square {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+
+/*Extend (Inheritance)
+==============================*/
+
+
+
+/*Extend ialah jalan untuk berkongsi sifat dengan satu pemilih dengan yang lain. */
+
+.display {
+	@include size(5em, 5em);
+	border: 5px solid $secondary-color;
+}
+
+.display-success {
+	@extend .display;
+	border-color: #22df56;
+}
+
+/* Dikompil kepada: */
+.display, .display-success {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.display-success {
+  border-color: #22df56;
+}
+
+
+
+
+/*Bersarang
+==============================*/
+
+
+
+/*Sass membenarkan anda untuk sarangkan pemilih dengan pemilih */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;		
+	}
+}
+
+/* '&' akan digantikan dengan pemilih induk. */
+/* Anda juga boleh sarangkan kelas-pseudo. */
+/* Perlu diingat terlebih bersarang akan membuat kod anda kurang mampu diselenggara.
+Sebagai contoh: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Dikompil kepada: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+
+```
+
+
+
+## SASS atau Sass?
+Adakah anda tertanya-tanya sama ada Sass adalah akronim atau tidak? Anda mungkin tidak perlu, tetapi saya akan memberitahu. Nama bahasa ini adalah perkataan, "Sass", dan tidak akronim.
+Kerana orang sentiasa menulis ia sebagai "Sass", pencipta bahasa bergurau memanggilnya "Syntactically Awesome StyleSheets".
+
+## Berlatih Sass
+Jika anda ingin bermain dengan Sass di pelayar anda, lihat [SassMeister](http://sassmeister.com/).
+Anda boleh guna salah satu sintaks, hanya pergi ke tetapan dan pilih sama ada Sass atau SCSS.
+
+
+## Bacaan lanjut
+* [Dokumentasi Rasmi](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) menyediakan tutorial (asas-lanjutan) dan artikel.
diff --git a/ms-my/xml-my.html.markdown b/ms-my/xml-my.html.markdown
new file mode 100644
index 00000000..a9d7509b
--- /dev/null
+++ b/ms-my/xml-my.html.markdown
@@ -0,0 +1,130 @@
+---
+language: xml
+filename: learnxml-ms.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+    - ["hack1m", "https://github.com/hack1m"]
+lang: ms-my   
+---
+
+XML adalah bahasa markup direka untuk menyimpan dan mengangkutan data.
+
+Tidak seperti HTML, XML tidak menyatakan bagaimana paparan atau mengformat data, hanya membawanya.
+
+* Sintaks XML
+
+```xml
+<!-- Komen di XML seperti ini -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<bookstore>
+  <book category="COOKING">
+    <title lang="en">Everyday Italian</title>
+    <author>Giada De Laurentiis</author>
+    <year>2005</year>
+    <price>30.00</price>
+  </book>
+  <book category="CHILDREN">
+    <title lang="en">Harry Potter</title>
+    <author>J K. Rowling</author>
+    <year>2005</year>
+    <price>29.99</price>
+  </book>
+  <book category="WEB">
+    <title lang="en">Learning XML</title>
+    <author>Erik T. Ray</author>
+    <year>2003</year>
+    <price>39.95</price>
+  </book>
+</bookstore>
+
+<!-- Di atas adalah fail XML biasa.
+  Ia bermula dengan perisytiharan, memaklumkan beberapa metadata (pilihan).
+
+  XML menggunakan struktur pokok, Di atas, nod akar ialah ‘bookstore’, yang mana mempunyai tiga nod anak, semua ‘books’. Nod itu mempunyai lebih nod anak (atau anak-anak), dan seterusnya…
+
+  Nod dibuat menggunakan tag pembuka/penutup, dan anak-anak hanya nod antara
+  pembuka dan penutup tag.-->
+
+
+  <!-- XML membawa dua jenis data:
+   1 - Atribut -> Iaitu metadata mengenai nod.
+       Biasanya, penghurai XML menggunakan informasi untuk menyimpan data dengan betul.
+       Ia mempunyai ciri-ciri yang dipaparkan bersama format name=“value” dalam tag
+       pembuka.
+
+   2 - Elemen -> Iaitu data tulen.
+       Iaitu apa penghurai akan menerima daripada fail XML.
+       Elemen memaparkan diantara pembuka dan penutup tag. —>
+
+
+<!-- Di bawah, elemen dengan dua atribut -->
+<file type="gif" id="4293">computer.gif</file>
+
+
+```
+
+* Dokumen Format sempurna x Pengesahan
+
+Satu dokumen XML adalah format sempurna jika ia adalah sintaksis yang betul.
+Walau bagaimanapun, ia mungkin menyuntik lebih banyak kekangan dalam dokumen itu,
+menggunakan definasi dokumen, seperti DTD dan Skema XML.
+
+Satu dokumen XML yang mana mengikut definasi dokumen dipanggil sah,
+mengenai dokumen itu.
+
+Dengan alat ini, anda boleh menyemak data XML di luar logik aplikasi.
+
+```xml
+
+<!-- Dibawah, anda boleh melihat versi ringkas daripada dokumen bookstore,
+  dengan tambahan definisi DTD. -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "Bookstore.dtd">
+<bookstore>
+  <book category="COOKING">
+    <title >Everyday Italian</title>
+    <price>30.00</price>
+  </book>
+</bookstore>
+
+<!-- DTD boleh menjadi sesuatu seperti ini: -->
+
+<!DOCTYPE note
+[
+<!ELEMENT bookstore (book+)>
+<!ELEMENT book (title,price)>
+<!ATTLIST book category CDATA "Literature">
+<!ELEMENT title (#PCDATA)>
+<!ELEMENT price (#PCDATA)>
+]>
+
+
+<!-- DTD bermula dengan pengisytiharan.
+  Berikut, nod akar diisytihar, memerlukan 1 atau lebih nod anak ‘book’.
+  Setiap ‘book’ harus mengandungi betul-betul satu ‘title’ dan ‘price’ dan atribut
+  dipanggil ‘category’, bersama “Literature" sebagai nilai lalai ia.
+  Nod ‘title’ dan ‘price’  mengandungi aksara data terhurai.-—>
+
+<!-- DTD boleh diisytiharkan di dalam fail XML itu sendiri. -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT bookstore (book+)>
+<!ELEMENT book (title,price)>
+<!ATTLIST book category CDATA "Literature">
+<!ELEMENT title (#PCDATA)>
+<!ELEMENT price (#PCDATA)>
+]>
+
+<bookstore>
+  <book category="COOKING">
+    <title >Everyday Italian</title>
+    <price>30.00</price>
+  </book>
+</bookstore>
+```
diff --git a/nim.html.markdown b/nim.html.markdown
index 79271732..5d00304d 100644
--- a/nim.html.markdown
+++ b/nim.html.markdown
@@ -11,7 +11,7 @@ that gives the programmer power without compromises on runtime efficiency.
 
 Nim is efficient, expressive, and elegant.
 
-```nimrod
+```nim
 var                     # Declare (and assign) variables,
   letter: char = 'n'    # with or without type annotations
   lang = "N" & "im"
diff --git a/nix.html.markdown b/nix.html.markdown
new file mode 100644
index 00000000..ef59a135
--- /dev/null
+++ b/nix.html.markdown
@@ -0,0 +1,354 @@
+---
+language: nix
+filename: learn.nix
+contributors:
+    - ["Chris Martin", "http://chris-martin.org/"]
+---
+
+Nix is a simple functional language developed for the
+[Nix package manager](https://nixos.org/nix/) and
+[NixOS](https://nixos.org/).
+
+You can evaluate Nix expressions using
+[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
+or [`nix-repl`](https://github.com/edolstra/nix-repl).
+
+```
+with builtins; [
+
+  #  Comments
+  #=========================================
+
+  # Inline comments look like this.
+
+  /* Multi-line comments
+     look like this. */
+
+
+  #  Booleans
+  #=========================================
+
+  (true && false)               # And
+  #=> false
+
+  (true || false)               # Or
+  #=> true
+
+  (if 3 < 4 then "a" else "b")  # Conditional
+  #=> "a"
+
+
+  #  Integers
+  #=========================================
+
+  # Integers are the only numeric type.
+
+  1 0 42 (-3)       # Some integers
+
+  (4 + 6 + 12 - 2)  # Addition
+  #=> 20
+
+  (7 / 2)           # Division
+  #=> 3
+
+
+  #  Strings
+  #=========================================
+
+  "Strings literals are in double quotes."
+
+  "
+    String literals can span
+    multiple lines.
+  "
+
+  ''
+    This is called an "indented string" literal.
+    It intelligently strips leading whitespace.
+  ''
+
+  ''
+    a
+      b
+  ''
+  #=> "a\n  b"
+
+  ("ab" + "cd")   # String concatenation
+  #=> "abcd"
+
+  # Antiquotation lets you embed values into strings.
+  ("Your home directory is ${getEnv "HOME"}")
+  #=> "Your home directory is /home/alice"
+
+
+  #  Paths
+  #=========================================
+
+  # Nix has a primitive data type for paths.
+  /tmp/tutorials/learn.nix
+
+  # A relative path is resolved to an absolute path at parse
+  # time, relative to the file in which it occurs.
+  tutorials/learn.nix
+  #=> /the-base-path/tutorials/learn.nix
+
+  # A path must contain at least one slash, so a relative
+  # path for a file in the same directory needs a ./ prefix,
+  ./learn.nix
+  #=> /the-base-path/learn.nix
+
+  # The / operator must be surrounded by whitespace if
+  # you want it to signify division.
+
+  7/2        # This is a path literal
+  (7 / 2)    # This is integer division
+
+
+  #  Imports
+  #=========================================
+
+  # A nix file contains a single top-level expression with no free
+  # variables. An import expression evaluates to the value of the
+  # file that it imports.
+  (import /tmp/foo.nix)
+
+  # Imports can also be specified by strings.
+  (import "/tmp/foo.nix")
+
+  # Import paths must be absolute. Path literals
+  # are automatically resolved, so this is fine.
+  (import ./foo.nix)
+
+  # But this does not happen with strings.
+  (import "./foo.nix")
+  #=> error: string ‘foo.nix’ doesn't represent an absolute path
+
+
+  #  Let
+  #=========================================
+
+  # `let` blocks allow us to bind values to variables.
+  (let x = "a"; in
+    x + x + x)
+  #=> "aaa"
+
+  # Bindings can refer to each other, and their order does not matter.
+  (let y = x + "b";
+       x = "a"; in
+    y + "c")
+  #=> "abc"
+
+  # Inner bindings shadow outer bindings.
+  (let a = 1; in
+    let a = 2; in
+      a)
+  #=> 2
+
+
+  #  Functions
+  #=========================================
+
+  (n: n + 1)      # Function that adds 1
+
+  ((n: n + 1) 5)  # That same function, applied to 5
+  #=> 6
+
+  # There is no syntax for named functions, but they
+  # can be bound by `let` blocks like any other value.
+  (let succ = (n: n + 1); in succ 5)
+  #=> 6
+
+  # A function has exactly one argument.
+  # Multiple arguments can be achieved with currying.
+  ((x: y: x + "-" + y) "a" "b")
+  #=> "a-b"
+
+  # We can also have named function arguments,
+  # which we'll get to later after we introduce sets.
+
+
+  #  Lists
+  #=========================================
+
+  # Lists are denoted by square brackets.
+
+  (length [1 2 3 "x"])
+  #=> 4
+
+  ([1 2 3] ++ [4 5])
+  #=> [1 2 3 4 5]
+
+  (concatLists [[1 2] [3 4] [5]])
+  #=> [1 2 3 4 5]
+
+  (head [1 2 3])
+  #=> 1
+  (tail [1 2 3])
+  #=> [2 3]
+
+  (elemAt ["a" "b" "c" "d"] 2)
+  #=> "c"
+
+  (elem 2 [1 2 3])
+  #=> true
+  (elem 5 [1 2 3])
+  #=> false
+
+  (filter (n: n < 3) [1 2 3 4])
+  #=> [ 1 2 ]
+
+
+  #  Sets
+  #=========================================
+
+  # A "set" is an unordered mapping with string keys.
+  { foo = [1 2]; bar = "x"; }
+
+  # The . operator pulls a value out of a set.
+  { a = 1; b = 2; }.a
+  #=> 1
+
+  # The // operator merges two sets.
+  ({ a = 1; } // { b = 2; })
+  #=> { a = 1; b = 2; }
+
+  # Values on the right override values on the left.
+  ({ a = 1; b = 2; } // { a = 3; c = 4; })
+  #=> { a = 3; b = 2; c = 4; }
+
+  # The rec keyword denotes a "recursive set",
+  # in which attributes can refer to each other.
+  (let a = 1; in     { a = 2; b = a; }.b)
+  #=> 1
+  (let a = 1; in rec { a = 2; b = a; }.b)
+  #=> 2
+
+  # Nested sets can be defined in a piecewise fashion.
+  {
+    a.b   = 1;
+    a.c.d = 2;
+    a.c.e = 3;
+  }.a.c
+  #=> { d = 2; e = 3; }
+
+  # An attribute's descendants cannot be assigned in this
+  # way if the attribute itself has been directly assigned.
+  {
+    a = { b = 1; };
+    a.c = 2;
+  }
+  #=> error: attribute ‘a’ already defined
+
+
+  #  With
+  #=========================================
+
+  # The body of a `with` block is evaluated with
+  # a set's mappings bound to variables.
+  (with { a = 1; b = 2; };
+    a + b)
+  # => 3
+
+  # Inner bindings shadow outer bindings.
+  (with { a = 1; b = 2; };
+    (with { a = 5; };
+      a + b))
+  #=> 7
+
+  # This first line of tutorial starts with "with builtins;"
+  # because builtins is a set the contains all of the built-in
+  # functions (length, head, tail, filter, etc.). This saves
+  # us from having to write, for example, "builtins.length"
+  # instead of just "length".
+
+
+  #  Set patterns
+  #=========================================
+
+  # Sets are useful when we need to pass multiple values
+  # to a function.
+  (args: args.x + "-" + args.y) { x = "a"; y = "b"; }
+  #=> "a-b"
+
+  # This can be written more clearly using set patterns.
+  ({x, y}: x + "-" + y) { x = "a"; y = "b"; }
+  #=> "a-b"
+
+  # By default, the pattern fails on sets containing extra keys.
+  ({x, y}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+  #=> error: anonymous function called with unexpected argument ‘z’
+
+  # Adding ", ..." allows ignoring extra keys.
+  ({x, y, ...}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+  #=> "a-b"
+
+
+  #  Errors
+  #=========================================
+
+  # `throw` causes evaluation to abort with an error message.
+  (2 + (throw "foo"))
+  #=> error: foo
+
+  # `tryEval` catches thrown errors.
+  (tryEval 42)
+  #=> { success = true; value = 42; }
+  (tryEval (2 + (throw "foo")))
+  #=> { success = false; value = false; }
+
+  # `abort` is like throw, but it's fatal; it cannot be caught.
+  (tryEval (abort "foo"))
+  #=> error: evaluation aborted with the following error message: ‘foo’
+
+  # `assert` evaluates to the given value if true;
+  # otherwise it throws a catchable exception.
+  (assert 1 < 2; 42)
+  #=> 42
+  (assert 1 > 2; 42)
+  #=> error: assertion failed at (string):1:1
+  (tryEval (assert 1 > 2; 42))
+  #=> { success = false; value = false; }
+
+
+  #  Impurity
+  #=========================================
+
+  # Because repeatability of builds is critical to the Nix package
+  # manager, in which, functional purity is emphasized in the Nix
+  # language. But there are a few impurities.
+
+  # You can refer to environment variables.
+  (getEnv "HOME")
+  #=> "/home/alice"
+
+  # The trace function is used for debugging. It prints the first
+  # argument to stderr and evaluates to the second argument.
+  (trace 1 2)
+  #=> trace: 1
+  #=> 2
+
+  # You can write files into the Nix store. Although impure, this is
+  # fairly safe because the file name is derived from the hash of
+  # its contents. You can read files from anywhere. In this example,
+  # we write a file into the store, and then read it back out.
+  (let filename = toFile "foo.txt" "hello!"; in
+    [filename (builtins.readFile filename)])
+  #=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ]
+
+  # We can also download files into the Nix store.
+  (fetchurl "https://example.com/package-1.2.3.tgz")
+  #=> "/nix/store/2drvlh8r57f19s9il42zg89rdr33m2rm-package-1.2.3.tgz"
+
+]
+```
+
+### Further Reading
+
+* [Nix Manual - Nix expression language]
+  (https://nixos.org/nix/manual/#ch-expression-language)
+
+* [James Fisher - Nix by example - Part 1: The Nix expression language]
+  (https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55)
+
+* [Susan Potter - Nix Cookbook - Nix By Example]
+  (http://funops.co/nix-cookbook/nix-by-example/)
diff --git a/nl-nl/amd-nl.html.markdown b/nl-nl/amd-nl.html.markdown
deleted file mode 100644
index d5e0022a..00000000
--- a/nl-nl/amd-nl.html.markdown
+++ /dev/null
@@ -1,235 +0,0 @@
----
-category: tool
-tool: amd
-contributors:
-    - ["Frederik Ring", "https://github.com/m90"]
-translators:
-    - ["Reinoud Kruithof", "https://github.com/reinoudk"]
-filename: learnamd-nl.js
-lang: nl-nl
----
-
-## Aan de slag met AMD
-
-De **Asynchronous Module Definition** API specificeert een mechanisme om JavaScript
- modules the defini�ren zodat de module en dependencies (afhankelijkheden) asynchroon
- geladen kunnen worden. Dit is vooral erg geschikt voor de browseromgeving, waar het
- synchroon laden van modules zorgt voor problemen qua prestatie, gebruiksvriendelijkheid,
- debugging en cross-domain toegangsproblemen. 
-
-### Basis concept
-```javascript
-// De basis AMD API bestaat uit niks meer dan twee methodes: `define` en `require`
-// and gaat vooral over de definitie en gebruik van modules: 
-// `define(id?, dependencies?, factory)` definieert een module
-// `require(dependencies, callback)` importeert een set van dependencies en
-// gebruikt ze in de gegeven callback
-
-// Laten we starten met het gebruiken van define om een nieuwe module (met naam)
-// te cre�eren, welke geen dependencies heeft. Dit doen we door een naam
-// en een zogeheten factory functie door te geven aan define:
-define('awesomeAMD', function(){
-  var isAMDAwesome = function(){
-    return true;
-  };
-  // De return waarde van een module's factory functie is
-  // wat andere modules of require calls ontvangen wanneer
-  // ze onze `awesomeAMD` module requiren. 
-  // De ge�xporteerde waarde kan van alles zijn: (constructor) functies,
-  // objecten, primitives, zelfs undefined (hoewel dat niet veel nut heeft).
-  return isAMDAwesome;
-});
-
-
-// We gaan nu een andere module defineren die afhankelijk is van onze 
-// `awesomeAMD` module. Merk hierbij op dat er nu een extra functieargument 
-// is die de dependencies van onze module defineert:
-define('schreewlelijk', ['awesomeAMD'], function(awesomeAMD){
-  // dependencies worden naar de factory's functieargumenten
-  // gestuurd in de volgorde waarin ze gespecificeert zijn
-  var vertelIedereen = function(){
-    if (awesomeAMD()){
-      alert('Dit is zOoOo cool!');
-    } else {
-      alert('Vrij saai, niet?');
-    }
-  };
-  return vertelIedereen;
-});
-
-// Nu we weten hoe we define moeten gebruiken, kunnen we require gebruiken
-// om ons programma mee te starten. De vorm van `require` is
-// `(arrayVanDependencies, callback)`.
-require(['schreeuwlelijk'], function(schreewlelijk){
-  schreeuwlelijk();
-});
-
-// Om deze tutorial code uit te laten voeren, gaan we hier een vrij basic
-// (niet-asynchrone) versie van AMD implementeren:
-function define(naam, deps, factory){
-  // merk op hoe modules zonder dependencies worden afgehandeld
-  define[naam] = require(factory ? deps : [], factory || deps);
-}
-
-function require(deps, callback){
-  var args = [];
-  // we halen eerst alle dependecies op die nodig zijn
-  // om require aan te roepen
-  for (var i = 0; i < deps.length; i++){
-    args[i] = define[deps[i]];
-  }
-  // voldoe aan alle dependencies van de callback
-  return callback.apply(null, args);
-}
-// je kan deze code hier in actie zien (Engels): http://jsfiddle.net/qap949pd/
-```
-
-### require.js in de echte wereld
-
-In contrast met het voorbeeld uit de introductie, implementeert `require.js`
- (de meest populaire AMD library) de **A** in **AMD**. Dit maakt het mogelijk
- om je modules en hun dependencies asynchroon in the laden via XHR:
-
-```javascript
-/* file: app/main.js */
-require(['modules/someClass'], function(SomeClass){
-  // de callback word uitgesteld tot de dependency geladen is
-  var things = new SomeClass();
-});
-console.log('Dus, hier wachten we!'); // dit wordt als eerste uitgevoerd
-```
-
-De afspraak is dat je over het algemeen ��n module in ��n bestand opslaat.
-`require.js` kan module-namen achterhalen gebaseerd op de bestandslocatie,
-dus je hoeft je module geen naam te geven. Je kan simpelweg aan ze referen 
- door hun locatie te gebruiken.
-In het voorbeeld nemen we aan dat `someClass` aanwezig is in de `modules` map,
- relatief ten opzichte van de `baseUrl` uit je configuratie.
-
-* app/
-  * main.js
-  * modules/
-    * someClass.js
-    * someHelpers.js
-    * ...
-  * daos/
-    * things.js
-    * ...
-
-Dit betekent dat we `someClass` kunnen defineren zonder een module-id te specificeren:
-
-```javascript
-/* file: app/modules/someClass.js */
-define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
-  // definitie van de module gebeurt, natuurlijk, ook asynchroon
-  function SomeClass(){
-    this.method = function(){/**/};
-    // ...
-  }
-  return SomeClass;
-});
-```
-Gebruik `requirejs.config(configObj)` om het gedrag van de standaard mapping
- aan te passen in je `main.js`: 
-
-```javascript
-/* file: main.js */
-requirejs.config({
-  baseUrl : 'app',
-  paths : {
-    // je kan ook modules uit andere locatie inladen
-    jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
-    coolLibUitBower : '../bower_components/cool-lib/coollib'
-  }
-});
-require(['jquery', 'coolLibUitBower', 'modules/someHelpers'], function($, coolLib, helpers){
-  // een `main` bestand moet require minstens eenmaal aanroepen,
-  // anders zal er geen code uitgevoerd worden
-  coolLib.doFancyDingenMet(helpers.transform($('#foo')));
-});
-```
-Op `require.js` gebaseerde apps hebben vaak een enkel beginpunt (`main.js`)
- welke toegevoegd wordt aan de `require.js` script tag als een data-attribuut.
-Deze zal automisch geladen en uitgevoerd worden als de pagina laadt:
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Honder script tags? Nooi meer!</title>
-</head>
-<body>
-  <script src="require.js" data-main="app/main"></script>
-</body>
-</html>
-```
-
-### Een heel project optimaliseren met r.js
-
-Veel mensen geven er de voorkeur aan om AMD te gebruiken tijdens de 
-  ontwikkelfase om code op een gezonde manier te organiseren maar 
-  willen nog steeds een enkel scriptbestand gebruiken in productie in 
-  plaats van honderderen XHR verzoeken uit te voeren als de pagina laadt.
-
-`require.js` wordt geleverd met een script genaamd `r.js` (die je waarschijnlijk
-uitvoert in node.js, hoewel Rhino ook ondersteund wordt) welke de 
-dependency book van je project analyseert en een enkel bestand bouwt met daarin
-al je module (juist genaamd), geminificeerd en klaar voor productie.
-
-Instaleren met `npm`:
-```shell
-$ npm install requirejs -g
-```
-
-Nu kun je het een configuratiebestand voeden:
-```shell
-$ r.js -o app.build.js
-```
-
-Voor ons bovenstaande voorbeeld zou de configuratie er zo uit kunnen zien:
-```javascript
-/* file : app.build.js */
-({
-  name : 'main', // naam van het beginpunt
-  out : 'main-built.js', // naam van het bestand waar de output naar geschreven wordt
-  baseUrl : 'app',
-  paths : {
-    // `empty:` verteld r.js dat dee nog steeds geladen moet worden van de CDN,
-    // gebruik makend van de locatie gespecificeert in `main.js`
-    jquery : 'empty:',
-    coolLibUitBower : '../bower_components/cool-lib/coollib'
-  }
-})
-```
-Verwissel simpelweg `data-main` om het gebouwde bestand te gebruiken in productie:
-```html
-<script src="require.js" data-main="app/main-built"></script>
-```
-
-Een erg gedetaileerd [overzicht van bouwopties](https://github.com/jrburke/r.js/blob/master/build/example.build.js) is
-beschikbar in de GitHub repo (Engels).
-
-Hieronder vind je nog meer informatie over AMD (Engels).
-
-### Onderwerpen die niet aan bod zijn gekomen
-* [Loader plugins / transforms](http://requirejs.org/docs/plugins.html)
-* [CommonJS style loading and exporting](http://requirejs.org/docs/commonjs.html)
-* [Advanced configuration](http://requirejs.org/docs/api.html#config)
-* [Shim configuration (loading non-AMD modules)](http://requirejs.org/docs/api.html#config-shim)
-* [CSS loading and optimizing with require.js](http://requirejs.org/docs/optimization.html#onecss)
-* [Using almond.js for builds](https://github.com/jrburke/almond)
-
-### Verder lezen:
-
-* [Official Spec](https://github.com/amdjs/amdjs-api/wiki/AMD)
-* [Why AMD?](http://requirejs.org/docs/whyamd.html)
-* [Universal Module Definition](https://github.com/umdjs/umd)
-
-### Implementaties:
-
-* [require.js](http://requirejs.org)
-* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
-* [cujo.js](http://cujojs.com/)
-* [curl.js](https://github.com/cujojs/curl)
-* [lsjs](https://github.com/zazl/lsjs)
-* [mmd](https://github.com/alexlawrence/mmd)
diff --git a/nl-nl/bash-nl.html.markdown b/nl-nl/bash-nl.html.markdown
new file mode 100644
index 00000000..da47e2a9
--- /dev/null
+++ b/nl-nl/bash-nl.html.markdown
@@ -0,0 +1,235 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Etan Reisner", "https://github.com/deryni"]
+translators:
+    - ["Jeroen Deviaene", "https://www.github.com/jerodev"]
+lang: nl-nl
+filename: LearnBash-nl.sh
+---
+
+Bash is de naam van den unix shell, deze wordt gebruikt voor het GNU operating system en is de standaard shell op Linux en Mac OS X.
+Bijna alle voorbeelden hier onder kunnen deel uitmaken van een shell script of kunnen uitgevoerd worden in de shell.
+
+[Lees er meer over hier.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# De eerste lijn in het schript is shebang, deze laat het systeem weten hoe
+# het script uitgevoerd moet worden: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Zoals je kan zien wordt # gebruikt om een commentaar lijn te starten.
+
+# Simpel hello world voorbeeld:
+echo Hello world!
+
+# Elke command start op een nieuwe lijn, of achter een puntkomma (;):
+echo 'Dit is de eerste lijn'; echo 'Dit is de tweede lijn'
+
+# Een varialbe declareren gebeurt op volgende manier:
+Variabele="Een string"
+
+# Maar niet op deze manier:
+Variabele = "Een string"
+# Bash ziet variable als een commando en zal een error geven omdat dit commando
+# niet bestaat.
+
+# Of op deze manier:
+Variabele= 'Een string'
+# Bash zal 'Een string' zien als een commanda en een error geven omdat het niet
+# gevonden kan worden.
+
+# Variabelen gebruiken:
+echo $Variabele
+echo "$Variabele"
+echo '$Variabele'
+# Wanneer je een variable wil toekennen, exporteren of nog anders gebruik je 
+# de naam zonder '$'. Als je de waarde van de variabele wilt, gebruik je een 
+# '$' voor de naam.
+
+# Strings vervangen in variables
+echo ${Variabele/Een/De}
+# Dit zal 'Een' vervangen door 'De' in de string
+
+# Substring
+Length=7
+echo ${Variabele:0:Length}
+# Dit zal de eerste 7 tekens van de string weergeven.
+
+# Standaard waarde voor variabele
+echo ${Foo:-"StandaardwaardeAlsFooLeegIsOfNietBestaat"}
+# Dit werkt voor null en lege strings (Foo=""). Dit werkt niet voor 0 (Foo=0).
+# Merk op dat dit enkel de waarde retourneerd en de variable niet aanpast.
+
+
+# Ingebouwde variabelen:
+# Er zijn enkele zeer handige ingebouwde variabelen, zoals:
+echo "Return waarde van laatste programma: $?"
+echo "PID van dit script: $$"
+echo "Aantal argumenten voor dit script: $#"
+echo "Alle argumenten voor dit script: $@"
+echo "Argumenten voor dit script in apparte variabelen: $1 $2..."
+
+# Een waarde lezen via input:
+echo "Wat is uw naam?"
+read Naam # Merk op dat we geen variabele gedeclareerd hebben
+echo Hallo, $Naam!
+
+# We hebben ook if structuren
+# Gebruik 'man test' voor meer informatie over condities.
+if [ $Naam -ne $USER ]
+then
+    echo "Uw naam is niet gelijk aan de gebruikersnaam"
+else
+    echo "Uw naam is de gebruikersnaam"
+fi
+
+# MERK OP: als $Naam leeg is ziet bash het bovenstaande als volgt:
+if [ -ne $USER ]
+# dit is ongeldige syntax
+# Dus de beter manier om dit te schrijven is
+if [ "$Naam" -ne $USER ] ...
+# Als naam nu leeg is, ziet bash nu nog steeds
+if [ "" -ne $USER ] ...
+# Dit werkt wel zoals het hoort
+
+# Er is ook conditionele executie
+echo "Altijd uitvoeren" || echo "Enkel uitvoeren als vorige command mislukt"
+echo "Altijd uitvoeren" && echo "Enkel uitvoeren als vorige command NIET mislukt"
+
+# Om && en || te gebruiken in if structuren moeten vierkante haken gebruikt worden:
+if [ "$Naam" == "Steve" ] && [ "$Leeftijd" -eq 15 ]
+then
+    echo "Dit wordt uitgevoerd als $Naam Steve is en $Leeftijd 15 is."
+fi
+
+# Expressies worden gemaakt met volgende syntax:
+echo $(( 10 + 5 ))
+
+# Bash werkt steeds in de context van een huidige map in het bestandssysteem.
+# Bestanden en mappen in de huidige map kunnen weergegeven worden met het ls
+# commando.
+ls
+
+# Commandos hebben opties die de uitvoer beinvloeden
+ls -l # Lijst elk bestand en map op een nieuwe lijn.
+
+# Resultaten van een vorig commando kunnen doorgegeven worden aan een volgend 
+# commando als input.
+# Het grep commando filter de input met een bepaald patroon. Op deze manier kunnen
+# we alle .txt bestanden weergeven in de huidige map.
+ls -l | grep "\.txt"
+
+# Commando's kunnen gekoppeld worden met andere commando's door gebruik te maken van
+# $( ):
+# Het volgende commando geeft het aantal bestanden weer in de huidige map
+echo "Er zijn hier $(ls | wc -l) bestanden."
+
+# Het zelfde kan gedaan worden met `, maar die kunnen niet genest worden. De methode
+# bij voorkeur is om $( ) te gebruiken.
+echo "Er zijn hier `ls | wc -l` bestanden."
+
+# Bash heeft een case statement dat werkt zoals in Java en C++
+case "$Variabele" in
+    0) echo "Er is een 0";;
+    1) echo "Er is een 1";;
+    *) echo "Er is iets";;
+esac
+
+# For lussen itereren over de gegeven argumenten
+# De waarde van $Variabele wordt hier drie keer afgeprint
+for Variable in {1..3}
+do
+    echo "$Variabele"
+done
+
+# Of schrijf een traditionele for loop op deze manier
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Lussen kunnen ook gebruikt worden met bestanden
+# Deze lus voert het cat commando uit op file1 en file2
+for Variable in file1 file2
+do
+    cat "$Variable"
+done
+
+# Of met het output commando
+for Output in $(ls)
+do
+    cat "$Output"
+done
+
+# while lus:
+while [ true ]
+do
+    echo "body van de lus..."
+    break
+done
+
+# Je kan ook functies aanmaken
+# Defenitie:
+function foo ()
+{
+    echo "Alle argumenten: $@"
+    echo "Apparte argumenten: $1 $2..."
+    echo "Dit is een functie"
+    return 0
+}
+
+# Of simpeler
+bar ()
+{
+    echo "Dit is een andere manier om functies te maken."
+    return 0
+}
+
+# Functies oproepen
+foo "Mijn naam is" $Naam
+
+# Enkele zeer handige commando's die je moet kennen
+# print de laatste 10 lijnen van file.txt
+tail -n 10 file.txt
+# print de eerste 10 lijnen van file.txt
+head -n 10 file.txt
+# Sorteer de lijnen in file.txt
+sort file.txt
+# Vind dubbele lijnen in file.txt
+uniq -d file.txt
+# Print de eerste kolom voor het ',' karakter
+cut -d ',' -f 1 file.txt
+# Vervang elke 'okay' met 'great' in file.txt (werkt ook met regex)
+sed -i 's/okay/great/g' file.txt
+# Print alle lijnen die voldoen aan de regex naar stdout
+grep "^foo.*bar$" file.txt
+
+
+# Gebruik de ingebouwde help functies door het help commando te gebruiken:
+help
+help help
+help for
+help return
+help source
+help .
+
+# Lees de bash documentatie met het man commando:
+apropos bash
+man 1 bash
+man bash
+
+# Lees bash info documentatie:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/nl-nl/brainfuck-nl.html.markdown b/nl-nl/bf.html.markdown
index 6062b24c..016e2ba2 100644
--- a/nl-nl/brainfuck-nl.html.markdown
+++ b/nl-nl/bf.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/nl-nl/coffeescript-nl.html.markdown b/nl-nl/coffeescript-nl.html.markdown
index dc0b1e19..390e6572 100644
--- a/nl-nl/coffeescript-nl.html.markdown
+++ b/nl-nl/coffeescript-nl.html.markdown
@@ -6,6 +6,7 @@ contributors:
 translators:
   - ["Jelle Besseling", "https://github.com/Jell-E"]
   - ["D.A.W. de Waal", "http://github.com/diodewaal"]
+  - ["Sam van Kampen", "http://tehsvk.net"]
 filename: coffeescript-nl.coffee
 lang: nl-nl
 ---
@@ -13,10 +14,10 @@ lang: nl-nl
 CoffeeScript is een kleine programmeertaal die direct compileert naar
 JavaScript en er is geen interpretatie tijdens het uitvoeren.
 CoffeeScript probeert om leesbare, goed geformatteerde en goed draaiende
-JavaScript code te genereren, die in elke JavaScript runtime werkt, als een
+JavaScript code te genereren, die in elke JavaScript-runtime werkt, als een
 opvolger van JavaScript.
 
-Op [de CoffeeScript website](http://coffeescript.org/), staat een
+Op [de CoffeeScript-website](http://coffeescript.org/), staat een
 volledigere tutorial voor CoffeeScript.
 
 ``` coffeescript
@@ -26,7 +27,7 @@ volledigere tutorial voor CoffeeScript.
 
 ###
 Blokken commentaar maak je zo, ze vertalen naar JavaScripts */ en /*
-in de uitvoer van de CoffeeScript compiler.
+in de uitvoer van de CoffeeScript-compiler.
 
 Het is belangrijk dat je ongeveer snapt hoe JavaScript
 werkt voordat je verder gaat.
@@ -43,7 +44,7 @@ getal = -42 if tegengestelde #=> if(tegengestelde) { getal = -42; }
 kwadraat = (x) -> x * x #=> var kwadraat = function(x) { return x * x; }
 
 vul = (houder, vloeistof = "koffie") ->
-  "Nu de #{houder} met #{koffie} aan het vullen..."
+  "Nu de #{houder} met #{vloeistof} aan het vullen..."
 #=>var vul;
 #
 #vul = function(houder, vloeistof) {
@@ -80,7 +81,7 @@ wedstrijd = (winnaar, lopers...) ->
 alert "Ik wist het!" if elvis?
 #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
 
-# Lijst abstractie:
+# Lijstabstracties:
 derdemachten = (wiskunde.derdemacht num for num in lijst)
 #=>derdemachten = (function() {
 #	var _i, _len, _results;
diff --git a/nl-nl/json-nl.html.markdown b/nl-nl/json-nl.html.markdown
new file mode 100644
index 00000000..906112ff
--- /dev/null
+++ b/nl-nl/json-nl.html.markdown
@@ -0,0 +1,71 @@
+---
+language: json
+filename: learnjson-nl.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+translators:
+  - ["Niels van Velzen", "https://nielsvanvelzen.me"]
+lang: nl-nl
+---
+
+Gezien JSON een zeer eenvouding formaat heeft zal dit een van de simpelste
+Learn X in Y Minutes ooit zijn.
+
+JSON heeft volgens de specificaties geen commentaar, ondanks dat hebben de
+meeste parsers support voor C-stijl (`//`, `/* */`) commentaar.
+Sommige parsers staan zelfs trailing komma's toe.
+(Een komma na het laatste element in een array of ahter de laatste eigenshap van een object).
+Het is wel beter om dit soort dingen te vermijden omdat het niet overal zal werken.
+
+In het voorbeeld zal alleen 100% geldige JSON gebruikt worden.
+
+Data types gesupport door JSON zijn: nummers, strings, booleans, arrays, objecten en null.
+Gesupporte browsers zijn: Firefox(Mozilla) 3.5, Internet Explorer 8, Chrome, Opera 10, Safari 4.
+De extensie voor JSON bestanden is ".json". De MIME type is "application/json"
+Enkele nadelen van JSON zijn het gebrek een type definities en een manier van DTD.
+
+```json
+{
+  "sleutel": "waarde",
+
+  "sleutels": "zijn altijd in quotes geplaatst",
+  "nummers": 0,
+  "strings": "Hallø, wereld. Alle unicode karakters zijn toegestaan, samen met \"escaping\".",
+  "boolean": true,
+  "niks": null,
+
+  "groot nummer": 1.2e+100,
+
+  "objecten": {
+    "commentaar": "In JSON gebruik je vooral objecten voor je strutuur",
+
+    "array": [0, 1, 2, 3, "Arrays kunnen alles in zich hebben.", 5],
+
+    "nog een object": {
+      "commentaar": "Objecten kunnen genest worden, erg handig."
+    }
+  },
+
+  "dwaasheid": [
+    {
+      "bronnen van kalium": ["bananen"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "alternatieve stijl": {
+    "commentaar": "Kijk dit!"
+  , "De komma positie": "maakt niet uit zolang het er maar is"
+  , "nog meer commentaar": "wat leuk"
+  },
+
+  "dat was kort": "En nu ben je klaar, dit was alles wat je moet weten over JSON."
+}
+```
diff --git a/nl-nl/json.html.markdown b/nl-nl/json.html.markdown
new file mode 100644
index 00000000..bedfb70a
--- /dev/null
+++ b/nl-nl/json.html.markdown
@@ -0,0 +1,61 @@
+---
+language: json
+filename: learnjson-nl.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+  - ["Mathieu De Coster", "https://github.com/m-decoster"]
+lang: nl-nl
+---
+
+Aangezien JSON een extreem eenvoudig datauitwisselingsformaat is, zal dit waarschijnlijk
+de meest eenvoudige Learn X in Y Minutes ooit zijn.
+
+Puur JSON heeft geen commentaar, maar de meeste parsers zullen commentaar in de stijl
+van C (`//`, `/* */`) aanvaarden. In dit voorbeeld zal alles 100% correcte JSON zijn.
+Gelukkig spreekt het meeste voor zichzelf.
+
+```json
+{
+  "key": "value",
+
+  "keys": "moeten altijd tussen dubbele aanhalingstekens staan",
+  "getallen": 0,
+  "strings": "Hellø, world. Alle Unicode-karakters zijn toegelaten, zo ook \"escaping\".",
+  "heeft json booleans?": true,
+  "niets": null,
+
+  "groot getal": 1.2e+100,
+
+  "objecten": {
+    "commentaar": "De meeste structuur wordt gemaakt met objecten.",
+
+    "array": [0, 1, 2, 3, "Arrays kunnen eender wat bevatten.", 5],
+
+    "nog een object": {
+      "commentaar": "Hoe handig, we kunnen objecten nesten."
+    }
+  },
+
+  "dwaasheid": [
+    {
+      "bronnen van kalium": ["bananen"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "alternatieve stijl": {
+    "commentaar": "kijk hier eens naar!"
+  , "komma locatie": "maakt niet uit - zo lang het voor de value komt, is alles in orde"
+  , "nog commentaar": "hoe leuk"
+  },
+
+  "dat was kort": "Je bent klaar. Je kent nu alles dat JSON kan aanbieden."
+}
+```
diff --git a/nl-nl/markdown-nl.html.markdown b/nl-nl/markdown-nl.html.markdown
new file mode 100644
index 00000000..35cc67c5
--- /dev/null
+++ b/nl-nl/markdown-nl.html.markdown
@@ -0,0 +1,242 @@
+---
+language: markdown
+filename: markdown-nl.md
+contributors:
+  - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+  - ["Jeroen Deviaene", "https://www.github.com/jerodev"]
+lang: nl-nl
+---
+
+Markdown is gecreëerd door John Gruber in 2004. Het is bedoeld om met een gemakkelijke te lezen en 
+schrijven syntax te zijn die gemakkelijk omgevormd kan worden naar HTML (en op heden verschillende
+andere formaten)
+
+```markdown
+<!-- Markdown erft over van HTML, dus ieder HTML bestand is een geldig Markdown
+bestand. Dit betekend ook dat html elementen gebruikt kunnen worden in Markdown
+zoals het commentaar element. Echter, als je een html element maakt in een Markdown 
+document kan je geen markdown gebruiken voor de waarde van dat element. -->
+
+<!-- Markdown varieert ook van implementatie tot implementatie en per parser. Deze
+tutorial zal de universele functies van Markdown -->
+
+<!-- Headers -->
+<!-- Je kan de HTML elementen <h1> tot <h6> gemakkelijk maken door voor de titel
+een aantal hashes (#) te plaatsen gelijk aan het level van de header.
+# Dit is een <h1>
+## Dit is een <h2>
+### Dit is een <h3>
+#### Dit is een <h4>
+##### Dit is een <h5>
+###### Dit is een <h6>
+
+<!-- Markdown heeft ook een alternatieve manier om h1 en h2 te maken -->
+Dit is een h1
+=============
+
+Dit is een h2
+-------------
+
+<!-- Simpele tekst stijlen -->
+<!-- Tekst kan heel gemakelijk gestyled worden cursief of bold met markdown -->
+
+*Deze tekst is cursief*
+_Deze tekst ook_
+
+**Deze tekst is vet gedrukt**
+__En deze tekst ook!__
+
+***Deze tekst is zowel bold als schuin gedrukt***
+**_Deze ook!_**
+*__En zelfs deze!__*
+
+<!-- In de github versie van markdown, die gebruikt wordt om markdown te renderen
+op Github, is er ook doorstrepen -->
+
+~~Deze tekst wordt doorstreept.~~
+
+<!-- Paragrafen worden onderscheiden door een of meerdere lege lijnen -->
+
+Dit is een paragraaf. 
+
+Dit is paragraaf 2.
+Dit is nog steeds paragraaf 2!
+
+
+Hallo, ik ben paragraaf 3.
+
+<!-- Citaten zijn gemakkelijk te maken met het '>' karakter. -->
+
+> Dit is een citaat. Je kan alle lijnen manueel starten met een '>'.
+> Of je kan de lijn heel heel, heel, lang laten worden zodat de parser deze automatisch zal afbreken en op een nieuwe lijn plaatsen.
+> Het maakt niet uit, zolang je start met een '>'.
+
+> Je kan ook in niveaus werken
+>> Niveau 2
+> Hoe leuk is dat?
+
+<!-- Lijsten -->
+<!-- Niet geordende lijsten kunnen gemaakt worden met sterretjes, plussen of streepjes -->
+
+* Item
+* Item
+* Nog een item
+
+of
+
++ Item
++ Item
++ Nog een item
+
+of
+
+- Item
+- Item
+- Een laatste item
+
+<!-- Geordende lijsten kunnen gemaakt wroden met cijfers -->
+
+1. Item een
+2. Item twee
+3. Item drie
+
+<!-- Het getal moet zelfs niet overeen komen met het item in de lijst, markdown zal
+automatisch de nummers aanpassen -->
+
+1. Item een
+1. Item twe
+1. Item drie
+<!-- (De output is gelijk aan de vorige lijst) -->
+
+<!-- Je kan ook gebruik maken van sub lijsten -->
+
+1. Item een
+2. Item twee
+3. Item drie
+    * Sub-item
+    * Sub-item
+4. Item vier
+
+<!-- Er zijn zelfs todo lijsten. Dit genereert HTML checkboxen. -->
+
+Boxen zonder een 'x' zijn niet aangevinkt
+- [ ] Eerste to-do item.
+- [ ] Tweede to-do item
+Dit item zal aangevinkt zijn in de gerenderde html.
+- [x] Deze taak is uitgevoerd
+
+<!-- Code blokken -->
+<!-- Een code block kan aangeduid worden door vier spaties of een tab -->
+
+    Dit is code
+    En dit ook
+
+<!-- Extra tabs kunnen gebruikt worden om tabs in de code aan te geven -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- Inline code kan aangeduid worden met ` -->
+
+John wist zelfs niet dat de `go_to()` functie bestond!
+
+<!-- In Github Markdown kan je een speciale syntax gebruiken die aangeeft welke
+taal gebruikt wordt in het code blok. -->
+
+\`\`\`ruby <!-- Wis de backslashes om dit te doen, juist ```ruby ! -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- Hier ook, geen backslashes, juist ``` -->
+
+<!-- Voor bovenstaande tekst moet geen tab gebruikt worden. Plus, Github zal syntax
+highlighting gebruiken voor deze specifieke taal. Hier, Ruby.
+
+<!-- Horizontale lijn (<hr />) -->
+<!-- Horizontale lijnen kunnen gemakkelijk toegevoegd worden door drie of meer
+sterretjes, of streepjes te plaatsen -->
+
+***
+---
+- - -
+****************
+
+<!-- Links -->
+<!-- Een van de beste dingen in Markdown is hoe simpel het is om links te maken.
+plaats de tekst om weer te geven tussen [ en ] gevolgd door de link tussen ( en ) -->
+
+[Klik mij!](http://test.com/)
+
+<!-- Een titel kan ook toegevoegd worden aan de link met aanhalingstekens -->
+
+[Klik mij!](http://test.com/ "Titel voor de link")
+
+<!-- Relative paden werken ook -->
+
+[Naar de muziek](/music/).
+
+<!-- Links kunnen ook gelegd worden met referenties -->
+
+[Klik deze link][link1] voor meer info!
+[Beijk ook dit][foobar] als je echt wil.
+
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Tof!"
+
+
+<!-- Afbeeldingen -->
+<!-- Afbeeldingen worden toegevoegd op exact de zelfde manier als links maar met een 
+uitroepteken aan het begin van de lijn. -->
+
+![Dit is de alt waarde van een afbeelding](http://imgur.com/myimage.jpg "Optionele titel")
+
+<!-- Referenties werkt ook zals bij links -->
+
+![Dit is de alt waarde][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "als een titel nodig is, staat deze hier"
+
+<!-- Varia -->
+<!-- Auto-links -->
+
+<http://testwebsite.com/> is gelijk aan
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Auto-links for emails -->
+
+<foo@bar.com>
+
+<!-- Karakters escapen -->
+
+Als je sterretjes wil gebruiken in je tekst zoals *dit* dan zal dit schuingedrukt weergegeven
+worden.
+Dit kan je oplossen met backslashes: \*dit\* staat tussen sterretjes
+
+<!-- Toetsenbord toetsen -->
+<!-- In Github Markdown, kan je <kbd> gebruiken om toetsenbord toetsen weer te geven -->
+
+Loopt je computer vast? Probeer volgende toetsen combinatie:
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+
+<!-- Tabellen -->
+<!-- Tabellen zijn momenteel enkel beschikbaar in Github Markdown en zijn redelijk omslachtig.
+Maar als je er echt wilt toevoegen: -->
+
+| Col1             | Col2        | Col3              |
+| :--------------- | :---------: | ----------------: |
+| Links uitgelijnt | Gecentreerd | Rechts uitgelijnt |
+| blah             | blah        | blah              |
+
+<!-- of, Voor het zelfde resultaat -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Zeer | Lelijke | Code!
+
+<!-- The end! -->
+
+```
+
+Voor meer info, bekijk de officiële post van John Gruber [hier](http://daringfireball.net/projects/markdown/syntax) en de handige cheatsheet van Adam Pritchard [hier](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/nl-nl/typescript-nl.html.markdown b/nl-nl/typescript-nl.html.markdown
new file mode 100644
index 00000000..dcea2a4d
--- /dev/null
+++ b/nl-nl/typescript-nl.html.markdown
@@ -0,0 +1,174 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+filename: learntypescript-nl.ts
+translators:
+  - ["Niels van Velzen", "https://nielsvanvelzen.me"]
+lang: nl-nl
+---
+
+TypeScript is een taal gericht op het versoepelen van de ontwikkeling van
+grote applicaties gemaakt in JavaScript.
+TypeScript voegt veelgebruikte technieken zoals klassen, modules, interfaces,
+generieken en statische typen toe aan JavaScript.
+TypeScript is een superset van JavaScript: alle JavaScript code is geldige
+TypeScript code waardoor de overgang van JavaScript naar TypeScript wordt versoepeld.
+
+Dit artikel focust zich alleen op de extra's van TypeScript tegenover [JavaScript] (../javascript-nl/).
+
+Om de compiler van TypeScript te kunnen proberen kun je naar de [Playground] (http://www.typescriptlang.org/Playground) gaan.
+Hier kun je automatisch aangevulde code typen in TypeScript en de JavaScript variant bekijken.
+
+```js
+// Er zijn 3 basis typen in TypeScript
+var isKlaar: boolean = false;
+var lijnen: number = 42;
+var naam: string = "Peter";
+
+// Wanneer het type onbekend is gebruik je "Any"
+var nietZeker: any = 4;
+nietZeker = "misschien een string";
+nietZeker = false; // Toch een boolean
+
+// Voor collecties zijn er "typed arrays"
+var lijst: number[] = [1, 2, 3];
+// of generieke arrays
+var lijst: Array<number> = [1, 2, 3];
+
+// Voor enumeraties:
+enum Kleur {Rood, Groen, Blauw};
+var c: Kleur = Kleur.Groen;
+
+// Als laatst, "void" wordt gebruikt voor als een functie geen resultaat geeft
+function groteVerschrikkelijkeMelding(): void {
+  alert("Ik ben een vervelende melding!");
+}
+
+// Functies zijn eersteklas ?, supporten de lambda "fat arrow" syntax en
+// gebruiken gebruiken "type inference"
+
+// Het volgende is allemaal hetzelfde
+var f1 = function(i: number): number { return i * i; }
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+var f4 = (i: number) => { return i * i; }
+// Omdat we maar 1 lijn gebruiken hoeft het return keyword niet gebruikt te worden
+var f5 = (i: number) =>  i * i;
+
+// Interfaces zijn structureel, elk object wat de eigenschappen heeft
+// is een gebruiker van de interface
+interface Persoon {
+  naam: string;
+  // Optionele eigenschappen worden gemarkeerd met "?"
+  leeftijd?: number;
+  // En natuurlijk functies
+  verplaats(): void;
+}
+
+// Object die gebruikt maakt van de "Persoon" interface
+// Kan gezien worden als persoon sinds het de naam en verplaats eigenschappen bevat
+var p: Persoon = { naam: "Bobby", verplaats: () => {} };
+// Object met de optionele leeftijd eigenschap
+var geldigPersoon: Persoon = { naam: "Bobby", leeftijd: 42, verplaats: () => {} };
+// Ongeldig persoon vanwege de leeftijds type
+var ongeldigPersoon: Persoon = { naam: "Bobby", leeftijd: true };
+
+// Interfaces kunnen ook een functie ype beschrijven
+interface ZoekFunc {
+  (bron: string, subString: string): boolean;
+}
+// Alleen de parameters types zijn belangrijk, namen maken niet uit.
+var mySearch: ZoekFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Classes - leden zijn standaard publiek
+class Punt {
+    // Eigenschappen
+    x: number;
+
+    // Constructor - de publieke / prive trefwoorden in deze context zullen
+    // eigenschappen in de klasse kunnen aanmaken zonder ze te defineren.
+    // In dit voorbeeld zal "y" net als "x" gedefineerd worden met minder code.
+    // Standaard waardes zijn ook gesupport
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Functies
+    dist(): number { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Statische leden
+    static origin = new Punt(0, 0);
+}
+
+var p1 = new Punt(10 ,20);
+var p2 = new Punt(25); // y zal de waarde 0 krijgen
+
+// Overnemen
+class Punt3D extends Punt {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Constructor van ouder aanroepen (Punt)
+    }
+
+    // Overschrijven
+    dist(): number {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Modules werken ongeveer hetzelfde als namespaces
+// met "." kan je submodules defineren
+module Geometrie {
+  export class Vierkant {
+    constructor(public zijLengte: number = 0) {
+    }
+
+    oppervlakte() {
+      return Math.pow(this.zijLengte, 2);
+    }
+  }
+}
+
+var s1 = new Geometrie.Vierkant(5);
+
+// Local alias for referencing a module
+import G = Geometrie;
+
+var s2 = new G.Vierkant(10);
+
+// Generieken
+// Classes
+class Tupel<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfaces
+interface Paar<T> {
+    item1: T;
+    item2: T;
+}
+
+// En functies
+var paarNaarTupel = function<T>(p: Paar<T>) {
+    return new Tupel(p.item1, p.item2);
+};
+
+var tupel = paarNaarTupel({ item1: "hallo", item2: "wereld" });
+
+// Refferentie naar een definitie bestand:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Verder lezen (engels)
+ * [TypeScript Official website] (http://www.typescriptlang.org/)
+ * [TypeScript language specifications (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Source Code on GitHub] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
diff --git a/nl-nl/xml-nl.html.markdown b/nl-nl/xml-nl.html.markdown
new file mode 100644
index 00000000..832de821
--- /dev/null
+++ b/nl-nl/xml-nl.html.markdown
@@ -0,0 +1,134 @@
+---
+language: xml
+filename: learnxml-nl.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+  - ["Frank van Gemeren", "https://github.com/frvge"]
+lang: nl-nl
+---
+
+XML is een markuptaal die ontwikkeld is om data in te bewaren en data mee te 
+verzenden.
+
+Anders dan HTML specificeert XML niet hoe data getoond of geformatteerd moet worden. 
+Het bevat de data slechts.
+
+* XML Syntax
+
+```xml
+<!-- Dit is commentaar in XML -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<boekenwinkel>
+  <boek categorie="KOKEN">
+    <title taal="nl">Alledaags Italiaans</titel>
+    <auteur>Giada De Laurentiis</auteur>
+    <jaar>2005</jaar>
+    <prijs>30.00</prijs>
+  </boek>
+  <boek categorie="KINDEREN">
+    <titel taal="nl">Harry Potter</titel>
+    <auteur>J K. Rowling</auteur>
+    <jaar>2005</jaar>
+    <prijs>29.99</prijs>
+  </boek>
+  <boek categorie="WEB">
+    <titel taal="en">Learning XML</titel>
+    <auteur>Erik T. Ray</auteur>
+    <jaar>2003</jaar>
+    <prijs>39.95</prijs>
+  </boek>
+</boekenwinkel>
+
+<!-- Hierboven staat een standaard XML bestand.
+  Het begint met een declaratie die optionele metadata bevat.
+
+  XML werkt met een boomstructuur. De stamknoop hierboven is 'boekenwinkel'. 
+  Deze heeft drie kinderen die allemaal 'boek' zijn. Deze knopen hebben op 
+  hun beurt weer kinderen, enzovoort...
+
+  Knopen hebben open- en sluittags. Kinderen zijn knopen die zich tussen de 
+  open- en sluittags van hun ouders bevinden. -->
+
+<!-- XML bevat two soorten data:
+  1 - Attributen -> Dit is metadata van een knoop.
+      Deze informatie wordt meestal door de XML parser gebruikt om de data op
+      de juiste manier op te slaan. Je herkent het door de syntax in de vorm 
+      van naam="waarde" in de open tag.
+  2 - Elementen -> Dit is de pure data
+      Deze gegevens worden door de parser uit het XML bestand gehaald.
+      Elementen staan tussen de open- en sluittags. -->
+
+
+<!-- Hieronder staat een element met twee attributen -->
+<bestand type="gif" id="4293">computer.gif</bestand>
+
+
+```
+
+* Grammaticaal correcte documenten x Validatie
+
+Een XML document is "grammaticaal correct" of "well-formatted" als de 
+syntax correct is. Het is ook mogelijk om meer structuur in het document 
+aan te brengen met document definities zoals DTD en XML Schema.
+
+Een XML document dat aan een document definitie voldoet wordt "valide" volgens 
+die document definitie genoemd.
+
+Met deze gereedschappen kan je de XML data buiten je applicatie logica 
+controleren.
+
+```xml
+
+<!-- Hieronder staat een versimpelde versie voor een boekenwinkel document,
+  met een toevoeging van een DTD definitie. -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "boekenwinkel.dtd">
+<boekenwinkel>
+  <boek categorie="KOKEN">
+    <titel>Alledaags Italiaans</titel>
+    <prijs>30.00</prijs>
+  </boek>
+</boekenwinkel>
+
+<!-- De DTD kan er als volgt uitzien:-->
+
+<!DOCTYPE note
+[
+<!ELEMENT boekenwinkel (boek+)>
+<!ELEMENT boek (titel,prijs)>
+<!ATTLIST boek categorie CDATA "Literatuur">
+<!ELEMENT titel (#PCDATA)>
+<!ELEMENT prijs (#PCDATA)>
+]>
+
+
+<!-- De DTD begint met een declaratie.
+  Hierna volgt de declaratie van de stamknoop, die 1 of meer 'boek' kinderen 
+  moet bevatten. 
+  Elk 'boek' moet precies 1 'titel' en 'prijs' element bevatten en een attribuut 
+  'categorie' hebben waarvan 'Literatuur' de standaard waarde is.
+  De 'titel' en 'prijs' knopen bevatten parsed character data.-->
+
+<!-- De DTD kan ook in het XML bestand zelf gedeclareerd worden.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT boekenwinkel (boek+)>
+<!ELEMENT boek (titel,prijs)>
+<!ATTLIST boek categorie CDATA "Literatuur">
+<!ELEMENT titel (#PCDATA)>
+<!ELEMENT prijs (#PCDATA)>
+]>
+
+<boekenwinkel>
+  <boek categorie="KOKEN">
+    <titel>Alledaags Italiaans</titel>
+    <prijs>30.00</prijs>
+  </boek>
+</boekenwinkel>
+```
diff --git a/nl-nl/yaml-nl.html.markdown b/nl-nl/yaml-nl.html.markdown
index a4a9d5fc..11af784f 100644
--- a/nl-nl/yaml-nl.html.markdown
+++ b/nl-nl/yaml-nl.html.markdown
@@ -5,21 +5,22 @@ contributors:
   - ["Adam Brenecki", "https://github.com/adambrenecki"]
 translators:
   - ["Niels van Velzen", "https://nielsvanvelzen.me"]
+  - ["Sam van Kampen", "http://tehsvk.net"]
 lang: nl-nl
 ---
 
-YAML is een data serialisatie taal ontworpen om snel te kunnen worden begrepen door mensen.
+YAML is een dataserialisatietaal ontworpen om snel te kunnen worden begrepen door mensen.
 
-Het is een strikte superset van JSON en bevat nieuwe regels en een stricte manier van inspringen, zoals bij Python. In tegenstelling tot Python kan je alleen geen tab tekens gebruiken.
+Het is een strikte superset van JSON en bevat nieuwe regels en een strikte manier van inspringen die lijkt op de manier van Python. In tegenstelling tot Python kan je alleen geen tabtekens gebruiken.
 
 ```yaml
 # Commentaar in YAML ziet er zo uit
 
-################
-# SCALAR TYPES #
-################
+##################
+# SCALAIRE TYPES #
+##################
 
-# Ons hoofd object (Wat in het hele document gebruikt wordt) is een map,
+# Ons hoofdobject (Wat in het hele document gebruikt wordt) is een map;
 # dit staat gelijk aan een dictionary, hash of object in andere talen.
 sleutel: waarde
 nog_een_sleutel: Een andere waarde
@@ -35,10 +36,10 @@ quote_waarde: "Een string in quotes"
 # Tekst over meerdere lijnen kan je schrijven als een 'letterlijk blok' (met |)
 # Of een 'gevouwen blok' (met >)
 letterlijk_blok: |
-    Dit hele blok met tekst is de waarde van de 'letterlijk_blok' sleutel,
+    Dit hele blok met tekst is de waarde van de 'letterlijk_blok'-sleutel,
     met nieuwe lijnen behouden.
 
-    Het blok blijft door gaan tot het geeindigd wordt door korter te inspringen.
+    Het blok blijft door gaan tot het geeindigd wordt door korter in te springen.
 
         Lijnen die groter zijn ingesprongen behouden dit.
 gevouwen_stijl: >
@@ -50,9 +51,9 @@ gevouwen_stijl: >
         Meer ingesprongen lijnen zullen hun nieuwe lijnen ook behouden,
         deze tekst zal over 2 lijnen te zien zijn.
 
-####################
-# COLLECTION TYPES #
-####################
+##################
+# COLLECTIETYPES #
+##################
 
 # Nesten wordt bereikt met inspringen.
 geneste_map:
@@ -61,7 +62,7 @@ geneste_map:
     andere_geneste_map:
         hallo: wereld
 
-# In een map is een sleutel niet verplicht om een string te gebruiken
+# In een map hoeft de sleutel geen string te zijn.
 0.25: een float als sleutel
 
 # Sleutels kunnen ook meerdere lijnen gebruiken met behulp van het vraagteken
@@ -70,14 +71,14 @@ geneste_map:
     met meerdere lijnen
 : en dit is de waarde
 
-# YAML staat ook collection types toe in sleutels, maar veel programmeertalen
+# YAML staat ook collectietypes toe in sleutels, maar veel programmeertalen
 # zullen hierover klagen.
 
 # Sequences (gelijk aan lijsten of arrays) zien er zo uit:
 een_sequence:
     - Item 1
     - Item 2
-    - 0.5 # sequences kunnen meerdere type waardes bevatten.
+    - 0.5 # sequences kunnen meerdere typen waardes bevatten.
     - Item 4
     - sleutel: waarde
       andere_sleutel: andere waarde
@@ -85,13 +86,13 @@ een_sequence:
         - Dit is een sequence
         - in een andere sequence
 
-# Doordat YAML een superset van JSON is kan je ook JSON-stijl mappen en
-# sequences maken:
+# Doordat YAML een superset van JSON is kan je ook mappen en
+# sequences volgens de JSON-stijl maken:
 json_map: {"sleutel": "waarde"}
 json_seq: [3, 2, 1, "takeoff"]
 
 #######################
-# EXTRA YAML FUNCTIES #
+# EXTRA YAML-FUNCTIES #
 #######################
 
 # YAML heeft ook een handige functie genaamd 'anchors' (ankers), deze laten je
@@ -102,16 +103,16 @@ andere_anker: *anker_naam
 
 # YAML heeft ook tags, deze gebruik je om een expliciet type te verklaren
 expliciete_string: !!str 0.5
-# Sommige parsers gebruiken taal specifieke tags, zoals deze voor Python's
-# complexe nummer type:
+# Sommige parsers gebruiken taalspecifieke tags, zoals deze voor Python's
+# complexe nummertype:
 python_complex_nummer: !!python/complex 1+2j
 
-####################
-# EXTRA YAML TYPES #
-####################
+#######################
+# EXTRA TYPES IN YAML #
+#######################
 
-# Strings en nummer zijn niet de enige types die YAML begrijpt.
-# ISO opgemaakte datum en datumtijd notaties werken ook:
+# Strings en nummers zijn niet de enige types die YAML begrijpt.
+# ISO opgemaakte datum- en datumtijdnotaties werken ook:
 datumtijd: 2001-12-15T02:59:43.1Z
 datumtijd_met_spaties: 2001-12-14 21:59:43.10 -5
 datum: 2002-12-14
@@ -124,13 +125,13 @@ gif_bestand: !!binary |
     +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
     AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
 
-# YAML heeft ook een set type, dat ziet er zo uit:
+# YAML heeft ook een settype, dat ziet er zo uit:
 set:
     ? item1
     ? item2
     ? item3
 
-# Zoals in Python zijn sets gewoon mappen met null waardes;
+# Zoals in Python zijn sets gewoon mappen met nulwaarden;
 # bovenstaand is gelijk aan:
 set2:
     item1: null
diff --git a/no-nb/JSON-no.html.markdown b/no-nb/JSON-no.html.markdown
new file mode 100644
index 00000000..6c8c3c79
--- /dev/null
+++ b/no-nb/JSON-no.html.markdown
@@ -0,0 +1,60 @@
+--- 
+language: json
+filename: learnjson-no.json
+lang: no-nb
+contributors:
+  - ["Ole Mathias Heggem", "https://github.com/msbone"]
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+---
+
+JSON er en enkel tekstbasert standard for datautveksling.
+Den er opprinnelig avledet fra JavaScript for å representere enkle datastrukturer.
+Standarden er imidlertid uavhengig av JavaScript eller andre programmeringsspråk.
+
+JSON i sin reneste form har ingen faktiske kommentarer, men de fleste parsere vil akseptere
+C-stil (`//`, `/* */`) kommentarer.
+
+```json
+{
+  "nøkkel": "verdi",
+  
+  "nøkler": "må alltid være i doble anførselstegn",
+  "tall": 0,
+  "strings": "Hellø, wørld. Alt unicode er godkjent, også \"escaping\".",
+  "har bools?": true,
+  "ingenting": null,
+
+  "stort tall": 1.2e+100,
+
+  "objekt": {
+    "kommentar": "Meste av strukturen kommer ifra objekt.",
+
+    "array": [0, 1, 2, 3, "Arrays kan inneholde alt.", 5],
+
+    "nytt object": {
+      "comment": "Ny kommentar"
+    }
+  },
+
+  "tull": [
+    {
+      "Kilde til Kalium": ["bananer"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "Alternativ": {
+    "Kommentar": "Sjekk ut ditta!"
+  , "plassering av komma": "Sålenge den er før verdien er det gyldig"
+  , "Enda en kommentar": "TØFT!"
+  },
+
+  "Ferdig": "Da er den korte innledninga til JSON ferdig"
+}
+```
diff --git a/no-nb/bash-no.html.markdown b/no-nb/bash-no.html.markdown
index ab0c064f..481aecbd 100644
--- a/no-nb/bash-no.html.markdown
+++ b/no-nb/bash-no.html.markdown
@@ -217,8 +217,6 @@ bar ()
 # Å kalle en funksjon:
 foo "Mitt navn er" $NAME
 
-# There are a lot of useful commands you should learn:
-# prints last 10 lines of file.txt
 # Det er mange nyttige kommandoer du bør lære deg:
 # "tail" skriver ut slutten av en fil, i dette tilfellet de siste 10 linjene
 tail -n 10 file.txt
diff --git a/objective-c.html.markdown b/objective-c.html.markdown
index 097cb846..2b599378 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -110,7 +110,7 @@ int main (int argc, const char * argv[])
     NSLog(@"%f", piDouble);
     NSLog(@"%4.2f", piDouble); // prints => "3.14"
 
-    // NSDecimalNumber is a fixed-point class that's more precise then float or double
+    // NSDecimalNumber is a fixed-point class that's more precise than float or double
     NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
     NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
     // NSDecimalNumber isn't able to use standard +, -, *, / operators so it provides its own:
@@ -133,6 +133,8 @@ int main (int argc, const char * argv[])
     NSArray *anArray      = @[@1, @2, @3, @4];
     NSNumber *thirdNumber = anArray[2];
     NSLog(@"Third number = %@", thirdNumber); // prints => "Third number = 3"
+    // Since Xcode 7, NSArray objects can be typed (Generics)
+    NSArray<NSString *> *stringArray = @[@"hello", @"world"];
     // NSMutableArray is a mutable version of NSArray, allowing you to change
     // the items in the array and to extend or shrink the array object.
     // Convenient, but not as efficient as NSArray.
@@ -146,6 +148,8 @@ int main (int argc, const char * argv[])
     NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
     NSObject *valueObject     = aDictionary[@"A Key"];
     NSLog(@"Object = %@", valueObject); // prints => "Object = (null)"
+    // Since Xcode 7, NSDictionary objects can be typed (Generics)
+    NSDictionary<NSString *, NSNumber *> *numberDictionary = @{@"a": @1, @"b": @2};
     // NSMutableDictionary also available as a mutable dictionary object
     NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
     [mutableDictionary setObject:@"value1" forKey:@"key1"];
@@ -161,6 +165,8 @@ int main (int argc, const char * argv[])
     // Set object
     NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
     NSLog(@"%@", set); // prints => {(Hello, World)} (may be in different order)
+    // Since Xcode 7, NSSet objects can be typed (Generics)
+    NSSet<NSString *> *stringSet = [NSSet setWithObjects:@"hello", @"world", nil];
     // NSMutableSet also available as a mutable set object
     NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
     [mutableSet addObject:@"Hello"];
@@ -700,7 +706,7 @@ if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
 // NOTE: If two or more protocols rely on each other, make sure to forward-declare them:
 #import "Brother.h"
 
-@protocol Brother; // Forward-declare statement. Without it, compiler would through error.
+@protocol Brother; // Forward-declare statement. Without it, compiler will throw error.
 
 @protocol Sister <NSObject>
 
diff --git a/ocaml.html.markdown b/ocaml.html.markdown
index 8faab297..59ead9ec 100644
--- a/ocaml.html.markdown
+++ b/ocaml.html.markdown
@@ -104,7 +104,7 @@ let fact_4 = factorial (5-1) ;;
 let sqr2 = sqr (-2) ;;
 
 (* Every function must have at least one argument.
-   Since some funcions naturally don't take any arguments, there's
+   Since some functions naturally don't take any arguments, there's
    "unit" type for it that has the only one value written as "()" *)
 let print_hello () = print_endline "hello world" ;;
 
@@ -216,7 +216,7 @@ List.nth my_list 1 ;;
 
 (* There are higher-order functions for lists such as map and filter. *)
 List.map (fun x -> x * 2) [1; 2; 3] ;;
-List.filter (fun x -> if x mod 2 = 0 then true else false) [1; 2; 3; 4] ;;
+List.filter (fun x -> x mod 2 = 0) [1; 2; 3; 4] ;;
 
 (* You can add an item to the beginning of a list with the "::" constructor
    often referred to as "cons". *)
diff --git a/paren.html.markdown b/paren.html.markdown
index cde14853..701cadfd 100644
--- a/paren.html.markdown
+++ b/paren.html.markdown
@@ -4,6 +4,7 @@ language: Paren
 filename: learnparen.paren
 contributors:
   - ["KIM Taegyoon", "https://github.com/kimtg"]
+  - ["Claudson Martins", "https://github.com/claudsonm"]
 ---
 
 [Paren](https://bitbucket.org/ktg/paren) is a dialect of Lisp. It is designed to be an embedded language.
@@ -77,7 +78,7 @@ some-var ; => 5
 ;; Accessing a previously unassigned variable is an exception
 ; x ; => Unknown variable: x : nil
 
-;; Local binding: Use lambda calculus! `a' and `b' are bound to `1' and `2' only within the (fn ...)
+;; Local binding: Use lambda calculus! 'a' and 'b' are bound to '1' and '2' only within the (fn ...)
 ((fn (a b) (+ a b)) 1 2) ; => 3
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -88,12 +89,12 @@ some-var ; => 5
 
 ;; Lists are vector-like data structures. (Random access is O(1).)
 (cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
-;; `list' is a convenience variadic constructor for lists
+;; 'list' is a convenience variadic constructor for lists
 (list 1 2 3) ; => (1 2 3)
 ;; and a quote can also be used for a literal list value
 (quote (+ 1 2)) ; => (+ 1 2)
 
-;; Can still use `cons' to add an item to the beginning of a list
+;; Can still use 'cons' to add an item to the beginning of a list
 (cons 0 (list 1 2 3)) ; => (0 1 2 3)
 
 ;; Lists are a very basic type, so there is a *lot* of functionality for
@@ -106,7 +107,7 @@ some-var ; => 5
 ;; 3. Functions
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; Use `fn' to create functions.
+;; Use 'fn' to create functions.
 ;; A function always returns the value of its last expression
 (fn () "Hello World") ; => (fn () Hello World) : fn
 
@@ -117,7 +118,7 @@ some-var ; => 5
 (set hello-world (fn () "Hello World"))
 (hello-world) ; => "Hello World"
 
-;; You can shorten this using the function definition syntatcic sugae:
+;; You can shorten this using the function definition syntactic sugar:
 (defn hello-world2 () "Hello World")
 
 ;; The () in the above is the list of arguments for the function
@@ -134,7 +135,7 @@ some-var ; => 5
 ;; 4. Equality
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; for numbers use `=='
+;; for numbers use '=='
 (== 3 3.0) ; => true
 (== 2 1) ; => false
 
@@ -166,7 +167,7 @@ some-var ; => 5
 ;; 6. Mutation
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; Use `set' to assign a new value to a variable or a place
+;; Use 'set' to assign a new value to a variable or a place
 (set n 5) ; => 5
 (set n (inc n)) ; => 6
 n ; => 6
diff --git a/pcre.html.markdown b/pcre.html.markdown
new file mode 100644
index 00000000..0b61653d
--- /dev/null
+++ b/pcre.html.markdown
@@ -0,0 +1,82 @@
+---
+language: PCRE
+filename: pcre.txt
+contributors:
+    - ["Sachin Divekar", "http://github.com/ssd532"]
+    
+---
+
+A regular expression (regex or regexp for short) is a special text string for describing a search pattern. e.g. to extract domain name from a string we can say `/^[a-z]+:/` and it will match `http:` from `http://github.com/`.  
+
+PCRE (Perl Compatible Regular Expressions) is a C library implementing regex. It was written in 1997 when Perl was the de-facto choice for complex text processing tasks. The syntax for patterns used in PCRE closely resembles Perl. PCRE syntax is being used in many big projects including PHP, Apache, R to name a few.
+
+
+There are two different sets of metacharacters:
+* Those that are recognized anywhere in the pattern except within square brackets
+```
+  \      general escape character with several uses
+  ^      assert start of string (or line, in multiline mode)
+  $      assert end of string (or line, in multiline mode)
+  .      match any character except newline (by default)
+  [      start character class definition
+  |      start of alternative branch
+  (      start subpattern
+  )      end subpattern
+  ?      extends the meaning of (
+         also 0 or 1 quantifier
+         also quantifier minimizer
+  *      0 or more quantifier
+  +      1 or more quantifier
+         also "possessive quantifier"
+  {      start min/max quantifier
+```
+
+* Those that are recognized within square brackets. Outside square brackets. They are also called as character classes.
+ 
+```
+ 
+  \      general escape character
+  ^      negate the class, but only if the first character
+  -      indicates character range
+  [      POSIX character class (only if followed by POSIX syntax)
+  ]      terminates the character class
+  
+```  
+
+PCRE provides some generic character types, also called as character classes. 
+```
+  \d     any decimal digit
+  \D     any character that is not a decimal digit
+  \h     any horizontal white space character
+  \H     any character that is not a horizontal white space character
+  \s     any white space character
+  \S     any character that is not a white space character
+  \v     any vertical white space character
+  \V     any character that is not a vertical white space character
+  \w     any "word" character
+  \W     any "non-word" character
+```
+
+## Examples
+
+We will test our examples on following string `66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"`. It is a standard Apache access log.
+
+| Regex | Result          | Comment |
+| :---- | :-------------- | :------ |
+| GET   | GET | GET matches the characters GET literally (case sensitive) |
+| \d+.\d+.\d+.\d+ | 66.249.64.13 | `\d+` match a digit [0-9] one or more times defined by `+` quantifier, `\.` matches `.` literally |
+| (\d+\.){3}\d+ | 66.249.64.13 | `(\d+\.){3}` is trying to match group (`\d+\.`) exactly three times. |
+| \[.+\] | [18/Sep/2004:11:07:48 +1000] | `.+` matches any character (except newline), `.` is any character |
+| ^\S+ | 66.249.64.13 | `^` means start of the line, `\S+` matches any number of non-space characters |
+| \+[0-9]+ | +1000 | `\+` matches the character `+` literally. `[0-9]` character class means single number. Same can be achieved using `\+\d+` |
+
+All these examples can be tried at https://regex101.com/ 
+
+1. Copy the example string in `TEST STRING` section
+2. Copy regex code in `Regular Expression` section 
+3. The web application will show the matching result
+
+
+## Further Reading
+
+
diff --git a/perl.html.markdown b/perl.html.markdown
index 61e8cd0e..17a538e3 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -21,9 +21,9 @@ use strict;
 use warnings;
 
 # All perl scripts and modules should include these lines. Strict causes
-# compilation to fail in cases like misspelled variable names, and warnings
-# will print warning messages in case of common pitfalls like concatenating
-# to an undefined value.
+# compilation to fail in cases like misspelled variable names, and
+# warnings will print warning messages in case of common pitfalls like
+# concatenating to an undefined value.
 
 #### Perl variable types
 
@@ -37,26 +37,50 @@ use warnings;
 #  A scalar represents a single value:
 my $animal = "camel";
 my $answer = 42;
+my $display = "You have $answer ${animal}s.\n";
 
 # Scalar values can be strings, integers or floating point numbers, and
 # Perl will automatically convert between them as required.
 
+# Strings in single quotes are literal strings. Strings in double quotes
+# will interpolate variables and escape codes like "\n" for newline.
+
 ## Arrays
 #  An array represents a list of values:
 my @animals = ("camel", "llama", "owl");
 my @numbers = (23, 42, 69);
 my @mixed   = ("camel", 42, 1.23);
 
-# Array elements are accessed using square brackets, with a $ to indicate
-# one value will be returned.
+# Array elements are accessed using square brackets, with a $ to
+# indicate one value will be returned.
 my $second = $animals[1];
 
+# The size of an array is retrieved by accessing the array in a scalar
+# context, such as assigning it to a scalar variable or using the
+# "scalar" operator.
+
+my $num_animals = @animals;
+print "Number of numbers: ", scalar(@numbers), "\n";
+
+# Arrays can also be interpolated into double-quoted strings, and the
+# elements are separated by a space character by default.
+
+print "We have these numbers: @numbers\n";
+
+# Be careful when using double quotes for strings containing symbols
+# such as email addresses, as it will be interpreted as a variable.
+
+my @example = ('secret', 'array');
+my $oops_email = "foo@example.com"; # 'foosecret array.com'
+my $ok_email = 'foo@example.com';
+
 ## Hashes
 #   A hash represents a set of key/value pairs:
 
 my %fruit_color = ("apple", "red", "banana", "yellow");
 
-#  You can use whitespace and the "=>" operator to lay them out more nicely:
+#  You can use whitespace and the "=>" operator to lay them out more
+#  nicely:
 
 my %fruit_color = (
   apple  => "red",
@@ -66,13 +90,18 @@ my %fruit_color = (
 # Hash elements are accessed using curly braces, again with the $ sigil.
 my $color = $fruit_color{apple};
 
+# All of the keys or values that exist in a hash can be accessed using
+# the "keys" and "values" functions.
+my @fruits = keys %fruit_color;
+my @colors = values %fruit_color;
+
 # Scalars, arrays and hashes are documented more fully in perldata.
 # (perldoc perldata).
 
 #### References
 
-# More complex data types can be constructed using references, which allow
-# you to build arrays and hashes within arrays and hashes.
+# More complex data types can be constructed using references, which
+# allow you to build arrays and hashes within arrays and hashes.
 
 my $array_ref = \@array;
 my $hash_ref = \%hash;
@@ -88,13 +117,14 @@ my $colors = {apple => "red", banana => "yellow"};
 my @fruits_array = @$fruits;
 my %colors_hash = %$colors;
 
-# As a shortcut, the arrow operator can be used to dereference and access a
-# single value.
+# As a shortcut, the arrow operator can be used to dereference and
+# access a single value.
 
 my $first = $array_ref->[0];
 my $value = $hash_ref->{banana};
 
-# See perlreftut and perlref for more in-depth documentation on references.
+# See perlreftut and perlref for more in-depth documentation on
+# references.
 
 #### Conditional and looping constructs
 
@@ -124,24 +154,28 @@ while (condition) {
 
 
 # for loops and iteration
-for (my $i = 0; $i < $max; $i++) {
+for my $i (0 .. $max) {
   print "index is $i";
 }
 
-for (my $i = 0; $i < @elements; $i++) {
-  print "Current element is " . $elements[$i];
-}
-
 for my $element (@elements) {
   print $element;
 }
 
+map {print} @elements;
+
 # implicitly
 
 for (@elements) {
   print;
 }
 
+# iterating through a hash (for and foreach are equivalent)
+
+foreach my $key (keys %hash) {
+  print $key, ': ', $hash{$key}, "\n";
+}
+
 # the Perlish post-condition way again
 print for @elements;
 
@@ -150,35 +184,45 @@ print $hash_ref->{$_} for keys %$hash_ref;
 
 #### Regular expressions
 
-# Perl's regular expression support is both broad and deep, and is the subject
-# of lengthy documentation in perlrequick, perlretut, and elsewhere.
-# However, in short:
+# Perl's regular expression support is both broad and deep, and is the
+# subject of lengthy documentation in perlrequick, perlretut, and
+# elsewhere. However, in short:
 
 # Simple matching
 if (/foo/)       { ... }  # true if $_ contains "foo"
-if ($a =~ /foo/) { ... }  # true if $a contains "foo"
+if ($x =~ /foo/) { ... }  # true if $x contains "foo"
 
 # Simple substitution
 
-$a =~ s/foo/bar/;         # replaces foo with bar in $a
-$a =~ s/foo/bar/g;        # replaces ALL INSTANCES of foo with bar in $a
+$x =~ s/foo/bar/;         # replaces foo with bar in $x
+$x =~ s/foo/bar/g;        # replaces ALL INSTANCES of foo with bar in $x
 
 
 #### Files and I/O
 
 # You can open a file for input or output using the "open()" function.
 
+# For reading:
 open(my $in,  "<",  "input.txt")  or die "Can't open input.txt: $!";
+# For writing (clears file if it exists):
 open(my $out, ">",  "output.txt") or die "Can't open output.txt: $!";
+# For writing (appends to end of file):
 open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";
 
-# You can read from an open filehandle using the "<>" operator.  In scalar
-# context it reads a single line from the filehandle, and in list context it
-# reads the whole file in, assigning each line to an element of the list:
+# You can read from an open filehandle using the "<>" operator.  In
+# scalar context it reads a single line from the filehandle, and in list
+# context it reads the whole file in, assigning each line to an element
+# of the list:
 
 my $line  = <$in>;
 my @lines = <$in>;
 
+# You can write to an open filehandle using the standard "print"
+# function.
+
+print $out @lines;
+print $log $msg, "\n";
+
 #### Writing subroutines
 
 # Writing subroutines is easy:
@@ -197,9 +241,9 @@ logger("We have a logger subroutine!");
 
 #### Modules
 
-# A module is a set of Perl code, usually subroutines, which can be used in
-# other Perl code. It is usually stored in a file with the extension .pm so
-# that Perl can find it.
+# A module is a set of Perl code, usually subroutines, which can be used
+# in other Perl code. It is usually stored in a file with the extension
+# .pm so that Perl can find it.
 
 package MyModule;
 use strict;
@@ -219,24 +263,25 @@ sub trim {
 use MyModule;
 MyModule::trim($string);
 
-# The Exporter module can help with making subroutines exportable, so they
-# can be used like this:
+# The Exporter module can help with making subroutines exportable, so
+# they can be used like this:
 
 use MyModule 'trim';
 trim($string);
 
-# Many Perl modules can be downloaded from CPAN (http://www.cpan.org/) and
-# provide a range of features to help you avoid reinventing the wheel.  A
-# number of popular modules like Exporter are included with the Perl
-# distribution itself. See perlmod for more details on modules in Perl.
+# Many Perl modules can be downloaded from CPAN (http://www.cpan.org/)
+# and provide a range of features to help you avoid reinventing the
+# wheel.  A number of popular modules like Exporter are included with
+# the Perl distribution itself. See perlmod for more details on modules
+# in Perl.
 
 #### Objects
 
-# Objects in Perl are just references that know which class (package) they
-# belong to, so that methods (subroutines) called on it can be found there.
-# The bless function is used in constructors (usually new) to set this up.
-# However, you never need to call it yourself if you use a module like Moose
-# or Moo (see below).
+# Objects in Perl are just references that know which class (package)
+# they belong to, so that methods (subroutines) called on it can be
+# found there. The bless function is used in constructors (usually new)
+# to set this up. However, you never need to call it yourself if you use
+# a module like Moose or Moo (see below).
 
 package MyCounter;
 use strict;
@@ -260,7 +305,8 @@ sub increment {
 
 1;
 
-# Methods can be called on a class or object instance with the arrow operator.
+# Methods can be called on a class or object instance with the arrow
+# operator.
 
 use MyCounter;
 my $counter = MyCounter->new;
@@ -268,9 +314,9 @@ print $counter->count, "\n"; # 0
 $counter->increment;
 print $counter->count, "\n"; # 1
 
-# The modules Moose and Moo from CPAN can help you set up your object classes.
-# They provide a constructor and simple syntax for declaring attributes. This
-# class can be used equivalently to the one above.
+# The modules Moose and Moo from CPAN can help you set up your object
+# classes. They provide a constructor and simple syntax for declaring
+# attributes. This class can be used equivalently to the one above.
 
 package MyCounter;
 use Moo; # imports strict and warnings
@@ -284,8 +330,8 @@ sub increment {
 
 1;
 
-# Object-oriented programming is covered more thoroughly in perlootut, and its
-# low-level implementation in Perl is covered in perlobj.
+# Object-oriented programming is covered more thoroughly in perlootut,
+# and its low-level implementation in Perl is covered in perlobj.
 ```
 
 #### FAQ
diff --git a/perl6.html.markdown b/perl6.html.markdown
index 5082a433..44960347 100644
--- a/perl6.html.markdown
+++ b/perl6.html.markdown
@@ -1,9 +1,10 @@
 ---
 category: language
 language: perl6
-filename: learnperl6.pl
+filename: learnperl6.p6
 contributors:
     - ["vendethiel", "http://github.com/vendethiel"]
+    - ["Samantha McVey", "https://cry.nu"]
 ---
 
 Perl 6 is a highly capable, feature-rich programming language made for at
@@ -17,36 +18,47 @@ double paragraphs, and single notes.
 
 `#=>` represents the output of a command.
 
-```perl
+```perl6
 # Single line comment start with a pound
 
 #`(
   Multiline comments use #` and a quoting construct.
   (), [], {}, 「」, etc, will work.
 )
+```
 
-### Variables
+## Variables
 
+```perl6
 # In Perl 6, you declare a lexical variable using `my`
 my $variable;
 # Perl 6 has 4 kinds of variables:
+```
+
+### Scalars
 
-## * Scalars. They represent a single value. They start with a `$`
+```perl6
+# Scalars represent a single value. They start with a `$`
 
 my $str = 'String';
 # double quotes allow for interpolation (which we'll see later):
 my $str2 = "String";
 
-# variable names can contain but not end with simple quotes and dashes,
-#  and can contain (and end with) underscores :
+# Variable names can contain but not end with simple quotes and dashes,
+# and can contain (and end with) underscores :
 # my $weird'variable-name_ = 5; # works !
 
-my $bool = True; # `True` and `False` are Perl 6's boolean
+my $bool = True; # `True` and `False` are Perl 6's boolean values.
 my $inverse = !$bool; # You can invert a bool with the prefix `!` operator
 my $forced-bool = so $str; # And you can use the prefix `so` operator
                            # which turns its operand into a Bool
+```
+
+### Arrays and Lists
 
-## * Lists. They represent multiple values. Their name start with `@`.
+```perl6
+# Arrays represent multiple values. Their name start with `@`.
+# Lists are similar but are an immutable type
 
 my @array = 'a', 'b', 'c';
 # equivalent to :
@@ -56,52 +68,89 @@ my @array = 1, 2, 3;
 
 say @array[2]; # Array indices start at 0 -- This is the third element
 
-say "Interpolate an array using [] : @array[]";
-#=> Interpolate an array using [] : 1 2 3
+say "Interpolate all elements of an array using [] : @array[]";
+#=> Interpolate all elements of an array using [] : 1 2 3
 
 @array[0] = -1; # Assign a new value to an array index
 @array[0, 1] = 5, 6; # Assign multiple values
 
 my @keys = 0, 2;
-@array[@keys] = @letters; # Assign using an array
+@array[@keys] = @letters; # Assignment using an array containing index values
 say @array; #=> a 6 b
+```
+
+### Hashes, or key-value Pairs.
 
-## * Hashes, or key-value Pairs.
-# Hashes are actually arrays of Pairs
-# (you can construct a Pair object using the syntax `Key => Value`),
-#  except they get "flattened" (hash context), removing duplicated keys.
+```perl6
+# Hashes are pairs of keys and values.
+# You can construct a Pair object using the syntax `Key => Value`.
+# Hash tables are very fast for lookup, and are stored unordered.
+# Keep in mind that keys get "flattened" in hash context, and any duplicated
+# keys are deduplicated.
 my %hash = 1 => 2,
            3 => 4;
 my %hash = foo => "bar", # keys get auto-quoted
             "some other" => "value", # trailing commas are okay
             ;
-my %hash = <key1 value1 key2 value2>; # you can also create a hash
-                                      # from an even-numbered array
-my %hash = key1 => 'value1', key2 => 'value2'; # same as this
+# Even though hashes are internally stored differently than arrays,
+# Perl 6 allows you to easily create a hash from an even numbered array:
+my %hash = <key1 value1 key2 value2>;
+
+my %hash = key1 => 'value1', key2 => 'value2'; # same result as above
 
 # You can also use the "colon pair" syntax:
 # (especially handy for named parameters that you'll see later)
-my %hash = :w(1), # equivalent to `w => 1`
-           # this is useful for the `True` shortcut:
-           :truey, # equivalent to `:truey(True)`, or `truey => True`
-           # and for the `False` one:
+my %hash = :w(1),    # equivalent to `w => 1`
+                     # this is useful for the `True` shortcut:
+           :truey,   # equivalent to `:truey(True)`, or `truey => True`
+                     # and for the `False` one:
            :!falsey, # equivalent to `:falsey(False)`, or `falsey => False`
            ;
 
 say %hash{'key1'}; # You can use {} to get the value from a key
 say %hash<key2>;   # If it's a string, you can actually use <>
                    # (`{key1}` doesn't work, as Perl6 doesn't have barewords)
+```
 
-## * Subs (subroutines, or functions in most other languages).
-sub say-hello { say "Hello, world" }
+## Subs
 
-sub say-hello-to(Str $name) { # You can provide the type of an argument
-                              # and it'll be checked at compile-time.
+```perl6
+# subroutines or functions as most other languages call them are
+# created with the `sub` keyword.
+sub say-hello { say "Hello, world" }
 
+# You can provide (typed) arguments.
+# If specified, the type will be checked at compile-time if possible,
+#  otherwise at runtime.
+sub say-hello-to(Str $name) {
     say "Hello, $name !";
 }
 
-## It can also have optional arguments:
+# A sub returns the last value of the block.
+sub return-value {
+    5;
+}
+say return-value; # prints 5
+sub return-empty {
+}
+say return-empty; # prints Nil
+
+# Some control flow structures produce a value, like if:
+sub return-if {
+	if True {
+		"Truthy";
+	}
+}
+say return-if; # prints Truthy
+
+# Some don't, like for:
+sub return-for {
+    for 1, 2, 3 { }
+}
+say return-for; # prints Nil
+
+
+## A sub can have optional arguments:
 sub with-optional($arg?) { # the "?" marks the argument optional
   say "I might return `(Any)` (Perl's 'null'-like value) if I don't have
         an argument passed, or I'll return my argument";
@@ -119,8 +168,8 @@ hello-to; #=> Hello, World !
 hello-to(); #=> Hello, World !
 hello-to('You'); #=> Hello, You !
 
-## You can also, by using a syntax akin to the one of hashes (yay unified syntax !),
-##  pass *named* arguments to a `sub`.
+## You can also, by using a syntax akin to the one of hashes
+## (yay unified syntax !), pass *named* arguments to a `sub`.
 # They're optional, and will default to "Any".
 sub with-named($normal-arg, :$named) {
   say $normal-arg + $named;
@@ -139,8 +188,8 @@ sub with-mandatory-named(:$str!)  {
   say "$str !";
 }
 with-mandatory-named(str => "My String"); #=> My String !
-with-mandatory-named; # run time error: "Required named parameter not passed"
-with-mandatory-named(3); # run time error: "Too many positional parameters passed"
+with-mandatory-named;   # run time error: "Required named parameter not passed"
+with-mandatory-named(3);# run time error:"Too many positional parameters passed"
 
 ## If a sub takes a named boolean argument ...
 sub takes-a-bool($name, :$bool) {
@@ -163,9 +212,9 @@ my &s = &say-hello;
 my &other-s = sub { say "Anonymous function !" }
 
 # A sub can have a "slurpy" parameter, or "doesn't-matter-how-many"
-sub as-many($head, *@rest) { # `*@` (slurpy) will basically "take everything else".
-                             # Note: you can have parameters *before* (like here)
-                             # a slurpy one, but not *after*.
+sub as-many($head, *@rest) {  #`*@` (slurpy) will "take everything else"
+# Note: you can have parameters *before* a slurpy one (like here),
+# but not *after*.
   say @rest.join(' / ') ~ " !";
 }
 say as-many('Happy', 'Happy', 'Birthday'); #=> Happy / Birthday !
@@ -180,8 +229,11 @@ sub concat3($a, $b, $c) {
 }
 concat3(|@array); #=> a, b, c
                   # `@array` got "flattened" as a part of the argument list
+```
+
+## Containers
 
-### Containers
+```perl6
 # In Perl 6, values are actually stored in "containers".
 # The assignment operator asks the container on the left to store the value on
 #  its right. When passed around, containers are marked as immutable.
@@ -193,6 +245,15 @@ sub mutate($n is rw) {
   say "\$n is now $n !";
 }
 
+my $m = 42;
+mutate $m; # $n is now 43 !
+
+# This works because we are passing the container $m to mutate.  If we try
+# to just pass a number instead of passing a variable it won't work because
+# there is no container being passed and integers are immutable by themselves:
+
+mutate 42; # Parameter '$n' expected a writable container, but got Int value
+
 # If what you want a copy instead, use `is copy`.
 
 # A sub itself returns a container, which means it can be marked as rw:
@@ -201,16 +262,17 @@ sub x-store() is rw { $x }
 x-store() = 52; # in this case, the parentheses are mandatory
                 # (else Perl 6 thinks `x-store` is an identifier)
 say $x; #=> 52
+```
 
+## Control Flow Structures
+### Conditionals
 
-### Control Flow Structures
-## Conditionals
-
+```perl6
 # - `if`
 # Before talking about `if`, we need to know which values are "Truthy"
-#  (represent True), and which are "Falsey" (or "Falsy") -- represent False.
-# Only these values are Falsey: 0, (), {}, "", Nil, A type (like `Str` or `Int`),
-#  and of course False itself.
+# (represent True), and which are "Falsey" (or "Falsy") -- represent False.
+# Only these values are Falsey: 0, (), {}, "", Nil, A type (like `Str` or `Int`)
+# and of course False itself.
 # Every other value is Truthy.
 if True {
   say "It's true !";
@@ -228,10 +290,19 @@ unless False {
 say "Quite truthy" if True;
 
 # - Ternary conditional, "?? !!" (like `x ? y : z` in some other languages)
-my $a = $condition ?? $value-if-true !! $value-if-false;
+#   returns $value-if-true if the condition is true and $value-if-false
+#   if it is false.
+#   my $result = $value condition ?? $value-if-true !! $value-if-false;
+
+my $age = 30;
+say $age > 18 ?? "You are an adult" !! "You are under 18";
+```
+
+### given/when, or switch
 
-# - `given`-`when` looks like other languages' `switch`, but much more
-# powerful thanks to smart matching and thanks to Perl 6's "topic variable", $_.
+```perl6
+# - `given`-`when` looks like other languages' `switch`, but is much more
+# powerful thanks to smart matching and Perl 6's "topic variable", $_.
 #
 # This variable contains the default argument of a block,
 #  a loop's current iteration (unless explicitly named), etc.
@@ -242,15 +313,17 @@ my $a = $condition ?? $value-if-true !! $value-if-false;
 # Since other Perl 6 constructs use this variable (as said before, like `for`,
 # blocks, etc), this means the powerful `when` is not only applicable along with
 # a `given`, but instead anywhere a `$_` exists.
+
 given "foo bar" {
   say $_; #=> foo bar
-  when /foo/ { # Don't worry about smart matching yet – just know `when` uses it.
+  when /foo/ { # Don't worry about smart matching yet – just know `when` uses it
                # This is equivalent to `if $_ ~~ /foo/`.
     say "Yay !";
   }
-  when $_.chars > 50 { # smart matching anything with True (`$a ~~ True`) is True,
+  when $_.chars > 50 { # smart matching anything with True is True,
+                       # i.e. (`$a ~~ True`) 
                        # so you can also put "normal" conditionals.
-                       # This when is equivalent to this `if`:
+                       # This `when` is equivalent to this `if`:
                        #  if $_ ~~ ($_.chars > 50) {...}
                        # Which means:
                        #  if $_.chars > 50 {...}
@@ -260,14 +333,17 @@ given "foo bar" {
     say "Something else"
   }
 }
+```
 
-## Looping constructs
+### Looping constructs
 
+```perl6
 # - `loop` is an infinite loop if you don't pass it arguments,
 # but can also be a C-style `for` loop:
 loop {
   say "This is an infinite loop !";
-  last; # last breaks out of the loop, like the `break` keyword in other languages
+  last; # last breaks out of the loop, like the `break` keyword in other
+        # languages
 }
 
 loop (my $i = 0; $i < 5; $i++) {
@@ -304,9 +380,11 @@ for @array {
 if long-computation() -> $result {
   say "The result is $result";
 }
+```
 
-### Operators
+## Operators
 
+```perl6
 ## Since Perl languages are very much operator-based languages,
 ## Perl 6 operators are actually just funny-looking subroutines, in syntactic
 ##  categories, like infix:<+> (addition) or prefix:<!> (bool not).
@@ -336,16 +414,37 @@ if long-computation() -> $result {
 # - `eqv` is canonical equivalence (or "deep equality")
 (1, 2) eqv (1, 3);
 
-# - `~~` is smart matching
+# - Smart Match Operator: `~~`
+# Aliases the left hand side to $_ and then evaluates the right hand side.
+# Here are some common comparison semantics:
+
+# String or Numeric Equality
+
+'Foo' ~~ 'Foo'; # True if strings are equal.
+12.5 ~~ 12.50; # True if numbers are equal.
+
+# Regex - For matching a regular expression against the left side.
+# Returns a (Match) object, which evaluates as True if regexp matches.
+
+my $obj = 'abc' ~~ /a/;
+say $obj; # ｢a｣
+say $obj.WHAT; # (Match)
+
+# Hashes
+'key' ~~ %hash; # True if key exists in hash
+
+# Type - Checks if left side "has type" (can check superclasses and roles)
+
+1 ~~ Int; # True
+
+# Smart-matching against a boolean always returns that boolean (and will warn).
+
+1 ~~ True; # True
+False ~~ True; # True
+
+# # General syntax is $arg ~~ &bool-returning-function;
 # For a complete list of combinations, use this table:
 # http://perlcabal.org/syn/S03.html#Smart_matching
-'a' ~~ /a/; # true if matches regexp
-'key' ~~ %hash; # true if key exists in hash
-$arg ~~ &bool-returning-function; # `True` if the function, passed `$arg`
-                                  # as an argument, returns `True`.
-1 ~~ Int; # "has type" (check superclasses and roles)
-1 ~~ True; # smart-matching against a boolean always returns that boolean
-           # (and will warn).
 
 # You also, of course, have `<`, `<=`, `>`, `>=`.
 # Their string equivalent are also avaiable : `lt`, `le`, `gt`, `ge`.
@@ -367,6 +466,7 @@ say @array[^10]; # you can pass arrays as subscripts and it'll return
 # Note : when reading an infinite list, Perl 6 will "reify" the elements
 # it needs, then keep them in memory. They won't be calculated more than once.
 # It also will never calculate more elements that are needed.
+# Trying 
 
 # An array subscript can also be a closure.
 # It'll be called with the length as the argument
@@ -386,41 +486,51 @@ my @seq =  3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99;
 say @numbers; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87
               # (only 20 values)
 
-## * And, Or
+## * And &&, Or ||
 3 && 4; # 4, which is Truthy. Calls `.Bool` on `4` and gets `True`.
 0 || False; # False. Calls `.Bool` on `0`
 
 ## * Short-circuit (and tight) versions of the above
-$a && $b && $c; # Returns the first argument that evaluates to False,
-                # or the last argument.
-$a || $b;
+#    Returns the first argument that evaluates to False, or the last argument.
+
+my ( $a, $b, $c ) = 1, 0, 2;
+$a && $b && $c; # Returns 0, the first False value
+
+# || Returns the first argument that evaluates to True
+$b || $a; # 1
 
 # And because you're going to want them,
 #  you also have compound assignment operators:
-$a *= 2; # multiply and assignment
+$a *= 2; # multiply and assignment. Equivalent to $a = $a * 2;
 $b %%= 5; # divisible by and assignment
 @array .= sort; # calls the `sort` method and assigns the result back
+```
 
-### More on subs !
+## More on subs !
+
+```perl6
 # As we said before, Perl 6 has *really* powerful subs. We're going to see
 # a few more key concepts that make them better than in any other language :-).
+```
 
-## Unpacking !
+### Unpacking !
+
+```perl6
 # It's the ability to "extract" arrays and keys (AKA "destructuring").
 # It'll work in `my`s and in parameter lists.
-my ($a, $b) = 1, 2;
-say $a; #=> 1
-my ($, $, $c) = 1, 2, 3; # keep the non-interesting anonymous
-say $c; #=> 3
+my ($f, $g) = 1, 2;
+say $f; #=> 1
+my ($, $, $h) = 1, 2, 3; # keep the non-interesting anonymous
+say $h; #=> 3
 
 my ($head, *@tail) = 1, 2, 3; # Yes, it's the same as with "slurpy subs"
 my (*@small) = 1;
 
-sub foo(@array [$fst, $snd]) {
+sub unpack_array(@array [$fst, $snd]) {
   say "My first is $fst, my second is $snd ! All in all, I'm @array[].";
   # (^ remember the `[]` to interpolate the array)
 }
-foo(@tail); #=> My first is 2, my second is 3 ! All in all, I'm 2 3
+unpack_array(@tail); #=> My first is 2, my second is 3 ! All in all, I'm 2 3
 
 
 # If you're not using the array itself, you can also keep it anonymous,
@@ -473,7 +583,11 @@ sub list-of($n) {
   }
 }
 my @list3 = list-of(3); #=> (0, 1, 2)
+```
 
+### lambdas
+
+```perl6
 ## You can create a lambda with `-> {}` ("pointy block") or `{}` ("block")
 my &lambda = -> $argument { "The argument passed to this lambda is $argument" }
 # `-> {}` and `{}` are pretty much the same thing, except that the former can
@@ -516,8 +630,11 @@ map(sub ($a, $b) { $a + $b + 3 }, @array); # (here with `sub`)
 
 # Note : those are sorted lexicographically.
 # `{ $^b / $^a }` is like `-> $a, $b { $b / $a }`
+```
 
-## About types...
+### About types...
+
+```perl6
 # Perl6 is gradually typed. This means you can specify the type
 #  of your variables/arguments/return types, or you can omit them
 #  and they'll default to "Any".
@@ -531,8 +648,11 @@ map(sub ($a, $b) { $a + $b + 3 }, @array); # (here with `sub`)
 # You can specify the type you're subtyping (by default, Any),
 #  and add additional checks with the "where" keyword:
 subset VeryBigInteger of Int where * > 500;
+```
 
-## Multiple Dispatch
+### Multiple Dispatch
+
+```perl6
 # Perl 6 can decide which variant of a `sub` to call based on the type of the
 # arguments, or on arbitrary preconditions, like with a type or a `where`:
 
@@ -576,69 +696,104 @@ multi with-or-without-you {
 # sub trait_mod:<is>(Routine $r, :$rw!) {}
 #
 # (commented because running this would be a terrible idea !)
+```
 
+## Scoping
 
-### Scoping
-# In Perl 6, contrarily to many scripting languages (like Python, Ruby, PHP),
-#  you are to declare your variables before using them. You know `my`.
-# (there are other declarators, `our`, `state`, ..., which we'll see later).
+```perl6
+# In Perl 6, unlike many scripting languages, (such as Python, Ruby, PHP),
+# you must declare your variables before using them. The `my` declarator
+# you have learned uses "lexical scoping". There are a few other declarators,
+# (`our`, `state`, ..., ) which we'll see later.
 # This is called "lexical scoping", where in inner blocks,
 #  you can access variables from outer blocks.
-my $foo = 'Foo';
-sub foo {
-  my $bar = 'Bar';
-  sub bar {
-    say "$foo $bar";
+my $file_scoped = 'Foo';
+sub outer {
+  my $outer_scoped = 'Bar';
+  sub inner {
+    say "$file_scoped $outer_scoped";
   }
-  &bar; # return the function
+  &inner; # return the function
 }
-foo()(); #=> 'Foo Bar'
+outer()(); #=> 'Foo Bar'
 
-# As you can see, `$foo` and `$bar` were captured.
+# As you can see, `$file_scoped` and `$outer_scoped` were captured.
 # But if we were to try and use `$bar` outside of `foo`,
 # the variable would be undefined (and you'd get a compile time error).
+```
+
+## Twigils
 
-# Perl 6 has another kind of scope : dynamic scope.
-# They use the twigil (composed sigil) `*` to mark dynamically-scoped variables:
-my $*a = 1;
-# Dyamically-scoped variables depend on the current call stack,
-#  instead of the current block depth.
-sub foo {
-  my $*foo = 1;
-  bar(); # call `bar` in-place
+```perl6
+# There are many special `twigils` (composed sigil's) in Perl 6.
+# Twigils define the variables' scope.
+# The * and ? twigils work on standard variables:
+# * Dynamic variable
+# ? Compile-time variable
+# The ! and the . twigils are used with Perl 6's objects:
+# ! Attribute (class member)
+# . Method (not really a variable)
+
+# `*` Twigil: Dynamic Scope
+# These variables use the`*` twigil to mark dynamically-scoped variables.
+# Dynamically-scoped variables are looked up through the caller, not through
+# the outer scope
+
+my $*dyn_scoped_1 = 1;
+my $*dyn_scoped_2 = 10;
+
+sub say_dyn {
+  say "$*dyn_scoped_1 $*dyn_scoped_2";
 }
-sub bar {
-  say $*foo; # `$*foo` will be looked in the call stack, and find `foo`'s,
-             #  even though the blocks aren't nested (they're call-nested).
-             #=> 1
+
+sub call_say_dyn {
+  my $*dyn_scoped_1 = 25; # Defines $*dyn_scoped_1 only for this sub.
+  $*dyn_scoped_2 = 100; # Will change the value of the file scoped variable.
+  say_dyn(); #=> 25 100 $*dyn_scoped 1 and 2 will be looked for in the call.
+             # It uses he value of $*dyn_scoped_1 from inside this sub's lexical
+             # scope even though the blocks aren't nested (they're call-nested).
 }
+say_dyn(); #=> 1 10
+call_say_dyn(); #=> 25 100
+                # Uses $*dyn_scoped_1 as defined in call_say_dyn even though
+                # we are calling it from outside.
+say_dyn(); #=> 1 100 We changed the value of $*dyn_scoped_2 in call_say_dyn
+           #         so now its value has changed.
+```
 
-### Object Model
+## Object Model
 
-# You declare a class with the keyword `class`, fields with `has`,
-# methods with `method`. Every attribute that is private is named `$!attr`.
-# Immutable public attributes are named `$.attr`
+```perl6
+# To call a method on an object, add a dot followed by the method name:
+# => $object.method
+# Classes are declared with the `class` keyword. Attributes are declared
+# with the `has` keyword, and methods declared with `method`.
+# Every attribute that is private uses the ! twigil for example: `$!attr`.
+# Immutable public attributes use the `.` twigil.
 #   (you can make them mutable with `is rw`)
+# The easiest way to remember the `$.` twigil is comparing it to how methods
+# are called.
 
 # Perl 6's object model ("SixModel") is very flexible,
 # and allows you to dynamically add methods, change semantics, etc ...
-# (this will not be covered here, and you should refer to the Synopsis).
+# (these will not all be covered here, and you should refer to:
+# https://docs.perl6.org/language/objects.html.
 
-class A {
-  has $.field; # `$.field` is immutable.
-               # From inside the class, use `$!field` to modify it.
-  has $.other-field is rw; # You can mark a public attribute `rw`.
-  has Int $!private-field = 10;
+class Attrib-Class {
+  has $.attrib; # `$.attrib` is immutable.
+               # From inside the class, use `$!attrib` to modify it.
+  has $.other-attrib is rw; # You can mark a public attribute `rw`.
+  has Int $!private-attrib = 10;
 
   method get-value {
-    $.field + $!private-field;
+    $.attrib + $!private-attrib;
   }
 
-  method set-value($n) {
-    # $.field = $n; # As stated before, you can't use the `$.` immutable version.
-    $!field = $n;   # This works, because `$!` is always mutable.
+  method set-value($param) { # Methods can take parameters
+    $!attrib = $param;   # This works, because `$!` is always mutable.
+	# $.attrib = $param; # Wrong: You can't use the `$.` immutable version.
 
-    $.other-field = 5; # This works, because `$.other-field` is `rw`.
+    $.other-attrib = 5; # This works, because `$.other-attrib` is `rw`.
   }
 
   method !private-method {
@@ -646,33 +801,47 @@ class A {
   }
 };
 
-# Create a new instance of A with $.field set to 5 :
-# Note: you can't set private-field from here (more later on).
-my $a = A.new(field => 5);
-$a.get-value; #=> 15
-#$a.field = 5; # This fails, because the `has $.field` is immutable
-$a.other-field = 10; # This, however, works, because the public field
-                     #  is mutable (`rw`).
-
-## Perl 6 also has inheritance (along with multiple inheritance)
-
-class A {
-  has $.val;
+# Create a new instance of Attrib-Class with $.attrib set to 5 :
+# Note: you can't set private-attribute from here (more later on).
+my $class-obj = Attrib-Class.new(attrib => 5);
+say $class-obj.get-value; #=> 15
+#$class-obj.attrib = 5; # This fails, because the `has $.attrib` is immutable
+$class-obj.other-attrib = 10; # This, however, works, because the public
+                              # attribute is mutable (`rw`).
+```
 
-  submethod not-inherited {
-    say "This method won't be available on B.";
-    say "This is most useful for BUILD, which we'll see later";
+### Object Inheritance
+
+```perl6
+#  Perl 6 also has inheritance (along with multiple inheritance)
+#  While `method`'s are inherited, `submethod`'s are not.
+#  Submethods are useful for object construction and destruction tasks,
+#  such as BUILD, or methods that must be overriden by subtypes.
+#  We will learn about BUILD later on.
+
+class Parent {
+  has $.age;
+  has $.name;
+  # This submethod won't be inherited by Child.
+  submethod favorite-color {
+    say "My favorite color is Blue";
   }
-
-  method bar { $.val * 5 }
+  # This method is inherited
+  method talk { say "Hi, my name is $!name" }
 }
-class B is A { # inheritance uses `is`
-  method foo {
-    say $.val;
-  }
-
-  method bar { $.val * 10 } # this shadows A's `bar`
+# Inheritance uses the `is` keyword
+class Child is Parent {
+  method talk { say "Goo goo ga ga" }
+  # This shadows Parent's `talk` method, This child hasn't learned to speak yet!
 }
+my Parent $Richard .= new(age => 40, name => 'Richard');
+$Richard.favorite-color; #=> "My favorite color is Blue"
+$Richard.talk; #=> "Hi, my name is Richard"
+# # $Richard is able to access the submethod, he knows how to say his name.
+
+my Child $Madison .= new(age => 1, name => 'Madison');
+$Madison.talk; # prints "Goo goo ga ga" due to the overrided method.
+# $Madison.favorite-color does not work since it is not inherited
 
 # When you use `my T $var`, `$var` starts off with `T` itself in it,
 # so you can call `new` on it.
@@ -680,13 +849,12 @@ class B is A { # inheritance uses `is`
 #  `$a .= b` is the same as `$a = $a.b`)
 # Also note that `BUILD` (the method called inside `new`)
 #  will set parent properties too, so you can pass `val => 5`.
-my B $b .= new(val => 5);
+```
 
-# $b.not-inherited; # This won't work, for reasons explained above
-$b.foo; # prints 5
-$b.bar; #=> 50, since it calls B's `bar`
+### Roles, or Mixins
 
-## Roles are supported too (also called Mixins in other languages)
+```perl6
+# Roles are supported too (also called Mixins in other languages)
 role PrintableVal {
   has $!counter = 0;
   method print {
@@ -699,8 +867,8 @@ class Item does PrintableVal {
   has $.val;
 
   # When `does`-ed, a `role` literally "mixes in" the class:
-  #  the methods and fields are put together, which means a class can access
-  #  the private fields/methods of its roles (but not the inverse !):
+  #  the methods and attributes are put together, which means a class can access
+  #  the private attributes/methods of its roles (but not the inverse !):
   method access {
     say $!counter++;
   }
@@ -714,37 +882,85 @@ class Item does PrintableVal {
   # NOTE: You can use a role as a class (with `is ROLE`). In this case, methods
   # will be shadowed, since the compiler will consider `ROLE` to be a class.
 }
+```
+
+## Exceptions
 
-### Exceptions
+```perl6
 # Exceptions are built on top of classes, in the package `X` (like `X::IO`).
-# Unlike many other languages, in Perl 6, you put the `CATCH` block *within* the
-#  block to `try`. By default, a `try` has a `CATCH` block that catches
-#  any exception (`CATCH { default {} }`).
+# In Perl6 exceptions are automatically 'thrown'
+open 'foo'; #> Failed to open file foo: no such file or directory
+# It will also print out what line the error was thrown at and other error info
+
+# You can throw an exception using `die`:
+die 'Error!'; #=> Error!
+# Or more explicitly:
+die X::AdHoc.new(payload => 'Error!');
+
+# In Perl 6, `orelse` is similar to the `or` operator, except it only matches
+# undefined variables instead of anything evaluating as false.
+# Undefined values include: `Nil`, `Mu` and `Failure` as well as `Int`, `Str`
+# and other types that have not been initialized to any value yet.
+# You can check if something is defined or not using the defined method:
+my $uninitialized;
+say $uninitiazilzed.defined; #> False
+# When using `orelse` it will disarm the exception and alias $_ to that failure
+# This will avoid it being automatically handled and printing lots of scary
+# error messages to the screen.
+# We can use the exception method on $_ to access the exception
+open 'foo' orelse say "Something happened {.exception}";
+# This also works:
+open 'foo' orelse say "Something happened $_"; #> Something happened
+              #>  Failed to open file foo: no such file or directory
+# Both of those above work but in case we get an object from the left side that
+# is not a failure we will probably get a warning.  We see below how we can use
+# `try` and `CATCH` to be more specific with the exceptions we catch.
+```
+
+### Using `try` and `CATCH`
+
+```perl6
+# By using `try` and `CATCH` you can contain and handle exceptions without
+# disrupting the rest of the program. `try` will set the last exception to
+# the special variable `$!` Note: This has no relation to $!variables.
+try open 'foo';
+say "Well, I tried! $!" if defined $!; #> Well, I tried! Failed to open file
+                                       #foo: no such file or directory
+# Now, what if we want more control over handling the exception?
+# Unlike many other languages, in Perl 6, you put the `CATCH` block *within*
+# the block to `try`. Similar to how $_ was set when we 'disarmed' the
+# exception with orelse, we also use $_ in the CATCH block.
+# Note: ($! is only set *after* the `try` block)
+# By default, a `try` has a `CATCH` block that catches
+# any exception (`CATCH { default {} }`).
+
+try { my $a = (0 %% 0);  CATCH { say "Something happened: $_" } }
+ #=> Something happened: Attempt to divide by zero using infix:<%%>
+
 # You can redefine it using `when`s (and `default`)
-#  to handle the exceptions you want:
+# to handle the exceptions you want:
 try {
   open 'foo';
-  CATCH {
-    when X::AdHoc { say "unable to open file !" }
+  CATCH {     # In the `CATCH` block, the exception is set to $_
+    when X::AdHoc { say "Error: $_" }
+     #=>Error: Failed to open file /dir/foo: no such file or directory
+
     # Any other exception will be re-raised, since we don't have a `default`
-    # Basically, if a `when` matches (or there's a `default`) marks the exception as
-    #  "handled" so that it doesn't get re-thrown from the `CATCH`.
+    # Basically, if a `when` matches (or there's a `default`) marks the
+	# exception as
+    # "handled" so that it doesn't get re-thrown from the `CATCH`.
     # You still can re-throw the exception (see below) by hand.
   }
 }
 
-# You can throw an exception using `die`:
-die X::AdHoc.new(payload => 'Error !');
-
-# You can access the last exception with `$!` (use `$_` in a `CATCH` block)
-
-# There are also some subtelties to exceptions. Some Perl 6 subs return a `Failure`,
-#  which is a kind of "unthrown exception". They're not thrown until you tried to look
-#  at their content, unless you call `.Bool`/`.defined` on them - then they're handled.
-#  (the `.handled` method is `rw`, so you can mark it as `False` back yourself)
+# There are also some subtleties to exceptions. Some Perl 6 subs return a
+# `Failure`, which is a kind of "unthrown exception". They're not thrown until
+# you tried to look at their content, unless you call `.Bool`/`.defined` on
+# them - then they're handled.
+# (the `.handled` method is `rw`, so you can mark it as `False` back yourself)
 #
-# You can throw a `Failure` using `fail`. Note that if the pragma `use fatal` is on,
-#  `fail` will throw an exception (like `die`).
+# You can throw a `Failure` using `fail`. Note that if the pragma `use fatal`
+# is on, `fail` will throw an exception (like `die`).
 fail "foo"; # We're not trying to access the value, so no problem.
 try {
   fail "foo";
@@ -757,58 +973,75 @@ try {
 # Those are "good" exceptions, which happen when you change your program's flow,
 #  using operators like `return`, `next` or `last`.
 # You can "catch" those with `CONTROL` (not 100% working in Rakudo yet).
+```
+
+## Packages
 
-### Packages
+```perl6
 # Packages are a way to reuse code. Packages are like "namespaces", and any
 #  element of the six model (`module`, `role`, `class`, `grammar`, `subset`
 #  and `enum`) are actually packages. (Packages are the lowest common denominator)
 # Packages are important - especially as Perl is well-known for CPAN,
 #  the Comprehensive Perl Archive Network.
-# You're not supposed to use the package keyword, usually:
-#  you use `class Package::Name::Here;` to declare a class,
-#  or if you only want to export variables/subs, you can use `module`:
+
+# You can use a module (bring its declarations into scope) with `use`
+use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module
+say from-json('[1]').perl; #=> [1]
+
+# You should not declare packages using the `package` keyword (unlike Perl 5).
+# Instead, use `class Package::Name::Here;` to declare a class, or if you only want to
+#  export variables/subs, you can use `module`.
+
 module Hello::World { # Bracketed form
                       # If `Hello` doesn't exist yet, it'll just be a "stub",
                       #  that can be redeclared as something else later.
   # ... declarations here ...
 }
 unit module Parse::Text; # file-scoped form
-grammar Parse::Text::Grammar { # A grammar is a package, which you could `use`
-}
 
-# You can use a module (bring its declarations into scope) with `use`
-use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module
-say from-json('[1]').perl; #=> [1]
+grammar Parse::Text::Grammar { # A grammar is a package, which you could `use`
+}                    # You will learn more about grammars in the regex section
 
 # As said before, any part of the six model is also a package.
 # Since `JSON::Tiny` uses (its own) `JSON::Tiny::Actions` class, you can use it:
 my $actions = JSON::Tiny::Actions.new;
 
 # We'll see how to export variables and subs in the next part:
+```
+
+## Declarators
 
-### Declarators
+```perl6
 # In Perl 6, you get different behaviors based on how you declare a variable.
 # You've already seen `my` and `has`, we'll now explore the others.
 
-## * `our` (happens at `INIT` time -- see "Phasers" below)
+## * `our` declarations happen at `INIT` time -- (see "Phasers" below)
 # It's like `my`, but it also creates a package variable.
 # (All packagish things (`class`, `role`, etc) are `our` by default)
-module Foo::Bar {
-  our $n = 1; # note: you can't put a type constraint on an `our` variable
-  our sub inc {
+module Var::Increment {
+  our $our-var = 1; # Note: you can't put a type constraint like Int on an
+  my $my-var = 22;  # `our` variable.
+  our sub Inc {
+
     our sub available { # If you try to make inner `sub`s `our`...
                         # Better know what you're doing (Don't !).
-      say "Don't do that. Seriously. You'd get burned.";
+      say "Don't do that. Seriously. You'll get burned.";
     }
+
     my sub unavailable { # `my sub` is the default
-      say "Can't access me from outside, I'm my !";
+      say "Can't access me from outside, I'm 'my'!";
     }
-    say ++$n; # increment the package variable and output its value
+    say ++$our-var; # Increment the package variable and output its value
   }
+
 }
-say $Foo::Bar::n; #=> 1
-Foo::Bar::inc; #=> 2
-Foo::Bar::inc; #=> 3
+say $Var::Increment::our-var; #=> 1 This works
+say $Var::Increment::my-var; #=> (Any) This will not work.
+
+Var::Increment::Inc; #=> 2
+Var::Increment::Inc; #=> 3 # Notice how the value of $our-var was
+                         # retained.
+Var::Increment::unavailable; #> Could not find symbol '&unavailable'
 
 ## * `constant` (happens at `BEGIN` time)
 # You can use the `constant` keyword to declare a compile-time variable/symbol:
@@ -824,7 +1057,7 @@ say why-not[^5]; #=> 5 15 25 35 45
 # (they exist in other langages such as C as `static`)
 sub fixed-rand {
   state $val = rand;
-  say $rand;
+  say $val;
 }
 fixed-rand for ^10; # will print the same number 10 times
 
@@ -840,15 +1073,17 @@ for ^5 -> $a {
              # Next iteration will re-run `rand`.
   }
 }
+```
 
+## Phasers
 
-
-### Phasers
+```perl6
 # Phasers in Perl 6 are blocks that happen at determined points of time in your
-#  program. When the program is compiled, when a for loop runs, when you leave a
-#  block, when an exception gets thrown ... (`CATCH` is actually a phaser !)
+# program.  They are called phasers because they mark a change in the phase
+# of a program.  For example, when the program is compiled, a for loop runs,
+# you leave a block, or an exception gets thrown. (`CATCH` is actually a phaser !)
 # Some of them can be used for their return values, some of them can't
-#  (those that can have a "[*]" in the beginning of their explanation text).
+# (those that can have a "[*]" in the beginning of their explanation text).
 # Let's have a look !
 
 ## * Compile-time phasers
@@ -864,15 +1099,23 @@ ENTER { say "[*] Runs everytime you enter a block, repeats on loop blocks" }
 LEAVE { say "Runs everytime you leave a block, even when an exception
     happened. Repeats on loop blocks." }
 
-PRE { say "Asserts a precondition at every block entry,
-    before ENTER (especially useful for loops)" }
+PRE {
+    say "Asserts a precondition at every block entry,
+        before ENTER (especially useful for loops)";
+    say "If this block doesn't return a truthy value,
+        an exception of type X::Phaser::PrePost is thrown.";
+}
 # exemple:
 for 0..2 {
     PRE { $_ > 1 } # This is going to blow up with "Precondition failed"
 }
 
-POST { say "Asserts a postcondition at every block exit,
-    after LEAVE (especially useful for loops)" }
+POST {
+    say "Asserts a postcondition at every block exit,
+        after LEAVE (especially useful for loops)";
+    say "If this block doesn't return a truthy value,
+        an exception of type X::Phaser::PrePost is thrown, like PRE.";
+}
 for 0..2 {
     POST { $_ < 2 } # This is going to blow up with "Postcondition failed"
 }
@@ -902,8 +1145,11 @@ sub do-db-stuff {
   KEEP $db.commit; # commit the transaction if all went well
   UNDO $db.rollback; # or rollback if all hell broke loose
 }
+```
 
-### Statement prefixes
+## Statement prefixes
+
+```perl6
 # Those act a bit like phasers: they affect the behavior of the following code.
 # Though, they run in-line with the executable code, so they're in lowercase.
 # (`try` and `start` are theoretically in that list, but explained somewhere else)
@@ -946,26 +1192,41 @@ say join ',', gather if False {
 constant thrice = gather for ^3 { say take $_ }; # Doesn't print anything
 # versus:
 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 !!
+## Iterables
+
+```perl6
+# Iterables are objects that can be iterated similar to the `for` construct
+# `flat`, flattens iterables:
+say (1, 10, (20, 10) ); #> (1 10 (20 10)) Notice how grouping is maintained
+say (1, 10, (20, 10) ).flat; #> (1 10 20 10) Now the iterable is flat
 
+# - `lazy` - Defer actual evaluation until value is fetched (forces lazy context)
+my @lazy-array = (1..100).lazy;
+say @lazy-array.is-lazy; #> True # Check for lazyness with the `is-lazy` method.
+say @lazy-array; #> [...] List has not been iterated on!
+my @lazy-array { .print }; # This works and will only do as much work as is
+# needed.
+[//]: # ( TODO explain that gather/take and map are all lazy)
 # - `sink` - An `eager` that discards the results (forces sink context)
 constant nilthingie = sink for ^3 { .say } #=> 0 1 2
 say nilthingie.perl; #=> Nil
 
-# - `quietly` - Supresses warnings
-# Not yet implemented !
+# - `quietly` blocks will suppress warnings:
+quietly { warn 'This is a warning!' }; #=> No output
 
 # - `contend` - Attempts side effects under STM
 # Not yet implemented !
+```
 
-### More operators thingies !
+## More operators thingies !
 
+```perl6
 ## Everybody loves operators ! Let's get more of them
 
 # The precedence list can be found here:
-# http://perlcabal.org/syn/S03.html#Operator_precedence
+# https://docs.perl6.org/language/operators#Operator_Precedence
 # But first, we need a little explanation about associativity:
 
 # * Binary operators:
@@ -979,8 +1240,11 @@ $a ! $b ! $c; # with a list-associative `!`, this is `infix:<>`
 !$a! # with left-associative `!`, this is `(!$a)!`
 !$a! # with right-associative `!`, this is `!($a!)`
 !$a! # with non-associative `!`, this is illegal
+```
 
-## Create your own operators !
+### Create your own operators !
+
+```perl6
 # Okay, you've been reading all of that, so I guess I should try
 #  to show you something exciting.
 # I'll tell you a little secret (or not-so-secret):
@@ -1044,8 +1308,11 @@ postcircumfix:<{ }>(%h, $key, :delete); # (you can call operators like that)
 
 # (you are, obviously, recommended against making an operator out of
 # *everything* -- with great power comes great responsibility)
+```
 
-## Meta operators !
+### Meta operators !
+
+```perl6
 # Oh boy, get ready. Get ready, because we're delving deep
 #  into the rabbit's hole, and you probably won't want to go
 #  back to other languages after reading that.
@@ -1088,10 +1355,11 @@ sub add($a, $b) { $a + $b }
 say [[&add]] 1, 2, 3; #=> 6
 
 ## * Zip meta-operator
-# This one is an infix meta-operator than also can be used as a "normal" operator.
-# It takes an optional binary function (by default, it just creates a pair),
-#  and will pop one value off of each array and call its binary function on these
-#  until it runs out of elements. It returns an array with all of these new elements.
+# This one is an infix meta-operator than also can be used as a "normal"
+# operator.  It takes an optional binary function (by default, it just creates
+# a pair), and will pop one value off of each array and call its binary function
+# on these until it runs out of elements. It returns an array with all of these
+# new elements.
 (1, 2) Z (3, 4); # ((1, 3), (2, 4)), since by default, the function makes an array
 1..3 Z+ 4..6; # (5, 7, 9), using the custom infix:<+> function
 
@@ -1131,8 +1399,11 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
 # Note : as for ranges, once reified, elements aren't re-calculated.
 # That's why `@primes[^100]` will take a long time the first time you print
 #  it, then be instant.
+```
 
-### Regular Expressions
+## Regular Expressions
+
+```perl6
 # I'm sure a lot of you have been waiting for this one.
 # Well, now that you know a good deal of Perl 6 already, we can get started.
 # First off, you'll have to forget about "PCRE regexps" (perl-compatible regexps).
@@ -1158,14 +1429,15 @@ say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
 #     (grammars are actually classes)
 #  - Earliest declaration wins
 say so 'a' ~~ /a/; #=> True
-say so 'a' ~~ / a /; # More readable with some spaces!
+say so 'a' ~~ / a /; #=> True #  More readable with some spaces!
 
 # In all our examples, we're going to use the smart-matching operator against
 #  a regexp. We're converting the result using `so`, but in fact, it's
 #  returning a `Match` object. They know how to respond to list indexing,
 #  hash indexing, and return the matched string.
 # The results of the match are available as `$/` (implicitly lexically-scoped).
-# You can also use the capture variables (`$0`, `$1`, ... starting at 0, not 1 !).
+# You can also use the capture variables which start at 0:
+#    `$0`, `$1', `$2`...
 #
 # You can also note that `~~` does not perform start/end checking
 #  (meaning the regexp can be matched with just one char of the string),
@@ -1173,50 +1445,63 @@ say so 'a' ~~ / a /; # More readable with some spaces!
 
 # In Perl 6, you can have any alphanumeric as a literal,
 # everything else has to be escaped, using a backslash or quotes.
-say so 'a|b' ~~ / a '|' b /; # `True`. Wouln't mean the same if `|` wasn't escaped
+say so 'a|b' ~~ / a '|' b /; # `True`. Wouldn't mean the same if `|` wasn't escaped
 say so 'a|b' ~~ / a \| b /; # `True`. Another way to escape it.
 
 # The whitespace in a regexp is actually not significant,
-#  unless you use the `:s` (`:sigspace`, significant space) modifier.
-say so 'a b c' ~~ / a b c /; # `False`. Space is not significant here
-say so 'a b c' ~~ /:s a b c /; # `True`. We added the modifier `:s` here.
-
+#  unless you use the `:s` (`:sigspace`, significant space) adverb.
+say so 'a b c' ~~ / a  b  c /; #> `False`. Space is not significant here
+say so 'a b c' ~~ /:s a b c /; #> `True`. We added the modifier `:s` here.
+# If we use only one space between strings in a regex, Perl 6 will warn us:
+say so 'a b c' ~~ / a b c /; #> 'False' #> Space is not significant here; please
+# use quotes or :s (:sigspace) modifier (or, to suppress this warning, omit the
+# space, or otherwise change the spacing)
+# To fix this and make the spaces less ambiguous,  either use at least two
+# spaces between strings or use the `:s` adverb.
+
+# As we saw before, we can embed the `:s` inside the slash delimiters, but we can
+# also put it outside of them if we specify `m` for 'match':
+say so 'a b c' ~~ m:s/a  b  c/; #> `True`
+# By using `m` to specify 'match' we can also use delimiters other than slashes:
+say so 'abc' ~~ m{a  b  c}; #> `True`
+# Use the :i adverb to specify case insensitivity:
+say so 'ABC' ~~ m:i{a  b  c}; #> `True`
 # It is, however, important as for how modifiers (that you're gonna see just below)
 #  are applied ...
 
 ## Quantifying - `?`, `+`, `*` and `**`.
 # - `?` - 0 or 1
-so 'ac' ~~ / a b c /; # `False`
-so 'ac' ~~ / a b? c /; # `True`, the "b" matched 0 times.
-so 'abc' ~~ / a b? c /; # `True`, the "b" matched 1 time.
+so 'ac' ~~ / a  b  c /; # `False`
+so 'ac' ~~ / a  b?  c /; # `True`, the "b" matched 0 times.
+so 'abc' ~~ / a  b?  c /; # `True`, the "b" matched 1 time.
 
 # ... As you read just before, whitespace is important because it determines
 #  which part of the regexp is the target of the modifier:
-so 'def' ~~ / a b c? /; # `False`. Only the `c` is optional
-so 'def' ~~ / ab?c /; # `False`. Whitespace is not significant
+so 'def' ~~ / a  b  c? /; # `False`. Only the `c` is optional
+so 'def' ~~ / a  b?  c /; # `False`. Whitespace is not significant
 so 'def' ~~ / 'abc'? /; # `True`. The whole "abc" group is optional.
 
 # Here (and below) the quantifier applies only to the `b`
 
 # - `+` - 1 or more
-so 'ac' ~~ / a b+ c /; # `False`; `+` wants at least one matching
-so 'abc' ~~ / a b+ c /; # `True`; one is enough
-so 'abbbbc' ~~ / a b+ c /; # `True`, matched 4 "b"s
+so 'ac' ~~ / a  b+  c /; # `False`; `+` wants at least one matching
+so 'abc' ~~ / a  b+  c /; # `True`; one is enough
+so 'abbbbc' ~~ / a  b+  c /; # `True`, matched 4 "b"s
 
 # - `*` - 0 or more
-so 'ac' ~~ / a b* c /; # `True`, they're all optional.
-so 'abc' ~~ / a b* c /; # `True`
-so 'abbbbc' ~~ / a b* c /; # `True`
-so 'aec' ~~ / a b* c /; # `False`. "b"(s) are optional, not replaceable.
+so 'ac' ~~ / a  b*  c /; # `True`, they're all optional.
+so 'abc' ~~ / a  b*  c /; # `True`
+so 'abbbbc' ~~ / a  b*  c /; # `True`
+so 'aec' ~~ / a  b*  c /; # `False`. "b"(s) are optional, not replaceable.
 
 # - `**` - (Unbound) Quantifier
 # If you squint hard enough, you might understand
 #  why exponentation is used for quantity.
-so 'abc' ~~ / a b ** 1 c /; # `True` (exactly one time)
-so 'abc' ~~ / a b ** 1..3 c /; # `True` (one to three times)
-so 'abbbc' ~~ / a b ** 1..3 c /; # `True`
-so 'abbbbbbc' ~~ / a b ** 1..3 c /; # `False` (too much)
-so 'abbbbbbc' ~~ / a b ** 3..* c /; # `True` (infinite ranges are okay)
+so 'abc' ~~ / a  b**1  c /; # `True` (exactly one time)
+so 'abc' ~~ / a  b**1..3  c /; # `True` (one to three times)
+so 'abbbc' ~~ / a  b**1..3  c /; # `True`
+so 'abbbbbbc' ~~ / a  b**1..3  c /; # `False` (too much)
+so 'abbbbbbc' ~~ / a  b**3..*  c /; # `True` (infinite ranges are okay)
 
 # - `<[]>` - Character classes
 # Character classes are the equivalent of PCRE's `[]` classes, but
@@ -1238,8 +1523,11 @@ so 'foo' ~~ / <-[ f o ]> + /; # False
 so 'foo' ~~ / <[ a..z ] - [ f o ]> + /; # False (any letter except f and o)
 so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /; # True (no letter except f and o)
 so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (the + doesn't replace the left part)
+```
+
+### Grouping and capturing
 
-## Grouping and capturing
+```perl6
 # Group: you can group parts of your regexp with `[]`.
 # These groups are *not* captured (like PCRE's `(?:)`).
 so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing
@@ -1268,14 +1556,17 @@ say $0; # The same as above.
 #  IFF it can have more than one element
 #  (so, with `*`, `+` and `**` (whatever the operands), but not with `?`).
 # Let's use examples to see that:
-so 'fooABCbar' ~~ / foo ( A B C )? bar /; # `True`
+
+# Note: We quoted A B C to demonstrate that the whitespace between them isn't significant.
+#       If we want the whitespace to *be* significant there, we can use the :sigspace modifier.
+so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; # `True`
 say $/[0]; #=> ｢ABC｣
 say $0.WHAT; #=> (Match)
-             # It can't be more than one, so it's only a single match object.
-so 'foobar' ~~ / foo ( A B C )? bar /; #=> True
+             # There can't be more than one, so it's only a single match object.
+so 'foobar' ~~ / foo ( "A" "B" "C" )? bar /; #=> True
 say $0.WHAT; #=> (Any)
              # This capture did not match, so it's empty
-so 'foobar' ~~ / foo ( A B C ) ** 0..1 bar /; # `True`
+so 'foobar' ~~ / foo ( "A" "B" "C" ) ** 0..1 bar /; # `True`
 say $0.WHAT; #=> (Array)
              # A specific quantifier will always capture an Array,
              #  may it be a range or a specific value (even 1).
@@ -1314,7 +1605,7 @@ so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ...
 #  and other things that can't traditionnaly be represented by normal regexps.
 #
 # Then, all the alternatives are tried at once, and the longest wins.
-# Exemples:
+# Examples:
 # DECLARATIVE | PROCEDURAL
 / 'foo' \d+     [ <subrule1> || <subrule2> ] /;
 # DECLARATIVE (nested groups are not a problem)
@@ -1325,11 +1616,11 @@ so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ...
 
 # Note: the first-matching `or` still exists, but is now spelled `||`
 'foo' ~~ / fo || foo /; # `fo` now.
+```
 
+## Extra: the MAIN subroutine
 
-
-
-### Extra: the MAIN subroutine
+```perl6
 # The `MAIN` subroutine is called when you run a Perl 6 file directly.
 # It's very powerful, because Perl 6 actually parses the arguments
 #  and pass them as such to the sub. It also handles named argument (`--foo`)
@@ -1357,13 +1648,12 @@ multi MAIN('import', File, Str :$as) { ... } # omitting parameter name
 # As you can see, this is *very* powerful.
 # It even went as far as to show inline the constants.
 # (the type is only displayed if the argument is `$`/is named)
+```
 
-###
-### APPENDIX A:
-###
+## APPENDIX A:
 ### List of things
-###
 
+```perl6
 # It's considered by now you know the Perl6 basics.
 # This section is just here to list some common operations,
 #  but which are not in the "main part" of the tutorial to bloat it up
@@ -1460,7 +1750,18 @@ for <a b c> {
 
 If you want to go further, you can:
 
- - Read the [Perl 6 Advent Calendar](http://perl6advent.wordpress.com/). This is probably the greatest source of Perl 6 information, snippets and such.
+ - Read the [Perl 6 Docs](https://docs.perl6.org/). This is a great
+ resource on Perl6.  If you are looking for something, use the search bar.
+ This will give you a dropdown menu of all the pages referencing your search
+ term (Much better than using Google to find Perl 6 documents!)
+ - Read the [Perl 6 Advent Calendar](http://perl6advent.wordpress.com/). This
+ is a great source of Perl 6 snippets and explainations.  If the docs don't
+ describe something well enough, you may find more detailed information here.
+ This information may be a bit older but there are many great examples and
+ explainations.  Posts stopped at the end of 2015 when the language was declared
+ stable and Perl 6.c was released.
  - Come along on `#perl6` at `irc.freenode.net`. The folks here are always helpful.
  - Check the [source of Perl 6's functions and classes](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo is mainly written in Perl 6 (with a lot of NQP, "Not Quite Perl", a Perl 6 subset easier to implement and optimize).
  - Read [the language design documents](http://design.perl6.org). They explain P6 from an implementor point-of-view, but it's still very interesting.
+
+ [//]: # ( vim: set filetype=perl softtabstop=2 shiftwidth=2 expandtab cc=80 : )
diff --git a/php-composer.html.markdown b/php-composer.html.markdown
new file mode 100644
index 00000000..16fed582
--- /dev/null
+++ b/php-composer.html.markdown
@@ -0,0 +1,167 @@
+---
+category: tool
+tool: composer
+contributors:
+    - ["Brett Taylor", "https://github.com/glutnix"]
+filename: LearnComposer.sh
+---
+
+[Composer](https://getcomposer.org/) is a tool for dependency management in PHP. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you.
+
+# Installing
+
+```sh
+# Installs the composer.phar binary into the current directory
+curl -sS https://getcomposer.org/installer | php
+# If you use this approach, you will need to invoke composer like this:
+php composer.phar about
+
+# Installs the binary into ~/bin/composer
+# Note: make sure ~/bin is in your shell's PATH environment variable
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Windows users should follow the [Windows installation instructions](https://getcomposer.org/doc/00-intro.md#installation-windows)
+
+## Confirming installation
+
+```sh
+# Check version and list options
+composer
+
+# Get more help for options
+composer help require
+
+# Check if Composer is able to do the things it needs, and if it's up to date
+composer diagnose
+composer diag # shorthand
+
+# Updates the Composer binary to the latest version
+composer self-update
+composer self # shorthand
+```
+
+# Usage
+
+Composer stores your project dependencies in `composer.json`. You can edit this file, but it is best to let Composer manage it for you.
+
+```sh
+# Create a new project in the current folder
+composer init
+# runs an interactive questionnaire asking you for details about your project.  Leaving them blank is fine unless you are making other projects dependent on this one.
+
+# If a composer.json file already exists, download the dependencies
+composer install
+
+# To download the just the production dependencies, i.e. excluding development dependencies
+composer install --no-dev
+
+# Add a production dependency to this project
+composer require guzzlehttp/guzzle
+# will figure out what the latest version of guzzlehttp/guzzle is, download it, and add the new dependency to composer.json's require field.
+
+composer require guzzlehttp/guzzle:6.0.*
+# will download the latest version matching the pattern (eg. 6.0.2) and add the dependency to composer.json's require field
+
+composer require --dev phpunit/phpunit:~4.5.0
+# will require as a development dependency. Will use the latest version >=4.5.0 and < 4.6.0
+
+composer require-dev phpunit/phpunit:^4.5.0
+# will require as a development dependency. Will use the latest version >=4.5.0 and < 5.0
+
+# For more information on Composer version matching, see [Composer's documentation on Versions](https://getcomposer.org/doc/articles/versions.md) for more details
+
+# To see what packages are available to install and currently installed
+composer show
+
+# To see what packages are currently installed
+composer show --installed
+
+# To find a package with 'mailgun' in its name or description
+composer search mailgun
+```
+
+[Packagist.org](https://packagist.org/) is the main repository for Composer packages. Search there for existing third-party packages.
+
+## `composer.json` vs `composer.lock`
+
+The `composer.json` file stores your project's floating version preferences for each dependency, along with other information.
+
+The `composer.lock` file stores exactly which version it has downloaded for each dependency. Never edit this file.
+
+If you include the `composer.lock` file in your git repository, every developer will install the currently used version of the dependency. Even when a new version of a dependency is released, Composer will continue to download the version recorded in the lock file.
+
+```sh
+# If you want to update all the dependencies to their newest version still matching your version preferences
+composer update
+
+# If you want the new version of a particular dependency:
+composer update phpunit/phpunit
+
+# If you wish to migrate a package to a newer version preference, you may need to remove the older package and its dependencies first.
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+
+```
+
+## Autoloader
+
+Composer creates an autoloader class you can require from your application. You can make instances of classes via their namespace.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### PSR-4 Autoloader
+
+You can add your own namespaces to the autoloader.
+
+In `composer.json`, add a 'autoload' field:
+
+```json
+{
+  "autoload": {
+    "psr-4": {"Acme\\": "src/"}
+  }
+}
+```
+This will tell the autoloader to look for anything in the `\Acme\` namespace within the `src` folder.
+
+You can also [use PSR-0, a Classmap or just a list of files to include](https://getcomposer.org/doc/04-schema.md#autoload). There is also the `autoload-dev` field for development-only namespaces.
+
+When adding or modifying the autoload key, you will need to rebuild the autoloader:
+
+```sh
+composer dump-autoload
+composer dump # shorthand
+
+# Optimizes PSR0 and PSR4 packages to be loaded with classmaps too. Slow to run, but improves performance on production.
+composer dump-autoload --optimize --no-dev
+```
+
+# Composer's Cache
+
+```sh
+# Composer will retain downloaded packages to use in the future. Clear it with:
+composer clear-cache
+```
+
+# Troubleshooting
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Topics not (yet) covered in this tutorial
+
+* Creating and distributing your own packages on Packagist.org or elsewhere
+* Pre- and post- script hooks: run tasks when certain composer events take place
+
+### References
+
+* [Composer - Dependency Manager for PHP](https://getcomposer.org/)
+* [Packagist.org](https://packagist.org/)
diff --git a/php.html.markdown b/php.html.markdown
index ce178a15..f247ba77 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -88,6 +88,8 @@ $escaped   = "This contains a \t tab character.";
 $unescaped = 'This just contains a slash and a t: \t';
 
 // Enclose a variable in curly braces if needed
+$apples = "I have {$number} apples to eat.";
+$oranges = "I have ${number} oranges to eat.";
 $money = "I have $${number} in the bank.";
 
 // Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners
@@ -142,6 +144,9 @@ $associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
 
 echo $associative['One']; // prints 1
 
+// Add an element to an associative array
+$associative['Four'] = 4;
+
 // List literals implicitly assign integer keys
 $array = ['One', 'Two', 'Three'];
 echo $array[0]; // => "One"
@@ -278,7 +283,7 @@ if (false) {
 
 if (false) {
     print 'Does not get printed';
-} elseif(true) {
+} elseif (true) {
     print 'Does';
 }
 
@@ -300,7 +305,7 @@ echo $b ?? 'b is not set'; // prints 'Does print'
 $x = 0;
 if ($x === '0') {
     print 'Does not print';
-} elseif($x == '1') {
+} elseif ($x == '1') {
     print 'Does not print';
 } else {
     print 'Does print';
@@ -337,7 +342,7 @@ switch ($x) {
 $i = 0;
 while ($i < 5) {
     echo $i++;
-}; // Prints "01234"
+} // Prints "01234"
 
 echo "\n";
 
@@ -462,7 +467,7 @@ function variable($word, ...$list) {
 	}
 }
 
-variable("Separate", "Hello", "World") // Separate || Hello | World | 
+variable("Separate", "Hello", "World"); // Separate || Hello | World |
 
 /********************************
  * Includes
@@ -525,7 +530,8 @@ class MyClass
     private $priv   = 'private';   // Accessible within the class only
 
     // Create a constructor with __construct
-    public function __construct($instanceProp) {
+    public function __construct($instanceProp)
+    {
         // Access instance variables with $this
         $this->instanceProp = $instanceProp;
     }
@@ -536,11 +542,26 @@ class MyClass
         print 'MyClass';
     }
 
-    //final keyword would make a function unoverridable
+    // final keyword would make a function unoverridable
     final function youCannotOverrideMe()
     {
     }
 
+    // Magic Methods
+
+    // what to do if Object is treated as a String
+    public function __toString()
+    {
+        return $property;
+    }
+
+    // opposite to __construct()
+    // called when object is no longer referenced
+    public function __destruct()
+    {
+        print "Destroying";
+    }
+
 /*
  * Declaring class properties or methods as static makes them accessible without
  * needing an instantiation of the class. A property declared as static can not
@@ -737,11 +758,15 @@ $cls = new SomeOtherNamespace\MyClass();
 *
 */
 
-class ParentClass {
-    public static function who() {
+class ParentClass
+{
+    public static function who()
+    {
         echo "I'm a " . __CLASS__ . "\n";
     }
-    public static function test() {
+
+    public static function test()
+    {
         // self references the class the method is defined within
         self::who();
         // static references the class the method was invoked on
@@ -755,8 +780,10 @@ I'm a ParentClass
 I'm a ParentClass
 */
 
-class ChildClass extends ParentClass {
-    public static function who() {
+class ChildClass extends ParentClass
+{
+    public static function who()
+    {
         echo "But I'm " . __CLASS__ . "\n";
     }
 }
@@ -797,7 +824,7 @@ echo "Current method is " . __METHOD__;
 echo "Current namespace is " . __NAMESPACE__;
 
 // Get the name of the current trait. Only returns a value when used inside a trait or object declaration.
-echo "Current namespace is " . __TRAIT__;
+echo "Current trait is " . __TRAIT__;
 
 /**********************
 *  Error Handling
diff --git a/pl-pl/brainfuck-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 69d814c4..801f1a9a 100644
--- a/pl-pl/brainfuck-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
new file mode 100644
index 00000000..3a51ade5
--- /dev/null
+++ b/pl-pl/haskell-pl.html.markdown
@@ -0,0 +1,444 @@
+---
+language: Haskell
+lang: pl-pl
+contributors:
+    - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
+---
+
+Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język 
+programowania. Jest znany przede wszystkim ze względu na jego monady oraz system
+typów, ale ja lubię do niego wracać przez jego elegancję. Sprawił on, że 
+programowanie jest prawdziwą przyjemnością.
+
+```haskell
+-- Komentarze jednolinijkowe zaczynają się od dwóch myślników
+{- Komentarze wielolinijkowe należy 
+zamykać w bloki klamrami.
+-}
+
+----------------------------------------------------
+-- 1. Podstawowe typy danych oraz operatory
+----------------------------------------------------
+
+-- Mamy liczby
+3 -- 3
+
+-- Podstawowe działania działają tak, jak powinny
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- dzielenie domyślnie zwraca ,,dokładny'' wynik
+35 / 4 -- 8.75
+
+-- dzielenie całkowitoliczbowe
+35 `div` 4 -- 8
+
+-- wartości logiczne także są podstawowym typem danych:
+True
+False
+
+-- operacje logiczne: negacja oraz porównania
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- W powyższych przykładach, `not` jest funkcją przyjmującą jeden argument.
+-- Haskell nie potrzebuje nawiasów, by wywołać funkcję: argumenty są po prostu
+-- wypisywane jeden za drugim. Ogólnie wygląda to tak:
+-- funkcja arg1 arg2 arg3...
+-- Sekcja poświęcona funkcjom zawiera informacje, jak stworzyć własne.
+
+-- Łańcuchy znaków (stringi) i pojedyncze znaki:
+"To jest lancuch."
+'a' -- znak
+'Nie mozna laczyc apostrofow z lancuchami.' -- błąd!
+
+-- Łańcuchy można sklejać
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Łańcuch jest listą własnych znaków
+['H', 'e', 'l', 'l', 'o'] -- "Hello"
+"To jest lancuch" !! 0 -- 'T'
+
+----------------------------------------------------
+-- 2. Listy oraz krotki
+----------------------------------------------------
+
+-- Wszystkie elementy listy muszą być tego samego typu.
+-- Poniższe dwie listy są identyczne:
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Zakresy są uniwersalne.
+['A'..'F'] -- "ABCDEF"
+
+-- Przy tworzeniu zakresów można określić krok.
+[0,2..10] -- [0, 2, 4, 6, 8, 10]
+[5..1] -- To nie zadziała, gdyż w Haskellu zakresy tworzone są domyślnie rosnąco
+[5,4..1] -- [5, 4, 3, 2, 1]
+
+-- indeksowanie listy od zera
+[1..10] !! 3 -- 4
+
+-- Można nawet tworzyć listy nieskończone!
+[1..] -- lista wszystkich liczb naturalnych
+
+-- Nieskończone listy mają prawo działać, ponieważ Haskell cechuje się leniwym 
+-- wartościowaniem. To oznacza, że obliczane są jedynie te elementy listy, 
+-- których istotnie potrzebujemy. Możemy poprosić o tysiączny element i 
+-- dostaniemy go:
+
+[1..] !! 999 -- 1000
+
+-- Haskell wyznaczył pierwsze tysiąc elementów listy, ale cała jej reszta 
+-- jeszcze nie istnieje! Nie zostanie obliczona ich wartość, póki nie zajdzie
+-- taka potrzeba.
+
+-- łączenie dwóch list
+[1..5] ++ [6..10]
+
+-- dodawanie pojedynczego elementu na początek listy
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- więcej operacji na listach
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- list comprehensions
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- z dodatkowym warunkiem
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- każdy element krotki może być innego typu, jednak sama krotka musi być stałej 
+-- długości. Przykładowo:
+("haskell", 1)
+
+-- dostęp do elementów pary (krotki długości 2):
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Funkcje
+----------------------------------------------------
+-- Prosta funkcja przyjmująca dwa argumenty
+add a b = a + b
+
+-- Pamiętaj, że podczas stosowania ghci, interpretera Haskella, wszelkie 
+-- definicje muszą zostać poprzedzone słowem `let`, na przykład:
+-- let add a b = a + b
+
+-- Używanie funkcji:
+add 1 2 -- 3
+
+-- Nazwę funkcji można podać między dwoma argumentami, ale wtedy musi zostać
+-- otoczona grawisami:
+1 `add` 2 -- 3
+
+-- Nazwa funkcji nie musi zawierać żadnych liter, przykładem czego jest 
+-- operator dzielenia:
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Strażnicy: prosty sposób na rozbijanie funkcji na przypadki
+fib x
+  | x < 2 = 1
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie wzorca jest podobne. Haskell sam automatycznie wybierze, która
+-- z poniższych definicji fib powinna zostać użyta:
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie z krotkami:
+foo (x, y) = (x + 1, y + 2)
+
+-- Dopasowanie z listami. Tutaj `x` jest pierwszym elementem listy, 
+-- natomiast `xs` to jej reszta (ogon). Poniższa funkcja nakłada funkcję
+-- na każdy z elementów listy:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Funkcje anonimowe tworzone są przy użyciu w-tył-ciachu, po którym następują
+-- wszystkie argumenty:
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- używanie zwijania z anonimowymi funkcjami: foldl1 zwija z lewej strony,
+-- przyjmując jako wartość początkową zbieracza pierwszy element listy.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Więcej funkcji
+----------------------------------------------------
+
+-- częściowe nakładanie: jeśli funkcja nie otrzyma wszystkich swoich argumentów, 
+-- zostaje cześciowo nałożona - zwraca funkcję, która przyjmuje pozostałe,
+-- brakujące argumenty.
+
+add a b = a + b
+foo = add 10 -- foo jest teraz funkcją, która przyjmuje liczbę, zwiększa ją o 10
+foo 5 -- 15
+
+-- Inny sposób na zapisanie tego samego:
+foo = (10+)
+foo 5 -- 15
+
+-- składanie funkcji:
+-- operator `.` składa wiele funkcji w jedną.
+-- Dla przykładu, foo jest funkcją, która powiększa swój argument o 10, mnoży 
+-- tak uzyskaną liczbę przez 4 i zwraca wynik:
+foo = (4*) . (10+)
+
+-- 4*(10 + 5) = 60
+foo 5 -- 60
+
+-- ustalanie kolejności
+-- Haskell posiada inny operator, `$`, który nakłada funkcję do podanego
+-- parametru. W przeciwieństwie do zwykłego lewostronnie łącznego nakładania 
+-- funkcji, którego priorytet jest najwyższy (10), operator `$` posiada
+-- priorytet 0 i jest prawostronnie łączny. Tak niski priorytet oznacza, że
+-- wyrażenie po prawej traktowane jest jako parametr funkcji po lewej
+
+-- wcześniej
+even (fib 7) -- fałsz
+
+-- równoważnie
+even $ fib 7 -- fałsz
+
+-- składanie funkcji
+even . fib $ 7 -- fałsz
+
+
+----------------------------------------------------
+-- 5. Sygnatury typów
+----------------------------------------------------
+
+-- Haskell posiada wyjątkowo silny system typów, w którym każde poprawne 
+-- wyrażenie ma swój typ.
+
+-- Kilka podstawowych typów:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Funkcje też są określonego typu.
+-- `not` przyjmuje wartość logiczną i taką też zwraca:
+-- not :: Bool -> Bool
+
+-- Przykład funkcji przyjmującej dwa argumenty
+-- add :: Integer -> Integer -> Integer
+
+-- Dobrą praktyką podczas definiowania wartości jest napisanie nad nią
+-- także jej typu:
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Wyrażenia warunkowe
+----------------------------------------------------
+
+-- wyrażenie warunkowe
+haskell = if 1 == 1 then "wspaniale" else "paskudnie" -- haskell = "wspaniale"
+
+-- wyrażenie warunkowe można rozbić na wiele linii, 
+-- ale trzeba uważać na wcięcia w kodzie
+haskell = if 1 == 1
+            then "wspaniale"
+            else "paskudnie"
+
+-- rozpatrywanie przypadków: oto jak można parsować argumenty z linii poleceń:
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+-- Haskell zastępuje pętle (których nie ma) rekurencyjnymi wywołaniami funkcji.
+-- map aplikuje funkcję do każdego elementu listy:
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- możesz zdefiniować funkcję for przy użyciu map:
+for array func = map func array
+
+-- a następnie użyć jej:
+for [0..5] $ \i -> show i
+
+-- mogliśmy użyć krótszego zapisu bez zmiany działania funkcji for:
+for [0..5] show
+
+-- Do redukcji listy służy polecenie foldl (foldr):
+-- foldl <fn> <initial value> <list>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- Jest to równoważne z:
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl składa od od lewej strony, foldr od prawej
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- To zaś równoważne jest:
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
+
+----------------------------------------------------
+-- 7. Typy danych
+----------------------------------------------------
+
+-- Oto jak tworzy się nowe typy danych w Haskellu:
+
+data Color = Red | Blue | Green
+
+-- Teraz można używać ich we własnych funkcjach:
+
+say :: Color -> String
+say Red = "You are Red!"
+say Blue = "You are Blue!"
+say Green =  "You are Green!"
+
+-- Twoje typy danych mogą posiadać nawet parametry:
+
+data Maybe a = Nothing | Just a
+
+-- Wszystkie poniższe są typu Maybe
+Just "hello"    -- typu `Maybe String`
+Just 1          -- typu `Maybe Int`
+Nothing         -- typu `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Chociaż obsługa wejścia i wyjścia nie może zostać wyjaśniona przez poznaniem
+-- monad, spróbujemy zrobić to częściowo
+
+-- Wykonanie programu napisanego w Haskellu wywołuje funkcję `main` 
+-- Musi zwrócić wartość typu `IO a` dla pewnego `a`. Przykład:
+
+main :: IO ()
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
+-- putStrLn has type String -> IO ()
+
+-- Najłatwiej obsłużyć wejście i wyjście, kiedy program zostanie 
+-- zaimplementowany jako funkcja String -> String. Funkcja
+--    interact :: (String -> String) -> IO ()
+-- pobiera pewien tekst, wykonuje na nim operacje, po czym wypisuje wynik.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Możesz myśleć o wartości typu `IO ()` jako reprezentującej ciąg czynności,
+-- które komputer ma wykonać, zupełnie niczym program komputerowy w imperatywnym
+-- języku programowania. Akcje można łączyć przy użyciu notacji `do`:
+
+sayHello :: IO ()
+sayHello = do
+   putStrLn "What is your name?"
+   name <- getLine -- this gets a line and gives it the name "name"
+   putStrLn $ "Hello, " ++ name
+
+-- Ćwiczenie: napisz własną wersję `interact`, 
+-- która czyta tylko jedną linię wejścia.
+
+-- Kod w `sayHello` nigdy się nie wykona. Jedyną akcją, która zostanie 
+-- uruchomiona, jest wartość `main`.
+-- Aby uruchomić `sayHello`, należy zastąpić poprzednią definicję `main` przez
+--   main = sayHello
+
+-- Spróbujmy lepiej zrozumieć, jak działa funkcja `getLine`, której właśnie
+-- użyliśmy. Jej typem jest
+--    getLine :: IO String
+-- Możesz myśleć o wartości typu `IO a` jako reprezentującej program, który
+-- wygeneruje wartość typu `a`, poza wszystkim innym, co jeszcze zrobi.
+-- Możemy także tworzyć własne akcje typu `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "This is a line. Duh"
+   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 (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- Możemy użyć tego tak jak używaliśmy `getLine`:
+
+main'' = do
+    putStrLn "I will echo two lines!"
+    result <- action
+    putStrLn result
+    putStrLn "This was all, folks!"
+
+-- Typ `IO` jest przykładem monady. Sposób w jakim Haskell używa monad do 
+-- obsługi wejścia i wyjścia pozwala mu być czysto funkcyjnym językiem.
+-- Każda funkcja, która wchodzi w interakcje ze światem zewnętrznym, oznaczana
+-- jest jako `IO` w jej sygnaturze typu, co umożliwia odróżnianie funkcji
+-- czystych od zależnych od świata lub modyfikujących stan.
+
+-- To naprawdę użyteczna własność, dzięki której jesteśmy w stanie uruchamiać
+-- czyste funkcje jednocześnie.
+
+----------------------------------------------------
+-- 9. Interaktywne środowisko programowania
+----------------------------------------------------
+
+-- Aby uruchomić repl (read-eval-print loop, interaktywne środowisko), należy
+-- wpisać `ghci`. Można już programować. Do definiowania nowych wartości służy
+-- słowo kluczowe `let`:
+
+let foo = 5
+
+-- Do sprawdzania typów dowolnej wartości (wyrażenia) wykorzystuje się `:t`:
+
+> :t foo
+foo :: Integer
+
+-- Działania takie jak `+`, `:` czy `$`, są funkcjami.
+-- Przed sprawdzeniem ich typu należy otoczyć je nawiasami:
+
+> :t (:)
+(:) :: a -> [a] -> [a]
+
+-- Dodatkowych informacji dostarcza `:i`:
+
+> :i (+)
+class Num a where
+  (+) :: a -> a -> a
+  ...
+    -- Defined in ‘GHC.Num’
+infixl 6 +
+
+-- Można nawet wykonywać akcje typu `IO ()`!
+
+> sayHello
+What is your name?
+Friend!
+Hello, Friend!
+
+```
+
+Pominęliśmy wiele aspektów Haskella, wliczając w to monady. To właśnie one 
+sprawiają, że programowanie w Haskellu sprawia tyle frajdy. Na zakończenie
+pokażę Tobie implementację algorytmu quicksort w Haskellu:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell może zostać zainstalowany na co najmniej dwa sposoby:
+ - tradycyjnie [przy użyciu Cabala](http://www.haskell.org/platform/),
+ - nowocześnie [z pomocą Stack](https://www.stackage.org/install).
+
+Godnymi poleceniami wprowadzeniami są wspaniałe
+[Learn you a Haskell](http://learnyouahaskell.com/) albo
+[Real World Haskell](http://book.realworldhaskell.org/).
diff --git a/pl-pl/json-pl.html.markdown b/pl-pl/json-pl.html.markdown
new file mode 100644
index 00000000..872455de
--- /dev/null
+++ b/pl-pl/json-pl.html.markdown
@@ -0,0 +1,85 @@
+---
+language: json
+filename: learnjson-pl.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Michael Neth", "https://github.com/infernocloud"]
+translators:
+  - ["Michał Mitrosz", "https://github.com/Voltinus"]
+lang: pl-pl
+---
+
+JSON to bardzo prosty format wymiany danych. Jak jest napisane na [json.org](http://json.org), jest łatwy do pisania i czytania dla ludzi i do parsowania i generowania dla maszyn.
+
+Kod JSON musi zawierać któreś z poniższych:
+* Zbiór par nazwa/wartość (`{ }`). W różnych językach jest to obiekt, rekord, struktura, słownik, tablica mieszająca, lista z kluczami, lub tablica asocjacyjna.
+* Uporządkowana lista wartości (`[ ]`). W różnych językach jest to tablica, wektor, lista, lub sekwencja.
+ tablica/lista/sekwencja (`[ ]`) lub słownik/obiekt/tablica asocjacyjna (`{ }`).
+
+JSON w swojej czystej postaci nie ma komentarzy, ale większość parserów akceptuje komentarze w stylu C (`//`, `/* */`). Niektóre parsery pozwalają także na końcowy przecinek (np. przecinek po ostatnim elemencie w tablicy lub po ostatiej własności obiektu), ale powinien on być omijany dla lepszej kompatybilności.
+
+Dla celów tego poradnika wszystko będzie 100% kodem JSON. Na szczęście, to samo mówi za siebie.
+
+Wspierane typy danych:
+
+* Łańcuchy znaków: `"witaj"`, `"\"Cytat.\""`, `"\u0abe"`, `"Nowa linia.\n"`
+* Liczby: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Obiekty: `{ "klucz": "wartość" }`
+* Tablice: `["Wartości"]`
+* Inne: `true`, `false`, `null`
+
+```json
+{
+  "klucz": "wartość",
+
+  "klucze": "muszą być zawsze zamknięte w podwójnych cudzysłowach",
+  "liczby": 0,
+  "łańcuchy": "Hellø, wørld. Wszystkie znaki unicode są dozwolone, razem z \"sekwencjami escape\".",
+  "wartości logiczne?": true,
+  "nic": null,
+
+  "duża liczba": 1.2e+100,
+
+  "obiekty": {
+    "komentarz": "Większość twojej struktury będzie zbudowana z obiektów.",
+
+    "tablica": [0, 1, 2, 3, "Tablice mogą mieć wewnątrz cokolwiek", 5],
+
+    "inny obiekt": {
+      "komentarz": "Elementy mogą się w sobie zawierać, bardzo użyteczne"
+    }
+  },
+
+  "głupota": [
+    {
+      "źródła potasu": ["banany"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "styl alternatywny": {
+    "komentarz": "sprawdź to!"
+  , "pozycja przecinka": "nie ma znaczenia, o ile jest przed następnym kluczem, jest poprawnie"
+  , "następny komentarz": "jak ładnie"
+  },
+
+
+
+  "znaki białe": "nie mają znaczenia",
+
+
+
+  "to było krótkie": "I gotowe. Wiesz już wszystko o formacie JSON."
+}
+```
+
+## Dalsza lektura
+
+* [JSON.org](http://json.org) Cały JSON pięknie wytłumaczony na podstawie grafik przypominających schematy blokowe.
diff --git a/pl-pl/ruby-pl.html.markdown b/pl-pl/ruby-pl.html.markdown
index 73b1a7d8..7ab47847 100644
--- a/pl-pl/ruby-pl.html.markdown
+++ b/pl-pl/ruby-pl.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: ruby
-filename: learnruby.rb
+filename: learnruby-pl.rb
 contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
diff --git a/pl-pl/vim-pl.html.markdown b/pl-pl/vim-pl.html.markdown
new file mode 100644
index 00000000..8ac2df56
--- /dev/null
+++ b/pl-pl/vim-pl.html.markdown
@@ -0,0 +1,236 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Adam Bobowski", "https://github.com/Bobowski"]
+lang: pl-pl
+filename: LearnVim-pl.txt
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) jest klonem popularnego edytora vi dla systemów Unix. 
+Zaprojektowany z myślą o prędkości edycji i zwiększeniu produktywności jest 
+wszechobecny na systemach UNIXopodobnych. Posiada wiele skrótów klawiszowych 
+do szybkiej nawigacji do wybranych miejsc w plikach oraz szybkiej edycji 
+danych fragmentów.
+
+## Podstawy nawigacji w Vim
+
+```
+    vim <nazwapliku> # Otwórz <nazwapliku> w vim
+    :q               # Zamknij vim
+    :w               # Zapisz aktualny plik
+    :wq              # Zapisz i wyjdź z vim
+    :q!              # Wyjdź bez zapisywania
+                     # ! *wymusza* wykonanie :q, dlatego nie wykonuje zapisu
+    :x               # Zapisz i wyjdź, krótszy odpowiednik :wq
+
+    u                # Cofnij operację
+    CTRL+R           # Powtórz operację
+
+    h                # Przesuń kursor w lewo
+    j                # Przesuń kursor w dół
+    k                # Przesuń kursor w górę
+    l                # Przesuń kursor w prawo
+
+    # Poruszanie w obrębie jednej lini
+
+    0                # Skocz do początku linii
+    $                # Skocz do końca linii
+    ^                # Skocz do pierwszego niebiałego znaku
+
+    # Wyszukiwanie w tekście
+
+    /slowo           # Zaznacza wszystkie wystąpienia słowa za kursorem
+    ?slowo           # Zaznacza wszystkie wystąpienia słowa przed kursorem
+    n                # Przemieszcza kursor do następnego wystąpienia słowa
+    N                # Przemieszcza kursor do poprzedniego wystąpenia słowa
+
+    :%s/foo/bar/g    # Zamień 'foo' na 'bar' w każdej linii tekstu
+    :s/foo/bar/g     # Zamień 'foo' na 'bar' w aktualnej linii
+
+    # Skoki do znaków
+
+    f<znak>          # Skocz do przodu i zatrzymaj się na <znak>
+    t<znak>          # Skocz do przodu i zatrzymaj się przed <znak> 
+
+    # Na przykład,    
+    f<               # Skocz do przodu i zatrzymaj się na <
+    t<               # Skocz do przodu i zatrzymaj się przed <
+    
+    # Moving by word
+
+    w                # Przesuń kursor do przodu o jedno słowo
+    b                # Przesuń kursor do tyłu o jedno słowo
+    e                # Przesuń kursor do końca aktualnego słowa
+
+    # Inne znaki do przemieszczania się
+
+    gg               # Skocz na początek pliku
+    G                # Skocz na koniec pliku
+    :NUM             # Skocz do linii o numerze NUM
+    H                # Skocz na górę ekranu
+    M                # Skocz na środek ekranu
+    L                # Skocz na dół ekranu
+```
+
+## Tryby:
+
+Vim oparty jest na koncepcji **trybów**.
+
+Command Mode - (Tryb komend) vim zaczyna w tym trybie, używany do nawigacji i wpisywania komend
+Insert Mode  - (Tryb wprowadzania) używany do wprowadzania zmian w pliku
+Visual Mode  - (Tryb wizualny) używany do zaznaczania tekstu i wykonywania komend na nim
+Ex Mode      - (Tryb Ex) 
+
+```
+    i                # Przechodzi to trybu wprowadzania, przed pozycją kursora
+    a                # Przechodzi do trybu wprowadzania, za pozycją kursora
+    v                # Przechodzi do trybu wizualnego
+    :                # Przechodzi do trybu ex
+    <esc>            # Wychodzi z dowolnego aktywnego trybu do trybu komend
+
+    # Kopiowanie i wklejanie tekstu
+
+    y                # Skopiuj zaznaczony tekst
+    yy               # Skopiuj aktualną linię
+    d                # Usuń zaznaczony tekst
+    dd               # Usuń aktualną linię
+    p                # Wklej skopiowany tekst za kursorem
+    P                # Wklej skopiowany tekst przed kursorem
+    x                # Usuń znak pod kursorem
+```
+
+## 'Gramatyka' vim'a
+
+Vim można traktować jako zbiór komend w formacie 'Akcja-Modyfikator-Obiekt', gdzie:
+
+Akcja       - jedna z dostępnych akcji
+Modyfikator - w jaki sposób wykonywana jest akcja
+Obiekt      - obiekt na którym wykonywana jest akcja
+
+Kilka ważnych przykładów Akcji, Modyfikatorów i Obiektów:
+
+```
+    # 'Akcje'
+ 
+    d                # Usuń
+    c                # Zmień
+    y                # Skopiuj
+    v                # Zaznacz
+
+    # 'Modyfikatory'
+
+    i                # W środku
+    a                # Dookoła
+    NUM              # Liczba
+    f                # Szuka czegoś i zatrzymuje się na tym
+    t                # Szuka czegoś i zatrzymuje się przed tym
+    /                # Znajduje napis od kursora naprzód
+    ?                # Znajduje napis przed kursorem
+
+    # 'Obiekty'
+
+    w                # Słowo
+    s                # Zdanie
+    p                # Paragraf
+    b                # Blok
+    
+    # Przykładowe 'zdania'
+
+    d2w              # Usuń 2 słowa
+    cis              # Zmień w zdaniu
+    yip              # Skopiuj paragraf w którym jest kursor
+    ct<              # Zamień na <
+    d$               # Usuń tekst do końca linii
+```
+
+## Pewne skróty i triki
+
+        <!--TODO: Dodać więcej!-->
+```
+    >                # Zrób wcięcie zaznaczonego bloku
+    <                # Usuń wcięcie zaznaczonego bloku
+    :earlier 15m     # Przywróć dokument do stanu z przed 15 minut 
+    :later 15m       # Odwróć efekt poprzedniej komendy
+    ddp              # Zamień kolejnością kolejne linie, dd potem p
+    .                # Powtórz poprzednią komendę
+```
+
+## Makra
+
+Makra są właściwie nagrywanymi akcjami. Gdy zaczynasz nagrywać makro, nagrywa ono
+**każdą** akcję i komendę jaką wykonasz do momentu przerwania nagrywania.
+Wywołanie makra wykonuje dokładnie te same operacje w tej samej kolejności.
+
+```
+    qa               # Zacznij nagrywać makro 'a'
+    q                # Przerwij nagrywanie
+    @a               # Odtwórz makro 'a'
+```
+
+### Konfiguracja ~/.vimrc
+
+Plik .vimrc może być użyty do skonfigurowania Vim'a przy jego starcie
+
+Poniżej zamieszczono przykładowy plik ~/.vimrc:
+
+```
+" Przykładowy ~/.vimrc
+" 2016.10 
+
+" Wymagane aby korzystać z opcji iMproved
+set nocompatible
+
+" Na podstawie typu pliku włącza inteligentne wcięcia i inne.
+filetype indent plugin on
+
+" Włącz podkreślanie składni
+syntax on
+
+" Lepsze uzupełnianie składni komend
+set wildmenu
+
+" Wyszukiwanie będzie ignorować wielkość liter poza przypadkami gdy użyjemy wielkich liter
+set ignorecase
+set smartcase
+
+" Po otwarciu pliku gdzie nie jest zdefiniowane zachowanie wcięć
+" zostanie zachowane wcięcie takie samo jak w aktualnej linii
+set autoindent
+
+" Wyświetlaj numer lini
+set number
+
+" Opcje wcięć, zmień w zależności od osobistych upodobań
+
+" Szerokość TAB w spacjach
+set tabstop=4
+
+" Liczba spacji w TAB podczas edycji
+set softtabstop=4
+
+" Liczba spacji gdy wykonywane są operacje wcięcia (>> i <<)
+set shiftwidth=4
+
+" Zamieniaj tabulatory na spacje
+set expandtab
+
+" Aktywuj inteligentne tabulatory i spacje do wcięć i wyrównań
+set smarttab
+```
+
+### Odniesienia [ENG]
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
diff --git a/powershell.html.markdown b/powershell.html.markdown
index fc944b85..bd46051c 100644
--- a/powershell.html.markdown
+++ b/powershell.html.markdown
@@ -19,7 +19,7 @@ rather than plain text.
 
 If you are uncertain about your environment:
 
-```
+```powershell
 Get-ExecutionPolicy -List
 Set-ExecutionPolicy AllSigned
 # Execution policies include:
@@ -35,7 +35,7 @@ $PSVersionTable
 
 Getting help:
 
-```
+```powershell
 # Find commands
 Get-Command about_* # alias: gcm
 Get-Command -Verb Add
@@ -52,7 +52,7 @@ Update-Help # Run as admin
 
 The tutorial starts here:
 
-```
+```powershell
 # As you already figured, comments start with #
 
 # Simple hello world example:
@@ -74,7 +74,7 @@ $aHashtable = @{name1='val1'; name2='val2'}
 # Using variables:
 echo $aString
 echo "Interpolation: $aString"
-echo "`$aString has length of $($aString.Length)"
+echo "$aString has length of $($aString.Length)"
 echo '$aString'
 echo @"
 This is a Here-String
@@ -113,7 +113,7 @@ if ($Age -is [string]) {
 	echo 'Adult'
 }
 
-# Switch statements are more powerfull compared to most languages
+# Switch statements are more powerful compared to most languages
 $val = "20"
 switch($val) {
   { $_ -eq 42 }           { "The answer equals 42"; break }
@@ -204,7 +204,7 @@ function foo([string]$name) {
 # Calling your function
 foo "Say my name"
 
-# Functions with named parameters, parameter attributes, parsable documention
+# Functions with named parameters, parameter attributes, parsable documentation
 <#
 .SYNOPSIS
 Setup a new website
@@ -300,7 +300,7 @@ $Shortcut.Save()
 
 Configuring your shell
 
-```
+```powershell
 # $Profile is the full path for your `Microsoft.PowerShell_profile.ps1`
 # All code there will be executed when the PS session starts
 if (-not (Test-Path $Profile)) {
@@ -308,7 +308,7 @@ if (-not (Test-Path $Profile)) {
 	notepad $Profile
 }
 # More info: `help about_profiles`
-# For a more usefull shell, be sure to check the project PSReadLine below
+# For a more useful shell, be sure to check the project PSReadLine below
 ```
 
 Interesting Projects  
diff --git a/pt-br/amd.html.markdown b/pt-br/amd.html.markdown
new file mode 100644
index 00000000..38c1f70f
--- /dev/null
+++ b/pt-br/amd.html.markdown
@@ -0,0 +1,218 @@
+---
+category: tool
+tool: amd
+contributors:
+    - ["Frederik Ring", "https://github.com/m90"]
+translators:
+    - ["Felipe Tarijon", "http://nanoincub.com/"]
+lang: pt-br
+filename: learnamd-pt.js
+---
+
+## Começando com AMD
+
+A API de Definição de Módulos Assíncrona **Asynchronous Module Definition** 
+especifica um mecanismo para definição de módulos em JavaScript para os quais o
+módulo e suas dependências podem ser carregados de forma assíncrona. Isso é
+particularmente bem adequado para o ambiente do browser onde o carregamento de
+módulos de forma síncrona fica sujeito a problemas de performance, usabilidade,
+debugging e problemas de acesso em requisições cross-domain.
+
+### Conceito básico
+```javascript
+// O básico da API de AMD consiste de nada mais que dois métodos: `define` e `require`
+// e isso é tudo sobre a definição de módulo e consumo:
+// `define(id?, dependências?, factory)` define um módulo
+// `require(dependências, callback)` importa uma série de dependências e
+// consome elas no callback passado como parâmetro.
+
+// Vamos começar usando o define para definir um novo módulo
+// que não tem dependências. Nós vamos fazer isso passando um nome
+// e uma função factory para definir:
+define('awesomeAMD', function(){
+  var isAMDAwesome = function(){
+    return true;
+  };
+  // O valor retornado da função de factory do módulo é
+  // o que os outros módulos ou chamadas de require irão
+  // receber quando requisitarem nosso módulo `awesomeAMD`.
+  // O valor exportado pode ser qualquer coisa, (construtor) funções,
+  // objetos, primitives, até mesmo undefined (apesar de que não irão ajudar muito).
+  return isAMDAwesome;
+});
+
+// Agora, vamos definir outro módulo que depende do nosso módulo `awesomeAMD`.
+// Perceba que existe um argumento adicional definindo nossas dependências do
+// módulo agora:
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+  // dependências serão passadas como argumentos da factory
+  // na ordem que elas forem especificadas
+  var tellEveryone = function(){
+    if (awesomeAMD()){
+      alert('Isso é tãaaao loko!');
+    } else {
+      alert('Bem estúpido, né não?');
+    }
+  };
+  return tellEveryone;
+});
+
+// Agora que nós sabemos como usar o define, vamos usar o `require` para
+// começar nosso programa. A assinatura do `require` é `(arrayDedependências, callback)`.
+require(['loudmouth'], function(loudmouth){
+  loudmouth();
+});
+
+// Para fazer esse tutorial executável, vamos implementar uma versão muito básica
+// (não-assíncrona) de AMD bem aqui nesse lugar:
+function define(nome, deps, factory){
+  // perceba como os módulos sem dependências são manipulados
+  define[nome] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+  var args = [];
+  // primeiro vamos recuperar todas as dependências necessárias
+  // pela chamada requerida
+  for (var i = 0; i < deps.length; i++){
+    args[i] = define[deps[i]];
+  }
+  // corresponder todas as dependências da função de callback
+  return callback.apply(null, args);
+}
+// você pode ver esse código em ação aqui: http://jsfiddle.net/qap949pd/
+```
+
+### Uso na vida real com require.js
+
+Em contraste com o exemplo introdutório, `require.js` (a biblioteca mais popular de AMD) na verdade implementa o **A** do **AMD**, permitindo que você carregue os módulos e suas
+dependências via XHR:
+
+```javascript
+/* file: app/main.js */
+require(['modules/algumaClasse'], function(AlgumaClasse){
+  // o callback é deferido até que a dependencia seja carregada
+  var coisa = new AlgumaClasse();
+});
+console.log('Então aqui estamos nós, esperando!'); // isso vai rodar primeiro
+```
+
+Por convenção, você geralmente guarda um módulo em um arquivo. `require.js` pode resolver nome de módulos baseado no caminho das pastas, então você não precisa nomear os seus módulos, mas sim simplesmente referenciar eles usando sua origem. No exemplo `algumaClasse` é adotado a pasta `modules`, relativa a configuração da sua `baseUrl`:
+
+* app/
+  * main.js
+  * modules/
+    * algumaClasse.js
+    * algunsHelpers.js
+    * ...
+  * daos/
+    * coisas.js
+    * ...
+
+Isso significa que nós podemos definir `algumaClasse` sem especificar o id de um módulo:
+
+```javascript
+/* arquivo: app/modules/algumaClasse.js */
+define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){
+  // definição de módulo, claro, irá acontecer também de forma assíncrona
+  function AlgumaClasse(){
+    this.metodo = function(){/**/};
+    // ...
+  }
+  return AlgumaClasse;
+});
+```
+Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize
+`requirejs.config(configObj)` em seu `main.js`:
+
+```javascript
+/* arquivo: main.js */
+requirejs.config({
+  baseUrl : 'app',
+  paths : {
+    // você pode também carregar módulos de outros locais
+    jquery : '//ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+});
+require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coolLib, helpers){
+  // um arquivo `main` precisa chamar o require pelo menos uma vez,
+  // caso contrário, o código jamais rodará
+  coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
+});
+```
+Apps baseados em `require.js` geralmente terão u´m único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Umas 100 tags de script? Nunca mais!</title>
+</head>
+<body>
+  <script src="require.js" data-main="app/main"></script>
+</body>
+</html>
+```
+
+### Otimizando um projeto inteiro utilizando r.js
+
+Muitas pessoas preferem usar AMD para sanar a organização do código durante o desenvolvimento, mas continuam querendo colocar um único arquivo de script em produção ao invés de realizarem centenas de requisições XHRs no carregamento da página.
+
+`require.js` vem com um script chamado `r.js` (que você vai provavelmente rodar em node.js, embora Rhino suporte também) que você pode analisar o gráfico de dependências de seu projeto, e fazer em um único arquivo contendo todos os seus módulos (corretamente nomeados), minificados e prontos para serem consumidos.
+
+Instale-o utilizando `npm`:
+```shell
+$ npm install requirejs -g
+```
+
+Agora você pode alimentá-lo com um arquivo de configuração:
+```shell
+$ r.js -o app.build.js
+```
+
+Para o nosso exemplo acima a configuração pode ser essa:
+```javascript
+/* file : app.build.js */
+({
+  name : 'main', // nome do ponto de acesso
+  out : 'main-built.js', // nome o arquivo para gravar a saída
+  baseUrl : 'app',
+  paths : {
+    // `empty:` fala para o r.js que isso ainda deve ser baixado da CDN, usando
+    // o local especificado no `main.js`
+    jquery : 'empty:',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+})
+```
+
+Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+Uma incrível e detalhada visão geral [de build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponível no repositório do GitHub.
+
+### Tópicos não abordados nesse tutorial
+* [Plugins de carregamento / transforms](http://requirejs.org/docs/plugins.html)
+* [CommonJS style carregamento e exportação](http://requirejs.org/docs/commonjs.html)
+* [Configuração avançada](http://requirejs.org/docs/api.html#config)
+* [Shim configuration (carregando módulos sem AMD)](http://requirejs.org/docs/api.html#config-shim)
+* [Carregando e otimizando CSS com require.js](http://requirejs.org/docs/optimization.html#onecss)
+* [Usando almond.js para builds](https://github.com/jrburke/almond)
+
+### Outras leituras:
+
+* [Especificação oficial](https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [Por quê AMD?](http://requirejs.org/docs/whyamd.html)
+* [Universal Module Definition](https://github.com/umdjs/umd)
+
+### Implementações:
+
+* [require.js](http://requirejs.org)
+* [dojo toolkit](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [cujo.js](http://cujojs.com/)
+* [curl.js](https://github.com/cujojs/curl)
+* [lsjs](https://github.com/zazl/lsjs)
+* [mmd](https://github.com/alexlawrence/mmd)
diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
new file mode 100644
index 00000000..75b3c268
--- /dev/null
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -0,0 +1,129 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+translators:
+    - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: asciidoc-pt.md
+---
+
+AsciiDoc é uma linguagem de marcação similar ao Markdown e pode ser
+usada para qualquer coisa, de livros até blogs. Criada em 2002 por
+Stuart Rackham, a linguagem é simples mas facilita muito a customização.
+
+Cabeçalho do documento
+
+Cabeçalhos são opcionais e não podem conter linhas em branco.
+Devem estar separados do conteúdo com pelo menos uma linha em branco.
+
+Apenas Título
+
+```
+= Título do documento
+
+Primeira sentência do documento.
+```
+
+Título e Autor
+
+```
+= Título do Documento
+Nome Sobrenome <nome.sobrenome@learnxinyminutes.com>
+
+Início do documento.
+```
+
+Múltiplos Autores
+
+```
+= Título do Documento
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Início do documento com múltiplos autores.
+```
+
+Linhas de revisão (requer uma linha de autor)
+
+```
+= Documento V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+Este artigo sobre batatas será divertido.
+```
+
+Parágrafos
+
+```
+Você não precisa fazer nada especial para criar um parágrafo.
+
+Adicione uma linha em branco entre os parágrafos para separá-los.
+
+Para criar uma linha em branco adicione um +
+e você terá uma quebra de linha!
+```
+
+Formatando texto
+
+```
+_underscore é itálico_
+*asterisco é negrito*
+*_você pode combinar efeitos_*
+`use crase para fonte monoespaçada`
+`*fonte monoespaçada em negrito*`
+```
+
+Título de seções
+
+```
+= Nível 0 (Use apenas no cabeçalho do documento)
+
+== Nível 1 <h2>
+
+=== Nível 2 <h3>
+
+==== Nível 3 <h4>
+
+===== Nível 4 <h5>
+
+====== Nível 5 <h6>
+
+======= Nível 6  <h7>
+
+```
+
+Listas
+
+Para criar uma lista com marcadores use asteriscos.
+
+```
+* foo
+* bar
+* baz
+```
+
+Para criar uma lista númerada use pontos.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+Você pode criar listas dentro de listas adicionando
+asteriscos ou pontos extras em até 5 níveis.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
new file mode 100644
index 00000000..2e299d09
--- /dev/null
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -0,0 +1,159 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+    - ["João Farias", "https://github.com/JoaoGFarias"]
+lang: pt-br
+---
+
+# Notação Assintótica
+
+## O que é?
+
+Notação Assintótica é uma linguagem que nos permite analisar o tempo de execução
+ de um algoritmo através da indentificação de seu comportamento com o
+ crescimento da entrada oferecida. Isso também é conhecido como taxa de
+ crescimento do algoritmo. O algoritmo de repente torna-se lento quando o
+ tamanho da entrada cresce? O algoritmo mantém, em geral, seu tempo de execução
+ rápido mesmo com aumento da entrada? Notação Assintótica nos dá a habilidade de
+ responder estas questões.
+
+## Quais são as alternativas para responder a estas questões?
+
+Um modo seria contar o número de operações primitivas com diferentes tamanhos de
+ entrada. Apesar desta ser uma solução válida, o trabalho que ela requer, mesmo para algoritmos simples, não a justifica.
+
+ Outro modo é fisicamente medir a quantidade de tempo que um algoritmo requer
+ para terminar com diferentes tamanhos de entrada. Entretanto, a precisão e
+ relatividade (tempo obtido seria relativo apenas à máquina onde ocorreu a
+   execução) deste método está limitado a variáveis de ambiente, como hardware,
+   poder de processamento, etc.
+
+## Tipos de Notação Assintótica
+
+Na primeira seção desse documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo
+ a medida que o tamanho da entrada cresce. Imaginemos um algoritmo como uma função
+ *f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então,
+ para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução
+ *f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução
+, a coordernada X representa o tamanho da entrada e os pontos representao o tempo
+de execução para dado tamanho de entrada.
+
+Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias
+maneiras. Você pode representar um algoritmo nas formas de Melhor Caso, Pior Caso
+ou Caso Médio.
+A maneira mais comum de analisar um algoritmo é pelo Pior Caso. Você tipicamente
+não avalia o melhor caso, porque essas condições não são atingidas com frequência.
+Um bom exemplo disto seria em algoritmos de ordenação; especificamente, na adição
+de elementos à árvores. O melhor caso na maioria de algoritmos pode ser de apenas
+uma operação. Entretanto, na maioria dos casos, o elemento a ser adicionado terá
+que percorrer a árvore de forma apropriada, o que pode causar a analise de um
+ramo inteiro.
+Este é o pior caso, e isto é o que você está se preparando.
+
+### Tipos de funções, limites e simplificação
+
+```
+Função Logarítmica - log n
+Função Linear - an + b
+Função Quadrática - an^2 + bn + c
+Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde *z* é uma constante
+Função Exponencial -  a^n, onde a é alguma constante
+```
+Estas são as funções básicas de crescimento usadas em várias notações. A lista
+ começa com a de crescimento mais lento (logarítima, a de execução mais rápida)
+e segue para a de crescimento mais rápido (exponencial, de execução mais lenta).
+Repare que enquando *n*, a entrada, cresce, cada uma dessas funções cresce mais
+rápido que quadrático, polinimial e exponencial, comparadas com logaritma e linear.
+
+Uma nota extremamente importante para notações é tentar usar os termos mais simples.
+Isto significa descartar constantes e termos de ordem mais baixa, pois quando o
+tamanho da entrada cresce para o infinito (limites matemáticos), os termos de ordem
+mais baixa e constantes tornam-se irrelevantes. Por exemplo, se você tiver uma
+constante muito grande, 2^9001, a simplificação não afeterá sua notação.
+
+Já que queremos as formas mais simples, mudemos nossa tabela um pouco...
+
+```
+Função Logarítmica - log n
+Função Linear - n
+Função Quadrática - n^2
+Função Polinomial - n^z, onde *z* é uma constante
+Função Exponencial - a^n, onde *a* é uma constante
+```
+
+### Big-O
+
+Big-O, também escrita como O, é uma Notação Assintótica para o pior caso. Digamos
+*f(n)* seja o tempo de exeução de um algoritmo e *g(n)) um tempo de complexidade
+arbritário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
+quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada
+n (n > 0).
+
+
+*Exemplo 1*
+
+```
+f(n) = 3log n + 100
+g(n) = log n
+```
+
+`f(n)` é O(g(n))?
+
+`3 log n + 100` é  O(log n)?
+
+Vejamos a definição de Big-O:
+
+```
+3log n + 100 <= c * log n
+```
+
+Há alguma constante c que satisfaça a definição para todo n?
+
+```
+3log n + 100 <= 150 * log n, n > 2 (Indefinido em n = 1)
+```
+
+Sim! A definição de Big-I for atentida, portante `f(n)` é `O(g(n))`.
+
+*Exemplo 2*
+
+```
+f(n) = 3*n^2
+g(n) = n
+```
+
+`f(n)` é O(g(n))?
+
+`3 * n^2` é O(n)?
+Vejamos a definição de Big-O:
+
+```
+3 * n^2 <= c * n
+```
+
+Há alguma constante c que satisfaça a definição para todo n?
+
+Não, não há. `f(n)` não é O(g(n)).
+
+### Big-Omega
+Big-Omega, também escrita como Ω, é uma Notação Assintótica para o melhor caso.
+
+`f(n)`é Ω(g(n)), se para qualquer constante real c (c > 0), `f(n)` é >= `c g(n)` para todo tamanho de entrada n (n > 0).
+
+Sinta-se livre para adicionar mais exemplos. Big-O é a notação primária usada para medir complexidade de algoritmos.
+
+### Notas Finais
+É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algoritms & Data Structures' virá; teremos um documento sobre analisar código em breve.
+
+## Livros
+
+* [Algorithms](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Algorithm Design](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Artigos Online
+
+* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf)
+* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
diff --git a/pt-br/asymptoticnotation-pt.html.markdown b/pt-br/asymptoticnotation-pt.html.markdown
new file mode 100644
index 00000000..c5299a11
--- /dev/null
+++ b/pt-br/asymptoticnotation-pt.html.markdown
@@ -0,0 +1,161 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+translators: 
+    - ["Carolina Knoll", "http://github.com/carolinaknoll"]
+lang: pt-br
+---
+
+# Aprenda X em Y minutos
+## Onde X=Notação Assintótica
+
+# Notações Assintóticas
+## O que são?
+
+Notações assintóticas são notações matemáticas que nos permitem analisar tempo de execução  
+de um algoritmo, identificando o seu comportamento de acordo como o tamanho de entrada para  
+o algoritmo aumenta. Também é conhecido como taxa de "crescimento" de um algoritmo. O algoritmo  
+simplesmente se torna incrivelmente lento conforme o seu tamanho aumenta? Será que pode-se na  
+maior parte manter o seu tempo de execução rápido mesmo quando o tamanho de entrada aumenta?  
+A notação assintótica nos dá a capacidade de responder a essas perguntas. 
+
+## Além desta, existem outras alternativas para responder a essas perguntas?
+
+Uma forma seria a de contar o número de operações primitivas em diferentes tamanhos de entrada. 
+Embora esta seja uma solução válida, a quantidade de trabalho necessário, mesmo para algoritmos 
+simples, não justifica a sua utilização.
+
+Outra maneira é a de medir fisicamente a quantidade de tempo que leva para se executar um algoritmo 
+de diferentes tamanhos. No entanto, a precisão e a relatividade (já que tempos obtidos só teriam 
+relação à máquina em que eles foram testados) deste método estão ligadas a variáveis ambientais, 
+tais como especificações de hardware, poder de processamento, etc.
+
+## Tipos de Notação Assintótica
+
+Na primeira seção deste documento nós descrevemos como uma notação assintótica identifica o comportamento  
+de um algoritmo como as alterações de tamanho de entrada (input). Imaginemos um algoritmo como uma função  
+f, n como o tamanho da entrada, e f (n) sendo o tempo de execução. Assim, para um determinado algoritmo f,  
+com tamanho de entrada n você obtenha algum tempo de execução resultante f (n). Isto resulta num gráfico,  
+em que o eixo Y representa o tempo de execução, o eixo X é o tamanho da entrada, e os pontos marcados são  
+os resultantes da quantidade de tempo para um dado tamanho de entrada.
+
+Pode-se rotular uma função ou algoritmo com uma notação assintótica de diversas maneiras diferentes.  
+Dentre seus exemplos, está descrever um algoritmo pelo seu melhor caso, pior caso, ou caso equivalente.  
+O mais comum é o de analisar um algoritmo pelo seu pior caso. Isso porque você normalmente não avaliaria  
+pelo melhor caso, já que essas condições não são as que você está planejando. Um bom exemplo disto é o de  
+algoritmos de ordenação; especificamente, a adição de elementos a uma estrutura de tipo árvore. O melhor  
+caso para a maioria dos algoritmos pode ser tão simples como uma única operação. No entanto, na maioria   
+dos casos, o elemento que você está adicionando terá de ser ordenado de forma adequada através da árvore,  
+o que poderia significar a análise de um ramo inteiro. Este é o pior caso, e é por ele que precisamos seguir.  
+
+### Tipos de funções, limites, e simplificação
+
+```
+Função Logaritmica - log n  
+Função Linear - an + b  
+Função Quadrática - an^2 + bn + c  
+Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde z é uma constante  
+Função Exponencial - a^n, onde a é uma constante  
+```
+
+Estas são algumas classificações básicas de crescimento de função usados em várias notações. A lista  
+começa com a função crescimento mais lento (logarítmica, com tempo de execução mais rápido) e vai até  
+a mais rápida (exponencial, com tempo de execução mais lento). Observe que 'n', ou nossa entrada,  
+cresce em cada uma dessas funções, e o resultado claramente aumenta muito mais rapidamente em função  
+quadrática, polinomial e exponencial, em comparação com a logarítmica e a linear.
+
+Uma observação de boa importância é que, para as notações a serem discutidas, deve-se fazer o melhor  
+para utilizar termos mais simples. Isto significa desrespeitar constantes, e simplificar termos de  
+ordem, porque, como o tamanho da entrada (ou n no nosso f (n) exemplo) aumenta infinitamente (limites  
+matemáticos), os termos em ordens mais baixas e constantes são de pouca ou nenhuma importância. Dito  
+isto, se você possui constantes com valor 2^9001, ou alguma outra quantidade ridícula, inimaginável,  
+perceberá que a simplificação distorcerá a precisão de sua notação.
+
+Já que nós queremos a forma mais simples, vamos modificar nossas funções um pouco.
+
+```
+Logaritmica - log n  
+Linear - n  
+Quadrática - n^2  
+Polinomial - n^z, onde z é uma constante  
+Exponencial - a^n, onde a é uma constante
+```
+
+### O Grande-O
+
+Grande-O, geralmente escrita como O, é uma Notação Assintótica para o pior caso para uma dada função. Digamos  
+que `f(n)` é o tempo de execução de seu algoritmo, e `g(n)` é uma complexidade de tempo arbitrário que você está  
+tentando se relacionar com o seu algoritmo. `f(n)` será O(g(n)), se, por qualquer constante real c (c > 0),  
+`f(n)` <= `c g(n)` para cada tamanho de entrada n (n > 0).  
+
+*Exemplo 1*
+
+```
+f(n) = 3log n + 100  
+g(n) = log n
+```
+
+É `f(n)` um O(g(n))?  
+É 3 `log n + 100` igual a O(log n)?  
+Vamos checar na definição de Grande-O.  
+
+```
+3log n + 100 <= c * log n
+```
+
+Existe alguma constante c que satisfaça isso para todo n?
+
+```
+3log n + 100 <= 150 * log n, n > 2 (indefinido em n = 1)
+```
+
+Sim! A definição de Grande-O foi satisfeita. Sendo assim, `f(n)` é O(g(n)).
+
+*Exemplo 2*
+
+```
+f(n) = 3 * n^2
+g(n) = n
+```
+
+É `f(n)` um O(g(n))? 
+É `3 * n^2` um O(n)? 
+Vamos ver na definição de Grande-O.
+
+```
+3 * n^2 <= c * n
+```
+
+Existe alguma constante que satisfaça isso para todo n? 
+Não, não existe. `f(n)` NÃO É O(g(n)).
+
+### Grande-Omega
+
+Grande-Omega, comumente escrito como Ω, é uma Notação Assintótica para o melhor caso, ou  
+uma taxa de crescimento padrão para uma determinada função.
+
+`f(n)` é Ω(g(n)), se, por qualquer constante c real (c > 0), `f(n)` é >= `c g(n)` para cada  
+tamanho de entrada n (n > 0).
+
+Sinta-se livre para pesquisar recursos adicionais e obter mais exemplos sobre este assunto!  
+Grande-O é a notação primária utilizada para tempo de execução de algoritmos, de modo geral.  
+
+### Notas de Finalização
+
+É complicado exibir este tipo de assunto de forma tão curta, então é definitivamente recomendado  
+pesquisar além dos livros e recursos on-line listados. Eles serão capazes de analisar o assunto com  
+uma profundidade muito maior, além de ter definições e exemplos. Mais sobre onde X="Algoritmos e  
+Estruturas de Dados" está a caminho: Haverá conteúdo focado na análise de exemplos de códigos reais  
+em breve. 
+
+## Livros
+
+* [Algorithms] (http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)  
+* [Algorithm Design] (http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Recursos Online
+
+* [MIT] (http://web.mit.edu/16.070/www/lecture/big_o.pdf)  
+* [KhanAcademy] (https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
new file mode 100644
index 00000000..ae18435a
--- /dev/null
+++ b/pt-br/bash-pt.html.markdown
@@ -0,0 +1,282 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+translators:
+    - ["Davidson Mizael", "https://github.com/davidsonmizael"]
+filename: LearnBash-pt_br.sh
+lang: pt-br
+---
+
+Tutorial de shell em português
+
+Bash é o nome do shell do Unix, que também é distribuido como shell do sistema 
+operacional GNU e como shell padrão para Linux e Mac OS X. Praticamente todos 
+os exemplos abaixo podem fazer parte de um shell script e pode ser executados
+diretamente no shell.
+
+[Leia mais sobre](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# A primeira linha do script é o shebang, que conta para o sistema como executar
+# o script: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Como você já deve ter percebido, comentários começam com #. 
+# Shebang também é um comentário.
+
+# Exemplo simples de hello world:
+echo Hello World!
+
+# Cada comando começa com uma nova linha, ou após um ponto virgula:
+echo 'Essa é a primeira linha'; echo 'Essa é a segunda linha'
+
+# A declaração de variáveis é mais ou menos assim
+Variavel="Alguma string"
+
+# Mas não assim:
+Variavel = "Alguma string"
+# Bash interpretará Variavel como um comando e tentará executar e lhe retornar
+# um erro porque o comando não pode ser encontrado.
+
+# Ou assim:
+Variavel= 'Alguma string'
+# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornar
+# um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel=' 
+# é vista com uma declaração de variável valida apenas para o escopo do comando 'Uma string').
+
+# Usando a variável:
+echo $Variavel
+echo "$Variavel"
+echo '$Variavel'
+# Quando você usa a variável em si — declarando valor, exportando, etc — você escreve
+# seu nome sem o $. Se você quer usar o valor da variável você deve usar o $.
+# Note que ' (aspas simples) não expandirão as variáveis!
+
+# Substituição de strings em variáveis
+echo ${Variavel/Alguma/Uma}
+# Isso substituirá a primeira ocorrência de "Alguma" por "Uma"
+
+# Substring de uma variável
+Tamanho=7
+echo ${Variavel:0:Tamanho}
+# Isso retornará apenas os 7 primeiros caractéres da variável
+
+# Valor padrão de uma variável
+echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
+# Isso funciona para nulo (Foo=) e (Foo=""); zero (Foo=0) retorna 0.
+# Note que isso apenas retornar o valor padrão e não mudar o valor da variável.
+
+# Variáveis internas
+# Tem algumas variáveis internas bem uteis, como
+echo "O ultimo retorno do programa: $?"
+echo "PID do script: $$"
+echo "Numero de argumentos passados para o script $#"
+echo "Todos os argumentos passados para o script $@"
+echo "Os argumentos do script em variáveis diferentes: $1, $2..."
+
+# Lendo o valor do input:
+echo "Qual o seu nome?"
+read Nome # Note que nós não precisamos declarar a variável
+echo Ola, $Nome
+
+# Nós temos a estrutura if normal:
+# use 'man test' para mais infomações para as condicionais
+if [ $Nome -ne $USER ]
+then
+	echo "Seu nome não é o seu username"
+else
+	echo "Seu nome é seu username"
+fi
+
+# Tem também execução condicional
+echo "Sempre executado" || echo "Somente executado se o primeiro falhar"
+echo "Sempre executado" && "Só executado se o primeiro NÃO falhar"
+
+# Para usar && e || com o if, você precisa multiplicar os pares de colchetes
+if [ $Nome == "Estevao"] && [ $Idade -eq 15]
+then
+	echo "Isso vai rodar se $Nome é igual Estevao E $Idade é 15."
+fi
+
+fi [ $Nome == "Daniela" ] || [ $Nome = "Jose" ] 
+then
+	echo "Isso vai rodar se $Nome é Daniela ou Jose."
+fi
+
+# Expressões são denotadas com o seguinte formato
+echo $(( 10 + 5))
+
+# Diferentemente das outras linguagens de programação, bash é um shell, então ele 
+# funciona no diretório atual. Você pode listar os arquivos e diretórios no diretório
+# atual com o comando ls:
+ls
+
+#Esse comando tem opções que controlam sua execução
+ls -l # Lista todo arquivo e diretorio em linhas separadas
+
+# Os resultados do comando anterior pode ser passado para outro comando como input.
+# O comando grep filtra o input com o padrão passado. É assim que listamos apenas
+# os arquivos .txt no diretório atual:
+ls -l | grep "\.txt"
+
+# Você pode redirecionar o comando de input e output (stdin, stdout e stderr).
+# Lê o stdin até ^EOF$ e sobrescreve hello.py com as linhas entre "EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ imprt print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("stderr", file=sys.stderr)
+for line in sys.stdin:
+	print(line, file=sys.stdout)
+EOF
+
+# Rode hello.py com várias instruções stdin, stdout e stderr:
+python hello.py < "input.in"
+python hello.py > "ouput.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# O erro no output sobrescreverá o arquivo se existir,
+# se ao invés disso você quiser complementar, use ">>":
+python hello.py >> "output.out" 2>> "error.err"
+
+# Sobrescreve output.out, complemente para error.err e conta as linhas
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+#Roda um comando e imprime o desencriptador (e.g. /dev/fd/123)
+# veja: man fd
+echo <(echo "#helloworld")
+
+# Sobrescreve ouput.out com "#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out > /dev/null
+
+# Limpa os arquivos temporários detalhando quais foram deletados (use '-i' para confirmar exclusão)
+rm -v output.out error.err output-and-error.log
+
+# Comando podem ser substituídos por outros comandos usando $( ):
+# O comando a seguir mostra o número de arquivos e diretórios no diretorio atual
+echo "Existem $(ls | wc -l) itens aqui."
+
+# O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se 
+# preferência ao uso do $( )
+echo "Existem `ls | wc -l` itens aqui."
+
+# Bash usa o comando case que funciona de uma maneira similar ao switch de Java e C++:
+case "$Variavel" in
+	# Lista de parametros para condições que você quer encontrar
+	0) echo "Isso é um Zero.";;
+	1) echo "Isso é um Um.";;
+	*) echo "Isso não é null.";;
+esac
+
+# loops for iteragem para quantos argumentos passados:
+# O conteudo de $Variavel é exibido três vezes.
+for Variavel in {1..3}
+do
+	echo "$Variavel"
+done
+
+# Ou use o loop da "maneira tradicional":
+for ((a=1; a <= 3; a++))
+do
+	echo $a
+done
+
+# Eles também podem ser usados em arquivos...
+# Isso irá rodar o comando 'cat' em arquivo1 e arquivo2
+for Variavel in arquivo1 arquivo2
+do
+	cat "$Variavel"
+done
+
+# ...ou o output de um comando
+# Isso irá usar cat no output do ls.
+for Output in $(ls)
+do
+	cat "$Output"
+done
+
+# loop while:
+while [ true ]
+do
+	echo "corpo do loop aqui..."
+	break
+done
+
+# Você também pode usar funções
+# Definição:
+function foo() {
+	echo "Argumentos funcionam bem assim como os dos scripts: $@"
+	echo "E: $1 $2..."
+	echo "Isso é uma função"
+	return 0
+}
+
+# ou simplesmente
+bar () {
+	echo "Outro jeito de declarar funções!"
+	return 0
+}
+
+# Chamando sua função
+foo "Meu nome é" $Nome
+
+# Existe um monte de comandos úteis que você deveria aprender:
+# exibe as 10 ultimas linhas de arquivo.txt
+tail -n 10 arquivo.txt
+# exibe as primeiras 10 linhas de arquivo.txt
+head -n 10 arquivo.txt
+# ordena as linhas de arquivo.txt
+sort arquivo.txt
+# reporta ou omite as linhas repetidas, com -d você as reporta
+uniq -d arquivo.txt
+# exibe apenas a primeira coluna após o caráctere ','
+cut -d ',' -f 1 arquivo.txt
+# substitui todas as ocorrencias de 'okay' por 'legal' em arquivo.txt (é compativel com regex)
+sed -i 's/okay/legal/g' file.txt
+# exibe para o stdout todas as linhas do arquivo.txt que encaixam com o regex
+# O exemplo exibe linhas que começam com "foo" e terminam com "bar"
+grep "^foo.*bar$" arquivo.txt
+# passe a opção "-c" para ao invês de imprimir o numero da linha que bate com o regex
+grep -c "^foo.*bar$" arquivo.txt
+# se você quer literalmente procurar por uma string,
+# e não pelo regex, use fgrep (ou grep -F)
+fgrep "^foo.*bar$" arquivo.txt
+
+
+# Leia a documentação interna do shell Bash com o comando interno 'help':
+help
+help help
+help for 
+help return
+help source
+help .
+
+# Leia a página principal da documentação com man
+apropos bash
+man 1 bash
+man bash
+
+# Leia a documentação de informação com info (? para ajuda)
+apropos info | grep '^info.*('
+man info
+info info 
+info 5 info 
+
+#Leia a documentação informativa do Bash:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash 
+```
diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/bf.html.markdown
index 9e4b458d..d6d7c6e9 100644
--- a/pt-br/brainfuck-pt.html.markdown
+++ b/pt-br/bf.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/pt-br/binary-search-pt.html.markdown b/pt-br/binary-search-pt.html.markdown
new file mode 100644
index 00000000..d3060506
--- /dev/null
+++ b/pt-br/binary-search-pt.html.markdown
@@ -0,0 +1,77 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+    - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+    - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+---
+
+# Busca Binária
+
+## Por Que Busca Binária?
+
+Operações de busca são um dos principais problemas na Ciência da Computação. 
+Atualmente existem mais de 1 trilhão de buscas por ano, e nós precisamos de 
+algoritmos que possam realizá-las rapidamente. Busca binária é um dos algoritmos 
+fundamentais em ciência da computação. A fim de explorá-la, iremos primeiro 
+construir um conhecimento teórico, e então utilizá-lo para implementar o 
+algoritmo apropriadamente.
+
+## Introdução
+
+Uma abordagem simples para implementar uma busca é realizar uma busca linear, 
+mas algoritmos nessa abordagem levam muito tempo, o qual cresce linearmente de 
+acordo com a quantidade ou número de dados. Por exemplo, iniciando do elemento 
+mais a esquerda de arr[] e um a um comparar x com cada elemento de arr[], se x 
+coincide com um elemento, retornar seu índice. Se x não coincide com nenhum dos 
+elementos, retornar -1.
+
+```
+Busca Linear: O (n)               Tempo Linear
+
+Busca Binária: O ( log(n) )		   Tempo Logarítmico
+
+```
+```
+def busca(arr, x):
+ 
+    for i in range(len(arr)):
+ 
+        if arr[i] == x:
+            return i
+ 
+    return -1
+
+```
+## Algoritmo de Busca Binária
+
+O pré-requisito básico para que uma busca binária funcione é que os dados que se
+desejam buscar devem estar ordenados (em qualquer ordem).
+
+### Pseudocódigo
+
+```
+A ideia da busca binária é usar a informação de que o array está ordenado e 
+reduzir a complexidade de tempo para O(Log n). Nós basicamente ignoramos metade 
+dos elementos após uma comparação.
+
+1) Compare x com o elemento do meio.
+2) Se x coincide com o elemento do meio, retorne o índice do meio.
+3) Senão Se x é maior que o elemento do meio, então x só pode estar no lado 
+direito do elemento do meio. Portanto nós pulamos para a metade direita.
+4) Senão (x é menor) pulamos para a metade esquerda.
+
+Essa é a ideia da implementação recursiva da busca binária.
+
+```
+
+### Considerações Finais
+
+Existem outras formas de busca binária que são muito úteis.
+
+## Recursos Online
+
+* [GeeksforGeeks](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)
+* [Topcoder Tutorial](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/)
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 61e267f5..fd392b9e 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -19,9 +19,9 @@ foi concebida para
 - suportar programação genérica
 
 Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais
-recentes, C++ é amplamente utilizado porque compila para instruções nativas que 
-podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os 
-genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade 
+recentes, C++ é amplamente utilizado porque compila para instruções nativas que
+podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
+genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
 faz C++ uma das linguagens de programação mais utilizadas.
 
 ```c++
@@ -33,7 +33,7 @@ faz C++ uma das linguagens de programação mais utilizadas.
 // declarações de variáveis, tipos primitivos, e funções. No entanto, C++ varia
 // em algumas das seguintes maneiras:
 
-// A função main() em C++ deve retornar um int, embora void main() é aceita 
+// A função main() em C++ deve retornar um int, embora void main() é aceita
 // pela maioria dos compiladores (gcc, bumbum, etc.)
 // Este valor serve como o status de saída do programa.
 // Veja http://en.wikipedia.org/wiki/Exit_status para mais informações.
@@ -105,7 +105,7 @@ int main()
 // Parâmetros padrão de função
 /////////////////////////////
 
-// Você pode fornecer argumentos padrões para uma função se eles não são 
+// Você pode fornecer argumentos padrões para uma função se eles não são
 // fornecidos pelo chamador.
 
 void doSomethingWithInts(int a = 1, int b = 4)
@@ -157,7 +157,7 @@ void foo()
 
 int main()
 {
-    // Assuma que tudo é do namespace "Second" a menos que especificado de 
+    // Assuma que tudo é do namespace "Second" a menos que especificado de
     // outra forma.
     using namespace Second;
 
@@ -222,7 +222,7 @@ cout << myString; // "Hello Dog"
 
 // Além de indicadores como os de C, C++ têm _referências_. Esses são tipos de
 // ponteiro que não pode ser reatribuída uma vez definidos e não pode ser nulo.
-// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário 
+// Eles também têm a mesma sintaxe que a própria variável: Não * é necessário
 // para _dereferencing_ e & (endereço de) não é usado para atribuição.
 
 using namespace std;
@@ -258,7 +258,7 @@ class Dog {
     std::string name;
     int weight;
 
-// Todos os membros a seguir este são públicos até que "private:" ou 
+// Todos os membros a seguir este são públicos até que "private:" ou
 // "protected:" é encontrado.
 public:
 
@@ -274,13 +274,13 @@ public:
 
     void setWeight(int dogsWeight);
 
-    // Funções que não modificam o estado do objecto devem ser marcadas como 
+    // Funções que não modificam o estado do objecto devem ser marcadas como
     // const. Isso permite que você chamá-los se for dada uma referência const
     // para o objeto. Além disso, observe as funções devem ser explicitamente
-    // declarados como _virtual_, a fim de ser substituídas em classes 
-    // derivadas. As funções não são virtuais por padrão por razões de 
+    // declarados como _virtual_, a fim de ser substituídas em classes
+    // derivadas. As funções não são virtuais por padrão por razões de
     // performance.
-    
+
     virtual void print() const;
 
     // As funções também podem ser definidas no interior do corpo da classe.
@@ -291,7 +291,7 @@ public:
     // Estes são chamados quando um objeto é excluído ou fica fora do escopo.
     // Isto permite paradigmas poderosos, como RAII
     // (veja abaixo)
-    // Destruidores devem ser virtual para permitir que as classes de ser 
+    // Destruidores devem ser virtual para permitir que as classes de ser
     // derivada desta.
     virtual ~Dog();
 
@@ -323,7 +323,7 @@ void Dog::print() const
 
 void Dog::~Dog()
 {
-    cout << "Goodbye " << name << "\n";
+    std::cout << "Goodbye " << name << "\n";
 }
 
 int main() {
@@ -343,8 +343,8 @@ class OwnedDog : public Dog {
 
     // Substituir o comportamento da função de impressão de todas OwnedDogs.
     // Ver http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
-    // Para uma introdução mais geral, se você não estiver familiarizado com o 
-    // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se 
+    // Para uma introdução mais geral, se você não estiver familiarizado com o
+    // polimorfismo subtipo. A palavra-chave override é opcional, mas torna-se
     // na verdade você está substituindo o método em uma classe base.
     void print() const override;
 
@@ -371,8 +371,8 @@ void OwnedDog::print() const
 // Inicialização e Sobrecarga de Operadores
 //////////////////////////////////////////
 
-// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como 
-// +, -, *, /, etc. Isto é feito através da definição de uma função que é 
+// Em C ++, você pode sobrecarregar o comportamento dos operadores, tais como
+// +, -, *, /, etc. Isto é feito através da definição de uma função que é
 // chamado sempre que o operador é usado.
 
 #include <iostream>
@@ -438,7 +438,7 @@ int main () {
 // mas qualquer tipo pode ser jogado como uma exceção
 #include <exception>
 
-// Todas as exceções lançadas dentro do bloco try pode ser capturado por 
+// Todas as exceções lançadas dentro do bloco try pode ser capturado por
 // manipuladores de captura subseqüentes
 try {
     // Não aloca exceções no heap usando _new_.
@@ -460,7 +460,7 @@ catch (const std::exception& ex)
 ///////
 
 // RAII significa alocação de recursos é de inicialização.
-// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o 
+// Muitas vezes, é considerado o paradigma mais poderoso em C++, e é o
 // conceito simples que um construtor para um objeto adquire recursos daquele
 // objeto e o destruidor liberá-los.
 
@@ -479,18 +479,18 @@ void doSomethingWithAFile(const char* filename)
 }
 
 // Infelizmente, as coisas são levemente complicadas para tratamento de erros.
-// Suponha que fopen pode falhar, e que doSomethingWithTheFile e 
-// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As 
-// exceções são a forma preferida de lidar com o fracasso, mas alguns 
-// programadores, especialmente aqueles com um conhecimento em C, discordam 
-// sobre a utilidade de exceções). Agora temos que verificar cada chamada para 
+// Suponha que fopen pode falhar, e que doSomethingWithTheFile e
+// doSomethingElseWithIt retornam códigos de erro se eles falharem. (As
+// exceções são a forma preferida de lidar com o fracasso, mas alguns
+// programadores, especialmente aqueles com um conhecimento em C, discordam
+// sobre a utilidade de exceções). Agora temos que verificar cada chamada para
 // o fracasso e fechar o identificador de arquivo se ocorreu um problema.
 
 bool doSomethingWithAFile(const char* filename)
 {
     FILE* fh = fopen(filename, "r"); // Abra o arquivo em modo de leitura
     if (fh == nullptr) // O ponteiro retornado é nulo em caso de falha.
-        reuturn false; // Relate o fracasso para o chamador.
+        return false; // Relate o fracasso para o chamador.
 
     // Suponha cada função retorne false, se falhar
     if (!doSomethingWithTheFile(fh)) {
@@ -511,7 +511,7 @@ bool doSomethingWithAFile(const char* filename)
 {
     FILE* fh = fopen(filename, "r");
     if (fh == nullptr)
-        reuturn false;
+        return false;
 
     if (!doSomethingWithTheFile(fh))
         goto failure;
@@ -581,10 +581,35 @@ void doSomethingWithAFile(const std::string& filename)
 //   vetor (i.e. array de autodimensionamento), mapas hash, e assim por diante
 //   tudo é automaticamente destruído quando eles saem de escopo
 // - Mutex usa lock_guard e unique_lock
+
+
+/////////////////////
+// Templates
+/////////////////////
+
+// Templates em C++ são utilizados para programação genérica, ou seja,
+// utilizar um tipo de dado genérico onde possa suportar qualquer entrada.
+// Por exemplo, invés de criar uma função que apenas some inteiros, você
+// poderá fazer uma função que soma double, float e inteiros em uma única
+// definição para reutilizar código.
+
+// Definimos um função que utiliza um "typename"
+template<class T>
+T soma(T a, T b) {
+  return A + B;
+}
+
+// E agora para executá-la
+int i=5, j=6, k;
+double f=2.0, g=0.5, h;
+k=sum<int>(i,j);
+h=sum<double>(f,g);
+
+// Deste modo, não precisamos fazer overload nas funções! (:
 ```
 Leitura Adicional:
 
-Uma referência atualizada da linguagem pode ser encontrada em 
+Uma referência atualizada da linguagem pode ser encontrada em
 <http://cppreference.com/w/cpp>
 
 Uma fonte adicional pode ser encontrada em <http://cplusplus.com>
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 2c274f12..0af553c8 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -28,7 +28,7 @@ Funcionam no C89 também.
 */
 
 // Constantes: #define <palavra-chave>
-#definie DAY_IN_YEAR 365
+#define DAY_IN_YEAR 365
 
 //enumerações também são modos de definir constantes.
 enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown
index dbc0c25c..d56840e0 100644
--- a/pt-br/clojure-macros-pt.html.markdown
+++ b/pt-br/clojure-macros-pt.html.markdown
@@ -142,6 +142,8 @@ Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo
 (inline-2 (1 + (3 / 2) - (1 / 2) + 1))
 ; -> 3 (Na verdade, 3N, desde que o numero ficou convertido em uma fração racional com /
 
+```
+
 ### Leitura adicional
 
 Escrevendo Macros de [Clojure para o Brave e True](http://www.braveclojure.com/)
diff --git a/pt-br/csharp.html.markdown b/pt-br/csharp.html.markdown
new file mode 100644
index 00000000..547f4817
--- /dev/null
+++ b/pt-br/csharp.html.markdown
@@ -0,0 +1,896 @@
+---
+language: c#
+filename: csharp-pt.cs
+contributors:
+    - ["Robson Alves", "http://robsonalves.net/"]    
+lang: pt-br
+---
+
+C# é uma linguagem elegante e altamente tipado orientada a objetos que permite aos desenvolvedores criarem uma variedade de aplicações seguras e robustas que são executadas no .NET Framework.
+
+[Read more here.](http://msdn.microsoft.com/pt-br/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Comentário de linha única começa com //
+/*
+Múltipas linhas é desta forma
+*/
+/// <summary>
+/// Esta é uma documentação comentário XML que pode ser usado para gerar externo
+/// documentação ou fornecer ajuda de contexto dentro de um IDE
+/// </summary>
+//public void MethodOrClassOrOtherWithParsableHelp() {}
+
+// Especificar qual namespace seu código irá usar
+// Os namespaces a seguir são padrões do .NET Framework Class Library 
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// Mas este aqui não é :
+using System.Data.Entity;
+// Para que consiga utiliza-lo, você precisa adicionar novas referências
+// Isso pode ser feito com o gerenciador de pacotes NuGet : `Install-Package EntityFramework`
+
+// Namespaces são escopos definidos para organizar o códgo em "pacotes" or "módulos"
+// Usando este código a partir de outra arquivo de origem: using Learning.CSharp;
+namespace Learning.CSharp
+{
+    // Cada .cs deve conter  uma classe com o mesmo nome do arquivo
+    // você está autorizado a contrariar isto, mas evite por sua sanidade.
+    public class AprenderCsharp
+    {
+        // Sintaxe Básica - Pule para as CARACTERÍSTICAS INTERESSANTES se você ja usou Java ou C++ antes.
+        public static void Syntax()
+        {
+            // Use Console.WriteLine para apresentar uma linha
+            Console.WriteLine("Hello World");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+            // Para apresentar sem incluir uma nova linha, use Console.Write
+            Console.Write("Hello ");
+            Console.Write("World");
+
+            ///////////////////////////////////////////////////
+            // Tpos e Variáveis
+            //
+            // Declare uma variável usando <tipo> <nome>
+            ///////////////////////////////////////////////////
+
+            // Sbyte - Signed 8-bit integer
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Unsigned 8-bit integer
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - 16-bit integer
+            // Signed - (-32,768 <= short <= 32,767)
+            // Unsigned - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Integer - 32-bit integer
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - 64-bit integer
+            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+            // Numbers default to being int or uint depending on size.
+            // L is used to denote that this variable value is of type long or ulong
+
+            // Double - Double-precision 64-bit IEEE 754 Floating Point
+            double fooDouble = 123.4; // Precision: 15-16 digits
+
+            // Float - Single-precision 32-bit IEEE 754 Floating Point
+            float fooFloat = 234.5f; // Precision: 7 digits
+            // f is used to denote that this variable value is of type float
+
+            // Decimal - a 128-bits data type, with more precision than other floating-point types,
+            // suited for financial and monetary calculations
+            decimal fooDecimal = 150.3m;
+
+            // Boolean - true & false
+            bool fooBoolean = true; // or false
+
+            // Char - A single 16-bit Unicode character
+            char fooChar = 'A';
+
+            // Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
+            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
+            string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
+            Console.WriteLine(fooString);
+
+            //  Você pode acessar todos os caracteres de string com um indexador: 
+            char charFromString = fooString[1]; // => 'e'
+            // Strings são imutáveis: você não pode fazer fooString[1] = 'X';
+
+            // Compare strings com sua atual cultura, ignorando maiúsculas e minúsculas
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // Formatando, baseado no sprintf
+            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Datas e formatações
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // Você pode juntar um string em mais de duas linhas com o símbolo @. Para escapar do " use ""
+            string bazString = @"Here's some stuff
+on a new line! ""Wow!"", the masses cried";
+
+            // Use const ou read-only para fazer uma variável imutável
+            // os valores da const são calculados durante o tempo de compilação
+            const int HoursWorkPerWeek = 9001;
+
+            ///////////////////////////////////////////////////
+            // Estrutura de Dados
+            ///////////////////////////////////////////////////
+
+            // Matrizes - zero indexado
+            // O tamanho do array pode ser decidido ainda na declaração
+            // O formato para declarar uma matriz é o seguinte: 
+            // <tipodado>[] <var nome> = new <tipodado>[<array tamanho>];
+            int[] intArray = new int[10];
+
+            // Outra forma de declarar & inicializar uma matriz
+            int[] y = { 9000, 1000, 1337 };
+
+            // Indexando uma matriz - Acessando um elemento
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+            // Matriz são alteráveis
+            intArray[1] = 1;
+
+            // Listas
+            // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis
+            // O formato de declarar uma lista é o seguinte:
+            // List<tipodado> <var nome> = new List<tipodado>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // inicializar
+            // O <> são para genéricos - Confira está interessante seção do material
+
+            // Lista não possuem valores padrão.
+            // Um valor deve ser adicionado antes e depois acessado pelo indexador
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+            // Outras estruturas de dados para conferir:
+            // Pilha/Fila
+            // Dicionário (uma implementação de map de hash)
+            // HashSet
+            // Read-only Coleção
+            // Tuple (.Net 4+)
+
+            ///////////////////////////////////////
+            // Operadores
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operators");
+
+            int i1 = 1, i2 = 2; // Forma curta para declarar diversas variáveis
+
+            // Aritmética é clara
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Modulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Comparações de operadores
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => falso
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => verdadeiro
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => verdadeiro
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => falso
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => verdadeiro
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => verdadeiro
+
+            // Operadores bit a bit (bitwise)
+            /*
+            ~       Unário bitwise complemento
+            <<      Signed left shift
+            >>      Signed right shift
+            &       Bitwise AND
+            ^       Bitwise exclusivo OR
+            |       Bitwise inclusivo OR
+            */
+
+            // Incrementações
+            int i = 0;
+            Console.WriteLine("\n->Inc/Dec-rementation");
+            Console.WriteLine(i++); //i = 1. Post-Incrementation
+            Console.WriteLine(++i); //i = 2. Pre-Incrementation
+            Console.WriteLine(i--); //i = 1. Post-Decrementation
+            Console.WriteLine(--i); //i = 0. Pre-Decrementation
+
+            ///////////////////////////////////////
+            // Estrutura de Controle
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Control Structures");
+
+            // Declaração if é como a linguagem C
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("I get printed");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("I don't");
+            }
+            else
+            {
+                Console.WriteLine("I also don't");
+            }
+
+            // Operador Ternário
+            // Um simples if/else pode ser escrito da seguinte forma
+            // <condição> ? <verdadeiro> : <falso>
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
+
+            // While loop
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                //Iterated 100 times, fooWhile 0->99
+                fooWhile++;
+            }
+
+            // Do While Loop
+            int fooDoWhile = 0;
+            do
+            {
+                // Inicia a interação 100 vezes, fooDoWhile 0->99
+                if (false)
+                    continue; // pule a intereção atual para apróxima
+
+                fooDoWhile++;
+
+                if (fooDoWhile == 50)
+                    break; // Interrompe o laço inteiro
+
+            } while (fooDoWhile < 100);
+
+            //estrutura de loop for  => for(<declaração para começar>; <condicional>; <passos>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                //Iterado 10 vezes, fooFor 0->9
+            }
+
+            // For Each Loop
+            // Estrutura do foreach  => foreach(<Tipo Iterador> <Nome do Iterador> in <enumerable>)
+            // O laço foreach  percorre sobre qualquer objeto que implementa IEnumerable ou IEnumerable<T>
+            // Toda a coleção de tipos  (Array, List, Dictionary...) no .Net framework
+            // implementa uma ou mais destas interfaces.
+            // (O ToCharArray() pode ser removido, por que uma string também implementa IEnumerable)
+            foreach (char character in "Hello World".ToCharArray())
+            {
+                //Iterated over all the characters in the string
+            }
+
+            // Switch Case
+            // Um switch funciona com os tipos de dados byte, short, char, e int.
+            // Isto também funcional com tipos enumeradors (discutidos em Tipos Enum),
+            // A classe String, and a few special classes that wrap
+            // tipos primitívos: Character, Byte, Short, and Integer.
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "January";
+                    break;
+                case 2:
+                    monthString = "February";
+                    break;
+                case 3:
+                    monthString = "March";
+                    break;
+                // You can assign more than one case to an action
+                // But you can't add an action without a break before another case
+                // (if you want to do this, you would have to explicitly add a goto case x
+                case 6:
+                case 7:
+                case 8:
+                    monthString = "Summer time!!";
+                    break;
+                default:
+                    monthString = "Some other month";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Converting Data Types And Typecasting
+            ///////////////////////////////////////
+
+            // Converting data
+
+            // Convert String To Integer
+            // this will throw a FormatException on failure
+            int.Parse("123");//returns an integer version of "123"
+
+            // try parse will default to type default on failure
+            // in this case: 0
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // Function is boolean
+                Console.WriteLine(tryInt);       // 123
+
+            // Convert Integer To String
+            // Convert class has a number of methods to facilitate conversions
+            Convert.ToString(123);
+            // or
+            tryInt.ToString();
+
+            // Casting
+            // Cast decimal 15 to a int
+            // and then implicitly cast to long
+            long x = (int) 15M;
+        }
+
+        ///////////////////////////////////////
+        // CLASSES - see definitions at end of file
+        ///////////////////////////////////////
+        public static void Classes()
+        {
+            // See Declaration of objects at end of file
+
+            // Use new to instantiate a class
+            Bicycle trek = new Bicycle();
+
+            // Call object methods
+            trek.SpeedUp(3); // You should always use setter and getter methods
+            trek.Cadence = 100;
+
+            // ToString is a convention to display the value of this Object.
+            Console.WriteLine("trek info: " + trek.Info());
+
+            // Instantiate a new Penny Farthing
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("funbike info: " + funbike.Info());
+
+            Console.Read();
+        } // End main method
+
+        // CONSOLE ENTRY A console application must have a main method as an entry point
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        //
+        // INTERESTING FEATURES
+        //
+
+        // DEFAULT METHOD SIGNATURES
+
+        public // Visibility
+        static // Allows for direct call on class without object
+        int // Return Type,
+        MethodSignatures(
+            int maxCount, // First variable, expects an int
+            int count = 0, // will default the value to 0 if not passed in
+            int another = 3,
+            params string[] otherParams // captures all other parameters passed to method
+        )
+        {
+            return -1;
+        }
+
+        // Methods can have the same name, as long as the signature is unique
+        // A method that differs only in return type is not unique
+        public static void MethodSignatures(
+            ref int maxCount, // Pass by reference
+            out int count)
+        {
+            count = 15; // out param must be assigned before control leaves the method
+        }
+
+        // GENERICS
+        // The classes for TKey and TValue is specified by the user calling this function.
+        // This method emulates the SetDefault of Python
+        public static TValue SetDefault<TKey, TValue>(
+            IDictionary<TKey, TValue> dictionary,
+            TKey key,
+            TValue defaultItem)
+        {
+            TValue result;
+            if (!dictionary.TryGetValue(key, out result))
+                return dictionary[key] = defaultItem;
+            return result;
+        }
+
+        // You can narrow down the objects that are passed in
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // We can iterate, since T is a IEnumerable
+            foreach (var item in toPrint)
+                // Item is an int
+                Console.WriteLine(item.ToString());
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // OPTIONAL PARAMETERS
+            MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
+            MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
+
+            // BY REF AND OUT PARAMETERS
+            int maxCount = 0, count; // ref params must have value
+            MethodSignatures(ref maxCount, out count);
+
+            // EXTENSION METHODS
+            int i = 3;
+            i.Print(); // Defined below
+
+            // NULLABLE TYPES - great for database interaction / return values
+            // any value type (i.e. not a class) can be made nullable by suffixing a ?
+            // <type>? <var name> = <value>
+            int? nullable = null; // short hand for Nullable<int>
+            Console.WriteLine("Nullable variable: " + nullable);
+            bool hasValue = nullable.HasValue; // true if not null
+
+            // ?? is syntactic sugar for specifying default value (coalesce)
+            // in case variable is null
+            int notNullable = nullable ?? 0; // 0
+
+            // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
+            var magic = "magic is a string, at compile time, so you still get type safety";
+            // magic = 9; will not work as magic is a string, not an int
+
+            // GENERICS
+            //
+            var phonebook = new Dictionary<string, string>() {
+                {"Sarah", "212 555 5555"} // Add some entries to the phone book
+            };
+
+            // Calling SETDEFAULT defined as a generic above
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
+            // nb, you don't need to specify the TKey and TValue since they can be
+            // derived implicitly
+            Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
+
+            // LAMBDA EXPRESSIONS - allow you to write code in line
+            Func<int, int> square = (x) => x * x; // Last T item is the return value
+            Console.WriteLine(square(3)); // 9
+
+            // ERROR HANDLING - coping with an uncertain world
+            try
+            {
+                var funBike = PennyFarthing.CreateWithGears(6);
+
+                // will no longer execute because CreateWithGears throws an exception
+                string some = "";
+                if (true) some = null;
+                some.ToLower(); // throws a NullReferenceException
+            }
+            catch (NotSupportedException)
+            {
+                Console.WriteLine("Not so much fun now!");
+            }
+            catch (Exception ex) // catch all other exceptions
+            {
+                throw new ApplicationException("It hit the fan", ex);
+                // throw; // A rethrow that preserves the callstack
+            }
+            // catch { } // catch-all without capturing the Exception
+            finally
+            {
+                // executes after try or catch
+            }
+
+            // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily.
+            // Most of objects that access unmanaged resources (file handle, device contexts, etc.)
+            // implement the IDisposable interface. The using statement takes care of
+            // cleaning those IDisposable objects for you.
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Nothing suspicious here");
+                // At the end of scope, resources will be released.
+                // Even if an exception is thrown.
+            }
+
+            // PARALLEL FRAMEWORK
+            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+            var websites = new string[] {
+                "http://www.google.com", "http://www.reddit.com",
+                "http://www.shaunmccarthy.com"
+            };
+            var responses = new Dictionary<string, string>();
+
+            // Will spin up separate threads for each request, and join on them
+            // before going to the next step!
+            Parallel.ForEach(websites,
+                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
+                website =>
+            {
+                // Do something that takes a long time on the file
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // This won't happen till after all requests have been completed
+            foreach (var key in responses.Keys)
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+
+            // DYNAMIC OBJECTS (great for working with other languages)
+            dynamic student = new ExpandoObject();
+            student.FirstName = "First Name"; // No need to define class first!
+
+            // You can even add methods (returns a string, and takes in a string)
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Beth"));
+
+            // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
+            // very useful Map / Filter / Reduce style methods
+            var bikes = new List<Bicycle>();
+            bikes.Sort(); // Sorts the array
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
+            var result = bikes
+                .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
+                .Where(b => b.IsBroken && b.HasTassles)
+                .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
+
+            var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
+
+            // Create a list of IMPLICIT objects based on some parameters of the bike
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Hard to show here, but you get type ahead completion since the compiler can implicitly work
+            // out the types above!
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+                Console.WriteLine(bikeSummary.Name);
+
+            // ASPARALLEL
+            // And this is where things get wicked - combines linq and parallel operations
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // this will happen in parallel! Threads will automagically be spun up and the
+            // results divvied amongst them! Amazing for large datasets when you have lots of
+            // cores
+
+            // LINQ - maps a store to IQueryable<T> objects, with delayed execution
+            // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
+            var db = new BikeRepository();
+
+            // execution is delayed, which is great when querying a database
+            var filter = db.Bikes.Where(b => b.HasTassles); // no query run
+            if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
+                filter = filter.Where(b => b.IsBroken); // no query run
+
+            var query = filter
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // still no query run
+
+            // Now the query runs, but opens a reader, so only populates are you iterate through
+            foreach (string bike in query)
+                Console.WriteLine(result);
+
+
+
+        }
+
+    } // End LearnCSharp class
+
+    // You can include other classes in a .cs file
+
+    public static class Extensions
+    {
+        // EXTENSION FUNCTIONS
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Class Declaration Syntax:
+    // <public/private/protected/internal> class <class name>{
+    //    //data fields, constructors, functions all inside.
+    //    //functions are called as methods in Java.
+    // }
+
+    public class Bicycle
+    {
+        // Bicycle's Fields/Variables
+        public int Cadence // Public: Can be accessed from anywhere
+        {
+            get // get - define a method to retrieve the property
+            {
+                return _cadence;
+            }
+            set // set - define a method to set a proprety
+            {
+                _cadence = value; // Value is the value passed in to the setter
+            }
+        }
+        private int _cadence;
+
+        protected virtual int Gear // Protected: Accessible from the class and subclasses
+        {
+            get; // creates an auto property so you don't need a member field
+            set;
+        }
+
+        internal int Wheels // Internal: Accessible from within the assembly
+        {
+            get;
+            private set; // You can set modifiers on the get/set methods
+        }
+
+        int _speed; // Everything is private by default: Only accessible from within this class.
+                    // can also use keyword private
+        public string Name { get; set; }
+
+        // Enum is a value type that consists of a set of named constants
+        // It is really just mapping a name to a value (an int, unless specified otherwise).
+        // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
+        // An enum can't contain the same value twice.
+        public enum BikeBrand
+        {
+            AIST,
+            BMC,
+            Electra = 42, //you can explicitly set a value to a name
+            Gitane // 43
+        }
+        // We defined this type inside a Bicycle class, so it is a nested type
+        // Code outside of this class should reference this type as Bicycle.Brand
+
+        public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
+
+        // Decorate an enum with the FlagsAttribute to indicate that multiple values can be switched on
+        [Flags] // Any class derived from Attribute can be used to decorate types, methods, parameters etc
+        public enum BikeAccessories
+        {
+            None = 0,
+            Bell = 1,
+            MudGuards = 2, // need to set the values manually!
+            Racks = 4,
+            Lights = 8,
+            FullPackage = Bell | MudGuards | Racks | Lights
+        }
+
+        // Usage: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell)
+        // Before .NET 4: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell
+        public BikeAccessories Accessories { get; set; }
+
+        // Static members belong to the type itself rather then specific object.
+        // You can access them without a reference to any object:
+        // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+        public static int BicyclesCreated { get; set; }
+
+        // readonly values are set at run time
+        // they can only be assigned upon declaration or in a constructor
+        readonly bool _hasCardsInSpokes = false; // read-only private
+
+        // Constructors are a way of creating classes
+        // This is a default constructor
+        public Bicycle()
+        {
+            this.Gear = 1; // you can access members of the object with the keyword this
+            Cadence = 50;  // but you don't always need it
+            _speed = 5;
+            Name = "Bontrager";
+            Brand = BikeBrand.AIST;
+            BicyclesCreated++;
+        }
+
+        // This is a specified constructor (it contains arguments)
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand)
+            : base() // calls base first
+        {
+            Gear = startGear;
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name;
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Constructors can be chained
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "big wheels", true, brand)
+        {
+        }
+
+        // Function Syntax:
+        // <public/private/protected> <return type> <function name>(<args>)
+
+        // classes can implement getters and setters for their fields
+        // or they can implement properties (this is the preferred way in C#)
+
+        // Method parameters can have default values.
+        // In this case, methods can be called with these parameters omitted
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // properties get/set values
+        // when only data needs to be accessed, consider using properties.
+        // properties may have either get or set, or both
+        private bool _hasTassles; // private variable
+        public bool HasTassles // public accessor
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // You can also define an automatic property in one line
+        // this syntax will create a backing field automatically.
+        // You can set an access modifier on either the getter or the setter (or both)
+        // to restrict its access:
+        public bool IsBroken { get; private set; }
+
+        // Properties can be auto-implemented
+        public int FrameSize
+        {
+            get;
+            // you are able to specify access modifiers for either get or set
+            // this means only Bicycle class can call set on Framesize
+            private set;
+        }
+
+        // It's also possible to define custom Indexers on objects.
+        // All though this is not entirely useful in this example, you
+        // could do bicycle[0] which yields "chris" to get the first passenger or
+        // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle)
+        private string[] passengers = { "chris", "phil", "darren", "regina" };
+
+        public string this[int i]
+        {
+            get {
+                return passengers[i];
+            }
+
+            set {
+                return passengers[i] = value;
+            }
+        }
+
+        //Method to display the attribute values of this Object.
+        public virtual string Info()
+        {
+            return "Gear: " + Gear +
+                    " Cadence: " + Cadence +
+                    " Speed: " + _speed +
+                    " Name: " + Name +
+                    " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Methods can also be static. It can be useful for helper methods
+        public static bool DidWeCreateEnoughBycles()
+        {
+            // Within a static method, we only can reference static class members
+            return BicyclesCreated > 9000;
+        } // If your class only needs static members, consider marking the class itself as static.
+
+
+    } // end class Bicycle
+
+    // PennyFarthing is a subclass of Bicycle
+    class PennyFarthing : Bicycle
+    {
+        // (Penny Farthings are those bicycles with the big front wheel.
+        // They have no gears.)
+
+        // calling parent constructor
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                throw new InvalidOperationException("You can't change gears on a PennyFarthing");
+            }
+        }
+
+        public static PennyFarthing CreateWithGears(int gears)
+        {
+            var penny = new PennyFarthing(1, 1);
+            penny.Gear = gears; // Oops, can't do this!
+            return penny;
+        }
+
+        public override string Info()
+        {
+            string result = "PennyFarthing bicycle ";
+            result += base.ToString(); // Calling the base version of the method
+            return result;
+        }
+    }
+
+    // Interfaces only contain signatures of the members, without the implementation.
+    interface IJumpable
+    {
+        void Jump(int meters); // all interface members are implicitly public
+    }
+
+    interface IBreakable
+    {
+        bool Broken { get; } // interfaces can contain properties as well as methods & events
+    }
+
+    // Class can inherit only one other class, but can implement any amount of interfaces
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Used to connect to DB for LinqToSql example.
+    /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+    /// </summary>
+    public class BikeRepository : DbContext
+    {
+        public BikeRepository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // End Namespace
+```
+
+## Topics Not Covered
+
+ * Attributes
+ * async/await, yield, pragma directives
+ * Web Development
+ 	* ASP.NET MVC & WebApi (new)
+ 	* ASP.NET Web Forms (old)
+ 	* WebMatrix (tool)
+ * Desktop Development
+ 	* Windows Presentation Foundation (WPF) (new)
+ 	* Winforms (old)
+
+## Further Reading
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+ * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
new file mode 100644
index 00000000..8de9bee6
--- /dev/null
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -0,0 +1,76 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+---
+
+# Programação Dinâmica
+
+## Introdução
+
+Programação Dinâmica é uma técnica poderosa utilizada para resolver uma classe 
+particular de problemas como veremos. A ideia é bastante simples, se você 
+solucionou um problema com uma dada entrada, então salve o resultado para 
+referência futura, e também para evitar resolver o mesmo problema novamente.
+
+Sempre se lembre!!
+"Aqueles que não conseguem lembrar o passado estão condenados a repeti-lo"
+
+## Maneiras de Solucionar tais Problemas
+
+1. Top-Down (De cima para baixo): Começe solucionando o problema quebrando-o em 
+partes. Se você perceber que o problema já foi resolvido, então simplemente 
+pegue a resposta salva. Se ainda não foi resolvido, solucione-o e salve a 
+resposta. Isso é geralmente fácil de pensar e muito intuitivo. É geralmente 
+referenciado como Memorização.
+
+2. Bottom-Up (De baixo para cima): Analise o problema e veja a ordem em que os 
+subproblemas são resolvidos e começe a solucionar dos problemas mais triviais, 
+até o problema dado. Neste processo, é garantido que os subproblemas são 
+resolvidos antes de resoler o problema. Isto é referenciado como Programação Dinâmica.
+
+## Exemplo de Programação Dinâmica
+
+O problema da subsequência crescente máxima consiste em encontrar a maior 
+subsequência crescente de uma dada sequência. Dada uma sequência 
+S= {a1 , a2 , a3, a4, ... , an-1, an} nós temos que encontrar o maior subconjunto 
+de forma que para todo j e i,  j < i no subconjunto aj < ai. Antes de mais nada 
+nós temos que encontrar o valor das maiores subsequências (LSi) para cada índice 
+i com o último elemento da sequência sendo ai. Então a maior LSi será a maior 
+subsequência na sequência dada. Para começar LSi é atribuído a um pois ai é 
+elemento da sequência (último elemento). Então para todo j tal que j < i e aj < 
+ai, nós procuramos o maior LSj e o adicionamos a LSi. Portanto o algoritmo tem 
+complexidade de tempo O(n2). O pseudocódigo para procurar o comprimento da 
+subsequência crescente máxima: A complexidade desse algoritmo poderia ser 
+reduzida utilizando uma estrutura de dados melhor que um array. Armazenando o 
+array antecedente e uma variável como maiorSequenciasAteAgora e seu índice 
+ajudariam a poupar muito tempo.
+Um conceito similar poderia ser aplicado ao procurar o maior caminho em um 
+grafo acíclico dirigido.
+---------------------------------------------------------------------------
+```
+ for i=0 to n-1
+            LS[i]=1
+            for j=0 to i-1
+                        if (a[i] >  a[j] and LS[i]<LS[j])
+                                    LS[i] = LS[j]+1
+ for i=0 to n-1
+            if (largest < LS[i])
+```
+
+### Alguns Problemas Famosos de Programação Dinâmica
+```
+Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code 
+
+Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem 
+
+Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence 
+```
+
+## Recursos Online (EN)
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/pt-br/elixir.html.markdown b/pt-br/elixir.html.markdown
new file mode 100644
index 00000000..f8c56101
--- /dev/null
+++ b/pt-br/elixir.html.markdown
@@ -0,0 +1,412 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+translators:
+    - ["Rodrigo Muniz", "http://github.com/muniz95"]
+lang: pt-br
+filename: learnelixir-pt.ex
+---
+
+Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
+É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada
+e muitos outros recursos.
+
+```elixir
+
+# Comentários de linha única começam com um símbolo de número.
+
+# Não há comentários de múltiplas linhas,
+# mas você pode empilhar os comentários.
+
+# Para usar o shell do elixir use o comando `iex`.
+# Compile seus módulos com o comando `elixirc`.
+
+# Ambos devem estar em seu path se você instalou o Elixir corretamente.
+
+## ---------------------------
+## -- Tipos Básicos
+## ---------------------------
+
+# Há números
+3    # integer
+0x1F # integer
+3.0  # float
+
+# Atoms, que são literais, uma constante com nome. Elas começam com `:`.
+:hello # atom
+
+# Tuplas que são guardadas contiguamente em memória.
+{1,2,3} # tupla
+
+# Podemos acessar um elemento de uma tupla om a função `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Listas que são implementadas como listas ligadas.
+[1,2,3] # lista
+
+# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir:
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
+# e não uma atribuição.
+#
+# Isto significa que o que estiver à esquerda (pattern) é comparado com o que
+# estiver à direita.
+#
+# É assim que o exemplo acima de acesso à head e tail de uma lista funciona.
+
+# Um pattern match retornará erro quando os lados não conferem, como neste exemplo
+# onde as tuplas tem diferentes tamanhos.
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Também há binários
+<<1,2,3>> # binary
+
+# Strings e char lists
+"hello" # string
+'hello' # char list
+
+# Strings de múltiplas linhas
+"""
+Strings
+de múltiplas
+linhas.
+"""
+#=> "Strings\nde múltiplas\nlinhas"
+
+# Strings são sempre codificadas em UTF-8:
+"héllò" #=> "héllò"
+
+# Strings são de fato apenas binários, e char lists apenas listas.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` em elixir retorna o valor ASCII para a letra `a`
+?a #=> 97
+
+# Para concatenar listas use `++`, para binários use `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+# Ranges são representados como `início..fim` (ambos inclusivos)
+1..10 #=> 1..10
+menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
+[lower, upper] #=> [1, 10]
+
+## ---------------------------
+## -- Operadores
+## ---------------------------
+
+# Matemática básica
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# Em elixir o operador `/` sempre retorna um float.
+
+# Para divisão de inteiros use `div`
+div(10, 2) #=> 5
+
+# Para obter o resto da divisão use `rem`
+rem(10, 3) #=> 1
+
+# Há também operadores booleanos: `or`, `and` e `not`.
+# Estes operadores esperam um booleano como primeiro argumento.
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo.
+# Todos os valores exceto `false` e `nil` serão avaliados como true.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` e `!==` são mais estritos ao comparar integers e floats:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Podemos comparar também dois tipos de dados diferentes:
+1 < :hello #=> true
+
+# A regra de ordenação no geral é definida abaixo:
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante,
+# mas que uma ordem total esteja bem definida é importante."
+
+## ---------------------------
+## -- Fluxo de Controle
+## ---------------------------
+
+# expressão `if` 
+if false do
+  "Isso nunca será visto"
+else
+  "Isso será"
+end
+
+# Também há `unless`
+unless true do
+  "Isso nunca será visto"
+else
+  "Isso será"
+end
+
+# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
+
+# `case` nos permite comparar um valor com muitos patterns:
+case {:um, :dois} do
+  {:quatro, :cinco} ->
+    "Isso não corresponde"
+  {:um, x} ->
+    "Isso corresponde e vincula `x` a `:dois`"
+  _ ->
+    "Isso corresponde a qualquer valor"
+end
+
+# É comum vincular o valor a `_` se não precisamos dele.
+# Por exemplo, se apenas a head de uma lista nos interessa:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Para melhor legibilidade podemos fazer o seguinte:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` nos permite verificar várias condições ao mesmo tempo.
+# Use `cond` em vez de aninhar vários `if`'s.
+cond do
+  1 + 1 == 3 ->
+    "Nunca serei visto"
+  2 * 5 == 12 ->
+    "Nem eu"
+  1 + 2 == 3 ->
+    "Mas eu serei"
+end
+
+# É comum definir a última condição igual a `true`, que sempre irá corresponder.
+cond do
+  1 + 1 == 3 ->
+    "Nunca serei visto"
+  2 * 5 == 12 ->
+    "Nem eu"
+  true ->
+    "Mas eu serei (isso é essencialmente um else)"
+end
+
+# `try/catch` é usado para capturar valores que são lançados, também suporta uma
+# cláusula `after` que é invocada havendo um valor capturado ou não.
+try do
+  throw(:hello)
+catch
+  message -> "Deu #{mensagem}."
+after
+  IO.puts("Sou o after.")
+end
+#=> Sou o after
+# "Deu :hello"
+
+## ---------------------------
+## -- Módulos e Funções
+## ---------------------------
+
+# Funções Anônimas (repare o ponto)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Elas também aceitam várias cláusulas e guards.
+# Guards permitem ajustes finos de pattern matching,
+# sendo indicados pela palavra `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir também fornece várias funções embutidas.
+# Estas estão disponíveis no escopo atual.
+is_number(10)    #=> true
+is_list("ola") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def`
+# para definir suas funções.
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc`
+# em seu terminal: elixirc math.ex
+
+# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`.
+# Uma função definida com `def` pode ser invocada por outros módulos,
+# já uma função privada pode ser invocada apenas localmente.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Declarações de funções também suportam guards cláusulas múltiplas:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Devido à imutabilidade, recursão é uma grande parte do elixir
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Módulos do elixir suportam atributos, hpa atributos embutidos e você
+# pode também adicionar os seus próprios.
+defmodule MyMod do
+  @moduledoc """
+  Este é um atributo embutido em um módulo de exemplo.
+  """
+
+  @my_data 100 # Este é um atributo customizado.
+  IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- Structs e Exceptions
+## ---------------------------
+
+# Structs são extensões no topo de mapas que trazem valores padrão,
+# garantias em tempo de compilação e polimorfismo para o Elixir.
+defmodule Pessoa do
+  defstruct nome: nil, idade: 0, peso: 0
+end
+
+joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 }
+#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"}
+
+# Acessa o valor de nome
+joe_info.name #=> "Joe"
+
+# Atualiza o valor de idade
+older_joe_info = %{ joe_info | idade: 31 }
+#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"}
+
+# O bloco `try` com a palavra `rescue` é usado para manipular exceções
+try do
+  raise "algum erro"
+rescue
+  RuntimeError -> "resgatado um erro em tempo de execução"
+  _error -> "isso resgatará qualquer erro"
+end
+
+# Toda exceção possui uma mensagem
+try do
+  raise "algum erro"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+
+## ---------------------------
+## -- Concorrência
+## ---------------------------
+
+# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
+# escrever programas concorrentes em elixir são três primitivos: spawning processes,
+# sending messages e receiving messages.
+
+# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
+# como argumento.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar
+# mensagens ao processo. Para envio de mensagens usamos o operador `send`.
+# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é
+# realizado com o mecanismo `receive`:
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Compile o módulo e crie um processo que avalie `area_loop` no shell
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# O shell também é um processo, você pode usar `self` para obter o pid atual
+self() #=> #PID<0.27.0>
+```
+
+## Referências
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong
diff --git a/pt-br/elm-pt.html.markdown b/pt-br/elm-pt.html.markdown
new file mode 100644
index 00000000..78a4f1b7
--- /dev/null
+++ b/pt-br/elm-pt.html.markdown
@@ -0,0 +1,384 @@
+---
+language: Elm
+contributors:
+    - ["Max Goldstein", "http://maxgoldste.in/"]
+translators:
+    - ["Marcel dos Santos", "https://twitter.com/marcelgsantos"]
+lang: pt-br
+filename: learnelm-pt.elm
+---
+
+Elm é uma linguagem de programação funcional reativa que compila para (client-side)
+JavaScript. Elm é estaticamente tipada, significando que o compilador captura a
+maioria dos erros imediatamente e fornece uma mensagem de erro limpa e compreensível.
+Elm é excelente para projetar interfaces de usuário e jogos para a web.
+
+
+```haskell
+-- Comentários de uma linha começam com dois traços.
+{- Comentários de múltiplas linhas podem ser delimitados em um bloco como este.
+{- Eles podem ser aninhados. -}
+-}
+
+{-- O Básico --}
+
+-- Operações Aritméticas
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+
+-- Cada número literal sem um ponto decimal pode ser um Int ou um Float.
+33 / 2 -- 16.5 com divisão de ponto flutuante
+33 // 2 -- 16 com divisão inteira
+
+-- Exponenciação
+5 ^ 2 -- 25
+
+-- Booleanos
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Strings e caracteres
+"Esta é uma string porque ela utiliza aspas duplas."
+'a' -- caracteres entre aspas simples
+
+-- Strings podem ser anexadas.
+"Olá " ++ "mundo!" -- "Olá mundo!"
+
+{-- Listas, Tuplas e Registros --}
+
+-- Cada elemento em uma lista deve ter o mesmo tipo.
+["the", "quick", "brown", "fox"]
+[1, 2, 3, 4, 5]
+-- O segundo exemplo também pode ser escrito com dois pontos.
+[1..5]
+
+-- Junte listas da mesma forma que strings.
+[1..5] ++ [6..10] == [1..10] -- True
+
+-- Para adicionar um item utilize "cons".
+0 :: [1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- A cabeça e a cauda de uma lista são retornadas como uma Maybe. Em vez de
+-- verificar cada valor para ver se ele é nulo, você lida com os valores
+-- faltantes explicitamente.
+List.head [1..5] -- Just 1
+List.tail [1..5] -- Just [2, 3, 4, 5]
+List.head [] -- Nothing
+-- List.functionName siginifica que a função faz parte do módulo List.
+
+-- Cada elemento em uma tupla pode ser de um tipo diferente, mas uma tupla
+-- tem um comprimento fixo.
+("elm", 42)
+
+-- Acesse os elementos de um par com as funções first e second.
+-- (Este é um atalho; nós iremos para o "caminho real" em breve.)
+fst ("elm", 42) -- "elm"
+snd ("elm", 42) -- 42
+
+-- Uma tupla vazia ou "unidade" às vezes é utilizada como um placeholder.
+-- É o único valor de seu tipo, também chamado de "Unit".
+()
+
+-- Registros são como tuplas mas os campos possuem nomes. A ordem dos campos
+-- não importa. Observe que os valores dos registros utilizam sinais de igual,
+-- e não dois-pontos.
+{ x = 3, y = 7 }
+
+-- Acesse um campo com um ponto e o nome do campo.
+{ x = 3, y = 7 }.x -- 3
+
+-- Ou com uma função acessora, que é um ponto e o nome do próprio campo.
+.y { x = 3, y = 7 } -- 7
+
+-- Atualiza os campos de um registro. (Ele já deve ter os campos.)
+{ person |
+  name = "George" }
+
+-- Atualiza vários campos de uma só vez utilizando os valores atuais.
+{ particle |
+  position = particle.position + particle.velocity,
+  velocity = particle.velocity + particle.acceleration }
+
+{-- Fluxo de Controle --}
+
+-- Declarações if sempre devem ter um else e os valores devem ser do mesmo tipo.
+if powerLevel > 9000 then
+  "WHOA!"
+else
+  "meh"
+
+-- Declarações if podem ser encadeadas.
+if n < 0 then
+  "n é negativo"
+else if n > 0 then
+  "n é positivo"
+else
+  "n é zero"
+
+-- Utilize declarações case para casar padrões entre diferentes possibilidades.
+case aList of
+  [] -> "casa com uma lista vazia"
+  [x]-> "casa com uma lista de exatamente um item, " ++ toString x
+  x::xs -> "casa com uma lista de pelo menos um item cuja cabeça é " ++ toString x
+-- O casamento do padrão acontece na ordem. Se colocarmos [x] por último, ele
+-- nunca iria casar porque x::xs também casa (xs seria a lista vazia). Os
+-- casamentos não "falham".
+-- O compilador irá alertá-lo sobre casos faltantes ou extras.
+
+-- Casa padrão com um Maybe.
+case List.head aList of
+  Just x -> "A cabeça é " ++ toString x
+  Nothing -> "A lista estava vazia."
+
+{-- Funções --}
+
+-- A sintaxe do Elm é muito mínima, baseando-se principalmente em espaços em
+-- branco em vez de parênteses e chaves. Não existe a palavra-chave "return".
+
+-- Define uma função com seu nome, argumentos, um sinal de igual e o corpo.
+multiply a b =
+  a * b
+
+-- Aplica (chama) uma função passando seus argumentos (vírgulas não necessárias).
+multiply 7 6 -- 42
+
+-- Aplica parcialmente uma função passando somente alguns de seus argumentos.
+-- Dando, em seguida, um novo nome a função.
+double =
+  multiply 2
+
+-- Constantes são semelhantes, exceto que não há argumentos.
+answer =
+  42
+
+-- Passa funções como argumentos para outras funções.
+List.map double [1..4] -- [2, 4, 6, 8]
+
+-- Ou escreva uma função anônima.
+List.map (\a -> a * 2) [1..4] -- [2, 4, 6, 8]
+
+-- Você pode casar um padrão na definição de funções quando há somente um caso.
+-- Esta função recebe uma tupla em vez de dois argumentos.
+-- Esta é a maneira que você normalmente vai desempacotar/extrair valores de tuplas.
+area (width, height) =
+  width * height
+
+area (6, 7) -- 42
+
+-- Utilize chaves para casar o padrão de nomes de campos de um registro.
+-- Utilize let para definir valores intermediários.
+volume {width, height, depth} =
+  let
+    area = width * height
+  in
+    area * depth
+
+volume { width = 3, height = 2, depth = 7 } -- 42
+
+-- Funções podem ser recursivas.
+fib n =
+  if n < 2 then
+    1
+  else
+    fib (n - 1) + fib (n - 2)
+
+List.map fib [0..8] -- [1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+-- Outra função recursiva (utilize List.length em um código de verdade).
+listLength aList =
+  case aList of
+    [] -> 0
+    x::xs -> 1 + listLength xs
+
+-- Chamadas de funções acontecem antes de qualquer operador infixo.
+-- Os parênteses indicam a precendência.
+cos (degrees 30) ^ 2 + sin (degrees 30) ^ 2 -- 1
+-- Primeiro degrees é aplicada em 30, então o resultado é passado para as
+-- funções de trigonometria, que então é elevado ao quadrado e, por fim, a
+-- adição acontece.
+
+{-- Tipos e Anotações de Tipos --}
+
+-- O compilador irá inferir o tipo de cada valor em seu programa.
+-- Tipos iniciam com letra maiúscula. Leia x : T como "x é do tipo T".
+-- Alguns tipos comuns que você pode ver no REPL do Elm.
+5 : Int
+6.7 : Float
+"hello" : String
+True : Bool
+
+-- Funções têm tipos também. Leia -> como "vai para". Pense no tipo mais à
+-- direita como o tipo do valor de retorno e os outros como argumentos.
+not : Bool -> Bool
+round : Float -> Int
+
+-- Quando você define um valor, é uma boa prática escrever seu tipo acima dele.
+-- A anotação é uma forma de documentação, que é verifica pelo compilador.
+double : Int -> Int
+double x = x * 2
+
+-- Argumentos de uma função são passados entre parênteses.
+-- Tipos com letra minúscula são tipos variáveis: eles podem ser de qualquer
+-- tipo, desde que cada chamada seja consistente.
+List.map : (a -> b) -> List a -> List b
+-- "List.map é do tipo a-vai-para-b, vai para lista de a e vai para lista de b."
+
+-- Existem três tipos especiais com minúsculas: number, comparable e appendable.
+-- Numbers permite que você utilize aritmética em Ints e Floats.
+-- Comparable permite você ordenar números e strings, como a < b.
+-- Appendable permite que coisas possam ser combinadas com a ++ b.
+
+{-- Type Aliases e Union Types --}
+
+-- Quando você escreve um registro ou uma tupla, seu tipo já existe.
+-- (Observe que os tipos de um registro utilizam dois-pontos e os valores de um
+-- registro utilizam igual.)
+origin : { x : Float, y : Float, z : Float }
+origin =
+  { x = 0, y = 0, z = 0 }
+
+-- Você pode dar um bom nome para tipos existentes com um type alias.
+type alias Point3D =
+  { x : Float, y : Float, z : Float }
+
+-- Se você cria um alias para um registro, você pode usar o nome como uma
+-- função construtora.
+otherOrigin : Point3D
+otherOrigin =
+  Point3D 0 0 0
+
+-- Mas ele ainda é do mesmo tipo, então você pode compará-los.
+origin == otherOrigin -- True
+
+-- Por outro lado, a definição de um union type cria um tipo que não existia
+-- antes. Um union type é chamado assim porque ele pode ser uma de muitas
+-- possibilidades. Cada uma das possibilidades é representada como uma "tag".
+type Direction =
+  North | South | East | West
+
+-- As tags podem levar outros valores de tipos conhecidos. Isso pode trabalhar
+-- recursivamente.
+type IntTree =
+  Leaf | Node Int IntTree IntTree
+-- "Leaf" e "Node" são as tags. Tudo após uma tag é um tipo.
+
+-- As tags podem ser usadas como valores ou funções.
+root : IntTree
+root =
+  Node 7 Leaf Leaf
+
+-- Union types (e type aliases) podem utilizar tipos variáveis.
+type Tree a =
+  Leaf | Node a (Tree a) (Tree a)
+-- "O tipo árvore-de-a é uma folha ou um nó de a, árvore-de-a e árvore-de-a."
+
+-- Casa padrão com union tags. As tags maiúsculas serão casadas de maneira exa-
+-- ta. As variáveis minúsculas irão casar com qualquer coisa. Sublinhado também
+-- casa com qualquer coisa, mas siginifica que você não o está utilizando.
+leftmostElement : Tree a -> Maybe a
+leftmostElement tree =
+  case tree of
+    Leaf -> Nothing
+    Node x Leaf _ -> Just x
+    Node _ subtree _ -> leftmostElement subtree
+
+-- Isso é praticamente a própria linguagem. Agora vamos ver como organizar e
+-- executar seu código.
+
+{-- Módulos e Imports --}
+
+-- As bibliotecas internas são organizadas em módulos, assim como quaisquer
+-- bibliotecas de terceiros que você possa utilizar. Para grandes projetos,
+-- você pode definir seus próprios módulos.
+
+-- Coloque isso no topo do arquivo. Se for omitido, você está no Main.
+module Name where
+
+-- Por padrão, tudo é exportado. Você pode especificar as exportações de forma
+-- explícita.
+module Name (MyType, myValue) where
+
+-- Um padrão comum é exportar um union type mas não suas tags. Isto é conhecido
+-- como "tipo opaco" e é frequentemente utilizado em bibliotecas.
+
+-- Importe código de outros módulos para utilizá-lo no seu código.
+-- Coloque Dict no escopo para você poder chamar Dict.insert.
+import Dict
+
+-- Importe o módulo Dict e o tipo Dict para que suas anotações não tenham que
+-- dizer Dict.Dict. Você ainda pode utilizar Dict.insert.
+import Dict exposing (Dict)
+
+-- Renomeie um import.
+import Graphics.Collage as C
+
+{-- Portas --}
+
+-- Uma porta indica que você estará se comunicando com o mundo exterior.
+-- Portas são permitidas somente no módulo Main.
+
+-- Uma porta de entrada é apenas uma assinatura de tipo.
+port clientID : Int
+
+-- Uma porta de saída tem uma definição.
+port clientOrders : List String
+port clientOrders = ["Books", "Groceries", "Furniture"]
+
+-- Não vamos entrar em detalhes, mas você configura callbacks no JavaScript
+-- para enviar nas portas de entrada e receber nas portas de saída.
+
+{-- Ferramentas de Linha de Comando --}
+
+-- Compila um arquivo.
+$ elm make MyFile.elm
+
+-- A primeira vez que você fizer isso, o Elm instalará as bibliotecas internas
+-- e criará o elm-package.json, onde a informação sobre seu projeto é mantida.
+
+-- O reactor é um servidor que compila e roda seus arquivos.
+-- Clique na chave ao lado dos nomes de arquivo para entrar no depurador de
+-- viagem no tempo.
+$ elm reactor
+
+-- Teste expressões simples no Read-Eval-Print Loop.
+$ elm repl
+
+-- Pacotes são identificados pelo usuário e nome do repositório no GitHub.
+-- Instale um novo pacote e registre-o no elm-package.json.
+$ elm package install evancz/elm-html
+
+-- Veja o que mudou entre as versões de um pacote.
+$ elm package diff evancz/elm-html 3.0.0 4.0.2
+-- O gerenciador de pacotes do Elm obriga o versionamento semântico, logo
+-- mudanças de versões no minor nunca quebrará o seu build!
+```
+
+A linguagem Elm é supreendentemente pequena. Agora você pode olhar para quase
+qualquer código-fonte em Elm e ter uma ideia aproximada do que está acontecendo.
+No entanto, as possibilidades para código resistente a erros e de fácil
+refatoração são infinitas!
+
+Aqui estão algumas referências utéis.
+
+* O [site do Elm](http://elm-lang.org/). Ele inclui:
+  * Links para os [instaladores](http://elm-lang.org/install)
+  * [Documentação](http://elm-lang.org/docs), incluindo [a referência de sintaxe](http://elm-lang.org/docs/syntax)
+  * Muitos [exemplos](http://elm-lang.org/examples) úteis
+
+* Documentação para as [bibliotecas internas do Elm](http://package.elm-lang.org/packages/elm-lang/core/latest/). Tome nota de:
+  * [Basics](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics), que é importada por padrão
+  * [Maybe](http://package.elm-lang.org/packages/elm-lang/core/latest/Maybe) e seu primo [Result](http://package.elm-lang.org/packages/elm-lang/core/latest/Result), comumente utilizados para valores faltantes e manipulação de erros
+  * Estruturas de dados como [List](http://package.elm-lang.org/packages/elm-lang/core/latest/List), [Array](http://package.elm-lang.org/packages/elm-lang/core/latest/Array), [Dict](http://package.elm-lang.org/packages/elm-lang/core/latest/Dict) e [Set](http://package.elm-lang.org/packages/elm-lang/core/latest/Set)
+  * [Codificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Encode) e [decodificação](http://package.elm-lang.org/packages/elm-lang/core/latest/Json-Decode) JSON
+
+* [A Arquitetura Elm](https://github.com/evancz/elm-architecture-tutorial#the-elm-architecture). Uma dissertação pelo criador do Elm com exemplos sobre como organizar código em componentes.
+
+* A [lista de e-mail do Elm](https://groups.google.com/forum/#!forum/elm-discuss). Todos são amigáveis e solícitos.
+
+* [Escopo em Elm](https://github.com/elm-guides/elm-for-js/blob/master/Scope.md#scope-in-elm) e [Como Ler uma Anotação de Tipo](https://github.com/elm-guides/elm-for-js/blob/master/How%20to%20Read%20a%20Type%20Annotation.md#how-to-read-a-type-annotation). Mais sobre guias da comunidade sobre o básico de Elm escrito por desenvolvedores JavaScript.
+
+Saia e escreva algum código Elm!
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
index 981da503..e59ba901 100644
--- a/pt-br/git-pt.html.markdown
+++ b/pt-br/git-pt.html.markdown
@@ -2,11 +2,15 @@
 category: tool
 tool: git
 lang: pt-br
-filename: LearnGit.txt
+filename: LearnGit-br.txt
 contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
 translators:
   - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+  - ["Bruno Volcov", "http://github.com/volcov"]
 ---
 
 Git é um sistema distribuido de gestão para código fonte e controle de versões.
@@ -28,7 +32,7 @@ a um arquivo ou conjunto de arquivos ao longo do tempo.
 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
+* Sistemas distribuídos não têm estrutura definida. É possivel ter um sistema
 centralizado ao estilo SVN usando git.
 
 [Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
@@ -52,7 +56,7 @@ 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 é constituido pelo diretório .git e a *working tree*
+Um repositório git é constituído pelo diretório .git e a *working tree*
 
 ### Diretório .git (componente do repositório)
 
@@ -84,6 +88,11 @@ 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.
 
+### *Tag*
+
+Uma tag é uma marcação em um ponto específico da história. Geralmente as
+pessoas usam esta funcionalidade para marcar pontos de release (v2.0, e por aí vai)
+
 ### *HEAD* e *head* (componentes do diretório .git)
 
 *HEAD* é a referência que aponta para o *branch* em uso. Um repositório só tem
@@ -131,10 +140,10 @@ Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da
 # Ver rapidamente os comandos disponiveis
 $ git help
 
-# Ver todos os comandos disponiveis
+# Ver todos os comandos disponíveis
 $ git help -a
 
-# Usar o *help* para um comando especifico
+# Usar o *help* para um comando específico
 # git help <comando_aqui>
 $ git help add
 $ git help commit
@@ -149,7 +158,7 @@ do repositório) e o *commit* da *HEAD* atual.
 
 ```bash
 # Apresenta o *branch*, arquivos não monitorados, alterações e outras
-# difereças
+# diferenças
 $ git status
 
 # Para aprender mais detalhes sobre git *status*
@@ -196,6 +205,29 @@ $ git branch -m myBranchName myNewBranchName
 $ git branch myBranchName --edit-description
 ```
 
+### Tag
+
+Gerencia as *tags*
+
+```bash
+# Listar tags
+$ git tag
+# Criar uma tag anotada.
+# O parâmetro -m define uma mensagem, que é armazenada com a tag.
+# Se você não especificar uma mensagem para uma tag anotada,
+# o Git vai rodar seu editor de texto para você digitar alguma coisa.
+$ git tag -a v2.0 -m 'minha versão 2.0'
+# Mostrar informações sobre a tag
+# O comando mostra a informação da pessoa que criou a tag,
+# a data de quando o commit foi taggeado,
+# e a mensagem antes de mostrar a informação do commit.
+$ git show v2.0
+# Enviar uma tag para o repositório remoto
+$ git push origin v2.0
+# Enviar várias tags para o repositório remoto
+$ git push origin --tags
+```
+
 ### checkout
 
 Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
@@ -368,7 +400,7 @@ perigoso quando não há certeza do que se está fazendo.
 
 ```bash
 # Restabelece a camada intermediária de registo para o último
-# commit (o directório fica sem alterações)
+# commit (o diretório fica sem alterações)
 $ git reset
 
 # Restabelece a camada intermediária de registo para o último commit, e
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 788dc1d2..181aa471 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -93,7 +93,7 @@ not False -- Nega uma falácia
 "AbBbbcAbbcbBbcbcb" !! 2 -- 'B'
 
 ----------------------------------------------------
--- Listas e Túplas
+-- 2. Listas e Túplas
 ----------------------------------------------------
 
 -- A construção de uma lista precisa ser de elementos homogêneos
diff --git a/pt-br/hy-pt.html.markdown b/pt-br/hy-pt.html.markdown
index 4230579d..5fa4df75 100644
--- a/pt-br/hy-pt.html.markdown
+++ b/pt-br/hy-pt.html.markdown
@@ -171,6 +171,6 @@ Este tutorial é apenas uma introdução básica para hy/lisp/python.
 
 Docs Hy: [http://hy.readthedocs.org](http://hy.readthedocs.org)
 
-Repo Hy no Github: [http://github.com/hylang/hy](http://github.com/hylang/hy)
+Repo Hy no GitHub: [http://github.com/hylang/hy](http://github.com/hylang/hy)
 
 Acesso ao freenode irc com #hy, hashtag no twitter: #hylang
diff --git a/pt-br/java-pt.html.markdown b/pt-br/java-pt.html.markdown
index 3c9512aa..82989502 100644
--- a/pt-br/java-pt.html.markdown
+++ b/pt-br/java-pt.html.markdown
@@ -214,42 +214,42 @@ public class LearnJava {
             //Iteração feita 10 vezes, fooFor 0->9
         }
         System.out.println("Valor do fooFor: " + fooFor);
-        
-        // O Loop For Each 
+
+        // O Loop For Each
         // Itera automaticamente por um array ou lista de objetos.
         int[] fooList = {1,2,3,4,5,6,7,8,9};
         //estrutura do loop for each => for(<objeto> : <array_de_objeto>)
         //lê-se: para cada objeto no array
         //nota: o tipo do objeto deve ser o mesmo do array.
-        
+
         for( int bar : fooList ){
             //System.out.println(bar);
             //Itera 9 vezes e imprime 1-9 em novas linhas
         }
-        
+
         // Switch
         // Um switch funciona com os tipos de dados: byte, short, char e int
         // Ele também funciona com tipos enumerados (vistos em tipos Enum)
         // como também a classe String e algumas outras classes especiais
         // tipos primitivos: Character, Byte, Short e Integer
-        int mes = 3; 
-        String mesString; 
-        switch (mes){ 
+        int mes = 3;
+        String mesString;
+        switch (mes){
             case 1:
-                    mesString = "Janeiro"; 
+                    mesString = "Janeiro";
                     break;
             case 2:
-                    mesString = "Fevereiro"; 
+                    mesString = "Fevereiro";
                     break;
             case 3:
-                    mesString = "Março"; 
+                    mesString = "Março";
                     break;
             default:
-                    mesString = "Algum outro mês"; 
+                    mesString = "Algum outro mês";
                     break;
         }
         System.out.println("Resultado do Switch: " + mesString);
-        
+
         // Condição de forma abreviada.
         // Você pode usar o operador '?' para atribuições rápidas ou decisões lógicas.
         // Lê-se "Se (declaração) é verdadeira, use <primeiro valor>
@@ -287,9 +287,9 @@ public class LearnJava {
         // Classes e Métodos
         ///////////////////////////////////////
 
-        System.out.println("\n->Classes e Métodos"); 
+        System.out.println("\n->Classes e Métodos");
 
-        // (segue a definição da classe Bicicleta) 
+        // (segue a definição da classe Bicicleta)
 
         // Use o new para instanciar uma classe
         Bicicleta caloi = new Bicicleta(); // Objeto caloi criado.
@@ -318,9 +318,9 @@ class Bicicleta {
 
     // Atributos/Variáveis da classe Bicicleta.
     public int ritmo;          // Public: Pode ser acessada em qualquer lugar.
-    private int velocidade;    // Private: Apenas acessível a classe. 
+    private int velocidade;    // Private: Apenas acessível a classe.
     protected int catraca; // Protected: Acessível a classe e suas subclasses.
-    String nome;               // default: Apenas acessível ao pacote. 
+    String nome;               // default: Apenas acessível ao pacote.
 
     // Construtores são uma forma de criação de classes
     // Este é o construtor padrão.
@@ -388,7 +388,7 @@ class Bicicleta {
 // Velocipede é uma subclasse de bicicleta.
 class Velocipede extends Bicicleta {
     // (Velocípedes são bicicletas com rodas dianteiras grandes
-    // Elas não possuem catraca.) 
+    // Elas não possuem catraca.)
 
     public Velocipede(int ritmoInicial, int velocidadeInicial){
         // Chame o construtor do pai (construtor de Bicicleta) com o comando super.
@@ -407,7 +407,7 @@ class Velocipede extends Bicicleta {
 
 // Interfaces
 // Sintaxe de declaração de Interface
-// <nível de acesso> Interface <nome-da-interface> extends <super-interfaces> {
+// <nível de acesso> interface <nome-da-interface> extends <super-interfaces> {
 // // Constantes
 // // Declarações de método
 //}
@@ -415,11 +415,15 @@ class Velocipede extends Bicicleta {
 // Exemplo - Comida:
 public interface Comestivel {
     public void comer(); // Qualquer classe que implementa essa interface, deve
-                        // Implementar este método.
+                         // implementar este método.
 }
 
 public interface Digestivel {
     public void digerir();
+    // Em Java 8, interfaces podem ter métodos default.
+    // public void digerir() {
+    //     System.out.println("digerindo ...");
+    // }
 }
 
 
@@ -438,7 +442,7 @@ public class Fruta implements Comestivel, Digestivel {
 }
 
 // Em Java, você pode estender somente uma classe, mas você pode implementar muitas
-// Interfaces. Por exemplo:
+// interfaces. Por exemplo:
 public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
     InterfaceDois {
 
@@ -461,8 +465,8 @@ public class ClasseExemplo extends ExemploClassePai implements InterfaceUm,
 //}
 
 // Marcar uma classe como abstrata significa que ela contém métodos abstratos que devem
-// ser definido em uma classe filha. Semelhante às interfaces, classes abstratas não podem
-// ser instanciadas, ao invés disso devem ser extendidas e os métodos abstratos
+// ser definidos em uma classe filha. Semelhante às interfaces, classes abstratas não podem
+// ser instanciadas, ao invés disso devem ser estendidas e os métodos abstratos
 // definidos. Diferente de interfaces, classes abstratas podem conter uma mistura de
 // métodos concretos e abstratos. Métodos em uma interface não podem ter um corpo,
 // a menos que o método seja estático, e as variáveis sejam finais, por padrão, ao contrário de um
@@ -482,7 +486,7 @@ public abstract class Animal
 
     // Não há necessidade de inicializar, no entanto, em uma interface
     // a variável é implicitamente final e, portanto, tem
-    // de ser inicializado.
+    // de ser inicializada.
     protected int idade;
 
     public void mostrarIdade()
@@ -501,7 +505,7 @@ class Cachorro extends Animal
 {
 
     // Nota: ainda precisamos substituir os métodos abstratos na
-    // classe abstrata
+    // classe abstrata.
     @Override
     public void fazerSom()
     {
@@ -532,13 +536,13 @@ class Cachorro extends Animal
 //}
 
 // Classes finais são classes que não podem ser herdadas e são, portanto, um
-// filha final. De certa forma, as classes finais são o oposto de classes abstratas
-// Porque classes abstratas devem ser estendidas, mas as classes finais não pode ser
+// filho final. De certa forma, as classes finais são o oposto de classes abstratas,
+// porque classes abstratas devem ser estendidas, mas as classes finais não podem ser
 // estendidas.
 public final class TigreDenteDeSabre extends Animal
 {
     // Nota: Ainda precisamos substituir os métodos abstratos na
-     // classe abstrata.
+    // classe abstrata.
     @Override
     public void fazerSom();
     {
@@ -552,7 +556,7 @@ public abstract class Mamifero()
     // Sintaxe de Métodos Finais:
     // <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
 
-    // Métodos finais, como, classes finais não podem ser substituídas por uma classe filha,
+    // Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
     // e são, portanto, a implementação final do método.
     public final boolean EImpulsivo()
     {
@@ -626,11 +630,11 @@ Os links fornecidos aqui abaixo são apenas para ter uma compreensão do tema, u
 
 Outros tópicos para pesquisar:
 
-* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html) 
+* [Tutorial Java para Sun Trail / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
 
 * [Modificadores de acesso do Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
 
-* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): 
+* [Coceitos de Programação Orientada à Objetos](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
     * [Herança](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
     * [Polimorfismo](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
     * [Abstração](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
@@ -646,3 +650,9 @@ Outros tópicos para pesquisar:
 Livros:
 
 * [Use a cabeça, Java] (http://www.headfirstlabs.com/books/hfjava/)
+
+Apostila:
+
+* [Java e Orientação a Objetos] (http://www.caelum.com.br/apostila-java-orientacao-objetos/)
+
+* [Java para Desenvolvimento Web] (https://www.caelum.com.br/apostila-java-web/)
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 59c6890e..e337f4bc 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -197,7 +197,6 @@ myObj.myFourthKey; // = undefined
 
 // A sintaxe para essa seção é quase idêntica a maioria das linguagens.
 
-// The `if` structure works as you'd expect.
 // A estrutura `if` funciona como deveria ser.
 var count = 1
 if (count == 3){
@@ -219,9 +218,6 @@ do {
     input = getInput();
 } while (!isValid(input))
 
-// The `for` loop is the same as C and Java:
-// initialisation; continue condition; iteration.
-
 // O loop `for` é o mesmo de C e Java:
 // inicialização, condição para continuar; iteração
 for (var i = 0; i < 5; i++){
diff --git a/pt-br/jquery-pt.html.markdown b/pt-br/jquery-pt.html.markdown
new file mode 100644
index 00000000..d49bea0f
--- /dev/null
+++ b/pt-br/jquery-pt.html.markdown
@@ -0,0 +1,131 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+    - ["Nikolas Silva", "https://github.com/nikolassilva"]
+filename: jquery-pt.js
+lang: pt-br
+---
+
+jQuery é uma biblioteca JavaScript que te ajuda a "fazer mais, escrevendo menos". Ela faz com que muitas tarefas comuns em JavaScript sejam mais simples de escrever. jQuery é usado por grandes empresas e desenvolvedores do mundo todo. Ela torna o AJAX, manipulação de eventos, manipulação do DOM, entre outros, mais fácil e rápido.
+
+Pelo jQuery ser uma biblioteca JavaScript você deve [aprende-lo primeiro](https://learnxinyminutes.com/docs/pt-br/javascript-pt/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Seletores
+
+// Seletores no jQuery são usados para selecionar um elemento
+var page = $(window); // Seleciona toda a viewport
+
+// Seletores também podem ser na forma do CSS
+var paragraph = $('p'); // Seleciona todos elementos de parágrafo
+var table1 = $('#table1'); // Seleciona o elemento com id 'table1'
+var squares = $('.square'); // Seleciona todos elementos com classe 'square'
+var square_p = $('p.square') // Seleciona todos elementos de parágrafo com a classe 'square'
+
+
+///////////////////////////////////
+// 2. Eventos e Efeitos
+// jQuery é muito bom em manipular o que acontece quando um evento é disparado
+// Um evento muito usado é o 'ready'  
+// Você pode usar o método ready para esperar até que um elemento tenha terminado de carregar
+$(document).ready(function(){
+  // O código não será executado até que o documento carregue
+});
+// Você também pode usar funções declaradas
+function onAction() {
+  // Isso será executado quando um evento for disparado
+}
+$('#btn').click(onAction); // Chama 'onAction' quando o elemento receber um clique
+
+// Outros eventos comuns são:
+$('#btn').dblclick(onAction); // Clique duplo
+$('#btn').hover(onAction); // Mouse sobre elemento
+$('#btn').focus(onAction); // Elemento recebe foco
+$('#btn').blur(onAction); // Elemento perde foco
+$('#btn').submit(onAction); // Envio de formulário
+$('#btn').select(onAction); // Quando o elemento é selecionado
+$('#btn').keydown(onAction); // Quando uma tecla é segurada
+$('#btn').keyup(onAction); // Quando uma tecla é solta
+$('#btn').keypress(onAction); // Quando uma tecla é pressionada
+$('#btn').mousemove(onAction); // Quando o mouse é movido
+$('#btn').mouseenter(onAction); // Quando o mouse entra no elemento
+$('#btn').mouseleave(onAction); // Quando o mouse sai do elemento
+
+
+// Eles também podem disparar os eventos em vez de manipulá-los,
+// simplesmente deixando de passar os parâmetros
+$('#btn').dblclick(); // Dispara um clique duplo no elemento
+
+// Você pode manipular múltiplos eventos usando o seletor apenas uma vez
+$('#btn').on(
+  {dblclick: myFunction1} // Disparado num clique duplo
+  {blur: myFunction1} // Disparado quando perder o foco
+);
+
+// Você pode mover e esconder elementos com alguns métodos de efeito
+$('.table').hide(); // Esconde o elemento
+
+// Nota: chamar uma função nesse método ainda irá esconder o elemento
+$('.table').hide(function(){
+    // Elemento é escondido e a função é executada
+});
+
+// Você pode guardar seletores em variáveis
+var tables = $('.table');
+
+// Alguns métodos básicos de manipulação do DOM:
+tables.hide(); // Esconde elemento(s)
+tables.show(); // Exibe elemento(s)
+tables.toggle(); // Alterna entre esconder/exibir
+tables.fadeOut(); // Efeito fade out
+tables.fadeIn(); // Efeito fade in
+tables.fadeToggle(); // Alterna entre fade out/in
+tables.fadeTo(0.5); // Efeito fade com opacidade específica (entre 0 e 1)
+tables.slideUp(); // Efeito de deslize pra cima
+tables.slideDown(); // Efeito de deslize pra baixo
+tables.slideToggle(); // Alterna entre deslizar pra cima/baixo
+
+// Todos os métodos acima levam velocidade (em milissegundos) e uma função callback
+tables.hide(1000, myFunction); // Esconde o elemento em 1 segundo e chama a função
+
+// No fadeTo é obrigatório definir a opacidade como segundo parâmetro
+tables.fadeTo(2000, 0.1, myFunction); // 2 segundos de fade para 0.1 de opacidade e chama a função
+
+// Você pode fazer animações mais avançadas com o método animate
+tables.animate({'margin-top':"+=50", height: "100px"}, 500, myFunction);
+// O método animate leva um objeto com valores CSS,
+// um parâmetro de opções para melhorar a animação
+// e uma função callback, como de costume
+
+///////////////////////////////////
+// 3. Manipulação
+
+// São similares aos efeitos, mas podem fazer mais
+$('div').addClass('taming-slim-20'); // Adiciona a classe taming-slim-20 em todas as divs
+
+// Métodos comuns de manipulação
+$('p').append('Hello world'); // Adiciona ao final do elemento
+$('p').attr('class'); // Obtém o valor de um atributo
+$('p').attr('class', 'content'); // Define o valor de um atributo
+$('p').hasClass('taming-slim-20'); // Retorna true se tiver a classe
+$('p').height(); // Obtém/define a altura do elemento
+
+
+// Pra maioria dos métodos de manipulação, pegar o valor de um 
+// elemento só afetará o primeiro deles
+$('p').height(); // Obtém a altura da primeira tag 'p'
+
+// Você pode usar o método each pra percorrer os elementos
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Adiciona a altura das tags 'p' na array
+});
+
+
+```
diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown
new file mode 100644
index 00000000..48d97e58
--- /dev/null
+++ b/pt-br/julia-pt.html.markdown
@@ -0,0 +1,748 @@
+---
+language: Julia
+filename: learnjulia-pt.jl
+contributors:
+    - ["Leah Hanson", "http://leahhanson.us"]
+translators:
+    - ["Davidson Mizael", "https://github.com/davidsonmizael"]
+lang: pt-br
+---
+
+Julia é uma linguagem homoiconic funcional focada na computação tecnica. Ao mesmo tempo que ela tem todo o poder dos homoiconic macros, funções de primeira classe, e controle de baixo nivel, Julia é tão facil para aprender e usar quanto Python.
+
+Este tutorial é baseado no Julia 0.3.
+
+```ruby
+# Linhas únicas de comentários começam com o simbolo hash(jogo da velha).
+#= Comentários de multiplas linhas podem ser escritos
+   colocando '#=' antes do texto e '=#'
+   após o texto. Eles também podem ser agrupados
+=#
+
+####################################################
+## 1. Tipos primitivos e operadores
+####################################################
+
+# Tudo em Julia é uma expressão.
+
+# Há muitos tipos básicos de numeros.
+3 # => 3 (Int64)
+3.2 # => 3.2 (Float64)
+2 + 1im # => 2 + 1im (Complex{Int64})
+2//3 # => 2//3 (Rational{Int64})
+
+# Todos os operadores inseguros normais estão disponiveis.
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7.0
+5 / 2 # => 2.5 # dividir um Int por um Int resulta em um float
+div(5, 2) # => 2 # para um restultado truncado, use div
+5 \ 35 # => 7.0
+2 ^ 2 # => 4 # elevado,não o opeardor binário xor
+12 % 10 # => 2
+
+# Impõe a priodidade nos parenteses
+(1 + 3) * 2 # => 8
+
+# Operadores binarios
+~2 # => -3   # not
+3 & 5 # => 1 # and
+2 | 4 # => 6 # or
+2 $ 4 # => 6 # xor
+2 >>> 1 # => 1 # deslocamento lógico de bits a direita
+2 >> 1  # => 1 # deslocamento aritmético de bits a direita
+2 << 1  # => 4 # deslocamento lógico/aritmético de bits a esquerda
+
+# Você pode usar a função bits para ver a representação binária de um numero.
+bits(12345)
+# => "0000000000000000000000000000000000000000000000000011000000111001"
+bits(12345.0)
+# => "0100000011001000000111001000000000000000000000000000000000000000"
+
+# Valores booleanos são primitivos.
+true
+false
+
+# Operadores booleanos
+!true # => false
+!false # => true
+1 == 1 # => true
+2 == 1 # => false
+1 != 1 # => false
+2 != 1 # => true
+1 < 10 # => true
+1 > 10 # => false
+2 <= 2 # => true
+2 >= 2 # => true
+# Comparações podem ser encadeadas
+1 < 2 < 3 # => true
+2 < 3 < 2 # => false
+
+# Strings são criadas com  "
+"Isso é uma String."
+
+# Caracteres literais são escritos com '
+'a'
+
+# Uma string pode ser indexada como um vetor de caracteres
+"Isso é uma string"[1] # => 'I' # Julia começa a indexar a partir do 1
+# Porém isso não funcionará direito com strings em UTF8,
+# portanto é recomendado usar iterações sobre uma string (map, loops com for, etc). 
+
+# $ pode ser usado para interpolação de string:
+"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
+# Você pode usar qualquer expressão Julia dentro dos parenteses.
+
+# Outro jeito de formatar strings é com um macro no printf.
+@printf "%d é menor que %f" 4.5 5.3 # 5 é menor que 5.300000
+
+# Escrever na tela é fácil
+println("Eu sou Julia. Prazer em conhece-lo!")
+
+####################################################
+## 2. Variáveis e coleções
+####################################################
+
+#Você não declara variáveis antes de atribui-lás.
+some_var = 5 # => 5
+some_var # => 5
+
+# Acessando a variável anterior não iniciada é um erro
+try
+    some_other_var # => ERROR: some_other_var não definida 
+catch e
+    println(e)
+end
+
+# Nomes de variáveis começam com uma letra.
+# Depois disso, você pode usar letras, digitos, underscores e pontos de exclamação.
+SomeOtherVar123! = 6 # => 6
+
+# Você também pode usar caractéres unicode
+☃ = 8 # => 8
+# Estes são especialmente reservados para notações matemáticas.
+2 * π # => 6.283185307179586
+
+# Uma nota na convenção de nomes em Julia:
+#
+# * A separação de palavras pode ser feita por underscores ('_'), mas o uso
+#   de underscore é desencorajado a menos que o nome da variável seja dificil
+#   de ler.
+#
+# * Os nomes de tipos começam com letra maiúscula e a separação de letras é 
+#   feita a partir de CamelCase no lugar de underscores.
+#
+# * Nomes de funções e macros são em minúsculo, sem underscore.
+#
+# * Funções que modificam a própria entrada tem nomes que terminam em !. Estas
+#   funções são chamadas as vezes de funções de mutação ou função in-place.
+
+# Vetores armazenam uma sequencia de valores indexados por integer de 1 a n:
+a = Int64[] # => 0-element Int64 Array
+
+# 1-Vetores dimensionais literais podem ter seus valores separados por virgula.
+b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
+b[1] # => 4
+b[end] # => 6
+
+# 2-Vetores dimensionais usam espaço para separar valores e ponto e virgula para linhas.
+matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
+
+# Adiciona-se coisas ao final de uma lista com push! e append!
+push!(a,1)     # => [1]
+push!(a,2)     # => [1,2]
+push!(a,4)     # => [1,2,4]
+push!(a,3)     # => [1,2,4,3]
+append!(a,b) # => [1,2,4,3,4,5,6]
+
+# Remove-se do final com pop!
+pop!(b)        # => 6 e 'b' agora é [4,5]
+
+# Vamos coloca-lo de novo
+push!(b,6)   # 'b' agora é [4,5,6] de novo.
+
+a[1] # => 1 # lembre-se que Julia indexa a partir de 1, não 0.
+
+# end é um atalho para a ultima posição. Pode ser usada em qualquer
+# expressão indexada.
+a[end] # => 6
+
+# nós também temos shift e unshift
+shift!(a) # => 1 e 'a' agora é [2,4,3,4,5,6]
+unshift!(a,7) # => [7,2,4,3,4,5,6]
+
+# Funções que terminam com ponto de exclamação indicam que elas modificam
+# seus argumentos.
+arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
+sort(arr) # => [4,5,6]; 'arr' continua [5,4,6]
+sort!(arr) # => [4,5,6]; 'arr' agora é [4,5,6]
+
+# Olhar além dos limites é um BoundsError
+try
+    a[0] # => ERROR: BoundsError() in getindex at array.jl:270
+    a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+catch e
+    println(e)
+end
+
+# Erros listam a linha e o nome do arquivo que ele está, mesmo se for uma 
+# biblioteca padrão. Se você construiu Julia pelo source, você pode olhar na 
+# pasta base dentro da pasta do Julia para encontrar esses arquivos.
+
+# Você pode inicializar vetores com limites
+a = [1:5;] # => 5-element Int64 Array: [1,2,3,4,5]
+
+# Você pode ver até um limite com a sintaxe separada
+a[1:3] # => [1, 2, 3]
+a[2:end] # => [2, 3, 4, 5]
+
+# Remova elementos de um array pelo index com splice!
+arr = [3,4,5]
+splice!(arr,2) # => 4 ; arr is now [3,5]
+
+# Concatene listas com append!
+b = [1,2,3]
+append!(a,b) # 'a' agora é [1, 2, 3, 4, 5, 1, 2, 3]
+
+# Cheque se um valor existe me uma lista com in
+in(1, a) # => true
+
+# Veja o tamanho com lenght
+length(a) # => 8
+
+# Tuples não podem ser mudados.
+tup = (1, 2, 3) # => (1,2,3) # um tuple (Int64,Int64,Int64).
+tup[1] # => 1
+try:
+    tup[1] = 3 # => ERROR: não há metodo setindex!((Int64,Int64,Int64),Int64,Int64)
+catch e
+    println(e)
+end
+
+# Muitas litas de funções também trabalham com tuples
+length(tup) # => 3
+tup[1:2] # => (1,2)
+in(2, tup) # => true
+
+#Você pode desempacotar tuples para variáveis.
+a, b, c = (1, 2, 3) # => (1,2,3)  # 'a' agora é 1, 'b' agora é 2 e 'c' agora é 3
+
+# Tuplas são criados mesmo se você deixar fora dos parenteses
+d, e, f = 4, 5, 6 # => (4,5,6)
+
+# Uma tupla de um elemento é diferente do valor que ele contém
+(1,) == 1 # => false
+(1) == 1 # => true
+
+# Olhe como é facil pra trocar dois valores
+e, d = d, e  # => (5,4) # 'd' agora é 5 e 'e' agora é 4
+
+# Dicionários armazenam mapeamentos
+empty_dict = Dict() # => Dict{Any,Any}()
+
+# Você pode criar um dicionário usando um literal
+filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+# => Dict{ASCIIString,Int64}
+
+# Veja os valores com []
+filled_dict["one"] # => 1
+
+# Pegue todas as chaves
+keys(filled_dict)
+# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Nota - as chaves dos dicionários não são ordenadas nem estão na ordem que você as inseriu.
+
+# Pegue todos os valores
+values(filled_dict)
+# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Nota - A mesma coisa que na nota acima sobre a ordenação das chaves.
+
+# Cheque pela existencia de chaves em um dicionário com in e haskey
+in(("one", 1), filled_dict) # => true
+in(("two", 3), filled_dict) # => false
+haskey(filled_dict, "one") # => true
+haskey(filled_dict, 1) # => false
+
+# Procurar por uma chave não existente irá gerar um erro
+try
+    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+catch e
+    println(e)
+end
+
+# Use o método get para escapar desse erro passando um valor padrão
+# get(dictionary,key,default_value)
+get(filled_dict,"one",4) # => 1
+get(filled_dict,"four",4) # => 4
+
+# Use sets para representar coleções de valores unicos e não ordenados
+empty_set = Set() # => Set{Any}()
+# Inicialize um set com valores
+filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+
+# Adicione mais valores para um set
+push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+
+# Cheque se um valor está no set
+in(2, filled_set) # => true
+in(10, filled_set) # => false
+
+# Não há funções para interseção de set, união e diferença.
+other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
+union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
+setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+
+####################################################
+## 3. Controle de fluxo
+####################################################
+
+# Vamos fazer uma variável
+some_var = 5
+
+# Aqui está um if. Identação nao é importante em Julia.
+if some_var > 10
+    println("some_var é totalmente maior que 10.")
+elseif some_var < 10    # Essa clausula elseif é opcional.
+    println("some_var é menor que 10.")
+else                    # A clausula else é opcional também.
+    println("some_var é literalmente 10.")
+end
+# => exibe "some_var é menor que 10"
+
+# Loops for repetem sobre variaveis iteráveis.
+# Tipos iterativos incluem Range, Array, set Dict e String.
+for animal=["dog", "cat", "mouse"]
+    println("$animal is a mammal")
+	# Você pode interpolar variáveis usando $ ou expressões em strings
+end
+# exibe:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+# Você pode usar 'in' no lugar de '='.
+for animal in ["dog", "cat", "mouse"]
+    println("$animal is a mammal")
+end
+# exibe:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+    println("$(a[1]) is a $(a[2])")
+end
+# exibe:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+    println("$k is a $v")
+end
+# exibe:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+# Loops while circulam enquanto a condição é true
+x = 0
+while x < 4
+    println(x)
+    x += 1  # Abreveação para x = x + 1
+end
+# exibe:
+#   0
+#   1
+#   2
+#   3
+
+# Trate exceções com um bloco try/catch
+try
+   error("help")
+catch e
+   println("caught it $e")
+end
+# => caught it ErrorException("help")
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# A palavra chave 'function' cria novas funções
+#function name(arglist)
+#  corpo...
+#end
+function add(x, y)
+    println("x is $x and y is $y")
+
+	# Funções retornam o valor da sua ultima declaração
+t    x + y
+end
+
+add(5, 6) # => 11 after printing out "x is 5 and y is 6"
+
+# Você pode definir funções que tomam um numero incerto de
+# argumentos 
+function varargs(args...)
+    return args
+    # use a palavra chave return para retornar um valor em qualquer parte da função
+end
+# => varargs (generic function with 1 method)
+
+varargs(1,2,3) # => (1,2,3)
+
+# O ... é chamado de splat.
+# Nós apenas o usamos na definição de uma função.
+# Também pode ser usado na chamada de uma função,
+# onde ela vai abrir um Array ou o conteúdo de um Tuple na lista de argumentos.
+Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # produz um Set de Arrays
+Set([1,2,3]...) # => Set{Int64}(1,2,3) # isso é equivalente a Set(1,2,3)
+
+x = (1,2,3)     # => (1,2,3)
+Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # um Set de Tuples
+Set(x...)       # => Set{Int64}(2,3,1)
+
+# Você pode definir funções com argumentos posicionais opcionais.
+function defaults(a,b,x=5,y=6)
+    return "$a $b and $x $y"
+end
+
+defaults('h','g') # => "h g and 5 6"
+defaults('h','g','j') # => "h g and j 6"
+defaults('h','g','j','k') # => "h g and j k"
+try
+    defaults('h') # => ERROR: no method defaults(Char,)
+    defaults() # => ERROR: no methods defaults()
+catch e
+    println(e)
+end
+
+# Você pode definir funções que tomam argumentos como palavras chaves
+function keyword_args(;k1=4,name2="hello") # note the ;
+    return ["k1"=>k1,"name2"=>name2]
+end
+
+keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
+keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
+keyword_args() # => ["name2"=>"hello","k1"=>4]
+
+# Você pode combinar todos os tipos de argumentos em uma só função
+function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
+    println("normal arg: $normal_arg")
+    println("optional arg: $optional_positional_arg")
+    println("keyword arg: $keyword_arg")
+end
+
+all_the_args(1, 3, keyword_arg=4)
+# exibe:
+#   normal arg: 1
+#   optional arg: 3
+#   keyword arg: 4
+
+# Julia tem funções de primeira classe
+function create_adder(x)
+    adder = function (y)
+        return x + y
+    end
+    return adder
+end
+
+# Isso é "sintexe furiosa de lambda" pra criar funções anônimas.
+(x -> x > 2)(3) # => true
+
+#Esta função é identica a implementação da create_adder acima.
+function create_adder(x)
+    y -> x + y
+end
+
+# Você também pode nomear funções internas, se você quiser
+function create_adder(x)
+    function adder(y)
+        x + y
+    end
+    adder
+end
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+
+# Há 
+# There are built-in higher order functions
+map(add_10, [1,2,3]) # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Nós podemos usar listas de compreensão para melhores mapeamentos
+[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+
+####################################################
+## 5. Tipos
+####################################################
+
+#Julia tem um sistema de tipos.
+# Todo valor tem um tipo. Variaveis não tem tipos próprios.
+# Você pode usar a função 'typeof' para pegar o valor.
+typeof(5) # => Int64
+
+# Tipos são valores de primeira classe.
+typeof(Int64) # => DataType
+typeof(DataType) # => DataType
+# DataType é o tipo que representa tipos, incluindo ele mesmo.
+
+# Tipos são usados para documentação, optimização e envio
+# Eles não são estaticamente checados.
+
+# Usuários podem definir tipos
+# Eles são como records ou structs em outras linguagens.
+# Novos tipos são definidos usando a palavra chave 'type'
+
+# type Name
+#   field::OptionalType
+#   ...
+# end
+type Tiger
+  taillength::Float64
+  coatcolor # não incluindo uma notação type é o mesmo que '::Any'
+end
+
+# Os argumentos padrões de um construtor são as propriedades
+# do tipo na ordem que eles são listados na definição.
+tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+
+# O tipo double como construtor de função para valores desse tipo
+# The type doubles as the constructor function for values of that type
+sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+
+# Esses tipos no estilo struct são chamados tipos concretos
+# Eles podem ser instanciados, mas não podem ter subtipos.
+# O outro tipo de tipos são os tipos abstratos.
+
+# abstract Name
+abstract Cat # apenas um nome e um ponto na hierarquia de tipo
+
+# Tipos abstratos podem ser instanciados, mas não podem ter subtipos.
+# Por exemplo, Number é um tipo abstrato
+subtypes(Number) # => 6-element Array{Any,1}:
+                 #     Complex{Float16}
+                 #     Complex{Float32}
+                 #     Complex{Float64}
+                 #     Complex{T<:Real}
+                 #     ImaginaryUnit
+                 #     Real
+subtypes(Cat) # => 0-element Array{Any,1}
+
+# Todo tipo tem um super tipo; use a função 'super' para pegá-lo.
+typeof(5) # => Int64
+super(Int64) # => Signed
+super(Signed) # => Real
+super(Real) # => Number
+super(Number) # => Any
+super(super(Signed)) # => Number
+super(Any) # => Any
+# Todos esss tipos, exceto o Int64, são abstratos.
+
+# <: é o operador de subtipagem
+type Lion <: Cat # Lion é um subtipo de Cat
+  mane_color
+  roar::String
+end
+
+# Você pode definir mais construtores para seu tipo
+# É só definir uma função com o mesmo nome do tipo
+# e chamar um construtor existente para pegar o valor do tipo correto
+Lion(roar::String) = Lion("green",roar)
+# Isso é um construtor externo porque ele está fora da definição do tipo
+
+type Panther <: Cat # Panther também é um subtipo de Cat
+  eye_color
+  Panther() = new("green")
+# Panthers terão apenas esse construtor, e não construtor padrão.
+end
+# Usando construtores internos, como Panther faz, lhe da o controle
+# sobre como os valores dos tipos são criados.
+# Quando possivel, você deve usar construtores externos mais do que internos.
+
+####################################################
+## 6. Multiple-Dispatch
+####################################################
+
+
+# Em Julia todas as funções nomeadas são funções genericas
+# Isso significa que elas são construidas de muitos métodos pequenos
+# Cada construtor para Lion é um metodo da função genérica Lion.Lion.
+
+# Para um exemplo sem construtor, vamos fazer a função meow
+
+# Definição para Lion, Panther e Tiger
+function meow(animal::Lion)
+  animal.roar #propriedades do tipo de acesso usando a notação ponto '.'
+end
+
+function meow(animal::Panther)
+  "grrr"
+end
+
+function meow(animal::Tiger)
+  "rawwwr"
+end
+
+# Testando a função meow
+meow(tigger) # => "rawwr"
+meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(Panther()) # => "grrr"
+
+# Revendo o tipo local de hierarchy
+issubtype(Tiger,Cat) # => false
+issubtype(Lion,Cat) # => true
+issubtype(Panther,Cat) # => true
+
+# Definindo uma função que recebe Cats
+function pet_cat(cat::Cat)
+  println("The cat says $(meow(cat))")
+end
+
+pet_cat(Lion("42")) # => exibe "The cat says 42"
+try
+    pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+catch e
+    println(e)
+end
+
+# Em linguagens orientadas a objeto, envio unico é comúm
+# isso significa que o método é selecionado baseado no tipo do seu primeiro argumento
+# Em Julia todos os tipos de argumentos contribuem na seleção do melhor método
+
+
+# Vamos definir uma função com mais argumentos, então poderemos ver a diferença
+function fight(t::Tiger,c::Cat)
+  println("The $(t.coatcolor) tiger wins!")
+end
+# => fight (generic function with 1 method)
+
+fight(tigger,Panther()) # => exibe The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => exibir The orange tiger wins!
+
+# Vamos mudar o comportamento quando o gato é especificamente um leão
+fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+# => fight (generic function with 2 methods)
+
+fight(tigger,Panther()) # => exobe The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => exobe The green-maned lion wins!
+
+# Nós não precisamos de um tigre para brigar
+fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# => fight (generic function with 3 methods)
+
+fight(Lion("balooga!"),Panther()) # => exibe The victorious cat says grrr
+try
+  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
+catch
+end
+
+# Aliás, vamos deixar o gato ir primeiro
+fight(c::Cat,l::Lion) = println("The cat beats the Lion")
+# => Warning: New definition
+#    fight(Cat,Lion) at none:1
+# is ambiguous with
+#    fight(Lion,Cat) at none:2.
+# Make sure
+#    fight(Lion,Lion)
+# is defined first.
+#fight (generic function with 4 methods)
+
+# Este aviso é porque não está claro qual método fight será chamado em:
+fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The victorious cat says rarrr
+# O resultado pode ser diferente em outras versões de Julia
+
+fight(l::Lion,l2::Lion) = println("The lions come to a tie")
+fight(Lion("RAR"),Lion("brown","rarrr")) # => exibe The lions come to a tie
+
+
+# Embaixo dos panos
+# Você pode olhar o llvm e o código assembly gerado.
+
+square_area(l) = l * l      # square_area (generic function with 1 method)
+
+square_area(5) #25
+
+# O que acontece quando alimentamos square_area com um inteiro?
+# What happens when we feed square_area an integer?
+code_native(square_area, (Int32,))  
+    #       .section    __TEXT,__text,regular,pure_instructions
+    #   Filename: none
+    #   Source line: 1              # Prólogo
+    #       push    RBP
+    #       mov RBP, RSP
+    #   Source line: 1
+    #       movsxd  RAX, EDI        # Busca l na memoria?
+    #       imul    RAX, RAX        # Faz o quadrado de l e armazena o resultado em RAX
+    #       pop RBP                 # Restaura o ponteiro de base antigo
+    #       ret                     # O resultado continua em RAX
+
+code_native(square_area, (Float32,))
+    #       .section    __TEXT,__text,regular,pure_instructions
+    #   Filename: none
+    #   Source line: 1
+    #       push    RBP
+    #       mov RBP, RSP
+    #   Source line: 1
+    #       vmulss  XMM0, XMM0, XMM0  # Múltiplicação escalar unica de precisão (AVX)
+    #       pop RBP
+    #       ret
+
+code_native(square_area, (Float64,))
+    #       .section    __TEXT,__text,regular,pure_instructions
+    #   Filename: none
+    #   Source line: 1
+    #       push    RBP
+    #       mov RBP, RSP
+    #   Source line: 1
+    #       vmulsd  XMM0, XMM0, XMM0 # Duplicação ecalar de precisão multipla(AVX)
+    #       pop RBP
+    #       ret
+    #   
+# Note que Julia usará instruções de ponto flutuante se quaser um dos
+# argumentos forem float
+# Vamos calcular a área de um circulo
+circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
+circle_area(5)                  # 78.53981633974483
+
+code_native(circle_area, (Int32,))
+    #       .section    __TEXT,__text,regular,pure_instructions
+    #   Filename: none
+    #   Source line: 1
+    #       push    RBP
+    #       mov RBP, RSP
+    #   Source line: 1
+    #       vcvtsi2sd   XMM0, XMM0, EDI          # Carrega inteiro (r) da memória
+    #       movabs  RAX, 4593140240              # Carrega pi
+    #       vmulsd  XMM1, XMM0, QWORD PTR [RAX]  # pi * r
+    #       vmulsd  XMM0, XMM0, XMM1             # (pi * r) * r
+    #       pop RBP
+    #       ret
+    #
+
+code_native(circle_area, (Float64,))
+    #       .section    __TEXT,__text,regular,pure_instructions
+    #   Filename: none
+    #   Source line: 1
+    #       push    RBP
+    #       mov RBP, RSP
+    #       movabs  RAX, 4593140496
+    #   Source line: 1
+    #       vmulsd  XMM1, XMM0, QWORD PTR [RAX]
+    #       vmulsd  XMM0, XMM1, XMM0
+    #       pop RBP
+    #       ret
+    #   
+```
+
+## Extras
+
+Você pode ver mais um monte de detalhes no [manual de Julia] (http://docs.julialang.org/en/latest/manual/)
+O melhor lugar pra pedir ajuda em Julia é a (muito amigável) [mailing list](https://groups.google.com/forum/#!forum/julia-users).
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index 4030ce3c..f22093f9 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -56,7 +56,7 @@ __E este também está._
 *--Danouse! Este também__*
 
 <!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
-Github, nós também temos: --> 
+GitHub, nós também temos: --> 
 
 ~~Este texto é processado com tachado.~~
 
@@ -148,7 +148,7 @@ dentro do seu código -->
 
 John não sabia nem o que o função 'goto()' fazia!
 
-<!-- Em Github Flavored Markdown, você pode usar uma sintaxe especial para o código -->
+<!-- Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código -->
 
 \`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
 ruby! --> 
@@ -157,7 +157,7 @@ def foobar
 end
 \`\`\` <!-- Aqui também, não barras invertidas, apenas ``` -->
 
-<-- O texto acima não requer recuo, mas o Github vai usar a sintaxe 
+<-- O texto acima não requer recuo, mas o GitHub vai usar a sintaxe 
 destacando do idioma que você especificar após a ``` -->
 
 <!-- Regra Horizontal (<hr />) --> 
@@ -230,7 +230,7 @@ Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja
 em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*.
 
 <!-- Tabelas --> 
-<!-- Tabelas estão disponíveis apenas no Github Flavored Markdown e são ligeiramente 
+<!-- Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente 
 complicadas, mas se você realmente quer: -->
 
 | Col1         | Col2     | Col3          |
diff --git a/pt-br/paren-pt.html.markdown b/pt-br/paren-pt.html.markdown
new file mode 100644
index 00000000..464a69d2
--- /dev/null
+++ b/pt-br/paren-pt.html.markdown
@@ -0,0 +1,196 @@
+---
+language: Paren
+filename: learnparen-pt.paren
+contributors:
+  - ["KIM Taegyoon", "https://github.com/kimtg"]
+translators:
+    - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+---
+
+[Paren](https://bitbucket.org/ktg/paren) é um dialeto do Lisp. É projetado para ser uma linguagem embutida.
+
+Alguns exemplos foram retirados de <http://learnxinyminutes.com/docs/racket/>.
+
+```scheme
+;;; Comentários
+# Comentários
+
+;; Comentários de única linha começam com um ponto e vírgula ou cerquilha
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Tipos de Dados Primitivos e Operadores
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Números
+123 ; inteiro
+3.14 ; double
+6.02e+23 ; double
+(int 3.14) ; => 3 : inteiro
+(double 123) ; => 123 : double
+
+;; O uso de funções é feito da seguinte maneira (f x y z ...)
+;; onde f é uma função e x, y, z, ... são os operandos
+;; Se você quiser criar uma lista literal de dados, use (quote) para impedir
+;; que sejam interpretados
+(quote (+ 1 2)) ; => (+ 1 2)
+;; Agora, algumas operações aritméticas
+(+ 1 1)  ; => 2
+(- 8 1)  ; => 7
+(* 10 2) ; => 20
+(^ 2 3) ; => 8
+(/ 5 2) ; => 2
+(% 5 2) ; => 1
+(/ 5.0 2) ; => 2.5
+
+;;; Booleanos
+true ; para verdadeiro
+false ; para falso
+(! true) ; => falso
+(&& true false (prn "não chega aqui")) ; => falso
+(|| false true (prn "não chega aqui")) ; => verdadeiro
+
+;;; Caracteres são inteiros.
+(char-at "A" 0) ; => 65
+(chr 65) ; => "A"
+
+;;; Strings são arrays de caracteres de tamanho fixo.
+"Olá, mundo!"
+"Sebastião \"Tim\" Maia"   ; Contra-barra é um caractere de escape
+"Foo\tbar\r\n" ; Inclui os escapes da linguagem C: \t \r \n
+
+;; Strings podem ser concatenadas também!
+(strcat "Olá " "mundo!") ; => "Olá mundo!"
+
+;; Uma string pode ser tratada como uma lista de caracteres
+(char-at "Abacaxi" 0) ; => 65
+
+;; A impressão é muito fácil
+(pr "Isso é" "Paren. ") (prn "Prazer em conhecê-lo!")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variáveis
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Você pode criar ou definir uma variável usando (set)
+;; o nome de uma variável pode conter qualquer caracter, exceto: ();#"
+(set alguma-variavel 5) ; => 5
+alguma-variavel ; => 5
+
+;; Acessar uma variável ainda não atribuída gera uma exceção
+; x ; => Unknown variable: x : nil
+
+;; Ligações locais: Utiliza cálculo lambda! 
+;; 'a' e 'b' estão ligados a '1' e '2' apenas dentro de (fn ...)
+((fn (a b) (+ a b)) 1 2) ; => 3
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Coleções
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Listas
+
+;; Listas são estruturas de dados semelhantes a vetores. (A classe de comportamento é O(1).)
+(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
+;; 'list' é uma variação conveniente para construir listas
+(list 1 2 3) ; => (1 2 3)
+;; Um quote também pode ser usado para uma lista de valores literais
+(quote (+ 1 2)) ; => (+ 1 2)
+
+;; Você ainda pode utilizar 'cons' para adicionar um item ao início da lista
+(cons 0 (list 1 2 3)) ; => (0 1 2 3)
+
+;; Listas são um tipo muito básico, portanto existe *enorme* funcionalidade
+;; para elas, veja alguns exemplos:
+(map inc (list 1 2 3))          ; => (2 3 4)
+(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4))    ; => (2 4)
+(length (list 1 2 3 4))     ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Funções
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use 'fn' para criar funções.
+;; Uma função sempre retorna o valor de sua última expressão
+(fn () "Olá Mundo") ; => (fn () Olá Mundo) : fn
+
+;; Use parênteses para chamar todas as funções, incluindo uma expressão lambda
+((fn () "Olá Mundo")) ; => "Olá Mundo"
+
+;; Atribuir uma função a uma variável
+(set ola-mundo (fn () "Olá Mundo"))
+(ola-mundo) ; => "Olá Mundo"
+
+;; Você pode encurtar isso utilizando a definição de função açúcar sintático:
+(defn ola-mundo2 () "Olá Mundo")
+
+;; Os () acima é a lista de argumentos para a função
+(set ola
+  (fn (nome)
+    (strcat "Olá " nome)))
+(ola "Steve") ; => "Olá Steve"
+
+;; ... ou equivalente, usando a definição açucarada:
+(defn ola2 (nome)
+  (strcat "Olá " name))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Igualdade
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Para números utilize '=='
+(== 3 3.0) ; => verdadeiro
+(== 2 1) ; => falso
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Controle de Fluxo
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Condicionais
+
+(if true 				; Testa a expressão
+    "isso é verdade"	; Então expressão
+    "isso é falso") 	; Senão expressão
+; => "isso é verdade"
+
+;;; Laços de Repetição
+
+;; O laço for é para número
+;; (for SÍMBOLO INÍCIO FIM SALTO EXPRESSÃO ..)
+(for i 0 10 2 (pr i "")) ; => Imprime 0 2 4 6 8 10
+(for i 0.0 10 2.5 (pr i "")) ; => Imprime 0 2.5 5 7.5 10
+
+;; Laço while
+((fn (i)
+  (while (< i 10)
+    (pr i)
+    (++ i))) 0) ; => Imprime 0123456789
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutação
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Use 'set' para atribuir um novo valor a uma variável ou local
+(set n 5) ; => 5
+(set n (inc n)) ; => 6
+n ; => 6
+(set a (list 1 2)) ; => (1 2)
+(set (nth 0 a) 3) ; => 3
+a ; => (3 2)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Macros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Macros lhe permitem estender a sintaxe da linguagem.
+;; Os macros no Paren são fáceis.
+;; Na verdade, (defn) é um macro.
+(defmacro setfn (nome ...) (set nome (fn ...)))
+(defmacro defn (nome ...) (def nome (fn ...)))
+
+;; Vamos adicionar uma notação infixa
+(defmacro infix (a op ...) (op a ...))
+(infix 1 + 2 (infix 3 * 4)) ; => 15
+
+;; Macros não são higiênicos, você pode sobrescrever as variáveis já existentes!
+;; Eles são transformações de códigos.
+```
diff --git a/pt-br/php-composer-pt.html.markdown b/pt-br/php-composer-pt.html.markdown
new file mode 100644
index 00000000..145f5cab
--- /dev/null
+++ b/pt-br/php-composer-pt.html.markdown
@@ -0,0 +1,184 @@
+---
+category: tool
+tool: composer
+contributors:
+    - ["Brett Taylor", "https://github.com/glutnix"]
+translators:
+    - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: LearnComposer-pt.sh
+---
+
+[Composer](https://getcomposer.org/) é uma ferramenta de gerenciamento de dependências para PHP. Ele permite que você defina as bibliotecas que seu projeto precisa, e então ele as gerencia (instala/atualiza) para você.
+
+# Instalando
+
+```sh
+# Instala o binário composer.phar no diretório atual
+curl -sS https://getcomposer.org/installer | php
+# Se você fizer desta forma, você precisará chamar o composer assim:
+php composer.phar about
+
+# Instala o binário em ~/bin/composer
+# Nota: certifique-se de que ~/bin está na variável de ambiente PATH do seu shell
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Usuários Windows devem seguir as Instruções de instalação para Windows:
+https://getcomposer.org/doc/00-intro.md#installation-windows (EN)
+
+## Confirmando a instalação
+
+```sh
+# Verifica a versão e lista as opções
+composer
+
+# Para obter ajuda com os comandos
+composer help require
+
+# Verifica se o Composer tem as permissões necessárias e se está atualizado
+composer diagnose
+composer diag # atalho
+
+# Atualiza o binário do Composer para a última versão
+composer self-update
+composer self # atalho
+```
+
+# Modo de uso
+
+O Composer armazena as dependências do seu projeto em `composer.json`.
+Você pode editar este arquivo, mas é recomendável deixar que o Composer faça isso.
+
+```sh
+# Cria um novo projeto na pasta atual
+composer init
+# Executa um questionário interativo, te pedindo detalhes sobre o projeto.
+# Você pode deixar o questionário em branco, desde que não haja outros projetos dependendo deste.
+
+# Se um arquivo composer.json já existir, baixa as dependências
+composer install
+
+# Para baixar apenas as dependências de produção, excluindo as de desenvolvimento
+composer install --no-dev
+
+# Adiciona uma dependência de produção ao projeto
+composer require guzzlehttp/guzzle
+# O Composer se encarrega de verificar qual é a última versão de
+# guzzlehttp/guzzle, baixar e adicionar a nova dependência no
+# campo 'require' do composer.json
+
+composer require guzzlehttp/guzzle:6.0.*
+# O composer baixa a última versão que combine com o padrão informado (6.0.2, por exemplo)
+# e adiciona essa dependência ao campo 'require' do arquivo composer.json
+
+composer require --dev phpunit/phpunit:~4.5.0
+# O composer irá baixar a dependencia como desenvolvimento,
+# usando a versão mais recente >= 4.5.0 e < 4.6.0
+
+composer require-dev phpunit/phpunit:^4.5.0
+# O composer irá baixar a dependencia como desenvolvimento,
+# usando a versão mais recente >= 4.5.0 e < 5.0
+
+# Para mais informações sobre os padrões de versões, veja a
+# Documentação sobre Versões do Composer: https://getcomposer.org/doc/articles/versions.md (EN)
+
+# Para ver quais pacotes estão disopníveis e quais estão instalados
+composer show
+
+# Para ver quais pacotes estão instalados
+composer show --installed
+
+# Para encontrar um pacote que tenha 'mailgun' no nome ou descrição
+composer search mailgun
+```
+
+[Packagist.org](https://packagist.org/) é o repositório principal para pacotes Composer. Pesquise aqui por pacotes existentes.
+
+## `composer.json` vs `composer.lock`
+
+O arquivo `composer.json` armazena as preferências de de versão de cada dependência, além de outras informações
+
+O arquivo `composer.lock` armazena exatamente qual versão foi baixada para cada dependência. Nunca altere este arquivo.
+
+Se você incluir o arquivo `composer.lock` no seu repositório git, todos os desenvolvedores irão instalar a mesma versão das dependências que você.
+Mesmo se uma nova versão for lançada, o Composer baixará apenas a versão salva no arquivo de lock.
+
+```sh
+# Atualizar todas as dependências para a versão mais recente (ainda dentro das preferências definidas)
+composer update
+
+# Para atualizar a versão de uma dependência específica:
+composer update phpunit/phpunit
+
+# Para migrar um pacote para uma nova preferência de versão, você pode precisar
+# remover o pacote antigo e suas dependências primeiro
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+
+```
+
+## Autoloader
+
+O Composer cria uma classe autoloader que você pode usar na sua aplicação.
+Você pode instanciar as classes pelos seus namespaces.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### Autoloader da PSR-4
+
+Você pode adicionar seus próprios namespaces ao autoloader.
+
+No `composer.json`, adicione um campo 'autoload':
+
+```json
+{
+  "autoload": {
+    "psr-4": {"Acme\\": "src/"}
+  }
+}
+```
+Isso irá dizer ao autoloader para buscar na pasta `src` tudo o que estiver no namespace `\Acme\`.
+
+Você também pode [usar a PSR-0, um mapa de classes ou apenas listar os arquivos para incluir](https://getcomposer.org/doc/04-schema.md#autoload),
+e pode usar o campo `autoload-dev` para namespaces de desenvolvimento.
+
+Ao adicionar ou alterar alguma chave de autoload, você precisará recriar o autoloader
+
+```sh
+composer dump-autoload
+composer dump # shorthand
+
+# Otimiza pacotes PSR-0 e PSR-4 para carregar com mapas de classes também.
+# É mais demorado, mas melhora a performance em produção.
+composer dump-autoload --optimize --no-dev
+```
+
+# O cache do Composer
+
+```sh
+# O Composer irá evitar baixar pacotes caso eles estejam no cache. Para limpar o cache:
+composer clear-cache
+```
+
+# Resolução de problemas
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Tópicos (ainda) não falados neste tutorial
+
+* Criando e distribuindo seus próprios pacotes no Packagist.org ou qualquer lugar
+* Hooks Pré- e Pós-: rodar tarefas específicas em determinados eventos do Composer
+
+### Referências
+
+* [Composer - O gerenciador de dependências do PHP](https://getcomposer.org/) (EN)
+* [Packagist.org](https://packagist.org/) (EN)
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 0e710742..8a1c956e 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -7,7 +7,7 @@ translators:
     - ["Abdala Cerqueira", "http://abda.la"]
     - ["Raquel Diniz", "http://twitter.com/raquelrdiniz"]
 lang: pt-br
-filename: learnphp-pt.php
+filename: php-pt.html.markdown
 ---
 
 Este documento descreve PHP 5+.
@@ -20,21 +20,23 @@ Este documento descreve PHP 5+.
 
 // Duas barras iniciam o comentário de uma linha.
 
-# O hash (aka pound symbol) também inicia, mas // é mais comum
+# O hash (aka pound symbol) também inicia, mas // é mais comum.
 
 /*
      O texto envolto por barra-asterisco e asterisco-barra
-     faz um comentário de múltiplas linhas
+     faz um comentário de múltiplas linhas.
 */
 
-// Utilize "echo" ou "print" para imprimir a saída
-print('Olá '); // Imprime "Olá " sem quebra de linha
+// Utilize "echo" ou "print" para imprimir a saída.
+print('Olá '); // Imprime "Olá " sem quebra de linha.
+print 'Olá '; // Não tem a necessidade de utilizar as chaves.
 
 // () são opcionais para print e echo
-echo "Mundo\n"; // Imprime "Mundo" com quebra de linha
-// (Todas as declarações devem terminar com um ponto e vírgula)
+echo "Mundo\n"; // Imprime "Mundo" com quebra de linha.
+echo ("Mundo\n"); // Podemos tambem utilizar com chaves no echo.
+// (Todas as declarações devem terminar com um ponto e vírgula.)
 
-// Qualquer coisa fora da tag <?php é impresso automaticamente
+// Qualquer coisa fora da tag <?php é impresso automaticamente.
 ?>
 Olá mundo novamente!
 <?php
@@ -48,7 +50,7 @@ Olá mundo novamente!
 // Um nome de variável válido se inicia com uma letra ou sublinhado,
 // seguido por qualquer quantidade de letras, números ou sublinhados.
 
-// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive)
+// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive).
 $boolean = true;  // ou TRUE ou True
 $boolean = false; // ou FALSE ou False
 
@@ -63,8 +65,8 @@ $float = 1.234;
 $float = 1.2e3;
 $float = 7E-10;
 
-// Excluir variável
-unset($int1)
+// Excluir variável.
+unset($int1);
 
 // Aritmética
 $soma      = 1 + 1; // 2
@@ -79,17 +81,19 @@ echo $numero++;    // Imprime 1 (incrementa após a avaliação)
 echo ++$numero;    // Imprime 3 (incrementa antes da avaliação)
 $numero /= $float; // Divide e atribui o quociente de $numero
 
-// Strings podem ser colocadas entre aspas simples
+// Strings podem ser colocadas entre aspas simples.
 $sgl_quotes = '$String'; // => '$String'
 
 // Evite o uso de aspas duplas, exceto para incorporar outras variáveis
 $dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.'
 
-// Os caracteres especiais só são escapados entre aspas duplas
-$escapado    = "Este contém um \t caractere tab.";
-$naoescapado = 'Este contém somente a barra e o t: \t';
+// Os caracteres especiais só são escapados entre aspas duplas.
+$escapado    = "Este contém um \t caractere tab."; 
+echo $escapado; //Imprime: Este contém um     caractere tab.
+$naoescapado = 'Este contém somente a barra e o t: \t'; 
+echo $naoescapado; //Imprime: Este contém somente a barra e o t: \t
 
-// Coloque uma variável entre chaves se necessário
+// Coloque uma variável entre chaves se necessário.
 $dinheiro = "Eu tenho $${numero} no banco.";
 
 // Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise
@@ -105,7 +109,7 @@ $sgl_quotes
 FIM;
 
 // Concatenação de string é feita com .
-echo 'Esta string ' . 'é concatenada';
+echo 'Esta string ' . 'é concatenada'; //Imprime: 'Esta string é concatenada'
 
 
 /********************************
@@ -120,7 +124,7 @@ echo 'Esta string ' . 'é concatenada';
 define("FOO",     "alguma coisa");
 
 // Acesso a uma constante é possível usando diretamente o nome escolhido
-echo 'Isto sairá '.FOO;
+echo 'Isto sairá '.FOO; //Imprime: Isto sairá alguma coisa
 
 
 /********************************
@@ -135,16 +139,16 @@ $associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3);
 // PHP 5.4 introduziu uma nova sintaxe
 $associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3];
 
-echo $associativo['Um']; // imprime 1
+echo $associativo['Um']; // Imprime 1.
 
 // Uma lista de literais atribui chaves inteiras implicitamente
 $array = ['Um', 'Dois', 'Tres'];
-echo $array[0]; // => "Um"
+echo $array[0]; // Imprime => "Um"
 
 // Adiciona um elemento no final do array
 $array[] = 'Quatro';
 
-// Remove um elemento do array
+// Remove um elemento do array.
 unset($array[3]);
 
 /********************************
@@ -155,12 +159,12 @@ echo('Olá Mundo!');
 // Imprime Olá Mundo! para stdout.
 // Stdout é uma página web se executado em um navegador.
 
-print('Olá Mundo!'); // O mesmo que o echo
+print('Olá Mundo!'); // O mesmo que o echo.
 
 // echo é atualmente um construtor de linguagem, então você pode 
 // remover os parênteses.
-echo 'Olá Mundo!';
-print 'Olá Mundo!'; // O print também é
+echo 'Olá Mundo!'; // Imprime: Olá Mundo!
+print 'Olá Mundo!'; // O print também é - Imprime: Olá Mundo! 
 
 $paragrafo = 'parágrafo';
 
@@ -181,11 +185,11 @@ $z = &$y;
 // $z irá mudar o valor de $y também, e vice-versa.
 // $x irá permanecer inalterado com o valor original de $y
 
-echo $x; // => 2
-echo $z; // => 2
+echo $x; // Imprime => 2
+echo $z; // Imprime => 2
 $y = 0;
-echo $x; // => 2
-echo $z; // => 0
+echo $x; // Imprime => 2
+echo $z; // Imprime => 0
 
 // Despeja tipos e valores de variável para o stdout
 var_dump($z); // imprime int(0)
@@ -222,13 +226,13 @@ assert(1 !== '1');
 // As variáveis podem ser convertidas entre tipos, dependendo da sua utilização.
 
 $inteiro = 1;
-echo $inteiro + $inteiro; // => 2
+echo $inteiro + $inteiro; // Imprime => 2
 
 $string = '1';
-echo $string + $string; // => 2 (strings são coagidas para inteiros)
+echo $string + $string; // Imprime => 2 (strings são coagidas para inteiros)
 
 $string = 'one';
-echo $string + $string; // => 0
+echo $string + $string; // Imprime => 0
 // Imprime 0 porque o operador + não pode fundir a string 'um' para um número
 
 // Tipo de fundição pode ser utilizado para tratar uma variável 
diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
new file mode 100644
index 00000000..9b6bd1b6
--- /dev/null
+++ b/pt-br/python3-pt.html.markdown
@@ -0,0 +1,746 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+translators:
+    - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
+lang: pt-br
+filename: learnpython3-pt.py
+---
+
+Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma
+das mais populares linguagens em existência. Eu fiquei morrendo de amor
+pelo Python por sua clareza sintática. É praticamente pseudocódigo executável.
+
+Suas opiniões são grandemente apreciadas. Você pode encontrar-me em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
+[serviço de e-mail do google].
+
+Observação: Este artigo trata de Python 3 especificamente. Verifique
+[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende
+aprender o velho Python 2.7.
+
+```python
+
+# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido).
+
+""" Strings de várias linhas podem ser escritas
+    usando três ", e são comumente usadas
+    como comentários.
+"""
+
+####################################################
+## 1. Tipos de dados primitivos e operadores
+####################################################
+
+# Você usa números normalmente
+3  # => 3
+
+# Matemática é como você espera que seja
+1 + 1   # => 2
+8 - 1   # => 7
+10 * 2  # => 20
+
+# Números inteiros por padrão, exceto na divisão, que retorna número
+# de ponto flutuante (float).
+35 / 5  # => 7.0
+
+# O resultado da divisão inteira arredonda para baixo tanto para números
+# positivos como para negativos.
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # funciona em float também
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
+
+# Quando você usa um float, o resultado é float.
+3 * 2.0  # => 6.0
+
+# operador módulo
+7 % 3  # => 1
+
+# Exponenciação (x**y, x elevado à potência y)
+2**4  # => 16
+
+# Determine a precedência usando parêntesis
+(1 + 3) * 2  # => 8
+
+# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
+True
+False
+
+# negação lógica com not
+not True   # => False
+not False  # => True
+
+# Operadores lógicos
+# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas
+True and False  # => False
+False or True   # => True
+
+# Observe a utilização de operadores lógicos com números inteiros
+0 and 2     # => 0
+-5 or 0     # => -5
+0 == False  # => True
+2 == True   # => False
+1 == True   # => True
+
+# Igualdade é ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Diferença é !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Mais comparações
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Comparações podem ser agrupadas
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# (operador 'is' e operador '==') is verifica se duas referenciam um
+# mesmo objeto, mas == verifica se as variáveis apontam para o
+# mesmo valor.
+a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
+b = a             # b referencia o que está referenciado por a
+b is a            # => True, a e b referenciam o mesmo objeto
+b == a            # => True, objetos a e b tem o mesmo conteúdo
+b = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
+b is a            # => False, a e b não referenciam o mesmo objeto
+b == a            # => True, objetos a e b tem o mesmo conteúdo
+
+# Strings são criadas com " ou '
+"Isto é uma string."
+'Isto também é uma string.'
+
+# Strings também podem ser somadas! Mas tente não fazer isso.
+"Olá " + "mundo!"  # => "Olá mundo!"
+# Strings podem ser somadas sem usar o '+'
+"Olá " "mundo!"    # => "Olá mundo!"
+
+# Uma string pode ser manipulada como se fosse uma lista de caracteres
+"Isso é uma string"[0]  # => 'I'
+
+# .format pode ser usado para formatar strings, dessa forma:
+"{} podem ser {}".format("Strings", "interpoladas")  # => "Strings podem ser interpoladas"
+
+# Você pode repetir os argumentos para digitar menos.
+"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal")
+# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack."
+
+# Você pode usar palavras-chave se quiser contar.
+"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha")  # => "Beto quer comer lasanha"
+
+# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto:
+"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga")  # => "Strings podem ser interpoladas da forma antiga"
+
+
+# None é um objeto
+None  # => None
+
+# Não use o operador de igualdade "==" para comparar objetos com None
+# Use "is" para isso. Ele checará pela identidade dos objetos.
+"etc" is None  # => False
+None is None   # => True
+
+# None, 0, e strings/listas/dicionários vazios todos retornam False.
+# Qualquer outra coisa retorna True
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
+
+
+####################################################
+## 2. Variáveis e coleções
+####################################################
+
+# Python tem uma função print
+print("Eu sou o Python. Prazer em conhecer!")  # => Eu sou o Python. Prazer em conhecer!
+
+# Por padrão a função print também imprime o caractere de nova linha ao final.
+# Use o argumento opcional end para mudar o caractere final.
+print("Olá, Mundo", end="!")  # => Olá, Mundo!
+
+# Forma simples para capturar dados de entrada via console
+input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string
+# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
+
+# Não é necessário declarar variáveis antes de iniciá-las
+# È uma convenção usar letras_minúsculas_com_sublinhados
+alguma_variavel = 5
+alguma_variavel  # => 5
+
+# Acessar uma variável que não tenha sido inicializada gera uma exceção.
+# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
+alguma_variavel_nao_inicializada  # Gera a exceção NameError
+
+# Listas armazenam sequencias
+li = []
+# Você pode iniciar com uma lista com alguns valores
+outra_li = [4, 5, 6]
+
+# Adicionar conteúdo ao fim da lista com append
+li.append(1)    # li agora é [1]
+li.append(2)    # li agora é [1, 2]
+li.append(4)    # li agora é [1, 2, 4]
+li.append(3)    # li agora é [1, 2, 4, 3]
+# Remover do final da lista com pop
+li.pop()        # => 3 e agora li é [1, 2, 4]
+# Vamos colocá-lo lá novamente!
+li.append(3)    # li agora é [1, 2, 4, 3] novamente.
+
+# Acessar uma lista da mesma forma que você faz com um array
+li[0]   # => 1
+# Acessa o último elemento
+li[-1]  # => 3
+
+# Acessando além dos limites gera um IndexError
+li[4]  # Gera o IndexError
+
+# Você pode acessar vários elementos com a sintaxe de limites
+# (É um limite fechado, aberto pra você que gosta de matemática.)
+li[1:3]   # => [2, 4]
+# Omitindo o final
+li[2:]    # => [4, 3]
+# Omitindo o início
+li[:3]    # => [1, 2, 4]
+# Selecione cada segunda entrada
+li[::2]   # => [1, 4]
+# Tenha uma cópia em ordem invertida da lista
+li[::-1]  # => [3, 4, 2, 1]
+# Use qualquer combinação dessas para indicar limites complexos
+# li[inicio:fim:passo]
+
+# Faça uma cópia profunda de um nível usando limites
+li2 = li[:]  # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False.
+
+# Apague elementos específicos da lista com "del"
+del li[2]  # li agora é [1, 2, 3]
+
+# Você pode somar listas
+# Observação: valores em li e other_li não são modificados.
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+
+# Concatene listas com "extend()"
+li.extend(other_li)  # Agora li é [1, 2, 3, 4, 5, 6]
+
+# Verifique se algo existe na lista com "in"
+1 in li  # => True
+
+# Examine  tamanho com "len()"
+len(li)  # => 6
+
+
+# Tuplas são como l istas, mas imutáveis.
+tup = (1, 2, 3)
+tup[0]      # => 1
+tup[0] = 3  # Gera um TypeError
+
+# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do
+# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,.
+type((1))   # => <class 'int'>
+type((1,))  # => <class 'tuple'>
+type(())    # => <class 'tuple'>
+
+# Você pode realizar com tuplas a maior parte das operações que faz com listas
+len(tup)         # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]          # => (1, 2)
+2 in tup         # => True
+
+# Você pode desmembrar tuplas (ou listas) em variáveis.
+a, b, c = (1, 2, 3)  # a é 1, b é 2 e c é 3
+# Por padrão, tuplas são criadas se você não coloca parêntesis.
+d, e, f = 4, 5, 6
+# Veja como é fácil permutar dois valores
+e, d = d, e  # d é 5, e é 4
+
+# Dicionários armazenam mapeamentos
+empty_dict = {}
+# Aqui está um dicionário preenchido na definição da referência
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+
+# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para
+# assegurar que a chave pode ser convertida para uma valor hash constante para
+# buscas rápidas.
+# Tipos imutáveis incluem inteiros, flotas, strings e tuplas.
+invalid_dict = {[1,2,3]: "123"}  # => Gera um TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}   # Já os valores, podem ser de qualquer tipo.
+
+# Acesse valores com []
+filled_dict["um"]  # => 1
+
+# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular
+# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso
+# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida.
+# Por isso, os resultados aqui apresentados podem não ser exatamente como os
+# aqui apresentados.
+list(filled_dict.keys())  # => ["três", "dois", "um"]
+
+
+# Acesse todos os valores de um iterável com "values()". Novamente, é
+# necessário encapsular ele com list() para não termos um iterável, e sim os
+# valores. Observe que, como foi dito acima, a ordem dos elementos não é
+# garantida.
+list(filled_dict.values())  # => [3, 2, 1]
+
+
+# Verifique a existência de chaves em um dicionário com "in"
+"um" in filled_dict  # => True
+1 in filled_dict      # => False
+
+# Acessar uma chave inexistente gera um KeyError
+filled_dict["quatro"]  # KeyError
+
+# Use o método "get()" para evitar um KeyError
+filled_dict.get("um")      # => 1
+filled_dict.get("quatro")     # => None
+# O método get permite um parâmetro padrão para quando não existir a chave
+filled_dict.get("um", 4)   # => 1
+filled_dict.get("quatro", 4)  # => 4
+
+# "setdefault()" insere em dicionário apenas se a dada chave não existir
+filled_dict.setdefault("cinco", 5)  # filled_dict["cinco"] tem valor 5
+filled_dict.setdefault("cinco", 6)  # filled_dict["cinco"] continua 5
+
+# Inserindo em um dicionário
+filled_dict.update({"quatro":4})  # => {"um": 1, "dois": 2, "três": 3, "quatro": 4}
+#filled_dict["quatro"] = 4        #outra forma de inserir em um dicionário
+
+# Remova chaves de um dicionário com del
+del filled_dict["um"]  # Remove a chave "um" de filled_dict
+
+
+# Armazenamento em sets... bem, são conjuntos
+empty_set = set()
+# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe.
+some_set = {1, 1, 2, 2, 3, 4}  # some_set agora é {1, 2, 3, 4}
+
+# Da mesma forma que chaves em um dicionário, elementos de um set devem ser
+# imutáveis.
+invalid_set = {[1], 1}  # => Gera um TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# Pode definir novas variáveis para um conjunto
+filled_set = some_set
+
+# Inclua mais um item no set
+filled_set.add(5)  # filled_set agora é {1, 2, 3, 4, 5}
+
+# Faça interseção de conjuntos com &
+other_set = {3, 4, 5, 6}
+filled_set & other_set  # => {3, 4, 5}
+
+# Faça união de conjuntos com |
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
+
+# Faça a diferença entre conjuntos com -
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
+
+# Verifique a existência em um conjunto com in
+2 in filled_set   # => True
+10 in filled_set  # => False
+
+
+
+####################################################
+## 3. Controle de fluxo e iteráveis
+####################################################
+
+# Iniciemos um variável
+some_var = 5
+
+# Aqui está uma expressão if. Indentação é significante em python!
+# imprime "somevar é menor que10"
+if some_var > 10:
+    print("some_var é absolutamente maior que 10.")
+elif some_var < 10:    # Esta cláusula elif é opcional.
+    print("some_var é menor que 10.")
+else:                  # Isto também é opcional.
+    print("some_var é, de fato, 10.")
+
+
+"""
+Laços for iteram sobre listas
+imprime:
+    cachorro é um mamífero
+    gato é um mamífero
+    rato é um mamífero
+"""
+for animal in ["cachorro", "gato", "rato"]:
+    # Você pode usar format() para interpolar strings formatadas
+    print("{} é um mamífero".format(animal))
+
+"""
+"range(número)" retorna um iterável de números
+de zero até o número escolhido
+imprime:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(menor, maior)" gera um iterável de números
+começando pelo menor até o maior
+imprime:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(menor, maior, passo)" retorna um iterável de números
+começando pelo menor número até o maior númeno, pulando de
+passo em passo. Se o passo não for indicado, o valor padrão é um.
+imprime:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+Laços while executam até que a condição não seja mais válida.
+imprime:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Maneira mais curta para for x = x + 1
+
+# Lide com exceções com um bloco try/except
+try:
+    # Use "raise" para gerar um erro
+    raise IndexError("Isto é um erro de índice")
+except IndexError as e:
+    pass                 # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui.
+except (TypeError, NameError):
+    pass                 # Varias exceções podem ser gerenciadas, se necessário.
+else:                    # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção.
+    print("Tudo certo!")   # Executa apenas se o código em try não gera exceção
+finally:                 #  Sempre é executado
+    print("Nós podemos fazer o código de limpeza aqui.")
+
+# Ao invés de try/finally para limpeza você pode usar a cláusula with
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Python provê uma abstração fundamental chamada Iterável.
+# Um iterável é um objeto que pode ser tratado como uma sequência.
+# O objeto retornou a função range, um iterável.
+
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => range(1,10). Esse é um objeto que implementa nossa interface iterável.
+
+# Nós podemos percorrê-la.
+for i in our_iterable:
+    print(i)  # Imprime um, dois, três
+
+# Mas não podemos acessar os elementos pelo seu índice.
+our_iterable[1]  # Gera um TypeError
+
+# Um iterável é um objeto que sabe como criar um iterador.
+our_iterator = iter(our_iterable)
+
+# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos.
+# Nós acessamos o próximo objeto com "next()".
+next(our_iterator)  # => "um"
+
+# Ele mantém o estado enquanto nós o percorremos.
+next(our_iterator)  # => "dois"
+next(our_iterator)  # => "três"
+
+# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator
+next(our_iterator)  # Gera StopIteration
+
+# Você pode capturar todos os elementos de um iterador aplicando list() nele.
+list(filled_dict.keys())  # => Retorna ["um", "dois", "três"]
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# Use "def" para criar novas funções.
+def add(x, y):
+    print("x é {} e y é {}".format(x, y))
+    return x + y  # Retorne valores com a cláusula return
+
+# Chamando funções com parâmetros
+add(5, 6)  # => imprime "x é 5 e y é 6" e retorna 11
+
+# Outro meio de chamar funções é com argumentos nomeados
+add(y=6, x=5)  # Argumentos nomeados podem aparecer em qualquer ordem.
+
+# Você pode definir funções que pegam um número variável de argumentos
+# posicionais
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)  # => (1, 2, 3)
+
+# Você pode definir funções que pegam um número variável de argumentos nomeados
+# também
+def keyword_args(**kwargs):
+    return kwargs
+
+# Vamos chamá-lo para ver o que acontece
+keyword_args(peh="grande", lago="ness")  # => {"peh": "grande", "lago": "ness"}
+
+
+# Você pode fazer ambos simultaneamente, se você quiser
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) imprime:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Quando chamar funções, você pode fazer o oposto de args/kwargs!
+# Use * para expandir tuplas e use ** para expandir dicionários!
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)            # equivalente a foo(1, 2, 3, 4)
+all_the_args(**kwargs)         # equivalente a foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalente a foo(1, 2, 3, 4, a=3, b=4)
+
+# Retornando múltiplos valores (com atribuição de tuplas)
+def swap(x, y):
+    return y, x  # Retorna múltiplos valores como uma tupla sem os parêntesis.
+                 # (Observação: os parêntesis foram excluídos mas podem estar
+                 # presentes)
+
+x = 1
+y = 2
+x, y = swap(x, y)     # => x = 2, y = 1
+# (x, y) = swap(x,y)  # Novamente, os parêntesis foram excluídos mas podem estar presentes.
+
+# Escopo de função
+x = 5
+
+def setX(num):
+    # A variável local x não é a mesma variável global x
+    x = num    # => 43
+    print (x)  # => 43
+
+def setGlobalX(num):
+    global x
+    print (x)  # => 5
+    x = num    # variável global x agora é 6
+    print (x)  # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python tem funções de primeira classe
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# Também existem as funções anônimas
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# TODO - Fix for iterables
+# Existem funções internas de alta ordem
+map(add_10, [1, 2, 3])          # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
+
+# Nós podemos usar compreensão de lista para interessantes mapas e filtros
+# Compreensão de lista armazena a saída como uma lista que pode ser uma lista
+# aninhada
+[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# Nós usamos o operador "class" para ter uma classe
+class Human:
+
+    # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+    # classe.
+    species = "H. sapiens"
+
+    # Construtor básico, é chamado quando esta classe é instanciada.
+    # Note que dois sublinhados no início e no final de uma identificados
+    # significa objetos ou atributos que são usados pelo python mas vivem em
+    # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos)
+    # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou
+    # algumas vezes chamados métodos dunder - "double underscore")
+    # Você não deve usar nomes assim por sua vontade.
+    def __init__(self, name):
+        @ Atribui o argumento ao atributo da  instância
+        self.name = name
+
+    # Um método de instância. Todos os métodos tem "self" como primeiro
+    # argumento
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # Um método de classe é compartilhado por todas as instâncias
+    # Eles são chamados com a classe requisitante como primeiro argumento
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Um método estático é chamado sem uma referência a classe ou instância
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instancie uma classe
+i = Human(name="Ian")
+print(i.say("oi"))     # imprime "Ian: oi"
+
+j = Human("Joel")
+print(j.say("olá"))  # imprime "Joel: olá"
+
+# Chama nosso método de classe
+i.get_species()  # => "H. sapiens"
+
+# Altera um atributo compartilhado
+Human.species = "H. neanderthalensis"
+i.get_species()  # => "H. neanderthalensis"
+j.get_species()  # => "H. neanderthalensis"
+
+# Chama o método estático
+Human.grunt()    # => "*grunt*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Você pode importar módulos
+import math
+print(math.sqrt(16))  # => 4
+
+# Você pode importar apenas funções específicas de um módulo
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Você pode importar todas as funções de um módulo para o namespace atual
+# Atenção: isso não é recomendado
+from math import *
+
+# Você pode encurtar o nome dos módulos
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# Módulos python são apenas arquivos python comuns. Você
+# pode escrever os seus, e importá-los. O nome do
+# módulo é o mesmo nome do arquivo.
+
+# Você pode procurar que atributos e funções definem um módulo.
+import math
+dir(math)
+
+
+####################################################
+## 7. Avançado
+####################################################
+
+# Geradores podem ajudar você a escrever código "preguiçoso"
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Um gerador cria valores conforme necessário.
+# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em
+# cada interação. Isto significa que valores maiores que 15 não serão
+# processados em double_numbers.
+# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar
+# um nome que normalmente colide com uma palavra reservada do python.
+range_ = range(1, 900000000)
+# Multiplica por 2 todos os números até encontrar um resultado >= 30
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decoradores
+# Neste exemplo beg encapsula say
+# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem
+# retornada
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Por favor! Eu sou pobre :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Você me paga uma cerveja?"
+    return msg, say_please
+
+
+print(say())                # Você me paga uma cerveja?
+print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :(
+```
+
+## Pronto para mais?
+
+### Free Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [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)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/pt-br/ruby-ecosystem-pt.html.markdown b/pt-br/ruby-ecosystem-pt.html.markdown
new file mode 100644
index 00000000..da4f6f37
--- /dev/null
+++ b/pt-br/ruby-ecosystem-pt.html.markdown
@@ -0,0 +1,147 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+    - ["Jon Smock", "http://github.com/jonsmock"]
+    - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+    - ["Claudson Martins", "http://github.com/claudsonm"]
+lang: pt-br
+
+---
+
+Pessoas utilizando Ruby geralmente têm uma forma de instalar diferentes versões
+do Ruby, gerenciar seus pacotes (ou gemas) e as dependências das gemas.
+
+## Gerenciadores Ruby
+
+Algumas plataformas possuem o Ruby pré-instalado ou disponível como um pacote.
+A maioria dos "rubistas" não os usam, e se usam, é apenas para inicializar outro
+instalador ou implementação do Ruby. Ao invés disso, rubistas tendêm a instalar
+um gerenciador para instalar e alternar entre diversas versões do Ruby e seus
+ambientes de projeto.
+
+Abaixo estão os gerenciadores Ruby mais populares:
+
+* [RVM](https://rvm.io/) - Instala e alterna entre os rubies. RVM também possui
+  o conceito de gemsets para isolar os ambientes dos projetos completamente.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Apenas instala os
+  rubies. Use este para um melhor controle sobre a instalação de seus rubies.
+* [rbenv](https://github.com/sstephenson/rbenv) - Apenas alterna entre os rubies.
+  Usado com o ruby-build. Use este para um controle mais preciso sobre a forma
+  como os rubies são carregados.
+* [chruby](https://github.com/postmodern/chruby) - Apenas alterna entre os rubies.
+  A concepção é bastante similar ao rbenv. Sem grandes opções sobre como os
+  rubies são instalados.
+
+## Versões do Ruby
+
+O Ruby foi criado por Yukihiro "Matz" Matsumoto, que continua a ser uma espécie
+de [BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), embora
+isso esteja mudando recentemente. Como resultado, a implementação de referência
+do Ruby é chamada de MRI (Matz' Reference Implementation), e quando você ver uma
+versão do Ruby, ela está se referindo a versão de lançamento do MRI.
+
+As três principais versões do Ruby em uso são:
+
+* 2.0.0 - Lançada em Fevereiro de 2013. Maioria das principais bibliotecas e 
+  suporte a frameworks 2.0.0.
+* 1.9.3 - Lançada em Outubro de 2011. Está é a versão mais utilizada pelos rubistas
+  atualmente. Também [aposentada](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/).
+* 1.8.7 - O Ruby 1.8.7 foi
+  [aposentado](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+A diferença entre a versão 1.8.7 para 1.9.x é muito maior do que a da 1.9.3 para
+a 2.0.0. Por exemplo, a série 1.9 introduziu encodes e uma VM bytecode. Ainda
+existem projetos na versão 1.8.7, mas eles estão tornando-se uma pequena minoria
+pois a maioria da comunidade migrou para a versão, pelo menos, 1.9.2 ou 1.9.3.
+
+## Implementações Ruby
+
+O ecossistema Ruby conta com várias diferentes implementações do Ruby, cada uma
+com pontos fortes e estados de compatibilidade. Para ser claro, as diferentes
+implementações são escritas em diferentes linguagens, mas *todas elas são Ruby*.
+Cada implementação possui hooks especiais e recursos extra, mas todas elas
+executam arquivos normais do Ruby tranquilamente. Por exemplo, JRuby é escrita
+em Java, mas você não precisa saber Java para utilizá-la.
+
+Muito maduras/compatíveis:
+
+* [MRI](https://github.com/ruby/ruby) - Escrita em C, esta é a implementação de
+  referência do Ruby. Por definição, é 100% compatível (consigo mesma). Todos os
+  outros rubies mantêm compatibilidade com a MRI (veja [RubySpec](#rubyspec) abaixo).
+* [JRuby](http://jruby.org/) - Escrita em Java e Ruby, esta implementação
+  robusta é um tanto rápida. Mais importante ainda, o ponto forte do JRuby é a
+  interoperabilidade com JVM/Java, aproveitando ferramentas JVM, projetos, e
+  linguagens existentes.
+* [Rubinius](http://rubini.us/) - Escrita principalmente no próprio Ruby, com
+  uma VM bytecode em C++. Também madura e rápida. Por causa de sua implementação
+  em Ruby, ela expõe muitos recursos da VM na rubyland.
+
+Medianamente maduras/compatíveis:
+
+* [Maglev](http://maglev.github.io/) - Construída em cima da Gemstone, uma
+  máquina virtual Smalltalk. O Smalltalk possui algumas ferramentas impressionantes,
+  e este projeto tenta trazer isso para o desenvolvimento Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Traz o Ruby para o desenvolvimento iOS.
+
+Pouco maduras/compatíveis:
+
+* [Topaz](http://topazruby.com/) - Escrita em RPython (usando o conjunto de
+  ferramentas PyPy), Topaz é bastante jovem e ainda não compatível. Parece ser
+  promissora como uma implementação Ruby de alta performance.
+* [IronRuby](http://ironruby.net/) - Escrita em C# visando a plataforma .NET,
+  o trabalho no IronRuby parece ter parado desde que a Microsoft retirou seu apoio.
+
+Implementações Ruby podem ter seus próprios números de lançamento, mas elas
+sempre focam em uma versão específica da MRI para compatibilidade. Diversas
+implementações têm a capacidade de entrar em diferentes modos (1.8 ou 1.9, por
+exemplo) para especificar qual versão da MRI focar.
+
+## RubySpec
+
+A maioria das implementações Ruby dependem fortemente da [RubySpec](http://rubyspec.org/).
+Ruby não tem uma especificação oficial, então a comunidade tem escrito
+especificações executáveis em Ruby para testar a compatibilidade de suas
+implementações com a MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) é um gerenciador de pacotes para Ruby mantido
+pela comunidade. RubyGems vem com o Ruby, portanto não é preciso baixar separadamente.
+
+Os pacotes do Ruby são chamados de "gemas", e elas podem ser hospedadas pela 
+comunidade em RubyGems.org. Cada gema contém seu código-fonte e alguns metadados,
+incluindo coisas como versão, dependências, autor(es) e licença(s).
+
+## Bundler
+
+[Bundler](http://bundler.io/) é um gerenciador de dependências para as gemas.
+Ele usa a Gemfile de um projeto para encontrar dependências, e então busca as
+dependências dessas dependências de forma recursiva. Ele faz isso até que todas 
+as dependências sejam resolvidas e baixadas, ou para se encontrar um conflito.
+
+O Bundler gerará um erro se encontrar um conflito entre dependências. Por exemplo, 
+se a gema A requer versão 3 ou maior que a gema Z, mas a gema B requer a versão 
+2, o Bundler irá notificá-lo que há um conflito. Isso se torna extremamente útil
+quando diversas gemas começam a referenciar outras gemas (que referem-se a outras
+gemas), o que pode formar uma grande cascata de dependências a serem resolvidas.
+
+# Testes
+
+Testes são uma grande parte da cultura do Ruby. O Ruby vem com o seu próprio 
+framework de teste de unidade chamado minitest (ou TestUnit para Ruby versão 1.8.x). 
+Existem diversas bibliotecas de teste com diferentes objetivos.
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - 
+  Framework de testes "Unit-style" para o Ruby 1.8 (built-in)
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - 
+  Framework de testes para o Ruby 1.9/2.0 (built-in)
+* [RSpec](http://rspec.info/) - Um framework de testes que foca na expressividade
+* [Cucumber](http://cukes.info/) - Um framework de testes BDD que analisa testes Gherkin formatados
+
+## Seja Legal
+
+A comunidade Ruby orgulha-se de ser uma comunidade aberta, diversa, e receptiva.
+O próprio Matz é extremamente amigável, e a generosidade dos rubistas em geral
+é incrível.
diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 668cd25f..1078f6c5 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -7,6 +7,7 @@ contributors:
   - ["Jean Matheus Souto", "http://jeanmatheussouto.github.io"]
 translators:
   - ["Katyanna Moura", "https://twitter.com/amelie_kn"]
+  - ["Alan Peterson Carvalho Silva", "https://twitter.com/DemonKart"]
 ---
 
 ```ruby
@@ -101,7 +102,7 @@ caminho_para_a_raiz_do_projeto = '/bom/nome/'
 caminho = '/nome/ruim/'
 
 # Símbolos (são objetos)
-# Símbolos são imutáveis, são constantes reutilizáveis representadadas
+# Símbolos são imutáveis, são constantes reutilizáveis representados
 # internamente por um valor inteiro. Eles são frequentemente usados no
 # lugar de strings para transmitir com eficiência os valores específicos
 # e significativos
@@ -260,7 +261,7 @@ somar 3, 4 #=> 7
 somar(3,4), 5 #=> 12
 
 # yield
-# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco
+# Todos os métodos possuem implicitamente um paramêtro opcional que é um bloco
 # ele pode ser chamado com a palavra chave 'yield'
 
 def ao_redor
@@ -285,7 +286,7 @@ class Humano
 
   # Inicialização básica (contructor)
   def initialize(nome, idade=0)
-    # Atribui o argumento para a variável de instancia "nome" do objeto
+    # Atribui o argumento para a variável de instância "nome" do objeto
     @nome = nome
     # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
     @idade = idade
@@ -301,7 +302,7 @@ class Humano
     @nome
   end
 
-  # Um método de classe usa a palavra chave self para se defenciar dos métodos de instância.
+  # Um método de classe usa a palavra chave self para se diferenciar dos métodos de instância.
   # Ele só pode ser chamado na classe, não na instancia
   def self.diz(msg)
     puts "#{msg}"
@@ -362,7 +363,7 @@ Trabalhador.foo # 0
 Humano.foo = 2 # 2
 Trabalhador.foo # 2
 
-# Uma variável de instância não é compartilhada por suas classes decendentes.
+# Uma variável de instância não é compartilhada por suas classes descendentes.
 
 class Humano
   @bar = 0
@@ -382,12 +383,65 @@ end
 Humano.bar # 0
 Doutor.bar # nil
 
+---
+
+module ModuloDeExemplo
+  def foo
+    'foo'
+  end
+end
+
+# Incluir (include) módulos conecta seus métodos às instâncias da classe 
+# Herdar (extend) módulos conecta seus métodos à classe em si
+
+class Pessoa
+  include ExemploDeModulo
+end
+
+class Livro
+  extend ExemploDeModulo
+end
+
+Pessoa.foo     # => NoMethodError: undefined method `foo' for Pessoa:Class
+Pessoa.new.foo # => 'foo'
+Livro.foo       # => 'foo'
+Livro.new.foo   # => NoMethodError: undefined method `foo'
+
+# Callbacks são executados ao incluir e herdar um módulo
+
+module ExemploDeConceito
+  def self.included(base)
+    base.extend(MetodosDeClasse)
+    base.send(:include, MetodosDeInstancia)
+  end
+
+  module MetodosDeClasse
+    def bar
+      'bar'
+    end
+  end
+
+  module MetodosDeInstancia
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Algo
+  include ExemploDeConceito
+end
+
+Algo.bar     # => 'bar'
+Algo.qux     # => NoMethodError: undefined method `qux'
+Algo.new.bar # => NoMethodError: undefined method `bar'
+Algo.new.qux # => 'qux'
 ```
 
-## Mais sobre Ruby
+## Recursos adicionais
 
-- [Documentação oficial](http://www.ruby-doc.org/core-2.1.1/)
 - [Aprenda Ruby com desafios](http://www.learneroo.com/modules/61/nodes/338) - Uma coleção de desafios para testar a linguagem.
+- [Documentação oficial](http://www.ruby-doc.org/core-2.1.1/)
 - [Ruby a partir de outras linguagens](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
 - [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/)- Um mais antigo [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) e tambem uma versão online disponível.
 - [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Uma versão colaborativa de um *style-guide*
diff --git a/pt-br/scala-pt.html.markdown b/pt-br/scala-pt.html.markdown
new file mode 100644
index 00000000..3459f567
--- /dev/null
+++ b/pt-br/scala-pt.html.markdown
@@ -0,0 +1,668 @@
+---
+language: Scala
+filename: learnscala-pt.scala
+contributors:
+    - ["George Petrov", "http://github.com/petrovg"]
+    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Ha-Duong Nguyen", "http://reference-error.org"]
+translators:
+    - ["Francieli Viane", "https://github.com/FFrancieli"]
+lang: pt-br
+---
+
+Scala - a linguagem escalável
+
+```scala
+
+/////////////////////////////////////////////////
+// 0. O básico
+/////////////////////////////////////////////////
+/*
+  Configurando o Scala:
+
+  1) Baixe o instalador do Scala - http://www.scala-lang.org/downloads
+  2) Extraia (unzip ou tar) para sua localização favorita e coloque o subdiretório
+  bin na variável de ambiente `PATH`
+*/
+
+/*
+  Tente o REPL
+
+  Scala tem uma ferramenta chamada REPL (Read-Eval-Print Loop) que é análogo a
+  interpretadores de linha de comando de outras linguagens. Você pode digitar
+  qualquer expressão de Scala e o resultado será calculado e impresso.
+
+  O REPL é uma ferramenta muito conveniente para testar e verificar código. Use-o
+  enquanto você lê o tutorial para explorar os conceitos rapidamente por conta própria.
+*/
+
+//Inicialize um REPL de Scala executando o comando scala no terminal. Você deve ver o prompt:
+$ scala
+scala>
+
+//Por padrão, cada expressão que você executa é salva como um novo valor enumerado:
+scala> 2 + 2
+res0: Int = 4
+
+// Valores padrões podem ser reutilizados. Observe o tipo do valor exibido no resultado...
+scala> res0 + 2
+res1: Int = 6
+
+// Scala é uma linguagem fortemente tipada. Você pode usar o REPL para verfificar o tipo
+// sem avaliar uma expressão.
+
+scala> :type (true, 2.0)
+(Boolean, Double)
+
+// As sessões do REPL podem ser salvas
+scala> :save /sites/repl-test.scala
+
+//Arquivos podem ser carregados no REPL
+scala> :load /sites/repl-test.scala
+Loading /sites/repl-test.scala...
+res2: Int = 4
+res3: Int = 6
+
+// Você pode pesquisar em seu histórico recente
+scala> :h?
+1 2 + 2
+2 res0 + 2
+3 :save /sites/repl-test.scala
+4 :load /sites/repl-test.scala
+5 :h?
+
+// Agora que você já sabe brincar, vamos aprender um pouco de Scala...
+
+/////////////////////////////////////////////////
+// 1. Introdução
+/////////////////////////////////////////////////
+
+// Comentários de uma linha começam com duas barras
+
+/*
+  Comentários com múltiplas linhas, como você já pode ver, são assim.
+*/
+
+// Imprimir e forçar uma linha na próxima impressão
+println("Hello world!")
+println(10)
+// Hello world!
+// 10
+
+//Imprimir sem forçar uma nova linha na próxima impressão
+print("Hello world")
+print(10)
+// Hello world10
+
+//A declaração de valores pode ser feita usando tanto o var quanto o val.
+// Declarações feitas com `val` são imutáveis, enquanto que declarações feitas
+// com var são mutáveis. Imutabilidade é uma coisa boa.
+val x = 10 // x is now 10
+x = 20     // error: reassignment to val
+var y = 10
+ = 20     // y agora é 20
+
+/*
+  Scala é uma linguagem estaticamente tipada. Observe ainda que nas declarações
+  acima nós não especificamos um tipo. Isso se deve a um recurso da linguagem
+  chamado de inferência. Na maioria dos casos, o compilador do Scala consegue
+  adivinhar qual tipo é, de forma que você não precisa digitar sempre. Nós
+  podemos declarar o tipo da variável de maneira explícita asim:
+*/
+
+val z: Int = 10
+val a: Double = 1.0
+
+// Note que a conversão automática de Int para Double, o resultado é 10.0, não 10
+val b: Double = 10
+
+//Valores booleanos
+true
+false
+
+//Operações booleanas
+!true         // false
+!false        // true
+true == false // false
+10 > 5        // true
+
+// Matemática é como o de costume
+1 + 1   // 2
+2 - 1   // 1
+5 * 3   // 15
+6 / 2   // 3
+6 / 4   // 1
+6.0 / 4 // 1.5
+6 / 4.0 // 1.5
+
+// Calcular uma expressão no REPL te dá o tipo e o valor do resultado
+1 + 7
+
+/* A linha acima resulta em:
+  scala> 1 + 7
+  res29: Int = 8
+
+  Isso significa que o resultado ao culcular  1 + 7 é um objeto do tipo Int com
+  valor 8.
+
+  Note que "res29" é o nome de uma variável gerada sequencialmente para guardar
+  os resultados das expressões que você executa, logo seu nome pode ser
+  diferente.
+*/
+
+"Strings em Scala são delimitadas por aspas duplas"
+'a' // Um caractere em Scala
+// 'Strings com aspas simples não existem em Scala.' <= isso causa um erro.
+
+// Strings possuem os métodos comuns de Java definidos
+"hello world".length
+"hello world".substring(2, 6)
+"hello world".replace("C", "3")
+
+// Elas também possuem alguns métodos extras do Scala. Veja também:
+scala.collection.immutable.StringOps
+"hello world".take(5)
+"hello world".drop(5)
+
+//Interpolação de string: observe o prefixo "s"
+val n = 45
+s"We have $n apples" // => "We have 45 apples"
+
+// Também é possível ter expressões dentro de interpolação de strings
+val a = Array(11, 9, 6)
+s"My second daughter is ${a(0) - a(2)} years old."    // => "My second daughter is 5 years old."
+s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
+s"Power of 2: ${math.pow(2, 2)}"                      // => "Power of 2: 4"
+
+// Formatação de strings interpoladas com o prefixo "f"
+f"Power of 5: ${math.pow(5, 2)}%1.0f"         // "Power of 5: 25"
+f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
+
+
+// Strings cruas, ignorando caracteres especiais
+raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
+
+//Alguns caracteres precisam ser "escapados", ex. uma aspa dupla dentro de uma string
+
+"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+
+// Aspas triplas permitem strings a abrangerem múltiplas linhas e conter Aspas
+val html = """<form id="daform">
+                <p>Press belo', Joe</p>
+                <input type="submit">
+              </form>"""
+
+
+/////////////////////////////////////////////////
+// 2. Funções
+/////////////////////////////////////////////////
+
+// Funções são definidas da seguinte maneira:
+//
+//   def nomeDaFuncao(args ...): TipoDeRetorno = {body ...}
+//
+// Se você vem de linguagens mais tradicionais, note a omissão da palavra chave
+//return. Em Scala a última expressão no bloco da função é o valor de retorno
+def sumOfSquares(x: Int, y: Int): Int = {
+  val x2 = x * x
+  val y2 = y * y
+  x2 + y2
+}
+
+// As { } podem ser omitidas se o corpo da função possui apenas uma expressão:
+def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
+
+// A sintaxe para chamar funções é familiar:
+sumOfSquares(3, 4)  // => 25
+
+// Você poode usar o nome dos parâmetros para especificá-los numa ordem diferente
+def subtract(x: Int, y: Int): Int = x - y
+
+subtract(10, 3)     // => 7
+subtract(y=10, x=3) // => -7
+
+// Na maioria dos casos (sendo funções recursivas a a exceção mais notável) o
+// tipo de retorno da função pode ser omitido, e o mesmo tipo de inferência que
+// vimos nas variáveis funcionará com o valor de retorno da função:
+def sq(x: Int) = x * x  // O compilador consegue adivinhar que o tipo de retorno é Int
+
+// Funções podem ter parâmetros padrão:
+def addWithDefault(x: Int, y: Int = 5) = x + y
+addWithDefault(1, 2) // => 3
+addWithDefault(1)    // => 6
+
+// Funções anônimas são semelhantes a essa:
+(x: Int) => x * x
+
+// Diferente de defs, até mesmo a entrada de funções anônimas podem ser omitidas
+// se o contexto deixar isso claro. Observe o tipo "Int => Int", que significa
+// uma função que recebe umn Int e retorna um Int.
+val sq: Int => Int = x => x * x
+
+// Se cada argumento na sua função anônima é usado apenas uma vez, Scala te fornece
+// uma maneira ainda mais curta de definí-lo. Estas funções anônimas acabam por
+// ser muito comuns, como será mostrado na sessão de estrutura de dados.
+val addOne: Int => Int = _ + 1
+val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
+
+addOne(5)      // => 6
+weirdSum(2, 4) // => 16
+
+// A palavra chave return existe em Scala, mas só retorna do def mais profundo que o cerca.
+//AVISO: O uso do return em Scala é propenso a erros e deve ser evitado.
+//Não há efeito em funções anônimas. Per exemplo:
+def foo(x: Int): Int = {
+  val anonFunc: Int => Int = { z =>
+    if (z > 5)
+      return z // Esta linha faz Z retornar o valor de foo!
+    else
+      z + 2    // Esta linha retorna o valor de anonFunc
+  }
+  anonFunc(x) // Esta linha retorna o valor de foo
+}
+
+/////////////////////////////////////////////////
+// 3. Controle de Fluxo
+/////////////////////////////////////////////////
+
+1 to 5
+val r = 1 to 5
+r.foreach(println)
+
+r foreach println
+///N.B.: Scala é bem flexível quando se fala de pontos e parêntesis - estude as regras
+//separadamente. Isso ajuda a escrever DSLs e APIs que são lidas como inglês.
+
+(5 to 1 by -1) foreach (println)
+
+// Um loop while
+var i = 0
+while (i < 10) { println("i " + i); i += 1 }
+
+while (i < 10) { println("i " + i); i += 1 }   // Sim, de novo. O que aconteceu? Por quê?
+
+i    // Exibe o valor de i. Note que o while é um loop no senso clássico -
+     // executa sequencialmente enquanto muda a variável do loop. While é muito
+     // rápido, mas usar os combinadores e compreenões acima é mais fácil
+     // para entender e paralizar
+
+// Um loop do-while
+i = 0
+do {
+  println("i ainda é menor que 10")
+  i += 1
+} while (i < 10)
+
+
+// Recursão é a forma mais idiomática de repetir uma ação em Scala (assim como na
+// maioria das linguagens de programação funcional)
+// Funções recursivas precisam de um tipo de retorno explícito, o compilador não
+// consegue inferir;
+// Aqui está o Unit
+def showNumbersInRange(a: Int, b: Int): Unit = {
+  print(a)
+  if (a < b)
+    showNumbersInRange(a + 1, b)
+}
+showNumbersInRange(1, 14)
+
+// Condicionais
+
+al x = 10
+
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println("yeah") else println("nay")
+
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+
+/////////////////////////////////////////////////
+// 4. Estrutura de Dados
+/////////////////////////////////////////////////
+
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)     // Int = 1
+a(3)     // Int = 5
+a(21)    // Lança uma exceção
+
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle")   // java.lang.String = no lo se
+
+val s = Set(1, 3, 7)
+s(0)      // Boolean = false
+s(1)      // Boolean = true
+
+/* Veja a documantação do map aqui -
+ * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ * e garanta que você leia
+ */
+
+ // Tuplas
+
+ (1, 2)
+
+ (4, 3, 2)
+
+ (1, 2, "three")
+
+ (a, 2, "three")
+
+ //Por que ter isso?
+ val divideInts = (x: Int, y: Int) => (x / y, x % y)
+
+//A função divideInts te dá o resultado e o resultado
+divideInts(10, 3)    // (Int, Int) = (3,1)
+
+//Para acessar os elementos de uma tupla, use _._n onde n é o índex do elemento
+
+val d = divideInts(10, 3)    // (Int, Int) = (3,1)
+
+d._1    // Int = 3
+d._2    // Int = 1
+
+// Alternativamente, você pode atribuir múltiplas variáveis para uma tupla, o
+// que é mais conveniente e legível em muitos casos
+val (div, mod) = divideInts(10, 3)
+
+div     // Int = 3
+mod     // Int = 1
+
+/////////////////////////////////////////////////
+// 5. Object Oriented Programming
+/////////////////////////////////////////////////
+
+/*
+    Tudo o que vimos até agora neste tutorial foram expressões simples (valores, funções, etc).
+    Essas expressões são boas para digitar no interpretador da linha de comando para
+    testes rápidos, mas elas não podem existir por si só em um arquivo Scala. Por exemplo,
+    você não pode ter simplesmente "val x = 5" em um arquivo Scala. Ao invés disso, os únicos
+    construtores de alto nível permitidos em Scala são:
+
+    - objects
+    - classes
+    - case classes
+    - traits
+
+    E agora vamos explicar o que é cada um deles.
+*/
+
+//classes são similares a classes em outras linguagens. Os argumentos do construtor
+// são declarados logo depois do nome da classe e a inicialização é feita no corpo da classe.
+
+class Dog(br: String) {
+  // codigo do construtor aqui
+  var breed: String = br
+
+  // Define um método chamado bark que retorna uma String
+  def bark = "Woof, woof!"
+
+  // Assume-se que os métodos e valores são públicos. As palavras chave "protected"
+  // e "private" também estão disponíveis.
+  private def sleep(hours: Int) =
+    println(s"I'm sleeping for $hours hours")
+
+  // Métodos abstratos são simplesmente métodos sem corpo. Se a gente remover o
+  // comentário da próxima linha a classe Dog teria que ser declarada como abstrata
+
+  //   abstract class Dog(...) { ... }
+  // def chaseAfter(what: String): String
+}
+
+// A palavra chave "object" cria um tipo e uma instância singlenton desse tipo.
+// É comum para classes em Scala ter um "companion object" (objeto companheiro),
+// onde, por exemlo, o comportamento é capturado pelas classes em si, mas o comportamento
+// relacionado a toda instância da classe vai em objects. A diferença é semelhante
+// a métodos versus métodos estáticos em outras linguagens. Note que objects e
+// classes podem ter o mesmo nome.
+
+object Dog {
+  def allKnownBreeds = List("pitbull", "shepherd", "retriever")
+  def createDog(breed: String) = new Dog(breed)
+}
+
+// Case classes são classes que possuem uma funcionalidade extra incorporada.
+// Uma dúvida comum para iniciantes em Scala é quando usar classes e quando usar
+// case classes. A linha é bem tênue, mas em geral classes tendem a focar em encapsulamento,
+// polimorfismo e comportamento. Os valores nestas classes tendem a ser privados e
+// apenas métodos ficam expostos. O propósito primário de uma case class é guardar
+// dados imutáveis. Às vezes as case classes possuem alguns poucos métodos, os quais
+// raramente possuem efeitos colaterais (side effects).
+case class Person(name: String, phoneNumber: String)
+
+// Cria uma nova instância. Observe que case classes não precisam de usar "new" ao serem instanciadas
+val george = Person("George", "1234")
+val kate = Person("Kate", "4567")
+
+// Com case classes você ganha algumas regalias, como getters:
+// With case classes, you get a few perks for free, like getters:
+george.phoneNumber  // => "1234"
+
+// Verificação de igualdade por campo (sem a necessidade de sobrescrever o método equals)
+Person("George", "1234") == Person("Kate", "1236")  // => false
+
+// Uma maneira fácil de copiar
+// otherGeorge == Person("george", "9876")
+val otherGeorge = george.copy(phoneNumber = "9876")
+
+// E muitas outras. Case classes também possuem pattern matching de graça. Veja no próximo tópico.
+
+// Traits a caminho.
+
+
+/////////////////////////////////////////////////
+// 6. Pattern Matching
+/////////////////////////////////////////////////
+
+// Pattern matching é um recurso muito poderoso e muito usado em Scala. Aqui
+// mostramos como o seu pattern se adequa a uma case class.
+// NB: Diferente de outras linguagens, Scala não precisa de quebras. Entrar em
+// todas as condições do pattern matching simples não acontece.
+
+def matchPerson(person: Person): String = person match {
+  // Enrão você especifica os padrões
+  case Person("George", number) => "We found George! His number is " + number
+  case Person("Kate", number)   => "We found Kate! Her number is " + number
+  case Person(name, number)     => "We matched someone : " + name + ", phone : " + number
+}
+
+val email = "(.*)@(.*)".r  // Define uma regex para o próximo exemplo.
+
+// Pattern matching pode parecer com o comando switch nas liguagens da família C,
+// mas é muito mais poderoso. Em Scala você pode encontrar mais correpondências:
+
+def matchEverything(obj: Any): String = obj match {
+  // Você pode encontrar valores correspondentes:
+  case "Hello world" => "Got the string Hello world"
+
+  // Você pode fazer correspondência por tipo:
+  case x: Double => "Got a Double: " + x
+
+  // Você pode especificar condições:
+  case x: Int if x > 10000 => "Got a pretty big number!"
+
+  // Você pode encontrar correspondência com case classes, como fizemos antes:
+  case Person(name, number) => s"Got contact info for $name!"
+
+  // Você pode encontrar correspondências por regex:
+  case email(name, domain) => s"Got email address $name@$domain"
+
+  // Você pode encontrar correspondencias por tuplas:
+  case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+
+  // Você pode encontrar corresponências por estruturas de dados:
+  case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
+
+  // Você pode aninhar padrões:
+  case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+
+  // Retornar qualquer valor (padrão - default) caso nenhuma das possibilidades é correspondente.
+  case _ => "Got unknown object"
+
+  // Na verdade, você pode fazer correspondência de padrão de qualquer objeto que
+  // tenha o método "unnaply". Este recurso é tão poderoso que o Scala te deixa
+  // criar funções inteiras como patterns:
+
+  val patternFunc: Person => String = {
+    case Person("George", number) => s"George's number: $number"
+    case Person(name, number) => s"Random person's number: $number"
+  }
+}
+
+/////////////////////////////////////////////////
+// 7. Programação Funcional
+/////////////////////////////////////////////////
+
+// Scala permite que métodos e funções recebam ou retornem outras funções ou métodos.
+
+val add10: Int => Int = _ + 10 // A function taking an Int and returning an Int
+List(1, 2, 3) map add10 // List(11, 12, 13) - add10 is applied to each element
+
+// Funções anônimas podem ser usadas ao invés de funções com nomes:
+List(1, 2, 3) map (x => x + 10)
+
+// E o símbolo underline ("_") pode ser usado quando há apenas um argumento para a função anônima.
+List(1, 2, 3) map (_ + 10)
+
+// Se tanto o bloco animo quanto a função que você estiver usando receberem apenas
+// um argumento, você pode inclusive omitir o símbolo _
+List(1, 2, 3) map (_ + 10)
+
+// Combinadores
+
+s.map(sq)
+
+val sSquared = s. map(sq)
+
+sSquared.filter(_ < 10)
+
+sSquared.reduce (_+_)
+
+// A função filter recebe um predicado (uma função do tipo A -> Boolean) e seleciona
+// todos os elementos que satisfazem o predicado.
+List(1, 2, 3) filter (_ > 2) // List(3)
+case class Person(name: String, age: Int)
+List(
+  Person(name = "Dom", age = 23),
+  Person(name = "Bob", age = 30)
+).filter(_.age > 25) // List(Person("Bob", 30))
+
+// Scala tem o método foreach definido em algumas collections em específico, o qual
+// recebe um tipo e retorna Unit (um método void)
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
+aListOfNumbers foreach (x => println(x))
+aListOfNumbers foreach println
+
+/* NB Ests não são laços for. A semântica dos laços for é 'repetir' enquanto um
+  for-comprehension define um relacionamento entre dois conjuntos de dados */
+
+
+/////////////////////////////////////////////////
+// 8. Implicits
+/////////////////////////////////////////////////
+
+/* ALERTA ALERTA:
+  Implicits são um conjunto de recursos poderosos de Scala e consequentemente é
+  fácil abusar deles. Iniciantes em Scala deveriam resistir a tentação de usá-los
+  até que eles entendam não apenas como eles funcionam mas também as melhores práticas
+  deles. Incluimos uma sessão neste tutorial sobre isso porque implicits são tão
+  corriqueiros em bibliotecas do Scala que é impossível fazer qualqeuer coisa expressiva
+  sem utilizar uma biblioteca que usa implicits. Isto é para você entender e trabalhar
+  com implicits. Não declare seus próprios implicits por conta própria.
+*/
+
+// qualquer valor (val, function, objects, etc) pode ser declarado para ser implícito
+// usando a, você adivinhou, palavra chave "implicit". Usaremos a classe Dog definida
+// na sessão 5 para os próximos exemplos.
+implicit val myImplicitInt = 100
+implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed)
+
+// A palavra chave implicit não muda o comportamento do valor por si só, então
+// os valores acima podem ser usados como de costume.
+myImplicitInt + 2                   // => 102
+myImplicitFunction("Pitbull").breed // => "Golden Pitbull"
+
+A diferença é que agora esses valores são elegíveis para serem usados quando outra
+// parte do código "precisa" de um valor implícito. Uma situação é uma função
+// com argumentos implícitos:
+def sendGreetings(toWhom: String)(implicit howMany: Int) =
+  s"Hello $toWhom, $howMany blessings to you and yours!"
+
+// Se fornecermos um valor para "howMany" a função se comporta como sempre
+sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
+
+// Mas se omitirmos o parâmetro implícito um valor implícito de mesmo tipo é usado,
+// neste caso, "myImplicitInt":
+sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
+
+// Parâmetros implícitos de funções nos permitem simular type classes em outras
+//linguagens funcionais. As linhas abaixo são a mesma coisa:
+// def foo[T](implicit c: C[T]) = ...
+// def foo[T : C] = ...
+
+// Outro caso no qual o compilador procura por um implicit é quando você tem obj.method(...)
+// mas "obj" não possui "method" como um método. Neste caso, se houver uma conversão
+// de implicit do tipo A => B, onde A é o tipo do "obj" e B tem um método chamado
+// "method", a conversão é aplicada. Então, tendo myImplicitFunction acima em escopo, podemos dizer:
+"Retriever".breed // => "Golden Retriever"
+"Sheperd".bark    // => "Woof, woof!"
+
+// Aqui, a String é convertida para Dog usando nossa função acima, então o método
+// apropriado é chamado. Isso é um recurso extremamente poderoso, mas de novo, não
+// é para ser usado de maneira leviana. Na verdade, quando você define a função
+// implícita, o seu compilador deve exibir um aviso de que você não deveria fazer isso,
+// a menos que você realmente saiba o que você está fazendo.
+
+/////////////////////////////////////////////////
+// 9. Misc
+/////////////////////////////////////////////////
+
+// Importando coisas
+import scala.collection.immutable.List
+
+// Importando todos os sub pacotes
+import scala.collection.immutable._
+
+// Importando várias classes em um único comando
+import scala.collection.immutable.{List, Map}
+
+// Renomeando um import usando '=>'
+import scala.collection.immutable.{List => ImmutableList}
+
+// Importa todas as classes, com exceção de algumas. O import abaixo importa todas as classes excluindo Map e Set:
+import scala.collection.immutable.{Map => _, Set => _, _}
+
+// Classes Java também podem ser importadas. A syntaxe de Scala pode ser usada:
+import java.swing.{JFrame, JWindow}
+
+// O ponto de entrada do seu programa é definido em um arquivo Scala usando um object com um único método main:
+object Application {
+  def main(args: Array[String]): Unit = {
+    // o código fica aqui
+  }
+}
+
+// Arquivos podem ter múltiplas classes e objects. Compile com scalac
+
+// Entrada e saída
+
+// Para ler um arquivo linha a linha
+import scala.io.Source
+for(line <- Source.fromFile("myfile.txt").getLines())
+  println(line)
+
+// Para escrever um arquivo use o PrintWriter do Javaval writer = new PrintWriter("myfile.txt")
+writer.write("Writing line for line" + util.Properties.lineSeparator)
+writer.write("Another line here" + util.Properties.lineSeparator)
+writer.close()
+
+##  Recursos adicionais
+
+* [Scala for the impatient](http://horstmann.com/scala/)
+* [Twitter Scala school](http://twitter.github.io/scala_school/)
+* [Documentação de Scala](http://docs.scala-lang.org/)
+* [Tente Scala no seu navegador](http://scalatutorials.com/tour/)
+* Junte [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
+```
diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown
new file mode 100644
index 00000000..2fb2953b
--- /dev/null
+++ b/pt-br/self-pt.html.markdown
@@ -0,0 +1,165 @@
+---
+language: self
+contributors:
+    - ["Russell Allen", "http://github.com/russellallen"]
+translators:
+    - ["Ricardo de Almeida Gonzaga", "http://github.com/ricardotk"]
+lang: pt-br
+filename: learnself-br.self
+---
+
+Self é um protótipo rápido baseado em linguagem orientada a objeto a qual roda em sua própria JIT vm. A maior parte do desenvolvimento é feito através de interações com objetos ativos, através de um ambiente visual de desenvolvimento chamado *morphic* com navegador e depurador integrados.
+
+Tudo em Self é um objeto. Toda computação é feita através do envio de mensagens para objetos. Objetos em Self podem ser compreendidos como conjuntos de slots de chave-valor.
+
+# Construindo objetos
+
+O analisador interno de Self pode construir objetos, incluindo objetos método.
+
+```
+"Isto é um comentario"
+
+"A string:"
+'Isto é uma string com caracteres \'escapados\'.\n'
+
+"Um inteiro de 30 bits"
+23
+
+"Um float de 30 bits"
+3.2
+
+"-20"
+-14r16
+
+"Um objeto o qual entende apenas uma menssagem, 'x' que retorna 20"
+(|
+  x = 20.
+|)
+
+"Um objeto o qual tambem entende 'x', que atribui o slot x"
+(|
+  x <- 20.
+|)
+
+"Um objeto o qual entende o método 'doubleX' que 
+dobra o valor de x e então retorna o objeto"
+(|
+  x <- 20.
+  doubleX = (x: x * 2. self)
+|)
+
+"Um objeto o qual entende todas as mensagens 
+que 'traits point' entende". O analisador  
+procura 'traits point' enviando as mensagens 
+'traits' e 'point' para um objeto conhecido
+chamado de 'lobby'. Ele procura pelo objeto
+'true' também enviando a mensagem 'true'
+para o 'lobby'."" 
+(|     parent* = traits point.
+       x = 7.
+       y <- 5.
+       isNice = true.
+|)
+```
+
+# Enviando mensagens para objetos
+
+Mensagens podem ser unárias, binárias ou palavras-chave. Precedência é nesta ordem. Diferentemente de Smalltalk, a precedência de mensagens binárias precisam ser especificadas, e todas as palavras-chave após a primeira devem começar com letra maiúscula. Mensagens são separadas de seu destinatário através de espaço em branco.
+
+```
+"mensagem unária, envia 'printLine' para o objeto '23' 
+o qual escreve a string '23' para stdout e retorna o objeto recebido (ie 23)"
+23 printLine
+
+"envia a mensagem '+' com '7' para '23', em seguida a mensagem '*' com '8' para o resultado"
+(23 + 7) * 8 
+
+"envia 'power:' para '2' com '8' retorna 256"
+2 power: 8 
+
+"envia 'keyOf:IfAbsent:' para 'hello' com argumentos 'e' e '-1'. 
+Retorna 1, o índice de 'e' em 'hello'."
+'hello' keyOf: 'e' IfAbsent: -1 
+```
+
+# Blocos
+
+Self define controle de fluxo assim como Smalltalk e Ruby por meio de blocos. Blocos são computações atrasadas da forma:
+
+```
+[|:x. localVar| x doSomething with: localVar]
+```
+
+Exemplos do uso de um bloco:
+
+```
+"retorna 'HELLO'"
+'hello' copyMutable mapBy: [|:c| c capitalize] 
+
+"retorna 'Nah'"
+'hello' size > 5 ifTrue: ['Yay'] False: ['Nah'] 
+
+"retorna 'HaLLO'"
+'hello' copyMutable mapBy: [|:c| 
+   c = 'e' ifTrue: [c capitalize]
+            False: ['a']]
+```
+
+Múltiplas expressões são separadas por ponto final. ^ retorna imediatamente.
+
+```
+"retorna An 'E'! How icky!"
+'hello' copyMutable mapBy: [|:c. tmp <- ''| 
+   tmp: c capitalize.
+   tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!'].
+   c capitalize
+   ]
+```
+
+Blocos são realizados (completados) ao enviá-los a mensagem 'value' e herdando (imcumbir a) seus contextos:
+```
+"retorna 0"
+[|x|
+    x: 15.
+    "Repetidamente envia 'value' para o primeiro bloco enquanto o resultado do
+     envio de 'value' para o segundo bloco é o objeto 'true'"
+    [x > 0] whileTrue: [x: x - 1]. 
+    x
+] value
+```
+
+# Métodos
+
+Métodos são como blocos, porém eles não estão dentro de um contexto, ao invés disto são armazenados como valores de slots. Diferentemente de Smalltalk, métodos por padrão retornam o seu valor final e não 'self'.
+
+```
+"Aqui está um objeto com um slot atribuível 'x' e um método 'reduceXTo: y'.
+Enviar a mensagem 'reduceXTo: 10' para este objeto colocará 
+o objeto '10' no slot 'x' e retornará o objeto original"
+(| 
+    x <- 50.
+    reduceXTo: y = (
+        [x > y] whileTrue: [x: x - 1]. 
+        self)
+|)
+.
+```
+
+# Protótipos
+
+Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copia-lo.
+
+```
+| d |
+d: dictionary copy.
+d at: 'hello' Put: 23 + 8.
+d at: 'goodbye' Put: 'No!.
+"Imprime No!"
+( d at: 'goodbye' IfAbsent: 'Yes! ) printLine.
+"Imprime 31"
+( d at: 'hello' IfAbsent: -1 ) printLine.
+```
+
+# Informações adicionais
+
+O [Manual do Self](http://handbook.selflanguage.org) tem muito mais informações, e nada melhor do que por a mão na massa com Self através de sua [homepage](http://www.selflanguage.org).
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index e840b8cf..4ad67a06 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -353,7 +353,7 @@ internal class Rect: Shape {
 
     func shrink() {
         if sideLength > 0 {
-            --sideLength
+            sideLength -= 1
         }
     }
 
diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
index 9d5bf292..ce3be407 100644
--- a/pt-br/tmux-pt.html.markdown
+++ b/pt-br/tmux-pt.html.markdown
@@ -9,11 +9,9 @@ lang: pt-br
 filename: LearnTmux-pt.txt
 ---
 
-O [tmux](http://tmux.sourceforge.net)
-é um multiplexador de terminal, ele permite que terminais sejam criados,
-acessados e controlados a partir de uma unica instância. tmux pode ser separado
-de uma tela e continuar rodando no plano de fundo e depois ser reacoplado à
-instância (ou tela original).
+O [tmux](http://tmux.sourceforge.net) é um multiplexador de terminal,
+ele permite criar vários terminais e gerenciar tudo na mesma interface.
+tmux pode também rodar em background e depois ser recuperado(exibido) novamente.
 
 ```
 
@@ -25,9 +23,9 @@ instância (ou tela original).
      -n "Janela"     # Cria uma janela com o nome "Janela"
      -c "/dir"       # Inícia em uma pasta específica
 
-    attach           # Reacopla a última seção disponível
-     -t "#"          # Reacopla a seção com nome "#"
-     -d              # Separa (Desacopla) a sessaão de outras instâncias.
+    attach           # Acopla a última seção disponível
+     -t "#"          # Acopla a seção com nome "#"
+     -d              # Separa (Desacopla) a seção de outras instâncias.
 
     ls               # Lista todas as seções
      -a              # Lista todas as seções abertas
@@ -39,56 +37,54 @@ instância (ou tela original).
     lsp              # Lista os painéis
      -a              # Lista todos os painéis
      -s              # Lista todos os painéis em uma seção
-     -t "#"          # Lista os painéis baseado no nome "#"
+     -t "#"          # Lista os painéis chamados "#"
 
-    kill-window      # Encerrar a janela corrente
-     -t "#"          # Encerrar a janela baseado no nome "#"
+    kill-window      # Encerrar a janela atual
+     -t "#"          # Encerrar a janela chamada "#"
      -a              # Encerrar todas as janelas
-     -a -t "#"       # Encerrar todas as janelas exceto a com nome "#"
+     -a -t "#"       # Encerrar todas as janelas exceto a "#"
 
-    kill-session     # Encerrar seção corrente
+    kill-session     # Encerrar seção atual
      -t "#"          # Encerrar seção com nome "#"
      -a              # Encerrar todas as seções
-     -a -t "#"       # Encerrar todas as seções exceto a com nome "#"
+     -a -t "#"       # Encerrar todas as seções exceto a "#"
 
 ```
 
-
 ### Teclas de atalhos (comandos)
 
-A maneira de controllar uma seção tmux acoplada é através de uma
-combinação de teclas de prefixo.
+As seções tmux acopladas são controladas através de teclas de atalho. (prefix key)
 
 ```
 ----------------------------------------------------------------------
-  (C-b) = Ctrl + b    # Combinação de prefixos para usar comandos(atalhos).
+  (C-b) = Ctrl + b    # Abre a opção de receber comandos(atalhos).
 
   (M-1) = Meta + 1 -or- Alt + 1
 ----------------------------------------------------------------------
 
   ?           # Lista todos os comandos.
-  :           # Acessa o lugar (prompt command) para receber comandos do tmux
-  r           # Força a redefiniçao do cliente acoplado.
+  :           # Acessa o prompt command do tmux
+  r           # Força a reinicialização do cliente acoplado.
   c           # Cria uma nova janela.
 
-  !           # Retira o painel corrente da janela.
-  %           # Divide o painel corrente em dois para a esquerda e direita.
-  "           # Divide o painel corrente em dois para cima e para baixo.
+  !           # Retira o painel atual da janela.
+  %           # Divide o painel atual em dois. Esquerda e direita.
+  "           # Divide o painel atual em dois. Para cima e para baixo.
 
-  n           # Move para a próxima janela.
-  p           # Move para a janela anterior.
-  {           # Troca o painel corrente pelo anterior.
+  n           # Muda para a próxima janela.
+  p           # Muda para a janela anterior.
+  {           # Troca o painel atual pelo anterior.
   }           # Troca o painel corrent pelo posterior.
 
   s           # Seleciona uma nova seção para o cliente acoplado iterativamente.
-  w           # Seleciona a janela corrente iterativamente.
+  w           # Seleciona a janela atual iterativamente.
   0 to 9      # Seleciona a janela de 0 à 9.
 
   d           # Separa o cliente atual.
   D           # Seleciona um cliente a ser separado.
 
-  &           # Encerra a janela corrente.
-  x           # Encerra o painel corrente.
+  &           # Encerra a janela atual.
+  x           # Encerra o painel atual.
 
   Up, Down    # Move para o painel acima, abaixo, a esquerda ou a direita.
   Left, Right
@@ -100,10 +96,10 @@ combinação de teclas de prefixo.
                        # 4) Principal verticamente.
                        # 5) Mosaico
 
-  C-Up, C-Down    # Altera o tamanho do painel corrente baseado em uma célula.
+  C-Up, C-Down    # Altera o tamanho do painel atual em uma célula.
   C-Left, C-Right
 
-  M-Up, M-Down    # Altera o tamanho do painel corrente baseado em cinco células.
+  M-Up, M-Down    # Altera o tamanho do painel atual em cinco células.
   M-Left, M-Right
 
 ```
@@ -116,17 +112,13 @@ Existe um arquivo chamado tmux.conf, ele pode ser usado para definir opções no
 
 
 ```
-# Exemplo de tmux.conf
-# 2014.10
+# Exemplo tmux.conf
+# 2015.12
 
 
 ### General
 ###########################################################################
 
-# Habilita UTF-8
-setw -g utf8 on
-set-option -g status-utf8 on
-
 # Limite da história de comandos
 set -g history-limit 2048
 
@@ -134,14 +126,14 @@ set -g history-limit 2048
 set -g base-index 1
 
 # Mouse
-set-option -g mouse-select-pane on
+set-option -g -q mouse on
 
 # Recarregar o arquivo de configuração sem a necessidade de reiniciar o programa
 unbind r
 bind r source-file ~/.tmux.conf
 
 
-### Teclas de atalho
+### Keybinds / Comandos
 ###########################################################################
 
 # Desvincular C-b como prefixo padrão.
@@ -150,7 +142,7 @@ unbind C-b
 # Define um novo prefixo padrão.
 set-option -g prefix `
 
-# Definir prefixos que podem ser usados para voltar para a janela anterior.
+# Voltar janela anterior quando comando for usado duas vezes.
 bind C-a last-window
 bind ` last-window
 
@@ -158,11 +150,11 @@ bind ` last-window
 bind F11 set-option -g prefix C-a
 bind F12 set-option -g prefix `
 
-# Preferencia de teclas de atalho
+# Preferencia de comandos
 setw -g mode-keys vi
 set-option -g status-keys vi
 
-# Mover enter paineis com teclas de orientaçao do vim
+# Alternar enter painéis com teclas de orientaçao do vim
 bind h select-pane -L
 bind j select-pane -D
 bind k select-pane -U
@@ -174,7 +166,7 @@ bind f next-window
 bind E swap-window -t -1
 bind F swap-window -t +1
 
-# Iterar entre os painéis
+# Dividir painéis
 bind = split-window -h
 bind - split-window -v
 unbind '"'
@@ -184,7 +176,7 @@ unbind %
 bind a send-prefix
 
 
-### Theme
+### Theme // Estilo
 ###########################################################################
 
 # Paleta de cores para a barra de status
@@ -209,8 +201,6 @@ setw -g window-status-bg black
 setw -g window-status-current-fg green
 setw -g window-status-bell-attr default
 setw -g window-status-bell-fg red
-setw -g window-status-content-attr default
-setw -g window-status-content-fg yellow
 setw -g window-status-activity-attr default
 setw -g window-status-activity-fg yellow
 
diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
new file mode 100644
index 00000000..f072b257
--- /dev/null
+++ b/pt-br/typescript-pt.html.markdown
@@ -0,0 +1,179 @@
+---
+language: TypeScript
+filename: learntypescript-pt.ts
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+  - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+TypeScript is a language that aims at easing development of large scale applications written in JavaScript.
+TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
+It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
+
+This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/).
+
+
+Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
+Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
+É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
+
+Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown).
+
+Para testar compilador do texto datilografado, de cabeça para o [Parque](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitida.
+
+```js
+// Existem 3 tipos básicos no TypeScript
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Quando é impossível saber, há o "Qualquer" tipo
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // Ok, definitivamente um boolean
+
+// Para coleções, não são matrizes e matrizes genéricas digitado
+var list: number[] = [1, 2, 3];
+// Como alternativa, usando o tipo de matriz genérica
+var list: Array<number> = [1, 2, 3];
+
+// Para enumerações:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Por último, "vazio" é utilizado no caso especial de uma função que não retorna nada
+function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!");
+}
+
+// Funções são cidadãos de primeira classe, apoiar a sintaxe lambda "seta gordura" e
+// Tipo de uso inferência
+
+// A seguir são equivalentes, a mesma assinatura será inferido pelo
+// Compilador, e mesmo JavaScript será emitido
+var f1 = function(i: number): number { return i * i; }
+// Tipo de retorno inferida
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Tipo de retorno inferida
+var f4 = (i: number) => { return i * i; }
+// Tipo de retorno inferido, one-liner significa nenhuma palavra-chave retorno necessário
+var f5 = (i: number) =>  i * i;
+
+// Interfaces são estruturais, qualquer coisa que tenha as propriedades é compatível com
+// A interface
+interface Person {
+  name: string;
+  // Propriedades opcionais, marcado com um "?"
+  age?: number;
+  // E de funções curso
+  move(): void;
+}
+
+// Objeto que implementa a "Pessoa" Interface
+// Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades
+var p: Person = { name: "Bobby", move: () => {} };
+// Os objetos que têm a propriedade opcional:
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// Não é uma pessoa porque a idade não é um número
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Interfaces também pode descrever um tipo de função
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Somente tipos dos parâmetros são importantes, os nomes não são importantes.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Classes - membros são públicos por padrão
+class Point {
+  // Propriedades
+    x: number;
+
+    // Construtor - the public/private keywords in this context will generate
+    // o código clichê para a propriedade e a inicialização no
+    // construtor.
+    // Neste exemplo, "y" será definida como "X" é, mas com menos código
+    // Os valores padrão também são suportados.
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Funções
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Membros Estáticos
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y será 0
+
+// Herança
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Chamada explícita para o construtor da super classe é obrigatória
+    }
+
+    // Sobrescrever
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Módulos, "." pode ser utilizado como separador de sub módulos
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Alias no local para fazer referência a um módulo
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Genericos
+// Classes
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfaces
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// e funções
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Incluindo referências a um arquivo de definição:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Leitura adicional
+ * [TypeScript site oficial](http://www.typescriptlang.org/)
+ * [TypeScript especificações de idioma (pdf)](http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Apresentando texto datilografado no Canal 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Código fonte no GitHub](https://github.com/Microsoft/TypeScript)
+ * [Definitivamente datilografado - repositório de definições de tipo](http://definitelytyped.org/)
diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
new file mode 100644
index 00000000..51eddb48
--- /dev/null
+++ b/pt-br/vim-pt.html.markdown
@@ -0,0 +1,239 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: LearnVim-pt.txt
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved - Vi Melhorado) é um clone do editor vi para Unix. Ele é um
+editor de texto projetado para ter velocidade e produtividade, e está presente
+na maioria dos systemas UNIX. O editor tem um grande número de atalhos de teclado
+para agilizar a navegação para pontos específicos no arquivo, além de edição rápida.
+
+## Navegação do Vim: o básico
+
+```
+    vim <nome-do-arquivo>   # Abre <nome-do-arquivo> no vim
+    :q               # Fecha o vim
+    :w               # Salva o arquivo atual
+    :wq              # Salva o arquivo e fecha o vim
+    :q!              # Fecha o vim e descarta as alterações no arquivo
+                     # ! *força* :q a executar, fechando o vim sem salvar antes
+    :x               # Salvar o arquivo e fechao vim (atalho para :wq)
+
+    u                # Desfazer
+    CTRL+R           # Refazer
+
+    h                # Move o cursor para a esquerda
+    j                # Move o cursor para baixo
+    k                # Move o cursor para cima
+    l                # Move o cursor para a direita
+
+    # Movendo o cursor dentro da linha
+
+    0                # Move para o início da linha
+    $                # Move para o final da linha
+    ^                # Move para o primeiro caractere da linha (ignora caracteres em branco)
+
+    # Pesquisa no texto
+
+    /palavra         # Destaca todas as ocorrências de 'palavra' após o cursor
+    ?palavra         # Destaca todas as ocorrências de 'palavra' antes do cursor
+    n                # Move o cursor para a próxima ocorrência após a pesquisa
+    N                # Move o cursor para a ocorrência anterior após a pesquisa
+
+    :%s/foo/bar/g    # Substitui 'foo' por 'bar' no arquivo inteiro
+    :s/foo/bar/g     # Substitui 'foo' por 'bar' na linha atual
+
+    # Pulando para caracteres específicos
+
+    f<caracter>      # Posiciona o cursor no próximo <caracter>
+    t<character>     # Posiciona o cursor antes do próximo <caracter> 
+
+    # Por exemplo,    
+    f<               # Posiciona o cursor no <
+    t<               # Posiciona o cursor logo antes do <
+    
+    # Movendo por palavras
+
+    w                # Move o cursor uma palavra a diante
+    b                # Move o cursor uma palavra atrás
+    e                # Move o cursor ao fim da palavra atual
+
+    # Outros caracteres para mover o cursor no arquivo
+
+    gg               # Move para o topo do arquivo
+    G                # Move para o final do arquivo
+    :NUM             # Move para a linha NUM (NUM é qualquer número)
+    H                # Move para o topo da tela visível
+    M                # Move para o meio da tela visível
+    L                # Move para o final da tela visível
+```
+
+## Modos:
+
+O Vim é baseado no conceito de **modos**.
+
+Modo Comando  - usado para navegar e escrever comandos - o Vim já inicia nesse modo
+Modo Inserção - usado para fazer alterações no arquivo
+Modo Visual   - usado para destacar textos e executar comandos neles
+Modo Ex       - usado para ir a linha com ':' no final da tela para executar comandos 
+
+```
+    i                # Coloca o Vim no Modo Inserção, logo antes do cursor
+    a                # Coloca o Vim no Modo Inserção, logo após o cursor
+    v                # Coloca o Vim no Modo Visual 
+    :                # Coloca o Vim no Modo Ex
+    <esc>            # Sai de qualquer modo que você estiver, e coloca o Vim no Modo Comando
+
+    # Copiando e colando texto
+
+    y                # Coloca a seleção atual na área de transferência
+    yy               # Coloca a linha atual na área de transferência
+    d                # Deleta a seleção tual
+    dd               # Deleta a linha atual
+    p                # Cola o texto copiado após a posição do cursor
+    P                # Cola o texto copiado antes da posição do cursor
+    x                # Deleta o caractere que está na posição do cursor
+```
+
+## A 'Gramática' do Vim
+
+Podemos pensar no Vim como uma série de comendos
+em um formato 'Verbo-Modificador-Nome', onde:
+
+Verbo       - sua ação 
+Modificador - como você executará sua ação
+Nome        - o objeto onde você vai executar sua acão
+
+Alguns exemplos importantes de 'Verbos', 'Modificadores' e 'Nomes':
+
+```
+    # 'Verbos'
+ 
+    d                # Apagar (Delete)
+    c                # Alterar (Change)
+    y                # Copiar (Yank)
+    v                # Seleção Visual
+
+    # 'Modificadores'
+
+    i                # Dentro (Inside)
+    a                # Em torno de (Around)
+    NUM              # Número (NUM qualquer número)
+    f                # Pesquisa algo e posiciona o cursor acima do resultado
+    t                # Pesquisa algo e posiciona o cursor logo antes do resultado
+    /                # Encontra algo a frente do cursor
+    ?                # Encontra algo antes do cursor
+
+    # 'Nomes'
+
+    w                # Palavra (word)
+    s                # Sentência
+    p                # Parágrafo
+    b                # Bloco
+    
+    # Exemplos de comandos
+
+    d2w              # Apaga 2 palavras
+    cis              # Altera dentro de uma sentência
+    yip              # Coloca o parágrafo atual da área de transferência)
+    ct<              # Altera para '<'
+                     # Altera todo o texto a partir da posição do cursor até o próximo '<'
+    d$               # Apaga tudo da posição do cursor até o final da linha
+```
+
+## Alguns atalhos e dicas
+
+        <!--TODO: Adicionar mais!-->
+```
+    >                # Adiciona um bloco de indentação
+    <                # Remove um bloco de indentação
+    :earlier 15m     # Reverte o documento para como ele estava há 15 minutos atrás
+    :later 15m       # Reverte o comando acima
+    ddp              # Troca linhas consecutivas de posição, dd e depois p
+    .                # Repete a última ação
+```
+
+## Macros
+
+Macros, basicamente, são ações graváveis.
+Quando você começa a gravar uma macro, ele salva **toda** ação e comando
+que você usar, até que você pare de gravar. Ao executar uma macro, ele aplica
+exatamente a mesma sequencia de ações e comandos na seleção atual.
+
+```
+    qa               # Inicia a gravação de uma macro chamado 'a'
+    q                # Para a gravação
+    @a               # Executa a macro
+```
+
+### Configurando o ~/.vimrc
+
+O arquivo .vimrc pode ser usado para configurar o Vim no seu início.
+
+Exemplo de arquivo ~/.vimrc
+
+```
+" Exemplo de ~/.vimrc
+" 2015.10 
+
+" Obrigatório para rodar apenas no Vim (Vi Improved)
+set nocompatible
+
+" Determina o tipo de arquivo pelo nome para habilitar indentação automática, etc
+filetype indent plugin on
+
+" Habilita sintaxe colorida
+syntax on
+
+" Ativa um 'auto-completar' melhor para a linha de comando
+set wildmenu
+
+" Faz as buscas não diferenciarem maiúsculas-minúsculas (case insensitive)
+" Exceto quando você usar letras maiúsculas
+set ignorecase
+set smartcase
+
+" Quando criar uma nova linha e a indentação por tipo de arquivo estiver
+" desabilitada, mantem a mesma indentação da linha atual
+set autoindent
+
+" Mostra o número das linhas à esquerda
+set number
+
+" Opções de indentação, aqui você pode mudar como preferir
+
+" Número de espaços visíveis por TAB
+set tabstop=4
+
+" Número de espaços por TAB ao editar um arquivo
+set softtabstop=4
+
+" Número de espaços usados nas funções de indentação (>> e <<)
+set shiftwidth=4
+
+" Converte TABs em espaços
+set expandtab
+
+" Habilita indentação/alinhamento inteligente
+set smarttab
+```
+
+### Referências
+
+[Vim | Home](http://www.vim.org/index.php) (EN)
+
+`$ vimtutor pt`
+
+[Vim: um tutorial/cartilha](https://danielmiessler.com/study/vim/) (EN)
+
+[O que são as partes sombrias do Vim que sua mãe nunca te explicou? (tópico no Stack Overflow)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about) (EN)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim) (EN)
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
new file mode 100644
index 00000000..341ae675
--- /dev/null
+++ b/pt-br/yaml-pt.html.markdown
@@ -0,0 +1,142 @@
+---
+language: yaml
+contributors:
+  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+  - ["Rodrigo Russo", "https://github.com/rodrigozrusso"]
+filename: learnyaml-pt.yaml
+lang: pt-br
+---
+
+YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
+legível por seres humanos.
+
+É um estrito subconjunto de JSON, com a adição de sintaticamente
+novas linhas e recuo significativos, como Python. Ao contrário de Python, no entanto,
+YAML não permite caracteres de tabulação literais em tudo.
+
+```yaml
+# Commentários em YAML são como este.
+
+###################
+# TIPOS ESCALARES #
+###################
+
+# Nosso objeto raiz (que continua por todo o documento) será um mapa,
+# o que equivale a um dicionário, hash ou objeto em outras linguagens.
+chave: valor
+outra_chave: Outro valor vai aqui.
+u_valor_numerico: 100
+notacao_cientifica: 1e+12
+boleano: true
+valor_nulo: null
+chave com espaco: valor
+# Observe que strings não precisam de aspas. Porém, elas podem ter.
+porem: "Uma string, entre aspas."
+"Chaves podem estar entre aspas tambem.": "É útil se você quiser colocar um ':' na sua chave."
+
+# Seqüências de várias linhas podem ser escritos como um 'bloco literal' (utilizando |),
+# ou em um 'bloco compacto' (utilizando '>').
+bloco_literal: |
+    Todo esse bloco de texto será o valor da chave 'bloco_literal',
+    preservando a quebra de com linhas.
+
+    O literal continua até de-dented, e a primeira identação é 
+    removida.
+
+        Quaisquer linhas que são 'mais identadas' mantém o resto de suas identações - 
+        estas linhas serão identadas com 4 espaços.
+estilo_compacto: >
+    Todo esse bloco de texto será o valor de 'estilo_compacto', mas esta
+    vez, todas as novas linhas serão substituídas com espaço simples.
+
+    Linhas em branco, como acima, são convertidas em um carater de nova linha.
+
+        Linhas 'mais-indentadas' mantém suas novas linhas também -
+        este texto irá aparecer em duas linhas.
+
+####################
+# TIPOS DE COLEÇÃO #
+####################
+
+# Texto aninhado é conseguido através de identação.
+um_mapa_aninhado:
+    chave: valor
+    outra_chave: Outro valor
+    outro_mapa_aninhado:
+        ola: ola
+
+# Mapas não tem que ter chaves com string.
+0.25: uma chave com valor flutuante
+
+# As chaves podem ser também objetos multi linhas, utilizando ? para indicar o começo de uma chave.
+? |
+    Esta é uma chave
+    que tem várias linhas
+: e este é o seu valor
+
+# também permite tipos de coleção de chaves, mas muitas linguagens de programação
+# vão reclamar.
+
+# Sequências (equivalente a listas ou arrays) semelhante à isso:
+uma_sequencia:
+    - Item 1
+    - Item 2
+    - 0.5 # sequencias podem conter tipos diferentes.
+    - Item 4
+    - chave: valor
+      outra_chave: outro_valor
+    -
+        - Esta é uma sequencia
+        - dentro de outra sequencia
+
+# Como YAML é um super conjunto de JSON, você também pode escrever mapas JSON de estilo e
+# sequencias:
+mapa_json: {"chave": "valor"}
+json_seq: [3, 2, 1, "decolar"]
+
+##########################
+# RECURSOS EXTRA DO YAML #
+##########################
+
+# YAML também tem um recurso útil chamado "âncoras", que permitem que você facilmente duplique
+# conteúdo em seu documento. Ambas estas chaves terão o mesmo valor:
+conteudo_ancora: & nome_ancora Essa string irá aparecer como o valor de duas chaves.
+outra_ancora: * nome_ancora
+
+# YAML também tem tags, que você pode usar para declarar explicitamente os tipos.
+string_explicita: !! str 0,5
+# Alguns analisadores implementam tags específicas de linguagem, como este para Python de
+# Tipo de número complexo.
+numero_complexo_em_python: !! python / complex 1 + 2j
+
+####################
+# YAML TIPOS EXTRA #
+####################
+
+# Strings e números não são os únicos que escalares YAML pode entender.
+# Data e 'data e hora' literais no formato ISO também são analisados.
+datetime: 2001-12-15T02: 59: 43.1Z
+datetime_com_espacos 2001/12/14: 21: 59: 43.10 -5
+Data: 2002/12/14
+
+# A tag !!binary indica que a string é na verdade um base64-encoded (condificado)
+# representação de um blob binário.
+gif_file: !!binary |
+    R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+    OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+    +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+    AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML também tem um tipo de conjunto, o que se parece com isso:
+set:
+    ? item1
+    ? item2
+    ? item3
+
+# Como Python, são apenas conjuntos de mapas com valors nulos; o acima é equivalente a:
+set2:
+    item1: nulo
+    item2: nulo
+    item3: nulo
+```
diff --git a/pt-pt/brainfuck-pt.html.markdown b/pt-pt/bf.html.markdown
index da4c787f..da4c787f 100644
--- a/pt-pt/brainfuck-pt.html.markdown
+++ b/pt-pt/bf.html.markdown
diff --git a/pt-pt/git-pt.html.markdown b/pt-pt/git-pt.html.markdown
index a85c9704..bd0f0fc5 100644
--- a/pt-pt/git-pt.html.markdown
+++ b/pt-pt/git-pt.html.markdown
@@ -2,7 +2,7 @@
 category: tool
 tool: git
 lang: pt-pt
-filename: LearnGit.txt
+filename: LearnGit-pt.txt
 contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
 translators:
diff --git a/pt-pt/swift.html.markdown b/pt-pt/swift.html.markdown
new file mode 100644
index 00000000..9462ee1c
--- /dev/null
+++ b/pt-pt/swift.html.markdown
@@ -0,0 +1,609 @@
+---
+language: swift
+filename: learnswift-pt.swift
+contributors:
+  - ["Grant Timmerman", "http://github.com/grant"]
+  - ["Christopher Bess", "http://github.com/cbess"]
+  - ["Joey Huang", "http://github.com/kamidox"]
+  - ["Anthony Nguyen", "http://github.com/anthonyn60"]
+  - ["Clayton Walker", "https://github.com/cwalk"]
+translators:
+  - ["João Costa", "https://github.com/joaofcosta"]
+lang: pt-pt
+---
+
+Swift é uma linguagem de programação criada pela Apple para o desenvolvimento em iOS e OS X.
+Desenhada de forma a coexistir com Objective-C e ser mais resiliente contra código errôneo, a linguagem Swift foi introduzida em 2014 na conferência para desenvolvedores WWDC da Apple.
+Swift usa o compilador LLVM incluido no XCode 6+.
+
+O livro oficial [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) da Apple está agora disponivel via iBooks.
+
+Consulta também o [guia de iniciação](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/DevelopiOSAppsSwift/) da Apple, que contêm um tutorial completo em Swift.
+
+```swift
+// importar um módulo
+import UIKit
+
+//
+// MARK: Básico
+//
+
+// O Xcode suporta landmarks para anotação de código e lista-as na jump bar
+// MARK: Marco de secção (MARK)
+// TODO: Algo a fazer em breve
+// FIXME: Reparar este código
+
+// Em Swift 2, println e print foram unidos num só método print. O print automaticamente acrescenta uma nova linha.
+print("Hello, world") // println mudou para print
+print("Hello, world", appendNewLine: false) // imprimir sem acrescentar uma nova linha
+
+// variáveis (var) podem ser modificadas depois de inicializadas
+// constantes (let) NÂO podem ser modificadas depois de inicializadas
+
+var myVariable = 42
+let øπΩ = "value" // nomes de variáveis em unicode
+let π = 3.1415926
+let convenience = "keyword" // nome de variável contextual
+let weak = "keyword"; let override = "another keyword" // expressões podem ser separadas com ';'
+let `class` = "keyword" // plicals permitem que keywords sejam usadas como nomes de vartiáveis
+let explicitDouble: Double = 70
+let intValue = 0007 // 7
+let largeIntValue = 77_000 // 77000
+let label = "some text " + String(myVariable) // Casting
+let piText = "Pi = \(π), Pi 2 = \(π * 2)" // interpolação de Strings
+
+// Valores especificos à build
+// usam a configuração de build -D
+#if false
+    print("Not printed")
+    let buildValue = 3
+#else
+    let buildValue = 7
+#endif
+print("Build value: \(buildValue)") // Build value: 7
+
+/*
+    Optionals são um dos recursos de Swift, Optionals tanto podem conter
+    um valor ou conter nil (sem valor) que indica que não existe um valor.
+    Adicionar um ponto de exclamção (?) após definir o tipo declara
+    esse valor como um Optional.
+
+    Como Swift requere que todas as propriedades tenham um valor, até nil
+    tem que ser explicitamente guardado como um valor Optional.
+
+    Optional<T> é uma enumeração.
+*/
+var someOptionalString: String? = "optional" // Pode assumir o valor nil
+// Igual ao de cima, mas ? é um operando pósfixo (açúcar sintático)
+var someOptionalString2: Optional<String> = "optional"
+
+if someOptionalString != nil {
+    // Não sou nil
+    if someOptionalString!.hasPrefix("opt") {
+        print("has the prefix")
+    }
+
+    let empty = someOptionalString?.isEmpty
+}
+someOptionalString = nil
+
+/*
+    Tentar usar ! para aceder a Optional com valor não existente, ou seja, nil,
+    causa em erro de execução.
+    É necessário ter sempre a certeza que um Optional não tem valor nil
+    antes de usar ! para fazer 'force-unwrap' ao seu valor.
+*/
+
+// Optional implicitamente desembrulhado
+var unwrappedString: String! = "Value is expected."
+// O mesmo de cima, mas ! é um operando pósfixo (mais açúcar sintático)
+var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected."
+
+if let someOptionalStringConstant = someOptionalString {
+    // Tem um valor diferente de nil
+    if !someOptionalStringConstant.hasPrefix("ok") {
+        // Não tem o prefixo
+    }
+}
+
+// Swift tem suporte para guardar valores de qualquer tipo.
+// AnyObject == id
+// Ao contrátio do `id` de Objective-C, AnyObject funciona com qualquer valor (Class, Int, struct, etc.)
+var anyObjectVar: AnyObject = 7
+anyObjectVar = "Changed value to a string, not good practice, but possible."
+
+/*
+    Comentar aqui
+
+    /*
+        Também é possível fazer comentários aninhados
+    */
+*/
+
+//
+// MARK: Coleções (Collections)
+//
+
+/*
+    Os tipos Array e Dictionary são structs e, portanto, `let` e `var`
+    também indicam se eles são mutáveis (var) or imutáveis (let)
+    na altura em que se declaram estes tipos.
+*/
+
+// Array
+var shoppingList = ["catfish", "water", "lemons"]
+shoppingList[1] = "bottle of water"
+let emptyArray = [String]() // let == imutável
+let emptyArray2 = Array<String>() // mesmo de cima
+var emptyMutableArray = [String]() // var == mutável
+
+
+// Dictionary
+var occupations = [
+    "Malcolm": "Captain",
+    "kaylee": "Mechanic"
+]
+occupations["Jayne"] = "Public Relations"
+let emptyDictionary = [String: Float]() // let == imutável
+let emptyDictionary2 = Dictionary<String, Float>() // mesmo de cima
+var emptyMutableDictionary = [String: Float]() // var == mutável
+
+
+//
+// MARK: Controlo de Fluxo (Control Flow)
+//
+
+// for loop (array)
+let myArray = [1, 1, 2, 3, 5]
+for value in myArray {
+    if value == 1 {
+        print("One!")
+    } else {
+        print("Not one!")
+    }
+}
+
+// for loop (dictionary)
+var dict = ["one": 1, "two": 2]
+for (key, value) in dict {
+    print("\(key): \(value)")
+}
+
+// ciclo for (limite)
+for i in -1...shoppingList.count {
+    print(i)
+}
+shoppingList[1...2] = ["steak", "peacons"]
+// usar ..< para excluir o último número
+
+// ciclo while
+var i = 1
+while i < 1000 {
+    i *= 2
+}
+
+// ciclo do-whie
+do {
+    print("hello")
+} while 1 == 2
+
+// Switch
+// Muito poderoso, imagine `if`s com açúcar sintático
+// Funciona para String, instâncias de objectos e primitivas (Int, Double, etc.)
+let vegetable = "red pepper"
+switch vegetable {
+case "celery":
+    let vegetableComment = "Add some raisins and make ants on a log."
+case "cucumber", "watercress":
+    let vegetableComment = "That would make a good tea sandwich."
+case let localScopeValue where localScopeValue.hasSuffix("pepper"):
+    let vegetableComment = "Is it a spicy \(localScopeValue)?"
+default: // obrigatório (de forma a cobrir todos os possíveis inputs)
+    let vegetableComment = "Everything tastes good in soup."
+}
+
+
+//
+// MARK: Funções (Functions)
+//
+
+// Funções são tipos de primeira classe, o que significa que podem ser
+// aninhadas dentro de outras funções e passadas como argumento
+
+// Função em Swift com documentação no header
+
+/**
+    Função de cumprimento.
+
+    - Um ponto em documentação
+    - Outro ponto na documentação
+
+    :param: nome Um nome
+    :param: dia Um dia
+    :returns: Uma string com um cumprimento contendo o nome e o dia.
+*/
+func greet(nome: String, dia: String) -> String {
+    return "Hello \(nome), today is \(dia)."
+}
+greet("Bob", "Tuesday")
+
+// Semelhante ao método de cima excepto ao comportamento dos argumentos
+func greet2(#nomeObrigatório: String, nomeArgumentoExterno nomeArgumentoLocal: String) -> String {
+    return "Hello \(nomeObrigatório), the day is \(nomeArgumentoLocal)"
+}
+greet2(nomeObrigatório:"John", nomeArgumentoExterno: "Sunday")
+
+// Função que devolve vários itens num tuplo
+func getGasPrices() -> (Double, Double, Double) {
+    return (3.59, 3.69, 3.79)
+}
+let pricesTuple = getGasPrices()
+let price = pricesTuple.2 // 3.79
+// Ignorar tuplos ou outros valores usando _ (underscore)
+let (_, price1, _) = pricesTuple // price1 == 3.69
+print(price1 == pricesTuple.1) // true
+print("Gas price: \(price)")
+
+// Argumentos variáveis
+func setup(numbers: Int...) {
+    // é um array
+    let number = numbers[0]
+    let argCount = numbers.count
+}
+
+// Passar e devolver funções
+func makeIncrementer() -> (Int -> Int) {
+    func addOne(number: Int) -> Int {
+        return 1 + number
+    }
+    return addOne
+}
+var increment = makeIncrementer()
+increment(7)
+
+// Passar por referência (inout)
+func swapTwoInts(inout a: Int, inout b: Int) {
+    let tempA = a
+    a = b
+    b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+swapTwoInts(&someIntA, &someIntB)
+print(someIntB) // 7
+
+
+//
+// MARK: Closures
+//
+var numbers = [1, 2, 6]
+
+// Funções são casos especiais de closures ({})
+
+// Exemplo de um Closure.
+// `->` separa o argumento e o tipo de retorno.
+// `in` separa o cabeçalho do closure do corpo do closure.
+numbers.map({
+    (number: Int) -> Int in
+    let result = 3 * number
+    return result
+})
+
+// Quando o tipo é conhecido, como em cima, podemos fazer o seguinte
+numbers = numbers.map({ number in 3 * number })
+// Ou até mesmo isto
+//numbers = numbers.map({ $0 * 3 })
+
+print(numbers) // [3, 6, 18]
+
+// Closure à direita (Trailing closure)
+numbers = sorted(numbers) { $0 > $1 }
+
+print(numbers) // [18, 6, 3]
+
+// Super curto, pois o operador < consegue inferir o tipo
+
+numbers = sorted(numbers, < )
+
+print(numbers) // [3, 6, 18]
+
+//
+// MARK: Estruturas (Structures)
+//
+
+// Estruturas (struct) e classes (class) têm capacidades muito semelhantes
+struct NamesTable {
+    let names = [String]()
+
+    // Custom subscript
+    subscript(index: Int) -> String {
+        return names[index]
+    }
+}
+
+// Estruturas têm um inicializador implicito que é automaticamente gerado
+let namesTable = NamesTable(names: ["Me", "Them"])
+let name = namesTable[1]
+print("Name is \(name)") // Name is Them
+
+//
+// MARK: Classes
+//
+
+// Classes, estruturas e os seus membros têm três níveis de controlo de acesso
+// Nomeadamente: interno (predefinição)(internal) , público (public), privado (private)
+
+public class Shape {
+    public func getArea() -> Int {
+        return 0;
+    }
+}
+
+// Todos os métodos e propriedades de uma classe são públicos.
+// Se só for necessário guarda dados num
+// objecto estruturado, então é melhor usar uma `struct`
+
+internal class Rect: Shape {
+    var sideLength: Int = 1
+
+    // Propriedade getter e setter personalizado
+    private var perimeter: Int {
+        get {
+            return 4 * sideLength
+        }
+        set {
+            // `newValue` é uma variável implicita disponível aos setters
+            sideLength = newValue / 4
+        }
+    }
+
+    // Carregar preguiçosamente uma propriedade
+    // subShape permanece a nil (unintialized) até o getter ser invocado
+    lazy var subShape = Rect(sideLength: 4)
+
+    // Se não for necessário um getter e setter personalizado,
+    // mas se quiser correr o código antes e depois de modificar ou aceder
+    // uma propriedade, é possível usar `willSet` e `didSet`
+    var identifier: String = "defaultID" {
+        // o argumento de `willSet` é o nome da variável para o novo valor
+        willSet(someIdentifier) {
+            print(someIdentifier)
+        }
+    }
+
+    init(sideLength: Int) {
+        self.sideLength = sideLength
+        // invocar super.init no final do método de inicialização
+        super.init()
+    }
+
+    func shrink() {
+        if sideLength > 0 {
+            sideLength -= 1
+        }
+    }
+
+    override func getArea() -> Int {
+        return sideLength * sideLength
+    }
+}
+
+// A class `Square` estende (extends) a classe `Rect` (hierarquia)
+class Square: Rect {
+    convenience init() {
+        self.init(sideLength: 5)
+    }
+}
+
+var mySquare = Square()
+print(mySquare.getArea()) // 25
+mySquare.shrink()
+print(mySquare.sideLength) // 4
+
+// Cast de uma instância de `Square` para `Shape`
+let aShape = mySquare as Shape
+
+// Compara instâncias, não é igual a == , visto que == compara objects (igual a)
+if mySquare === mySquare {
+    print("Yep, it's mySquare")
+}
+
+// Inicializador (init) com Optional
+class Circle: Shape {
+    var radius: Int
+    override func getArea() -> Int {
+        return 3 * radius * radius
+    }
+
+    // Colocar um ponto de interrpgação depois de `init` cria um inicializador
+    // Optional, o qual pode retornar nil
+    init?(radius: Int) {
+        self.radius = radius
+        super.init()
+
+        if radius <= 0 {
+            return nil
+        }
+    }
+}
+
+var myCircle = Circle(radius: 1)
+print(myCircle?.getArea())    // Optional(3)
+print(myCircle!.getArea())    // 3
+var myEmptyCircle = Circle(radius: -1)
+print(myEmptyCircle?.getArea())    // "nil"
+if let circle = myEmptyCircle {
+    // Não vai executar pois a variável myEmptyCircle é igual a nil
+    print("circle is not nil")
+}
+
+
+//
+// MARK: Enumerações (Enums)
+//
+
+// Enums pode opcionalmente ser um tipo especifico ou não.
+// Enums podem conter métodos tal como as classes.
+
+enum Suit {
+    case Spades, Hearts, Diamonds, Clubs
+    func getIcon() -> String {
+        switch self {
+        case .Spades: return "♤"
+        case .Hearts: return "♡"
+        case .Diamonds: return "♢"
+        case .Clubs: return "♧"
+        }
+    }
+}
+
+// Os valores de Enum permitem syntax reduzida, não é preciso escrever o tipo do enum
+// quando a variável é explicitamente definida.
+var suitValue: Suit = .Hearts
+
+// Enums que não sejam inteiros obrigam a atribuições valor bruto (raw value) diretas
+enum BookName: String {
+    case John = "John"
+    case Luke = "Luke"
+}
+print("Name: \(BookName.John.rawValue)")
+
+// Enum com valores associados
+enum Furniture {
+    // Associar com um inteiro (Int)
+    case Desk(height: Int)
+    // Associar com uma String e um Int
+    case Chair(String, Int)
+
+    func description() -> String {
+        switch self {
+        case .Desk(let height):
+            return "Desk with \(height) cm"
+        case .Chair(let brand, let height):
+            return "Chair of \(brand) with \(height) cm"
+        }
+    }
+}
+
+var desk: Furniture = .Desk(height: 80)
+print(desk.description())     // "Desk with 80 cm"
+var chair = Furniture.Chair("Foo", 40)
+print(chair.description())    // "Chair of Foo with 40 cm"
+
+
+//
+// MARK: Protocolos (Protocols)
+//
+
+// Protocolos (`protcol`s) obrigam a que os tipos tenham
+// propriedades de instância, métodos de instância, métodos de tipo,
+// operadores e subscripts específicos.
+
+protocol ShapeGenerator {
+    var enabled: Bool { get set }
+    func buildShape() -> Shape
+}
+
+// Protocolos definidos com @objc permitem funções com optional
+// que permitem verificar se existem conformidade
+@objc protocol TransformShape {
+    optional func reshaped()
+    optional func canReshape() -> Bool
+}
+
+class MyShape: Rect {
+    var delegate: TransformShape?
+
+    func grow() {
+        sideLength += 2
+
+        // Coloca um ponto de interrogação após uma propriedade opcional, método
+        // ou subscript para graciosamente ignorar um valor nil e retornar nil
+        // em vez de provoar um erro em tempo de execução ("optional chaining").
+        if let allow = self.delegate?.canReshape?() {
+            // testar o delegate e depois o método
+            self.delegate?.reshaped?()
+        }
+    }
+}
+
+
+//
+// MARK: Outro
+//
+
+// extensões (`extension`s): Adiciona funcionalidade extra a um tipo já existente.
+
+// Square agora "conforma" com o protocolo `Printable`
+extension Square: Printable {
+    var description: String {
+        return "Area: \(self.getArea()) - ID: \(self.identifier)"
+    }
+}
+
+print("Square: \(mySquare)")
+
+// Também é possível extender tipos já embutidos
+extension Int {
+    var customProperty: String {
+        return "This is \(self)"
+    }
+
+    func multiplyBy(num: Int) -> Int {
+        return num * self
+    }
+}
+
+print(7.customProperty) // "This is 7"
+print(14.multiplyBy(3)) // 42
+
+// Generics: Semelhante a Java e C#. Usa a palavra-chave `where` para
+// especificar requisitos do `generics`.
+
+func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
+        }
+    }
+    return nil
+}
+let foundAtIndex = findIndex([1, 2, 3, 4], 3)
+print(foundAtIndex == 2) // true
+
+// Operadores:
+// Operadores personalizados podem começar com caracteres:
+//      / = - + * % < > ! & | ^ . ~
+// ou
+// Caracteres Unicode matemáticos, símbolos, setas, dingbat e
+// caracteres de desenho linha/caixa.
+operador prefixo !!! {}
+
+// Um operador prefixo que triplica o comprimento do lado quando usado
+prefix func !!! (inout shape: Square) -> Square {
+    shape.sideLength *= 3
+    return shape
+}
+
+// valor atual
+print(mySquare.sideLength) // 4
+
+// muda o comprimento deste lado usando o operador personalizado !!!, aumenta
+// o comprimento 3x
+!!!mySquare
+print(mySquare.sideLength) // 12
+
+// Operadores também podem ser generics
+infix operator <-> {}
+func <-><T: Equatable> (inout a: T, inout b: T) {
+    let c = a
+    a = b
+    b = c
+}
+
+var foo: Float = 10
+var bar: Float = 20
+
+foo <-> bar
+print("foo is \(foo), bar is \(bar)") // "foo is 20.0, bar is 10.0"
+```
diff --git a/purescript.html.markdown b/purescript.html.markdown
index 6d8cfbb9..9ea84d5b 100644
--- a/purescript.html.markdown
+++ b/purescript.html.markdown
@@ -48,7 +48,7 @@ not true -- false
 23 == 23 -- true
 1 /= 4 -- true
 1 >= 4 -- false
--- Comparisions < <= > >=
+-- Comparisons < <= > >=
 -- are defined in terms of compare
 compare 1 2 -- LT
 compare 2 2 -- EQ
@@ -62,10 +62,10 @@ true && (9 >= 19 || 1 < 2) -- true
 "Hellow\
 \orld" -- "Helloworld"
 -- Multiline string with newlines
-"""Hello 
+"""Hello
 world""" -- "Hello\nworld"
 -- Concatenate
-"such " ++ "amaze" -- "such amaze"
+"such " <> "amaze" -- "such amaze"
 
 --
 -- 2. Arrays are Javascript arrays, but must be homogeneous
@@ -85,7 +85,7 @@ head [1,2,3] -- Just (1)
 tail [3,2,1] -- Just ([2,1])
 init [1,2,3] -- Just ([1,2])
 last [3,2,1] -- Just (1)
--- Random access - indexing
+-- Array access - indexing
 [3,4,5,6,7] !! 2 -- Just (5)
 -- Range
 1..5 -- [1,2,3,4,5]
@@ -197,7 +197,7 @@ let even x = x `mod` 2 == 0
 filter even (1..10) -- [2,4,6,8,10]
 map (\x -> x + 11) (1..5) -- [12,13,14,15,16]
 
--- Requires purescript-foldable-traversabe (Data.Foldable)
+-- Requires purescript-foldable-traversable (Data.Foldable)
 
 foldr (+) 0 (1..10) -- 55
 sum (1..10) -- 55
@@ -208,4 +208,3 @@ any even [1,2,3] -- true
 all even [1,2,3] -- false
 
 ```
-
diff --git a/pyqt.html.markdown b/pyqt.html.markdown
new file mode 100644
index 00000000..6bdb6488
--- /dev/null
+++ b/pyqt.html.markdown
@@ -0,0 +1,82 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+---
+
+**Qt** is a widely-known framework for developing cross-platform software that can be run on various software and hardware platforms with little or no change in the code, while having the power and speed of native applications. Though **Qt** was originally written in *C++*.
+
+
+This is an adaption on the C++ intro to QT by [Aleksey Kholovchuk](https://github.com/vortexxx192
+), some of the code examples should result in the same functionality
+this version just having been done using pyqt! 
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Create an application object 
+    app = QtGui.QApplication(sys.argv)
+	# Create a widget where our label will be placed in
+    w = QtGui.QWidget()
+	# Add a label to the widget 
+    b = QtGui.QLabel(w)
+	# Set some text for the label 
+    b.setText("Hello World!")
+	# Give some size and placement information 
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Give our window a nice title 
+    w.setWindowTitle("PyQt")
+	# Have everything display
+    w.show()
+	# Execute what we have asked for, once all setup
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+In order to get some of the more advanced features in **pyqt** we need to start looking at building additional elements. 
+Here we show how to introduce a dialog popup box, useful for asking the user to confirm a decision or to provide information.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Create a button and attach to widget w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Tell b to call this function when clicked
+    # notice the lack of "()" on the function call
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# This function should create a dialog window with a button
+# that waits to be clicked and then exits the program
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # This modality tells the popup to block the parent whilst it's active
+    d.setWindowModality(Qt.ApplicationModal)
+    # On click I'd like the entire process to end
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/python.html.markdown b/python.html.markdown
index 2e7fd8be..0de51285 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -2,26 +2,30 @@
 language: python
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
-    - ["Amin Bandali", "http://aminbandali.com"]
+    - ["Amin Bandali", "https://aminb.org"]
     - ["Andre Polykanine", "https://github.com/Oire"]
     - ["evuez", "http://github.com/evuez"]
+    - ["asyne", "https://github.com/justblah"]
+    - ["habi", "http://github.com/habi"]
 filename: learnpython.py
 ---
 
-Python was created by Guido Van Rossum in the early 90s. It is now one of the most popular
-languages in existence. I fell in love with Python for its syntactic clarity. It's basically
-executable pseudocode.
+Python was created by Guido Van Rossum in the early 90s. It is now one of the
+most popular languages in existence. I fell in love with Python for its
+syntactic clarity. It's basically executable pseudocode.
 
-Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
+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. Python 2.7 is reaching end of life and will stop being maintained in 2020,
-it is though recommended to start learning Python with Python 3.
-For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
+to Python 2.x. Python 2.7 is reaching end of life and will stop being
+maintained in 2020, it is though recommended to start learning Python with
+Python 3. For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
 
-It is also possible to write Python code which is compatible with Python 2.7 and 3.x at the same time,
-using Python [`__future__` imports](https://docs.python.org/2/library/__future__.html). `__future__` imports
-allow you to write Python 3 code that will run on Python 2, so check out the Python 3 tutorial.
+It is also possible to write Python code which is compatible with Python 2.7
+and 3.x at the same time, using Python [`__future__` imports](https://docs.python.org/2/library/__future__.html). `__future__` imports
+allow you to write Python 3 code that will run on Python 2, so check out the
+Python 3 tutorial.
 
 ```python
 
@@ -33,7 +37,7 @@ allow you to write Python 3 code that will run on Python 2, so check out the Pyt
 """
 
 ####################################################
-## 1. Primitive Datatypes and Operators
+# 1. Primitive Datatypes and Operators
 ####################################################
 
 # You have numbers
@@ -50,41 +54,42 @@ allow you to write Python 3 code that will run on Python 2, so check out the Pyt
 5 / 2  # => 2
 
 # To fix division we need to learn about floats.
-2.0     # This is a float
+2.0  # This is a float
 11.0 / 4.0  # => 2.75 ahhh...much better
 
 # Result of integer division truncated down both for positive and negative.
-5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # works on floats too
+5 // 3  # => 1
+5.0 // 3.0  # => 1.0 # works on floats too
 -5 // 3  # => -2
--5.0 // 3.0 # => -2.0
+-5.0 // 3.0  # => -2.0
 
 # Note that we can also import division module(Section 6 Modules)
 # to carry out normal division with just one '/'.
 from __future__ import division
-11/4    # => 2.75  ...normal division
-11//4   # => 2 ...floored division
+
+11 / 4  # => 2.75  ...normal division
+11 // 4  # => 2 ...floored division
 
 # Modulo operation
-7 % 3 # => 1
+7 % 3  # => 1
 
 # Exponentiation (x to the yth power)
-2**4 # => 16
+2 ** 4  # => 16
 
 # Enforce precedence with parentheses
 (1 + 3) * 2  # => 8
 
 # Boolean Operators
 # Note "and" and "or" are case-sensitive
-True and False #=> False
-False or True #=> True
+True and False  # => False
+False or True  # => True
 
 # Note using Bool operators with ints
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-1 == True #=> True
+0 and 2  # => 0
+-5 or 0  # => -5
+0 == False  # => True
+2 == True  # => False
+1 == True  # => True
 
 # negate with not
 not True  # => False
@@ -123,12 +128,15 @@ not False  # => True
 # A string can be treated like a list of characters
 "This is a string"[0]  # => 'T'
 
-#String formatting with %
-#Even though the % string operator will be deprecated on Python 3.1 and removed
-#later at some time, it may still be good to know how it works.
+# You can find the length of a string
+len("This is a string")  # => 16
+
+# String formatting with %
+# Even though the % string operator will be deprecated on Python 3.1 and removed
+# later at some time, it may still be good to know how it works.
 x = 'apple'
 y = 'lemon'
-z = "The items in the basket are %s and %s" % (x,y)
+z = "The items in the basket are %s and %s" % (x, y)
 
 # A newer way to format strings is the format method.
 # This method is the preferred way
@@ -164,20 +172,21 @@ bool("")  # => False
 
 
 ####################################################
-## 2. Variables and Collections
+# 2. Variables and Collections
 ####################################################
 
 # Python has a print statement
-print "I'm Python. Nice to meet you!" # => I'm Python. Nice to meet you!
+print "I'm Python. Nice to meet you!"  # => I'm Python. Nice to meet you!
 
 # Simple way to get input data from console
-input_string_var = raw_input("Enter some data: ") # Returns the data as a string
-input_var = input("Enter some data: ") # Evaluates the data as python code
+input_string_var = raw_input(
+    "Enter some data: ")  # Returns the data as a string
+input_var = input("Enter some data: ")  # Evaluates the data as python code
 # Warning: Caution is recommended for input() method usage
 # Note: In python 3, input() is deprecated and raw_input() is renamed to input()
 
 # No need to declare variables before assigning to them.
-some_var = 5    # Convention is to use lower_case_with_underscores
+some_var = 5  # Convention is to use lower_case_with_underscores
 some_var  # => 5
 
 # Accessing a previously unassigned variable is an exception.
@@ -194,14 +203,14 @@ li = []
 other_li = [4, 5, 6]
 
 # Add stuff to the end of a list with append
-li.append(1)    # li is now [1]
-li.append(2)    # li is now [1, 2]
-li.append(4)    # li is now [1, 2, 4]
-li.append(3)    # li is now [1, 2, 4, 3]
+li.append(1)  # li is now [1]
+li.append(2)  # li is now [1, 2]
+li.append(4)  # li is now [1, 2, 4]
+li.append(3)  # li is now [1, 2, 4, 3]
 # Remove from the end with pop
-li.pop()        # => 3 and li is now [1, 2, 4]
+li.pop()  # => 3 and li is now [1, 2, 4]
 # Let's put it back
-li.append(3)    # li is now [1, 2, 4, 3] again.
+li.append(3)  # li is now [1, 2, 4, 3] again.
 
 # Access a list like you would any array
 li[0]  # => 1
@@ -223,21 +232,21 @@ li[2:]  # => [4, 3]
 # Omit the end
 li[:3]  # => [1, 2, 4]
 # Select every second entry
-li[::2]   # =>[1, 4]
+li[::2]  # =>[1, 4]
 # Reverse a copy of the list
-li[::-1]   # => [3, 4, 2, 1]
+li[::-1]  # => [3, 4, 2, 1]
 # Use any combination of these to make advanced slices
 # li[start:end:step]
 
 # Remove arbitrary elements from a list with "del"
-del li[2]   # li is now [1, 2, 3]
+del li[2]  # li is now [1, 2, 3]
 
 # You can add lists
-li + other_li   # => [1, 2, 3, 4, 5, 6]
+li + other_li  # => [1, 2, 3, 4, 5, 6]
 # Note: values for li and for other_li are not modified.
 
 # Concatenate lists with "extend()"
-li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]
 
 # Remove first occurrence of a value
 li.remove(2)  # li is now [1, 3, 4, 5, 6]
@@ -251,31 +260,29 @@ li.index(2)  # => 1
 li.index(7)  # Raises a ValueError as 7 is not in the list
 
 # Check for existence in a list with "in"
-1 in li   # => True
+1 in li  # => True
 
 # Examine the length with "len()"
-len(li)   # => 6
-
+len(li)  # => 6
 
 # Tuples are like lists but are immutable.
 tup = (1, 2, 3)
-tup[0]   # => 1
+tup[0]  # => 1
 tup[0] = 3  # Raises a TypeError
 
 # You can do all those list thingies on tuples too
-len(tup)   # => 3
-tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
-tup[:2]   # => (1, 2)
-2 in tup   # => True
+len(tup)  # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]  # => (1, 2)
+2 in tup  # => True
 
 # You can unpack tuples (or lists) into variables
-a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
-d, e, f = 4, 5, 6       # you can leave out the parentheses
+a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
+d, e, f = 4, 5, 6  # you can leave out the parentheses
 # Tuples are created by default if you leave out the parentheses
-g = 4, 5, 6             # => (4, 5, 6)
+g = 4, 5, 6  # => (4, 5, 6)
 # Now look how easy it is to swap two values
-e, d = d, e     # d is now 5 and e is now 4
-
+e, d = d, e  # d is now 5 and e is now 4
 
 # Dictionaries store mappings
 empty_dict = {}
@@ -283,30 +290,33 @@ empty_dict = {}
 filled_dict = {"one": 1, "two": 2, "three": 3}
 
 # Look up values with []
-filled_dict["one"]   # => 1
+filled_dict["one"]  # => 1
 
 # Get all keys as a list with "keys()"
-filled_dict.keys()   # => ["three", "two", "one"]
+filled_dict.keys()  # => ["three", "two", "one"]
 # Note - Dictionary key ordering is not guaranteed.
 # Your results might not match this exactly.
 
 # Get all values as a list with "values()"
-filled_dict.values()   # => [3, 2, 1]
+filled_dict.values()  # => [3, 2, 1]
 # Note - Same as above regarding key ordering.
 
+# Get all key-value pairs as a list of tuples with "items()"
+filled_dicts.items()  # => [("one", 1), ("two", 2), ("three", 3)]
+
 # Check for existence of keys in a dictionary with "in"
-"one" in filled_dict   # => True
-1 in filled_dict   # => False
+"one" in filled_dict  # => True
+1 in filled_dict  # => False
 
 # Looking up a non-existing key is a KeyError
-filled_dict["four"]   # KeyError
+filled_dict["four"]  # KeyError
 
 # Use "get()" method to avoid the KeyError
-filled_dict.get("one")   # => 1
-filled_dict.get("four")   # => None
+filled_dict.get("one")  # => 1
+filled_dict.get("four")  # => None
 # The get method supports a default argument when the value is missing
-filled_dict.get("one", 4)   # => 1
-filled_dict.get("four", 4)   # => 4
+filled_dict.get("one", 4)  # => 1
+filled_dict.get("four", 4)  # => 4
 # note that filled_dict.get("four") is still => None
 # (get doesn't set the value in the dictionary)
 
@@ -317,47 +327,46 @@ filled_dict["four"] = 4  # now, filled_dict["four"] => 4
 filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
 filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
 
-
 # Sets store ... well sets (which are like lists but can contain no duplicates)
 empty_set = set()
 # Initialize a "set()" with a bunch of values
-some_set = set([1, 2, 2, 3, 4])   # some_set is now set([1, 2, 3, 4])
+some_set = set([1, 2, 2, 3, 4])  # some_set is now set([1, 2, 3, 4])
 
 # order is not guaranteed, even though it may sometimes look sorted
 another_set = set([4, 3, 2, 2, 1])  # another_set is now set([1, 2, 3, 4])
 
 # Since Python 2.7, {} can be used to declare a set
-filled_set = {1, 2, 2, 3, 4}   # => {1, 2, 3, 4}
+filled_set = {1, 2, 2, 3, 4}  # => {1, 2, 3, 4}
 
 # Add more items to a set
-filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
 
 # Do set intersection with &
 other_set = {3, 4, 5, 6}
-filled_set & other_set   # => {3, 4, 5}
+filled_set & other_set  # => {3, 4, 5}
 
 # Do set union with |
-filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
 
 # Do set difference with -
-{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
 
 # Do set symmetric difference with ^
 {1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
 
 # Check if set on the left is a superset of set on the right
-{1, 2} >= {1, 2, 3} # => False
+{1, 2} >= {1, 2, 3}  # => False
 
 # Check if set on the left is a subset of set on the right
-{1, 2} <= {1, 2, 3} # => True
+{1, 2} <= {1, 2, 3}  # => True
 
 # Check for existence in a set with in
-2 in filled_set   # => True
-10 in filled_set   # => False
+2 in filled_set  # => True
+10 in filled_set  # => False
 
 
 ####################################################
-## 3. Control Flow
+#  3. Control Flow
 ####################################################
 
 # Let's just make a variable
@@ -367,12 +376,11 @@ some_var = 5
 # prints "some_var is smaller than 10"
 if some_var > 10:
     print "some_var is totally bigger than 10."
-elif some_var < 10:    # This elif clause is optional.
+elif some_var < 10:  # This elif clause is optional.
     print "some_var is smaller than 10."
-else:           # This is optional too.
+else:  # This is optional too.
     print "some_var is indeed 10."
 
-
 """
 For loops iterate over lists
 prints:
@@ -428,12 +436,12 @@ try:
     # Use "raise" to raise an error
     raise IndexError("This is an index error")
 except IndexError as e:
-    pass    # Pass is just a no-op. Usually you would do recovery here.
+    pass  # Pass is just a no-op. Usually you would do recovery here.
 except (TypeError, NameError):
-    pass    # Multiple exceptions can be handled together, if required.
-else:   # Optional clause to the try/except block. Must follow all except blocks
-    print "All good!"   # Runs only if the code in try raises no exceptions
-finally: #  Execute under all circumstances
+    pass  # Multiple exceptions can be handled together, if required.
+else:  # Optional clause to the try/except block. Must follow all except blocks
+    print "All good!"  # Runs only if the code in try raises no exceptions
+finally:  # Execute under all circumstances
     print "We can clean up resources here"
 
 # Instead of try/finally to cleanup resources you can use a with statement
@@ -441,20 +449,22 @@ with open("myfile.txt") as f:
     for line in f:
         print line
 
+
 ####################################################
-## 4. Functions
+# 4. Functions
 ####################################################
 
 # Use "def" to create new functions
 def add(x, y):
     print "x is {0} and y is {1}".format(x, y)
-    return x + y    # Return values with a return statement
+    return x + y  # Return values with a return statement
+
 
 # Calling functions with parameters
-add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+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.
+add(y=6, x=5)  # Keyword arguments can arrive in any order.
 
 
 # You can define functions that take a variable number of
@@ -462,7 +472,8 @@ add(y=6, x=5)   # Keyword arguments can arrive in any order.
 def varargs(*args):
     return args
 
-varargs(1, 2, 3)   # => (1, 2, 3)
+
+varargs(1, 2, 3)  # => (1, 2, 3)
 
 
 # You can define functions that take a variable number of
@@ -470,14 +481,17 @@ varargs(1, 2, 3)   # => (1, 2, 3)
 def keyword_args(**kwargs):
     return kwargs
 
+
 # Let's call it to see what happens
-keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
 
 
 # You can do both at once, if you like
 def all_the_args(*args, **kwargs):
     print args
     print kwargs
+
+
 """
 all_the_args(1, 2, a=3, b=4) prints:
     (1, 2)
@@ -488,9 +502,10 @@ all_the_args(1, 2, a=3, b=4) prints:
 # Use * to expand positional args and use ** to expand keyword args.
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
-all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
-all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
-all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args)  # equivalent to foo(1, 2, 3, 4)
+all_the_args(**kwargs)  # equivalent to foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+
 
 # you can pass args and kwargs along to other functions that take args/kwargs
 # by expanding them with * and ** respectively
@@ -499,54 +514,64 @@ def pass_all_the_args(*args, **kwargs):
     print varargs(*args)
     print keyword_args(**kwargs)
 
+
 # Function Scope
 x = 5
 
+
 def set_x(num):
     # Local var x not the same as global variable x
-    x = num # => 43
-    print x # => 43
+    x = num  # => 43
+    print x  # => 43
+
 
 def set_global_x(num):
     global x
-    print x # => 5
-    x = num # global var x is now set to 6
-    print x # => 6
+    print x  # => 5
+    x = num  # global var x is now set to 6
+    print x  # => 6
+
 
 set_x(43)
 set_global_x(6)
 
+
 # Python has first class functions
 def create_adder(x):
     def adder(y):
         return x + y
+
     return adder
 
+
 add_10 = create_adder(10)
-add_10(3)   # => 13
+add_10(3)  # => 13
 
 # There are also anonymous functions
-(lambda x: x > 2)(3)   # => True
-(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
+(lambda x: x > 2)(3)  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
 
 # There are built-in higher order functions
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
-map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
+map(add_10, [1, 2, 3])  # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
 
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
 
 # We can use list comprehensions for nice maps and filters
 [add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
+
+# You can construct set and dict comprehensions as well.
+{x for x in 'abcddeef' if x in 'abc'}  # => {'a', 'b', 'c'}
+{x: x ** 2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
 
 
 ####################################################
-## 5. Classes
+# 5. Classes
 ####################################################
 
 # We subclass from object to get a class.
 class Human(object):
-
     # A class attribute. It is shared by all instances of this class
     species = "H. sapiens"
 
@@ -561,7 +586,6 @@ class Human(object):
         # Initialize property
         self.age = 0
 
-
     # An instance method. All methods take "self" as the first argument
     def say(self, msg):
         return "{0}: {1}".format(self.name, msg)
@@ -597,45 +621,46 @@ class Human(object):
 
 # Instantiate a class
 i = Human(name="Ian")
-print i.say("hi")     # prints out "Ian: hi"
+print i.say("hi")  # prints out "Ian: hi"
 
 j = Human("Joel")
 print j.say("hello")  # prints out "Joel: hello"
 
 # Call our class method
-i.get_species()   # => "H. sapiens"
+i.get_species()  # => "H. sapiens"
 
 # Change the shared attribute
 Human.species = "H. neanderthalensis"
-i.get_species()   # => "H. neanderthalensis"
-j.get_species()   # => "H. neanderthalensis"
+i.get_species()  # => "H. neanderthalensis"
+j.get_species()  # => "H. neanderthalensis"
 
 # Call the static method
-Human.grunt()   # => "*grunt*"
+Human.grunt()  # => "*grunt*"
 
 # Update the property
 i.age = 42
 
 # Get the property
-i.age # => 42
+i.age  # => 42
 
 # Delete the property
 del i.age
 i.age  # => raises an AttributeError
 
-
 ####################################################
-## 6. Modules
+# 6. Modules
 ####################################################
 
 # You can import modules
 import math
+
 print math.sqrt(16)  # => 4
 
 # You can get specific functions from a module
 from math import ceil, floor
+
 print ceil(3.7)  # => 4.0
-print floor(3.7)   # => 3.0
+print floor(3.7)  # => 3.0
 
 # You can import all functions from a module.
 # Warning: this is not recommended
@@ -643,9 +668,11 @@ from math import *
 
 # You can shorten module names
 import math as m
-math.sqrt(16) == m.sqrt(16)   # => True
+
+math.sqrt(16) == m.sqrt(16)  # => True
 # you can also test that the functions are equivalent
 from math import sqrt
+
 math.sqrt == m.sqrt == sqrt  # => True
 
 # Python modules are just ordinary python files. You
@@ -655,38 +682,94 @@ math.sqrt == m.sqrt == sqrt  # => True
 # You can find out which functions and attributes
 # defines a module.
 import math
+
 dir(math)
 
 
+# If you have a Python script named math.py in the same
+# folder as your current script, the file math.py will
+# be loaded instead of the built-in Python module.
+# This happens because the local folder has priority
+# over Python's built-in libraries.
+
+
 ####################################################
-## 7. Advanced
+# 7. Advanced
 ####################################################
 
-# Generators help you make lazy code
+# Generators
+# A generator "generates" values as they are requested instead of storing
+# everything up front
+
+# The following method (*NOT* a generator) will double all values and store it
+# in `double_arr`. For large size of iterables, that might get huge!
 def double_numbers(iterable):
+    double_arr = []
+    for i in iterable:
+        double_arr.append(i + i)
+    return double_arr
+
+
+# Running the following would mean we'll double all values first and return all
+# of them back to be checked by our condition
+for value in double_numbers(range(1000000)):  # `test_non_generator`
+    print value
+    if value > 5:
+        break
+
+
+# We could instead use a generator to "generate" the doubled value as the item
+# is being requested
+def double_numbers_generator(iterable):
     for i in iterable:
         yield i + i
 
-# A generator creates values on the fly.
-# Instead of generating and returning all values at once it creates one in each
-# iteration.  This means values bigger than 15 wont be processed in
-# double_numbers.
-# Note xrange is a generator that does the same thing range does.
-# Creating a list 1-900000000 would take lot of time and space to be made.
-# xrange creates an xrange generator object instead of creating the entire list
-# like range does.
-# We use a trailing underscore in variable names when we want to use a name that
-# would normally collide with a python keyword
-xrange_ = xrange(1, 900000000)
-
-# will double all numbers until a result >=30 found
-for i in double_numbers(xrange_):
-    print i
-    if i >= 30:
+
+# Running the same code as before, but with a generator, now allows us to iterate
+# over the values and doubling them one by one as they are being consumed by
+# our logic. Hence as soon as we see a value > 5, we break out of the
+# loop and don't need to double most of the values sent in (MUCH FASTER!)
+for value in double_numbers_generator(xrange(1000000)):  # `test_generator`
+    print value
+    if value > 5:
         break
 
+# BTW: did you notice the use of `range` in `test_non_generator` and `xrange` in `test_generator`?
+# Just as `double_numbers_generator` is the generator version of `double_numbers`
+# We have `xrange` as the generator version of `range`
+# `range` would return back and array with 1000000 values for us to use
+# `xrange` would generate 1000000 values for us as we request / iterate over those items
+
+# Just as you can create a list comprehension, you can create generator
+# comprehensions as well.
+values = (-x for x in [1, 2, 3, 4, 5])
+for x in values:
+    print(x)  # prints -1 -2 -3 -4 -5 to console/terminal
+
+# You can also cast a generator comprehension directly to a list.
+values = (-x for x in [1, 2, 3, 4, 5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
 
 # Decorators
+# A decorator is a higher order function, which accepts and returns a function.
+# Simple usage example – add_apples decorator will add 'Apple' element into
+# fruits list returned by get_fruits target function.
+def add_apples(func):
+    def get_fruits():
+        fruits = func()
+        fruits.append('Apple')
+        return fruits
+    return get_fruits
+
+@add_apples
+def get_fruits():
+    return ['Banana', 'Mango', 'Orange']
+
+# Prints out the list of fruits with 'Apple' element in it:
+# Banana, Mango, Orange, Apple
+print ', '.join(get_fruits())
+
 # in this example beg wraps say
 # Beg will call say. If say_please is True then it will change the returned
 # message
diff --git a/python3.html.markdown b/python3.html.markdown
index ff531b17..5aa61b65 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -9,7 +9,7 @@ contributors:
 filename: learnpython3.py
 ---
 
-Python was created by Guido Van Rossum in the early 90s. It is now one of the most popular
+Python was created by Guido van Rossum in the early 90s. It is now one of the most popular
 languages in existence. I fell in love with Python for its syntactic clarity. It's basically
 executable pseudocode.
 
@@ -23,7 +23,7 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
 
 """ Multiline strings can be written
     using three "s, and are often used
-    as comments
+    as documentation.
 """
 
 ####################################################
@@ -37,8 +37,6 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
 1 + 1   # => 2
 8 - 1   # => 7
 10 * 2  # => 20
-
-# Except division which returns floats, real numbers, by default
 35 / 5  # => 7.0
 
 # Result of integer division truncated down both for positive and negative.
@@ -47,14 +45,14 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
 -5 // 3      # => -2
 -5.0 // 3.0  # => -2.0
 
-# When you use a float, results are floats
-3 * 2.0  # => 6.0
+# The result of division is always a float
+10.0 / 3  # => 3.3333333333333335
 
 # Modulo operation
 7 % 3  # => 1
 
 # Exponentiation (x**y, x to the yth power)
-2**4  # => 16
+2**3  # => 8
 
 # Enforce precedence with parentheses
 (1 + 3) * 2  # => 8
@@ -73,11 +71,14 @@ True and False  # => False
 False or True   # => True
 
 # Note using Bool operators with ints
+# False is 0 and True is 1
+# Don't mix up with bool(ints) and bitwise and/or (&,|)
 0 and 2     # => 0
 -5 or 0     # => -5
 0 == False  # => True
 2 == True   # => False
 1 == True   # => True
+-5 != False != True #=> True
 
 # Equality is ==
 1 == 1  # => True
@@ -113,12 +114,15 @@ b == a            # => True, a's and b's objects are equal
 
 # Strings can be added too! But try not to do this.
 "Hello " + "world!"  # => "Hello world!"
-# Strings can be added without using '+'
+# String literals (but not variables) can be concatenated without using '+'
 "Hello " "world!"    # => "Hello world!"
 
 # A string can be treated like a list of characters
 "This is a string"[0]  # => 'T'
 
+# You can find the length of a string
+len("This is a string")  # => 16
+
 # .format can be used to format strings, like this:
 "{} can be {}".format("Strings", "interpolated")  # => "Strings can be interpolated"
 
@@ -142,13 +146,13 @@ None  # => None
 "etc" is None  # => False
 None is None   # => True
 
-# None, 0, and empty strings/lists/dicts all evaluate to False.
+# None, 0, and empty strings/lists/dicts/tuples all evaluate to False.
 # All other values are True
 bool(0)   # => False
 bool("")  # => False
 bool([])  # => False
 bool({})  # => False
-
+bool(())  # => False
 
 ####################################################
 ## 2. Variables and Collections
@@ -158,14 +162,14 @@ bool({})  # => False
 print("I'm Python. Nice to meet you!")  # => I'm Python. Nice to meet you!
 
 # By default the print function also prints out a newline at the end.
-# Use the optional argument end to change the end character.
+# Use the optional argument end to change the end string.
 print("Hello, World", end="!")  # => Hello, World!
 
 # Simple way to get input data from console
 input_string_var = input("Enter some data: ") # Returns the data as a string
 # Note: In earlier versions of Python, input() method was named as raw_input()
 
-# No need to declare variables before assigning to them.
+# There are no declarations, only assignments.
 # Convention is to use lower_case_with_underscores
 some_var = 5
 some_var  # => 5
@@ -174,6 +178,10 @@ some_var  # => 5
 # See Control Flow to learn more about exception handling.
 some_unknown_var  # Raises a NameError
 
+# if can be used as an expression
+# Equivalent of C's '?:' ternary operator
+"yahoo!" if 3 > 2 else 2  # => "yahoo!"
+
 # Lists store sequences
 li = []
 # You can start with a prefilled list
@@ -198,11 +206,12 @@ li[-1]  # => 3
 li[4]  # Raises an IndexError
 
 # You can look at ranges with slice syntax.
+# The start index is included, the end index is not
 # (It's a closed/open range for you mathy types.)
 li[1:3]   # => [2, 4]
-# Omit the beginning
-li[2:]    # => [4, 3]
 # Omit the end
+li[2:]    # => [4, 3]
+# Omit the beginning
 li[:3]    # => [1, 2, 4]
 # Select every second entry
 li[::2]   # =>[1, 4]
@@ -269,7 +278,7 @@ d, e, f = 4, 5, 6
 e, d = d, e  # d is now 5 and e is now 4
 
 
-# Dictionaries store mappings
+# Dictionaries store mappings from keys to values
 empty_dict = {}
 # Here is a prefilled dictionary
 filled_dict = {"one": 1, "two": 2, "three": 3}
@@ -315,7 +324,7 @@ filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
 
 # Adding to a dictionary
 filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
-#filled_dict["four"] = 4        #another way to add to dict
+filled_dict["four"] = 4         # another way to add to dict
 
 # Remove keys from a dictionary with del
 del filled_dict["one"]  # Removes the key "one" from filled dict
@@ -335,10 +344,8 @@ some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}
 invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
 valid_set = {(1,), 1}
 
-# Can set new variables to a set
-filled_set = some_set
-
 # Add one more item to the set
+filled_set = some_set
 filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
 
 # Do set intersection with &
@@ -373,8 +380,9 @@ filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
 # Let's just make a variable
 some_var = 5
 
-# Here is an if statement. Indentation is significant in python!
-# prints "some_var is smaller than 10"
+# Here is an if statement. Indentation is significant in Python!
+# Convention is to use four spaces, not tabs.
+# This prints "some_var is smaller than 10"
 if some_var > 10:
     print("some_var is totally bigger than 10.")
 elif some_var < 10:    # This elif clause is optional.
@@ -462,7 +470,7 @@ with open("myfile.txt") as f:
 
 # Python offers a fundamental abstraction called the Iterable.
 # An iterable is an object that can be treated as a sequence.
-# The object returned the range function, is an iterable.
+# The object returned by the range function, is an iterable.
 
 filled_dict = {"one": 1, "two": 2, "three": 3}
 our_iterable = filled_dict.keys()
@@ -486,7 +494,7 @@ next(our_iterator)  # => "one"
 next(our_iterator)  # => "two"
 next(our_iterator)  # => "three"
 
-# After the iterator has returned all of its data, it gives you a StopIterator Exception
+# After the iterator has returned all of its data, it raises a StopIteration exception
 next(our_iterator)  # Raises StopIteration
 
 # You can grab all the elements of an iterator by calling list() on it.
@@ -558,13 +566,13 @@ x = 5
 def set_x(num):
     # Local var x not the same as global variable x
     x = num    # => 43
-    print (x)  # => 43
+    print(x)   # => 43
 
 def set_global_x(num):
     global x
-    print (x)  # => 5
+    print(x)   # => 5
     x = num    # global var x is now set to 6
-    print (x)  # => 6
+    print(x)   # => 6
 
 set_x(43)
 set_global_x(6)
@@ -583,24 +591,64 @@ add_10(3)   # => 13
 (lambda x: x > 2)(3)                  # => True
 (lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
 
-# TODO - Fix for iterables
 # There are built-in higher order functions
-map(add_10, [1, 2, 3])          # => [11, 12, 13]
-map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
+list(map(add_10, [1, 2, 3]))          # => [11, 12, 13]
+list(map(max, [1, 2, 3], [4, 2, 1]))  # => [4, 2, 3]
 
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
+list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]
 
 # We can use list comprehensions for nice maps and filters
 # List comprehension stores the output as a list which can itself be a nested list
 [add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
 [x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
 
+# You can construct set and dict comprehensions as well.
+{x for x in 'abcddeef' if x not in 'abc'}  # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
 ####################################################
-## 5. Classes
+## 5. Modules
 ####################################################
 
+# You can import modules
+import math
+print(math.sqrt(16))  # => 4.0
+
+# You can get specific functions from a module
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# You can import all functions from a module.
+# Warning: this is not recommended
+from math import *
+
+# You can shorten module names
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# Python modules are just ordinary Python files. You
+# can write your own, and import them. The name of the
+# module is the same as the name of the file.
+
+# You can find out which functions and attributes
+# are defined in a module.
+import math
+dir(math)
+
+# If you have a Python script named math.py in the same
+# folder as your current script, the file math.py will
+# be loaded instead of the built-in Python module.
+# This happens because the local folder has priority
+# over Python's built-in libraries.
+
+
+####################################################
+## 6. Classes
+####################################################
 
-# We use the "class" operator to get a class
+# We use the "class" statement to create a class
 class Human:
 
     # A class attribute. It is shared by all instances of this class
@@ -608,20 +656,24 @@ class Human:
 
     # 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
+    # or attributes that are used by Python but that live in user-controlled
     # namespaces. Methods(or objects or attributes) like: __init__, __str__,
-    # __repr__ etc. are called magic methods (or sometimes called dunder methods)
+    # __repr__ etc. are called special 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
 
         # Initialize property
-        self.age = 0
+        self._age = 0
 
     # An instance method. All methods take "self" as the first argument
     def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=msg)
+        print ("{name}: {message}".format(name=self.name, message=msg))
+
+    # Another instance method
+    def sing(self):
+        return 'yo... yo... microphone check... one two... one two...'
 
     # A class method is shared among all instances
     # They are called with the calling class as the first argument
@@ -635,8 +687,8 @@ class Human:
         return "*grunt*"
 
     # A property is just like a getter.
-    # It turns the method age() into an read-only attribute
-    # of the same name.
+    # It turns the method age() into an read-only attribute of the same name.
+    # There's no need to write trivial getters and setters in Python, though.
     @property
     def age(self):
         return self._age
@@ -652,94 +704,169 @@ class Human:
         del self._age
 
 
-# Instantiate a class
-i = Human(name="Ian")
-print(i.say("hi"))     # prints out "Ian: hi"
+# When a Python interpreter reads a source file it executes all its code.
+# This __name__ check makes sure this code block is only executed when this
+# module is the main program.
+if __name__ == '__main__':
+    # Instantiate a class
+    i = Human(name="Ian")
+    i.say("hi")                     # "Ian: hi"
+    j = Human("Joel")
+    j.say("hello")                  # "Joel: hello"
+    # i and j are instances of type Human, or in other words: they are Human objects
+
+    # Call our class method
+    i.say(i.get_species())          # "Ian: H. sapiens"
+    # Change the shared attribute
+    Human.species = "H. neanderthalensis"
+    i.say(i.get_species())          # => "Ian: H. neanderthalensis"
+    j.say(j.get_species())          # => "Joel: H. neanderthalensis"
+
+    # Call the static method
+    print(Human.grunt())            # => "*grunt*"
+    
+    # Cannot call static method with instance of object 
+    # because i.grunt() will automatically put "self" (the object i) as an argument
+    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given
+                                    
+    # Update the property for this instance
+    i.age = 42
+    # Get the property
+    i.say(i.age)                    # => "Ian: 42"
+    j.say(j.age)                    # => "Joel: 0"
+    # Delete the property
+    del i.age
+    # i.age                         # => this would raise an AttributeError
 
-j = Human("Joel")
-print(j.say("hello"))  # prints out "Joel: hello"
 
-# Call our class method
-i.get_species()  # => "H. sapiens"
+####################################################
+## 6.1 Multiple Inheritance
+####################################################
 
-# Change the shared attribute
-Human.species = "H. neanderthalensis"
-i.get_species()  # => "H. neanderthalensis"
-j.get_species()  # => "H. neanderthalensis"
+# Another class definition
+class Bat:
 
-# Call the static method
-Human.grunt()    # => "*grunt*"
+    species = 'Baty'
 
-# Update the property
-i.age = 42
+    def __init__(self, can_fly=True):
+        self.fly = can_fly
 
-# Get the property
-i.age # => 42
+    # This class also has a say method
+    def say(self, msg):
+        msg = '... ... ...'
+        return msg
 
-# Delete the property
-del i.age
-i.age  # => raises an AttributeError
+    # And its own method as well
+    def sonar(self):
+        return '))) ... ((('
 
+if __name__ == '__main__':
+    b = Bat()
+    print(b.say('hello'))
+    print(b.fly)
 
+# To take advantage of modularization by file you could place the classes above in their own files,
+# say, human.py and bat.py
 
-####################################################
-## 6. Modules
-####################################################
+# To import functions from other files use the following format
+# from "filename-without-extension" import "function-or-class"
 
-# You can import modules
-import math
-print(math.sqrt(16))  # => 4.0
+# superhero.py
+from human import Human
+from bat import Bat
 
-# You can get specific functions from a module
-from math import ceil, floor
-print(ceil(3.7))   # => 4.0
-print(floor(3.7))  # => 3.0
+# Batman inherits from both Human and Bat
+class Batman(Human, Bat):
 
-# You can import all functions from a module.
-# Warning: this is not recommended
-from math import *
+    # Batman has its own value for the species class attribute
+    species = 'Superhero'
 
-# You can shorten module names
-import math as m
-math.sqrt(16) == m.sqrt(16)  # => True
+    def __init__(self, *args, **kwargs):
+        # Typically to inherit attributes you have to call super:
+        #super(Batman, self).__init__(*args, **kwargs)      
+        # However we are dealing with multiple inheritance here, and super()
+        # only works with the next base class in the MRO list.
+        # So instead we explicitly call __init__ for all ancestors.
+        # The use of *args and **kwargs allows for a clean way to pass arguments,
+        # with each parent "peeling a layer of the onion".
+        Human.__init__(self, 'anonymous', *args, **kwargs)
+        Bat.__init__(self, *args, can_fly=False, **kwargs)
+        # override the value for the name attribute
+        self.name = 'Sad Affleck'
 
-# Python modules are just ordinary python files. You
-# can write your own, and import them. The name of the
-# module is the same as the name of the file.
+    def sing(self):
+        return 'nan nan nan nan nan batman!'
+
+
+if __name__ == '__main__':
+    sup = Batman()
+
+    # Instance type checks
+    if isinstance(sup, Human):
+        print('I am human')
+    if isinstance(sup, Bat):
+        print('I am bat')
+    if type(sup) is Batman:
+        print('I am Batman')
+
+    # Get the Method Resolution search Order used by both getattr() and super().
+    # This attribute is dynamic and can be updated
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>, <class 'human.Human'>, <class 'bat.Bat'>, <class 'object'>)
+
+    # Calls parent method but uses its own class attribute
+    print(sup.get_species())    # => Superhero
+
+    # Calls overloaded method
+    print(sup.sing())           # => nan nan nan nan nan batman!
+
+    # Calls method from Human, because inheritance order matters
+    sup.say('I agree')          # => Sad Affleck: I agree
+
+    # Call method that exists only in 2nd ancestor
+    print(sup.sonar())          # => ))) ... (((
+
+    # Inherited class attribute
+    sup.age = 100
+    print(sup.age)
+
+    # Inherited attribute from 2nd ancestor whose default value was overridden.
+    print('Can I fly? ' + str(sup.fly))
 
-# You can find out which functions and attributes
-# defines a module.
-import math
-dir(math)
 
 
 ####################################################
 ## 7. Advanced
 ####################################################
 
-# Generators help you make lazy code
+# Generators help you make lazy code.
 def double_numbers(iterable):
     for i in iterable:
         yield i + i
 
-# A generator creates values on the fly.
-# Instead of generating and returning all values at once it creates one in each
-# iteration.  This means values bigger than 15 wont be processed in
-# double_numbers.
-# We use a trailing underscore in variable names when we want to use a name that
-# would normally collide with a python keyword
-range_ = range(1, 900000000)
-# will double all numbers until a result >=30 found
-for i in double_numbers(range_):
+# Generators are memory-efficient because they only load the data needed to
+# process the next value in the iterable. This allows them to perform
+# operations on otherwise prohibitively large value ranges.
+# NOTE: `range` replaces `xrange` in Python 3.
+for i in double_numbers(range(1, 900000000)):  # `range` is a generator.
     print(i)
     if i >= 30:
         break
 
+# Just as you can create a list comprehension, you can create generator
+# comprehensions as well.
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+    print(x)  # prints -1 -2 -3 -4 -5 to console/terminal
+
+# You can also cast a generator comprehension directly to a list.
+values = (-x for x in [1,2,3,4,5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
 
 # Decorators
-# in this example beg wraps say
-# Beg will call say. If say_please is True then it will change the returned
-# message
+# In this example `beg` wraps `say`. If say_please is True then it
+# will change the returned message.
 from functools import wraps
 
 
@@ -769,21 +896,14 @@ print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
 ### Free Online
 
 * [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
 * [Ideas for Python Projects](http://pythonpracticeprojects.com)
 * [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)
 * [First Steps With Python](https://realpython.com/learn/python-first-steps/)
 * [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
 * [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
 * [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
 * [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
-
-### Dead Tree
-
-* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
-* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python 3](http://www.diveintopython3.net/index.html)
+* [A Crash Course in Python for Scientists](http://nbviewer.jupyter.org/gist/anonymous/5924718)
diff --git a/pythonstatcomp.html.markdown b/pythonstatcomp.html.markdown
index f8d83b98..8ee3aa64 100644
--- a/pythonstatcomp.html.markdown
+++ b/pythonstatcomp.html.markdown
@@ -1,8 +1,8 @@
 ---
-language: Statistical computing with Python
+category: tool
+tool: Statistical Computing with Python
 contributors:
     - ["e99n09", "https://github.com/e99n09"]
-filename: pythonstatcomp.py
 ---
 
 This is a tutorial on how to do some typical statistical programming tasks using Python. It's intended for people basically familiar with Python and experienced at statistical programming in a language like R, Stata, SAS, SPSS, or MATLAB.
@@ -150,9 +150,8 @@ ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
 url = "https://raw.githubusercontent.com/e99n09/R-notes/master/data/hre.csv"
 r = requests.get(url)
 fp = "hre.csv"
-f = open(fp, "wb")
-f.write(r.text.encode("UTF-8"))
-f.close()
+with open(fp, "wb") as f:
+    f.write(r.text.encode("UTF-8"))
 
 hre = pd.read_csv(fp)
 
diff --git a/qt.html.markdown b/qt.html.markdown
new file mode 100644
index 00000000..a9c855a6
--- /dev/null
+++ b/qt.html.markdown
@@ -0,0 +1,159 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt.cpp
+contributors:
+    - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+lang: en
+---
+
+**Qt** is a widely-known framework for developing cross-platform software that can be run on various software and hardware platforms with little or no change in the code, while having the power and speed of native applications. Though **Qt** was originally written in *C++*, there are its ports to other languages: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** is great for creating applications with graphical user interface (GUI). This tutorial is how to do it in *C++*.
+
+```c++
+/*
+ * Let's start clasically
+ */
+
+// all headers from Qt framework start with capital letter 'Q'
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+	 // create an object to manage application-wide resources
+    QApplication app(argc, argv);
+
+    // create line edit widget and show it on screen
+    QLineEdit lineEdit("Hello world!");
+    lineEdit.show();
+
+    // start the application's event loop
+    return app.exec();
+}
+```
+
+GUI-related part of **Qt** is all about *widgets* and *connections* between them.
+
+[READ MORE ABOUT WIDGETS](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Let's create a label and a button.
+ * A label should appear when a button is pressed.
+ * 
+ * Qt code is speaking for itself.
+ */
+ 
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+    
+    // add vertical layout 
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);  
+
+    QLabel textLabel("Thanks for pressing that button");
+    layout.addWidget(&textLabel);
+    textLabel.hide();
+
+    QPushButton button("Press me");
+    layout.addWidget(&button);
+    
+    // show hidden label when the button is pressed
+    QObject::connect(&button, &QPushButton::pressed,
+                     &textLabel, &QLabel::show);
+
+    return app.exec();
+}
+```
+
+Notice that *QObject::connect* part. This method is used to connect *SIGNALS* of one objects to *SLOTS* of another.
+
+**Signals** are being emited when certain things happen with objects, like *pressed* signal is emited when user presses on QPushButton object.
+
+**Slots** are *actions* that might be performed in response to received signals.
+
+[READ MORE ABOUT SLOTS AND SIGNALS](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+Next, let's learn that we can not only use standard widgets but also extend their behaviour using inheritance. Let's create a button and count how many times it was pressed. For this purpose we define our own class *CounterLabel*.  It must be declared in separate file because of specific Qt architecture.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+    Q_OBJECT  // Qt-defined macros that must be present in every custom widget
+
+public:
+    CounterLabel() : counter(0) {
+        setText("Counter has not been increased yet");  // method of QLabel
+    }
+
+public slots:
+    // action that will be called in response to button press
+    void increaseCounter() {
+        setText(QString("Counter value: %1").arg(QString::number(++counter)));
+    }
+
+private:
+    int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// Almost the same as in previous example
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);
+
+    CounterLabel counterLabel;
+    layout.addWidget(&counterLabel);
+
+    QPushButton button("Push me once more");
+    layout.addWidget(&button);
+    QObject::connect(&button, &QPushButton::pressed,
+                     &counterLabel, &CounterLabel::increaseCounter);
+
+    return app.exec();
+}
+```
+
+That's it! Of course, Qt framework is much much larger than the part that was covered in this tutorial, so be ready to read and practice.
+
+## Further reading
+
+- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Good luck and have fun!
diff --git a/racket.html.markdown b/racket.html.markdown
index 0fe3f030..c6b1deba 100644
--- a/racket.html.markdown
+++ b/racket.html.markdown
@@ -114,18 +114,42 @@ some-var ; => 5
   "Alice"
   me) ; => "Bob"
 
+;; let* is like let, but allows you to use previous bindings in creating later bindings
+(let* ([x 1]
+       [y (+ x 1)])
+       (* x y))
+
+;; finally, letrec allows you to define recursive and mutually recursive functions
+(letrec ([is-even? (lambda (n)
+                       (or (zero? n)
+                           (is-odd? (sub1 n))))]
+           [is-odd? (lambda (n)
+                      (and (not (zero? n))
+                           (is-even? (sub1 n))))])
+    (is-odd? 11))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; 3. Structs and Collections
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Structs
+; By default, structs are immutable
 (struct dog (name breed age))
 (define my-pet
   (dog "lassie" "collie" 5))
 my-pet ; => #<dog>
+; returns whether the variable was constructed with the dog constructor
 (dog? my-pet) ; => #t
+; accesses the name field of the variable constructed with the dog constructor
 (dog-name my-pet) ; => "lassie"
 
+; You can explicitly declare a struct to be mutable with the #:mutable option
+(struct rgba-color (red green blue alpha) #:mutable)
+(define burgundy
+   (rgba-color 144 0 32 1.0))
+(set-rgba-color-green! burgundy 10)
+(rgba-color-green burgundy) ; => 10
+
 ;;; Pairs (immutable)
 ;; `cons' constructs pairs, `car' and `cdr' extract the first
 ;; and second elements
@@ -140,8 +164,25 @@ my-pet ; => #<dog>
 (cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
 ;; `list' is a convenience variadic constructor for lists
 (list 1 2 3) ; => '(1 2 3)
-;; and a quote can also be used for a literal list value
+;; a quote can also be used for a literal list value
 '(1 2 3) ; => '(1 2 3)
+;; a quasiquote (represented by the backtick character) with commas 
+;; can be used to evaluate functions
+`(1 ,(+ 1 1) 3) ; => '(1 2 3)
+
+;; With lists, car/cdr work slightly differently
+(car '(1 2 3)) ; => 1
+(cdr '(1 2 3)) ; => '(2 3)
+
+;; Racket also has predefined functions on top of car and cdr, to extract parts of a list
+(cadr (list 1 2 3)) ; => 2
+(car (cdr (list 1 2 3))) ; => 2
+
+(cddr (list 1 2 3)) ; => '(3)
+(cdr (cdr (list 1 2 3))) ; => '(3)
+
+(caddr (list 1 2 3)) ; => 3
+(car (cdr (cdr (list 1 2 3)))) ; => 3
 
 ;; Can still use `cons' to add an item to the beginning of a list
 (cons 4 '(1 2 3)) ; => '(4 1 2 3)
diff --git a/red.html.markdown b/red.html.markdown
index 05da3c3f..5f6ffc86 100644
--- a/red.html.markdown
+++ b/red.html.markdown
@@ -23,18 +23,19 @@ from any platform to any other platform. And it will do this all from a binary e
 Ready to learn your first Red?
 
 ```
-All text before the header will be treated as comment, as long as you avoid using the
-word "red" starting with a capital "R" in this pre-header text. This is a temporary
-shortcoming of the used lexer but most of the time you start your script or program
-with the header itself.
-The header of a red script is the capitalized word "red" followed by a
-whitespace character followed by a block of square brackets [].
-The block of brackets can be filled with useful information about this script or
-program: the author's name, the filename, the version, the license, a summary of
-what the program does or any other files it needs.
-The red/System header is just like the red header, only saying "red/System" and
-not "red".
+All text before the header will be treated as comment, as long as you avoid
+using the word "red" starting with a capital "R" in this pre-header text.
+This is a temporary shortcoming of the used lexer but most of the time you
+start your script or program with the header itself.
 
+The header of a red script is the capitalized word "red" followed by a
+whitespace character followed by a block of square brackets []. The block of
+brackets can be filled with useful information about this script or program:
+the author's name, the filename, the version, the license, a summary of what
+the program does or any other files it needs. The red/System header is just
+like the red header, only saying "red/System" and not "red".
+```
+```red
 Red []
 
 ;this is a commented line
@@ -50,9 +51,9 @@ comment {
 ; no need to restrict this to a 'main' function.
 
 ; Valid variable names start with a letter and can contain numbers,
-; variables containing only capital A thru F and numbers and ending with 'h' are
-; forbidden, because that is how hexadecimal numbers are expressed in Red and
-; Red/System.
+; variables containing only capital A thru F and numbers and ending with 'h'
+; are forbidden, because that is how hexadecimal numbers are expressed in Red
+; and Red/System.
 
 ; assign a value to a variable using a colon ":"
 my-name: "Red"
@@ -63,8 +64,8 @@ reason-for-using-the-colon: {Assigning values using the colon makes
 }
 is-this-name-valid?: true
 
-; print output using print, or prin for printing without a newline or linefeed at the
-; end of the printed text.
+; print output using print, or prin for printing without a newline or linefeed
+; at the end of the printed text.
 
 prin " My name is " print my-name
 My name is Red
@@ -72,7 +73,7 @@ My name is Red
 print ["My name is " my-name lf]
 My name is Red
 
-; In case you haven't already noticed: statements do NOT end with a semicolon ;-)
+; If you haven't already noticed: statements do NOT end with a semicolon ;-)
 
 ;
 ; Datatypes
@@ -85,13 +86,13 @@ My name is Red
 ; Some of the available types are integer! string! block!
 
 ; Declaring variables before using them?
-; Red knows by itself what variable is best to use for the data you want to use it
-; for.
+; Red knows by itself what variable is best to use for the data you want to
+; use it for.
 ; A variable declaration is not always necessary.
 ; It is considered good coding practise to declare your variables,
 ; but it is not forced upon you by Red.
-; You can declare a variable and specify its type. a variable's type determines its
-; size in bytes.
+; You can declare a variable and specify its type. a variable's type
+; determines its size in bytes.
 
 ; Variables of integer! type are usually 4 bytes or 32 bits
 my-integer: 0
@@ -111,10 +112,10 @@ i2 - i1 ; result 1
 i2 * i1 ; result 2
 i1 / i2 ; result 0 (0.5, but truncated towards 0)
 
-; Comparison operators are probably familiar, and unlike in other languages you
-; only need a single '=' sign for comparison.
-; There is a boolean like type in Red. It has values true and false, but also the
-; values on/off or yes/no can be used
+; Comparison operators are probably familiar, and unlike in other languages
+; you only need a single '=' sign for comparison.
+; There is a boolean like type in Red. It has values true and false, but also
+; the values on/off or yes/no can be used
 
 3 = 2 ; result false
 3 != 2 ; result true
@@ -127,22 +128,22 @@ i1 / i2 ; result 0 (0.5, but truncated towards 0)
 ; Control Structures
 ;
 ; if
-; Evaluate a block of code if a given condition is true. IF does not return any value,
-; so cannot be used in an expression.
+; Evaluate a block of code if a given condition is true. IF does not return
+; any value, so cannot be used in an expression.
 if a < 0 [print "a is negative"]
 
 ; either
-; Evaluate a block of code if a given condition is true, else evaluate an alternative
-; block of code. If the last expressions in both blocks have the same type, EITHER can
-; be used inside an expression.
-either a < 0 [
+; Evaluate a block of code if a given condition is true, else evaluate an
+; alternative block of code. If the last expressions in both blocks have the
+; same type, EITHER can be used inside an expression.
+either a > 0 [
+   msg: "positive"
+][
    either a = 0 [
        msg: "zero"
    ][
        msg: "negative"
    ]
-][
-   msg: "positive"
 ]
 
 print ["a is " msg lf]
@@ -150,14 +151,14 @@ print ["a is " msg lf]
 ; There is an alternative way to write this
 ; (Which is allowed because all code paths return a value of the same type):
 
-msg: either a < 0 [
+msg: either a > 0 [
+   "positive"
+][
    either a = 0 [
        "zero"
    ][
        "negative"
    ]
- ][
-   "positive"
 ]
 print ["a is " msg lf]
 
@@ -172,8 +173,8 @@ until [
 ]
 ;   will output:
 ooooo
-; Note that the loop will always be evaluated at least once, even if the condition is
-; not met from the beginning.
+; Note that the loop will always be evaluated at least once, even if the
+; condition is not met from the beginning.
 
 ; while
 ; While a given condition is met, evaluate a block of code.
diff --git a/ro-ro/bash-ro.html.markdown b/ro-ro/bash-ro.html.markdown
index debeb67a..32a878b2 100644
--- a/ro-ro/bash-ro.html.markdown
+++ b/ro-ro/bash-ro.html.markdown
@@ -12,166 +12,171 @@ lang: ro-ro
 filename: LearnBash-ro.sh
 ---
 
-Bash este numele shell-ului unix, care a fost de asemenea distribuit drept shell pentru sistemul de operare GNU si ca shell implicit pentru Linux si Mac OS X.
+Bash este numele shell-ului UNIX, care a fost de asemenea distribuit drept shell pentru sistemul de operare GNU și ca shell implicit pentru Linux si Mac OS X.
 Aproape toate exemplele de mai jos pot fi parte dintr-un script sau pot fi executate direct in linia de comanda.
 
-[Citeste mai multe:](http://www.gnu.org/software/bash/manual/bashref.html)
+[Citește mai multe:](http://www.gnu.org/software/bash/manual/bashref.html)
 
 ```bash
 #!/bin/bash
 # Prima linie din script se numeste "shebang" 
-# care spune systemului cum sa execute scriptul
+# care spune sistemului cum să execute scriptul
 # http://en.wikipedia.org/wiki/Shebang_(Unix)
-# Dupa cum te-ai prins deja, comentariile incep cu #. 
+# După cum te-ai prins deja, comentariile încep cu #. 
 # Shebang este de asemenea un comentariu.
 
 # Exemplu simplu de hello world:
 echo Hello world!
 
-# Fiecare comanda incepe pe o linie noua, sau dupa punct si virgula ;
+# Fiecare comandă începe pe o linie nouă, sau după punct și virgula ;
 echo 'Prima linie'; echo 'A doua linie'
 
 # Declararea unei variabile se face astfel:
-VARIABLE="Niste text"
+VARIABLE="Niște text"
 
-# DAR nu asa:
+# DAR nu așa:
 VARIABLE = "Niste text"
-# Bash va crede ca VARIABLE este o comanda care trebuie executata si va
-# returna o eroare pentru ca nu va putea fi gasita.
+# Bash va crede că VARIABLE este o comandă care trebuie executată și va
+# returna o eroare pentru că nu va putea fi găsita.
 
 # Folosind variabila:
 echo $VARIABLE
 echo "$VARIABLE"
 echo '$VARIABLE'
-# Atunci cand folosesti variabila, o atribui, o exporti sau altfel, 
-# numele ei se scrie fara $.
-# Daca vrei sa folosesti valoarea variabilei, atunci trebuie sa folosesti $.
-# Atentie la faptul ca ' (apostrof) nu va inlocui variabla cu valoarea ei.
+# Atunci când folosesti variabila, o atribui, o exporți sau altfel, 
+# numele ei se scrie fără $.
+# Daca vrei sa folosesti valoarea variabilei, atunci trebuie să folosești $.
+# Atentie la faptul că ' (apostrof) nu va inlocui variabla cu valoarea ei.
 
-# Inlocuirea de caractere in variabile
-echo ${VARIABLE/Some/A}
-# Asta va inlocui prima aparitie a "Some" cu "A" in variabila de mai sus.
+# Inlocuirea de caractere în variabile
+echo ${VARIABLE/Niște/Un}
+# Asta va înlocui prima apariție a "Niște" cu "Un" în variabila de mai sus.
 
-# Substring dintr-o variabila
+# Substring dintr-o variabilă
 echo ${VARIABLE:0:7}
 # Asta va returna numai primele 7 caractere din variabila.
 
 # Valoarea implicita a unei variabile:
-echo ${FOO:-"ValoareaImplicitaDacaFOOLipsesteSauEGoala"}
-# Asta functioneaza pentru null (FOO=),
-# sir de caractere gol (FOO=""), zero (FOO=0) returneaza 0
+echo ${FOO:-"ValoareaImplicitaDacaFOOLipseșteSauEGoală"}
+# Asta functionează pentru null (FOO=),
+# sir de caractere gol (FOO=""), zero (FOO=0) returnează 0
 
 # Variabile pre-existente
-echo "Ulima valoare returnata de ultimul program rulat: $?"
-echo "ID-ul procesului (PID) care ruleaza scriptul: $$"
-echo "Numarul de argumente: $#"
+echo "Ulima valoare returnată de ultimul program rulat: $?"
+echo "ID-ul procesului (PID) care rulează scriptul: $$"
+echo "Numărul de argumente: $#"
 echo "Argumentele scriptului: $@"
-echo "Argumentele scriptului separate in variabile: $1 $2..."
+echo "Argumentele scriptului separate în variabile: $1 $2..."
 
-# Citind o valoare din consola
-echo "Care e numele tau?"
-read NAME # Observa faptul ca nu a trebuit sa declaram o variabila noua
+# Citind o valoare din consolă
+echo "Care e numele tău?"
+read NAME # Observă faptul că nu a trebuit să declarăm o variabilă nouă
 echo Salut, $NAME!
 
 # Avem obisnuita instructiune "if"
-# Foloseste "man test" pentru mai multe informatii 
-# despre instructinea conditionala
+# Folosește "man test" pentru mai multe informații 
+# despre instrucținea conditionala
 if [ $NAME -ne $USER ]
 then
-    echo "Numele tau este username-ul tau"
+    echo "Numele tău este username-ul tău"
 else
-    echo "Numele tau nu este username-ul tau"
+    echo "Numele tău nu este username-ul tău"
 fi
 
-# Este de asemenea si executarea conditionala de comenzi
-echo "Intotdeauna executat" || echo "Executat daca prima instructiune esueaza"
-echo "Intotdeauna executat" && echo "Executat daca prima instructiune NU esueaza"
+# Există, de asemenea, și executarea conditională de comenzi
+echo "Întotdeauna executat" || echo "Executat dacă prima instrucțiune eșuează"
+echo "Întotdeauna executat" && echo "Executat dacă prima instrucțiune NU esuează"
 
-# Expresiile apar in urmatorul format
+# Expresiile apar în urmatorul format
 echo $(( 10 + 5 ))
 
-# Spre deosebire de alte limbaje de programare bash este un shell - asa ca 
-# functioneaza in contextul directorului curent. Poti vedea fisiere si directoare
+# Spre deosebire de alte limbaje de programare, bash este un shell - așa că 
+# funcționează in contextul directorului curent. Poți vedea fișiere și directoare
 # din directorul curent folosind comanda "ls":
 ls
 
-# Aceste comenzi au optiuni care la controleaza executia
-ls -l # Listeaza fiecare fisier si director pe o linie separata
+# Aceste comenzi au optiuni care le controlează execuțiă
+ls -l # Listează fiecare fișier și director pe o linie separată
 
 # Rezultatele comenzii anterioare pot fi 
-# trimise urmatoarei comenzi drept argument
-# Comanda grep filtreaza argumentele trimise cu sabloane. 
+# trimise următoarei comenzi drept argument
+# Comanda grep filtrează argumentele trimise cu sabloane. 
 # Astfel putem vedea fiserele .txt din directorul curent.
 ls -l | grep "\.txt"
 
-# De asemenea poti redirectiona o comanda, input si error output
-python2 hello.py < "input.in"
-python2 hello.py > "output.out"
-python2 hello.py 2> "error.err"
-# Output-ul va suprascrie fisierul daca acesta exista.
-# Daca vrei sa fie concatenate poti folosi ">>" 
-
-# Comenzile pot fi inlocuite in interiorul altor comenzi folosind $( ):
-# Urmatoarea comanda afiseaza numarul de fisiere 
-# si directoare din directorul curent
-echo "Sunt $(ls | wc -l) fisiere aici."
-
-# Acelasi lucru se poate obtine folosind apostrf-ul inversat ``,
-# dar nu pot fi folosite unele in interiorul celorlalte asa ca modalitatea 
-# preferata este de a folosi $( )
-echo "Sunt `ls | wc -l` fisiere aici."
-
-# Bash foloseste o instructiune 'case' care functioneaza 
-# in mod similar cu instructiunea switch din Java si C++
+# De asemenea, poți redirecționa date de intrare spre sau erori/date de ieșire
+# dinspre o comandă
+python2 hello.py < "intrare.in"
+python2 hello.py > "ieșire.out"
+python2 hello.py 2> "erori.err"
+# Output-ul va suprascrie fișierul dacă acesta există.
+# Daca vrei să fie concatenate datele poți folosi ">>" în loc de ">"
+
+# Comenzile pot fi înlocuite în interiorul altor comenzi folosind $( ):
+# Urmatoarea comandă afișează numărul de fișiere 
+# și directoare din directorul curent
+echo "Sunt $(ls | wc -l) fișiere aici."
+
+# Același lucru se poate obține folosind apostroful inversat ``,
+# dar nu pot fi folosite limbricate, așa ca modalitatea 
+# preferată este de a folosi $( )
+echo "Sunt `ls | wc -l` fișiere aici."
+
+# Bash folosește o instrucțiune 'case' care funcționeaza 
+# în mod similar cu instructiunea switch din Java si C++
 case "$VARIABLE" in 
     0) echo "Este un zero.";;
     1) echo "Este un unu.";;
     *) echo "Nu este null";;
 esac
 
-# Instructiunea for parcurge toate elementele trimise:
-# Continutul variabilei $VARIABLE este printat de 3 ori
+# Instrucțiunea 'for' parcurge toate elementele trimise:
+# Conținutul variabilei $VARIABLE este printat de 3 ori
 for VARIABLE in {1..3}
 do
     echo "$VARIABLE"
 done
 
-# while loop:
+# Buclă while:
 while [true]
 do
-    echo "in interiorul iteratiei aici..."
+    echo "în interiorul iterației aici..."
     break
 done
 
-# De asemenea poti defini functii
-# Definitie:
+# De asemenea poți defini funcții
+# Definiție:
 function foo ()
 {
-    echo "Argumentele functioneaza ca si argumentele scriptului: $@"
+    echo "Argumentele funcționeaza ca și argumentele scriptului: $@"
     echo "Si: $1 $2..."
-    echo "Asta este o functie"
+    echo "Asta este o funcție"
     return 0
 }
 
-# sau mai simplu
+# sau mai simplu:
 bar ()
 {
-    echo "Alta metoda de a declara o functie"
+    echo "Altă metodă de a declara o funcție"
     return 0
 }
 
-# Invocarea unei functii
+# Invocarea unei funcții:
 foo "Numele meu este: " $NAME
 
-# Sunt o multime de comenzi utile pe care ar trebui sa le inveti:
+# Sunt o multime de comenzi utile pe care ar trebui să le inveți:
 tail -n 10 file.txt
-# printeaza ultimele 10 linii din fisierul file.txt
+# afișează ultimele 10 linii din fișierul file.txt
+
 head -n 10 file.txt
-# printeaza primele 10 linii din fisierul file.txt
+# afișează primele 10 linii din fișierul file.txt
+
 sort file.txt
-# sorteaza liniile din file.txt
+# sortează liniile din file.txt
+
 uniq -d file.txt
-# raporteaza sau omite liniile care se repeta, cu -d le raporteaza
+# raporteaza sau omite liniile care se repetă. Cu -d le raporteaza
+
 cut -d ',' -f 1 file.txt
-# printeaza doar prima coloana inainte de caracterul ","
+# printează doar prima coloană inainte de caracterul ","
 ```
diff --git a/ro-ro/bf-ro.html.markdown b/ro-ro/bf-ro.html.markdown
new file mode 100644
index 00000000..686dd39d
--- /dev/null
+++ b/ro-ro/bf-ro.html.markdown
@@ -0,0 +1,91 @@
+---
+language: bf
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Petru Dimitriu", "http://petru-dimitriu.github.io"]
+filename: bf-ro.html
+lang: ro-ro
+---
+
+Brainfuck (un nume propriu care nu primește majusculă inițială decât la începutul
+propoziției) este un limbaj de programare Turing-comple extrem de minimalist cu
+doar 8 instrucțiuni.
+
+Puteți încerca brainfuck în navigatorul dumneavoastră cu [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Orice caracter in afara de "><+-.,[]" (fara ghilimele) este ignorat.
+
+Brainfuck se reprezinta ca un vector de 30 000 de celule initializate cu zero
+si un pointer de date care trimite spre celula curenta.
+
+Exista opt comenzi:
++ : Incrementeaza valoarea celulei curente cu 1.
+- : Decrementeaza valoarea celulei curente cu 1.
+> : Muta pointerul de date la urmatoarea celula (o celula la dreapta).
+< : Muta pointerul de date la celula precedenta (o celula la stanga).
+. : Afiseaza valoarea caracterului ASCII din celul caurenta (ex. 65 = 'A').
+, : Citeste un singur caracter si plaseaza valoarea lui in celula curenta.
+[ : Daca valoarea in celula curenta este zero, sare la urmatorul caracter ] .
+    Altfel, merge la urmatoarea instructiune.
+] : Daca valoarea in celula curenta este zero, sare la urmatoarea
+	instructiune.
+    Altfel, se intoarce la instructiunea de dupa caracterul [ precedent .
+
+[ and ] formeaza un ciclu. Evident, trebuie ca parantezarea sa fie corecta.
+
+Sa privim cateva programe brainfuck simple.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Acest program afiseaza litera 'A'. Mai intai, incrementeaza celula #1 pana
+la valoarea 6. Celula #1 va fi folosita pentru ciclare. Apoi, intra in ciclu
+([) si muta pointerul la celula #2. Incrementeaza celula #2 de 10 ori,
+muta pointerul la celula #1 si decrementeaza celula #1. Acest ciclu parcurge
+6 iteratii (este nevoie de 6 decrementari pentru ca celula #1 sa ajunga la 0),
+iar dupa aceea se trece la caracterul ] corespunzator si se continua executia.
+
+In acest moment, ne aflam in celula #1, care are valoarea 0, in timp ce celula
+#2 are valoarea 60. Ne mutam pe celula #2, incrementam de 5 ori, pentru a
+obtine valoarea 65, si apoi afisam valoarea celulei #2. 65 este codul ASCII
+pentru 'A', deci se afiseaza 'A' in terminal.
+
+, [ > + < - ] > .
+
+Acest program citeste un caracter de la intrarea utilizator si copiaza caracterul
+in celula #1. Apoi incepem un ciclu. Se muta pointerul in celula #2, se
+incremneteaza valoarea de la celula #2, se muta inapoi la celula #1, se
+decrementeaza valoarea de la celula #1. Aceasta continua pana cand celula #1 este
+0 iar celula #2 retine vechea valoare a celulei #1. Deoarece ne aflam in celula
+#1 la sfarsitul ciclului, ne mutam pe celula #2 si afisam simbolul corespunzator
+in ASCII.
+
+Aveti in vedere ca spatiile sunt doar pentru usurinta citirii. La fel de bine
+programul ar fi putut fi scris astfel:
+
+,[>+<-]>.
+
+Incercati sa va dati seama ce face acest program:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Acest program citeste doua numere ca intrare si le inmulteste.
+
+Pe scurt, programul citeste doua date de intrare, apoi incepe ciclul
+mare, a carui conditie se afla in celula #1; apoi se muta la celula #2
+si incepe un ciclu imbricat a carui conditie de reluare se afla in
+celula #2, si care incrementeaza celula #3. Totusi aici intervine o
+problema: La sfarsitul ciclului imbricat, celula #2 este zero. In
+acest caz, celula ciclul imbricat nu va mai functiona data viitoare.
+Pentru a rezolva aceasta problema, incrementam celula si #4, si
+recopiem celula #4 in celula #2. In final, celula #3 este rezultatul.
+
+```
+
+Așadar acesta este limbajul brainfuck. Nu e atât de greu, nu? Pentru
+amuzament, puteți să scrieți propriile dumneavoastră limbaje, sau puteți
+scrie un interpretor pentru brainfuck într-un alt limbaj. Interpretorul
+este destul de ușor de implementat, dar dacă sunteți masochist, încercați
+să implementați un interpretor de brainfuck… în brainfuck.
diff --git a/ro-ro/coffeescript-ro.html.markdown b/ro-ro/coffeescript-ro.html.markdown
new file mode 100644
index 00000000..695274d2
--- /dev/null
+++ b/ro-ro/coffeescript-ro.html.markdown
@@ -0,0 +1,102 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+    - ["Bogdan Lazar", "http://twitter.com/tricinel"]
+filename: coffeescript-ro.coffee
+lang: ro-ro
+---
+
+CoffeeScript este un limbaj de programare care este compilat in Javascript. Nu exista un interpretator la runtime-ul aplicatiei. Fiind unul din successorii Javascript, CoffeeScript incearca sa compileze Javascript usor de citit si performant.
+
+Mai cititi si [website-ul CoffeeScript](http://coffeescript.org/), care contine un tutorial complet Coffeescript.
+
+```coffeescript
+# CoffeeScript este un limbaj de hipster.
+# Se foloseste de trendurile multor limbaje moderne de programare.
+# Comentarii sunt ca in Ruby sau Python.
+
+###
+Comentariile in bloc sunt create cu `###`, iar acestea sunt transformate in `/*` si `*/` pentru Javascript
+
+Ar trebuie sa intelegeti Javascript pentru a continua cu acest ghid.
+###
+
+# Atribuirea valorilor:
+numar   = 42 #=> var numar = 42;
+opus = true #=> var opus = true;
+
+# Conditii:
+numar = -42 if opus #=> if(opus) { numar = -42; }
+
+# Functii:
+laPatrat = (x) -> x * x #=> var laPatrat = function(x) { return x * x; }
+
+plin = (recipient, lichid = "cafea") ->
+  "Umplem #{recipient} cu #{cafea}..."
+#=>var plin;
+#
+#plin = function(recipient, lichid) {
+#  if (lichid == null) {
+#    lichid = "cafea";
+#  }
+#  return "Umplem " + recipient + " cu " + lichid + "...";
+#};
+
+# Liste:
+lista = [1..5] #=> var lista = [1, 2, 3, 4, 5];
+
+# Obiecte:
+matematica =
+  radacina:   Math.sqrt
+  laPatrat: laPatrat
+  cub:   (x) -> x * square x
+#=> var matematica = {
+#    "radacina": Math.sqrt,
+#    "laPatrat": laPatrat,
+#    "cub": function(x) { return x * square(x); }
+#   };
+
+# Splats:
+cursa = (castigator, alergatori...) ->
+  print castigator, alergatori
+#=>cursa = function() {
+#    var alergatori, castigator;
+#    castigator = arguments[0], alergatori = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#    return print(castigator, alergatori);
+#  };
+
+# Verificarea existentei:
+alert "Stiam eu!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Stiam eu!"); }
+
+# Operatiuni cu matrice:
+cuburi = (math.cube num for num in list)
+#=>cuburi = (function() {
+#	  var _i, _len, _results;
+#	  _results = [];
+# 	for (_i = 0, _len = list.length; _i < _len; _i++) {
+#		  num = list[_i];
+#		  _results.push(math.cube(num));
+#	  }
+#	  return _results;
+# })();
+
+alimente = ['broccoli', 'spanac', 'ciocolata']
+mananca aliment for aliment in alimente when aliment isnt 'ciocolata'
+#=>alimente = ['broccoli', 'spanac', 'ciocolata'];
+#
+#for (_k = 0, _len2 = alimente.length; _k < _len2; _k++) {
+#  aliment = alimente[_k];
+#  if (aliment !== 'ciocolata') {
+#    eat(aliment);
+#  }
+#}
+```
+
+## Resurse aditionale
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
diff --git a/ro-ro/haskell-ro.html.markdown b/ro-ro/haskell-ro.html.markdown
new file mode 100644
index 00000000..b0cc4099
--- /dev/null
+++ b/ro-ro/haskell-ro.html.markdown
@@ -0,0 +1,455 @@
+---
+language: Haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+translators:
+    - ["Petru Dimitriu", "http://petru-dimitriu.github.io"]
+lang: ro-ro
+filename: haskell-ro.html
+---
+
+Haskell este un limbaj de programare practic, pur funcțional.
+
+```haskell
+-- Comentariile pe o singura linie incep cu 2 cratime.
+{- Comentariile multilinie
+  se scriu astfel.
+-}
+
+----------------------------------------------------
+-- 1. Tipuri de date primitive si operatori
+----------------------------------------------------
+
+-- Exista numere
+3 -- 3
+
+-- Matematica functioneaza ca de obicei
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- Impartirea este cu virgula
+35 / 4 -- 8.75
+
+-- Impartirea cu rest
+35 `div` 4 -- 8
+
+-- Valorile booleene sunt primitive
+True
+False
+
+-- Operatii logice
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- In exemplele de mai sus, `not` este o functie ce primeste o valoare.
+-- In Haskell nu se pun paranteze pentru apelurile de functie. Toate
+-- argumentele sunt insirate dupa numele functiei. Sablonul general este:
+-- func arg1 arg2 arg3
+-- Vedeti sectiunea despre functii pentru a afla cum sa scrieti propria functie.
+
+-- Caractere si siruri de caractere
+"Acesta este un sir de caractere"
+'a' -- un caracter
+'Nu se pot folosi apostroafe pentru siruri.' -- eroare!
+
+-- Sirurile pot fi concatenate
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Un string e de fapt o lista de caractere
+['H', 'e', 'l', 'l', 'o'] -- "Hello"
+"Acesta este un string" !! 0 -- 'A'
+
+
+----------------------------------------------------
+-- 2. Liste si tupli
+----------------------------------------------------
+
+-- Fiecare element dintr-o lista trebuie sa aiba acelasi tip.
+-- Urmatoarele liste sunt identice.
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Intervalele sunt versatile.
+['A'..'F'] -- "ABCDEF"
+
+-- Se poate specifica un pas pentru intervale.
+[0,2..10] -- [0, 2, 4, 6, 8, 10]
+[5..1] -- Aceasta nu functioneaza deoarece pasul implicit este incrementarea.
+[5,4..1] -- [5, 4, 3, 2, 1]
+
+-- indexarea intr-o lista este de la zero
+[1..10] !! 3 -- se obtine 4
+
+-- Se pot crea liste infinite
+[1..] -- lista tuturor numerelor naturale
+
+-- Listele infinite functioneaza pentru ca Haskell foloseste "evaluare lenesa"
+-- adica evalueaza lucrurile doar cand este nevoie de ele. Deci se poate
+-- cere al 1000-lea element din lista infinita a numerelor naturale astfel:
+
+[1..] !! 999 -- rezulta 1000
+
+-- Haskell a evaluat elementele 1 - 1000 din lista... dar restul elementelor
+-- acestei liste "infinite" nu exista inca! Haskell nu le va evalua pana
+-- nu va fi nevoie de ele.
+
+-- concatenarea a doua liste
+[1..5] ++ [6..10]
+
+-- alipirea la capul listei
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- operatii cu liste
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- intelegerea listelor
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- folosind o conditie
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- Fiecare element dintr-un tuplu poate fi de un tip diferit
+-- dar un tuplu are lungime fixa
+-- Un tuplu:
+("haskell", 1)
+
+-- accesarea elementelor unui tuplu pereche
+fst ("haskell", 1) -- "haskell" (first)
+snd ("haskell", 1) -- 1 (second)
+
+----------------------------------------------------
+-- 3. Functii
+----------------------------------------------------
+-- O functie simpla ce sumeaza doua variabile
+add a b = a + b
+
+-- Aveti in vedere ca daca folositi ghci (interpretorul Haskell)
+-- trebuie sa scrieti in fata si `let`, adica
+-- let add a b = a + b
+
+-- Apelarea functiei
+add 1 2 -- rezulta 3
+
+-- Numele functiei se poate pune si intre argumente
+-- folosind apostrof intors:
+1 `add` 2 -- 3
+
+-- Se pot defini functii fara litere in denumire! Astfel se pot
+-- defini noi operatori! De exemplu, iata un operator care realizeaza
+-- impartirea intreaga
+(//) a b = a `div` b
+35 // 4 -- rezulta 8
+
+-- Guards: o metoda usoara de a crea ramuri de executie
+fib x
+  | x < 2 = 1
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Potrivirea sirurilor se face similar. Aici am definit 3 definitii
+-- pentru fib. Haskell o va alege automat pe prima care se potriveste
+-- cu sablonul valorii.
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Potrivirea in tupli:
+foo (x, y) = (x + 1, y + 2)
+
+-- Potrivirea in liste. Aici `x` este primul element al listei,
+-- iar `xs` este restul litei. Putem scrie propria functie
+-- de mapare
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Functiile anonime sunt create folosind un backslash urmat
+-- de toate argumentele.
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- utilizarea fold (denumit `inject` in alte limbaje) cu o functie
+-- anonima. foldl1 inseamna pliere la stanga, folosind prima valoare
+-- din lista drept valoarea initiala pentru acumulator
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Mai multe functii
+----------------------------------------------------
+
+-- aplicare partiala; daca nu se introduc toate argumentele unei functii,
+-- este "aplicata partial", adica returneaza o noua functie ce primeste
+-- restul argumentelor, avand deja setate argumentele introduse
+
+add a b = a + b
+foo = add 10 -- foo este o functie ce primeste un numar si ii aduna 10
+foo 5 -- 15
+
+-- alta maniera de a scrie acelasi lucru
+foo = (10+)
+foo 5 -- 15
+
+-- compunerea functiilor
+-- operatorul `.` inlantuieste functiile.
+-- De exeplu, aici foo este o functie care aduna 10 unui numar, il inmul
+-- teste cu 4 si returneaza rezultatul calcului
+foo = (4*) . (10+)
+
+-- 4*(10 + 5) = 60
+foo 5 -- 60
+
+-- alterarea precedentei
+-- Haskell detine un operator numit `$`. Acest operator aplica o functie
+-- unui parametru dat. Fata de aplicarea standard a functiilor, care
+-- foloseste prioritatea maxim posibila 10 si este asociativa la stanga,
+-- operatorul `$` are prioritatea 0 si este asociativ la dreapta.
+-- Aceasta inseamna ca expresia de la dreapta este aplicata ca parametru
+-- functiei din stanga
+
+-- inainte
+even (fib 7) -- false
+
+-- echivalent
+even $ fib 7 -- false
+
+-- compunerea functiilor
+even . fib $ 7 -- false
+
+
+----------------------------------------------------
+-- 5. Type signatures
+----------------------------------------------------
+
+-- Haskell are un sistem de tipuri de date foarte puternic; fiecare expresie
+-- valida are un tip.
+
+-- Cateva tipuri de baza:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Functiile au tipuri de asemenea.
+-- `not` primeste un boolean si returneaza un boolean.
+-- not :: Bool -> Bool
+
+-- Iata o functie ce primeste doi intregi
+-- add :: Integer -> Integer -> Integer
+
+-- Cand se defineste o valoare, este bine sa se precizeze tipul ei deasupra.
+double :: Integer -> Integer
+double x = x * 2
+
+---------------------------------------------------------
+-- 6. Controlul executiei si instructiunile conditionale
+---------------------------------------------------------
+
+-- expresia conditionala if
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- cand expresiile sunt pe mai multe linii, este importanta indentarea
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- expresiile de tip case; iata cum se verifica argumentele programului
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+
+-- Haskell nu foloseste cicluri, ci recursie
+-- map aplica o functie fiecarui element dintr-o lista
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- se poate face o functie for folosind map
+for array func = map func array
+
+-- si apoi se poate folosi astfel:
+for [0..5] $ \i -> show i
+
+-- se poate scrie si asa:
+for [0..5] show
+
+-- Se poate folosi foldl sau foldr pentru a reduce o lista
+-- foldl <fn> <valoare initiala> <lista>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- Acelasi lucru ca a scrie
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl functioneaza spre stanga, foldr spre dreapta
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- Acealsi lucru ca:
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
+
+----------------------------------------------------
+-- 7. Tipuri de date
+----------------------------------------------------
+
+-- Iata cum se creeaza un tip de date in Haskell
+
+data Culoare = Rosu | Albastru | Verde
+
+-- Acum poate fi folosit in functii
+
+
+spune :: Culoare -> String
+spune Rosu = "Esti Rosu!"
+spune Albastru = "Esti Albastru!"
+spune Verde =  "Esti Verde!"
+
+-- Tipul de date poate avea si parametri.
+
+data Maybe a = Nothing | Just a
+
+-- Toate acestea sunt de tipul Maybe
+Just "hello"    -- de tipul `Maybe String`
+Just 1          -- de tipul `Maybe Int`
+Nothing         -- de tipul `Maybe a` pentru oricare `a`
+
+----------------------------------------------------
+-- 8. IO in Haskell
+----------------------------------------------------
+
+-- Desi IO nu se poate explica intru totul fara a explica monadele,
+-- nu este atat de greu de explicat pentru o idee de baza.
+
+-- Cand se executa un program Haskell, se apeleaza `main`.
+-- Trebuie sa returneze o valoare de tio `IO a` pentru un anumit tip `a`.
+-- De exemplu:
+
+main :: IO ()
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
+-- putStrLn are tipul String -> IO ()
+
+-- Cel mai usor se lucreaza cu IO daca se implementeaza programul
+-- ca o functie de la String la String. Functia
+--    interact :: (String -> String) -> IO ()
+-- citeste un text, executa o functie asupra ei, apoi afiseaza
+-- iesirea.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- O valoare de tipul `IO ()` poate fi privita ca reprezentand
+-- o secventa de actiuni pe care care computerul sa le execute,
+-- similar cu felul in care un program este scris intr-un limbaj
+-- imperativ. Putem folosi notatia `do` pentru a inlantui actiunile.
+-- De exemplu:
+
+sayHello :: IO ()
+sayHello = do
+   putStrLn "What is your name?"
+   name <- getLine -- citeste o linie
+   putStrLn $ "Hello, " ++ name
+
+-- Exercise: Scrieti propria functie `interact` care citeste
+--           o singura linie de la intrare.
+
+
+-- Codul din `sayHello` nu va fi niciodata executat. Singura actiunile
+-- care este executata este valoarea lui `main`.
+-- Pentru a rula `sayHello.`, eliminati definitia de mai sus a `main`.
+-- si inlocuiti-o cu
+--   main = sayHello
+
+-- Sa intelegem mai bine cum functioneaza functia `getLine`.
+-- Tipul ei este:
+--    getLine :: IO String
+-- Pueti privi o valoare de tipul `IO a` ca fiind un program
+-- de computer care va genera o valoare de tipul `a` cand
+-- este executata (pe langa orice altceva face). O putem denumi
+-- si refolosi utilizand `<-`. De asemenea putem face propriile
+-- actiuni te tipul `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "Aceasta e o linie."
+   input1 <- getLine
+   input2 <- getLine
+   --Tipul instructiunii `do` este cel de pe ultima sa linie.
+   -- `return` nu este un cuvant cheie, ci o functie
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- Putem folosi aceasta exact cum am folosit `getLine`:
+
+main'' = do
+    putStrLn "I will echo two lines!"
+    result <- action
+    putStrLn result
+    putStrLn "This was all, folks!"
+
+-- Tipul `IO` este un exemplu de "monada". Felul in care Haskell foloseste
+-- o monada pentru a realiza opeartii de intrare si iesire il face un limbaj
+-- pur functional. Orice functie care interactioneaza cu exteriorul (adica
+-- realieaza IO) este marcata ca `IO` in semnatura ei. Aceasta ne permite
+-- sa spunem ce functii sunt "pure", adica nu interactioneaza cu exteriorul.
+
+-- Aceasta este o facilitate foarte puternica, deoarece este usor sa
+-- se ruleze functii pure concurent; asadar, concurenta in Haskell se face usor
+
+----------------------------------------------------
+-- 9. REPL in Haskell
+----------------------------------------------------
+
+-- Se porneste introducand `ghci`.
+-- Dupa aceasta, se poate introduce cod Haskell.
+-- Toate valorile noi trebuie precedate de `let`.
+
+let foo = 5
+
+-- Puteti vedea tipul oricarei valori sau expresii cu `:t`.
+
+> :t foo
+foo :: Integer
+
+-- Operatorii, precum `+`, `:` si `$` sunt functii.
+-- Tipul lor poate fi observat punand operatorii intre paranteze.
+
+> :t (:)
+(:) :: a -> [a] -> [a]
+
+-- Se pot obtine informatii despre fiecare nume folosind `:i`
+
+> :i (+)
+class Num a where
+  (+) :: a -> a -> a
+  ...
+    -- Defined in ‘GHC.Num’
+infixl 6 +
+
+--De asemenea se poate executa orice actiune de tipul `IO ()`
+
+> sayHello
+What is your name?
+Friend!
+Hello, Friend!
+
+```
+Mai sunt multe de spus despre Haskell, printre care typclasses și monade.
+Acestea sunt marile idei care fac programarea în Haskell atât de interesantă.
+Vă las un exemplu final în Haskell: o variantă de implementare a sortării rapide
+(quicksort) în Haskell:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Există două maniere populare de a instala Haskell: prin [instalarea bazată pe Cabal](http://www.haskell.org/platform/), și prin mai noul [proces bazat pe Stack](https://www.stackage.org/install).
+
+Se poate găsi o introducere în Haskell mult mai blândă la adresele
+[Learn you a Haskell](http://learnyouahaskell.com/) sau
+[Real World Haskell](http://book.realworldhaskell.org/).
diff --git a/ro-ro/json-ro.html.markdown b/ro-ro/json-ro.html.markdown
new file mode 100644
index 00000000..e897059c
--- /dev/null
+++ b/ro-ro/json-ro.html.markdown
@@ -0,0 +1,61 @@
+---
+language: json
+filename: learnjson-ro.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+    - ["Serban Constantin", "https://github.com/fuzzmz"]
+lang: ro-ro
+---
+
+Deoarece JSON este un fromat foarte simplu de schimb de date acesta va fi
+probabil cel mai simplu Invata X in Y minute.
+
+JSON in forma cea mai pura nu contine comentarii insa majoritatea parserelor
+vor accepta comentarii in stil C (`//`, `/* */`). Pentru acest caz insa totul
+va fi JSON 100% valid. Din fericire codul vorbeste de la sine.
+
+```json
+{
+  "cheie": "valoare",
+  
+  "chei": "trebuie mereu inconjurate de ghilimele",
+  "numere": 0,
+  "stringuri": "Bunã. Tot setul unicode este permis, chiar si \"escaping\".",
+  "are booleane?": true,
+  "nimic": null,
+
+  "numere mari": 1.2e+100,
+
+  "obiecte": {
+    "comentariu": "Majoritatea structurii va veni din obiecte.",
+
+    "vectori": [0, 1, 2, 3, "Vectorii pot avea orice in ei.", 5],
+
+    "alt obiect": {
+      "comentariu": "Lucrurile pot fi subordonate. Foarte util."
+    }
+  },
+
+  "glumite": [
+    {
+      "surse de potasiu": ["banane"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "stil alternativ": {
+    "comentariu": "ia uite la asta!"
+  , "pozitia virgulei": "nu conteaza - daca e inaintea valorii atunci e valida"
+  , "alt comentariu": "ce dragut"
+  },
+
+  "a fost scurt": "Am terminat. Acum stii tot ce are JSON de oferit."
+}
+```
diff --git a/ro-ro/latex-ro.html.markdown b/ro-ro/latex-ro.html.markdown
new file mode 100644
index 00000000..f661db0a
--- /dev/null
+++ b/ro-ro/latex-ro.html.markdown
@@ -0,0 +1,256 @@
+---
+language: latex
+contributors:
+    - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+    - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"]
+translators:
+    - ["Petru Dimitriu", "http://petru-dimitriu.github.io"]
+filename: learn-latex-ro.tex
+lang: ro-ro
+---
+
+```tex
+% Toate comentariile încep cu %
+% Nu există comentarii multi-linie
+
+% LaTeX NU este un program software de procesare text de tipul
+% "What You See Is What You Get"
+% precum MS Word, sau OpenOffice Writer
+
+% Toate comenzile LaTeX încep cu backslash. (\)
+
+% Documentele LaTeX încep cu o linie care definește tipul documentului
+% care urmează a fi compilat. Alte tipuri de documente sunt book (carte),
+% presentation (prezentare), etc. Opțiunile pentru document apar
+% între paranteze drepte. În acest caz, specificăm că vrem să folosim
+% un corp de text (font) de 12 puncte.
+\documentclass[12pt]{article}
+
+% Mai apoi definim pachetele pe care documentul le folosește.
+% Dacă vreți să includeți grafice, text colorat sau
+% cod sursă din alt fișier în documentul dumneavoastră,
+% trebuie să îmbogățiți capabilitățile LaTeX. Aceasta se realizează
+% adăugând pachete. Voi include pachetele float și caption pentru
+% imagini.
+\usepackage{caption}
+\usepackage{float}
+% această comandă este necesară atunci când vreți să scrieți codul
+% sursă folosind diacrtice! (cum e cazul aici, unde translatorul
+% a vrut să scrie neapărat folosind diacriticele românești)
+\usepackage[utf8]{inputenc}
+
+% De asemenea, putem defini și alte proprietăți pentru documente.
+\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu \\ Traducere de Petru Dimitriu}
+\date{\today}
+\title{Învățați LaTeX în Y minute!}
+
+% Suntem gata să începem documentul.
+% Tot ce se află înaintea acestei linii se numește "Preambul"
+\begin{document}
+% dacă am setat autorul, data și titlul, putem cere LaTeX să
+% creeze o pagină de titlu
+\maketitle
+
+% Cele mai multe documente științifice au un rezumat; puteți folosi comenzile
+% predefinite pentru acesta. Acesta ar trebui să apară, așa cum ar fi logic,
+% după titlu, dar înainte de secțiunile principale ale corpului.
+% Această comandă este disponibilă în clasele de document article și report.
+\begin{abstract}
+ Documentațue LaTeX scrisă în LaTeX. O idee nicidecum nouă și nicidecum a mea!
+\end{abstract}
+
+% Comenzile pentru secțiuni sunt intuitive.
+% Toate titlurile secțiunilor sunt adăugate automat la tabla de materii (cuprins).
+\section{Introducere}
+Salut, mă numesc Petru. Astăzi vom învăța împreună LaTeX!
+
+\section{Altă secțiune}
+Acesta este textul pentru altă secțiune. Vom face o subsecțiune.
+
+\subsection{Aceasta este o subsecțiune}
+Și încă una.
+
+\subsubsection{Pitagora}
+Mult mai bine.
+\label{subsec:pitagora}
+
+% Folosind asteriscul putem suprima numărătoarea automată a LaTeX.
+% Aceasta funcționează și pentru alte comenzi LaTeX.
+\section*{Secțiune fără numerotare}
+Totuși nu toate secțiunile trebuie să fie nenumerotate!
+
+\section{Note despre text}
+În general LaTeX se pricepe să pună textul unde trebuie. Dacă o linie are \\
+nevoie \\ să \\ fie \\ întreruptă, puteți adăuga două caractere backslash
+la codul sursă.
+
+\section{Liste}
+Listele sunt printre cel mai simplu de făcut lucruri în LaTeX! Mâine merg la
+cumpărături așa că fac o listă:
+\begin{enumerate} % Aceasta creează un mediu "enumerate"
+  % \item spune mediului "enumerate" să incrementeze
+  \item salată
+  \item 27 pepeni
+  \item un singur iepuroi
+  % putem suprascrie numărul elementului folosind []
+  \item[câte?] conserve de ton
+
+  Nu este un element din listă, dar încă face parte din "enumerate".
+
+\end{enumerate} % Toate mediile trebuie să aibă o instrucțiune de încheiere.
+
+\section{Matematică}
+
+Una dintre principalele întrebuințări ale LaTeX este realizarea
+articolelor academice sau a fișelor tehnice, de obicei aflate în
+universul matematicii și științelor exacte. Astfel, trebuie să putem
+adăuga simboluri speciale în documentul nostru! \\
+
+Matematica are multe simboluri, mult mai multe decât se găsesc
+pe o tastatură - printre ele, simboluri pentru mulțimi și relații,
+săgeți, operatori și litere grecești.\\
+
+Mulțimile și relațiile sunt esențiale în lucrările științifce matematice.
+Iată cum se scrie: toți y aparținând lui X.\\
+$\forall$ x $\in$ X. \\
+
+% Observați cum am avut nevoie să pun semnul $ înainte și după simboluri.
+% Aceasta pentru că atunci când scriem, suntem în modul text (text-mode).
+% Totuși simbolurile matematice există numai în modul matematic (math-mode).
+% Când ne aflăm în text-mode, putem scrie texte în math-mode punând $ înainte
+% și după simboluri. La fel și viceversa. Și variabilele pot fi redate
+% în math-mode. Putem intra în math-mode și scriind \[\].
+
+\[a^2 + b^2 = c^2 \]
+
+Îmi place litera $\xi$. De asemenea îmi plac $\beta$, $\gamma$ și
+$\sigma$. Nu există nicio literă grecească necunoscută pentru LaTeX!
+
+Operatorii sunt esențiali într-un document matematic!
+funcțiile trigonometrice ($\sin$, $\cos$, $\tan$),
+logaritmii și exponențialele ($\log$, $\exp$),
+limitele ($\lim$), etc.
+au comenzi definite în LaTeX pentru fiecare.
+Să vedem cum scriem o ecuație: \\
+
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
+
+Fracțiile (numărător - numitor) pot fi scrise astfel:
+% 10 / 7
+$^{10}/_{7}$ \\
+
+% Fracții relativ complexe pot fi scrie ca
+% \frac{numărător}{numitor}
+$\frac{n!}{k!(n - k)!}$ \\
+
+Putem insera ecuații și într-un "mediu pentru ecuații".
+
+% Afișează text matematic într-un mediu pentru ecuații.
+\begin{equation} % intră în math-mode
+    c^2 = a^2 + b^2.
+    \label{eq:pitagora} % pentru referențiere
+\end{equation}
+% toate instrucțiunile cu \begin trebuie să fie cuplate cu o instrucțiune cu \end
+
+Putem referenția noua noastră ecuație!
+~\ref{eq:pitagora} este cunoscută și ca Teorema lui Pitagora, despre care vorbim și la Sec.~\ref{subsec:pitagora}. Multe lucruri prot fi etichetate:
+figuri, ecuații, secțiuni, etc.
+
+Sumele discrete și integralele se scriu cu comenzile sum și int.
+
+% Unele compilatoare LaTeX nu acceptă să existe linii goale
+% într-un mediu pentru ecuații.
+\begin{equation}
+  \sum_{i=0}^{5} f_{i}
+\end{equation}
+\begin{equation}
+  \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
+\end{equation}
+
+\section{Figuri}
+
+Să inserăm o figură. Așezarea figurilor poate fi ușor dificilă.
+Eu trebuie să mă uit peste opțiunile de așezare de fiecare dată.
+
+\begin{figure}[H] % H denumește opțiunle de așezare
+    \centering % centrează figura pe pagină
+    % Inserează o figură scalată la 0.8 din lățimea paginii.
+    %\includegraphics[width=0.8\linewidth]{right-triangle.png}
+    % Comentat pentru a nu împiedica fișierul să compileze.
+    \caption{Triunghi dreptunghic cu laturile $a$, $b$, $c$}
+    \label{fig:right-triangle}
+\end{figure}
+
+\subsection{Tabel}
+Putem insera tabele la fel cum inserăm figuri.
+
+\begin{table}[H]
+  \caption{Descriere pentru tabel}
+  % argumentele {} controlează cum vor fi afișate coloanele
+  \begin{tabular}{c|cc}
+    Număr &  Nume & Prenume \\ % Numele coloanelor sunt separate prin $
+    \hline % a linie orizonală
+    1 & Popescu & Ion \\
+    2 & Sima & Felix
+  \end{tabular}
+\end{table}
+
+% \section{Hyperlinkuri} % În curând
+
+\section{Cum facem ca LaTeX să nu compileze ceva (de exemplu cod sursă)}
+Să zicem că vrem să includem niște cod în documentul nostru LaTeX.
+Vom avea nevoie ca LaTeX să nu încerce să interpreteze acel cod,
+ci doar să îl redea în document. Vom face asta cu un mediu verbatim.
+
+% Există și alte pachete (i.e. minty, lstlisting, etc.)
+% dar verbatim este pachetul cel mai simplu.
+\begin{verbatim}
+  print("Salut lume!")
+  a%b; % hei! putem folosi % în verbatim
+  random = 4;
+\end{verbatim}
+
+\section{Compilarea}
+Acum vă întrebați cum se compilează acest document minunat și să vă
+minunați de rezultat, un PDF LaTeX. (da, documentul acesta chiar
+compilează). \\
+Realizarea documentului cu LaTeX va parcurge următorii pași:
+  \begin{enumerate}
+    \item Se scrie documentul în text simplu. (codul sursă)
+    \item Se compilează documentul pentru a produce un PDF.
+     Compilarea arată cam așa în Linux:\\
+     \begin{verbatim}
+        $pdflatex learn-latex.tex learn-latex.pdf
+     \end{verbatim}
+  \end{enumerate}
+
+Anumite editoare pentru LaTeX combină pașii 1 și 2 în același produs software.
+Așadar, dacă vreți să vedeți realizați pasul 1 dar nu și pasul 2, el se poate
+realiza "în spate".
+
+Scrieți toate informațiile de formatare în pasul 1. Compilarea din pasul 2
+se ocupă de producerea documentului în formatul definit în pasul 1.
+
+\section{Final}
+
+Asta e tot pentru moment!
+
+% De multe ori veți vrea să aveți o secțiune cu bibliografie în document.
+% Cea mai ușoară modalitate este folosind mediul thebibliography.
+\begin{thebibliography}{1}
+  % Similar celorlalte liste, comanda \bibitem e folosită pentru a înșirui
+  % elemente; fiecare element poate fi citat în interiorul textului
+  \bibitem{latexwiki} Uimitoarea carte wiki LaTeX: {\em https://en.wikibooks.org/wiki/LaTeX}
+  \bibitem{latextutorial} Un tutorial propriu-zis: {\em http://www.latex-tutorial.com}
+\end{thebibliography}
+
+% încheie documentul
+\end{document}
+```
+
+## Mai multe despre LaTeX
+
+* Uimitoarea carte wiki LaTeX: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX)
+* Un tutorial propriu-zis: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown
index 125ba2f4..c96e30dc 100644
--- a/ro-ro/python-ro.html.markdown
+++ b/ro-ro/python-ro.html.markdown
@@ -8,14 +8,16 @@ filename: learnpython-ro.py
 lang: ro-ro
 ---
 
-Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a devenit astăzi unul din
-cele mai populare limbaje de programare. M-am indrăgostit de Python pentru claritatea sa sintactică.
-Python este aproape pseudocod executabil.
+Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a
+devenit astăzi unul din cele mai populare limbaje de programare.
+M-am indrăgostit de Python pentru claritatea sa sintactică. Python este aproape
+pseudocod executabil.
 
-Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule) sau ociule [at] [google's email service]
+Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule)
+sau ociule [at] [google's email service]
 
-Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O versiune Python 3 va apărea
-în curând, în limba engleză mai întâi.
+Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x.
+O versiune Python 3 va apărea în curând, în limba engleză mai întâi.
 
 ```python
 # Comentariile pe o singură linie încep cu un caracter diez.
@@ -36,7 +38,8 @@ Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O
 10 * 2 #=> 20
 35 / 5 #=> 7
 
-# Împărţirea este un pic surprinzătoare. Este de fapt împărţire pe numere întregi şi rotunjeşte
+# Împărţirea este un pic surprinzătoare. Este de fapt împărţire pe numere
+# întregi şi rotunjeşte
 # automat spre valoarea mai mică
 5 / 2 #=> 2
 
diff --git a/ro-ro/xml-ro.html.markdown b/ro-ro/xml-ro.html.markdown
new file mode 100644
index 00000000..269010c2
--- /dev/null
+++ b/ro-ro/xml-ro.html.markdown
@@ -0,0 +1,133 @@
+---
+language: xml
+filename: learnxml-ro.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+    - ["Serban Constantin", "https://github.com/fuzzmz"]
+lang: ro-ro
+---
+
+XML este un limbaj de markup ce are ca scop stocarea si transportul de date.
+
+Spre deosebire de HTML, XML nu specifica cum sa fie afisata sau formatata
+informatia, ci doar o transporta.
+
+* Sintaxa XML
+
+```xml
+<!-- Comentariile in XML arata asa -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<librarie>
+  <carte categorie="GATIT">
+    <titlu limba="ro">Mancaruri italiene</titlu>
+    <autor>Giada De Laurentiis</autor>
+    <an>2005</an>
+    <pret>30.00</pret>
+  </carte>
+  <carte categorie="COPII">
+    <titlu limba="ro">Harry Potter</titlu>
+    <autor>J K. Rowling</autor>
+    <an>2005</an>
+    <pret>29.99</pret>
+  </carte>
+  <carte categorie="WEB">
+    <titlu limba="ro">Invata XML</titlu>
+    <autor>Erik T. Ray</autor>
+    <an>2003</an>
+    <pret>39.95</pret>
+  </carte>
+</librarie>
+
+<!-- Deasupra este un fisier XML obisnuit.
+  Incepe cu o declaratie ce adauga niste metadata (optional).
+  
+  XML foloseste o structura arborescenta. Deasupra, nodul de baza este
+  'librarie', care are trei noduri copil, toate 'carti'. Acele noduri au la
+  randul lor noduri copii si asa mai departe...
+
+  Nodurile sunt create folosind taguri deschise/inchise, iar copii sunt doar
+  noduri intre tagurile de deschis si inchis.-->  
+
+
+<!-- XML transporta doua tipuri de date:
+  1 - Atribute -> Metadata despre un nod.
+      In general, parserul XML foloseste aceasta informatie sa stocheze
+      proprietatile datelor.
+      Este caracterizat de aparitia in paranteze in cadrul tagului deschis
+  2 - Elemente -> Date pure.
+      Asta este ceea ce parserul va extrage din documentul XML.
+      Elementele apar intre tagurile deschis si inchis, fara paranteze. -->
+      
+  
+<!-- Dedesubt, un element cu doua atribute -->
+<file type="gif" id="4293">computer.gif</file>
+
+
+```
+
+* Document bine formatat x Validare
+
+Un document XML este bine formatat daca este corect sintactic.
+Cu toate astea este posibil sa injectam mai multe constrangeri in document
+folosind definitii precum DTD si XML Schema.
+
+Un document XML ce foloseste o definitie de document este numit valid in
+contextul documentului. 
+
+Cu acest tool poti verifica datele XML in afara codului aplicatiei.
+
+```xml
+
+<!-- Dedesubt este o versiune simplificata a documentului librarie, 
+  cu aditia definitiei DTD.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "Librarie.dtd">
+<librarie>
+  <carte categorie="GATIT">
+    <titlu >Everyday Italian</titlu>
+    <pret>30.00</pret>
+  </carte>
+</librarie>
+
+<!-- DTD-ul poate fi ceva similar cu:-->
+
+<!DOCTYPE note
+[
+<!ELEMENT librarie (carte+)>
+<!ELEMENT carte (titlu,pret)>
+<!ATTLIST carte categorie CDATA "Literatura">
+<!ELEMENT titlu (#PCDATA)>
+<!ELEMENT pret (#PCDATA)>
+]>
+
+
+<!-- DTD-ul incepe cu o declaratie.
+  Dupa, nodul de baza este declarat, cerand unul sau mai multe noduri copii
+  de tipul 'carte'.
+  Fiecare 'carte' trebuie sa contina exact un 'titlu' si 'pret' si un atribut
+  numit 'categorie', cu "Literatura" ca valoare implicita.
+  Nodurile 'titlu' si 'pret' contin parsed character data.-->
+
+<!-- DTD-ul poate fi declara si in interiorul fisierului XML.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT librarie (carte+)>
+<!ELEMENT carte (titlu,pret)>
+<!ATTLIST carte categorie CDATA "Literatura">
+<!ELEMENT titlu (#PCDATA)>
+<!ELEMENT pret (#PCDATA)>
+]>
+
+<librarie>
+  <carte categorie="GATIT">
+    <titlu >Everyday Italian</titlu>
+    <pret>30.00</pret>
+  </carte>
+</librarie>
+```
diff --git a/rst.html.markdown b/rst.html.markdown
new file mode 100644
index 00000000..65f848ed
--- /dev/null
+++ b/rst.html.markdown
@@ -0,0 +1,108 @@
+---
+language: restructured text (RST)
+contributors:
+    - ["DamienVGN", "https://github.com/martin-damien"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+filename: restructuredtext.rst
+---
+
+RST is a file format formely created by Python community to write documentation (and so, is part of Docutils).
+
+RST files are simple text files with lightweight syntax (comparing to HTML).
+
+
+## Installation
+
+To use Restructured Text, you will have to install [Python](http://www.python.org) and the `docutils` package.
+
+`docutils` can be installed using the commandline:
+
+```bash
+$ easy_install docutils
+```
+
+If your system has `pip`, you can use it too:
+
+```bash
+$ pip install docutils
+```
+
+
+## File syntax
+
+A simple example of the file syntax:
+
+```
+.. Lines starting with two dots are special commands. But if no command can be found, the line is considered as a comment
+
+=========================================================
+Main titles are written using equals signs over and under
+=========================================================
+
+Note that there must be as many equals signs as title characters.
+
+Title are underlined with equals signs too
+==========================================
+
+Subtitles with dashes
+---------------------
+
+And sub-subtitles with tildes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can  put text in *italic* or in **bold**, you can "mark" text as code with double backquote ``: ``print()``.
+
+Lists are as simple as in Markdown:
+
+- First item
+- Second item
+    - Sub item
+
+or
+
+* First item
+* Second item
+    * Sub item
+
+Tables are really easy to write:
+
+=========== ========
+Country     Capital
+=========== ========
+France      Paris
+Japan       Tokyo
+=========== ========
+
+More complex tabless can be done easily (merged columns and/or rows) but I suggest you to read the complete doc for this :)
+
+There are multiple ways to make links:
+
+- By adding an underscore after a word : Github_ and by adding the target URL after the text (this way has the advantage to not insert unnecessary URLs inside readable text).
+- By typing a full comprehensible URL : https://github.com/ (will be automatically converted to a link)
+- By making a more Markdown-like link: `Github <https://github.com/>`_ .
+
+.. _Github https://github.com/
+
+```
+
+
+## How to Use It
+
+RST comes with docutils where you have `rst2html`, for example:
+
+```bash
+$ rst2html myfile.rst output.html
+```
+
+*Note : On some systems the command could be rst2html.py*
+
+But there are more complex applications that use the RST format:
+
+- [Pelican](http://blog.getpelican.com/), a static site generator
+- [Sphinx](http://sphinx-doc.org/), a documentation generator
+- and many others
+
+
+## Readings
+
+- [Official quick reference](http://docutils.sourceforge.net/docs/user/rst/quickref.html)
diff --git a/ru-ru/asymptotic-notation-ru.html.markdown b/ru-ru/asymptotic-notation-ru.html.markdown
new file mode 100644
index 00000000..73ad80ba
--- /dev/null
+++ b/ru-ru/asymptotic-notation-ru.html.markdown
@@ -0,0 +1,225 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Divay Prakash", "http://github.com/divayprakash"]
+translators:
+    - ["pru-mike", "http://gihub.com/pru-mike"]
+lang: ru-ru
+---
+
+# О-cимволика
+
+## Что это такое?
+
+О-cимволика или асимптотическая запись это система символов позволяющая оценить
+время выполнения алгоритма, устанавливая зависимость времени выполнения от
+увеличения объема входных данных, так же известна как оценка
+сложности алгоритмов. Быстро-ли алгоритм станет невероятно медленным, когда
+объем входных данных увеличится? Будет-ли алгоритм выполняться достаточно быстро,
+если объем входных данных возрастет? О-символика позволяет ответить на эти
+вопросы.
+
+## Можно-ли по-другому найти ответы на эти вопросы?
+
+Один способ это подсчитать число элементарных операций в зависимости от
+различных объемов входных данных. Хотя это и приемлемое решение, тот объем
+работы которого оно потребует, даже для простых алгоритмов, делает его 
+использование неоправданным.
+
+Другой способ это измерить какое время алгоритм потребует для завершения на
+различных объемах входных данных. В тоже время, точность и относительность
+(полученное время будет относиться только к той машине на которой оно
+вычислено) этого метода зависит от среды выполнения: компьютерного аппаратного
+обеспечения, мощности процессора и т.д.
+
+## Виды О-символики
+
+В первом разделе этого документа мы определили, что О-символика
+позволяет оценивать алгоритмы в зависимости от изменения размера входных
+данных. Представим что алгоритм это функция f, n размер входных данных и 
+f(n) время выполнения. Тогда для данного алгоритма f c размером входных
+данных n получим какое-то результирующее время выполнения f(n).
+Из этого можно построить график, где ось Y время выполнения, ось X размер входных
+данных и точки на графике это время выполнения для заданного размера входных
+данных.
+
+С помощью О-символики можно оценить функцию или алгоритм
+несколькими различными способами. Например можно оценить алгоритм исходя
+из нижней оценки, верхней оценки, тождественной оценки. Чаще всего встречается
+анализ на основе верхней оценки. Как правило не используется нижняя оценка,
+потому что она не подходит под планируемые условия. Отличный пример алгоритмы
+сортировки, особенно добавление элементов в древовидную структуру. Нижняя оценка
+большинства таких алгоритмов может быть дана как одна операция. В то время как в
+большинстве случаев, добавляемые элементы должны быть отсортированы
+соответствующим образом при помощи дерева, что может потребовать обхода целой
+ветви. Это и есть худший случай, для которого планируется верхняя оценка.
+
+### Виды функций, пределы и упрощения
+
+```
+Логарифмическая функция - log n
+Линейная функция - an + b
+Квадратическая функция - an^2 + bn +c
+Полиномиальная функция - an^z + . . . + an^2 + a*n^1 + a*n^0, где z константа
+Экспоненциальная функция - a^n, где a константа
+```
+
+Приведены несколько базовых функций используемых при определении сложности в
+различных оценках. Список начинается с самой медленно возрастающей функции
+(логарифм, наиболее быстрое время выполнения) и следует до самой быстро
+возрастающей функции (экспонента, самое медленное время выполнения). Отметим,
+что в то время как 'n' или размер входных данных, возрастает в каждой из этих функций,
+результат намного быстрее возрастает в квадратической, полиномиальной
+и экспоненциальной по сравнению с логарифмической и линейной.
+
+Крайне важно понимать, что при использовании описанной далее нотации необходимо
+использовать упрощенные выражения.
+Это означает, что необходимо отбрасывать константы и слагаемые младших порядков,
+потому что если размер входных данных (n в функции f(n) нашего примера)
+увеличивается до бесконечности (в пределе), тогда слагаемые младших порядков
+и константы становятся пренебрежительно малыми. Таким образом, если есть
+константа например размера 2^9001 или любого другого невообразимого размера,
+надо понимать, что её упрощение внесёт значительные искажения в точность
+оценки.
+
+Т.к. нам нужны упрощенные выражения, немного скорректируем нашу таблицу...
+
+```
+Логарифм - log n
+Линейная функция - n
+Квадратическая функция - n^2
+Полиномиальная функция - n^z, где z константа
+Экспонента - a^n, где a константа
+```
+
+### О-Большое
+О-Большое, записывается как **О**, это асимптотическая запись для оценки худшего
+случая или для ограничения заданой функции сверху. Это позволяет сделать 
+_**асимптотическую оценку верхней границы**_ скорости роста времени выполнения 
+алгоритма. Допустим `f(n)` время выполнения алгоритма и `g(n)` заданная временная
+сложность которая проверяется для алгоритма. Тогда `f(n)` это O(g(n)), если
+существуют действительные константы с (с > 0) и n<sub>0</sub>, такие
+что `f(n)` <= `c g(n)` выполняется для всех n начиная с некоторого n<sub>0</sub> (n > n<sub>0</sub>).
+
+*Пример 1*
+
+```
+f(n) = 3log n + 100
+g(n) = log n
+```
+
+Является-ли `f(n)` O(g(n))?
+Является-ли `3 log n + 100` O(log n)?
+Посмотрим на определение О-Большого:
+
+```
+3log n + 100 <= c * log n
+```
+
+Существуют-ли константы c, n<sub>0</sub> такие что выражение верно для всех n > n<sub>0</sub>
+
+```
+3log n + 100 <= 150 * log n, n > 2 (неопределенно для n = 1)
+```
+
+Да! По определению О-Большого `f(n)` является O(g(n)).
+
+*Пример 2*
+
+```
+f(n) = 3 * n^2
+g(n) = n
+```
+
+Является-ли `f(n)` O(g(n))?
+Является-ли `3 * n^2` O(n)?
+Посмотрим на определение О-Большого:
+
+```
+3 * n^2 <= c * n
+```
+
+Существуют-ли константы c, n<sub>0</sub> такие что выражение верно для всех n > n<sub>0</sub>?
+Нет, не существуют. `f(n)` НЕ ЯВЛЯЕТСЯ O(g(n)).
+
+### Омега-Большое
+Омега-Большое, записывается как **Ω**, это асимптотическая запись для оценки
+лучшего случая или для ограничения заданой функции снизу. Это позволяет сделать
+_**асимптотическую оценку нижней границы**_ скорости роста времени выполнения 
+алгоритма. 
+
+`f(n)` принадлежит Ω(g(n)), если существуют действительные константы
+с (с > 0) и <sub>0</sub> (n<sub>0</sub> > 0), такие что `f(n)` >= `c g(n)` для всех n > n<sub>0</sub>.
+
+### Примечание
+
+Асимптотические оценки сделаные при помощи О-Большое и Омега-Большое могут
+как быть так и не быть точными. Для того что бы обозначить что границы не
+являются асимптотически точными используются записи о-малое и омега-малое.
+
+### О-Малое
+O-Малое, записывается как **о**, это асимптотическая запись для оценки верхней
+границы времени выполнения алгоритма, при условии что граница не является
+асимптотически точной.
+
+`f(n)` является o(g(n)), если можно подобрать такие действительные константы,
+что для всех c (c > 0) найдется n<sub>0</sub> (n<sub>0</sub> > 0), так
+что `f(n)` < `c g(n)` выполняется для всех n (n > n<sub>0</sub>).
+
+Определения О-символики для О-Большое и О-Малое похожи. Главное отличие в том,
+что если f(n) = O(g(n)), тогда условие f(n) <= c g(n) выполняется если _**существует**_
+константа c > 0, но если f(n) = o(g(n)), тогда условие f(n) < c g(n) выполняется
+для _**всех**_ констант с > 0.
+
+### Омега-малое
+Омега-малое, записывается как **ω**, это асимптотическая запись для оценки
+верней границы времени выполнения алгоритма, при условии что граница не является
+асимптотически точной.
+
+`f(n)` является ω(g(n)), если можно подобрать такие действительные константы,
+что для всех c (c > 0) найдется n<sub>0</sub> (n<sub>0</sub> > 0), так
+что `f(n)` > `c g(n)` выполняется для всех n (n > n<sub>0</sub>)
+
+Определения Ω-символики и ω-символики похожи. Главное отличие в том, что
+если f(n) = Ω(g(n)), тогда условие f(n) >= c g(n) выполняется если _**существует**_
+константа c > 0, но если f(n) = ω(g(n)), тогда условие f(n) > c g(n)
+выполняется для _**всех**_ констант с > 0.
+
+### Тета
+Тета, записывается как **Θ**, это асимптотическая запись для оценки
+_***асимптотически точной границы***_ времени выполнения алгоритма.
+
+`f(n)` является Θ(g(n)), если для некоторых действительных
+констант c1, c2 и n<sub>0</sub> (c1 > 0, c2 > 0, n<sub>0</sub> > 0),
+`c1 g(n)` < `f(n)` < `c2 g(n)` для всех n (n > n<sub>0</sub>).
+
+∴ `f(n)` является Θ(g(n)) означает что `f(n)` является O(g(n))
+и `f(n)` является Ω(g(n)).
+
+О-Большое основной инструмент для анализа сложности алгоритмов.
+Так же смотрите примеры по ссылкам.
+
+### Заключение
+Такую тему сложно изложить кратко, поэтому обязательно стоит пройти по ссылкам и
+посмотреть дополнительную литературу. В них дается более глубокое описание с
+определениями и примерами.
+
+
+## Дополнительная литература
+
+* [Алгоритмы на Java](https://www.ozon.ru/context/detail/id/18319699/)
+* [Алгоритмы. Построение и анализ](https://www.ozon.ru/context/detail/id/33769775/)
+
+## Ссылки
+
+* [Оценки времени исполнения. Cимвол O()](http://algolist.manual.ru/misc/o_n.php)
+* [Асимптотический анализ и теория вероятностей](https://www.lektorium.tv/course/22903)
+
+## Ссылки (Eng)
+
+* [Algorithms, Part I](https://www.coursera.org/learn/algorithms-part1)
+* [Cheatsheet 1](http://web.mit.edu/broder/Public/asymptotics-cheatsheet.pdf)
+* [Cheatsheet 2](http://bigocheatsheet.com/)
+
diff --git a/ru-ru/brainfuck-ru.html.markdown b/ru-ru/bf.html.markdown
index fcee185f..20f0fa56 100644
--- a/ru-ru/brainfuck-ru.html.markdown
+++ b/ru-ru/bf.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
diff --git a/ru-ru/binary-search-ru.html.markdown b/ru-ru/binary-search-ru.html.markdown
new file mode 100644
index 00000000..9ed62cb8
--- /dev/null
+++ b/ru-ru/binary-search-ru.html.markdown
@@ -0,0 +1,64 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+    - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+    - ["Evan K.", "https://github.com/justblah"]
+lang: ru-ru    
+---
+
+# Двоичный (бинарный) поиск
+
+## Зачем использовать двоичный поиск?
+
+Поиск является одной из главных проблем в области вычислительной техники. На сегодняшний день осуществляется более одного триллиона поисковых запросов в год, поэтому нам нужны алгоритмы, которые могут делать это очень быстро. Двоичный поиск является одним из фундаментальных алгоритмов в информатике. Для его изучения мы освоим теорию, а затем используем её для реализации алгоритма.
+
+## Вступление
+
+Самый простой вариант поиска – линейный поиск, но этот подход занимает много времени, и растет линейно, пропорционально набору данных. Пример реализации – начинаем с крайнего левого элемента массива S, один за другим сравниваем искомое значение X с каждым элементом массива S, если X совпадает с элементом S, возвращаем индекс. Если X не совпадает ни с одним из элементов массива S, возвращаем -1.
+
+```
+Линейный поиск: O (n)            Линейная сложность
+
+Двоичный поиск: O ( log(n) )		 Логарифмическая сложность
+
+```
+```
+def search(arr, x):
+
+    for i in range(len(arr)):
+
+        if arr[i] == x:
+            return i
+
+    return -1
+
+```
+
+## Алгоритм двоичного поиска
+
+Для корректной работы двоичного поиска набор данных для поиска должен быть отсортирован (в любом порядке).
+
+### Алгоритм
+
+```
+Главная идея двоичного поиска заключается в использовании информации о том, что массив уже отсортирован,
+что и позволяет упростить сложность алгоритма до O(Logn). Мы попросту отбрасываем половину элементов набора сразу после одного сравнения.
+1) Сравнить X с элементом в середине набора S.
+2) Если X равен элементу в середине - возвращаем индекс среднего элемента.
+3) Если значение X больше, чем средний элемент набора, значит X находится в правой части набора. Повторяем алгоритм для правой половины набора.
+4) В противном случае (X меньше) повторяем алгоритм для левой половины набора.
+Это и есть рекурсивная реализация двоичного поиска.
+
+```
+
+### На заметку
+
+Существует и другая форма двоичного поиска, которая можеть быть полезна.
+
+## На почитать
+
+* [Проектирование, реализация и примеры](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA)
+* [Описание алгоритма ИТМО](http://neerc.ifmo.ru/wiki/index.php?title=%D0%A6%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B4%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA)
+* [Ошибки при реализации бинарного поиска](https://habrahabr.ru/post/146228/)
diff --git a/ru-ru/c++-ru.html.markdown b/ru-ru/c++-ru.html.markdown
new file mode 100644
index 00000000..cef5ab7e
--- /dev/null
+++ b/ru-ru/c++-ru.html.markdown
@@ -0,0 +1,892 @@
+---
+language: c++
+filename: learncpp-ru.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+translators:
+    - ["Bohdan Shtepan", "http://modern-dev.com"]
+lang: ru-ru
+---
+
+C++ - компилируемый, статически типизированный язык программирования общего назначения, который,
+[как заявляет создатель языка Бьёрн Страуструп](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+был разработан как
+
+- "лучшая замена C"
+- язык с поддержкой абстракции данных
+- язык с поддержкой объектно-ориентированого программирования
+- язык с поддержкой обобщенного программирования
+
+Хотя его синтаксис может показаться более трудным или сложным для понимания, чем в более современных языках,
+он широко применяется, так как код, написанный на C++, компилируется в набор инструкций, которые могут быть выполнены напрямую
+процессором. C++ широко используется для разработки программного обеспечения, являясь одним из самых популярных языков
+программирования. Область его применения включает создание операционных систем, разнообразных прикладных программ, драйверов
+устройств, приложений для встраиваемых систем, высокопроизводительных серверов, а также развлекательных приложений (игр).
+
+```c++
+//////////////////
+// Сравнение с C
+//////////////////
+
+// C++ практически представляет собой надмножество C и имеет схожий синтаксис
+// для объявления переменных, примитивов и функций.
+
+// Так же, как и в С, точкой входа в программу является функция с именем main,
+// которая возвращает целочисленное значение.
+// Это значение является кодом ответа программы.
+// Смотрите https://goo.gl/JYGKyv для более подробной информации.
+int main(int argc, char** argv)
+{
+    // Аргументы командной строки, переданные в программу, хранятся в переменных
+	// argc и argv, так же, как и в C.
+    // argc указывает на количество аргументов,
+    // а argv является массивом C-подобных строк (char*), который непосредсвенно
+	// содержит аргументы.
+    // Первым аргументом всегда передается имя программы.
+    // argc и argv могут быть опущены, если вы не планируете работать с аругментами
+	// коммандной строки.
+	// Тогда сигнатура функции будет иметь следующий вид: int main()
+
+    // Возвращаемое значение 0 указывает на успешное завершение программы.
+    return 0;
+}
+
+// Тем не менее, C++ имеет свои отличия:
+
+// В C++ символьные литералы имеют тип char.
+sizeof('c') == sizeof(char) == 1
+
+// В C символьные литералы - целые числа.
+sizeof('c') == sizeof(int)
+
+
+// C++ имеет строгое прототипирование.
+void func(); // функция, которая не принимает аргументов.
+
+// В языке C
+void func(); // функция, которая может принять сколько угодно аргументов.
+
+// Использование nullptr вместо NULL в C++.
+int* ip = nullptr;
+
+// Стандартные заголовочные файлы С доступны в С++,
+// но с префиксом "с" и не имеют суффикса .h.
+#include <cstdio>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+///////////////////////
+// Перегрузка функций
+///////////////////////
+
+// С++ поддерживает перегрузку функций, при условии,
+// что каждая функция принимает различные параметры.
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("My int is %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // Использование void print(const char*)
+    print(15); // Использование void print(int)
+}
+
+/////////////////////////////
+// Аргументы функций по умолчанию
+/////////////////////////////
+
+// Вы можете предоставить аргументы по умолчанию для функции,
+// если они не предоставлены при вызове функции.
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Здесь что-то делаем с числами
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Аргументы по умолчанию должны быть в конце списка аргументов.
+
+void invalidDeclaration(int a = 1, int b) // Ошибка!
+{
+}
+
+
+/////////////
+// Пространства имен
+/////////////
+
+// Пространства имен предоставляют отдельные области для переменной,
+// функции и других объявлений.
+// Пространства имен могут быть вложенными.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("This is First::Nested::foo\n");
+        }
+    } // конец пространства имен Nested
+} // конец пространства имен First
+
+namespace Second {
+    void foo()
+    {
+        printf("This is Second::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("This is global foo\n");
+}
+
+int main()
+{
+    // Включает все функци из пространства имен Second в текущую область видимости.
+    // Обратите внимание, что простой вызов foo() больше не работает,
+    // так как теперь не ясно, вызываем ли мы foo из пространства имен Second, или
+	// из глобальной области видимости.
+    using namespace Second;
+
+    Second::foo(); // напечатает "This is Second::foo"
+    First::Nested::foo(); // напечатает "This is First::Nested::foo"
+    ::foo(); // напечатает "This is global foo"
+}
+
+///////////////
+// Ввод и вывод
+///////////////
+
+// Ввод и вывод в C++ использует потоки
+// cin, cout и cerr представляют потоки stdin, stdout и stderr.
+// << - оператор вставки, >> - оператор извлечения.
+
+#include <iostream> // Включение файла для работы с потоками Ввода\Вывода.
+
+using namespace std; // Потоки доступны в пространстве имен std (стандартная библиотека)
+
+int main()
+{
+   int myInt;
+
+   // Выводит в stdout (или в терминал/на экран)
+   cout << "Enter your favorite number:\n";
+   // Принимает ввод
+   cin >> myInt;
+
+   // cout может принимать форматирование
+   cout << "Your favorite number is " << myInt << "\n";
+   // напечатает "Your favorite number is <myInt>"
+
+    cerr << "Used for error messages";
+}
+
+//////////
+// Строки
+//////////
+
+// Строки в C++ являются объектами и имеют много функций-членов.
+#include <string>
+
+using namespace std; // Строки также доступны в пространстве имен std (стандартная библиотека)
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + используется для конкатенации строк.
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// Строки в C++ могут изменяться и имеют семантику значений.
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+/////////////
+// Ссылки
+/////////////
+
+// Кроме указателей, доступных в C,
+// C++ имеет _ссылки_.
+// Это такой тип указателя, который не может быть переназначен после инициализации
+// и не может иметь значения null.
+// Ссылки имеют схожий с переменными синтаксис:
+// * больше не используется для разыменования и
+// & (адрес) не используется для назначения.
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // Здесь создается ссылка на foo.
+fooRef += ". Hi!"; // Изменяет foo по ссылке
+cout << fooRef; // Печатает "I am foo. Hi!"
+
+// Не переназначает "fooRef". Это то же самое, что и "foo = bar", и
+//   foo == "I am bar"
+// после этой строчки.
+cout << &fooRef << endl; // Печатает адрес foo
+fooRef = bar;
+cout << &fooRef << endl; // По-прежнему печатает адрес foo
+cout << fooRef;  // Печатает "I am bar"
+
+// Адрес fooRef остается тем же, то есть он по-прежнему ссылается на foo.
+
+
+const string& barRef = bar; // Создает константную ссылку.
+// Так же, как и в C, константные значения (а также указатели и ссылки) не могут быть изменены.
+barRef += ". Hi!"; // Ошибка, константная ссылка не может быть изменена.
+
+// Обходной путь: Прежде чем мы рассмотрим указатели более детально, нам нужно ознакомиться
+// с концепцией, известной как "временный объект". Представьте, что мы имеем следующий код
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Вот что на самом деле происходит во второй строке:
+//   - tempObjectFun возвращает строковый объект
+//   - из возвращаемого объекта создается новая строка в качестве аргумента конструктору
+//   - возвращаемый объект уничтожается
+// Возвращаемый объект называется временным объектом. Временные объекты создаются,
+// когда функция возвращает объект, и уничтожаются в конце выполнения обрамляющего
+// выражения (По крайней мере, так это описывает спецификация, хотя компиляторы могут
+// изменять это поведение. Для более подробной информации смотрите "оптимизация
+// возвращаемого значения".) Таким образом в этом коде:
+foo(bar(tempObjectFun()))
+
+// предполагая, что foo и bar существуют, объект, возвращаемый tempObjectFun, передается
+// в bar, и уничтожается перед вызовом foo.
+
+// Возвращаемся к указателям. Исключением для правила "в конце выполнения обрамляющего
+// выражения" является временный объект, привязанный к ссылке const, в этом случае
+// его жизненный цикл продлевается до текущей области видимости:
+
+void constReferenceTempObjectFun() {
+  // constRef получает временный объект, и он действителен до конца этой функции.
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// В C++11 предоставлен еще один тип ссылок специально для временных объектов.
+// objects. Вы не можете объявить переменную этого типа, но он имеет приоритет
+// в резолюции перегрузки:
+
+void someFun(string& s) { ... }  // Обычная ссылка
+void someFun(string&& s) { ... }  // Ссылка на временный объект
+
+string foo;
+someFun(foo);  // Выполняет версию с обычной ссылкой
+someFun(tempObjectFun());  // Выполняет версию с временной ссылкой.
+
+// Например, существуют следующие две версии конструктора std::basic_string:
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// Идея в том, что если мы конструируем новую строку из временного объекта (который
+// так или иначе будет уничтожен), мы можем использовать более эффективный конструктор,
+// который "спасает" части этой временной строки. Эта концепция была названа
+// "move semantics".
+
+/////////////////////
+// Перечисления
+/////////////////////
+
+// Перечисления - способ объявления констант и установки их значений, в основном
+// использующийся для упрощения чтения кода.
+enum ECarTypes
+{
+  Sedan,
+  Hatchback,
+  SUV,
+  Wagon
+};
+
+ECarTypes GetPreferredCarType()
+{
+	return ECarTypes::Hatchback;
+}
+
+// На момент выхода C++11 есть простой способ назначения типа перечисления, что
+// полезно в случае сериализации данных и преобразований между конечным типом и
+// соответствующими константами.
+enum ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Сериализуем InputValue в файл
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// Перечисление неявно преобразуется в uint8_t из-за ранее объявленного
+	// типа перечисления.
+	WriteByteToFile(InputCarType);
+}
+
+// С другой стороны, чтобы избежать случайного приведения к целочисленному типу или
+// другому перечислению, вы можете создать класс перечисления, который не будет
+// преобразовываться неявно.
+enum class ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Сериализуем InputValue в файл
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// Хотя ECarTypes имеет тип uint8_t, код не будет скомпилирован из-за того,
+	// что перечисление было объявлено как класс перечисления.
+	WriteByteToFile(InputCarType);
+}
+
+//////////////////////////////////////////
+// Классы и объектно-ориентированное программирование
+//////////////////////////////////////////
+
+// Пример классов
+#include <iostream>
+
+// Объявление класса.
+// Обычно классы объявляют в заголовочном (.h или .hpp) файле.
+class Dog {
+    // Переменные-члены и функции являются приватными по умолчанию.
+    std::string name;
+    int weight;
+
+// Все члены после этой сроки являются открытыми
+// пока "private:" или "protected:" не будет объявлено.
+public:
+
+    // Конструктор по умолчанию
+    Dog();
+
+    // Объявление функций-членов
+    // Обратите внимание, мы используем std::string здесь вместо использования
+    // using namespace std;
+    // выше.
+    // Никогда не размещайте выражение "using namespace" в заголовке.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // Функции, которые не изменяют состояние объекта,
+    // должны быть помечены как const.
+    // Это позволяет вызывать их, если дана const ссылка на объект.
+    // Обратите внимание, функции должны быть явно объявлены как _virtual_,
+    // если вы хотите перегрузить их в производных классах.
+    // Функции не являются виртуальными по умолчанию для повышения производительности.
+    virtual void print() const;
+
+    // Также функции могут быть определены внутри тела класса.
+    // Функции, определенные следующим образом, автоматически встроены.
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // Наряду с конструкторами, в C++ есть деструкторы.
+    // Они вызываются, когда объект удаляется или выпадает из области видимости.
+    // Это активирует мощную парадигму программирования, известную как RAII
+    // (смотрите ниже)
+    // Деструктор должен быть виртуальным, если класс будет производным.
+    // Если он не виртуальный, тогда деструктор производного класса не будет вызван,
+    // если объект удален по ссылке или указателю базового класса.
+    virtual ~Dog();
+
+}; // Определение класса должно завершаться точкой с запятой.
+
+// Функции-члены класса, как правило, реализуются в .cpp файлах.
+Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// Объекты (такие как строки) должны передаваться по ссылке если вы будете
+// изменять их, или const-ссылке если нет.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Обратите внимание, "virtual" требуется только в объявлении, не в определении.
+void Dog::print() const
+{
+    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    std::cout << "Goodbye " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // Печатает "A dog has been constructed"
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // Печатает "Dog is Barkley and weighs 10 kg"
+    return 0;
+} // Печатает "Goodbye Barkley"
+
+// Интерфейсы:
+
+// Этот класс наследует все открытые и защищенные члены класса Dog
+// так же, как и все закрытые, но не может непосредственно получить доступ к закрытым
+// членам\методам без открытых или защищенных методов для этого.
+class OwnedDog : public Dog {
+
+    void setOwner(const std::string& dogsOwner);
+
+    // Переопределяем поведение функции печати для всех OwnedDog. Смотрите
+    // https://goo.gl/3kuH2x для боле общего введения, если вы не знакомы
+    // с концепцией полиморфизма подтипов (включения).
+    // Ключевое слово override является необязательным, но указывает, что метод
+    // на самом деле перегружается в базовом классе.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Тем временем, в соответствующем .cpp файле:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Вызывает функцию print в базовом классе Dog
+    std::cout << "Dog is owned by " << owner << "\n";
+    // Печатает "Dog is <name> and weights <weight>"
+    //        "Dog is owned by <owner>"
+}
+
+//////////////////////////////////////////
+// Инициализация и перегрузка операторов.
+//////////////////////////////////////////
+
+// В C++ вы можете перегрузить поведение таких операторов: +, -, *, / и др..
+// Это делается путем определения функции, которая вызывается,
+// когда используется оператор.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Значения по умолчанию для переменных-членов могут быть установлены
+	// следующим образом.
+    double x = 0;
+    double y = 0;
+
+    // Определяем новый конструктор, который инициализирует Point со значениями
+    // по умолчанию (0, 0)
+    Point() { };
+
+    // Следующий синтаксис известен как список инициализации и является верным способом
+	// инициализировать значения членов класса.
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* Ничего не делайте, кроме инициализации значений */ }
+
+    // Перегружаем оператор +.
+    Point operator+(const Point& rhs) const;
+
+    // Перегружаем оператор +=.
+    Point& operator+=(const Point& rhs);
+
+    // Имеет смысл добавить перегрузку операторов - и -=,
+    // но для краткости мы опустим эти детали.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Создает новую точку, которая является суммой этой точки и rhs.
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // Здесь происходит вызов оператора + класса Point
+    // Точка "up" вызывает + (функция) с параметром "right"
+    Point result = up + right;
+    // Печатает "Result is upright (1,1)"
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+/////////////////////
+// Шаблоны
+/////////////////////
+
+// Шаблоны в С++, в основном, используются для обобщенного программирования, хотя
+// они гораздо более мощны, чем дженерики в других языках. Они также поддерживают
+// явные, частные и функциональные типы классов; на самом деле, они являются
+// тьюринг-полным языком, встроенным в C++!
+
+// Мы начнем с наиболее распространенного типа обобщенного программирования. Чтобы
+// определить класс или функцию, которая принимает параметр типа:
+template<class T>
+class Box {
+public:
+    // В этом классе T может быть любого типа.
+    void insert(const T&) { ... }
+};
+
+// Во время компиляции компилятор фактически генерирует копии каждого шаблона
+// с замещенными параметрами, поэтому полное определение класса должно присутствовать
+// при каждом вызове. Именно поэтому классы шаблонов полностью определены в
+// заголовочных файлах.
+
+// Чтобы создать экземпляр класса шаблона на стеке:
+Box<int> intBox;
+
+// и вы можете использовать его, как и ожидалось:
+intBox.insert(123);
+
+// Вы, конечно, можете использовать вложенные шаблоны:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// Вплоть до С++11, вы должны были ставить пробел между двумя символами '>', иначе '>>'
+// принимался парсером, как оператор сдвига вправо.
+
+// Иногда вы можете увидеть
+//   template<typename T>
+// вместо этого. В этом случае ключевые слова 'class' и 'typename' _в основном_
+// взаимозаменяемыми. Для более подробной информации смотрите
+//   http://en.wikipedia.org/wiki/Typename
+// (да-да, это ключевое слово имеет собственную страничку на вики).
+
+// Аналогичным образом, шаблонная функция:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Обратите внимание, что здесь ничего не указано о типе параметра. Компилятор
+// будет генерировать и затем проверять на тип каждый вызов шаблона, поэтому
+// данная функция работает с любым типом 'T', который имеет метод 'bark'.
+
+Dog fluffy;
+fluffy.setName("Fluffy");
+barkThreeTimes(fluffy); // Печатает "Fluffy barks" три раза.
+
+//Параметры шаблона не должны быть классами:
+template<int Y>
+void printMessage() {
+  cout << "Learn C++ in " << Y << " minutes!" << endl;
+}
+
+// В конце концов, вы можете явно специализировать шаблоны для более эффективного
+// кода. Конечно, большинство реальных случаев использования специализации
+// не так тривиально, как это. Обратите внимание, вам все еще нужно явно объявить
+// функцию (или класс) в качестве шаблона, даже если вы явно указали все параметры.
+template<>
+void printMessage<10>() {
+  cout << "Learn C++ faster in only 10 minutes!" << endl;
+}
+
+printMessage<20>();  // Печатает "Learn C++ in 20 minutes!"
+printMessage<10>();  // Печатает "Learn C++ faster in only 10 minutes!"
+
+
+/////////////////////
+// Обработка исключений
+/////////////////////
+
+// Стандартная библиотека предоставляет несколько типов исключений
+// (смотрите http://en.cppreference.com/w/cpp/error/exception)
+// но, в принципе, любой тип может быть брошен в качестве исключения.
+#include <exception>
+#include <stdexcept>
+
+// Все исключения, брошенные в блоке _try_ могут быть пойманы в последующем блоке
+// _catch_.
+try {
+    // Не выделяйте память в куче для исключений с помощью ключевого слова _new_.
+    throw std::runtime_error("A problem occurred");
+}
+
+// Поймайте исключение по константной ссылке, если оно является объектом
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Ловит любое исключение, не пойманное предыдущим блоком _catch_
+catch (...)
+{
+    std::cout << "Unknown exception caught";
+    throw; // Повторный выброс исключения
+}
+
+///////
+// Получение ресурса есть инициализация (RAII)
+///////
+
+// Программная идиома объектно-ориентированного программирования, смысл которой
+// заключается в том, что с помощью тех или иных программных механизмов получение
+// некоторого ресурса неразрывно совмещается с инициализацией, а освобождение -
+// с уничтожением объекта.
+
+// Чтобы понять, на сколько это полезно,
+// рассмотрим функцию, которая использует обработчик файлов в С:
+void doSomethingWithAFile(const char* filename)
+{
+    // Для начала, предположим, ничего не может потерпеть неудачу.
+
+    FILE* fh = fopen(filename, "r"); // Открываем файл в режиме чтения.
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Закрываем обработчик файла.
+}
+
+// К сожалению, вещи быстро осложняются обработкой ошибок.
+// Предположим, fopen может потерпеть неудачу, тогда doSomethingWithTheFile и
+// doSomethingElseWithIt вернут коды ошибок, если потерпят неудачу.
+//  (Исключения являются предпочтительным способом обработки ошибок,
+//   но некоторые программисты, особенно те, кто имеет большой опыт работы с С,
+//   не согласны с аргументами о полезности исключений).
+// Теперь мы должны проверить каждый вызов на наличие ошибок и закрыть обработчик
+// файла, если он есть.
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Открывает файл в режиме чтения
+    if (fh == nullptr) // В случае неудачи возвращаемый указатель принимает значение null.
+        return false; // Сообщает о неудаче вызывающему.
+
+    // Предположим, каждая функция возвращает false в случае неудачи
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Закрываем обработчик файла, чтобы не было утечек
+        return false; // Сообщает об ошибке.
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Закрываем обработчик файла, чтобы не было утечек
+        return false; // Сообщает об ошибке.
+    }
+
+    fclose(fh); // Закрываем обработчик файла, чтобы не было утечек
+    return true; // Указывает на успех
+}
+
+// C-программисты часто упорядочивают это с помощью goto:
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // Закрываем файл.
+    return true; // Указывает на успех
+
+failure:
+    fclose(fh);
+    return false; // Сообщает об ошибке.
+}
+
+// Если функции указывают на ошибки с помощью исключений, вещи становятся проще,
+// но все еще не оптимальны.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Открываем файл в режиме чтения
+    if (fh == nullptr)
+        throw std::runtime_error("Could not open the file.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Убедитесь, что закрываете файл, если происходит ошибка.
+        throw; // Затем повторно бросает исключение.
+    }
+
+    fclose(fh); // Закрываем файл.
+    // Успех
+}
+
+// Сравните это с использованием класса потока файла (fstream) в С++, который
+// использует свой деструктор, чтобы закрыть файл. Еще раз взгляните выше,
+// деструктор вызывается автоматически, когда объект выпадает из области видимости.
+void doSomethingWithAFile(const std::string& filename)
+{
+    // ifstream определяет файловый поток
+    std::ifstream fh(filename); // Открыть файл
+
+    // Что-то делать с файлом
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // Здесь файл автоматически закрывается в деструкторе.
+
+// Это имеет _огромнейшие_ преимущества:
+// 1. Неважно, что произойдет,
+//    ресурсы (в данном случае дескриптор файла) будут очищены.
+//    После того, как вы правильно напишете деструктор,
+//    Больше будет _невозможно_ закрыть обработчик файлов или допустить утечку.
+// 2. Обратите внимание, что код намного проще.
+//    Деструктор закрывает файловый поток "за кулисами", и вам больше не нужно об
+//     этом беспокоиться.
+// 3. Код устойчив к исключениям.
+//    Исключение может быть брошено в любом месте в функции, и это никак не повлияет
+//    на очистку.
+
+// Весь идиоматический код на С++ широко использует RAII для всех ресурсов.
+// Дополнительные примеры включат:
+// - Использование памяти unique_ptr и shared_ptr
+// - Контейнеры - стандартная библиотека связанных списков, векторы
+//   (т.е. самоизменяемые массивы), хэш-таблицы и все остальное автоматически
+//    уничтожается сразу же, когда выходит за пределы области видимости.
+// - Ипользование мьютексов lock_guard и unique_lock
+
+// Контейнеры с пользовательскими классами в качестве ключей требуют
+// сравнивающих функций в самом объекте или как указатель на функцию. Примитивы
+// имеют компараторы по умолчанию, но вы можете перегрузить их.
+class Foo {
+public:
+	int j;
+	Foo(int a) : j(a) {}
+};
+struct compareFunction {
+    bool operator()(const Foo& a, const Foo& b) const {
+        return a.j < b.j;
+    }
+};
+// это не допускается (хотя это может варьироваться в зависимости от компилятора)
+// std::map<Foo, int> fooMap;
+std::map<Foo, int, compareFunction> fooMap;
+fooMap[Foo(1)]  = 1;
+fooMap.find(Foo(1)); //true
+
+/////////////////////
+// Веселые вещи
+/////////////////////
+
+// Аспекты С++, которые могут быть удивительными для новичков (и даже для некоторых
+// ветеранов). Этот раздел, к сожалению, очень неполон. С++ является одним из самых
+// простых языков, где очень легко выстрелить себе в ногу.
+
+// Вы можете перегрузить приватные методы!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Перегружает Foo::bar!
+};
+
+
+// 0 == false == NULL (в основном)!
+bool* pt = new bool;
+*pt = 0; // Устанавливает значение указателя 'pt' в false.
+pt = 0;  // Устанавливает значение 'pt' в нулевой указатель. Обе строки проходят
+		// компиляцию без ошибок.
+
+// nullptr приходит на помощь:
+int* pt2 = new int;
+*pt2 = nullptr; // Не пройдет компиляцию
+pt2 = nullptr;  // Устанавливает pt2 в null.
+
+// Существует исключение для булевых значений.
+// Это позволит вам проверить указатели с помощью if(!ptr),
+// но как следствие вы можете установить nullptr в bool напрямую!
+*pt = nullptr;  // Это по прежнему проходит компиляцию, даже если '*pt' - bool!
+
+
+// '=' != '=' != '='!
+// Вызывает Foo::Foo(const Foo&) или некий вариант (смотрите "move semantics")
+// копирования конструктора.
+Foo f2;
+Foo f1 = f2;
+
+// Вызывает Foo::Foo(const Foo&) или вариант, но копирует только часть 'Foo' из
+// 'fooSub'. Любые другие члены 'fooSub' пропускаются. Иногда это ужасное поведение
+// называют "object slicing."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Вызывает Foo::operator=(Foo&) или вариант.
+Foo f1;
+f1 = f2;
+
+
+// Как по-настоящему очистить контейнер:
+class Foo { ... };
+vector<Foo> v;
+for (int i = 0; i < 10; ++i)
+  v.push_back(Foo());
+
+// В следующей точке размер v устанавливается в 0, но деструктор не вызывается
+// и не происходит очистка ресурсов!
+v.empty();
+v.push_back(Foo());  // Новые значения копируются в первый вставленный Foo
+
+// Настоящее уничтожение всех значений v. Смотрите раздел о временном объекте
+// для объяснения того, как это работает.
+v.swap(vector<Foo>());
+
+```
+## Дальнейшее чтение:
+
+Наиболее полное и обновленное руководство по С++ можно найти на
+<http://cppreference.com/w/cpp>
+
+Дополнительные ресурсы могут быть найдены на <http://cplusplus.com>
diff --git a/ru-ru/c-ru.html.markdown b/ru-ru/c-ru.html.markdown
index 5988b159..71e41ee3 100644
--- a/ru-ru/c-ru.html.markdown
+++ b/ru-ru/c-ru.html.markdown
@@ -11,7 +11,7 @@ lang: ru-ru
 
 Что ж, Си всё ещё является лидером среди современных высокопроизводительных языков.
 
-Для большинствоа программистов, Си – это самый низкоуровневый язык на котором они когда-либо писали,
+Для большинства программистов, Си – это самый низкоуровневый язык на котором они когда-либо писали,
 но этот язык даёт больше, чем просто повышение производительности.
 Держите это руководство в памяти и вы сможете использовать Си максимально эффективно.
 
@@ -145,7 +145,7 @@ int main() {
     f1 / f2; // => 0.5, плюс-минус погрешность потому что,
     // цифры с плавающей точкой вычисляются неточно!
 
-    // Модуль
+    // Остаток от деления
     11 % 3; // => 2
 
     // Операции сравнения вам уже знакомы, но в Си нет булевого типа.
@@ -170,7 +170,7 @@ int main() {
     !0; // => 1
     1 && 1; // => 1 (логическое И)
     0 && 1; // => 0
-    0 || 1; // => 1 (лигическое ИЛИ)
+    0 || 1; // => 1 (логическое ИЛИ)
     0 || 0; // => 0
 
     // Битовые операторы
@@ -202,7 +202,7 @@ int main() {
     int ii = 0;
     while (ii < 10) {
         printf("%d, ", ii++); // инкрементация происходит после того как
-                              // знаечние ii передано ("postincrement")
+                              // значение ii передано ("postincrement")
     } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
 
     printf("\n");
@@ -212,7 +212,7 @@ int main() {
     do {
         printf("%d, ", kk);
     } while (++kk < 10); // инкрементация происходит перед тем как
-                         // передаётся знаечние kk ("preincrement")
+                         // передаётся значение kk ("preincrement")
     // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
 
     printf("\n");
@@ -229,7 +229,7 @@ int main() {
     switch (some_integral_expression) {
     case 0: // значения должны быть целыми константами (и могут быть выражениями)
         do_stuff();
-        break; // если не написать break; то управление будет передено следующему блоку
+        break; // если не написать break; то управление будет передано следующему блоку
     case 1:
         do_something_else();
         break;
@@ -247,7 +247,7 @@ int main() {
     // Каждое выражение в Си имеет тип, но вы можете привести один тип к другому, 
     // если хотите (с некоторыми искажениями).
 
-    int x_hex = 0x01; // Вы можете назначать переменные с помощью шеснадцатеричного кода.
+    int x_hex = 0x01; // Вы можете назначать переменные с помощью шестнадцатеричного кода.
 
     // Приведение типов будет пытаться сохранять цифровые значения.
     printf("%d\n", x_hex); // => Prints 1
@@ -285,17 +285,17 @@ int main() {
     printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer));
     // => Напечатает "8, 4" в 64 битной системе
 
-    // Для того, чтобы получить знаечние по адресу, напечатайте * перед именем.
-    // Да, использование * при объявлении указателя и получении значения по адресу
+    // Для того, чтобы получить значение по адресу, напечатайте * перед именем.
+    // Да, * используется при объявлении указателя и для получении значения по адресу
     // немного запутано, но вы привыкнете.
-    printf("%d\n", *px); // => Напечаатет 0, значение перемененной x
+    printf("%d\n", *px); // => Напечатает 0, значение перемененной x
 
     // Вы также можете изменять значение, на которое указывает указатель.
     (*px)++; // Инкрементирует значение на которое указывает px на единицу
     printf("%d\n", *px); // => Напечатает 1
     printf("%d\n", x); // => Напечатает 1
 
-    // Массивы удобно использовать для болшого количества однотипных данных.
+    // Массивы удобно использовать для большого количества однотипных данных.
     int x_array[20];
     int xx;
     for (xx = 0; xx < 20; xx++) {
@@ -305,9 +305,10 @@ int main() {
     // Объявление указателя на int с адресом массива.
     int* x_ptr = x_array;
     // x_ptr сейчас указывает на первый элемент массива (со значением 20). 
-    // Это рабоатет, потому что имя массива возвращает указатель на первый элемент.
-    // Например, когда массив передаётся в функцию или назначается указателю, он
-    // невявно преобразуется в указатель.
+    // Это работает, потому что при обращении к имени массива возвращается 
+    // указатель на первый элемент.
+    // Например, когда массив передаётся в функцию или присваивается указателю, он
+    // неяввно преобразуется в указатель.
     // Исключения: когда массив является аргументом для оператор '&':
     int arr[10];
     int (*ptr_to_arr)[10] = &arr; // &arr не является 'int *'!
@@ -422,7 +423,7 @@ void function_1() {
     // Вы можете объявить указатель на структуру
     struct rectangle *my_rec_ptr = &my_rec;
 
-    // Можно доступаться к структуре и через указатель
+    // Можно получить доступ к структуре и через указатель
     (*my_rec_ptr).width = 30;
 
     // ... или ещё лучше: используйте оператор -> для лучшей читабельночти
@@ -436,7 +437,7 @@ int area(rect r) {
     return r.width * r.height;
 }
 
-// Если вы имеете большую структуру, можно доступаться к ней "по указателю",
+// Если вы имеете большую структуру, можно получить доступ к ней "по указателю",
 // чтобы избежать копирования всей структуры.
 int area(const rect *r) {
     return r->width * r->height;
@@ -456,7 +457,7 @@ int area(const rect *r) {
 
 void str_reverse_through_pointer(char *str_in) {
     // Определение функции через указатель.
-    void (*f)(char *); // Сигнатура должна полность совпадать с целевой функцией.
+    void (*f)(char *); // Сигнатура должна полностью совпадать с целевой функцией.
     f = &str_reverse; // Присвоить фактический адрес (во время исполнения)
     // "f = str_reverse;" тоже будет работать.
     //Имя функции (как и массива) возвращает указатель на начало.
diff --git a/ru-ru/clojure-ru.html.markdown b/ru-ru/clojure-ru.html.markdown
index 451da312..356d1cc0 100644
--- a/ru-ru/clojure-ru.html.markdown
+++ b/ru-ru/clojure-ru.html.markdown
@@ -321,7 +321,7 @@ keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
 ; Также модуль может быть импортирован формой require
 (require 'clojure.string)
 
-; После этого модуль становится доступе в текущем пространстве имен,
+; После этого модуль становится доступен в текущем пространстве имен,
 ; а вызов его функций может быть осуществлен указанием полного имени функции:
 (clojure.string/blank? "") ; => true
 
diff --git a/ru-ru/css-ru.html.markdown b/ru-ru/css-ru.html.markdown
index 2e2d40b7..e0e5e30b 100644
--- a/ru-ru/css-ru.html.markdown
+++ b/ru-ru/css-ru.html.markdown
@@ -116,7 +116,7 @@ element:visited {}
 /* или еще не проходил по ней */
 element:link {}
 
-/* выбранное поле воода (input) */
+/* выбранное поле ввода (input) */
 element:focus {}
 
 
@@ -132,7 +132,7 @@ selector {
     width: 200px; /* пиксели */
     font-size: 20pt; /* пункты */
     width: 5cm; /* сантиметры */
-    min-width: 50mm; /* милиметры */
+    min-width: 50mm; /* миллиметры */
     max-width: 5in; /* дюймы */
     height: 0.2vh; /* умножается на высоту окна браузера (CSS3) */
     width: 0.4vw; /* умножается на ширину окна браузера (CSS3) */
@@ -235,7 +235,7 @@ p { property: value !important; }
 
 ## Совместимость
 
-Несмотря на то, что большая часть функций CSS2 (а также CSS3) подеррживается всеми
+Несмотря на то, что большая часть функций CSS2 (а также CSS3) поддерживается всеми
 браузерами и устройствами, не забывайте проверять совместимость CSS-правил
 с современными браузерами.
 
diff --git a/ru-ru/d-ru.html.markdown b/ru-ru/d-ru.html.markdown
index 8f4233fd..bfa3f085 100644
--- a/ru-ru/d-ru.html.markdown
+++ b/ru-ru/d-ru.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: d
+language: D
 filename: learnd-ru.d
 contributors:
     - ["Anton Pastukhov", "http://dprogramming.ru/"]
@@ -7,11 +7,12 @@ contributors:
     - ["Andre Polykanine", "http://oire.me/"]
 lang: ru-ru
 ---
+
 D - современный компилируемый язык общего назначения с Си-подобным синтаксисом,
 который сочетает удобство, продуманный дизайн и высокую производительность.
 D - это С++, сделанный правильно.
 
-```d
+```c
 // Welcome to D! Это однострочный комментарий
 
 /* многострочный
diff --git a/ru-ru/forth-ru.html.markdown b/ru-ru/forth-ru.html.markdown
new file mode 100644
index 00000000..05316578
--- /dev/null
+++ b/ru-ru/forth-ru.html.markdown
@@ -0,0 +1,240 @@
+---
+language: forth
+contributors:
+    - ["Horse M.D.", "http://github.com/HorseMD/"]
+translators:
+    - ["Dmitrii Kuznetsov", "https://github.com/torgeek"]
+filename: learnforth-ru.fs
+lang: ru-ru
+---
+
+Форт создан Чарлзом Муром в 70-е годы. Это императивный, стековый язык программирования и среда исполнения программ. Использовался в таких проектах как Open Firmware. Продолжает применятся в проектах. Применяется в НАСА.
+
+Внимание: эта материал использует реализацию Форта - Gforth, но большая часть написанного будет работать в других средах.
+
+```
+\ Это комментарий
+( Это тоже комментарий, но использыется для предоределённых слов )
+
+\ --------------------------------- Прекурсор --------------------------------
+
+\ Всё программирование на Форте заключается в манипулировании 
+\ параметрами на стеке.
+5 2 3 56 76 23 65    \ ok
+
+\ Эти числа добавляются в стек слева направо
+.s    \ <7> 5 2 3 56 76 23 65 ok
+
+\ В Форте всё - это слова-команды или числа. Слова разделяются любым числом
+\ пробелов и переходов на новую строку. Длина слова не больше 31 литеры.
+
+\ ---------------------------- Базовая арифметика ----------------------------
+
+\ Арифметика (фактически все ключевые слова требуют данных) - это манипуляция 
+\ данными на стеке.
+5 4 +    \ ok
+
+\ `.` показывает верхнее значение в стеке:
+.    \ 9 ok
+
+\ Ещё примеры арифметических выражений:
+6 7 * .        \ 42 ok
+1360 23 - .    \ 1337 ok
+12 12 / .      \ 1 ok
+13 2 mod .     \ 1 ok
+
+99 negate .    \ -99 ok
+-99 abs .      \ 99 ok
+52 23 max .    \ 52 ok
+52 23 min .    \ 23 ok
+
+\ --------------------------- Манипуляции со стеком ---------------------------
+
+\ Естественно, когда мы работаем со стеком, то используем 
+\ больше полезных методов:
+
+3 dup -          \ дублировать верхний элемент в стеке 
+                 \ (1-й становится эквивалентным 2-му): 3 - 3
+2 5 swap /       \ поменять местами верхний элемент со 2-м элементом: 5 / 2
+6 4 5 rot .s     \ сменять по очереди 3-и верхних элемента: 4 5 6
+4 0 drop 2 /     \ снять верхний элемент (не печатается на экране): 4 / 2
+1 2 3 nip .s     \ снять второй элемент (подобно исключению элемента):   1 3
+
+\ ------------------ Более продвинутые манипуляции со стеком ------------------
+
+1 2 3 4 tuck   \ дублировать верхний елемент стека во вторую позицию: 
+               \ 1 2 4 3 4 ok
+1 2 3 4 over   \ диблировать второй елемент наверх стека: 
+               \ 1 2 3 4 3 ok
+1 2 3 4 2 roll \ *переместить* элемент в заданной позиции наверх стека:
+               \ 1 3 4 2 ok
+1 2 3 4 2 pick \ *дублировать* элемент в заданной позиции наверх: 
+               \ 1 2 3 4 2 ok
+
+\ Внимание! Обращения к стеку индексируются с нуля.
+
+\ --------------------------- Создание новых слов -----------------------------
+
+\ Определение новых слов через уже известные. Двоеточие `:` переводит Форт 
+\ в режим компиляции выражения, которое заканчивается точкой с запятой `;`.
+: square ( n -- n ) dup * ;    \ ok
+5 square .                     \ 25 ok
+
+\ Мы всегда можем посмотреть, что содержится в слове:
+see square     \ : square dup * ; ok
+
+\ -------------------------------- Зависимости --------------------------------
+
+\ -1 == true, 0 == false. Однако, некоторые ненулевые значения 
+\ обрабатываются как true:
+42 42 =    \ -1 ok
+12 53 =    \ 0 ok
+
+\ `if` это компилируемое слово. `if` <stuff to do> `then` <rest of program>.
+: ?>64 ( n -- n ) dup 64 > if ." Больше чем 64!" then ;   
+\ ok
+100 ?>64                                                  
+\ Больше чем 64! ok
+
+\ Else:
+: ?>64 ( n -- n ) dup 64 > if ." Больше чем 64!" else ." меньше чем 64!" then ;
+100 ?>64    \ Больше чем 64! ok
+20 ?>64     \ меньше чем 64! ok
+
+\ ------------------------------------ Циклы -----------------------------------
+
+\ `do` это тоже компилируемое слово.
+: myloop ( -- ) 5 0 do cr ." Hello!" loop ; \ ok
+myloop
+\ Hello!
+\ Hello!
+\ Hello!
+\ Hello!
+\ Hello! ok
+
+\ `do` предполагает наличие двух чисел на стеке: конечное и начальное число.
+
+\ Мы можем назначить в цикле переменную `i` для значения индекса:
+: one-to-12 ( -- ) 12 0 do i . loop ;     \ ok
+one-to-12                                 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 ok
+
+\ `?do` работает подобным образом, за исключением пропуска начального 
+\ и конечного значения индекса цикла.
+: squares ( n -- ) 0 ?do i square . loop ;   \ ok
+10 squares                                   \ 0 1 4 9 16 25 36 49 64 81 ok
+
+\ Изменение "шага" цикла проиводится командой `+loop`:
+: threes ( n n -- ) ?do i . 3 +loop ;    \ ok
+15 0 threes                             \ 0 3 6 9 12 ok
+
+\ Запуск бесконечного цикла - `begin` <stuff to do> <flag> `until`:
+: death ( -- ) begin ." Вы всё ещё здесь?" 0 until ;    \ ok
+
+\ ---------------------------- Переменные и память ----------------------------
+
+\ Используйте `variable`, что бы объявить `age` в качестве переменной.
+variable age    \ ok
+
+\ Затем мы запишем число 21 в переменную 'age' (возраст) словом `!`.
+21 age !    \ ok
+
+\ В заключении мы можем напечатать значение переменной прочитав его словом `@`, 
+\ которое добавит значение на стек или использовать слово `?`, 
+\ что бы прочитать и распечатать в одно действие.
+age @ .    \ 21 ok
+age ?      \ 21 ok
+
+\ Константы объявляются аналогично, за исключем того, что мы не должны 
+\ беспокоиться о выделении адреса в памяти:
+100 constant WATER-BOILING-POINT    \ ok
+WATER-BOILING-POINT .               \ 100 ok
+
+\ ---------------------------------- Массивы ----------------------------------
+
+\ Создание массива похоже на объявление переменной, но нам нужно выделить
+\ больше памяти.
+
+\ Вы можете использовать слова `2 cells allot` для создания массива 
+\ размером 3 элемента:
+variable mynumbers 2 cells allot    \ ok
+
+\ Инициализировать все значения в 0
+mynumbers 3 cells erase    \ ok
+
+\ В качестве альтернативы мы можем использовать `fill`:
+mynumbers 3 cells 0 fill
+
+\ или мы можем пропустить все слова выше и инициализировать массив 
+\ нужными значениями:
+create mynumbers 64 , 9001 , 1337 , \ ok (the last `,` is important!)
+
+\ ... что эквивалентно:
+
+\ Ручная запись значений по индексам ячеек:
+64 mynumbers 0 cells + !      \ ok
+9001 mynumbers 1 cells + !    \ ok
+1337 mynumbers 2 cells + !    \ ok
+
+\ Чтение значений по индексу:
+0 cells mynumbers + ?    \ 64 ok
+1 cells mynumbers + ?    \ 9001 ok
+
+\ Мы можем просто сделать собственное слово для манипуляции массивом:
+: of-arr ( n n -- n ) cells + ;    \ ok
+mynumbers 2 of-arr ?               \ 1337 ok
+
+\ Которую тоже можно использовать для записи значений:
+20 mynumbers 1 of-arr !    \ ok
+mynumbers 1 of-arr ?       \ 20 ok
+
+\ ------------------------------ Стек возвратов ------------------------------
+
+\ Стек возвратов используется для удержания ссылки,
+\ когда одно слово запускает другое, например, в цикле.
+
+\ Мы всегда видим это, когда используем `i`, которая возвращает дубль верхнего
+\ значения стека. `i` это эквивалент `r@`.
+: myloop ( -- ) 5 0 do r@ . loop ;    \ ok
+
+\ Так же как при чтении мы можем добавить ссылку в стек возвратов и удалить её:
+5 6 4 >r swap r> .s    \ 6 5 4 ok
+
+\ Внимание: так как Форт использует стек возвратов для указателей на слово `>r`
+\ следует всегда пользоваться `r>`.
+
+\ ---------------- Операции над числами с плавающей точкой --------------------
+
+\ Многие фортовцы стараются избегать использование слов с вещественными числами.
+8.3e 0.8e f+ f.    \ 9.1 ok
+
+\ Обычно мы просто используем слово 'f', когда обращаемся к вещественным числам:
+variable myfloatingvar    \ ok
+4.4e myfloatingvar f!     \ ok
+myfloatingvar f@ f.       \ 4.4 ok
+
+\ ---------- В завершение несколько полезных замечаний и слов -----------------
+
+\ Указание несуществующего слова очистит стек. Тем не менее, есть специальное 
+\ слово для этого:
+clearstack
+
+\ Очистка экрана:
+page
+
+\ Загрузка форт-файла:
+\ s" forthfile.fs" included
+
+\ Вы можете вывести список всех слов словаря Форта (это большой список!):
+words
+
+\ Выход из Gforth:
+bye
+
+```
+
+##Готовы к большему?
+
+* [Начала Форта (англ.)](http://www.forth.com/starting-forth/)
+* [Простой Форт (англ.)](http://www.murphywong.net/hello/simple.htm)
+* [Мышление Форта (англ.)](http://thinking-forth.sourceforge.net/)
+* [Учебники Форта (рус.)](http://wiki.forth.org.ru/УчебникиФорта)
diff --git a/ru-ru/go-ru.html.markdown b/ru-ru/go-ru.html.markdown
index e06ae9bd..6c8622cc 100644
--- a/ru-ru/go-ru.html.markdown
+++ b/ru-ru/go-ru.html.markdown
@@ -35,6 +35,7 @@ package main
 // Import предназначен для указания зависимостей этого файла.
 import (
     "fmt"      // Пакет в стандартной библиотеке Go
+    "io/ioutil" // Реализация функций ввод/ввывода.
     "net/http" // Да, это веб-сервер!
     "strconv"  // Конвертирование типов в строки и обратно
     m "math"   // Импортировать math под локальным именем m.
@@ -321,6 +322,14 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     // Обработка запроса и отправка данных методом из http.ResponseWriter
     w.Write([]byte("You learned Go in 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("\nWebserver said: `%s`", string(body))
+}
 ```
 
 ## Что дальше
diff --git a/ru-ru/haskell-ru.html.markdown b/ru-ru/haskell-ru.html.markdown
index e15fe6b7..fecee51b 100644
--- a/ru-ru/haskell-ru.html.markdown
+++ b/ru-ru/haskell-ru.html.markdown
@@ -66,7 +66,7 @@ not False -- True
 
 
 ----------------------------------------------------
--- Списки и Кортежи
+-- 2. Списки и Кортежи
 ----------------------------------------------------
 
 -- Все элементы списка в Haskell
diff --git a/ru-ru/html-ru.html.markdown b/ru-ru/html-ru.html.markdown
new file mode 100644
index 00000000..5069d77f
--- /dev/null
+++ b/ru-ru/html-ru.html.markdown
@@ -0,0 +1,129 @@
+---
+language: html
+filename: learnhtml.html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Lana Tim", "https://github.com/LanaTim"]
+lang: ru-ru
+---
+
+HTML расшифровывается как Hypertext Markup Language(гипертекстовый язык разметки).
+Это язык используют для написания страниц для World Wide Web(всемирной паутины).
+Это язык разметки позволяет писать веб-страниц с помощью кода, чтобы определять, 
+как должны быть отображены текст и данные.
+На самом деле, HTML файлы представляют собой простые текстовые файлы.
+Что такое разметка? Это способ организации данных страницы,
+путем открытия и закрытия тегов(помещая данные внутрь этих тегов).
+Эта разметка служит, чтобы придать значение тексту, который он окружает.
+Как и в других языках программирования, HTML имеет много версий. Здесь мы будем говорить о HTML5.
+
+
+**Примечание:** Вы можете тестировать различные теги и элементы по мере продвижения 
+через учебник на сайте, как [codepen](http://codepen.io/pen/) для того, чтобы увидеть 
+их влияние, понять, как они работают и ознакомиться с языком.
+В данной статье рассматривается в основном HTML синтаксис и некоторые полезные советы.
+
+```html
+<!-- Комментарии заключаются как эта лини\! -->
+
+<!-- #################### Теги #################### -->
+   
+<!-- Ниже приведен пример HTML-файл, который мы будем анализировать. -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Мой сайт</title>
+		</head>
+		<body>
+			<h1>Привет, мир!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">
+				Переходите сюда, чтоб посмотреть как это выглядит.
+			</a>
+			<p>Это параграф.</p>
+			<p>Это другой параграф.</p>
+			<ul>
+				<li>Это элемент не нумерованного списка (маркированный список)</li>
+				<li>Это другой элемент</li>
+				<li>Это последний элемент в списке</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- HTML-файл всегда начинается с указанием браузеру, что страница это HTML. -->
+<!doctype html>
+
+<!-- После этого, страница начинается с <html> тега. -->
+<html>
+
+<!-- страница будет закрыта в конце с помощью тега </html>. -->
+</html>
+
+<!-- Ничто не должно появиться после этого заключительного тега. -->
+
+<!-- Внутри (между открывающим и закрывающим тегами <html> </ html>), мы находим: -->
+
+<!-- Заголовок определяется <head> (it он должен быть закрыт </head>). -->
+<!-- Заголовок содержит описание и дополнительную информацию, которая не отображается; это метаданные. -->
+
+<head>
+	<title>Мой сайт</title><!-- Тег <title> указывает браузеру заголовок, чтобы показать в строке заголовка названия и вкладки браузера окна. -->
+</head>
+
+<!-- После секция <head>, находится секция - <body> -->
+<!-- До этого момента, ничего описаное не будет отображаться в окне браузера. -->
+<!-- Мы должны наполнить <body>  содержанием, которое будет отображаться. -->
+
+<body>
+	<h1>Hello, world!</h1> <!-- Тег h1 создает заголовок. -->
+	<!-- Так же существуют другие заголовки от имеющего большее значение <h1> по убыванию к  <h6>. -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">Переходите сюда, чтоб посмотреть как это выглядит.</a>
+	<!--гиперссылка на URL, заданнf атрибутом href="" -->
+	<p>Это параграф.</p> <!-- Тег <p> позволяет нам добавдять текст на странице HTML. -->
+	<p>Это другой параграф.</p>
+	<ul> <!-- Тег <ul> создает маркированный список. -->
+	<!-- Для того, чтобы иметь пронумерованный список лучше использовать <ol> 
+		тогда первый элемент будет иметь значение 1. для второго элемента, 2. и так далее. -->
+		<li>Это элемент в не нумерованном списке (маркированный список)</li>
+		<li>Это еще один элемент</li>
+		<li>И это последний пункт в списке</li>
+	</ul>
+</body>
+
+<!-- Вот так просто можно создать HTML страницу. -->
+
+<!--Но можно добавить множество дополнительных типов HTML тегов. -->
+
+<!-- Для вставки картинки -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- Источник изображения указывается с помощью атрибута src="" -->
+<!-- Источником может быть URL или даже путь к файлу на вашем компьютере. -->
+
+<!-- Кроме того, можно создать таблицу. -->
+
+<table> <!-- Мы открыли <table> элемент. -->
+	<tr> <!-- <tr> позволяет создать ряд. -->
+		<th>Первый заголовок</th> <!-- <th> позволяет дать название для столбца таблицы. -->
+		<th>Второй заголовок</th>
+	</tr>
+	<tr>
+		<td>Первый ряд, первая колонка</td> <!-- <td> позволяет нам создать ячейку таблицы. -->
+		<td>Первый ряд, вторая колонка</td>
+	</tr>
+	<tr>
+		<td>Второй ряв, первая колонка</td>
+		<td>Второй ряд, вторая колонка</td>
+	</tr>
+</table>
+
+```
+
+## Применение
+
+HTML файлы имеют окончание(расширение) `.html`.
+
+## Узнать больше
+
+* [википедиа](https://ru.wikipedia.org/wiki/HTML)
+* [HTML учебник](https://developer.mozilla.org/ru/docs/Web/HTML)
+* [htmlbook](http://htmlbook.ru/)
diff --git a/ru-ru/java-ru.html.markdown b/ru-ru/java-ru.html.markdown
index b24ad555..a1a5cdfc 100644
--- a/ru-ru/java-ru.html.markdown
+++ b/ru-ru/java-ru.html.markdown
@@ -9,7 +9,7 @@ filename: LearnJavaRu.java
 lang: ru-ru
 ---
 
-Java - это объектно ориентированный язык программирования общего назначения,
+Java - это объектно-ориентированный язык программирования общего назначения,
 основанный на классах и поддерживающий параллельное программирование.
 [Подробнее читайте здесь.](http://docs.oracle.com/javase/tutorial/java/index.html)
 
@@ -43,17 +43,41 @@ public class LearnJavaRu {
             " Double: " + 3.14 +
             " Boolean: " + true);
 
-        // Чтобы напечатать что-либо не заканчивая переводом строки
-        // используется System.out.print.
+        // Чтобы печатать что-либо, не заканчивая переводом строки,
+        // используйте System.out.print.
         System.out.print("Hello ");
         System.out.print("World");
 
+        // Используйте System.out.printf() для печати с форматированием
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
 
         ///////////////////////////////////////
-        // Типы и Переменные
+        // Переменные
         ///////////////////////////////////////
 
+        /*
+        *  Объявление переменных
+        */
         // Переменные объявляются с использованием <тип> <имя>
+        int fooInt;
+        // Одновременное объявление нескольких переменных одного типа
+        // <type> <name1>, <name2>, <name3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Инициализация переменных
+        */
+
+        // объявление и инициализация переменной <type> <name> = <val>
+        int fooInt = 1;
+        int fooInt1, fooInt2, fooInt3;
+        // инициализация нескольких переменных одного типа
+        // <type> <name1>, <name2>, <name3> = <val>
+        fooInt1 = fooInt2 = fooInt3 = 1;
+
+        /*
+        *  Типы переменных
+        */
         // Byte - 8-битное целое число.
         // (-128 <= byte <= 127)
         byte fooByte = 100;
@@ -247,7 +271,7 @@ public class LearnJavaRu {
         // Switch Case
         // switch работает с типами byte, short, char и int.
         // Также он работает с перечислениями,
-        // классом String и с некоторыми классами-обертками над
+        // классом String (с Java 7) и с некоторыми классами-обертками над
         // примитивными типами: Character, Byte, Short и Integer.
         int month = 3;
         String monthString;
@@ -319,7 +343,7 @@ public class LearnJavaRu {
         System.out.println("trek info: " + trek.toString());
 
     } // Конец метода main.
-} // Конец класса LearnJava.
+} // Конец класса LearnJavaRu.
 
 
 // Вы можете включать другие, не публичные классы в .java файл.
@@ -362,7 +386,7 @@ class Bicycle {
     // Классы в Java часто реализуют сеттеры и геттеры для своих полей.
 
     // Синтаксис определения метода:
-    // <модификатор> <тип возвращаемого значения> <имя>(<аргументы>)
+    // <модификатор доступа> <тип возвращаемого значения> <имя метода>(<аргументы>)
     public int getCadence() {
         return cadence;
     }
@@ -424,10 +448,10 @@ class PennyFarthing extends Bicycle {
 
 // Интерфейсы
 // Синтаксис определения интерфейса: 
-// <модификатор доступа> interface <имя> extends <базовый интерфейс> {
-//        // Константы
-//        // Определение методов.
-//}
+// <модификатор доступа> interface <имя интерфейса> extends <базовый интерфейс> {
+//     // Константы
+//     // Определение методов
+// }
 
 // Пример - Еда:
 public interface Edible {
diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
index 54499f46..1f1ffce6 100644
--- a/ru-ru/javascript-ru.html.markdown
+++ b/ru-ru/javascript-ru.html.markdown
@@ -359,6 +359,7 @@ myFunc(); // = undefined
 // И наоборот, функция может быть присвоена объекту и получать доступ к нему
 // через this, даже если она не была прикреплена к нему при объявлении.
 var myOtherFunc = function() {
+    return this.myString.toUpperCase();
 }
 myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = "ПРИВЕТ, МИР!"
diff --git a/ru-ru/kotlin-ru.html.markdown b/ru-ru/kotlin-ru.html.markdown
new file mode 100644
index 00000000..21940e41
--- /dev/null
+++ b/ru-ru/kotlin-ru.html.markdown
@@ -0,0 +1,375 @@
+---
+language: kotlin
+filename: LearnKotlin-ru.kt
+lang: ru-ru
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators:
+    - ["Vadim Toptunov", "https://github.com/VadimToptunov"]
+---
+
+Kotlin - статистически типизированный язык для JVM, Android и браузера. Язык полностью cjdvtcnbv c Java. 
+[Более детальная информация здесь.](https://kotlinlang.org/)
+
+```kotlin
+// Однострочные комментарии начинаются с //
+/*
+А вот так выглядят многострочные комментарии.
+*/
+
+// Ключевое слово "package" действует и используется // абсолютно также, как и в Java.
+package com.learnxinyminutes.kotlin
+
+/*
+Точкой входа в программу на языке Kotlin является функция "main".
+Приведенная ниже функция передает массив, содержащий любые аргументы из командной строки.
+*/
+fun main(args: Array<String>) {
+    /*
+    Объявление значений производится с помощью или "var", или "val".
+    Значения объявленные с помощью "val" не могут быть изменены или перезаписаны, в то время как объявленные с помощью "var" - могут.
+    */
+    val fooVal = 10 // мы не можем потом изменить значение fooVal на какое-либо иное
+    var fooVar = 10
+    fooVar = 20 // значение fooVar затем может быть изменено.
+
+    /*
+    В большинстве случаев Kotlin самостоятельно может определить тип переменной, поэтому нам не нужно явно указывать его каждый раз.
+    Мы можем явно объявить тип переменной следующим образом:
+    */
+    val foo: Int = 7
+
+    /*
+    Строки могут быть представлены тем же образом, что и в Java.
+    Для экранирования используется обратный слэш.
+    */
+    val fooString = "My String Is Here!"
+    val barString = "Printing on a new line?\nNo Problem!"
+    val bazString = "Do you want to add a tab?\tNo Problem!"
+    println(fooString)
+    println(barString)
+    println(bazString)
+
+    /*
+    Необработанная строка разделяется тройной кавычкой (""").
+    Необработанные строки могут содержать символы новой строки и любые другие символы.
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Hello, world!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    Строки могут содержать в себе шаблонные выражения.
+    Шаблонные выражения начинаются со знака доллара ($).
+    */
+    val fooTemplateString = "$fooString has ${fooString.length} characters"
+    println(fooTemplateString)
+
+    /*
+    Переменная, которая содержит null должна быть явно обозначена как nullable.
+    Переменная может быть обозначена как nullable с помощью добавления знака вопроса(?) к ее типу.
+    Мы можем получить доступ к nullable переменной используя оператор ?. .
+    Для того, чтобы указать иное значение, если переменная является null, мы используем оператор ?: .
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    Функции могут быть объявлены с помощью ключевого слова "fun".
+    Аргументы функции указываются в скобках после имени функции.
+    Аргументы функции также могу иметь и значение по умолчанию.
+    Если требуется, то тип возвращаемого функцией значения, может быть указан после аргументов.
+    */
+    fun hello(name: String = "world"): String {
+        return "Hello, $name!"
+    }
+    println(hello("foo")) // => Hello, foo!
+    println(hello(name = "bar")) // => Hello, bar!
+    println(hello()) // => Hello, world!
+
+    /*
+    Параметр функции может быть отмечен с помощью ключевого слова "vararg", для того чтобы позволить аргументам попасть в функцию.
+    */
+    fun varargExample(vararg names: Int) {
+        println("Argument has ${names.size} elements")
+    }
+    varargExample() // => Argument has 0 elements
+    varargExample(1) // => Argument has 1 elements
+    varargExample(1, 2, 3) // => Argument has 3 elements
+
+    /*
+    Если функция состоит из одиночного выражения, фигурные скобки могут быть опущены. Тело функции указывается после знака = .
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // Если возвращаемый тип может быть выведен, то нам не нужно его дополнительно указывать.
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // Функции могут брать другие функции в качестве аргументов, а также могут возвращать функции. 
+    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // Именованные функции могут быть определены в качестве аргументов с помощью оператора :: .
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // Lambda-выражения могут быть определены в качестве аргументов.
+    val notZero = not {n -> n == 0}
+    /*
+    Если lambda-выражение имеет только один параметр, то ее определение может быть опущено (вместе с ->).
+    Имя этого единственного параметра будет "it".
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // Ключевое слово "class" используется для 
+    // объявления классов.
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int): Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    Чтобы создать новый экземпляр класса, нужно вызвать конструктор.
+    Обратите внимание, что в Kotlin нет ключевого слова "new".
+    */
+    val fooExampleClass = ExampleClass(7)
+    // Функции-члены могут быть вызваны с использованием точечной нотации.
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    В случае, если функция была помечена ключевым словом "infix", она может быть вызвана с помощью инфиксной нотации. 
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    Data-классы - это компактный способ создать классы, которые лишь хранят данные.
+    Методы "hashCode"/"equals" и "toString" генерируютсяч автоматически. 
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // Data-классы обладают функцией "copy".
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // Объекты могут быть деструктурированы на множество переменных.
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+    
+    // Деструктурирование в цикле "for"
+    for ((a, b, c) in listOf(fooData)) {
+        println("$a $b $c") // => 1 100 4
+    }
+    
+    val mapData = mapOf("a" to 1, "b" to 2)
+    // Map.Entry также может быть дествуктурирован
+    for ((key, value) in mapData) {
+        println("$key -> $value")
+    }
+
+    // Функция "with" аналогична оператору "with" в JavaScript.
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    Можно создать список с помощью функции "ListOf".
+    Этот список будет неизменяемым, т.е. элементы не могут быть удалены или добавлены в него.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // Элементы списка доступны по их индексу в нем. 
+    println(fooList[1]) // => b
+
+    // Изменяемый список может быть создан спомощью функции "mutableListOf".
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // Мы можем создать набор, используя функцию "setOf". 
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // Мы можем создать отображение (map), используя функцию "mapOf".
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // Получить доступ к значениям отображения (map) можно с помощью их ключа. 
+    println(fooMap["a"]) // => 8
+
+    /*
+    Последовательности представляют собой коллекции с ленивой оценкой.
+    Мы можем создать последовательность, используя функцию "generateSequence".
+    */
+    val fooSequence = generateSequence(1, { it + 1 })
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // Пример использования последовательности для генерации чисел Фибоначчи:
+    fun fibonacciSequence(): Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next(): Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin предоставляет функции высшего порядка для работы с коллекциями.
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "even" else "odd"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // Цикл "for" может использоваться со всем, что предоставляет  итератор.
+    for (c in "hello") {
+        println(c)
+    }
+
+    // Циклы "while" работают также, как и в других языках.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    "if" может быть использован в качестве выражения, которое возвращает значение.
+    По этой причине в Kotlin тернарный оператор ?: не нужен.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "even" else "odd"
+    println("$num is $message") // => 5 is odd
+
+    // "when" может быть использован как альтернатива цепочке "if-else if".
+    val i = 10
+    when {
+        i < 7 -> println("first block")
+        fooString.startsWith("hello") -> println("second block")
+        else -> println("else block")
+    }
+
+    // "when" может быть использован с аргументами.
+    when (i) {
+        0, 21 -> println("0 or 21")
+        in 1..20 -> println("in the range 1 to 20")
+        else -> println("none of the above")
+    }
+
+    // "when" также может быть использовано как функция, возвращающая значение.
+    var result = when (i) {
+        0, 21 -> "0 or 21"
+        in 1..20 -> "in the range 1 to 20"
+        else -> "none of the above"
+    }
+    println(result)
+
+    /*
+    Мы можем проверить, что объект принадлежит к определенному типу, используя оператор "is".
+    Если объект проходит проверку типа, то он может использоваться как этот тип без явной его  передачи.
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x is automatically cast to Boolean
+            return x
+        } else if (x is Int) {
+            // x is automatically cast to Int
+            return x > 0
+        } else if (x is String) {
+            // x is automatically cast to String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hello, world!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    // Smartcast также работает с блоком "when"
+    fun smartCastWhenExample(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    Расширения - это способ добавить новый функционал к классу. 
+    Это то же самое, что методы расширений в C#.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hello, world!".remove('l')) // => Heo, word!
+
+    println(EnumExample.A) // => A
+    println(ObjectExample.hello()) // => hello
+}
+
+// Enum-классы схожи с типами enum в Java.
+enum class EnumExample {
+    A, B, C
+}
+
+/*
+Ключевое слово "object" может использоваться для создания одноэлементных объектов.
+Мы не можем его инстанцировать, но можем вызывать его уникальный экземпляр по имени.
+Это похоже на одиночные объекты Scala.
+*/
+object ObjectExample {
+    fun hello(): String {
+        return "hello"
+    }
+}
+
+fun useObject() {
+    ObjectExample.hello()
+    val someRef: Any = ObjectExample // we use objects name just as is
+}
+
+```
+
+### Дальнейшее чтение:
+
+* [Учебные материалы по Kotlin](https://kotlinlang.org/docs/tutorials/)
+* [Попробуй Kotlin в своем браузере](http://try.kotlinlang.org/)
+* [Список ресурсов по языку Kotlin](http://kotlin.link/)
diff --git a/ru-ru/markdown-ru.html.markdown b/ru-ru/markdown-ru.html.markdown
index eb8e4881..ff7a0cc3 100644
--- a/ru-ru/markdown-ru.html.markdown
+++ b/ru-ru/markdown-ru.html.markdown
@@ -2,55 +2,77 @@
 language: markdown
 contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
+    - ["Jacob Ward", "http://github.com/JacobCWard/"]
+translators:
     - ["Pirogov Alexey", "http://twitter.com/alex_pir"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
 filename: markdown-ru.md
 lang: ru-ru
 ---
 
 Язык разметки Markdown создан Джоном Грубером (англ. John Gruber)
-и Аароном Шварцем (англ. Aaron H. Swartz) в 2004 году.
+в 2004 году.
 Авторы задавались целью создать максимально удобочитаемый
 и удобный в публикации облегчённый язык разметки,
 пригодный для последующего преобразования в HTML
 (а также и в другие форматы).
 
+Также реализации Markdown варьируют в зависимости от парсера.
+В этом руководстве будет указано, какие функции универсальны для языка,
+а какие зависят от конкретного парсера.
+
+- [HTML-элементы](#html-elements)
+- [Заголовки](#headings)
+- [Простейшая стилизация текста](#simple-text-styles)
+- [Абзацы](#paragraphs)
+- [Списки](#lists)
+- [Блоки кода](#code-blocks)
+- [Горизонтальный разделитель](#horizontal-rule)
+- [Ссылки](#links)
+- [Изображения](#images)
+- [Разное](#miscellany)
+
+## HTML-элементы
+Markdown является надмножеством HTML, поэтому любой HTML-файл является
+корректным документом Markdown.
+
  ```markdown
-<!-- Markdown является надмножеством HTML, поэтому любой HTML-файл является
-валидным документом Markdown, что позволяет использовать напрямую
+<!-- Это позволяет использовать напрямую
 любые элементы HTML-разметки, такие, например, как этот комментарий.
   Встроенные в документ HTML-элементы не затрагиваются парсером Markdown
-и попадают в итоговый HTML без изменений. Однако, следует понимать,
+и попадают в итоговый HTML без изменений. Однако следует понимать,
 что эта же особенность не позволяет использовать разметку Markdown внутри
 HTML-элементов -->
 
-<!-- Ещё одна особенность формата Markdown состоит в том, что поддерживаемые
-возможности разметки зависят от конкретной реализации парсера. В данном
-руководстве возможности, поддерживаемые лишь определёнными парсерами,
-сопровождаются соответствующими примечаниями. -->
-
-<!-- Заголовки -->
+## Заголовки 
 
-<!-- HTML-элементы от <h1> до <h6> размечаются очень просто:
+HTML-элементы от <h1> до <h6> размечаются очень просто:
 текст, который должен стать заголовком, предваряется
-соответствующим количеством символов "#": -->
+соответствующим количеством символов "#":
+
+```markdown
 # Это заголовок h1
 ## Это заголовок h2
 ### Это заголовок h3
 #### Это заголовок h4
 ##### Это заголовок h5
 ###### Это заголовок h6
+```
+Markdown позволяет размечать заголовки <h1> и <h2> ещё одним способом:
 
-<!-- Markdown позволяет размечать заголовки <h1> и <h2> ещё одним способом: -->
+```markdown
 Это заголовок h1
 ================
 
 А это заголовок h2
 ------------------
+```
 
-<!-- Простейшая стилизация текста -->
+## Простейшая стилизация текста
 
-<!-- Текст легко сделать полужирным и/или курсивным: -->
+Текст легко сделать полужирным и/или курсивным:
 
+```markdown
 *Этот текст будет выведен курсивом.*
 _Так же, как этот._
 
@@ -60,44 +82,58 @@ __И этот тоже.__
 ***Полужирный курсив.***
 **_И тут!_**
 *__И даже здесь!__*
+```
 
-<!-- В Github Flavored Markdown (версии Markdown, использующейся в Github,
-для рендеринга Markdown-документов) текст можно сделать зачёркнутым: -->
+В Github Flavored Markdown, стандарте, который используется в Github,
+текст также можно сделать зачёркнутым:
 
+```markdown
 ~~Зачёркнутый текст.~~
+```
+
+## Абзацы
+
+Абзацами являются любые строки, следующие друг за другом.
+Разделяются же абзацы одной или несколькими пустыми строками:
 
-<!-- Абзацами являются любые строки, следующие друг за другом.
-Разделяются же абзацы одной или несколькими пустыми строками: -->
+```markdown
+Это абзац. Я печатаю в абзаце, разве это не прикольно?
 
-Это абзац. Всё предельно просто.
+А тут уже абзац №2.
+Эта строка всё ещё относится к абзацу №2!
 
-А тут уже параграф №2.
-Эта строка всё ещё относится к параграфу №2!
 
+О, а вот это уже абзац №3!
+```
 
-О, а вот это уже параграф №3!
+Для вставки принудительных переносов можно завершить абзац двумя дополнительными пробелами:
 
-<!-- Для вставки принудительных переносов можно использовать HTML-тэг <br/>: -->
+```markdown
+Эта строка завершается двумя пробелами (выделите, чтобы увидеть!).  
 
-Принудительный <br/> перенос!
+Над этой строкой есть <br />!
+```
 
-<!-- Цитаты размечаются с помощью символа ">": -->
+Цитаты размечаются с помощью символа «>»:
 
+```markdown
 > Это цитата. В цитатах можно
-> принудительно переносить строки, вставляя ">" в начало каждой следующей строки. А можно просто оставлять достаточно длинными, и такие длинные строки будут перенесены автоматически.
+> принудительно переносить строки, вставляя «>» в начало каждой следующей строки. А можно просто оставлять их достаточно длинными, и такие длинные строки будут перенесены автоматически.
 > Разницы между этими двумя подходами к переносу строк нет, коль скоро
-> каждая строка начинается с символа ">"
+> каждая строка начинается с символа «>»
 
 > А ещё цитаты могут быть многоуровневыми:
 >> как здесь
 >>> и здесь :)
 > Неплохо?
+```
 
-<!-- Списки -->
-<!-- Маркированные списки размечаются вставкой в начало каждого элемента
-одного из символов "*", "+" или "-":
-(символ должен быть одним и тем же для всех элементов) -->
+## Списки
+Маркированные списки размечаются вставкой в начало каждого элемента
+одного из символов «*», «+» или «-»:
+(символ должен быть одним и тем же для всех элементов)
 
+```markdown
 * Список,
 * Размеченный
 * Звёздочками
@@ -113,167 +149,207 @@ __И этот тоже.__
 - Список,
 - Размеченный
 - Дефисами
+```
 
-<!-- В нумерованных списках каждая строка начинается
-с числа и точки вслед за ним: -->
+В нумерованных списках каждая строка начинается
+с числа и точки вслед за ним:
 
+```markdown
 1. Первый элемент
 2. Второй элемент
 3. Третий элемент
+```
 
-<!-- Заметьте, нумеровать элементы корректно необязательно. Достаточно указать
-любое число в начале каждого элемента и рендер пронумерует элементы сам!
-Правда, злоупотреблять этим не стоит :) -->
+Заметьте, нумеровать элементы корректно необязательно. Достаточно указать
+любое число в начале каждого элемента, и парсер пронумерует элементы сам!
+Правда, злоупотреблять этим не стоит :)
 
+```markdown
 1. Первый элемент
 1. Второй элемент
 1. Третий элемент
-<!-- (Этот список будет отрендерен так же, как и предыдущий!) -->
+```
+(Этот список будет отображён так же, как и предыдущий!)
 
-<!-- Списки могут быть вложенными: -->
+Списки могут быть вложенными:
 
+```markdown
 1. Введение
 2. Начало работы
 3. Примеры использования
     * Простые
     * Сложные
 4. Заключение
+```
+
+Можно даже делать списки задач. Блок ниже создаёт HTML-флажки. 
 
-<!-- Блоки с исходным кодом -->
-<!-- Фрагменты исходного кода выделяются очень просто - каждая строка блока должна иметь отступ в четыре пробела либо в один символ табуляции -->
+```markdown
+Для отметки флажка используйте «x»
+- [ ] Первая задача
+- [ ] Вторая задача
+Этот флажок ниже будет отмечен
+- [x] Задача была завершена
+```
 
+## Блоки кода
+
+Фрагменты исходного кода (обычно отмечаемые тегом `<code>`) выделяются просто:
+каждая строка блока должна иметь отступ в четыре пробела либо в один символ табуляции.
+
+```markdown
     Это код,
-    причём - многострочный
+    причём многострочный
+```
 
-<!-- Дополнительные отступы в коде следует делать с помощью четырёх пробелов: -->
+Вы также можете делать дополнительные отступы, добавляя символы табуляции
+или по четыре пробела:
 
+```markdown
     my_array.each do |item|
         puts item
     end
+```
 
-<!-- Иногда бывает нужно вставить фрагмент кода прямо в строку текста,
+Иногда бывает нужно вставить фрагмент кода прямо в строку текста,
 не выделяя код в блок. Для этого фрагменты кода нужно обрамлять
-символами "`": -->
+символами «`»:
 
-Например, можно выделить имя функции `go_to()` прямо посреди текста.
+```markdown
+Ваня даже не знал, что делает функция `go_to()`!
+```
 
-<!-- Github Flavored Markdown позволяет указать для блока кода синтаксис оного.
-В этом случае синтаксис внутри блока будет подсвечен. Пример: -->
+В Github Flavored Markdown для блоков кода можно использовать
+специальный синтаксис:
 
-\`\`\`ruby <!-- Только нужно будет убрать символы "\", оставив лишь "```ruby" -->
+<pre>
+<code class="highlight">&#x60;&#x60;&#x60;ruby
 def foobar
-    puts "Hello world!"
+    puts "Привет, мир!"
 end
-\`\`\` <!-- И здесь тоже backslashes нужно убрать, т.е. оставить "```" -->
+&#x60;&#x60;&#x60;</code></pre>
 
-<-- Обратите внимание: фрагмент, указанный выше, не предваряется отступами,
-поскольку Github сам в состоянии определить границы блока - по строкам "```" -->
+Во фрагменте, приведённом выше, отступ не требуется.
+Кроме того, Github подсветит синтаксис языка, указанного после \`\`\`
 
-<!-- Горизонтальный разделитель (<hr />) -->
-<!-- Разделители добавляются вставкой строки из трёх и более
-(одинаковых) символов "*" или "-": -->
+## Горизонтальный разделитель
 
+Разделители (`<hr>`) добавляются вставкой строки из трёх и более
+(одинаковых) символов «*» или «-», с пробелами или без них:
+
+```markdown
 ***
 ---
-- - - <!-- между символами допустимы пробелы -->
+- - -
 ****************
+```
+
+## Ссылки
 
-<!-- Ссылки -->
-<!-- Одной из сильных сторон Markdown можно смело считать то,
+Одной из сильных сторон Markdown можно смело считать то,
 как просто размечаются гиперссылки. Для создания ссылки укажите
 текст ссылки, заключив его в квадратные скобки,
-и сразу после - url, заключенный в "круглые" -->
+и сразу после — URL-адрес, заключенный в круглые
 
+```markdown
 [Ссылка!](http://test.com/)
+```
+Также для ссылки можно указать всплывающую подсказку (`title`), используя
+кавычки внутри круглых скобок:
 
-<!-- Также для ссылки можно указать всплывающую подсказку: -->
-
+```markdown
 [Ссылка!](http://test.com/ "Ссылка на Test.com")
+```
+Относительные пути тоже возможны:
 
-<!-- В url можно использовать относительные пути: -->
-
+```markdown
 [Перейти к музыке](/music/).
+```
 
-<!-- Markdown позволяет размечать ссылку в виде сноски: -->
+Markdown также позволяет размечать ссылку в виде сноски:
 
-[Здесь][link1] высможете узнать больше!
-А можно кликнуть [сюда][foobar], если очень хочется.
+<pre><code class="highlight">&#x5b;<span class="nv">Щёлкните эту ссылку</span>][<span class="ss">link1</span>] для подробной информации!
+&#x5b;<span class="nv">Также посмотрите эту ссылку,</span>][<span class="ss">foobar</span>] если хотите.
 
-<!-- где-нибудь внизу -->
-[link1]: http://test.com/ "Круто!"
-[foobar]: http://foobar.biz/ "Тоже хорошо!"
+&#x5b;<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Круто!"</span>
+&#x5b;<span class="nv">foobar</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Нормально!"</span></code></pre>
 
-<!-- Примечания:
-- Подсказка может быть заключена в одинарные кавычки вместо двойных,
-  а также в круглые скобки.
-- Сноска может находиться в любом месте документа и может иметь
-идентификатор (далее ID) произвольной длины,
-лишь бы это ID был уникальным. -->
+`Title` также может быть в одинарных кавычках или круглых скобках, а также
+отсутствовать вовсе. Ссылки на сноски могут быть в любом месте документа,
+а идентификаторы могут быть какими угодно, лишь бы они были уникальными.
 
-<!-- Также при разметке ссылок-сносок можно опустить ID,
-если текст ссылки уникален в пределах документа: -->
+Существует также неявное именование, когда ссылка является идентификатором.
 
-Ссылка на [Google][].
+<pre><code class="highlight">&#x5b;<span class="nv">Это</span>][] ссылка.
 
-[google]: http://google.com/
+&#x5b;<span class="nv">это</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
 
-<!-- Правда, эта возможность не очень распространена. -->
+Правда, эта возможность не очень распространена.
 
-<!-- Изображения -->
-<!-- Разметка изображений очень похожа на разметку ссылок.
-Нужно всего лишь добавить "!" перед ссылкой! -->
+## Изображения
+Разметка изображений очень похожа на разметку ссылок.
+Нужно всего лишь добавить перед ссылкой восклицательный знак!
 
+```markdown
 ![Альтернативный текст для изображения](http://imgur.com/myimage.jpg "Подсказка")
+```
+Изображения тоже могут быть оформлены, как сноски.
 
-<!-- Изображения тоже могут быть оформлены, как сноски: -->
-
-![Альтернативный текст][myimage]
-
-![То же изображение ещё раз][myimage]
-
-[myimage]: relative/urls/cool/image.jpg "подсказка"
+<pre><code class="highlight">!&#x5b;<span class="nv">Это альтернативный текст.</span>][<span class="ss">myimage</span>]
 
-<!-- Ещё немного ссылок: -->
-<!-- Автоссылки -->
+&#x5b;<span class="nv">myimage</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"Если нужна подсказка, её можно добавить"</span></code></pre>
+## Разное
+### Автоссылки
 
+```markdown
 Ссылка вида <http://testwebsite.com/> эквивалентна
 [http://testwebsite.com/](http://testwebsite.com/)
+```
 
-<!-- Автоссылки для адресов электронной почты -->
+### Автоссылки для адресов электронной почты
 
+```markdown
 <foo@bar.com>
+```
+
+### Экранирование символов
 
-<!-- Экранирование символов -->
+```markdown
+Я хочу напечатать *текст, заключённый в звёздочки*, но я не хочу,
+чтобы он был курсивным. Тогда я делаю так:
+\*Текст, заключённый в звёздочки\*
+```
 
-<!-- Может потребоваться вставить спецсимвол в текст "как есть",
-т.е. защитить его от обработки парсером.
-Такой символ должен быть "экранирован" с помощью обратной косой черты
-(символа "\"): -->
+### Клавиши на клавиатуре
+В Github Flavored Markdown для представления клавиш на клавиатуре
+вы можете использовать тег `<kbd>`.
 
-\*текст, заключённый в звёздочки!\*
+```markdown
+Ваш компьютер завис? Попробуйте нажать
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
 
-<!-- Таблицы -->
-<!-- Таблицы официально поддерживаются только в Github Flavored Markdown,
+### Таблицы
+Таблицы официально поддерживаются только в GitHub Flavored Markdown,
 да и синтаксис имеют не слишком удобный.
-Но если очень нужно, размечайте таблицы так: -->
+Но если очень нужно, размечайте таблицы так:
 
+```markdown
 | Столбец 1    | Столбец 2    | Столбец 3    |
 | :----------- | :----------: | -----------: |
 | Выравнивание | Выравнивание | Выравнивание |
 | влево        | по центру    | вправо       |
+```
+Или более компактно
 
-<!-- Или более компактно -->
-
-Колонка 1|Колонка 2|Колонка 3
+```markdown
+Столбец 1|Столбец 2|Столбец 3
 :--|:-:|--:
 Выглядит|это|страшновато...
-
-<!-- Ну вот и всё! -->
-
 ```
 
-За более подробной информацией обращайтесь к [статье](http://daringfireball.net/projects/markdown/syntax) Джона Грубера о синтаксисе Markdown.
+Ну вот и всё!
 
-Также часто бывает полезной отличная ["шпаргалка"](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) по Markdown от Adam Pritchard.
+За более подробной информацией обращайтесь к [статье](http://daringfireball.net/projects/markdown/syntax) Джона Грубера о синтаксисе Markdown.
 
-Если вдруг встретите ошибки в переводе или же захотите его дополнить, делайте pull requests - авторы всегда рады обратной связи!
+Также часто бывает полезной отличная ["шпаргалка"](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) по Markdown от Адама Притчарда.
diff --git a/ru-ru/nim-ru.html.markdown b/ru-ru/nim-ru.html.markdown
new file mode 100644
index 00000000..d05583d7
--- /dev/null
+++ b/ru-ru/nim-ru.html.markdown
@@ -0,0 +1,279 @@
+---
+language: Nim
+filename: learnNim-ru.nim
+contributors:
+    - ["Jason J. Ayala P.", "http://JasonAyala.com"]
+    - ["Dennis Felsing", "http://felsin9.de/nnis/"]
+translators:
+    - ["Nomadic", "https://github.com/n0madic"]
+lang: ru-ru
+---
+
+Nim (ранее известный, как Nimrod) — язык программирования со статической
+типизацией, поддерживающий процедурный, объектно-ориентированный,
+функциональный и обобщённый стили программирования.
+
+Nim эффективный, выразительный и элегантный.
+
+```nim
+var                     # Объявление (и присваивание) переменных,
+  letter: char = 'n'    # с указанием типа или без
+  lang = "N" & "im"
+  nLength : int = len(lang)
+  boat: float
+  truth: bool = false
+
+let            # Используйте let *сразу* для объявления и связывания переменных.
+  legs = 400   # legs неизменяемый.
+  arms = 2_000 # Символ _ игнорируется и удобен для длинных чисел.
+  aboutPi = 3.15
+
+const            # Константы вычисляются во время компиляции. Это обеспечивает
+  debug = true   # производительность и полезно в выражениях этапа компиляции.
+  compileBadCode = false
+
+when compileBadCode:            # `when` это `if` этапа компиляции.
+  legs = legs + 1               # Эта ошибка никогда не будет скомпилирована.
+  const input = readline(stdin) # Значения констант должны быть известны во
+                                # время компиляции.
+
+discard 1 > 2 # Примечание. Компилятор будет жаловаться, если результат
+              # выражения не используется. `discard` обходит это.
+
+discard """
+Это может использоваться как многострочный комментарий.
+Или для не поддающегося синтаксическому анализу, сломанного кода
+"""
+
+#
+# Структуры данных
+#
+
+# Кортежи
+
+var
+  child: tuple[name: string, age: int]   # Кортежи определяют *как* имя поля
+  today: tuple[sun: string, temp: float] # так *и* порядок полей.
+
+child = (name: "Rudiger", age: 2) # Присвоить все сразу литералом ()
+today.sun = "Overcast"            # или отдельно по полям.
+today.temp = 70.1
+
+# Последовательности
+
+var
+  drinks: seq[string]
+
+drinks = @["Water", "Juice", "Chocolate"] # @[V1,..,Vn] является литералом
+                                          # последовательности
+
+drinks.add("Milk")
+
+if "Milk" in drinks:
+  echo "We have Milk and ", drinks.len - 1, " other drinks"
+
+let myDrink = drinks[2]
+
+#
+# Определение типов
+#
+
+# Определение собственных типов позволяет компилятору работать на вас.
+# Это то, что делает статическую типизацию мощной и полезной.
+
+type
+  Name = string # Псевдоним типа дает вам новый тип, который равнозначен
+  Age = int     # старому типу, но более нагляден.
+  Person = tuple[name: Name, age: Age] # Определение структур данных.
+  AnotherSyntax = tuple
+    fieldOne: string
+    secondField: int
+
+var
+  john: Person = (name: "John B.", age: 17)
+  newage: int = 18 # Было бы лучше использовать Age, чем int
+
+john.age = newage # Но это все же работает, потому что int и Age синонимы.
+
+type
+  Cash = distinct int    # `distinct` делает новый тип несовместимым с его
+  Desc = distinct string # базовым типом.
+
+var
+  money: Cash = 100.Cash # `.Cash` преобразует int в наш тип
+  description: Desc  = "Interesting".Desc
+
+when compileBadCode:
+  john.age  = money        # Error! age is of type int and money is Cash
+  john.name = description  # Компилятор говорит: "Нельзя!"
+
+#
+# Дополнительные типы и структуры данных
+#
+
+# Перечисления позволяют типу иметь одно из ограниченного числа значений
+
+type
+  Color = enum cRed, cBlue, cGreen
+  Direction = enum # Альтернативный формат
+    dNorth
+    dWest
+    dEast
+    dSouth
+var
+  orient = dNorth # `orient` имеет тип Direction, со значением `dNorth`
+  pixel = cGreen # `pixel` имеет тип Color, со значением `cGreen`
+
+discard dNorth > dEast # Перечисления обычно являются "порядковыми" типами
+
+# Поддиапазоны определяют ограниченный допустимый диапазон
+
+type
+  DieFaces = range[1..20] # Допустимым значением являются только int от 1 до 20
+var
+  my_roll: DieFaces = 13
+
+when compileBadCode:
+  my_roll = 23 # Error!
+
+# Arrays
+
+type
+  RollCounter = array[DieFaces, int]  # Массивы фиксированной длины и
+  DirNames = array[Direction, string] # индексируются любым порядковым типом.
+  Truths = array[42..44, bool]
+var
+  counter: RollCounter
+  directions: DirNames
+  possible: Truths
+
+possible = [false, false, false] # Массивы создаются литералом [V1,..,Vn]
+possible[42] = true
+
+directions[dNorth] = "Ahh. The Great White North!"
+directions[dWest] = "No, don't go there."
+
+my_roll = 13
+counter[my_roll] += 1
+counter[my_roll] += 1
+
+var anotherArray = ["Default index", "starts at", "0"]
+
+# Доступны другие структуры данных, в том числе таблицы, множества,
+# списки, очереди и crit-bit деревья.
+# http://nim-lang.org/docs/lib.html#collections-and-algorithms (EN)
+
+#
+# IO и поток управления выполнением
+#
+
+# `case`, `readLine()`
+
+echo "Read any good books lately?"
+case readLine(stdin)
+of "no", "No":
+  echo "Go to your local library."
+of "yes", "Yes":
+  echo "Carry on, then."
+else:
+  echo "That's great; I assume."
+
+# `while`, `if`, `continue`, `break`
+
+import strutils as str # http://nim-lang.org/docs/strutils.html (EN)
+echo "I'm thinking of a number between 41 and 43. Guess which!"
+let number: int = 42
+var
+  raw_guess: string
+  guess: int
+while guess != number:
+  raw_guess = readLine(stdin)
+  if raw_guess == "": continue # Пропустить эту итерацию
+  guess = str.parseInt(raw_guess)
+  if guess == 1001:
+    echo("AAAAAAGGG!")
+    break
+  elif guess > number:
+    echo("Nope. Too high.")
+  elif guess < number:
+    echo(guess, " is too low")
+  else:
+    echo("Yeeeeeehaw!")
+
+#
+# Итерации (циклы)
+#
+
+for i, elem in ["Yes", "No", "Maybe so"]: # Или просто `for elem in`
+  echo(elem, " is at index: ", i)
+
+for k, v in items(@[(person: "You", power: 100), (person: "Me", power: 9000)]):
+  echo v
+
+let myString = """
+an <example>
+`string` to
+play with
+""" # Многострочная "сырая" строка
+
+for line in splitLines(myString):
+  echo(line)
+
+for i, c in myString:       # Индекс и символ. Или `for j in` только для символов
+  if i mod 2 == 0: continue # Компактная форма `if`
+  elif c == 'X': break
+  else: echo(c)
+
+#
+# Процедуры
+#
+
+type Answer = enum aYes, aNo
+
+proc ask(question: string): Answer =
+  echo(question, " (y/n)")
+  while true:
+    case readLine(stdin)
+    of "y", "Y", "yes", "Yes":
+      return Answer.aYes  # Перечисления могут быть квалифицированы
+    of "n", "N", "no", "No":
+      return Answer.aNo
+    else: echo("Please be clear: yes or no")
+
+proc addSugar(amount: int = 2) = # Значение поумолчанию 2, ничего не возвращает
+  assert(amount > 0 and amount < 9000, "Crazy Sugar")
+  for a in 1..amount:
+    echo(a, " sugar...")
+
+case ask("Would you like sugar in your tea?")
+of aYes:
+  addSugar(3)
+of aNo:
+  echo "Oh do take a little!"
+  addSugar()
+# Здесь нет необходимости в `else`. Возможны только `yes` и `no`.
+
+#
+# FFI (интерфейс внешних функций)
+#
+
+# Так как Nim компилируется в C, то FFI делается очень просто:
+
+proc strcmp(a, b: cstring): cint {.importc: "strcmp", nodecl.}
+
+let cmp = strcmp("C?", "Easy!")
+```
+
+Кроме того, Nim выделяется среди себе подобных метапрограммированием,
+производительностью, функциями этапа компиляции.
+
+## Дальнейшее чтение (EN)
+
+* [Домашняя страница](http://nim-lang.org)
+* [Скачать](http://nim-lang.org/download.html)
+* [Сообщество](http://nim-lang.org/community.html)
+* [FAQ](http://nim-lang.org/question.html)
+* [Документация](http://nim-lang.org/documentation.html)
+* [Руководство](http://nim-lang.org/docs/manual.html)
+* [Стандартная библиотека](http://nim-lang.org/docs/lib.html)
+* [Rosetta Code](http://rosettacode.org/wiki/Category:Nim)
diff --git a/ru-ru/php-ru.html.markdown b/ru-ru/php-ru.html.markdown
index 37b6a86e..181368de 100644
--- a/ru-ru/php-ru.html.markdown
+++ b/ru-ru/php-ru.html.markdown
@@ -32,7 +32,7 @@ print('Hello '); // Напечатать "Hello " без перевода стр
 
 // () необязательно применять для print и echo
 echo "World\n"; // Напечатать "World" и перейти на новую строку.
-// (все утверждения должны заканчиваться ;)
+// (все утверждения должны заканчиваться точкой с запятой)
 
 // Любые символы за пределами закрывающего тега выводятся автоматически:
 ?>
@@ -45,8 +45,8 @@ Hello World Again!
  */
 
 // Переменные начинаются с символа $.
-// Правильное имя переменной начинается с буквы или знака подчеркивания,
-// и может содержать любые цифры, буквы, или знаки подчеркивания.
+// Правильное имя переменной начинается с буквы или символа подчеркивания,
+// за которым следует любое количество букв, цифр или символов подчеркивания.
 // Не рекомендуется использовать кириллические символы в именах (прим. пер.)
 
 // Логические значения нечувствительны к регистру
@@ -55,10 +55,13 @@ $boolean = false; // или FALSE или False
 
 // Целые числа
 $int1 = 12;   // => 12
-$int2 = -12;  // => -12-
+$int2 = -12;  // => -12
 $int3 = 012;  // => 10 (ведущий 0 обозначает восьмеричное число)
 $int4 = 0x0F; // => 15 (ведущие символы 0x означают шестнадцатеричное число)
 
+// Двоичная запись integer доступна начиная с PHP 5.4.0.
+$int5 = 0b11111111; // 255 (0b в начале означает двоичное число)
+
 // Дробные числа
 $float = 1.234;
 $float = 1.2e3;
@@ -87,7 +90,9 @@ $dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
 $escaped   = "This contains a \t tab character.";
 $unescaped = 'This just contains a slash and a t: \t';
 
-// Заключайте переменные в фигурные скобки если это необходимо
+// Заключайте переменные в фигурные скобки, если это необходимо
+$apples = "I have {$number} apples to eat.";
+$oranges = "I have ${number} oranges to eat.";
 $money = "I have $${number} in the bank.";
 
 // Начиная с PHP 5.3, синтаксис nowdocs может использоваться для
@@ -106,6 +111,9 @@ END;
 // Строки соединяются при помощи .
 echo 'This string ' . 'is concatenated';
 
+// echo можно передавать строки как параметры
+echo 'Multiple', 'Parameters', 'Valid'; // печатает 'MultipleParametersValid'
+
 
 /********************************
  * Константы
@@ -114,18 +122,19 @@ echo 'This string ' . 'is concatenated';
 // Константа определяется при помощи define()
 // и никогда не может быть изменена во время выполнения программы!
 
-// Правильное имя константы начинается с буквы или символа подчеркивания,
-// и содержит любое колличество букв, цифр и знаков подчеркивания.
+// Правильное имя константы начинается с буквы или символа подчеркивания
+// и содержит любое колличество букв, цифр или символов подчеркивания.
 define("FOO", "something");
 
-// Доступ к константе возможен через прямое указание её имени
-echo 'This outputs '.FOO;
+// Доступ к константе возможен через прямое указание её имени без знака $
+echo FOO; // печатает 'something'
+echo 'This outputs ' . FOO; // печатает 'This ouputs something'
 
 /********************************
  * Массивы
  */
 
-// Все массивы в PHP - это ассоциативные массивы или хеши,
+// Все массивы в PHP - это ассоциативные массивы
 
 // Ассоциативные массивы, известные в других языках как HashMap.
 
@@ -136,11 +145,20 @@ $associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
 $associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
 
 echo $associative['One']; // печатает 1
+// Добавить элемент в ассоциативный массив
+$associative['Four'] = 4;
+
 
 // Список тоже содержит целочисленные ключи
 $array = ['One', 'Two', 'Three'];
 echo $array[0]; // => "One"
 
+// Добавить элемент в конец массива
+$array[] = 'Four';
+// или
+array_push($array, 'Five');
+// удалить элемент из массива
+unset($array[3]);
 
 /********************************
  * Вывод
@@ -180,6 +198,10 @@ $y = 0;
 echo $x; // => 2
 echo $z; // => 0
 
+// Вывести тип и значение переменной в stdout
+var_dump($z); // печатает int(0)
+// Напечатать переменную в stdout в удобочитаемом виде
+print_r($array); // печатает: Array ( [0] => One [1] => Two [2] => Three )
 
 /********************************
  * Логические выражения
@@ -189,7 +211,7 @@ $b = '0';
 $c = '1';
 $d = '1';
 
-// Утверждение (assert) выдает предупреждение если аргумент не true
+// Утверждение (assert) выдает предупреждение, если его аргумент не true
 
 // Эти сравнения всегда будут истинными, даже если типы будут различаться
 assert($a == $b); // "равно"
@@ -200,12 +222,21 @@ assert($c > $b); // больше
 assert($a <= $b); // меньше или равно
 assert($c >= $d); // больше или равно
 
-// Следующие утверждения истинны, если переменные имеют одинаковый тип.
+// Следующие утверждения истинны, если переменные имеют одинаковые тип.
 assert($c === $d);
 assert($a !== $d);
 assert(1 == '1');
 assert(1 !== '1');
 
+// 'Spaceship' оператор (с PHP 7) используется для сравнения двух выражений.
+// Возвращает -1, 0 или 1, когда выражение слева меньше, равно или больше
+// выражения справа.
+$a = 100;
+$b = 1000;
+
+echo $a <=> $a; // 0, выражения равны
+echo $a <=> $b; // -1, $a < $b
+echo $b <=> $a; // 1, $b > $a
 // Переменные могут изменять тип в зависимости от их использования.
 $integer = 1;
 echo $integer + $integer; // => 2
@@ -261,6 +292,11 @@ if (false) {
 // Тернарный оператор
 print (false ? 'Does not get printed' : 'Does');
 
+// сокращенная запись тернарного оператора с PHP 5.3
+// эквивалентно "$x ? $x : 'Does'"
+$x = false;
+print($x ?: 'Does');
+
 $x = 0;
 if ($x === '0') {
     print 'Does not print';
@@ -284,35 +320,35 @@ This is displayed otherwise.
 // Использование switch.
 switch ($x) {
     case '0':
-        print 'Switch does type coercion';
-        break; // You must include a break, or you will fall through
-               // to cases 'two' and 'three'
+        print 'Switch использует неточное сравнение';
+        break; // вы должны использовать break, иначе PHP будет продолжать
+               // исполнять команды следующих секций case 'two' и 'three'
     case 'two':
     case 'three':
-        // Do something if $variable is either 'two' or 'three'
+        // делаем что-то, если $x == 'two' или $x == 'three'
         break;
     default:
-        // Do something by default
+        // делаем что-то по умолчанию
 }
 
 // Циклы: while, do...while и for
 $i = 0;
 while ($i < 5) {
     echo $i++;
-}; // Prints "01234"
+}; // печатает "01234"
 
 echo "\n";
 
 $i = 0;
 do {
     echo $i++;
-} while ($i < 5); // Prints "01234"
+} while ($i < 5); // печатает "01234"
 
 echo "\n";
 
 for ($x = 0; $x < 10; $x++) {
     echo $x;
-} // Напечатает "0123456789"
+} // печатает "0123456789"
 
 echo "\n";
 
@@ -335,17 +371,17 @@ echo "\n";
 $i = 0;
 while ($i < 5) {
     if ($i === 3) {
-        break; // Exit out of the while loop
+        break; // выйти из цикла while
     }
     echo $i++;
 } // Напечатает "012"
 
 for ($i = 0; $i < 5; $i++) {
     if ($i === 3) {
-        continue; // Skip this iteration of the loop
+        continue; // пропустить текущую итерацию цикла
     }
     echo $i;
-} // Напечатает "0124"
+} // печатает "0124"
 
 
 /********************************
@@ -360,7 +396,7 @@ function my_function () {
 echo my_function(); // => "Hello"
 
 // Правильное имя функции начинается с буквы или символа подчеркивания
-// и состоит из букв, цифр или знаков подчеркивания.
+// и состоит из букв, цифр или символов подчеркивания.
 
 function add ($x, $y = 1) { // $y по умолчанию равно 1
   $result = $x + $y;
@@ -447,7 +483,7 @@ $value = include 'my-include.php';
 
 class MyClass
 {
-    const MY_CONST      = 'value'; // A constant
+    const MY_CONST      = 'value'; // Константа
 
     static $staticVar   = 'static';
 
@@ -651,12 +687,167 @@ use My\Namespace as SomeOtherNamespace;
 
 $cls = new SomeOtherNamespace\MyClass();
 
+*//**********************
+* Позднее статическое связывание.
+*
+*/
+
+class ParentClass
+{
+    public static function who()
+    {
+        echo "I'm a " . __CLASS__ . "\n";
+    }
+
+    public static function test()
+    {
+        // self ссылается на класс в котором определен метод.
+        self::who();
+        // static ссылается на класс в котором метод вызван.
+        static::who();
+    }
+}
+
+ParentClass::test();
+/*
+I'm a ParentClass
+I'm a ParentClass
+*/
+
+class ChildClass extends ParentClass
+{
+    public static function who()
+    {
+        echo "But I'm " . __CLASS__ . "\n";
+    }
+}
+
+ChildClass::test();
+/*
+I'm a ParentClass
+But I'm ChildClass
+
+/**********************
+* Позднее статическое связывание.
+*
+*/
+
+class ParentClass
+{
+    public static function who()
+    {
+        echo "I'm a " . __CLASS__ . "\n";
+    }
+
+    public static function test()
+    {
+        // self ссылается на класс в котором определен метод.
+        self::who();
+        // static ссылается на класс в котором метод вызван.
+        static::who();
+    }
+}
+
+ParentClass::test();
+/*
+I'm a ParentClass
+I'm a ParentClass
+*/
+
+class ChildClass extends ParentClass
+{
+    public static function who()
+    {
+        echo "But I'm " . __CLASS__ . "\n";
+    }
+}
+
+ChildClass::test();
+/*
+I'm a ParentClass
+But I'm ChildClass
+*/
+
+
+/**********************
+*  Магические константы
+*
+*/
+
+// Возвращает имя текущего класса. Должно быть использовано внутри класса.
+echo "Current class name is " . __CLASS__;
+
+// Возвращает полный путь текущей папки из которой вызван файл.
+echo "Current directory is " . __DIR__;
+
+    // Обычно используют в таких случаях:
+    require __DIR__ . '/vendor/autoload.php';
+
+// Возвращает полный путь к текущему файлу.
+echo "Current file path is " . __FILE__;
+
+// Возвращает имя текущей функции.
+echo "Current function name is " . __FUNCTION__;
+
+// Возвращает номер текущей линии.
+echo "Current line number is " . __LINE__;
+
+// Возвращает имя текущего метода. Возвращает только если вызван внутри метода.
+echo "Current method is " . __METHOD__;
+
+// Возвращает имя текущего пространства имен.
+echo "Current namespace is " . __NAMESPACE__;
+
+// Возвращает имя текущего трейта.
+// Возвращает только если испольщуется внутри трейта.
+echo "Current namespace is " . __TRAIT__;
+
+
+/**********************
+*  Обработка ошибок
+*  
 */
 
+// Простую обработку ошибок можно произвести спомощью try catch блока.
+
+try {
+    // Выполняем что-то
+} catch (Exception $e) {
+    // Обработка исключения
+}
+
+// При использовании try catch блока в области вилимости, стоит использовать
+// следующий подход:
+
+try {
+    // Do something
+} catch (\Exception $e) {
+    // Обработка исключения
+}
+
+// Специальное(кастомное) исключение - exceptions
+
+class MyException extends Exception {}
+
+try {
+
+    $condition = true;
+
+    if ($condition) {
+        throw new MyException('Something just happend');
+    }
+
+} catch (MyException $e) {
+    // Обработка исключения
+}
+
 ```
 
 ## Смотрите также:
-Посетите страницу [официальной документации PHP](http://www.php.net/manual/) для справки. 
+Посетите страницу [официальной документации PHP](http://www.php.net/manual/) для справки.
+
 Если вас интересуют полезные приемы использования PHP посетите [PHP The Right Way](http://www.phptherightway.com/).
+
 Если вы раньше пользовались языком с хорошей организацией пакетов, посмотрите [Composer](http://getcomposer.org/).
-Для изучения стандартов использования языка посетите PHP Framework Interoperability Group's [PSR standards](https://github.com/php-fig/fig-standards). 
+
+Для изучения стандартов использования языка посетите PHP Framework Interoperability Group's [PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/ru-ru/pyqt-ru.html.markdown b/ru-ru/pyqt-ru.html.markdown
new file mode 100644
index 00000000..24afc03d
--- /dev/null
+++ b/ru-ru/pyqt-ru.html.markdown
@@ -0,0 +1,86 @@
+---
+category: tool
+tool: PyQT
+lang: ru-ru
+filename: learnpyqt-ru.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Vadim Toptunov", "https://github.com/VadimToptunov"]
+---
+
+**Qt** - широко известный кросс-платформенный фреймворк для разработки программного обеспечения,
+который может быть использован на различных софтварных и хардварных платформах без какого-либо
+изменения в коде. Данный фреймворк при этом обладает мощью и скоростью нативных приложений. 
+Qt и был изначально написан на *C++*.
+
+Данный текст является адаптацией введения в Qt на C++ под авторством Алексея Ковальчука для pyqt.
+
+
+```python
+
+def window():
+    # Создайте объект приложения 
+    app = QtGui.QApplication(sys.argv)
+    # Создайте виджет, где будет находиться наш лейбл
+    w = QtGui.QWidget()
+    # Добавьте лейбл в виджет
+    b = QtGui.QLabel(w)
+    # Задайте текст для лейбла
+    b.setText("Hello World!")
+    # Задайте информация о размере и расположении 
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+    # Задайте заголовок окна 
+    w.setWindowTitle("PyQt")
+    # Все ранее написанное выводится на экран
+    w.show()
+    # Настройка
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Для того, чтобы получить более продвинутые функции приложения в pyqt, нам необходимо 
+обратить внимание на создание дополнительных элементов. Ниже представлено создание всплывающего диалогового окна, которое просит пользователя подтвердить его решение или предоставить какую-либо 
+информацию.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Создайте кнопку и прикрепите ее к виджету w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Укажите b вызвать эту функцию при клике мышкой
+    # Заметьте, что в вызове функции отсутствуют "()"
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+
+Данная функция должна создавать диалоговое окно с кнопкой, которая ждет клика по себе 
+и затем завершает программу.
+
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Эта модальность сообщает всплывающему окну блокировать родительский элемент, пока он активен
+    d.setWindowModality(Qt.ApplicationModal)
+    # Процесс завершается по клику мышкой
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/ru-ru/qt-ru.html.markdown b/ru-ru/qt-ru.html.markdown
new file mode 100644
index 00000000..d0a70c9d
--- /dev/null
+++ b/ru-ru/qt-ru.html.markdown
@@ -0,0 +1,158 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-ru.cpp
+contributors:
+    - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+    - ["Evan K.", "https://github.com/justblah"]
+lang: ru-ru
+---
+
+**Qt** является широко известным фреймворком для разработки кросс-платформенного программного обеспечения, которое может быть запущено на различных программно-аппаратных платформах практически без изменений в коде, сохраняя при этом мощность и скорость нативных приложений. Хоть **Qt** и был изначально написан на *C++*, у него есть реализации и на других языках: *PyQt*, *QtRuby*, *PHP-Qt* и т.д.
+
+**Qt** отлично подходит для создания приложений с графическим пользовательским интерфейсом (GUI). Это руководство о том, как сделать это на *C++*.
+
+```c++
+/*
+ * Начнём по-старинке
+ */
+
+// все header файлы импортированные из Qt начинаются с заглавной 'Q'
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+    // создаем объект для управления данными приложения
+    QApplication app(argc, argv);
+
+    // создаем редактируемую строку и отобразим её на экране
+    QLineEdit lineEdit("Hello world!");
+    lineEdit.show();
+
+    // запускаем цикл для обработки событий (event loop)
+    return app.exec();
+}
+```
+
+GUI часть **Qt** полностью состоит из *виджетов* и *связей* между ними.
+
+[(EN) ПОДРОБНЕЕ О ВИДЖЕТАХ](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * В этом примере мы отобразим надпись с кнопкой.
+ * Надпись будет появляться после нажатия на кнопку.
+ *
+ * Код на Qt говорит сам за себя.
+ */
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    // добавляем вертикальное расположение
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);  
+
+    QLabel textLabel("Thanks for pressing that button");
+    layout.addWidget(&textLabel);
+    textLabel.hide();
+
+    QPushButton button("Press me");
+    layout.addWidget(&button);
+
+    // отображаем скрытую надпись после нажатия на кнопку
+    QObject::connect(&button, &QPushButton::pressed,
+                     &textLabel, &QLabel::show);
+
+    return app.exec();
+}
+```
+Обратите внимание на метод *QObject::connect*. Этот метод соединяет *СИГНАЛЫ* одного объекта со *СЛОТАМИ* другого.
+
+**Сигналы** отправляются когда с объектами происходят отпределённые события, например, сигнал *нажатие* отправляется когда пользователь нажимает на объект типа QPushButton.
+
+**Слоты** это *действия*, которые могут быть выполнены в ответ на полученные сигналы.
+
+[(EN) ПОДРОБНЕЕ О СЛОТАХ И СИГНАЛАХ](http://doc.qt.io/qt-4.8/signalsandslots.html)
+
+
+Далее рассмотрим, как можно не только использовать стандартные виджеты, но и расширять их поведение с помощью наследования. Давайте создадим кнопку и посчитаем, сколько раз она была нажата. Для этого мы определяем наш собственный класс *CounterLabel*. Он должен быть объявлен в отдельном файле из-за специфической архитектуры Qt.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+    Q_OBJECT  // макрос Qt, обязателен для всех виджетов
+
+public:
+    CounterLabel() : counter(0) {
+        setText("Counter has not been increased yet");  // метод QLabel
+    }
+
+public slots:
+    // действие, которое будет вызвано в ответ на нажатие
+    void increaseCounter() {
+        setText(QString("Counter value: %1").arg(QString::number(++counter)));
+    }
+
+private:
+    int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// Почти тоже самое, что и в предыдущем примере
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);
+
+    CounterLabel counterLabel;
+    layout.addWidget(&counterLabel);
+
+    QPushButton button("Push me once more");
+    layout.addWidget(&button);
+    QObject::connect(&button, &QPushButton::pressed,
+                     &counterLabel, &CounterLabel::increaseCounter);
+
+    return app.exec();
+}
+```
+
+## На почитать
+Это всё! Конечно, фреймворк Qt намного объемнее, чем часть, которая была рассмотрена в этом руководстве, так что будьте готовы читать и практиковаться.
+
+[(EN) ДОКУМЕНТАЦИЯ](http://wiki.qt.io/Main/ru)
+
+Удачи!
diff --git a/ru-ru/swift-ru.html.markdown b/ru-ru/swift-ru.html.markdown
index 77987bb3..7ff660e1 100644
--- a/ru-ru/swift-ru.html.markdown
+++ b/ru-ru/swift-ru.html.markdown
@@ -4,9 +4,11 @@ contributors:
   - ["Grant Timmerman", "http://github.com/grant"]
   - ["Christopher Bess", "http://github.com/cbess"]
   - ["Joey Huang", "http://github.com/kamidox"]
+  - ["Alexey Nazaroff", "http://github.com/rogaven"]
 filename: learnswift-ru.swift
 translators:
   - ["Dmitry Bessonov", "https://github.com/TheDmitry"]
+  - ["Alexey Nazaroff", "https://github.com/rogaven"]
 lang: ru-ru
 ---
 
@@ -21,6 +23,8 @@ Swift - это язык программирования, созданный к�
 Смотрите еще [начальное руководство](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html) Apple, которое содержит полное учебное пособие по Swift.
 
 ```swift
+// Версия Swift: 3.0
+
 // импорт модуля
 import UIKit
 
@@ -31,10 +35,14 @@ import UIKit
 // Xcode поддерживает маркеры, чтобы давать примечания своему коду
 // и вносить их в список обозревателя (Jump Bar)
 // MARK: Метка раздела
+// MARK: - Метка с разделителем
 // TODO: Сделайте что-нибудь вскоре
 // FIXME: Исправьте этот код
 
-println("Привет, мир")
+// Начиная со второй версии Swift, println и print объединены в методе print.
+// Перенос строки теперь добавляется в конец автоматически.
+print("Привет, мир!") // println – теперь просто print
+print("Привет, мир!", terminator: "") // вывод текста без переноса строки
 
 // переменные (var), значение которых можно изменить после инициализации
 // константы (let), значение которых нельзя изменить после инициализации
@@ -56,12 +64,12 @@ let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Вставка переменны
 // Сборка особых значений
 // используя ключ -D сборки конфигурации
 #if false
-    println("Не печатается")
+    print("Не печатается")
     let buildValue = 3
 #else
     let buildValue = 7
 #endif
-println("Значение сборки: \(buildValue)") // Значение сборки: 7
+print("Значение сборки: \(buildValue)") // Значение сборки: 7
 
 /*
     Опционалы - это особенность языка Swift, которая допускает вам сохранять
@@ -79,35 +87,45 @@ var someOptionalString2: Optional<String> = "опционал"
 if someOptionalString != nil {
     // я не nil
     if someOptionalString!.hasPrefix("opt") {
-        println("содержит префикс")
+        print("содержит префикс")
     }
-    
+
     let empty = someOptionalString?.isEmpty
 }
 someOptionalString = nil
 
+/*
+Использование ! для доступа к несуществующему опциональному значению генерирует
+рантайм ошибку. Всегда проверяйте, что опционал содержит не пустое значение,
+перед тем как раскрывать его через !.
+*/
+
 // неявная развертка опциональной переменной
 var unwrappedString: String! = "Ожидаемое значение."
 // как и выше, только ! - постфиксный оператор (с еще одним синтаксическим сахаром)
 var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Ожидаемое значение."
 
+// If let конструкции -
+// If let это специальная конструкция в Swift, которая позволяет проверить Optional
+// справа от `=` непустой, и если это так - разворачивает его и присваивает левой части.
 if let someOptionalStringConstant = someOptionalString {
-    // имеется некоторое значение, не nil
+    // имеется некоторое (`Some`) значение, не `nil`
     if !someOptionalStringConstant.hasPrefix("ok") {
         // нет такого префикса
     }
 }
 
 // Swift поддерживает сохранение значения любого типа
+// Для этих целей есть два ключевых слова `Any` и `AnyObject`
 // AnyObject == id
-// В отличие от `id` в Objective-C, AnyObject работает с любым значением (Class,
-// Int, struct и т.д.)
-var anyObjectVar: AnyObject = 7
-anyObjectVar = "Изменять значение на строку не является хорошей практикой, но возможно."
+// `Any` же, в отличие от `id` в Objective-C, `Any` работает с любым значением (Class, Int, struct и т.д.)
+var anyVar: Any = 7
+anyVar = "Изменять значение на строку не является хорошей практикой, но возможно."
+let anyObjectVar: AnyObject = Int(1) as NSNumber
 
 /*
     Комментируйте здесь
-    
+
     /*
         Вложенные комментарии тоже поддерживаются
     */
@@ -129,6 +147,7 @@ shoppingList[1] = "бутылка воды"
 let emptyArray = [String]() // let == неизменный
 let emptyArray2 = Array<String>() // как и выше
 var emptyMutableArray = [String]() // var == изменяемый
+var explicitEmptyMutableStringArray: [String] = [] // так же как и выше
 
 
 // Словарь
@@ -140,31 +159,39 @@ occupations["Jayne"] = "Связи с общественностью"
 let emptyDictionary = [String: Float]() // let == неизменный
 let emptyDictionary2 = Dictionary<String, Float>() // как и выше
 var emptyMutableDictionary = [String: Float]() // var == изменяемый
+var explicitEmptyMutableDictionary: [String: Float] = [:] // то же
 
 
 //
 // MARK: Поток управления
 //
 
+// С помощью "," можно указать дополнительные условия для раскрытия
+// опциональных значений.
+let someNumber = Optional<Int>(7)
+if let num = someNumber, num > 3 {
+    print("Больше 3х")
+}
+
 // цикл for для массива
 let myArray = [1, 1, 2, 3, 5]
 for value in myArray {
     if value == 1 {
-        println("Один!")
+        print("Один!")
     } else {
-        println("Не один!")
+        print("Не один!")
     }
 }
 
 // цикл for для словаря
 var dict = ["один": 1, "два": 2]
 for (key, value) in dict {
-    println("\(key): \(value)")
+    print("\(key): \(value)")
 }
 
 // цикл for для диапазона чисел
 for i in -1...shoppingList.count {
-    println(i)
+    print(i)
 }
 shoppingList[1...2] = ["бифштекс", "орехи пекан"]
 // используйте ..< для исключения последнего числа
@@ -176,8 +203,8 @@ while i < 1000 {
 }
 
 // цикл do-while
-do {
-    println("привет")
+repeat {
+    print("привет")
 } while 1 == 2
 
 // Переключатель
@@ -204,7 +231,7 @@ default: // обязательный (чтобы предусмотреть вс
 // Функции являются типом первого класса, т.е. они могут быть вложены в функциях
 // и могут передаваться между собой
 
-// Функция с документированным заголовком Swift (формат reStructedText)
+// Функция с документированным заголовком Swift (формат Swift-модифицированный Markdown)
 
 /**
     Операция приветствия
@@ -212,20 +239,20 @@ default: // обязательный (чтобы предусмотреть вс
     - Маркер в документировании
     - Еще один маркер в документации
 
-    :param: name - это имя
-    :param: day - это день
-    :returns: Строка, содержащая значения name и day.
+    - Parameter name	: Это имя
+    - Parameter day	: Это день
+    - Returns : Строка, содержащая значения name и day.
 */
 func greet(name: String, day: String) -> String {
     return "Привет \(name), сегодня \(day)."
 }
-greet("Боб", "вторник")
+greet(name: "Боб", day: "вторник")
 
 // как и выше, кроме обращения параметров функции
-func greet2(#requiredName: String, externalParamName localParamName: String) -> String {
-    return "Привет \(requiredName), сегодня \(localParamName)"
+func greet2(name: String, externalParamName localParamName: String) -> String {
+    return "Привет \(name), сегодня \(localParamName)"
 }
-greet2(requiredName:"Иван", externalParamName: "воскресенье")
+greet2(name: "Иван", externalParamName: "Воскресенье")
 
 // Функция, которая возвращает множество элементов в кортеже
 func getGasPrices() -> (Double, Double, Double) {
@@ -235,8 +262,31 @@ let pricesTuple = getGasPrices()
 let price = pricesTuple.2 // 3.79
 // Пропускайте значения кортежей с помощью подчеркивания _
 let (_, price1, _) = pricesTuple // price1 == 3.69
-println(price1 == pricesTuple.1) // вывод: true
-println("Цена газа: \(price)")
+print(price1 == pricesTuple.1) // вывод: true
+print("Цена газа: \(price)")
+
+// Именованные параметры кортежа
+func getGasPrices2() -> (lowestPrice: Double, highestPrice: Double, midPrice: Double) {
+    return (1.77, 37.70, 7.37)
+}
+let pricesTuple2 = getGasPrices2()
+let price2 = pricesTuple2.lowestPrice
+let (_, price3, _) = pricesTuple2
+print(pricesTuple2.highestPrice == pricesTuple2.1) // вывод: true
+print("Самая высокая цена за газ: \(pricesTuple2.highestPrice)")
+
+// guard утверждения
+func testGuard() {
+    // guards обеспечивают прерывание дальнейшего выполнения функции,
+    // позволяя держать обработчики ошибок рядом с проверкой условия
+    // Объявляемая переменная находится в той же области видимости, что и guard.
+    guard let aNumber = Optional<Int>(7) else {
+        return
+    }
+
+    print("число равно \(aNumber)")
+}
+testGuard()
 
 // Переменное число аргументов
 func setup(numbers: Int...) {
@@ -246,7 +296,7 @@ func setup(numbers: Int...) {
 }
 
 // Передача и возврат функций
-func makeIncrementer() -> (Int -> Int) {
+func makeIncrementer() -> ((Int) -> Int) {
     func addOne(number: Int) -> Int {
         return 1 + number
     }
@@ -256,15 +306,15 @@ var increment = makeIncrementer()
 increment(7)
 
 // передача по ссылке
-func swapTwoInts(inout a: Int, inout b: Int) {
+func swapTwoInts(a: inout Int, b: inout Int) {
     let tempA = a
     a = b
     b = tempA
 }
 var someIntA = 7
 var someIntB = 3
-swapTwoInts(&someIntA, &someIntB)
-println(someIntB) // 7
+swapTwoInts(a: &someIntA, b: &someIntB)
+print(someIntB) // 7
 
 
 //
@@ -291,13 +341,13 @@ numbers = numbers.map({ number in 3 * number })
 print(numbers) // [3, 6, 18]
 
 // Хвостовое замыкание
-numbers = sorted(numbers) { $0 > $1 }
+numbers = numbers.sorted { $0 > $1 }
 
 print(numbers) // [18, 6, 3]
 
 // Суперсокращение, поскольку оператор < выполняет логический вывод типов
 
-numbers = sorted(numbers, < )
+numbers = numbers.sorted(by: <)
 
 print(numbers) // [3, 6, 18]
 
@@ -307,8 +357,8 @@ print(numbers) // [3, 6, 18]
 
 // Структуры и классы имеют очень похожие характеристики
 struct NamesTable {
-    let names = [String]()
-    
+    let names: [String]
+
     // Пользовательский индекс
     subscript(index: Int) -> String {
         return names[index]
@@ -316,9 +366,48 @@ struct NamesTable {
 }
 
 // У структур автогенерируемый (неявно) инициализатор
-let namesTable = NamesTable(names: ["Me", "Them"])
+let namesTable = NamesTable(names: ["Иван", "Яков"])
 let name = namesTable[1]
-println("Name is \(name)") // Name is Them
+print("Имя :\(name)") // Имя: Яков
+
+//
+// MARK: Обработка ошибок
+//
+
+// Протокол `Error` используется для перехвата выбрасываемых ошибок
+enum MyError: Error {
+    case BadValue(msg: String)
+    case ReallyBadValue(msg: String)
+}
+
+// фунции помеченные словом `throws` должны вызываться с помощью `try`
+func fakeFetch(value: Int) throws -> String {
+    guard 7 == value else {
+        throw MyError.ReallyBadValue(msg: "Действительно плохое значение")
+    }
+
+    return "тест"
+}
+
+func testTryStuff() {
+    // предполагается, что не будет выброшено никаких ошибок,
+    // в противном случае мы получим рантайм исключение
+    let _ = try! fakeFetch(value: 7)
+
+    // Если возникает ошибка, то выполнение продолжится. Но если значение равно nil,
+    // то результат будет опционалом
+    let _ = try? fakeFetch(value: 7)
+
+    do {
+        // обычно try оператор, позволяющий обработать ошибку в `catch` блоке
+        try fakeFetch(value: 1)
+    } catch MyError.BadValue(let msg) {
+        print("Ошибка: \(msg)")
+    } catch {
+        // все остальное
+    }
+}
+testTryStuff()
 
 //
 // MARK: Классы
@@ -329,7 +418,7 @@ println("Name is \(name)") // Name is Them
 
 public class Shape {
     public func getArea() -> Int {
-        return 0;
+        return 0
     }
 }
 
@@ -339,7 +428,7 @@ public class Shape {
 
 internal class Rect: Shape {
     var sideLength: Int = 1
-    
+
     // Пользовательский сеттер и геттер
     private var perimeter: Int {
         get {
@@ -350,12 +439,17 @@ internal class Rect: Shape {
             sideLength = newValue / 4
         }
     }
-    
+
+    // Вычисляемые свойства должны быть объявлены с помощью `var`, ведь они могут меняться
+    var smallestSideLength: Int {
+        return self.sideLength - 1
+    }
+
     // Ленивая загрузка свойства
     // свойство subShape остается равным nil (неинициализированным),
     // пока не вызовется геттер
     lazy var subShape = Rect(sideLength: 4)
-    
+
     // Если вам не нужны пользовательские геттеры и сеттеры,
     // но все же хотите запустить код перед и после вызовов геттера или сеттера
     // свойств, вы можете использовать `willSet` и `didSet`
@@ -365,19 +459,19 @@ internal class Rect: Shape {
             print(someIdentifier)
         }
     }
-    
+
     init(sideLength: Int) {
         self.sideLength = sideLength
         // последним всегда вызывается super.init, когда init с параметрами
         super.init()
     }
-    
+
     func shrink() {
         if sideLength > 0 {
-            --sideLength
+            sideLength -= 1
         }
     }
-    
+
     override func getArea() -> Int {
         return sideLength * sideLength
     }
@@ -400,7 +494,7 @@ let aShape = mySquare as Shape
 
 // сравнение экземпляров, в отличие от ==, которая проверяет эквивалентность
 if mySquare === mySquare {
-    println("Ага, это mySquare")
+    print("Ага, это mySquare")
 }
 
 // Опциональная инициализация (init)
@@ -409,13 +503,13 @@ class Circle: Shape {
     override func getArea() -> Int {
         return 3 * radius * radius
     }
-    
+
     // Поместите постфиксный знак вопроса после `init` - это и будет опциональная инициализация,
     // которая может вернуть nil
     init?(radius: Int) {
         self.radius = radius
         super.init()
-        
+
         if radius <= 0 {
             return nil
         }
@@ -423,13 +517,13 @@ class Circle: Shape {
 }
 
 var myCircle = Circle(radius: 1)
-println(myCircle?.getArea())    // Optional(3)
-println(myCircle!.getArea())    // 3
+print(myCircle?.getArea())    // Optional(3)
+print(myCircle!.getArea())    // 3
 var myEmptyCircle = Circle(radius: -1)
-println(myEmptyCircle?.getArea())    // "nil"
+print(myEmptyCircle?.getArea())    // "nil"
 if let circle = myEmptyCircle {
     // не будет выполняться, поскольку myEmptyCircle равен nil
-    println("circle не nil")
+    print("circle не nil")
 }
 
 
@@ -456,12 +550,13 @@ enum Suit {
 // указывать тип перечисления, когда переменная объявляется явно
 var suitValue: Suit = .Hearts
 
-// Нецелочисленные перечисления требуют прямого указания значений
+// Значения нецелочисленных перечислений должны быть указаны явно
+// или могут выводится с помощью функции `rawValue` из имени
 enum BookName: String {
-    case John = "Иоанн"
+    case John
     case Luke = "Лука"
 }
-println("Имя: \(BookName.John.rawValue)")
+print("Имя: \(BookName.John.rawValue)")
 
 // Перечисление (enum) со связанными значениями
 enum Furniture {
@@ -469,7 +564,7 @@ enum Furniture {
     case Desk(height: Int)
     // Связать с типами String и Int
     case Chair(String, Int)
-    
+
     func description() -> String {
         switch self {
         case .Desk(let height):
@@ -481,9 +576,9 @@ enum Furniture {
 }
 
 var desk: Furniture = .Desk(height: 80)
-println(desk.description())     // "Письменный стол высотой 80 см."
+print(desk.description())     // "Письменный стол высотой 80 см."
 var chair = Furniture.Chair("Foo", 40)
-println(chair.description())    // "Стул марки Foo высотой 40 см."
+print(chair.description())    // "Стул марки Foo высотой 40 см."
 
 
 //
@@ -500,23 +595,24 @@ protocol ShapeGenerator {
 }
 
 // Протоколы, объявленные с @objc, допускают необязательные функции,
-// которые позволяют вам проверять на соответствие
+// которые позволяют вам проверять на соответствие. Для функций также необходимо указать @objc
 @objc protocol TransformShape {
-    optional func reshaped()
-    optional func canReshape() -> Bool
+    @objc optional func reshape()
+    @objc optional func canReshape() -> Bool
 }
 
 class MyShape: Rect {
     var delegate: TransformShape?
-    
+
     func grow() {
         sideLength += 2
+
         // Размещайте знак вопроса перед опционным свойством, методом
         // или индексом, чтобы не учитывать nil-значение и возвратить nil
         // вместо выбрасывания ошибки выполнения (т.н. "опционная цепочка")
-        if let allow = self.delegate?.canReshape?() {
+        if let reshape = self.delegate?.canReshape?(), reshape {
             // проверка делегата на выполнение метода
-            self.delegate?.reshaped?()
+            self.delegate?.reshape?()
         }
     }
 }
@@ -528,42 +624,42 @@ class MyShape: Rect {
 
 // `extension`s: Добавляет расширенный функционал к существующему типу
 
-// Класс Square теперь "соответствует" протоколу `Printable`
-extension Square: Printable {
+// Класс Square теперь "соответствует" протоколу `CustomStringConvertible`
+extension Square: CustomStringConvertible {
     var description: String {
         return "Площадь: \(self.getArea()) - ID: \(self.identifier)"
     }
 }
 
-println("Объект Square: \(mySquare)")
+print("Объект Square: \(mySquare)")
 
 // Вы также можете расширить встроенные типы
 extension Int {
     var customProperty: String {
         return "Это \(self)"
     }
-    
+
     func multiplyBy(num: Int) -> Int {
         return num * self
     }
 }
 
-println(7.customProperty) // "Это 7"
-println(14.multiplyBy(3)) // 42
+print(7.customProperty) // "Это 7"
+print(14.multiplyBy(num: 3)) // 42
 
 // Обобщения: Подобно языкам Java и C#. Используйте ключевое слово `where`,
 // чтобы определить условия обобщений.
 
 func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
+    for (index, value) in array.enumerated() {
         if value == valueToFind {
             return index
         }
     }
     return nil
 }
-let foundAtIndex = findIndex([1, 2, 3, 4], 3)
-println(foundAtIndex == 2) // вывод: true
+let foundAtIndex = findIndex(array: [1, 2, 3, 4], valueToFind: 3)
+print(foundAtIndex == 2) // вывод: true
 
 // Операторы:
 // Пользовательские операторы могут начинаться с символов:
@@ -571,19 +667,33 @@ println(foundAtIndex == 2) // вывод: true
 // или
 // Unicode- знаков математики, символов, стрелок, декорации и линий/кубов,
 // нарисованных символов.
-prefix operator !!! {}
+prefix operator !!!
 
 // Префиксный оператор, который утраивает длину стороны, когда используется
-prefix func !!! (inout shape: Square) -> Square {
+prefix func !!! (shape: inout Square) -> Square {
     shape.sideLength *= 3
     return shape
 }
 
 // текущее значение
-println(mySquare.sideLength) // 4
+print(mySquare.sideLength) // 4
 
 // Используя пользовательский оператор !!!, изменится длина стороны
 // путем увеличения размера в 3 раза
 !!!mySquare
-println(mySquare.sideLength) // 12
+print(mySquare.sideLength) // 12
+
+// Операторы также могут быть обобщенными
+infix operator <->
+func <-><T: Equatable> (a: inout T, b: inout T) {
+    let c = a
+    a = b
+    b = c
+}
+
+var foo: Float = 10
+var bar: Float = 20
+
+foo <-> bar
+print("foo это \(foo), bar это \(bar)") // "foo = 20.0, bar = 10.0"
 ```
diff --git a/ru-ru/tmux-ru.html.markdown b/ru-ru/tmux-ru.html.markdown
new file mode 100644
index 00000000..aa7545cc
--- /dev/null
+++ b/ru-ru/tmux-ru.html.markdown
@@ -0,0 +1,252 @@
+---
+category: tool
+tool: tmux
+contributors:
+  - ["mdln", "https://github.com/mdln"]
+translators:
+  - ["Davydov Anton", "https://github.com/davydovanton"]
+filename: LearnTmux-ru.txt
+lang: ru-ru
+---
+
+[tmux](http://tmux.sourceforge.net) - терминальный мультиплексор.
+Он позволяет создавать, получать доступ и контролировать любое
+количество терминалов из единого окна.
+Сессия tmux также может быть свернута в фоновый режим, и она
+будет работать в фоне, а после к ней можно будет подключиться.
+
+
+```
+
+  tmux [command]     # Запуск команды 'tmux'
+                     # без какой-либо команды создаст новую сессию
+
+    new              # Создать новую сессию
+     -s "Session"    # Создать именованную сессию
+     -n "Window"     # Создать именованное окно
+     -c "/dir"       # Запустить сессию в конкретной директории
+
+    attach           # Подключиться к последней/существующей сессии
+     -t "№"          # Подключиться к определенной сессии
+     -d              # Завершить определенную сессию
+
+    ls               # Список открытых сессий
+     -a              # Список всех открытых сессий
+
+    lsw              # Список окон
+     -a              # Список всех окон
+     -s              # Список всех окон в сессии
+
+    lsp              # Список панелей
+     -a              # Список всех панелей
+     -s              # Список всех панелей в сессии
+     -t              # Список всех панелей для конкретного объекта
+
+    kill-window      # Закрыть текущее окно
+     -t "#"          # Закрыть конкретное окно
+     -a              # Закрыть все окна
+     -a -t "#"       # Закрыть все окна, кроме конкретного
+
+    kill-session     # Завершить текущую сессию
+     -t "#"          # Завершить конкретную сессию
+     -a              # Завершить все сессии
+     -a -t "#"       # Завершить все сессии, кроме конкретной
+
+```
+
+
+### "Горячие" клавиши
+
+Способ, с помощью которого контролируется любая tmux
+сессия, - комбинация клавиш, называемая 'Префиксом'.
+
+```
+----------------------------------------------------------------------
+  (C-b) = Ctrl + b    # 'Префикс' необходим для
+                      # использования горячих клавиш
+
+  (M-1) = Meta + 1 -или- Alt + 1
+----------------------------------------------------------------------
+
+  ?                    # Список всех горячих клавиш
+  :                    # Начать ввод в командной строке tmux
+  r                    # Принудительная перерисовка текущего клиента
+  c                    # Создать новое окно
+
+  !                    # Переместить текущую панель в отдельное окно
+  %                    # Разделить текущую панель на две: левую и правую
+  "                    # Разделить текущую панель на две: верхнюю и нижнюю
+
+  n                    # Переместиться на следующее окно
+  p                    # Переместиться на предыдущее окно
+  {                    # Заменить текущую панель на предыдущую
+  }                    # Заменить текущую панель на следующую
+
+  s                    # Интерактивный выбор запущенных сессий
+  w                    # Интерактивный выбор текущего окна
+  от 0 до 9            # Выбрать окно номер 0..9
+
+  d                    # Отключить текущий клиент
+  D                    # Выбрать клиент, который будет отключен
+
+  &                    # Закрыть текущее окно
+  x                    # Закрыть текущую панель
+
+  Стрелки вверх, вниз  # Переместиться на панель выше, ниже, левее
+  влево, вправо        # или правее
+
+  M-1 to M-5           # Расставить панели:
+                         # 1) выровнять по горизонтали
+                         # 2) выровнять по вертикали
+                         # 3) основное горизонтально
+                         # 4) основное вертикально
+                         # 5) мозаикой
+
+  C-Up, C-Down         # Изменение размера текущей панели с шагом в одну
+  C-Left, C-Right      # колонку
+
+  M-Up, M-Down         # Изменение размера текущей панели с шагом в пять
+  M-Left, M-Right      # колонок
+
+```
+
+
+### Настройка ~/.tmux.conf
+
+Файл tmux.conf может быть использован для автоматической установки
+опций при старте, как, например, .vimrc или init.el.
+
+```
+# Пример файла tmux.conf
+# 2014.10
+
+
+### Общее
+###########################################################################
+
+# Включить поддержку UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Установить лимит истории
+set -g history-limit 2048
+
+# Порядковый номер первой панели
+set -g base-index 1
+
+# Включить поддержку мыши
+set-option -g mouse-select-pane on
+
+# Принудительная перезагрузка конфигурационного файла
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Горячие клавиши
+###########################################################################
+
+# Отменить комбинацию C-b как стандартный префикс
+unbind C-b
+
+# Установить новую комбинацию как префикс
+set-option -g prefix `
+
+# Вернуть предыдущее окно, если префикс был нажат два раза
+bind C-a last-window
+bind ` last-window
+
+# Разрешить замену C-a и ` на F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Настройки клавиш
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Перемещение между панелями, как в vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Переключить/Заменить окно
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Комманды, упрощающие разделением панелей
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Активировать центральную сессию (когда вложенный tmux) для отправки команд
+bind a send-prefix
+
+
+### Цветовая схема
+###########################################################################
+
+# Цветовая палитра строки состояния
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Цветовая палитра окантовки панели
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Цветовая палитра сообщений
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Цветовая палитра статус окна
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### Интерфейс
+###########################################################################
+
+# Уведомления
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Автоматическая установка заголовка окна
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Настройки строки состояния
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Показывать системные характеристики в статусбаре
+# Требует https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+### Ссылки
+
+[Tmux | Домашняя страница](http://tmux.sourceforge.net)
+
+[Страница мануала Tmux](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Отображение CPU/MEM % в статусбаре](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
diff --git a/ru-ru/typescript-ru.html.markdown b/ru-ru/typescript-ru.html.markdown
new file mode 100644
index 00000000..09bbb2d1
--- /dev/null
+++ b/ru-ru/typescript-ru.html.markdown
@@ -0,0 +1,173 @@
+---
+language: TypeScript
+lang: ru-ru
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Fadil Mamedov", "https://github.com/fadilmamedov"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+filename: learntypescript-ru.ts
+---
+
+TypeScript — это язык программирования, целью которого является лёгкая разработка широкомасштабируемых JavaScript-приложений.
+TypeScript добавляет в Javascript общие концепции, такие, как классы, модули, интерфейсы, обобщённое программирование и (опционально) статическую типизацию.  
+Это надмножество языка JavaScript: весь JavaScript-код является валидным TypeScript-кодом, следовательно, может быть добавлен бесшовно в любой проект. 
+Компилятор TypeScript генерирует JavaScript-код.
+
+Эта статья концентрируется только на синтаксисе TypeScript, в противовес статье о [JavaScript](javascript-ru/).
+
+Для тестирования компилятора TypeScript пройдите по ссылке в [песочницу](http://www.typescriptlang.org/Playground). 
+Там вы можете написать код (с поддержкой автодополнения) и сразу же увидеть сгенерированный JavaScript код.
+
+```js
+// В TypeScript есть 3 базовых типа
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Андерс";
+
+// Тип «any» для случаев, когда заранее неизвестен тип переменной
+var notSure: any = 4;
+notSure = "а может быть, строка";
+notSure = false; // а теперь логический тип
+
+// Для коллекций есть типизированные массивы и обобщённые массивы
+var list: number[] = [1, 2, 3];
+// Как альтернатива, использование обобщённого массива
+var list: Array<number> = [1, 2, 3];
+
+// Перечисления:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Наконец, «void» используется для обозначения того, что функция ничего не возвращает
+function bigHorribleAlert(): void {
+  alert("Я маленькое надоедливое окошко!");
+}
+
+// Функции — это объекты первого класса. Они поддерживают лямбда-синтаксис (=>)
+// и используют вывод типов (type inference)
+
+// Следующие строки кода являются эквивалентными, компилятором предполагается
+// одинаковая сигнатура, на выходе генерируется одинаковый JavaScript-код
+var f1 = function(i: number): number { return i * i; }
+// Предполагается возвращаемый тип
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Предполагается возвращаемый тип
+var f4 = (i: number) => { return i * i; }
+// Предполагается возвращаемый тип, в однострочной функции ключевое слово «return» не нужно
+var f5 = (i: number) =>  i * i;
+
+// Интерфейсы являются структурными; всё, что имеет свойства, совместимо с интерфейсом
+interface Person {
+  name: string;
+  // Опциональные свойства, помеченные символом «?»
+  age?: number;
+  // И, конечно, функции
+  move(): void;
+}
+
+// Объект, который реализует интерфейс «Person»
+// К нему можно обращаться, как к «Person», так как он имеет свойства «name» и «move»
+var p: Person = { name: "Бобби", move: () => {} };
+// Объекты, которые могут иметь опциональные свойства:
+var validPerson: Person = { name: "Бобби", age: 42, move: () => {} };
+// Это не «Person», поскольку «age» не является числовым значением
+var invalidPerson: Person = { name: "Бобби", age: true };
+
+// Интерфейсы могут также описывать функциональный тип
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Важны только типы параметров, имена — нет.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Классы. Члены класса по умолчанию являются публичными
+class Point {
+  	// Свойства
+    x: number;
+
+    // Конструктор — ключевые слова public/private в данном контексте сгенерируют
+    // шаблонный код для свойства и для инициализации в конструкторе
+    // В данном примере «y» будет определён так же, как и «x», но меньшим количеством кода
+    // Значения по умолчанию также поддерживаются
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Функции
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Статические члены
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y будет равен 0
+
+// Наследование
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Явный вызов конструктора базового класса обязателен
+    }
+
+    // Перегрузка
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Модули, знак «.» может быть использован как разделитель для обозначения подмодулей
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Локальный псевдоним для ссылки на модуль
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Обобщённое программирование
+// Классы
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Интерфейсы
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// И функции
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Включение ссылки на файл определения:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Для дальнейшего чтения
+ * [Официальный веб-сайт TypeScript](http://www.typescriptlang.org/)
+ * [Спецификация языка TypeScript (pdf)](http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg — Introducing TypeScript на Channel 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Исходный код на GitHub](https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed — репозиторий определений типов](http://definitelytyped.org/)
diff --git a/ru-ru/vim-ru.html.markdown b/ru-ru/vim-ru.html.markdown
new file mode 100644
index 00000000..f43f99eb
--- /dev/null
+++ b/ru-ru/vim-ru.html.markdown
@@ -0,0 +1,241 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Anton Slukovskiy", "https://github.com/slukovskiy"]
+filename: LearnVim-ru.txt
+lang: ru-ru
+---
+
+[Vim](http://www.vim.org)
+(Vi IMproved) это клон полулярного текстового редактора для Unix. Он разработан
+с целью повышения скорости и продуктивности и повсеместно используется в 
+большинство Юникс-подобных систем. В нем имеется множество клавиатурных 
+сочетаний для быстрой навигации к определенным точкам в файле и быстрого 
+редактирования.
+
+## Основы навигации в vim
+
+```
+    vim <filename>   # Открыть <filename> в vim
+    :q               # Выйти из vim
+    :w               # Сохранить текущий файл
+    :wq              # Сохранить и выйти
+    :q!              # Выйти из vim не сохраняя файл
+
+    :x               # Сохранить файл и выйти из vim, короткая версия :wq
+
+    u                # Отмена последней команды
+    CTRL+R           # Отмена отмены
+
+    h                # Переместить курсор на один символ влево
+    j                # Переместить курсор на один символ вниз
+    k                # Переместить курсор на один символ вверх
+    l                # Переместить курсор на один символ вправо
+
+    # Перемещение по строке
+
+    0                # Переместить курсор к началу строки
+    $                # Переместить курсор к концу строки
+    ^                # Переместить курсор к первому непустому символу в строке
+
+    # Поиск в тексте
+
+    /<word>          # Подсветить все вхождения <word>  в тексте после курсора
+    ?<word>          # Подсветить все вхождения <word>  в тексте до курсора
+    n                # Передвигает курсор к следующему вхождения искомого слова
+    N                # Передвигает курсор к предыдущему вхождения искомого слова
+
+    :%s/foo/bar/g    # Меняет «foo» на «bar» во всем файле
+    :s/foo/bar/g     # Меняет «foo» на «bar» на текущей строке
+
+    # Переходы к символу
+
+    f<character>     # Перенести курсор к <character>
+    t<character>     # Перенести курсор вперед и остановиться прямо
+                     # перед <character>
+
+    # Например,
+    f<               # Перести курсор и остановиться на <
+    t<               # Перенсти курсор и остановиться прямо перед <
+    
+    # Перемещение по словам
+
+    w                # Переместиться вперед на одно слово
+    b                # Перенеститься назад на одно слово
+    e                # Перейти к концу текущего слова
+
+    # Другие команды для передвижения по тексту
+
+    gg               # Перейти к началу файла
+    G                # Перейти к концу файла
+    :NUM             # Перейти к строке под номером NUM 
+                     # (NUM может быть любым числом)
+    H                # Переместить курсор к верхнему краю экрана
+    M                # Переместить курсор к середине экрана
+    L                # Переместить курсор к нижнему краю экрана
+```
+
+## Режимы:
+
+Vim основывается на концепте **режимов**.
+
+Командный режим - vim запускается в этом режиме по-умолчанию, используется для 
+навигации и ввода команд.
+Режим ввода - используется для внесения изменений в файле.
+Визуальный режим - используется для подсветки текста и выполнения операций над ним.
+Режим командной строки - используется для ввода команд в нижнем углу экрана после символа «:».
+
+```
+    i                # Переводит vim в режим вставки перед позицией курсора
+    a                # Переводит vim в режим вставки после позиции курсора
+    v                # Переводит vim в визуальный режим
+    :                # Переводит vim в режим командной строки
+    <esc>            # Выходит из любого режима в котором вы находитесь 
+                     # в командный режим
+
+    # Копирование и вставка текста
+
+    y                # Скопировать выделенное
+    yy               # Скопировать текущую строку
+    d                # Удалить выделенное
+    dd               # Удалить текущую строку
+    p                # Вставить скопированный текст после текущей позиции курсора
+    P                # Вставить скопированный текст перед текущей позицией курсора
+    x                # Удалить символ под текущей позицией курсора
+```
+
+## «Грамматика» vim
+
+Vim можно рассматривать как набор команд в формате «Глагол-Модификатор-Существительное», где:
+
+Глагол - ваше действие.
+Модификатор - то как вы его выполняете.
+Существительное - объект над которым вы его выполняете.
+
+Несколько важных пример «Глаголов», «Модификаторов», и «Существительных»:
+
+```
+    # «Глаголы»
+ 
+    d                # Удалить
+    c                # Изменить
+    y                # Скопировать
+    v                # Визуально выделить
+
+    # «Модификаторы»
+
+    i                # Внутри
+    a                # Снаружи
+    NUM              # Число
+    f                # Ищет что-то и останавливается на нем
+    t                # Ищет что-то и останавливается перед ним
+    /                # Ищет строку после курсора
+    ?                # Ищет строку перед курсором
+
+    # «Существительные»
+
+    w                # Слово
+    s                # Предложение
+    p                # Параграф
+    b                # Блок
+    
+    # Образцы «предложений» или команд
+
+    d2w              # Удалить 2 слова
+    cis              # Изменить объемлющее предложение
+    yip              # Скопировать объемлющий параграф
+    ct<              # Изменяет текст от курсора до следующей открывающей скобки
+    d$               # Удалить все от положения курсора до конца строки
+```
+
+## Некоторые сокращения и хитрости
+
+        <!--TODO: Add more!-->
+```
+    >                # Сдвинуть выделенное на один отступ вправо
+    <                # Сдвинуть выделенное на один отступ влево
+    :earlier 15m     # Возвращает документ к состоянию в котором он был 
+                     # 15 минут назад
+    :later 15m       # Отменяет предыдущую команду
+    ddp              # Меняет позиции последовательных строк, сначала dd затем p
+    .                # Повторяет предыдущее действие
+```
+
+## Макросы
+
+Макросы это просто записываемые действия.
+Во время записи макросы запоминают **все** действия и команды до тех пор пока 
+запись не будет остановлена.При вызове макрос применяет ту же самую последовательность 
+действий и команд на выделенном тексте.
+
+```
+    qa               # Начать запись макроса под именем «a»
+    q                # Закончить запись
+    @a               # Выполнить макрос 
+```
+
+### Настройка ~/.vimrc
+
+Файл .vimrc может использоваться для настройки Vim при запуске.
+
+Вот пример файла ~/.vimrc:
+
+```
+" Пример ~/.vimrc
+" 2015.10 
+
+" Отключает совместимость со старым vi
+set nocompatible
+
+" Определяет тип файла по его имени для разрешения автоматических отступов и т. д.
+filetype indent plugin on
+
+" Включает подсветку синтаксиса
+syntax on
+
+" Улучшенное автодополнение команд 
+set wildmenu
+
+" Использовать поиск не чувствительный к регистру 
+" за исключением использования заглавный букв
+set ignorecase
+set smartcase
+
+" Копирует отступы с текущей строки при добавлении новой
+set autoindent
+
+" Показывать номера строк
+set number
+
+" Настройки отступов, изменяйте по собственному вкусу
+
+" Количество видимых пробелов на один символ табуляции
+set tabstop=4
+
+" Количество пробелов в символе табуляции при редактировании
+set softtabstop=4
+
+" Количество пробелов в отступе при использовании операций >> и << 
+set shiftwidth=4
+
+" Конвертировать символы табуляции в пробелы
+set expandtab
+
+" Включить умную табуляцию и пробелы для отступов и выравнивания
+set smarttab
+```
+
+### Ссылки
+
+[Vim | Home (EN)](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer (EN)](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread) (EN)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim_%28%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9%29)
diff --git a/ru-ru/xml-ru.html.markdown b/ru-ru/xml-ru.html.markdown
index b0096b75..bf3f22b0 100644
--- a/ru-ru/xml-ru.html.markdown
+++ b/ru-ru/xml-ru.html.markdown
@@ -128,3 +128,18 @@ XML-документ, который следует описанию докум�
   </book>
 </bookstore>
 ```
+
+## DTD совместимость и определение XML Schema(схем/структуры)
+ 
+Поддержка DTDs является повсеместным, потому что это довольно старая технология. К сожалению, современные функции XML как пространств имен(namespaces) не поддерживаются DTDs. Определения XML-схемы (XSDs) предназначены для замены DTDs которая в свою очередь предназначена для определения грамматики XML-документа.
+
+## Ресурсы
+
+* [Валидатор XML (ссылка на английском языке)](http://www.xmlvalidation.com)
+
+## Для будущего прочтения
+
+* [XML Schema Definitions Tutorial (ссылка на английском языке)](http://www.w3schools.com/schema/)
+* [DTD руководство (ссылка на английском языке)](http://www.w3schools.com/xml/xml_dtd_intro.asp)
+* [XML руководство (ссылка на английском языке)](http://www.w3schools.com/xml/default.asp)
+* [использование XPath запросов для парсинга XML (ссылка на английском языке)](http://www.w3schools.com/xml/xml_xpath.asp)
diff --git a/ruby.html.markdown b/ruby.html.markdown
index adf5ce81..a1532855 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -210,7 +210,7 @@ array.push(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 Ruby's primary dictionary with key/value pairs.
 # Hashes are denoted with curly braces:
 hash = { 'color' => 'green', 'number' => 5 }
 
@@ -612,7 +612,7 @@ Something.new.qux # => 'qux'
 
 - [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
 - [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Learn Ruby through a series of interactive tutorials.
-- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
+- [Official Documentation](http://ruby-doc.org/core)
 - [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
 - [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
 - [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
diff --git a/rust-pt.html.markdown b/rust-pt.html.markdown
new file mode 100644
index 00000000..79f69269
--- /dev/null
+++ b/rust-pt.html.markdown
@@ -0,0 +1,332 @@
+---
+language: rust
+filename: rust-pt.rs
+contributors:
+    - ["Paulo Henrique Rodrigues Pinheiro", "https://about.me/paulohrpinheiro"]
+filename: learnrust.rs
+lang: pt-br
+---
+
+Rust é uma linguagem de programação desenvolvida pelo Mozilla Research. Rust
+combina controle de baixo nível sobre o desempenho com facilidades de alto
+nível e garantias de segurança.
+
+Ele atinge esse objetico sem necessitar de um coletor de lixo ou um processo
+*runtime*, permitindo que se use bibliotecas Rust em substituição a bibliotecas 
+em C.
+
+A primeira versão de Rust, 0.1, apareceu em janeiro de 2012, e por três anos o
+desenvolvimento correu tão rapidamente que que até recentemente o uso de
+versões estáveis foi desencorajado e em vez disso a recomendação era usar as
+versões empacotadas toda noite.
+
+Em 15 de maio de 2015, a versão 1.0 de Rust foi liberada com a garantia total
+de compatibilidade reversa. Melhorias no tempo de compilação e em outros
+aspectos do compilador estão disponíveis atualmente nas versões empacotadas à
+noite. Rust adotou um modelo de versões *train-based* com novas versões
+regularmente liberadas a cada seis semanas. A versão 1.1 beta de Rust foi
+disponibilizada ao mesmo tempo que a versão 1.0.
+
+Apesar de Rust ser uma linguagem mais e baixo nível, Rust tem alguns conceitos
+funcionais geralmente encontradas em linguagens de alto nível. Isso faz Rust
+não apenas rápido, mas também fácil e eficiente para programar.
+
+```rust
+// Isso é um comentário. Linhas de comentários são assim...
+// e múltiplas linhas se parecem assim.
+
+/// Comentários para documentação são assim e permitem notação em markdown.
+/// # Exemplos
+///
+/// ```
+/// let five = 5
+/// ```
+
+///////////////
+// 1. Básico //
+///////////////
+
+// Funções
+// `i32` é o tipo para inteiros com sinal de 32 bits
+fn add2(x: i32, y: i32) -> i32 {
+    // Implicit return (no semicolon)
+    x + y
+}
+
+// Função main
+fn main() {
+    // Números //
+
+    // Immutable bindings
+    let x: i32 = 1;
+
+    // Inteiros/Sufixos para ponto flutuante
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inferência de tipos
+    // Em geral, o compilador Rust consegue inferir qual o tipo de uma 
+    // variável, então você não tem que escrever uma anotação explícita de tipo.
+    // Ao longo desse tutorial, os tipos serão explicitamente anotados em 
+    // muitos lugares, mas apenas com propóstico demonstrativo. A inferência de 
+    // tipos pode gerenciar isso na maioria das vezes.
+    let implicit_x = 1;
+    let implicit_f = 1.3;
+
+    // Aritmética
+    let sum = x + y + 13;
+
+    // Variáveis mutáveis
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Strings //
+
+    // String literais
+    let x: &str = "hello world!";
+
+    // Imprimindo
+    println!("{} {}", f, x); // 1.3 hello world
+
+    // Uma `String` – uma String alocada no heap
+    let s: String = "hello world".to_string();
+
+    // Uma String slice - uma visão imutável em outra string.
+    // Basicamente, isso é um par imutável de ponteiros para uma string - ele
+    // não contém o conteúdo de uma strinf, apenas um ponteiro para o começo e 
+    // um ponteiro para o fim da área de memória para a string, estaticamente
+    // alocada ou contida em outro objeto (nesse caso, `s`)
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // hello world hello world
+
+    // Vetores/arrays //
+
+    // Um array de tamanho fixo
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Um array dinâmico (vetor)
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Uma fatia – uma visão imutável em um vetor ou array
+    // Isso é como um string slice, mas para vetores
+    let slice: &[i32] = &vector;
+
+    // Use `{:?}` para imprimir alguma coisa no estilo de depuração
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuplas //
+
+    // Uma tupla é um conjunto de tamanho fixo de valores de tipos
+    // possivelmente diferentes
+    let x: (i32, &str, f64) = (1, "hello", 3.4);
+
+    // Desestruturando `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 hello 3.4
+
+    // Indexando
+    println!("{}", x.1); // hello
+
+    //////////////
+    // 2. Tipos //
+    //////////////
+
+    // Struct
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origin: Point = Point { x: 0, y: 0 };
+
+    // Uma estrutura com campos sem nome, chamada 'estrutura em tupla'
+    struct Point2(i32, i32);
+
+    let origin2 = Point2(0, 0);
+
+    // enum básico com na linguagem C
+    enum Direction {
+        Left,
+        Right,
+        Up,
+        Down,
+    }
+
+    let up = Direction::Up;
+
+    // Enum com campos
+    enum OptionalI32 {
+        AnI32(i32),
+        Nothing,
+    }
+
+    let two: OptionalI32 = OptionalI32::AnI32(2);
+    let nothing = OptionalI32::Nothing;
+
+    // Generics //
+
+    struct Foo<T> { bar: T }
+
+    // Isso é definido na biblioteca padrão como um `Option`
+    enum Optional<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Methods //
+
+    impl<T> Foo<T> {
+        // Métodos recebem um parâmetro `self` explícito
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Traits (conhecidos como interfaces ou typeclasses em outras linguagens)//
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    //////////////////////////////////
+    // 3. Reconhecimento de padrões //
+    //////////////////////////////////
+
+    let foo = OptionalI32::AnI32(1);
+    match foo {
+        OptionalI32::AnI32(n) => println!("it’s an i32: {}", n),
+        OptionalI32::Nothing  => println!("it’s nothing!"),
+    }
+
+    // Reconhecimento avançado de padrões
+    struct FooBar { x: i32, y: OptionalI32 }
+    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
+            println!("The numbers are zero!"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
+            println!("The numbers are the same"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
+            println!("Different numbers: {} {}", n, m),
+        FooBar { x: _, y: OptionalI32::Nothing } =>
+            println!("The second number is Nothing!"),
+    }
+
+    //////////////////////////
+    // 4. Controle de fluxo //
+    //////////////////////////
+
+    // `for` laços de repetição/iteração
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Ranges
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // prints `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Maths is working!");
+    } else {
+        println!("Oh no...");
+    }
+
+    // `if` como expressão
+    let value = if true {
+        "good"
+    } else {
+        "bad"
+    };
+
+    // laço `while` de repetição
+    while 1 == 1 {
+        println!("The universe is operating normally.");
+    }
+
+    // Repetição infinita
+    loop {
+        println!("Hello!");
+    }
+
+    ////////////////////////////////////////
+    // 5. Proteção de memória & ponteiros //
+    ////////////////////////////////////////
+
+    // Ponteiro com dono - somente uma coisa pode 'possuir' esse ponteiro por
+    // vez.
+    // Isso significa que quando `Box` perde seu escopo, ele pode ser
+    // automaticamente desalocado com segurança.
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // dereference
+    // Aqui, `now_its_mine` possui o controle exclusivo de `mine`. Em outras 
+    // palavras, `mine` tem o controle transferido.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", mine); // não compila porque `now_its_mine` é o dono
+
+    // Referência - um ponteiro imutável que referencia outro dado
+    // Quando uma referência é dada a um valor, nós dizemos que o valor foi
+    // emprestado 'borrowed'.
+    // Quando um valor é emprestado sem ser mutável, ele não pode ser alterado
+    // ou ter a sua propriedade transferida.
+    // Um empréstimo finaliza quando o escopo em que ele foi criado termina.
+
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // AO contrário de `mine`, `var` ainda pode ser usado
+    println!("{}", *ref_var);
+    // var = 5; // não compila porque `var` é emprestado
+    // *ref_var = 6; // não compila, porque `ref_var` é uma referência imutável
+
+    // Referência mutável
+    // Quando um valor mutável é emprestado, ele não pode ser acessado.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;         // '*' aponta para var2, que é mutável e emprestada
+
+    println!("{}", *ref_var2); // 6 , // var2 não compila.
+    // ref_var2 é do tipo &mut i32, que guarda uma referência i32, não o valor.
+    // var2 = 2; // não compila porque `var2` é empretada.
+}
+```
+
+## Outras leituras
+
+Existe muita coisa sobre Rust - isto aqui é apenas o básico para que você possa 
+entender as coisas mais importantes. Para aprender mais sobre Rust, leia [The 
+Rust Programming Language](http://doc.rust-lang.org/book/index.html) e 
+acompanhe [/r/rust](http://reddit.com/r/rust). A galera no canal #rust do
+irc.mozilla.org também estão sempre dispostos a ajudar os novatos.
+
+Você pode brincar com outras característica de Rust com um compilador online
+no portal oficial do projeto [Rust playpen](http://play.rust-lang.org), or ler 
+mais na página oficial [Rust website](http://rust-lang.org).
+
+No Brasil acompanhe os encontros do [Meetup Rust São Paulo]
+(http://www.meetup.com/pt-BR/Rust-Sao-Paulo-Meetup/).
+
diff --git a/rust.html.markdown b/rust.html.markdown
index d0c56b4a..6b75fa87 100644
--- a/rust.html.markdown
+++ b/rust.html.markdown
@@ -27,8 +27,15 @@ concepts that are generally found in higher-level languages. This makes
 Rust not only fast, but also easy and efficient to code in.
 
 ```rust
-// This is a comment. Single-line look like this...
-/* ...and multi-line comment look like this */
+// This is a comment. Line comments look like this...
+// and extend multiple lines like this.
+
+/// Documentation comments look like this and support markdown notation.
+/// # Examples
+///
+/// ```
+/// let five = 5
+/// ```
 
 ///////////////
 // 1. Basics //
@@ -81,9 +88,10 @@ fn main() {
     let s: String = "hello world".to_string();
 
     // A string slice – an immutable view into another string
-    // This is basically an immutable pointer to a string – it doesn’t
+    // This is basically an immutable pair of pointers to a string – it doesn’t
     // actually contain the contents of a string, just a pointer to
-    // something that does (in this case, `s`)
+    // the begin and a pointer to the end of a string buffer,
+    // statically allocated or contained in another object (in this case, `s`)
     let s_slice: &str = &s;
 
     println!("{} {}", s, s_slice); // hello world hello world
@@ -278,10 +286,10 @@ fn main() {
     var = 3;
     let ref_var: &i32 = &var;
 
-    println!("{}", var); // Unlike `box`, `var` can still be used
+    println!("{}", var); // Unlike `mine`, `var` can still be used
     println!("{}", *ref_var);
     // var = 5; // this would not compile because `var` is borrowed
-    // *ref_var = 6; // this would not too, because `ref_var` is an immutable reference
+    // *ref_var = 6; // this would not either, because `ref_var` is an immutable reference
 
     // Mutable reference
     // While a value is mutably borrowed, it cannot be accessed at all.
@@ -289,8 +297,9 @@ fn main() {
     let ref_var2: &mut i32 = &mut var2;
     *ref_var2 += 2;         // '*' is used to point to the mutably borrowed var2
 
-    println!("{}", *ref_var2); // 6 , //var2 would not compile. //ref_var2 is of type &mut i32, so                                                      //stores a reference to an i32 not the value.
-    // var2 = 2; // this would not compile because `var2` is borrowed
+    println!("{}", *ref_var2); // 6 , // var2 would not compile.
+    // ref_var2 is of type &mut i32, so stores a reference to an i32, not the value.
+    // var2 = 2; // this would not compile because `var2` is borrowed.
 }
 ```
 
diff --git a/sass.html.markdown b/sass.html.markdown
index 4d4ece71..224db80e 100644
--- a/sass.html.markdown
+++ b/sass.html.markdown
@@ -5,6 +5,7 @@ contributors:
   - ["Laura Kyle", "https://github.com/LauraNK"]
   - ["Sean Corrales", "https://github.com/droidenator"]
   - ["Kyle Mendes", "https://github.com/pink401k"]
+  - ["Keith Miyake", "https://github.com/kaymmm"]
 ---
 
 Sass is a CSS extension language that adds features such as variables, nesting, mixins and more.
@@ -15,7 +16,7 @@ This tutorial is written using SCSS.
 
 If you're already familiar with CSS3, you'll be able to pick up Sass relatively quickly. It does not provide any new styling properties but rather the tools to write your CSS more efficiently and make maintenance much easier.
 
-```scss
+```sass
 
 
 //Single line comments are removed when Sass is compiled to CSS.
@@ -52,16 +53,161 @@ body {
 	font-family: 'Roboto', sans-serif;
 }
 
-
 /* This is much more maintainable than having to change the color
 each time it appears throughout your stylesheet. */
 
 
 
-/* Mixins
+/* Control Directives
 ============================== */
 
+/* Sass lets you use @if, @else, @for, @while, and @each to control the
+   compilation of your code to CSS. */
+
+/* @if/@else blocks behave exactly as you might expect */
+
+$debug: true !default;
+
+@mixin debugmode {
+	@if $debug {
+		@debug "Debug mode enabled";
+
+		display: inline-block;
+	}
+	@else {
+		display: none;
+	}
+}
+
+.info {
+	@include debugmode;
+}
+
+/* If $debug is set to true, .info is displayed; if it's set to false then
+.info is not displayed.
 
+Note: @debug will output debugging information to the command line.
+Useful for checking variables while debugging your SCSS. */
+
+.info {
+	display: inline-block;
+}
+
+/* @for is a control loop that iterates through a range of values.
+Particularly useful for setting styles on a collection of items.
+There are two forms, "through" and "to". The former includes the last value,
+the latter stops at the last value. */
+
+@for $c from 1 to 4 {
+	div:nth-of-type(#{$c}) {
+		left: ($c - 1) * 900 / 3;
+	}
+}
+
+@for $c from 1 through 3 {
+	.myclass-#{$c} {
+		color: rgb($c * 255 / 3, $c * 255 / 3, $c * 255 / 3);
+	}
+}
+
+/* Will compile to: */
+
+div:nth-of-type(1) {
+	left: 0;
+}
+
+div:nth-of-type(2) {
+	left: 300;
+}
+
+div:nth-of-type(3) {
+	left: 600;
+}
+
+.myclass-1 {
+	color: #555555;
+}
+
+.myclass-2 {
+	color: #aaaaaa;
+}
+
+.myclass-3 {
+	color: white;
+// SASS automatically converts #FFFFFF to white
+}
+
+/* @while is very straightforward: */
+
+$columns: 4;
+$column-width: 80px;
+
+@while $columns > 0 {
+	.col-#{$columns} {
+		width: $column-width;
+		left: $column-width * ($columns - 1);
+	}
+
+	$columns: $columns - 1;
+}
+
+/* Will output the following CSS: */
+
+.col-4 {
+	width: 80px;
+	left: 240px;
+}
+
+.col-3 {
+	width: 80px;
+	left: 160px;
+}
+
+.col-2 {
+	width: 80px;
+	left: 80px;
+}
+
+.col-1 {
+	width: 80px;
+	left: 0px;
+}
+
+/* @each functions like @for, except using a list instead of ordinal values
+Note: you specify lists just like other variables, with spaces as
+delimiters. */
+
+$social-links: facebook twitter linkedin reddit;
+
+.social-links {
+	@each $sm in $social-links {
+		.icon-#{$sm} {
+			background-image: url("images/#{$sm}.png");
+		}
+	}
+}
+
+/* Which will output: */
+
+.social-links .icon-facebook {
+	background-image: url("images/facebook.png");
+}
+
+.social-links .icon-twitter {
+	background-image: url("images/twitter.png");
+}
+
+.social-links .icon-linkedin {
+	background-image: url("images/linkedin.png");
+}
+
+.social-links .icon-reddit {
+	background-image: url("images/reddit.png");
+}
+
+
+/* Mixins
+==============================*/
 
 /* If you find you are writing the same code for more than one
 element, you might want to store that code in a mixin.
@@ -93,7 +239,6 @@ div {
 	background-color: #A3A4FF;
 }
 
-
 /* You can use mixins to create a shorthand property. */
 
 @mixin size($width, $height) {
@@ -139,7 +284,7 @@ body {
 }
 
 .footer {
-  background-color: fade_out(#000000, 0.25)
+  background-color: fade_out(#000000, 0.25);
 }
 
 /* Compiles to: */
@@ -156,7 +301,7 @@ body {
    mixins. When trying to choose between a function or a mixin, remember
    that mixins are best for generating CSS while functions are better for
    logic that might be used throughout your Sass code. The examples in
-   the Math Operators' section are ideal candidates for becoming a reusable
+   the 'Math Operators' section are ideal candidates for becoming a reusable
    function. */
 
 /* This function will take a target size and the parent size and calculate
@@ -432,9 +577,7 @@ You can use either syntax, just go into the settings and select either Sass or S
 
 
 ## Compatibility
-Sass can be used in any project as long as you have a program to compile it
-into CSS. You'll want to verify that the CSS you're using is compatible
-with your target browsers.
+Sass can be used in any project as long as you have a program to compile it into CSS. You'll want to verify that the CSS you're using is compatible with your target browsers.
 
 [QuirksMode CSS](http://www.quirksmode.org/css/) and [CanIUse](http://caniuse.com) are great resources for checking compatibility.
 
diff --git a/scala.html.markdown b/scala.html.markdown
index e82c1c36..78053b40 100644
--- a/scala.html.markdown
+++ b/scala.html.markdown
@@ -12,22 +12,62 @@ Scala - the scalable language
 
 ```scala
 
+/////////////////////////////////////////////////
+// 0. Basics
+/////////////////////////////////////////////////
 /*
-  Set yourself up:
+  Setup Scala:
 
   1) Download Scala - http://www.scala-lang.org/downloads
-  2) Unzip/untar to your favourite location and put the bin subdir in your `PATH` environment variable
-  3) Start a Scala REPL by running `scala`. You should see the prompt:
+  2) Unzip/untar to your favorite location and put the bin subdir in your `PATH` environment variable
+*/
 
-  scala>
+/*
+  Try the REPL
 
-  This is the so called REPL (Read-Eval-Print Loop). You may type any Scala
-  expression, and the result will be printed. We will explain what Scala files
-  look like further into this tutorial, but for now, let's start with some
-  basics.
+  Scala has a tool called the REPL (Read-Eval-Print Loop) that is analogous to
+  commandline interpreters in many other languages. You may type any Scala
+  expression, and the result will be evaluated and printed.  
 
+  The REPL is a very handy tool to test and verify code.  Use it as you read
+  this tutorial to quickly explore concepts on your own.
 */
 
+// Start a Scala REPL by running `scala`. You should see the prompt:
+$ scala
+scala>
+
+// By default each expression you type is saved as a new numbered value
+scala> 2 + 2
+res0: Int = 4
+
+// Default values can be reused.  Note the value type displayed in the result..
+scala> res0 + 2
+res1: Int = 6
+
+// Scala is a strongly typed language. You can use the REPL to check the type
+// without evaluating an expression.
+scala> :type (true, 2.0)
+(Boolean, Double)
+
+// REPL sessions can be saved
+scala> :save /sites/repl-test.scala
+
+// Files can be loaded into the REPL
+scala> :load /sites/repl-test.scala
+Loading /sites/repl-test.scala...
+res2: Int = 4
+res3: Int = 6
+
+// You can search your recent history
+scala> :h?
+1 2 + 2
+2 res0 + 2
+3 :save /sites/repl-test.scala
+4 :load /sites/repl-test.scala
+5 :h?
+
+// Now that you know how to play, let's learn a little scala...
 
 /////////////////////////////////////////////////
 // 1. Basics
@@ -48,7 +88,7 @@ println(10)
 // Printing, without forcing a new line on next print
 print("Hello world")
 print(10)
-// Hello world!10
+// Hello world10
 
 // Declaring values is done using either var or val.
 // val declarations are immutable, whereas vars are mutable. Immutability is
@@ -88,6 +128,7 @@ true == false // false
 6 / 2   // 3
 6 / 4   // 1
 6.0 / 4 // 1.5
+6 / 4.0 // 1.5
 
 
 // Evaluating an expression in the REPL gives you the type and value of the result
@@ -419,8 +460,52 @@ val otherGeorge = george.copy(phoneNumber = "9876")
 
 // And many others. Case classes also get pattern matching for free, see below.
 
+// Traits
+// Similar to Java interfaces, traits define an object type and method
+// signatures. Scala allows partial implementation of those methods.
+// Constructor parameters are not allowed. Traits can inherit from other
+// traits or classes without parameters.
+
+trait Dog {
+	def breed: String
+	def color: String
+	def bark: Boolean = true
+	def bite: Boolean
+}
+class SaintBernard extends Dog {
+	val breed = "Saint Bernard"
+	val color = "brown"
+	def bite = false
+}  
+
+scala> b  
+res0: SaintBernard = SaintBernard@3e57cd70  
+scala> b.breed  
+res1: String = Saint Bernard  
+scala> b.bark  
+res2: Boolean = true  
+scala> b.bite  
+res3: Boolean = false  
+
+// A trait can also be used as Mixin. The class "extends" the first trait,
+// but the keyword "with" can add additional traits.
+
+trait Bark {
+	def bark: String = "Woof"
+}
+trait Dog {
+	def breed: String
+	def color: String
+}
+class SaintBernard extends Dog with Bark {
+	val breed = "Saint Bernard"
+	val color = "brown"
+}
 
-// Traits coming soon!
+scala> val b = new SaintBernard
+b: SaintBernard = SaintBernard@7b69c6ba
+scala> b.bark
+res0: String = Woof
 
 
 /////////////////////////////////////////////////
@@ -553,7 +638,7 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
  * best practices around them. We only include this section in the tutorial
  * because they are so commonplace in Scala libraries that it is impossible to
  * do anything meaningful without using a library that has implicits. This is
- * meant for you to understand and work with implicts, not declare your own.
+ * meant for you to understand and work with implicits, not declare your own.
  */
 
 // Any value (vals, functions, objects, etc) can be declared to be implicit by
diff --git a/self.html.markdown b/self.html.markdown
index 9290a0c9..fc7f69db 100644
--- a/self.html.markdown
+++ b/self.html.markdown
@@ -60,7 +60,7 @@ also sending the message 'true' to the lobby."
 
 # Sending messages to objects
 
-Messages can either be unary, binary or keyword. Precedence is in that order. Unlike Smalltalk, the precedence of binary messages must be specified, and all keywords after the first must start with a capital letter. Messages are separeated from their destination by whitespace.
+Messages can either be unary, binary or keyword. Precedence is in that order. Unlike Smalltalk, the precedence of binary messages must be specified, and all keywords after the first must start with a capital letter. Messages are separated from their destination by whitespace.
 
 ```
 "unary message, sends 'printLine' to the object '23'
diff --git a/shutit.html.markdown b/shutit.html.markdown
new file mode 100644
index 00000000..d16290b3
--- /dev/null
+++ b/shutit.html.markdown
@@ -0,0 +1,318 @@
+---
+category: tool
+tool: ShutIt
+contributors:
+    - ["Ian Miell", "http://ian.meirionconsulting.tk"]
+filename: learnshutit.html
+---
+
+## ShutIt
+
+ShutIt is an shell automation framework designed to be easy to use.
+
+It is a wrapper around a python-based expect clone (pexpect).
+
+You can look at it as 'expect without the pain'.
+
+It is available as a pip install.
+
+## Hello World
+
+Starting with the simplest example. Create a file called example.py:
+
+```python
+
+import shutit
+session = shutit.create_session('bash')
+session.send('echo Hello World', echo=True)
+```
+
+Running this with:
+
+```bash
+python example.py
+```
+
+outputs:
+
+```bash
+$ python example.py
+echo "Hello World"
+echo "Hello World"
+Hello World
+Ians-MacBook-Air.local:ORIGIN_ENV:RhuebR2T#
+```
+
+The first argument to 'send' is the command you want to run. The 'echo'
+argument outputs the terminal interactions. By default ShutIt is silent.
+
+'send' takes care of all the messing around with prompts and 'expects' that
+you might be familiar with from expect.
+
+
+## Log Into a Server
+
+Let's say you want to log into a server and run a command. Change example.py
+to:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.login('ssh you@example.com', user='you', password='mypassword')
+session.send('hostname', echo=True)
+session.logout()
+```
+
+which will log you into your server (if you replace with your details) and
+output the hostname.
+
+```
+$ python example.py
+hostname
+hostname
+example.com
+example.com:cgoIsdVv:heDa77HB#
+```
+
+Obviously that's insecure! Instead you can run:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+password = session.get_input('', ispass=True)
+session.login('ssh you@example.com', user='you', password=password)
+session.send('hostname', echo=True)
+session.logout()
+```
+
+which forces you to input the password:
+
+```
+$ python example.py
+Input Secret:
+hostname
+hostname
+example.com
+example.com:cgoIsdVv:heDa77HB#
+```
+
+Again, the 'login' method handles the changing prompt from a login. You give
+ShutIt the login command, the user you expect to log in as, and a password
+(if needed), and ShutIt takes care of the rest.
+
+'logout' handles the ending of a 'login', handling any changes to the prompt
+for you.
+
+## Log Into Multiple Servers
+
+Let's say you have a server farm of two servers, and want to log onto both.
+Just create two sessions and run similar login and send commands:
+
+```python
+import shutit
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session1.get_input('Password for server1', ispass=True)
+password2 = session2.get_input('Password for server2', ispass=True)
+session1.login('ssh you@one.example.com', user='you', password=password1)
+session2.login('ssh you@two.example.com', user='you', password=password2)
+session1.send('hostname', echo=True)
+session2.send('hostname', echo=True)
+session1.logout()
+session2.logout()
+```
+
+would output:
+
+```bash
+$ python example.py
+Password for server1
+Input Secret:
+
+Password for server2
+Input Secret:
+hostname
+hostname
+one.example.com
+one.example.com:Fnh2pyFj:qkrsmUNs# hostname
+hostname
+two.example.com
+two.example.com:Gl2lldEo:D3FavQjA#
+```
+
+## Example: Monitor Multiple Servers
+
+We can turn the above into a simple monitoring tool by adding some logic to
+examine the output of a command:
+
+```python
+import shutit
+capacity_command="""df / | awk '{print $5}' | tail -1 | sed s/[^0-9]//"""
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session.get_input('Password for server1', ispass=True)
+password2 = session.get_input('Password for server2', ispass=True)
+session1.login('ssh you@one.example.com', user='you', password=password1)
+session2.login('ssh you@two.example.com', user='you', password=password2)
+capacity = session1.send_and_get_output(capacity_command)
+if int(capacity) < 10:
+	print('RUNNING OUT OF SPACE ON server1!')
+capacity = session2.send_and_get_output(capacity_command)
+if int(capacity) < 10:
+	print('RUNNING OUT OF SPACE ON server2!')
+session1.logout()
+session2.logout()
+```
+
+Here you use the 'send\_and\_get\_output' method to retrieve the output of the
+capacity command (df).
+
+There are much more elegant ways to do the above (eg have a dictionary of the
+servers to iterate over), but it's up to you how clever you need the python to
+be.
+
+
+## More Intricate IO - Expecting
+
+Let's say you have an interaction with an interactive command line application
+you want to automate. Here we will use telnet as a trivial example:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.send('telnet', expect='elnet>', echo=True)
+session.send('open google.com 80', expect='scape character', echo=True)
+session.send('GET /', echo=True, check_exit=False)
+session.logout()
+```
+
+Note the 'expect' argument. You only need to give a subset of telnet's
+prompt to match and continue.
+
+Note also the 'check\_exit' argument in the above, which is new. We'll come back
+to that. The output of the above is:
+
+```bash
+$ python example.py
+telnet
+telnet> open google.com 80
+Trying 216.58.214.14...
+Connected to google.com.
+Escape character is '^]'.
+GET /
+HTTP/1.0 302 Found
+Cache-Control: private
+Content-Type: text/html; charset=UTF-8
+Referrer-Policy: no-referrer
+Location: http://www.google.co.uk/?gfe_rd=cr&ei=huczWcj3GfTW8gfq0paQDA
+Content-Length: 261
+Date: Sun, 04 Jun 2017 10:57:10 GMT
+
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+<TITLE>302 Moved</TITLE></HEAD><BODY>
+<H1>302 Moved</H1>
+The document has moved
+<A HREF="http://www.google.co.uk/?gfe_rd=cr&amp;ei=huczWcj3GfTW8gfq0paQDA">
+here
+</A>.
+</BODY></HTML>
+Connection closed by foreign host.
+```
+
+Now back to 'check\_exit=False'. Since the telnet command returns a failure exit
+code (1) and we don't want the script to fail, you set 'check\_exit=False' to
+let ShutIt know you don't care about the exit code.
+
+If you didn't pass that argument in, ShutIt gives you an interactive terminal
+if there is a terminal to communicate with. This is called a 'pause point'.
+
+
+## Pause Points
+
+You can trigger a 'pause point' at any point by calling
+
+```python
+[...]
+session.pause_point('This is a pause point')
+[...]
+```
+
+within your script, and then continue with the script by hitting CTRL and ']'
+at the same time. This is great for debugging: add a pause point, have a look
+around, then continue. Try this:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.pause_point('Have a look around!')
+session.send('echo "Did you enjoy your pause point?"', echo=True)
+```
+
+with output like this:
+
+```bash
+$ python example.py
+Have a look around!
+
+Ians-Air.home:ORIGIN_ENV:I00LA1Mq#  bash
+imiell@Ians-Air:/space/git/shutit  ⑂ master +    
+CTRL-] caught, continuing with run...
+2017-06-05 15:12:33,577 INFO: Sending:  exit
+2017-06-05 15:12:33,633 INFO: Output (squashed):  exitexitIans-Air.home:ORIGIN_ENV:I00LA1Mq#  [...]
+echo "Did you enjoy your pause point?"
+echo "Did you enjoy your pause point?"
+Did you enjoy your pause point?
+Ians-Air.home:ORIGIN_ENV:I00LA1Mq#
+```
+
+
+## More Intricate IO - Backgrounding
+
+Returning to our 'monitoring multiple servers' example, let's imagine we
+have a long-running task that we want to run on each server. By default, ShutIt
+works serially which would take a long time. But we can run tasks in the
+background to speed things up.
+
+Here you can try an example with the trivial command: 'sleep 60'.
+
+
+```python
+import shutit
+import time
+long_command="""sleep 60"""
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session1.get_input('Password for server1', ispass=True)
+password2 = session2.get_input('Password for server2', ispass=True)
+session1.login('ssh you@one.example.com', user='you', password=password1)
+session2.login('ssh you@two.example.com', user='you', password=password2)
+start = time.time()
+session1.send(long_command, background=True)
+session2.send(long_command, background=True)
+print('That took: ' + str(time.time() - start) + ' seconds to fire')
+session1.wait()
+session2.wait()
+print('That took: ' + str(time.time() - start) + ' seconds to complete')
+```
+
+My laptop says it took 0.5 seconds to run fire those two commands, and then just
+over a minute to complete (using the 'wait' method).
+
+Again, this is trivial, but imagine you have hundreds of servers to manage like
+this and you can see the power it can bring in a few lines of code and one
+python import.
+
+
+## Learn More
+
+There's a lot more that can be done with ShutIt.
+
+To learn more, see:
+
+[ShutIt](https://ianmiell.github.io/shutit/)
+[GitHub](https://github.com/ianmiell/shutit/blob/master/README.md)
+
+It's a broader automation framework, and the above is its 'standalone mode'.
+
+Feedback, feature requests, 'how do I?'s highly appreciated! Reach me at
+[@ianmiell](https://twitter.com/ianmiell)
diff --git a/sk-sk/LearnGit-sk.txt b/sk-sk/LearnGit-sk.txt
deleted file mode 100644
index 070a0489..00000000
--- a/sk-sk/LearnGit-sk.txt
+++ /dev/null
@@ -1,208 +0,0 @@
-$ git init
-
-# Zobraz a Nastav Základné Konfiguračné Premenné (Globálne)
-$ git config --global user.email "MôjEmail@Zoho.com"
-$ git config --global user.name  "Moje Meno
-
-# Rýchlo zobraz všetky dostupné príkazy
-$ git help
-
-# Zobraz všetky dostupné príkazy
-$ git help -a
-
-# Zobraz konkrétnu pomoc - použivateľský manuál
-# git help <príkaz_tu>
-$ git help add
-$ git help commit
-$ git help init
-# alebo git <príkaz_tu> --help
-$ git add --help
-$ git commit --help
-$ git init --help
-
-# Zobrazí vetvu, nesledované súbory, zmeny a ostatné rozdiely
-$ git status
-# Zistí iné vychytávky o git statuse
-$ git help status
-
-# pridá súbor z tvojho pracovného adresára
-$ git add HelloWorld.java
-
-# pridá súbor z iného adresára
-$ git add /cesta/k/súboru/HelloWorld.c
-
-# Môžeš použiť regulárne výrazy!
-$ git add ./*.java
-
-# zobraz existujúce vetvy a vzdialené repozitáre
-$ git branch -a
-
-# vytvor novú vetvu
-$ git branch myNewBranch
-
-# vymaž vetvu
-$ git branch -d myBranch
-
-# premenuj vetvu
-# git branch -m <starémeno> <novémeno>
-$ git branch -m mojaStaraVetva mojaNovaVetva
-
-# zmeň opis vetvy
-$ git branch myBranchName --edit-description
-
-# Zobrazí tagy
-$ git tag
-# Vytvorí tag so správou
-# -m špecifikuje správu, ktorá bude s tagom uložená.
-# Ak nešpeficikuješ správu pri tagu so správou,
-# Git spustí tvoj editor, aby si ju napísal.
-$ git tag -a v2.0 -m 'moja verzia 2.0'
-
-# Ukáž informácie o tagu
-# Zobrazí zadané informácie, dátum tagnutia commitu
-# a správu pred zobrazením informácií o commite.
-$ git show v2.0
-
-# Zverejní (pushne) jediný tag do vzdialeného repozitára
-$ git push origin v2.0
-
-# Zverejní viacero tagov do vzdialeného repozitára
-$ git push origin --tags
-
-# Aktualizuj strom, aby odpovedal (predvolene) 
-# hlavnej vetve repozitáru (master branch)
-$ git checkout
-
-# Aktualizuj strom, aby odpovedal konrkétnej vetve
-$ git checkout menoVetvy
-
-# Vytvor novú vetvu & prepni sa na ňu
-# ekvivalentný príkaz: "git branch <meno>; git checkout <meno>"
-$ git checkout -b nováVetva
-
-# Naklonuj learnxinyminutes-docs
-$ git clone https://github.com/adambard/learnxinyminutes-docs.git
-
-# povrchné klonovanie - rýchlejšie, uloží iba najnovšiu snímku
-$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
-
-# naklonuj iba konkrétnu vetvu
-$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
-
-# commitni so správou
-$ git commit -m "Pridal som multiplyNumbers() funkciu do HelloWorld.c"
-
-# automaticky pridaj zmenené a vymazané súbory do staging indexu,  potom ich commitni.
-$ git commit -a -m "Zmenil som foo.php a vymazal bar.php"
-
-# zmeň posledný commit (toto nahradí predchádzajúci commit novým)
-$ git commit --amend -m "Správna správa"
-
-# Ukáž rozdiel medzi pracovným repozitárom a indexom.
-$ git diff
-
-# Ukáž rozdiely medzi indexom a najnovším commitom.
-$ git diff --cached
-
-# Ukáž rozdiely medzi pracovným adresárom a najnovším commitom.
-$ git diff HEAD
-
-# Nastav, aby sa vo výsledkoch vyhľadávania zobrazovalo číslo riadku
-$ git config --global grep.lineNumber true
-
-# Urob výsledky vyhľadávania čitateľnejšie, vrátane zoskupovania
-$ git config --global alias.g "grep --break --heading --line-number"
-
-# Vďaka Travisovi Jefferymu za túto sekciu
-# Hľadaj "názovPremennej" vo všetkých java súboroch
-$ git grep 'názovPremennej' -- '*.java'
-
-# Hľadaj riadok, ktorý obsahuje "názovPoľa" a "add" alebo "remove"
-$ git grep -e 'arrayListName' --and \( -e add -e remove \)
-
-# Zobraz všetky commity
-$ git log
-
-# Zobraz iba správy a referencie commitov
-$ git log --oneline
-
-# Zobraz zlúčené (merged) commity
-$ git log --merges
-
-# Zobraz všetky commity vo forme ASCII grafu
-$ git log --graph
-
-# Zlúč vybranú vetvu do aktuálnej.
-$ git merge názovVetvy
-
-# Vždy vytvor zlučovací commit
-$ git merge --no-ff názovVetvy
-
-# Premenuj súbor
-$ git mv HelloWorld.c HelloNewWorld.c
-
-# Presuň súbor
-$ git mv HelloWorld.c ./nová/cesta/HelloWorld.c
-
-# "Nasilu" premenuj, alebo presuň
-# "existujúciSúbor" už v adresári existuje, bude prepísaný
-$ git mv -f môjSúbor existujúciSúbor
-
-# Aktualizuje tvoj lokálny repozitár zlúčením nových zmien
-# zo vzdialených "origin" a "master" vetiev.
-# git pull <alias-vzdialeného-repo> <vetva>
-$ git pull origin master
-
-# Predvolene, git pull aktualizuje tvoju aktuálnu vetvu
-# zlúčením nových zmien zo vzdialenej vetvy 
-$ git pull
-
-# Zlúč zmeny zo vzdialenej vetvy a presuň vetvu do nového základného commitu (rebase)
-# vetva commitne na tvoj lokálny repozitár, ekvivalentný príkaz: "git pull <alias-vzdialeného-repo> <vrstva>, git rebase <branch>"
-$ git pull origin master --rebase
-
-# Zverejni a zlúč zmeny z lokálneho repozitára do
-# vzdialených vetiev s názvom "origin" a "master".
-# git push <vzdialené> <vetvy>
-$ git push origin master
-
-# Predvolene git zverejní a zlúči zmeny z
-# aktuálnej vetvy do vzdialenej vetvy s ňou spojenej
-$ git push
-
-# Na spojenie lokálnej vetvy so vzdialenou pridaj -u:
-$ git push -u origin master
-# Kedykoľvek budeš chcieť zverejniť z rovnakej lokálnej vetvy, použi príkaz:
-$ git push
-
-# Aplikuj commity z experimentálnej vetvy na master
-# git rebase <základnáVetva> <ináVetva>
-$ git rebase master experimentBranch
-
-# Resetni index (vrstvu medzi pracovným stromom a Git repozitárom), aby odpovedal najnovšiemu commitu (adresár ostane nezmenený)
-$ git reset
-
-# Resetni index, aby odpovedal najnovšiemu commitu (adresár sa prepíše)
-$ git reset --hard
-
-# Presunie vrchol aktuálnuej vetvy do konkrétneho commitu (adresár ostane nezmenený)
-# všetky zmeny sú zachované v adresári.
-$ git reset 31f2bb1
-
-# Vezmi späť konkrétny commit
-$ git revert <commit>
-
-# odstráň HelloWorld.c
-$ git rm HelloWorld.c
-
-# Odstráň súbor z vnoreného adresára
-$ git rm /pather/to/the/file/HelloWorld.c
-
-
-
-
-
-
-
-
-
diff --git a/sk-sk/bash.html.markdown b/sk-sk/bash.html.markdown
new file mode 100644
index 00000000..e9d1490c
--- /dev/null
+++ b/sk-sk/bash.html.markdown
@@ -0,0 +1,286 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Etan Reisner", "https://github.com/deryni"]
+translators:
+    - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+filename: LearnBash-sk.sh
+---
+
+Bash je pomenovanie pre unix shell (príkazový interpreter), ktorý bol
+tiež distribuovaný ako shell pre GNU operačné systémy a ako predvolený
+shell pre Linux a Mac OS X.
+Takmer všetky príklady uvedené nižšie môžu byť súčasťou shell skriptu alebo
+vykonané priamo v shelli.
+
+[Viac informácií tu.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# Prvý riadok skriptu je tzv. shebang, ktorý systému povie ako skript vykonať:
+# http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Komentáre začínajú znakom #. Shebang je tiež komentár.
+
+# Jednoduchý príklad:
+echo Ahoj svet!
+
+# Každý príkaz začína na novom riadku alebo za bodkočiarkou:
+echo 'Toto je prvý riadok'; echo 'Toto je druhý riadok'
+
+# Deklarácia premenných vyzerá takto:
+Premenna="Nejaky retazec"
+
+# Ale nie takto:
+Premenna = "Nejaky retazec"
+# Bash si bude myslieť, že Premenna je príkaz, ktorý musí vykonať.
+# Výsledkom bude chyba, pretože taký príkaz nenájde.
+
+# Alebo takto:
+Premenna= 'Nejaky retazec'
+# Bash zistí, že 'Nejaky retazec' je príkaz, ktorý musí vykonať.
+# Výsledkom je opäť chyba, lebo taký príkaz neexistuje.
+
+# Používanie premenných:
+echo $Premenna
+echo "$Premenna"
+echo '$Premenna'
+# Keď je premenná použitá samostatne - priradenie, exportovanie a pod. - jej
+# meno sa píše bez znaku $. Keď sa používa hodnota premennej, pred názov sa
+# dáva znak $. Pozor však pri použití ' (apostrof), ktorý nenahradí premennú
+# hodnotou!
+
+# Nahradenie reťazca v premennej
+echo ${Premenna/Nieco/A}
+# Toto nahradí prvý výskyt reťazca "Nieco" za "A"
+
+# Podreťazec z premennej
+Dlzka=7
+echo ${Premenna:0:Dlzka}
+# Toto vráti iba prvých 7 znakov z hodnoty premennej
+
+# Predvolená hodnota premennej
+echo ${Foo:-"PredvolenaHodnotaAkFooChybaAleboJePrazdna"}
+# Toto funguje pre null (Foo=) a prázdny reťazec (Foo="");
+# nula (Foo=0) vráti 0. Všimni si, že toto iba vráti predvolenú hodnotu,
+# ale nezmení hodnotu premennej.
+
+# Štandardné premenné:
+# Existujú aj užitočné "vstavané" premenné, ako
+echo "Hodnota vrátená posledným programom: $?"
+echo "PID skriptu: $$"
+echo "Počet argumentov: $#"
+echo "Argumeny skriptu: $@"
+echo "Argumeny skriptu oddelené do rôznych premenných: $1 $2..."
+
+# Čítanie hodnoty zo vstupu:
+echo "Ako sa voláš?"
+read Meno # Premenná nemusí byť deklarovaná skôr
+echo Ahoj, $Meno!
+
+# Klasická if štruktúra:
+# použi 'man test' Pre viac informácií o podmienkach
+if [ $Meno -ne $USER ]
+then
+    echo "Meno nie je tvoje používateľské meno"
+else
+    echo "Meno je tvoje používateľské meno"
+fi
+
+# Existuje aj podmienené vykonanie
+echo "Vykonané vždy" || echo "Vykonané iba ak prvý príkaz zlyhá"
+echo "Vykonané vždy" && echo "Vykonané iba ak prvý príkaz uspeje"
+
+# Pre použitie && a || s if-podmienkou je potrebné použiť zátvorky:
+if [ $Meno == "Steve" ] && [ $Vek -eq 15 ]
+then
+    echo "Toto sa spustí ak $Meno je Steve a $Vek je 15."
+fi
+
+if [ $Meno == "Daniya" ] || [ $Meno == "Zach" ]
+then
+    echo "Toto sa spustí ak $Meno je Daniya alebo Zach."
+fi
+
+# Pre výrazy sa používa nasledovný formát:
+echo $(( 10 + 5 ))
+
+# Na rozdiel od programovacích jazykov shell pracuje v kontexte aktuálneho
+# adresára. Môžeš si prehliadať súbory a adresáre v aktuálnom adresári pomocou
+# príkazu ls:
+ls
+
+# Tieto príkazy majú aj argumenty pre úpravu ich správania:
+ls -l # Vypíše zoznam súborov a priečinkov, každý na samostatnom riadku
+
+# Výsledok predchádzajúceho príkazu môže byť využitý priamo ako vstup pre
+# ďalší príkaz.
+# Príkaz grep filtruje vstupvyužitím poskytnutého vzoru. Takto môžeme vypísať
+# iba .txt súbory:
+ls -l | grep "\.txt"
+
+# Vstup a výstup príkazu (stdin, stdout, stderr) môžu byť presmerované.
+# Toto číta stdin až po ^EOF$ a prepíše hello.py riadkami medzi "EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Spustí hello.py s rôznymi presmerovaniami pre stdin, stdout a stderr:
+python hello.py < "vstup.in"
+python hello.py > "vystup.out"
+python hello.py 2> "chyby.err"
+python hello.py > "vystup-a-chyby.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Chybový výstup prepíše uvedený súbor, ak už existuje.
+# Ak chceš výstup pridať za existujúci obsah, použi ">>":
+python hello.py >> "vystup.out" 2>> "chyby.err"
+
+# Prepíše vystup.out, pripojí k chyby.err a spočíta riadky:
+info bash 'Basic Shell Features' 'Redirections' > vystup.out 2>> chyby.err
+wc -l vystup.out chyby.err
+
+# Spustí príkaz a vypíše deskriptor súboru (napr. /dev/fd/123)
+# pozri: man fd
+echo <(echo "#ahojsvet")
+
+# Prepíše vystup.out s "#ahojsvet":
+cat > vystup.out <(echo "#ahojsvet")
+echo "#ahojsvet" > vystup.out
+echo "#ahojsvet" | cat > vystup.out
+echo "#ahojsvet" | tee vystup.out >/dev/null
+
+# Potichu odstráni dočasné súbory (pridaj '-i' pre interaktivitu)
+rm -v vystup.out chyby.err vystup-a-chyby.log
+
+# Príkazy môžu byť nahradené v iných príkazoch použitím $( ):
+# Nasledujúci príkaz vypíše počet súborov a adresárov v aktuálnom adresári
+echo "Je tu $(ls | wc -l) súborov a priečinkov."
+
+# To isté sa dá spraviť pomocou spätného apostrofu ``, tie však nemôžu byť
+# vhniezdené - preferovaný spôsob je preto $( ).
+echo "Je tu `ls | wc -l` súborov a priečinkov."
+
+# Bash používa case, ktorý funguje podobne ako switch v Jave a C++:
+case "$Premenna" in
+    #Zoznam vzorov pre podmienky
+    0) echo "Je to nula.";;
+    1) echo "Je to jednotka.";;
+    *) echo "Nie je to null.";;
+esac
+
+# for-cyklus iteruje cez všetky argumenty:
+# Obsah premennej $Premenna sa vypíše trikrát.
+for Premenna in {1..3}
+do
+    echo "$Premenna"
+done
+
+# Alebo "tradičným" spôsobom:
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Môžu sa použiť aj na súbory..
+# Toto spustí príkaz 'cat' na subor1 a subor2
+for Premenna in subor1 subor2
+do
+    cat "$Premenna"
+done
+
+# ..alebo na výstup príkazu.
+# Toto použije príkaz cat na výstup z ls.
+for Vystup in $(ls)
+do
+    cat "$Vystup"
+done
+
+# while-cykklus:
+while [ true ]
+do
+    echo "telo cyklu..."
+    break
+done
+
+# Môžeš tiež definovať funkice
+# Definícia:
+function foo ()
+{
+    echo "Argumenty fungujú rovnako ako pri skriptoch: $@"
+    echo "A: $1 $2..."
+    echo "Toto je funkcia"
+    return 0
+}
+
+# alebo jednoducho
+bar ()
+{
+    echo "Iný spôsob definície funkcií"
+    return 0
+}
+
+# Volanie funkcie
+foo "Moje meno je" $Meno
+
+# Existuje veľa užitočných príkazov, ktoré sa oplatí naučiť:
+# vypíše posledných 10 riadkov zo subor.txt
+tail -n 10 subor.txt
+# vypíše prvých 10 riadkov zo subor.txt
+head -n 10 subor.txt
+# zotriedi riadky zo subor.txt
+sort subor.txt
+# vypíše alebo vynechá opakované riadky, použitím -d ich vypíše
+uniq -d subor.txt
+# vypíše iba prvý stĺpecpred znakom ','
+cut -d ',' -f 1 subor.txt
+# nahradí každý výskyt 'oukej' za 'super' v subor.txt (možnosť použiť regex)
+sed -i 's/oukej/super/g' subor.txt
+# vypíše všetky riadky zo subor.txt ktoré vyhovujú regexu
+# ukážka vypíše riadky ktoré začínajú s "foo" a končia s "bar"
+grep "^foo.*bar$" subor.txt
+# pre výpis počtu riadkov vyhovujúcich regexu slúži "-c"
+grep -c "^foo.*bar$" subor.txt
+# pre vyhľadávanie reťazca bez regexu slúži fgrep (alebo grep -F)
+fgrep "^foo.*bar$" subor.txt
+
+
+# Prečítaj si dokumentáciu k Bash shellu použitím príkazu 'help':
+help
+help help
+help for
+help return
+help source
+help .
+
+# Prečítaj si Bash manpage dokumentáciu príkazom 'man'
+apropos bash
+man 1 bash
+man bash
+
+# Prečítaj si info dokumentáciu pomocou 'info' (? pre help)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Prečítaj si bash info dokumentáciu:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/sk-sk/coffeescript.html.markdown b/sk-sk/coffeescript.html.markdown
new file mode 100644
index 00000000..30bbceec
--- /dev/null
+++ b/sk-sk/coffeescript.html.markdown
@@ -0,0 +1,108 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+  - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+filename: coffeescript-fr.coffee
+---
+
+CoffeeScript je jazyk, ktorý sa kompiluje do ekvivalentného JavaScriptu,
+neexistuje peňho interpretácia počas behu programu (runtime).
+CoffeeScript sa snaží vytvárať čitateľný, pekne formátovaný a optimalizovaný
+JavaScriptový kód pracujúci pod každým JavaScriptovým prostredím.
+
+Pozri tiež [stránku CoffeeScript](http://coffeescript.org/), ktoré obsahuje kompletný tutoriál o CoffeeScripte.
+
+```coffeescript
+# CoffeeScript je jazyk hipsterov.
+# Ide s trendom mnohých moderných jazykov.
+# Komentáre sú podobné tým v Ruby a Pythone, používajú symbol #.
+
+###
+Blokové komentáre vyzerajú takto, prekladajú sa priamo do '/ * ... * /'
+pre výsledný kód JavaScriptu.
+
+Predtým, než budeš pokračovať, mal by si rozumieť sémantike JavaScriptu.
+###
+
+# Priradenia:
+cislo = 42   #=> var cislo = 42;
+opak  = true #=> var opak = true;
+
+# Podmienky:
+cislo = -42 if opak #=> if(opak) { cislo = -42; }
+
+# Funkcie:
+stvorec = (x) -> x * x #=> var stvorec = function(x) { return x * x; }
+
+vypln = (nadoba, tekutina = "káva") ->
+  "#{nadoba} sa napĺňa tekutinou #{tekutina}..."
+#=>var vypln;
+#
+#vypln = function(nadoba, tekutina) {
+#  if (tekutina == null) {
+#    tekutina = "káva";
+#  }
+#  return nadoba + " sa napĺňa tekutinou " + tekutina + "...";
+#};
+
+# Rozsahy:
+zoznam = [1..5] #=> var zoznam = [1, 2, 3, 4, 5];
+
+# Objekty:
+matika =
+  zaklad:  Math.sqrt
+  stvorec: square
+  kocka:   (x) -> x * square x
+#=> var matika = {
+#  "zaklad": Math.sqrt,
+#  "stvorec": square,
+#  "kocka": function(x) { return x * square(x); }
+#}
+
+# Splat operátor:
+zavod = (vitaz, bezci...) ->
+  print vitaz, bezci
+#=>zavod = function() {
+#  var vitaz, bezci;
+#  vitaz = arguments[0],
+#  bezci = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#  return print(vitaz, bezci);
+#};
+
+# Existencia:
+alert "Vedel som to!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null)
+# { alert("Vedel som to!"); }
+
+# Pole:
+kocky = (matika.kocka cislo for cislo in zoznam)
+#=>kocky = (function() {
+#	var _i, _len, _results;
+#	_results = [];
+# 	for (_i = 0, _len = zoznam.length; _i < _len; _i++) {
+#		cislo = zoznam[_i];
+#		_results.push(matika.kocka(cislo));
+#	}
+#	return _results;
+#  })();
+
+jedla = ['brokolica', 'špenát', 'čokoláda']
+zjedz jedlo for jedlo in jedla when jedlo isnt 'čokoláda'
+#=>jedla = ['brokolica', 'špenát', 'čokoláda'];
+#
+#for (_k = 0, _len2 = jedla.length; _k < _len2; _k++) {
+#  jedlo = jedla[_k];
+#  if (jedlo !== 'čokoláda') {
+#    zjedz(jedlo);
+#  }
+#}
+```
+
+## Ďalšie zdroje
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
diff --git a/sk-sk/elixir.html.markdown b/sk-sk/elixir.html.markdown
new file mode 100644
index 00000000..2401f92e
--- /dev/null
+++ b/sk-sk/elixir.html.markdown
@@ -0,0 +1,470 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+translators:
+  - ["Peter Szatmary", "https://github.com/peterszatmary"]
+lang: sk-sk
+filename: learnelixir-sk.ex
+---
+
+Elixir je moderný funkcionálny jazyk vytvorený nad Erlang VM (virtuálnym
+strojom). Je plne kompatibilný s Erlangom, ale ponúka viac štandardnú syntax
+a množstvo funkcií.
+
+```Elixir
+
+# Jednoriadkový komentár začína symbolom #
+
+# Neexistuje viacriadkový komentár, avšak je možné vyskladať za sebou viac
+# jednoriadkových komentárov.
+
+# Pre spustenie Elixir shellu zadajte príkaz `iex`
+# Kompiláciu zdrojových kódov vykonáte príkazom `elixirc`
+
+# Obe príkazy by sa už mali nachádzať v path pokiaľ ste nainštalovali elixir
+# správne.
+
+## ---------------------------
+## -- Základné typy
+## ---------------------------
+
+# Čísla
+3    # integer
+0x1F # integer
+3.0  # float
+
+# Atómy, sú literály, konštanty s rovnakým menom. Začínajú s `:`.
+:ahoj # atom
+
+# Tzv. Tuples sú v pamäti uložené súvisle.
+{1,2,3} # tuple
+
+# Pristúpiť k tuple elementu vieme pomocou funkcie `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Zoznamy sú implementované ako linkované zoznamy.
+[1,2,3] # zoznam
+
+# Vieme pristúpiť k hlavičke (head) a chvostu (tail) zoznamu:
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# V Elixire, rovnako ako v Erlangu, `=` znamená pattern matching a nie
+# klasické priradenie.
+#
+# To znamená, že ľavá strana (pattern / vzor) je postavená oproti pravej
+# strane.
+#
+# Takto funguje aj príklad vyššie s čítaním hlavičky a chvosta zoznamu.
+
+# Pattern match končí chybou ak sa obe strany nezhodujú, v tomto príklade majú
+# tuples rôznu veľkosť.
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Binárne typy
+<<1,2,3>> # binary
+
+# Reťazce a zoznamy znakov
+"ahoj" # reťazec
+'ahoj' # zoznam znakov
+
+# Viacriadkový reťazec
+"""
+Ja som viacriadkový
+reťazec.
+"""
+#=> "Ja som viacriadkový\nreťazec.\n"
+
+# Reťazce sú kódované v UTF-8:
+"héllò" #=> "héllò"
+
+# Reťazce sú skutočne iba binárne typy, a zoznamy znakov sú iba zoznamy.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` v elixire vráti ASCII číselnú reprezentáciu pre znak `a`
+?a #=> 97
+
+# Pre spájanie zoznamov sa používa `++`, pre binárne typy `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'ahoj ' ++ 'svet'  #=> 'ahoj svet'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"Ahoj " <> "svet"  #=> "ahoj svet"
+
+# Rozsahy sú reprezentované ako `začiatok..koniec` (obe inkluzívne)
+1..10 #=> 1..10
+dolna..horna = 1..10 # Na rozsahy možno použiť rovnako pattern matching
+[dolna, horna] #=> [1, 10]
+
+# Mapy sú páry kľúč-hodnota
+pohlavia = %{"david" => "muž", "gillian" => "žena"}
+pohlavia["david"] #=> "muž"
+
+# Mapy s kľúčmi reprezentovanými atómami môžu byť použité takto
+pohlavia = %{david: "muž", gillian: "žena"}
+pohlavia.gillian #=> "žena"
+
+## ---------------------------
+## -- Operátory
+## ---------------------------
+
+# Trošku matematiky
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# V elixire operátor `/` vždy vráti float (reálne číslo).
+
+# Pre celočíselné delenie sa používa `div`
+div(10, 2) #=> 5
+
+# Pre celočíselné delenie so zvyškom `rem`
+rem(10, 3) #=> 1
+
+# Boolean operátory: `or`, `and` a `not`.
+# Tieto operátori očakávajú ako svoj prvý argument boolean.
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir tiež poskytuje `||`, `&&` a `!` , ktoré akceptujú argumenty
+# ľubovoľného typu.
+# Všetky hodnoty okrem `false` a `nil` budú vyhodnotené ako true.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Pre porovnávanie máme: `==`, `!=`, `===`, `!==`, `<=`,
+`>=`, `<` a `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` a `!==` sú viac striktné pri porovnávaní celých čísel (integer) a
+# desatinných čísel (float).
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Vieme porovnať dokonca dva rôzne údajové typy:
+1 < :ahoj #=> true
+
+# Celkové poradie triedenia:
+#
+# číslo < atom < referencia < funkcia < port < pid < tuple < zoznam < bitový
+# string
+
+# Výrok Joe Armstronga: "Aktuálne poradie nie je dôležité, ale
+# dôležité je to, že celkové poradie je dobre definované."
+
+## ---------------------------
+## -- Riadenie toku
+## ---------------------------
+
+# `if` výraz
+if false do
+  "Toto nebude nikdy videné"
+else
+  "Toto bude"
+end
+
+# Existuje aj `unless`
+unless true do
+  "Toto nebude nikdy videné"
+else
+  "Toto bude"
+end
+
+# Pamätáte sa na pattern matching? Mnoho štruktúr pre riadenie toku v
+# elixire sa spoliehajú práve na pattern matching.
+
+# `case` dovolí nám porovnať hodnotu oproti mnohým vzorom:
+case {:one, :two} do
+  {:four, :five} ->
+    "Toto nebude zhodné"
+  {:one, x} ->
+    "Toto bude zhodné a nastaví `x` na hodnotu `:two` "
+  _ ->
+    "Toto bude zhodné z ľubovoľnou hodnotou."
+end
+
+# Je zvyčajné nastaviť hodnotu do `_` ak ju nepotrebujete.
+# Napríklad, ak je pre nás potrebná iba hlavička zoznamu (head):
+[head | _] = [1,2,3]
+head #=> 1
+
+# Pre lepšiu čitateľnosť môžme urobiť nasledovné:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` dovoľuje kontrolovať viac podmienok naraz.
+# Použite `cond` namiesto vnorovania mnohých `if` výrazov.
+cond do
+  1 + 1 == 3 ->
+    "Nebudem nikdy videný"
+  2 * 5 == 12 ->
+    "Ani ja"
+  1 + 2 == 3 ->
+    "Ja budem"
+end
+
+# Je bežné nastaviť poslednú podmienku rovnajúcu sa `true` , ktorá bude vždy
+# zodpovedať.
+cond do
+  1 + 1 == 3 ->
+    "Nebudem nikdy videný"
+  2 * 5 == 12 ->
+    "Ani ja"
+  true ->
+    "Ale ja budem (je to v podstate vetva else)"
+end
+
+# `try/catch` sa používa na zachytenie hodnôt, ktoré boli vyhodené, takisto
+# podporuje `after` klauzulu, ktorá je zavolaná vždy, či bola hodnota
+# zachytená alebo nie.
+try do
+  throw(:ahoj)
+catch
+  message -> "Mám #{message}."
+after
+  IO.puts("Som after klauzula.")
+end
+#=> Som after klauzula
+# "Mám :ahoj"
+
+## ---------------------------
+## -- Moduly a funkcie
+## ---------------------------
+
+# Anonymné funkcie (všimnite si bodku)
+stvorec = fn(x) -> x * x end
+stvorec.(5) #=> 25
+
+# Takisto akceptujú viax klauzúl a tzv. stráže (guards).
+# Stráže vám umožnia pattern matching ešte viac zlepšiť, tieto časti sú
+# označené kľúčovým slovom `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir tiež poskytuje množstvo vstavaných funkcií.
+# Tie sú dostupné v aktuálnom scope (viditeľnej oblasti).
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Možno zgrupovať viac funkcií do jedného modulu. V module použite `def`
+# na definíciu funkcie.
+defmodule Matematika do
+  def sucet(a, b) do
+    a + b
+  end
+
+  def na_druhu(x) do
+    x * x
+  end
+end
+
+Matematika.sucet(1, 2)  #=> 3
+Matematika.na_druhu(3) #=> 9
+
+# Na zkompilovanie našeho Matematika modulu ho uložte ako `math.ex`  a použite
+# `elixirc` v termináli: elixirc math.ex
+
+# V module môžme definovať funkcie s `def` a privátne funkcie s `defp`.
+# Funkcia definovaná s `def` je možné volať z iných modulov, privátne funkcie
+# môžu byť volané iba lokálne.
+defmodule SukromnaMatematika do
+  def sucet(a, b) do
+    rob_sucet(a, b)
+  end
+
+  defp rob_sucet(a, b) do
+    a + b
+  end
+end
+
+SukromnaMatematika.sucet(1, 2)    #=> 3
+# SukromnaMatematika.rob_sucet(1, 2) #=> ** (UndefinedFunctionError)
+
+# Deklarácie funkcií tiež podporujú stráže (guards) a viacnásobné klauzuly:
+
+defmodule Geometria do
+  def oblast({:obdlznik, w, h}) do
+    w * h
+  end
+
+  def oblast({:kruh, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometria.oblast({:obdlznik, 2, 3}) #=> 6
+Geometria.oblast({:kruh, 3})       #=> 28.25999999999999801048
+# Geometria.oblast({:kruh, "nie_je_cislo"})
+#=> ** (FunctionClauseError) no function clause matching in Geometria.oblast/1
+
+# Vďaka nemeniteľnosti (immutability) je rekurzia významnou časťou elixiru
+defmodule Rekurzia do
+  def sumuj_zoznam([hlavicka | schvost], acc) do
+    sumuj_zoznam(chvost, acc + hlavicka)
+  end
+
+  def sumuj_zoznam([], acc) do
+    acc
+  end
+end
+
+Rekurzia.sumuj_zoznam([1,2,3], 0) #=> 6
+
+# Elixir moduly podporujú atribúty, existujú vstavané atribúty a takisto
+# môžte pridávať vlastné.
+defmodule MojModul do
+  @moduledoc """
+  Toto je vstavaný atribút v príkladovom module.
+  """
+
+  @moj_udaj 100 # Toto je vlastný atribút.
+  IO.inspect(@moj_udaj) #=> 100
+end
+
+# Pipe operátor (rúra) |> umožnuje predať výsledok výrazu ako prvý parameter
+# do ďalšej funkcie.
+
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Štruktúry a výnimky
+## ---------------------------
+
+# Štruktúry sú rozšírenia postavené na mapách, ktoré prinášajú defaultné
+# hodnoty, garancie v čase kompilácie a polymorfizmus do Elixiru.
+defmodule Osoba do
+  defstruct meno: nil, vek: 0, vyska: 0
+end
+
+joe_info = %Osoba{ meno: "Joe", vek: 30, vyska: 180 }
+#=> %Osoba{vek: 30, vyska: 180, meno: "Joe"}
+
+# Prístup k hodnote mena
+joe_info.meno #=> "Joe"
+
+# Zmena hodnoty veku
+starsi_joe_info = %{ joe_info | vek: 31 }
+#=> %Osoba{vek: 31, vyska: 180, meno: "Joe"}
+
+# `try` blok s kľúčovým slovom `rescue` sa používa na riadenie výnimiek
+try do
+  raise "nejaký error"
+rescue
+  RuntimeError -> "zachytí runtime error"
+  _error -> "zachytí ľubovoľný iný error"
+end
+#=> "zachytí runtime error"
+
+# Každá výnimka má správu
+try do
+  raise "nejaký error"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "nejaký error"
+
+## ---------------------------
+## -- Konkurencia
+## ---------------------------
+
+# Elixir sa pri konkurencii spolieha na Actor model. Všetko čo je
+# potrebné na písanie konkuretných programov v elixire sú tri primitívy:
+# spawning procesy, posielanie a prijímanie správ.
+
+# Na spustnenie nového procesu použijeme `spawn` funkciu, ktorá má ako
+# parameter funkciu.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` vracia pid (identifikátor procesu), tento pid možno použiť na
+# posielanie správ procesu. Správu pošleme `send` operatorátorom.
+# Aby všetko fungovalo ako má, potrebujeme byť schopný správu prijať. To
+# dosiahneme s `receive` mechanizmom:
+
+# `receive do` blok sa používa na počúvanie správ a ich spracúvavanie v čase
+# prijatia. `receive do` blok spracuje iba jednu prijatú správu. Pre
+# spracovanie viacerých správ, musí funkcia s `receive do` blokom rekurzívne
+# volať samu seba, aby sa dostala opäť do `receive do` bloku.
+
+defmodule Geometria do
+  def slucka_oblasti do
+    receive do
+      {:obdlznik, w, h} ->
+        IO.puts("Oblast = #{w * h}")
+        slucka_oblasti()
+      {:kruh, r} ->
+        IO.puts("Oblast = #{3.14 * r * r}")
+        slucka_oblasti()
+    end
+  end
+end
+
+# Kompiluj modul a vytvor proces, ktorý vyhodnotí `slucka_oblasti` v shelli
+
+pid = spawn(fn -> Geometria.slucka_oblasti() end) #=> #PID<0.40.0>
+# Alternatívne
+pid = spawn(Geometria, :slucka_oblasti, [])
+
+# Pošli správu ku `pid`, ktorá bude v zhode so vzorom v receive časti
+send pid, {:obdlznik, 2, 3}
+#=> Oblast = 6
+#   {:obdlznik,2,3}
+
+send pid, {:kruh, 2}
+#=> Oblast = 12.56000000000000049738
+#   {:kruh,2}
+
+# Shell je takisto proces, môžete použiť `self` pre zistenie aktuálneho pid-u
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agenti
+## ---------------------------
+
+# Agent je proces, ktorý udržuje informácie o meniacej sa hodnote
+
+# Vytvor agenta s `Agent.start_link` parametrom, ktorého je funkcia
+# Iniciálny stav agenta bude čokoľvek, čo daná funkcia vráti
+{ok, moj_agent} = Agent.start_link(fn -> ["cervena, zelena"] end)
+
+# `Agent.get` vezme meno agenta a `fn` , ktorej je odovzdaný aktuálny stav
+# Čokoľvek čo `fn` vráti je to, čo dostanete späť
+Agent.get(moj_agent, fn farby -> farby end) #=> ["cervena, "zelena"]
+
+# Zmena stavu agenta rovnakým spôsobom
+Agent.update(moj_agent, fn farby -> ["modra" | farby] end)
+```
+
+## Referencie
+
+* [Začíname](http://elixir-lang.org/getting-started/introduction.html) z
+[Elixir stránky](http://elixir-lang.org)
+* [Elixir dokumentácia](http://elixir-lang.org/docs/master/)
+* [Elixir programovanie](https://pragprog.com/book/elixir/programming-elixir)
+ od Dave Thomasa
+* [Elixir ťahák](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* [Nauč sa kúsok Erlangu pre veľké dobro!](http://learnyousomeerlang.com/) od
+Freda Heberta
+* [Erlang programovanie: Softvér pre konkurentný svet](https://pragprog
+.com/book/jaerlang2/programming-erlang) od Joe Armstronga
diff --git a/sk-sk/json.html.markdown b/sk-sk/json.html.markdown
new file mode 100644
index 00000000..2b1fbb58
--- /dev/null
+++ b/sk-sk/json.html.markdown
@@ -0,0 +1,61 @@
+---
+language: json
+filename: learnjson-sk.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+  - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+---
+
+Nakoľko je JSON extrémne jednoduchý formát na výmenu dát, toto bude
+pravdepodobne najjednoduchšie "Learn X in Y Minutes".
+
+JSON v jeho základnej forme nemá komentáre, ale veľa parserov akceptuje
+komentáre v štýle C (`//`, `/* */`). V tomto návode však bude všetko
+100% valídny JSON.
+
+```json
+{
+  "kľúč": "hodnota",
+
+  "kľúč": "musí byť vždy uzavretý v dvojitých uvodzovkách",
+  "čísla": 0,
+  "reťazce": "Ahøj, svet. Unicode je povolený pri použití \"únikovej sekvencie (escaping)\".",
+  "boolean?": true,
+  "nič": null,
+
+  "veľké číslo": 1.2e+100,
+
+  "objekty": {
+    "komentár": "Väčšina štruktúry bude pochádzať z objektov.",
+
+    "pole": [0, 1, 2, 3, "Pole môže obsahovať čokoľvek.", 5],
+
+    "iný objekt": {
+      "komentár": "Môžu byť vhniezdené, čo môže byť užitočné."
+    }
+  },
+
+  "nezmysly": [
+    {
+      "zdroje draslíka": ["banány"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "alternatívny štýl": {
+    "komentár": "sleduj toto!"
+  , "pozícia čiarky": "nezáleží na nej - pokiaľ je pred hodnotou, všetko je ok"
+  , "iný komentár": "pekné, že?"
+  },
+
+  "to bolo rýchle": "A už sme aj na konci. Teraz ovládš všetko, čo ti JSON môže ponúknuť."
+}
+```
diff --git a/sk-sk/ruby.html.markdown b/sk-sk/ruby.html.markdown
new file mode 100644
index 00000000..799865b0
--- /dev/null
+++ b/sk-sk/ruby.html.markdown
@@ -0,0 +1,553 @@
+---
+language: ruby
+filename: learnruby-sk.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+translators:
+  - ["Juraj Kostolanský", "http://www.kostolansky.sk"]
+lang: sk-sk
+---
+
+```ruby
+# Toto je komentár
+
+=begin
+Toto je viacriadkový komentár
+Nikto ho nepoužíva
+Ani ty by si nemal
+=end
+
+# V prvom rade: Všetko je objekt.
+
+# Čísla sú objekty
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Základná aritmetika
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+
+# Aritmetika je iba syntaktickým cukrom
+# pre volanie metódy nad objektom
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Špeciálne hodnoty sú objektami
+nil # nič
+true # pravda
+false # lož
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Rovnosť
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Nerovnosť
+1 != 1 #=> false
+2 != 1 #=> true
+
+# Okrem samotného false, nil je jedinou ďalšou 'nepravdivou' hodnotou
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Ďalšie porovnania
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Logické operácie
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Existujú aj alternatívne verzie logických operátorov s nižšou prioritou.
+# Tie sa využívajú ako konštrukcie pre riadenie toku na reťazenie výrazov
+# kým jeden z nich nevráti true alebo false.
+
+# `sprav_nieco_ine` sa vykoná ak bude `sprav_nieco` úspešné (vráti true)
+sprav_nieco() and sprav_nieco_ine()
+# `zaznamenaj_chybu` sa vykoná ak `sprav_nieco` neuspeje (vráti false)
+sprav_nieco() or zaznamenaj_chybu()
+
+
+# Reťazce sú objekty
+
+'Ja som reťazec'.class #=> String
+"Ja som tiež reťazec".class #=> String
+
+retazec = 'použiť interpoláciu reťazca'
+"Môžem #{retazec} pri použití dvojitých úvodzoviek"
+#=> "Môžem použiť interpoláciu reťazca pri použití dvojitých úvodzoviek"
+
+# Preferuj jednoduché úvodzovky pred dvojitými, ak je to možné
+# Dvojité úvodzovky totiž vyžadujú ďalšie výpočty
+
+# Kombinuj reťazce, ale nie s číslami
+'ahoj ' + 'svet'  #=> "ahoj svet"
+'ahoj ' + 3 #=> TypeError: can't convert Fixnum into String
+'ahoj ' + 3.to_s #=> "ahoj 3"
+
+# Výpis na štandardný výstup
+puts "Píšem!"
+
+
+# Premenné
+x = 25 #=> 25
+x #=> 25
+
+# Všimni si, že priradenie vracia priradenú hodnotu
+# To umožňuje viacnásobné priradenie:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Podľa konvencie sa pre mená premenných využíva snake_case
+snake_case = true
+
+# Používaj správne (opisné) mená premenných
+cesta_ku_korenovemu_adresaru = '/dobre/meno/'
+cesta = '/zle/meno/'
+
+
+# Symboly (sú objektami)
+# Symboly sú nemenné znovupoužiteľné konštanty, ktoré sú interne
+# reprezentované ako číslo. Často sa používajú namiesto reťazcov
+# pre efektívnu reprezentáciu špecifickej hodnoty.
+
+:cakajuci.class #=> Symbol
+
+status = :cakajuci
+
+status == :cakajuci #=> true
+
+status == 'cakajuci' #=> false
+
+status == :schvaleny #=> false
+
+
+# Polia
+
+# Toto je pole
+pole = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Polia môžu obsahovať rôzne typy objektov
+
+[1, 'ahoj', false] #=> [1, "ahoj", false]
+
+# Polia môžu byť indexované
+# Od začiatku
+pole[0] #=> 1
+pole[12] #=> nil
+
+# Podobne ako pri aritmetike, prístup prostredníctvom [var]
+# je iba syntaktickým cukrom pre volanie metódy [] nad objektom
+pole.[] 0 #=> 1
+pole.[] 12 #=> nil
+
+# Od konca
+pole[-1] #=> 5
+
+# Pomocou počiatočného indexu a dĺžky
+pole[2, 3] #=> [3, 4, 5]
+
+# Alebo rozsahom
+pole[1..3] #=> [2, 3, 4]
+
+# Pridanie prvku do pola
+pole << 6 #=> [1, 2, 3, 4, 5, 6]
+# Alebo takto
+pole.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Skontroluje, či už je objekt v poli
+pole.include?(1) #=> true
+
+
+# Asociatívne polia (hash) sú slovníkmi s dvojicami kľúč-hodnota.
+# Asociatívne polia sú označované kučeravými zátvorkami:
+asoc_pole = { 'farba' => 'zelena', 'cislo' => 5 }
+
+asoc_pole.keys #=> ['farba', 'cislo']
+
+# V asociatívnych poliach sa rýchlo vyhľadáva pomocou kľúča
+asoc_pole['farba'] #=> 'zelena'
+asoc_pole['cislo'] #=> 5
+
+# Asking a hash for a key that doesn't exist returns nil:
+asoc_pole['nic tu nie je'] #=> nil
+
+# Od verzie Ruby 1.9 existuje špeciálna syntax,
+# pri ktorej sa využíva symbol ako kľúč
+
+nove_asoc_pole = { defcon: 3, akcia: true }
+nove_asoc_pole.keys #=> [:defcon, :akcia]
+
+# Skontroluje existenciu kľúča a hodnoty v asociatívnom poli
+nove_asoc_pole.has_key?(:defcon) #=> true
+nove_asoc_pole.has_value?(3) #=> true
+
+# Tip: Polia aj asociatívne polia sú vypočítateľné (Enumerable)
+# Zdieľajú veľa užitočných metód ako each, map, count a ďalšie
+
+
+# Štruktúry riadenia
+
+if true
+  'if podmienka'
+elsif false
+  'else if, voliteľná vetva'
+else
+  'else, tiež voliteľná vetva'
+end
+
+for pocitadlo in 1..5
+  puts "iterácia #{pocitadlo}"
+end
+#=> iterácia 1
+#=> iterácia 2
+#=> iterácia 3
+#=> iterácia 4
+#=> iterácia 5
+
+# NIKTO však nepoužíva for cyklus
+# Aj ty by si mal preferovať metódu "each" a podať jej blok
+# Blok kus kódu, ktorý môžeš podať metódam ako "each"
+# Je podobný lambdám alebo anonymným funkciám v iných jazykoch
+#
+# Metóda "each" pre rozsah spustí blokpre každý element tohto rozsahu
+# Blok získava počítadlo ako parameter
+# Volanie metódy "each" s blokomvyzerá takto:
+
+(1..5).each do |pocitadlo|
+  puts "iterácia #{pocitadlo}"
+end
+#=> iterácia 1
+#=> iterácia 2
+#=> iterácia 3
+#=> iterácia 4
+#=> iterácia 5
+
+# Blok môže byť uzavretý aj v kučeravých záítvorkách:
+(1..5).each { |pocitadlo| puts "iterácia #{pocitadlo}" }
+
+# Obsah dátových štruktúr môže byť tiež prechádzaný pomocou metódy "each"
+pole.each do |prvok|
+  puts "#{prvok} je súčasťou pola"
+end
+asoc_pole.each do |kluc, hodnota|
+  puts "#{kluc} je #{hodnota}"
+end
+
+pocitadlo = 1
+while pocitadlo <= 5 do
+  puts "iterácia #{pocitadlo}"
+  pocitadlo += 1
+end
+#=> iterácia 1
+#=> iterácia 2
+#=> iterácia 3
+#=> iterácia 4
+#=> iterácia 5
+
+znamka = 'B'
+
+case znamka
+when 'A'
+  puts 'Len tak ďalej, chlapče'
+when 'B'
+  puts 'Viac šťastia nabudúce'
+when 'C'
+  puts 'Zvládneš to aj lepšie'
+when 'D'
+  puts 'S odratými ušami'
+when 'F'
+  puts 'Zlyhal si!'
+else
+  puts 'Iný systém známkovania, čo?'
+end
+#=> "Viac šťastia nabudúce"
+
+# prípady (cases) môžu tiež využívať rozsahy
+znamka = 82
+case znamka
+when 90..100
+  puts 'Hurá!'
+when 80...90
+  puts 'Dobrá práca'
+else
+  puts 'Zlyhal si!'
+end
+#=> "Dobrá práca"
+
+# Zaobchádzanie s výnimkami
+begin
+  # kód, ktorý môže vyhodiť výnimku
+  raise NoMemoryError, 'Došla ti pamäť.'
+rescue NoMemoryError => premenna_vynimky
+  puts 'Nastala vynimka NoMemoryError', premenna_vynimky
+rescue RuntimeError => ina_premenna_vynimky
+  puts 'Nastala vynimka RuntimeError'
+else
+  puts 'Toto sa spustí, ak nenastala žiadna výnimka'
+ensure
+  puts 'Táto časť kódu sa spustí vždy'
+end
+
+# Funkcie
+
+def zdvojnasob(x)
+  x * 2
+end
+
+# Funkcie (a bloky) implicitne vracajú hodnotu posledného výrazu
+zdvojnasob(2) #=> 4
+
+# Zátvorky sú voliteľné ak je výsledok jednoznačný
+zdvojnasob 3 #=> 6
+
+zdvojnasob zdvojnasob 3 #=> 12
+
+def suma(x, y)
+  x + y
+end
+
+# Argumenty metódy sa oddeľujú čiarkami
+suma 3, 4 #=> 7
+
+suma suma(3, 4), 5 #=> 12
+
+# yield
+# Všetky metódy majú implicitný, voliteľný parameter bloku
+# môže byť zavolaný ako kľúčové slovo 'yield'
+
+def obal
+  puts '{'
+  yield
+  puts '}'
+end
+
+obal { puts 'ahoj svet' }
+
+# {
+# ahoj svet
+# }
+
+
+# Funkcii môžeš odovzdať blok
+# "&" označuje referenciu na tento blok
+def hostia(&blok)
+  blok.call 'nejake argumenty'
+end
+
+# Tiež môžeš odovzdať zoznam argumentov, ktoré sa prevedú na pole
+# Na to sa využíva operátor "*"
+def hostia(*pole)
+  pole.each { |host| puts host }
+end
+
+
+# Trieda sa definuje kľúčovým slovom class
+class Clovek
+
+  # Premenná triedy. Je zdieľaná všetkými inštanciami tejto triedy.
+  @@druh = 'H. sapiens'
+
+  # Jednoduchý inicializátor
+  def initialize(meno, vek = 0)
+    # Priradí argument k premennej inštancie "meno"
+    @meno = meno
+    # Ak nie je uvedený vek, použije sa špecifikovaná predvolená hodnota
+    @vek = vek
+  end
+
+  # Jednoduchá metóda pre nastavenie hodnoty premennej
+  def meno=(meno)
+    @meno = meno
+  end
+
+  # Jednoduchá metóda pre získanie hodnoty premennej
+  def meno
+    @meno
+  end
+
+  # Vyššie uvedená funkcionalita môže byť zapúzdrená použitím
+  # metódy attr_accessor
+  attr_accessor :meno
+
+  # Metódy pre nastavenie a získanie hodnoty premennej môžu byť vytvorené
+  # aj individuálne
+  attr_reader :meno
+  attr_writer :meno
+
+  # Metóda triedy používa kľúčové slovo self pre odlíšenie
+  # od metód inštancií. Môže byť volaná iba nad triedou, nie inštanciou.
+  def self.povedz(sprava)
+    puts sprava
+  end
+
+  def druh
+    @@druh
+  end
+end
+
+
+# Vytvorenie inštancie triedy
+jim = Clovek.new('Jim Halpert')
+
+dwight = Clovek.new('Dwight K. Schrute')
+
+# Skúsme zavolať zopár metód
+jim.druh #=> "H. sapiens"
+jim.meno #=> "Jim Halpert"
+jim.meno = "Jim Halpert II" #=> "Jim Halpert II"
+jim.meno #=> "Jim Halpert II"
+dwight.druh #=> "H. sapiens"
+dwight.meno #=> "Dwight K. Schrute"
+
+# Volanie metódy triedy
+Clovek.povedz('Ahoj') #=> "Ahoj"
+
+# Rozsah platnosti premennej je definovaná spôsobom, akým ju nazveme.
+# Premenné začínajúce znakom $ majú globálnu platnosť.
+$premenna = "Ja som globálna premenná"
+defined? $premenna #=> "global-variable"
+
+# Premenné začínajúce znakom @ majú platnosť v rámci inštancie
+@premenna = "Ja som premenná inštancie"
+defined? @premenna #=> "instance-variable"
+
+# Premenné začínajúce znakmi @@ majú platnosť v rámci triedy
+@@premenna= "Ja som premenná triedy"
+defined? @@premenna #=> "class variable"
+
+# Premenné začínajúce veľkým písmenom sú konštanty
+Premenna = "Ja som konštanta"
+defined? Premenna #=> "constant"
+
+# Trieda je tiež objektom v ruby, takže aj ona môže mať premenné inštancie.
+# Premenná triedy je zdieľaná triedou a jej nasledovníkmi.
+
+# Základná trieda
+class Clovek
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(hodnota)
+    @@foo = hodnota
+  end
+end
+
+# Odvodená trieda
+class Pracovnik < Clovek
+end
+
+Clovek.foo # 0
+Pracovnik.foo # 0
+
+Clovek.foo = 2 # 2
+Pracovnik.foo # 2
+
+# Premenné inštancie triedy nie sú zdieľané jej nasledovníkmi.
+
+class Clovek
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(hodnota)
+    @bar = hodnota
+  end
+end
+
+class Doktor < Clovek
+end
+
+Clovek.bar # 0
+Doktor.bar # nil
+
+module PrikladModulu
+  def foo
+    'foo'
+  end
+end
+
+# Vloženie modulu (include) previaže jeho metódy s inštanciou triedy.
+# Rozšírenie modulu (extend) previaže jeho metódy so samotnou triedou.
+
+class Osoba
+  include PrikladModulu
+end
+
+class Kniha
+  extend PrikladModulu
+end
+
+Osoba.foo     # => NoMethodError: undefined method `foo' for Osoba:Class
+Osoba.new.foo # => 'foo'
+Kniha.foo       # => 'foo'
+Kniha.new.foo   # => NoMethodError: undefined method `foo'
+
+# Spätné volania sú vykonané pri vložení alebo rozšírení modulu
+
+module PrikladKoncernu
+  def self.included(zaklad)
+    zaklad.extend(MetodyTriedy)
+    zaklad.send(:include, MetodyInstancie)
+  end
+
+  module MetodyTriedy
+    def bar
+      'bar'
+    end
+  end
+
+  module MetodyInstancie
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Nieco
+  include PrikladKoncernu
+end
+
+Nieco.bar     # => 'bar'
+Nieco.qux     # => NoMethodError: undefined method `qux'
+Nieco.new.bar # => NoMethodError: undefined method `bar'
+Nieco.new.qux # => 'qux'
+```
+
+## Ďalšie zdroje
+
+- [Nauč sa ruby v príkladoch s úlohami](http://www.learneroo.com/modules/61/nodes/338) - Variácia tejto referencie s úlohami v prehliadači.
+- [Oficiálna dokumentácia](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby z iných jazykov](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Staršia [bezplatná edícia](http://ruby-doc.com/docs/ProgrammingRuby/) je dostupná online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Komunitná príručka odporúčaných štýlov programovania v Ruby.
diff --git a/smallbasic.html.markdown b/smallbasic.html.markdown
new file mode 100644
index 00000000..9244525e
--- /dev/null
+++ b/smallbasic.html.markdown
@@ -0,0 +1,131 @@
+---
+language: SmallBASIC
+filename: learnsmallbasic.bas
+contributors:
+    - ["Chris Warren-Smith", "http://smallbasic.sourceforge.net"]
+---
+
+## About
+
+SmallBASIC is a fast and easy to learn BASIC language interpreter ideal for everyday calculations, scripts and prototypes. SmallBASIC includes trigonometric, matrices and algebra functions, a built in IDE, a powerful string library, system, sound, and graphic commands along with structured programming syntax.
+
+## Development
+
+SmallBASIC was originally developed by Nicholas Christopoulos in late 1999 for the Palm Pilot. Project development has been continued by Chris Warren-Smith since around 2005.
+
+Versions of SmallBASIC have been made for a number of early hand held devices including Franklin eBookman and the Nokia 770. Also various desktop versions have been released based on a variety of GUI tool-kits, some of which have become defunct. The current supported platforms are Linux and Windows based on SDL2 and Android based on NDK. A desktop command line version is also available, although not typically released in binary form.
+
+In around 2008 a large corporation released a BASIC like programming environment with a similar sounding name. SmallBASIC is not related to this other project.
+
+```
+REM This is a comment
+' and this is also a comment
+
+REM print text
+print "hello"
+? "? is short for PRINT"
+
+REM Control structures
+FOR index = 0 TO 10 STEP 2
+  ? "This is line number "; index
+NEXT
+J=0
+REPEAT
+ J++
+UNTIL J=10
+WHILE J>0
+ J--
+WEND
+
+REM Select case statement
+Select Case "Cool"
+ Case "null", 1,2,3,4,5,6,7,8,"Cool","blah"
+ Case "Not cool"
+   PRINT "Epic fail"
+ Case Else
+   PRINT "Fail"
+End Select
+
+REM catching errors with TRY/CATCH
+Try
+  fn = Freefile
+  Open filename For Input As #fn
+Catch err
+  Print "failed to open"
+End Try
+
+REM User defined subs and functions
+func add2(x,y)
+  ' variables may be declared as local within the scope of a SUB or FUNC
+  local K
+  k = "k will cease to exist when this FUNC returns"
+  add2=x+y
+end
+Print add2(5,5)
+sub print_it(it)
+  print it
+end
+print_it "IT...."
+
+REM Display lines and pixels
+At 0,ymax/2+txth("Q")
+Color 1: ? "sin(x)":
+Color 8: ? "cos(x)":
+Color 12: ? "tan(x)"
+Line 0,ymax/2,xmax,ymax/2
+For i=0 to xmax
+  Pset i,ymax/2-sin(i*2*pi/ymax)*ymax/4 color 1
+  Pset i,ymax/2-cos(i*2*pi/ymax)*ymax/4 color 8
+  Pset i,ymax/2-tan(i*2*pi/ymax)*ymax/4 color 12
+Next
+showpage
+
+REM SmallBASIC is great for experimenting with fractals and other interesting effects
+Delay 3000
+Randomize
+ff = 440.03
+For j = 0 to 20
+  r = rnd * 1000 % 255
+  b = rnd * 1000 % 255
+  g = rnd * 1000 % 255
+  c = rgb(r,b,g)
+  ff += 9.444
+  for i=0 to 25000
+    f += ff
+    x = min(xmax, -x + cos(f*i))
+    y = min(ymax, -y + sin(f*i))
+    pset x, y color c
+    if (i%1000==0) then
+      showpage
+    fi
+  next
+Next j
+
+REM For computer historians, SmallBASIC can run programs
+REM found in early computer books and magazines, for example:
+10 LET A=9
+20 LET B=7
+30 PRINT A*B
+40 PRINT A/B
+
+REM SmallBASIC also has support for a few modern concepts such as JSON
+aa = array("{\"cat\":{\"name\":\"harry\"},\"pet\":\"true\"}")
+If (ismap(aa) == false) Then
+  throw "not an map"
+End If
+Print aa
+
+PAUSE
+
+```
+
+## Articles
+
+* [Getting started](http://smallbasic.sourceforge.net/?q=node/1573)
+* [Welcome to SmallBASIC](http://smallbasic.sourceforge.net/?q=node/838)
+
+## GitHub
+
+* [Source code](https://github.com/smallbasic/SmallBASIC)
+* [Reference snapshot](http://smallbasic.github.io/)
+
diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown
index 3b388505..cc7ab84c 100644
--- a/smalltalk.html.markdown
+++ b/smalltalk.html.markdown
@@ -37,7 +37,7 @@ Feedback highly appreciated! Reach me at [@jigyasa_grover](https://twitter.com/j
 
 `"Comments are enclosed in quotes"`
 
-`"Period (.) is the statement seperator"`
+`"Period (.) is the statement separator"`
 
 ## Transcript:
 ```
@@ -305,7 +305,7 @@ result := (switch at: $B) value.
 x := 4. y := 1.
 [x > 0] whileTrue: [x := x - 1. y := y * 2].                "while true loop"
 [x >= 4] whileFalse: [x := x + 1. y := y * 2].              "while false loop"
-x timesRepeat: [y := y * 2].                                "times repear loop (i := 1 to x)"
+x timesRepeat: [y := y * 2].                                "times repeat loop (i := 1 to x)"
 1 to: x do: [:a | y := y * 2].                              "for loop"
 1 to: x by: 2 do: [:a | y := y / 2].                        "for loop with specified increment"
 #(5 4 3) do: [:a | x := x + a].                             "iterate over array elements"
@@ -320,7 +320,7 @@ y := x isUppercase.                                         "test if upper case"
 y := x isLetter.                                            "test if letter"
 y := x isDigit.                                             "test if digit"
 y := x isAlphaNumeric.                                      "test if alphanumeric"
-y := x isSeparator.                                         "test if seperator char"
+y := x isSeparator.                                         "test if separator char"
 y := x isVowel.                                             "test if vowel"
 y := x digitValue.                                          "convert to numeric digit value"
 y := x asLowercase.                                         "convert to lower case"
@@ -946,10 +946,11 @@ Utilities openCommandKeyHelp
 ### Free Online
 
 * [GNU Smalltalk User's Guide](https://www.gnu.org/software/smalltalk/manual/html_node/Tutorial.html)
-* [smalltalk dot org](http://www.smalltalk.org/smalltalk/learning.html)
+* [smalltalk dot org](http://www.smalltalk.org/)
 * [Computer Programming using GNU Smalltalk](http://www.canol.info/books/computer_programming_using_gnu_smalltalk/)
 * [Smalltalk Cheatsheet](http://www.angelfire.com/tx4/cus/notes/smalltalk.html)
 * [Smalltalk-72 Manual](http://www.bitsavers.org/pdf/xerox/parc/techReports/Smalltalk-72_Instruction_Manual_Mar76.pdf)
 * [BYTE: A Special issue on Smalltalk](https://archive.org/details/byte-magazine-1981-08)
 * [Smalltalk, Objects, and Design](https://books.google.co.in/books?id=W8_Une9cbbgC&printsec=frontcover&dq=smalltalk&hl=en&sa=X&ved=0CCIQ6AEwAWoVChMIw63Vo6CpyAIV0HGOCh3S2Alf#v=onepage&q=smalltalk&f=false)
 * [Smalltalk: An Introduction to Application Development Using VisualWorks](https://books.google.co.in/books?id=zalQAAAAMAAJ&q=smalltalk&dq=smalltalk&hl=en&sa=X&ved=0CCgQ6AEwAmoVChMIw63Vo6CpyAIV0HGOCh3S2Alf/)
+* [Smalltalk Programming Resources](http://www.whoishostingthis.com/resources/smalltalk/)
diff --git a/solidity.html.markdown b/solidity.html.markdown
index a511bbb3..602d74f0 100644
--- a/solidity.html.markdown
+++ b/solidity.html.markdown
@@ -8,7 +8,7 @@ contributors:
 
 Solidity lets you program on [Ethereum](https://www.ethereum.org/), a
 blockchain-based virtual machine that allows the creation and
-execution of smart contracts, without needing centralized or trusted parties.
+execution of smart contracts, without requiring centralized or trusted parties.
 
 Solidity is a statically typed, contract programming language that has
 similarities to Javascript and C. Like objects in OOP, each contract contains
@@ -18,8 +18,17 @@ global variables.
 
 Some Ethereum contract examples include crowdfunding, voting, and blind auctions.
 
+There is a high risk and high cost of errors in Solidity code, so you must be very careful to test
+and slowly rollout. WITH THE RAPID CHANGES IN ETHEREUM, THIS DOCUMENT IS UNLIKELY TO STAY UP TO
+DATE, SO YOU SHOULD FOLLOW THE SOLIDITY CHAT ROOM AND ETHEREUM BLOG FOR THE LATEST. ALL CODE HERE IS
+PROVIDED AS IS, WITH SUBSTANTIAL RISK OF ERRORS OR DEPRECATED CODE PATTERNS.
+
+Unlike other code, you may also need to add in design patterns like pausing, deprecation, and
+throttling usage to reduce risk. This document primarily discusses syntax, and so excludes many
+popular design patterns.
+
 As Solidity and Ethereum are under active development, experimental or beta
-features are explicitly marked, and subject to change. Pull requests welcome.
+features are typically marked, and subject to change. Pull requests welcome.
 
 ```javascript
 // First, a simple Bank contract
@@ -36,10 +45,11 @@ features are explicitly marked, and subject to change. Pull requests welcome.
 
 /* 'contract' has similarities to 'class' in other languages (class variables,
 inheritance, etc.) */
-contract SimpleBank { // CamelCase
+contract SimpleBank { // CapWords
     // Declare state variables outside function, persist through life of contract
 
     // dictionary that maps addresses to balances
+    // always be careful about overflow attacks with numbers
     mapping (address => uint) private balances;
 
     // "private" means that other contracts can't directly query balances
@@ -49,10 +59,10 @@ contract SimpleBank { // CamelCase
     // 'public' makes externally readable (not writeable) by users or contracts
 
     // Events - publicize actions to external listeners
-    event DepositMade(address accountAddress, uint amount);
+    event LogDepositMade(address accountAddress, uint amount);
 
     // Constructor, can receive one or many variables here; only one allowed
-    function AcmeBank() {
+    function SimpleBank() {
         // msg provides details about the message that's sent to the contract
         // msg.sender is contract caller (address of contract creator)
         owner = msg.sender;
@@ -65,7 +75,7 @@ contract SimpleBank { // CamelCase
         // no "this." or "self." required with state variable
         // all values set to data type's initial value by default
 
-        DepositMade(msg.sender, msg.value); // fire event
+        LogDepositMade(msg.sender, msg.value); // fire event
 
         return balances[msg.sender];
     }
@@ -76,11 +86,14 @@ contract SimpleBank { // CamelCase
     /// @return The balance remaining for the user
     function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
         if(balances[msg.sender] >= withdrawAmount) {
+            // Note the way we deduct the balance right away, before sending - due to
+            // the risk of a recursive call that allows the caller to request an amount greater
+            // than their balance
             balances[msg.sender] -= withdrawAmount;
 
             if (!msg.sender.send(withdrawAmount)) {
-                // to be safe, may be sending to contract that
-                // has overridden 'send' which may then fail
+                // increment back only on fail, as may be sending to contract that
+                // has overridden 'send' on the receipt end
                 balances[msg.sender] += withdrawAmount;
             }
         }
@@ -150,8 +163,10 @@ address public owner;
 
 // All addresses can be sent ether
 owner.send(SOME_BALANCE); // returns false on failure
-if (owner.send) {} // typically wrap in 'if', as contract addresses have
-// functions have executed on send and can fail
+if (owner.send) {} // REMEMBER: wrap in 'if', as contract addresses have
+// functions executed on send and these can fail
+// Also, make sure to deduct balances BEFORE attempting a send, as there is a risk of a recursive
+// call that can drain the contract
 
 // can override send by defining your own
 
@@ -215,9 +230,9 @@ mapping (string => uint) public balances;
 balances["charles"] = 1;
 console.log(balances["ada"]); // is 0, all non-set key values return zeroes
 // 'public' allows following from another contract
-contractName.balances("claude"); // returns 1
+contractName.balances("charles"); // returns 1
 // 'public' created a getter (but not setter) like the following:
-function balances(address _account) returns (uint balance) {
+function balances(string _account) returns (uint balance) {
     return balances[_account];
 }
 
@@ -351,8 +366,11 @@ function b() {
 // access events from outside blockchain (with lightweight clients)
 // typically declare after contract parameters
 
+// Typically, capitalized - and add Log in front to be explicit and prevent confusion
+// with a function call
+
 // Declare
-event Sent(address from, address to, uint amount); // note capital first letter
+event LogSent(address indexed from, address indexed to, uint amount); // note capital first letter
 
 // Call
 Sent(from, to, amount);
@@ -396,7 +414,10 @@ onlyIfState(State.A)
 modifier checkValue(uint amount) {
     _
     if (msg.value > amount) {
-        msg.sender.send(amount - msg.value);
+        uint amountToRefund = amount - msg.value;
+        if (!msg.sender.send(amountToRefund)) {
+            throw;
+        }
     }
 }
 
@@ -409,6 +430,21 @@ modifier checkValue(uint amount) {
 // Syntax same as javascript, but no type conversion from non-boolean
 // to boolean (comparison operators must be used to get the boolean val)
 
+// For loops that are determined by user behavior, be careful - as contracts have a maximal
+// amount of gas for a block of code - and will fail if that is exceeded
+// For example:
+for(uint x = 0; x < refundAddressList.length; x++) {
+    if (!refundAddressList[x].send(SOME_AMOUNT)) {
+       throw;
+    }
+}
+
+// Two errors above:
+// 1. A failure on send stops the loop from completing, tying up money
+// 2. This loop could be arbitrarily long (based on the amount of users who need refunds), and
+// therefore may always fail as it exceeds the max gas for a block
+// Instead, you should let people withdraw individually from their subaccount, and mark withdrawn
+
 
 // 7. OBJECTS/CONTRACTS
 
@@ -587,13 +623,13 @@ contract CrowdFunder {
     address public fundRecipient; // creator may be different than recipient
     uint public minimumToRaise; // required to tip, else everyone gets refund
     string campaignUrl;
+    byte constant version = 1;
 
     // Data structures
     enum State {
         Fundraising,
-        ExpiredRefundPending,
-        Successful,
-        ExpiredRefundComplete
+        ExpiredRefund,
+        Successful
     }
     struct Contribution {
         uint amount;
@@ -604,11 +640,11 @@ contract CrowdFunder {
     State public state = State.Fundraising; // initialize on create
     uint public totalRaised;
     uint public raiseBy;
+    uint public completeAt;
     Contribution[] contributions;
 
-    event fundingReceived(address addr, uint amount, uint currentTotal);
-    event allRefundsSent();
-    event winnerPaid(address winnerAddress);
+    event LogFundingReceived(address addr, uint amount, uint currentTotal);
+    event LogWinnerPaid(address winnerAddress);
 
     modifier inState(State _state) {
         if (state != _state) throw;
@@ -620,10 +656,13 @@ contract CrowdFunder {
         _
     }
 
+    // Wait 6 months after final contract state before allowing contract destruction
     modifier atEndOfLifecycle() {
-        if(state != State.ExpiredRefundComplete && state != State.Successful) {
+    if(!((state == State.ExpiredRefund || state == State.Successful) &&
+        completeAt + 6 months < now)) {
             throw;
         }
+        _
     }
 
     function CrowdFunder(
@@ -651,9 +690,10 @@ contract CrowdFunder {
         );
         totalRaised += msg.value;
 
-        fundingReceived(msg.sender, msg.value, totalRaised);
+        LogFundingReceived(msg.sender, msg.value, totalRaised);
 
         checkIfFundingCompleteOrExpired();
+        return contributions.length - 1; // return id
     }
 
     function checkIfFundingCompleteOrExpired() {
@@ -663,9 +703,9 @@ contract CrowdFunder {
 
             // could incentivize sender who initiated state change here
         } else if ( now > raiseBy )  {
-            state = State.ExpiredRefundPending;
-            refundAll();
+            state = State.ExpiredRefund; // backers can now collect refunds by calling getRefund(id)
         }
+        completeAt = now;
     }
 
     function payOut()
@@ -676,22 +716,27 @@ contract CrowdFunder {
             throw;
         }
 
-        winnerPaid(fundRecipient);
+
+        LogWinnerPaid(fundRecipient);
     }
 
-    function refundAll()
+    function getRefund(id)
     public
-    inState(State.ExpiredRefundPending)
+    inState(State.ExpiredRefund)
     {
-        uint length = contributions.length;
-        for (uint i = 0; i < length; i++) {
-            if(!contributions[i].contributor.send(contributions[i].amount)) {
-                throw;
-            }
+        if (contributions.length <= id || id < 0 || contributions[id].amount == 0 ) {
+            throw;
+        }
+
+        uint amountToRefund = contributions[id].amount;
+        contributions[id].amount = 0;
+
+        if(!contributions[id].contributor.send(amountToSend)) {
+            contributions[id].amount = amountToSend;
+            return false;
         }
 
-        allRefundsSent();
-        state = State.ExpiredRefundComplete;
+      return true;
     }
 
     function removeContract()
@@ -700,13 +745,13 @@ contract CrowdFunder {
     atEndOfLifecycle()
     {
         selfdestruct(msg.sender);
+        // creator gets all money that hasn't be claimed
     }
 
     function () { throw; }
 }
 // ** END EXAMPLE **
 
-
 // 10. OTHER NATIVE FUNCTIONS
 
 // Currency units
@@ -732,8 +777,14 @@ sha3("ab", "cd");
 ripemd160("abc");
 sha256("def");
 
+// 11. SECURITY
+
+// Bugs can be disastrous in Ethereum contracts - and even popular patterns in Solidity,
+// may be found to be antipatterns
 
-// 11. LOW LEVEL FUNCTIONS
+// See security links at the end of this doc
+
+// 12. LOW LEVEL FUNCTIONS
 // call - low level, not often used, does not provide type safety
 successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');
 
@@ -742,7 +793,7 @@ successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');
 someContractAddress.callcode('function_name');
 
 
-// 12. STYLE NOTES
+// 13. STYLE NOTES
 // Based on Python's PEP8 style guide
 
 // Quick summary:
@@ -753,7 +804,7 @@ someContractAddress.callcode('function_name');
 // else should be placed on own line
 
 
-// 13. NATSPEC COMENTS
+// 14. NATSPEC COMENTS
 // used for documentation, commenting, and external UIs
 
 // Contract natspec - always above contract definition
@@ -773,9 +824,8 @@ someContractAddress.callcode('function_name');
 - [Solidity Docs](https://solidity.readthedocs.org/en/latest/)
 - [Solidity Style Guide](https://ethereum.github.io/solidity//docs/style-guide/): Ethereum's style guide is heavily derived from Python's [pep8](https://www.python.org/dev/peps/pep-0008/) style guide.
 - [Browser-based Solidity Editor](http://chriseth.github.io/browser-solidity/)
-- [Gitter Chat room](https://gitter.im/ethereum/solidity)
+- [Gitter Solidity Chat room](https://gitter.im/ethereum/solidity)
 - [Modular design strategies for Ethereum Contracts](https://docs.erisindustries.com/tutorials/solidity/)
-- Editor Snippets ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
 
 ## Sample contracts
 - [Dapp Bin](https://github.com/ethereum/dapp-bin)
@@ -783,13 +833,24 @@ someContractAddress.callcode('function_name');
 - [ConsenSys Contracts](https://github.com/ConsenSys/dapp-store-contracts)
 - [State of Dapps](http://dapps.ethercasts.com/)
 
+## Security
+- [Thinking About Smart Contract Security](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Smart Contract Security](https://blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Hacking Distributed Blog](http://hackingdistributed.com/)
+
 ## Information purposefully excluded
 - Libraries
 
 ## Style
 - Python's [PEP8](https://www.python.org/dev/peps/pep-0008/) is used as the baseline style guide, including its general philosophy
 
+## Editors
+- [Vim Solidity](https://github.com/tomlion/vim-solidity)
+- Editor Snippets ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
+
 ## Future To Dos
 - New keywords: protected, inheritable
+- List of common design patterns (throttling, RNG, version upgrade)
+- Common security anti patterns
 
 Feel free to send a pull request with any edits - or email nemild -/at-/ gmail
diff --git a/standard-ml.html.markdown b/standard-ml.html.markdown
index 143980e7..c9eb2a2e 100644
--- a/standard-ml.html.markdown
+++ b/standard-ml.html.markdown
@@ -24,6 +24,12 @@ val phone_no = 5551337
 val pi = 3.14159
 val negative_number = ~15  (* Yeah, unary minus uses the 'tilde' symbol *)
 
+(* Optionally, you can explicitly declare types. This is not necessary as
+   ML will automatically figure out the types of your values. *)
+val diameter = 7926 : int
+val e = 2.718 : real
+val name = "Bobby" : string
+
 (* And just as importantly, functions: *)
 fun is_large(x : int) = if x > 37 then true else false
 
@@ -31,6 +37,8 @@ fun is_large(x : int) = if x > 37 then true else false
 val tau = 2.0 * pi         (* You can multiply two reals *)
 val twice_rent = 2 * rent  (* You can multiply two ints *)
 (* val meh = 1.25 * 10 *)  (* But you can't multiply an int and a real *)
+val yeh = 1.25 * (Real.fromInt 10) (* ...unless you explicitly convert
+                                      one or the other *)
 
 (* +, - and * are overloaded so they work for both int and real. *)
 (* The same cannot be said for division which has separate operators: *)
@@ -227,17 +235,18 @@ val hmm = answer "What is the meaning of life, the universe and everything?"
 
 (* Functions can take several arguments by taking one tuples as argument: *)
 fun solve2 (a : real, b : real, c : real) =
-    ( (~b + Math.sqrt(b * b - 4.0*a*c)) / (2.0 * a),
-      (~b - Math.sqrt(b * b - 4.0*a*c)) / (2.0 * a) )
+    ((~b + Math.sqrt(b * b - 4.0 * a * c)) / (2.0 * a),
+     (~b - Math.sqrt(b * b - 4.0 * a * c)) / (2.0 * a))
 
 (* Sometimes, the same computation is carried out several times. It makes sense
    to save and re-use the result the first time. We can use "let-bindings": *)
 fun solve2 (a : real, b : real, c : real) =
-    let val discr  = b * b - 4.0*a*c
+    let val discr  = b * b - 4.0 * a * c
         val sqr = Math.sqrt discr
         val denom = 2.0 * a
     in ((~b + sqr) / denom,
-        (~b - sqr) / denom) end
+        (~b - sqr) / denom)
+    end
 
 
 (* Pattern matching is a funky part of functional programming.  It is an
@@ -284,6 +293,9 @@ val thermometer =
 val some_result = (fn x => thermometer (x - 5) ^ thermometer (x + 5)) 37
 
 (* Here is a higher-order function that works on lists (a list combinator) *)
+(* map f l
+       applies f to each element of l from left to right, 
+       returning the list of results. *)
 val readings = [ 34, 39, 37, 38, 35, 36, 37, 37, 37 ]  (* first an int list *)
 val opinions = List.map thermometer readings (* gives [ "Cold", "Warm", ... ] *)
 
@@ -316,7 +328,11 @@ val n = op + (5, 5)   (* n is now 10 *)
 (* 'op' is useful when combined with high order functions because they expect
    functions and not operators as arguments. Most operators are really just
    infix functions. *)
-val sum_of_numbers = foldl op+ 0 [1,2,3,4,5]
+(* foldl f init [x1, x2, ..., xn]
+       returns
+       f(xn, ...f(x2, f(x1, init))...)
+       or init if the list is empty. *)
+val sum_of_numbers = foldl op+ 0 [1, 2, 3, 4, 5]
 
 
 (* Datatypes are useful for creating both simple and complex structures *)
@@ -399,7 +415,8 @@ fun writePoem(filename) =
     let val file = TextIO.openOut(filename)
         val _ = TextIO.output(file, "Roses are red,\nViolets are blue.\n")
         val _ = TextIO.output(file, "I have a gun.\nGet in the van.\n")
-    in TextIO.closeOut(file) end
+    in TextIO.closeOut(file)
+    end
 
 (* Read a nice poem from a file into a list of strings *)
 fun readPoem(filename) =
diff --git a/sv-se/brainfuck-sv.html.markdown b/sv-se/brainfuck-sv.html.markdown
new file mode 100644
index 00000000..e9fbc436
--- /dev/null
+++ b/sv-se/brainfuck-sv.html.markdown
@@ -0,0 +1,85 @@
+---
+language: brainfuck
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+    - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+    - ["Richard Lindberg", "https://github.com/Lidenburg"]
+lang: sv-se
+---
+
+Brainfuck (ej versaliserat förutom vid ny mening) är ett extremt
+minimalistiskt Turing-komplett programmeringsspråk med endast 8 kommandon.
+
+Du kan testa brainfuck i din webbläsare via [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Alla karaktärer förutom "><+-.,[]" (inte inkluderat citattecken) ignoreras.
+
+Brainfuck är representerat av ett fält med 30 000 celler initialiserade till
+noll och en data pekare som pekar på den valda cellen.
+
+Det finns åtta kommandon:
++ : Ökar värdet av den valda cellen med ett.
+- : Minskar värdet av den valda cellen med ett.
+> : Flyttar data pekaren till nästa cell (cellen till höger).
+< : Flyttar data pekaren till förra cellen (cellen till vänster).
+. : Skriver ut ASCII värdet av den valda cellen (t.ex. 65 = 'A').
+, : Läser in en karaktär till den valda cellen.
+[ : Om värdet vid den valda cellen är noll, hoppa till matchande ].
+    Annars fortsätts till nästa instruktion.
+] : Om värdet vid den valda cellen är noll, fortsätt till nästa instruktion.
+    Annars, gå tillbaka till matchande ].
+
+[ och ] formar en while loop.
+
+Nedan är ett exempel på ett simpelt brainfuck program.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Programmet skriver ut bokstaven 'A'. Först ökar den värdet av cell #1 till 6.
+Cell #1 kommer att användas för att loopa. Sen börjar den loopen (vid '[') och
+flyttar till cell #2. Den ökar värdet av cell #2 10 gånger, går tillbaka till
+cell #1 och minskar den med 1. Den gör det här 6 gånger (så många iterationer
+det tar för cell #1 att bli noll).
+
+Nu är programmet på cell #1, vilket har ett värde av 0 och cell #2 har värdet 60.
+Programmet flyttar pekaren till cell #2 och ökar värdet med 5, vilket leder till
+att cell #2 har ett värde av 65 (vilket är bokstaven 'A' i ASCII), sedan skriver
+den ut cell #2 och bokstaven 'A' skrivs ut till skärmen.
+
+
+, [ > + < - ] > .
+
+Det här programmet läser en karaktär från användaren och kopierar karaktären
+till cell #1. Sedan startas en loop. Pekaren flyttas till cell #2, värder ökas
+med ett, pekaren flyttas tillbaka till cell #1 och minskar värdet med ett.
+Det här fortsätter tills cell #1 innehåller noll och cell #2 innehåller det
+värde som cell #1 innehöll från början. Eftersom att programmet vid slutet av
+loopen är på cell #1 flyttas pekaren till cell #2 och sedan skriver den ut
+värdet av cell #2 i ASCII.
+
+Värt att komma ihåg är att programmet ovan kan skrivas utan mellanslag också:
+
+,[>+<-]>.
+
+
+Försök och lista ut vad det här programmet gör:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Programmet tar två nummer som indata, och multiplicerar dem.
+
+Kärnan av det är att den först läser in två tal/bokstäver. Sedan startar
+den yttre loopen som beror på cell #1. Sedan går den vidare till cell #2 och
+startar den innre loopen som beror på cell #2 och ökar cell #3. Men det uppstår
+ett problem: Vid slutet av den innre loopen är cell #2 noll. Vilket betyder att
+den inre loopen inte kommer att fungera tills nästa gång. För att lösa det här
+problemet ökas också cell #4 som sedan kopieras till cell #2.
+Sedan är resultatet i cell #3.
+```
+
+Och det är brainfuck. Inte så svårt va? För skojs skull kan du skriva dina egna
+brainfuck program, eller skriva en egen brainfuck interpretator i ett annat
+språk. interpretatorn är ganska simpel att implementera, men om man är en
+masochist, testa att skriva en brainfuck interpretator… i brainfuck.
diff --git a/sv-se/json-sv.html.markdown b/sv-se/json-sv.html.markdown
new file mode 100644
index 00000000..002aec2e
--- /dev/null
+++ b/sv-se/json-sv.html.markdown
@@ -0,0 +1,84 @@
+---
+language: json
+filename: learnjson-sv.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Michael Neth", "https://github.com/infernocloud"]
+translators:
+  - ["Lari Kovanen", "https://github.com/larkov"]
+  - ["Joakim Lahtinen", "https://github.com/VibyJocke"]
+lang: sv-se
+---
+
+JSON är ett extremt enkelt datautbytesformat. Som [json.org](http://json.org) beskriver så är det lätt för människor att läsa och skriva, och för datorer att tolka och generera.
+
+En bit av JSON måste representera antingen:
+* En samling av namn/värde-par (`{ }`). I olika språk kan denna realiseras som ett objekt, struct, dictionary, hash-tabell, nyckellista eller en associativ array.
+* En ordnad lista av värden (`[ ]`). I olika språk kan denna realiseras som en array, vektor, lista eller sekvens.
+
+JSON i dess renaste form har inga kommentarer, men de flesta tolkarna accepterar C-stils (`//`, `/* */`) kommentarer. Vissa tolkar tolererar även komman efter sista elementet i en array, eller det sista attributet av ett objekt, men dessa bör undvikas för bättre kompabilitet.
+
+Detta dokument kommer dock att tillämpa 100% giltigt JSON. Lyckligtvis så är resten av dokumentet självförklarande.
+
+Följande datatyper stöds:
+* Strängar: `"hello"`, `"\"A quote.\""`, `"\u0abe"`, `"Newline.\n"`
+* Nummer: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Objekt: `{ "key": "value" }`
+* Arrayer: `["Values"]`
+* Övriga: `true`, `false`, `null`
+
+```json
+{
+  "nyckel": "värde",
+
+  "nycklar": "måste alltid omslutas med dubbla citationstecken",
+  "nummer": 0,
+  "strängar": "Alla unicode-tecken (inklusive \"escaping\") är tillåtna.",
+  "boolska värden?": true,
+  "nullvärden": null,
+
+  "stora tal": 1.2e+100,
+
+  "objekt": {
+    "kommentar": "De flesta datastukturerna i JSON kommer i form av objekt.",
+
+    "matris": [0, 1, 2, 3, "Matriser kan innehålla vad som helst.", 5],
+
+    "ytterligare objekt": {
+      "kommentar": "Objekten kan vara nästlade."
+    }
+  },
+
+  "trams": [
+    {
+      "kaliumkällor": ["bananer"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "alternativ formatering": {
+    "kommentar": "kolla på detta!"
+  , "kommats position": "spelar ingen roll - så länge det kommer innan värdet"
+  , "en kommentar till": "vad fint"
+  },
+
+
+
+  "blanksteg": "Spelar ingen roll.",
+
+
+
+  "det var kort": "Nu är du klar och kan allt vad JSON har att erbjuda."
+}
+```
+
+## Fortsatt läsning
+
+* [JSON.org](http://json.org/json-sv.html) Allt du kan tänkas vilja veta om JSON, och lite därtill.
diff --git a/swift.html.markdown b/swift.html.markdown
index 46768375..c17510b6 100644
--- a/swift.html.markdown
+++ b/swift.html.markdown
@@ -7,6 +7,7 @@ contributors:
   - ["Anthony Nguyen", "http://github.com/anthonyn60"]
   - ["Clayton Walker", "https://github.com/cwalk"]
   - ["Fernando Valverde", "http://visualcosita.xyz"]
+  - ["Alexey Nazaroff", "https://github.com/rogaven"]
 filename: learnswift.swift
 ---
 
@@ -94,6 +95,8 @@ var unwrappedString: String! = "Value is expected."
 // same as above, but ! is a postfix operator (more syntax candy)
 var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected."
 
+// If let structure -
+// If let is a special structure in Swift that allows you to check if an Optional rhs holds a value, and in case it does - unwraps and assigns it to the lhs.
 if let someOptionalStringConstant = someOptionalString {
     // has `Some` value, non-nil
     if !someOptionalStringConstant.hasPrefix("ok") {
@@ -101,11 +104,18 @@ if let someOptionalStringConstant = someOptionalString {
     }
 }
 
+// The nil-coalescing operator ?? unwraps an optional if it contains a non-nil value, or returns a default value.
+var someOptionalString: String?
+let someString = someOptionalString ?? "abc"
+print(someString) // abc
+
 // Swift has support for storing a value of any type.
-// AnyObject == id
-// Unlike Objective-C `id`, AnyObject works with any value (Class, Int, struct, etc.)
-var anyObjectVar: AnyObject = 7
-anyObjectVar = "Changed value to a string, not good practice, but possible."
+// For that purposes there is two keywords: `Any` and `AnyObject`
+// `AnyObject` == `id` from Objective-C
+// `Any` – also works with any scalar values (Class, Int, struct, etc.)
+var anyVar: Any = 7
+anyVar = "Changed value to a string, not good practice, but possible."
+let anyObjectVar: AnyObject = Int(1) as NSNumber
 
 /*
     Comment here
@@ -149,11 +159,11 @@ var explicitEmptyMutableDictionary: [String: Float] = [:] // same as above
 // MARK: Control Flow
 //
 
-// Condition statements support "where" clauses, which can be used
+// Condition statements support "," (comma) clauses, which can be used
 // to help provide conditions on optional values.
-// Both the assignment and the "where" clause must pass.
+// Both the assignment and the "," clause must pass.
 let someNumber = Optional<Int>(7)
-if let num = someNumber where num > 3 {
+if let num = someNumber, num > 3 {
     print("num is greater than 3")
 }
 
@@ -228,13 +238,13 @@ A greet operation
 func greet(name: String, day: String) -> String {
     return "Hello \(name), today is \(day)."
 }
-greet("Bob", day: "Tuesday")
+greet(name: "Bob", day: "Tuesday")
 
 // similar to above except for the function parameter behaviors
-func greet2(requiredName requiredName: String, externalParamName localParamName: String) -> String {
-    return "Hello \(requiredName), the day is \(localParamName)"
+func greet2(name: String, externalParamName localParamName: String) -> String {
+    return "Hello \(name), the day is \(localParamName)"
 }
-greet2(requiredName: "John", externalParamName: "Sunday")
+greet2(name: "John", externalParamName: "Sunday")
 
 // Function that returns multiple items in a tuple
 func getGasPrices() -> (Double, Double, Double) {
@@ -277,7 +287,7 @@ func setup(numbers: Int...) {
 }
 
 // Passing and returning functions
-func makeIncrementer() -> (Int -> Int) {
+func makeIncrementer() -> ((Int) -> Int) {
     func addOne(number: Int) -> Int {
         return 1 + number
     }
@@ -287,14 +297,14 @@ var increment = makeIncrementer()
 increment(7)
 
 // pass by ref
-func swapTwoInts(inout a: Int, inout b: Int) {
+func swapTwoInts(a: inout Int, b: inout Int) {
     let tempA = a
     a = b
     b = tempA
 }
 var someIntA = 7
 var someIntB = 3
-swapTwoInts(&someIntA, b: &someIntB)
+swapTwoInts(a: &someIntA, b: &someIntB)
 print(someIntB) // 7
 
 
@@ -322,7 +332,7 @@ numbers = numbers.map({ number in 3 * number })
 print(numbers) // [3, 6, 18]
 
 // Trailing closure
-numbers = numbers.sort { $0 > $1 }
+numbers = numbers.sorted { $0 > $1 }
 
 print(numbers) // [18, 6, 3]
 
@@ -349,8 +359,8 @@ print("Name is \(name)") // Name is Them
 // MARK: Error Handling
 //
 
-// The `ErrorType` protocol is used when throwing errors to catch
-enum MyError: ErrorType {
+// The `Error` protocol is used when throwing errors to catch
+enum MyError: Error {
     case BadValue(msg: String)
     case ReallyBadValue(msg: String)
 }
@@ -366,15 +376,15 @@ func fakeFetch(value: Int) throws -> String {
 
 func testTryStuff() {
     // assumes there will be no error thrown, otherwise a runtime exception is raised
-    let _ = try! fakeFetch(7)
+    let _ = try! fakeFetch(value: 7)
 
     // if an error is thrown, then it proceeds, but if the value is nil
     // it also wraps every return value in an optional, even if its already optional
-    let _ = try? fakeFetch(7)
+    let _ = try? fakeFetch(value: 7)
 
     do {
         // normal try operation that provides error handling via `catch` block
-        try fakeFetch(1)
+        try fakeFetch(value: 1)
     } catch MyError.BadValue(let msg) {
         print("Error message: \(msg)")
     } catch {
@@ -441,7 +451,7 @@ internal class Rect: Shape {
 
     func shrink() {
         if sideLength > 0 {
-            --sideLength
+            sideLength -= 1
         }
     }
 
@@ -568,10 +578,11 @@ protocol ShapeGenerator {
 }
 
 // Protocols declared with @objc allow optional functions,
-// which allow you to check for conformance
+// which allow you to check for conformance. These functions must be
+// marked with @objc also.
 @objc protocol TransformShape {
-    optional func reshape()
-    optional func canReshape() -> Bool
+    @objc optional func reshape()
+    @objc optional func canReshape() -> Bool
 }
 
 class MyShape: Rect {
@@ -583,7 +594,7 @@ class MyShape: Rect {
         // Place a question mark after an optional property, method, or
         // subscript to gracefully ignore a nil value and return nil
         // instead of throwing a runtime error ("optional chaining").
-        if let reshape = self.delegate?.canReshape?() where reshape {
+        if let reshape = self.delegate?.canReshape?(), reshape {
             // test for delegate then for method
             self.delegate?.reshape?()
         }
@@ -618,20 +629,20 @@ extension Int {
 }
 
 print(7.customProperty) // "This is 7"
-print(14.multiplyBy(3)) // 42
+print(14.multiplyBy(num: 3)) // 42
 
 // Generics: Similar to Java and C#. Use the `where` keyword to specify the
 //   requirements of the generics.
 
-func findIndex<T: Equatable>(array: [T], _ valueToFind: T) -> Int? {
-    for (index, value) in array.enumerate() {
+func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
+    for (index, value) in array.enumerated() {
         if value == valueToFind {
             return index
         }
     }
     return nil
 }
-let foundAtIndex = findIndex([1, 2, 3, 4], 3)
+let foundAtIndex = findIndex(array: [1, 2, 3, 4], valueToFind: 3)
 print(foundAtIndex == 2) // true
 
 // Operators:
@@ -639,10 +650,10 @@ print(foundAtIndex == 2) // true
 //      / = - + * % < > ! & | ^ . ~
 // or
 // Unicode math, symbol, arrow, dingbat, and line/box drawing characters.
-prefix operator !!! {}
+prefix operator !!!
 
 // A prefix operator that triples the side length when used
-prefix func !!! (inout shape: Square) -> Square {
+prefix func !!! (shape: inout Square) -> Square {
     shape.sideLength *= 3
     return shape
 }
@@ -655,8 +666,8 @@ print(mySquare.sideLength) // 4
 print(mySquare.sideLength) // 12
 
 // Operators can also be generics
-infix operator <-> {}
-func <-><T: Equatable> (inout a: T, inout b: T) {
+infix operator <->
+func <-><T: Equatable> (a: inout T, b: inout T) {
     let c = a
     a = b
     b = c
diff --git a/ta_in/css-ta.html.markdown b/ta_in/css-ta.html.markdown
index 56f94ed0..cbe88f1e 100644
--- a/ta_in/css-ta.html.markdown
+++ b/ta_in/css-ta.html.markdown
@@ -7,9 +7,9 @@ contributors:
     - ["Connor Shea", "https://github.com/connorshea"]
     - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
 translators:
-	- ["Rasendran Kirushan", "https://github.com/kirushanr"]
-filename: learncss.css
-lang:in-ta
+    - ["Rasendran Kirushan", "https://github.com/kirushanr"]
+filename: learncss-ta.css
+lang: in-ta
 ---
 
 
diff --git a/ta_in/javascript-ta.html.markdown b/ta_in/javascript-ta.html.markdown
index f0b0a36a..d3fe5a85 100644
--- a/ta_in/javascript-ta.html.markdown
+++ b/ta_in/javascript-ta.html.markdown
@@ -5,8 +5,8 @@ contributors:
     - ['Ariel Krakowski', 'http://www.learneroo.com']
 translators:
   - ["Rasendran Kirushan", "https://github.com/kirushanr"]
-filename: javascript.js
-lang:in-ta
+filename: javascript-ta.js
+lang: in-ta
 ---
 
 javascript 1995 ஆம்  ஆண்டு Netscape இல் பணிபுரிந்த Brendan Eich
diff --git a/ta_in/xml-ta.html.markdown b/ta_in/xml-ta.html.markdown
index a9bfa9cd..d782399d 100644
--- a/ta_in/xml-ta.html.markdown
+++ b/ta_in/xml-ta.html.markdown
@@ -1,11 +1,11 @@
 ---
 language: xml
-filename: learnxml.xml
+filename: learnxml-ta.xml
 contributors:
   - ["João Farias", "https://github.com/JoaoGFarias"]
 translators:
   - ["Rasendran Kirushan", "https://github.com/kirushanr"]
-lang:in-ta
+lang: in-ta
 ---
 
 
diff --git a/tcl.html.markdown b/tcl.html.markdown
index b90bd690..1f4ca63b 100644
--- a/tcl.html.markdown
+++ b/tcl.html.markdown
@@ -1,21 +1,21 @@
 ---
 language: Tcl
 contributors:
-    - ["Poor Yorick", "http://pooryorick.com/"]
+    - ["Poor Yorick", "https://pooryorick.com/"]
 filename: learntcl.tcl
 ---
 
-Tcl was created by [John Ousterhout](http://wiki.tcl.tk/John Ousterout) as a
-reusable scripting language for chip design tools he was creating.  In 1997 he
+Tcl was created by [John Ousterhout](https://wiki.tcl.tk/John%20Ousterout) as a
+reusable scripting language for circuit design tools that he authored.  In 1997 he
 was awarded the [ACM Software System
-Award](http://en.wikipedia.org/wiki/ACM_Software_System_Award) for Tcl.  Tcl
+Award](https://en.wikipedia.org/wiki/ACM_Software_System_Award) for Tcl.   Tcl
 can be used both as an embeddable scripting language and as a general
 programming language.  It can also be used as a portable C library, even in
 cases where no scripting capability is needed, as it provides data structures
 such as dynamic strings, lists, and hash tables.  The C library also provides
 portable functionality for loading dynamic libraries, string formatting and
-code conversion, filesystem operations, network operations, and more.
-Various features of Tcl stand out:
+code conversion, filesystem operations, network operations, and more.  Various
+features of Tcl stand out:
 
 * Convenient cross-platform networking API
 
@@ -30,99 +30,105 @@ Various features of Tcl stand out:
 * A threading model recognized as robust and easy to use
 
 
-If Lisp is a list processor, then Tcl is a string processor.  All values are
-strings.  A list is a string format.  A procedure definition is a string
-format.  To achieve performance, Tcl internally caches structured
-representations of these values.  The list commands, for example, operate on
+Tcl has much in common with Lisp, but instead of lists, Tcl uses strings as the
+currency of the language.  All values are strings.  A list is a string with a
+defined format, and the body of a procedure (a script) is also a string rather
+than a block.  To achieve performance, Tcl internally caches structured
+representations of these values.  list routines, for example, operate on
 the internal cached representation, and Tcl takes care of updating the string
 representation if it is ever actually needed in the script.  The copy-on-write
-design of Tcl allows script authors can pass around large data values without
+design of Tcl allows script authors to pass around large data values without
 actually incurring additional memory overhead.  Procedures are automatically
-byte-compiled unless they use the more dynamic commands such as "uplevel",
+byte-compiled unless they use the more dynamic routines such as "uplevel",
 "upvar", and "trace".
 
 Tcl is a pleasure to program in.  It will appeal to hacker types who find Lisp,
 Forth, or Smalltalk interesting, as well as to engineers and scientists who
 just want to get down to business with a tool that bends to their will.  Its
-discipline of exposing all programmatic functionality as commands, including
-things like loops and mathematical operations that are usually baked into the
+discipline of exposing all programmatic functionality as routines, including
+things like looping and mathematical operations that are usually baked into the
 syntax of other languages, allows it to fade into the background of whatever
-domain-specific functionality a project needs. It's syntax, which is even
+domain-specific functionality a project needs. Its syntax, which is even
 lighter that that of Lisp, just gets out of the way.
 
 
 
-
-
 ```tcl
 #! /bin/env tclsh
 
-################################################################################
+###############################################################################
 ## 1. Guidelines
-################################################################################
+###############################################################################
 
-# Tcl is not Bash or C!  This needs to be said because standard shell quoting
+# Tcl is not Sh or C!  This needs to be said because standard shell quoting
 # habits almost work in Tcl and it is common for people to pick up Tcl and try
 # to get by with syntax they know from another language.  It works at first,
-# but soon leads to frustration with more complex scripts.
+# but soon leads to frustration when scripts become more complex.
 
-# Braces are just a quoting mechanism, not a code block constructor or a list
-# constructor.  Tcl doesn't have either of those things.  Braces are used,
-# though, to escape special characters in procedure bodies and in strings that
-# are formatted as lists.
+# Braces are a quoting mechanism, not syntax for the construction of code
+# blocks or lists. Tcl doesn't have either of those things.  Braces are used to
+# escape special characters, which makes them well-suited for quoting procedure
+# bodies and strings that should be interpreted as lists.
 
 
-################################################################################
+###############################################################################
 ## 2. Syntax
-################################################################################
-
-# Every line is a command.  The first word is the name of the command, and
-# subsequent words are arguments to the command. Words are delimited by
-# whitespace.  Since every word is a string, in the simple case no special
-# markup such as quotes, braces, or backslash, is necessary.  Even when quotes
-# are used, they are not a string constructor, but just another escaping
-# character.
+###############################################################################
 
-set greeting1 Sal
-set greeting2 ut
-set greeting3 ations
+# A script is made up of commands delimited by newlines or semiclons.  Each
+# command is a call to a routine.  The first word is the name of a routine to
+# call, and subsequent words are arguments to the routine.  Words are delimited
+# by whitespace.  Since each argument is a word in the command it is already a
+# string, and may be unquoted:
+set part1 Sal
+set part2 ut; set part3 ations
 
 
-#semicolon also delimits commands
-set greeting1 Sal; set greeting2 ut; set greeting3 ations
+# a dollar sign introduces variable substitution:
+set greeting $part1$part2$part3
 
 
-# Dollar sign introduces variable substitution
-set greeting $greeting1$greeting2$greeting3
+# When "set" is given only the name of a variable, it returns the
+# value of that variable:
+set part3 ;# Returns the value of the variable.
 
 
-# Bracket introduces command substitution.  The result of the command is
-# substituted in place of the bracketed script.  When the "set" command is
-# given only the name of a variable, it returns the value of that variable.
-set greeting $greeting1$greeting2[set greeting3]
+# Left and right brackets embed a script to be evaluated for a result to
+# substitute into the word:
+set greeting $part1$part2[set part3]
 
 
-# Command substitution should really be called script substitution, because an
-# entire script, not just a command, can be placed between the brackets. The
-# "incr" command increments the value of a variable and returns its value.
+# An embedded script may be composed of multiple commands, the last of which provides
+# the result for the substtution:
 set greeting $greeting[
-	incr i
-	incr i
-	incr i
+    incr i
+    incr i
+    incr i
 ]
+puts $greeting ;# The output is "Salutations3" 
+
+# Every word in a command is a string, including the name of the routine, so
+# substitutions can be used on it as well. Given this variable
+# assignment,
+set action pu
+
+# , the following three commands are equivalent:
+puts $greeting
+${action}ts $greeting 
+[set action]ts $greeting
 
 
-# backslash suppresses the special meaning of characters
+# backslash suppresses the special meaning of characters:
 set amount \$16.42
 
 
-# backslash adds special meaning to certain characters
+# backslash adds special meaning to certain characters:
 puts lots\nof\n\n\n\n\n\nnewlines
 
 
 # A word enclosed in braces is not subject to any special interpretation or
 # substitutions, except that a backslash before a brace is not counted when
-# looking for the closing brace
+# looking for the closing brace:
 set somevar {
     This is a literal $ sign, and this \} escaped
     brace remains uninterpreted
@@ -130,41 +136,44 @@ set somevar {
 
 
 # In a word enclosed in double quotes, whitespace characters lose their special
-# meaning
+# meaning:
 set name Neo
 set greeting "Hello, $name"
 
 
-#variable names can be any string
+# A variable name can be any string:
 set {first name} New
 
 
-# The brace form of variable substitution handles more complex variable names
+# The braced form of variable substitution handles more complex variable names:
 set greeting "Hello, ${first name}"
 
 
-# The "set" command can always be used instead of variable substitution
+# "set" can always be used instead of variable substitution, and can handle all
+# variable names:
 set greeting "Hello, [set {first name}]"
 
 
-# To promote the words within a word to individual words of the current
-# command, use the expansion operator, "{*}".
-```
-
-```tcl
-set {*}{name Neo}
-
-# is equivalent to
+# To unpack a list into the command, use the expansion operator, "{*}".  These
+# two commands are equivalent:
 set name Neo
+set {*}{name Neo}
 
 
 # An array is a special variable that is a container for other variables.
 set person(name) Neo
-set person(gender) male
+set person(destiny) {The One}
 set greeting "Hello, $person(name)"
 
 
-# A namespace holds commands and variables
+# "variable" can be used to declare or set variables. In contrast with "set",
+# which uses both the global namespace and the current namespace to resolve a
+# variable name, "variable" uses only the current namespace:
+variable name New
+
+
+# "namespace eval" creates a new namespace if it doesn't exist.  A namespace
+# can contain both routines and variables:
 namespace eval people {
     namespace eval person1 {
         variable name Neo
@@ -172,48 +181,102 @@ namespace eval people {
 }
 
 
-#The full name of a variable includes its enclosing namespace(s), delimited by two colons:
-set greeting "Hello $people::person1::name"
+# Use two or more colons to delimit namespace components in variable names:
+namespace eval people {
+    set greeting "Hello $person1::name"
+}
+
+# Two or more colons also delimit namespace components in routine names:
+proc people::person1::speak {} {
+    puts {I am The One.}
+}
+
+# Fully-qualified names begin with two colons:
+set greeting "Hello $::people::person1::name"
+
+
 
+###############################################################################
+## 3. No More Syntax
+###############################################################################
 
+# All other functionality is implemented via routines.  From this point on,
+# there is no new syntax.  Everything else there is to learn about
+# Tcl is about the behaviour of individual routines and what meaning they
+# assign to their arguments.
 
-################################################################################
-## 3. A Few Notes
-################################################################################
 
-# All other functionality is implemented via commands.  From this point on,
-# there is no new syntax.  Everything else there is to learn about Tcl is about
-# the behaviour of individual commands, and what meaning they assign to their
-# arguments.
 
+###############################################################################
+## 4. Variables and Namespaces
+###############################################################################
+
+# Each variable and routine is associated with some namespace.
 
 # To end up with an interpreter that can do nothing, delete the global
 # namespace.  It's not very useful to do such a thing, but it illustrates the
-# nature of Tcl.
-namespace delete ::
-
+# nature of Tcl.  The name of the global namespace is actually the empty
+# string, but the only way to represent it is as a fully-qualified name. To
+# try it out call this routine:
+proc delete_global_namespace {} {
+    namespace delete ::
+}
 
-# Because of name resolution behaviour, it's safer to use the "variable" command to
-# declare or to assign a value to a namespace. If a variable called "name" already
-# exists in the global namespace, using "set" here will assign a value to the global variable
-# instead of creating a new variable in the local namespace.
+# Because "set" always keeps its eye on both the global namespace and the
+# current namespace, it's safer to use "variable" to declare a variable or
+# assign a value to a variable.  If a variable called "name" already exists in
+# the global namespace, using "set" here will assign a value to the global
+# variable instead of to a variable in the current namespace, whereas
+# "variable" operates only on the current namespace.
 namespace eval people {
     namespace eval person1 {
         variable name Neo
     }
 }
 
+# Once a variable is declared in a namespace, [set] sees it instead of seeing
+# an identically-named variable in the global namespace:
+namespace eval people {
+    namespace eval person1 {
+        variable name
+        set name Neo
+    }
+}
+
+# But if "set" has to create a new variable, it always does it relative to the
+# current namespace:
+unset name
+namespace eval people {
+    namespace eval person1 {
+        set name neo
+    }
 
-# The full name of a variable can always be used, if desired.
-set people::person1::name Neo
+}
+set people::person1::name
 
 
+# An absolute name always begins with the name of the global namespace (the
+# empty string), followed by two colons:
+set ::people::person1::name Neo
 
-################################################################################
-## 4. Commands
-################################################################################
 
-# Math can be done with the "expr" command.
+# Within a procedure, the "variable" links a variable in the current namespace
+# into the local scope:
+namespace eval people::person1 {
+    proc fly {} {
+        variable name
+        puts "$name is flying!"
+    }
+}
+
+
+
+
+###############################################################################
+## 4. Built-in Routines
+###############################################################################
+
+# Math can be done with the "expr":
 set a 3
 set b 4
 set c [expr {$a + $b}]
@@ -223,53 +286,63 @@ set c [expr {$a + $b}]
 # "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions" for details.
 
 
-# The "expr" command understands variable and command substitution
+# "expr" understands variable and script substitution:
 set c [expr {$a + [set b]}]
 
 
-# The "expr" command provides a set of mathematical functions
+# "expr" provides a set of mathematical functions:
 set c [expr {pow($a,$b)}]
 
 
-# Mathematical operators are available as commands in the ::tcl::mathop
-# namespace
+# Mathematical operators are available as routines in the ::tcl::mathop
+# namespace:
 ::tcl::mathop::+ 5 3
 
-# Commands can be imported from other namespaces
+# Routines can be imported from other namespaces:
 namespace import ::tcl::mathop::+
 set result [+ 5 3]
 
 
-# New commands can be created via the "proc" command.
+# Non-numeric values must be quoted, and operators like "eq" can be used to
+# constrain the operation to string comparison:
+set name Neo
+expr {{Bob} eq $name}
+
+# The general operators fall back to string string comparison if numeric
+# operation isn't feasible:
+expr {{Bob} == $name}
+
+
+# "proc" creates new routines:
 proc greet name {
     return "Hello, $name!"
 }
 
-#multiple parameters can be specified
+#multiple parameters can be specified:
 proc greet {greeting name} {
     return "$greeting, $name!"
 }
 
 
 # As noted earlier, braces do not construct a code block.  Every value, even
-# the third argument of the "proc" command, is a string.  The previous command
-# rewritten to not use braces at all:
-proc greet greeting\ name return\ \"Hello,\ \$name!
+# the third argument to "proc", is a string.  The previous command
+# can be rewritten using no braces:
+proc greet greeting\ name return\ \"\$greeting,\ \$name!\"
 
 
 
-# When the last parameter is the literal value, "args", it collects all extra
-# arguments when the command is invoked
-proc fold {cmd args} {
-    set res 0
+# When the last parameter is the literal value "args", all extra arguments
+# passed to the routine are collected into a list and assigned to "args":
+proc fold {cmd first args} {
     foreach arg $args {
-        set res [$cmd $res $arg]
+        set first [$cmd $first $arg]
     }
+    return $first
 }
 fold ::tcl::mathop::* 5 3 3 ;# ->  45
 
 
-# Conditional execution is implemented as a command
+# Conditional execution is implemented as a routine:
 if {3 > 4} {
     puts {This will never happen}
 } elseif {4 > 4} {
@@ -279,30 +352,40 @@ if {3 > 4} {
 }
 
 
-# Loops are implemented as commands.  The first, second, and third
-# arguments of the "for" command are treated as mathematical expressions
+# Loops are implemented as routines.  The first and third arguments to 
+# "for" are treated as scripts, while the second argument is treated as
+# an expression:
+set res 0
 for {set i 0} {$i < 10} {incr i} {
     set res [expr {$res + $i}]
 }
+unset res
 
 
-# The first argument of the "while" command is also treated as a mathematical
-# expression
+# The first argument to "while" is also treated as an expression:
 set i 0
 while {$i < 10} {
     incr i 2
 }
 
 
-# A list is a specially-formatted string.  In the simple case, whitespace is sufficient to delimit values
+# A list is a string, and items in the list are delimited by whitespace:
 set amounts 10\ 33\ 18
 set amount [lindex $amounts 1]
 
+# Whitespace in a list item must be quoted:
+set inventory {"item 1" item\ 2 {item 3}}
+
+
+# It's generally a better idea to use list routines when modifing lists:
+lappend inventory {item 1} {item 2} {item 3}
+
 
 # Braces and backslash can be used to format more complex values in a list.  A
 # list looks exactly like a script, except that the newline character and the
-# semicolon character lose their special meanings.  This feature makes Tcl
-# homoiconic.  There are three items in the following list.
+# semicolon character lose their special meanings, and there is no script or
+# variable substitution.  This feature makes Tcl homoiconic.  There are three
+# items in the following list:
 set values {
 
     one\ two
@@ -314,19 +397,19 @@ set values {
 }
 
 
-# Since a list is a string, string operations could be performed on it, at the
-# risk of corrupting the formatting of the list.
+# Since, like all values, a list is a string, string operations could be
+# performed on it, at the risk of corrupting the formatting of the list:
 set values {one two three four}
 set values [string map {two \{} $values] ;# $values is no-longer a \
-    properly-formatted listwell-formed list
+    properly-formatted list
 
 
-# The sure-fire way to get a properly-formmated list is to use "list" commands
+# The sure-fire way to get a properly-formatted list is to use "list" routines:
 set values [list one \{ three four]
 lappend values { } ;# add a single space as an item in the list
 
 
-# Use "eval" to evaluate a value as a script
+# Use "eval" to evaluate a value as a script:
 eval {
     set name Neo
     set greeting "Hello, $name"
@@ -334,84 +417,94 @@ eval {
 
 
 # A list can always be passed to "eval" as a script composed of a single
-# command.
+# command:
 eval {set name Neo}
 eval [list set greeting "Hello, $name"]
 
 
-# Therefore, when using "eval", use [list] to build up a desired command
+# Therefore, when using "eval", , use "list" to build
+# up the desired command:
 set command {set name}
 lappend command {Archibald Sorbisol}
 eval $command
 
 
-# A common mistake is not to use list functions when building up a command
+# A common mistake is not to use list functions when building up a command:
 set command {set name}
 append command { Archibald Sorbisol}
-eval $command ;# There is an error here, because there are too many arguments \
-    to "set" in {set name Archibald Sorbisol}
+try {
+    eval $command ;# The error here is that there are too many arguments \
+        to "set" in {set name Archibald Sorbisol}
+} on error {result eoptions} {
+    puts [list {received an error} $result]
+}
 
+# This mistake can easily occur with "subst":
 
-# This mistake can easily occur with the "subst" command.
 set replacement {Archibald Sorbisol}
 set command {set name $replacement}
-set command [subst $command]
-eval $command ;# The same error as before: too many arguments to "set" in \
-    {set name Archibald Sorbisol}
+set command [subst $command] 
+try {
+    eval $command ;# The same error as before:  too many arguments to "set" in \
+        {set name Archibald Sorbisol}
+} trap {TCL WRONGARGS} {result options} {
+    puts [list {received another error} $result]
+}
 
 
-# The proper way is to format the substituted value using use the "list"
-# command.
+# "list" correctly formats a value for substitution:
 set replacement [list {Archibald Sorbisol}]
 set command {set name $replacement}
 set command [subst $command]
 eval $command
 
 
-# It is extremely common to see the "list" command being used to properly
-# format values that are substituted into Tcl script templates.  There are
-# several examples of this, below.
+# "list" is commonly used to format values for substitution into scripts: There
+# are several examples of this, below.
 
 
-# The "apply" command evaluates a string as a command.
+# "apply" evaluates a two-item list as a routine:
 set cmd {{greeting name} {
     return "$greeting, $name!"
 }}
 apply $cmd Whaddup Neo
 
+# A third item can be used to specify the namespace to apply the routine in:
+set cmd [list {greeting name} {
+    return "$greeting, $name!"
+} [namespace current]]
+apply $cmd Whaddup Neo
 
-# The "uplevel" command evaluates a script in some enclosing scope.
+
+# "uplevel" evaluates a script at some higher level in the call stack:
 proc greet {} {
-	uplevel {puts "$greeting, $name"}
+    uplevel {puts "$greeting, $name"}
 }
 
 proc set_double {varname value} {
-	if {[string is double $value]} {
-		uplevel [list variable $varname $value]
-	} else {
-		error [list {not a double} $value]
-	}
+    if {[string is double $value]} {
+        uplevel [list variable $varname $value]
+    } else {
+        error [list {not a double} $value]
+    }
 }
 
 
-# The "upvar" command links a variable in the current scope to a variable in
-# some enclosing scope
+# "upvar" links a variable at the current level in the call stack to a variable
+# at some higher level:
 proc set_double {varname value} {
-	if {[string is double $value]} {
-		upvar 1 $varname var
-		set var $value
-	} else {
-		error [list {not a double} $value]
-	}
+    if {[string is double $value]} {
+        upvar 1 $varname var
+        set var $value
+    } else {
+        error [list {not a double} $value]
+    }
 }
 
 
-#get rid of the built-in "while" command.
+# Get rid of the built-in "while" routine, and use "proc" to define a new one:
 rename ::while {}
-
-
-# Define a new while command with the "proc" command.  More sophisticated error
-# handling is left as an exercise.
+# handling is left as an exercise:
 proc while {condition script} {
     if {[uplevel 1 [list expr $condition]]} {
         uplevel 1 $script
@@ -420,27 +513,68 @@ proc while {condition script} {
 }
 
 
-# The "coroutine" command creates a separate call stack, along with a command
-# to enter that call stack. The "yield" command suspends execution in that
-# stack.
-proc countdown {} {
-	#send something back to the initial "coroutine" command
-	yield
+# "coroutine" creates a new call stack, a new routine to enter that call stack,
+# and then calls that routine.  "yield" suspends evaluation in that stack and
+# returns control to the calling stack:
+proc countdown count {
+    # send something back to the creater of the coroutine, effectively pausing
+    # this call stack for the time being.
+    yield [info coroutine]
 
-	set count 3
-	while {$count > 1} {
-		yield [incr count -1]
-	}
-	return 0
+    while {$count > 1} {
+        yield [incr count -1]
+    }
+    return 0
 }
-coroutine countdown1 countdown
-coroutine countdown2 countdown
-puts [countdown 1] ;# -> 2
-puts [countdown 2] ;# -> 2
-puts [countdown 1] ;# -> 1
-puts [countdown 1] ;# -> 0
-puts [coundown 1] ;# -> invalid command name "countdown1"
-puts [countdown 2] ;# -> 1
+coroutine countdown1 countdown 3
+coroutine countdown2 countdown 5
+puts [countdown1] ;# -> 2 
+puts [countdown2] ;# -> 4 
+puts [countdown1] ;# -> 1 
+puts [countdown1] ;# -> 0 
+catch {
+    puts [coundown1] ;# -> invalid command name "countdown1"
+} cres copts 
+puts $cres
+puts [countdown2] ;# -> 3 
+
+
+# Coroutine stacks can yield control to each other:
+
+proc pass {whom args} {
+    return [yieldto $whom {*}$args]
+}
+
+coroutine a apply {{} {
+        yield
+        set result [pass b {please pass the salt}]
+        puts [list got the $result]
+        set result [pass b {please pass the pepper}]
+        puts [list got the $result]
+}}
+
+coroutine b apply {{} {
+    set request [yield]
+    while 1 {
+        set response [pass c $request]
+        puts [list [info coroutine] is now yielding]
+        set request [pass a $response]
+    }
+}}
+
+coroutine c apply {{} {
+    set request [yield]
+    while 1 {
+        if {[string match *salt* $request]} {
+            set request [pass b salt]
+        } else {
+            set request [pass b huh?]
+        }
+    }
+}}
+
+# get things moving
+a
 
 
 ```
diff --git a/tcsh.html.markdown b/tcsh.html.markdown
new file mode 100644
index 00000000..a95a84b0
--- /dev/null
+++ b/tcsh.html.markdown
@@ -0,0 +1,790 @@
+---
+language: tcsh
+filename: LearnTCSH.csh
+contributors:
+    - ["Nicholas Christopoulos", "https://github.com/nereusx"]
+lang: en
+---
+tcsh ("tee-see-shell") is a Unix shell based on and compatible with the C shell (csh).
+It is essentially the C shell with programmable command-line completion, command-line editing,
+and a few other features.
+It is the native root shell for BSD-based systems such as FreeBSD.
+
+Almost all Linux distros and BSD today use tcsh instead of the original csh. In
+most cases csh is a symbolic link that points to tcsh.
+This is because tcsh is backward compatible with csh, and the last
+is not maintained anymore.
+
+- [TCSH Home](http://www.tcsh.org/)
+- [TCSH Wikipedia](https://en.wikipedia.org/wiki/Tcsh)
+- [TCSH manual page](http://www.tcsh.org/tcsh.html/top.html)
+- [“An Introduction to the C shell”, William Joy](https://docs.freebsd.org/44doc/usd/04.csh/paper.html)
+- [TCSH Bug reports and/or features requests](https://bugs.gw.com/)
+
+Some more files:
+[tcsh help command (for 132x35 terminal size)](https://github.com/nereusx/dotfiles/blob/master/csh-help),
+[my ~/.tcshrc](https://github.com/nereusx/dotfiles/blob/master/.tcshrc)
+
+```tcsh
+#!/bin/tcsh
+# First line of the script is shebang which tells the system how to execute the
+# script: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# TCSH emulates the shebang on systems which don't understand it.
+
+# In most cases you'll use `#!/bin/tcsh -f', because `-f' option does not load
+# any resource or start-up files, or perform any command hashing, and thus
+# starts faster.
+
+# --- the echo command --------------------------------------------------------
+# The `echo' writes each word to the shell's standard output, separated by
+# spaces and terminated with a newline. The echo_style shell variable may be
+# set to emulate (or not) the flags and escape sequences.
+
+# Display the value of echo_style
+echo $echo_style
+
+# Enable `echo' to support backslashed characters and `-n' option (no new line)
+# This is the default for tcsh, but your distro may change it. Slackware has
+# done so.
+set echo_style = both
+
+# Prints "Hello world"
+echo Hello world
+echo "Hello world"
+echo 'Hello world'
+echo `echo Hello world`
+
+# This prints "twonlines" in one line
+echo two\nlines
+
+# Prints the two lines
+echo "two\nlines"
+echo 'two\nlines'
+
+# --- Basic Syntax ------------------------------------------------------------
+
+# A special character (including a blank or tab) may be prevented from having
+# its special meaning by preceding it with a backslash `\'.
+# this will display the last history commands
+echo !!
+# this will not
+echo \!\!
+
+# Single quotes prevents expanding special characters too, but some
+# characters like `!' and backslash have higher priority
+# `$' (variable value) will not expands
+echo '$1 tip'
+# `!' (history) will expands
+echo '!!'
+
+# Strings enclosed by back-quotes will be executed and replaced by the result.
+echo `ls`
+
+# Semi-colon separate commands
+echo 'first line'; echo 'second line'
+
+# There is also conditional execution
+echo "Always executed" || echo "Only executed if first command fails"
+echo "Always executed" && echo "Only executed if first command does NOT fail"
+
+# Parenthesised commands are always executed in a subshell,
+
+# example: create a project and then informs you that it finished while
+# it does the installation.
+make && ( espeak "BOSS, compilation finished"; make install )
+
+# prints the home directory but leaving you where you were
+(cd; pwd); pwd
+
+# Read tcsh man-page documentation
+man tcsh
+
+# --- Variables ---------------------------------------------------------------
+# The shell maintains a list of variables, each of which has as value a list of
+# zero or more words. The values of shell variables can be displayed and
+# changed with the `set' and `unset' commands.
+# The system maintains its own list of ``environment'' variables.
+# These can be displayed and changed with `printenv', `setenv' and `unsetenv'.
+# The syntax of setenv is similar to POSIX sh.
+
+# Assign a value or nothing will create a variable
+# Assign nothing
+set var
+# Assign a numeric value
+# the '@' denotes the expression is arithmetic; it works similar to 'set' but
+# the right value can be a numeric expression.
+@ var = 1 + 2
+# Assign a string value
+set var = "Hello, I am the contents of 'var' variable"
+# Assign the output of a program
+set var = `ls`
+
+# Remove a variable
+unset var
+# Prints 1 (true) if the variable `var' exists otherwise prints 0 (false)
+echo $?var
+# Print all variables and their values
+set
+
+# Prints the contents of 'var'
+echo $var;
+echo "$var";
+# Prints the string `$var'
+echo \$var
+echo '$var'
+# braces can be used to separate variable from the rest when its needed
+set num = 12; echo "There ${num}th element"
+
+# Prints the number of characters of the value: 6
+set var = '123456'; echo $%var
+
+### LISTs
+# Assign a list of values
+set var = ( one two three four five )
+# Print all the elements: one two three four five
+echo $var
+echo $var[*]
+# Print the count of elements: 5
+echo $#var
+# Print indexed element; prints the second element: two
+echo $var[2]
+# Print range of elements; prints 2nd up to 3rd: two, three
+echo $var[2-3]
+# Prints all elements starting from the 3rd: three four five
+echo $var[3-]
+# Prints print all up to 3rd element: one two three
+echo $var[-3]
+
+### Special Variables
+# $argv         list of command-line arguments
+# $argv[0]      this file-name (the file of the script file)
+# $# $0, $n, $* are the same as $#argv, $argv[0], $argv[n], $argv[*]
+# $status, $?   the exit code of the last command that executed
+# $_            the previous command line
+# $!            the PID of the last background process started by this shell
+# $$            script's PID
+
+# $path, $PATH  the list of directories that will search for executable to run
+# $home, $HOME  user's home directory, also the `~' can be used instead
+# $uid          user's login ID
+# $user         user's login name
+# $gid          the user's group ID
+# $group        the user's group-name
+# $cwd, $PWD    the Current/Print Working Directory
+# $owd          the previous working directory
+# $tcsh         tcsh version
+# $tty          the current tty; ttyN for linux console, pts/N for terminal
+#               emulators under X
+# $term         the terminal type
+# $verbose      if set, causes the words of each command to be printed.
+#               can be set by the `-v' command line option too.
+# $loginsh      if set, it is a login shell
+
+# TIP: $?0 is always false in interactive shells
+# TIP: $?prompt is always false in non-interactive shells
+# TIP: if `$?tcsh' is unset; you run the original `csh' or something else;
+#      try `echo $shell'
+# TIP: $verbose this is useful to debugging scripts
+# NOTE: $PWD and $PATH are synchronised with $cwd and $pwd automatically.
+
+# --- Variable modifiers ------------------------------------------------------
+# Syntax: ${var}:m[:mN]
+# Where <m> is:
+# h : the directory  t : the filenane  r : remove extension   e : the extension
+# u : uppercase the first lowercase letter
+# l : lowercase the first uppercase letter
+# p : print but do not execute it (hist)
+# q : quote the substituted words, preventing further substitutions
+# x : like q, but break into words at white spaces
+# g : apply the following modifier once to each word
+# a  : apply the following modifier as many times as possible to single word
+# s/l/r/ : search for `l' and replace with `r', not regex; the `&' in the r is
+# replaced by l
+# & : Repeat the previous substitution
+
+# start with this file
+set f = ~/Documents/Alpha/beta.txt
+# prints ~/Documents/Alpha/beta
+echo $f:r
+# prints ~/Documents/Alpha
+echo $f:h
+# prints beta.txt
+echo $f:t
+# prints txt
+echo $f:e
+# prints beta
+echo $f:t:r
+# prints Beta
+echo $f:t:r:u
+# prints Biota
+echo $f:t:r:u:s/eta/iota/
+
+# --- Redirection -------------------------------------------------------------
+
+# Create file.txt and write the standard output to it
+echo 'this string' > file.txt
+# Create file.txt and write the standard output and standard error to it
+echo 'this string' >& file.txt
+# Append the standard output to file.txt
+echo 'this string' >> file.txt
+# Append the standard output and standard error to file.txt
+echo 'this string' >>& file.txt
+# Redirect the standard input from file.txt
+cat < file.txt
+# Input from keyboard; this stores the input line to variable `x'
+set x = $<
+# Document here;
+cat << LABEL
+...text here...
+LABEL
+
+# TIP: this is how to get standard error separated:
+(grep 'AGP' /usr/src/linux/Documentation/* > output-file.txt) >& error-file.txt
+
+# example: read a name from standard input and display a greetings message
+echo -n "Enter your name? "
+set name = $<
+echo "Greetings $name"
+
+# --- Expressions ------------------------------------------------------------
+
+# Operators:
+# ==  equal         !=  not equal    !  not
+#  >  greater than   <  less than   >=  greater or equal  <= less or equal
+# &&  logical AND   ||  logical OR
+
+if ( $name != $user ) then
+    echo "Your name isn't your username"
+else
+    echo "Your name is your username"
+endif
+
+# single-line form
+if ( $name != $user ) echo "Your name isn't your username"
+
+# NOTE: if $name is empty, tcsh sees the above condition as:
+# if ( != $user ) ...
+# which is invalid syntax
+# so the "safe" way to use potentially empty variables in tcsh is:
+# if ( "$name" != $user ) ...
+# which, when $name is empty, is seen by tcsh as:
+# if ( "" != $user ) ...
+# which works as expected
+
+# There is also conditional execution
+echo "Always executed" || echo "Only executed if first command fails"
+echo "Always executed" && echo "Only executed if first command does NOT fail"
+
+# To use && and || with if statements, you don't need multiple pairs of
+# square brackets:
+if ( "$name" == "Steve" && "$age" == 15 ) then
+    echo "This will run if $name is Steve AND $age is 15."
+endif
+
+if ( "$name" == "Daniya" || "$name" == "Zach" ) then
+    echo "This will run if $name is Daniya OR Zach."
+endif
+
+# String matching operators ( `=~' and `!~' )
+# The ‘==’ ‘!=’ ‘=~’ and ‘!~’ operators compare their arguments as strings;
+# all others operate on numbers. The operators ‘=~’ and ‘!~’ are like ‘!=’
+# and ‘==’ except that the right hand side is a glob-pattern against which
+# the left hand operand is matched.
+
+if ( $user =~ ni[ck]* ) echo "Greetings Mr. Nicholas."
+if ( $user !~ ni[ck]* ) echo "Hey, get out of Nicholas PC."
+
+# Arithmetic expressions are denoted with the following format:
+@ result = 10 + 5
+echo $result
+
+# Arithmetic Operators
+# +, -, *, /, %
+#
+# Arithmetic Operators which must be parenthesised
+# !, ~, |, &, ^, ~, <<, >>,
+# Compare and logical operators
+#
+# All operators are same as in C.
+
+# It is non so well documented that numeric expressions require spaces
+# in-between; Also, `@' has its own parser, it seems that work well when the
+# expression is parenthesised otherwise the primary parser seems it is active.
+# Parenthesis require spaces around, this is documented.
+
+# wrong
+@ x = $y+1
+@ x = 0644 & 022;      echo $x
+@ x = (0644 & 022) +1; echo $x
+@ x = (0644 & 022)+ 1; echo $x
+@ x = ( ~077 );        echo $x
+
+# correct
+@ x = $y + 1
+@ x = ( 0644 & 022 ) + 1; echo $x
+@ x = ( ~ 077 );          echo $x
+@ x = ( ~ 077 | 022 );    echo $x
+@ x = ( ! 0 );            echo $x
+
+# C's operators ++ and -- are supported if there is not assignment
+@ result ++
+
+# None shell created to do mathematics;
+# Except for the basic operations, use an external command with backslashes.
+#
+# I suggest the calc as the best option.
+# (http://www.isthe.com/chongo/tech/comp/calc/)
+#
+# The standard Unix's bc as second option
+# (https://www.gnu.org/software/bc/manual/html_mono/bc.html)
+#
+# The standard Unix's AWK as third option
+# (https://www.gnu.org/software/gawk/manual/gawk.html)
+
+# You can also use `perl', `php' or even several BASICs, but prefer the
+# above utilities for faster load-and-run results.
+
+# real example: (that I answer in StackExchange)
+# REQ: x := 1001b OR 0110b
+
+# in `tcsh' expression (by using octal)
+@ x = ( 011 | 06 ); echo $x
+
+# the same by using `calc' (and using binary as the original req)
+set x = `calc '0b1001 | 0b110'`; echo $x
+
+# --- File Inquiry Operators --------------------------------------------------
+# NOTE: The builtin `filetest' command do the same thing.
+
+#### Boolean operators
+# -r  read access    -w  write access    -x  execute access    -e  existence
+# -f  plain file     -d  directory       -l  symbolic link     -p  named pipe
+# -S  socket file
+# -o  ownership      -z  zero size       -s  non-zero size
+# -u  SUID is set    -g  SGID is set     -k  sticky is set
+# -b  block device   -c  char device
+# -t  file (digit) is an open file descriptor for a terminal device
+
+# if the file `README' exists, displays a message
+if ( -e README ) echo "I have already README file"
+
+# if the `less' program is installed, use this instead of `more'
+if ( -e `where less` ) then
+	alias more 'less'
+endif
+
+#### Non-boolean operators
+# -Z  returns the file size in bytes
+# -M  returns the modification time (mtime)    -M: returns mtime string
+# -A  returns the lass access time (atime)     -A: returns atime string
+# -U  returns the owners user ID               -U: returns the owners user-name
+# -G  returns the group ID                     -G: returns the group-name
+# -P  returns the permissions as octal number  -Pmode returns perm. AND mode
+
+# this will display the date as Unix-time integer: 1498511486
+filetest -M README.md
+
+# This will display "Tue Jun 27 00:11:26 2017"
+filetest -M: README.md
+
+# --- Basic Commands ----------------------------------------------------------
+
+# Navigate though file system with `chdir' (cd)
+cd path # change working directory
+cd      # change to home directory
+cd -    # change to previous directory
+cd ..   # go up one directory
+
+# Examples:
+cd ~/Downloads # go to my `Downloads' directory
+
+# Use `mkdir` to create new directories.
+mkdir newdir
+# The `-p` flag causes new intermediate directories to be created as necessary.
+mkdir -p ~/.backup/saves
+
+# which & where
+# find if csh points to tcsh
+ls -lha `which csh`
+# find if csh is installed on more than one directory
+where csh
+
+# --- Pipe-lines --------------------------------------------------------------
+# A pipeline is a sequence of processes chained together by their standard
+# streams, so that the output of each process (stdout) feeds directly as input
+# (stdin) to the next one. This `pipes' are created with the `|' special
+# character and it is one of the most powerful characteristics of Unix.
+
+# example:
+ls -l | grep key | less
+# "ls -l" produces a process, the output (stdout) of which is piped to the
+# input (stdin) of the process for "grep key"; and likewise for the process
+# for "less".
+
+# the `ls', the `grep' and the `less' are programs of Unix and they have their
+# own man-page. The `pipe' mechanism is part of the kernel but the syntax
+# and the control is job of the shell, the tcsh in our case.
+
+# NOTE: `pipe' mechanism has Windows too, but it is buggy and I sign it for all
+# versions until Windows XP SP3 API32 which was the last one that I worked on.
+# Microsoft still denied it but is well known bug since it is a common method
+# for inter-process communication. For small I/O it will work well.
+# tcsh, along with grep, gcc and perl is one of the first Unix programs that
+# ported to DOS (with EMX DOS extender) and later to Windows (1998).
+
+# example: this will convert tcsh to PostScript and will show it with okular
+zcat /usr/man/man1/tcsh.1.gz | groff -Tps -man | okular -
+
+# a better version
+zcat `locate -b -n 1 '\tcsh.1.gz'` | groff -Tps -man | okular -
+
+# even better
+set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz");
+ zcat `eval $loc` | groff -Tps -man | okular -
+
+# the same, modified to create man page pdf
+set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz");
+ zcat `eval $loc` | groff -Tps -man | ps2pdf - ${page}.pdf
+
+# the same, but now shows the ${page}.pdf too
+set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz");
+ zcat `eval $loc` | groff -Tps -man | ps2pdf - ${page}.pdf && okular tcsh.pdf
+
+# NOTE: `okular' is the default application of KDE environment and it shows
+# postcript and pdf files. You can replace it with your lovely pdf viewer.
+# zcat, locate, groff, are common programs in all Unices. `ps2pdf' program
+# is part of `ghostscript' package that is widely used.
+
+# --- Control Flow ------------------------------------------------------------
+
+#### IF-THEN-ELSE-ENDIF
+# Syntax:
+# if ( expr ) then
+#    ...
+# [else if ( expr2 ) then
+#    ...]
+# [else
+#    ...]
+# endif
+#
+# If the specified expr is true then the commands to the first else are
+# executed; otherwise if expr2 is true then the commands to the second else
+# are executed, etc.
+# Any number of else-if pairs are possible; only one endif is needed.
+#
+# Single-line form:
+#
+# if ( expr ) command
+#
+# If `expr' evaluates true, then command is executed.
+# `command' must be a simple command, not an alias, a pipeline, a command list
+# or a parenthesized command list. With few words, avoid to use it.
+#
+# BUG: Input/output redirection occurs even if expr is false and command is
+# thus not executed.
+#
+
+# check if we are in non-interactive shell and quit if true
+if ( $?USER == 0 || $?prompt == 0 ) exit
+
+# check if we are a login shell
+if ( $?loginsh ) then
+	# check if you are on linux console (not X's terminal)
+	if ( $tty =~ tty* ) then
+		# enable keypad application keys (man console_codes)
+		echo '\033='
+	endif
+endif
+
+#### SWITCH-ENDSW
+# Syntax:
+# switch ( expr )
+# case pattern:
+#     ...
+#     [breaksw]
+# [default:
+#     ...]
+# endsw
+#
+# tcsh uses a case statement that works similarly to switch in C.
+# Each case label is successively matched, against the specified string which
+# is first command and filename  expanded. The file  metacharacters `*', `?'
+# and `[...]' may be used in the case labels. If none of the labels match the
+# execution begins after the default label if its defined.
+# The command `breaksw' causes execution to continue after the endsw. Otherwise
+# control may fall through case labels and default labels as in C.
+
+switch ( $var )
+case *.[1-9]:
+case *.[1-9].gz:
+	echo "$var is a man-page."
+	breaksw
+case *gz:
+	echo "$var is gzipped"
+	breaksw
+default:
+	file $var
+endsw
+
+#### FOREACH-END
+# Syntax:
+# foreach name ( wordlist )
+#	...
+#   [break | continue]
+# end
+#
+# Successively sets the variable `name' to each member of `wordlist' and
+# executes the sequence of commands between this command and the matching
+# `end' keyword. The `continue' keyword jump to the next element back to
+# top; and the `break' keyword terminates the loop.
+#
+# BUG: `foreach' doesn't ignore here documents when looking for its end.
+
+# example: counting 1 to 10
+foreach i ( `seq 1 10` )
+    echo $i
+end
+
+# example: type all files in the list
+foreach f ( a.txt b.txt c.txt )
+	cat $f
+end
+
+# example: convert wma to ogg
+foreach f ( *.wma )
+	ffmpeg -i "$f" "$f:r".ogg
+end
+
+#### WHILE-END
+# while ( expr )
+#     ...
+#     [break | continue]
+# end
+#
+# Executes the commands between the `while' and the matching `end' while `expr'
+# evaluates non-zero. `break' and `continue' may be used to terminate or
+# continue the loop prematurely.
+
+# count from 1 to 10
+set num = 1
+while ( $num <= 10 )
+	echo $num
+	@ num ++
+end
+
+# print all directories of CWD
+set lst = ( * )
+while ( $#lst )
+	if ( -d $lst[1] ) echo $lst[1] is directory
+	shift lst
+end
+
+# separate command-line arguments to options or parameters
+set options
+set params
+set lst = ( $* )
+while ( $#lst )
+	if ( "$lst[1]" =~ '-*' ) then
+		set options = ( $options $lst[1] )
+	else
+		set params = ( $params $lst[1] )
+	endif
+	shift lst
+end
+echo 'options =' $options
+echo 'paramaters =' $params
+
+#### REPEAT
+# Syntax: repeat count command
+#
+# The specified command, which is subject to the same restrictions as the
+# command in the one line if statement above, is executed count times.
+# I/O redirections occur exactly once, even if count is 0.
+#
+# TIP: in most cases prefer `while'
+
+repeat 3 echo "ding dong"
+
+# --- Functions ---------------------------------------------------------------
+# tcsh has no functions but its expression syntax is advanced enough to use
+# `alias' as functions. Another method is recursion
+
+# Alias argument selectors; the ability to define an alias to take arguments
+# supplied to it and apply them to the commands that it refers to.
+# Tcsh is the only shell that provides this feature.
+#
+# \!#   argument selector for all arguments, including the alias/command
+#       itself; arguments need not be supplied.
+# \!*   argument selector for all arguments, excluding the alias/command;
+#       arguments need not be supplied.
+# \!$   argument selector for the last argument; argument need not be supplied,
+#       but if none is supplied, the alias name is considered to be the
+#       last argument.
+# \!^   argument selector for first argument; argument MUST be supplied.
+# \!:n  argument selector for the nth argument; argument MUST be supplied;
+#       n=0 refers to the alias/command name.
+# \!:m-n   argument selector for the arguments from the mth to the nth;
+#       arguments MUST be supplied.
+# \!:n-$   argument selector for the arguments from the nth to the last;
+#       at least argument n MUST be supplied.
+
+# Alias the cd command so that when you change directories, the contents
+# are immediately displayed.
+alias cd 'cd \!* && ls'
+
+# --- Recursion method --- begin ---
+#!/bin/tcsh -f
+set todo = option1
+if ( $#argv > 0 ) then
+	set todo = $argv[1]
+endif
+
+switch ( $todo )
+case option1:
+#	...
+	$0 results
+	breaksw
+case option2:
+#	...
+	$0 results
+	breaksw
+case results:
+	echo "print the results here"
+#	...
+	breaksw
+default:
+	echo "Unknown option: $todo"
+#	exit 0
+endsw
+# --- Recursion method --- end ---
+
+# --- examples ----------------------------------------------------------------
+
+# this script prints available power-states if no argument is set;
+# otherwise it set the state of the $argv[1]
+# --- power-state script --- begin --------------------------------------------
+#!/bin/tcsh -f
+# get parameter ("help" for none)
+set todo = help
+if ( $#argv > 0 ) then
+	set todo = $argv[1]
+endif
+# available options
+set opts = `cat /sys/power/state`
+# is known?
+foreach o ( $opts )
+	if ( $todo == $o ) then
+		# found; execute it
+		echo -n $todo > /sys/power/state
+		break
+	endif
+end
+# print help and exit
+echo "usage: $0 [option]"
+echo "available options on kernel: $opts"
+# --- power-state script --- end ----------------------------------------------
+
+# Guess the secret number game
+# --- secretnum.csh --- begin -------------------------------------------------
+#!/bin/tcsh -f
+set secret=`shuf -i1-100 -n1`
+echo "I have a secret number from 1 up to 100"
+while ( 1 )
+	echo -n "Guess: "
+	set guess = $<
+	if ( $secret == $guess ) then
+		echo "You found it"
+		exit 1
+	else
+		if ( $secret > $guess ) then
+			echo "its greater"
+		else if ( $secret < $guess ) then
+				echo "its lesser"
+			endif
+		endif
+	endif
+end
+# --- secretnum.csh --- end ---------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Appendices
+
+#### About [T]CSH:
+# * CSH is notorious about its bugs;
+# * It was also famous about its advanced interactive mode.
+# * TCSH is famous that have the most advanced completition subsystem.
+# * TCSH is famous that have the most advanced aliases subsystem; aliases
+#   can take parameters and often used as functions!
+# * TCSH is well known that preferred by people  (me too) because of better
+#   syntax. All shells are using Thomson's syntax with exception of [t]csh,
+#   fish and plan9's shells (rc, ex).
+# * It is smaller and consume far less memory than bash, zsh even mksh!
+#   (memusage reports)
+# * TCSH still has bugs; less but have; if you write readable clean code you'll
+#   find none; well almost none... This has to do with the implementation of
+#   csh; that no means the other shells has good implementation.
+# * no one well known shell is capable for regular programming; if your script
+#   getting big, use a programming language, or at least PHP or Perl (good
+#   script languages).
+#
+# Advises:
+# 1. Do not use redirection in single-line if (it is well documented bug)
+#    In most cases avoid to use single-line IFs.
+# 2. Do not mess up with other shells code, c-shell is not compatible with
+#    other shells and has different abilities and priorities.
+# 3. Use spaces as you'll use them to write readable code in any language.
+#    A bug of csh was `set x=1' worked, `set x = 1' worked, `set x =1' did not!
+# 4. It is well documented that numeric expressions require spaces in-between;
+#    also parenthesise all bit-wise and unary operators.
+# 5. Do not write a huge weird expression with several quotes, backslashes etc
+#    It is bad practice for generic programming, it is dangerous in any shell.
+# 6. Help tcsh, report the bug here <https://bugs.gw.com/>
+# 7. Read the man page, `tcsh' has huge number of options, and variables.
+#
+#    I suggest the following options enabled by default
+#    --------------------------------------------------
+# Even in non-interactive shells
+#    set echo_style=both
+#    set backslash_quote
+#    set parseoctal
+#    unset noclobber
+#
+# Whatever...
+#    set inputmode=insert
+#    set autolist
+#    set listjobs
+#    set padhour
+#    set color
+#    set colorcat
+#    set nobeep
+#    set cdtohome
+#
+#    set histdup
+#    set histlit
+#    set nohistclop
+#
+#    unset compat_expr
+#    unset noglob
+#    unset autologout
+#    unset time
+#    unset tperiod
+#
+# NOTE: If the `backslash_quote' is set, it may create compatibility issues
+# with other tcsh scripts which was written without it.
+#
+# NOTE: The same for `parseoctal', but it is better to fix the problematic
+# scripts.
+#
+# NOTE: **for beginners only**
+# This enable automatically rescan `path' directories if need to. (like bash)
+#    set autorehash
+
+#### common aliases
+#    alias hist  'history 20'
+#    alias ll    'ls --color -lha'
+#    alias today "date '+%d%h%y'
+#    alias ff    'find . -name '
+
+#### a nice prompt
+#    set prompt = "%B%{\033[35m%}%t %{\033[32m%}%n@%m%b %C4 %# "
+```
diff --git a/tests/encoding.rb b/tests/encoding.rb
new file mode 100644
index 00000000..a0b3b184
--- /dev/null
+++ b/tests/encoding.rb
@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require 'charlock_holmes'
+$file_count = 0;
+markdown_files = Dir["./**/*.html.markdown"]
+markdown_files.each do |file|
+  begin
+    contents = File.read(file)
+    detection = CharlockHolmes::EncodingDetector.detect(contents)
+    case detection[:encoding]
+    when 'UTF-8'
+      $file_count = $file_count + 1
+    when 'ISO-8859-1'
+      $file_count = $file_count + 1
+    when /ISO-8859/
+      puts "Notice: #{file} was detected as #{detection[:encoding]} encoding. Everything is probably fine."
+      $file_count = $file_count + 1
+    else
+      puts "WARNING #{file} was detected as #{detection[:encoding]} encoding. Please save the file in UTF-8!"
+    end
+  rescue Exception => msg
+    puts msg
+  end
+end
+files_failed = markdown_files.length - $file_count
+if files_failed != 0
+  puts "FAILURE!!! #{files_failed} files were unable to be validated as UTF-8!"
+  puts "Please resave the file as UTF-8."
+  exit 1
+else
+  puts "Success. All #{$file_count} files passed UTF-8 validity checks."
+  exit 0
+end
diff --git a/tests/yaml.rb b/tests/yaml.rb
new file mode 100644
index 00000000..0ed918e0
--- /dev/null
+++ b/tests/yaml.rb
@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'yaml';
+$file_count = 0;
+markdown_files = Dir["./**/*.html.markdown"]
+markdown_files.each do |file|
+  begin
+    YAML.load_file(file)
+    $file_count = $file_count + 1
+  rescue Exception => msg
+    puts msg
+  end
+end
+files_failed = markdown_files.length - $file_count
+if files_failed != 0
+  puts "FAILURE!!! #{files_failed} files were unable to be parsed!"
+  puts "Please check the YAML headers for the documents that failed!"
+  exit 1
+else
+  puts "All #{$file_count} files were verified valid YAML"
+  exit 0
+end
diff --git a/tmux.html.markdown b/tmux.html.markdown
index c9e3db6b..1214a5ba 100644
--- a/tmux.html.markdown
+++ b/tmux.html.markdown
@@ -116,16 +116,12 @@ like how .vimrc or init.el are used.
 
 ```
 # Example tmux.conf
-# 2014.10
+# 2015.12
 
 
 ### General
 ###########################################################################
 
-# Enable UTF-8
-setw -g utf8 on
-set-option -g status-utf8 on
-
 # Scrollback/History limit
 set -g history-limit 2048
 
@@ -133,7 +129,7 @@ set -g history-limit 2048
 set -g base-index 1
 
 # Mouse
-set-option -g mouse-select-pane on
+set-option -g -q mouse on
 
 # Force reload of config file
 unbind r
@@ -208,8 +204,6 @@ setw -g window-status-bg black
 setw -g window-status-current-fg green
 setw -g window-status-bell-attr default
 setw -g window-status-bell-fg red
-setw -g window-status-content-attr default
-setw -g window-status-content-fg yellow
 setw -g window-status-activity-attr default
 setw -g window-status-activity-fg yellow
 
@@ -250,6 +244,4 @@ set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] |
 
 [Display CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
 
-[tmuxinator - Manage complex tmux sessions](https://github.com/tmuxinator/tmuxinator) 
-
-
+[tmuxinator - Manage complex tmux sessions](https://github.com/tmuxinator/tmuxinator)
diff --git a/toml.html.markdown b/toml.html.markdown
new file mode 100755
index 00000000..980563f9
--- /dev/null
+++ b/toml.html.markdown
@@ -0,0 +1,274 @@
+---
+language: toml
+filename: learntoml.toml
+contributors:
+  - ["Alois de Gouvello", "https://github.com/aloisdg"]
+---
+
+TOML stands for Tom's Obvious, Minimal Language. It is a data serialisation language designed to be a minimal configuration file format that's easy to read due to obvious semantics.
+
+It is an alternative to YAML and JSON. It aims to be more human friendly than JSON and simpler that YAML. TOML is designed to map unambiguously to a hash table. TOML should be easy to parse into data structures in a wide variety of languages.
+
+Be warned, TOML's spec is still changing a lot. Until it's marked as 1.0, you
+should assume that it is unstable and act accordingly. This document follows TOML v0.4.0. 
+
+```toml
+# Comments in TOML look like this.
+
+################
+# SCALAR TYPES #
+################
+
+# Our root object (which continues for the entire document) will be a map,
+# which is equivalent to a dictionary, hash or object in other languages.
+
+# The key, equals sign, and value must be on the same line
+# (though some values can be broken over multiple lines).
+key = "value"
+string = "hello"
+number = 42
+float = 3.14
+boolean = true
+dateTime = 1979-05-27T07:32:00-08:00
+scientificNotation = 1e+12
+"key can be quoted" = true # Both " and ' are fine
+"key may contains" = "letters, numbers, underscores, and dashes"
+
+# A bare key must be non-empty, but an empty quoted key is allowed
+"" = "blank"     # VALID but discouraged
+'' = 'blank'     # VALID but discouraged
+
+##########
+# String #
+##########
+
+# All strings must contain only valid UTF-8 characters.
+# We can escape characters and some of them have a compact escape sequence.
+# For example, \t add a tabulation. Refers to the spec to get all of them.
+basicString = "are surrounded by quotation marks. \"I'm quotable\". Name\tJos"
+
+multiLineString = """
+are surrounded by three quotation marks
+on each side and allow newlines."""
+
+literalString = 'are surrounded by single quotes. Escaping are not allowed.'
+
+multiLineLiteralString = '''
+are surrounded by three single quotes on each side
+and allow newlines. Still no escaping.
+The first newline is trimmed in raw strings.
+   All other whitespace
+   is preserved. #! are preserved?
+'''
+
+# For binary data it is recommended that you use Base64, another ASCII or UTF8
+# encoding. The handling of that encoding will be application specific.
+
+###########
+# Integer #
+###########
+
+## Integers can start with a +, a - or nothing.
+## Leading zeros are not allowed. Hex, octal, and binary forms are not allowed.
+## Values that cannot be expressed as a series of digits are not allowed.
+int1 = +42
+int2 = 0
+int3 = -21
+integerRange = 64
+
+## You can use underscores to enhance readability. Each
+## underscore must be surrounded by at least one digit.
+int4 = 5_349_221
+int5 = 1_2_3_4_5     # VALID but discouraged
+
+#########
+# Float #
+#########
+
+# Floats are an integer followed by a fractional and/or an exponent part.
+flt1 = 3.1415
+flt2 = -5e6
+flt3 = 6.626E-34
+
+###########
+# Boolean #
+###########
+
+bool1 = true
+bool2 = false
+boolMustBeLowercase = true
+
+############
+# Datetime #
+############
+
+date1 = 1979-05-27T07:32:00Z # follows the RFC 3339 spec
+date2 = 1979-05-27T07:32:00 # without offset
+date3 = 1979-05-27 # without offset nor time
+
+####################
+# COLLECTION TYPES #
+####################
+
+#########
+# Array #
+#########
+
+array1 = [ 1, 2, 3 ]
+array2 = [ "Commas", "are", "delimiters" ]
+array3 = [ "Don't mixed", "different", "types" ]
+array4 = [ [ 1.2, 2.4 ], ["all", 'strings', """are the same""", '''type'''] ]
+array5 = [
+  "Whitespace", "is", "ignored"
+]
+
+#########
+# Table #
+#########
+
+# Tables (or hash tables or dictionaries) are collections of key/value
+# pairs. They appear in square brackets on a line by themselves.
+# Empty tables are allowed and simply have no key/value pairs within them.
+[table]
+
+# Under that, and until the next table or EOF are the key/values of that table.
+# Key/value pairs within tables are not guaranteed to be in any specific order.
+[table-1]
+key1 = "some string"
+key2 = 123
+
+[table-2]
+key1 = "another string"
+key2 = 456
+
+# Dots are prohibited in bare keys because dots are used to signify nested tables.
+# Naming rules for each dot separated part are the same as for keys.
+[dog."tater.man"]
+type = "pug"
+
+# In JSON land, that would give you the following structure:
+# { "dog": { "tater.man": { "type": "pug" } } }
+
+# Whitespace around dot-separated parts is ignored, however, best practice is to
+# not use any extraneous whitespace.
+[a.b.c]            # this is best practice
+[ d.e.f ]          # same as [d.e.f]
+[ j . "ʞ" . 'l' ]  # same as [j."ʞ".'l']
+
+# You don't need to specify all the super-tables if you don't want to. TOML knows
+# how to do it for you.
+# [x] you
+# [x.y] don't
+# [x.y.z] need these
+[x.y.z.w] # for this to work
+
+# As long as a super-table hasn't been directly defined and hasn't defined a
+# specific key, you may still write to it.
+[a.b]
+c = 1
+
+[a]
+d = 2
+
+# You cannot define any key or table more than once. Doing so is invalid.
+
+# DO NOT DO THIS
+[a]
+b = 1
+
+[a]
+c = 2
+
+# DO NOT DO THIS EITHER
+[a]
+b = 1
+
+[a.b]
+c = 2
+
+# All table names must be non-empty.
+[]     # INVALID
+[a.]   # INVALID
+[a..b] # INVALID
+[.b]   # INVALID
+[.]    # INVALID
+
+################
+# Inline table #
+################
+
+inlineTables = { areEnclosedWith = "{ and }", mustBeInline = true }
+point = { x = 1, y = 2 }
+
+###################
+# Array of Tables #
+###################
+
+# An array of tables can be expressed by using a table name in double brackets.
+# Each table with the same double bracketed name will be an item in the array.
+# The tables are inserted in the order encountered.
+
+[[products]]
+name = "array of table"
+sku = 738594937
+emptyTableAreAllowed = true
+
+[[products]]
+
+[[products]]
+name = "Nail"
+sku = 284758393
+color = "gray"
+
+# You can create nested arrays of tables as well. Each double-bracketed
+# sub-table will belong to the nearest table element above it.
+
+[[fruit]]
+  name = "apple"
+
+  [fruit.Geometry]
+    shape = "round"
+    note = "I am an fruit's property"
+
+  [[fruit.color]]
+    name = "red"
+    note = "I am an array's item in apple"
+
+  [[fruit.color]]
+    name = "green"
+    note = "I am in the same array than red"
+
+[[fruit]]
+  name = "banana"
+
+  [[fruit.color]]
+    name = "yellow"
+    note = "I am an array's item too but banana's one"
+```
+
+In JSON land, this code will be:
+
+```json
+{
+  "fruit": [
+    {
+      "name": "apple",
+      "geometry": { "shape": "round", "note": "..."},
+      "color": [
+        { "name": "red", "note": "..." },
+        { "name": "green", "note": "..." }
+      ]
+    },
+    {
+      "name": "banana",
+      "color": [
+        { "name": "yellow", "note": "..." }
+      ]
+    }
+  ]
+}
+```
+
+### More Resources
+
++ [TOML official repository](https://github.com/toml-lang/toml)
diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/bf-tr.html.markdown
index bd842b17..e7015cd0 100644
--- a/tr-tr/brainfuck-tr.html.markdown
+++ b/tr-tr/bf-tr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 filename: brainfuck-tr
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io"]
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 2d4240ed..33544765 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -202,7 +202,7 @@ int main() {
     0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
 
     // Isaretli sayilari kaydirirken dikkatli olun - tanimsizlar sunlardir:
-    // - isaretli sayinin isaret bitinde yap�ilan kaydirma (int a = 1 << 32)
+    // - isaretli sayinin isaret bitinde yap?ilan kaydirma (int a = 1 << 32)
     // - negatif sayilarda sol kaydirma (int a = -1 << 2)
     // - LHS tipinde >= ile olan ofset genisletmelerde yapilan kaydirma:
     //   int a = 1 << 32; // UB if int is 32 bits wide
diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
new file mode 100644
index 00000000..1900ee93
--- /dev/null
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -0,0 +1,44 @@
+---
+language: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "https://github.com/akashdeepgoel"]
+translators:
+    - ["Mehmet Cem Yaraş", "https://www.linkedin.com/in/yarascem/"]
+lang: tr-tr
+---
+
+Dinamik Programlama
+Giriş
+Dinamik Programlama, göreceğimiz gibi belirli bir problem sınıfını çözmek için kullanılan güçlü bir tekniktir. Fikir çok basittir, verilen girdiyle ilgili bir sorunu çözdüyseniz, aynı sorunun tekrar çözülmesini önlemek için sonucunu gelecekte referans olarak kaydedilmesine dayanır.
+
+Her zaman hatırla! "Geçmiş hatırlayamayanlar, aynı şeyleri tekrar yaşamaya mahkumlardır!"
+
+Bu tür sorunların çözüm yolları
+
+1-Yukarıdan aşağıya:
+Verilen problemi çözerek çözmeye başlayın. Sorunun zaten çözüldüğünü görürseniz, kaydedilen cevabı döndürmeniz yeterlidir. Çözülmemişse, çözünüz ve cevabı saklayınız. Bu genellikle düşünmek kolaydır ve çok sezgiseldir. Buna Ezberleştirme denir.
+
+2-Aşağıdan yukarıya:
+Sorunu analiz edin ve alt problemlerin çözülme sırasını görün ve önemsiz alt sorundan verilen soruna doğru başlayın. Bu süreçte, problemi çözmeden önce alt problemlerin çözülmesi gerekmektedir. Buna Dinamik Programlama denir.
+
+Örnek
+En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini bulmaktır. S = {a1, a2, a3, a4, ............., an-1} dizisi göz önüne alındığında, en uzun bir alt kümeyi bulmak zorundayız, böylece tüm j ve i, j için <I, aj <ai alt kümesinde. Her şeyden önce, en son alt dizgenin (LSi) değerini dizinin son elemanı olan ai'nin her indeksinde bulmalıyız. Daha sonra en büyük LSi, verilen dizideki en uzun alt dizin olacaktır. Başlamak için, ai, dizinin elemanı olduğundan (Son öğe) LSi atanır. Sonra tüm j için j <i ve aj <ai gibi, En Büyük LSj'yi buluruz ve LSi'ye ekleriz. Sonra algoritma O (n2) zaman alır.
+
+En uzun artan alt dizinin uzunluğunu bulmak için sözde kod: Bu algoritmaların karmaşıklığı dizi yerine daha iyi veri yapısı kullanılarak azaltılabilir. Büyük dizin ve dizin gibi selefi dizi ve değişkeni saklama çok zaman kazandıracaktır.
+
+Yönlendirilmiş asiklik grafiğinde en uzun yolu bulmak için benzer bir kavram uygulanabilir.
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (largest < LS[i])
+    
+Bazı Ünlü Dinamik Programlama Problemleri
+-Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs—floyd-warshall-algorithm-with-c-program-source-code
+-Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—the-integer-knapsack-problem
+-Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—longest-common-subsequence
+
+Online Kaynaklar
+https://www.codechef.com/wiki/tutorial-dynamic-programming
diff --git a/tr-tr/fsharp-tr.html.markdown b/tr-tr/fsharp-tr.html.markdown
new file mode 100644
index 00000000..8c47397c
--- /dev/null
+++ b/tr-tr/fsharp-tr.html.markdown
@@ -0,0 +1,631 @@
+---
+language: F#
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com/"]
+translators:
+    - ["Mustafa Zengin", "http://zengin.github.com/"]
+filename: learnfsharp-tr.fs
+lang: tr-tr
+---
+
+F# fonksiyonel ve nesne yönelimli, genel amaçlı bir programlama dilidir. Bedava ve açık kaynaklıdır ve Linux, Mac, Windows ve dahasında çalışır.
+
+Hataları derleme zamanında yakalayan çok güçlü bir tip sistemine sahiptir, ancak tip çıkarımı yaptığından dinamik bir dil gibi görünür.
+
+F#'ın söz dizimi C-stili dillerden farklıdır:
+
+* Küme parantezi kod bloklarını ayırmak için kullanılmaz. Bunun yerine Python'da olduğu gibi girinti kullanılır.
+* Parametreleri birbirinden ayırmak için virgül yerine boşluk karakteri kullanılır.
+
+Aşağıdaki kodu denemek istiyorsanız, [tryfsharp.org](http://www.tryfsharp.org/Create)'a gidin be interaktif REPL'e kodu yapıştırın.
+
+```csharp
+
+// tek satır yorumlar ikili bölme işareti ile başlar
+(* çok satırlı yorumlar ( * . . . * ) ikilisini kullanır
+
+-çok satırlı yorumun sonu- *)
+
+// ================================================
+// Temel Söz Dizimi
+// ================================================
+
+// ------ "Değişkenler" (tam da değil) ------
+// "let" anahtar kelimesi (değişmez) değer tanımlar
+let tamsayım = 5
+let ondalığım = 3.14
+let stringim = "merhaba"           // tip bilgisi olmamasına dikkat
+
+// ------ Listeler ------
+let ikidenBeşe = [2; 3; 4; 5]      // Köşeli parantezler listeleri oluşturur,
+                                   // değerler ise noktalı virgülle ayrılır.
+let birdenBeşe = 1 :: ikidenBeşe   // :: yeni birinci elemanı olan bir liste oluşturur.
+// Sonuç: [1; 2; 3; 4; 5]
+let sıfırdanBeşe = [0; 1] @ ikidenBeşe  // @ iki listeyi birbirine ekler.
+
+// ÖNEMLİ: virgüller hiçbir zaman ayraç olarak kullanılmaz, sadece noktalı virgüller!
+
+// ------ Fonksiyonlar ------
+// "let" anahtar kelimesi isimlendirilmiş fonksiyonları da tanımlar.
+let kare x = x * x          // Parantez kullanılmadığına dikkat.
+kare 3                      // Şimdi fonksiyonu uygulayın. Yine parantez yok.
+
+let topla x y = x + y       // topla (x,y) kullanmayın! Bu tamamen başka bir anlama geliyor.
+topla 2 3                   // Şimdi fonksiyonu uygulayın.
+
+// çok satırlı bir fonksiyon tanımlamak için sadece girinti kullanın. Noktalı virgül gerekmez.
+let çiftler liste =
+   let çiftMi x = x % 2 = 0     // "çiftMi"yi alt fonksiyon olarak tanımlayın
+   List.filter çiftMi liste     // List.filter 'boolean bir fonksiyon' ve
+                                // 'üzerinde çalışılacak bir liste' parametrelerinden oluşan
+                                // bir kütüphane fonksiyonu
+                              
+çiftler birdenBeşe              // Şimdi fonksiyonu uygula.
+
+// Parantezleri önceliği netleştirmek için kullanabilirsiniz. Bu örnek
+// "map"i önce iki argümana, sonra sonuç üzerinde "ekle" uyguluyor.
+// Parantezler olmasaydı, "List.map" List.sum'ın ilk argümanı olurdu.
+let yüzeKadarKarelerinToplamı =
+   List.sum ( List.map kare [1..100] )
+
+// Bir operasyonun sonucunu bir sonrakine "|>" kullanarak besleyebilirsin.
+// Veri beslemek F#'ta UNIX'te olduğu gibi yaygındır..
+
+// Burada yüzeKadarKarelerinToplamı fonksiyonunun veri beslemeyle yazılmış hali var:
+let veriBeslemeyleYüzeKadarKarelerinToplamı =
+   [1..100] |> List.map kare |> List.sum  // "kare" önceden tanımlanmıştı
+
+// Lambda'ları (anonim fonksiyonları) "fun" anahtar kelimesiyle tanımlayabilirsin
+let funlaYüzeKadarKarelerinToplamı =
+   [1..100] |> List.map (fun x -> x * x) |> List.sum
+
+// F#'ta "return" anahtar kelimesi yoktur. Bir fonksiyon
+// her zaman son kullanılan ifadeyi döndürür.
+
+// ------ Kalıp eşleştirme ------
+// Match..with.. çok güçlü bir case/switch türevidir.
+let basitKalıpEşleştirme =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x a'dır"
+    | "b" -> printfn "x b'dir"
+    | _ -> printfn "x başka bir şeydir"   // alt çizgi bütün kalıplarla eşleşir
+
+// F# varsayılan olarak null'lara izin vermez -- Option tipini kullanıp
+// kalıp eşleştirme yapmalısın.
+// Some(..) ve None, Nullable tipler gibidir.
+let geçerliDeğer = Some(99)
+let geçersizDeğer = None
+
+// Bu örnekte, match..with "Some" ve "None"la eşleştirme yapıyor,
+// ve ayrıca "Some" içerisindeki değeri de çıkarıyor.
+let optionKalıpEşleştirme input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionKalıpEşleştirme geçerliDeğer
+optionKalıpEşleştirme geçersizDeğer
+
+// ------ Yazdırma ------
+// printf/printfn fonksiyonları C#'taki 
+// Console.Write/WriteLine fonksiyonlarına benzer.
+printfn "Bir tamsayı %i, bir ondalık %f, bir boolean %b yazdırma" 1 2.0 true
+printfn "Bir string %s, ve jenerik bir tip %A" "merhaba" [1; 2; 3; 4]
+
+// sprintf/sprintfn fonksiyonları ise veriyi string'e
+// çevirmek içindir, C#'taki String.Format gibi.
+
+// ================================================
+// Fonksiyonlar hakkında dahası
+// ================================================
+
+// F# gerçek bir fonksiyonel dildir. Fonksiyonlar birinci
+// sınıf varlıklardır ve güçlü yapılar oluşturmak için
+// birleştirilebilirler.
+
+// Modüller fonksiyonları gruplamak için kullanılır.
+// Her bir modül için girinti gerekir.
+module FonksiyonOrnekleri =
+
+    // Temel bir ekleme fonksiyonu tanımla
+    let topla x y = x + y
+
+    // Bir fonksiyonun temel kullanımı
+    let a = topla 1 2
+    printfn "1 + 2 = %i" a
+
+    // Parametreleri kaynaklamak için parçalı uygulama
+    let kırkİkiEkle = topla 42
+    let b = kırkİkiEkle 1
+    printfn "42 + 1 = %i" b
+
+    // Fonksiyonları birleştirmek için kompozisyon
+    let birEkle = topla 1
+    let ikiEkle = topla 2
+    let üçEkle = birEkle >> ikiEkle
+    let c = üçEkle 7
+    printfn "3 + 7 = %i" c
+
+    // Yüksek dereceli fonksiyonlar
+    [1..10] |> List.map üçEkle |> printfn "yeni liste: %A"
+
+    // Fonksiyonlar listesi ve dahası
+    let altıEkle = [birEkle; ikiEkle; üçEkle] |> List.reduce (>>)
+    let d = altıEkle 7
+    printfn "1 + 2 + 3 + 7 = %i" d
+
+// ================================================
+// Listeler ve kolleksiyonlar
+// ================================================
+
+// Üç çesit sıralı fonksiyon vardır:
+// * Listeler en temel değiştirilemez kolleksiyonlardır.
+// * Diziler değiştirilebilir ve gerektiğinde daha verimlidirler.
+// * Seriler tembel (lazy evaluation) ve sonsuzdurlar (Enumeratörler gibi). 
+// 
+// Değiştirilmez map'ler ve kümeler ve bütün .NET kolleksiyonları
+// diğer kolleksiyon türleridir.
+
+module ListeÖrnekleri =
+
+    // listeler köşeli parantez kullanır
+    let liste1 = ["a"; "b"]
+    let liste2 = "c" :: liste1    // :: başa eleman ekler
+    let liste3 = liste1 @ liste2   // @ listeleri birbirine ekler
+
+    // Liste comprehension'ları (jeneratörler olarak da bilinir)
+    let kareler = [for i in 1..10 do yield i * i]
+
+    // asal sayı jeneratörü
+    let rec elek = function
+        | (p::xler) -> p :: elek [ for x in xler do if x % p > 0 then yield x ]
+        | []      -> []
+    let asallar = elek [2..50]
+    printfn "%A" asallar
+
+    // Listelerle kalıp eşleştirme
+    let listeEşleyici liste =
+        match liste with
+        | [] -> printfn "liste boş"
+        | [birinci] -> printfn "listede sadece bir eleman var: %A " birinci
+        | [birinci; ikinci] -> printfn "liste: %A ve %A" birinci ikinci
+        | _ -> printfn "listede ikiden fazla eleman var"
+
+    listeEşleyici [1; 2; 3; 4]
+    listeEşleyici [1; 2]
+    listeEşleyici [1]
+    listeEşleyici []
+
+    // Listeleri kullanarak recursion
+    let rec ekle liste =
+        match liste with
+        | [] -> 0
+        | x::xler -> x + ekle xler
+    ekle [1..10]
+
+    // -----------------------------------------
+    // Standart kütüphane fonksiyonları
+    // -----------------------------------------
+
+    // map
+    let üçEkle x = x + 3
+    [1..10] |> List.map üçEkle
+
+    // filter
+    let çift x = x % 2 = 0
+    [1..10] |> List.filter çift
+
+    // ve dahası -- dökümantasyona bakınız
+
+module DiziÖrnekleri =
+
+    // Diziler köşeli parantezle birlikte çubuk karakterini kullanır
+    let dizi1 = [| "a"; "b" |]
+    let birinci = dizi1.[0]        // nokta kullanarak indeks erişimi
+
+    // Diziler için kalıp eşleştirme listlerle aynıdır
+    let diziEşleştirici liste =
+        match liste with
+        | [| |] -> printfn "dizi boş"
+        | [| birinci |] -> printfn "dizide sadece bir eleman var: %A " birinci
+        | [| birinci; ikinci |] -> printfn "dizi: %A ve %A" birinci ikinci
+        | _ -> printfn "dizide ikiden fazla eleman var"
+
+    diziEşleştirici [| 1; 2; 3; 4 |]
+
+    // Listede olduğu gibi kütüphane fonksiyonları
+
+    [| 1..10 |]
+    |> Array.map (fun i -> i + 3)
+    |> Array.filter (fun i -> i % 2 = 0)
+    |> Array.iter (printfn "değer: %i. ")
+
+
+module SeriÖrnekleri =
+
+    // seriler kıvrık parantez kullanır
+    let seri1 = seq { yield "a"; yield "b" }
+
+    // seriler yield'ı kullanabilir
+    // ve alt seriler barındırabilir
+    let garip = seq {
+        // "yield" bir eleman ekliyor
+        yield 1; yield 2;
+
+        // "yield!" bütün bir alt seriyi ekliyor
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i % 2 = 0 then yield i }}
+    // test
+    garip |> Seq.toList
+
+
+    // Seriler "unfold" kullanılarak oluşturulabilir
+    // Fibonacci serisi örneği
+    let fib = Seq.unfold (fun (birinci,ikinci) ->
+        Some(birinci + ikinci, (ikinci, birinci + ikinci))) (0,1)
+
+    // test
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "ilk 10 fibonacci sayısı: %A" fib10
+
+
+// ================================================
+// Veri Tipleri
+// ================================================
+
+module VeriTipiÖrnekleri =
+
+    // Bütün veriler varsayılan olarak değiştirilemezdir.
+
+    // -- Tuple oluşturmak için virgül kullan
+    let ikiliTuple = 1, 2
+    let üçlüTuple = "a", 2, true
+    
+    // Tuple'lar çabuk ve kolay anonim tiplerdir.
+    // paketi açmak için kalıp eşleştirme kullan
+    let x, y = ikiliTuple  // x = 1, y = 2
+
+    // ------------------------------------
+    // Record tipi isimlendirilmiş alanlara sahiptir
+    // ------------------------------------
+
+    // "type" ile kıvrık parantezleri record tipi oluşturmak için kullan
+    type Kişi = {Ad:string; Soyad:string}
+
+    // "let" ile kıvrık parantezi record tipi oluşturmak için kullan
+    let kişi1 = {Ad="Falanca"; Soyad="Kişi"}
+
+    // paketi açmak için kalıp eşleştirme kullan
+    let {Ad = Ad} = kişi1    // birinci="John"
+
+    // ------------------------------------
+    // Union tipleri (değişkenler olarak da bilinir) birden fazla
+    // seçeneğe sahiptir. Belli bir zamanda sadece bir tanesi geçerlidir.
+    // ------------------------------------
+
+    // "type" ile çubuk karakterini union tipi tanımlamak için kullan
+    type Sıcaklık =
+        | Santigrat of float
+        | Fahrenhayt of float
+
+    // Seçeneklerden birini kullan
+    let derece1 = Fahrenhayt 98.6
+    let derece2 = Santigrat 37.0
+
+    // Paketi açmak için bütün seçenekler üzerinde kalıp eşleştirme kullan
+    let dereceYazdır = function
+       | Santigrat t -> printfn "%f C" t
+       | Fahrenhayt t -> printfn "%f F" t
+
+    dereceYazdır derece1
+    dereceYazdır derece2
+
+    // ------------------------------------
+    // Yinelgen (Recursive) tipler
+    // ------------------------------------
+
+    // Tipler alt sınıflar oluşturmadan karmaşık şekillerde
+    // yinelgen olarak birleştirilebilirler.
+    type Çalışan =
+      | İşçi of Kişi
+      | Yönetici of Çalışan list
+
+    let falancaKişi = {Ad="Falanca"; Soyad="Kişi"}
+    let işçi = İşçi falancaKişi
+
+    // ------------------------------------
+    // Tipleri Kullanarak Modelleme
+    // ------------------------------------
+
+    // Union tipleri bayrak kullanmadan durum modelleme için harikadır.
+    type EpostaAdresi =
+        | GeçerliEpostaAdresi of string
+        | GeçersizEpostaAdresi of string
+
+    let epostaGöndermeyiDene eposta =
+        match eposta with                     // kalıp eşleştirme kullan
+        | GeçerliEpostaAdresi adres -> ()     // gönder
+        | GeçersizEpostaAdresi adres -> ()    // gönderme
+
+    // Union tiplerin record tiplerle birleşimi
+    // domain driven design için iyi bir temel oluşturur.
+    // Domain'i yansıtan yüzlerce ufak tip oluşturabilirsiniz.
+
+    type Ürün = { ÜrünKodu: string; Miktar: int }
+    type Ödeme = Ödeme of float
+    type AktifSepetVerisi = { ÖdenmemişÜrünler: Ürün list }
+    type ÖdenmişSepetVerisi = { ÖdenmişÜrünler: Ürün list; Ödeme: Ödeme}
+
+    type AlışverişSepeti =
+        | BosSepet  // veri yok
+        | AktifSepet of AktifSepetVerisi
+        | ÖdenmişSepet of ÖdenmişSepetVerisi
+
+    // ------------------------------------
+    // Tipler için içgüdüsel davranış
+    // ------------------------------------
+
+    // Çekirdek tipler kendinden çok kullanışlı özelliklere sahiptir
+    // Ek kodlama gerektirmez
+    // * Değişmezlik
+    // * Debug ederken yazdırma
+    // * Eşitlik ve kıyaslama
+    // * Serialization
+
+    // %A kullanarak yazdırma
+    printfn "ikiliTuple=%A,\nKişi=%A,\Sıcaklık=%A,\nÇalışan=%A"
+             ikiliTuple kişi1 derece1 işçi
+
+    // Eşitlik ve kıyaslama içgüdüseldir.
+    // İskambil kartlarıyla bir örnek
+    type Simge = Sinek | Karo | Maça | Kupa
+    type Sıra = İki | Üç | Dört | Beş | Altı | Yedi | Sekiz
+                | Dokuz | On | Bacak | Kız | Papaz | As
+
+    let el = [ Sinek, As; Kupa, Üç; Kupa, As;
+                 Maça, Bacak; Karo, İki; Karo, As ]
+
+    // Sıralama
+    List.sort el |> printfn "artarak dizilen el: %A"
+    List.max el |> printfn "en yüksek kart: %A"
+    List.min el |> printfn "en düşük kart: %A"
+
+
+// ================================================
+// Aktif Kalıplar
+// ================================================
+
+module AktifKalıpÖrnekleri =
+
+    // F# "aktif kalıplar" denen bir kalıp eşleştirmeye sahiptir.
+    // Kalıplar dinamik bir şekilde tespit edilip eşleştirilebilir.
+
+    // Aktif kalıplar için söz dizimi (| ... |) şeklindedir
+
+    // Örneğin, karakter tiplerini eşleyen bir "aktif" kalıp tanımlayın...
+    let (|Rakam|Harf|Boşluk|Diğer|) karakter =
+       if System.Char.IsDigit(karakter) then Rakam
+       else if System.Char.IsLetter(karakter) then Harf
+       else if System.Char.IsWhiteSpace(karakter) then Boşluk
+       else Diğer
+
+    // ... daha sonra eşleme mantığı çok daha net yapmak için bunu kullanın
+    let karakterYazdır karakter =
+      match karakter with
+      | Rakam -> printfn "%c bir rakamdır" karakter
+      | Harf -> printfn "%c bir harftir" karakter
+      | Boşluk -> printfn "%c bir boşluktur" karakter
+      | _ -> printfn "%c başka bir şeydir" karakter
+
+    // Bir liste yazdırma
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter karakterYazdır
+
+    // -----------------------------------
+    // Aktif Kalıpları Kullanarak FizzBuzz
+    // -----------------------------------
+
+    // Parçalı eşleşen kalıplar da oluşturabilirsiniz
+    // Tanımda alt çizgi karakterini kullanın ve eşleşince Some döndürün.
+    let (|ÜçünKatı|_|) i = if i % 3 = 0 then Some ÜçünKatı else None
+    let (|BeşinKatı|_|) i = if i % 5 = 0 then Some BeşinKatı else None
+
+    // Ana fonksiyon
+    let fizzBuzz i =
+      match i with
+      | ÜçünKatı & BeşinKatı -> printf "FizzBuzz, "
+      | ÜçünKatı -> printf "Fizz, "
+      | BeşinKatı -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // test
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Sadelik
+// ================================================
+
+module AlgoritmaÖrnekleri =
+
+    // F#'ın sinyal/gürültü oranı yüksektir, dolayısıyla
+    // kod algoritmayla hemen hemen aynı görünür.
+
+    // ------ Örnek: karelerToplami fonksiyonunu tanımla ------
+    let karelerToplamı n =
+       [1..n]                 // 1) 1'den n'e kadar bütün sayıları al
+       |> List.map kare       // 2) hepsinin karesini al
+       |> List.sum            // 3) sonuçları topla
+
+    // test
+    karelerToplamı 100 |> printfn "kareler toplamı = %A"
+
+    // ------ Örnek: bir sıralama fonksiyonu tanımla ------
+    let rec sırala liste =
+       match liste with
+       // Liste boşsa
+       | [] ->
+            []                              // boş listeyi döndür
+       // Liste boş değilse
+       | ilkEleman::diğerElemanlar ->       // İlk elemanı al
+            let küçükElemanlar =            // Daha küçük elemanları 
+                diğerElemanlar              // diğerlerinden ayır
+                |> List.filter (fun e -> e < ilkEleman)
+                |> sırala                   // ve sırala
+            let büyükElemanlar =            // Daha büyük elemanları
+                diğerElemanlar              // diğerlerinden ayır
+                |> List.filter (fun e -> e >= ilkEleman)
+                |> sırala                   // ve sırala
+            // 3 parçayı birbirine ekle ve listeyi döndür
+            List.concat [küçükElemanlar; [ilkEleman]; büyükElemanlar]
+
+    // test
+    sırala [1; 5; 23; 18; 9; 1; 3] |> printfn "Sırala = %A"
+
+// ================================================
+// Eşzamansız kod
+// ================================================
+
+module EşzamansızÖrneği =
+
+    // F# "pyramid of doom" durumuyla karşılaştırmayacak şekilde
+    // içgüdüsel eşzamansız özelliklere sahiptir.
+    //
+    // Bir sonraki örnek bir web sayfasını paralel bir şekilde indirir.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // İçeriği eşzamansız bir şekilde getir
+    let eşzamansızUrlGetir url =
+        async {   // "async" anahtar kelimesi ve kıvrık parantez
+                  // "async (eşzamansız)" nesneyi oluşturur
+            let istek = WebRequest.Create(Uri(url))
+            use! cevap = istek.AsyncGetResponse()
+                // use! eşzamansız atamadır
+            use akış = cevap.GetResponseStream()
+                // "use" kullanılan bloğun dışına çıkınca
+                // close()'u otomatik olarak tetikler
+            use okuyucu = new IO.StreamReader(akış)
+            let html = okuyucu.ReadToEnd()
+            printfn "İndirme tamamlandı: %s" url
+            }
+
+    // İndirmek için bir web sitesi listesi
+    let siteler = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // İndir
+    siteler
+    |> List.map eşzamansızUrlGetir  // eşzamansız görevlerden oluşan bir liste yap
+    |> Async.Parallel               // bu görevleri paralel çalışacak şekilde ayarla
+    |> Async.RunSynchronously       // başlat
+
+// ================================================
+// .NET uyumluluğu
+// ================================================
+
+module NetUyumlulukÖrnekleri =
+
+    // F#, C#'ın yapabildiği hemen herşeyi yapabilir,
+    // ve .NET ve Mono kütüphaneleriyle tereyağından kıl çeker gibi çalışır.
+
+    // ------- var olan kütüphane fonksiyonları ile çalışma -------
+
+    let (i1başarılı, i1) = System.Int32.TryParse("123");
+    if i1başarılı then printfn "%i olarak dönüştürüldü" i1 else printfn "dönüştürme başarısız"
+
+    // ------- Arayüzleri yol üstünde tanımlayın! -------
+
+    // IDisposable'ı sağlayan yeni bir nesne oluştur
+    let kaynakOluştur isim =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s atıldı" isim }
+
+    let kaynakKullanVeAt =
+        use r1 = kaynakOluştur "birinci kaynak"
+        printfn "birinci kaynağı kullanıyor"
+        for i in [1..3] do
+            let kaynakİsmi = sprintf "\tiç kaynak %d" i
+            use geçici = kaynakOluştur kaynakİsmi
+            printfn "\t%s ile bir şey yap" kaynakİsmi
+        use r2 = kaynakOluştur "ikinci kaynak"
+        printfn "ikinci kaynağı kullanıyor"
+        printfn "bitti."
+
+    // ------- Nesne yönelimli kod -------
+
+    // F# aynı zamanda tam bir nesne yönelimli dildir.
+    // Sınıfları, kalıtımı ve sanal metotları destekler.
+
+    // Genel tipli bir arayüz
+    type IEnumerator<'a> =
+        abstract member Şimdiki : 'a
+        abstract SonrakineGeç : unit -> bool
+
+    // Sanal metotları olan soyut temel sınıflar
+    [<AbstractClass>]
+    type Şekil() =
+        // sadece okunabilir özellikler
+        abstract member Genişlik : int with get
+        abstract member Yükseklik : int with get
+        // sanal olmayan metot
+        member this.ÇevreleyenAlan = this.Yükseklik * this.Genişlik
+        // temel uygulamasıyla bir sanal metot
+        abstract member Yazdır : unit -> unit
+        default this.Yazdır () = printfn "Ben bir şekil (önümden çekil!)"
+
+    // Somut bir sınıfın soyut sınıftan kalıtımı
+    type Dikdörtgen(x:int, y:int) =
+        inherit Şekil()
+        override this.Genişlik = x
+        override this.Yükseklik = y
+        override this.Yazdır ()  = printfn "Ben bir dikdörtgenim"
+
+    // test
+    let r = Dikdörtgen(2, 3)
+    printfn "Genişlik: %i" r.Genişlik
+    printfn "Çevreleyen Alan: %i" r.ÇevreleyenAlan
+    r.Yazdır()
+
+    // ------- ekleme metotları -------
+
+    // C#'ta olduğu gibi F# da var olan sınıfları ekleme metotları ile genişletebilir.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // test
+    let s = "Ahmet"
+    printfn "'%s' 'A' ile başlar = %A" s s.StartsWithA
+
+    // ------- olaylar -------
+
+    type Butonum() =
+        let tıklamaOlayı = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = tıklamaOlayı.Publish
+
+        member this.DenemeOlayı(arg) =
+            tıklamaOlayı.Trigger(this, arg)
+
+    // test
+    let butonum = new Butonum()
+    butonum.OnClick.Add(fun (sender, arg) ->
+            printfn "arg=%O ile beraber bir tıklama olayı" arg)
+
+    butonum.DenemeOlayı("Merhaba Dünya!")
+
+```
+
+## Daha fazla bilgi
+
+F# hakkında daha fazla demo için [Try F#](http://www.tryfsharp.org/Learn) sitesine gidin, veya benim (yazarın) [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/) serimi okuyun.
+
+F# hakkında daha fazla bilgi için: [fsharp.org](http://fsharp.org/).
diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
index bac8f6fc..b8f11e39 100644
--- a/tr-tr/markdown-tr.html.markdown
+++ b/tr-tr/markdown-tr.html.markdown
@@ -52,7 +52,7 @@ __Bu yazı da kalın.__
 **_Bu da öyle!_**
 *__Hatta bu bile!__*
 
-<!-- Github Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
+<!-- GitHub Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
 ~~Bu yazı üstü çizili olarak gözükecek.~~
 
 <!-- Paragraflar bir veya daha fazla boş satırla ayrılır. -->
@@ -151,7 +151,7 @@ kullanabilirsiniz -->
 
 Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor!
 
-<!-- Github Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
+<!-- GitHub Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
 
 \`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! -->
 def foobar
@@ -159,7 +159,7 @@ def foobar
 end
 \`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` -->
 
-<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, Github da 
+<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, GitHub da 
 ``` işaretinden sonra belirttiğiniz yazılım diline göre gerekli
 syntax aydınlatmaları uygulanacaktır -->
 
@@ -230,7 +230,7 @@ Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmama
 bunun için, şu şekilde: \*bu yazı italik değil, yıldızlar arasında\*.
 
 <!-- Tablolar -->
-<!-- Tablolar sadece Github Flavored Markdown'da destekleniyor ve açıkçası
+<!-- Tablolar sadece GitHub Flavored Markdown'da destekleniyor ve açıkçası
 performansı çok yoruyorlar, fakat illa ki kullanmak isterseniz: -->
 
 | Sütun1       | Sütun 2  | Sütün 3       |
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index c7de2922..e53d5568 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -618,14 +618,19 @@ print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayana
 
 ### Ücretsiz Online
 
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
 * [Ideas for Python Projects](http://pythonpracticeprojects.com)
-
 * [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)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
 
 ### Kitaplar
 
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 15056bb8..e694d95d 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -2,7 +2,7 @@
 language: swift
 contributors:
   - ["Özgür Şahin", "https://github.com/ozgurshn/"]
-filename: learnswift.swift
+filename: learnswift-tr.swift
 lang: tr-tr
 ---
 
diff --git a/tr-tr/typescript-tr.html.markdown b/tr-tr/typescript-tr.html.markdown
new file mode 100644
index 00000000..1bf674c6
--- /dev/null
+++ b/tr-tr/typescript-tr.html.markdown
@@ -0,0 +1,180 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Mustafa Zengin", "http://zengin.github.com"]
+filename: learntypescript-tr.ts
+lang: tr-tr
+---
+
+TypeScript, JavaScript'le yazılmış büyük ölçekli uygulamaların geliştirilmesini kolaylaştırmayı hedefleyen bir dildir.
+TypeScript, JavaScript'e sınıflar, modüller, arayüzler, jenerik tipler ve (isteğe bağlı) static tipleme gibi genel konseptler ekler.
+JavaScript, TypeScript'in bir alt kümesidir: Bütün JavaScript kodları geçerli birer TypeScript kodudur ve sorunsuz herhangi bir projeye eklenebilirler. TypeScript derleyici JavaScript kodu üretir.
+
+Bu makale sadece TypeScript'e ait ekstra söz dizimini konu alır, JavaScript için bkz: [JavaScript] (../javascript/).
+
+TypeScript derleyiciyi test etmek için [Playground] (http://www.typescriptlang.org/Playground)'a gidin. Orada otomatik tamamlama ile kod yazabilecek ve üretilen JavaScript'i görebileceksiniz.
+
+```js
+// TypeScript'te üç ana tip vardır.
+var bittiMi: boolean = false;
+var satırlar: number = 42;
+var isim: string = "Anders";
+
+// Tipin bilinmediği zamanlar için "Any" tipi
+var bilinmiyor: any = 4;
+bilinmiyor = "belki de bir string'dir";
+bilinmiyor = false; // tamam, boolean olsun
+
+// Kolleksiyon olarak, tipli ve jenerik diziler
+var liste: number[] = [1, 2, 3];
+// Alternatif olarak jenerik Array tipi
+var liste: Array<number> = [1, 2, 3];
+
+// 'enum' tipleri:
+enum Renk {Kırmızı, Yeşil, Mavi};
+var r: Renk = Renk.Yeşil;
+
+// Son olarak, "void" hiç bir şey döndürmeyen fonksiyonlarda kullanılan tiptir.
+function çokFeciBirUyarı(): void {
+  alert("Ben biraz sinir bozucuyum!");
+}
+
+// Fonksiyonlar birinci sınıf vatandaşlardır ve "kalın ok" lambda söz dizimi "=>"
+// ve tip çıkarımı kullanırlar.
+// Aşağıda listelenenler birbirinin aynısı ve derleyici aynı fonksiyon yapısını
+// çıkaracak ve aynı JavaScript kodunu üretecektir
+var f1 = function(i: number): number { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+var f4 = (i: number) => { return i * i; }
+// Döndürülen tip tip çıkarımıyla belirlendi
+// Tek satırlık yazımda "return" anahtar kelimesine ihtiyaç yok.
+var f5 = (i: number) =>  i * i;
+
+// Arayüzler yapısaldır, listelenen özelliklere sahip her şey arayüzle uyumludur.
+interface Kişi {
+  isim: string;
+  // İsteğe bağlı özellikler "?" ile işaretlenir
+  yaş?: number;
+  // Ve fonksiyonlar...
+  hareketEt(): void;
+}
+
+// "Kişi" arayüzünü kullanan bir nesne
+// isim ve hareketEt özelliklerine sahip olduğu için Kişi olarak kullanılabilir.
+var p: Kişi = { isim: "Anders", hareketEt: () => {} };
+// İsteğe bağlı özelliğe sahip bir Kişi
+var geçerliKişi: Kişi = { isim: "Anders", yaş: 42, hareketEt: () => {} };
+// Geçersiz bir kişi, çünkü yaş bir sayı (number) tipi değil
+var geçersizKişi: Kişi = { isim: "Anders", yaş: true };
+
+// Arayüzler bir fonksiyon tipi de ifade edebilirler
+interface aramaFonksiyonu {
+  (kaynak: string, altString: string): boolean;
+}
+
+// Parametrelerin sadece tipleri önemli, isimleri önemli değil
+var benimAramam: aramaFonksiyonu;
+benimAramam = function(kynk: string, alt: string) {
+  return kynk.search(alt) != -1;
+}
+
+// Sınıflar - üyeler (members) varsayılan olarak public'tir.
+class Nokta {
+  // Özellikler
+  x: number;
+
+  // Yapıcı (constructor) - bu bağlamdaki public/private anahtar kelimeleri
+  // özellikler için gerekli demirbaş kodu oluşturur ve ilk değerlerin
+  // atanmasını sağlar.
+  // Bu örnekte, "y" de "x" gibi tanımlanacak is, but with less code
+  // Default values are also supported
+
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
+
+  // Fonksiyonlar
+  mesafe() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+  // Statik üyeler
+  static orijin = new Nokta(0, 0);
+}
+
+var p1 = new Nokta(10 ,20);
+var p2 = new Nokta(25); //y = 0
+
+// Kalıtım
+class Nokta3Boyutlu extends Nokta {
+  constructor(x: number, y: number, public z: number = 0) {
+    super(x, y); // süper sınıfın yapıcısını çağırmak zorunlu
+  }
+
+  // yeniden tanımlama
+  mesafe() {
+    var d = super.mesafe();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// Modüller, "." alt modülleri ayırmak için kullanılabilir
+module Geometri {
+  export class Kare {
+    constructor(public kenarUzunluğu: number = 0) {
+    }
+    alan() {
+      return Math.pow(this.kenarUzunluğu, 2);
+    }
+  }
+}
+
+var s1 = new Geometri.Kare(5);
+
+// Modüle atıfta bulunmak için yerel takma ad
+import G = Geometri;
+
+var s2 = new G.Kare(10);
+
+// Jenerik Tipler
+// Sınıflar
+class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+// Arayüzler
+interface Çift<T> {
+  item1: T;
+  item2: T;
+}
+
+// Ve fonksiyonlar
+var çifttenTupleÜret = function<T>(p: Çift<T>) {
+  return new Tuple(p.item1, p.item2);
+};
+
+var tuple = çifttenTupleÜret({ item1:"merhaba", item2:"dünya"});
+
+// Tanım dosyasına atıfta bulunma:
+/// <reference path="jquery.d.ts" />
+
+// Şablon Stringleri (ters apostrof kullanan stringler)
+// Şablon Stringlerinin kullanımı
+var isim = 'Anders';
+var selamlama = `Merhaba ${isim}, nasılsın?`
+// Şablon Stringleri ile çok satırlı stringler
+var çokSatırlıString = `Bu çok satırlı
+bir string örneği`;
+
+```
+
+## Daha fazlası
+ * [TypeScript Resmi Sitesi] (http://www.typescriptlang.org/)
+ * [TypeScript dil spesifikasyonu (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Channel 9'da TypeScript'e Giriş] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [GitHub'ta Açık Kaynak Kodu] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - tip tanımları için kaynak] (http://definitelytyped.org/)
diff --git a/typescript.html.markdown b/typescript.html.markdown
index 47e41405..ef37182d 100644
--- a/typescript.html.markdown
+++ b/typescript.html.markdown
@@ -9,29 +9,38 @@ TypeScript is a language that aims at easing development of large scale applicat
 TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
 It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
 
-This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/).
+This article will focus only on TypeScript extra syntax, as opposed to [JavaScript](javascript.html.markdown).
 
 To test TypeScript's compiler, head to the [Playground] (http://www.typescriptlang.org/Playground) where you will be able to type code, have auto completion and directly see the emitted JavaScript.
 
-```js
+```ts
 // There are 3 basic types in TypeScript
-var isDone: boolean = false;
-var lines: number = 42;
-var name: string = "Anders";
+let isDone: boolean = false;
+let lines: number = 42;
+let name: string = "Anders";
+
+// But you can omit the type annotation if the variables are derived from explicit literals
+let isDone = false;
+let lines = 42;
+let name = "Anders";
 
 // When it's impossible to know, there is the "Any" type
-var notSure: any = 4;
+let notSure: any = 4;
 notSure = "maybe a string instead";
 notSure = false; // okay, definitely a boolean
 
+// Use const keyword for constant variables
+const numLivesForCat = 9;
+numLivesForCat = 1; // Error
+
 // For collections, there are typed arrays and generic arrays
-var list: number[] = [1, 2, 3];
+let list: number[] = [1, 2, 3];
 // Alternatively, using the generic array type
-var list: Array<number> = [1, 2, 3];
+let list: Array<number> = [1, 2, 3];
 
 // For enumerations:
-enum Color {Red, Green, Blue};
-var c: Color = Color.Green;
+enum Color { Red, Green, Blue };
+let c: Color = Color.Green;
 
 // Lastly, "void" is used in the special case of a function returning nothing
 function bigHorribleAlert(): void {
@@ -43,14 +52,16 @@ function bigHorribleAlert(): void {
 
 // The following are equivalent, the same signature will be infered by the
 // compiler, and same JavaScript will be emitted
-var f1 = function(i: number): number { return i * i; }
-// Return type inferred
-var f2 = function(i: number) { return i * i; }
-var f3 = (i: number): number => { return i * i; }
+let f1 = function (i: number): number { return i * i; }
 // Return type inferred
-var f4 = (i: number) => { return i * i; }
-// Return type inferred, one-liner means no return keyword needed
-var f5 = (i: number) =>  i * i;
+let f2 = function (i: number) { return i * i; }
+// "Fat arrow" syntax
+let f3 = (i: number): number => { return i * i; }
+// "Fat arrow" syntax with return type inferred
+let f4 = (i: number) => { return i * i; }
+// "Fat arrow" syntax with return type inferred, braceless means no return
+// keyword needed
+let f5 = (i: number) => i * i;
 
 // Interfaces are structural, anything that has the properties is compliant with
 // the interface
@@ -64,19 +75,19 @@ interface Person {
 
 // Object that implements the "Person" interface
 // Can be treated as a Person since it has the name and move properties
-var p: Person = { name: "Bobby", move: () => {} };
+let p: Person = { name: "Bobby", move: () => { } };
 // Objects that have the optional property:
-var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+let validPerson: Person = { name: "Bobby", age: 42, move: () => { } };
 // Is not a person because age is not a number
-var invalidPerson: Person = { name: "Bobby", age: true };
+let invalidPerson: Person = { name: "Bobby", age: true };
 
 // Interfaces can also describe a function type
 interface SearchFunc {
   (source: string, subString: string): boolean;
 }
 // Only the parameters' types are important, names are not important.
-var mySearch: SearchFunc;
-mySearch = function(src: string, sub: string) {
+let mySearch: SearchFunc;
+mySearch = function (src: string, sub: string) {
   return src.search(sub) != -1;
 }
 
@@ -102,8 +113,8 @@ class Point {
   static origin = new Point(0, 0);
 }
 
-var p1 = new Point(10 ,20);
-var p2 = new Point(25); //y will be 0
+let p1 = new Point(10, 20);
+let p2 = new Point(25); //y will be 0
 
 // Inheritance
 class Point3D extends Point {
@@ -113,7 +124,7 @@ class Point3D extends Point {
 
   // Overwrite
   dist() {
-    var d = super.dist();
+    let d = super.dist();
     return Math.sqrt(d * d + this.z * this.z);
   }
 }
@@ -129,12 +140,12 @@ module Geometry {
   }
 }
 
-var s1 = new Geometry.Square(5);
+let s1 = new Geometry.Square(5);
 
 // Local alias for referencing a module
 import G = Geometry;
 
-var s2 = new G.Square(10);
+let s2 = new G.Square(10);
 
 // Generics
 // Classes
@@ -150,28 +161,28 @@ interface Pair<T> {
 }
 
 // And functions
-var pairToTuple = function<T>(p: Pair<T>) {
+let pairToTuple = function <T>(p: Pair<T>) {
   return new Tuple(p.item1, p.item2);
 };
 
-var tuple = pairToTuple({ item1:"hello", item2:"world"});
+let tuple = pairToTuple({ item1: "hello", item2: "world" });
 
 // Including references to a definition file:
 /// <reference path="jquery.d.ts" />
 
 // Template Strings (strings that use backticks)
 // String Interpolation with Template Strings
-var name = 'Tyrone';
-var greeting = `Hi ${name}, how are you?`
+let name = 'Tyrone';
+let greeting = `Hi ${name}, how are you?`
 // Multiline Strings with Template Strings
-var multiline = `This is an example
+let multiline = `This is an example
 of a multiline string`;
 
 ```
 
 ## Further Reading
  * [TypeScript Official website] (http://www.typescriptlang.org/)
- * [TypeScript language specifications (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [TypeScript language specifications] (https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)
  * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
  * [Source Code on GitHub] (https://github.com/Microsoft/TypeScript)
  * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
diff --git a/uk-ua/bash-ua.html.markdown b/uk-ua/bash-ua.html.markdown
index b7e4a5ba..c6e9ebb1 100644
--- a/uk-ua/bash-ua.html.markdown
+++ b/uk-ua/bash-ua.html.markdown
@@ -13,13 +13,13 @@ contributors:
     - ["Etan Reisner", "https://github.com/deryni"]
 translators:
     - ["Ehreshi Ivan", "https://github.com/IvanEh"]
+    - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
 lang: uk-ua
 ---
 
 Bash - командна оболонка unix (unix shell), що також розповсюджувалась як оболонка для
 операційної системи GNU і зараз використовується як командна оболонка за замовчуванням
 для Linux i Max OS X.
-Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell.
 Майже всі приклади, що наведені нижче можуть бути частиною shell-скриптів або
 виконані в оболонці
 
@@ -28,7 +28,7 @@ Bash - командна оболонка unix (unix shell), що також ро
 ```bash
 #!/bin/bash
 # Перший рядок скрипта - це shebang, який вказує системі, як потрібно виконувати
-# скрипт. Як ви вже зрозуміли, коментарі починаються з #. Shebang - тоже коментар
+# скрипт. Як ви вже зрозуміли, коментарі починаються з #. Shebang - також коментар
 
 # Простий приклад hello world:
 echo Hello world!
@@ -123,7 +123,7 @@ fi
 # Вирази позначаються наступним форматом:
 echo $(( 10 + 5 ))
 
-# На відмінно від інших мов програмування, Bash - це командна оболонка, а
+# На відміну від інших мов програмування, Bash - це командна оболонка, а
 # отже, працює в контексті поточної директорії
 ls
 
@@ -135,7 +135,7 @@ ls -l # Показати кожен файл і директорію на окр
 # Таким чином ми можемо переглянути тільки *.txt файли в поточній директорії:
 ls -l | grep "\.txt"
 
-# Ви можете перенаправ вхід і вихід команди (stdin, stdout, stderr).
+# Ви можете перенаправити вхід і вихід команди (stdin, stdout, stderr).
 # Наступна команда означає: читати із stdin, поки не зустрінеться ^EOF$, і
 # перезаписати hello.py наступними рядками (до рядка "EOF"):
 cat > hello.py << EOF
@@ -155,7 +155,7 @@ python hello.py > "output.out"
 python hello.py 2> "error.err"
 python hello.py > "output-and-error.log" 2>&1
 python hello.py > /dev/null 2>&1
-# Поток помилок перезапише фпйл, якщо цей файл існує
+# Потік помилок перезапише файл, якщо цей файл існує
 # тому, якщо ви хочете дописувати до файлу, використовуйте ">>":
 python hello.py >> "output.out" 2>> "error.err"
 
@@ -172,7 +172,6 @@ echo "#helloworld" > output.out
 echo "#helloworld" | cat > output.out
 echo "#helloworld" | tee output.out >/dev/null
 
-# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим)
 # Очистити тимчасові файли з детальним виводом (додайте '-i'
 # для інтерактивного режиму)
 rm -v output.out error.err output-and-error.log
@@ -194,7 +193,7 @@ case "$VARIABLE" in
 esac
 
 # Цикл for перебирає елементи передані в аргумент:
-# Значення $VARIABLE буде напечатано тричі.
+# Значення $VARIABLE буде надруковано тричі.
 for VARIABLE in {1..3}
 do
     echo "$VARIABLE"
@@ -260,12 +259,11 @@ uniq -d file.txt
 cut -d ',' -f 1 file.txt
 # замінити кожне 'okay' на 'great' у файлі file.txt (підтримується regex)
 sed -i 's/okay/great/g' file.txt
-# вивести в stdout все рядки з file.txt, що задовольняють шаблону regex;
+# вивести в stdout всі рядки з file.txt, що задовольняють шаблону regex;
 # цей приклад виводить рядки, що починаються на foo і закінчуються на bar:
 grep "^foo.*bar$" file.txt
 # використайте опцію -c, щоб вивести кількість входжень
 grep -c "^foo.*bar$" file.txt
-# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F)
 # щоб здійснити пошук по рядку, а не по шаблону regex, використовуйте fgrea (або grep -F)
 fgrep "^foo.*bar$" file.txt 
 
diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
new file mode 100644
index 00000000..1ea30f3d
--- /dev/null
+++ b/uk-ua/java-ua.html.markdown
@@ -0,0 +1,783 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+translators:
+    - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+filename: LearnJavaUa.java
+lang: uk-ua
+---
+
+Java є об’єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах.
+[Детальніше читайте тут, англ.](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Однорядковий коментар починається з //
+/*
+Багаторядковий коментар виглядає так.
+*/
+/**
+JavaDoc-коментар виглядає так. Використовується для опису класу та членів класу.
+*/
+
+// Імпорт класу ArrayList з пакета java.util
+import java.util.ArrayList;
+// Імпорт усіх класів з пакета java.security 
+import java.security.*;
+
+// Кожний .java файл містить один зовнішній публічний клас, ім’я якого співпадає
+// з іменем файлу.
+public class LearnJava {
+
+    // Для запуску програма, написана на java, повинна мати точку входу у вигляді методу main.
+    public static void main (String[] args) {
+
+        // Використання System.out.println() для виводу на друк рядків.
+        System.out.println("Привіт, світе!");
+        System.out.println(
+            " Ціле число: " + 10 +
+            " Число з рухомою комою подвійної точности: " + 3.14 +
+            " Булеве значення: " + true);
+
+        // Для друку без переходу на новий рядок використовується System.out.print().
+        System.out.print("Привіт, ");
+        System.out.print("світе");
+
+        // Використання System.out.printf() для простого форматованого виводу на друк.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        ///////////////////////////////////////
+        // Змінні
+        ///////////////////////////////////////
+
+        /*
+        *  Оголошення змінних
+        */
+        // Для оголошення змінних використовується формат <тип> <змінна>
+        int fooInt;
+        // Оголошення декількох змінних одного типу <тип> <ім’я1>, <ім’я2>, <ім’я3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Ініціалізація змінних
+        */
+
+        // Ініціалізація змінної з використанням формату <тип> <ім’я> = <значення>
+        int fooInt = 1;
+        // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім’я1>, <ім’я2>, <ім’я3> = <значення>
+        int fooInt1, fooInt2, fooInt3;
+        fooInt1 = fooInt2 = fooInt3 = 1;
+
+        /*
+        *  Типи змінних
+        */
+        // Байт — 8-бітне ціле число зі знаком
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short — 16-бітне ціле число зі знаком
+        // (-32 768 <= short <= 32 767)
+        short fooShort = 10000;
+
+        // Integer — 32-бітне ціле число зі знаком
+        // (-2 147 483 648 <= int <= 2 147 483 647)
+        int fooInt = 1;
+
+        // Long — 64-бітне ціле число зі знаком
+        // (-9 223 372 036 854 775 808 <= long <= 9 223 372 036 854 775 807)
+        long fooLong = 100000L;
+        // L використовується для позначення того, що число має тип Long;
+        // інакше число буде трактуватись як integer.
+
+        // Примітка: Java не має беззнакових типів.
+
+        // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754 
+        // 2^-149 <= float <= (2-2^-23) * 2^127
+        float fooFloat = 234.5f;
+        // f або F використовується для позначення того, що змінна має тип float;
+        // інакше трактується як double.
+
+        // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754 
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double fooDouble = 123.4;
+
+        // Boolean — true & false (істина чи хиба)
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char — 16-бітний символ Unicode
+        char fooChar = 'A';
+
+        // final - посилання на такі змінні не можуть бути присвоєні іншим об’єктам,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // але вони можуть мати відкладену ініціалізацію.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger -Незмінні знакові цілі числа довільної точності
+        //
+        // BigInteger є типом даних, який дає можливість розробнику виконувати операції
+        // з цілими числами, розрядність яких більша за 64 біти. Числа зберігаються у масиві
+        // байтів, операції над ними виконуються функціями, які мають клас BigInteger
+        //
+        // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок.
+        
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+
+        // BigDecimal — Незмінні знакові дробові числа довільної точності
+        //
+        // BigDecimal складається з двох частин: цілого числа довільної точності 
+        // з немасштабованим значенням та 32-бітного масштабованого цілого числа
+        //
+        // BigDecimal дозволяє розробникам контролювати десяткове округлення.
+        // Рекомендовано використовувати BigDecimal зі значеннями валют
+        // і там, де необхідна точність дробових обчислень.
+        //
+        // BigDecimal може бути ініціалізований типами даних int, long, double або String
+        // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+        
+        // Для дотримання заданої точності рекомендується використовувати
+        // конструктор, який приймає String 
+        
+        BigDecimal tenCents = new BigDecimal("0.1");
+
+
+        // Рядки
+        String fooString = "Це мій рядок!";
+
+        // \n є символом переходу на новий рядок
+        String barString = "Друк з нового рядка?\nНема питань!";
+        // \t — це символ табуляції
+        String bazString = "Хочете додати табуляцію?\tТримайте!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Масиви
+        // Розмір масиву має бути визначений перед ініціалізацією
+        // Наведений формат ілюструє ініціалізацію масивів
+        // <тип даних>[] <ім’я змінної> = new <тип даних>[<розмір масиву>];
+        // <тип даних> <ім’я змінної>[] = new <тип даних>[<розмір масиву>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Інший шлях оголошення та ініціалізації масиву
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Індексація масиву — доступ за елементами
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Масиви є змінними та мають нульовий елемент.
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Додатково
+        // ArrayLists — Схожі на масив, але мають більший функціонал та змінний розмір.
+        // LinkedLists — Реалізація двозв’язного списку. Всі операції
+        //               виконуються так, як очікується від
+        //               двозв’язного списку.
+        // Maps — Множина об’єктів, які пов’язують ключ зі значенням. Map є
+        //        інтерфейсом, тому не може бути успадкований.
+        //        Типи ключів і значень, які зберігаються в Map, мають
+        //        вказуватись у класі, який його реалізує.
+		//		  Ключ не може повторюватись і пов’язаний лише з одним значенням        
+        // HashMaps — Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map.
+        //            Це дозволяє виконувати певні операції,
+        //            такі, як отримання та вставка елемента,
+        //            залишаючись постійними навіть для великої кількості елементів.
+
+        ///////////////////////////////////////
+        // Оператори
+        ///////////////////////////////////////
+        System.out.println("\n->Оператори");
+
+        int i1 = 1, i2 = 2; // Коротка форма присвоєння
+
+        // Арифметичні операції виконуються очевидним способом
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int повертається як int)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+        // Ділення з остачею
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Оператори порівняння
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Логічні оператори
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Бітові оператори!
+        /*
+        ~      Унарне бітове доповнення
+        <<     Знаковий зсув уліво
+        >>     Знаковий/Арифметичний зсув управо
+        >>>    Беззнаковий/Логічний зсув управо
+        &      Бітове І
+        ^      Бітови виключне АБО
+        |      Бітове АБО
+        */
+
+        // Інкремент
+        int i = 0;
+        System.out.println("\n->Інкремент/Декремент");
+        // Оператори ++ і -- здійснюють інкремент та декремент ретроспективно.
+        // Якщо вони розташовані перед змінною, операція виконається перед поверненням;
+        // якщо після неї — повернеться інкремент або декремент.
+        System.out.println(i++); // i = 1, друкує 0 (постінкремент)
+        System.out.println(++i); // i = 2, друкує 2 (преінкремент)
+        System.out.println(i--); // i = 1, друкує 2 (постдекремент)
+        System.out.println(--i); // i = 0, друкує 0 (предекремент)
+
+        ///////////////////////////////////////
+        // Керуючі конструкції
+        ///////////////////////////////////////
+        System.out.println("\n->Керуючі конструкції");
+
+        // Оператор if використовується так само, як у мові C
+        int j = 10;
+        if (j == 10) {
+            System.out.println("Це надрукується");
+        } else if (j > 10) {
+            System.out.println("А це — ні");
+        } else {
+            System.out.println("Це — також ні");
+        }
+
+        // Цикл з передумовою While
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Інкремент лічильника
+            // Виконається 100 разів, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("fooWhile Value: " + fooWhile);
+
+        // Цикл з післяумовою Do While
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Інкремент лічильника
+            // Виконається 99 разів, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("Значення fooDoWhile: " + fooDoWhile);
+
+        // Цикл з параметром For
+        // структура циклу => for(<початковий стан>; <умова завершення>; <крок>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Виконається 10 разів, fooFor 0->9
+        }
+        System.out.println("Значення fooFor: " + fooFor);
+        
+        // Вихід із вкладеного циклу через мітку
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // вихід із зовнішнього циклу, а не лише внутрішнього
+            }
+          }
+        }
+        
+        // Цикл For Each
+        // Призначений для перебору масивів та колекцій       
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};       
+
+        for (int bar : fooList) {
+            System.out.println(bar);
+            // Повторюється 9 разів та друкує числа від 1 до 9 на нових рядках
+        }
+
+        // Оператор вибору Switch Case
+        // Оператор вибору працює з типами даних byte, short, char, int.
+        // Також працює з переліками Enum, 
+        // класом String та класами-обгортками примітивних типів:
+        // Character, Byte, Short та Integer.
+        int month = 3;
+        String monthString;
+        switch (month) {
+            case 1: monthString = "Січень";
+                    break;
+            case 2: monthString = "Лютий";
+                    break;
+            case 3: monthString = "Березень";
+                    break;
+            default: monthString = "Інший місяць";
+                     break;
+        }
+        System.out.println("Результат Switch Case: " + monthString);
+        
+        // Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так:
+        String myAnswer = "можливо";
+        switch(myAnswer) {
+            case "так":
+                System.out.println("Ви відповіли «Так».");
+                break;
+            case "ні":
+                System.out.println("Ви відповіли «ні».");
+                break;
+            case "можливо":
+                System.out.println("Ви відповіли «Можливо».");
+                break;
+            default:
+                System.out.println("Ви відповіли «" + myAnswer + "»");
+                break;
+        }
+
+        // Тернарний оператор вибору
+        // Можна використовувати оператор «?» (знак питання) для визначення умови.
+        // Читається так: «Якщо (умова) вірна, то <перше значення>, інакше
+        // <друге значення>»
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Надрукується А, бо умова вірна
+
+
+        ////////////////////////////////////////
+        // Перетворення типів
+        ////////////////////////////////////////
+
+        // Перетворення String на Integer
+        Integer.parseInt("123");//поверне числову версію рядка "123"
+
+        // Перетворення Integer на String
+        Integer.toString(123);//повертає рядкову версію 123
+
+        // Для інших перетворень є наступні класи:
+        // Double
+        // Long
+        // String
+
+        // Приведення типів
+        // Тут можна прочитати про приведення об’єктів (англ.):
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Класи та функції
+        ///////////////////////////////////////
+
+        System.out.println("\n->Класи та функції");
+
+        // (Клас Bicycle наведений нижче)
+
+        // Новий об’єкт класу
+        Bicycle trek = new Bicycle();
+
+        // Виклик методу об’єкта
+        trek.speedUp(3); // Постійно використовуються методи з назвами set і get
+        trek.setCadence(100);
+
+        // toString повертає рядкове представлення об’єкту.
+        System.out.println("Інформація про об’єкт trek: " + trek.toString());
+        
+        // У Java немає синтаксису для явного створення статичних колекцій.
+        // Це можна зробити так:
+
+        private static final Set<String> COUNTRIES = new HashSet<String>();
+        static {
+           validCodes.add("DENMARK");
+           validCodes.add("SWEDEN");
+           validCodes.add("FINLAND");
+        }
+
+        // Але є інший спосіб — ініціалізація з подвійними фігурними дужками.
+
+        private static final Set<String> COUNTRIES = new HashSet<String>() {{
+            add("DENMARK");
+            add("SWEDEN");
+            add("FINLAND");
+        }}
+
+        // Використовується анонімний внутрішній клас
+
+    } // Кінець методу main
+} // Кінець класу LearnJava
+
+
+// У .java-файл можна додавати інші, не public класи зовнішнього рівня,
+// але це не є хорошою практикою. Розміщуйте класи в окремих файлах.
+
+
+// Синтаксис оголошення класу:
+// <public/private/protected> class <ім’я класу> {
+//    // поля, конструктори, функції та ін.
+//    // у Java функції називаються методами.
+// }
+
+class Bicycle {
+
+    // Поля (змінні) класу Bicycle
+    public int cadence; // Public: доступно звідусіль
+    private int speed;  // Private: доступно лише у межах класу
+    protected int gear; // Protected: доступно лише класові та його нащадкам
+    String name; // за замовчанням: доступно у даному пакеті
+
+    static String className; // статична змінна класу
+
+    // статичний блок
+    // Java не має статичних конструкторів, але
+    // має статичний блок ініціалізації змінних класу    
+    // Цей блок виконується при завантаженні класу.
+    static {
+        className = "Bicycle";
+    }
+
+    // Конструктори є способом створення класу
+    // Оце — конструктор
+    public Bicycle() {
+        // Можна викликати інший конструктор:
+        // this(1, 50, 5, "Bontrager");
+        gear = 1;
+        cadence = 50;
+        speed = 5;
+        name = "Bontrager";
+    }
+
+    // Цей конструктор приймає аргументи
+    public Bicycle(int startCadence, int startSpeed, int startGear,
+        String name) {
+        this.gear = startGear;
+        this.cadence = startCadence;
+        this.speed = startSpeed;
+        this.name = name;
+    }
+
+    // Синтаксис методу:
+    // <public/private/protected> <тип повернутого значення> <ім’я методу>(<аргументи>)
+
+    // Java-класи часто мають методи для отримання та встановлення змінних
+
+    // Синтаксис оголошення методу:
+    // <модифікатор доступу> <тип повернутого значення> <ім’я методу>(<аргументи>)
+    public int getCadence() {
+        return cadence;
+    }
+
+    // void-методи не повертають значень
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+
+    public void speedUp(int increment) {
+        speed += increment;
+    }
+
+    public void slowDown(int decrement) {
+        speed -= decrement;
+    }
+
+    public void setName(String newName) {
+        name = newName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    //Метод показує значення змінних об’єкту.
+    @Override // Успадковано від класу Object.
+    public String toString() {
+        return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+            " name: " + name;
+    }
+} // кінець класу Bicycle
+
+// PennyFarthing є розширенням (нащадком) класу Bicycle
+class PennyFarthing extends Bicycle {
+    // (Penny Farthings мають велике переднє колесо.
+    // Вони не мають передач.)
+
+    public PennyFarthing(int startCadence, int startSpeed){
+        // Виклик батьківського конструктора через super
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // Перевизначений метод має бути відмічений аннотацією, яка починається зі знака @.
+    // Для ознайомлення з аннотаціями перейдіть за посиланням
+    // http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGear(int gear) {
+        gear = 0;
+    }
+}
+
+// Інтерфейси
+// Синтаксис оголошення інтерфейсів
+// <рівень доступу> interface <ім’я інтерфейсу> extends <батьківський інтерфейс> {
+//     // Константи
+//     // Оголошення методів
+// }
+
+//Приклад — їжа (Food):
+public interface Edible {
+    public void eat(); // Будь-які класи, що реалізують цей інтерфейс,
+                       // повинні реалізувати цей метод.
+}
+
+public interface Digestible {
+    public void digest();
+}
+
+
+// Можна створити клас, що реалізує обидва інтерфейси.
+public class Fruit implements Edible, Digestible {
+  
+    @Override
+    public void eat() {
+        // ...
+    }
+
+    @Override
+    public void digest() {
+        // ...
+    }
+}
+
+// В Java можна успадковувати лише один клас, але реалізовувати багато
+// інтерфейсів. Наприклад:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+    InterfaceTwo {
+
+    @Override
+    public void InterfaceOneMethod() {
+    }
+
+    @Override
+    public void InterfaceTwoMethod() {
+    }
+
+}
+
+// Абстрактні класи
+
+// Синтаксис оголошення абстрактних класів:
+// <рівень доступу> abstract <ім’я класу> extends <батьківський абстрактний клас> {
+//     // Константи і змінні
+//     // Оголошення методів
+// }
+
+// Позначення класу як абстрактного означає, що оголошені у ньому методи мають
+// бути реалізовані у дочірніх класах. Подібно до інтерфейсів, не можна створити екземпляри
+// абстракних класів, але їх можна успадковувати. Нащадок зобов’язаний реалізувати всі абстрактні
+// методи. на відміну від інтерфейсів, абстрактні класи можуть мати як визначені,
+// так і абстрактні методи. Методи в інтерфейсах не мають тіла,
+// за винятком статичних методів, а змінні неявно мають модифікатор final, на відміну від
+// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод «main».
+
+public abstract class Animal
+{
+    public abstract void makeSound();
+
+    // Метод може мати тіло
+    public void eat()
+    {
+        System.out.println("Я тварина, і я їм.");  
+        // Зауваження: є доступ до приватних змінних.
+        age = 30;
+    }
+
+    // Ініціалізація не потрібна
+    protected int age;
+
+    public void printAge()
+    {
+        System.out.println(age);  
+    }
+
+    // Абстрактні класи МОЖУТЬ мати метод «main».
+    public static void main(String[] args)
+    {
+        System.out.println("Я абстрактний");
+    }
+}
+
+class Dog extends Animal
+{
+    // Слід помічати перевизначення абстрактних методів
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Гав!");
+        // age = 30;	==> ПОМИЛКА! age є private для Animal
+    }
+
+    // Зауваження: Буде помилка, якщо використати аннотацію
+    // @Override тут, так як у java не можна
+    // перевизначати статичні методи.
+    // Те, що тут відбувається, називається приховування методів.
+    // Більш детально: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// Фінальні класи
+
+// Синтаксис оголошення фінальних класів
+// <рівень доступу> final <ім’я класу> {
+//     // Константи і змінні
+//     // Оголошення методів
+// }
+
+// Фінальні класи не можуть мати нащадків, також самі вони є останніми нащадками.
+// Фінальні класи є протилежністю абстрактних у цьому плані.
+
+public final class SaberToothedCat extends Animal
+{
+    // Перевизначення методу
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Гррр!");
+    }
+}
+
+// Фінальні методи
+public abstract class Mammal()
+{
+    // Синтаксис фінальних методів:
+    // <модифікатор доступу> final <тип повернутого значення> <ім’я функції>(<аргументи>)
+
+    // Фінальні методи не можуть бути перевизначені класом-нащадком,
+    // вони є остаточною реалізацією методу.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
+}
+
+
+// Тип Enum (перелік)
+//
+// Enum є спеціальним типом даних, який дозволяє змінним бути певною множиною
+// визначених констант. Змінна має відповідати одному зі значень, що
+// заздалегідь визначені для неї. Оскільки це константи, імена типів полів у enum
+// задаються у верхньому регістрі. Тип «перелік» у Java задається за допомогою
+// ключового слова enum. Наприклад, перелік днів тижня можна задати так:
+
+public enum Day {
+    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+    THURSDAY, FRIDAY, SATURDAY 
+}
+
+// Перелік Day можна використовувати так:
+
+public class EnumTest {
+    
+    // Змінна того же типу, що й перелік
+    Day day;
+    
+    public EnumTest(Day day) {
+        this.day = day;
+    }
+    
+    public void tellItLikeItIs() {
+        switch (day) {
+            case MONDAY:
+                System.out.println("Понеділкі важкі.");
+                break;
+                    
+            case FRIDAY:
+                System.out.println("П’ятниці краще.");
+                break;
+                         
+            case SATURDAY: 
+            case SUNDAY:
+                System.out.println("Вихідні найліпші.");
+                break;
+                        
+            default:
+                System.out.println("Середина тижня так собі.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        EnumTest firstDay = new EnumTest(Day.MONDAY);
+        firstDay.tellItLikeItIs(); // => Понеділки важкі.
+        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
+        thirdDay.tellItLikeItIs(); // => Середина тижня так собі.
+    }
+}
+
+// Переліки набагато потужніші, ніж тут показано. 
+// Тіло переліків може містити методи та інші змінні.
+// Дивіться більше тут: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## Додатково для читання
+
+Посилання, наведені нижче, дозволяють тільки зрозуміти тему. Щоб знайти конкретні приклади, використовуйте Ґуґл.
+
+**Офіційні посібники Oracle**:
+
+* [Посібник Java від Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java — модифікатори доступу](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [ООП-концепції](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Наслідування](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Поліморфізм](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Абстракція](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Виключення](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Інтерфейси](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [параметризація](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Стиль коду у Java](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+**Online-практика та посібники**
+
+* [Learneroo.com — Вивчаємо Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Книжки**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 9614f9ca..ac6a2bde 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -3,6 +3,7 @@ language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
+    - ["clearsense", "https://github.com/clearsense"]
 filename: javascript-uk.js
 translators:
   - ["Ivan", "https://github.com/IvanEh"]
@@ -10,7 +11,7 @@ translators:
 lang: uk-ua
 ---
 
-JavaScript було створено в 1995 році Бренданом Айком, який працював у копаніх Netscape.
+JavaScript було створено в 1995 році Бренданом Айком, який працював у компанії Netscape.
 Він був задуманий як проста мова сценаріїв для веб-сайтів, який би доповнював Java
 для більш складних веб-застосунків. Але тісна інтеграція з веб-сторінками і
 вбудована підтримка браузерами призвела до того, що JavaScript став популярніший
@@ -350,6 +351,7 @@ myFunc(); // = undefined
 // Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до 
 // цього об’єкта через this
 var myOtherFunc = function() {
+    return this.myString.toUpperCase();
 }
 myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = "HELLO, WORLD!"
@@ -407,7 +409,7 @@ myObj.__proto__ = myPrototype;
 myObj.meaningOfLife; // = 42
 
 // Аналогічно для функцій
-myObj.myFunc(); // = "Hello, world!"
+myObj.myFunc(); // = "hello, world!"
 
 // Якщо інтерпретатор не знайде властивості в прототипі, то він продовжить пошук
 // в прототипі прототипа і так далі
@@ -432,7 +434,7 @@ myObj.meaningOfLife; // = 43
 
 // Другий спосіб: у конструкторів є властивість з іменем prototype. Це *не*
 // прототип функції-конструктора, це прототип для нових об’єктів, які будуть створені
-// цим конструктором і ключового слова new.
+// цим конструктором і ключовим словом new.
 MyConstructor.prototype = {
     myNumber: 5,
     getMyNumber: function() {
@@ -454,9 +456,6 @@ myNumber == myNumberObj; // = true
 typeof myNumber; // = 'number'
 typeof myNumberObj; // = 'object'
 myNumber === myNumberObj; // = false
-if (0) {
-    // Цей код не виконається, тому що 0 - це хиба.
-}
 
 // Об’єкти-обгортки і вбудовані типи мають спільні прототипи, тому
 // ви можете розширити функціонал рядків:
@@ -484,12 +483,12 @@ if (Object.create === undefined) { // не перезаписуємо метод
 
 ## Що почитати
 
-[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
-[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
-[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
-[4]: http://www.learneroo.com/modules/64/nodes/350
-[5]: http://bonsaiden.github.io/JavaScript-Garden/
-[6]: http://www.amazon.com/gp/product/0596805527/
-[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
-[8]: http://eloquentjavascript.net/
-[9]: http://jstherightway.org/
+* [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+* [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+* [3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
+* [4]: http://www.learneroo.com/modules/64/nodes/350
+* [5]: http://bonsaiden.github.io/JavaScript-Garden/
+* [6]: http://www.amazon.com/gp/product/0596805527/
+* [7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+* [8]: http://eloquentjavascript.net/
+* [9]: http://jstherightway.org/
diff --git a/uk-ua/json-ua.html.markdown b/uk-ua/json-ua.html.markdown
index 8ee12a93..c9a3d3fb 100644
--- a/uk-ua/json-ua.html.markdown
+++ b/uk-ua/json-ua.html.markdown
@@ -1,28 +1,34 @@
 ---
 language: json
-filename: learnjson-ru.json
+filename: learnjson-ua.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
   - ["Ehreshi Ivan", "https://github.com/IvanEh"]
+  - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
 lang: uk-ua
 ---
 
-JSON - це надзвичайно простий формат обміну даними. Це мабуть буде найлегшим курсом 
-"Learn X in Y Minutes".
+JSON - це надзвичайно простий формат обміну даними. Згідно з [json.org](http://json.org), для людей він легкий в написанні і читанні, а для комп’ютерів в розборі та генерації.
 
-В загальному випадку в JSON немає коментарів, але більшість парсерів дозволяють 
-використовувати коментарі в С-стилі(//, /\* \*/). Можна залишити кому після останнього
-поля, але все-таки краще такого уникати для кращої сумісності
+JSON підтримує наступні структури даних:
+
+* Колекція пар ключ/значення (`{ "ключ": "значення" }`). У різних мовах програмування реалізується як об’єкт, запис, структура, словник, хеш-таблиця, іменований список або асоціативний масив.
+* Впорядкований список значень (`[ "елемент0", "елемент1" ]`). У різних мовах програмування реалізується як масив, вектор, список або послідовність.
+* Рядки: `"привіт"`, `"\"Лапки\""`, `"\u0abe"`, `"Новий рядок.\n"`
+* Числа: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Інші: `true`, `false`, `null`
+
+JSON в чистій формі не містить коментарів, але більшість парсерів підтримують коментарі в C-стилі (`//`, `/* */`). Деякі парсери також не звертають уваги на кому після останнього поля, але їх варто уникати для кращої сумісності.
 
 ```json
 {
-  "ключ": "значеннь",
+  "ключ": "значення",
   
   "ключі": "завжди мають бути обгорнуті в подвійні лапки",
   "числа": 0,
-  "рядки": "Пρивет, світ. Допускаються всі unicode-символи разом з \"екрануванням\".",
+  "рядки": "Пρивіт, світe. Допускаються всі unicode-символи разом із \"екрануванням\".",
   "логічний тип": true,
   "нічого": null,
 
@@ -34,13 +40,13 @@ JSON - це надзвичайно простий формат обміну да
     "масив": [0, 1, 2, 3, "масиви можуть містити будь-які типи", 5],
 
     "інший об’єкт": {
-      "коментра": "Об’єкти можуть містити інші об’єкти. Це дуже корисно."
+      "коментар": "Об’єкти можуть містити інші об’єкти. Це дуже корисно."
     }
   },
 
   "безглуздя": [
     {
-      "джерело калія": ["банани"]
+      "джерело калію": ["банани"]
     },
     [
       [1, 0, 0, 0],
@@ -50,13 +56,13 @@ JSON - це надзвичайно простий формат обміну да
     ]
   ],
   
-  "альтернативнтй стиль": {
+  "альтернативний стиль": {
     "коментар": "Гляньте!"
-  , "позиція коми": "неважлива, поки вона знаходиться до наступного поля"
+  , "позиція коми": "неважлива, коректно якщо вона знаходиться перед наступним полем"
   , "інший коментар": "класно"
   },
 
-  "Це було не довго": "І ви справилист. Тепер ви знаєте все про JSON."
+  "Це було не довго": "І ви впорались! Тепер ви знаєте все про JSON."
 }
 
 Одиничний масив значень теж є правильним JSON
diff --git a/uk-ua/ruby-ua.html.markdown b/uk-ua/ruby-ua.html.markdown
new file mode 100644
index 00000000..74346dfe
--- /dev/null
+++ b/uk-ua/ruby-ua.html.markdown
@@ -0,0 +1,625 @@
+---
+language: ruby
+filename: learnruby-ua.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+translators:
+  - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
+lang: uk-ua
+---
+
+Rubi — це інтерпретована, повністю об'єктно-орієнтована мова програмування з чіткою динамічною типізацією.
+
+```ruby
+# Це коментар
+
+=begin
+Це багаторядковий коментар
+Ніхто їх не використовує
+Тобі теж не варто
+=end
+
+# В першу чергу: все являється об’єктом.
+
+# Числа це об’єкти
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Базова арифметика
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+
+# Побітові оператори
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# Арифметика це просто синтаксичний цукор
+# для виклику методу об’єкта
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Спеціальні значення теж об’єкти
+nil # еквівалентно null в інших мовах
+true # істина
+false # хиба
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Рівність
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Нерівність
+1 != 1 #=> false
+2 != 1 #=> true
+
+# Окрім власне false, nil це ще одне "хибне" значення
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Інші порівняння
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Комбінований оператор порівняння
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Логічні оператори
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Є альтернативні версії логічних операторів з набагато меншим
+# прецедентом. Вони використовуються в конструкціях з контролем
+# виконання ланцюга виразів які повертають булевий результат.
+
+# `do_something_else` викликається лише якщо `do_something` повертає true.
+do_something() and do_something_else()
+# `log_error` викликається лише якщо `do_something` повертає false.
+do_something() or log_error()
+
+
+# Strings це об’єкти
+
+'Я — рядок'.class #=> String
+"Я теж рядок".class #=> String
+
+placeholder = 'використовувати інтерполяцію рядків'
+"Я можу #{placeholder} коли користуюсь рядками в подвійних лапках"
+#=> "Я можу використовувати інтерполяцію рядків коли користуюсь рядками в подвійних лапках"
+
+# Варто надавати перевагу рядкам в одинарних лапках де це можливо
+# Рядки в подвійних лапках викликають додаткові внутрішні обчислення
+
+# Об’єднуйте рядки, але не з числами
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+
+# Об’єднуйте рядки з операторами
+'hello ' * 3 #=> "hello hello hello "
+
+# Додавання до рядка
+'hello' << ' world' #=> "hello world"
+
+# Вивести рядок з переходом на новий рядок вкінці
+puts "Я надрукований!"
+#=> Я надрукований!
+#=> nil
+
+# Вивести рядок без переходу на новий
+print "Я надрукований!"
+#=> Я надрукований! => nil
+
+# Змінні
+x = 25 #=> 25
+x #=> 25
+
+# Зверніть увагу, оператор присвоєння повертає присвоєне значення
+# Отже можна робити одночасне присвоєння кількох змінних:
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Для назв змінних використовується зміїний_регістр
+snake_case = true
+
+# Використовуйте назви змінних які їх характеризують 
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+
+# Символи (теж об’єкти)
+# Символи є незмінними константами багаторазового використання, внутрішньо
+# представлені цілочисельним значенням. Вони часто використовуються замість
+# рядків щоб ефективно передати конкретні, значущі значення.
+
+:pending.class #=> Symbol
+
+status = :pending
+
+status == :pending #=> true
+
+status == 'pending' #=> false
+
+status == :approved #=> false
+
+# Масиви
+
+# Ось масив
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Масиви можуть містити елементи різних типів
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Масиви можуть бути проіндексовані
+# З початку
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+# Як і арифметика, доступ до елемента масиву у вигляді [індекс] — це лише
+# синтаксичний цукор виклику методу [] об’єкта
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# З кінця
+array[-1] #=> 5
+array.last #=> 5
+
+# З початковим індексом та довжиною
+array[2, 3] #=> [3, 4, 5]
+
+# Реверс масиву
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Елементи масиву за діапазоном індексів
+array[1..3] #=> [2, 3, 4]
+
+# Додавати елементи в масив можна так:
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# Або так:
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Перевірити чи масив містить елемент
+array.include?(1) #=> true
+
+# Хеш — це масив пар ключ/значення.
+# Хеш оголошується з використанням фігурних дужок:
+hash = { 'color' => 'green', 'number' => 5 }
+
+hash.keys #=> ['color', 'number']
+
+# Значення в хеші може бути швидко знайдене за ключем:
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+
+# Запит значення за неіснуючим ключем повертає nil:
+hash['nothing here'] #=> nil
+
+# Починаючи з Ruby 1.9 з’явився спеціальний синтаксис при використанні
+# символів в якості ключів:
+new_hash = { defcon: 3, action: true }
+
+new_hash.keys #=> [:defcon, :action]
+
+# Перевірка наявності ключів та значень в хеші
+new_hash.key?(:defcon) #=> true
+new_hash.value?(3) #=> true
+
+# Хеші та масиви — перелічувальні типи даних
+# Вони мають багато корисних методів, такі як each, map, count, та інші.
+
+# Оператор вибору "if"
+if true
+  'якщо'
+elsif false
+  'інакше якщо, опціонально'
+else
+  'інакше, також опціонально'
+end
+
+# Оператор циклу "for"
+for counter in 1..5
+  puts "ітерація #{counter}"
+end
+#=> ітерація 1
+#=> ітерація 2
+#=> ітерація 3
+#=> ітерація 4
+#=> ітерація 5
+
+# Проте, ніхто не використовує "for" в циклах.
+# Замість цього варто використовувати метод "each" і передати йому блок.
+# Блок — це відокремлений код який можна передати в метод, наприклад в "each".
+# Це аналог лямбда-виразів, анонімних функцій або замикань в інших мовах програмування.
+
+# Метод "each" для діапазону запускає блок один раз для кожного елементу діапазону.
+# Лічильник передається блоку в якості аргументу.
+
+# Виклик методу "each" з блоком виглядає наступним чином:
+(1..5).each do |counter|
+  puts "ітерація #{counter}"
+end
+#=> ітерація 1
+#=> ітерація 2
+#=> ітерація 3
+#=> ітерація 4
+#=> ітерація 5
+
+# Також можна загорнути блок в фігурні дужки:
+(1..5).each { |counter| puts "ітерація #{counter}" }
+
+# Вміст структур даних також може бути ітерований використовуючи метод "each":
+array.each do |element|
+  puts "#{element} є елементом масиву"
+end
+hash.each do |key, value|
+  puts "#{key} є #{value}"
+end
+
+# Якщо є необхідність індексувати ітерацію, можна використати метод "each_with_index":
+array.each_with_index do |element, index|
+  puts "#{element} під номером #{index} в масиві"
+end
+
+# Оператор циклу "while"
+counter = 1
+while counter <= 5 do
+  puts "ітерація #{counter}"
+  counter += 1
+end
+#=> ітерація 1
+#=> ітерація 2
+#=> ітерація 3
+#=> ітерація 4
+#=> ітерація 5
+
+# Є й інші корисні функції для циклів, такі як "map", "reduce",
+# "inject" та інші. Наприклад "map" в циклі проходить по масиву,
+# виконує над елементами операцію(-ї) в блоці і повертає абсолютно
+# новий масив.
+array = [1,2,3,4,5]
+doubled = array.map do |element|
+  element * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+# Оператор множинного вибору
+grade = 'B'
+
+case grade
+when 'A'
+  puts 'Відмінно!'
+when 'B'
+  puts 'Пощастить наступного разу'
+when 'C'
+  puts 'Ти можеш краще'
+when 'D'
+  puts 'Майже четвірка'
+when 'E'
+  puts 'Випросив'
+when 'F'
+  puts 'Не здав!'
+else
+  puts 'Інша система оцінювання, так?'
+end
+#=> "Пощастить наступного разу"
+
+# Оператор "case" також може використовувати діапазон:
+grade = 82
+case grade
+when 90..100
+  puts 'Ура!'
+when 80...90
+  puts 'Хороша робота'
+when 60...80
+  puts 'Ну, хоч щось'
+else
+  puts 'Не здав!'
+end
+#=> "Хороша робота"
+
+# Обробка вийнятків:
+begin
+  # код з можливим вийнятком
+  raise NoMemoryError, 'Ви використали всю пам’ять.'
+rescue NoMemoryError => exception_variable
+  puts 'Помилка NoMemoryError', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'Помилка RuntimeError'
+else
+  puts 'Цей код запуститься якщо вийнятків не було взагалі'
+ensure
+  puts 'Цей код запуститься в будь-якому випадку'
+end
+
+# Функції
+
+def double(x)
+  x * 2
+end
+
+# Функції (і всі блоки) неявно повертають значення останнього виразу
+double(2) #=> 4
+
+# Дужки не є обов’язковими якщо результат недвозначний
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Аргументи методів розділяються комою
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Всі методи мають неявний, опціональний параметр, який
+# можна викликат за допомогою ключового слова 'yield'
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts 'привіт світ' }
+
+# {
+# привіт світ
+# }
+
+
+# Ви можете передати блок у функцію
+# "&" позначає посилання на блок
+def guests(&block)
+  block.call 'some_argument'
+end
+
+# Ви можете передати список аргументів, вони будуть перетворені в масив
+# Для цього існує оператор ("*")
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Якщо метод повертає масив, ви можете використати деструктуризацію
+def foods
+    ['млинці', 'бутерброд', 'лазанья']
+end
+breakfast, lunch, dinner = foods
+breakfast #=> 'млинці'
+dinner #=> 'лазанья'
+
+# Зазвичай методи які повертають булевий результат закінчуються знаком питання
+5.even? # false
+5.odd? # true
+
+# І якщо метод закінчується знаком оклику, то він робить щось деструктивне 
+# типу зміни отриманого аргументу. Багато методів мають версію з "!" які
+# змінюють аргумент, та без "!" що повертають новий об’єкт
+company_name = "Дандер Міфлін"
+company_name.upcase #=> "ДАНДЕР МІФЛІН"
+company_name #=> "Дандер Міфлін"
+company_name.upcase! # змінна company_name зміниться цього разу!
+company_name #=> "ДАНДЕР МІФЛІН"
+
+
+# Клас оголошується ключовим словом class
+class Human
+
+  # Змінна класу. Вона поширюється на всі екземпляри цього класу.
+  @@species = 'Homo sapiens'
+
+  # Основний ініціалізатор
+  def initialize(name, age = 0)
+    # Призначення аргументу "name" до однойменної змінної екземпляру
+    @name = name
+    # Якщо аргумент "age" не заданий, то йому буде присвоєно дефолтне значення
+    # зі списку аргументів
+    @age = age
+  end
+
+  # Метод-сетер
+  def name=(name)
+    @name = name
+  end
+
+  # Метод-ґетер
+  def name
+    @name
+  end
+
+  # Функціональність вище може бути інкапсульована використовуючи метод attr_accessor:
+  attr_accessor :name
+
+  # Ґетери і сетери можуть бути створені індивідуально, наприклад:
+  attr_reader :name
+  attr_writer :name
+
+  # Метод класу позначається ключовим словом "self", щоб відрізнити від
+  # методів екземпляра класу.
+  # Він може бути викликаний лише в класі, але не в екземплярі.
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# Ініціалізуємо клас
+jim = Human.new('Джим Галперт')
+
+dwight = Human.new('Дуайт Шрут')
+
+# Викличемо кілька методів
+jim.species #=> "Homo sapiens"
+jim.name #=> "Джим Галперт"
+jim.name = "Джим Галперт II" #=> "Джим Галперт II"
+jim.name #=> "Джим Галперт II"
+dwight.species #=> "Homo sapiens"
+dwight.name #=> "Дуайт Шрут"
+
+# Викликати метод класу
+Human.say('Привіт') #=> "Привіт"
+
+# Область видимості змінних визначається способом оголошення імені змінної.
+# Змінні, що починаються на "$" мають глобальну область видимості.
+$var = "Я глобальна змінна"
+defined? $var #=> "global-variable"
+
+# Зміннні, що опчинають на "@" мають область видимості екзкмпляра
+@var = "Я змінна екземпляра"
+defined? @var #=> "instance-variable"
+
+# Змінні, що починаються на "@@" мають область видимості класу
+@@var = "Я змінна класу"
+defined? @@var #=> "class variable"
+
+# Змінні, що починаються з великої букви, є константами
+Var = "Я константа"
+defined? Var #=> "constant"
+
+# Клас теж об’єкт. Тому клас може мати змінні екземпляра.
+# Змінна класу поширюється між класом і всіма його нащадками.
+
+# Базовий клас
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Похідний клас (нащадок)
+class Worker < Human
+end
+
+Human.foo # 0
+Worker.foo # 0
+
+Human.foo = 2 # 2
+Worker.foo # 2
+
+# Змінна екземпляра класу не поширюється між класами-нащадками.
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+Human.bar # 0
+Doctor.bar # nil
+
+module ModuleExample
+  def foo
+    'foo'
+  end
+end
+
+# Включення модулів додає їхні методи до екземплярів класу
+# Розширення модулів додає їхні методи в сам клас
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => NoMethodError: undefined method `foo'
+
+# Колбек виконується при включенні і розширенні модуля
+
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     # => 'bar'
+Something.qux     # => NoMethodError: undefined method `qux'
+Something.new.bar # => NoMethodError: undefined method `bar'
+Something.new.qux # => 'qux'
+```
+
+## Додаткові ресурси
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Learn Ruby through a series of interactive tutorials.
+- [Official Documentation](http://ruby-doc.org/core)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
+- [Try Ruby](http://tryruby.org) - Learn the basic of Ruby programming language, interactive in the browser.
diff --git a/vi-vn/html-vi.html.markdown b/vi-vn/html-vi.html.markdown
new file mode 100644
index 00000000..4897649f
--- /dev/null
+++ b/vi-vn/html-vi.html.markdown
@@ -0,0 +1,123 @@
+---
+language: html
+filename: learnhtml.html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Xuan (Sean) Luong", "https://github.com/xuanluong"]
+lang: vi-vn
+---
+
+HTML là viết tắt của HyperText Markup Language (Ngôn ngữ đánh dấu siêu văn bản).
+Nó là một ngôn ngữ cho phép chúng ta viết nên những trang web.
+Nó là một ngôn ngữ đánh dấu, cho phép chúng ta viết trang web bằng code để chỉ định cách thức mà văn bản và dữ liệu nên được trình bày.
+Tập tin html thực chất chỉ là một tập tin văn bản đơn giản.
+Đánh dấu có nghĩa là gì? Nó là một phương pháp tổ chức dữ liệu của một trang web bằng cách bao quanh dữ liệu bởi các thẻ (tags) mở và đóng.
+Việc đánh dấu phục vụ mục đích cung cấp tầm quan trọng của phần văn bản mà nó bao quanh.
+Cũng như các ngôn ngữ máy tính khác, HTML có nhiều phiên bản. Ở đây chúng ta nói về HTML5.
+
+**Lưu ý :**  Bạn có thể thử nghiệm những thẻ và phần tử HTML khác nhau trong quá trình đọc bài viết bằng cách truy cập những trang web như [codepen](http://codepen.io/pen/) để có thể thấy được tác dụng của những thẻ hay phần tử HTML đó,
+nhằm hiểu cách chúng hoạt động và làm quen với ngôn ngữ HTML.
+Bài viết này chủ yếu bàn về cú pháp của HTML và một vài mẹo hữu dụng.
+
+
+```html
+<!-- Bình luận được bao quanh bởi các ký tự giống như trong ví dụ này -->
+
+<!-- #################### Các thẻ #################### -->
+   
+<!-- Dưới đây là tập tin HTML ví dụ mà chúng ta sẽ phân tích. -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Trang web của tôi</title>
+		</head>
+		<body>
+			<h1>Xin chào!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">Truy cập để biết cái gì sẽ được hiển thị</a>
+			<p>Đây là một văn bản.</p>
+			<p>Một văn bản khác.</p>
+			<ul>
+				<li>Đây là một danh sách không liệt kê</li>
+				<li>Đây là một danh sách không liệt kê khác</li>
+				<li>Danh sách không liệt kê cuối cùng của danh sách cha</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- Một tập tin HTML luôn bắt đầu bằng việc thể hiện cho trình duyệt rằng nó là một trang HTML -->
+<!doctype html>
+
+<!-- Sau đó nó bắt đầu với một thẻ <html> mở -->
+<html>
+
+<!-- thẻ đó sẽ được đóng vào cuối tập tin bằng một thẻ đóng </html>. -->
+</html>
+
+<!-- Không nên viết gì sau thể đóng cuối cùng này. -->
+
+<!-- Ở bên trong (giữa thẻ đóng và mở <html></html>), ta tìm thấy: -->
+
+<!-- Phần đầu được định nghĩa bằng <head> (và phải được đóng lại bằng </head>). -->
+<!-- Phần đầu chứa một vài định nghĩa và những thông tin khác không được dùng để hiển thị; đây gọi là siêu dữ liệu (metadata) -->
+
+<head>
+	<title>Trang web của tôi</title><!-- Thẻ <title> cho trình duyệt biết dòng chữ để hiển thị trên thanh tựa đề của trình duyệt vả tên tab. -->
+</head>
+
+<!-- Sau phần <head> ta sẽ gặp thẻ <body> -->
+<!-- Cho tới đây, chưa có gì được hiển thị trên cửa sổ trình duyệt.  -->
+<!-- Chúng ta phải đưa nội dùng vào phần <body> để hiển thị. -->
+
+<body>
+	<h1>Xin chào!</h1> <!-- Thẻ h1 tạo ra một đề mục. -->
+	<!-- Ngoài <h1> ra ta còn có những đề mục cấp thấp hơn, từ h2 đến h6 -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">Truy cập để biết cái gì sẽ được hiển thị</a> <!-- một liên kết đền một url được cung cấp bởi thuộc tính href="" -->
+	<p>Đây là một văn bản.</p> <!-- Thẻ <p> cho phép đưa văn bản vào trang html. -->
+	<p>Một văn bản khác.</p>
+	<ul> <!-- Thẻ <ul> tạo ra danh sách không đánh s. -->
+	<!-- Để có một danh sách có đánh số ta dùng thể <ol> thay vì <ul> từ đó sẽ có số thứ tự  1. cho phần tử đầu tiên, 2. cho phần tử thứ hai, v.v... -->
+		<li>Đây là một danh sách không liệt kê</li>
+		<li>Đây là một danh sách không liệt kê khác</li>
+		<li>Danh sách không liệt kê cuối cùng của danh sách cha</li>
+	</ul>
+</body>
+
+<!-- Và ta đã có một tập tim HTML. Việc tạo ra tập tin HTML có thể được thực hiện một cách đơn giản. -->
+
+<!-- Những ta cũng có thể thêm vào những loại thẻ HTML khác. -->
+
+<!-- Chèn vào một ảnh. -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- Nguồn của ảnh sẽ được khai báo qua thuộc tính src="" -->
+<!-- Nguồn ảnh có thể là một URL hoặc đường dẫn tới một tập tin trong máy. -->
+
+<!-- Ta cũng có thể tạo ra một table. -->
+
+<table> <!-- Tạo bảng với thẻ <table>. -->
+	<tr> <!-- <tr> dùng để tạo ra một hàng. -->
+		<th>Cột một</th> <!-- <th> dùng để khai báo tên cột. -->
+		<th>Cột hai</th>
+	</tr>
+	<tr>
+		<td>hàng một, cột một</td> <!-- <td> dùng để tạo ra một ô trong table. -->
+		<td>hàng một, cột hai</td>
+	</tr>
+	<tr>
+		<td>hàng hai, cột một</td>
+		<td>hàng hai, cột hai</td>
+	</tr>
+</table>
+
+```
+
+## Cách sử dụng
+
+HTML được viết trong tập tin có phần mở rộng `.html`.
+
+## Thông tin mở rộng
+
+* [wikipedia](https://vi.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/vi-vn/objective-c-vi.html.markdown b/vi-vn/objective-c-vi.html.markdown
index 38e418e9..8bc334ab 100644
--- a/vi-vn/objective-c-vi.html.markdown
+++ b/vi-vn/objective-c-vi.html.markdown
@@ -1,12 +1,10 @@
 ---

-

 language: Objective-C

 contributors:

     - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]

     - ["Yannick Loriot", "https://github.com/YannickL"]

 lang: vi-vn

 filename: LearnObjectiveC-vi.m

-

 ---

 

 Objective-C là ngôn ngữ lập trình chính được sử dụng bởi Apple cho các hệ điều hành OS X, iOS và các framework tương ứng của họ, Cocoa và Cocoa Touch.

diff --git a/vi-vn/python3-vi.html.markdown b/vi-vn/python3-vi.html.markdown
new file mode 100644
index 00000000..16238b35
--- /dev/null
+++ b/vi-vn/python3-vi.html.markdown
@@ -0,0 +1,913 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["evuez", "http://github.com/evuez"]
+translators:
+    - ["Xuan (Sean) Luong, https://github.com/xuanluong"]
+filename: learnpython3.py
+lang: vi-vn
+---
+
+Python được tạo ra bởi Guido van Rossum vào đầu những năm 90s. Ngày nay nó là một trong những ngôn ngữ phổ biến
+nhất còn tồn tại. Tôi thích Python vì sự rõ ràng, trong sáng về mặt cú pháp. Về cơ bản, Python có thể coi
+như một loại mã giả (pseudocode) có thể thực thi được.
+
+Mọi phản hồi đều sẽ được tích cực ghi nhận! Bạn có thể liên lạc với tôi qua Twitter [@louiedinh](http://twitter.com/louiedinh) hoặc louiedinh [at] [google's email service]
+
+Lưu ý: Bài viết này áp dụng riêng cho Python 3. Truy cập [vào đây](http://learnxinyminutes.com/docs/python/) nếu bạn muốn học phiên bản cũ Python 2.7
+
+```python
+
+# Dòng bình luận (comment) bắt đầu bằng dấu thăng (#)
+
+""" Những chuỗi ký tự (string) nằm trên nhiều dòng
+    có thể được viết bằng cách dùng 3 dấu nháy " và thường
+    được dùng trong quá trình viết tài liệu (documentation).
+"""
+
+####################################################
+## 1. Các kiểu dữ liệu cơ bản và Các phép toán
+####################################################
+
+# Bạn có những con số
+3  # => 3
+
+# Tính toán với những con số là những điều có thể bạn sẽ làm
+1 + 1   # => 2
+8 - 1   # => 7
+10 * 2  # => 20
+35 / 5  # => 7.0
+
+# Kết quả của phép chia số nguyên sẽ được làm tròn xuống cho cả số dương và số âm
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # phép chia số nguyên cũng áp dụng được cho kiểu dữ liệu float biểu diễn số thực
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
+
+# Kết quả của phép chia luôn là số thực
+10.0 / 3  # => 3.3333333333333335
+
+# Phép toán lấy phần dư (modulo)
+7 % 3  # => 1
+
+# Phép lũy thừa (x**y, x lũy thừa y)
+2**3  # => 8
+
+# Áp đặt thứ tự tính toán bằng dấu ngoặc
+(1 + 3) * 2  # => 8
+
+# Kiểu Boolean cũng là một kiểu dữ liệu cơ bản (Lưu ý: ký tự đầu tiên viết hoa)
+True
+False
+
+# Phủ định bằng từ khóa 'not'
+not True   # => False
+not False  # => True
+
+# Các phép toán với kiểu Boolean
+# Lưu ý từ khóa "and" và "or" là case-sensitive
+True and False  # => False
+False or True   # => True
+
+# Lưu ý khi sử dụng các phép toán của kiểu Boolean với số nguyên 'int'
+# False là 0 và True là 1
+# Đừng nhầm lẫn các phép toán Boolean cho số nguyên và các phép toán and/or trên bit (& và |)
+0 and 2     # => 0
+-5 or 0     # => -5
+0 == False  # => True
+2 == True   # => False
+1 == True   # => True
+-5 != False != True #=> True
+
+# So sánh bằng với ==
+1 == 1  # => True
+2 == 1  # => False
+
+# So sánh không bằng với !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Các phép so sánh khác
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Các phép so sánh có thể xâu chuỗi với nhau!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# (is vs. ==) từ khóa is kiểm tra xem 2 biến có cùng tham chiếu một đối tượng, còn == kiếm tra
+# xem hai đối tượng có cùng giá trị hay không.
+a = [1, 2, 3, 4]  # a trỏ tới một danh sách (list) mới, [1, 2, 3, 4]
+b = a             # b trỏ tới nơi mà a cũng đang trỏ tới
+b is a            # => True, a và b cùng trỏ tới một đối tượng
+b == a            # => True, đối tượng mà a và b trỏ tới có cùng giá trị
+b = [1, 2, 3, 4]  # b trỏ tới một danh sách mới, [1, 2, 3, 4]
+b is a            # => False, a và b không cùng trỏ tới một đối tượng
+b == a            # => True, đối tượng mà a và b trỏ tới không có cùng giá trị
+
+# Chuỗi ký tự được tạo ra bằng dấu nháy kép " hoặc nháy đơn '
+"Đây là một chuỗi ký tự."
+'Đây cũng là một chuỗi ký tự.'
+
+# Chuỗi ký tự có thể được cộng với nhau can be added too! Tuy nhiên nên tránh làm như vậy
+"Xin " + "chào!"  # => "Xin chào!"
+# Các chuỗi ký tự không phải là biến (literals) có thể được nối với nhau mà không cần dùng phép cộng '+'
+"Xin " "chào!"    # => "Xin chào!"
+
+# Một chuỗi ký tự có thể xem như một danh sách (list) các ký tự
+"Đây là một chuỗi ký tự"[0]  # => 'Đ'
+
+# Bạn có thể tìm chiều dài một chuỗi
+len("Đây là một chuỗi")  # => 16
+
+# .format có thể được dùng để định dạng chuỗi, ví dụ như:
+"{} có thể được {}".format("Chuỗi ký tự", "định dạng")  # => "Chuỗi ký tự có thể được định dạng"
+
+# Bạn có thể lặp lại đối số (arguments) khi định dạnh để không phải gõ nhiều lần
+"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
+# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+
+# Bạn có thể dùng từ khóa nếu bạn không muốn đếm
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")  # => "Bob wants to eat lasagna"
+
+# Nếu code Python 3 của bạn cần phải chạy với Python 2.5 hoặc các bản cũ hơn, bạn cũng có thể
+# dùng cách định dạng cũ:
+"%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
+
+
+# None là một đối tượng
+None  # => None
+
+# Đừng dùng so sánh bằng "==" để so sánh đối tượng với None
+# Thay vào đó dùng is. Nó sẽ kiểm tra xem một đối tượng có đồng nhất với None hay không.
+"etc" is None  # => False
+None is None   # => True
+
+# None, 0, và chuỗi/danh sách (list)/từ điển (dict)/tuple rỗng khi chuyển về kiểu Boolean đều có giá trị là False.
+# Tất cả những giá trị khác đều là True
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
+bool(())  # => False
+
+####################################################
+## 2. Biến và Các kiểu dữ liệu gộp (Collections)
+####################################################
+
+# Hàm print trong Python
+print("Tôi là Python. Rất hân hạnh được làm quen!")  # => Tôi là Python. Rất hân hạnh được làm quen!
+
+# Hàm print mặc định in thêm ký tự xuống dòng
+# Dùng đối số tùy chọn (optional argument) để thay đổi cách kết thúc chuỗi.
+print("Hello, World", end="!")  # => Hello, World!
+
+# Một cách đơn giản để lấy dữ liệu vào từ bàn phím
+input_string_var = input("Nhập dữ liệu: ") # Trả về dữ liệu vào là một chuỗi
+# Lưu ý: Trong những phiên bản cũ của Python input() có tên là raw_input()
+
+# Không cần phải khai báo biến mà chỉ có gán giá trị cho biến.
+# Quy ước là sử dụng chữ_viết_thường_có_dấu_gạch_dưới
+some_var = 5
+some_var  # => 5
+
+# Truy cập một biến chưa được gán trước đó sẽ tạo ra biệt lệ (exception).
+# Đọc mục Luồng điều khiển để hiểu thêm về việc giải quyết các biệt lệ (exception handling)
+some_unknown_var  # Sinh ra một biệt lệ kiểu NameError
+
+# if có thể dùng như một biểu thức
+# Tương đương với phép toán ba ngôi trong C: '?:'
+"yahoo!" if 3 > 2 else 2  # => "yahoo!"
+
+# Kiểu danh sách (list) lưu trữ chuỗi đối tượng tuần tự
+li = []
+# Bạn có thể bắt đầu với một danh sách đã có sãn các phần tử
+other_li = [4, 5, 6]
+
+# Thêm phần tử vào cuối danh sách bằng phương thức append
+li.append(1)    # li bây giờ là [1]
+li.append(2)    # li bây giờ là [1, 2]
+li.append(4)    # li bây giờ là [1, 2, 4]
+li.append(3)    # li bây giờ là [1, 2, 4, 3]
+# Xóa phần tử cuối cùng bằng phương thức pop
+li.pop()        # => 3 and li is now [1, 2, 4]
+# Sau đó ta có thể đưa đối tượng trở lại danh sách
+li.append(3)    # li trở lại là [1, 2, 4, 3].
+
+# Truy cập một danh sách như bạn làm với một mảng (array)
+li[0]   # => 1
+# Truy cập phần tử cuối cùng
+li[-1]  # => 3
+
+# Truy cập ngoài giới hạn sẽ tạo ra biệt lệ IndexError
+li[4]  # Sinh ra một biệt lệ kiểu IndexError
+
+# Bạn có thể truy cập một đoạn bằng phép cắt (slice).
+# Chỉ mục bắt đầu được tính làm điểm bắt đầu còn chỉ mục kết thúc thì không, mà là chỉ mục của phần tử tiếp theo phần tử kết thúc
+# (Về mặt toán học thì đây là một đoạn đóng/mở, hay nửa đoạn)
+li[1:3]   # => [2, 4]
+# Lấy từ vị trí thứ 3 đến hết
+li[2:]    # => [4, 3]
+# Lấy từ đầu đến vị trí thứ 3
+li[:3]    # => [1, 2, 4]
+# Lấy những phần tử có chỉ mục chẵn
+li[::2]   # =>[1, 4]
+# Trả về bản sao của danh sách bị đảo ngược
+li[::-1]  # => [3, 4, 2, 1]
+# Kết hợp 3 tham số để làm những phép cắt phức tạp hơn
+# li[start:end:step]
+
+# Tạo ra một bản sao sâu (deep copy) bằng phép cắt
+li2 = li[:]  # => li2 = [1, 2, 4, 3] but (li2 is li) will result in false.
+
+# Xóa phần tử nào đó của danh sách bằng "del"
+del li[2]  # li is now [1, 2, 3]
+
+# Xóa đi phần tử đầu tiên mang một giá trị nhất định
+li.remove(2)  # li bây giờ là [1, 3]
+li.remove(2)  # Sinh ra biệt lệ kiểu ValueError vì 2 không tồn tại trong danh sách
+
+# Chèn một phần tử vào một vị trí cụ thể
+li.insert(1, 2)  # li bây giờ lại là [1, 2, 3]
+
+# Tìm chỉ mục của của phần tử đầu tiên mang một giá trị nhất định
+li.index(2)  # => 1
+li.index(4)  # Sinh ra biệt lệ a ValueError as 4 is not in the list
+
+# Bạn có thể cộng dồn các danh sách
+# Lưu ý: giá trị của li và other_li không đổi
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+
+# Nối danh sách bằng "extend()"
+li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]
+
+# Kiểm tra sự tồn tại của một phần tử trong danh sách bằng "in"
+1 in li  # => True
+
+# Xác định độ dài bằng "len()"
+len(li)  # => 6
+
+
+# Tuple cũng giống như danh sách nhưng không thể thay đổi giá trị được (immutable)
+tup = (1, 2, 3)
+tup[0]      # => 1
+tup[0] = 3  # Sinh ra biệt lệ kiểu TypeError
+
+# Lưu ý rằng tuple có độ dài là 1 phải có dấu phẩy theo sau phần tử cuối
+# nhưng tuples có độ dài khác, ngay cả tuple rỗng, thì không cần như vậy
+type((1))   # => <class 'int'>
+type((1,))  # => <class 'tuple'>
+type(())    # => <class 'tuple'>
+
+# Hầu hết các phép toán của danh sách đều áp dụng được cho tuples
+len(tup)         # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]          # => (1, 2)
+2 in tup         # => True
+
+# Bạn có thể gán giá trị cho nhiều biến một lúc bằng tuple (tuple unpacking)
+a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
+# Sau đây là unpacking kiểu mở rộng
+a, *b, c = (1, 2, 3, 4)  # a bây giờ là 1, b là [2, 3] và c là 4
+# Tuple được tự động tạo ra nếu bạn không để dấu ngoặc đơn
+d, e, f = 4, 5, 6
+# Hoán đổi hai biến trở nên dễ dàng
+e, d = d, e  # d bây giờ là 5 và e là 4
+
+
+# Kiểu dữ liệu từ điển (dictionaries) lưu trữ ánh xạ từ các khóa (keys) đến các giá trị (values)
+empty_dict = {}
+# Sau đây là một từ điển có sẵn phần tử
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Lưu ý rằng khóa của từ điển phải có kiểu dữ liệu thuộc loại immutable. Điều này để bảo đảm rằng
+# khóa đó luôn được chuyển hóa thành một giá trị băm (hash value) duy nhất khi tìm kiếm trong từ điển
+# Những kiểu immutable bao gồm số nguyên (int), số thực (float), chuỗi ký tự (string), hay tuple
+invalid_dict = {[1,2,3]: "123"}  # => Sinh ra biệt lệ kiểu TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}   # Tuy nhiên, giá trị có thể thuộc bất kỳ kiểu gì
+
+# Truy cập giá trị của một từ khóa bằng dấu []
+filled_dict["one"]  # => 1
+
+# Tất cả khóa trong một từ điển có thể được chuyển thành một đối tượng khả lặp (iterable).
+# Chúng ta cần phải gọi hàm list() để chuyển một iterable thành một danh sách.
+# Chúng ta sẽ bàn về vấn đề này sau. Lưu ý - Thứ tự của khóa trong từ điển sẽ không được đảm bảo.
+# Những gì bạn thấy khi chạy dòng code dưới đây có thể sẽ không hoàn toàn giống như vậy.
+list(filled_dict.keys())  # => ["three", "two", "one"]
+
+
+# Tất cả các giá trị có thể chuyển thành một đối tượng khả lặp bằng cách gọi hàm "values()".
+# Chúng ta cũng vẫn phải gọi hàm list() nếu muốn chuyển nó thành một danh sách. Lưu ý - thứ
+# tự của giá trị cũng không được đảm bảo
+list(filled_dict.values())  # => [3, 2, 1]
+
+
+# Sự tồn tại của khóa trong từ điển có thể kiểm tra được thông qua từ khóa "in"
+"one" in filled_dict  # => True
+1 in filled_dict      # => False
+
+# Truy xuất giá trị của một khóa không tồn tại trong từ điển sẽ tạo ra biệt lệ KeyError
+filled_dict["four"]  # KeyError
+
+# Dừng phương thức "get()" để tránh tạo ra biệt lệ KeyError
+filled_dict.get("one")      # => 1
+filled_dict.get("four")     # => None
+# Phương thức get hỗ trợ một đối số mặt định khi không thể tìm thấy giá trị ứng với từ khóa
+filled_dict.get("one", 4)   # => 1
+filled_dict.get("four", 4)  # => 4
+
+# "setdefault()" chèn một giá trị ứng với khóa nếu khóa đó không có sẵn trong từ điển
+filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+
+# Thêm khóa và giá trị vào từ điển
+filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
+filled_dict["four"] = 4         # another way to add to dict
+
+# Xóa một khóa ra khỏi từ điển bằng từ khóa del
+del filled_dict["one"]  # Removes the key "one" from filled dict
+
+# Bắt đầu từ Python 3.5 bạn có thể unpack từ điển trong một từ điển khác
+{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
+{'a': 1, **{'a': 2}}  # => {'a': 2}
+
+
+
+# Kiểu tập hợp (set) lưu trữ ... tập hợp
+empty_set = set()
+# Khởi tạo giá trị một tập hợp với nhiều giá tri. Vâng, nhìn nó khá giống từ điển.
+some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}
+
+# Tương tự như khóa của từ điển, phần tử của một tập hợp cũng phải là immutable
+invalid_set = {[1], 1}  # => Sinh ra biệt lệ TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# Thêm một phần tử vào tập hợp
+filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
+
+# Thực hiện phép giao hai tập hợp bằng phép toán &
+other_set = {3, 4, 5, 6}
+filled_set & other_set  # => {3, 4, 5}
+
+# Thực hiện phép hợp bằng phép toán |
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
+
+# Lấy hiệu của hai tập hơp bằng phép toán -
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
+
+# Lấy hiệu đối xứng bằng phép toán ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# Kiểm tra tập hợp bên trái là tập cha của bên phải
+{1, 2} >= {1, 2, 3} # => False
+
+# Kiểm tra xem tập hợp bên trái có phải là tập con của tập hợp bên phải
+{1, 2} <= {1, 2, 3} # => True
+
+# Kiểm tra sự tồn tại của một phần tử trong tập hợp bằng từ khóa in
+2 in filled_set   # => True
+10 in filled_set  # => False
+
+
+
+####################################################
+## 3. Luồng điều khiển và kiểu khả lặp
+####################################################
+
+# Đầu tiên hãy tạo ra một biến
+some_var = 5
+
+# Sau đây là một câu lệnh if. Khoảng cách lề rất quan trọng trong Python
+# Quy ước chung là dùng khoảng trắng chứ không phải ký tự tab
+# Chuỗi sau sẽ được in ra "some_var is smaller than 10"
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:    # Phần elif là tùy chọn.
+    print("some_var is smaller than 10.")
+else:                  # else cũng là tùy chọn.
+    print("some_var is indeed 10.")
+
+
+"""
+Lặp qua một danh sách bằng for
+in ra:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # Bạn có thể dùng format() để gán một giá trị vào giữa chuỗi (string interpolation)
+    print("{} is a mammal".format(animal))
+
+"""
+"range(number)" trả về một đối tượng khả lặp kiểu số
+từ 0 đến giá trị của number
+in ra:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(lower, upper)" trả về một đối tượng khả lặp kiểu số
+từ giá trị lower đến giá trị upper
+in ra:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(lower, upper, step)" trả về một đối tượng khả lặp kiểu số
+từ giá trị lower đến giá trị upper, tăng dần theo giá trị
+của step. Nếu không có giá trị của step thì mặc định là 1.
+in ra:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+Vòng lặp while tiếp tục lặp khi điều kiện còn được thỏa mãn
+in ra:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # cách viết ngán cho x = x + 1
+
+# Handle exceptions with a try/except block
+# Đối phó với biệt lệ bằng khối lệnh try/except
+try:
+    # Dùng "raise" để ném ra một biệt lệ
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass                 # pass có nghĩa là không làm gì cả. Thông thường đây là nơi để khắc phụ vấn đề làm xảy ra biệt lệ
+except (TypeError, NameError):
+    pass                 # Nhiều biệt lệ có thể được đối phó cùng một lúc nếu cần
+else:                    # Không bắt buộc phải sử dụng else nhưng nếu dùng thì nó phải sau tất cả các khối except
+    print("All good!")   # Chỉ thực thi nếu không có biệt lệ phát sinh
+finally:                 # Luôn thực thi trong mọi hoàn cảnh
+    print("We can clean up resources here")
+
+# Thay vì dùng try/finally để thu hồi tài nguyên (resources) ta có thể dùng with
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Python hỗ trợ kiểu dữ liệu khả lặp (iterable).
+# Một đối tượng khả lặp có thể được xem như là một chuỗi các đối tượng tuần tự (sequence)
+# Đối tượng trả về bởi hàm range là một khả lặp.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => dict_keys(['one', 'two', 'three']). Đây là một đối tượng khả lặp
+
+# Ta có thể lặp qua đối tượng
+for i in our_iterable:
+    print(i)  # In ra một, hai, ba
+
+# Tuy nhiên chúng ta không thể truy cập phần tử bằng chỉ mục
+our_iterable[1]  # Sinh ra biệt lệ TypeError
+
+# Một đối tượng khả lặp là đối tượng có thể tạo ra một iterator
+our_iterator = iter(our_iterable)
+
+# iterator là một đối tượng ghi nhớ được trạng thái trong quá trình nó được duyệt qua
+# đối tượng kế tiếp có thể truy cập được bằng hàm next
+next(our_iterator)  # => "one"
+
+# Nó ghi nhớ trạng thái trong quá trình lặp
+next(our_iterator)  # => "two"
+next(our_iterator)  # => "three"
+
+# Sau khi iterator đã trả về tất cả dữ liệu, nó sẽ sinh ra biệt lệ kiểu StopIteration
+next(our_iterator)  # Sinh ra biệt lệ StopIteration
+
+# Ta có thể lấy tất cả phần tử của một iterator bằng cách gọi hàm list với nó
+list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+
+
+####################################################
+## 4. Hàm
+####################################################
+
+# Dùng từ khóa def để định nghĩa hàm
+def add(x, y):
+    print("x is {} and y is {}".format(x, y))
+    return x + y  # từ khóa return để trả về một giá trị
+
+# Gọi một hàm với đối số
+add(5, 6)  # => In ra "x is 5 and y is 6" và trả về 11
+
+# Một cách khác để gọi hàm là dùng đối số có từ khóa (keyword arguments)
+add(y=6, x=5)  # Đối số có từ khóa có thể xuất hiện với thứ tự bất kỳ
+
+# Bạn có thể định nghĩa hàm có số lượng đối số vị trí (positional arguments) không biết trước
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)  # => (1, 2, 3)
+
+# Số lượng tham số từ khóa cũng có thể không cần biết trước
+def keyword_args(**kwargs):
+    return kwargs
+
+# Thử gọi hàm để xem điều gì xảy ra
+keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
+
+
+# Có thể định nghĩa hàm dùng cả hai loại đối số
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) in ra:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Khi gọi hàm, bạn có thể làm ngược với khi định nghĩa
+# Dùng dấu * để lấy giá trị từ args và ** với giá trị từ kwargs
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)            # tương đương với foo(1, 2, 3, 4)
+all_the_args(**kwargs)         # tương đương với foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # tương đương với foo(1, 2, 3, 4, a=3, b=4)
+
+# Trả về nhiều giá trị (gán vào một tuple)
+def swap(x, y):
+    return y, x  # Trả về nhiều giá trị dưới dạng một tuple mà không cần dấu ngoặc.
+                 # (Lưu ý là dấu ngoặc đơn đã được bỏ đi những vẫn có thể được thêm vào)
+
+x = 1
+y = 2
+x, y = swap(x, y)     # => x = 2, y = 1
+# (x, y) = swap(x,y)  # dấu ngoặc đơn đã được bỏ đi những vẫn có thể được thêm vào
+
+# Tầm vực của hàm
+x = 5
+
+def set_x(num):
+    # Biến cục bộ x không đồng nhất với biến toàn cục x
+    x = num    # => 43
+    print(x)   # => 43
+
+def set_global_x(num):
+    global x
+    print(x)   # => 5
+    x = num    # biến toàn cục x được gán giá trị là 6
+    print(x)   # => 6
+
+set_x(43)
+set_global_x(6)
+
+
+# Hàm trong Python cũng là đối tượng
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# Có những hàm không tên
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# Có những hàm cấp cao được hỗ trọ sẵn
+list(map(add_10, [1, 2, 3]))          # => [11, 12, 13]
+list(map(max, [1, 2, 3], [4, 2, 1]))  # => [4, 2, 3]
+
+list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]
+
+# list comprehension có thể dùng để hay thế map và filter
+# list comprehension lưu giá trị xuất vào một danh sách mà bản thân nó có thể lồng trong danh sách khác
+[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
+
+# Tập hơp và từ điển cũng có thể được tao ra thông qua set comprehension và dict comprehension
+{x for x in 'abcddeef' if x not in 'abc'}  # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+## 5. Mô đun
+####################################################
+
+# Bạn có thể import một mô đun
+import math
+print(math.sqrt(16))  # => 4.0
+
+# Bạn có thể lấy một hàm cụ thể từ một mô đun
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Hoặc import tất cả hàm từ một mô đun
+# Cảnh báo: đây không phải là một cách hay
+from math import *
+
+# Có thể làm tên của module ngắn lại
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# Mô đun trong Python chỉ là những tập tin Python bình thường. Bạn
+# có thể viết mô đun của mình và import chúng. Tên của mô đun
+# cũng là tên của tập tin.
+
+# You can find out which functions and attributes
+# are defined in a module.
+# Bạn có thể liệt kê những hàm và thuộc tính
+# được định nghĩa trong một mô đun
+import math
+dir(math)
+
+# Nếu bạn có một tập tin code Python gọi là math.py ở cùng
+# thư mục với tập tin hiện tai, tập tin math.py sẽ
+# được nạp vào thay vì mô đun được cung cấp sẵn (built-in) trong Python.
+# Điều này xảy ra vì thư mục hiện tại có ưu tiên
+# hơn những thư viện cung cấp sẵn.
+
+
+####################################################
+## 6. Lớp (classes)
+####################################################
+
+# Ta dùng từ khóa "class" đề định nghĩa một lớp
+class Human:
+
+    # Một thuộc tính của lớp được chia sẽ bởi tất cả đối tượng của lớp này
+    species = "H. sapiens"
+
+    # Hàm khởi tạo cơ bản sẽ được goi khi một đối tượng được tạo ra.
+    # Lưu ý 2 dấu gạch dưới ở đầu và cuối ám chỉ đối tượng
+    # hoặc thuộc tính dùng bở Python những tồn tại trong không gian tên
+    # do người dùng kiểm soát. Phương thức (hoặc thuộc tính) như: __init__, __str__,
+    # __repr__ v.v.. là những phương thức đặc biệt.
+    # Bạn không nên tự đặt những tên như vậy.
+    def __init__(self, name):
+        # Gán đối số vào thuộc tính name của đối tượng
+        self.name = name
+
+        # Khởi tạo thuộc tính
+        self._age = 0
+
+    # Một phương thức trên đối tượng. Tất cả đều có đối số đầu tiên là "self"
+    def say(self, msg):
+        print ("{name}: {message}".format(name=self.name, message=msg))
+
+    # Một phương thức trên đối tượng khác
+    def sing(self):
+        return 'yo... yo... microphone check... one two... one two...'
+
+    # Một phương thức trên lớp được chia sẻ với mọi đối tượng
+    # Lớp đó cũng là đối số thứ nhất của phương thức đó
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Một phương thức tĩnh được gọi mà không có lớp hay đối tượng đi kèm
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+    # Một thuộc tính chỉ giống như một hàm truy xuất.
+    # Nó biến phương thức age() thành một thuộc tính chỉ đọc cùng tên.
+    # Tuy nhiên trong Python không nhất thiết phải viết những hàm đọc và ghi quá đơn giản
+    @property
+    def age(self):
+        return self._age
+
+    # Đây là hàm để ghi giá trị cho thuộc tính
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # Đây là hàm để xóa thuộc tính
+    @age.deleter
+    def age(self):
+        del self._age
+
+
+# Khi trình thông dịch Python đọc một tập tin mã nguồn, nó thực thi tất cả code trong đó.
+# Kiểm tra giá trị của __name__ bảo đảm rằng đoạn mã bên dưới chỉ thực thi khi
+# mô đun này là chương trình chính
+if __name__ == '__main__':
+    # Khởi tạo một đối tượng
+    i = Human(name="Ian")
+    i.say("hi")                     # "Ian: hi"
+    j = Human("Joel")
+    j.say("hello")                  # "Joel: hello"
+    # i và j là thực thể của kiểu Human, nói cách khác: chúng là những đối tượng Human
+
+    # Gọi những phương thức trên lớp
+    i.say(i.get_species())          # "Ian: H. sapiens"
+    # Thay đổi thuộc tính chung
+    Human.species = "H. neanderthalensis"
+    i.say(i.get_species())          # => "Ian: H. neanderthalensis"
+    j.say(j.get_species())          # => "Joel: H. neanderthalensis"
+
+    # Gọi phương thức tĩnh
+    print(Human.grunt())            # => "*grunt*"
+    
+    # Không thể gọi phương thức tĩnh với một thực thể/đối tượng
+    # bởi vì i.grunt() sẽ tự động đặt "self" (tức là đối tượng i) làm đối số thứ nhất
+    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given
+                                    
+    # Thay đổi thuộc tính của đối tượng
+    i.age = 42
+    # Truy cập thuộc tính
+    i.say(i.age)                    # => "Ian: 42"
+    j.say(j.age)                    # => "Joel: 0"
+    # Xóa thuộc tính
+    del i.age
+    # i.age                         # => dòng nãy sẽ tạo ra biệt lệ AttributeError
+
+
+####################################################
+## 6.1 Đa thừa kế
+####################################################
+
+# Một định nghĩa lớp khác
+class Bat:
+
+    species = 'Baty'
+
+    def __init__(self, can_fly=True):
+        self.fly = can_fly
+
+    # Lớp này có phương thức say
+    def say(self, msg):
+        msg = '... ... ...'
+        return msg
+
+    # Và một phương thức khác
+    def sonar(self):
+        return '))) ... ((('
+
+if __name__ == '__main__':
+    b = Bat()
+    print(b.say('hello'))
+    print(b.fly)
+
+# Để tận dụng việc mô đun hóa thành từng tập tin, bạn có thể đặt những lớp định nghĩa ở trên vào các tập tin riêng,
+# ví dụ như human.py và bat.py
+
+# Để import hàm từ tập tin khác dừng cấu trúc sau
+# from "filename-without-extension" import "function-or-class"
+
+# superhero.py
+from human import Human
+from bat import Bat
+
+# Batman thừa kế từ lớp Human và Bat
+class Batman(Human, Bat):
+
+    # Batman có giá trị riêng cho thuộc tính trên lớp species
+    species = 'Superhero'
+
+    def __init__(self, *args, **kwargs):
+	# Cách điển hình để thừa kế thuộc tính là gọi super
+	# super(Batman, self).__init__(*args, **kwargs)
+	# Tuy nhiên với đa thừa kế, super() sẽ chỉ gọi lớp cơ sở tiếp theo trong danh sách MRO.
+	# Vì thế, ta sẽ gọi cụ thể hàm __init__ của các lớp chả.
+	# Sử dụng *args và **kwargs cho phép việc truyền đối số gọn gàng hơn,
+	# trong đó mỗi lớp cha sẽ chịu trách nhiệm cho những phần thuộc về nó
+        Human.__init__(self, 'anonymous', *args, **kwargs)
+        Bat.__init__(self, *args, can_fly=False, **kwargs)
+	# ghi đè giá trị của thuộc tính name
+        self.name = 'Sad Affleck'
+
+    def sing(self):
+        return 'nan nan nan nan nan batman!'
+
+
+if __name__ == '__main__':
+    sup = Batman()
+
+    # Kiểm tra kiểu đối tượng
+    if isinstance(sup, Human):
+        print('I am human')
+    if isinstance(sup, Bat):
+        print('I am bat')
+    if type(sup) is Batman:
+        print('I am Batman')
+
+    # Truy xuất thứ tự phương thức của các lớp cha (Method Resolution search Order), vốn được dùng bởi cả getattr() và super9)
+    # Thuộc tính này động và có thể được cập nhật
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>, <class 'human.Human'>, <class 'bat.Bat'>, <class 'object'>)
+
+    # Gọi phương thức của lớp cha nhưng dùng thuộc tính trên chính lớp hiện tại
+    print(sup.get_species())    # => Superhero
+
+    # Gọi phương thức được nạp chồng
+    print(sup.sing())           # => nan nan nan nan nan batman!
+
+    # Gọi phương thức của Human, bởi vì thứ tự thừa kế ảnh hưởng đến phương thức được gọi
+    sup.say('I agree')          # => Sad Affleck: I agree
+
+    # Gọi phương thức chỉ tồn tại ở lớp cha thứ 2
+    print(sup.sonar())          # => ))) ... (((
+
+    # Thuộc tính cấp lớp được thừa kế
+    sup.age = 100
+    print(sup.age)
+
+    # Thuộc tính thừa kế từ lớp cha thứ 2 có giá trị mặc định đã bị ghi đè
+    print('Can I fly? ' + str(sup.fly))
+
+
+
+####################################################
+## 7. Phần nâng cao
+####################################################
+
+# Generator giúp ta viết những đoạn code lười biếng (áp dụng nguyên tắc lazy evaluation)
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Generators tiết kiệm bộ nhớ vì nó chỉ tải dữ liệu khi cần
+# xử lý giá trị kế tiếp của một đối tượng khả lặp. Điều này cho phép generator thực hiện
+# những thao tác mà bình thường không làm được trên những khoảng giá trị lớn
+# Lưu ý: `range` thay thế `xrange` trong Python3.
+
+for i in double_numbers(range(1, 900000000)):  # `range` là một generator.
+    print(i)
+    if i >= 30:
+        break
+
+# Cũng như danh sách có list comprehension, generator cũng có generator
+# comprehension
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+    print(x)  # in -1 -2 -3 -4 -5 ra màn hình dòng lệnh
+
+# Một generator cũng có thể bị ép kiểu thành danh sách
+values = (-x for x in [1,2,3,4,5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
+
+# Decorators
+# Trong ví dụ này hàm `beg` 'phủ lên' hàm `say`. Nếu say_please là True thì nó
+# sẽ thay đội giá trị trả về
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Làm ơn! Tui rất nghèo :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Mua bia cho tui nhé?"
+    return msg, say_please
+
+
+print(say())                 # Mua bia cho tui nhé?
+print(say(say_please=True))  # Mua bia cho tui nhé? Làm ơn! Tui rất nghèo :(
+```
+
+## Sẵn sàng để học nhiều hơn?
+
+### Miễn phí trên mạng
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
+* [Dive Into Python 3](http://www.diveintopython3.net/index.html)
+* [A Crash Course in Python for Scientists](http://nbviewer.jupyter.org/gist/anonymous/5924718)
diff --git a/vi-vn/ruby-ecosystem-vi.html.markdown b/vi-vn/ruby-ecosystem-vi.html.markdown
new file mode 100644
index 00000000..518cf072
--- /dev/null
+++ b/vi-vn/ruby-ecosystem-vi.html.markdown
@@ -0,0 +1,148 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+    - ["Jon Smock", "http://github.com/jonsmock"]
+    - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+    - ["Vinh Nguyen", "http://rubydaily.net"]
+lang: vi-vn
+---
+
+Nhìn chung các lập trình viên Ruby luôn có cách để cài đặt các phiên bản
+Ruby khác nhau, quản lý các gói (hoặc gems), và quản lý các thư viện.
+
+## Trình quản lý Ruby
+
+Một vài nền tảng phải có Ruby đã được cài đặt trước hoặc có sẵn như một gói.
+Số đông lập trình viên Ruby không sử dụng cái này, hoặc nếu có, họ chỉ sử
+dụng chúng để bootstrap cài đặt Ruby. Thay vào đó, các lập trình viên Ruby
+có xu hướng cài đặt trình quản lý Ruby để cài đặt và chuyển đổi các phiên
+bản của Ruby và môi trường Ruby cho dự án của họ.
+
+Dưới đây là các trình quản lý môi trường Ruby nổi tiếng:
+
+* [RVM](https://rvm.io/) - Cài đặt và chuyển đổi các phiên bản Ruby. RVM cũng
+  có các khái niệm về tập các gems để quản lý môi trường dự án một
+  cách tốt nhất.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Chỉ cài đặt các
+  phiên bản Ruby. Sử dụng cái này giúp cho việc cài đặt Ruby tốt hơn.
+* [rbenv](https://github.com/sstephenson/rbenv) - Chỉ dùng để chuyển đổi các
+  phiên bản Ruby. Được sử dụng đi kèm với ruby-build. Tiện ích này sẽ giúp
+  cho việc dùng Ruby tốt hơn.
+* [chruby](https://github.com/postmodern/chruby) - Chỉ dùng để chuyển đổi các
+  phiên bản Ruby. Tương tự như rbenv. Không quan tâm làm thế nào Ruby được
+  cài đặt.
+
+## Các phiên bản Ruby
+
+Ruby được tạo ra bởi Yukihiro "Matz" Matsumoto, người được xem như là một
+[BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), mặc dầu gần
+đây luôn thay đổi. Kết quả là, tham chiếu của Ruby được gọi là MRI(Matz'
+Reference Implementation), và khi bạn biết về một phiên bản Ruby, nó đang
+được tham chiếu để phát hành một phiên bản của MRI.
+
+Có ba phiên bản Ruby chính thức được dùng là:
+
+* 2.0.0 - Được phát hành vào tháng 2 năm 2013. Hầu hết các thư viện lớn, và
+nền tảng đều hỗ trợ 2.0.0.
+* 1.9.3 - Được phát hành vào tháng 10 năm 2011. Đây là phiên bản hầu hết các
+lập trình viên Ruby đang dùng. [Nhưng đã không còn hỗ trợ](
+  https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended
+  /)
+* 1.8.7 - [Ruby 1.8.7 đã không còn được sử dụng](
+  http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+Sự thay đổi giữa phiên bản 1.8.7 đến 1.9.x lớn hơn nhiều so với thay đổi từ
+1.9.3 đến 2.0.0. Ví dụ, các phiên bản 1.9 giới thiệu các bảng mã và một
+byecote VM. Có các dự án vẫn đang ở 1.8.7, nhưng chúng chiếm một số lượng ít
+, phần lớn cộng đồng đã chuyển sang ít nhất là 1.9.2 hoặc 1.9.3
+
+## Các ứng dụng Ruby
+
+Hệ sinh thái Ruby có rất nhiều ứng dụng, với mỗi thế mạnh độc đáo và khả
+năng tương thích. Để rõ ràng hơn, sự khác nhau giữa các ứng dụng được viết
+bằng các ngôn ngữ khác nhau, nhưng *chúng vẫn là Ruby*.
+Mỗi ứng dụng có các hook đặc trưng và những tính năng đặc biệt, nhưng tất cả
+đều chạy Ruby rất tốt. Ví dụ, JRuby được viết bằng Java, nhưng bạn không
+cần biết Java để sử dụng.
+
+Một số ứng dụng nổi tiếng/tương thích cao:
+
+* [MRI](https://github.com/ruby/ruby) - Được viết bằng C, đây là ứng dụng
+  tham chiếu của Ruby. Nó tương thích 100%. Tất cả các phiên bản Ruby có khả
+  năng duy trì với MRI(xem [RubySpec](#rubyspec) bên dưới).
+* [JRuby](http://jruby.org/) - Được viết bằng Java và Ruby, ứng dụng này khá
+  nhanh. Điểm mạnh quan trọng nhất của JRuby là JVM/Java interop, tận dụng
+  các công cụ, dự án và ngôn ngữ hiện có của JVM.
+* [Rubinius](http://rubini.us/) - Được viết bằng ngôn ngữ chính là Ruby với
+  một C++ bytecode VM. Rất nhanh. Bởi vì nó được phát triển bằng chính Ruby.
+
+Một số ứng dụng khá nổi tiếng/tương thích:
+
+* [Maglev](http://maglev.github.io/) - Đứng đầu Gemstone, một Smalltalk VM.
+  SmallTalk có một vài tiện ích hấp dẫn, và trong dự án này đã mang nó vào
+  môi trường Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Mang Ruby đến việc phát triển iOS.
+
+Một số ứng dụng tốt/tương thích:
+
+* [Topaz](http://topazruby.com/) - Được biết bằng RPython (sử dụng Pypy),
+  Topaz vẫn còn rất trẻ và chưa hoàn toàn tương thích. Nó hứa hẹn khả năng
+  trở thành một ứng dụng Ruby tương thích cao.
+* [IronRuby](http://ironruby.net/) - Được viết bằng C# hướng đến nền tảng .NET
+  , IronRuby dường như đã dừng hoạt động kể từ khi Microsoft rút hỗ trợ.
+
+Các ứng dụng Ruby có các phiên bản riêng của mình, nhưng chúng luôn luôn
+hướng đến sự một phiên bản đặc biệt của MRI cho sự tương thích. Nhiều ứng
+dụng có khả năng đến các chế độ khác nhau (ví dụ, 1.8 hoặc 1.9) để hướng đến
+phiên bản MRI.
+
+## RubySpec
+
+Hầu hết các ứng dụng Ruby dựa vào [RubySpec](http://rubyspec.org/). Ruby không
+có thông báo chính thức, nhưng cộng đồng đã viết những specs thực thi trong
+Ruby để kiểm tra sự tương thích với MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) là một cộng đồng quản lý các gói cho Ruby.
+RubyGems đi kèm với Ruby, bởi vậy không cần cài đặt riêng lẻ.
+
+Các gói Ruby được gọi là "gems", và chúng được host bởi cộng đồng tại
+RubyGems.org. Một gem chứa mã nguồn của nó và một vài mô tả, bao gồm những
+thứ như phiên bản, các thư viện độc lập, các tác giả và các loại giấy phép.
+
+## Bundler
+
+[Bundler](http://bundler.io/) là một gem giải quyết độc lập. Nó sử dụng một
+Gemfile để tìm kiếm các thư viện độc lập trong dự án, và sau đó sẽ lấy về
+các thư viện của các thư viện độc lập này. Nó thực hiện cho đến khi việc
+tải các thư viện hoàn tất, hoặc nó sẽ dừng nếu xuất hiện bất kỳ xung đột nào.
+
+Bundler sẽ hiển thị lỗi nếu tìm thấy bất kỳ xung đột giữa các thư viện. Ví
+dụ, nếu như gem A yêu cầu gem Z có phiên bản 3 hoặc cao hơn, nhưng gem B lại
+yêu cầu gem Z phiên bản 2. Bundler sẽ thông báo cho bạn sự xung đột này.
+Điều này đã rất hữu ích khi nhiều gem tham chiếu các các gem khác (trong
+gem này lại tham chiếu đến các gem khác nữa), có thể hình thành một đồ thị
+lớn để nói.
+
+# Kiểm thử
+
+Kiểm thử là một phần lớn của Ruby. Ruby mang đến một nền tảng kiểm thử theo
+kiểu Unit được gọi là minitest (hoặc TestUnit for phiên bản Ruby 1.8.x).
+Có nhiều thư viện kiểm thử với các mục đích khác nhau.
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/
+  Unit.html) - Nền tảng kiểm thử theo kiểu Unit của Ruby 1.8.
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest
+  /rdoc/MiniTest.html) -Nền tảng kiểm thử được xây dựng cho Ruby 1.9/2.0
+* [RSpec](http://rspec.info/) - Một nền tảng kiểm thử tập trung vào sự
+  hoạt động.
+* [Cucumber](http://cukes.info/) - Một nền tảng kiểm thử theo kiểu BDD dưới
+  định dạng Gherkin.
+
+## Be Nice
+
+Cộng đồng Ruby tự hào là một cộng đồng mở, đa dạng và chào đón tất cả mọi
+người. Bản thân Matz là một người cực kỳ thân thiện, và các lập trình viên
+Ruby rất tuyệt vời.
diff --git a/vim.html.markdown b/vim.html.markdown
new file mode 100644
index 00000000..70f43be1
--- /dev/null
+++ b/vim.html.markdown
@@ -0,0 +1,236 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+filename: LearnVim.txt
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) is a clone of the popular vi editor for Unix. It is a text 
+editor designed for speed and increased productivity, and is ubiquitous in most 
+unix-based systems. It has numerous keybindings for speedy navigation to 
+specific points in the file, and for fast editing.
+
+## Basics of navigating Vim
+
+```
+    vim <filename>   # Open <filename> in vim
+    :q               # Quit vim
+    :w               # Save current file
+    :wq              # Save file and quit vim
+    :q!              # Quit vim without saving file
+                     # ! *forces* :q to execute, hence quiting vim without saving
+    :x               # Save file and quit vim, shorter version of :wq
+
+    u                # Undo
+    CTRL+R           # Redo
+
+    h                # Move left one character
+    j                # Move down one line
+    k                # Move up one line
+    l                # Move right one character
+
+    # Moving within the line
+
+    0                # Move to beginning of line
+    $                # Move to end of line
+    ^                # Move to first non-blank character in line
+
+    # Searching in the text
+
+    /word            # Highlights all occurences of word after cursor
+    ?word            # Highlights all occurences of word before cursor
+    n                # Moves cursor to next occurence of word after search
+    N                # Moves cursor to previous occerence of word
+
+    :%s/foo/bar/g    # Change 'foo' to 'bar' on every line in the file
+    :s/foo/bar/g     # Change 'foo' to 'bar' on the current line
+
+    # Jumping to characters
+
+    f<character>     # Jump forward and land on <character>
+    t<character>     # Jump forward and land right before <character> 
+
+    # For example,    
+    f<               # Jump forward and land on <
+    t<               # Jump forward and land right before <
+    
+    # Moving by word
+
+    w                # Move forward by one word
+    b                # Move back by one word
+    e                # Move to end of current word
+
+    # Other characters for moving around
+
+    gg               # Go to the top of the file
+    G                # Go to the bottom of the file
+    :NUM             # Go to line number NUM (NUM is any number)
+    H                # Move to the top of the screen
+    M                # Move to the middle of the screen
+    L                # Move to the bottom of the screen
+```
+
+## Modes:
+
+Vim is based on the concept on **modes**.
+
+Command Mode - vim starts up in this mode, used to navigate and write commands 
+Insert Mode  - used to make changes in your file 
+Visual Mode  - used to highlight text and do operations to them 
+Ex Mode      - used to drop down to the bottom with the ':' prompt to enter commands
+
+```
+    i                # Puts vim into insert mode, before the cursor position
+    a                # Puts vim into insert mode, after the cursor position
+    v                # Puts vim into visual mode    
+    :                # Puts vim into ex mode
+    <esc>            # 'Escapes' from whichever mode you're in, into Command mode
+
+    # Copying and pasting text
+
+    y                # Yank whatever is selected
+    yy               # Yank the current line
+    d                # Delete whatever is selected
+    dd               # Delete the current line
+    p                # Paste the copied text after the current cursor position
+    P                # Paste the copied text before the current cursor position
+    x                # Deleting character under current cursor position
+```
+
+## The 'Grammar' of vim
+
+Vim can be thought of as a set of commands in a 
+'Verb-Modifier-Noun' format, where:
+
+Verb     - your action 
+Modifier - how you're doing your action 
+Noun     - the object on which your action acts on
+
+A few important examples of 'Verbs', 'Modifiers', and 'Nouns':
+
+```
+    # 'Verbs'
+ 
+    d                # Delete
+    c                # Change
+    y                # Yank (copy)
+    v                # Visually select
+
+    # 'Modifiers'
+
+    i                # Inside
+    a                # Around
+    NUM              # Number (NUM is any number)
+    f                # Searches for something and lands on it
+    t                # Searches for something and stops before it
+    /                # Finds a string from cursor onwards
+    ?                # Finds a string before cursor
+
+    # 'Nouns'
+
+    w                # Word
+    s                # Sentence
+    p                # Paragraph
+    b                # Block
+    
+    # Sample 'sentences' or commands
+
+    d2w              # Delete 2 words
+    cis              # Change inside sentence
+    yip              # Yank inside paragraph (copy the para you're in)
+    ct<              # Change to open bracket
+                     # Change the text from where you are to the next open bracket
+    d$               # Delete till end of line
+```
+
+## Some shortcuts and tricks
+
+        <!--TODO: Add more!-->
+```
+    >                # Indent selection by one block
+    <                # Dedent selection by one block
+    :earlier 15m     # Reverts the document back to how it was 15 minutes ago
+    :later 15m       # Reverse above command
+    ddp              # Swap position of consecutive lines, dd then p
+    .                # Repeat previous action
+    :w !sudo tee %   # Save the current file as root
+```
+
+## Macros
+
+Macros are basically recordable actions.
+When you start recording a macro, it records **every** action and command
+you use, until you stop recording. On invoking a macro, it applies the exact
+same sequence of actions and commands again on the text selection.
+
+```
+    qa               # Start recording a macro named 'a'
+    q                # Stop recording
+    @a               # Play back the macro
+```
+
+### Configuring ~/.vimrc
+
+The .vimrc file can be used to configure Vim on startup.
+
+Here's a sample ~/.vimrc file:
+
+```
+" Example ~/.vimrc
+" 2015.10 
+
+" Required for vim to be iMproved
+set nocompatible
+
+" Determines filetype from name to allow intelligent auto-indenting, etc.
+filetype indent plugin on
+
+" Enable syntax highlighting
+syntax on
+
+" Better command-line completion
+set wildmenu
+
+" Use case insensitive search except when using capital letters
+set ignorecase
+set smartcase
+
+" When opening a new line and no file-specific indenting is enabled,
+" keep same indent as the line you're currently on
+set autoindent
+
+" Display line numbers on the left
+set number
+
+" Indentation options, change according to personal preference
+
+" Number of visual spaces per TAB
+set tabstop=4
+
+" Number of spaces in TAB when editing
+set softtabstop=4
+
+" Number of spaces indented when reindent operations (>> and <<) are used
+set shiftwidth=4
+
+" Convert TABs to spaces
+set expandtab
+
+" Enable intelligent tabbing and spacing for indentation and alignment
+set smarttab
+```
+
+### References
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
diff --git a/visualbasic.html.markdown b/visualbasic.html.markdown
index 0371e6f6..f081b907 100644
--- a/visualbasic.html.markdown
+++ b/visualbasic.html.markdown
@@ -272,11 +272,3 @@ Module Module1
 End Module
 
 ```
-
-## References
-
-I learnt Visual Basic in the console application. It allowed me to understand the principles of computer programming to go on to learn other programming languages easily.
-
-I created a more indepth <a href="http://www.vbbootcamp.co.uk/" Title="Visual Basic Tutorial">Visual Basic tutorial</a> for those who would like to learn more.
-
-The entire syntax is valid. Copy the and paste in to the Visual Basic compiler and run (F5) the program.
diff --git a/yaml.html.markdown b/yaml.html.markdown
index 507c4d1f..95adbd83 100644
--- a/yaml.html.markdown
+++ b/yaml.html.markdown
@@ -25,9 +25,9 @@ YAML doesn't allow literal tab characters at all.
 key: value
 another_key: Another value goes here.
 a_number_value: 100
-# If you want to use number 1 as a value, you have to enclose it in quotes, 
-# otherwise, YAML parser will assume that it is a boolean value of true.
 scientific_notation: 1e+12
+# The number 1 will be interpreted as a number, not a boolean. if you want
+# it to be intepreted as a boolean, use true
 boolean: true
 null_value: null
 key with spaces: value
@@ -164,3 +164,8 @@ set2:
     item2: null
     item3: null
 ```
+
+### More Resources
+
++ [YAML official website](http://yaml.org/)
++ [Online YAML Validator](http://codebeautify.org/yaml-validator)
diff --git a/zfs.html.markdown b/zfs.html.markdown
index 74487e35..3d033da9 100644
--- a/zfs.html.markdown
+++ b/zfs.html.markdown
@@ -9,7 +9,7 @@ filename: LearnZfs.txt
 
 [ZFS](http://open-zfs.org/wiki/Main_Page)
 is a rethinking of the storage stack, combining traditional file systems as well as volume
-managers into one cohesive tool.  ZFS has some specific teminology that sets it appart from
+managers into one cohesive tool.  ZFS has some specific terminology that sets it apart from
 more traditional storage systems, however it has a great set of features with a focus on
 usability for systems administrators.
 
@@ -23,7 +23,8 @@ types of VDEV's that offer various advantages, including redundancy and speed.
 VDEV's offer better reliability and safety than a RAID card.  It is discouraged to use a
 RAID setup with ZFS, as ZFS expects to directly manage the underlying disks.
 
-Types of VDEV's 
+Types of VDEV's
+
 * stripe (a single disk, no redundancy)
 * mirror (n-way mirrors supported)
 * raidz
@@ -39,13 +40,13 @@ increase your IOPS.
 ### Storage Pools
 
 ZFS uses Storage Pools as an abstraction over the lower level storage provider (VDEV), allow
-you to separate the user visable file system from the physcal layout.
+you to separate the user visible file system from the physical layout.
 
 ### ZFS Dataset
 
-ZFS datasets are analagous to traditional filesystems but with many more features.  They
+ZFS datasets are analogous to traditional filesystems but with many more features.  They
 provide many of ZFS's advantages.  Datasets support [Copy on Write](https://en.wikipedia.org/wiki/Copy-on-write)
-snapshots, quota's, compression and deduplication.
+snapshots, quota's, compression and de-duplication.
 
 
 ### Limits
@@ -60,6 +61,7 @@ single host can have 2^64 storage pools.  The limits are huge.
 ### Storage Pools
 
 Actions:
+
 * List
 * Status
 * Destroy
@@ -68,7 +70,7 @@ Actions:
 List zpools
 
 ```bash
-# Create a raidz zpool 
+# Create a raidz zpool
 $ zpool create bucket raidz1 gpt/zfs0 gpt/zfs1 gpt/zfs2
 
 # List ZPools
@@ -347,7 +349,7 @@ $ zfs promote tank/home/sarlalian_new
 
 ### Putting it all together
 
-This following a script utilizing FreeBSD, jails and ZFS to automate 
+This following a script utilizing FreeBSD, jails and ZFS to automate
 provisioning a clean copy of a mysql staging database from a live replication
 slave.
 
@@ -384,7 +386,7 @@ mv /jails/staging/etc/rc.conf.staging /jails/staging/etc/rc.conf.local
 echo "==== Starting the staging db server ===="
 jail -c staging
 
-echo "==== Make sthe staging database not pull from the master ===="
+echo "==== Makes the staging database not pull from the master ===="
 echo "STOP SLAVE;" | /usr/local/bin/mysql -u root -pmyrootpassword -h staging
 echo "RESET SLAVE;" | /usr/local/bin/mysql -u root -pmyrootpassword -h staging
 ```
@@ -393,7 +395,7 @@ echo "RESET SLAVE;" | /usr/local/bin/mysql -u root -pmyrootpassword -h staging
 ### Additional Reading
 
 * [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
-* [FreeBSD Handbook on ZFS](https://wiki.freebsd.org/ZF://wiki.freebsd.org/ZFS)
+* [FreeBSD Handbook on ZFS](https://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/zfs.html)
 * [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
 * [Oracle's Tuning Guide](http://www.oracle.com/technetwork/articles/servers-storage-admin/sto-recommended-zfs-settings-1951715.html)
 * [OpenZFS Tuning Guide](http://open-zfs.org/wiki/Performance_tuning)
diff --git a/zh-cn/angularjs-cn.html.markdown b/zh-cn/angularjs-cn.html.markdown
new file mode 100644
index 00000000..418a817d
--- /dev/null
+++ b/zh-cn/angularjs-cn.html.markdown
@@ -0,0 +1,710 @@
+---
+category: tool
+tool: AngularJS
+contributors:
+    - ["Walter Cordero", "http://waltercordero.com"]
+filename: learnangular-cn.html
+translators:
+   - ["Jiang Haiyun", "http://www.atjiang.com"]
+lang: zh-cn
+---
+
+## AngularJS 教程。
+
+AngularJS 1.0 版在 2012 年发布。
+Miško Hevery, 一位 Google 员工， 从 2009 年开始开发 AngularJS。
+结果发现这个想法很好，从而该项目现在也被 Google 官方所支持了。
+
+AngularJS 是一个 JavaScript 框架。它可以通过一个 "script" 标签添加到一个 HTML 页面中。
+AngularJS 通过指令扩展了 HTML 属性，并且通过表达式将数据绑定到 HTML。
+
+## 你应该已经了解了的知识
+
+在学习 AngularJS 之前， 你应该对以下知识有了基本的了解：
+
+- HTML
+- CSS
+- JavaScript
+
+```html
+// AngularJS 是一个 JavaScript 框架。它是一个用 JavaScript 写的库。
+// AngularJS 以一个 JavaScript 文件的形式发布，并且能通过一个 script 标签添加到一个网页中：
+// <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+
+///////////////////////////////////
+// AngularJS 扩展 HTML
+
+//AngularJS 通过 ng-directives 扩展 HTML。
+//ng-app 指令定义一个 AngularJS 应用。
+//ng-model 指令将 HTML 控件 (input, select, textarea) 的值绑定到应用的数据上。
+//ng-bind 指令将应用的数据绑定到 HTML 视图上。
+<!DOCTYPE html>
+<html>
+  <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div ng-app="">
+      <p>Name: <input type="text" ng-model="name"></p>
+      <p ng-bind="name"></p>
+    </div>
+  </body>
+</html>
+
+/*
+  * 例子解析：
+  * AngularJS 在网页加载后自动开启。
+  * ng-app 指令告诉 AngularJS： <div> 元素是 AngularJS 应用的 "所有者"。
+  * ng-model 指令将 input 输入框的值绑定到应用的 name 变量上。
+  * ng-bind 指令将 <p> 元素的 innerHTML 绑定到应用的 name 变量上。
+*/
+<tag> 这里是要解析的内容 </tag>
+
+///////////////////////////////////
+// AngularJS 表达式
+
+// AngularJS 表达式写在双括号内： {{ 表达式 }}。
+// AngularJS 表达式采用和 ng-bind 指令一样的方式将数据绑定到 HTML。
+// AngularJS 将在编写表达式的原样位置上 "输出" 数据。
+// AngularJS 表达式非常像 JavaScript 表达式：它们能包含文本，运算符和变量。
+// 例如 {{ 5 + 5 }} 或 {{ firstName + " " + lastName }}
+<!DOCTYPE html>
+<html>
+  <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div ng-app="">
+      <p>My first expression: {{ 5 + 5 }}</p>
+    </div>
+  </body>
+</html>
+
+//如果你删除了 ng-app 指令， HTML 将原样显示表达式，不对它进行解析：
+<!DOCTYPE html>
+<html>
+  <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div>
+      <p>My first expression: {{ 5 + 5 }}</p>
+    </div>
+  </body>
+</html>
+
+// AngularJS 表达式采用和 ng-bind 指令一样的方式将 AngularJS 数据绑定到 HTML。
+<!DOCTYPE html>
+<html>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+  <body>
+    <div ng-app="">
+      <p>Name: <input type="text" ng-model="name"></p>
+      <p>{{name}}</p>
+    </div>
+  </body>
+</html>
+
+// AngularJS 的数字类似 JavaScript 的数字：
+<div ng-app="" ng-init="quantity=1;cost=5">
+  <p>Total in dollar: {{ quantity * cost }}</p>
+</div>
+
+//AngularJS 的字符串类似 JavaScript 的字符串：
+<div ng-app="" ng-init="firstName='John';lastName='Doe'">
+  <p>The name is <span ng-bind="firstName + ' ' + lastName"></span></p>
+</div>
+
+//AngularJS 的对象类似 JavaScript 的对象：
+<div ng-app="" ng-init="person={firstName:'John',lastName:'Doe'}">
+  <p>The name is {{ person.lastName }}</p>
+</div>
+
+//AngularJS 的数组类似 JavaScript 的数组：
+<div ng-app="" ng-init="points=[1,15,19,2,40]">
+  <p>The third result is {{ points[2] }}</p>
+</div>
+
+// 和 JavaScript 表达式一样， AngularJS 表达式能包含文本，运算符和变量。
+// 和 JavaScript 表达式不同， AngularJS 表达式能写在 HTML 内。
+// AngularJS 表达式不支持条件，循环和异常，而 JavaScript 表达式却支持。
+// AngularJS 表达式支持过滤器，而 JavaScript 表达式不支持。
+
+///////////////////////////////////
+// AngularJS 指令
+
+
+//AngularJS 指令使用前缀 ng- 扩展 HTML 属性。
+//ng-app 指令初始化一个 AngularJS 应用。
+//ng-init 指令初始化应用的数据。
+//ng-model 指令将 HTML 控件 (input, select, textarea) 的值绑定到应用的数据上。
+<div ng-app="" ng-init="firstName='John'">
+  <p>Name: <input type="text" ng-model="firstName"></p>
+  <p>You wrote: {{ firstName }}</p>
+</div>
+
+//使用 ng-init 并不常见。你将在有关控制器的章节中学习如何初始化数据。
+
+//ng-repeat 指令会重复一个 HTML 元素：
+<div ng-app="" ng-init="names=['Jani','Hege','Kai']">
+  <ul>
+    <li ng-repeat="x in names">
+      {{ x }}
+    </li>
+  </ul>
+</div>
+
+//ng-repeat 指令用在一个对象数组上：
+<div ng-app="" ng-init="names=[
+{name:'Jani',country:'Norway'},
+{name:'Hege',country:'Sweden'},
+{name:'Kai',country:'Denmark'}]">
+  <ul>
+    <li ng-repeat="x  in names">
+      {{ x.name + ', ' + x.country }}
+    </li>
+  </ul>
+</div>
+
+// AngularJS 最适合用于数据库 CRUD (Create Read Update Delete) 的应用。
+// 只需设想这些对象都是来自一个数据库的记录。
+
+// ng-app 指令定义一个 AngularJS 应用的根元素。
+// ng-app 指令将在页面加载后自动启动（自动初始化）应用。
+// 稍后你将学习如何为 ng-app 设置一个值（如 ng-app="myModule"）， 来连接代码模块。
+
+// ng-init 指令为一个 AngularJS 应用定义初始值。
+// 通常，你不太使用 ng-init。你会转而使用一个控制器或模块。
+// 你将在稍后学到更多有关控制器和模块的内容。
+
+//ng-model 指令将 HTML 控件 (input, select, textarea) 的值绑定到应用的数据上。
+//ng-model 指令还能：
+//为应用的数据提供类型验证 (number, email, required)。
+//为应用的数据提供状态信息 (invalid, dirty, touched, error)。
+//为 HTML 元素提供 CSS 类。
+//将 HTML 元素绑定到 HTML 表单。
+
+//ng-repeat 指令为集合（一个数组）中的每个元素克隆出 HTML 元素。
+
+///////////////////////////////////
+// AngularJS 控制器
+
+// AngularJS 控制器控制 AngularJS 应用中的数据。
+// AngularJS 控制器就是常规的 JavaScript 对象。
+
+// AngularJS 应用由控制器控制。
+// ng-controller 指令定义应用的控制器。
+// 一个控制器就是一个 JavaScript 对象， 通过标准的 JavaScript 对象构建器创建。
+
+<div ng-app="myApp" ng-controller="myCtrl">
+
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('myCtrl', function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+});
+</script>
+
+//应用的解析：
+
+//AngularJS 应用通过 ng-app="myApp" 定义。该应用运行在 <div> 内。
+//ng-controller="myCtrl" 属性是一个 AngularJS 指令。它定义了一个控制器。
+//myCtrl 函数是一个 JavaScript 函数。
+//AngularJS 将使用一个 $scope 对象来调用控制器。
+//AngularJS 中， $scope 就是该应用对象（应用的变量和函数的所有者）。
+//该控制器在 $scope 内创建了两个属性（即变量 firstName 和 lastName）。
+//ng-model 指令将输入表单项绑定到控制器的属性上（firstName 和 lastName）。
+
+//以上的例子演示了一个包含有两个属性 lastName 和 firstName 的控制器。
+//一个控制器也可以有方法（函数的变量）：
+<div ng-app="myApp" ng-controller="personCtrl">
+
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{fullName()}}
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('personCtrl', function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+    $scope.fullName = function() {
+        return $scope.firstName + " " + $scope.lastName;
+    }
+});
+</script>
+
+//在较大型的应用中， 通常是将控制器代码保存在外部文件中。
+//只需将 <script> </script> 标签之间的代码复制到一个名为 personController.js 的外部文件中：
+
+<div ng-app="myApp" ng-controller="personCtrl">
+
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+
+</div>
+
+<script src="personController.js"></script>
+
+// 为方便下个例子使用，我们将创建一个新的控制器文件：
+angular.module('myApp', []).controller('namesCtrl', function($scope) {
+    $scope.names = [
+        {name:'Jani',country:'Norway'},
+        {name:'Hege',country:'Sweden'},
+        {name:'Kai',country:'Denmark'}
+    ];
+});
+
+//将文件保存为 namesController.js：
+//然后在一个应用中使用该控制器：
+
+<div ng-app="myApp" ng-controller="namesCtrl">
+
+<ul>
+  <li ng-repeat="x in names">
+    {{ x.name + ', ' + x.country }}
+  </li>
+</ul>
+
+</div>
+
+<script src="namesController.js"></script>
+
+///////////////////////////////////
+// AngularJS 过滤器
+
+// 过滤器可以通过一个管道符添加到表达式和指令上。
+// AngularJS 过滤器能用来转换数据：
+
+- **currency**:  将一个数字格式化成货币格式。
+- **filter**:  从一个数组中选择一组子集元素。
+- **lowercase**: 将一个字符串格式化成小写形式。
+- **orderBy**: 依据一个表达式排序一个数组。
+- **upper**: 将一个字符串格式化成大写形式。
+
+//一个过滤器可以通过一个管道符 (|) 及一个过滤器表达式添加到一个表达式上。
+//（在下面的两个例子中，我们将使用前一章中的 person 控制器）
+//uppercase 过滤器将字符串格式化成大写格式：
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<p>The name is {{ lastName | uppercase }}</p>
+
+</div>
+
+//lowercase 过滤器将字符串格式化成小写格式：
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<p>The name is {{ lastName | lowercase }}</p>
+
+</div>
+
+//currency 过滤器将一个数字格式化成货币格式：
+<div ng-app="myApp" ng-controller="costCtrl">
+
+<input type="number" ng-model="quantity">
+<input type="number" ng-model="price">
+
+<p>Total = {{ (quantity * price) | currency }}</p>
+
+</div> 
+
+//一个过滤器可以通过一个管道符 (|) 及一个过滤器表达式添加到一个指令上。
+//orderBy 过滤器根据一个表达式排序一个数组：
+<div ng-app="myApp" ng-controller="namesCtrl">
+
+<ul>
+  <li ng-repeat="x in names | orderBy:'country'">
+    {{ x.name + ', ' + x.country }}
+  </li>
+</ul>
+
+<div>
+
+//一个输入框过滤器可以通过一个管道符 (|) 
+//以及后跟一个冒号和模式名的 filter 添加到一个指令上。
+//该过滤器从一个数组中选择一个子集：
+
+<div ng-app="myApp" ng-controller="namesCtrl">
+
+<p><input type="text" ng-model="test"></p>
+
+<ul>
+  <li ng-repeat="x in names | filter:test | orderBy:'country'">
+    {{ (x.name | uppercase) + ', ' + x.country }}
+  </li>
+</ul>
+
+</div>
+
+///////////////////////////////////
+// AngularJS AJAX - $http
+
+//$http 是一个从远程服务器读取数据的 AngularJS 服务。
+
+// 以下数据可由一个 web 服务器提供：
+// http://www.w3schools.com/angular/customers.php
+// **访问 URL 来查看数据格式**
+
+// AngularJS $http 是一个从 web 服务器上读取数据的核心服务。
+// $http.get(url) 这个函数用来读取服务器数据。
+<div ng-app="myApp" ng-controller="customersCtrl"> 
+
+<ul>
+  <li ng-repeat="x in names">
+    {{ x.Name + ', ' + x.Country }}
+  </li>
+</ul>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('customersCtrl', function($scope, $http) {
+    $http.get("http://www.w3schools.com/angular/customers.php")
+    .success(function(response) {$scope.names = response.records;});
+});
+</script>
+
+// 应用解析：
+
+// AngularJS 应用由 ng-app 定义。该应用运行在一个 <div> 中。
+// ng-controller 指令命名控制器对象。
+// customersCtrl 函数是一个标准的 JavaScript 对象构造器。
+// AngularJS 会使用一个 $scope 和 $http 对象来调用 customersCtrl。
+// $scope 就是该应用对象（应用的变量和函数的所有者）。
+// $http 是一个用于请求外部数据的 XMLHttpRequest 对象。
+// $http.get() 从 http://www.w3schools.com/angular/customers.php 读取 JSON 数据。
+// 如果成功， 该控制器会根据来自服务器的 JSON 数据，在 $scope 中创建一个属性 (names)。
+
+
+// 向不同的服务器（不同于请求页）请求数据，称作跨站 HTTP 请求。
+// 跨站请求在网站上很普遍。许多网页会从不同的服务器加载 CSS，图片和脚本。
+// 在现代浏览器中，基于安全原因，从脚本内进行跨站 HTTP 请求是被禁止的。
+// 下面的这行代码，已被加入到我们的 PHP 例子中，以便允许跨站访问。
+header("Access-Control-Allow-Origin: *");
+
+
+///////////////////////////////////
+// AngularJS 表格
+
+// 使用 angular 显示表格非常简单：
+<div ng-app="myApp" ng-controller="customersCtrl"> 
+
+<table>
+  <tr ng-repeat="x in names">
+    <td>{{ x.Name }}</td>
+    <td>{{ x.Country }}</td>
+  </tr>
+</table>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('customersCtrl', function($scope, $http) {
+    $http.get("http://www.w3schools.com/angular/customers.php")
+    .success(function (response) {$scope.names = response.records;});
+});
+</script>
+
+// 要排序表格，添加一个 orderBy 过滤器：
+<table>
+  <tr ng-repeat="x in names | orderBy : 'Country'">
+    <td>{{ x.Name }}</td>
+    <td>{{ x.Country }}</td>
+  </tr>
+</table>
+
+// 要显示表格索引值，添加一个带有 $index 的 <td>：
+<table>
+  <tr ng-repeat="x in names">
+    <td>{{ $index + 1 }}</td>
+    <td>{{ x.Name }}</td>
+    <td>{{ x.Country }}</td>
+  </tr>
+</table>
+
+// 使用 $even 和 $odd
+<table>
+  <tr ng-repeat="x in names">
+    <td ng-if="$odd" style="background-color:#f1f1f1">{{ x.Name }}</td>
+    <td ng-if="$even">{{ x.Name }}</td>
+    <td ng-if="$odd" style="background-color:#f1f1f1">{{ x.Country }}</td>
+    <td ng-if="$even">{{ x.Country }}</td>
+  </tr>
+</table>
+
+///////////////////////////////////
+// AngularJS HTML DOM
+
+//AngularJS 有用于将应用的数据绑定到 HTML DOM 元素属性的指令。
+
+// ng-disabled 指令将 AngularJS 应用的数据绑定到 HTML 元素的 disabled 属性上。
+
+<div ng-app="" ng-init="mySwitch=true">
+
+<p>
+<button ng-disabled="mySwitch">Click Me!</button>
+</p>
+
+<p>
+<input type="checkbox" ng-model="mySwitch">Button
+</p>
+
+</div>
+
+//应用解析：
+
+// ng-disabled 指令将应用的 mySwitch 数据绑定到 HTML 按钮的 disabled 属性上。
+// ng-model 指令将 HTML checkbox 元素的值绑定到 mySwitch 的值上。
+// 如果 mySwitch 的值求值为 true，则该按钮将被禁用：
+<p>
+<button disabled>Click Me!</button>
+</p>
+
+// 如果 mySwitch 的值求值为 false，则该按钮将不会被禁用：
+<p>
+  <button>Click Me!</button>
+</p>
+
+// ng-show 指令显示或隐藏一个 HTML 元素。
+
+<div ng-app="">
+
+<p ng-show="true">I am visible.</p>
+
+<p ng-show="false">I am not visible.</p>
+
+</div>
+
+// ng-show 指令基于 ng-show 的值显示（或隐藏）一个 HTML 元素。
+// 你可以使用任何能求值成 true 或 false 的表达式：
+<div ng-app="">
+<p ng-show="hour > 12">I am visible.</p>
+</div>
+
+///////////////////////////////////
+// AngularJS 事件
+
+// AngularJS 有它自己的 HTML 事件指令。
+
+// ng-click 指令定义一个 AngularJS 点击事件。
+<div ng-app="myApp" ng-controller="myCtrl">
+
+<button ng-click="count = count + 1">Click me!</button>
+
+<p>{{ count }}</p>
+
+</div>
+<script>
+var app = angular.module('myApp', []);
+app.controller('myCtrl', function($scope) {
+    $scope.count = 0;
+});
+</script>
+
+// ng-hide 指令可用于设置一个应用的部分区域的可见性。
+// 值 ng-hide="true" 使得一个 HTML 元素不可见。
+// 值 ng-hide="false" 使得一个 HTML 元素可见。
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<button ng-click="toggle()">Toggle</button>
+
+<p ng-hide="myVar">
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+</p>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('personCtrl', function($scope) {
+    $scope.firstName = "John",
+    $scope.lastName = "Doe"
+    $scope.myVar = false;
+    $scope.toggle = function() {
+        $scope.myVar = !$scope.myVar;
+    };
+});
+</script>
+
+//应用解析：
+
+// personController 的第一部分和讲述控制器章节中的一样。
+// 该应用有一个默认属性（一个变量）：$scope.myVar = false：
+// ng-hide 指令依据 myVar 的值（true 或 false），
+// 设置 <p> 元素的可见性，该元素含有两个输入框。
+// 函数 toggle() 将 myVar 在 true 和 false 间进行切换。
+// 值 ng-hide="true" 使得该元素不可见。
+
+
+// ng-show 指令也能用来设置一个应用的某部分的可见性。
+// 值 ng-show="false" 使得一个 HTML 元素不可见。
+// 值 ng-show="true" 使得一个 HTML 元素可见。
+// 这个例子与上面的一样，但用 ng-show 替代了 ng-hide：
+<div ng-app="myApp" ng-controller="personCtrl">
+
+<button ng-click="toggle()">Toggle</button>
+
+<p ng-show="myVar">
+First Name: <input type="text" ng-model="firstName"><br>
+Last Name: <input type="text" ng-model="lastName"><br>
+<br>
+Full Name: {{firstName + " " + lastName}}
+</p>
+
+</div>
+
+<script>
+var app = angular.module('myApp', []);
+app.controller('personCtrl', function($scope) {
+    $scope.firstName = "John",
+    $scope.lastName = "Doe"
+    $scope.myVar = true;
+    $scope.toggle = function() {
+        $scope.myVar = !$scope.myVar;
+    }
+});
+</script>
+
+///////////////////////////////////
+// AngularJS 模块
+
+// 一个 AngularJS 模块定义一个应用。
+// 模块是一个应用的不同部分所在的一个容器。
+// 模块是应用控制器的一个容器。
+// 控制器总是隶属于一个模块。
+
+// 这个应用 ("myApp") 有一个控制器 ("myCtrl")：
+
+<!DOCTYPE html>
+<html>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+<body>
+
+<div ng-app="myApp" ng-controller="myCtrl">
+{{ firstName + " " + lastName }}
+</div>
+
+<script>
+var app = angular.module("myApp", []);
+app.controller("myCtrl", function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+});
+</script>
+
+</body>
+</html>
+
+// 在 AngularJS 应用中通常将模块和控制器放置在 JavaScript 文件中。
+// 在本例中，"myApp.js" 包含了一个应用模块的定义，而 "myCtrl.js" 包含了控制器：
+
+<!DOCTYPE html>
+<html>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+<body>
+
+<div ng-app="myApp" ng-controller="myCtrl">
+{{ firstName + " " + lastName }}
+</div>
+
+<script src="myApp.js"></script>
+<script src="myCtrl.js"></script>
+
+</body>
+</html>
+
+//myApp.js
+var app = angular.module("myApp", []); 
+
+// 模块定义中的 [] 参数可用来定义依赖的模块。
+
+// myCtrl.js
+app.controller("myCtrl", function($scope) {
+    $scope.firstName  = "John";
+    $scope.lastName= "Doe";
+});
+
+// JavaScript 中应该避免使用全局函数。它们会非常容易地被覆盖
+// 或被其它脚本破坏。
+
+// AngularJS 脚本通过将所有函数保存在模块内，缓解了这种问题。
+
+// 虽然 HTML 应用中通常是将脚本放置在
+// <body> 元素的末尾，但还是推荐你要么在
+// <head> 中要么在 <body> 的开头处加载 AngularJS 库。
+
+// 这是因为对 angular.module 的调用只有在库被加载后才能被编译。
+
+<!DOCTYPE html>
+<html>
+<body>
+<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
+
+<div ng-app="myApp" ng-controller="myCtrl">
+{{ firstName + " " + lastName }}
+</div>
+
+<script>
+var app = angular.module("myApp", []);
+app.controller("myCtrl", function($scope) {
+    $scope.firstName = "John";
+    $scope.lastName = "Doe";
+});
+</script>
+
+</body>
+</html>
+
+
+///////////////////////////////////
+// AngularJS 应用
+
+// AngularJS 模块定义 AngularJS 应用。
+// AngularJS 控制器控制 AngularJS 应用。
+// ng-app 指令定义该应用，ng-controller 定义该控制器。
+<div ng-app="myApp" ng-controller="myCtrl">
+  First Name: <input type="text" ng-model="firstName"><br>
+  Last Name: <input type="text" ng-model="lastName"><br>
+  <br>
+  Full Name: {{firstName + " " + lastName}}
+</div>
+<script>
+  var app = angular.module('myApp', []);
+  app.controller('myCtrl', function($scope) {
+      $scope.firstName= "John";
+      $scope.lastName= "Doe";
+  });
+</script>
+
+// AngularJS 模块定义应用：
+var app = angular.module('myApp', []);
+
+// AngularJS 控制器控制应用：
+app.controller('myCtrl', function($scope) {
+    $scope.firstName= "John";
+    $scope.lastName= "Doe";
+});
+```
+
+## 来源 & 参考
+
+**例子**
+
+- http://www.w3schools.com/angular/angular_examples.asp
+
+**参考**
+
+- http://www.w3schools.com/angular/angular_ref_directives.asp
+- http://www.w3schools.com/angular/default.asp
diff --git a/zh-cn/brainfuck-cn.html.markdown b/zh-cn/bf-cn.html.markdown
index a6f3fa09..6cea3012 100644
--- a/zh-cn/brainfuck-cn.html.markdown
+++ b/zh-cn/bf-cn.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: brainfuck
+language: bf
 lang: zh-cn
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
diff --git a/zh-cn/c++-cn.html.markdown b/zh-cn/c++-cn.html.markdown
index e1551e2b..87951bc3 100644
--- a/zh-cn/c++-cn.html.markdown
+++ b/zh-cn/c++-cn.html.markdown
@@ -188,7 +188,7 @@ int main()
    cout << "Your favorite number is " << myInt << "\n";

    // 显示“Your favorite number is <myInt>”

 

-    cerr << "Used for error messages";

+   cerr << "Used for error messages";

 }

 

 /////////

@@ -315,14 +315,14 @@ void Dog::print() const
 

 void Dog::~Dog()

 {

-    cout << "Goodbye " << name << "\n";

+    std::cout << "Goodbye " << name << "\n";

 }

 

 int main() {

     Dog myDog; // 此时显示“A dog has been constructed”

     myDog.setName("Barkley");

     myDog.setWeight(10);

-    myDog.printDog(); // 显示“Dog is Barkley and weighs 10 kg”

+    myDog.print(); // 显示“Dog is Barkley and weighs 10 kg”

     return 0;

 } // 显示“Goodbye Barkley”

 

diff --git a/zh-cn/common-lisp-cn.html.markdown b/zh-cn/common-lisp-cn.html.markdown
index b82829a9..b8979ed0 100644
--- a/zh-cn/common-lisp-cn.html.markdown
+++ b/zh-cn/common-lisp-cn.html.markdown
@@ -14,6 +14,8 @@ ANSI Common Lisp 是一个广泛通用于各个工业领域的、支持多种范
 
 免费的经典的入门书籍[《实用 Common Lisp 编程》](http://www.gigamonkeys.com/book/)
 
+许多人都抱怨上面这本书的翻译。[《ANSI Common Lisp》](http://acl.readthedocs.org/en/latest/)也许对中文读者更友好一些。
+
 另外还有一本热门的近期出版的
 [Land of Lisp](http://landoflisp.com/).
 
@@ -287,7 +289,7 @@ nil                  ; 逻辑假，或者空列表
 ;; （通过键）检索对应的值
 (gethash 'a *m*) ; => 1, t
 
-;; 注意此处有一细节：Common Lisp往往返回多个值。`gethash`返回的两个值是t，代表找到了这个元素；返回nil表示没有找到这个元素。
+;; 注意此处有一细节：Common Lisp往往返回多个值。`gethash`返回的第二个值是t，代表找到了这个元素；返回nil表示没有找到这个元素。
 ;;（译者注：返回的第一个值表示给定的键所对应的值或者nil；）
 ;;（第二个是一个布尔值，表示在哈希表中是否存在这个给定的键）
 ;; 例如，如果可以找到给定的键所对应的值，则返回一个t，否则返回nil
diff --git a/zh-cn/dynamic-programming-cn.html.markdown b/zh-cn/dynamic-programming-cn.html.markdown
new file mode 100644
index 00000000..b75c5404
--- /dev/null
+++ b/zh-cn/dynamic-programming-cn.html.markdown
@@ -0,0 +1,57 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+filename: dynamic-programming-cn.html.markdown
+lang: zh-cn
+translators:
+   - ["EtaoinWu", "https://github.com/EtaoinWu"]
+---
+
+# 动态规划
+
+## 简介
+
+动态规划是一种实用的技巧，它可以用来解决一系列特定问题。它的思路很简单，如果你对某个给定的输入解决了一个问题，那么你可以保存已有信息，以避免重复计算，节约计算时间。
+
+记住，只有那些没有办法记住历史的才被迫做更多的苦力。(Fibonacci就是一个显然的例子)
+
+## 解决问题的方式
+
+1. *自顶向下* : 利用分支策略分解问题。如果你已经解决过当前子问题了，那么就返回已有信息。如果当前子问题没有计算过，那么就对它进行计算。这样的方法很易于思考、很直观。这被称作“记忆化”。
+
+2. *自底向上* : 首先分析问题，将问题分解为不同规模的问题，并决定它们的顺序，按顺序计算，直到解决给定规模的问题。这样的流程可以保证在解决较大的问题之前解决（它所依赖的）较小的问题。这种流程被称作“动态规划”。
+
+## 动态规划的例子
+
+最长上升子序列问题。给定`S= {a[1] , a[2] , a[3], a[4], ............., a[n-1], a[n] }`，求出一个子序列，使得对于所有在这个子序列中所有满足`j<i`的`j`与`i`，满足`aj<ai`。首先我们要讨论以原序列的第`i`个元素结尾的最长上升子序列`dp[i]`。那么答案是整个dp序列的最大值。考虑`dp[i]`，它的最后一个元素为`a[i]`。枚举它的倒数第二个元素`a[j]`，则`a[j]<a[i]`成立。则`dp[i]`就是所有这样的`dp[j]`的最大值加上1(最后一个元素)。这个算法具有*O(n^2)*的时间复杂度。
+
+此算法的伪代码：
+
+```python
+for i=0 to n-1
+    dp[i]=0
+    for j=0 to i-1
+        if (a[i] >  a[j] and dp[i]<dp[j])
+            LS[i] = LS[j]
+	dp[i]=dp[i]+1
+for i=0 to n-1
+    if (largest < dp[i])
+		largest = dp[i]
+```
+
+这个算法的复杂度可以通过将数组换为其他数据结构来优化，来获得*O(n * log n)*的时间复杂度。
+
+同样的思路可以求出有向无环图上的最大路径。
+
+### 一些著名的动态规划问题及其实现
+
+- Floyd Warshall 算法 - [教程与C实现源码](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
+- 整数背包问题 - [教程与C实现源码](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- 最长公共子序列问题 - [教程与C实现源码](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
+
+## 在线资源
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
+* [洛谷](https://www.luogu.org/problem/lists?name=&orderitem=pid&tag=3)
diff --git a/zh-cn/go-cn.html.markdown b/zh-cn/go-cn.html.markdown
index 49224085..75498367 100644
--- a/zh-cn/go-cn.html.markdown
+++ b/zh-cn/go-cn.html.markdown
@@ -6,7 +6,8 @@ contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
     - ["pantaovay", "https://github.com/pantaovay"]
     - ["lidashuang", "https://github.com/lidashuang"]
-    
+    - ["Tim Zhang", "https://github.com/ttimasdf"]
+
 ---
 
 发明Go语言是出于更好地完成工作的需要。Go不是计算机科学的最新发展潮流，但它却提供了解决现实问题的最新最快的方法。
@@ -27,7 +28,10 @@ package main
 // Import语句声明了当前文件引用的包。
 import (
     "fmt"       // Go语言标准库中的包
+    "io/ioutil" // 包含一些输入输出函数
+    m "math"    // 数学标准库，在此文件中别名为m
     "net/http"  // 一个web服务器包
+    "os"        // 系统底层函数，如文件读写
     "strconv"   // 字符串转换
 )
 
@@ -36,7 +40,7 @@ import (
 func main() {
     // 往标准输出打印一行。
     // 用包名fmt限制打印函数。
-    fmt.Println("Hello world!")
+    fmt.Println("天坑欢迎你!")
 
     // 调用当前包的另一个函数。
     beyondHello()
@@ -54,7 +58,11 @@ func beyondHello() {
     learnTypes()                            // 少于y分钟，学的更多！
 }
 
-// 多变量和多返回值的函数
+/* <- 快看快看我是跨行注释_(:з」∠)_
+Go语言的函数可以有多个参数和 *多个* 返回值。
+在这个函数中， `x`、`y` 是参数，
+`sum`、`prod` 是返回值的标识符（可以理解为名字）且类型为int
+*/
 func learnMultiple(x, y int) (sum, prod int) {
     return x + y, x * y // 返回两个值
 }
@@ -62,11 +70,11 @@ func learnMultiple(x, y int) (sum, prod int) {
 // 内置变量类型和关键词
 func learnTypes() {
     // 短声明给你所想。
-    s := "Learn Go!" // String类型
+    str := "少说话多读书!" // String类型
+
+    s2 := `这是一个
+可以换行的字符串` // 同样是String类型
 
-    s2 := `A "raw" string literal
-can include line breaks.` // 同样是String类型
-    
     // 非ascii字符。Go使用UTF-8编码。
     g := 'Σ' // rune类型，int32的别名，使用UTF-8编码
 
@@ -80,16 +88,29 @@ can include line breaks.` // 同样是String类型
     // 字符转换
     n := byte('\n') // byte是uint8的别名
 
-    // 数组类型编译的时候大小固定。
+    // 数组（Array）类型的大小在编译时即确定
     var a4 [4] int              // 有4个int变量的数组，初始为0
     a3 := [...]int{3, 1, 5}     // 有3个int变量的数组，同时进行了初始化
 
-    // Slice 可以动态的增删。Array和Slice各有千秋，但是使用slice的地方更多些。
-    s3 := []int{4, 5, 9}        // 和a3相比，这里没有省略号
-    s4 := make([]int, 4)        // 分配一个有4个int型变量的slice，全部被初始化为0
-
-    var d2 [][]float64          // 声明而已，什么都没有分配
-    bs := []byte("a slice")     // 类型转换的语法
+    // Array和slice各有所长，但是slice可以动态的增删，所以更多时候还是使用slice。
+    s3 := []int{4, 5, 9}    // 回去看看 a3 ，是不是这里没有省略号？
+    s4 := make([]int, 4)    // 分配4个int大小的内存并初始化为0
+    var d2 [][]float64      // 这里只是声明，并未分配内存空间
+    bs := []byte("a slice") // 进行类型转换
+
+    // 切片（Slice）的大小是动态的，它的长度可以按需增长
+    // 用内置函数 append() 向切片末尾添加元素
+    // 要增添到的目标是 append 函数第一个参数，
+    // 多数时候数组在原内存处顺次增长，如
+    s := []int{1, 2, 3}     // 这是个长度3的slice
+    s = append(s, 4, 5, 6)  // 再加仨元素，长度变为6了
+    fmt.Println(s) // 更新后的数组是 [1 2 3 4 5 6]
+
+    // 除了向append()提供一组原子元素（写死在代码里的）以外，我们
+    // 还可以用如下方法传递一个slice常量或变量，并在后面加上省略号，
+    // 用以表示我们将引用一个slice、解包其中的元素并将其添加到s数组末尾。
+    s = append(s, []int{7, 8, 9}...) // 第二个参数是一个slice常量
+    fmt.Println(s)  // 更新后的数组是 [1 2 3 4 5 6 7 8 9]
 
     p, q := learnMemory()       // 声明p,q为int型变量的指针
     fmt.Println(*p, *q)         // * 取值
@@ -100,13 +121,28 @@ can include line breaks.` // 同样是String类型
 
     // 在Go语言中未使用的变量在编译的时候会报错，而不是warning。
     // 下划线 _ 可以使你“使用”一个变量，但是丢弃它的值。
-    _,_,_,_,_,_,_,_,_ = s2, g, f, u, pi, n, a3, s4, bs
+    _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+    // 通常的用法是，在调用拥有多个返回值的函数时，
+    // 用下划线抛弃其中的一个参数。下面的例子就是一个脏套路，
+    // 调用os.Create并用下划线变量扔掉它的错误代码。
+    // 因为我们觉得这个文件一定会成功创建。
+    file, _ := os.Create("output.txt")
+    fmt.Fprint(file, "这句代码还示范了如何写入文件呢")
+    file.Close()
+
     // 输出变量
     fmt.Println(s, c, a4, s3, d2, m)
 
-    learnFlowControl() // 回到流程控制 
+    learnFlowControl() // 回到流程控制
 }
 
+// 和其他编程语言不同的是，go支持有名称的变量返回值。
+// 声明返回值时带上一个名字允许我们在函数内的不同位置
+// 只用写return一个词就能将函数内指定名称的变量返回
+func learnNamedReturns(x, y int) (z int) {
+    z = x * y
+    return // z is implicit here, because we named it earlier.
+
 // Go全面支持垃圾回收。Go有指针，但是不支持指针运算。
 // 你会因为空指针而犯错，但是不会因为增加指针而犯错。
 func learnMemory() (p, q *int) {
@@ -126,10 +162,10 @@ func expensiveComputation() int {
 func learnFlowControl() {
     // If需要花括号，括号就免了
     if true {
-        fmt.Println("told ya")
+        fmt.Println("这句话肯定被执行")
     }
     // 用go fmt 命令可以帮你格式化代码，所以不用怕被人吐槽代码风格了，
-    // 也不用容忍被人的代码风格。
+    // 也不用容忍别人的代码风格。
     if false {
         // pout
     } else {
@@ -146,15 +182,28 @@ func learnFlowControl() {
     }
     // 和if一样，for也不用括号
     for x := 0; x < 3; x++ { // ++ 自增
-        fmt.Println("iteration", x)
+        fmt.Println("遍历", x)
     }
     // x在这里还是1。为什么？
 
     // for 是go里唯一的循环关键字，不过它有很多变种
     for { // 死循环
-        break    // 骗你的 
+        break    // 骗你的
         continue // 不会运行的
     }
+
+    // 用range可以枚举 array、slice、string、map、channel等不同类型
+    // 对于channel，range返回一个值，
+    // array、slice、string、map等其他类型返回一对儿
+    for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
+        // 打印map中的每一个键值对
+        fmt.Printf("索引：%s, 值为：%d\n", key, value)
+    }
+    // 如果你只想要值，那就用前面讲的下划线扔掉没用的
+    for _, name := range []string{"Bob", "Bill", "Joe"} {
+        fmt.Printf("你是。。 %s\n", name)
+    }
+
     // 和for一样，if中的:=先给y赋值，然后再和x作比较。
     if y := expensiveComputation(); y > x {
         x = y
@@ -163,17 +212,55 @@ func learnFlowControl() {
     xBig := func() bool {
         return x > 100 // x是上面声明的变量引用
     }
-    fmt.Println("xBig:", xBig()) // true （上面把y赋给x了） 
+    fmt.Println("xBig:", xBig()) // true （上面把y赋给x了）
     x /= 1e5                     // x变成10
     fmt.Println("xBig:", xBig()) // 现在是false
 
+    // 除此之外，函数体可以在其他函数中定义并调用，
+    // 满足下列条件时，也可以作为参数传递给其他函数：
+    //   a) 定义的函数被立即调用
+    //   b) 函数返回值符合调用者对类型的要求
+    fmt.Println("两数相加乘二: ",
+        func(a, b int) int {
+            return (a + b) * 2
+        }(10, 2)) // Called with args 10 and 2
+    // => Add + double two numbers: 24
+
     // 当你需要goto的时候，你会爱死它的！
     goto love
 love:
 
+    learnFunctionFactory() // 返回函数的函数多棒啊
+    learnDefer()      // 对defer关键字的简单介绍
     learnInterfaces() // 好东西来了！
 }
 
+func learnFunctionFactory() {
+    // 空行分割的两个写法是相同的，不过第二个写法比较实用
+    fmt.Println(sentenceFactory("原谅")("当然选择", "她！"))
+
+    d := sentenceFactory("原谅")
+    fmt.Println(d("当然选择", "她！"))
+    fmt.Println(d("你怎么可以", "她？"))
+}
+
+// Decorator在一些语言中很常见，在go语言中，
+// 接受参数作为其定义的一部分的函数是修饰符的替代品
+func sentenceFactory(mystring string) func(before, after string) string {
+    return func(before, after string) string {
+        return fmt.Sprintf("%s %s %s", before, mystring, after) // new string
+    }
+}
+
+func learnDefer() (ok bool) {
+    // defer表达式在函数返回的前一刻执行
+    defer fmt.Println("defer表达式执行顺序为后进先出（LIFO）")
+    defer fmt.Println("\n这句话比上句话先输出，因为")
+    // 关于defer的用法，例如用defer关闭一个文件，
+    // 就可以让关闭操作与打开操作的代码更近一些
+    return true
+}
+
 // 定义Stringer为一个接口类型，有一个方法String
 type Stringer interface {
     String() string
@@ -194,9 +281,9 @@ func (p pair) String() string { // p被叫做“接收器”
 func learnInterfaces() {
     // 花括号用来定义结构体变量，:=在这里将一个结构体变量赋值给p。
     p := pair{3, 4}
-    fmt.Println(p.String()) // 调用pair类型p的String方法 
-    var i Stringer          // 声明i为Stringer接口类型 
-    i = p                   // 有效！因为p实现了Stringer接口（类似java中的塑型） 
+    fmt.Println(p.String()) // 调用pair类型p的String方法
+    var i Stringer          // 声明i为Stringer接口类型
+    i = p                   // 有效！因为p实现了Stringer接口（类似java中的塑型）
     // 调用i的String方法，输出和上面一样
     fmt.Println(i.String())
 
@@ -205,14 +292,28 @@ func learnInterfaces() {
     fmt.Println(p) // 输出和上面一样，自动调用String函数。
     fmt.Println(i) // 输出和上面一样。
 
+    learnVariadicParams("great", "learning", "here!")
+}
+
+// 有变长参数列表的函数
+func learnVariadicParams(myStrings ...interface{}) {
+    // 枚举变长参数列表的每个参数值
+    // 下划线在这里用来抛弃枚举时返回的数组索引值
+    for _, param := range myStrings {
+        fmt.Println("param:", param)
+    }
+
+    // 将可变参数列表作为其他函数的参数列表
+    fmt.Println("params:", fmt.Sprintln(myStrings...))
+
     learnErrorHandling()
 }
 
 func learnErrorHandling() {
-    // ", ok"用来判断有没有正常工作 
+    // ", ok"用来判断有没有正常工作
     m := map[int]string{3: "three", 4: "four"}
     if x, ok := m[1]; !ok { // ok 为false，因为m中没有1
-        fmt.Println("no one there")
+        fmt.Println("别找了真没有")
     } else {
         fmt.Print(x) // 如果x在map中的话，x就是那个值喽。
     }
@@ -245,17 +346,17 @@ func learnConcurrency() {
 
     cs := make(chan string)       // 操作string的channel
     cc := make(chan chan string)  // 操作channel的channel
-    go func() { c <- 84 }()       // 开始一个goroutine来发送一个新的数字 
+    go func() { c <- 84 }()       // 开始一个goroutine来发送一个新的数字
     go func() { cs <- "wordy" }() // 发送给cs
     // Select类似于switch，但是每个case包括一个channel操作。
     // 它随机选择一个准备好通讯的case。
     select {
     case i := <-c: // 从channel接收的值可以赋给其他变量
-        fmt.Println("it's a", i)
+        fmt.Println("这是……", i)
     case <-cs: // 或者直接丢弃
-        fmt.Println("it's a string")
-    case <-cc: // 空的，还没作好通讯的准备 
-        fmt.Println("didn't happen.")
+        fmt.Println("这是个字符串！")
+    case <-cc: // 空的，还没作好通讯的准备
+        fmt.Println("别瞎想")
     }
     // 上面c或者cs的值被取到，其中一个goroutine结束，另外一个一直阻塞。
 
@@ -265,22 +366,43 @@ func learnConcurrency() {
 // http包中的一个简单的函数就可以开启web服务器。
 func learnWebProgramming() {
     // ListenAndServe第一个参数指定了监听端口，第二个参数是一个接口，特定是http.Handler。
-    err := http.ListenAndServe(":8080", pair{})
-    fmt.Println(err) // 不要无视错误。
+    go func() {
+        err := http.ListenAndServe(":8080", pair{})
+        fmt.Println(err) // 不要无视错误。
+    }()
+
+    requestServer()
 }
 
 // 使pair实现http.Handler接口的ServeHTTP方法。
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     // 使用http.ResponseWriter返回数据
-    w.Write([]byte("You learned Go in Y minutes!"))
+    w.Write([]byte("Y分钟golang速成!"))
+}
+
+func requestServer() {
+    resp, err := http.Get("http://localhost:8080")
+    fmt.Println(err)
+    defer resp.Body.Close()
+    body, err := ioutil.ReadAll(resp.Body)
+    fmt.Printf("\n服务器消息： `%s`", string(body))
 }
 ```
 
 ## 更进一步
 
-Go的根源在[Go官方网站](http://golang.org/)。
-在那里你可以学习入门教程，通过浏览器交互式地学习，而且可以读到很多东西。
+关于Go的一切你都可以在[Go官方网站](http://golang.org/)找到。
+在那里你可以获得教程参考，在线试用，和更多的资料。
+在简单的尝试过后，在[官方文档](https://golang.org/doc/)那里你会得到你所需要的所有资料、关于编写代码的规范、库和命令行工具的文档与Go的版本历史。
 
-强烈推荐阅读语言定义部分，很简单而且很简洁！(as language definitions go these days.)
+强烈推荐阅读语言定义部分，很简单而且很简洁！（赶时髦！）
+
+你还可以前往[Go在线体验中心](https://play.golang.org/p/tnWMjr16Mm)进，在浏览器里修改并运行这些代码，一定要试一试哦！你可以将[https://play.golang.org](https://play.golang.org)当作一个[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop)，在那里体验语言特性或运行自己的代码，连环境都不用配！
 
 学习Go还要阅读Go[标准库的源代码](http://golang.org/src/)，全部文档化了，可读性非常好，可以学到go，go style和go idioms。在[文档](http://golang.org/pkg/)中点击函数名，源代码就出来了！
+
+[Go by example](https://gobyexample.com/)也是一个学习的好地方。
+
+
+
+Go Mobile添加了对移动平台的支持（Android and iOS）。你可以完全用go语言来创造一个app或编写一个可以从Java或Obj-C调用的函数库，敬请参考[Go Mobile page](https://github.com/golang/go/wiki/Mobile)。
diff --git a/zh-cn/haskell-cn.html.markdown b/zh-cn/haskell-cn.html.markdown
index b0b1183f..c854169e 100644
--- a/zh-cn/haskell-cn.html.markdown
+++ b/zh-cn/haskell-cn.html.markdown
@@ -66,7 +66,7 @@ not False -- True
 
 
 ----------------------------------------------------
--- 列表和元组
+-- 2. 列表和元组
 ----------------------------------------------------
 
 -- 一个列表中的每一个元素都必须是相同的类型。
diff --git a/zh-cn/html-cn.html.markdown b/zh-cn/html-cn.html.markdown
new file mode 100644
index 00000000..6f60d5ce
--- /dev/null
+++ b/zh-cn/html-cn.html.markdown
@@ -0,0 +1,121 @@
+---
+language: html
+filename: learnhtml-cn.html
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["zxyqwe", "https://github.com/zxyqwe"]
+lang: zh-cn
+---
+
+HTML是超文本标记语言的缩写。
+这门语言可以让我们为万维网创造页面。
+这是一门标记语言，它允许我们用代码来指示网页上文字和数据应该如何显示。
+实际上html文件是简单的文本文件。
+什么是标记？标记是通过使用开始和结束标签包围数据的方法，来组织管理页面上的数据。
+这些标记对它们环绕的文本有重要的意义。
+和其它计算机语言意义，HTML有很多版本。这里我们将讨论HTML5。
+
+**注意：**  你可以在类似[codepen](http://codepen.io/pen/)的网站上的教程中，尝试不同的标签和元素带来的效果，理解它们如何起效，并且逐渐熟悉这门语言。
+本文主要关注HTML的语法和一些有用的小窍门。
+
+
+```html
+<!-- 注释要像本行一样被包围起来！ -->
+
+<!-- #################### 标签 #################### -->
+   
+<!-- 下面是一个我们将要分析的HTML文件的例子。 -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>我的网站</title>
+		</head>
+		<body>
+			<h1>Hello, world!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">来看看这里有什么</a>
+			<p>这是一个段落。</p>
+			<p>这是另外一个段落。</p>
+			<ul>
+				<li>这是一个非计数列表的一项（项目符合列表）</li>
+				<li>这是另一项</li>
+				<li>这是列表中的最后一项</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- 一个HTML文件通常开始于向浏览器表明本页面是HTML。 -->
+<!doctype html>
+
+<!-- 在这之后，由<html>开始标签作为起始。 -->
+<html>
+
+<!-- 在文件的最后会由</html>标签结束。 -->
+</html>
+
+<!-- 在最终的标签后面应该没有任何东西。 -->
+
+<!-- 在其中（在开始标签<html>和结束标签</html>中间）我们可以看到： -->
+
+<!-- 由标签<head>定义的头部 （头部必须被</head>标签关闭）。 -->
+<!-- 头部包含一些不显示的描述和额外信息；这些是元数据。 -->
+
+<head>
+	<title>我的网站</title><!-- <title>标签告诉浏览器在浏览器窗口的标题区和标签栏应该显示什么标题。 -->
+</head>
+
+<!-- 在<head>区域之后，我们可以看到<body>标签 -->
+<!-- 在这点之前的内容都不会显示在浏览器的窗口中。 -->
+<!-- 我们必须在正文区填上需要显示的内容。 -->
+
+<body>
+	<h1>Hello, world!</h1> <!-- h1标签创建了一个标题 -->
+	<!-- <h1>标签可以有一些副标题，从最重要的（h2）到最细微的（h6）。 -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">来看看这里有什么</a> <!-- 一个指向href=""属性中URL的超链接 -->
+	<p>这是一个段落。</p> <!-- <p>标签让我们在html页面中显示文字 -->
+	<p>这是另外一个段落。</p>
+	<ul> <!-- <ul>标签创建了一个项目符合列表。 -->
+	<!-- 如果需要一个编号列表，我们可以使用<ol>标签。这样会在在第一项前显示1.，第二项前显示2.，以此类推。 -->
+		<li>这是一个非计数列表的一项（项目符合列表）</li>
+		<li>这是另一项</li>
+		<li>这是列表中的最后一项</li>
+	</ul>
+</body>
+
+<!-- 好了，创建一个HTML文件就是这么简单。 -->
+
+<!-- 当然我们还可以加入很多额外的HTML标签类型。 -->
+
+<!-- 插入图片。 -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- 图片源是由src=""属性指明的 -->
+<!-- 图片源可以是一个URL或者你电脑上一个文件的路径。 -->
+
+<!-- 创建表格也没问题。 -->
+
+<table> <!-- 我们开始一个<table>元素 -->
+	<tr> <!-- <tr>让我们创建一行 -->
+		<th>第一个表头</th> <!-- <th>让我们给表格列一个标题 -->
+		<th>第二个表头</th>
+	</tr>
+	<tr>
+		<td>第一行第一列</td> <!-- <td>让我们创建一个单元格 -->
+		<td>第一行第二列</td>
+	</tr>
+	<tr>
+		<td>第二行第一列</td>
+		<td>第二行第二列</td>
+	</tr>
+</table>
+
+```
+
+## 使用
+
+HTML文件使用`.html`后缀。
+
+## 扩展阅读
+
+* [维基百科](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/zh-cn/java-cn.html.markdown b/zh-cn/java-cn.html.markdown
index 1e9c38f6..27003f3e 100644
--- a/zh-cn/java-cn.html.markdown
+++ b/zh-cn/java-cn.html.markdown
@@ -108,7 +108,7 @@ public class LearnJava {
         boolean [] booleanArray = new boolean[100];
 
         // 声明并初始化数组也可以这样:
-        int [] y = {9000, 1000, 1337};
+        int [] intArray = {9000, 1000, 1337};
 
         // 随机访问数组中的元素
         System.out.println("intArray @ 0: " + intArray[0]);
@@ -309,7 +309,7 @@ class Bicycle {
         name = "Bontrager";
     }
 
-    // 一下是一个含有参数的构造函数
+    // 以下是一个含有参数的构造函数
     public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
         this.gear = startGear;
         this.cadence = startCadence;
diff --git a/zh-cn/jquery-cn.html.markdown b/zh-cn/jquery-cn.html.markdown
new file mode 100644
index 00000000..4b23274e
--- /dev/null
+++ b/zh-cn/jquery-cn.html.markdown
@@ -0,0 +1,131 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+    - ["zxyqwe", "https://github.com/zxyqwe"]
+lang: zh-cn
+filename: jquery-cn.js
+---
+
+jQuery是JavaScript的一个函数库，它可以帮你“写更少，做更多”。它集成了很多常见的JavaScript任务并且很容易调用。jQuery被世界各地的很多的大公司和开发者使用。它包括了AJAX，事件处理，文档操作以及很多其它功能，并且更加简单和快速。
+
+正因为jQuery是JavaScript的一个函数库，所以你需要[首先学习JavaScript](https://learnxinyminutes.com/docs/javascript/)
+
+```js
+
+
+///////////////////////////////////
+// 1. 选择器
+
+// jQuery中的选择器被用来选择一个元素
+var page = $(window); // 选择整个视窗
+
+// 选择器可以作为CSS选择器使用
+var paragraph = $('p'); // 选择所有段落元素
+var table1 = $('#table1'); // 选择id为table1的元素
+var squares = $('.square'); // 选择所有类是square的元素
+var square_p = $('p.square') // 选择具有square类的所有段落
+
+
+///////////////////////////////////
+// 2. 事件和效果
+// jQuery非常善于处理当事件触发的时候应该做什么
+// 一个非常常见的事件就是文档的就绪事件
+// 你可以用ready方法，在所有元素完成加载的时候执行
+$(document).ready(function(){
+  // 只有文档加载完成以后代码才会执行
+});
+// 你也可以用定义了的函数
+function onAction() {
+  // 本函数在事件触发的时候被执行
+}
+$('#btn').click(onAction); // 当点击的时候调用onAction函数
+
+// 其它常见的事件：
+$('#btn').dblclick(onAction); // 双击
+$('#btn').hover(onAction); // 划过
+$('#btn').focus(onAction); // 聚焦
+$('#btn').blur(onAction); // 失焦
+$('#btn').submit(onAction); // 提交
+$('#btn').select(onAction); // 当元素被选中
+$('#btn').keydown(onAction); // 当一个按键被按下
+$('#btn').keyup(onAction); // 当一个按键被抬起
+$('#btn').keypress(onAction); // 当一个按键被按住
+$('#btn').mousemove(onAction); // 当鼠标在移动
+$('#btn').mouseenter(onAction); // 鼠标移入元素
+$('#btn').mouseleave(onAction); // 鼠标离开元素
+
+
+// 如果不提供任何参数的话，那么这些方法可以触发事件
+// 而不是定义处理事件的方法
+$('#btn').dblclick(); // 触发元素上的双击
+
+// 你可以只用选择器一次而处理多个事件
+$('#btn').on(
+  {dblclick: myFunction1} // 双击的时候触发
+  {blur: myFunction1} // 失焦的时候触发
+);
+
+// 你可以用一些效果函数来移动或隐藏元素
+$('.table').hide(); // 隐藏元素
+
+// 注意：在这些方法中调用函数会仍然隐藏元素
+$('.table').hide(function(){
+    // 元素先隐藏然后函数被执行
+});
+
+// 你可以在变量中储存选择器
+var tables = $('.table');
+
+// 一些基本的文档操作方法有：
+tables.hide(); // 隐藏元素
+tables.show(); // 显示元素
+tables.toggle(); // 对被选元素进行隐藏和显示的切换
+tables.fadeOut(); // 淡出
+tables.fadeIn(); // 淡入
+tables.fadeToggle(); // 对被选元素进行淡入和淡出显示的切换
+tables.fadeTo(0.5); // 把被选元素逐渐改变至给定的不透明度（0和1之间）
+tables.slideUp(); // 通过调整高度来滑动隐藏被选元素
+tables.slideDown(); // 对被选元素进行滑动隐藏和滑动显示的切换
+tables.slideToggle(); // 对被选元素进行滑动隐藏和滑动显示的切换
+
+// 上面所有的方法接受速度参数（毫秒）和一个回调函数
+tables.hide(1000, myFunction); // 持续一秒的隐藏动画然后执行函数
+
+// fadeTo要求提供透明度参数作为第二个参数
+tables.fadeTo(2000, 0.1, myFunction); // 通过2秒钟将透明度变为0.1然后执行函数
+
+// 你可以用animate方法实现一些略微高级的效果
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// animate方法接受一个包含CSS和值的对象作为目标，
+// 其次是可选的速度参数，
+// 以及最后的回调函数
+
+///////////////////////////////////
+// 3. 操作
+
+// 这些类似效果函数但是可以做更多
+$('div').addClass('taming-slim-20'); // 给所有div添加类taming-slim-20
+
+// 常见操作方法
+$('p').append('Hello world'); // 添加到元素末尾
+$('p').attr('class'); // 获取属性
+$('p').attr('class', 'content'); // 设置属性
+$('p').hasClass('taming-slim-20'); // 如果有类则为真
+$('p').height(); // 获取和设置元素的高度
+
+
+// 对于很多的操作函数来说，获取元素的信息
+// 仅仅是第一个符合元素的
+$('p').height(); // 仅仅获取第一个p标签的高度
+
+// 你可以用each来迭代所有元素
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // 把所有p标签的高度加入数组
+});
+
+
+```
diff --git a/zh-cn/json-cn.html.markdown b/zh-cn/json-cn.html.markdown
index 3a8db2cf..73d3eb57 100644
--- a/zh-cn/json-cn.html.markdown
+++ b/zh-cn/json-cn.html.markdown
@@ -8,12 +8,21 @@ filename: learnjson-cn.json
 lang: zh-cn
 ---
 
-因为JSON是一个极其简单的数据交换形式，这个最有可能将会是曾经最简单
-的Learn X in Y Minutes。
+因为JSON是一个极其简单的数据交换格式，本教程最有可能成为有史以来最简单的
+Learn X in Y Minutes。
 
-最纯正形式的JSON没有实际的注解，但是大多数解析器将会
-接受C-风格(//, /\* \*/)的注解。为了这个目的，但是，
-一切都将会是100%有效的JSON。幸亏，它是不言自明的。
+纯正的JSON实际上没有注释，但是大多数解析器都
+接受C-风格(//, /\* \*/)的注释。为了兼容性，最好不要在其中写这样形式的注释。
+
+因此，本教程的一切都会是100%有效的JSON。幸亏，它的表达能力很丰富。
+
+支持的数据类型：
+
+- 字符串: "hello", "\"A quote.\"", "\u0abe", "Newline.\n"
+- 数字: 23, 0.11, 12e10, 3.141e-10, 1.23e+4
+- 对象: { "key": "value" }
+- 数组: ["Values"]
+- 其他: true, false, null
 
 ```json
 {
diff --git a/zh-cn/kotlin-cn.html.markdown b/zh-cn/kotlin-cn.html.markdown
new file mode 100644
index 00000000..5d655029
--- /dev/null
+++ b/zh-cn/kotlin-cn.html.markdown
@@ -0,0 +1,346 @@
+---
+language: kotlin
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators:
+    - ["Jimin Lu", "https://github.com/lujimin"]
+filename: LearnKotlin-cn.kt
+lang: zh-cn
+---
+
+Kotlin是一门适用于JVM、Android和浏览器的静态类型编程语言。它100%兼容Java。
+[了解更多。](https://kotlinlang.org/)
+
+```java
+// 单行注释从 // 开始
+/*
+多行注释看起来像这样。
+*/
+
+// "package" 关键字的工作方式与Java相同。
+package com.learnxinyminutes.kotlin
+
+/*
+Kotlin程序的入口点是一个"main"函数
+该函数传递一个包含任何命令行参数的数组。
+*/
+fun main(args: Array<String>) {
+    /*
+    使用"var"或"val"来声明一个值。
+    "val"声明的值不能被重新赋值，而"var"声明的值可以。
+    */
+    val fooVal = 10 // 以后我们不能再次给fooVal赋值
+    var fooVar = 10
+    fooVar = 20 // fooVar可以被再次赋值
+
+    /*
+    在大多数情况下，Kotlin可以确定变量的类型是什么，
+    所以我们不必要每次都去明确指定它。
+    我们可以像这样明确地声明一个变量的类型：
+    */
+    val foo: Int = 7
+
+    /*
+    可以采取和Java类似的方法来表示一个字符串。
+    用反斜杠来转义字符。
+    */
+    val fooString = "My String Is Here!";
+    val barString = "Printing on a new line?\nNo Problem!";
+    val bazString = "Do you want to add a tab?\tNo Problem!";
+    println(fooString);
+    println(barString);
+    println(bazString);
+
+    /*
+    原始字符串用三重引号(""")来定义。
+    原始字符串可以包含换行符以及其他任何字符。
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Hello, world!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    字符串可以包含模板表达式。
+    模板表达式从一个美元符号($)开始。
+    */
+    val fooTemplateString = "$fooString has ${fooString.length} characters"
+    println(fooTemplateString)
+
+    /*
+    当某个变量的值可以为 null 的时候，我们必须被明确指定它是可为空的。
+    在变量声明处的类型后面加上?来标识它是可为空的。
+    我们可以用?.操作符来访问可为空的变量。
+    我们可以用?:操作符来指定一个在变量为空时使用的替代值。
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    使用"fun"关键字来声明一个函数。
+    函数的参数在函数名后面的括号内指定。
+    函数的参数可以设定一个默认值。
+    如果需要的话，函数的返回值类型可以在参数后面指定。
+    */
+    fun hello(name: String = "world") : String {
+        return "Hello, $name!"
+    }
+    println(hello("foo")) // => Hello, foo!
+    println(hello(name = "bar")) // => Hello, bar!
+    println(hello()) // => Hello, world!
+
+    /*
+    用"vararg"关键字来修饰一个函数的参数来允许可变参数传递给该函数
+    */
+    fun varargExample(vararg names: Int) {
+        println("Argument has ${names.size} elements")
+    }
+    varargExample() // => Argument has 0 elements
+    varargExample(1) // => Argument has 1 elements
+    varargExample(1, 2, 3) // => Argument has 3 elements
+
+    /*
+    当函数只包含一个单独的表达式时，大括号可以被省略。
+    函数体可以被指定在一个=符号后面。
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // 如果返回值类型可以被推断，那么我们不需要指定它。
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // 函数可以用函数作为参数并且可以返回函数。
+    fun not(f: (Int) -> Boolean) : (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // 命名函数可以用::运算符被指定为参数。
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // 匿名函数可以被指定为参数。
+    val notZero = not {n -> n == 0}
+    /*
+    如果一个匿名函数只有一个参数
+    那么它的声明可以被省略（连同->）。
+    这个参数的名字是"it"。
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // "class"关键字用来声明类。
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int) : Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int) : Int {
+            return x * y
+        }
+    }
+    /*
+    我们调用构造方法来创建一个新的实例。
+    注意，Kotlin没有"new"关键字。
+    */
+    val fooExampleClass = ExampleClass(7)
+    // 可以使用一个点号来调用成员函数。
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    如果使用"infix"关键字来标记一个函数
+    那么可以使用中缀表示法来调用该函数。
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    数据类是创建只包含数据的类的一个简洁的方法。
+    "hashCode"、"equals"和"toString"方法将被自动生成。
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // 数据类有一个"copy"函数
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // 对象可以被解构成为多个变量
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+
+    // "with"函数类似于JavaScript中的"with"用法。
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    我们可以使用"listOf"函数来创建一个list。
+    这个list是不可变的 - 元素不可以被添加或删除。
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // 可以通过索引来访问list中的元素。
+    println(fooList[1]) // => b
+
+    // 可以使用"mutableListOf"函数来创建一个可变的list。
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // 我们可以使用"setOf"函数来创建一个set。
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // 我们可以使用"mapOf"函数来创建一个map。
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // 可以通过键来访问map中的值。
+    println(fooMap["a"]) // => 8
+
+    /*
+    序列表示惰性求值集合。
+    我们可以使用"generateSequence"函数来创建一个序列。
+    */
+    val fooSequence = generateSequence(1, {it + 1})
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // 一个用序列来生成斐波那契数列的例子。
+    fun fibonacciSequence() : Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next() : Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin为集合提供高阶函数。
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "even" else "odd"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // 任何提供迭代器的都可以使用"for"循环。
+    for (c in "hello") {
+        println(c)
+    }
+
+    // "while"循环的用法和其他语言一样。
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    // "when"可以用来替代"if-else if"链。
+    val i = 10
+    when {
+        i < 7 -> println("first block")
+        fooString.startsWith("hello") -> println("second block")
+        else -> println("else block")
+    }
+
+    // "when"可以带参数。
+    when (i) {
+        0, 21 -> println("0 or 21")
+        in 1..20 -> println("in the range 1 to 20")
+        else -> println("none of the above")
+    }
+
+    // "when"可以作为一个函数，提供返回值。
+    var result = when (i) {
+        0, 21 -> "0 or 21"
+        in 1..20 -> "in the range 1 to 20"
+        else -> "none of the above"
+    }
+    println(result)
+
+    /*
+    我们可以通过使用"is"操作符来检查一个对象是否是某个类型的。
+    如果对象通过了类型检查那么它可以作为该类型使用而不需要强制转换它。
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x自动转换为Boolean
+            return x
+        } else if (x is Int) {
+            // x自动转换为Int
+            return x > 0
+        } else if (x is String) {
+            // x自动转换为String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hello, world!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    /*
+    扩展是用来给一个类添加新的功能的。
+    它类似于C#的扩展方法。
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hello, world!".remove('l')) // => Heo, word!
+
+    println(EnumExample.A) // => A
+    println(ObjectExample.hello()) // => hello
+}
+
+// 枚举类和Java的枚举类型类似。
+enum class EnumExample {
+    A, B, C
+}
+
+/*
+"object"关键字用来创建单例对象。
+我们不能把它赋给一个变量，但我们可以通过它的名字引用它。
+这类似于Scala的单例对象。
+*/
+object ObjectExample {
+    fun hello() : String {
+        return "hello"
+    }
+}
+
+```
+
+### 进一步阅读
+
+* [Kotlin教程](https://kotlinlang.org/docs/tutorials/)
+* [在您的浏览器中使用Kotlin](http://try.kotlinlang.org/)
+* [Kotlin资源列表](http://kotlin.link/)
diff --git a/zh-cn/latex-cn.html.markdown b/zh-cn/latex-cn.html.markdown
new file mode 100644
index 00000000..83491acd
--- /dev/null
+++ b/zh-cn/latex-cn.html.markdown
@@ -0,0 +1,277 @@
+---
+language: latex
+contributors:
+    - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+    - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"]
+    - ["Svetlana Golubeva", "https://attillax.github.io/"]
+translators:
+    - ["Dp Leo", "https://github.com/minoriwww"]
+filename: learn-latex-cn.tex
+lang: zh-cn
+---
+
+```tex
+% 所有的注释行以 % 开头
+% 没有多行注释语法
+
+% LaTeX 不是一个“所见即所得” 的文字处理软件
+% 这与 MS Word，和 OpenOffice Writer 不同
+
+% 每一个LaTeX命令由反斜线 (\) 开始
+
+% LaTeX 文档以对编译对象文档的定义开始
+% 这些文档包括书籍，报告，演示等
+% 文档的选项出现在中括号里
+% 下例中，我们设定文章字体为12pt
+\documentclass[12pt]{article}
+
+% 之后我们定义该文档所用的库
+% 如果想要引入图片，彩色字，或是其他语言的源码在您的文档中
+% 您需要增强 LaTeX 的功能。这将通过添加库来实现
+% 下例中将要为展示数据引入 float 和 caption 库
+% 为超链接引入 hyperref 库
+\usepackage{caption}
+\usepackage{float}
+\usepackage{hyperref}
+
+% 我们还可以定义其他文档属性！
+\author{Chaitanya Krishna Ande, Colton Kohnke, Sricharan Chiruvolu \& \\
+Svetlana Golubeva}
+\date{\today}
+\title{Learn \LaTeX \hspace{1pt} in Y Minutes!}
+
+% 现在我们开始正文
+% 这一行之前都是“序章”
+\begin{document} 
+% 如果想设定作者，时间，标题字段我们可使用 LaTeX 来建立标题页
+\maketitle
+
+% 分章节时，可以建立目录
+% 我们需要编译文档两次来保证他们顺序正确
+% 使用目录来分开文档是很好的做法
+% 这里我们使用 \newpage 操作符
+\newpage
+\tableofcontents
+
+\newpage
+
+% 许多研究论文有摘要部分。这可以使用预定义的指令来实现
+% 它应被放在逻辑上正确的位置，即顶部标题等的下面和文章主体的上面
+% 该指令可以再报告和文章中使用
+\begin{abstract}
+ \LaTeX \hspace{1pt} documentation written as \LaTeX! How novel and totally not
+ my idea!
+\end{abstract}
+
+% 章节指令非常直观
+% 所有章节标题会自动地添加到目录中
+\section{Introduction}
+Hello, my name is Colton and together we're going to explore \LaTeX!
+
+\section{Another section}
+This is the text for another section. I think it needs a subsection.
+
+\subsection{This is a subsection} % 子章节同样非常直观
+I think we need another one
+
+\subsubsection{Pythagoras}
+Much better now.
+\label{subsec:pythagoras}
+
+% 使用型号我们可以借助 LaTeX 内置的编号功能
+% 这一技巧也在其他指令中有效
+\section*{This is an unnumbered section} 
+然而并不是所有章节都要被标序号
+
+\section{Some Text notes}
+%\section{Spacing} % 需要增加有关空白间隔的信息
+\LaTeX \hspace{1pt} is generally pretty good about placing text where it should
+go. If 
+a line \\ needs \\ to \\ break \\ you add \textbackslash\textbackslash 
+\hspace{1pt} to the source code. \\ 
+
+\section{Lists}
+Lists are one of the easiest things to create in \LaTeX! I need to go shopping
+tomorrow, so let's make a grocery list.
+\begin{enumerate} % 此处创建了一个“枚举”环境
+  % \item 使枚举增加一个单位
+  \item Salad.
+  \item 27 watermelon.
+  \item A single jackrabbit.
+  % 我们甚至可以通过使用 [] 覆盖美剧的数量
+  \item[how many?] Medium sized squirt guns.
+
+  Not a list item, but still part of the enumerate.
+
+\end{enumerate} % 所有环境都有终止符
+
+\section{Math}
+
+使用 \LaTeX \hspace{1pt} 的一个最主要的方面是学术论文和技术文章
+通常在数学和科学的领域 
+因此我们需要在文章中插入特殊符号！ \\
+
+数学符号极多，远超出你能在键盘上找到的那些；
+集合关系符，箭头，操作符，希腊字符等等 \\
+
+集合与关系在数学文章中很重要
+如声明所有 x 属于 X $\forall$ x $\in$ X. \\
+% 注意我们需要在这些符号之前和之后增加 $ 符号
+% 因为在编写时我们处于 text-mode，然而数学符号只在 math-mode 中存在
+% text mode 进入 math-mode 使用 $ 操作符
+% 反之亦然，变量同时会在 math-mode 中被渲染。
+% 我们也可以使用 \[\] 来进入 math mode
+
+\[a^2 + b^2 = c^2 \]
+
+My favorite Greek letter is $\xi$. I also like $\beta$, $\gamma$ and $\sigma$.
+I haven't found a Greek letter yet that \LaTeX \hspace{1pt} doesn't know
+about! \\
+
+常用函数操作符同样很重要： 
+trigonometric functions ($\sin$, $\cos$, $\tan$), 
+logarithms 和 exponentials ($\log$, $\exp$), 
+limits ($\lim$), etc. 
+在 LaTeX 指令中预定义 
+让我们写一个等式看看发生了什么：
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\
+
+分数可以写成以下形式：
+
+% 10 / 7
+$$ ^{10}/_{7} $$
+
+% 相对比较复杂的分数可以写成
+% \frac{numerator}{denominator}
+$$ \frac{n!}{k!(n - k)!} $$ \\
+
+我们同样可以插入公式（equations）在环境 ``equation environment'' 下。
+
+% 展示数学相关时，使用方程式环境
+\begin{equation} % 进入 math-mode
+    c^2 = a^2 + b^2.
+    \label{eq:pythagoras} % 为了下一步引用
+\end{equation} % 所有 \begin 语句必须有end语句对应
+
+引用我们的新等式！
+Eqn.~\ref{eq:pythagoras} is also known as the Pythagoras Theorem which is also
+the subject of Sec.~\ref{subsec:pythagoras}. A lot of things can be labeled: 
+figures, equations, sections, etc.
+
+求和（Summations）与整合（Integrals）写作 sum 和 int ：
+
+% 一些编译器会提醒在等式环境中的空行
+
+\begin{equation} 
+  \sum_{i=0}^{5} f_{i}
+\end{equation} 
+\begin{equation} 
+  \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
+\end{equation} 
+
+\section{Figures}
+
+让我们插入图片。图片的放置非常微妙。
+我在每次使用时都会查找可用选项。
+
+\begin{figure}[H] % H 是放置选项的符号
+    \centering % 图片在本页居中
+    % 宽度放缩为页面的0.8倍
+    %\includegraphics[width=0.8\linewidth]{right-triangle.png} 
+    % 需要使用想象力决定是否语句超出编译预期
+    \caption{Right triangle with sides $a$, $b$, $c$}
+    \label{fig:right-triangle}
+\end{figure}
+
+\subsection{Table}
+插入表格与插入图片方式相同
+
+\begin{table}[H]
+  \caption{Caption for the Table.}
+  % 下方的 {} 描述了表格中每一行的绘制方式
+  % 同样，我在每次使用时都会查找可用选项。
+  \begin{tabular}{c|cc} 
+    Number &  Last Name & First Name \\ % 每一列被 & 分开
+    \hline % 水平线
+    1 & Biggus & Dickus \\
+    2 & Monty & Python
+  \end{tabular}
+\end{table}
+
+\section{Getting \LaTeX \hspace{1pt} to not compile something (i.e. Source Code)}
+现在增加一些源代码在 \LaTeX \hspace{1pt} 文档中，
+我们之后需要 \LaTeX \hspace{1pt} 不翻译这些内容而仅仅是把他们打印出来
+这里使用 verbatim environment。 
+
+% 也有其他库存在 (如. minty, lstlisting, 等)
+% 但是 verbatim 是最基础和简单的一个
+\begin{verbatim} 
+  print("Hello World!")
+  a%b; % 在这一环境下我们可以使用 %
+  random = 4; #decided by fair random dice roll
+\end{verbatim}
+
+\section{Compiling} 
+
+现在你大概想了解如何编译这个美妙的文档
+然后得到饱受称赞的 \LaTeX \hspace{1pt} pdf文档
+(这个文档确实被编译了)。 \\
+得到最终文档，使用 \LaTeX \hspace{1pt} 组合步骤：
+  \begin{enumerate}
+    \item Write the document in plain text (the ``source code'').
+    \item Compile source code to produce a pdf. 
+     The compilation step looks like this (in Linux): \\
+     \begin{verbatim} 
+        > pdflatex learn-latex.tex
+     \end{verbatim}
+  \end{enumerate}
+
+许多 \LaTeX \hspace{1pt}编译器把步骤1和2在同一个软件中进行了整合
+所以你可以只看步骤1完全不看步骤2
+步骤2同样在以下情境中使用情景 \footnote{以防万一，当你使用引用时
+ (如 Eqn.~\ref{eq:pythagoras})，你将需要多次运行步骤2
+来生成一个媒介文件 *.aux 。}.
+% 同时这也是在文档中增加脚标的方式
+
+在步骤1中，用普通文本写入格式化信息
+步骤2的编译阶段则注意在步骤1 中定义的格式信息。
+
+\section{Hyperlinks}
+同样可以在文档中加入超链接
+使用如下命令在序言中引入库：
+\begin{verbatim} 
+    \usepackage{hyperref}
+\end{verbatim}
+
+有两种主要的超链接方式 \\
+\url{https://learnxinyminutes.com/docs/latex/}， 或  
+\href{https://learnxinyminutes.com/docs/latex/}{shadowed by text}
+% 你不可以增加特殊空格和符号，因为这将会造成编译错误
+
+这个库同样在输出PDF文档时制造略缩的列表，或在目录中激活链接
+
+
+\section{End}
+
+这就是全部内容了！
+
+% 通常，你会希望文章中有个引用部分
+% 最简单的建立方式是使用书目提要章节
+\begin{thebibliography}{1}
+  % 与其他列表相同， \bibitem 命令被用来列出条目
+  % 每个记录可以直接被文章主体引用
+  \bibitem{latexwiki} The amazing \LaTeX \hspace{1pt} wikibook: {\em 
+https://en.wikibooks.org/wiki/LaTeX}
+  \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
+\end{thebibliography}
+
+% 结束文档
+\end{document}
+```
+
+## LaTeX 进阶
+
+* The amazing LaTeX wikibook: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX)
+* An actual tutorial: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
diff --git a/zh-cn/less-cn.html.markdown b/zh-cn/less-cn.html.markdown
new file mode 100644
index 00000000..365a0287
--- /dev/null
+++ b/zh-cn/less-cn.html.markdown
@@ -0,0 +1,387 @@
+---
+language: less
+filename: learnless-cn.less
+contributors:
+  - ["Saravanan Ganesh", "http://srrvnn.me"]
+translators:
+   - ["Jiang Haiyun", "http://www.atjiang.com"]
+lang: zh-cn
+---
+
+
+Less是一种CSS预处理器，它增加了诸如变量、嵌套、mixin等功能。
+Less(以及其它预处理器，如[Sass](http://sass-lang.com/))能帮助开发人员编写易维护，DRY (Don't Repeat Yourself) 的代码。
+
+```css
+
+
+//单行注释在编译成CSS后会被删除。
+
+/* 多行注释将保留. */
+
+
+
+/* 变量
+==============================*/
+
+
+/* 你可以将一个CSS值（如一个颜色值）保存到变量中。
+   使用'@'符号来创建一个变量。*/
+
+@primary-color: #a3a4ff;
+@secondary-color: #51527f;
+@body-font: 'Roboto', sans-serif;
+
+/* 你可以在你的样式文件中使用这些变量。
+   现在假如你想修改颜色，你只需修改一次即可。*/
+
+body {
+	background-color: @primary-color;
+	color: @secondary-color;
+	font-family: @body-font;
+}
+
+/* 以上将编译成： */
+
+body {
+	background-color: #a3a4ff;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* 相比于在你的样式文件中逐个修改，这种方式维护性更好。 */
+
+
+
+/* Mixins
+==============================*/
+
+
+/* 如果你要为多个元素编写同样的代码，
+   你可能想实现轻松地重用。*/
+
+.center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* 你只需简单地将选择子作为样式添加进来就能使用mixin了 */
+
+div {
+	.center;
+	background-color: @primary-color;
+}
+
+/* 它将编译成: */
+
+.center {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #a3a4ff;
+}
+
+/* 通过在选择子后添加括号，可以使这些mixin代码不被编译 */
+
+.center() {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+
+div {
+  .center;
+  background-color: @primary-color;
+}
+
+/* 将编译成: */
+div {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+  background-color: #a3a4ff;
+}
+
+
+
+/* 嵌套
+==============================*/
+
+
+/* Less允许你在选择子中嵌套选择子 */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #f00;
+	}
+}
+
+/* '&'将被替换成父选择子。*/
+/* 你也可以嵌套伪类。 */
+/* 注意过度嵌套将会导致代码难以维护。
+   最佳实践推荐在嵌套时不超过3层。
+   例如： */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* 编译成： */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* 函数
+==============================*/
+
+
+/* Less提供的函数可以用来完成多种任务。
+   考虑以下情况： */
+
+/* 函数可以通过其名称及传入其所需的参数来调用。 */
+
+body {
+  width: round(10.25px);
+}
+
+.header {
+	background-color: lighten(#000, 0.5);
+}
+
+.footer {
+  background-color: fadeout(#000, 0.25)
+}
+
+/* 编译成: */
+
+body {
+  width: 10px;
+}
+
+.header {
+  background-color: #010101;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* 你也可以定义自己的函数。函数非常类似于mixin。
+   当你在函数和mixin之间抉择时，
+   记住mixin最适合用来创建CSS而函数更适合于
+   处理那些可能在你的Less代码中使用的逻辑。
+   '数学运算符'部分的例子是转成可重用函数的最佳选择。*/
+
+/* 该函数计算两数的平均值： */
+
+.average(@x, @y) {
+  @average-result: ((@x + @y) / 2);
+}
+
+div {
+  .average(16px, 50px); // "调用"mixin
+  padding: @average-result;    // 使用它的"返回"值
+}
+
+/* 编译成: */
+
+div {
+  padding: 33px;
+}
+
+
+
+/* 扩展 (继承)
+==============================*/
+
+
+/* 扩展是在选择子间共享属性的一种方法。 */
+
+.display {
+  height: 50px;
+}
+
+.display-success {
+  &:extend(.display);
+	border-color: #22df56;
+}
+
+/* 编译成: */
+.display,
+.display-success {
+  height: 50px;
+}
+.display-success {
+  border-color: #22df56;
+}
+
+/* 扩展一条CSS语句优于创建一个mixin，
+   这是由其组合所有共享相同基样式的类的方式决定的。
+   如果使用mixin完成，其属性将会在调用了该mixin的每条语句中重复。
+   虽然它不至会影响你的工作流，但它会在由Less编译器
+   生成的的文件中添加不必要的代码。*/
+
+
+
+/* 片段与导入
+==============================*/
+
+
+/* Less允许你创建片段文件。它有助于你的Less代码保持模块化。
+   片段文件习惯上以'_'开头，例如 _reset.css，并被导入到
+   一个将会被编译成CSS的主less文件中。*/
+
+/* 考虑以下的CSS，我们将把它们放入一个叫_reset.css的文件中 */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Less提供的@import能用来将片段导入到文件中。
+   它与传统的CSS @import语句不同，无需通过
+   HTTP请求获取导入文件。Less提取导入文件
+   并将它们与编译后的代码结合起来。 */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* 编译成: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* 数学运算符
+==============================*/
+
+
+/* Less提供以下的运算符: +, -, *, /, 和 %。
+   相比于使用你事先手工计算好了的数值，它们
+   对于直接在你的Less文件中计算数值很有用。
+   以下是设置一个两列设计的例子。*/
+
+@content-area: 960px;
+@main-content: 600px;
+@sidebar-content: 300px;
+
+@main-size: @main-content / @content-area * 100%;
+@sidebar-size: @sidebar-content / @content-area * 100%;
+@gutter: 100% - (@main-size + @sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: @main-size;
+}
+
+.sidebar {
+  width: @sidebar-size;
+}
+
+.gutter {
+  width: @gutter;
+}
+
+/* 编译成： */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+## 实践Less
+
+如果你想在你的浏览器中尝试LESS，参阅：
+* [Codepen](http://codepen.io/)
+* [LESS2CSS](http://lesscss.org/less-preview/)
+
+## 兼容性
+
+Less可以用于任何项目中，只要你有程序能将它编译成CSS即可。你还需要验证你所使用的CSS是否与你的目标浏览器兼容。
+
+[QuirksMode CSS](http://www.quirksmode.org/css/)和[CanIUse](http://caniuse.com) 对于检查兼容性来说都是不错的资源。
+
+## 延伸阅读资料
+* [Official Documentation](http://lesscss.org/features/)
+* [Less CSS - Beginner's Guide](http://www.hongkiat.com/blog/less-basic/)
diff --git a/zh-cn/lua-cn.html.markdown b/zh-cn/lua-cn.html.markdown
index f7065445..6736dc2a 100644
--- a/zh-cn/lua-cn.html.markdown
+++ b/zh-cn/lua-cn.html.markdown
@@ -416,7 +416,7 @@ lua-users.org上的[Lua简明参考](http://lua-users.org/files/wiki_insecure/us
 * <a href="http://lua-users.org/wiki/OsLibraryTutorial">os library</a>
 
 顺便说一下，整个文件是可运行的Lua; 
-保存为 learn-cn.lua 用命令 `lua learn.lua` 启动吧！
+保存为 learn-cn.lua 用命令 `lua learn-cn.lua` 启动吧！
 
 本文首次撰写于 [tylerneylon.com](http://tylerneylon.com) 同时也有 [github gist](https://gist.github.com/tylerneylon/5853042) 版.
 
diff --git a/zh-cn/markdown-cn.html.markdown b/zh-cn/markdown-cn.html.markdown
index b633714d..87ed46ad 100644
--- a/zh-cn/markdown-cn.html.markdown
+++ b/zh-cn/markdown-cn.html.markdown
@@ -53,7 +53,7 @@ __此文本也是__
 **_或者这样。_**
 *__这个也是！__*
 
-<!-- 在 Github 采用的 Markdown 中 -->
+<!-- 在 GitHub 采用的 Markdown 中 -->
 
 ~~此文本为删除线效果。~~
 
@@ -142,7 +142,7 @@ __此文本也是__
 
 John 甚至不知道 `go_to()` 方程是干嘛的!
 
-<!-- 在Github的 Markdown中，对于代码你可以使用特殊的语法 -->
+<!-- 在GitHub的 Markdown中，对于代码你可以使用特殊的语法 -->
 
 \`\`\`ruby <!-- 插入时记得移除反斜线， 仅留```ruby ！ -->
 def foobar
@@ -150,7 +150,7 @@ def foobar
 end
 \`\`\` <!-- 这里也是，移除反斜线，仅留 ``` -->
 
-<!-- 以上代码不需要缩进，而且 Github 会根据```后表明的语言来进行语法高亮 -->
+<!-- 以上代码不需要缩进，而且 GitHub 会根据```后表明的语言来进行语法高亮 -->
 
 <!-- 水平线 （<hr />） -->
 <!-- 水平线可由三个或以上的星号或者减号创建，可带可不带空格。 -->
@@ -220,7 +220,7 @@ end
 斜体化, 所以我就: \*这段置文字于星号之间\*。
 
 <!-- 表格 -->
-<!-- 表格只被 Github 的 Markdown 支持，并且有一点笨重，但如果你真的要用的话: -->
+<!-- 表格只被 GitHub 的 Markdown 支持，并且有一点笨重，但如果你真的要用的话: -->
 
 | 第一列        | 第二列    | 第三列       |
 | :----------   | :------:  | ----------:  |
diff --git a/zh-cn/r-cn.html.markdown b/zh-cn/r-cn.html.markdown
index 0c46bc22..d576db29 100644
--- a/zh-cn/r-cn.html.markdown
+++ b/zh-cn/r-cn.html.markdown
@@ -285,7 +285,7 @@ while (a > 4) {
 }
 
 # 记住，在 R 语言中 for / while 循环都很慢
-# 建议使用 apply()（我们一会介绍）来错做一串数据（比如一列或者一行数据）
+# 建议使用 apply()（我们一会介绍）来操作一串数据（比如一列或者一行数据）
 
 # IF/ELSE
 
@@ -303,7 +303,7 @@ if (4 > 3) {
 
 # 定义如下
 jiggle <- function(x) {
-	x + rnorm(x, sd=.1)	#add in a bit of (controlled) noise
+	x = x + rnorm(1, sd=.1)	# 添加一点（正态）波动	
 	return(x)
 }
 
diff --git a/zh-cn/ruby-cn.html.markdown b/zh-cn/ruby-cn.html.markdown
index 14d38137..657a913d 100644
--- a/zh-cn/ruby-cn.html.markdown
+++ b/zh-cn/ruby-cn.html.markdown
@@ -10,6 +10,7 @@ contributors:
   - ["ftwbzhao", "https://github.com/ftwbzhao"]
 translators:
   - ["Lin Xiangyu", "https://github.com/oa414"]
+  - ["Jiang Haiyun", "https://github.com/haiiiiiyun"]
 ---
 
 ```ruby
@@ -35,6 +36,13 @@ translators:
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+
+# 位运算符
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
 
 # 算术符号只是语法糖而已
 # 实际上是调用对象的方法
@@ -42,7 +50,7 @@ translators:
 10.* 5 #=> 50 
 
 # 特殊的值也是对象
-nil # 空
+nil # 相当于其它语言中的 null
 true # 真
 false # 假
 
@@ -54,13 +62,11 @@ false.class #=> FalseClass
 1 == 1 #=> true
 2 == 1 #=> false
 
-# 不等运算符
+# 不相等运算符
 1 != 1 #=> false
 2 != 1 #=> true
-!true  #=> false
-!false #=> true
 
-# 除了false自己，nil是唯一的值为false的对象 
+# 除了false自己，nil是唯一的另一个值为false的对象
 
 !nil   #=> true
 !false #=> true
@@ -72,6 +78,26 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
+
+# 组合比较运算符
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# 逻辑运算符
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# 也有优先级更低的逻辑运算符
+# 它们用于控制流结构中，用来串接语句，直到返回true或false。
+
+# `do_something_else` 只当 `do_something` 返回true时才会被调用
+do_something() and do_something_else()
+# `log_error` 只当 `do_something` 返回false时才会被调用
+do_something() or log_error()
+
+
 # 字符串是对象
 
 'I am a string'.class #=> String
@@ -81,9 +107,28 @@ placeholder = "use string interpolation"
 "I can #{placeholder} when using double quoted strings"
 #=> "I can use string interpolation when using double quoted strings"
 
+# 尽可能优先使用单引号的字符串
+# 双引号的字符串会进行一些额外的内部处理
+
+# 合并字符串，但不能和数字合并
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+
+# 合并字符串及其运算符
+'hello ' * 3 #=> "hello hello hello "
+
+# 字符串追加
+'hello' << ' world' #=> "hello world"
 
-# 输出值
+# 打印输出，并在末尾加换行符
 puts "I'm printing!"
+#=> I'm printing!
+#=> nil
+
+# 打印输出，不加换行符
+print "I'm printing!"
+#=> I'm printing! => nil
 
 # 变量
 x = 25 #=> 25
@@ -96,17 +141,16 @@ x = y = 10 #=> 10
 x #=> 10
 y #=> 10
 
-# 按照惯例，用 snake_case 作为变量名
+# 按照惯例，使用类似snake_case风格的变量名
 snake_case = true
 
-# 使用具有描述性的运算符
+# 使用有意义的变量名
 path_to_project_root = '/good/name/'
 path = '/bad/name/'
 
 # 符号（Symbols，也是对象)
-# 符号是不可变的，内部用整数类型表示的可重用的值。
-# 通常用它代替字符串来有效地表示有意义的值。
-
+# 符号是不可变的，内部用整数值表示的可重用的常数
+# 通常用它代替字符串来有效地表示有意义的值
 
 :pending.class #=> Symbol
 
@@ -132,26 +176,36 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 array[0] #=> 1
 array[12] #=> nil
 
-# 像运算符一样，[var]形式的访问
-# 也就是一个语法糖
-# 实际上是调用对象的[] 方法
+# 像运算符一样，[var] 形式的访问
+# 也只是语法糖
+# 实际上是调用对象的 [] 方法
 array.[] 0 #=> 1
 array.[] 12 #=> nil
 
 # 从尾部开始
 array[-1] #=> 5
+array.last #=> 5
 
 # 同时指定开始的位置和长度
 array[2, 3] #=> [3, 4, 5]
 
-# 或者指定一个范围
+# 将数组逆序
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# 或者指定一个区间
 array[1..3] #=> [2, 3, 4]
 
 # 像这样往数组增加一个元素
 array << 6 #=> [1, 2, 3, 4, 5, 6]
+# 或者像这样
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
 
-# 哈希表是Ruby的键值对的基本数据结构
-# 哈希表由大括号定义
+# 检查元素是否包含在数组中
+array.include?(1) #=> true
+
+# 哈希表是 Ruby 的主要键/值对表示法
+# 哈希表由大括号表示
 hash = {'color' => 'green', 'number' => 5}
 
 hash.keys #=> ['color', 'number']
@@ -160,22 +214,17 @@ hash.keys #=> ['color', 'number']
 hash['color'] #=> 'green'
 hash['number'] #=> 5
 
-# 查询一个不存在地键将会返回nil
+# 查询一个不存在的键将会返回nil
 hash['nothing here'] #=> nil
 
-# 用 #each 方法来枚举哈希表:
-hash.each do |k, v|
-  puts "#{k} is #{v}"
-end
-
-# 从Ruby 1.9开始, 用符号作为键的时候有特别的记号表示:
+# 从Ruby 1.9开始，用符号作为键的时候有特别的记号表示:
 
-new_hash = { defcon: 3, action: true}
+new_hash = { defcon: 3, action: true }
 
 new_hash.keys #=> [:defcon, :action]
 
 # 小贴士：数组和哈希表都是可枚举的
-# 它们可以共享一些有用的方法，比如each, map, count 等等
+# 它们共享一些有用的方法，比如each,map,count等等
 
 # 控制流
 
@@ -196,9 +245,15 @@ end
 #=> iteration 4
 #=> iteration 5
 
-# 然而
-# 没人用for循环
-#  用`each`来代替，就像这样
+
+# 但是，没有人用for循环。
+# 你应该使用"each"方法，然后再传给它一个块。
+# 所谓块就是可以传给像"each"这样的方法的代码段。
+# 它类似于其它语言中的lambdas, 匿名函数或闭包。
+#
+# 区间上的"each"方法会对区间中的每个元素运行一次块代码。
+# 我们将counter作为一个参数传给了块。
+# 调用带有块的"each"方法看起来如下：
 
 (1..5).each do |counter|
   puts "iteration #{counter}"
@@ -209,6 +264,23 @@ end
 #=> iteration 4
 #=> iteration 5
 
+# 你也可以将块包含在一个大括号中：
+(1..5).each { |counter| puts "iteration #{counter}" }
+
+# 数据结构中的内容也可以使用each来遍历。
+array.each do |element|
+  puts "#{element} is part of the array"
+end
+hash.each do |key, value|
+  puts "#{key} is #{value}"
+end
+
+# 如果你还需要索引值，可以使用"each_with_index"，并且定义
+# 一个索引变量
+array.each_with_index do |element, index|
+  puts "#{element} is number #{index} in the array"
+end
+
 counter = 1
 while counter <= 5 do
   puts "iteration #{counter}"
@@ -220,6 +292,20 @@ end
 #=> iteration 4
 #=> iteration 5
 
+# Ruby 中还有很多有用的循环遍历函数，
+# 如"map","reduce","inject"等等。
+# 以map为例，它会遍历数组，并根据你在
+# 块中定义的逻辑对它进行处理，然后返回
+# 一个全新的数组。
+array = [1,2,3,4,5]
+doubled = array.map do |element|
+  element * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
 grade = 'B'
 
 case grade
@@ -236,6 +322,33 @@ when 'F'
 else 
   puts "Alternative grading system, eh?"
 end
+#=> "Better luck next time"
+
+# case也可以用区间
+grade = 82
+case grade
+when 90..100
+  puts 'Hooray!'
+when 80...90
+  puts 'OK job'
+else
+  puts 'You failed!'
+end
+#=> "OK job"
+
+# 异常处理：
+begin
+  # 这里的代码可能会抛出异常
+  raise NoMemoryError, 'You ran out of memory.'
+rescue NoMemoryError => exception_variable
+  puts 'NoMemoryError was raised', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'RuntimeError was raised now'
+else
+  puts 'This runs if no exceptions were thrown at all'
+ensure
+  puts 'This code always runs no matter what'
+end
 
 # 函数
 
@@ -243,7 +356,7 @@ def double(x)
   x * 2
 end
 
-# 函数 (以及所有的方法块) 隐式地返回了最后语句的值
+# 函数 (以及所有的块) 隐式地返回最后语句的值
 double(2) #=> 4
 
 # 当不存在歧义的时候括号是可有可无的
@@ -261,8 +374,8 @@ sum 3, 4 #=> 7
 sum sum(3,4), 5 #=> 12
 
 # yield
-# 所有的方法都有一个隐式的块参数
-# 可以用yield参数调用
+# 所有的方法都有一个隐式的，可选的块参数
+# 可以用 'yield' 关键字调用
 
 def surround
   puts "{"
@@ -276,45 +389,84 @@ surround { puts 'hello world' }
 # hello world
 # }
 
+# 可以向函数传递一个块
+# "&"标记传递的块是一个引用
+def guests(&block)
+  block.call 'some_argument'
+end
 
-# 用class关键字定义一个类
-class Human
-
-     # 一个类变量，它被这个类地所有实例变量共享
-    @@species = "H. sapiens"
+# 可以传递多个参数，这些参数会转成一个数组，
+# 这也是使用星号符 ("*") 的原因：
+def guests(*array)
+  array.each { |guest| puts guest }
+end
 
-    # 构造函数
-    def initialize(name, age=0)
-        # 将参数name的值赋给实例变量@name
-        @name = name
-        # 如果没有给出age, 那么会采用参数列表中地默认地值
-        @age = age
-    end
+# 如果函数返回一个数组，在赋值时可以进行拆分：
+def foods
+    ['pancake', 'sandwich', 'quesadilla']
+end
+breakfast, lunch, dinner = foods
+breakfast #=> 'pancake'
+dinner #=> 'quesadilla'
 
-    # 基本的 setter 方法
-    def name=(name)
-        @name = name
-    end
+# 按照惯例，所有返回布尔值的方法都以?结尾
+5.even? # false
+5.odd? # true
 
-    # 基本地 getter 方法
-    def name
-        @name
-    end
+# 如果方法名末尾有!，表示会做一些破坏性的操作，比如修改调用者自身。
+# 很多方法都会有一个!的版本来进行修改，和一个非!的版本
+# 只用来返回更新了的结果
+company_name = "Dunder Mifflin"
+company_name.upcase #=> "DUNDER MIFFLIN"
+company_name #=> "Dunder Mifflin"
+company_name.upcase! # we're mutating company_name this time!
+company_name #=> "DUNDER MIFFLIN"
 
-    # 一个类方法以self.开头
-    # 它可以被类调用，但不能被类的实例调用
-    def self.say(msg)
-       puts "#{msg}"
-    end
 
-    def species
-        @@species
-    end
+# 用class关键字定义一个类
+class Human
 
+  # 一个类变量，它被这个类的所有实例变量共享
+  @@species = "H. sapiens"
+  
+  # 基本构造函数
+  def initialize(name, age = 0)
+    # 将参数值赋给实例变量"name"
+    @name = name
+    # 如果没有给出age,那么会采用参数列表中的默认值
+    @age = age
+  end
+  
+  # 基本的setter方法
+  def name=(name)
+    @name = name
+  end
+  
+  # 基本地getter方法
+  def name
+    @name
+  end
+  
+  # 以上的功能也可以用下面的attr_accessor来封装
+  attr_accessor :name
+  
+  # Getter/setter方法也可以像这样单独创建
+  attr_reader :name
+  attr_writer :name
+  
+  # 类方法通过使用self与实例方法区别开来。
+  # 它只能通过类来调用，不能通过实例调用。
+  def self.say(msg)
+    puts "#{msg}"
+  end
+  
+  def species
+    @@species
+  end
 end
 
 
-# 类的例子
+# 初始化一个类
 jim = Human.new("Jim Halpert")
 
 dwight = Human.new("Dwight K. Schrute")
@@ -327,7 +479,132 @@ jim.name #=> "Jim Halpert II"
 dwight.species #=> "H. sapiens"
 dwight.name #=> "Dwight K. Schrute"
 
-# 调用对象的方法
-Human.say("Hi") #=> "Hi"
+# 调用类方法
+Human.say('Hi') #=> "Hi"
+
+# 变量的作用域由它们的名字格式定义
+# 以$开头的变量具有全局域
+$var = "I'm a global var"
+defined? $var #=> "global-variable"
+
+# 以@开头的变量具有实例作用域
+@var = "I'm an instance var"
+defined? @var #=> "instance-variable"
+
+# 以@@开头的变量具有类作用域
+@@var = "I'm a class var"
+defined? @@var #=> "class variable"
+
+# 以大写字母开头的变量是常数
+Var = "I'm a constant"
+defined? Var #=> "constant"
+
+# 类也是对象。因此类也可以有实例变量。
+# 类变量在类以及其继承者之间共享。
+
+# 基类
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# 派生类
+class Worker < Human
+end
+
+Human.foo # 0
+Worker.foo # 0
+
+Human.foo = 2 # 2
+Worker.foo # 2
+
+# 类实例变量不能在继承类间共享。
+
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+Human.bar # 0
+Doctor.bar # nil
+
+module ModuleExample
+  def foo
+    'foo'
+  end
+end
+
+# '包含'模块后，模块的方法会绑定为类的实例方法
+# '扩展'模块后，模块的方法会绑定为类方法
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => NoMethodError: undefined method `foo'
+
+# 当包含或扩展一个模块时，相应的回调代码会被执行。
 
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     # => 'bar'
+Something.qux     # => NoMethodError: undefined method `qux'
+Something.new.bar # => NoMethodError: undefined method `bar'
+Something.new.qux # => 'qux'
 ```
+
+
+## 其它资源
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Learn Ruby through a series of interactive tutorials.
+- [Official Documentation](http://ruby-doc.org/core)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
+- [Try Ruby](http://tryruby.org) - Learn the basic of Ruby programming language, interactive in the browser.
diff --git a/zh-cn/rust-cn.html.markdown b/zh-cn/rust-cn.html.markdown
index 17a897df..5d3fc693 100644
--- a/zh-cn/rust-cn.html.markdown
+++ b/zh-cn/rust-cn.html.markdown
@@ -268,7 +268,7 @@ fn main() {
     var = 3;
     let ref_var: &i32 = &var;
 
-    println!("{}", var); //不像 `box`, `var` 还可以继续使用
+    println!("{}", var); //不像 `mine`, `var` 还可以继续使用
     println!("{}", *ref_var);
     // var = 5; // 编译报错，因为 `var` 被借用了
     // *ref_var = 6; // 编译报错，因为 `ref_var` 是不可变引用
diff --git a/zh-cn/sass-cn.html.markdown b/zh-cn/sass-cn.html.markdown
new file mode 100644
index 00000000..985c6470
--- /dev/null
+++ b/zh-cn/sass-cn.html.markdown
@@ -0,0 +1,585 @@
+---
+language: sass
+filename: learnsass-cn.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+  - ["Kyle Mendes", "https://github.com/pink401k"]
+  - ["Keith Miyake", "https://github.com/kaymmm"]
+translators:
+   - ["Jiang Haiyun", "http://www.atjiang.com"]
+lang: zh-cn
+---
+
+Sass是一种CSS扩展语言，它增加了诸如变量、嵌套、mixin等功能。
+Sass(以及其它预处理器，如[Less](http://lesscss.org/)等) 能帮助开发人员编写易维护和 DRY (Don't Repeat Yourself)的代码。
+
+Sass有两种不同的语法可选用。SCSS的语法和CSS的相同，但增加了Sass的额外功能。或者Sass（原来的语法），它使用缩进而非大括号和分号。
+
+本教程使用SCSS编写。
+
+如果你已熟悉CSS3，你可能相对能较快地掌握Sass。它并没有提供任何新的类型属性，而只是提供了一些工具使你能更高效的编写CSS，并且使维护更加容易。
+
+```scss
+
+
+// 单行注释当Sass被编译成CSS后会被删除。
+
+/* 多行注释将保留. */
+
+/* 变量
+============================== */
+
+
+
+/* 你可以将一个CSS值（如一个颜色值）保存到变量中。
+使用'$'符号来创建一个变量。*/
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* 你可以在你的样式文件中使用变量。
+   现在假如你想修改颜色，你只需修改一次即可。*/
+
+body {
+	background-color: $primary-color;
+	color: $secondary-color;
+	font-family: $body-font;
+}
+
+/* 以上将编译成： */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+/* 相比于在你的样式文件中逐个进行修改，这种方式维护性更好。 */
+
+
+
+/* 控制指令
+============================== */
+
+/* Sass允许你使用@if, @else, @for, @while, 和 @each 来控制
+   你的代码如何编译成CSS */
+
+/* @if/@else块的行为和你可能预想的会完全相同 */
+
+$debug: true !default;
+
+@mixin debugmode {
+	@if $debug {
+		@debug "Debug mode enabled";
+
+		display: inline-block;
+	}
+	@else {
+		display: none;
+	}
+}
+
+.info {
+	@include debugmode;
+}
+
+/* 如果$debug设置为了true, .info 将会显示; 如果设置为false那么
+   .info 将不显示。
+
+注意： @debug将在命令行中输出调试信息。
+在调试你的SCSS时它对于检查变量很有用。*/
+
+.info {
+	display: inline-block;
+}
+
+/* @for是控制循环，它能遍历区间值。
+它对于设置一组元素的类型特别有用。
+有两种形式，"through"和"to"。前者包括最末那个值，
+而后者止于最末那个值。 
+*/
+
+@for $c from 1 to 4 {
+	div:nth-of-type(#{$c}) {
+		left: ($c - 1) * 900 / 3;
+	}
+}
+
+@for $c from 1 through 3 {
+	.myclass-#{$c} {
+		color: rgb($c * 255 / 3, $c * 255 / 3, $c * 255 / 3);
+	}
+}
+
+/* 将编译成: */
+
+div:nth-of-type(1) {
+	left: 0;
+}
+
+div:nth-of-type(2) {
+	left: 300;
+}
+
+div:nth-of-type(3) {
+	left: 600;
+}
+
+.myclass-1 {
+	color: #555555;
+}
+
+.myclass-2 {
+	color: #aaaaaa;
+}
+
+.myclass-3 {
+	color: white;
+// SASS automatically converts #FFFFFF to white
+}
+
+/* @while也非常直白： */
+
+$columns: 4;
+$column-width: 80px;
+
+@while $columns > 0 {
+	.col-#{$columns} {
+		width: $column-width;
+		left: $column-width * ($columns - 1);
+	}
+
+	$columns: $columns - 1;
+}
+
+/* 将输出以下CSS: */
+
+.col-4 {
+	width: 80px;
+	left: 240px;
+}
+
+.col-3 {
+	width: 80px;
+	left: 160px;
+}
+
+.col-2 {
+	width: 80px;
+	left: 80px;
+}
+
+.col-1 {
+	width: 80px;
+	left: 0px;
+}
+
+/* @each函数类似@for, 除了它使用一个列表而不是序列值
+注意: 你指定列表的方式和指定其它变量一样，
+用空格作为分隔符。 */
+
+$social-links: facebook twitter linkedin reddit;
+
+.social-links {
+	@each $sm in $social-links {
+		.icon-#{$sm} {
+			background-image: url("images/#{$sm}.png");
+		}
+	}
+}
+
+/* 将输出: */
+
+.social-links .icon-facebook {
+	background-image: url("images/facebook.png");
+}
+
+.social-links .icon-twitter {
+	background-image: url("images/twitter.png");
+}
+
+.social-links .icon-linkedin {
+	background-image: url("images/linkedin.png");
+}
+
+.social-links .icon-reddit {
+	background-image: url("images/reddit.png");
+}
+
+
+/* Mixins
+==============================*/
+
+/* 如果你发现你要为多个元素编写相同的代码，
+你可能想将那些代码保存到一个mixin中。
+
+使用'@mixin'指令，再为你的mixin加上一个名称。*/
+
+@mixin center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* 你可以通过'@include'及mixin名来调用mixin。 */
+
+div {
+	@include center;
+	background-color: $primary-color;
+}
+
+/* 将编译成: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+/* 你可以使用mixin来创建一个快捷属性。*/
+
+@mixin size($width, $height) {
+	width: $width;
+	height: $height;
+}
+
+/* 你可以通过传入width和height参数来调用它。*/
+
+.rectangle {
+	@include size(100px, 60px);
+}
+
+.square {
+	@include size(40px, 40px);
+}
+
+/* 编译成: */
+.rectangle {
+  width: 100px;
+  height: 60px;
+}
+
+.square {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+/* 函数
+============================== */
+
+
+
+/* Sass提供的函数可以用来完成各种各样的任务。
+   考虑以下情况 */
+
+/* 函数可以通过其名称及传入其所需的参数来调用 */
+body {
+  width: round(10.25px);
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25);
+}
+
+/* 编译成: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* 你也可以定义你自己的函数。函数非常类似于mixin。
+   当你在函数和mixin之间抉择时，记住mixin最适合于创建CSS而函数更适合于
+   处理那些可能在你的Sass代码中使用的逻辑。'数学运算符'部分的例子
+   是转成可重用函数的最理想选择。 */
+
+/* 该函数将接收一个目标尺寸大小和父结点尺寸大小，然后计算并
+    返回百分数 */
+
+@function calculate-percentage($target-size, $parent-size) {
+  @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+  width: $main-content;
+}
+
+.sidebar {
+  width: calculate-percentage(300px, 960px);
+}
+
+/* 编译成: */
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+
+
+/* 扩展 (继承)
+============================== */
+
+
+
+/* 扩展是在选择子间共享属性的一种方法。 */
+
+.display {
+	@include size(5em, 5em);
+	border: 5px solid $secondary-color;
+}
+
+.display-success {
+	@extend .display;
+	border-color: #22df56;
+}
+
+/* 编译成: */
+.display, .display-success {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.display-success {
+  border-color: #22df56;
+}
+
+/* 扩展一条CSS语句优于创建一个mixin，
+   这是由Sass组合所有共享相同基样式的类的方式决定的。
+   如果使用mixin完成，width, height, 和border将会在
+   调用了该mixin的每条语句中重复。虽然它不至于会影响你的工作流，
+   但它会在由Sass编译器生成的的文件中添加不必要的代码。*/
+
+
+/* 嵌套
+============================== */
+
+
+
+/* Sass允许在选择子中嵌套选择子 */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;
+	}
+}
+
+/* '&'将被父选择子替换。*/
+/* 你也可以嵌套伪类。 */
+/* 注意过度嵌套将导致你的代码难以维护。
+最佳实践推荐在嵌套时不超过3层。
+例如： */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* 编译成： */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* 片段与导入
+============================== */
+
+
+
+/* Sass允许你创建片段文件。它有助于你的Sass代码保持模块化。
+   片段文件应该以 '_' 开头，例如 _reset.css。
+   片段不会输出到CSS中。*/
+
+/* 考虑以下的CSS，我们会将它们放入一个叫作_reset.css的文件中 */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Sass提供的@import能用来将片段导入到文件中。
+   它与传统的CSS @import语句不同，不需要通过
+   另外的HTTP请求来获取导入的文件。
+   Sass提取导入文件并将它与编译后的代码结合起来。 */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* 编译成: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* 占位符选择子
+============================== */
+
+
+
+/* 占位符在创建用于扩展的CSS语句时非常有用。
+   如果你想创建一条只通过@extend使用的CSS语句，你可以利用占位符来实现。
+   占位符以'%'而非'.'或'#'开头。占位符不会出现在编译后的CSS中 */
+
+%content-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  @extend %content-window;
+  background-color: #0000ff;
+}
+
+/* 编译成: */
+
+.message-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  background-color: #0000ff;
+}
+
+
+
+/* 数学运算
+============================== */
+
+
+
+/* Sass提供以下的运算符: +, -, *, /, 和 %。它们
+   相比于使用你事先手工计算好了的数值，它们
+   对于直接在你的Sass文件中计算数值很有用。
+   以下是设置一个简单的两列设计的例子。*/
+
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: $main-size;
+}
+
+.sidebar {
+  width: $sidebar-size;
+}
+
+.gutter {
+  width: $gutter;
+}
+
+/* 编译成： */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+```
+
+## SASS还是Sass?
+该语言的名字，“Sass”，是一个词，不是一个缩写。
+你有没想过Sass是否是一个缩写词？你可能没有，但我反正会告诉你。
+该语言的名字是一个单词，不是一个缩写词。
+由于人们老是将它写成"SASS"，语言的作者开玩笑地称它为"Syntactically Awesome StyleSheets"。
+
+
+## 实践Sass
+如果你想在你的浏览器中尝试Sass，参阅[SassMeister](http://sassmeister.com/)。
+你可以选用任一种语法，只需进到设置页然后选择Sass或SCSS。
+
+
+## 兼容性
+Sass可以用于任何项目中，只要你有程序能将它编译成CSS即可。你还需要验证你所使用的CSS是否与你的目标浏览器兼容。
+
+[QuirksMode CSS](http://www.quirksmode.org/css/)和[CanIUse](http://caniuse.com)对于检查兼容性来说都是不错的资源。
+
+
+## 延伸阅读资料
+* [Official Documentation](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) 上提供了教程(初学者-高级)和文章。
diff --git a/zh-cn/scala-cn.html.markdown b/zh-cn/scala-cn.html.markdown
index 508dd58e..f3327b5b 100644
--- a/zh-cn/scala-cn.html.markdown
+++ b/zh-cn/scala-cn.html.markdown
@@ -369,7 +369,7 @@ object Dog {
 
 // Case 类是有额外内建功能的类。Scala 初学者常遇到的问题之一便是何时用类
 // 和何时用 case 类。界线比较模糊，但通常类倾向于封装，多态和行为。类中的值
-// 的作用域一般为 private ， 只有方向是暴露的。case 类的主要目的是放置不可变
+// 的作用域一般为 private ， 只有方法是暴露的。case 类的主要目的是放置不可变
 // 数据。它们通常只有几个方法，且方法几乎没有副作用。
 case class Person(name: String, phoneNumber: String)
 
diff --git a/zh-cn/standard-ml-cn.html.markdown b/zh-cn/standard-ml-cn.html.markdown
new file mode 100644
index 00000000..269d6bc3
--- /dev/null
+++ b/zh-cn/standard-ml-cn.html.markdown
@@ -0,0 +1,438 @@
+---
+language: "Standard ML"
+contributors:
+    - ["Simon Shine", "http://shine.eu.org/"]
+    - ["David Pedersen", "http://lonelyproton.com/"]
+    - ["James Baker", "http://www.jbaker.io/"]
+    - ["Leo Zovic", "http://langnostic.inaimathi.ca/"]
+filename: standard-ml-cn.html
+translators:
+   - ["Buqian Zheng", "https://github.com/zhengbuqian"]
+lang: zh-cn
+---
+
+Standard ML是一门拥有类型推断和一些副作用的函数式编程语言。学习Standard ML的一些
+难点在于：递归、模式匹配和类型推断（猜测正确的类型但是决不允许隐式类型转换）。与Haskell的
+不同之处在于Standard ML拥有引用，允许对变量进行更新。
+
+```ocaml
+(* Standard ML的注释以 (* 开头，以 *) 结束。注释可以嵌套，也就意味着所有的 (* 标签都
+   需要由一个 *) 结束。这条注释就是两个嵌套的注释的例子。*)
+
+(* 一个Standard ML程序包括声明，例如值声明： *)
+val rent = 1200
+val phone_no = 5551337
+val pi = 3.14159
+val negative_number = ~15  (* 是的，一元运算符用波浪符号`~`表示 *)
+
+(* 你当然也可以显示的声明类型，但这并不是必须的，因为ML会自动推断出值的类型。*)
+val diameter = 7926 : int
+val e = 2.718 : real
+val name = "Bobby" : string
+
+(* 同样重要的还有函数： *)
+fun is_large(x : int) = if x > 37 then true else false
+
+(* 浮点数被叫做实数： "real". *)
+val tau = 2.0 * pi         (* 两个real可以相乘 *)
+val twice_rent = 2 * rent  (* 两个int也可以相乘 *)
+(* val meh = 1.25 * 10 *)  (* 但是你不能让int和real相乘。 *)
+val yeh = 1.25 * (Real.fromInt 10) (* ...除非你显示的把一个转换为另一个*)
+
+(* +, - 和 * 被重载过，所以可以作用于int和real。*)
+(* 但是除法有单独的运算符： *)
+val real_division = 14.0 / 4.0  (* 结果是 3.5 *)
+val int_division  = 14 div 4    (* 结果是 3， 向下取整 *)
+val int_remainder = 14 mod 4    (* 结果是 2， 因为 3*4 = 12 *)
+
+(* ~ 有时其实是函数 (比如被放在变量前面的时候) *)
+val negative_rent = ~(rent)  (* 即使rent是"real"也正确 *)
+
+(* 当然也有布尔值和相关的运算符 *)
+val got_milk = true
+val got_bread = false
+val has_breakfast = got_milk andalso got_bread  (* 'andalso' 是运算符 *)
+val has_something = got_milk orelse got_bread   (* 'orelse' 是运算符 *)
+val is_sad = not(has_something)                 (* not 是一个函数 *)
+
+(* 很多值都可以用判等性运算符进行比较： = 和 <> *)
+val pays_same_rent = (rent = 1300)  (* false *)
+val is_wrong_phone_no = (phone_no <> 5551337)  (* false *)
+
+(* <> 运算符就是其他大部分语言里的 != 。 *)
+(* 'andalso' 和 'orelse' 在很多其他语言里被叫做 && 和 || 。 *)
+
+(* 实际上，上面大部分的圆括号都是不需要的。比如表达上面内容的一些不同的方式： *)
+fun is_large x = x > 37  
+val is_sad = not has_something
+val pays_same_rent = rent = 1300  (* 看起来很奇怪，但是就是这样的。 *)
+val is_wrong_phone_no = phone_no <> 5551337
+val negative_rent = ~rent  (* ~ rent (注意空格) 也正确 *)
+
+(* 圆括号大部分时候用来把东西们组合在一起 *)
+val some_answer = is_large (5 + 5)      (* 没有圆括号的话会出错！ *)
+(* val some_answer = is_large 5 + 5 *)  (* 会被理解为： (is_large 5) + 5. 错了！ *)
+
+(* 除了boolean, int, real，Standard ML也有char和string *)
+val foo = "Hello, World!\n"  (* \n是换行的转移字符 *)
+val one_letter = #"a"        (* 这种酷炫的语法表示一个字符a *)
+
+val combined = "Hello " ^ "there, " ^ "fellow!\n"  (* 拼接字符串 *)
+
+val _ = print foo       (* 你可以打印一些东西，这儿我们队打印的结果并不感兴趣，因此 *)
+val _ = print combined  (* 用 _ 把结果丢掉了 *)
+(* val _ = print one_letter *)  (* 只有字符串才能被这样打印 *)
+
+
+val bar = [ #"H", #"e", #"l", #"l", #"o" ]  (* SML 也有列表！ *)
+(* val _ = print bar *)  (* 然而列表和string是不同的 *)
+
+(* 当然这二者可以相互转换。String是一个库，implode和size是这个库里接受string作为
+   参数的函数。*)
+val bob = String.implode bar          (* 结果是 "Hello" *)
+val bob_char_count = String.size bob  (* 结果是 5 *)
+val _ = print (bob ^ "\n")            (* 为了好看加了个换行符 *)
+
+(* 列表可以包含任意类型的元素 *)
+val numbers = [1, 3, 3, 7, 229, 230, 248]  (* : int list *)
+val names = [ "Fred", "Jane", "Alice" ]    (* : string list *)
+
+(* 列表甚至可以包含列表！ *)
+val groups = [ [ "Alice", "Bob" ],
+               [ "Huey", "Dewey", "Louie" ],
+               [ "Bonnie", "Clyde" ] ]     (* : string list list *)
+
+val number_count = List.length numbers     (* 结果是 7 *)
+
+(* 你可以使用 :: 操作符把单个值放到同样类型列表的最前面。
+   :: 叫做con操作符（名字来自Lisp） *)
+val more_numbers = 13 :: numbers  (* 结果是 [13, 1, 3, 3, 7, ...] *)
+val more_groups  = ["Batman","Superman"] :: groups
+
+(* 拥有同样类型元素的列表可以使用 @ 操作符连接起来 *)
+val guest_list = [ "Mom", "Dad" ] @ [ "Aunt", "Uncle" ]
+
+(* 使用 :: 操作符也能完成这项工作。但是这有点绕，因为左手边必须是单个元素
+   而右边必须是这种元素的列表 *)
+val guest_list = "Mom" :: "Dad" :: [ "Aunt", "Uncle" ]
+val guest_list = "Mom" :: ("Dad" :: ("Aunt" :: ("Uncle" :: [])))
+
+(* 如果你有很多同样类型的列表，也可以整个拼接成一个。 *)
+val everyone = List.concat groups  (* [ "Alice", "Bob", "Huey", ... ] *)
+
+(* 列表可以包含任意（无限）数量的元素 *)
+val lots = [ 5, 5, 5, 6, 4, 5, 6, 5, 4, 5, 7, 3 ]  (* still just an int list *)
+
+(* 但是列表只能包含一种类型的元素 *)
+(* val bad_list = [ 1, "Hello", 3.14159 ] : ??? list *)
+
+(* 而元组Tuples则可以包含有限固定数量的不同类型的元素 *)
+val person1 = ("Simon", 28, 3.14159)  (* : string * int * real *)
+
+(* 你甚至可以让列表和元组相互嵌套 *)
+val likes = [ ("Alice", "ice cream"),
+              ("Bob",   "hot dogs"),
+              ("Bob",   "Alice") ]     (* : (string * string) list *)
+
+val mixup = [ ("Alice", 39),
+              ("Bob",   37),
+              ("Eve",   41) ]  (* : (string * int) list *)
+
+val good_bad_stuff =
+  (["ice cream", "hot dogs", "chocolate"],
+   ["liver", "paying the rent" ])           (* : string list * string list *)
+
+(* 记录Record是每个位置带名字的元组 *)
+
+val rgb = { r=0.23, g=0.56, b=0.91 } (* : {b:real, g:real, r:real} *)
+
+(* 使用Record时不需要提前声明每个位置的名字。 有不同名字的Record属于不同的类型
+   即使他们的值的类型是相同的。比如说：*)
+val Hsl = { H=310.3, s=0.51, l=0.23 } (* : {H:real, l:real, s:real} *)
+val Hsv = { H=310.3, s=0.51, v=0.23 } (* : {H:real, s:real, v:real} *)
+
+(* ...如果你想判断 `Hsv = Hsl` 或者 `rgb = Hsl` 的话，会得到一个类型错误。虽然他们都包含3个
+   real，但是由于名字不同，其类型也不同。 *)
+
+(* 可以使用 # 符号取出元组的值 *)
+
+val H = #H Hsv (* : real *)
+val s = #s Hsl (* : real *)
+
+(* 函数！ *)
+fun add_them (a, b) = a + b    (* 一个简单的加法函数 *)
+val test_it = add_them (3, 4)  (* 结果是 7 *)
+
+(* 复杂函数通常会为了可读性写成多行 *)
+fun thermometer temp =
+    if temp < 37
+    then "Cold"
+    else if temp > 37
+         then "Warm"
+         else "Normal"
+
+val test_thermo = thermometer 40  (* 结果是 "Warm" *)
+
+(* if 实际上是表达式而不是声明。一个函数体只可以包含一个表达式。但是还是有一些小技巧
+   让一个函数做更多的事。 *)
+
+(* 函数也可以使用调用自己的结果 (递归！) *)
+fun fibonacci n =
+    if n = 0 then 0 else                   (* 终止条件 *)
+    if n = 1 then 1 else                   (* 终止条件 *)
+    fibonacci (n - 1) + fibonacci (n - 2)  (* 递归 *)
+
+(* 有的时候，手写出递归函数的执行过程能帮助理解递归概念：
+
+ fibonacci 4
+   ~> fibonacci (4 - 1) + fibonacci (4 - 2)
+   ~> fibonacci 3 + fibonacci 2
+   ~> (fibonacci (3 - 1) + fibonacci (3 - 2)) + fibonacci 2
+   ~> (fibonacci 2 + fibonacci 1) + fibonacci 2
+   ~> ((fibonacci (2 - 1) + fibonacci (2 - 2)) + fibonacci 1) + fibonacci 2
+   ~> ((fibonacci 1 + fibonacci 0) + fibonacci 1) + fibonacci 2
+   ~> ((1 + fibonacci 0) + fibonacci 1) + fibonacci 2
+   ~> ((1 + 0) + fibonacci 1) + fibonacci 2
+   ~> (1 + fibonacci 1) + fibonacci 2
+   ~> (1 + 1) + fibonacci 2
+   ~> 2 + fibonacci 2
+   ~> 2 + (fibonacci (2 - 1) + fibonacci (2 - 2))
+   ~> 2 + (fibonacci (2 - 1) + fibonacci (2 - 2))
+   ~> 2 + (fibonacci 1 + fibonacci 0)
+   ~> 2 + (1 + fibonacci 0)
+   ~> 2 + (1 + 0)
+   ~> 2 + 1
+   ~> 3  第四个斐波那契数
+
+ *)
+
+(* 函数不能改变它引用的值。它只能暂时的使用同名的新变量来覆盖这个值。也就是说，变量其实是
+   常数，只有在递归的时候才表现的比较像变量。因此，变量也被叫做值绑定。举个例子： *)
+
+val x = 42
+fun answer(question) =
+    if question = "What is the meaning of life, the universe and everything?"
+    then x
+    else raise Fail "I'm an exception. Also, I don't know what the answer is."
+val x = 43
+val hmm = answer "What is the meaning of life, the universe and everything?"
+(* 现在 hmm 的值是 42。  这是因为函数 answer 引用的x是函数定义之前的x。 *)
+
+(* 函数通过接受一个元组来接受多个参数。 *)
+fun solve2 (a : real, b : real, c : real) =
+    ((~b + Math.sqrt(b * b - 4.0 * a * c)) / (2.0 * a),
+     (~b - Math.sqrt(b * b - 4.0 * a * c)) / (2.0 * a))
+
+(* 有时候同样的计算会被计算多次，因此把结果保存下来以重复使用是很有必要的。
+   这时可以使用 let 绑定。 *)
+fun solve2 (a : real, b : real, c : real) =
+    let val discr  = b * b - 4.0 * a * c
+        val sqr = Math.sqrt discr
+        val denom = 2.0 * a
+    in ((~b + sqr) / denom,
+        (~b - sqr) / denom)
+    end
+
+(* 模式匹配是函数式编程的一个精巧的部分，它是实现 if 的另一种方式。  
+   斐波那契函数可以被重写为如下方式： *)
+fun fibonacci 0 = 0  (* 终止条件 *)
+  | fibonacci 1 = 1  (* 终止条件 *)
+  | fibonacci n = fibonacci (n - 1) + fibonacci (n - 2)  (* 递归 *)
+
+(* 模式匹配也可以用于比如元组、列表和记录的复合类型。"fun solve2 (a, b, c) = ..."
+   的写法实际上也是对于一个三元素元组的模式匹配。类似但是比较不直观的是你也可以从列表的开头
+   对列表元素进行匹配。 *)
+fun first_elem (x::xs) = x
+fun second_elem (x::y::xs) = y
+fun evenly_positioned_elems (odd::even::xs) = even::evenly_positioned_elems xs
+  | evenly_positioned_elems [odd] = []  (* 终止条件：丢弃结果 *)
+  | evenly_positioned_elems []    = []  (* 终止条件 *)
+
+(* 匹配记录的时候，比如使用每个位置的名字，每个位置的值都需要绑定，但是顺序并不重要。 *)
+
+fun rgbToTup {r, g, b} = (r, g, b)    (* fn : {b:'a, g:'b, r:'c} -> 'c * 'b * 'a *)
+fun mixRgbToTup {g, b, r} = (r, g, b) (* fn : {b:'a, g:'b, r:'c} -> 'c * 'b * 'a *)
+
+(* 如果传入参数 {r=0.1, g=0.2, b=0.3}，上面的两个函数都会返回 (0.1, 0.2, 0.3)。
+   但是传入参数 {r=0.1, g=0.2, b=0.3, a=0.4} 的话则会得到类型错误 *)
+
+(* 高阶函数： 可以接受其他函数作为参数的函数
+   函数只不过是另一种类型的值，不需要依附与一个名字而存在。
+   没有名字的函数被叫做匿名函数或者lambda表达式或者闭包（因为匿名函数也依赖于词法作用域）*)
+val is_large = (fn x => x > 37)
+val add_them = fn (a,b) => a + b
+val thermometer =
+    fn temp => if temp < 37
+               then "Cold"
+               else if temp > 37
+                    then "Warm"
+                    else "Normal"
+
+(* 下面的代码就是用了匿名函数，结果是 "ColdWarm" *)
+val some_result = (fn x => thermometer (x - 5) ^ thermometer (x + 5)) 37
+
+(* 这是一个作用于列表的高阶函数 *)
+(* map f l
+       把f从左至右作用于l的每一个元素，并返回结果组成的列表。 *)
+val readings = [ 34, 39, 37, 38, 35, 36, 37, 37, 37 ]  (* 先定义一个列表 *)
+val opinions = List.map thermometer readings (* 结果是 [ "Cold", "Warm", ... ] *)
+
+(* filter 函数用于筛选列表 *)
+val warm_readings = List.filter is_large readings  (* 结果是 [39, 38] *)
+
+(* 你也可以创建自己的高阶函数。函数也可以通过 curry 来接受多个参数。
+   从语法上来说，curry就是使用空格来分隔参数，而不是逗号和括号。 *)
+fun map f [] = []
+  | map f (x::xs) = f(x) :: map f xs
+
+(* map 的类型是 ('a -> 'b) -> 'a list -> 'b list ，这就是多态。 *)
+(* 'a 被叫做类型变量 *)
+
+
+(* 函数可以被声明为中缀的。 *)
+val plus = add_them   (* plus 现在和 add_them 是同一个函数。 *)
+infix plus            (* plus 现在是一个中缀操作符。 *)
+val seven = 2 plus 5  (* seven 现在被绑定上了 7 *)
+
+(* 函数也可以在声明之前就声明为中缀 *)
+infix minus
+fun x minus y = x - y (* 这样有点不容易判断哪个是参数。 *)
+val four = 8 minus 4  (* four 现在被绑定上了 4 *)
+
+(* 中缀函数/操作符也可以使用 'op' 函数变回前缀函数。 *)
+val n = op + (5, 5)   (* n is now 10 *)
+
+(* 'op' 在结合高阶函数的时候非常有用，因为高阶函数接受的是函数而不是操作符作为参数。
+   大部分的操作符其实都是中缀函数。 *)
+(* foldl f init [x1, x2, ..., xn]
+       返回
+       f(xn, ...f(x2, f(x1, init))...)
+       或者如果列表为空时返回 init *)
+val sum_of_numbers = foldl op+ 0 [1, 2, 3, 4, 5]
+
+
+(* 可以很方便的使用 datatype 定义或简单或复杂的数据结构。 *)
+datatype color = Red | Green | Blue
+
+(* 这个函数接受 color 之一作为参数。 *)
+fun say(col) =
+    if col = Red then "You are red!" else
+    if col = Green then "You are green!" else
+    if col = Blue then "You are blue!" else
+    raise Fail "Unknown color"
+
+val _ = print (say(Red) ^ "\n")
+
+(* datatype 经常和模式匹配一起使用。 *)
+fun say Red   = "You are red!"
+  | say Green = "You are green!"
+  | say Blue  = "You are blue!"
+  | say _     = raise Fail "Unknown color"
+
+
+(* 一个二叉树 datatype *)
+datatype 'a btree = Leaf of 'a
+                  | Node of 'a btree * 'a * 'a btree (* 三个参数的构造器 *)
+
+(* 一颗二叉树： *)
+val myTree = Node (Leaf 9, 8, Node (Leaf 3, 5, Leaf 7))
+
+(* 画出来应该是这个样子：
+
+           8
+          / \
+ leaf -> 9   5
+            / \
+   leaf -> 3   7 <- leaf
+ *)
+
+(* 这个函数计算所有节点值的和。 *)
+fun count (Leaf n) = n
+  | count (Node (leftTree, n, rightTree)) = count leftTree + n + count rightTree
+
+val myTreeCount = count myTree  (* myTreeCount is now bound to 32 *)
+
+
+(* 异常！ *)
+(* 使用关键字 'raise' 来抛出异常： *)
+fun calculate_interest(n) = if n < 0.0
+                            then raise Domain
+                            else n * 1.04
+
+(* 使用 "handle" 关键字来处理异常 *)
+val balance = calculate_interest ~180.0
+              handle Domain => ~180.0    (* x 现在的值是 ~180.0 *)
+
+(* 某些异常还包含额外信息 *)
+(* 一些内建异常的例子： *)
+fun failing_function []    = raise Empty  (* 空列表异常 *)
+  | failing_function [x]   = raise Fail "This list is too short!"
+  | failing_function [x,y] = raise Overflow  (* 用作计算 *)
+  | failing_function xs    = raise Fail "This list is too long!"
+
+(* 使用 'handle' 时也可以使用模式匹配来保证异常都被处理。 *)
+val err_msg = failing_function [1,2] handle Fail _ => "Fail was raised"
+                                          | Domain => "Domain was raised"
+                                          | Empty  => "Empty was raised"
+                                          | _      => "Unknown exception"
+
+(* err_msg 的值会是 "Unknown exception" 
+   因为 Overflow 没有在模式中列出，因此匹配到了通配符_。 *)
+
+(* 我们也可以定义自己的异常 *)
+exception MyException
+exception MyExceptionWithMessage of string
+exception SyntaxError of string * (int * int)
+
+(* 文件读写！ *)
+(* 把一首诗写进文件： *)
+fun writePoem(filename) =
+    let val file = TextIO.openOut(filename)
+        val _ = TextIO.output(file, "Roses are red,\nViolets are blue.\n")
+        val _ = TextIO.output(file, "I have a gun.\nGet in the van.\n")
+    in TextIO.closeOut(file)
+    end
+
+(* 把一首诗读进一个字符串列表： *)
+fun readPoem(filename) =
+    let val file = TextIO.openIn filename
+        val poem = TextIO.inputAll file
+        val _ = TextIO.closeIn file
+    in String.tokens (fn c => c = #"\n") poem
+    end
+
+val _ = writePoem "roses.txt"
+val test_poem = readPoem "roses.txt"  (* gives [ "Roses are red,",
+                                                 "Violets are blue.",
+                                                 "I have a gun.",
+                                                 "Get in the van." ] *)
+
+(* 我们还可以创建指向值的引用，引用可以被更新。 *)
+val counter = ref 0 (* 使用 ref 函数创建一个引用。 *)
+
+(* 使用赋值运算符给引用复制 *)
+fun set_five reference = reference := 5
+
+(* 使用解引用运算符得到引用的值 *)
+fun equals_five reference = !reference = 5
+
+(* 递归很复杂的时候，也可以使用 while 循环 *)
+fun decrement_to_zero r = if !r < 0
+                          then r := 0
+                          else while !r >= 0 do r := !r - 1
+
+(* 这将会返回 unit （也就是什么都没有，一个0元素的元组） *)
+
+(* 要返回值，可以使用分号来分开表达式。 *)
+fun decrement_ret x y = (x := !x - 1; y)
+```
+
+## 阅读更多
+
+* 安装交互式编译器 (REPL)，如：
+  [Poly/ML](http://www.polyml.org/),
+  [Moscow ML](http://mosml.org),
+  [SML/NJ](http://smlnj.org/).
+* 上Coursera上的课程 [Programming Languages](https://www.coursera.org/course/proglang).
+* 购买 Larry C. Paulson 写的 *ML for the Working Programmer* 书。
+* 使用 [StackOverflow's sml 标签](http://stackoverflow.com/questions/tagged/sml).
diff --git a/zh-cn/swift-cn.html.markdown b/zh-cn/swift-cn.html.markdown
index 3efe4941..cba9252d 100644
--- a/zh-cn/swift-cn.html.markdown
+++ b/zh-cn/swift-cn.html.markdown
@@ -31,7 +31,7 @@ import UIKit
 
 // Swift2.0 println() 及 print() 已经整合成 print()。
 print("Hello, world") // 这是原本的 println()，会自动进入下一行
-print("Hello, world", appendNewLine: false) // 如果不要自动进入下一行，需设定进入下一行为 false
+print("Hello, world", terminator: "") // 如果不要自动进入下一行，需设定结束符为空串
 
 // 变量 (var) 的值设置后可以随意改变
 // 常量 (let) 的值设置后不能改变
@@ -171,8 +171,8 @@ while i < 1000 {
     i *= 2
 }
 
-// do-while 循环
-do {
+// repeat-while 循环
+repeat {
     print("hello")
 } while 1 == 2
 
@@ -212,11 +212,11 @@ default: // 在 Swift 里，switch 语句的 case 必须处理所有可能的情
 func greet(name: String, day: String) -> String {
     return "Hello \(name), today is \(day)."
 }
-greet("Bob", "Tuesday")
+greet("Bob", day: "Tuesday")
 
-// 函数参数前带 `#` 表示外部参数名和内部参数名使用同一个名称。
+// 第一个参数表示外部参数名和内部参数名使用同一个名称。
 // 第二个参数表示外部参数名使用 `externalParamName` ，内部参数名使用 `localParamName`
-func greet2(#requiredName: String, externalParamName localParamName: String) -> String {
+func greet2(requiredName requiredName: String, externalParamName localParamName: String) -> String {
     return "Hello \(requiredName), the day is \(localParamName)"
 }
 greet2(requiredName:"John", externalParamName: "Sunday")    // 调用时，使用命名参数来指定参数的值
@@ -235,8 +235,8 @@ print("Gas price: \(price)")
 // 可变参数
 func setup(numbers: Int...) {
     // 可变参数是个数组
-    let number = numbers[0]
-    let argCount = numbers.count
+    let _ = numbers[0]
+    let _ = numbers.count
 }
 
 // 函数变量以及函数作为返回值返回
@@ -257,7 +257,7 @@ func swapTwoInts(inout a: Int, inout b: Int) {
 }
 var someIntA = 7
 var someIntB = 3
-swapTwoInts(&someIntA, &someIntB)
+swapTwoInts(&someIntA, b: &someIntB)
 print(someIntB) // 7
 
 
@@ -286,17 +286,10 @@ numbers = numbers.map({ number in 3 * number })
 print(numbers) // [3, 6, 18]
 
 // 简洁的闭包
-numbers = sorted(numbers) { $0 > $1 }
-// 函数的最后一个参数可以放在括号之外，上面的语句是这个语句的简写形式
-// numbers = sorted(numbers, { $0 > $1 })
+numbers = numbers.sort { $0 > $1 }
 
 print(numbers) // [18, 6, 3]
 
-// 超级简洁的闭包，因为 `<` 是个操作符函数
-numbers = sorted(numbers, < )
-
-print(numbers) // [3, 6, 18]
-
 
 //
 // MARK: 结构体
@@ -305,7 +298,7 @@ print(numbers) // [3, 6, 18]
 // 结构体和类非常类似，可以有属性和方法
 
 struct NamesTable {
-    let names = [String]()
+    let names: [String]
 
     // 自定义下标运算符
     subscript(index: Int) -> String {
@@ -380,7 +373,7 @@ internal class Rect: Shape {
 
     func shrink() {
         if sideLength > 0 {
-            --sideLength
+            sideLength -= 1
         }
     }
 
@@ -516,7 +509,7 @@ protocol ShapeGenerator {
 // 一个类实现一个带 optional 方法的协议时，可以实现或不实现这个方法
 // optional 方法可以使用 optional 规则来调用
 @objc protocol TransformShape {
-    optional func reshaped()
+    optional func reshape()
     optional func canReshape() -> Bool
 }
 
@@ -528,9 +521,9 @@ class MyShape: Rect {
 
         // 在 optional 属性，方法或下标运算符后面加一个问号，可以优雅地忽略 nil 值，返回 nil。
         // 这样就不会引起运行时错误 (runtime error)
-        if let allow = self.delegate?.canReshape?() {
+        if let reshape = self.delegate?.canReshape?() where reshape {
             // 注意语句中的问号
-            self.delegate?.reshaped?()
+            self.delegate?.reshape?()
         }
     }
 }
@@ -542,8 +535,8 @@ class MyShape: Rect {
 
 // 扩展: 给一个已经存在的数据类型添加功能
 
-// 给 Square 类添加 `Printable` 协议的实现，现在其支持 `Printable` 协议
-extension Square: Printable {
+// 给 Square 类添加 `CustomStringConvertible` 协议的实现，现在其支持 `CustomStringConvertible` 协议
+extension Square: CustomStringConvertible {
     var description: String {
         return "Area: \(self.getArea()) - ID: \(self.identifier)"
     }
@@ -567,8 +560,8 @@ print(14.multiplyBy(3)) // 42
 
 // 泛型: 和 Java 及 C# 的泛型类似，使用 `where` 关键字来限制类型。
 // 如果只有一个类型限制，可以省略 `where` 关键字
-func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
+func findIndex<T: Equatable>(array: [T], _ valueToFind: T) -> Int? {
+    for (index, value) in array.enumerate() {
         if value == valueToFind {
             return index
         }
diff --git a/zh-cn/typescript-cn.html.markdown b/zh-cn/typescript-cn.html.markdown
new file mode 100644
index 00000000..2651b1cb
--- /dev/null
+++ b/zh-cn/typescript-cn.html.markdown
@@ -0,0 +1,173 @@
+---
+language: TypeScript
+category: language
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Shawn Zhang", "https://github.com/shawnzhang009"]
+filename: learntypescript-cn.ts
+lang: zh-cn
+---
+
+TypeScript是一门为开发大型JavaScript应用而设计的语言。TypeScript在JavaScript的基础上增加了类、模块、接口、泛型和静态类型（可选）等常见的概念。它是JavaScript的一个超集：所有JavaScript代码都是有效的TypeScript代码，所以任何JavaScript项目都可以无缝引入TypeScript. TypeScript编译器会把TypeScript代码编译成JavaScript代码。
+
+本文只关注TypeScript额外增加的区别于[JavaScript](../javascript-cn/)的语法，.
+
+如需测试TypeScript编译器，你可以在[Playground](http://www.typescriptlang.org/Playground)码代码，它会自动编译成JavaScript代码然后直接显示出来。
+
+```js
+// TypeScript有三种基本类型
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// 如果不知道是什么类型，可以使用"any"(任意)类型
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // 亦可，定义为布尔型
+
+// 对于集合的声明, 有类型化数组和泛型数组
+var list: number[] = [1, 2, 3];
+// 另外一种，使用泛型数组
+var list: Array<number> = [1, 2, 3];
+
+// 枚举：
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// 最后，"void"用于函数没有任何返回的特殊情况下
+function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!");
+}
+
+// 函数是"第一等公民"(first class citizens), 支持使用箭头表达式和类型推断
+
+// 以下是相等的，TypeScript编译器会把它们编译成相同的JavaScript代码
+var f1 = function(i: number): number { return i * i; }
+// 返回推断类型的值
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// 返回推断类型的值
+var f4 = (i: number) => { return i * i; }
+// 返回推断类型的值, 单行程式可以不需要return关键字和大括号
+var f5 = (i: number) =>  i * i;
+
+// 接口是结构化的，任何具有这些属性的对象都与该接口兼容
+interface Person {
+  name: string;
+  // 可选属性，使用"?"标识
+  age?: number;
+  // 函数
+  move(): void;
+}
+
+// 实现"Person"接口的对象，当它有了"name"和"move"方法之后可被视为一个"Person"
+var p: Person = { name: "Bobby", move: () => {} };
+// 带了可选参数的对象
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// 因为"age"不是"number"类型所以这不是一个"Person"
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// 接口同样可以描述一个函数的类型
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// 参数名并不重要，参数类型才是重要的
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// 类 - 成员默认为公共的(public)
+class Point {
+  // 属性
+  x: number;
+
+  // 构造器 - 这里面的public/private关键字会为属性生成样板代码和初始化值
+  // 这个例子中，y会被同x一样定义，不需要额外代码
+  // 同样支持默认值
+
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
+
+  // 函数
+  dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+  // 静态成员
+  static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y为0
+
+// 继承
+class Point3D extends Point {
+  constructor(x: number, y: number, public z: number = 0) {
+    super(x, y); // 必须显式调用父类的构造器
+  }
+
+  // 重写
+  dist() {
+    var d = super.dist();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// 模块, "."可以作为子模块的分隔符
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// 引入模块并定义本地别名
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// 泛型
+// 类
+class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+// 接口
+interface Pair<T> {
+  item1: T;
+  item2: T;
+}
+
+// 以及函数
+var pairToTuple = function<T>(p: Pair<T>) {
+  return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// 引用定义文件
+// <reference path="jquery.d.ts" />
+
+// 模板字符串(使用反引号的字符串)
+// 嵌入变量的模板字符串
+var name = 'Tyrone';
+var greeting = `Hi ${name}, how are you?`
+// 有多行内容的模板字符串
+var multiline = `This is an example
+of a multiline string`;
+
+```
+
+## 参考资料
+ * [TypeScript官网](http://www.typescriptlang.org/)
+ * [TypeScript语言规范说明书(pdf)](http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - TypeScript介绍](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [GitHub源码](https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - 类型定义仓库](http://definitelytyped.org/)
diff --git a/zh-cn/vim-cn.html.markdown b/zh-cn/vim-cn.html.markdown
new file mode 100644
index 00000000..22dbace6
--- /dev/null
+++ b/zh-cn/vim-cn.html.markdown
@@ -0,0 +1,238 @@
+---
+category: tool
+tool: vim
+filename: LearnVim-cn.txt
+contributors:
+   - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+   - ["Jiang Haiyun", "https://github.com/haiiiiiyun"]
+lang: zh-cn
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) 是 Unix 上的流行编辑器 vi 的克隆版本。这个文本编辑器
+是为性能和提升效率而设计的，并且在大多数基于 unix 的系统上普遍存在。
+它有大量的快捷键可用来快速导航到文件的特定位置，以便进行快速编辑。
+
+## Vim 导航基础
+
+```
+    vim <filename>   # 在 Vim 中打开 <filename>
+    :q               # 退出 Vim
+    :w               # 保存当前文件
+    :wq              # 保存文件并退出 Vim 
+    :q!              # 退出 Vim 并且不保存文件
+                     # ! *强制* 执行 :q， 因此没有保存就退出 Vim
+    :x               # 保存文件并且退出 Vim， 是 :wq 的简写版本
+
+    u                # 撤销
+    CTRL+R           # 重做
+
+    h                # 左移一个字符
+    j                # 下移一行
+    k                # 上移一行
+    l                # 右移一个字符
+
+    # 在行内移动
+
+    0                # 移到行首
+    $                # 移到行尾
+    ^                # 移到行内的第一个非空白字符处
+
+    # 在文本中查找
+
+    /word            # 光标之后的所有该词都高亮显示
+    ?word            # 光标之前的所有该词都高亮显示
+    n                # 查找后将光标移到该词的下一个出现位置
+    N                # 光标移到该词的上一个出现位置
+
+    :%s/foo/bar/g    # 将文件每一行上的所有 'foo' 都改成 'bar'
+    :s/foo/bar/g     # 将当前行上的所有 'foo' 都改成 'bar'
+
+    # 跳到字符处
+
+    f<字符>         # 向前跳移到 <字符> 上
+    t<字符>         # 向前跳移到 <字符> 的左侧
+
+    # 例如，    
+    f<               # 向前跳移到 < 上
+    t<               # 向前跳移到 < 的左侧
+    
+    # 按词移动
+    # 默认一个单词由字母，数字和下划线组成
+
+    w                # 移动到下一个词首
+    b                # 移动到前一个词首
+    e                # 移动到下一个词尾
+    
+
+    # 移动的其它命令
+
+    gg               # 移到文件顶部
+    G                # 移到文件末尾
+    :NUM             # 移到第 NUM 行 (NUM 是任意数字)
+    H                # 移到屏幕顶部
+    M                # 移到屏幕中间位置
+    L                # 移到屏幕末尾
+```
+
+## 模式:
+
+Vim 基于 **模式** 这个概念。
+
+命令模式 - Vim 启动后就处于这个模式，用于导航和操作命令
+插入模式 - 用于在你的文件中进行修改
+可视模式 - 用于高亮文本并对它们进行操作
+Ex 模式  - 用于跳到底部的 ':' 提示行上输入命令
+
+```
+    i                # 在光标位置前，将 Vim 切换到插入模式
+    a                # 在光标位置后，将 Vim 切换到插入模式
+    v                # 将 Vim 切换到可视模式
+    :                # 将 Vim 切换到 ex 模式
+    <esc>            # 无论你当前处于什么模式，都返回到命令模式
+
+    # 复制和粘贴文本
+
+    y                # 复制所选的内容
+    yy               # 复制当前行
+    d                # 删除所选的内容
+    dd               # 删除当前行
+    p                # 在当前光标位置后粘贴复制的文本
+    P                # 在当前光标位置前粘贴复制的文本
+    x                # 删除当前光标位置处的字符
+```
+
+## Vim 的 '语法'
+
+Vim 可以被认为是按 '动词-修饰词-名词' 格式编排的一组命令：
+
+动词     - 你的动作
+修饰词   - 你如何执行你的动作
+名词     - 你的动作所作用于的对象
+
+关于 '动词'，'修饰词'，和 '名词' 的几个重要例子：
+
+```
+    # '动词'
+    
+    d                # 删除
+    c                # 修改
+    y                # 复制
+    v                # 可视化选择
+
+    # '修饰词'
+
+    i                # 内部的
+    a                # 周围的
+    NUM              # 数字 (NUM 是任意数字)
+    f                # 查找文本并位于其上
+    t                # 查找文本并停于其前面
+    /                # 从光标处开始查找字符串
+    ?                # 在光标前查找字符串
+
+    # '名词'
+
+    w                # 词
+    s                # 句子
+    p                # 段落
+    b                # 块
+    
+    # 示例 '语句' 或命令
+
+    d2w              # 删除 2 个词
+    cis              # 修改段落内的内容
+    yip              # 复制段落内的内容 (复制你所在的段落)
+    ct<              # 修改直到括号开启处
+                     # 对你的当前位置直到下个括号开启处的内容进行修改
+    d$               # 删除直到行尾
+```
+
+## 一些快捷键和技巧
+
+        <!--TODO: Add more!-->
+```
+    >                # 将所选内容缩进一级
+    <                # 将所选内容取消缩进一级
+    :earlier 15m     # 将文档还原到 15 分钟前的状态
+    :later 15m       # 逆转上述命令
+    ddp              # 相邻行交换位置，先 dd 再 p
+    .                # 重复之前动作
+```
+
+## 宏
+
+宏基本上来说就是可录制的动作。
+当你开始录制宏时，它会记录你使用的 **每个** 动作和命令，
+直到你停止录制。当调用宏时，它会将这个完全相同的动作和命令序列
+再次应用于所选文本之上。
+
+```
+    qa               # 开始录制一个叫 'a' 的宏
+    q                # 停止录制
+    @a               # 重播宏
+```
+
+### 配置 ~/.vimrc
+
+.vimrc 可用于在启动时对 Vim 进行配置。
+
+这里是一个示例 ~/.vimrc 文件：
+
+```
+" 示例 ~/.vimrc
+" 2015.10 
+
+" 需要 Vim iMproved 版本
+set nocompatible
+
+" 根据文件名检测文件类型，以便能进行智能自动缩进等操作。
+filetype indent plugin on
+
+" 开启语法高亮
+syntax on
+
+" 更好的命令行补全
+set wildmenu
+
+" 除了当使用大写字母时使用大小写无关查找
+set ignorecase
+set smartcase
+
+" 当新开一行时，如果没有开启文件特定的缩进规则，
+" 则缩进保持与你当前行一致
+set autoindent
+
+" 在左侧显示行号
+set number
+
+" 缩进选项，根据个人偏好进行修改
+
+" 每个 TAB 的可视空格数
+set tabstop=4
+
+" 编辑时 TAB 对应的空格数
+set softtabstop=4
+
+" 当使用缩进操作 (>> 和 <<) 时缩进的空格数
+set shiftwidth=4
+
+" 将 TAB 转换成空格
+set expandtab
+
+" 为缩进和对齐开启智能化的 TAB 和空格切换功能
+set smarttab
+```
+
+### 参考
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
diff --git a/zh-cn/visualbasic-cn.html.markdown b/zh-cn/visualbasic-cn.html.markdown
index 95f01ed6..59f18fe2 100644
--- a/zh-cn/visualbasic-cn.html.markdown
+++ b/zh-cn/visualbasic-cn.html.markdown
@@ -3,7 +3,7 @@ language: Visual Basic
 contributors:
     - ["Brian Martin", "http://brianmartin.biz"]
 translators:
-    - ["Abner Chou", "http://github.com/NoahDragon"]
+    - ["Abner Chou", "http://cn.abnerchou.me"]
 lang: zh-cn
 filename: learnvisualbasic.vb-cn
 ---
diff --git a/zh-cn/yaml-cn.html.markdown b/zh-cn/yaml-cn.html.markdown
index fc510eb5..bbda20e9 100644
--- a/zh-cn/yaml-cn.html.markdown
+++ b/zh-cn/yaml-cn.html.markdown
@@ -4,33 +4,36 @@ contributors:
   - ["Adam Brenecki", "https://github.com/adambrenecki"]
 translators:
   - ["Zach Zhang", "https://github.com/checkcheckzz"]
+  - ["Jiang Haiyun", "https://github.com/haiiiiiyun"]
 filename: learnyaml-cn.yaml
 lang: zh-cn
 ---
 
-YAML是一个数据序列化语言，被设计成人类直接可写可读的。
+YAML 是一个数据序列化语言，被设计成人类直接可写可读的。
 
-它是JSON的严格超集，增加了语法显著换行符和缩进，就像Python。但和Python不一样，
-YAML根本不容许文字制表符。
+它是 JSON 的严格超集，增加了语法显著换行符和缩进，就像 Python。但和 Python 不一样，
+YAML 根本不容许文字制表符。
 
 
 ```yaml
-# YAML中的注解看起来像这样。
+# YAML 中的注解看起来像这样。
 
 ################
-# 标量类型 #
+# 标量类型     #
 ################
 
-# 我们的根对象 (它们在整个文件里延续) 将会是一个地图，
+# 我们的根对象 (它们在整个文件里延续) 将会是一个映射，
 # 它等价于在别的语言里的一个字典，哈西表或对象。
 key: value
 another_key: Another value goes here.
 a_number_value: 100
+# 如果你想将数字 1 作为值，你必须要将它括在引号中。
+# 不然 YAML 解析器会假定它是一个布尔值 true。
 scientific_notation: 1e+12
 boolean: true
 null_value: null
 key with spaces: value
-# 注意到字符串不需要被引用。但是，它们可以被引用。
+# 注意到字符串不需要被括在引号中。但是，它们可以被括起来。
 "Keys can be quoted too.": "Useful if you want to put a ':' in your key."
 
 # 多行字符串既可以写成像一个'文字块'(使用 |)，
@@ -54,7 +57,7 @@ folded_style: >
         this text will appear over two lines.
 
 ####################
-# 集合类型 #
+# 集合类型         #
 ####################
 
 # 嵌套是通过缩进完成的。
@@ -64,18 +67,24 @@ a_nested_map:
     another_nested_map:
         hello: hello
 
-# 地图不用有字符串键值。
+# 映射的键值不必是字符串。
 0.25: a float key
 
-# 键值也可以是多行对象，用?表明键值的开始。
+# 键值也可以是复合型的，比如多行对象
+# 我们用 ? 后跟一个空格来表示一个复合键的开始。
 ? |
     This is a key
     that has multiple lines
 : and this is its value
 
-# YAML也容许键值是集合类型，但是很多语言将会抱怨。
+# YAML 也允许使用复杂键语法表示序列间的映射关系。
+# 但有些语言的解析器可能会不支持。
+# 一个例子：
+? - Manchester United
+  - Real Madrid
+: [ 2001-01-01, 2002-02-02 ]
 
-# 序列 (等价于表或数组) 看起来像这样：
+# 序列 (等价于列表或数组) 看起来像这样：
 a_sequence:
     - Item 1
     - Item 2
@@ -87,50 +96,75 @@ a_sequence:
         - This is a sequence
         - inside another sequence
 
-# 因为YAML是JSON的超集，你也可以写JSON风格的地图和序列：
+# 因为 YAML 是 JSON 的超集，你也可以写 JSON 风格的映射和序列：
 json_map: {"key": "value"}
 json_seq: [3, 2, 1, "takeoff"]
 
 #######################
-# 其余的YAML特点 #
+# 其余的 YAML 特性    #
 #######################
 
-# YAML还有一个方便的特点叫'锚'，它让你简单地在整个文件里重复内容。
-# 两个键值将会有相同的值：
+# YAML 还有一个方便的特性叫 '锚'，它能让你很容易在文档中进行文本复用。
+# 如下两个键会有相同的值：
 anchored_content: &anchor_name This string will appear as the value of two keys.
 other_anchor: *anchor_name
 
-# YAML还有标签，你可以用它显示地声明类型。
+# 锚也可被用来复制/继承属性
+base: &base
+    name: Everyone has same name
+
+foo: &foo
+    <<: *base
+    age: 10
+
+bar: &bar
+    <<: *base
+    age: 20
+
+# foo 和 bar 将都含有 name: Everyone has same name
+
+# YAML 还有标签，你可以用它显示地声明类型。
 explicit_string: !!str 0.5
-# 一些解析器实现特定语言的标签，就像这个为了Python的复数类型。
+# 一些解析器实现特定语言的标签，就像这个针对 Python 的复数类型。
 python_complex_number: !!python/complex 1+2j
 
+# 我们也可以在 YAML 的复合键中使用特定语言的标签
+? !!python/tuple [5, 7]
+: Fifty Seven
+# 将会是 Python 中的  {(5, 7): 'Fifty Seven'}
+
 ####################
-# 其余的YAML类型 #
+# 其余的 YAML 类型 #
 ####################
 
-# 字符串和数字不是仅有的YAML可以理解的标量。
-# ISO 格式的日期和日期时间文字也是可以被解析的。
+# 除了字符串和数字，YAML 还能理解其它标量。
+# ISO 格式的日期和日期时间文本也可以被解析。
 datetime: 2001-12-15T02:59:43.1Z
 datetime_with_spaces: 2001-12-14 21:59:43.10 -5
 date: 2002-12-14
 
-# 这个!!binary标签表明一个字符串实际上是一个二进制blob的base64编码表示。
+# 这个 !!binary 标签表明这个字符串实际上
+# 是一个用 base64 编码表示的二进制 blob。
 gif_file: !!binary |
     R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
     OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
     +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
     AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
 
-# YAML还有一个集合类型，它看起来像这样：
+# YAML 还有一个集合类型，它看起来像这样：
 set:
     ? item1
     ? item2
     ? item3
 
-# 像Python一样，集合仅是有null数值的地图；上面的集合等价于：
+# 像 Python 一样，集合仅是值为 null 的映射；上面的集合等价于：
 set2:
     item1: null
     item2: null
     item3: null
 ```
+
+### 更多资源
+
++ [YAML official website](http://yaml.org/)
++ [Online YAML Validator](http://codebeautify.org/yaml-validator)
diff --git a/zh-cn/zfs-cn.html.markdown b/zh-cn/zfs-cn.html.markdown
new file mode 100644
index 00000000..fdf5277e
--- /dev/null
+++ b/zh-cn/zfs-cn.html.markdown
@@ -0,0 +1,397 @@
+---
+category: tool
+tool: zfs
+contributors:
+    - ["sarlalian", "http://github.com/sarlalian"]
+translators:
+    - ["Alan Cheng", "https://github.com/kedaio"]
+filename: LearnZfs-cn.txt
+lang: zh-cn
+---
+
+[ZFS](http://open-zfs.org/wiki/Main_Page)
+是重新思考与储存相关技术的结果，它把传统的文件系统和卷管理器集成到一个工具当中.
+ZFS不但有把它和传统存储系统分开来的特有术语，也有很多聚焦于可用性的功能。
+
+
+## ZFS概念
+
+### 虚拟设备（Virtual Devices，VDEV）
+
+对于操作系统来说，VDEV和传统的RAID阵列卡所呈现的raid设备类似。VDEV有几种不同的类型，每种类型
+都有自己的优势，包括冗余和速度。一般来说，VDEV的可靠性和安全性比阵列卡要好。因此使用ZFS时不
+建议使用阵列卡。让ZFS直接管理磁盘。
+
+VDEV的类型
+* stripe (条带。单个磁盘，没有冗余)
+* mirror (镜像。支持n-way镜像)
+* raidz
+	* raidz1 (一个奇偶校验磁盘, 类似于RAID 5)
+	* raidz2 (两个奇偶校验磁盘, 类似于RAID 6)
+	* raidz3 (三个奇偶校验磁盘, 没有类似RAID等级)
+* disk  （磁盘）
+* file (文件。不推荐在生产环境中使用，因为中间又多了一层不必要的文件系统)
+
+数据会以条带方式存储于存储池中的所有VDEV上。因此一个存储池中的VDEV越多，IOPS就越高。
+
+###  storage pool （存储池） 
+
+ZFS 使用存储池来作为底层存储提供者（VDEV）的抽象。这样可以把用户可见的文件系统和底层的物理磁盘
+布局分离开来。
+
+### ZFS 数据集（Dataset）
+
+ZFS 数据集类似于传统的文件系统（译者注：或者说是目录），但是提供了更多的功能。ZFS的很多优势也是
+在这一层体现出来的。数据集支持 [Copy on Write](https://en.wikipedia.org/wiki/Copy-on-write)
+快照, 配额, 压缩和重复消除（de-duplication）.
+
+
+### 限制
+
+一个目录最多可包含 2^48个文件, 每个文件最大可以是16 exabytes.  一个存储池最大可包含256 zettabytes 、
+(2^78) 的空间, 可以条带化地分布于2^64 设备上. 单一主机最多可以创建2^64个存储池。这些限制可以说是相
+当大。
+
+
+## 命令
+
+### 存储池
+
+Actions: （存储池操作） 
+* List   （列举）
+* Status （查看状态）
+* Destroy （删除）
+* Get/Set properties （获取/设置属性）
+
+List zpools （列举存储池（也叫zpool））
+
+```bash
+# 创建一个raidz类型的存储池(名称为bucket）
+$ zpool create bucket raidz1 gpt/zfs0 gpt/zfs1 gpt/zfs2
+
+# 列出所有存储池
+$ zpool list
+NAME    SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP  HEALTH  ALTROOT
+zroot   141G   106G  35.2G         -    43%    75%  1.00x  ONLINE  -
+
+# 列出某一存储池的详细信息
+$ zpool list -v zroot
+NAME                                     SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP HEALTH  ALTROOT
+zroot                                    141G   106G  35.2G         -    43%    75%  1.00x ONLINE  -
+  gptid/c92a5ccf-a5bb-11e4-a77d-001b2172c655   141G   106G  35.2G         -    43%    75%
+```
+
+Status of zpools （存储池状态）
+
+```bash
+# 获取全部zpool状态信息
+$ zpool status
+  pool: zroot
+ state: ONLINE
+  scan: scrub repaired 0 in 2h51m with 0 errors on Thu Oct  1 07:08:31 2015
+config:
+
+        NAME                                          STATE     READ WRITE CKSUM
+        zroot                                         ONLINE       0     0     0
+          gptid/c92a5ccf-a5bb-11e4-a77d-001b2172c655  ONLINE       0     0     0
+
+errors: No known data errors
+
+# 用scrub来更正存储池错误信息
+$ zpool scrub zroot
+$ zpool status -v zroot
+  pool: zroot
+ state: ONLINE
+  scan: scrub in progress since Thu Oct 15 16:59:14 2015
+        39.1M scanned out of 106G at 1.45M/s, 20h47m to go
+        0 repaired, 0.04% done
+config:
+
+        NAME                                          STATE     READ WRITE CKSUM
+        zroot                                         ONLINE       0     0     0
+          gptid/c92a5ccf-a5bb-11e4-a77d-001b2172c655  ONLINE       0     0     0
+
+errors: No known data errors
+```
+
+Properties of zpools （存储池属性）
+
+```bash
+
+# 获取某一存储池的全部属性。属性可能是系统提供，也可能是用户设置
+$ zpool get all zroot
+NAME   PROPERTY                       VALUE                          SOURCE
+zroot  size                           141G                           -
+zroot  capacity                       75%                            -
+zroot  altroot                        -                              default
+zroot  health                         ONLINE                         -
+...
+
+# 设置存储池属性，下例这是设置comment(备注)属性
+$ zpool set comment="Storage of mah stuff" zroot
+$ zpool get comment
+NAME   PROPERTY  VALUE                 SOURCE
+tank   comment   -                     default
+zroot  comment   Storage of mah stuff  local
+```
+
+Remove zpool （删除存储池）
+
+```bash
+$ zpool destroy test
+```
+
+
+### Datasets （数据集）
+
+Actions:   （数据集相关操作）
+* Create   （创建）
+* List     （列举）
+* Rename   （重命名）
+* Delete   （删除）
+* Get/Set properties   （获取/设置属性）
+
+Create datasets
+
+```bash
+# 创建数据集
+$ zfs create tank/root/data
+$ mount | grep data
+tank/root/data on /data (zfs, local, nfsv4acls)
+
+# 创建子数据集
+$ zfs create tank/root/data/stuff
+$ mount | grep data
+tank/root/data on /data (zfs, local, nfsv4acls)
+tank/root/data/stuff on /data/stuff (zfs, local, nfsv4acls)
+
+
+# 创建卷
+$ zfs create -V zroot/win_vm
+$ zfs list zroot/win_vm
+NAME                 USED  AVAIL  REFER  MOUNTPOINT
+tank/win_vm         4.13G  17.9G    64K  -
+```
+
+List datasets （列举数据集）
+
+```bash
+# 列出所有数据集
+$ zfs list
+NAME                                                                       USED  AVAIL  REFER  MOUNTPOINT
+zroot                                                                      106G  30.8G   144K  none
+zroot/ROOT                                                                18.5G  30.8G   144K  none
+zroot/ROOT/10.1                                                              8K  30.8G  9.63G  /
+zroot/ROOT/default                                                        18.5G  30.8G  11.2G  /
+zroot/backup                                                              5.23G  30.8G   144K  none
+zroot/home                                                                 288K  30.8G   144K  none
+...
+
+# 列举某一数据集的信息
+$ zfs list zroot/home
+NAME         USED  AVAIL  REFER  MOUNTPOINT
+zroot/home   288K  30.8G   144K  none
+
+# 列出快照
+$ zfs list -t snapshot
+zroot@daily-2015-10-15                                                                  0      -   144K  -
+zroot/ROOT@daily-2015-10-15                                                             0      -   144K  -
+zroot/ROOT/default@daily-2015-10-15                                                     0      -  24.2G  -
+zroot/tmp@daily-2015-10-15                                                           124K      -   708M  -
+zroot/usr@daily-2015-10-15                                                              0      -   144K  -
+zroot/home@daily-2015-10-15                                                             0      -  11.9G  -
+zroot/var@daily-2015-10-15                                                           704K      -  1.42G  -
+zroot/var/log@daily-2015-10-15                                                       192K      -   828K  -
+zroot/var/tmp@daily-2015-10-15                                                          0      -   152K  -
+```
+
+Rename datasets （重命名数据集）
+
+```bash
+$ zfs rename tank/root/home tank/root/old_home
+$ zfs rename tank/root/new_home tank/root/home
+```
+
+Delete dataset （删除数据集）
+
+```bash
+# 数据集如果有快照则无法删除
+zfs destroy tank/root/home
+```
+
+Get / set properties of a dataset （获取/设置数据集属性）
+
+```bash
+# 获取数据集全部属性
+$ zfs get all  zroot/usr/home                                                                                              │157 # Create Volume
+NAME            PROPERTY              VALUE                  SOURCE                                                                          │158 $ zfs create -V zroot/win_vm
+zroot/home      type                  filesystem             -                                                                               │159 $ zfs list zroot/win_vm
+zroot/home      creation              Mon Oct 20 14:44 2014  -                                                                               │160 NAME                 USED  AVAIL  REFER  MOUNTPOINT
+zroot/home      used                  11.9G                  -                                                                               │161 tank/win_vm         4.13G  17.9G    64K  -
+zroot/home      available             94.1G                  -                                                                               │162 ```
+zroot/home      referenced            11.9G                  -                                                                               │163
+zroot/home      mounted               yes                    -
+...
+
+# 获取数据集属性
+$ zfs get compression zroot/usr/home
+NAME            PROPERTY     VALUE     SOURCE
+zroot/home      compression  off       default
+
+# 设置数据集属性（下例为设置压缩属性compression）
+$ zfs set compression=gzip-9 mypool/lamb
+
+# 列举所有数据集的名称、配额和预留属性
+$ zfs list -o name,quota,reservation
+NAME                                                               QUOTA  RESERV
+zroot                                                               none    none
+zroot/ROOT                                                          none    none
+zroot/ROOT/default                                                  none    none
+zroot/tmp                                                           none    none
+zroot/usr                                                           none    none
+zroot/home                                                          none    none
+zroot/var                                                           none    none
+...
+```
+
+
+### Snapshots （快照）
+
+快照是ZFS 的一个非常重要的功能
+
+* 快照占用的空间等于它和原始数据的差异量
+* 创建时间以秒计
+* 恢复时间和写入速度相同
+* 易于自动化
+
+Actions:  （快照相关操作）
+* Create  （创建）
+* Delete  （删除）
+* Rename  （重命名）
+* Access snapshots  （访问）
+* Send / Receive    （发送/接收）
+* Clone             （克隆。译者注：关于clone和快照的区别可参看[这里](http://docs.oracle.com/cd/E19253-01/819-5461/gbcxz/index.html)）
+
+
+Create snapshots （创建快照）
+
+```bash
+# 为单一数据集创建快照
+zfs snapshot tank/home/sarlalian@now
+
+# 为数据集及其子集创建快照
+$ zfs snapshot -r tank/home@now
+$ zfs list -t snapshot
+NAME                       USED  AVAIL  REFER  MOUNTPOINT
+tank/home@now                 0      -    26K  -
+tank/home/sarlalian@now       0      -   259M  -
+tank/home/alice@now           0      -   156M  -
+tank/home/bob@now             0      -   156M  -
+...
+
+Destroy snapshots （删除快照）
+
+```bash
+# 如何删除快照
+$ zfs destroy tank/home/sarlalian@now
+
+# 删除某一数据集及其子集的快照
+$ zfs destroy -r tank/home/sarlalian@now
+
+```
+
+Renaming Snapshots （重命名）
+
+```bash
+# 重命名快照
+$ zfs rename tank/home/sarlalian@now tank/home/sarlalian@today
+$ zfs rename tank/home/sarlalian@now today
+
+# zfs rename -r tank/home@now @yesterday
+```
+
+Accessing snapshots  （访问快照）
+
+```bash
+# cd进入一个快照目录
+$ cd /home/.zfs/snapshot/
+```
+
+Sending and Receiving
+
+```bash
+# 备份快照到一个文件
+$ zfs send tank/home/sarlalian@now | gzip > backup_file.gz
+
+# 发送快照到另一个数据集
+$ zfs send tank/home/sarlalian@now | zfs recv backups/home/sarlalian
+
+# 发送快照到一个远程主机
+$ zfs send tank/home/sarlalian@now | ssh root@backup_server 'zfs recv tank/home/sarlalian'
+
+# 发送完整数据集及其快照到一个新主机
+$ zfs send -v -R tank/home@now | ssh root@backup_server 'zfs recv tank/home'
+```
+
+Cloneing Snapshots  （克隆快照）
+
+```bash
+# 克隆一个快照
+$ zfs clone tank/home/sarlalian@now tank/home/sarlalian_new
+
+# 提升克隆，让它不再依赖原始快照
+$ zfs promote tank/home/sarlalian_new
+```
+
+### 汇总
+
+下面这个脚本使用了FreeBSD, jails和ZFS，来自动在一个mysql群集的热备主机上为一个mysq staging数据库
+创建一份纯净的拷贝。
+
+```bash
+#!/bin/sh
+
+echo "==== Stopping the staging database server ===="
+jail -r staging
+
+echo "==== Cleaning up existing staging server and snapshot ===="
+zfs destroy -r zroot/jails/staging
+zfs destroy zroot/jails/slave@staging
+
+echo "==== Quiescing the slave database ===="
+echo "FLUSH TABLES WITH READ LOCK;" | /usr/local/bin/mysql -u root -pmyrootpassword -h slave
+
+echo "==== Snapshotting the slave db filesystem as zroot/jails/slave@staging ===="
+zfs snapshot zroot/jails/slave@staging
+
+echo "==== Starting the slave database server ===="
+jail -c slave
+
+echo "==== Cloning the slave snapshot to the staging server ===="
+zfs clone zroot/jails/slave@staging zroot/jails/staging
+
+echo "==== Installing the staging mysql config ===="
+mv /jails/staging/usr/local/etc/my.cnf /jails/staging/usr/local/etc/my.cnf.slave
+cp /jails/staging/usr/local/etc/my.cnf.staging /jails/staging/usr/local/etc/my.cnf
+
+echo "==== Setting up the staging rc.conf file ===="
+mv /jails/staging/etc/rc.conf.local /jails/staging/etc/rc.conf.slave
+mv /jails/staging/etc/rc.conf.staging /jails/staging/etc/rc.conf.local
+
+echo "==== Starting the staging db server ===="
+jail -c staging
+
+echo "==== Makes the staging database not pull from the master ===="
+echo "STOP SLAVE;" | /usr/local/bin/mysql -u root -pmyrootpassword -h staging
+echo "RESET SLAVE;" | /usr/local/bin/mysql -u root -pmyrootpassword -h staging
+```
+
+
+### 延伸阅读
+
+* [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
+* [FreeBSD Handbook on ZFS](https://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/zfs.html)
+* [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
+* [Oracle's Tuning Guide](http://www.oracle.com/technetwork/articles/servers-storage-admin/sto-recommended-zfs-settings-1951715.html)
+* [OpenZFS Tuning Guide](http://open-zfs.org/wiki/Performance_tuning)
+* [FreeBSD ZFS Tuning Guide](https://wiki.freebsd.org/ZFSTuningGuide)
diff --git a/zh-tw/bash-tw.html.markdown b/zh-tw/bash-tw.html.markdown
new file mode 100644
index 00000000..78b39f2d
--- /dev/null
+++ b/zh-tw/bash-tw.html.markdown
@@ -0,0 +1,377 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Etan Reisner", "https://github.com/deryni"]
+    - ["Jonathan Wang", "https://github.com/Jonathansw"]   
+    - ["Leo Rudberg", "https://github.com/LOZORD"]
+    - ["Betsy Lorton", "https://github.com/schbetsy"]
+    - ["John Detter", "https://github.com/jdetter"]
+translators:
+    - ["Jinchang Ye", "https://github.com/Alwayswithme"]
+    - ["Chunyang Xu", "https://github.com/XuChunyang"]
+    - ["Weihang Lo", "https://github.com/weihanglo"]
+filename: LearnBash-tw.sh
+lang: zh-tw
+---
+
+Bash 是一個爲 GNU 計劃編寫的 Unix shell，是 Linux 和 Mac OS X 下預設的 shell。
+以下大多數例子可以作爲腳本的一部分運行，也可直接在 shell 下互動執行。
+
+[更多資訊](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# 腳本的第一行叫 shebang，用來告知系統如何執行該腳本:
+# 參見： http://en.wikipedia.org/wiki/Shebang_(Unix)
+# 如你所見，註釋以 # 開頭，shebang 也是註釋。
+
+# 顯示 “Hello world!”
+echo Hello world!
+
+# 每一句指令以換行或分號隔開：
+echo 'This is the first line'; echo 'This is the second line'
+
+# 宣告一個變數：
+Variable="Some string"
+
+# 下面是錯誤的做法：
+Variable = "Some string"
+# Bash 會把 Variable 當做一個指令，由於找不到該指令，因此這裡會報錯。
+
+# 也不可以這樣：
+Variable= 'Some string'
+# Bash 會認爲 'Some string' 是一條指令，由於找不到該指令，這裡會再次報錯。
+# （這個例子中 'Variable=' 這部分會被當作僅對 'Some string' 起作用的賦值。）
+
+# 使用變數：
+echo $Variable
+echo "$Variable"
+echo '$Variable'
+# 當你賦值 (assign) 、匯出 (export)，或者以其他方式使用變數時，變數名前不加 $。
+# 如果要使用變數的值， 則要加 $。
+# 注意： ' (單引號) 不會展開變數。
+
+# 參數展開式 ${}:
+echo ${Variable}
+# 這是一個參數展開的簡單用法
+# 使用參數展開會得到該變數的值，也就是會「展開」或印出該值。
+# 在展開期間，可以修改該值或該參數。
+# 以下是修改參數展開式的範例：
+
+# 在變數內部進行字串代換
+echo ${Variable/Some/A}
+# 會把 Variable 中首次出現的 "some" 替換成 “A”。
+
+# 變數的截取
+Length=7
+echo ${Variable:0:Length}
+# 這樣僅會返回變數值的前7個字元
+
+# 變數的預設值
+echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
+# 對 null (Foo=) 和空字串 (Foo="") 起作用； 零（Foo=0）時返回0
+# 注意這僅返回預設值而不是改變變數的值
+
+# 括號展開 { }
+# 用以產生任意的字串
+echo {1..10}
+echo {a..z}
+# 這將會輸出該範圍內的起始值到最終值。
+
+# 內建變數：
+# 下面的內建變數很有用
+echo "Last program's return value: $?"
+echo "Script's PID: $$"
+echo "Number of arguments: $#"
+echo "Scripts arguments: $@"
+echo "Scripts arguments separated in different variables: $1 $2..."
+
+# 現在，我們知道變數如何使用與印出
+# 讓我們開始學習其他Bash基礎吧！
+
+# 使用 `pwd` 指令，可以得知當前工作目錄
+# `pwd` 意指 「印出工作目錄」(print working directory)。
+# 我們也可使用內建變數 `$PWD`。
+# 下列兩行指令等價：
+echo "I'm in $(pwd)" # 執行 `pwd` 且將該值內插至輸出中
+echo "I'm in $PWD" # 直接內插 `$PWD` 變數
+
+# 如果終端機上有太多輸出，`clear` 指令可以清除螢幕先前的輸出
+clear
+# Ctrl-L 也有相同的效果
+
+# 讀取輸入：
+echo "What's your name?"
+read Name # 這裡不需要宣告新變數
+echo Hello, $Name!
+
+# 一般 if 結構看起來像這樣：
+# 'man test' 可查看更多的信息
+if [ $Name != $USER ]
+then
+    echo "Your name isn't your username"
+else
+    echo "Your name is your username"
+fi
+
+# 注意： 如果 $Name 為空，bash會將該條件式解讀成：
+if [ != USER ]
+# 這是一個錯誤的語法
+# 所以，安全避免空變數的方法如下：
+if [ "$Name" != $USER ] ...
+# 如果 $Name 為空，該條件式將被視為：
+if [ "" != $USER]
+# 此條件式可正常運作
+
+
+# 根據上一個指令執行結果決定是否執行下一個指令
+echo "Always executed" || echo "Only executed if first command fails"
+echo "Always executed" && echo "Only executed if first command does NOT fail"
+
+# 在 if 語句中使用 && 和 || 需要多對方括號
+if [ $Name == "Steve" ] && [ $Age -eq 15 ]
+then
+    echo "This will run if $Name is Steve AND $Age is 15."
+fi
+
+if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
+then
+    echo "This will run if $Name is Daniya OR Zach."
+fi
+
+# 表達式的格式如下:
+echo $(( 10 + 5 ))
+
+# 與其他程式語言不同的是，bash 運行時依賴上下文。比如，使用 ls 時，列出當前目錄。
+ls
+
+# 指令可以帶有選項：
+ls -l # 列出文件和目錄的詳細信息
+ls -t # 以最後修改時間，對文件與目錄排序
+ls -R # 遞迴列出目錄與次目錄的內容
+
+# 前一個指令的輸出可以當作後一個指令的輸入。grep 用來匹配字串。
+# 用下面的指令列出當前目錄下所有的 txt 文件：
+ls -l | grep "\.txt"
+
+# 使用 `cat` 將檔案印出在標準輸出中：
+cat file.txt
+
+# 使用 `cat` 讀取檔案
+Contents=$(cat file.txt)
+echo "START OF FILE\n$Contents\nEND OF FILE"
+
+# 使用 `cp` 複製檔案或目錄，`cp` 會創建新版本的來源檔案／目錄
+# 所以，編輯副本不會影響到初始來源（反之亦然）。
+# 注意，如果目的地已存在該檔案／目錄，該檔案／目錄將會被覆寫
+cp srcFile.txt clone.txt
+cp -r srcDirectory/ dst/ # 遞迴複製
+
+# 如需在兩台電腦間交換檔案，請查看 `scp` 或 `sftp`。
+# `scp` 與 `cp` 相似。
+# `sftp` 則有更高的互動性（與 `ftp` 相似）。
+
+# 使用 `mv` 來移動目錄與檔案。
+# `mv` 與 `cp` 相似，但會刪除來源。
+# `mv` 也可以用來重新命名檔案／目錄！
+mv s0urc3.txt dst.txt
+
+# 由於 bash 運行時依賴當前目錄的上下文，
+# 需要在其他目錄執行指令時，可使用 `cd` 改變當前目錄：
+cd ~    # 到家目錄
+cd ..   # 到上一層目錄
+        # (^^例如, 從 /home/username/Downloads 到 /home/username)
+cd /home/username/Documents   # 到指定目錄
+cd ~/Documents/..    # 仍位於家目錄，不是嗎？
+
+# 使用子殼程式 (subshells) 在不同目錄間工作
+(echo "First, I'm here: $PWD") && (cd someDir; echo "Then, I'm here: $PWD")
+pwd # 仍在第一個目錄
+
+# 使用 `mkdir` 來建立新的目錄
+mkdir myNewDir
+# 使用 `-p` 選項參數，將會自動創建路徑中不存在的目錄
+mkdir -p myNewDir/with/intermediate/directories
+
+# 將指令的輸出輸入重新導向（標準輸入、標準輸出、標準錯誤輸出）。
+# 從標準輸入讀取資料，直到 ^EOF$ （End-of-file)，且將讀取的資料覆寫至hello.py
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# 重新導向可以到標準輸出（stdout），標準輸入（stdin）和標準錯誤輸出（stderr）。
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# `>` 會覆蓋已存在的文件， `>>` 會以累加的方式輸出文件中。
+python hello.py >> "output.out" 2>> "error.err"
+
+# 覆蓋 output.out , 追加 error.err 並統計行數
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# 運行指令並印出文件描述 （比如 /dev/fd/123）
+# 具體可查看： man fd
+echo <(echo "#helloworld")
+
+# 以 "#helloworld" 覆蓋 output.out:
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# 清理臨時文件並顯示詳情（增加 '-i' 選項啓用互動模式）
+# 警告： `rm` 指令無法復原
+rm -v output.out error.err output-and-error.log
+rm -r tempDir/ # 遞迴刪除
+
+# 一個指令可用 $( ) 嵌套在另一個指令內部：
+# 以下的指令會印出當前目錄下的目錄和文件總數
+echo "There are $(ls | wc -l) items here."
+
+# 反引號 `` 起相同作用，但不允許嵌套
+# 優先使用 $(  ).
+echo "There are `ls | wc -l` items here."
+
+# Bash 的 case 語句與 Java 和 C++ 中的 switch 語句類似:
+case "$Variable" in
+    # 列出需要匹配的字串
+    0) echo "There is a zero.";;
+    1) echo "There is a one.";;
+    *) echo "It is not null.";;
+esac
+
+# 循環遍歷給定的參數序列:
+# 變數$Variable 的值會被印出 3 次。
+for Variable in {1..3}
+do
+    echo "$Variable"
+done
+
+# 或傳統的 “for循環” ：
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# 也可以用於文件
+# 用 cat 輸出 file1 和 file2 內容
+for Variable in file1 file2
+do
+    cat "$Variable"
+done
+
+# 或作用於其他命令的輸出
+# 對 ls 輸出的文件執行 cat 指令。
+for Output in $(ls)
+do
+    cat "$Output"
+done
+
+# while 循環：
+while [ true ]
+do
+    echo "loop body here..."
+    break
+done
+
+# 你也可以使用函數
+# 定義函數：
+function foo ()
+{
+    echo "Arguments work just like script arguments: $@"
+    echo "And: $1 $2..."
+    echo "This is a function"
+    return 0
+}
+
+# 更簡單的方法
+bar ()
+{
+    echo "Another way to declare functions!"
+    return 0
+}
+
+# 呼叫函數
+foo "My name is" $Name
+
+# 有很多有用的指令需要學習:
+# 打印 file.txt 的最後 10 行
+tail -n 10 file.txt
+# 印出 file.txt 的前 10 行
+head -n 10 file.txt
+# 將 file.txt 按行排序
+sort file.txt
+# 報告或忽略重複的行，用選項 -d 印出重複的行
+uniq -d file.txt
+# 打印每行中 ',' 之前內容
+cut -d ',' -f 1 file.txt
+# 將 file.txt 文件所有 'okay' 替換爲 'great', （兼容正規表達式）
+sed -i 's/okay/great/g' file.txt
+# 將 file.txt 中匹配正則的行打印到標準輸出
+# 這裡印出以 "foo" 開頭, "bar" 結尾的行
+grep "^foo.*bar$" file.txt
+# 使用選項 "-c" 統計行數
+grep -c "^foo.*bar$" file.txt
+# 其他實用的選項參數
+grep -r "^foo.*bar$" someDir/ # 遞迴的 `grep`
+grep -n "^foo.*bar$" file.txt # 顯示行數
+grep -rI "^foo.*bar$" someDir/ # 遞迴的 `grep`, 但忽略二進位檔案
+# 同樣的搜尋，再過濾包含「baz」的行
+grep "^foo.*bar$" file.txt | grep -v "baz"
+
+# 如果要搜尋字面上的字串而不是用正規表達式，使用 `fgrep` 或 `grep -F`
+fgrep "foobar" file.txt
+
+# trap command allows you to execute a command when a signal is received by your script.
+# `trap` 可以在一個script運行，接收到特定信號時，執行對應的指令
+# `trap` 接收到 `SIGHUP`、`SIGINT`、`SIGTERM` 信號時，會移除 $TEMP_FILE
+trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
+
+# `sudo` 可用於以superuser的身分執行指令
+$NAME1=$(whoami)
+$NAME2=$(sudo whoami)
+echo "Was $NAME1, then became more powerful $NAME2"
+
+# 以 bash 內建的 'help' 指令閱讀 Bash 內建文件：
+help
+help help
+help for
+help return
+help source
+help .
+
+# 用 man 指令閱讀相關的 Bash 手冊
+apropos bash
+man 1 bash
+man bash
+
+# 用 info 指令查閱命令的 info 文件 （info 中按 ? 顯示幫助信息）
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# 閱讀 Bash 的 info 文件：
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/zh-tw/elixir-tw.html.markdown b/zh-tw/elixir-tw.html.markdown
new file mode 100644
index 00000000..c15f90c1
--- /dev/null
+++ b/zh-tw/elixir-tw.html.markdown
@@ -0,0 +1,413 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+translators:
+    - ["Tai An Su", "https://github.com/taiansu"]
+filename: learnelixir-tw.ex
+lang: zh-tw
+---
+
+Elixir 是一門建構在 Erlang 虛擬機上的現代函數式語言。它完全與 Erlang 相容，但
+採行了比較常見的語法，並提供更多的功能。
+
+```elixir
+
+# 單行註解以井字號開頭
+
+# 沒有多行註解的功能
+# 但你可以連續使用多個單行
+
+# 用 `iex` 來進入 elixir shell
+# 用 `elixirc` 來編譯你的模組
+
+# 如果你已成功安裝 elixir 的話，這兩個命令應已在你的 path 下。
+
+## ---------------------------
+## -- 基本型別
+## ---------------------------
+
+# 數字
+3    # 整數
+0x1F # 整數
+3.0  # 浮點數
+
+# 原子 (Atoms) 是不可變的字面常數，以 `:` 開頭。
+:hello # atom
+
+# 元組(Tuples) 會存在記憶體連續的區段裡。
+{1,2,3} # tuple
+
+# 我們可以用 `elem` 函式來取得 tuple 中的元素。
+elem({1, 2, 3}, 0) #=> 1
+
+# 串列 (List) 是用連結串列實作的。
+[1,2,3] # list
+
+# 我們可以這樣取得串列的頭尾元素：
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# 在 elixir 中，就如同 Erlang 裡一樣，`=` 代表的是模式比對，而非指派。
+#
+# 這代表將使用左手邊的模式 (pattern) 去與右手邊的值進行比對。
+#
+# 這也是先前取得串列的頭尾元素的運作原理
+
+# 當模式比對無法找到合適的配對時，將會回報錯誤，如下例中兩個 tuple 的大小不一致。
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# 還有二進位的型別
+<<1,2,3>> # binary
+
+# 字串與字母串列
+"hello" # string
+'hello' # char list
+
+# 多行字串
+"""
+I'm a multi-line
+string.
+"""
+#=> "I'm a multi-line\nstring.\n"
+
+# 字串皆使用 UTF-8 編碼
+"héllò" #=> "héllò"
+
+# 字串其實是以二進位實作，而字母串列就只是單純的串列。
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` 在 elixir 中會回傳字母 `a` 的 ASCII 整數
+?a #=> 97
+
+# 用 `++` 來合併串列，而合併二進位則要用 `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+# 範圍 (Ranges) 則是以 `開頭..結尾`來宣告 (頭尾都包含在內)
+1..10 #=> 1..10
+lower..upper = 1..10 # 可以對 range 進行模式比對
+[lower, upper] #=> [1, 10]
+
+## ---------------------------
+## -- 運算元
+## ---------------------------
+
+# 簡單算數
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# 在 elixir 中， `/` 運算元永遠回傳浮點數。
+
+# 若需要回傳整數的除法，用 `div`
+div(10, 2) #=> 5
+
+# 要得到除法的餘數時，用 `rem`
+rem(10, 3) #=> 1
+
+# 還有布林運算元: `or`, `and` and `not`.
+# 這些運算元要求第一個參數必需為布林值。
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir 也提供了 `||`, `&&` 及 `!`，它們接受任何型別的參數。
+# 除了 `false` 與 `nil` 之外的值都會被當做 true。
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# 用來比較的運算元有：`==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` 和 `!==` 會嚴格比較整數與浮點數
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# 兩個不同的型別也可以比較
+1 < :hello #=> true
+
+# 所有型別的排序如下：
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# 引用 Joe Armstrong 的話： "實際排序的先後並不重要， 但有明確排出全體順序的定
+# 義才是重要的。"
+
+## ---------------------------
+## -- 控制流程
+## ---------------------------
+
+# `if` 表達式
+if false do
+  "This will never be seen"
+else
+  "This will"
+end
+
+# 也有 `unless`
+unless true do
+  "This will never be seen"
+else
+  "This will"
+end
+
+# 還記得模式比對嗎？Elixir 中許多控制流程的結構都依賴模式比對來運作。
+
+# `case` 讓我們可以將一個值與許多模式進行比對：
+case {:one, :two} do
+  {:four, :five} ->
+    "This won't match"
+  {:one, x} ->
+    "This will match and bind `x` to `:two` in this clause"
+  _ ->
+    "This will match any value"
+end
+
+# 當我們不需要某個值的時候，通常會將它比對成 `_`。
+# 例如我們只關心串列的第一個值的情況時：
+[head | _] = [1,2,3]
+head #=> 1
+
+# 若希望程式更好懂時，我們會這樣處理：
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` 讓我們可以同時檢測多個不同的值。
+# 用 `cond` 來代替巢狀的 `if` 表達式
+cond do
+  1 + 1 == 3 ->
+    "I will never be seen"
+  2 * 5 == 12 ->
+    "Me neither"
+  1 + 2 == 3 ->
+    "But I will"
+end
+
+# 把最後一個條件設為 `true` 來捕捉剩下的所有情況是很常見的作法。
+cond do
+  1 + 1 == 3 ->
+    "I will never be seen"
+  2 * 5 == 12 ->
+    "Me neither"
+  true ->
+    "But I will (this is essentially an else)"
+end
+
+# `try/catch` 用來捕捉拋出的值，它也提供 `after` 子句，無論是否有接到拋出的值，
+# 最後都會調用其下的程式。
+try do
+  throw(:hello)
+catch
+  message -> "Got #{message}."
+after
+  IO.puts("I'm the after clause.")
+end
+#=> I'm the after clause
+# "Got :hello"
+
+## ---------------------------
+## -- 模組與函式
+## ---------------------------
+
+# 匿名函式 (注意那個句點)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# 匿名函式也接受多個子句及防衛(guards)
+# Guards 可以進行模式比對
+# 用 `when` 來描述 guards
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir 也提供許多內建的函式
+# 這些在預設的作用域下都可以使用
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# 你可以用模組將多個的函式集合在一起。在模組裡，用 `def` 來定義函式。
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# 要編譯我們的 Math 模組時，先將它存成 `math.ex`，再用 `elixirc` 進行編譯。
+# 在終端機輸入： elixirc math.ex
+
+# 在模組中我們可以用 `def` 宣告函式，及用 `defp` 宣告私有 (private) 函式。
+# 使用 `def` 定義的函式可以在其它的模組中被調用。
+# 私有的函式只能在這個模組內部調用。
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# 函式宣告也支援用防衛條件及多個條件子句
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# 由於不可變特性 (immutability)，遞迴在 elixir 中扮演重要的角色。
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Elixir 模組也支援屬性，模組有內建一些屬性，而你也可以定義自己的屬性。
+defmodule MyMod do
+  @moduledoc """
+  這是內建的屬性，模組文件
+  """
+
+  @my_data 100 # 這是自訂的屬性
+  IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- 結構與例外 (Structs and Exceptions)
+## ---------------------------
+
+# 結構 (structs) 是 maps 的擴展。是 Elixir 裡可以有預設值，編譯期檢查及
+# 多形 (polymorphism) 的資料結構。
+defmodule Person do
+  defstruct name: nil, age: 0, height: 0
+end
+
+joe_info = %Person{ name: "Joe", age: 30, height: 180 }
+#=> %Person{age: 30, height: 180, name: "Joe"}
+
+# 取得 name 的值
+joe_info.name #=> "Joe"
+
+# 更新 age 的值
+older_joe_info = %{ joe_info | age: 31 }
+#=> %Person{age: 31, height: 180, name: "Joe"}
+
+# The `try` block with the `rescue` keyword is used to handle exceptions
+# 帶有 `rescue` 關鍵字的 `try` 區塊是用來進行例外處理的。
+try do
+  raise "some error"
+rescue
+  RuntimeError -> "rescued a runtime error"
+  _error -> "this will rescue any error"
+end
+#=> "rescued a runtime error"
+
+# 所有的異常都有帶著一個訊息
+try do
+  raise "some error"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "some error"
+
+## ---------------------------
+## -- 平行處理
+## ---------------------------
+
+# Elixir 依靠 actor 模式來進行平行處理。在 elixir 中要寫出平行處理程式，
+# 只需要三個基本要素：建立行程，發送訊息及接收訊息。
+
+# 我們用 `spawn` 函式來建立行程，它接收一個函式當參數。
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` 會回傳一個 pid (行程識別碼)，你可以利用這個 pid 來對該行程傳送訊息。
+# 我們會使用 `send` 運算元來傳送訊息。但首先我們要讓該行程可以接收訊息。這要用
+# 到 `receive` 機制來達成。
+
+# `receive` 區塊能讓行程監聽接收到的訊息。每個 `receive do` 區塊只能接收一條
+# 訊息。若要接收多條訊息時，含有 `receive do` 的函式必須要在接到訊息後，遞迴呼
+# 叫自己以再次進入 `receive do` 區塊。
+
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# 編譯模組，並在 shell 中創造一個行程來執行 `area_loop`。
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# 更簡潔的替代寫法
+pid = spawn(Geometry, :area_loop, [])
+
+# 對 `pid` 傳送訊息，則會與接收區塊進行樣式比對。
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# The shell is also a process, you can use `self` to get the current pid
+# shell 也是一個行程 (process)，你可以用 `self` 拿到目前的 pid
+self() #=> #PID<0.27.0>
+```
+
+## 參考資料
+
+* [Getting started guide](http://elixir-lang.org/getting-started/introduction.html) from the [Elixir website](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) by Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) by Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) by Joe Armstrong