Merge branch 'master' into patch-2

396 files changed, 38859 insertions, 12197 deletions

diff --git a/.gitattributes b/.gitattributes
index 96d2bb5a..da8c9d63 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -46,13 +46,13 @@ 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
+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
+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
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 7bc9d01b..7bc421a7 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,5 +1,8 @@
 /fr-fr/ @vendethiel

 /ru-ru/ @Menelion

 /uk-ua/ @Menelion

-/zh-cn/ @geoffliu

-/zh-tw/ @geoffliu

+/zh-cn/ @geoffliu @imba-tjd

+/zh-tw/ @geoffliu @imba-tjd

+/ko-kr/ @justin-themedium

+/pt-pt/ @mribeirodantas

+/pt-br/ @mribeirodantas

diff --git a/ATS.html.markdown b/ATS.html.markdown
new file mode 100644
index 00000000..f290ac0f
--- /dev/null
+++ b/ATS.html.markdown
@@ -0,0 +1,607 @@
+---
+language: ATS
+contributors:
+  - ["Mark Barbone", "https://github.com/mb64"]
+filename: learnats.dats
+---
+
+ATS is a low-level functional programming language.  It has a powerful type
+system which lets you write programs with the same level of control and
+efficiency as C, but in a memory safe and type safe way.
+
+The ATS type system supports:
+
+* Full type erasure: ATS compiles to efficient C
+* Dependent types, including [LF](http://twelf.org/wiki/LF) and proving
+  metatheorems
+* Refinement types
+* Linearity for resource tracking
+* An effect system that tracks exceptions, mutation, termination, and other
+  side effects
+
+This tutorial is not an introduction to functional programming, dependent types,
+or linear types, but rather to how they all fit together in ATS.  That said, ATS
+is a very complex language, and this tutorial doesn't cover it all.  Not only
+does ATS's type system boast a wide array of confusing features, its
+idiosyncratic syntax can make even "simple" examples hard to understand.  In the
+interest of keeping it a reasonable length, this document is meant to give a
+taste of ATS, giving a high-level overview of what's possible and how, rather
+than attempting to fully explain how everything works.
+
+You can [try ATS in your browser](http://www.ats-lang.org/SERVER/MYCODE/Patsoptaas_serve.php),
+or install it from [http://www.ats-lang.org/](http://www.ats-lang.org/).
+
+
+```ocaml
+// Include the standard library
+#include "share/atspre_define.hats"
+#include "share/atspre_staload.hats"
+
+// To compile, either use
+//   $ patscc -DATS_MEMALLOC_LIBC program.dats -o program
+// or install the ats-acc wrapper https://github.com/sparverius/ats-acc and use
+//   $ acc pc program.dats
+
+// C-style line comments
+/* and C-style block comments */
+(* as well as ML-style block comments *)
+
+/*************** Part 1: the ML fragment ****************/
+
+val () = print "Hello, World!\n"
+
+// No currying
+fn add (x: int, y: int) = x + y
+
+// fn vs fun is like the difference between let and let rec in OCaml/F#
+fun fact (n: int): int = if n = 0 then 1 else n * fact (n-1)
+
+// Multi-argument functions need parentheses when you call them; single-argument
+// functions can omit parentheses
+val forty_three = add (fact 4, 19)
+
+// let is like let in SML
+fn sum_and_prod (x: int, y: int): (int, int) =
+  let
+    val sum = x + y
+    val prod = x * y
+  in (sum, prod) end
+
+// 'type' is the type of all heap-allocated, non-linear types
+// Polymorphic parameters go in {} after the function name
+fn id {a:type} (x: a) = x
+
+// ints aren't heap-allocated, so we can't pass them to 'id'
+// val y: int = id 7 // doesn't compile
+
+// 't@ype' is the type of all non-linear potentially unboxed types. It is a
+// supertype of 'type'.
+// Templated parameters go in {} before the function name
+fn {a:t@ype} id2 (x: a) = x
+
+val y: int = id2 7 // works
+
+// can't have polymorphic t@ype parameters
+// fn id3 {a:t@ype} (x: a) = x // doesn't compile
+
+// explicity specifying type parameters:
+fn id4 {a:type} (x: a) = id {a} x // {} for non-template parameters
+fn id5 {a:type} (x: a) = id2<a> x // <> for template parameters
+fn id6 {a:type} (x: a) = id {..} x // {..} to explicitly infer it
+
+// Heap allocated shareable datatypes
+// using datatypes leaks memory
+datatype These (a:t@ype, b:t@ype) = This of a
+                                  | That of b
+                                  | These of (a, b)
+
+// Pattern matching using 'case'
+fn {a,b: t@ype} from_these (x: a, y: b, these: These(a,b)): (a, b) =
+  case these of
+  | This(x) => (x, y) // Shadowing of variable names is fine; here, x shadows
+                      // the parameter x
+  | That(y) => (x, y)
+  | These(x, y) => (x, y)
+
+// Partial pattern match using 'case-'
+// Will throw an exception if passed This
+fn {a,b:t@ype} unwrap_that (these: These(a,b)): b =
+  case- these of
+  | That(y) => y
+  | These(_, y) => y
+
+
+/*************** Part 2: refinements ****************/
+
+// Parameterize functions by what values they take and return
+fn cool_add {n:int} {m:int} (x: int n, y: int m): int (n+m) = x + y
+
+// list(a, n) is a list of n a's
+fun square_all {n:int} (xs: list(int, n)): list(int, n) =
+  case xs of
+  | list_nil() => list_nil()
+  | list_cons(x, rest) => list_cons(x * x, square_all rest)
+
+fn {a:t@ype} get_first {n:int | n >= 1} (xs: list(a, n)): a =
+  case+ xs of // '+' asks ATS to prove it's total
+  | list_cons(x, _) => x
+
+// Can't run get_first on lists of length 0
+// val x: int = get_first (list_nil()) // doesn't compile
+
+// in the stdlib:
+// sortdef nat = {n:int | n >= 0}
+// sortdef pos = {n:int | n >= 1}
+
+fn {a:t@ype} also_get_first {n:pos} (xs: list(a, n)): a =
+  let
+    val+ list_cons(x, _) = xs // val+ also works
+  in x end
+
+// tail-recursive reverse
+fun {a:t@ype} reverse {n:int} (xs: list(a, n)): list(a, n) =
+  let
+    // local functions can use type variables from their enclosing scope
+    // this one uses both 'a' and 'n'
+    fun rev_helper {i:nat} (xs: list(a, n-i), acc: list(a, i)): list(a, n) =
+      case xs of
+      | list_nil() => acc
+      | list_cons(x, rest) => rev_helper(rest, list_cons(x, acc))
+  in rev_helper(xs, list_nil) end
+
+// ATS has three context-dependent namespaces
+// the two 'int's mean different things in this example, as do the two 'n's
+fn namespace_example {n:int} (n: int n): int n = n
+//                      ^^^                         sort namespace
+//                    ^          ^^^ ^   ^^^ ^      statics namespace
+// ^^^^^^^^^^^^^^^^^          ^                  ^  value namespace
+
+// a termination metric can go in .< >.
+// it must decrease on each recursive call
+// then ATS will prove it doesn't infinitely recurse
+fun terminating_factorial {n:nat} .<n>. (n: int n): int =
+  if n = 0 then 1 else n * terminating_factorial (n-1)
+
+
+/*************** Part 3: the LF fragment ****************/
+
+// ATS supports proving theorems in LF (http://twelf.org/wiki/LF)
+
+// Relations are represented by inductive types
+
+// Proofs that the nth fibonacci number is f
+dataprop Fib(n:int, m:int) =
+  | FibZero(0, 0)
+  | FibOne(1, 1)
+  | {n, f1, f2: int} FibInd(n, f1 + f2) of (Fib(n-1,f1), Fib(n-2,f2))
+
+// Proved-correct fibonacci implementation
+// [A] B is an existential type: "there exists A such that B"
+// (proof | value)
+fun fib {n:nat} .<n>. (n: int n): [f:int] (Fib(n,f) | int f) =
+  if n = 0 then (FibZero | 0) else
+  if n = 1 then (FibOne | 1) else
+  let
+    val (proof1 | val1) = fib (n-1)
+    val (proof2 | val2) = fib (n-2)
+  // the existential type is inferred
+  in (FibInd(proof1, proof2) | val1 + val2) end
+
+// Faster proved-correct fibonacci implementation
+fn fib_tail {n:nat} (n: int n): [f:int] (Fib(n,f) | int f) =
+  let
+    fun loop {i:int | i < n} {f1, f2: int} .<n - i>.
+          (p1: Fib(i,f1), p2: Fib(i+1,f2)
+          | i: int i, f1: int f1, f2: int f2, n: int n
+          ): [f:int] (Fib(n,f) | int f) =
+      if i = n - 1
+      then (p2 | f2)
+      else loop (p2, FibInd(p2,p1) | i+1, f2, f1+f2, n)
+  in if n = 0 then (FibZero | 0) else loop (FibZero, FibOne | 0, 0, 1, n) end
+
+// Proof-level lists of ints, of type 'sort'
+datasort IntList = ILNil of ()
+                 | ILCons of (int, IntList)
+
+// ILAppend(x,y,z) iff x ++ y = z
+dataprop ILAppend(IntList, IntList, IntList) =
+  | {y:IntList} AppendNil(ILNil, y, y)
+  | {a:int} {x,y,z: IntList}
+    AppendCons(ILCons(a,x), y, ILCons(a,z)) of ILAppend(x,y,z)
+
+// prfuns/prfns are compile-time functions acting on proofs
+
+// metatheorem: append is total
+prfun append_total {x,y: IntList} .<x>. (): [z:IntList] ILAppend(x,y,z)
+  = scase x of // scase lets you inspect static arguments (only in prfuns)
+  | ILNil() => AppendNil
+  | ILCons(a,rest) => AppendCons(append_total())
+
+
+/*************** Part 4: views ****************/
+
+// views are like props, but linear; ie they must be consumed exactly once
+// prop is a subtype of view
+
+// 'type @ address' is the most basic view
+
+fn {a:t@ype} read_ptr {l:addr} (pf: a@l | p: ptr l): (a@l | a) =
+  let
+    // !p searches for usable proofs that say something is at that address
+    val x = !p
+  in (pf | x) end
+
+// oops, tried to dereference a potentially invalid pointer
+// fn {a:t@ype} bad {l:addr} (p: ptr l): a = !p // doesn't compile
+
+// oops, dropped the proof (leaked the memory)
+// fn {a:t@ype} bad {l:addr} (pf: a@l | p: ptr l): a = !p // doesn't compile
+
+fn inc_at_ptr {l:addr} (pf: int@l | p: ptr l): (int@l | void) =
+  let
+    // !p := value writes value to the location at p
+    // like !p, it implicitly searches for usable proofs that are in scope
+    val () = !p := !p + 1
+  in (pf | ()) end
+
+// threading proofs through gets annoying
+fn inc_three_times {l:addr} (pf: int@l | p: ptr l): (int@l | void) =
+  let
+    val (pf2 | ()) = inc_at_ptr (pf | p)
+    val (pf3 | ()) = inc_at_ptr (pf2 | p)
+    val (pf4 | ()) = inc_at_ptr (pf3 | p)
+  in (pf4 | ()) end
+
+// so there's special syntactic sugar for when you don't consume a proof
+fn dec_at_ptr {l:addr} (pf: !int@l | p: ptr l): void =
+  !p := !p - 1           // ^ note the exclamation point
+
+fn dec_three_times {l:addr} (pf: !int@l | p: ptr l): void =
+  let
+    val () = dec_at_ptr (pf | p)
+    val () = dec_at_ptr (pf | p)
+    val () = dec_at_ptr (pf | p)
+  in () end
+
+// dataview is like dataprop, but linear
+// A proof that either the address is null, or there is a value there
+dataview MaybeNull(a:t@ype, addr) =
+  | NullPtr(a, null)
+  | {l:addr | l > null} NonNullPtr(a, l) of (a @ l)
+
+fn maybe_inc {l:addr} (pf: !MaybeNull(int, l) | p: ptr l): void =
+  if ptr1_is_null p
+  then ()
+  else let
+    // Deconstruct the proof to access the proof of a @ l
+    prval NonNullPtr(value_exists) = pf
+    val () = !p := !p + 1
+    // Reconstruct it again for the caller
+    prval () = pf := NonNullPtr(value_exists)
+  in () end
+
+// array_v(a,l,n) represents and array of n a's at location l
+// this gets compiled into an efficient for loop, since all proofs are erased
+fn sum_array {l:addr}{n:nat} (pf: !array_v(int,l,n) | p: ptr l, n: int n): int =
+  let
+    fun loop {l:addr}{n:nat} .<n>. (
+      pf: !array_v(int,l,n)
+    | ptr: ptr l,
+      length: int n,
+      acc: int
+    ): int = if length = 0
+      then acc
+      else let
+        prval (head, rest) = array_v_uncons(pf)
+        val result = loop(rest | ptr_add<int>(ptr, 1), length - 1, acc + !ptr)
+        prval () = pf := array_v_cons(head, rest)
+      in result end
+  in loop (pf | p, n, 0) end
+
+// 'var' is used to create stack-allocated (lvalue) variables
+val seven: int = let
+    var res: int = 3
+    // they can be modified
+    val () = res := res + 1
+    // addr@ res is a pointer to it, and view@ res is the associated proof
+    val (pf | ()) = inc_three_times(view@ res | addr@ res)
+    // need to give back the view before the variable goes out of scope
+    prval () = view@ res := pf
+  in res end
+
+// References let you pass lvalues, like in C++
+fn square (x: &int): void =
+  x := x * x // they can be modified
+
+val sixteen: int = let
+    var res: int = 4
+    val () = square res
+  in res end
+
+fn inc_at_ref (x: &int): void =
+  let
+    // like vars, references have views and addresses
+    val (pf | ()) = inc_at_ptr(view@ x | addr@ x)
+    prval () = view@ x := pf
+  in () end
+
+// Like ! for views, & references are only legal as argument types
+// fn bad (x: &int): &int = x // doesn't compile
+
+// this takes a proof int n @ l, but returns a proof int (n+1) @ l
+// since they're different types, we can't use !int @ l like before
+fn refined_inc_at_ptr {n:int}{l:addr} (
+  pf: int n @ l | p: ptr l
+): (int (n+1) @ l | void) =
+  let
+    val () = !p := !p + 1
+  in (pf | ()) end
+
+// special syntactic sugar for returning a proof at a different type
+fn refined_dec_at_ptr {n:int}{l:addr} (
+  pf: !int n @ l >> int (n-1) @ l | p: ptr l
+): void =
+  !p := !p - 1
+
+// legal but very bad code
+prfn swap_proofs {v1,v2:view} (a: !v1 >> v2, b: !v2 >> v1): void =
+  let
+    prval tmp = a
+    prval () = a := b
+    prval () = b := tmp
+  in () end
+
+// also works with references
+fn refined_square {n:int} (x: &int n >> int (n*n)): void =
+  x := x * x
+
+fn replace {a,b:vtype} (dest: &a >> b, src: b): a =
+  let
+    val old = dest
+    val () = dest := src
+  in old end
+
+// values can be uninitialized
+fn {a:vt@ype} write (place: &a? >> a, value: a): void =
+  place := value
+
+val forty: int = let
+    var res: int
+    val () = write (res, 40)
+  in res end
+
+// viewtype: a view and a type
+viewtypedef MaybeNullPtr(a:t@ype) = [l:addr] (MaybeNull(a, l) | ptr l)
+// MaybeNullPtr has type 'viewtype' (aka 'vtype')
+// type is a subtype of vtype and t@ype is a subtype of vt@ype
+
+// The most general identity function:
+fn {a:vt@ype} id7 (x: a) = x
+
+// since they contain views, viewtypes must be used linearly
+// fn {a:vt@ype} duplicate (x: a) = (x, x) // doesn't compile
+// fn {a:vt@ype} ignore (x: a) = () // doesn't compile
+
+// arrayptr(a,l,n) is a convenient built-in viewtype
+fn easier_sum_array {l:addr}{n:nat} (p: !arrayptr(int,l,n), n: int n): int =
+  let
+    fun loop {i:nat | i <= n} (
+      p: !arrayptr(int,l,n), n: int n, i: int i, acc: int
+    ): int =
+      if i = n
+      then acc
+      else loop(p, n, i+1, acc + p[i])
+  in loop(p, n, 0, 0) end
+
+
+/*************** Part 5: dataviewtypes ****************/
+
+// a dataviewtype is a heap-allocated non-shared inductive type
+
+// in the stdlib:
+// dataviewtype list_vt(a:vt@ype, int) =
+//   | list_vt_nil(a, 0)
+//   | {n:nat} list_vt_cons(a, n+1) of (a, list_vt(a, n))
+
+fn {a:vt@ype} length {n:int} (l: !list_vt(a, n)): int n =
+  let                         // ^ since we're not consuming it
+    fun loop {acc:int} (l: !list_vt(a, n-acc), acc: int acc): int n =
+      case l of
+      | list_vt_nil() => acc
+      | list_vt_cons(head, tail) => loop(tail, acc + 1)
+  in loop (l, 0) end
+
+//     vvvvv  not vt@ype, because you can't easily get rid of a vt@ype
+fun {a:t@ype} destroy_list {n:nat} (l: list_vt(a,n)): void =
+  case l of
+  // ~ pattern match consumes and frees that node
+  | ~list_vt_nil() => ()
+  | ~list_vt_cons(_, tail) => destroy_list tail
+
+// unlike a datatype, a dataviewtype can be modified:
+fun {a:vt@ype} push_back {n:nat} (
+  x: a,
+  l: &list_vt(a,n) >> list_vt(a,n+1)
+): void =
+  case l of
+  | ~list_vt_nil() => l := list_vt_cons(x, list_vt_nil)
+  // @ pattern match disassembles/"unfolds" the datavtype's view, so you can
+  // modify its components
+  | @list_vt_cons(head, tail) => let
+      val () = push_back (x, tail)
+      // reassemble it with fold@
+      prval () = fold@ l
+    in () end
+
+fun {a:vt@ype} pop_last {n:pos} (l: &list_vt(a,n) >> list_vt(a,n-1)): a =
+  let
+    val+ @list_vt_cons(head, tail) = l
+  in case tail of
+    | list_vt_cons _ => let
+        val res = pop_last tail
+        prval () = fold@ l
+      in res end
+    | ~list_vt_nil() => let
+        val head = head
+        // Deallocate empty datavtype nodes with free@
+        val () = free@{..}{0} l
+        val () = l := list_vt_nil()
+      in head end
+ /** Equivalently:
+  * | ~list_vt_nil() => let
+  *     prval () = fold@ l
+  *     val+ ~list_vt_cons(head, ~list_vt_nil()) = l
+  *     val () = l := list_vt_nil()
+  *   in head end
+  */
+  end
+
+// "holes" (ie uninitialized memory) can be created with _ on the RHS
+// This function uses destination-passing-style to copy the list in a single
+// tail-recursive pass.
+fn {a:t@ype} copy_list {n:nat} (l: !list_vt(a, n)): list_vt(a, n) =
+  let
+    var res: ptr
+    fun loop {k:nat} (l: !list_vt(a, k), hole: &ptr? >> list_vt(a, k)): void =
+      case l of
+      | list_vt_nil() => hole := list_vt_nil
+      | list_vt_cons(first, rest) => let
+          val () = hole := list_vt_cons{..}{k-1}(first, _)
+          //                                            ^ on RHS: a hole
+          val+list_vt_cons(_, new_hole) = hole
+          //               ^ on LHS: wildcard pattern (not a hole)
+          val () = loop (rest, new_hole)
+          prval () = fold@ hole
+        in () end
+    val () = loop (l, res)
+  in res end
+
+// Reverse a linked-list *in place* -- no allocations or frees
+fn {a:vt@ype} in_place_reverse {n:nat} (l: list_vt(a, n)): list_vt(a, n) =
+  let
+    fun loop {k:nat} (l: list_vt(a, n-k), acc: list_vt(a, k)): list_vt(a, n) =
+      case l of
+      | ~list_vt_nil() => acc
+      | @list_vt_cons(x, tail) => let
+          val rest = replace(tail, acc)
+          // the node 'l' is now part of acc instead of the original list
+          prval () = fold@ l
+        in loop (rest, l) end
+  in loop (l, list_vt_nil) end
+
+
+/*************** Part 6: miscellaneous extras ****************/
+
+// a record
+// Point has type 't@ype'
+typedef Point = @{ x= int, y= int }
+val origin: Point = @{ x= 0, y= 0 }
+
+// tuples and records are normally unboxed, but there are boxed variants
+// BoxedPoint has type 'type'
+typedef BoxedPoint = '{ x= int, y= int }
+val boxed_pair: '(int,int) = '(5, 3)
+
+// When passing a pair as the single argument to a function, it needs to be
+// written @(a,b) to avoid ambiguity with multi-argument functions
+val six_plus_seven = let
+    fun sum_of_pair (pair: (int,int)) = pair.0 + pair.1
+  in sum_of_pair @(6, 7) end
+
+// When a constructor has no associated data, such as None(), the parentheses
+// are optional in expressions.  However, they are mandatory in patterns
+fn inc_option (opt: Option int) =
+  case opt of
+  | Some(x) => Some(x+1)
+  | None() => None
+
+// ATS has a simple FFI, since it compiles to C and (mostly) uses the C ABI
+%{
+// Inline C code
+int scanf_wrapper(void *format, void *value) {
+    return scanf((char *) format, (int *) value);
+}
+%}
+// If you wanted to, you could define a custom dataviewtype more accurately
+// describing the result of scanf
+extern fn scanf (format: string, value: &int): int = "scanf_wrapper"
+
+fn get_input_number (): Option int =
+  let
+    var x: int = 0
+  in
+    if scanf("%d\n", x) = 1
+    then Some(x)
+    else None
+  end
+
+// extern is also used for separate declarations and definitions
+extern fn say_hi (): void
+// later on, or in another file:
+implement say_hi () = print "hi\n"
+
+// if you implement main0, it will run as the main function
+// implmnt is an alias for implement
+implmnt main0 () = ()
+
+// as well as for axioms:
+extern praxi view_id {a:view} (x: a): a
+// you don't need to actually implement the axioms, but you could
+primplmnt view_id x = x
+// primplmnt is an alias for primplement
+
+// Some standard aliases are:
+// List0(a) = [n:nat] list(a,n) and List0_vt(a) = [n:nat] list_vt(a,n)
+// t0p = t@ype and vt0p = vt@ype
+fun {a:t0p} append (xs: List0 a, ys: List0 a): List0 a =
+  case xs of
+  | list_nil() => ys
+  | list_cons(x, xs) => list_cons(x, append(xs, ys))
+
+// there are many ways of doing things after one another
+val let_in_example = let
+    val () = print "thing one\n"
+    val () = print "thing two\n"
+  in () end
+
+val parens_example = (print "thing one\n"; print "thing two\n")
+
+val begin_end_example = begin
+    print "thing one\n";
+    print "thing two\n"; // optional trailing semicolon
+  end
+
+// and many ways to use local variables
+fun times_four_let x =
+  let
+    fun times_two (x: int) = x * 2
+  in times_two (times_two x) end
+
+local
+  fun times_two (x: int) = x * 2
+in
+  fun times_four_local x = times_two (times_two x)
+end
+
+fun times_four_where x = times_two (times_two x)
+  where {
+    fun times_two (x: int) = x * 2
+  }
+
+//// The last kind of comment in ATS is an end-of-file comment.
+
+Anything between the four slashes and the end of the file is ignored.
+
+Have fun with ATS!
+```
+
+## Learn more
+
+This isn't all there is to ATS -- notably, some core features like closures and
+the effect system are left out, as well as other less type-y stuff like modules
+and the build system.  If you'd like to write these sections yourself,
+contributions would be welcome!
+
+To learn more about ATS, visit the [ATS website](http://www.ats-lang.org/), in
+particular the [documentation page](http://www.ats-lang.org/Documents.html).
+
diff --git a/CHICKEN.html.markdown b/CHICKEN.html.markdown
index 3f7cc2db..4ae45cac 100644
--- a/CHICKEN.html.markdown
+++ b/CHICKEN.html.markdown
@@ -362,8 +362,6 @@ sqr                        ;; => #<procedure (sqr x)>
 ;; 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
@@ -375,12 +373,12 @@ sqr                        ;; => #<procedure (sqr x)>
 (numerator 2/3)                    ;; => 2
 
 ;; 'utf8' provides unicode support
-(require-extension utf8)
+(import 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
+;; See http://wiki.call-cc.org/man/5/Module%20(chicken%20file%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)))
@@ -396,14 +394,14 @@ sqr                        ;; => #<procedure (sqr x)>
 
 ;; 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
+(import 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
+(import srfi-13)                   ;; string library
 (string-reverse "pan")             ;; => "nap"
 (string-index "Turkey" #\k)        ;; => 3
 (string-every char-upper-case? "CHICKEN") ;; => #t
@@ -448,7 +446,7 @@ sqr                        ;; => #<procedure (sqr x)>
 ; 9. Modules
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; Also See http://wiki.call-cc.org/man/4/Modules
+;; Also See http://wiki.call-cc.org/man/5/Modules
 
 ;; The 'test' module exports a value named 'hello' and a macro named 'greet'
 (module test (hello greet)
@@ -509,11 +507,11 @@ sqr                        ;; => #<procedure (sqr x)>
 
 ```
 ## Further Reading
-* [CHICKEN User's Manual](http://wiki.call-cc.org/man/4/The%20User%27s%20Manual).
+* [CHICKEN User's Manual](https://wiki.call-cc.org/manual).
 * [R5RS 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)
+* [For programmers of other languages](https://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
index 3dfd38ce..f3556efa 100644
--- a/CONTRIBUTING.markdown
+++ b/CONTRIBUTING.markdown
@@ -16,27 +16,29 @@ 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
+* **Keep lines under 80 chars**
+   * Try to keep **line length in code blocks to 80 characters or fewer**.
+   * Otherwise, the text will overflow and look odd.
+   * This and other potential pitfalls to format the content consistently are
+     identified by the freely available
+     [markdownlint](https://github.com/markdownlint/markdownlint).
+* **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 ensure
+     your file is UTF-8 encoded.
+   * Leave out the byte-order-mark (BOM) at the start of the file (in Vim, use
+     `:set nobomb`).
+   * 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`.
-
+    `UTF-8 Unicode (with BOM) text`.
 
 ### Header configuration
 
@@ -47,59 +49,67 @@ 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
+* **language** The *programming language* in question
+* **contributors** A list of [author, URL] lists to credit
 
 Other fields:
 
-- **category**: The category of the article. So far, can be one of *language*,
+* **category**: The category of the article. So far, can be one of *language*,
   *tool* or *Algorithms & Data Structures*. Defaults to *language* if omitted.
-- **filename**: The filename for this article's code. It will be fetched, mashed
+* **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
+   * 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
----
+*--
 ```
 
-### Should I add myself as a Contributor?
+### Syntax highlighter
+
+[Rouge](https://github.com/rouge-ruby/rouge/wiki/List-of-supported-languages-and-lexers) is used for syntax highlighting.
+
+### Should I add myself as a contributor?
 
 If you want to add yourself to contributors, keep in mind that contributors get
 equal billing, and the first contributor usually wrote the whole article. Please
-use your judgement when deciding if your contribution constitutes a substantial
+use your judgment when deciding if your contribution constitutes a substantial
 addition or not.
 
 ## Building the site locally
 
 You can build the site locally to test your changes. Follow the steps below.
 
-* Install Ruby language runtime and RubyGems. See [here](https://middlemanapp.com/basics/install/) for more details.
-* Clone or zip download the [learnxinyminutes-site](https://github.com/adambard/learnxinyminutes-site) repo.
-	* `git clone https://github.com/adambard/learnxinyminutes-site`
+* Install Ruby language runtime and RubyGems. See
+  [here](https://middlemanapp.com/basics/install/)
+  for more details.
+* Clone or zip download the
+  [learnxinyminutes-site](https://github.com/adambard/learnxinyminutes-site)
+  repository.
+   * `git clone https://github.com/adambard/learnxinyminutes-site`
 * Install Middleman and other required dependencies using Bundler.
-	* `cd learnxinyminutes-site/`
-	* `bundle install`
+   * `cd learnxinyminutes-site/`
+   * `bundle install`
 * Get the source in place
-	* Copy the contents of your clone of the fork of learnxinyminutes-docs repo
-	into the `source/docs` folder. There shouldn't be a `learnxinyminutes-docs`
-	folder inside the `docs` folder, it should just contain all the repo
-	contents.
-	* Checkout your fork of the learnxinyminutes-docs repo as `source/docs`.
-		* `cd source/docs/`
-		* `git clone https://github.com/YOUR-USERNAME/learnxinyminutes-docs ./source/docs/`
+   * Copy the contents of your clone of the fork of learnxinyminutes-docs repo
+     into the `source/docs` folder. There shouldn't be a `learnxinyminutes-docs`
+     folder inside the `docs` folder, it should just contain all the repo
+     contents.
+   * Checkout your fork of the learnxinyminutes-docs repo as `source/docs`.
+      * `cd source/docs/`
+      * `git clone https://github.com/YOUR-USERNAME/learnxinyminutes-docs ./source/docs/`
 * Build the site or run a development server to test your changes (NOTE: run
-these commands at `learnxinyminutes-site/`).
-	* Build - `bundle exec middleman build`
-	* Dev server - `bundle exec middleman --force-polling --verbose`
+  these commands at `learnxinyminutes-site/`).
+   * Build - `bundle exec middleman build`
+   * Dev server - `bundle exec middleman --force-polling --verbose`
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 00000000..604209a8
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,359 @@
+Creative Commons Legal Code
+
+Attribution-ShareAlike 3.0 Unported
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR
+    DAMAGES RESULTING FROM ITS USE.
+
+License
+
+THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE
+COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY
+COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS
+AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.
+
+BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE
+TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY
+BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS
+CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND
+CONDITIONS.
+
+1. Definitions
+
+ a. "Adaptation" means a work based upon the Work, or upon the Work and
+    other pre-existing works, such as a translation, adaptation,
+    derivative work, arrangement of music or other alterations of a
+    literary or artistic work, or phonogram or performance and includes
+    cinematographic adaptations or any other form in which the Work may be
+    recast, transformed, or adapted including in any form recognizably
+    derived from the original, except that a work that constitutes a
+    Collection will not be considered an Adaptation for the purpose of
+    this License. For the avoidance of doubt, where the Work is a musical
+    work, performance or phonogram, the synchronization of the Work in
+    timed-relation with a moving image ("synching") will be considered an
+    Adaptation for the purpose of this License.
+ b. "Collection" means a collection of literary or artistic works, such as
+    encyclopedias and anthologies, or performances, phonograms or
+    broadcasts, or other works or subject matter other than works listed
+    in Section 1(f) below, which, by reason of the selection and
+    arrangement of their contents, constitute intellectual creations, in
+    which the Work is included in its entirety in unmodified form along
+    with one or more other contributions, each constituting separate and
+    independent works in themselves, which together are assembled into a
+    collective whole. A work that constitutes a Collection will not be
+    considered an Adaptation (as defined below) for the purposes of this
+    License.
+ c. "Creative Commons Compatible License" means a license that is listed
+    at https://creativecommons.org/compatiblelicenses that has been
+    approved by Creative Commons as being essentially equivalent to this
+    License, including, at a minimum, because that license: (i) contains
+    terms that have the same purpose, meaning and effect as the License
+    Elements of this License; and, (ii) explicitly permits the relicensing
+    of adaptations of works made available under that license under this
+    License or a Creative Commons jurisdiction license with the same
+    License Elements as this License.
+ d. "Distribute" means to make available to the public the original and
+    copies of the Work or Adaptation, as appropriate, through sale or
+    other transfer of ownership.
+ e. "License Elements" means the following high-level license attributes
+    as selected by Licensor and indicated in the title of this License:
+    Attribution, ShareAlike.
+ f. "Licensor" means the individual, individuals, entity or entities that
+    offer(s) the Work under the terms of this License.
+ g. "Original Author" means, in the case of a literary or artistic work,
+    the individual, individuals, entity or entities who created the Work
+    or if no individual or entity can be identified, the publisher; and in
+    addition (i) in the case of a performance the actors, singers,
+    musicians, dancers, and other persons who act, sing, deliver, declaim,
+    play in, interpret or otherwise perform literary or artistic works or
+    expressions of folklore; (ii) in the case of a phonogram the producer
+    being the person or legal entity who first fixes the sounds of a
+    performance or other sounds; and, (iii) in the case of broadcasts, the
+    organization that transmits the broadcast.
+ h. "Work" means the literary and/or artistic work offered under the terms
+    of this License including without limitation any production in the
+    literary, scientific and artistic domain, whatever may be the mode or
+    form of its expression including digital form, such as a book,
+    pamphlet and other writing; a lecture, address, sermon or other work
+    of the same nature; a dramatic or dramatico-musical work; a
+    choreographic work or entertainment in dumb show; a musical
+    composition with or without words; a cinematographic work to which are
+    assimilated works expressed by a process analogous to cinematography;
+    a work of drawing, painting, architecture, sculpture, engraving or
+    lithography; a photographic work to which are assimilated works
+    expressed by a process analogous to photography; a work of applied
+    art; an illustration, map, plan, sketch or three-dimensional work
+    relative to geography, topography, architecture or science; a
+    performance; a broadcast; a phonogram; a compilation of data to the
+    extent it is protected as a copyrightable work; or a work performed by
+    a variety or circus performer to the extent it is not otherwise
+    considered a literary or artistic work.
+ i. "You" means an individual or entity exercising rights under this
+    License who has not previously violated the terms of this License with
+    respect to the Work, or who has received express permission from the
+    Licensor to exercise rights under this License despite a previous
+    violation.
+ j. "Publicly Perform" means to perform public recitations of the Work and
+    to communicate to the public those public recitations, by any means or
+    process, including by wire or wireless means or public digital
+    performances; to make available to the public Works in such a way that
+    members of the public may access these Works from a place and at a
+    place individually chosen by them; to perform the Work to the public
+    by any means or process and the communication to the public of the
+    performances of the Work, including by public digital performance; to
+    broadcast and rebroadcast the Work by any means including signs,
+    sounds or images.
+ k. "Reproduce" means to make copies of the Work by any means including
+    without limitation by sound or visual recordings and the right of
+    fixation and reproducing fixations of the Work, including storage of a
+    protected performance or phonogram in digital form or other electronic
+    medium.
+
+2. Fair Dealing Rights. Nothing in this License is intended to reduce,
+limit, or restrict any uses free from copyright or rights arising from
+limitations or exceptions that are provided for in connection with the
+copyright protection under copyright law or other applicable laws.
+
+3. License Grant. Subject to the terms and conditions of this License,
+Licensor hereby grants You a worldwide, royalty-free, non-exclusive,
+perpetual (for the duration of the applicable copyright) license to
+exercise the rights in the Work as stated below:
+
+ a. to Reproduce the Work, to incorporate the Work into one or more
+    Collections, and to Reproduce the Work as incorporated in the
+    Collections;
+ b. to create and Reproduce Adaptations provided that any such Adaptation,
+    including any translation in any medium, takes reasonable steps to
+    clearly label, demarcate or otherwise identify that changes were made
+    to the original Work. For example, a translation could be marked "The
+    original work was translated from English to Spanish," or a
+    modification could indicate "The original work has been modified.";
+ c. to Distribute and Publicly Perform the Work including as incorporated
+    in Collections; and,
+ d. to Distribute and Publicly Perform Adaptations.
+ e. For the avoidance of doubt:
+
+     i. Non-waivable Compulsory License Schemes. In those jurisdictions in
+        which the right to collect royalties through any statutory or
+        compulsory licensing scheme cannot be waived, the Licensor
+        reserves the exclusive right to collect such royalties for any
+        exercise by You of the rights granted under this License;
+    ii. Waivable Compulsory License Schemes. In those jurisdictions in
+        which the right to collect royalties through any statutory or
+        compulsory licensing scheme can be waived, the Licensor waives the
+        exclusive right to collect such royalties for any exercise by You
+        of the rights granted under this License; and,
+   iii. Voluntary License Schemes. The Licensor waives the right to
+        collect royalties, whether individually or, in the event that the
+        Licensor is a member of a collecting society that administers
+        voluntary licensing schemes, via that society, from any exercise
+        by You of the rights granted under this License.
+
+The above rights may be exercised in all media and formats whether now
+known or hereafter devised. The above rights include the right to make
+such modifications as are technically necessary to exercise the rights in
+other media and formats. Subject to Section 8(f), all rights not expressly
+granted by Licensor are hereby reserved.
+
+4. Restrictions. The license granted in Section 3 above is expressly made
+subject to and limited by the following restrictions:
+
+ a. You may Distribute or Publicly Perform the Work only under the terms
+    of this License. You must include a copy of, or the Uniform Resource
+    Identifier (URI) for, this License with every copy of the Work You
+    Distribute or Publicly Perform. You may not offer or impose any terms
+    on the Work that restrict the terms of this License or the ability of
+    the recipient of the Work to exercise the rights granted to that
+    recipient under the terms of the License. You may not sublicense the
+    Work. You must keep intact all notices that refer to this License and
+    to the disclaimer of warranties with every copy of the Work You
+    Distribute or Publicly Perform. When You Distribute or Publicly
+    Perform the Work, You may not impose any effective technological
+    measures on the Work that restrict the ability of a recipient of the
+    Work from You to exercise the rights granted to that recipient under
+    the terms of the License. This Section 4(a) applies to the Work as
+    incorporated in a Collection, but this does not require the Collection
+    apart from the Work itself to be made subject to the terms of this
+    License. If You create a Collection, upon notice from any Licensor You
+    must, to the extent practicable, remove from the Collection any credit
+    as required by Section 4(c), as requested. If You create an
+    Adaptation, upon notice from any Licensor You must, to the extent
+    practicable, remove from the Adaptation any credit as required by
+    Section 4(c), as requested.
+ b. You may Distribute or Publicly Perform an Adaptation only under the
+    terms of: (i) this License; (ii) a later version of this License with
+    the same License Elements as this License; (iii) a Creative Commons
+    jurisdiction license (either this or a later license version) that
+    contains the same License Elements as this License (e.g.,
+    Attribution-ShareAlike 3.0 US)); (iv) a Creative Commons Compatible
+    License. If you license the Adaptation under one of the licenses
+    mentioned in (iv), you must comply with the terms of that license. If
+    you license the Adaptation under the terms of any of the licenses
+    mentioned in (i), (ii) or (iii) (the "Applicable License"), you must
+    comply with the terms of the Applicable License generally and the
+    following provisions: (I) You must include a copy of, or the URI for,
+    the Applicable License with every copy of each Adaptation You
+    Distribute or Publicly Perform; (II) You may not offer or impose any
+    terms on the Adaptation that restrict the terms of the Applicable
+    License or the ability of the recipient of the Adaptation to exercise
+    the rights granted to that recipient under the terms of the Applicable
+    License; (III) You must keep intact all notices that refer to the
+    Applicable License and to the disclaimer of warranties with every copy
+    of the Work as included in the Adaptation You Distribute or Publicly
+    Perform; (IV) when You Distribute or Publicly Perform the Adaptation,
+    You may not impose any effective technological measures on the
+    Adaptation that restrict the ability of a recipient of the Adaptation
+    from You to exercise the rights granted to that recipient under the
+    terms of the Applicable License. This Section 4(b) applies to the
+    Adaptation as incorporated in a Collection, but this does not require
+    the Collection apart from the Adaptation itself to be made subject to
+    the terms of the Applicable License.
+ c. If You Distribute, or Publicly Perform the Work or any Adaptations or
+    Collections, You must, unless a request has been made pursuant to
+    Section 4(a), keep intact all copyright notices for the Work and
+    provide, reasonable to the medium or means You are utilizing: (i) the
+    name of the Original Author (or pseudonym, if applicable) if supplied,
+    and/or if the Original Author and/or Licensor designate another party
+    or parties (e.g., a sponsor institute, publishing entity, journal) for
+    attribution ("Attribution Parties") in Licensor's copyright notice,
+    terms of service or by other reasonable means, the name of such party
+    or parties; (ii) the title of the Work if supplied; (iii) to the
+    extent reasonably practicable, the URI, if any, that Licensor
+    specifies to be associated with the Work, unless such URI does not
+    refer to the copyright notice or licensing information for the Work;
+    and (iv) , consistent with Ssection 3(b), in the case of an
+    Adaptation, a credit identifying the use of the Work in the Adaptation
+    (e.g., "French translation of the Work by Original Author," or
+    "Screenplay based on original Work by Original Author"). The credit
+    required by this Section 4(c) may be implemented in any reasonable
+    manner; provided, however, that in the case of a Adaptation or
+    Collection, at a minimum such credit will appear, if a credit for all
+    contributing authors of the Adaptation or Collection appears, then as
+    part of these credits and in a manner at least as prominent as the
+    credits for the other contributing authors. For the avoidance of
+    doubt, You may only use the credit required by this Section for the
+    purpose of attribution in the manner set out above and, by exercising
+    Your rights under this License, You may not implicitly or explicitly
+    assert or imply any connection with, sponsorship or endorsement by the
+    Original Author, Licensor and/or Attribution Parties, as appropriate,
+    of You or Your use of the Work, without the separate, express prior
+    written permission of the Original Author, Licensor and/or Attribution
+    Parties.
+ d. Except as otherwise agreed in writing by the Licensor or as may be
+    otherwise permitted by applicable law, if You Reproduce, Distribute or
+    Publicly Perform the Work either by itself or as part of any
+    Adaptations or Collections, You must not distort, mutilate, modify or
+    take other derogatory action in relation to the Work which would be
+    prejudicial to the Original Author's honor or reputation. Licensor
+    agrees that in those jurisdictions (e.g. Japan), in which any exercise
+    of the right granted in Section 3(b) of this License (the right to
+    make Adaptations) would be deemed to be a distortion, mutilation,
+    modification or other derogatory action prejudicial to the Original
+    Author's honor and reputation, the Licensor will waive or not assert,
+    as appropriate, this Section, to the fullest extent permitted by the
+    applicable national law, to enable You to reasonably exercise Your
+    right under Section 3(b) of this License (right to make Adaptations)
+    but not otherwise.
+
+5. Representations, Warranties and Disclaimer
+
+UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR
+OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY
+KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE,
+INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY,
+FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF
+LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS,
+WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION
+OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.
+
+6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE
+LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR
+ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES
+ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS
+BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. Termination
+
+ a. This License and the rights granted hereunder will terminate
+    automatically upon any breach by You of the terms of this License.
+    Individuals or entities who have received Adaptations or Collections
+    from You under this License, however, will not have their licenses
+    terminated provided such individuals or entities remain in full
+    compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will
+    survive any termination of this License.
+ b. Subject to the above terms and conditions, the license granted here is
+    perpetual (for the duration of the applicable copyright in the Work).
+    Notwithstanding the above, Licensor reserves the right to release the
+    Work under different license terms or to stop distributing the Work at
+    any time; provided, however that any such election will not serve to
+    withdraw this License (or any other license that has been, or is
+    required to be, granted under the terms of this License), and this
+    License will continue in full force and effect unless terminated as
+    stated above.
+
+8. Miscellaneous
+
+ a. Each time You Distribute or Publicly Perform the Work or a Collection,
+    the Licensor offers to the recipient a license to the Work on the same
+    terms and conditions as the license granted to You under this License.
+ b. Each time You Distribute or Publicly Perform an Adaptation, Licensor
+    offers to the recipient a license to the original Work on the same
+    terms and conditions as the license granted to You under this License.
+ c. If any provision of this License is invalid or unenforceable under
+    applicable law, it shall not affect the validity or enforceability of
+    the remainder of the terms of this License, and without further action
+    by the parties to this agreement, such provision shall be reformed to
+    the minimum extent necessary to make such provision valid and
+    enforceable.
+ d. No term or provision of this License shall be deemed waived and no
+    breach consented to unless such waiver or consent shall be in writing
+    and signed by the party to be charged with such waiver or consent.
+ e. This License constitutes the entire agreement between the parties with
+    respect to the Work licensed here. There are no understandings,
+    agreements or representations with respect to the Work not specified
+    here. Licensor shall not be bound by any additional provisions that
+    may appear in any communication from You. This License may not be
+    modified without the mutual written agreement of the Licensor and You.
+ f. The rights granted under, and the subject matter referenced, in this
+    License were drafted utilizing the terminology of the Berne Convention
+    for the Protection of Literary and Artistic Works (as amended on
+    September 28, 1979), the Rome Convention of 1961, the WIPO Copyright
+    Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996
+    and the Universal Copyright Convention (as revised on July 24, 1971).
+    These rights and subject matter take effect in the relevant
+    jurisdiction in which the License terms are sought to be enforced
+    according to the corresponding provisions of the implementation of
+    those treaty provisions in the applicable national law. If the
+    standard suite of rights granted under applicable copyright law
+    includes additional rights not granted under this License, such
+    additional rights are deemed to be included in the License; this
+    License is not intended to restrict the license of any rights under
+    applicable law.
+
+
+Creative Commons Notice
+
+    Creative Commons is not a party to this License, and makes no warranty
+    whatsoever in connection with the Work. Creative Commons will not be
+    liable to You or any party on any legal theory for any damages
+    whatsoever, including without limitation any general, special,
+    incidental or consequential damages arising in connection to this
+    license. Notwithstanding the foregoing two (2) sentences, if Creative
+    Commons has expressly identified itself as the Licensor hereunder, it
+    shall have all rights and obligations of Licensor.
+
+    Except for the limited purpose of indicating to the public that the
+    Work is licensed under the CCPL, Creative Commons does not authorize
+    the use by either party of the trademark "Creative Commons" or any
+    related trademark or logo of Creative Commons without the prior
+    written consent of Creative Commons. Any permitted use will be in
+    compliance with Creative Commons' then-current trademark usage
+    guidelines, as may be published on its website or otherwise made
+    available upon request from time to time. For the avoidance of doubt,
+    this trademark restriction does not form part of the License.
+
+    Creative Commons may be contacted at https://creativecommons.org/.
diff --git a/ada.html.markdown b/ada.html.markdown
new file mode 100644
index 00000000..7191c5dc
--- /dev/null
+++ b/ada.html.markdown
@@ -0,0 +1,416 @@
+---
+language: Ada
+filename: learn.ada
+contributors:
+    - ["Luke A. Guest", "https://github.com/Lucretia"]
+    - ["Fernando Oleo Blanco", "https://github.com/Irvise"]
+    - ["Fabien Chouteau", "https://github.com/Fabien-Chouteau"]
+    - ["Manuel", "https://github.com/mgrojo"]
+---
+
+Ada is a strong statically typed imperative, [object-oriented](https://ada-lang.io/docs/arm/AA-3/AA-3.9), [real-time](https://ada-lang.io/docs/arm/AA-D), [parallel](https://ada-lang.io/docs/arm/AA-9) and [distributed](https://ada-lang.io/docs/arm/AA-9) programming language from the Pascal/Algol family of languages, but nowadays, it only has a passing resemblance to Pascal, with the only remnants left being the ```begin/end``` keyword pair, the ```:=``` assignment symbol, records and ```if/case``` control statement structures.
+
+Ada was originally designed to be an [object-based](https://ada-lang.io/docs/arm/AA-3/AA-3.3) language and to replace 100's of languages in use by the US government. This means that all entities are objects, not in the object-oriented sense. The language became [Object-Oriented](https://ada-lang.io/docs/arm/AA-3/AA-3.9) in 1995, and added [interfaces](https://ada-lang.io/docs/arm/AA-3/AA-3.9#Subclause_3.9.4) derived from Java in 2005. [Contract based](https://ada-lang.io/docs/arm/AA-13/AA-13.1#Subclause_13.1.1) programming was introduced with Ada 2012.
+
+Ada was designed to be easy to read and learn, even for non-programmers, e.g. management within an organisation, therefore programs written in the language tend to be a bit more verbose.
+
+Ada is a modern programming language, and now has a package manager like other modern languages, Alire, see below.
+
+```ada
+--  Comments are written with a double hyphen and exist until the end of
+--  the line.
+
+--  You do not need to call the entry point "Main" or "main," you should
+--  name it based on what the program does.
+procedure Empty is
+   --  This is a declarative part.
+begin
+   --  Statements go here.
+   null;  --  Do nothing here.
+end Empty;
+
+--  Ada compilers accept compilation units which can be library packages,
+--  tasks, sub-programs, generics, etc.
+
+--  This is where "context clauses" go, these can be pragmas or "with"
+--  statements. "with" is equivalent to "include" or "import" in other
+--  languages.
+with Ada.Text_IO;  --  Get access to a library package.
+
+procedure Hello is
+begin
+   Ada.Text_IO.Put_Line ("Hello, world");
+
+   Ada.Text_IO.Put ("Hello again, world");
+   Ada.Text_IO.New_Line;
+end Hello;
+
+
+--  Ada has a real module system. Modules are called packages and are split into
+--  two component parts, the specification and a body.
+--  It is important to introduce packages early, as you will be using them from
+--  the start.
+package Stuff is
+   --  We could add the following line in order to tell the compiler that this
+   --  package does not have to run any code before the "main" procedure starts.
+   --  pragma Preelaborate;
+
+   --  Packages can be nested within the same file or externally.
+   --  Nested packages are accessed via dot notation, e.g. Stuff.Things.My.
+   package Things is
+      My : constant Integer := 100;
+   end Things;
+
+   --  If there are sub-programs declared within the specification, the body
+   --  of the sub-program must be declared within the package body.
+   procedure Do_Something;  --  If a subprogram takes no parameters, empty
+                            --  parentheses are not required, unlike other
+                            --  languages.
+
+   --  We can also make generic sub-programs.
+   generic
+      type Element is (<>);  --  The "(<>)" notation specifies that only
+                             --  discrete types can be passed into the generic.
+   procedure Swap (Left, Right : in out Element);
+
+   --  Sometimes we want to hide how a type is defined from the outside world
+   --  so that nobody can mess with it directly. The full type must be defined
+   --  within the private section below.
+   type Blobs is private;
+
+   --  We can also make types "limited" by putting this keyword after the "is"
+   --  keyword, this means that the user cannot copy objects of that type
+   --  around, like they normally could.
+private
+   type Blobs is new Integer range -25 .. 25;
+end Stuff;
+
+
+package body Stuff is
+   --  Sub-program body.
+   procedure Do_Something is
+      --  We can nest sub-programs too.
+      --  Parameters are defined with the direction of travel, in, in out, out.
+      --  If the direction of travel is not specified, they are in by default.
+      function Times_4 (Value : in Integer) return Integer is
+      begin
+         return Value * 4;
+      end Times_4;
+
+      I : Integer := 4;
+   begin
+      I := Times_4 (I);
+   end Do_Something;
+
+
+   --  Generic procedure body.
+   procedure Swap (Left, Right : in out Element) is
+      Temp : Element := Left;
+   begin
+      Left  := Right;
+      Right := Temp;
+   end Swap;
+begin
+   --  If we need to initialise something within the package, we can do it
+   --  here.
+   Do_Something;
+end Stuff;
+
+
+with Ada.Unchecked_Conversion;
+with Ada.Text_IO;
+with Stuff;
+
+procedure LearnAdaInY is
+   --  Indentation is 3 spaces.
+
+   --  The most important feature in Ada is the type. Objects have types and an
+   --  object of one type cannot be assigned to an object of another type.
+
+   --  You can, and should, define your own types for the domain you are
+   --  modelling. But you can use the standard types to start with and then
+   --  replace them later with your own types, this could be called a form of
+   --  gradual typing.
+
+   --  The standard types would only really be a good starting point for binding
+   --  to other languages, like C. Ada is the only language with a standardised
+   --  way to bind with C, Fortran and COBOL! See the links in the References
+   --  section with more information on binding to these languages.
+
+   type Degrees is range 0 .. 360;  --  This is a type. Its underlying
+                                    --  representation is an Integer.
+
+   type Hues is (Red, Green, Blue, Purple, Yellow);  --  So is this. Here, we
+                                                     --  are declaring an
+                                                     --  Enumeration.
+
+   --  This is a modular type. They behave like Integers that automatically
+   --  wrap around. In this specific case, the range would be 0 .. 359.
+   --  If we added 1 to a variable containing the value 359, we would receive
+   --  back 0. They are very useful for arrays.
+   type Degrees_Wrap is mod 360;
+
+   --  You can restrict a type's range using a subtype, this makes them
+   --  compatible with each other, i.e. the subtype can be assigned to an
+   --  object of the type, as can be seen below.
+   subtype Primaries is Hues range Red .. Blue;  --  This is a range.
+
+   --  You can define variables or constants like this:
+   --  Var_Name : Type := Value;
+
+   --  10 is a universal integer. These universal numerics can be used with
+   --  any type which matches the base type.
+   Angle : Degrees := 10;
+   Value : Integer := 20;
+   --  New_Angle : Degrees := Value;  --  Incompatible types won't compile.
+   --  New_Value : Integer := Angle;
+
+   Blue_Hue   :          Primaries := Blue;  --  A variable.
+   Red_Hue    : constant Primaries := Red;   --  A constant.
+   Yellow_Hue : constant Hues      := Yellow;
+   Colour_1   : constant Hues      := Red_Hue;
+   --  Colour_2   : constant Primaries := Yellow_Hue;  --  uncomment to compile.
+
+   --  You can force conversions, but then you are warned by the name of the
+   --  package that you may be doing something unsafe.
+   function Degrees_To_Int is new Ada.Unchecked_Conversion
+     (Source => Degrees,   --  Line continuations are indented by 2 spaces.
+      Target => Integer);
+
+   New_Value_2 : Integer := Degrees_To_Int (Angle);  --  Note, space before (.
+
+   --  GNAT is the GNU Ada Translator (compiler).
+   --  Ada has a style guide and GNAT will warn you to adhere to it, and has
+   --  option to check your style so that you can correct it so that all Ada
+   --  source looks consistent. However, the style can be customized.
+
+   --  Yes, you can even define your own floating and fixed point types, this
+   --  is a very rare and unique ability. "digits" refers to the minimum
+   --  digit precision that the type should support. "delta" is for fixed
+   --  point types and refers to the smallest change that the type will support.
+   type Real_Angles is digits 3 range 0.0 .. 360.0;
+   type Fixed_Angles is delta 0.01 digits 5 range 0.0 .. 360.0;
+
+   RA : constant Real_Angles  := 36.45;
+   FA : constant Fixed_Angles := 360.0;  --  ".0" in order to make it a Float.
+
+   --  You can have normal Latin 1 based strings by default.
+   Str  : constant String    := "This is a constant string";
+   --  When initialising from a string literal, the compiler knows the bounds,
+   --  so we don't have to define them.
+
+   --  Strings are arrays. Note how parentheses are used to access elements of
+   --  an array? This is mathematical notation and was used because square
+   --  brackets were not available on all keyboards at the time Ada was
+   --  created. Also, because an array can be seen as a function from a
+   --  mathematical perspective, so it made converting between arrays and
+   --  functions easier.
+   Char : constant Character := Str (Str'First);  --  "'First" is a type
+                                                  --  attribute.
+
+   --  Ada 2022 includes the use of [] for array initialisation when using
+   --  containers, which were added in Ada 2012.
+
+   --  Arrays are usually always defined as a type.
+   --  They can be any dimension.
+   type My_Array_1 is array (1 .. 4, 3 .. 7, -20 .. 20) of Integer;
+
+   --  Yes, unlike other languages, you can index arrays with other discrete
+   --  types such as enumerations and modular types or arbitrary ranges.
+   type Axes is (X, Y, Z);
+
+   --  You can define the array's range using the 'Range attribute from
+   --  another type.
+   type Vector is array (Axes'Range) of Float;
+
+   V1 : constant Vector := (0.0, 0.0, 1.0);
+
+   --  A record is the same as a structure in C, C++.
+   type Entities is record
+      Name     : String (1 .. 10);  --  Always starts at a positive value,
+                                    --  inclusive range.
+      Position : Vector;
+   end record;
+
+   --  In Ada, array bounds are immutable. You therefore have to provide a
+   --  string literal with a value for every character.
+   E1 : constant Entities := ("Blob      ", (0.0, 0.0, 0.0));
+
+   --  An alternative is to use an array aggregate and assign a default value
+   --  to every element that wasn't previously assigned in this aggregate.
+   --  "others" is used to indicate anything else that has not been
+   --  explicitly initialized.
+   E2 : constant Entities := (('B', 'l', 'o', 'b', others => ' '),
+                              (0.0, 0.0, 0.0));
+
+   --  There are dynamic length strings (see references section) available in
+   --  the standard library.
+
+   --  We can make an object be initialised to its default values with the box
+   --  notation, "<>". "others" is used to indicate anything else that has not
+   --  been explicitly initialized.
+   Null_Entity : constant Entities := (others => <>);
+
+   --  Object-orientation is accomplished via an extension of record syntax,
+   --  tagged records, see link above in first paragraph.
+
+   --  We can rename objects (aliases) to make readability a bit better.
+   package IO renames Ada.Text_IO;
+begin
+   --  We can output enumerations as names.
+   IO.Put_Line ("Blue_Hue   = " &  --  & is the string concatenation operator.
+                Blue'Image);       --  ' accesses attributes on objects.
+                  --  The Image attribute converts a value to a string.
+                  --  Ada 2022 has extended Image to custom types too.
+                  --  Access this with -gnat2022 compiler flag.
+   IO.Put_Line ("Yellow_Hue = " &
+                --  We can use the type's attribute.
+                Primaries'Image (Yellow_Hue));
+
+   --  We can define local variables within a declare block, this can be made
+   --  more readable by giving it a label.
+   Enum_IO : declare
+      package Hue_IO is new IO.Enumeration_IO (Hues);
+
+      --  Using a package makes everything inside that package visible within
+      --  this block, it is good practice to only do this locally and not on
+      --  a whole package within the context clause.
+      use Hue_IO;
+   begin
+      --  We can print out the enumeration values too.
+      Put (Purple); --  Note we don't have to prefix the Put procedure with
+                    --  Hue_IO.
+      IO.New_Line;  --  We still need to prefix with IO here.
+      Put (Red_Hue);
+      IO.New_Line;
+   end Enum_IO;
+
+   --  Loops have a consistent form. "<form> loop ... end loop".
+   --  Where "form" can be "while" or "for" or missing as below, if
+   --  you place the "loop ... end loop;" construct on their own lines,
+   --  you can comment out or experiment with different loop constructs more
+   --  easily.
+   declare
+      Counter : Positive := Positive'First;  --  This is 1.
+   begin
+      --  We can label loops so we can exit from them more easily if we need to.
+      Infinite :
+      loop
+         IO.Put_Line ("[Infinite loop] Counter = " & Counter'Image);
+
+         Counter := Counter + 1;
+
+         --  This next line implements a repeat ... until or do ... while loop construct.
+         --  Comment it out for an infinite loop.
+         exit Infinite when Counter = 5;  --  Equality tests use a single "=".
+      end loop Infinite;  --  Useful when implementing state machines.
+   end;
+
+   declare  --  We don't have to have a label.
+      Counter : Positive := Positive'First;  --  This is 1.
+   begin
+      while Counter < 10
+      loop
+         IO.Put_Line ("Counter = " & Counter'Image);
+
+         Counter := Counter + 1;  --  There is no explicit inc/decrement.
+
+         --  Ada 2022 introduced @ for LHS, so the above would be written as
+         --  Counter := @ + 1;  --  Try it, -gnat2022.
+      end loop;
+   end;
+
+   declare
+      package Hue_IO is new IO.Enumeration_IO (Hues);
+
+      --  We can have multiple packages on one line, but I tend to use one
+      --  package per line for readability.
+      use IO, Hue_IO;
+   begin
+      Put ("Hues : ");  --  Note, no prefix.
+
+      --  Because we are using the 'Range attribute, the compiler knows it is
+      --  safe and can omit run-time checks here.
+      for Hue in Hues'Range
+      loop
+         Put (Hue);
+
+         --  Types and objects know about their bounds, their First .. Last
+         --  values. These can be specified as range types.
+         if Hue /= Hues'Last then  --  The /= means "not equal to" like the
+                                   --  maths symbol ≠.
+            Put (", ");
+         end if;
+      end loop;
+
+      IO.New_Line;
+   end;
+
+   --  All objects know their bounds, including strings.
+   declare
+      C : Character := Str (50);  --  Warning caused and exception raised at
+                                  --  runtime.
+      --  The exception raised above can only be handled by an outer scope,
+      --  see wikibook link below.
+   begin
+      null;  --  We will never get to this point because of the above.
+   end;
+exception
+   when Constraint_Error =>
+      IO.Put_Line ("Caught the exception");
+end LearnAdaInY;
+```
+
+Now, that's a lot of information for a basic intro to Ada, and I've only touched the surface, there's much more to look at in the references section below. I haven't even touched on dynamic memory allocation which includes [pools](https://ada-lang.io/docs/arm/AA-13/AA-13.11), this is because for the most part, Ada programs don't need it, you can do a lot without it.
+
+As I stated above, Ada barely looks like Pascal and if you look at the original [Green specification](https://apps.dtic.mil/sti/trecms/pdf/ADB950587.pdf) (Warning: Huge 4575 page scanned PDF - starting on page 460), it looks nothing like it at all (page 505 of that PDF).
+
+The above source code will compile, but also will give warnings showing the power of the strong static type system.
+
+## Download this source
+
+If you already have the GNAT toolchain installed, you can cut and paste the above into a new file, e.g. ```learn-ada-in-y.ada``` and then run the following:
+
+```bash
+$ gnatchop learn-ada-in-y.ada # This breaks the program into its specification ".ads" and body ".adb".
+$ gnatmake empty.adb # gnatmake takes care of compilation of all units and linking.
+$ gnatmake hello.adb
+$ gnatmake learnadainy.adb
+```
+
+Or, download [Alire](https://alire.ada.dev), copy it to somewhere in your PATH and then do the following:
+
+**N.B.** Alire will automatically install the toolchain for you if you don't have one installed and will ask you to select which you want to use.
+
+```bash
+$ alr search learnadainy
+$ alr get learnadainy
+$ cd learnadainy
+$ alr run empty
+$ alr run hello
+$ alr run learnadainy
+```
+
+## Further Reading
+
+* [Ada Programming Language](https://ada-lang.io)
+* [Ada 2022 Reference Manual](https://ada-lang.io/docs/arm)
+* [Ada Style Guide](https://ada-lang.io/docs/style-guide/Ada_Style_Guide)
+* [Learn more Ada/Spark at AdaCore's site](https://learn.adacore.com)
+
+## References from the source above
+
+1. [wikibook](https://en.wikibooks.org/wiki/Ada_Programming/Exceptions#Exception_handlers)
+2. [C](https://ada-lang.io/docs/arm/AA-B/AA-B.3)
+3. [Fortran](https://ada-lang.io/docs/arm/AA-B/AA-B.5/)
+4. [COBOL](https://ada-lang.io/docs/arm/AA-B/AA-B.4/)
+5. [dynamic length strings](https://ada-lang.io/docs/arm/AA-A/AA-A.4#Subclause_A.4.5)
+
+### Multi-line comments
+
+Multi-line comments are not allowed as they are error prone.
+
+> Such comments would require a closing comment delimiter and this would again raise the dangers associated with the (unintentional) omission of the closing delimiter: entire sections of a program could be ignored by the compiler without the programmer realizing it
+>
+> [Ada 83 Rationale](http://archive.adaic.com/standards/83rat/html/ratl-02-01.html#2.1)
+
diff --git a/amd.html.markdown b/amd.html.markdown
index d7fb41ba..fc8f20a4 100644
--- a/amd.html.markdown
+++ b/amd.html.markdown
@@ -1,212 +1,212 @@
----

-category: tool

-tool: amd

-contributors:

-    - ["Frederik Ring", "https://github.com/m90"]

-filename: learnamd.js

----

-

-## Getting Started with AMD

-

-The **Asynchronous Module Definition** API specifies a mechanism for defining

-JavaScript modules such that the module and its dependencies can be asynchronously

-loaded. This is particularly well suited for the browser environment where

-synchronous loading of modules incurs performance, usability, debugging, and

-cross-domain access problems.

-

-### Basic concept

-```javascript

-// The basic AMD API consists of nothing but two methods: `define` and `require`

-// and is all about module definition and consumption:

-// `define(id?, dependencies?, factory)` defines a module

-// `require(dependencies, callback)` imports a set of dependencies and

-// consumes them in the passed callback

-

-// Let's start by using define to define a new named module

-// that has no dependencies. We'll do so by passing a name

-// and a factory function to define:

-define('awesomeAMD', function(){

-  var isAMDAwesome = function(){

-    return true;

-  };

-  // The return value of a module's factory function is

-  // what other modules or require calls will receive when

-  // requiring our `awesomeAMD` module.

-  // The exported value can be anything, (constructor) functions,

-  // objects, primitives, even undefined (although that won't help too much).

-  return isAMDAwesome;

-});

-

-// Now, let's define another module that depends upon our `awesomeAMD` module.

-// Notice that there's an additional argument defining our

-// module's dependencies now:

-define('loudmouth', ['awesomeAMD'], function(awesomeAMD){

-  // dependencies will be passed to the factory's arguments

-  // in the order they are specified

-  var tellEveryone = function(){

-    if (awesomeAMD()){

-      alert('This is sOoOo rad!');

-    } else {

-      alert('Pretty dull, isn\'t it?');

-    }

-  };

-  return tellEveryone;

-});

-

-// As we do know how to use define now, let's use `require` to

-// kick off our program. `require`'s signature is `(arrayOfDependencies, callback)`.

-require(['loudmouth'], function(loudmouth){

-  loudmouth();

-});

-

-// To make this tutorial run code, let's implement a very basic

-// (non-asynchronous) version of AMD right here on the spot:

-function define(name, deps, factory){

-  // notice how modules without dependencies are handled

-  define[name] = require(factory ? deps : [], factory || deps);

-}

-

-function require(deps, callback){

-  var args = [];

-  // first let's retrieve all the dependencies needed

-  // by the require call

-  for (var i = 0; i < deps.length; i++){

-    args[i] = define[deps[i]];

-  }

-  // satisfy all the callback's dependencies

-  return callback.apply(null, args);

-}

-// you can see this code in action here: http://jsfiddle.net/qap949pd/

-```

-

-### Real-world usage with require.js

-

-In contrast to the introductory example, `require.js` (the most popular AMD library) actually implements the **A** in **AMD**, enabling you to load modules and their dependencies asynchronously via XHR:

-

-```javascript

-/* file: app/main.js */

-require(['modules/someClass'], function(SomeClass){

-  // the callback is deferred until the dependency is loaded

-  var thing = new SomeClass();

-});

-console.log('So here we are, waiting!'); // this will run first

-```

-

-By convention, you usually store one module in one file. `require.js` can resolve module names based on file paths, so you don't have to name your modules, but can simply reference them using their location. In the example `someClass` is assumed to be in the `modules` folder, relative to your configuration's `baseUrl`:

-

-* app/

-  * main.js

-  * modules/

-    * someClass.js

-    * someHelpers.js

-    * ...

-  * daos/

-    * things.js

-    * ...

-

-This means we can define `someClass` without specifying a module id:

-

-```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;

-});

-```

-To alter the default path mapping behavior use `requirejs.config(configObj)` in your `main.js`:

-

-```javascript

-/* file: main.js */

-requirejs.config({

-  baseUrl : 'app',

-  paths : {

-    // you can also load modules from other locations

-    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){

-  // a `main` file needs to call require at least once,

-  // otherwise no code will ever run

-  coolLib.doFancyStuffWith(helpers.transform($('#foo')));

-});

-```

-`require.js`-based apps will usually have a single entry point (`main.js`) that is passed to the `require.js` script tag as a data-attribute. It will be automatically loaded and executed on 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>

-```

-

-### Optimizing a whole project using r.js

-

-Many people prefer using AMD for sane code organization during development, but still want to ship a single script file in production instead of performing hundreds of XHRs on page load.

-

-`require.js` comes with a script called `r.js` (that you will probably run in node.js, although Rhino is supported too) that can analyse your project's dependency graph, and build a single file containing all your modules (properly named), minified and ready for consumption.

-

-Install it using `npm`:

-```shell

-$ npm install requirejs -g

-```

-

-Now you can feed it with a configuration file:

-```shell

-$ r.js -o app.build.js

-```

-

-For our above example the configuration might look like:

-```javascript

-/* file : app.build.js */

-({

-  name : 'main', // name of the entry point

-  out : 'main-built.js', // name of the file to write the output to

-  baseUrl : 'app',

-  paths : {

-    // `empty:` tells r.js that this should still be loaded from the CDN, using

-    // the location specified in `main.js`

-    jquery : 'empty:',

-    coolLibFromBower : '../bower_components/cool-lib/coollib'

-  }

-})

-```

-

-To use the built file in production, simply swap `data-main`:

-```html

-<script src="require.js" data-main="app/main-built"></script>

-```

-

-An incredibly detailed [overview of build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) is available in the GitHub repo.

-

-### Topics not covered in this tutorial

-* [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)

-

-### Further reading:

-

-* [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)

-

-### Implementations:

-

-* [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)

+---
+category: tool
+tool: amd
+contributors:
+    - ["Frederik Ring", "https://github.com/m90"]
+filename: learnamd.js
+---
+
+## Getting Started with AMD
+
+The **Asynchronous Module Definition** API specifies a mechanism for defining
+JavaScript modules such that the module and its dependencies can be asynchronously
+loaded. This is particularly well suited for the browser environment where
+synchronous loading of modules incurs performance, usability, debugging, and
+cross-domain access problems.
+
+### Basic concept
+```javascript
+// The basic AMD API consists of nothing but two methods: `define` and `require`
+// and is all about module definition and consumption:
+// `define(id?, dependencies?, factory)` defines a module
+// `require(dependencies, callback)` imports a set of dependencies and
+// consumes them in the passed callback
+
+// Let's start by using define to define a new named module
+// that has no dependencies. We'll do so by passing a name
+// and a factory function to define:
+define('awesomeAMD', function(){
+  var isAMDAwesome = function(){
+    return true;
+  };
+  // The return value of a module's factory function is
+  // what other modules or require calls will receive when
+  // requiring our `awesomeAMD` module.
+  // The exported value can be anything, (constructor) functions,
+  // objects, primitives, even undefined (although that won't help too much).
+  return isAMDAwesome;
+});
+
+// Now, let's define another module that depends upon our `awesomeAMD` module.
+// Notice that there's an additional argument defining our
+// module's dependencies now:
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+  // dependencies will be passed to the factory's arguments
+  // in the order they are specified
+  var tellEveryone = function(){
+    if (awesomeAMD()){
+      alert('This is sOoOo rad!');
+    } else {
+      alert('Pretty dull, isn\'t it?');
+    }
+  };
+  return tellEveryone;
+});
+
+// As we do know how to use define now, let's use `require` to
+// kick off our program. `require`'s signature is `(arrayOfDependencies, callback)`.
+require(['loudmouth'], function(loudmouth){
+  loudmouth();
+});
+
+// To make this tutorial run code, let's implement a very basic
+// (non-asynchronous) version of AMD right here on the spot:
+function define(name, deps, factory){
+  // notice how modules without dependencies are handled
+  define[name] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+  var args = [];
+  // first let's retrieve all the dependencies needed
+  // by the require call
+  for (var i = 0; i < deps.length; i++){
+    args[i] = define[deps[i]];
+  }
+  // satisfy all the callback's dependencies
+  return callback.apply(null, args);
+}
+// you can see this code in action here: http://jsfiddle.net/qap949pd/
+```
+
+### Real-world usage with require.js
+
+In contrast to the introductory example, `require.js` (the most popular AMD library) actually implements the **A** in **AMD**, enabling you to load modules and their dependencies asynchronously via XHR:
+
+```javascript
+/* file: app/main.js */
+require(['modules/someClass'], function(SomeClass){
+  // the callback is deferred until the dependency is loaded
+  var thing = new SomeClass();
+});
+console.log('So here we are, waiting!'); // this will run first
+```
+
+By convention, you usually store one module in one file. `require.js` can resolve module names based on file paths, so you don't have to name your modules, but can simply reference them using their location. In the example `someClass` is assumed to be in the `modules` folder, relative to your configuration's `baseUrl`:
+
+* app/
+  * main.js
+  * modules/
+    * someClass.js
+    * someHelpers.js
+    * ...
+  * daos/
+    * things.js
+    * ...
+
+This means we can define `someClass` without specifying a module id:
+
+```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;
+});
+```
+To alter the default path mapping behavior use `requirejs.config(configObj)` in your `main.js`:
+
+```javascript
+/* file: main.js */
+requirejs.config({
+  baseUrl : 'app',
+  paths : {
+    // you can also load modules from other locations
+    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){
+  // a `main` file needs to call require at least once,
+  // otherwise no code will ever run
+  coolLib.doFancyStuffWith(helpers.transform($('#foo')));
+});
+```
+`require.js`-based apps will usually have a single entry point (`main.js`) that is passed to the `require.js` script tag as a data-attribute. It will be automatically loaded and executed on 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>
+```
+
+### Optimizing a whole project using r.js
+
+Many people prefer using AMD for sane code organization during development, but still want to ship a single script file in production instead of performing hundreds of XHRs on page load.
+
+`require.js` comes with a script called `r.js` (that you will probably run in node.js, although Rhino is supported too) that can analyse your project's dependency graph, and build a single file containing all your modules (properly named), minified and ready for consumption.
+
+Install it using `npm`:
+```shell
+$ npm install requirejs -g
+```
+
+Now you can feed it with a configuration file:
+```shell
+$ r.js -o app.build.js
+```
+
+For our above example the configuration might look like:
+```javascript
+/* file : app.build.js */
+({
+  name : 'main', // name of the entry point
+  out : 'main-built.js', // name of the file to write the output to
+  baseUrl : 'app',
+  paths : {
+    // `empty:` tells r.js that this should still be loaded from the CDN, using
+    // the location specified in `main.js`
+    jquery : 'empty:',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+})
+```
+
+To use the built file in production, simply swap `data-main`:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+An incredibly detailed [overview of build options](https://github.com/jrburke/r.js/blob/master/build/example.build.js) is available in the GitHub repo.
+
+### Topics not covered in this tutorial
+* [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)
+
+### Further reading:
+
+* [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)
+
+### Implementations:
+
+* [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/ansible.html.markdown b/ansible.html.markdown
index 30dfba13..847505c1 100644
--- a/ansible.html.markdown
+++ b/ansible.html.markdown
@@ -44,7 +44,7 @@ for, which provides an excellent UI.
 #### Cons
 
 * It is an agent-less tool - every agent consumes up to 16MB ram - in some
-environments, it may be noticable amount.
+environments, it may be noticeable amount.
 * It is agent-less - you have to verify your environment consistency
 'on-demand' - there is no built-in mechanism that would warn you about some
 change automatically (this can be achieved with reasonable effort)
@@ -691,7 +691,7 @@ to specify the username.
 
 Note: You may like to execute Ansible with `--ask-sudo-pass` or add the user to
 sudoers file in order to allow non-supervised execution if you require 'admin'
-privilages.
+privileges.
 
 [Read more](http://docs.ansible.com/ansible/latest/become.html)
 
@@ -753,3 +753,4 @@ the `register` command.
 * [A system administrator's guide to getting started with Ansible - FAST!](https://www.redhat.com/en/blog/system-administrators-guide-getting-started-ansible-fast)
 * [Ansible Tower](https://www.ansible.com/products/tower) - Ansible Tower provides a web UI, dashboard and rest interface to ansible.
 * [Ansible AWX](https://github.com/ansible/awx) - The Open Source version of Ansible Tower.
+* [Ansible Tutorial for Beginners: Ultimate Playbook & Examples](https://spacelift.io/blog/ansible-tutorial)
diff --git a/ar-ar/sql-ar.html.markdown b/ar-ar/sql-ar.html.markdown
new file mode 100644
index 00000000..dea20c1f
--- /dev/null
+++ b/ar-ar/sql-ar.html.markdown
@@ -0,0 +1,135 @@
+---
+language: SQL
+filename: learnsql-ar.sql
+contributors:
+  - ["Bob DuCharme", "http://bobdc.com/"]
+translators:
+    - ["Ahmed Omar Eissa", "https://twitter.com/AhmedOmarEissa"]
+lang: ar-ar
+---
+<div dir="rtl">
+
+لغة الاستعلام الهيكلية 
+(SQL) 
+هي لغة قياسية
+[ISO/IEC 9075](https://www.iso.org/standard/63555.html)
+لإنشاء قواعد البيانات المخزنة �ي مجموعة من الجداول التعامل معها. عادةً ما تضي� التطبيقات 
+امتدادات خاصة بها إلى اللغة ؛ تعد 
+[مقارنة نسخ SQL المختل�ة](http://troels.arvin.dk/db/rdbms/) 
+مرجعًا جيدًا لاختلا�ات النسخ.
+
+تو�ر النسخ عادةً موجه سطر أوامر
+command line prompt
+حيث يمكنك إدخال الأوامر المعروضة هنا بشكل ت�اعلي، كما أنها تو�ر طريقة لتن�يذ سلسلة من هذه الأوامر المخزنة �ي مل� نصي. إظهار رسالة الانتهاء من العمل مع الموجه الت�اعلي مثال جيد على امكانية اضا�ة أوامر غير قياسية، معظم النسخ تدعم أحد أوامر
+QUIT , EXIT
+.أو كليهما
+
+�ي الامثلة بالأس�ل تعتمدالعديد من الأوامرأن قاعدة بيانات الموظ�ين
+[MySQL employee sample database](https://dev.mysql.com/doc/employee/en/) 
+الموجودة على
+[github](https://github.com/datacharmer/test_db)
+قد تم تحميلها مسبقا. المل�ات على
+github 
+هي مجموعة من الاوامر تشبه الموجودة بالاس�ل و تقوم الأوامر بإنشاء الجدوال وإدخال بيانات مجموعة من الموظ�ين المتخيلين �ي شركة. تعتمد الأوامر المستخدمة �ي هذا البرنامج على نسخة 
+SQL 
+التي تستخدمها، 
+</div>
+
+
+
+
+```sql
+-- تبدأ التعليقات بشرطتين. قم بإنهاء كل أمر ب�اصلة منقوطة
+
+-- حساسة لحالة الاحر� SQL لا تعتبر
+-- �قط ليسهل تمييزها عن أسماه الأعمدة والجداول وقواعد البيانات UPPER-CASE  الاوامر الموجودة هنا تستخدم الحالة العليا للاحر� 
+
+-- إنشاء ومسح قاعدة بيانات، أسماء قواعد البيانات والجداول حساسة لحالة الأحر�
+CREATE DATABASE someDatabase;
+DROP DATABASE someDatabase;
+
+-- عرض قواعد البيانات الموجودة
+SHOW DATABASES;
+
+--استخدام قاعدة بيانات محددة
+USE employees;
+
+-- �ي قاعدة البيانات المستخدمة departments ارجاع كل السطور والاعمدة �ي جدول 
+-- ستظهر النتائج على الشاشة بشكل تلقائي لتتص�حها.
+SELECT * FROM departments;
+
+-- �قط dept_name و dept_no لكن سنسترجع عمودي departments استرجاع كل أسطر من جدول 
+-- لا مانع من تقسيم الاوامر بين السطور
+
+SELECT dept_no,
+       dept_name FROM departments;
+
+-- لكن هذه المرة سنسترجع ٥ أسطر �قط departments استرجاع كل الاعمدة من جدول
+SELECT * FROM departments LIMIT 5;
+
+--en يحتوي علي dept_name �ي حالة أن عمود  departments من جدول  dept_name استرجاع عمود 
+
+SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
+
+-- S استرجاع كل أعمدة جدول الاقسام �ي حالة أن اسم القسم يبدأ بحر�  
+-- متبوعا بأربعة حرو� 
+
+SELECT * FROM departments WHERE dept_name LIKE 'S____';
+
+-- استرجاع قيم العناوين من جدول العناوين بدون تكرار 
+SELECT DISTINCT title FROM titles;
+
+-- ن�س المثال السابق مع ترتيب العناوين أبجديا 
+SELECT DISTINCT title FROM titles ORDER BY title;
+
+-- اظهار عدد السطور �ي جدول الأقسام 
+SELECT COUNT(*) FROM departments;
+
+
+-- en اظهار عدد السطور �ي جدول الأقسام التي تحتوي �ي عمود اسم القسم علي 
+SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
+
+
+-- ربط المعلومات بين الجداول، جدول العناوين يظهر رقم كل موظ� ومسماه الوظي�ي 
+-- ومتي حصل على هذا المسمى وإلي متى ولكن بدلا من اظهار رقم الموظ� سنستخدم هذا الرقم
+-- للحصول على اسم الموظ� الاول والأخير من جدول الموظ�ين مع إظهار ١٠ سطور �قط
+SELECT employees.first_name, employees.last_name,
+       titles.title, titles.from_date, titles.to_date
+FROM titles INNER JOIN employees ON
+       employees.emp_no = titles.emp_no LIMIT 10;
+
+-- إظهار كل الجدوال �ي كل قواعد البيانات 
+-- النسخ المختل�ة تقدم اختصارات لمثل هذا الأمر لقاعدة البيانات المستخدمة
+
+SELECT * FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE='BASE TABLE';
+
+-- يحتوى على عمودان �ي قاعدة البيانات المستخدمة tablename1 أنشاء جدول يسمى  
+-- يوجد العديد من الطرق لتعري� الاعمدة وأنواع البيانات �ي العمود
+CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
+
+--  هذا با�تراض ان الجدول يمكن اضا�ة الاسطر له .tablename1 اضا�ة سطر �ي جدول 
+INSERT INTO tablename1 VALUES('Richard','Mutt');
+
+--John إلى fname سنغير قيمة عمود tablename1  �ي 
+-- Mutt هي lname  �ي حالة أن قيمة العمود
+UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
+
+
+-- 'M' تبدأ ب  lname �ي حالة أن قيمة عمود  tablename1 مسح السطور من جدول 
+DELETE FROM tablename1 WHERE lname like 'M%';
+
+-- مع ترك الجدول �ارغ tablename1 مسح جميع السطور من جدول 
+DELETE FROM tablename1;
+
+-- تماما tablename1 إزالة جدول 
+DROP TABLE tablename1;
+```
+<div dir="rtl">
+
+## اقرأ أكثر
+
+* [Codecademy - SQL](https://www.codecademy.com/learn/learn-sql)مقدمة جيدة للتعلم عن طريق التطبيق.
+* [Database System Concepts](https://www.db-book.com) ال�صل رقم ٣ من الكتاب مقدمة �ي (SQL) تحتوى علي شرح م�صل لم�اهيم (SQL)
+
+</div>
diff --git a/arturo.html.markdown b/arturo.html.markdown
new file mode 100644
index 00000000..c3c4dc43
--- /dev/null
+++ b/arturo.html.markdown
@@ -0,0 +1,432 @@
+---
+language: arturo
+filename: learnarturo.art
+contributors:
+  - ["Dr.Kameleon", "https://github.com/drkameleon"]
+---
+
+```red
+; this is a comment
+; this is another comment
+
+;---------------------------------
+; VARIABLES & VALUES
+;---------------------------------
+
+; numbers
+a1: 2
+a2: 3.14
+a3: to :complex [1 2.0]     ; 1.0+2.0i
+
+; strings
+c1: "this is a string"
+c2: {
+    this is a multiline string
+    that is indentation-agnostic
+}
+c3: {:
+    this is 
+        a verbatim
+            multiline string
+                which will remain exactly
+                    as the original
+:}
+
+; characters
+ch: `c`
+
+; blocks/arrays
+d: [1 2 3]
+
+; dictionaries
+e: #[
+    name: "John"
+    surname: "Doe"
+    age: 34
+    likes: [pizza spaghetti]
+]
+
+; yes, functions are values too
+f: function [x][
+    2 * x
+]
+
+; dates
+g: now              ; 2021-05-03T17:10:48+02:00
+
+; booleans
+h1: true
+h2: false
+
+;---------------------------------
+; BASIC OPERATORS
+;---------------------------------
+
+; simple arithmetic
+1 + 1       ; => 2
+8 - 1       ; => 7
+4.2 - 1.1   ; => 3.1
+10 * 2      ; => 20
+35 / 4      ; => 8
+35 // 4     ; => 8.75
+2 ^ 5       ; => 32
+5 % 3       ; => 2
+
+; bitwise operators
+and 3 5     ; => 1
+or 3 5      ; => 7
+xor 3 5     ; => 6
+
+; pre-defined constants
+pi          ; => 3.141592653589793
+epsilon     ; => 2.718281828459045
+null        ; => null
+true        ; => true
+false       ; => false
+
+;---------------------------------
+; COMPARISON OPERATORS
+;---------------------------------
+
+; equality
+1 = 1       ; => true
+2 = 1       ; => false
+
+; inequality
+1 <> 1      ; => false
+2 <> 1      ; => true
+
+; more comparisons
+1 < 10      ; => true
+1 =< 10     ; => true
+10 =< 10    ; => true
+1 > 10      ; => false
+1 >= 10     ; => false
+11 >= 10    ; => true
+
+;---------------------------------
+; CONDITIONALS
+;---------------------------------
+
+; logical operators
+and? true true      ; => true
+and? true false     ; => false
+or? true false      ; => true
+or? false false     ; => false
+
+and? [1=2][2<3]     ; => false 
+                    ; (the second block will not be evaluated)
+
+; simple if statements
+if 2 > 1 [ print "yes!"]    ; yes!
+if 3 <> 2 -> print "true!"  ; true!
+
+; if/else statements
+if? 2 > 3 -> print "2 is greater than 3"
+else -> print "2 is not greater than 3"         ; 2 is not greater than 3
+
+; switch statements
+switch 2 > 3 -> print "2 is greater than 3"
+             -> print "2 is not greater than 3" ; 2 is not greater than 3
+
+a: (2 > 3)["yes"]["no"]         ; a: "no"
+a: (2 > 3)? -> "yes" -> "no"    ; a: "no" (exactly the same as above)
+
+; case/when statements
+case [1]
+    when? [>2] -> print "1 is greater than 2. what?!"
+    when? [<0] -> print "1 is less than 0. nope..."
+    else -> print "here we are!"                ; here we are!
+
+;---------------------------------
+; LOOPS
+;---------------------------------
+
+; with `loop`
+arr: [1 4 5 3]
+loop arr 'x [
+    print ["x =" x]
+]
+; x = 1
+; x = 4
+; x = 5
+; x = 3
+
+; with loop and custom index
+loop.with:'i arr 'x [
+    print ["item at position" i "=>" x]
+]
+; item at position 0 => 1
+; item at position 1 => 4
+; item at position 2 => 5
+; item at position 3 => 3
+
+; using ranges
+loop 1..3 'x ->         ; since it's a single statement
+    print x             ; there's no need for [block] notation
+                        ; we can wrap it up using the `->` syntactic sugar
+
+loop `a`..`c` 'ch ->
+    print ch
+; a
+; b
+; c
+
+; picking multiple items
+loop 1..10 [x y] ->
+    print ["x =" x ", y =" y]
+; x = 1 , y = 2 
+; x = 3 , y = 4 
+; x = 5 , y = 6 
+; x = 7 , y = 8 
+; x = 9 , y = 10 
+
+; looping through a dictionary
+dict: #[name: "John", surname: "Doe", age: 34]
+loop dict [key value][
+    print [key "->" value]
+]
+; name -> John 
+; surname -> Doe 
+; age -> 34 
+                    
+; while loops
+i: new 0
+while [i<3][
+    print ["i =" i]
+    inc 'i
+]
+; i = 0
+; i = 1
+; i = 2
+ 
+;---------------------------------
+; STRINGS
+;---------------------------------
+
+; case
+a: "tHis Is a stRinG"
+print upper a               ; THIS IS A STRING
+print lower a               ; this is a string
+print capitalize a          ; tHis Is a stRinG
+
+; concatenation
+a: "Hello " ++ "World!"     ; a: "Hello World!"
+
+; strings as an array
+split "hello"               ; => [h e l l o]
+split.words "hello world"   ; => [hello world]
+
+print first "hello"         ; h
+print last "hello"          ; o
+
+; conversion
+to :string 123              ; => "123"
+to :integer "123"           ; => 123
+
+; joining strings together
+join ["hello" "world"]              ; => "helloworld"
+join.with:"-" ["hello" "world"]     ; => "hello-world"
+
+; string interpolation
+x: 2
+print ~"x = |x|"            ; x = 2
+
+; interpolation with `print`
+print ["x =" x]             ; x = 2
+                            ; (`print` works by calculating the given block
+                            ;  and joining the different values as strings
+                            ;  with a single space between them)
+
+; templates
+print render.template {
+    <||= switch x=2 [ ||>
+        Yes, x = 2
+    <||][||>
+        No, x is not 2
+    <||]||> 
+} ; Yes, x = 2
+
+; matching
+prefix? "hello" "he"        ; => true
+suffix? "hello" "he"        ; => false
+
+contains? "hello" "ll"      ; => true
+contains? "hello" "he"      ; => true
+contains? "hello" "x"       ; => false
+
+in? "ll" "hello"            ; => true 
+in? "x" "hello"             ; => false
+
+;---------------------------------
+; BLOCKS
+;---------------------------------
+
+; calculate a block
+arr: [1 1+1 1+1+1]
+@arr                        ; => [1 2 3]
+
+; execute a block
+sth: [print "Hello world"]  ; this is perfectly valid,
+                            ; could contain *anything*
+                            ; and will not be executed...
+
+do sth                      ; Hello world
+                            ; (...until we tell it to)
+
+; array indexing
+arr: ["zero" "one" "two" "three"]
+print first arr             ; zero
+print arr\0                 ; zero
+print last arr              ; three
+print arr\3                 ; three
+
+x: 2
+print get arr x             ; two
+print arr \ 2               ; two
+                            ; (using the `\` infix alias for get -
+                            ;  notice space between the operands! 
+                            ;  otherwise, it'll be parsed as a path)
+
+; setting an array element
+arr\0: "nada"
+set arr 2 "dos"
+print arr                   ; nada one dos three
+
+; adding elements to an array
+arr: new []
+'arr ++ "one"
+'arr ++ "two"
+print arr                   ; one two
+
+; remove elements from an array
+arr: new ["one" "two" "three" "four"]
+'arr -- "two"               ; arr: ["one" "three" "four"]
+remove 'arr .index 0        ; arr: ["three" "four"]
+
+; getting the size of an array
+arr: ["one" 2 "three" 4]
+print size arr              ; 4
+
+; getting a slice of an array
+print slice ["one" "two" "three" "four"] 0 1        ; one two
+
+; check if array contains a specific element
+print contains? arr "one"   ; true
+print contains? arr "five"  ; false
+
+; sorting array
+arr: [1 5 3 2 4]
+sort arr                    ; => [1 2 3 4 5]
+sort.descending arr         ; => [5 4 3 2 1]
+
+; mapping values
+map 1..10 [x][2*x]          ; => [2 4 6 8 10 12 14 16 18 20]
+map 1..10 'x -> 2*x         ; same as above
+map 1..10 => [2*&]          ; same as above
+map 1..10 => [2*]           ; same as above
+
+; selecting/filtering array values
+select 1..10 [x][odd? x]    ; => [1 3 5 7 9]
+select 1..10 => odd?        ; same as above
+
+filter 1..10 => odd?        ; => [2 4 6 8 10]
+                            ; (now, we leave out all odd numbers - 
+                            ;  while select keeps them)
+
+; misc operations
+arr: ["one" 2 "three" 4]
+reverse arr                 ; => [4 "three" 2 "one"]
+shuffle arr                 ; => [2 4 "three" "one"]
+unique [1 2 3 2 3 1]        ; => [1 2 3]
+permutate [1 2 3]           ; => [[1 2 3] [1 3 2] [3 1 2] [2 1 3] [2 3 1] [3 2 1]]
+take 1..10 3                ; => [1 2 3]
+repeat [1 2] 3              ; => [1 2 1 2 1 2]
+
+;---------------------------------
+; FUNCTIONS
+;---------------------------------
+
+; declaring a function
+f: function [x][ 2*x ]
+f: function [x]-> 2*x       ; same as above
+f: $[x]->2*x                ; same as above (only using the `$` alias 
+                            ;  for the `function`... function)
+
+; calling a function
+f 10                        ; => 20
+
+; returning a value
+g: function [x][
+    if x < 2 -> return 0
+
+    res: 0
+    loop 0..x 'z [
+        res: res + z
+    ]
+    return res
+]
+
+;---------------------------------
+; CUSTOM TYPES
+;---------------------------------
+
+; defining a custom type
+define :person [                            ; define a new custom type "Person"
+    name                                    ; with fields: name, surname, age
+    surname
+    age 
+][ 
+    ; with custom post-construction initializer
+    init: [
+        this\name: capitalize this\name
+    ]
+
+    ; custom print function
+    print: [
+        render "NAME: |this\name|, SURNAME: |this\surname|, AGE: |this\age|"
+    ]
+
+    ; custom comparison operator
+    compare: 'age
+]
+
+; create a method for our custom type
+sayHello: function [this][
+    ensure -> is? :person this
+
+    print ["Hello" this\name]
+]
+
+; create new objects of our custom type
+a: to :person ["John" "Doe" 34]                 ; let's create 2 "Person"s
+b: to :person ["jane" "Doe" 33]                 ; and another one
+
+; call pseudo-inner method
+sayHello a                                      ; Hello John                       
+sayHello b                                      ; Hello Jane
+
+; access object fields
+print ["The first person's name is:" a\name]    ; The first person's name is: John
+print ["The second person's name is:" b\name]   ; The second person's name is: Jane
+
+; changing object fields
+a\name: "Bob"                                   
+sayHello a                                      ; Hello Bob
+
+; verifying object type
+print type a                                    ; :person
+print is? :person a                             ; true
+
+; printing objects
+print a                                         ; NAME: John, SURNAME: Doe, AGE: 34
+
+; sorting user objects (using custom comparator)
+sort @[a b]                                     ; Jane..., John...
+sort.descending @[a b]                          ; John..., Jane...       
+```
+
+## Additional resources
+
+- [Official documentation](https://arturo-lang.io/documentation/) - Arturo official documentation & reference.
+- [Online playground](https://arturo-lang.io/playground/) - Online REPL for the Arturo programming language.
diff --git a/asciidoc.html.markdown b/asciidoc.html.markdown
index 51d0d7c9..557ed294 100644
--- a/asciidoc.html.markdown
+++ b/asciidoc.html.markdown
@@ -3,7 +3,7 @@ language: asciidoc
 contributors:
     - ["Ryan Mavilia", "http://unoriginality.rocks/"]
     - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
-filename: asciidoc.md
+filename: asciidoc.adoc
 ---
 
 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.
diff --git a/assemblyscript.html.markdown b/assemblyscript.html.markdown
new file mode 100644
index 00000000..4433b41e
--- /dev/null
+++ b/assemblyscript.html.markdown
@@ -0,0 +1,202 @@
+---
+language: Assemblyscript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+    - ["Steve Huguenin-Elie", "https://github.com/StEvUgnIn"]
+    - ["Sebastian Speitel", "https://github.com/SebastianSpeitel"]
+    - ["Max Graey", "https://github.com/MaxGraey"]
+filename: learnassemblyscript.ts
+---
+
+__AssemblyScript__ compiles a variant of __TypeScript__ (basically JavaScript with types) to __WebAssembly__ using __Binaryen__. It generates lean and mean WebAssembly modules while being just an `npm install` away.
+
+This article will focus only on AssemblyScript extra syntax, as opposed to [TypeScript](/docs/typescript) and [JavaScript](/docs/javascript).
+
+To test AssemblyScript's compiler, head to the
+[Playground](https://bit.ly/asplayground) where you will be able
+to type code, have auto completion and directly see the emitted WebAssembly.
+
+```ts
+// There are many basic types in AssemblyScript,
+let isDone: boolean = false;
+let name: string = "Anders";
+
+// but integer type come as signed (sized from 8 to 64 bits)
+let lines8: i8 = 42;
+let lines16: i16 = 42;
+let lines32: i32 = 42;
+let lines64: i64 = 42;
+
+// and unsigned (sized from 8 to 64 bits),
+let ulines8: u8 = 42;
+let ulines16: u16 = 42;
+let ulines32: u32 = 42;
+let ulines64: u64 = 42;
+
+// and float has two sizes possible (32/64).
+let rate32: f32 = 1.0
+let rate64: f64 = 1.0
+
+// But you can omit the type annotation if the variables are derived
+// from explicit literals
+let _isDone = false;
+let _lines = 42;
+let _name = "Anders";
+
+// Use const keyword for constants
+const numLivesForCat = 9;
+numLivesForCat = 1; // Error
+
+// For collections, there are typed arrays and generic arrays
+let list1: i8[] = [1, 2, 3];
+// Alternatively, using the generic array type
+let list2: Array<i8> = [1, 2, 3];
+
+// For enumerations:
+enum Color { Red, Green, Blue };
+let c: Color = Color.Green;
+
+// Functions imported from JavaScript need to be declared as external
+// @ts-ignore decorator
+@external("alert")
+declare function alert(message: string): void;
+
+// and you can also import JS functions in a namespace
+declare namespace window {
+  // @ts-ignore decorator
+  @external("window", "alert")
+  function alert(message: string): void;
+}
+
+// Lastly, "void" is used in the special case of a function returning nothing
+export function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!"); // calling JS function here
+}
+
+// Functions are first class citizens, support the lambda "fat arrow" syntax
+
+// The following are equivalent, the compiler does not offer any type
+// inference for functions yet, and same WebAssembly will be emitted.
+export function f1 (i: i32): i32 { return i * i; }
+// "Fat arrow" syntax
+let f2 = (i: i32): i32 => { return i * i; }
+// "Fat arrow" syntax, braceless means no return keyword needed
+let f3 = (i: i32): i32 => i * i;
+
+// Classes - members are public by default
+export class Point {
+  // Properties
+  x: f64;
+
+  // Constructor - the public/private keywords in this context will generate
+  // the boiler plate code for the property and the initialization in the
+  // constructor.
+  // In this example, "y" will be defined just like "x" is, but with less code
+  // Default values are also supported
+
+  constructor(x: f64, public y: f64 = 0) {
+    this.x = x;
+  }
+
+  // Functions
+  dist(): f64 { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+  // Static members
+  static origin: Point = new Point(0, 0);
+}
+
+// Classes can be explicitly marked as extending a parent class.
+// Any missing properties will then cause an error at compile-time.
+export class PointPerson extends Point {
+  constructor(x: f64, y: f64, public name: string) {
+    super(x, y);
+  }
+  move(): void {}
+}
+
+let p1 = new Point(10, 20);
+let p2 = new Point(25); //y will be 0
+
+// Inheritance
+export class Point3D extends Point {
+  constructor(x: f64, y: f64, public z: f64 = 0) {
+    super(x, y); // Explicit call to the super class constructor is mandatory
+  }
+
+  // Overwrite
+  dist(): f64 {
+    let d = super.dist();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// Namespaces, "." can be used as separator for sub namespaces
+export namespace Geometry {
+  class Square {
+    constructor(public sideLength: f64 = 0) {
+    }
+    area(): f64 {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+let s1 = new Geometry.Square(5);
+
+// Generics
+// AssemblyScript compiles generics to one concrete method or function per set 
+// of unique contextual type arguments, also known as [monomorphisation]. 
+// Implications are that a module only includes and exports concrete functions 
+// for sets of type arguments actually used and that concrete functions can be 
+// shortcutted with [static type checks] at compile time, which turned out to 
+// be quite useful.
+// Classes
+export class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+export class Pair<T> {
+  item1: T;
+  item2: T;
+}
+
+// And functions
+export function pairToTuple <T>(p: Pair<T>): Tuple<T, T> {
+  return new Tuple(p.item1, p.item2);
+};
+
+let tuple = pairToTuple<string>({ item1: "hello", item2: "world" });
+
+// Including references to a TypeScript-only definition file:
+/// <reference path="jquery.d.ts" />
+
+// Template Strings (strings that use backticks)
+// String Interpolation with Template Strings
+let name = 'Tyrone';
+let greeting = `Hi ${name}, how are you?`
+// Multiline Strings with Template Strings
+let multiline = `This is an example
+of a multiline string`;
+
+let numbers: Array<i8> = [0, 1, 2, 3, 4];
+let moreNumbers: Array<i8> = numbers;
+moreNumbers[5] = 5; // Error, elements are read-only
+moreNumbers.push(5); // Error, no push method (because it mutates array)
+moreNumbers.length = 3; // Error, length is read-only
+numbers = moreNumbers; // Error, mutating methods are missing
+
+// Type inference in Arrays
+let ints = [0, 1, 2, 3, 4]  // will infer as Array<i32>
+let floats: f32[] = [0, 1, 2, 3, 4]  // will infer as Array<f32>
+let doubles = [0.0, 1.0, 2, 3, 4]  // will infer as Array<f64>
+let bytes1 = [0 as u8, 1, 2, 3, 4]  // will infer as Array<u8>
+let bytes2 = [0, 1, 2, 3, 4]  as u8[] // will infer as Array<u8>
+let bytes3: u8[] = [0, 1, 2, 3, 4] // will infer as Array<u8>
+
+```
+
+## Further Reading
+ * [AssemblyScript Official website] (https://www.assemblyscript.org/)
+ * [AssemblyScript source documentation] https://github.com/AssemblyScript/website/tree/main/src)
+ * [Source Code on GitHub] (https://github.com/AssemblyScript/assemblyscript)
diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown
index a6acf54e..0739c02d 100644
--- a/asymptotic-notation.html.markdown
+++ b/asymptotic-notation.html.markdown
@@ -135,7 +135,7 @@ Let's look at the definition of Big-O.
 3 * n^2 <= c * n
 ```
 
-Is there some pair of constants c, n<sub>0</sub> that satisfies this for all n > <sub>0</sub>?
+Is there some pair of constants c, n<sub>0</sub> that satisfies this for all n > n<sub>0</sub>?
 No, there isn't. `f(n)` is NOT O(g(n)).
 
 ### Big-Omega
diff --git a/awk.html.markdown b/awk.html.markdown
index 3ff3f937..e1d4a0a3 100644
--- a/awk.html.markdown
+++ b/awk.html.markdown
@@ -48,7 +48,7 @@ BEGIN {
     # 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..
+    # Variables are global. Just set them or use them, no need to declare.
     count = 0;
 
     # Operators just like in C and friends
@@ -118,12 +118,12 @@ BEGIN {
     # Arrays
     arr[0] = "foo";
     arr[1] = "bar";
-    
+
     # You can also initialize an array with the built-in function split()
-    
+
     n = split("foo:bar:baz", arr, ":");
-   
-    # You also have associative arrays (actually, they're all associative arrays)
+
+    # You also have associative arrays (indeed, they're all associative arrays)
     assoc["foo"] = "bar";
     assoc["bar"] = "baz";
 
@@ -178,26 +178,26 @@ function arithmetic_functions(a, b, c,     d) {
     # Now, to demonstrate the arithmetic functions
 
     # Most AWK implementations have some standard trig functions
-    localvar = sin(a);
-    localvar = cos(a);
-    localvar = atan2(b, a); # arc tangent of b / a
+    d = sin(a);
+    d = cos(a);
+    d = atan2(b, a); # arc tangent of b / a
 
     # And logarithmic stuff
-    localvar = exp(a);
-    localvar = log(a);
+    d = exp(a);
+    d = log(a);
 
     # Square root
-    localvar = sqrt(a);
+    d = sqrt(a);
 
     # Truncate floating point to integer
-    localvar = int(5.34); # localvar => 5
+    d = int(5.34); # d => 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.
+    d = rand(); # Random number between 0 and 1.
 
     # Here's how to return a value
-    return localvar;
+    return d;
 }
 
 function string_functions(    localvar, arr) {
@@ -209,14 +209,15 @@ function string_functions(    localvar, arr) {
     # 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"
+    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
-    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+    n = split("foo-bar-baz", arr, "-");
+    # result: a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
 
     # Other useful stuff
     sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
@@ -238,9 +239,9 @@ function io_functions(    localvar) {
     # 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, but to get the same output, the string
-    # must match exactly, so use a variable:
-    
+    # it feel sort of like shell scripting, but to get the same output, the
+    # string must match exactly, so use a variable:
+
     outfile = "/tmp/foobar.txt";
 
     print "foobar" > outfile;
@@ -261,7 +262,7 @@ function io_functions(    localvar) {
 
     # Reads a line from a file and stores in localvar
     infile = "/tmp/foobar.txt";
-    getline localvar < infile; 
+    getline localvar < infile;
     close(infile);
 }
 
@@ -273,10 +274,10 @@ function io_functions(    localvar) {
 # 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. 
+# 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:
@@ -376,11 +377,15 @@ END {
 }
 
 ```
+
 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.
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
+  GNU Awk is found on most Linux systems.
 * [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
-* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical summary and list of "gotchas" (places where different implementations may behave in different or unexpected ways). 
+* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical
+  summary and list of "gotchas" (places where different implementations may
+  behave in different or unexpected ways).
 * [basic libraries for awk](https://github.com/dubiousjim/awkenough)
diff --git a/ballerina.html.markdown b/ballerina.html.markdown
new file mode 100644
index 00000000..7f055343
--- /dev/null
+++ b/ballerina.html.markdown
@@ -0,0 +1,432 @@
+---
+language: Ballerina
+contributors:
+    - ["Anjana Fernando", "https://github.com/lafernando"]
+filename: learn_ballerina.bal
+---
+
+[Ballerina](https://ballerina.io/) is a statically-typed programming language for making development for the cloud an enjoyable experience. 
+
+```java
+// Single-line comment
+
+// Import modules into the current source file 
+import ballerina/io;
+import ballerina/time;
+import ballerina/http;
+import ballerinax/java.jdbc;
+import ballerina/lang.'int as ints;
+import ballerinax/awslambda;
+// Module alias "af" used in code in place of the full module name
+import ballerinax/azure.functions as af;
+
+http:Client clientEP = new ("https://freegeoip.app/");
+jdbc:Client accountsDB = new ({url: "jdbc:mysql://localhost:3306/AccountsDB", 
+                               username: "test", password: "test"});
+
+// A service is a first-class concept in Ballerina, and is one of the 
+// entrypoints to a Ballerina program. 
+// The Ballerina platform also provides support for easy deployment to 
+// environments such as Kubernetes (https://ballerina.io/learn/deployment/kubernetes/).
+service geoservice on new http:Listener(8080) {
+
+    @http:ResourceConfig {
+        path: "/geoip/{ip}"
+    }
+    resource function geoip(http:Caller caller, http:Request request,
+                            string ip) returns @tainted error? {
+        http:Response resp = check clientEP->get("/json/" + <@untainted>ip);
+        check caller->respond(<@untainted> check resp.getTextPayload());
+    }
+
+}
+
+// Serverless Function-as-a-Service support with AWS Lambda.
+// The Ballerina compiler automatically generates the final deployment 
+// artifact to be deployed.
+@awslambda:Function
+public function echo(awslambda:Context ctx, json input) returns json {
+    return input;
+}
+
+@awslambda:Function
+public function notifyS3(awslambda:Context ctx, 
+                         awslambda:S3Event event) returns json {
+    return event.Records[0].s3.'object.key;
+}
+
+// Serverless Function-as-a-Service support with Azure Functions.
+// Similar to AWS Lambda, the compiler generates the deployment artifacts.
+@af:Function
+public function fromQueueToQueue(af:Context ctx, 
+        @af:QueueTrigger { queueName: "queue1" } string inMsg,
+        @af:QueueOutput { queueName: "queue2" } af:StringOutputBinding outMsg) {
+    outMsg.value = inMsg;
+}
+
+// A custom record type
+public type Person record {
+    string id;              // required field
+    string name;            
+    int age?;               // optional field
+    string country = "N/A"; // default value
+};
+
+@af:Function
+public function fromHttpTriggerCosmosDBInput(
+        @af:HTTPTrigger { route: "c1/{country}" } af:HTTPRequest httpReq, 
+        @af:CosmosDBInput { connectionStringSetting: "CosmosDBConnection", 
+        databaseName: "db1", collectionName: "c1", 
+        sqlQuery: "select * from c1 where c1.country = {country}" } 
+        Person[] dbReq)
+        returns @af:HTTPOutput string|error {
+    return dbReq.toString();
+}
+
+public function main() returns @tainted error? {
+    int a = 10;               // 64-bit signed integer
+    float b = 1.56;           // 64-bit IEEE 754-2008 binary floating point number
+    string c = "hello";       // a unicode string
+    boolean d = true;         // true, false
+    decimal e = 15.335;       // decimal floating point number
+
+    var f = 20;               // type inference with 'var' - 'f' is an int
+    
+    int[] intArray = [1, 2, 3, 4, 5, 6];
+    int x = intArray.shift(); // similar to a dequeue operation
+    x = intArray.pop();       // removes the last element
+    intArray.push(10);        // add to the end
+
+    // Tuples - similar to a fixed length array with a distinct type for each slot
+    [string, int] p1 = ["Jack", 1990]; 
+    [string, int] p2 = ["Tom", 1986];
+    io:println("Name: ", p1[0], " Birth Year: ", p1[1]);
+
+    string name1;
+    int birthYear1;
+    [name1, birthYear1] = p1;     // tuple destructuring
+
+    var [name2, birthYear2] = p2; // declare and assign values in the same statement
+
+    // If statements
+    int ix = 10;
+    if ix < 10 {
+        io:println("value is less than 10");
+    } else if ix == 10 {
+        io:println("value equals to 10");
+    } else {
+        io:println("value is greater than 10");
+    }
+
+    // Loops
+    int count = 10;
+    int i = 0;
+    while i < 10 {
+        io:println(i);
+    }
+    // Loop from 0 to count (inclusive)
+    foreach var j in 0...count {
+        io:println(j);
+    }
+    // Loop from 0 to count (non-inclusive)
+    foreach var j in 0..<count {
+        io:println(j);
+    }
+    // Loop a list
+    foreach var j in intArray {
+        io:println(j);
+    }
+
+    json j1 = { "name" : name1, "birthYear" : birthYear1, "zipcode" : 90210 };
+    io:println(j1.name, " - ", j1.zipcode);
+    // New fields are added to a JSON value through "mergeJson"
+    var j2 = j1.mergeJson({ "id" : "90400593053"});
+
+    // XML namespace declaration
+    xmlns "http://example.com/ns1" as ns1;
+    xmlns "http://example.com/default";
+    
+    // XML variable from a literal value
+    xml x1 = xml `<ns1:entry><name>{{name1}}</name><birthYear>{{birthYear1}}</birthYear></ns1:entry>`;
+    io:println(x1);
+    // Access specific elements in the XML value
+    io:println(x1/<name>);
+    // List all child items in the XML value
+    io:println(x1/*);
+
+    // Function invocations
+    x = add(1, 2);
+    io:println(multiply(2, 4));
+    // Invocation providing value for the defaultable parameter
+    io:println(multiply(3, 4, true));
+    // Invocation with values to a rest parameter (multi-valued)
+    io:println(addAll(1, 2, 3));
+    io:println(addAll(1, 2, 3, 4, 5));
+
+    // Function pointers
+    (function (int, int) returns int) op1 = getOperation("add");
+    (function (int, int) returns int) op2 = getOperation("mod");
+    io:println(op1(5, 10));
+    io:println(op2(13, 10));
+
+    // Closures
+    (function (int x) returns int) add5 = getAdder(5);
+    (function (int x) returns int) add10 = getAdder(10);
+    io:println(add5(10));
+    io:println(add10(10));
+
+    int[] numbers = [1, 2, 3, 4, 5, 6, 7, 8];
+    // Functional iteration
+    int[] evenNumbers = numbers.filter(function (int x) returns boolean { return x % 2 == 0; });
+
+    // Union types - "input" is of type either string or byte[]
+    string|byte[] uval = "XXX";
+
+    // A type test expression ("uval is string") can be used to check the 
+    // runtime type of a variable.
+    if uval is string {
+        // In the current scope, "uval" is a string value
+        string data = "data:" + uval;
+    } else {
+        // Since the expression in the "if" statement ruled out that it's not a string,
+        // the only type left is "byte[]"; so in the current scope, "uval" will always
+        // be a "byte[]".
+        int inputLength = uval.length();
+    }
+
+    // Error handling
+    string input = io:readln("Enter number: ");
+    int|error result = ints:fromString(input);
+    if result is int {
+        io:println("Number: ", result);
+    } else {
+        io:println("Invalid number: ", input);
+    }
+
+    // A check expression can be used to directly return the error from
+    // the current function if its subexpression evaluated to an error
+    // value in the runtime. 
+    int number = check ints:fromString(input); 
+
+    // Concurrent execution using workers in a function
+    doWorkers();
+
+    // Asynchronous execution with futures
+    future<int> f10 = start fib(10);
+    var webresult = clientEP->get("/");
+    int fresult = wait f10;
+    if webresult is http:Response {
+        io:println(webresult.getTextPayload());
+        io:println(fresult);
+    }
+
+    // Mapping types
+    map<int> ageMap = {};
+    ageMap["Peter"] = 25;
+    ageMap["John"] = 30;
+
+    int? agePeter = ageMap["Peter"]; // int? is the union type int|() - int or nill
+    if agePeter is int {
+        io:println("Peter's age is ", agePeter);
+    } else {
+        io:println("Peter's age is not found");
+    }
+
+    Person person1 = { id: "p1", name : "Anne", age: 28, country: "Sri Lanka" };
+    Scores score1 = { physics : 80, mathematics: 95 };
+    score1["chemistry"] = 75;
+    io:println(score1["chemistry"]);
+
+    Student student1 = { id: "s1", name: "Jack", age: 25, country: "Japan" };
+    student1.college = "Stanford";
+    string? jacksCollege = student1?.college; // optional field access
+    if jacksCollege is string {
+        io:println("Jack's college is ", jacksCollege);
+    }
+
+    // Due to the structural type system, "student1" can be assigned to "person2",
+    // since the student1's structure is compatible with person2's,
+    // where we can say, a "Student" is a "Person" as well. 
+    Person person2 = student1;
+
+    map<int> grades = {"Jack": 95, "Anne": 90, "John": 80, "Bill": 55};
+    Person px1 = {id: "px1", name: "Jack", age: 30, country: "Canada"};
+    Person px2 = {id: "px2", name: "John", age: 25};
+    Person px3 = {id: "px3", name: "Anne", age: 17, country: "UK"};
+    Person px4 = {id: "px4", name: "Bill", age: 15, country: "USA"};
+    Person[] persons = [];
+    persons.push(px1);
+    persons.push(px2);
+    persons.push(px3);
+    persons.push(px4);
+
+    // Query expressions used to execute complex queries for list data
+    Result[] results = from var person in persons
+                       let int lgrade = (grades[person.name] ?: 0)
+                       where lgrade > 75 
+                           let string targetCollege = "Stanford"
+                           select { 
+                               name: person.name, 
+                               college: targetCollege, 
+                               grade: lgrade 
+                           };
+
+    // Compile-time taint checking for handling untrusted data
+    string s1 = "abc";
+    mySecureFunction(s1);
+    // Explicitely make "s2" a tainted value. External input to a Ballerina
+    // program such as command-line arguments and network input are by-default
+    // marked as tainted data.
+    string s2 = <@tainted> s1;
+    // "s2x" is now a tainted value, since its value is derived using a 
+    // tainted value (s1).
+    string s2x = s2 + "abc";
+    // The following line uncommented will result in a compilation error,
+    // since we are passing a tainted value (s2x) to a function which 
+    // exepects an untainted value.
+    // mySecureFunction(s2x);
+
+    // Instantiating objects
+    Employee emp1 = new("E0001", "Jack Smith", "Sales", 2009);
+    io:println("The company service duration of ", emp1.name, 
+               " is ", emp1.serviceDuration());
+
+    // Supported operations can be executed in a transaction by enclosing the actions
+    // in a "transaction" block. 
+    transaction {
+        // Executes the below database operations in a single local transactions
+        var r1 = accountsDB->update("UPDATE Employee SET balance = balance + ? WHERE id = ?", 5500.0, "ID001");
+        var r2 = accountsDB->update("UPDATE Employee SET balance = balance + ? WHERE id = ?", 5500.0, "ID001");
+    }
+}
+
+// An object is a behavioural type, which encapsulates both data and functionality.
+type Employee object {
+    
+    // Private fields are only visible within the object and its methods
+    private string empId;
+    // Public fields can be accessed by anyone
+    public string name;
+    public string department;
+    // The default qualifier is a "protected" field, 
+    // which are accessible only within the module.
+    int yearJoined;           
+    
+    // The object initialization function; automatically called when an object is instantiated.
+    public function __init(string empId, string name, string department, int yearJoined) {
+        self.empId = empId;
+        self.name = name;
+        self.department = department;
+        self.yearJoined = yearJoined;        
+    }
+
+    // An object method
+    public function serviceDuration() returns int {
+        time:Time ct = time:currentTime();
+        return time:getYear(ct) - self.yearJoined;
+    }
+
+};
+
+// Student is a subtype of Person
+type Student record {
+    string id;
+    string name;
+    int age;
+    string college?;
+    string country;
+};
+
+type Scores record {
+    int physics;
+    int mathematics;
+};
+
+type Result record {
+    string name;
+    string college;
+    int grade;
+};
+
+public function getOperation(string op) returns (function (int, int) returns int) {
+    if op == "add" {
+        return add;
+    } else if op == "mod" {
+        return function (int a, int b) returns int { // anonymous function
+            return a % b;
+        };
+    } else {
+        return (x, y) => 0; // single expression anonymous no-op function 
+    }
+}
+
+// Two required parameters
+public function add(int a, int b) returns int {
+    return a + b;
+}
+
+// 'log' is a defaultable parameter
+public function multiply(int a, int b, boolean log = false) returns int {
+    if log {
+        io:println("Multiplying ", a, " with ", b);
+    }
+    return a * b;
+}
+
+// 'numbers' is a rest parameter - it can have multiple values, 
+// similar to an array.
+public function addAll(int... numbers) returns int {
+    int result = 0;
+    foreach int number in numbers {
+        result += number;
+    }
+    return result;
+}
+
+public function getAdder(int n) returns (function (int x) returns int) {
+    return function (int x) returns int { // returns closure
+        return x + n;
+    };
+}
+
+function fib(int n) returns int {
+    if n <= 2 {
+        return 1;
+    } else {
+        return fib(n - 1) + fib(n - 2);
+    }
+}
+
+// The code in worker blocks "w1" and "w2" are executed concurrency 
+// when this function is invoked. The "wait" expressions waits for
+// the given workers to finish to retrieve their results.
+public function doWorkers() {
+    worker w1 returns int {
+        int j = 10;
+        j -> w2;
+        int b;
+        b = <- w2;
+        return b * b;
+    }
+    worker w2 returns int {
+        int a;
+        a = <- w1;
+        a * 2 -> w1;
+        return a + 2;
+    }
+    record {int w1; int w2;} x = wait {w1, w2};
+    io:println(x);
+}
+
+// A function which takes in only an untainted string value.
+public function mySecureFunction(@untainted string input) {
+    io:println(input);
+}
+```
+
+### Further Reading
+
+* [Ballerina by Example](https://ballerina.io/learn/by-example/)
+* [User Guide](https://ballerina.io/learn/installing-ballerina/)
+* [API Documentation](https://ballerina.io/learn/api-docs/ballerina/)
+* [Language Specification](https://ballerina.io/spec/)
diff --git a/bash.html.markdown b/bash.html.markdown
index 11ce4e74..e0e4f88a 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -17,6 +17,8 @@ contributors:
     - ["John Detter", "https://github.com/jdetter"]
     - ["Harry Mumford-Turner", "https://github.com/harrymt"]
     - ["Martin Nicholson", "https://github.com/mn113"]
+    - ["Mark Grimwood", "https://github.com/MarkGrimwood"]
+    - ["Emily Grace Seville", "https://github.com/EmilySeville7cfg"]
 filename: LearnBash.sh
 translators:
     - ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
@@ -36,104 +38,107 @@ or executed directly in the shell.
 # As you already figured, comments start with #. Shebang is also a comment.
 
 # Simple hello world example:
-echo Hello world! # => Hello world!
+echo "Hello world!" # => Hello world!
 
 # Each command starts on a new line, or after a semicolon:
-echo 'This is the first line'; echo 'This is the second line'
-# => This is the first line
-# => This is the second line
+echo "This is the first command"; echo "This is the second command"
+# => This is the first command
+# => This is the second command
 
 # Declaring a variable looks like this:
-Variable="Some string"
+variable="Some string"
 
 # But not like this:
-Variable = "Some string" # => returns error "Variable: command not found"
-# Bash will decide that Variable is a command it must execute and give an error
+variable = "Some string" # => returns error "variable: command not found"
+# Bash will decide that `variable` is a command it must execute and give an error
 # because it can't be found.
 
 # Nor like this:
-Variable= 'Some string' # => returns error: "Some string: command not found"
-# Bash will decide that 'Some string' is a command it must execute and give an
-# error because it can't be found. (In this case the 'Variable=' part is seen
-# as a variable assignment valid only for the scope of the 'Some string'
-# command.)
+variable= "Some string" # => returns error: "Some string: command not found"
+# Bash will decide that "Some string" is a command it must execute and give an
+# error because it can't be found. In this case the "variable=" part is seen
+# as a variable assignment valid only for the scope of the "Some string"
+# command.
 
 # Using the variable:
-echo $Variable # => Some string
-echo "$Variable" # => Some string
-echo '$Variable' # => $Variable
-# When you use the variable itself — assign it, export it, or else — you write
+echo "$variable" # => Some string
+echo '$variable' # => $variable
+# When you use a variable itself — assign it, export it, or else — you write
 # 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} # => Some string
-# 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 can be modified
-# Below are other modifications that add onto this expansion
-
-# String substitution in variables
-echo ${Variable/Some/A} # => A string
-# This will substitute the first occurrence of "Some" with "A"
-
-# Substring from a variable
-Length=7
-echo ${Variable:0:Length} # => Some st
+# You can write variable without surrounding quotes but it's not recommended.
+
+# Parameter expansion ${...}:
+echo "${variable}" # => Some string
+# This is a simple usage of parameter expansion such as two examples above.
+# Parameter expansion gets a value from a variable.
+# It "expands" or prints the value.
+# During the expansion time the value or parameter can be modified.
+# Below are other modifications that add onto this expansion.
+
+# String substitution in variables:
+echo "${variable/Some/A}" # => A string
+# This will substitute the first occurrence of "Some" with "A".
+
+# Substring from a variable:
+length=7
+echo "${variable:0:length}" # => Some st
 # This will return only the first 7 characters of the value
-echo ${Variable: -5} # => tring
-# This will return the last 5 characters (note the space before -5)
+echo "${variable: -5}" # => tring
+# This will return the last 5 characters (note the space before -5).
+# The space before minus is mandatory here.
 
-# String length
-echo ${#Variable} # => 11
+# String length:
+echo "${#variable}" # => 11
 
-# Indirect expansion
-OtherVariable="Variable"
-echo ${!OtherVariable} # => Some String
-# This will expand the value of OtherVariable
+# Indirect expansion:
+other_variable="variable"
+echo ${!other_variable} # => Some string
+# This will expand the value of `other_variable`.
 
-# Default value for variable
-echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
+# The default value for variable:
+echo "${foo:-"DefaultValueIfFooIsMissingOrEmpty"}"
 # => DefaultValueIfFooIsMissingOrEmpty
-# This works for null (Foo=) and empty string (Foo=""); zero (Foo=0) returns 0.
+# 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.
 
-# Declare an array with 6 elements
-array0=(one two three four five six)
-# Print first element
-echo $array0 # => "one"
-# Print first element
-echo ${array0[0]} # => "one"
-# Print all elements
-echo ${array0[@]} # => "one two three four five six"
-# Print number of elements
-echo ${#array0[@]} # => "6"
-# Print number of characters in third element
-echo ${#array0[2]} # => "5"
-# Print 2 elements starting from forth
-echo ${array0[@]:3:2} # => "four five"
-# Print all elements. Each of them on new line.
-for i in "${array0[@]}"; do
-    echo "$i"
+# Declare an array with 6 elements:
+array=(one two three four five six)
+# Print the first element:
+echo "${array[0]}" # => "one"
+# Print all elements:
+echo "${array[@]}" # => "one two three four five six"
+# Print the number of elements:
+echo "${#array[@]}" # => "6"
+# Print the number of characters in third element
+echo "${#array[2]}" # => "5"
+# Print 2 elements starting from fourth:
+echo "${array[@]:3:2}" # => "four five"
+# Print all elements each of them on new line.
+for item in "${array[@]}"; do
+    echo "$item"
 done
 
-# Brace Expansion { }
-# Used to generate arbitrary strings
-echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
-echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
-# This will output the range from the start value to the end value
-
 # Built-in variables:
-# There are some useful built-in variables, like
+# There are some useful built-in variables, like:
 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..."
 
+# Brace Expansion {...}
+# used to generate arbitrary strings:
+echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
+echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
+# This will output the range from the start value to the end value.
+# Note that you can't use variables here:
+from=1
+to=10
+echo {$from..$to} # => {$from..$to}
+
 # Now that we know how to echo and use variables,
-# let's learn some of the other basics of bash!
+# 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".
@@ -143,33 +148,46 @@ 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` clears your screen:
 clear
-# Ctrl-L also works for clearing output
+# 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
-echo Hello, $Name!
+read name
+# Note that we didn't need to declare a new variable.
+echo "Hello, $name!"
 
-# We have the usual if structure:
-# use `man test` for more info about conditionals
-if [ $Name != $USER ]
-then
+# We have the usual if structure.
+# Condition is true if the value of $name is not equal to the current user's login username:
+if [[ "$name" != "$USER" ]]; then
     echo "Your name isn't your username"
 else
     echo "Your name is your username"
 fi
-# True if the value of $Name is not equal to the current user's login username
 
-# NOTE: if $Name is empty, bash sees the above condition as:
-if [ != $USER ]
-# which is invalid syntax
-# so the "safe" way to use potentially empty variables in bash is:
-if [ "$Name" != $USER ] ...
-# which, when $Name is empty, is seen by bash as:
-if [ "" != $USER ] ...
-# which works as expected
+# To use && and || with if statements, you need multiple pairs of square brackets:
+read age
+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
+# There are other comparison operators for numbers listed below:
+# -ne - not equal
+# -lt - less than
+# -gt - greater than
+# -le - less than or equal to
+# -ge - greater than or equal to
+
+# There is also the `=~` operator, which tests a string against the Regex pattern:
+email=me@example.com
+if [[ "$email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
+then
+    echo "Valid email!"
+fi
 
 # There is also conditional execution
 echo "Always executed" || echo "Only executed if first command fails"
@@ -178,27 +196,19 @@ echo "Always executed" && echo "Only executed if first command does NOT fail"
 # => Always executed
 # => Only executed if first command does NOT fail
 
-
-# To use && and || with if statements, you need multiple pairs of square brackets:
-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
-
-# There is also the `=~` operator, which tests a string against a Regex pattern:
-Email=me@example.com
-if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
-then
-    echo "Valid email!"
-fi
-# Note that =~ only works within double [[ ]] square brackets,
-# which are subtly different from single [ ].
-# See https://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs for more on this.
+# A single ampersand & after a command runs it in the background. A background command's
+# output is printed to the terminal, but it cannot read from the input.
+sleep 30 &
+# List background jobs
+jobs # => [1]+  Running                 sleep 30 &
+# Bring the background job to the foreground
+fg
+# Ctrl-C to kill the process, or Ctrl-Z to pause it
+# Resume a background process after it has been paused with Ctrl-Z
+bg
+# Kill job number 2
+kill %2
+# %1, %2, etc. can be used for fg and bg as well
 
 # Redefine command `ping` as alias to send only 5 packets
 alias ping='ping -c 5'
@@ -220,7 +230,8 @@ 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.
+# Results (stdout) of the previous command can be passed as input (stdin) to the next command
+# using a pipe |. Commands chained in this way are called a "pipeline", and are run concurrently.
 # The `grep` command filters the input with provided patterns.
 # That's how we can list .txt files in the current directory:
 ls -l | grep "\.txt"
@@ -260,7 +271,7 @@ cd      # also goes 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??
+cd ~/Documents/..    # now in home directory (if ~/Documents exists)
 cd -    # change to last directory
 # => /home/username/Documents
 
@@ -275,9 +286,13 @@ mkdir -p myNewDir/with/intermediate/directories
 # if the intermediate directories didn't already exist, running the above
 # command without the `-p` flag would return an error
 
-# You can redirect command input and output (stdin, stdout, and stderr).
+# You can redirect command input and output (stdin, stdout, and stderr)
+# using "redirection operators". Unlike a pipe, which passes output to a command,
+# a redirection operator has a command's input come from a file or stream, or
+# sends its output to a file or stream.
+
 # Read from stdin until ^EOF$ and overwrite hello.py with the lines
-# between "EOF":
+# between "EOF" (which are called a "here document"):
 cat > hello.py << EOF
 #!/usr/bin/env python
 from __future__ import print_function
@@ -299,6 +314,8 @@ python hello.py 2> "error.err" # redirect error output to error.err
 
 python hello.py > "output-and-error.log" 2>&1
 # redirect both output and errors to output-and-error.log
+# &1 means file descriptor 1 (stdout), so 2>&1 redirects stderr (2) to the current
+# destination of stdout (1), which has been redirected to output-and-error.log.
 
 python hello.py > /dev/null 2>&1
 # redirect all output and errors to the black hole, /dev/null, i.e., no output
@@ -402,13 +419,17 @@ function foo ()
     echo "Arguments work just like script arguments: $@"
     echo "And: $1 $2..."
     echo "This is a function"
-    return 0
+    returnValue=0    # Variable values can be returned
+    return $returnValue
 }
 # Call the function `foo` with two arguments, arg1 and arg2:
 foo arg1 arg2
 # => Arguments work just like script arguments: arg1 arg2
 # => And: arg1 arg2...
 # => This is a function
+# Return values can be obtained with $?
+resultValue=$?
+# More than 9 arguments are also possible by using braces, e.g. ${10}, ${11}, ...
 
 # or simply
 bar ()
@@ -429,7 +450,7 @@ tail -n 10 file.txt
 # prints first 10 lines of file.txt
 head -n 10 file.txt
 
-# sort file.txt's lines
+# print file.txt's lines in sorted order
 sort file.txt
 
 # report or omit repeated lines, with -d it reports them
diff --git a/bf.html.markdown b/bf.html.markdown
index 1e415a4d..adc58f02 100644
--- a/bf.html.markdown
+++ b/bf.html.markdown
@@ -4,12 +4,13 @@ filename: bf.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
+    - ["rilysh", "https://github.com/rilysh"]
 ---
 
 Brainfuck (not capitalized except at the start of a sentence) is an extremely
 minimal Turing-complete programming language with just 8 commands.
 
-You can try brainfuck on your browser with [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+You can try brainfuck on your browser with [brainfuck-online](https://copy.sh/brainfuck/).
 
 ```bf
 Any character not "><+-.,[]" (excluding quotation marks) is ignored.
@@ -80,3 +81,8 @@ And that's brainfuck. Not that hard, eh? For fun, you can write your own
 brainfuck programs, or you can write a brainfuck interpreter in another
 language. The interpreter is fairly simple to implement, but if you're a
 masochist, try writing a brainfuck interpreter… in brainfuck.
+
+## Further Reading
+ * [esolang-wiki](https://esolangs.org/wiki/Brainfuck)
+ * [learn brainfuck](http://cydathria.com/bf/brainfuck.html)
+ * [other resources](http://www.muppetlabs.com/~breadbox/bf/)
diff --git a/c++.html.markdown b/c++.html.markdown
index 6e94e03e..499eb669 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp.cpp
 contributors:
     - ["Steven Basart", "https://github.com/xksteven"]
@@ -158,6 +158,10 @@ namespace Second {
     {
         printf("This is Second::foo\n");
     }
+    void bar()
+    {
+    	printf("This is Second::bar\n");
+    }
 }
 
 void foo()
@@ -168,10 +172,12 @@ void foo()
 int main()
 {
     // Includes all symbols from namespace Second into the current scope. Note
-    // that simply foo() no longer works, since it is now ambiguous whether
-    // we're calling the foo in namespace Second or the top level.
+    // that while bar() works, simply using foo() no longer works, since it is
+    // now ambiguous whether we're calling the foo in namespace Second or the
+    // top level.
     using namespace Second;
 
+    bar(); // prints "This is Second::bar"
     Second::foo(); // prints "This is Second::foo"
     First::Nested::foo(); // prints "This is First::Nested::foo"
     ::foo(); // prints "This is global foo"
@@ -946,7 +952,7 @@ mymap.insert(pair<char,int>('Z',26));
 // To iterate
 map<char,int>::iterator it;
 for (it=mymap.begin(); it!=mymap.end(); ++it)
-    std::cout << it->first << "->" << it->second << std::cout;
+    std::cout << it->first << "->" << it->second << std::endl;
 // Output:
 // A->1
 // Z->26
@@ -1196,5 +1202,6 @@ compl 4    // Performs a bitwise not
 Further Reading:
 
 * An up-to-date language reference can be found at [CPP Reference](http://cppreference.com/w/cpp).
-* Additional resources may be found at [CPlusPlus](http://cplusplus.com).
+* A tutorial  for beginners or experts, covering many modern features and good practices: [LearnCpp.com](https://www.learncpp.com/)
 * A tutorial covering basics of language and setting up coding environment is available at [TheChernoProject - C++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
+* Additional resources may be found at [CPlusPlus](http://cplusplus.com).
diff --git a/c.html.markdown b/c.html.markdown
index ff396d21..ef341abf 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -1,16 +1,16 @@
 ---
-language: c
+language: C
 filename: learnc.c
 contributors:
-    - ["Adam Bard", "http://adambard.com/"]
-    - ["�rpád Goretity", "http://twitter.com/H2CO3_iOS"]
-    - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
-    - ["Marco Scannadinari", "https://marcoms.github.io"]
-    - ["Zachary Ferguson", "https://github.io/zfergus2"]
-    - ["himanshu", "https://github.com/himanshu81494"]
-    - ["Joshua Li", "https://github.com/JoshuaRLi"]
-    - ["Dragos B. Chirila", "https://github.com/dchirila"]
-    - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
+  - ["Adam Bard", "http://adambard.com/"]
+  - ["�rpád Goretity", "http://twitter.com/H2CO3_iOS"]
+  - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
+  - ["Marco Scannadinari", "https://marcoms.github.io"]
+  - ["Zachary Ferguson", "https://github.io/zfergus2"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Joshua Li", "https://github.com/JoshuaRLi"]
+  - ["Dragos B. Chirila", "https://github.com/dchirila"]
+  - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
 ---
 
 Ah, C. Still **the** language of modern high-performance computing.
@@ -46,31 +46,47 @@ Multi-line comments don't nest /* Be careful */  // comment ends on this line...
 
 // Enumeration constants are also ways to declare constants.
 // All statements must end with a semicolon
-enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
+enum days {SUN, MON, TUE, WED, THU, FRI, SAT};
+// SUN gets 0, MON gets 1, TUE gets 2, etc.
+
+// Enumeration values can also be specified
+enum days {SUN = 1, MON, TUE, WED = 99, THU, FRI, SAT};
 // MON gets 2 automatically, TUE gets 3, etc.
+// WED get 99, THU gets 100, FRI gets 101, etc.
 
 // Import headers with #include
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
-// (File names between <angle brackets> are headers from the C standard library.)
-// For your own headers, use double quotes instead of angle brackets:
-//#include "my_header.h"
+// File names between <angle brackets> tell the compiler to look in your system
+// libraries for the headers.
+// For your own headers, use double quotes instead of angle brackets, and
+// provide the path:
+#include "my_header.h" 		// local file
+#include "../my_lib/my_lib_header.h" //relative path
 
 // Declare function signatures in advance in a .h file, or at the top of
 // your .c file.
 void function_1();
 int function_2(void);
 
-// Must declare a 'function prototype' before main() when functions occur after
-// your main() function.
+// At a minimum, you must declare a 'function prototype' before its use in any function.
+// Normally, prototypes are placed at the top of a file before any function definition.
 int add_two_ints(int x1, int x2); // function prototype
 // although `int add_two_ints(int, int);` is also valid (no need to name the args),
 // it is recommended to name arguments in the prototype as well for easier inspection
 
-// Your program's entry point is a function called
-// main with an integer return type.
+// Function prototypes are not necessary if the function definition comes before
+// any other function that calls that function. However, it's standard practice to
+// always add the function prototype to a header file (*.h) and then #include that
+// file at the top. This prevents any issues where a function might be called
+// before the compiler knows of its existence, while also giving the developer a
+// clean header file to share with the rest of the project.
+
+// Your program's entry point is a function called "main". The return type can
+// be anything, however most operating systems expect a return type of `int` for
+// error code processing.
 int main(void) {
   // your program
 }
@@ -85,6 +101,12 @@ int main (int argc, char** argv)
   // %d is an integer, \n is a newline
   printf("%d\n", 0); // => Prints 0
 
+  // take input using scanf
+  // '&' is used to define the location
+  // where we want to store the input value
+  int input;
+  scanf("%d", &input);
+
   ///////////////////////////////////////
   // Types
   ///////////////////////////////////////
@@ -96,13 +118,14 @@ int main (int argc, char** argv)
   // For the sake of the tutorial, variables are declared dynamically under
   // C99-compliant standards.
 
-  // ints are usually 4 bytes
+  // ints are usually 4 bytes (use the `sizeof` operator to check)
   int x_int = 0;
 
-  // shorts are usually 2 bytes
+  // shorts are usually 2 bytes (use the `sizeof` operator to check)
   short x_short = 0;
 
-  // chars are guaranteed to be 1 byte
+  // chars are defined as the smallest addressable unit for a processor.
+  // This is usually 1 byte, but for some systems it can be more (ex. for TMS320 from TI it's 2 bytes).
   char x_char = 0;
   char y_char = 'y'; // Char literals are quoted with ''
 
@@ -145,19 +168,25 @@ 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};
+  // You can initialize an array of twenty ints that all equal 0 thusly:
+  int my_array[20] = {0};
   // where the "{0}" part is called an "array initializer".
-  // NOTE that you get away without explicitly declaring the size of the array,
-  // IF you initialize the array on the same line. So, the following declaration
-  // is equivalent:
-  char my_array[] = {0};
-  // BUT, then you have to evaluate the size of the array at run-time, like this:
+  // All elements (if any) past the ones in the initializer are initialized to 0:
+  int my_array[5] = {1, 2};
+  // So my_array now has five elements, all but the first two of which are 0:
+  // [1, 2, 0, 0, 0]
+  // NOTE that you get away without explicitly declaring the size
+  // of the array IF you initialize the array on the same line:
+  int my_array[] = {0};
+  // NOTE that, when not declaring the size, the size of the array is the number
+  // of elements in the initializer. With "{0}", my_array is now of size one: [0]
+  // To evaluate the size of the array at run-time, divide its byte size by the
+  // byte size of its element type:
   size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]);
-  // WARNING If you adopt this approach, you should evaluate the size *before*
-  // you begin passing the array to function (see later discussion), because
-  // arrays get "downgraded" to raw pointers when they are passed to functions
-  // (so the statement above will produce the wrong result inside the function).
+  // WARNING You should evaluate the size *before* you begin passing the array
+  // to functions (see later discussion) because arrays get "downgraded" to
+  // raw pointers when they are passed to functions (so the statement above
+  // will produce the wrong result inside the function).
 
   // Indexing an array is like other languages -- or,
   // rather, other languages are like C
@@ -224,14 +253,23 @@ int main (int argc, char** argv)
   (float)i1 / i2; // => 0.5f
   i1 / (double)i2; // => 0.5 // Same with double
   f1 / f2; // => 0.5, plus or minus epsilon
-  
-  // Floating-point numbers and calculations are not exact
-  // for instance it is not giving mathematically correct results
+
+  // Floating-point numbers are defined by IEEE 754, thus cannot store perfectly
+  // exact values. For instance, the following does not produce expected results
+  // because 0.1 might actually be 0.099999999999 inside the computer, and 0.3
+  // might be stored as 0.300000000001.
   (0.1 + 0.1 + 0.1) != 0.3; // => 1 (true)
-  // and it is NOT associative
+  // and it is NOT associative due to reasons mentioned above.
   1 + (1e123 - 1e123) != (1 + 1e123) - 1e123; // => 1 (true)
   // this notation is scientific notations for numbers: 1e123 = 1*10^123
 
+  // It is important to note that most all systems have used IEEE 754 to
+  // represent floating points. Even python, used for scientific computing,
+  // eventually calls C which uses IEEE 754. It is mentioned this way not to
+  // indicate that this is a poor implementation, but instead as a warning
+  // that when doing floating point comparisons, a little bit of error (epsilon)
+  // needs to be considered.
+
   // Modulo is there as well, but be careful if arguments are negative
   11 % 3;    // => 2 as 11 = 2 + 3*x (x=3)
   (-11) % 3; // => -2, as one would expect
@@ -239,7 +277,7 @@ int main (int argc, char** argv)
 
   // Comparison operators are probably familiar, but
   // there is no Boolean type in C. We use ints instead.
-  // (Or _Bool or bool in C99.)
+  // (C99 introduced the _Bool type provided in stdbool.h)
   // 0 is false, anything else is true. (The comparison
   // operators always yield 0 or 1.)
   3 == 2; // => 0 (false)
@@ -379,7 +417,7 @@ int main (int argc, char** argv)
   */
   /*
     it is generally considered bad practice to do so, except if
-    you really know what you are doing. See 
+    you really know what you are doing. See
     https://en.wikipedia.org/wiki/Spaghetti_code#Meaning
   */
 
@@ -391,13 +429,16 @@ int main (int argc, char** argv)
   // if you want (with some constraints).
 
   int x_hex = 0x01; // You can assign vars with hex literals
+                    // binary is not in the standard, but allowed by some
+                    // compilers (x_bin = 0b0010010110)
 
   // Casting between types will attempt to preserve their numeric values
   printf("%d\n", x_hex); // => Prints 1
   printf("%d\n", (short) x_hex); // => Prints 1
   printf("%d\n", (char) x_hex); // => Prints 1
 
-  // Types will overflow without warning
+  // If you assign a value greater than a types max val, it will rollover
+  // without warning.
   printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 if char is 8 bits long)
 
   // For determining the max value of a `char`, a `signed char` and an `unsigned char`,
@@ -543,7 +584,8 @@ the function are copies of the original arguments (except arrays). Anything you
 do to the arguments in the function do not change the value of the original
 argument where the function was called.
 
-Use pointers if you need to edit the original argument values.
+Use pointers if you need to edit the original argument values (arrays are always
+passed in as pointers).
 
 Example: in-place string reversal
 */
@@ -554,9 +596,11 @@ void str_reverse(char *str_in)
   char tmp;
   size_t ii = 0;
   size_t len = strlen(str_in); // `strlen()` is part of the c standard library
-                               // NOTE: length returned by `strlen` DOESN'T include the
-                               //       terminating NULL byte ('\0')
-  for (ii = 0; ii < len / 2; ii++) { // in C99 you can directly declare type of `ii` here
+                               // NOTE: length returned by `strlen` DOESN'T
+                               //       include the terminating NULL byte ('\0')
+  // in C99 and newer versions, you can directly declare loop control variables
+  // in the loop's parentheses. e.g., `for (size_t ii = 0; ...`
+  for (ii = 0; ii < len / 2; ii++) {
     tmp = str_in[ii];
     str_in[ii] = str_in[len - ii - 1]; // ii-th char from end
     str_in[len - ii - 1] = tmp;
@@ -588,6 +632,24 @@ printf("first: %d\nsecond: %d\n", first, second);
 // values will be swapped
 */
 
+// Return multiple values.
+// C does not allow for returning multiple values with the return statement. If
+// you would like to return multiple values, then the caller must pass in the
+// variables where they would like the returned values to go. These variables must
+// be passed in as pointers such that the function can modify them.
+int return_multiple( int *array_of_3, int *ret1, int *ret2, int *ret3)
+{
+    if(array_of_3 == NULL)
+        return 0; //return error code (false)
+
+    //de-reference the pointer so we modify its value
+   *ret1 = array_of_3[0];
+   *ret2 = array_of_3[1];
+   *ret3 = array_of_3[2];
+
+   return 1; //return error code (true)
+}
+
 /*
 With regards to arrays, they will always be passed to functions
 as pointers. Even if you statically allocate an array like `arr[10]`,
@@ -653,7 +715,7 @@ struct rectangle {
 
 void function_1()
 {
-  struct rectangle my_rec;
+  struct rectangle my_rec = { 1, 2 }; // Fields can be initialized immediately
 
   // Access struct members with .
   my_rec.width = 10;
@@ -677,6 +739,16 @@ int area(rect r)
   return r.width * r.height;
 }
 
+// Typedefs can also be defined right during struct definition
+typedef struct {
+  int width;
+  int height;
+} rect;
+// Like before, doing this means one can type
+rect r;
+// instead of having to type
+struct rectangle r;
+
 // if you have large structs, you can pass them "by pointer" to avoid copying
 // the whole struct:
 int areaptr(const rect *r)
@@ -716,6 +788,10 @@ typedef void (*my_fnp_type)(char *);
 // my_fnp_type f;
 
 
+/////////////////////////////
+// Printing characters with printf()
+/////////////////////////////
+
 //Special characters:
 /*
 '\a'; // alert (bell) character
@@ -825,16 +901,17 @@ enum traffic_light_state {GREEN, YELLOW, RED};
 Node createLinkedList(int *vals, int len);
 
 /* Beyond the above elements, other definitions should be left to a C source */
-/* file. Excessive includes or definitions should, also not be contained in */
+/* 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. */
 
 ```
+
 ## Further Reading
 
 Best to find yourself a copy of [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)
-It is *the* book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some
+It is _the_ book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some
 inaccuracies (well, ideas that are not considered good anymore) or now-changed practices.
 
 Another good resource is [Learn C The Hard Way](http://learncodethehardway.org/c/) (not free).
diff --git a/ca-es/asciidoc-ca.html.markdown b/ca-es/asciidoc-ca.html.markdown
index a88aba52..6d387213 100644
--- a/ca-es/asciidoc-ca.html.markdown
+++ b/ca-es/asciidoc-ca.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
 lang: ca-es
-filename: asciidoc-ca.md
+filename: asciidoc-ca.adoc
 ---
 
 AsciiDoc és un llenguatge de marques similar a Markdown i que pot ser usat per qualsevol ús, des de llibres fins a blogs.
diff --git a/ca-es/go-ca.html.markdown b/ca-es/go-ca.html.markdown
index 99f0d393..7bec4ba4 100644
--- a/ca-es/go-ca.html.markdown
+++ b/ca-es/go-ca.html.markdown
@@ -95,7 +95,7 @@ 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.
+	f := 3.14159 // 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.
@@ -433,25 +433,25 @@ func requestServer() {
 ## 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
+(https://go.dev/). 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
+[the docs](https://go.dev/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).
+Es pot jugar amb codi a [Go playground](https://go.dev/play/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
+servir [https://go.dev/play/](https://go.dev/play/) 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/).
+[el codi font de la llibreria estàndard](https://go.dev/src/).
 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/)
+pot clicar en un nom de funció en [la documentació](https://go.dev/pkg/)
 i veure'n el codi!
 
 Un altre gran recurs per aprendre Go és
diff --git a/cairo.html.markdown b/cairo.html.markdown
new file mode 100644
index 00000000..dd3ca036
--- /dev/null
+++ b/cairo.html.markdown
@@ -0,0 +1,864 @@
+---
+language: Cairo
+filename: learnCairo.sol
+contributors:
+    - ["Darlington Nnam", "https://github.com/Darlington02"]
+---
+
+# Cairo
+
+Cairo is a Turing-complete language that allows you write provable programs
+(where one party can prove to another that a certain computation was executed
+correctly) on StarkNet.
+
+## StarkNet
+
+StarkNet is a decentralized ZK-rollup that operates as an Ethereum layer 2
+chain.
+
+In this document, we are going to be going in-depth into understanding Cairo's
+syntax and how you could create and deploy a Cairo smart contract on StarkNet.
+
+**NB: As at the time of this writing, StarkNet is still at v0.10.3, with Cairo
+1.0 coming soon. The ecosystem is young and evolving very fast, so you might
+want to check the [official docs](https://www.cairo-lang.org/docs) to confirm
+this document is still up-to-date. Pull requests are welcome!**
+
+## Setting Up A Development Environment
+
+Before we get started writing codes, we will need to setup a Cairo development
+environment, for writing, compiling and deploying our contracts to StarkNet.
+For the purpose of this tutorial we are going to be using the
+[Protostar Framework](https://github.com/software-mansion/protostar).
+Installation steps can be found in the docs
+[here](https://docs.swmansion.com/protostar/docs/tutorials/installation).
+Note that Protostar supports just Mac and Linux OS, Windows users might need to
+use WSL, or go for other alternatives such as the Official
+[StarkNet CLI](https://www.cairo-lang.org/docs/quickstart.html) or
+[Nile from Openzeppelin](https://github.com/OpenZeppelin/nile)
+
+Once you're done with the installations, run the command `protostar -v` to
+confirm your installation was successful. If successful, you should see your
+Protostar version displayed on the screen.
+
+## Initializing a new project
+
+Protostar similar to Truffle for solidity development can be installed once and
+used for multiple projects. To initialize a new Protostar project, run the
+following command:
+
+```
+protostar init
+```
+
+It would then request the project's name and the library's directory name,
+you'd need to fill in this, and a new project will be initialized successfully.
+
+## Compiling, Declaring, Deploying and Interacting with StarkNet Contracts
+
+Within the `src` folder you'll find a boilerplate contract that comes with
+initializing a new Protostar project, `main.cairo`. We are going to be
+compiling, declaring and deploying this contract.
+
+### Compiling Contracts
+
+To compile a Cairo contract using Protostar, ensure a path to the contract is
+specified in the `[contracts]` section of the `protostar.toml` file. Once
+you've done that, open your terminal and run the command:
+
+```
+protostar build
+```
+
+And you should get an output similar to what you see below, with a `main.json`
+and `main_abi.json` files created in the `build` folder.
+<img src="./images/cairo/build.png" alt="building your contract">
+
+### Declaring Contracts
+
+With the recent StarkNet update to 0.10.3, the DEPLOY transaction was
+deprecated and no longer works. To deploy a transaction, you must first declare
+a Contract to obtain the class hash, then deploy the declared contract using the
+[Universal Deployer Contract](https://community.starknet.io/t/universal-deployer-contract-proposal/1864).
+
+Before declaring or deploying your contract using Protostar, you should set the
+private key associated with the specified account address in a file, or in the
+terminal. To set your private key in the terminal, run the command:
+
+```
+export PROTOSTAR_ACCOUNT_PRIVATE_KEY=[YOUR PRIVATE KEY HERE]
+```
+
+Then to declare our contract using Protostar run the following command (for
+visual clarity, the backslash sign symbolizes the continuing line):
+
+```
+protostar declare ./build/main.json \
+  --network testnet \
+  --account 0x0691622bBFD29e835bA4004e7425A4e9630840EbD11c5269DE51C16774585b16 \
+  --max-fee auto
+```
+
+where `network` specifies the network we are deploying to, `account` specifies
+account whose private key we are using, `max-fee` specifies the maximum fee to
+be paid for the transaction. You should get the class hash outputted as seen
+below:
+<img src="./images/cairo/declare.png" alt="declaring your contract">
+
+### Deploying Contracts
+
+After obtaining our class hash from declaring, we can now deploy using the
+command below:
+
+```
+protostar \
+  deploy 0x02a5de1b145e18dfeb31c7cd7ff403714ededf5f3fdf75f8b0ac96f2017541bc \
+  --network testnet \
+  --account 0x0691622bBFD29e835bA4004e7425A4e9630840EbD11c5269DE51C16774585b16 \
+  --max-fee auto
+```
+
+where `0x02a5de1b145e18dfeb31c7cd7ff403714ededf5f3fdf75f8b0ac96f2017541bc` is
+the class hash of our contract.
+<img src="./images/cairo/deploy.png" alt="deploying your contract">
+
+### Interacting with Contracts
+
+To interact with your deployed contract, we will be using `Argent X`
+(alternative: `Braavos`), and `Starkscan` (alternative: `Voyager`). To install
+and setup `Argent X`, see this
+[guide](https://www.argent.xyz/learn/how-to-create-an-argent-x-wallet/).
+
+Copy your contract address, displayed on screen from the previous step, and
+head over to [Starkscan](https://testnet.starkscan.co/) to search for the
+contract. Once found, you can make write calls to the contract in the following
+sequence:
+
++ click on the "connect wallet" button,
+  <img src="./images/cairo/connect.png" alt="connect wallet">
++ select `Argent X` and approve the connection
+  <img src="./images/cairo/connect2.png" alt="connect to argentX">
++ you can now make read and write calls easily.
+
+## Let's learn Cairo
+
+First let's look at a default contract that comes with Protostar which allows
+you to set balance on deployment, increase, and get the balance.
+
+```
+// Language directive - instructs compiler its a StarkNet contract
+%lang starknet
+
+// Library imports from the Cairo-lang library
+from starkware.cairo.common.math import assert_nn
+from starkware.cairo.common.cairo_builtins import HashBuiltin
+
+// @dev Storage variable that stores the balance of a user.
+// @storage_var is a decorator that instructs the compiler the function
+//   below it is a storage variable.
+@storage_var
+func balance() -> (res: felt) {}
+
+// @dev Constructor writes the balance variable to 0 on deployment
+// Constructors sets storage variables on deployment. Can accept arguments too.
+@constructor
+func constructor{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}() {
+  balance.write(0); 
+  return();
+}
+
+// @dev increase_balance updates the balance variable
+// @param amount the amount you want to add to balance
+// @external is a decorator that specifies the func below it is an external
+//   function.
+@external
+func increase_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(amount: felt){
+  with_attr error_message("Amount must be positive. Got: {amount}.") {
+    assert_nn(amount);
+  }
+
+  let (res) = balance.read();
+  balance.write(res + amount);
+  return ();
+}
+
+// @dev returns the balance variable
+// @view is a decorator that specifies the func below it is a view function.
+@view
+func get_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}() -> (res: felt) {
+  let (res) = balance.read();
+  return (res,);
+}
+```
+
+Before proceeding to the main lessons, try to build, deploy and interact with
+this contract.
+NB: You should be at `main.cairo` if you are using Protostar.
+
+### 1. The Felt data type
+
+Unlike solidity, where you have access to various data types, Cairo comes with
+just a single data type `..felts`. Felts stands for Field elements, and are a
+252 bit integer in the range `0<=x<=P` where `P` is a prime number. You can
+create a `Uint256` in Cairo by utlizing a struct of two 128 bits felts.
+
+```
+struct Uint256 {
+  low: felt, // The low 128 bits of the value.
+  high: felt, // The high 128 bits of the value.
+}
+```
+
+To avoid running into issues with divisions, it's safer to work with the
+`unsigned_div_rem` method from Cairo-lang's library.
+
+### 2. Lang Directive and Imports
+
+To get started with writing a StarkNet contract, you must specify the directive:
+
+```
+%lang starknet
+```
+
+This directive informs the compiler you are writing a contract and not a
+program. The difference between both is contracts have access to StarkNet's
+storage, programs don't and as such are stateless.
+
+There are important functions you might need to import from the official
+Cairo-lang library or Openzeppelin's, e.g.
+
+```
+from starkware.cairo.common.cairo_builtins import HashBuiltin
+from cairo_contracts.src.openzeppelin.token.erc20.library import ERC20
+from starkware.cairo.common.uint256 import Uint256
+from starkware.cairo.common.bool import TRUE
+```
+
+### 3. Data Structures
+
++ Storage variables: Cairo's storage is a map with `2^251` slots, where each
+  slot is a felt which is initialized to `0`. You create one using the
+  `@storage_var` decorator.
+
+  ```
+  @storage_var
+  func names() -> (name: felt) {}
+  ```
+
++ Storage mappings: Unlike Solidity where mappings have a separate keyword, in
+  Cairo you create mappings using storage variables.
+
+  ```
+  @storage_var
+  func names(address: felt) -> (name: felt) {}
+  ```
+
++ Structs: are a means to create custom data types in Cairo. A `struct` has a
+  size, which is the sum of the sizes of its members. The size can be
+  retrieved using `MyStruct.SIZE`. You create a struct in Cairo using the
+  `struct` keyword.
+
+  ```
+  struct Person {
+    name: felt,
+    age: felt,
+    address: felt,
+  }
+  ```
+
++ Constants: Constants are fixed and as such can't be altered after being set.
+  They evaluate to an integer (field element) at compile time. To create a
+  constant in Cairo, you use the `const` keyword. It's proper practice to
+  capitalize constant names.
+
+  ```
+  const USER = 0x01C6cfC1DB2ae90dACEA243F0a8C2F4e32560F7cDD398e4dA2Cc56B733774E9b
+  ```
+
++ Arrays: Arrays can be defined as a `pointer(felt*)` to the first element of
+  the array. As an array is populated, its elements take up contigous memory
+  cells. The `alloc` keyword can be used to dynamically allocate a new memory
+  segment, which can be used to store an array:
+
+  ```
+  let (myArray: felt*) = alloc ();
+  assert myArray[0] = 1;
+  assert myArray[1] = 2;
+  assert myArray[3] = 3;
+  ```
+
+  You can also use the `new` operator to create fixed-size arrays using
+  tuples. The new operator is useful as it enables you allocate memory and
+  initialize the object in one instruction
+
+  ```
+  func foo() {
+    tempvar arr: felt* = new (1, 1, 2, 3, 5);
+    assert arr[4] = 5;
+    return ();
+  }
+  ```
+
++ Tuples: A tuple is a finite, ordered, unchangeable list of elements. It is
+  represented as a comma-separated list of elements enclosed by parentheses.
+  Their elements may be of any combination of valid types.
+
+  ```
+  local tuple0: (felt, felt, felt) = (7, 9, 13);
+  ```
+
++ Events: Events allows a contract emit information during the course of its
+  execution, that can be used outside of StarkNet. An event can be created,
+  subsequently emitted:
+
+  ```
+  @event
+  func name_stored(address, name) {}
+
+  name_stored.emit(address, name);
+  ```
+
+### 4. Constructors, External and View functions
+
++ Constructors: Constructors are a way to intialize state variables on
+  contract deployment. You create a constructor using the `@constructor`
+  decorator.
+
+  ```
+  @constructor
+  func constructor{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+  range_check_ptr}(_name: felt) {
+    let (caller) = get_caller_address();
+    names.write(caller, _name);
+    return ();
+  }
+  ```
+
++ External functions: External functions are functions that modifies the state
+  of the network. You create an external function using the `@external`
+  decorator:
+
+  ```
+  @external
+  func store_name{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+  range_check_ptr}(_name: felt){
+    let (caller) = get_caller_address();
+    names.write(caller, _name);
+    stored_name.emit(caller, _name);
+    return ();
+  }
+  ```
+
++ View functions: View functions do not modify the state of the blockchain.
+  You can create a view function using the `@view` decorator.
+
+  ```
+  @view
+  func get_name{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+  range_check_ptr}(_address: felt) -> (name: felt){
+    let (name) = names.read(_address);
+    return (name,);
+  }
+  ```
+
+    NB: Unlike Solidity, Cairo supports just External and View function types.
+    You can alternatively also create an internal function by not adding any
+    decorator to the function.
+
+### 5. Decorators
+
+All functions in Cairo are specified by the `func` keyword, which can be
+confusing. Decorators are used by the compiler to distinguish between these
+functions.
+
+Here are the most common decorators you'll encounter in Cairo:
+
++ `@storage_var` — used for specifying state variables.
++ `@constructor` — used for specifying constructors.
++ `@external` — used for specifying functions that write to a state variable.
++ `@event` — used for specifying events
++ `@view` — used to specify functions reading from a state variable
++ `@contract_interface` — used for specifying function interfaces.
++ `@l1_handler` — used for specifying functions that processes message sent from
+  an L1 contract in a messaging bridge.
+
+### 6. BUILTINS, HINTS & IMPLICIT Arguments
+
++ `BUILTINS` are predefined optimized low-level execution units, which are
+  added to Cairo’s CPU board. They help perform predefined computations like
+  pedersen hashing, bitwise operations etc, which are expensive to perform in
+  Vanilla Cairo. Each builtin in Cairo is assigned a separate memory location,
+  accessible through regular Cairo memory calls using implicit parameters. You
+  specify them using the `%builtins` directive
+
+  Here is a list of available builtins in Cairo:
+
+    + `output` — the output builtin is used for writing program outputs
+    + `pedersen` — the pedersen builtin is used for pedersen hashing
+      computations
+    + `range_check` — This builtin is mostly used for integer comparisons,
+      and facilitates check to confirm that a field element is within a range
+      `[0, 2^128)`
+    + `ecdsa` — the ecdsa builtin is used for verifying ECDSA signatures
+    + `bitwise` — the bitwise builtin is used for carrying out bitwise
+      operations on felts
+
++ `HINTS` are pieces of Python codes, which contains instructions that only
+  the prover sees and executes. From the point of view of the verifier these
+  hints do not exist. To specify a hint in Cairo, you need to encapsulate it
+  within `%{` and `%}`. It is good practice to avoid using hints as much as
+  you can in your contracts, as hints are not added to the bytecode, and thus
+  do not count in the total number of execution steps.
+
+  ```
+  %{
+    # Python hint goes here
+  %}
+  ```
+
++ `IMPLICIT ARGUMENTS` are not restricted to the function body, but can be
+  inherited by other functions calls that require them. Implicit arguments are
+  passed in between curly bracelets, like you can see below:
+
+  ```
+  func store_name{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+  range_check_ptr}(_name: felt){
+    let (caller) = get_caller_address();
+    names.write(caller, _name);
+    stored_name.emit(caller, _name);
+    return ();
+  }
+  ```
+
+### 7. Error Messages and Access Controls
+
+You can create custom errors in Cairo which is outputted to the user upon failed
+execution. This can be very useful for implementing checks and proper access
+control mechanisms. An example is preventing a user to call a function except
+user is `admin`.
+
+```
+// imports
+from starkware.starknet.common.syscalls import get_caller_address
+
+// create an admin constant
+const ADMIN = 0x01C6cfC1DB2ae90dACEA243F0a8C2F4e32560F7cDD398e4dA2Cc56B733774E9b
+
+// implement access control
+with_attr error_message("You do not have access to make this action!"){
+  let (caller) = get_caller_address();
+  assert ADMIN = caller;
+}
+
+// using an assert statement throws if condition is not true, thus
+// returning the specified error.
+```
+
+### 8. Contract Interfaces
+
+Contract interfaces provide a means for one contract to invoke or call the
+external function of another contract. To create a contract interface, you use
+the `@contract_interface` keyword:
+
+```
+@contract_interface
+  namespace IENS {
+    func store_name(_name: felt) {
+    }
+
+    func get_name(_address: felt) -> (name: felt) {
+    }
+  }
+```
+
+Once a contract interface is specified, any contract can make calls to that
+contract passing in the contract address as the first parameter like this:
+
+```
+IENS.store_name(contract_address, _name);
+```
+
+Note that Interfaces exclude the function body/logic and the implicit
+arguments.
+
+### 9. Recursions
+
+Due to the unavailability of loops, Recursion is the go-to for similar
+operations. In simple terms, a recursive function is one which calls itself
+repeatedly.
+
+A good example to demonstrate this is writing a function for getting the nth
+fibonacci number:
+
+```
+@external
+func fibonacci{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(n : felt) -> (result : felt){
+  alloc_locals;
+  if (n == 0){
+    return (0);
+  }
+  if (n == 1){
+    return (1);
+  }
+  let (local x) = fibonacci(n - 1);
+  let (local y) = fibonacci(n - 2);
+  return (result=(x + y));
+}
+```
+
+The nth fibonacci term is the sum of the `nth - 1` and the `nth - 2` numbers,
+that's why we get these two as `(x,y)` using recursion.
+
+NB: when implementing recursive functions, always remember to implement a base
+case (`n==0`, `n==1` in our case), to prevent stack overflows.
+
+### 10. Registers
+
+Registers holds values that may change over time. There are 3 major types of
+registers:
+
++ `ap` (allocation pointer) points to a yet unused memory. Temporary variables
+   created using `let`, `tempvar` are held here, and thus susceptible to being
+   revoked.
++ `fp` (frame pointer) points to the frame of the current function. The address
+  of all the function arguments and local variables are relative to this
+  register and as such can never be revoked.
++ `pc` (program counter) points to the current instruction.
+
+### 11. Revoked References
+
+Revoked references occur when there is a call instruction to another function,
+between the definition of a reference variable that depends on `ap` (temp
+variables) and its usage. This occurs as the compiler may not be able to compute
+the change of `ap` (as one may jump to the label from another place in the
+program, or call a function that might change ap in an unknown way).
+
+Here is an example to demonstrate what I mean:
+
+```
+@external
+func get_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}() -> (res: felt) {
+  return (res=100);
+}
+
+@external
+func double_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}() -> (res: felt) {
+  let multiplier = 2;
+  let (balance) = get_balance();
+  let new_balance = balance * multiplier;
+  return (res=new_balance);
+}
+```
+
+If you run that code, you'll run into the revoked reference error as we are
+trying to access the `multiplier` variable after calling the `get_balance`
+function.
+
+In simple cases you can resolve revoked references by adding the keyword
+`alloc_locals` within function scopes. In more complex cases you might need to
+create a local variable to resolve it.
+
+```
+// resolving the `double_balance` function:
+@external
+func double_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}() -> (res: felt) {
+  alloc_locals;
+  let multiplier = 2;
+  let (balance) = get_balance();
+  let new_balance = balance * multiplier;
+  return (res=new_balance);
+}
+```
+
+### 12. Understanding Cairo's Punctuations
+
++ `;` (semicolon). Used at the end of each instruction
++ `()` (parentheses). Used in a function declaration, if statements, and in a
+  tuple declaration
++ `{}` (curly braces). Used in a declaration of implicit arguments and to define
+  code blocks.
++ `[]` (square brackets). Standalone brackets represent the value at a
+  particular address location (such as the allocation pointer, `[ap]`). Brackets
+  following a pointer or a tuple act as a subscript operator, where `x[2]`
+  represents the element with index `2` in `x`.
++ `*` (single asterisk). Refers to the pointer of an expression.
++ `%` (percent sign). Appears at the start of a directive, such as `%builtins`
+  or `%lang`.
++ `%{` and `%}` represent Python hints.
++ `_` (underscore). A placeholder to handle values that are not used, such as an
+  unused function return value.
+
+## Full Contract Example
+
+Below is a simple automated market maker contract example that implements most
+of what we just learnt! Re-write, deploy, have fun!
+
+```
+%lang starknet
+
+from starkware.cairo.common.cairo_builtins import HashBuiltin
+from starkware.cairo.common.hash import hash2
+from starkware.cairo.common.alloc import alloc
+from starkware.cairo.common.math import (assert_le, assert_nn_le,
+  unsigned_div_rem)
+from starkware.starknet.common.syscalls import (get_caller_address,
+  storage_read, storage_write)
+
+
+// CONSTANTS
+//
+// @dev the maximum amount of each token that belongs to the AMM
+const BALANCE_UPPER_BOUND = 2 ** 64;
+
+const TOKEN_TYPE_A = 1;
+const TOKEN_TYPE_B = 2;
+
+// @dev Ensure the user's balances are much smaller than the pool's balance
+const POOL_UPPER_BOUND = 2 ** 30;
+const ACCOUNT_BALANCE_BOUND = 1073741; // (2 ** 30 / 1000)
+
+
+// STORAGE VARIABLES
+//
+// @dev A map from account and token type to corresponding balance
+@storage_var
+func account_balance(account_id: felt, token_type: felt) -> (balance: felt) {}
+
+// @dev a map from token type to corresponding pool balance
+@storage_var
+func pool_balance(token_type: felt) -> (balance: felt) {}
+
+
+// GETTERS
+//
+// @dev returns account balance for a given token
+// @param account_id Account to be queried
+// @param token_type Token to be queried
+@view
+func get_account_token_balance{syscall_ptr: felt*, pedersen_ptr:
+HashBuiltin*, range_check_ptr}(
+  account_id: felt, token_type: felt
+  ) -> (balance: felt) {
+  return account_balance.read(account_id, token_type);
+}
+
+// @dev return the pool's balance
+// @param token_type Token type to get pool balance
+@view
+func get_pool_token_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(
+  token_type: felt
+  ) -> (balance: felt) {
+  return pool_balance.read(token_type);
+}
+
+
+// EXTERNALS
+//
+// @dev set pool balance for a given token
+// @param token_type Token whose balance is to be set
+// @param balance Amount to be set as balance
+@external
+func set_pool_token_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(
+  token_type: felt, balance: felt
+  ) {
+  with_attr error_message("exceeds maximum allowed tokens!"){
+    assert_nn_le(balance, BALANCE_UPPER_BOUND - 1);
+  }
+
+  pool_balance.write(token_type, balance);
+  return ();
+}
+
+// @dev add demo token to the given account
+// @param token_a_amount amount of token a to be added
+// @param token_b_amount amount of token b to be added
+@external
+func add_demo_token{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(
+    token_a_amount: felt, token_b_amount: felt
+  ) {
+  alloc_locals;
+  let (account_id) = get_caller_address();
+
+  modify_account_balance(account_id=account_id, token_type=TOKEN_TYPE_A,
+    amount=token_a_amount);
+  modify_account_balance(account_id=account_id, token_type=TOKEN_TYPE_B,
+    amount=token_b_amount);
+
+  return ();
+}
+
+// @dev intialize AMM
+// @param token_a amount of token a to be set in pool
+// @param token_b amount of token b to be set in pool
+@external
+func init_pool{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(
+  token_a: felt, token_b: felt
+  ) {
+  with_attr error_message("exceeds maximum allowed tokens!"){
+    assert_nn_le(token_a, POOL_UPPER_BOUND - 1);
+    assert_nn_le(token_b, POOL_UPPER_BOUND - 1);
+  }
+
+  set_pool_token_balance(token_type=TOKEN_TYPE_A, balance=token_a);
+  set_pool_token_balance(token_type=TOKEN_TYPE_B, balance=token_b);
+
+  return ();
+}
+
+
+// @dev swaps token between the given account and the pool
+// @param token_from token to be swapped
+// @param amount_from amount of token to be swapped
+// @return amount_to the token swapped to
+@external
+func swap{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
+  token_from: felt, amount_from: felt
+  ) -> (amount_to: felt) {
+  alloc_locals;
+  let (account_id) = get_caller_address();
+
+  // verify token_from is TOKEN_TYPE_A or TOKEN_TYPE_B
+  with_attr error_message("token not allowed in pool!"){
+    assert (token_from - TOKEN_TYPE_A) * (token_from - TOKEN_TYPE_B) = 0;
+    }
+
+  // check requested amount_from is valid
+  with_attr error_message("exceeds maximum allowed tokens!"){
+    assert_nn_le(amount_from, BALANCE_UPPER_BOUND - 1);
+    }
+
+  // check user has enough funds
+  let (account_from_balance) =
+    get_account_token_balance(account_id=account_id, token_type=token_from);
+  with_attr error_message("insufficient balance!"){
+    assert_le(amount_from, account_from_balance);
+    }
+
+  let (token_to) = get_opposite_token(token_type=token_from);
+  let (amount_to) = do_swap(account_id=account_id, token_from=token_from,
+    token_to=token_to, amount_from=amount_from);
+
+  return (amount_to=amount_to);
+}
+
+
+// INTERNALS
+//
+// @dev internal function that updates account balance for a given token
+// @param account_id Account whose balance is to be modified
+// @param token_type Token type to be modified
+// @param amount Amount Amount to be added
+func modify_account_balance{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(
+  account_id: felt, token_type: felt, amount: felt
+  ) {
+  let (current_balance) = account_balance.read(account_id, token_type);
+  tempvar new_balance = current_balance + amount;
+
+  with_attr error_message("exceeds maximum allowed tokens!"){
+    assert_nn_le(new_balance, BALANCE_UPPER_BOUND - 1);
+    }
+
+  account_balance.write(account_id=account_id, token_type=token_type,
+    value=new_balance);
+  return ();
+}
+
+// @dev internal function that swaps tokens between the given account and
+// the pool
+// @param account_id Account whose tokens are to be swapped
+// @param token_from Token type to be swapped from
+// @param token_to Token type to be swapped to
+// @param amount_from Amount to be swapped
+func do_swap{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*,
+range_check_ptr}(
+  account_id: felt, token_from: felt, token_to: felt, amount_from: felt
+  ) -> (amount_to: felt) {
+  alloc_locals;
+
+  // get pool balance
+  let (local amm_from_balance) = get_pool_token_balance(token_type =
+    token_from);
+  let (local amm_to_balance) = get_pool_token_balance(token_type=token_to);
+
+  // calculate swap amount
+  let (local amount_to, _) = unsigned_div_rem((amm_to_balance *
+    amount_from), (amm_from_balance + amount_from));
+
+  // update token_from balances
+  modify_account_balance(account_id=account_id, token_type=token_from,
+    amount=-amount_from);
+  set_pool_token_balance(token_type=token_from, balance=(amm_from_balance
+    + amount_from));
+
+  // update token_to balances
+  modify_account_balance(account_id=account_id, token_type=token_to,
+    amount=amount_to);
+  set_pool_token_balance(token_type=token_to, balance=(amm_to_balance -
+    amount_to));
+
+  return (amount_to=amount_to);
+}
+
+
+// @dev internal function to get the opposite token type
+// @param token_type Token whose opposite pair needs to be gotten
+func get_opposite_token(token_type: felt) -> (t: felt) {
+  if(token_type == TOKEN_TYPE_A) {
+    return (t=TOKEN_TYPE_B);
+  } else {
+    return (t=TOKEN_TYPE_A);
+  }
+}
+```
+
+## Additional Resources
+
++ [Official documentation](https://www.cairo-lang.org/docs/)
++ [Starknet EDU](https://medium.com/starknet-edu)
++ [Journey through Cairo](https://medium.com/@darlingtonnnam/journey-through-cairo-i-setting-up-protostar-and-argentx-for-local-development-ba40ae6c5524)
++ [Demystifying Cairo whitepaper](https://medium.com/@pban/demystifying-cairo-white-paper-part-i-b71976ad0108)
++ [Learn about StarkNet with Argent](https://www.argent.xyz/learn/tag/starknet/)
+
+## Development Frameworks
+
++ [Protostar](https://docs.swmansion.com/protostar/docs/tutorials/installation)
++ [Nile](https://github.com/OpenZeppelin/nile)
++ [StarkNet CLI](https://www.cairo-lang.org/docs/quickstart.html)
+
+## Helpful Libraries
+
++ [Cairo-lang](https://github.com/starkware-libs/cairo-lang)
++ [Openzeppelin](https://github.com/OpenZeppelin/cairo-contracts)
+
+## Educational Repos
+
++ [StarkNet Cairo 101](https://github.com/starknet-edu/starknet-cairo-101)
++ [StarkNet ERC721](https://github.com/starknet-edu/starknet-erc721)
++ [StarkNet ERC20](https://github.com/starknet-edu/starknet-erc20)
++ [L1 -> L2 Messaging](https://github.com/starknet-edu/starknet-messaging-bridge)
++ [StarkNet Debug](https://github.com/starknet-edu/starknet-debug)
++ [StarkNet Accounts](https://github.com/starknet-edu/starknet-accounts)
++ [Min-Starknet](https://github.com/Darlington02/min-starknet)
+
+## Security
+
++ [Amarna static analysis for Cairo programs](https://blog.trailofbits.com/2022/04/20/amarna-static-analysis-for-cairo-programs/)
++ [Cairo and StarkNet security by Ctrl03](https://ctrlc03.github.io/)
++ [How to hack almost any Cairo smart contract](https://medium.com/ginger-security/how-to-hack-almost-any-starknet-cairo-smart-contract-67b4681ac0f6)
++ [Analyzing Cairo code using Armana](https://dic0de.substack.com/p/analyzing-cairo-code-using-amarna?sd=pf)
+
+## Future TO-DOs
+
+Update tutorial to fit Cairo 1.0
diff --git a/citron.html.markdown b/citron.html.markdown
index bd3c398c..ce607ca1 100644
--- a/citron.html.markdown
+++ b/citron.html.markdown
@@ -68,7 +68,7 @@ False not. # True
 ###########################################
 
 # You may assign values to the current scope:
-var name is value. # assignes `value` into `name`
+var name is value. # assigns `value` into `name`
 
 # You may also assign values into the current object's namespace
 my name is value. # assigns `value` into the current object's `name` property
@@ -146,7 +146,7 @@ add(3, 5). # 8
 
 3 `add` 5. # 8
 # This call binds as such: add[(3), 5]
-# because the default fixity is left, and the default precedance is 1
+# because the default fixity is left, and the default precedence is 1
 
 # You may change the precedence/fixity of this operator with a pragma
 #:declare infixr 1 add
diff --git a/clojure.html.markdown b/clojure.html.markdown
index 20812a9b..21d5a088 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -412,7 +412,7 @@ Clojuredocs.org has documentation with examples for most core functions:
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
 4Clojure is a great way to build your clojure/FP skills:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org (yes, really) has a number of getting started articles:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/cobol.html.markdown b/cobol.html.markdown
index 1b33f9cc..1350c66f 100644
--- a/cobol.html.markdown
+++ b/cobol.html.markdown
@@ -14,7 +14,7 @@ organizations.
       *COBOL has significant differences between legacy (COBOL-85)
       *and modern (COBOL-2002 and COBOL-2014) versions.
       *Legacy versions require columns 1-6 to be blank (they are used
-      *to store the index number of the punched card..)
+      *to store the index number of the punched card).
       *A '*' in column 7 means a comment.
       *In legacy COBOL, a comment can only be a full line.
       *Modern COBOL doesn't require fixed columns and uses *> for
@@ -106,7 +106,7 @@ organizations.
       PROCEDURE DIVISION.
          FIRST-PARA.
              DISPLAY 'THIS IS IN FIRST-PARA'.
-         PERFORM THIRD-PARA THRU FOURTH-PARA. *>skip second-para and perfrom 3rd & 4th
+         PERFORM THIRD-PARA THRU FOURTH-PARA. *>skip second-para and perform 3rd & 4th
          *> then after performing third and fourth,
          *> return here and continue the program until STOP RUN.
    
@@ -132,7 +132,7 @@ organizations.
       
       *Now it is time to learn about two related COBOL verbs: string and unstring.
 
-      *The string verb is used to concatenate, or put together, two or more stings.
+      *The string verb is used to concatenate, or put together, two or more strings.
       *Unstring is used, not surprisingly, to separate a         
       *string into two or more smaller strings. 
       *It is important that you remember to use ‘delimited by’ when you
diff --git a/crystal.html.markdown b/crystal.html.markdown
index ae027a8d..d32712ce 100644
--- a/crystal.html.markdown
+++ b/crystal.html.markdown
@@ -4,6 +4,7 @@ filename: learncrystal.cr
 contributors:
     - ["Vitalii Elenhaupt", "http://veelenga.com"]
     - ["Arnaud Fernandés", "https://github.com/TechMagister/"]
+    - ["Valentin Baca", "https://github.com/valbaca/"]
 
 ---
 
@@ -64,24 +65,25 @@ true.class #=> Bool
 1.5e10.class  #=> Float64
 1.5e-7.class  #=> Float64
 
-# Chars
+# Chars use 'a' pair of single quotes
 
 'a'.class #=> Char
 
-# Octal codepoint
-'\101' #=> 'A' : Char
+# Chars are 32-bit unicode
+'�' #=> '�' : Char
 
 # Unicode codepoint
 '\u0041' #=> 'A' : Char
 
-# Strings
+# Strings use a "pair" of double quotes
 
 "s".class #=> String
 
 # Strings are immutable
 s = "hello, "  #=> "hello, "        : String
 s.object_id    #=> 134667712        : UInt64
-s += "Crystal" #=> "hello, Crystal" : String
+s += "Crystal"
+s              #=> "hello, Crystal" : String
 s.object_id    #=> 142528472        : UInt64
 
 # Supports interpolation
@@ -89,7 +91,8 @@ s.object_id    #=> 142528472        : UInt64
 
 # Multiline string
 "This is
-   multiline string"
+   multiline string" #=> "This is\n   multiline string"
+
 
 # String with double quotes
 %(hello "world") #=> "hello \"world\""
@@ -110,7 +113,7 @@ sentence == "question?"   #=> false : Bool
 # Arrays
 
 [1, 2, 3].class         #=> Array(Int32)
-[1, "hello", 'x'].class #=> Array(Int32 | String | Char)
+[1, "hello", 'x'].class #=> Array(Char | Int32 | String)
 
 # Empty arrays should specify a type
 []               # Syntax error: for empty arrays use '[] of ElementType'
@@ -154,24 +157,24 @@ array.includes? 3 #=> true
 
 # 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 = Set{1, 2, 3} #=> Set{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
+set = Set(typeof(1, 2, 3)).new #=> Set{} : Set(Int32)
+set << 1                       #=> Set{1} : Set(Int32)
+set << 2                       #=> Set{1, 2} : Set(Int32)
+set << 3                       #=> Set{1, 2, 3} : Set(Int32)
 
 # Hashes
 
 {1 => 2, 3 => 4}.class   #=> Hash(Int32, Int32)
-{1 => 2, 'a' => 3}.class #=> Hash(Int32 | Char, Int32)
+{1 => 2, 'a' => 3}.class #=> Hash(Char| Int32, Int32)
 
-# Empty hashes should specify a type
-{}                     # Syntax error
-{} of Int32 => Int32   # {}
-Hash(Int32, Int32).new # {}
+# Empty hashes must specify a type
+{}                     # Syntax Error: for empty hashes use '{} of KeyType => ValueType'
+{} of Int32 => Int32   # {} : Hash(Int32, Int32)
+Hash(Int32, Int32).new # {} : Hash(Int32, Int32)
 
 # Hashes can be quickly looked up by key
 hash = {"color" => "green", "number" => 5}
@@ -179,6 +182,9 @@ hash["color"]        #=> "green"
 hash["no_such_key"]  #=> Missing hash key: "no_such_key" (KeyError)
 hash["no_such_key"]? #=> nil
 
+# The type of the returned value is based on all key types
+hash["number"] #=> 5 : (Int32 | String)
+
 # Check existence of keys hash
 hash.has_key? "color" #=> true
 
@@ -220,7 +226,7 @@ Range.new(1, 10).class #=> Range(Int32, Int32)
 # Access tuple's value by its index
 tuple = {:key1, :key2}
 tuple[1] #=> :key2
-tuple[2] #=> syntax error : Index out of bound
+tuple[2] #=> Error: index out of bounds for Tuple(Symbol, Symbol) (2 not in -2..1)
 
 # Can be expanded into multiple variables
 a, b, c = {:a, 'b', "c"}
@@ -246,7 +252,7 @@ elsif false
   "else-if, optional"
 else
   "else, also optional"
-end
+end 
 
 puts "if as a suffix" if true
 
@@ -314,7 +320,7 @@ if a < 3
 else
   a = true
 end
-typeof a #=> (Bool | String)
+typeof(a) #=> (Bool | String)
 
 if a && b
   # here both a and b are guaranteed not to be Nil
@@ -388,15 +394,19 @@ dinner    #=> "quesadilla"
 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
+# Also by convention, 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"
+fruits = ["grapes", "apples", "bananas"]
+fruits.sort  #=> ["apples", "bananas", "grapes"]
+fruits       #=> ["grapes", "apples", "bananas"]
+fruits.sort! #=> ["apples", "bananas", "grapes"]
+fruits       #=> ["apples", "bananas", "grapes"]
 
+# However, some mutating methods do not end in !
+fruits.shift #=> "apples"
+fruits       #=> ["bananas", "grapes"]
 
 # Define a class with the class keyword
 class Human
@@ -404,7 +414,7 @@ class Human
   # A class variable. It is shared by all instances of this class.
   @@species = "H. sapiens"
 
-  # type of name is String
+  # An instance variable. Type of name is String
   @name : String
 
   # Basic initializer
@@ -469,9 +479,9 @@ class TestClass
 end
 # Variables that start with a capital letter are constants
 Var = "I'm a constant"
-Var = "can't be updated" # Already initialized constant Var
+Var = "can't be updated" # Error: already initialized constant Var
 
-# Class is also an object in crystal. So class can have instance variables.
+# Class is also an object in Crystal. So a class can have instance variables.
 # Class variable is shared among the class and all of its descendants.
 
 # base class
diff --git a/cs-cz/css.html.markdown b/cs-cz/css.html.markdown
index 54a0a08e..ed69c73a 100644
--- a/cs-cz/css.html.markdown
+++ b/cs-cz/css.html.markdown
@@ -220,9 +220,11 @@ 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í.
diff --git a/cs-cz/go.html.markdown b/cs-cz/go.html.markdown
index 36217414..18880a3b 100644
--- a/cs-cz/go.html.markdown
+++ b/cs-cz/go.html.markdown
@@ -33,7 +33,7 @@ Go má již v základu vynikající knihovnu a je s ním spojená nadšená komu
  řádkový komentář */
 
 // Každý zdroják za�íná deklarací balí�ku (package)
-// Main je vyhrazené jméno, které ozna�uje spustitelný soubor,
+// main je vyhrazené jméno, které ozna�uje spustitelný soubor,
 // narozdíl od knihovny
 package main
 
@@ -90,7 +90,7 @@ 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.
+	f := 3.14159 // 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í
@@ -408,20 +408,20 @@ func requestServer() {
 
 ## Kam dále
 
-Vše hlavní o Go se nachází na [oficiálních stránkách go](http://golang.org/).
+Vše hlavní o Go se nachází na [oficiálních stránkách go](https://go.dev/).
 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
+Kromě úvodu, [dokumenty](https://go.dev/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
+Pokud si chcete pohrát s Go, tak navštivte [hřiště Go](https://go.dev/play/p/r46YvCu-XX).
+Můžete tam spouštět programy s prohlíže�e. Také můžete [https://go.dev/play/](https://go.dev/play/) 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/)
+Na vašem knižním seznamu, by neměly chybět [zdrojáky stadardní knihovny](https://go.dev/src/).
+Důkladně popisuje a dokumentuje Go, styl zápisu Go a Go idiomy. Pokud kliknete na [dokumentaci](https://go.dev/pkg/)
 tak se podíváte na dokumentaci.
 
 Dalším dobrým zdrojem informací je [Go v ukázkách](https://gobyexample.com/).
diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 35becf94..e1a96f32 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -5,44 +5,87 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Michal Martinek", "https://github.com/MichalMartinek"]
+    - ["Tomáš Hartman", "https://github.com/tomas-hartman"]
 filename: markdown-cz.md
 lang: cs-cz
 ---
 
-Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce �itelná
-a psatelná syntaxe, která je jednoduše převeditelná do HTML (a dnes i do mnoha
-dalších formátů)
+Markdown byl vytvořen Johnem Gruberem v roce 2004 jako zna�kovací jazyk, který
+lze snadno �íst a psát a který je možné jednoduše převést do HTML (a dnes i do
+mnoha dalších formátů).
+
+Implementace markdownu se v různých parserech (syntaktických analyzátorech,
+které markdown dále zpracovávají) mírně odlišuje. V této příru�ce se snažíme
+upozorňovat, kdy se jedná o obecnou vlastnost markdownu a kdy se jedná o
+specifickou vlastnost daného parseru.
+
+## Obsah
+
+- [Obsah](#obsah)
+- [HTML Elementy](#html-elementy)
+- [Nadpisy](#nadpisy)
+- [Jednoduché stylování textu](#jednoduché-stylování-textu)
+- [Odstavce](#odstavce)
+  - [Blokové citace](#blokové-citace)
+- [Seznamy](#seznamy)
+- [Bloky kódu](#bloky-kódu)
+- [Vodorovná �ára (`<hr />`)](#vodorovná-�ára-hr-)
+- [Odkazy](#odkazy)
+  - [Obsahy](#obsahy)
+- [Obrázky](#obrázky)
+- [Ostatní](#ostatní)
+  - [Automatické odkazy](#automatické-odkazy)
+  - [Automatické odkazy z emailů](#automatické-odkazy-z-emailů)
+  - [Escapování znaků](#escapování-znaků)
+  - [Klávesové zkratky](#klávesové-zkratky)
+  - [Tabulky](#tabulky)
+- [Markdownlint](#markdownlint)
+- [Reference](#reference)
+
+## HTML Elementy
+
+Markdown je nadstavba HTML. To znamená, že každý HTML kód je zároveň validním
+kódem v Markdownu.
+
+```md
+<!-- To znamená, že v Markdownu můžeme používat HTML elementy jako například 
+komentáře, které nebudou ovlivněny parserem Markdownu. Na druhou stranu to také 
+znamená, že pokud ve svém Markdown kódu vytvoříte HTML element, už v rámci 
+tohoto elementu nelze použít Markdown. 
+
+Markdown využívá i tato stránka, a tak by tento text, kdyby nebyl obalen v bloku 
+kódu (viz níže), jako validní HTML komentář vůbec nebyl vidět. -->
+```
+
+## Nadpisy
+
+HTML elementy `<h1>` až `<h6>` vytvoříte jednoduše tak, že nadpisu předsadíte
+takový po�et křížků (#), jaký odpovídá úrovni nadpisu.
 
 ```md
-<!-- Markdown je nadstavba nad HTML, takže jakýkoliv kód HTML je validní
-Markdown, to znamená, že můžeme používat HTML elementy, třeba jako komentář, a
-nebudou ovlivněny parserem Markdownu. Avšak, pokud vytvoříte HTML element v
-Markdownu, tak nemůžete používat syntaxi Markdownu uvnitř tohoto elementu. -->
-
-<!-- Markdown se také mírně liší v jednotlivých interpretacích parseru. Tento
-návod vás bude upozorňovat, které vlastnosti jsou obecné a které specifické pro
-konkrétní parser. -->
-
-<!-- Nadpisy -->
-<!-- Můžete vytvořit HTML elementy <h1> až <h6> jednoduše tak, že text předsadíte
-po�tem křížků (#), podle toho jaké úrovně to má být nadpis -->
 # Toto je <h1>
 ## Toto je <h2>
 ### Toto je <h3>
 #### Toto je <h4>
 ##### Toto je <h5>
 ###### Toto je <h6>
+```
+
+Markdown obsahuje ještě dva další způsoby, jak vytvořit h1 a h2:
 
-<!-- Markdown obsahuje taky dvě další cesty, jak udělat h1 a h2 -->
+```md
 Toto je h1
 ==========
 
 Toto je h2
 ----------
+```
+
+## Jednoduché stylování textu
 
-<!-- Jednoduché stylování textu -->
-<!-- Pomocí markdownu můžete text jednoduše ozna�it jako kurzívu �i tu�ný -->
+Pomocí markdownu můžete text jednoduše ozna�it jako kurzívu �i tu�ný text.
 
+```md
 *Tento text je kurzívou;*
 _StejnÄ› jako tento._
 
@@ -50,47 +93,62 @@ _StejnÄ› jako tento._
 __StejnÄ› jako tento.__
 
 ***Tento text je obojí***
-**_Jako tento!_**
-*__A tento!__*
+**_Tak jako tento!_**
+*__Nebo tento!__*
+```
 
-<!-- Ve verzi Markdownu od GitHubu, máme k dispozici taky prošktrnutí: -->
+Ve verzi Markdownu od GitHubu máme k dispozici také přeškrtnutí:
 
-~~Tento text je prošktrnutý.~~
+```md
+~~Tento text je přeškrtnutý.~~
+```
 
-<!-- Odstavce jsou jedna nebo více řádek textu, oddělených jednou nebo více prázdnými řádky. -->
+## Odstavce
 
-Toto je odstavec. Píši odstavec, není to zábava?
+Odstavce tvoří jeden nebo více řádků textu, oddělených jedním nebo více
+prázdnými řádky.
 
-Te� jsem v odstavci 2.
-Jsem pořád v odstavci 2!
+```md
+Toto je odstavec. Zde jsem napsal odstavec a je to bezva!
 
+Te� jsem v odstavci 2.
+A tady jsem pořád v odstavci 2!
 
-Toto je odstavec 3.
+Ale tady už je odstavec 3.
+```
 
-<!-- Chtěli jste někdy vložit znak <br /> tag? Můžete napsat na konec odstavce
-dvě nebo více mezer a potom za�ít nový odstavec. -->
+Pokud byste chtěli vložit HTML element `<br />`, můžete na konec odstavce napsat
+dvě nebo více mezer a potom za�ít nový odstavec.
 
+```md
 Tento odstavec kon�í dvěma mezerami.  
 
-Nad tímto odstavcem je  <br />!
+Nad tímto odstavcem je <br />!
+```
+
+### Blokové citace
 
-<!-- Blokové citace se dělají jednoduše pomocí znaku >. -->
+Blokové citace se dělají jednoduše uvozením řádku znakem >.
 
+```md
 > Toto je bloková citace. Můžete dokonce
-> manuálně rozdělit řádky, a před každý vložit >, nebo nechat vaše řádky jakkoliv dlouhé, ať se zarovnají sami.
-> Nedělá to rozdíl, dokud za�ínáte vždy znakem >.
+> manuálně rozdělit řádky, a před každý vložit >, nebo nechat vaše řádky 
+> jakkoli dlouhé, ať se zarovnají samy.
+> Je to jedno, pokud vždy za�ínají symbolem `>`.
+
+> Použít můžu i více než jednu úroveň
+>> odsazení.
+> Co vy na to?
+```
 
-> Můžu použít více než jednu
->> odsazení?
-> Jak je to úhledné, že?
+## Seznamy
 
-<!-- Seznamy -->
-<!-- Ne�íslovaný seznam můžete jednoduše udělat pomocí hvězdi�ek, plusů, nebo
- poml�ek -->
+Ne�íslovaný seznam můžete jednoduše udělat pomocí hvězdi�ek, plusů nebo poml�ek:
 
+```md
 * Položka
 * Položka
-* Jinná položka
+* Jiná položka
 
 nebo
 
@@ -103,158 +161,248 @@ nebo
 - Položka
 - Položka
 - Další položka
+```
 
-<!-- Číslovaný seznam se dělají pomocí �ísla a . -->
+Číslované seznamy se dělají pomocí �íslice a `.`.
 
+```md
 1. Položka jedna
 2. Položka dvě
 3. Položka tři
 
-<!-- Nemusíte dokonce psát �ísla správně a markdown je zobrazi správně,
-     ale nemusí to být vždy dobrý nápad -->
+<!-- Čísla ani nemusíte psát popořadě. Markdown je umí zobrazit správně, jenom 
+je třeba vždy překontrolovat, že �íslování funguje správně. -->
 
 1. Položka jedna
 1. Položka dvě
 1. Položka tři
-<!-- (Toto zobrazí to samě, jako příklad nadtím.) -->
 
-<!-- Můžete také tvořit podseznamy -->
+<!-- (Toto zobrazí to samé, jako příklad nad tím.) -->
+```
+
+Můžete také tvořit podseznamy:
 
+```md
 1. Položka jedna
 2. Položka dvě
 3. Položka tři
-    * Podpoložka
-    * Podpoložka
+    - Podpoložka
+    - Podpoložka
 4. Položka �tyři
+```
 
-<!-- Existují i zašktávací seznamy. Toto vytvoří HTML checkboxy. -->
+Vytvořit lze i zaškrtávací seznamy. Takto lze vytvořit seznam s HTML checkboxy.
+(Boxy níže bez 'x' jsou nezaškrtnuté checkboxy.)
 
-Boxy níže bez 'x' jsou nezašktrnuté checkboxy.
-- [ ] První úkol
-- [ ] Druhý úkol
-Tento box bude zašktrnutý
+```md
+- [ ] První úkol, který je třeba dokon�it
+- [ ] Druhý úkol na dodělání
+Tento box bude zaškrtnutý
 - [x] Tento úkol byl dokon�en
+```
+
+## Bloky kódu
 
-<!-- Bloky ködu -->
-<!-- Můžete ozna�it kód bloku (který používá <code> element) odsazením pomocí 4
-     mezer, nebo tabu -->
+Bloky kódu můžete ozna�it tak, že řádek odsadíte �tyřmi mezerami nebo pomocí
+tabu. Pro interpretaci kódu parser používá `<code>` element.
 
+```md
     Toto je kód
     StejnÄ› jako toto
+```
 
-<!-- Můžete dokonce přidat další 4 mezery nebo tab pro další odsazení -->
+Pro ještě hlubší odsazení můžete přidat další 4 mezery nebo další tab:
 
+```md
     moje_pole.each do |i|
-        puts i
+      puts i
     end
+```
 
-<!-- Kód na řádku může být ozna�en pomocí zpětných apostrofů ` -->
+Jednořádkový kód můžete zabalit do dvou zpětných apostrofů (`) tak, jako
+kdybyste text normálně stylovali:
 
-Jan nevědel, jak se dělá `go_to()` funkce!
+```md
+Honza neměl tušení, co dělá funkce `go_to()`!
+```
 
-<!-- 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 ! -->
+````md
+```ruby
 def neco
-    puts "Ahoj světe!"
+  puts "Ahoj světe!"
 end
-\`\`\` <!-- zde taky, žádné zpětná lomítka, pouze ``` -->
+```
+````
+
+Text výše nepotřebuje �tyřmezerové odsazení a parser navíc použije zvýraznění
+syntaxe pro zvolený jazyk.
 
-<!-- Text výše nepotřebuje odsazení a navíc GitHub použije zvýraznění ozna�eného
- jazyka. -->
+## Vodorovná �ára (`<hr />`)
 
-<!-- Horizontální �ára (<hr />) -->
-<!-- Horizontální �ára se jednoduše přidá pomocí 3 nebo více hvězdi�ek nebo poml�ek
-s nebo bez mezer. -->
+Vodorovnou oddělovací �áru lze snadno přidat pomocí 3 nebo více hvězdi�ek (nebo
+poml�ek), a to bu� s mezerami mezi jednotlivými znaky, nebo bez nich.
 
+```md
 ***
 ---
 - - -
 ****************
+```
+
+## Odkazy
 
-<!-- Odkazy -->
-<!-- Jedna z nejlepších věcí na Markdownu je, jak jednoduše se dělají odkazy.
-Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a je to. -->
+```md
+<!-- Jedna z nejlepších vlastností Markdownu je, jak snadno lze s jeho pomocí 
+vytvářet odkazy. Text odkazu, který chcete zobrazit vložte do [] a hned za něj 
+v kulatých závorkách () připojte url adresu. -->
 
 [Klikni na mÄ›!](http://test.com/)
 
-<!-- Můžete také přidat jméno linku pomocí uvozovek -->
+
+<!-- V uvozovkách za url můžete přidat název odkazu -->
 
 [Klikni na mÄ›!](http://test.com/ "Odkaz na Test.com")
 
-<!-- Relativní cesty fungují taky -->
+
+<!-- Relativní cesty fungují také -->
 
 [Jdi na hudbu](/hudba/).
 
-<!-- Markdown taktéž podporuje reference odkazů. -->
+
+<!-- Markdown taktéž podporuje referen�ní odkazy -->
 
 [Klikni na tento odkaz][link1] pro více informací!
-[Taky zkontrolujte tento odkaz][neco], když chcete.
+[Taky zkontrolujte tento odkaz][neco], jestli tedy chcete.
 
 [link1]: http://test.com/ "Cool!"
 [neco]: http://neco.czz/ "Dobře!"
 
-<!-- Titulek může být v apostrofech nebo závorkách, nebo vyjmutý úplně. Reference
- může být kdekoliv ve vašem dokumentu a identifikátor může být jakýkoliv, dokud
- je unikátní.-->
+<!-- Titulek v tomto případě může být v jednoduchých uvozovkách, závorkách, nebo 
+zcela vynechaný. Reference může být kdekoliv ve vašem dokumentu a identifikátory 
+mohou být jakékoli, pokud jsou unikátní. -->
+
 
-<!-- Také existuje "implicitní pojmenování", které použije text jako id -->
+<!-- V markdownu existuje rovněž "implicitní pojmenování", které použije text 
+odkazu jako své id -->
 
 [Toto][] je odkaz..
 
 [toto]: http://totojelink.cz/
 
-<!-- Ale toto není zrovna běžné užívané. -->
+<!-- Ale tento způsob se obvykle nepoužívá. -->
+```
 
-<!-- Obrázky -->
-<!-- Obrázky se dělají stejně jako odkazy, ale s vykři�níkem na za�átku -->
+### Obsahy
+
+Kombinace seznamů, odkazů a nadpisů využívají také některé parsery pro
+generování obsahu Markdown souborů. Jako identifikátory slouží jména nadpisů
+psané malými písmeny, které jsou uvozené křížkem (`#`). Víceslovné nadpisy
+bývají propojeny poml�kou (`-`), která někdy nahrazuje i speciální znaky. Jiné
+speciální znaky mohou být vynechány.
+
+```md
+- [Nadpis](#nadpis)
+- [Víceslovný text](#víceslovný-text)
+- [Odstavce](#odstavce)
+  - [Podkapitola <h3 />](#podkapitola-h3-)
+```
+
+V případě obsahů se v každém případě jedná o nadstavbu, která nemusí všude
+fungovat stejnÄ›.
+
+## Obrázky
+
+```md
+<!-- Obrázky se vytváří stejně jako odkazy, ale s vykři�níkem na za�átku -->
 
 ![Toto je atribut alt pro obrázek](http://imgur.com/myimage.jpg "Nepovinný titulek")
 
-<!-- Reference fungují, jak bychom �ekali-->
+<!-- Reference fungují tak, jak bychom �ekali -->
 
 ![Toto je atribut alt][mujobrazek]
 
 [mujobrazek]: relativni/cesta/obrazek.jpg "a toto by byl titulek"
+```
+
+## Ostatní
+
+### Automatické odkazy
+
+```md
+<http://stranka.cz/> 
 
-<!-- Ostatní -->
-<!-- Automatické odkazy -->
+je stejné jako
 
-<http://stranka.cz/> je stejná jako
 [http://stranka.cz/](http://stranka.cz/)
+```
 
-<!-- Automatické odkazy pro emaily-->
+### Automatické odkazy z emailů
 
+```md
 <jmeno@prijmeni.cz>
+```
 
-<!-- Escapování znaků -->
+### Escapování znaků
 
-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\*.
+```md
+Chci napsat *tento text obklopený hvězdi�kami*, ale protože nechci, aby to bylo 
+kurzívou, tak hvězdi�ky vyescapuji `\`: \*tento text bude 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 -->
+### Klávesové zkratky
+
+```md
+<!-- V Markdownu od GitHubu můžete použít tag <kbd> k ozna�ení kláves 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ě,
-     ale když je opravdu chcete: -->
+### Tabulky
 
+Tabulky lze využít pouze v Markdownu od GitHubu a jejich syntax je trošku
+zvláštní. Kdybyste je chtěli použít, vytváří se takto:
+
+```md
 | Sloupec1     | Sloupec2 | Sloupec3      |
 | :----------- | :------: | ------------: |
 | Vlevo zarovn.| Na střed | Vpravo zarovn.|
 | blah         | blah     | blah          |
 
-<!-- nebo, to jde i taky: -->
+<!-- nebo je jde taky zapsat takto: -->
 
 Sloupec 1 | Sloupec2 | Sloupec3
 :-- | :-: | --:
-Ohh toto je tak ošklivé | radši to | nedělejte
+Že se to nedá �íst? | No tak to takhle | radši nedělejte.
+```
 
-<!-- Konec -->
+## Markdownlint
 
-```
+Pro usnadnění práce s Markdownem a s cílem sjednotit styl psaní jeho kódu vznikl
+nástroj `Markdownlint`. Tento nástroj je dostupný i jako plugin pro některé
+editory kódu (IDE) a lze jej použít jako nástroj pro vytváření a ověřování
+validity a �itelnosti Markdownu kódu.
+
+---
+
+## Reference
+
+Pro více informací doporu�ujeme oficiální �lánek o syntaxi od Johna Grubera
+ [zde](http://daringfireball.net/projects/markdown/syntax) a skvělý tahák od
+ Adama Pritcharda [zde](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+
+---
+
+> _Pozn. překladatele:_ Tento text vznikl jako překlad původního �lánku, který
+> pochází z roku 2013 a kombinace původního �eského překladu z roku 2015.
+> Některé informace v tomto �lánku, zejména ty, týkající se specifických
+> vlastností parserů markdownu tak již dnes mohou být zastaralé.
+
+Aktuální informace o specifických vlastnostech různých implementací Markdownu
+můžete nalézt zde (v angli�tině):
 
-Pro více informací, prozkoumejte oficiální �lánek o syntaxi od Johna Grubera
- [zde](http://daringfireball.net/projects/markdown/syntax) a skvělý tahák od Adama Pritcharda [zde](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+- [Markdown pro GitHub](https://docs.github.com/en/github/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax)
+- [Markdown pro GitLab](https://docs.gitlab.com/ee/user/markdown.html)
diff --git a/csharp.html.markdown b/csharp.html.markdown
index b965c2d4..1d7d0881 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c#
+language: C#
 contributors:
     - ["Irfan Charania", "https://github.com/irfancharania"]
     - ["Max Yankov", "https://github.com/golergka"]
@@ -12,9 +12,9 @@ contributors:
 filename: LearnCSharp.cs
 ---
 
-C# is an elegant and type-safe object-oriented language that enables developers to build a variety of secure and robust applications that run on the .NET Framework.
+C# is an elegant and type-safe object-oriented language that enables developers to build a variety of secure and robust applications that run on the cross-platform .NET framework.
 
-[Read more here.](https://docs.microsoft.com/dotnet/csharp/getting-started/introduction-to-the-csharp-language-and-the-net-framework)
+[Read more here.](https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/)
 
 ```c#
 // Single-line comments start with //
@@ -29,7 +29,7 @@ Multi-line comments look like this
 /// </summary>
 /// <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) {}
+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 Library
@@ -48,6 +48,10 @@ using System.Data.Entity;
 
 // Namespaces define scope to organize code into "packages" or "modules"
 // Using this code from another source file: using Learning.CSharp;
+
+// You can also do this in C# 10, it is called file-scoped namespaces.
+// namespace Learning.CSharp;
+
 namespace Learning.CSharp
 {
     // Each .cs file should at least contain a class with the same name as the file.
@@ -154,7 +158,7 @@ on a new line! ""Wow!"", the masses cried";
 
             // Arrays - zero indexed
             // The array size must be decided upon declaration
-            // The format for declaring an array is follows:
+            // The format for declaring an array is
             // <datatype>[] <var name> = new <datatype>[<array size>];
             int[] intArray = new int[10];
 
@@ -168,7 +172,7 @@ on a new line! ""Wow!"", the masses cried";
 
             // Lists
             // Lists are used more frequently than arrays as they are more flexible
-            // The format for declaring a list is follows:
+            // The format for declaring a list is
             // List<datatype> <var name> = new List<datatype>();
             List<int> intList = new List<int>();
             List<string> stringList = new List<string>();
@@ -178,14 +182,14 @@ on a new line! ""Wow!"", the masses cried";
             // Lists don't default to a value;
             // A value must be added before accessing the index
             intList.Add(1);
-            Console.WriteLine("intList @ 0: " + intList[0]);
+            Console.WriteLine("intList at 0: " + intList[0]);
 
-            // Others data structures to check out:
+            // Other data structures to check out:
             // Stack/Queue
             // Dictionary (an implementation of a hash map)
             // HashSet
             // Read-only Collections
-            // Tuple (.Net 4+)
+            // Tuple (.NET 4+)
 
             ///////////////////////////////////////
             // Operators
@@ -218,20 +222,20 @@ on a new line! ""Wow!"", the masses cried";
             |       Bitwise inclusive OR
             */
 
-            // Incrementations
+            // Incrementing
             int i = 0;
-            Console.WriteLine("\n->Inc/Dec-rementation");
-            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
+            Console.WriteLine("\n->Inc/Dec-rement");
+            Console.WriteLine(i++); //Prints "0", i = 1. Post-Increment
+            Console.WriteLine(++i); //Prints "2", i = 2. Pre-Increment
+            Console.WriteLine(i--); //Prints "2", i = 1. Post-Decrement
+            Console.WriteLine(--i); //Prints "0", i = 0. Pre-Decrement
 
             ///////////////////////////////////////
             // Control Structures
             ///////////////////////////////////////
             Console.WriteLine("\n->Control Structures");
 
-            // If statements are c-like
+            // If statements are C-like
             int j = 10;
             if (j == 10)
             {
@@ -284,7 +288,7 @@ on a new line! ""Wow!"", the masses cried";
             // For Each Loop
             // foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>)
             // The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
-            // All the collection types (Array, List, Dictionary...) in the .Net framework
+            // All the collection types (Array, List, Dictionary...) in the .NET framework
             // implement one or both of these interfaces.
             // (The ToCharArray() could be removed, because a string also implements IEnumerable)
             foreach (char character in "Hello World".ToCharArray())
@@ -293,7 +297,7 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             // Switch Case
-            // A switch works with the byte, short, char, and int data types.
+            // A switch works with 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.
@@ -312,7 +316,7 @@ on a new line! ""Wow!"", the masses cried";
                     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
+                // (if you want to do this, you would have to explicitly add a goto case x)
                 case 6:
                 case 7:
                 case 8:
@@ -333,16 +337,25 @@ on a new line! ""Wow!"", the masses cried";
             // 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
+            // TryParse will default to the type's default value 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
+            // The Convert class has a number of methods to facilitate conversions
+
+            // String to int
+
+            // Better
+            bool result = int.TryParse(string, out var integer)
+            int.Parse(string);
+
+            // Not recommended
             Convert.ToString(123);
-            // or
+
+            // Int to string
             tryInt.ToString();
 
             // Casting
@@ -375,6 +388,9 @@ on a new line! ""Wow!"", the masses cried";
             Console.Read();
         } // End main method
 
+        // Available in C# 9 and later, this is basically syntactic sugar for a class. Records are immutable*.
+        public record ARecord(string Csharp);
+
         // CONSOLE ENTRY - A console application must have a main method as an entry point
         public static void Main(string[] args)
         {
@@ -412,7 +428,7 @@ on a new line! ""Wow!"", the masses cried";
 
         // GENERICS
         // The classes for TKey and TValue is specified by the user calling this function.
-        // This method emulates the SetDefault of Python
+        // This method emulates Python's dict.setdefault()
         public static TValue SetDefault<TKey, TValue>(
             IDictionary<TKey, TValue> dictionary,
             TKey key,
@@ -744,7 +760,7 @@ on a new line! ""Wow!"", the masses cried";
             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
+        // Code outside of this class should reference this type as Bicycle.BikeBrand
 
         public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
 
@@ -1299,16 +1315,27 @@ namespace Csharp7
 ```
 
 ## Topics Not Covered
+✨ New, � Old, 🎈 LTS, 🔥 Cross-platform, � Windows-only
 
  * Attributes
- * async/await
+
+ * Asynchronous Programming
+
  * Web Development
- 	* ASP.NET MVC & WebApi (new)
- 	* ASP.NET Web Forms (old)
- 	* WebMatrix (tool)
+    * ASP.NET Core ✨
+
  * Desktop Development
- 	* Windows Presentation Foundation (WPF) (new)
- 	* Winforms (old)
+ 	* Windows Presentation Foundation � 🎈 �
+    * Universal Windows Platform ✨ �
+    * Uno Platform 🔥 ✨
+ 	* WinForms � 🎈 �
+    * Avalonia 🔥 ✨
+    * WinUI ✨ �
+
+* Cross-platform Development
+    * Xamarin.Forms �
+    * MAUI ✨
+
 
 ## Further Reading
 
@@ -1321,4 +1348,4 @@ namespace Csharp7
  * [LINQ Pocket Reference](http://shop.oreilly.com/product/9780596519254.do)
  * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
  * [freeCodeCamp - C# Tutorial for Beginners](https://www.youtube.com/watch?v=GhQdlIFylQ8)
- 
\ No newline at end of file
+ 
diff --git a/css.html.markdown b/css.html.markdown
index b8adc886..948b70ac 100644
--- a/css.html.markdown
+++ b/css.html.markdown
@@ -102,19 +102,24 @@ div.some-parent.class-name { }
 /* 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 { }
+/* for example, when a link hasn't been visited */
+selected:link { }
 
 /* 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 */
+/* or when the cursor hovers over an element */
+selector:hover { }
+
+/* or when a link is clicked on */
+selector:active { }
+
+/* These pseudo classes regarding links should always be written in the above order or the code might not work as expected */
+
+/* Any element that is the first child of its parent */
 selector:first-child {}
 
 /* any element that is the last child of its parent */
diff --git a/cue.html.markdown b/cue.html.markdown
new file mode 100644
index 00000000..a1ff0822
--- /dev/null
+++ b/cue.html.markdown
@@ -0,0 +1,551 @@
+---
+name: CUE
+category: language
+language: CUE
+filename: learncue.cue
+contributors:
+    - ["Daniel Cox", "https://github.com/danielpcox"]
+    - ["Coleman McFarland", "https://github.com/dontlaugh"]
+---
+
+CUE is an expressive (but not Turing-complete) JSON superset, exportable to JSON or YAML. It supports optional types and many other conveniences for working with large configuration sets. The unification engine has roots in logic programming, and as such it provides a ready solution to modern configuration management problems.
+
+When CUE is exported to JSON, values from every processed file are unified into one giant object. Consider these two files:
+
+```yaml
+//name.cue
+name: "Daniel"
+```
+
+```yaml
+//disposition.cue
+disposition: "oblivious"
+```
+
+Now we can unify and export to JSON:
+```bash
+% cue export name.cue disposition.cue
+{
+    "name": "Daniel",
+    "disposition": "oblivious"
+}
+```
+
+Or YAML:
+```bash
+% cue export --out yaml name.cue disposition.cue 
+name: Daniel
+disposition: oblivious
+```
+
+Notice the C-style comments are not in the output. Also notice that the keys in CUE syntax did not require quotes. Some special characters do require quotes:
+
+```yaml
+works_fine: true
+"needs-quotes": true
+```
+
+Unification doesn't just unify across files, it is also a *global merge* of all types and values. The following fails, because the *types* are different.
+
+```yaml
+//string_value.cue
+foo: "baz"
+```
+
+```yaml
+//integer_value.cue
+foo: 100
+```
+
+```bash
+% cue export string_value.cue integer_value.cue 
+foo: conflicting values "baz" and 100 (mismatched types string and int):
+    integer_value.cue:1:6
+    string_value.cue:1:6
+```
+
+But even if we quote the integer, it still fails, because the *values* conflict and there is no way to unify everything into a top-level object.
+
+```yaml
+//string_value.cue
+foo: "baz"
+```
+
+```yaml
+//integer_value.cue
+foo: "100"  // a string now
+```
+
+```bash
+% cue export string_value.cue integer_value.cue
+foo: conflicting values "100" and "baz":
+    integer_value.cue:1:6
+    string_value.cue:1:6
+```
+
+Types in CUE *are* values; special ones that the unification engine knows have certain behavior relative to other values. During unification it requires that values match the specified types, and when concrete values are required, you will get an error if there's only a type. So this is fine:
+
+```yaml
+street: "1 Infinite Loop"
+street: string
+```
+
+While `cue export` produces YAML or JSON, `cue eval` produces CUE. This is useful for converting YAML or JSON to CUE, or for inspecting the unified output in CUE itself. It's fine to be missing concrete values in CUE (though it prefers concrete values when emitting CUE when both are available and match),
+
+```yaml
+//type-only.cue
+amount: float
+```
+
+```bash
+% cue eval type-only.cue
+amount: float
+```
+
+but you *need* concrete values if you want to export (or if you tell `eval` to require them with `-c`):
+
+```bash
+% cue export type-only.cue
+amount: incomplete value float
+```
+
+Give it a value that unifies with the type, and all is well.
+
+```yaml
+//concrete-value.cue
+amount: 3.14
+```
+
+```bash
+% cue export type-only.cue concrete-value.cue
+{
+    "amount": 3.14
+}
+```
+
+The method of unifying concrete values with types that share a common syntax is very powerful, and much more compact than, e.g., JSON Schema. This way, schema, defaults, and data are all expressible in CUE.
+
+Default values may be supplied with a type using an asterisk:
+
+```yaml
+// default-port.cue
+port: int | *8080
+```
+
+```bash
+% cue eval default-port.cue
+port: 8080
+```
+
+Enum-style options ("disjunctions" in CUE) may be specified with an `|` separator:
+
+```yaml
+//severity-enum.cue
+severity: "high" | "medium" | "low"
+severity: "unknown"
+```
+
+```bash
+% cue eval severity-enum.cue
+severity: 3 errors in empty disjunction:
+severity: conflicting values "high" and "unknown":
+    ./severity-enum.cue:1:11
+    ./severity-enum.cue:1:48
+severity: conflicting values "low" and "unknown":
+    ./severity-enum.cue:1:31
+    ./severity-enum.cue:1:48
+severity: conflicting values "medium" and "unknown":
+    ./severity-enum.cue:1:20
+    ./severity-enum.cue:1:48
+```
+
+You can even have disjunctions of structs (not shown, but it works like you'd expect).
+
+CUE has "definitions", and you can use them like you would variable declarations in other languages. They are also for defining struct types. You can apply a struct of type definitions to some concrete value(s) with `&`. Also notice you can say "a list with type #Whatever" using `[...#Whatever]`.
+
+```yaml
+// definitions.cue
+
+#DashboardPort: 1337
+
+configs: {
+    host: "localhost"
+    port: #DashboardPort
+}
+
+#Address: {
+    street: string
+    city: string
+    zip?: int  // ? makes zip optional
+}
+
+some_address: #Address & {
+  street: "1 Rocket Rd"
+  city: "Hawthorne"
+}
+
+more_addresses: [...#Address] & [
+  {street: "1600 Amphitheatre Parkway", city: "Mountain View", zip: "94043"},
+  {street: "1 Hacker Way", city: "Menlo Park"}
+]
+```
+
+```bash
+% cue export --out yaml definitions.cue
+configs:
+  host: localhost
+  port: 1337
+some_address:
+  street: 1 Rocket Rd
+  city: Hawthorne
+more_addresses:
+  - street: 1600 Amphitheatre Parkway
+    city: Mountain View
+    zip: "94043"
+  - street: 1 Hacker Way
+    city: Menlo Park
+```
+
+CUE supports more complex values and validation:
+
+```yaml
+#Country: {
+  name: =~"^\\p{Lu}" // Must start with an upper-case letter
+  pop: >800 & <9_000_000_000 // More than 800, fewer than 9 billion
+}
+
+vatican_city: #Country & {
+  name: "Vatican City"
+  pop: 825
+}
+```
+
+CUE may save you quite a bit of time with all the sugar it provides on top of mere JSON. Here we're defining, "modifying", and validating a nested structure in three lines: (Notice the `[]` syntax used around `string` to signal to the engine that `string` is a constraint, not a string in this case.) 
+
+```yaml
+//paths.cue
+
+// path-value pairs
+outer: middle1: inner: 3
+outer: middle2: inner: 7
+
+// collection-constraint pair
+outer: [string]: inner: int
+```
+
+```bash
+% cue export paths.cue
+{
+    "outer": {
+        "middle1": {
+            "inner": 3
+        },
+        "middle2": {
+            "inner": 7
+        }
+    }
+}
+```
+
+In the same vein, CUE supports "templates", which are a bit like functions of a single argument. Here `Name` is bound to each string key immediately under `container` while the struct underneath *that* is evaluated.
+
+```yaml
+//templates.cue
+
+container: [Name=_]: {
+    name:     Name
+    replicas: uint | *1
+    command:  string
+}
+
+container: sidecar: command: "envoy"
+
+container: service: {
+    command:  "fibonacci"
+    replicas: 2
+}
+```
+
+```bash
+% cue eval templates.cue
+container: {
+    sidecar: {
+        name:     "sidecar"
+        replicas: 1
+        command:  "envoy"
+    }
+    service: {
+        name:     "service"
+        command:  "fibonacci"
+        replicas: 2
+    }
+}
+```
+
+And while we're talking about references like that, CUE supports scoped references.
+
+```yaml
+//scopes-and-references.cue
+v: "top-level v"
+b: v // a reference
+a: {
+    b: v // matches the top-level v
+}
+
+let V = v
+a: {
+    v: "a's inner v"
+    c: v // matches the inner v
+    d: V // matches the top-level v now shadowed by a.v
+}
+av: a.v // matches a's v
+```
+
+```bash
+% cue eval --out yaml scopes-and-references.cue
+```
+
+```yaml
+v: top-level v
+b: top-level v
+a:
+  b: top-level v
+  v: a's inner v
+  c: a's inner v
+  d: top-level v
+av: a's inner v
+```
+
+I changed the order of the keys in the output for clarity. Order doesn't actually matter, and notice that duplicate keys at a given level are *all* unified.
+
+You can hide fields be prefixing them with `_` (quote the field if you need a `_` prefix in an emitted field)
+
+```yaml
+//hiddens.cue
+"_foo": 2
+_foo:   3
+foo:    4
+_#foo:  5
+#foo : 6
+```
+
+```bash
+% cue eval hiddens.cue
+"_foo": 2
+foo:    4
+#foo:   6
+
+% cue export hiddens.cue
+{
+    "_foo": 2,
+    "foo": 4
+}
+```
+
+Notice the difference between `eval` and `export` with respect to definitions. If you want to hide a definition in CUE, you can prefix *that* with `_`.
+
+Interpolation of values and fields:
+
+```yaml
+//interpolation.cue
+
+#expense: 90
+#revenue: 100
+message: "Your profit was $\( #revenue - #expense)"
+
+cat: {
+    type: "Cuddly"
+    "is\(type)":    true
+}
+```
+
+```bash
+% cue export interpolation.cue
+{
+    "message": "Your profit was $10",
+    "cat": {
+        "type": "Cuddly",
+        "isCuddly": true
+    }
+}
+```
+
+Operators, list comprehensions, conditionals, imports...:
+
+```yaml
+//getting-out-of-hand-now.cue
+import "strings"  // we'll come back to this
+
+// operators are nice
+g: 5 / 3         // CUE can do math
+h: 3 * "blah"    // and Python-like string repetition
+i: 3 * [1, 2, 3] // with lists too
+j: 8 < 10        // and supports boolean ops
+
+// conditionals are also nice
+price: number
+// Require a justification if price is too high
+if price > 100 {
+	justification: string
+}
+price:         200
+justification: "impulse buy"
+
+// list comprehensions are powerful and compact
+#items: [ 1, 2, 3, 4, 5, 6, 7, 8, 9]
+comp: [ for x in #items if x rem 2 == 0 {x*x}]
+
+// and... well you can do this too
+#a: [ "Apple", "Google", "SpaceX"]
+for k, v in #a {
+	"\( strings.ToLower(v) )": {
+		pos:     k + 1
+		name:    v
+		nameLen: len(v)
+	}
+}
+```
+
+```bash
+% cue export getting-out-of-hand-now.cue
+```
+
+```json
+{
+    "g": 1.66666666666666666666667,
+    "h": "blahblahblah",
+    "i": [1, 2, 3, 1, 2, 3, 1, 2, 3],
+    "j": true,
+    "apple": {
+        "pos": 1,
+        "name": "Apple",
+        "nameLen": 5
+    },
+    "google": {
+        "pos": 2,
+        "name": "Google",
+        "nameLen": 6
+    },
+    "price": 200,
+    "justification": "impulse buy",
+    "comp": [
+        4,
+        16,
+        36,
+        64
+    ],
+    "spacex": {
+        "pos": 3,
+        "name": "SpaceX",
+        "nameLen": 6
+    }
+}
+```
+
+At this point it's worth mentioning that CUE may not be Turing-complete, but it *is* powerful enough for you to shoot yourself in the foot, so do try to keep it clear. It's easy to go off the deep end and make your config *harder* to work with if you're not careful. Make use of those comments, at least, and/or...
+
+To that end, CUE supports packages and modules. CUE files are standalone by default, but if you put a package clause at the top, you're saying that file is unifiable with other files "in" the same package.
+
+```yaml
+//a.cue
+package config
+
+foo: 100
+bar: int
+```
+
+```yaml
+//b.cue
+package config
+
+bar: 200
+```
+
+If you create these two files in a new directory and run `cue eval` (no arguments), it will unify them like you'd expect. It searches the current directory for .cue files, and if they all have the same package, they will be unified.
+
+Packages are more clear in the context of "modules". Modules are the *largest* unit of organization. Basically every time you have a project that spans multiple files, you should create a module and name it with something that looks like the domain and path of a URL, e.g., `example.com/something`. When you import anything from this module, even from *within* the module, you must do so using the fully-qualified module path which will be prefixed with this module name.
+
+You can create a new module like so:
+
+```bash
+mkdir mymodule && cd mymodule
+cue mod init example.com/mymodule
+```
+
+This creates a `cue.mod/` subdirectory within that `mymodule` directory, and `cue.mod/` contains the following file and subdirectories:
+
+- `module.cue`  (which defines your module name, in this case with `module: "example.com/mymodule"`)
+- pkg/
+- gen/
+- usr/
+
+For a different perspective on this and details about what's in there, see https://cuelang.org/docs/concepts/packages/. For my purposes here, I'll say you don't need to think about the contents of this directory *at all*, except that your module name will be the prefix for all imports within your module.
+
+Where will your module file hierarchy go? All files and directories for your module are rooted in `mymodule/`, the directory that also contains `cue.mod/`. If you want to import a package, you'll prefix it with `example.com/mymodule`, followed by a relative path rooted in `mymodule/`.
+
+To make it concrete, consider the following:
+
+```
+mymodule
+├── config
+│   ├── a.cue
+│   └── b.cue
+├── cue.mod
+│   ├── module.cue
+│   ├── pkg
+│   └── usr
+└── main.cue
+```
+
+`cue.mod/` and the files underneath it were created by `cue mod init example.com/mymodule`. I then created the `config/` subdirectory with `a.cue` and `b.cue` inside. Then I created `main.cue` to act as my top-level file to rule them all.
+
+Running `eval` (no arguments) checks to see if there's only one package in all .cue files in the current directory, and if so, it unifies them and outputs the result. In this case, there's only main.cue with package `main` (nothing special about "main" there, it just seemed appropriate), so that's the one.
+
+```bash
+% cue eval
+configuredBar: 200
+```
+
+The contents of `main.cue` is:
+
+```yaml
+//main.cue
+
+package main
+import "example.com/mymodule/config"
+
+configuredBar: config.bar
+```
+
+`config/a.cue` and `config/b.cue` are files from earlier, except now they've both got `package config` at the top:
+
+```yaml
+//a.cue
+package config
+
+foo: 100
+bar: int
+```
+
+```yaml
+//b.cue
+package config
+
+bar: 200
+```
+
+So there you go. If you want to verify that it's actually unifying both files under `config/`, you can change `bar: int` to `bar: string` in `a.cue` and re-run `cue eval` to get a nice type error:
+
+```
+cue eval                                                                     2022-01-06 17:51:24
+configuredBar: conflicting values string and 200 (mismatched types string and int):
+    ./config/a.cue:4:6
+    ./config/b.cue:3:6
+    ./main.cue:5:16
+```
+
+That's it for now. I understand there are more package management features coming in the future and the design decisions around `cue.mod` are looking ahead to that.
+
+Finally, CUE has built-in modules with powerful functionality. We saw one of these earlier, when we imported "strings" and used `strings.ToLower`. Imports without fully-qualified module names are assumed to be built-ins. The full list and documentation for each is here: https://pkg.go.dev/cuelang.org/go/pkg
+
+This has been a condensation of the official docs and tutorials, so go give the source material some love: https://cuelang.org/docs/tutorials/
diff --git a/dart.html.markdown b/dart.html.markdown
index b215474a..ab3c07d2 100644
--- a/dart.html.markdown
+++ b/dart.html.markdown
@@ -45,7 +45,7 @@ const CONSTANT_VALUE = "I CANNOT CHANGE";
 CONSTANT_VALUE = "DID I?"; //Error
 /// Final is another variable declaration that cannot be change once it has been instantiated. Commonly used in classes and functions
 /// `final` can be declared in pascalCase.
-final finalValue = "value cannot be change once instantiated";
+final finalValue = "value cannot be changed once instantiated";
 finalValue = "Seems not"; //Error
 
 /// `var` is another variable declaration that is mutable and can change its value. Dart will infer types and will not change its data type
@@ -77,13 +77,12 @@ example1() {
   nested1();
 }
 
-/// Anonymous functions don't include a name but can take number of arguments
+/// Anonymous functions don't include a name
 example2() {
   //// Explicit return type.
-  nested1(Function<void> fn) {
+  nested1(void Function() fn) {
     fn();
   }
-
   nested1(() => print("Example2 nested 1"));
 }
 
@@ -717,6 +716,6 @@ main() {
 ## Further Reading
 
 Dart has a comprehensive web-site. It covers API reference, tutorials, articles and more, including a
-useful Try Dart online.
-[https://www.dartlang.org](https://www.dartlang.org)
-[https://try.dartlang.org](https://try.dartlang.org)
+useful DartPad (a cloud-based Dart coding playground).
+[https://dart.dev/](https://dart.dev)
+[https://dartpad.dev/](https://dartpad.dev)
diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown
index e3f64a00..d0a62c66 100644
--- a/de-de/asciidoc-de.html.markdown
+++ b/de-de/asciidoc-de.html.markdown
@@ -4,15 +4,19 @@ contributors:
     - ["Ryan Mavilia", "http://unoriginality.rocks/"]
 translators:
   - ["Dennis Keller", "https://github.com/denniskeller"]
-filename: asciidoc-de.md
+filename: asciidoc-de.adoc
 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.
+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.
+Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen
+mindestens eine Leerzeile vom Inhalt versetzt sein.
 
 Nur Titel
 
@@ -104,7 +108,8 @@ Um eine nummerierte Liste zu erstellen, verwendest du Punkte.
 . item 3
 ```
 
-Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
+Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise
+Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
 
 ```
 * foo 1
diff --git a/de-de/brainfuck-de.html.markdown b/de-de/brainfuck-de.html.markdown
index dd62dd67..09f01cd2 100644
--- a/de-de/brainfuck-de.html.markdown
+++ b/de-de/brainfuck-de.html.markdown
@@ -1,11 +1,11 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["urfuchs", "https://github.com/urfuchs"]
-filename: brainfuck-de
+filename: brainfuck-de.bf
 lang: de-de
 
 ---
diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown
index 87e75ad6..cca54c30 100644
--- a/de-de/c++-de.html.markdown
+++ b/de-de/c++-de.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-de.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown
index f9090518..3a726b83 100644
--- a/de-de/c-de.html.markdown
+++ b/de-de/c-de.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c
+language: C
 filename: learnc-de.c
 contributors:
     - ["caminsha", "https://github.com/caminsha"]
diff --git a/de-de/crystal-de.html.markdown b/de-de/crystal-de.html.markdown
new file mode 100644
index 00000000..535267ee
--- /dev/null
+++ b/de-de/crystal-de.html.markdown
@@ -0,0 +1,561 @@
+---
+language: crystal
+contributors:
+    - ["Vitalii Elenhaupt", "http://veelenga.com"]
+    - ["Arnaud Fernandés", "https://github.com/TechMagister/"] 
+translators:
+    - ["caminsha", "https://github.com/caminsha"]
+filename: learncrystal-de.cr
+lang: de-de
+---
+
+```crystal
+
+# Das ist ein Kommentar
+
+# Alles ist ein Objekt
+nil.class # => Nil
+100.class # => Int32
+true.class # => Bool
+
+# Falschwerte sind: nil, false und Nullpointer
+!nil    # => true    : Bool
+!false  # => true    : Bool
+!0      # => false   : Bool
+
+# Integer
+
+1.class # => Int32
+
+# Fünf vorzeichenbehaftete Ganzzahlen
+1_i8.class   # =>    Int8
+1_i16.class  # =>    Int16
+1_i32.class  # =>    Int32
+1_i64.class  # =>    Int64
+1_i128.class # =>    Int128
+
+# Fünf vorzeichenlose Ganzzahlen
+1_u8.class   # =>    UInt8
+1_u16.class  # =>    UInt16
+1_u32.class  # =>    UInt32
+1_u64.class  # =>    UInt64
+1_u128.class # =>    UInt128
+
+
+2147483648.class            # => Int64
+9223372036854775808.class   # => UInt64
+
+# Binäre Zahlen
+0b1101 # => 13  : Int32
+
+# Oktalzahlen
+0o123 # => 83   : Int32
+
+# Hexadezimalzahlen
+0xFE012D # => 16646445 : Int32
+0xfe012d # => 16646445 : Int32
+
+# Gleitkommazahlen (floats)
+
+1.0.class   # => Float64
+
+# Es gibt zwei Typen von Gleitkommazahlen
+
+1.0_f32.class   # => Float32
+1_f32.class     # => Float32
+
+1e10.class      # => Float64
+1.5e10.class    # => Float64
+1.5e-7.class    # => Float64
+
+
+# Chars (einzelne Zeichen)
+
+'a'.class   # => Char
+
+# Oktale Schreibweise
+'\101'      # => 'A' : Char
+
+# Unicode Schreibweise
+'\u0041'    # => 'A' : Char
+
+# Strings (Zeichenketten)
+"s".class   # => String
+
+# Strings sind unveränderlich
+s = 'hello, "   # => "hello, "          : String
+s.object_id     # => 1234667712         : UInt64
+s += "Crystal"  # => "hello, Crystal"   : String
+s.object_id     # => 142528472          : UInt64
+
+# Interpolation wird unterstützt
+"sum = #{1 + 2}"    # => "sum = 3"  : String
+
+# Mehrzeilige Strings
+" Dies ist ein
+    mehrzeiliger String."
+
+# String mit doppeltem Anführungszeichen
+%(hello "world")    # => "hello \"world\""
+
+# Symbole
+# Unveränderbare, wiederverwendbare Konstanten, welche intern als Int32 Integer
+# Werte repräsentiert werden.
+# Symbole werden oft anstelle von Strings verwendet, um bestimmte Werte zu bestimmen.
+
+: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)
+
+# Leere Arrays sollten einen Typen definieren
+[]                  # => Syntaxfehler: für leere Arrays,
+                    # verwende `[] of ElementType`
+[] of Int32         # => [] : Array(Int32)
+Array(Int32).new    # => [] : Array(Int32)
+
+# Arrays können indiziert werden
+array = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5] : Array(Int32)
+array[0]                # => 1               : Int32
+array[10]               # führt zu einem IndexError
+array[-6]               # führt zu einem IndexError
+array[10]?              # => nil             : (Int32 | Nil)
+array[-6]?              # => nil             : (Int32 | Nil)
+
+# Starte am Ende des Arrays
+array[-1]               # => 5
+
+# Mit einem Startindex und einer Länge
+array[2, 4]             # => [3, 4, 5]
+
+# oder mit einem Bereich
+array[1..3]             # => [2, 3, 4]
+
+# Füge etwas zu einem Array hinzu
+array << 6              # => [1, 2, 3, 4, 5, 6]
+
+# Entferne Einträge am Ende des Arrays
+array.pop               # => 6
+array                   # => [1, 2, 3, 4, 5]
+
+# Entferne ersten Eintrag im Array
+array.shift             # => 1
+array                   # => [2, 3, 4, 5]
+
+# Überprüfe, ob ein Element in einem Array existiert
+array.includes? 3       # => true
+
+# Spezielle Syntax für String-Arrays und Symbol-Arrays
+%w(one two three)   # => ["one", "two", "three"]    : Array(String)
+%i(one two three)   # 0> [:one, :two, :three]       : Array(Symbol)
+
+# Es gibt auch für andere Arrays eine spezielle Syntax, wenn die Methoden
+# `.new` und `#<<` definiert werden.
+set = Set{1, 2, 3}  # => [1, 2, 3]
+set.class           # => Set(Int32)
+
+# Das obere ist äquivalent zu:
+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)
+
+# Leere Hashes sollten einen Typen spezifieren
+{}                      # Syntaxfehler
+{} of Int32 => Int32    # {}
+Hash(Int32, Int32).new  # {}
+
+# Hashes können schnell mit dem Key nachgeschaut werden
+hash = {"color" => "green", "number" => 5}
+hash["color"]           # => "green"
+hash["no_such_key"]     # => Fehlender hash key: "no_such_key" (KeyError)
+hash["no_such_key"]?    # => nil
+
+# Überprüfe die Existenz eines Hashkeys
+hash.has_key? "color"   # => true
+
+# Spezielle Schreibweise für Symbol- und Stringkeys
+{key1: 'a', key2: 'b'}      # {:key1 => 'a', :key2 => 'b'} 
+{"key1": 'a', "key2": 'b'}  # {"key1" => 'a', "key2" => 'b'}
+
+# Die spezielle Syntax für Hash-Literale gibt es auch für andere Typen, sofern
+# diese die Methoden `.new` und `#[]=` Methoden definieren.
+class MyType
+    def []=(key, value)
+        puts "do stuff"
+    end
+end
+
+MyType{"foo" => "bar"}
+
+# Das obere ist äquivalent zu:
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+# Ranges (Bereiche)
+1..10                   # => Range(Int32, Int32)
+Range.new(1,10).class   # => Range(Int32, Int32)
+
+# Ranges können inklusiv oder exklusiv sein.
+(3..5).to_a     # => [3, 4, 5]
+(3...5).to_a    # => [3, 4]
+
+# Überprüfe, ob ein Range einen Wert enthält oder nicht.
+(1..8).includes? 2  # => true
+
+# Tupel sind unveränderliche, Stack-zugewiese Folgen von Werten mit fester 
+# Größe und möglicherweise unterschiedlichen Typen
+{1, "hello", 'x'}.class # => Tuple(Int32, String, Char)
+
+# Erhalte den Wert eines Tupels über den Index
+tuple = {:key1, :key2}
+tuple[1] # => :key2
+tuple[2] # syntax error: Index out of bound
+
+# Können auf mehrere Variablen erweitert werden
+a, b, c = {:a, 'b', "c"}
+a   # => :a
+b   # => 'b'
+c   # => "c"
+
+# Procs repräsentieren ein Funktionspointer mit einem optionalen Kontext.
+# Normalerweise wird ein Proc mit einem proc-Literal erstellt.
+proc = ->(x : Int32) { x.to_s }
+proc.class  # => Print(Int32, String)
+# Außerdem kann man auch mit der Methode `new` ein Proc erstellen.
+Proc(Int32, String).new { |x| x.to_s }
+
+# Rufe ein Proc auf mit der Methode `call`
+proc.call 10    # => "10"
+
+# Kontrollstatements
+
+if true
+    "if statement"
+elsif false
+    "else-f, optional"
+else
+    "else, auch optional"
+end
+
+puts "if as a suffix" if true # => if as a suffix
+
+# If als Ausdruck
+a = if 2 > 1
+        3
+    else
+        4
+    end
+
+a # => 3
+
+# Bedingter ternärer Ausdruck
+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..."
+
+# Schleifen
+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
+
+# Der bevorzugte Weg, ist `each` zu verwenden.
+(1..3).each do |index|
+    puts "Index: #{index}"
+end
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Der Typ der Variablen hängt vom Typen innerhalb der Kontrollanweisung ab
+if a < 3
+    a = "hello"
+else
+    a = true
+end
+typeof a    # => (Bool | String)
+
+if a && b
+    # Hier wird garantiert, dass weder a noch b vom Typ Nil sind
+end
+
+if a.is_a? String
+    a.class # => String
+end
+
+# Funktionen
+def double(x)
+    x * 2
+end
+
+# Funktionen geben implizit den Wert der letzten Anweisung zurück
+# Dies ist auch bei anderen Blöcken der Fall.
+double(2)       # => 4
+
+# Klammern müssen nicht gesetzt werden, wenn der Aufruf eindeutig ist
+double 3        # => 6
+double double 3 # => 12
+
+def sum(x, y)
+    x + y
+end
+
+# Funktionsargumente werden mit einem Komma separiert.
+sum 3, 4            # => 7
+
+sum sum(3, 4), 5    # => 12
+
+# yield
+# Alle Methoden haben einen impliziten, optionalen Blockparameter.
+# Dieser kann mit dem Schlüsselwort `yield` aufgerufen werden.
+
+def surround
+    puts '{'
+    yield
+    puts '}'
+end
+
+surround { puts "Hallo Welt" }
+
+# {
+# Hallo Welt 
+# }
+
+# Du kannst ein Block einer Funktion übergeben.
+# "&" kennzeichnet eine Referenz zu einem übergebenen Block
+def guests(&block)
+    block.call "some_argument"
+end
+
+# Du kannst eine Liste von Argumenten mitgeben, welche zu einem Array
+# umgewandelt werden.
+# Hierfür ist der Splat-Operator ("*")
+def guests(*array)
+    array.each { |guest| puts guest }
+end
+
+# Wenn eine Methode ein Array zurückgibt, kann destrukturiende Zuordnung
+# verwendet werden.
+def foods
+    ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast   # => "pancake"
+dinner      # => "quesadilla"
+
+# Gemäß der Konvention enden alle Methoden, welchen einen Boolean zurückgeben
+# mit einem Fragezeichen.
+5.even? # false
+5.odd?  # true
+
+# Und wenn eine Methode mit einem Ausrufezeichen endet, macht sie etwas
+# destruktives. Zum Beispiel wird der Aufrufer verändert. Einige Methoden haben
+# eine !-Version, um eine Änderung zu machen und eine Nicht-!-Version, welche
+# lediglich eine neue veränderte Version zurückgibt.
+
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald"    # => "Donald Mifflin"
+company_name    # => "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name    # => "Donald Mifflin"
+
+# definiere eine Klasse mit dem Schlüsselwort `class`.
+class Human
+
+# eine Klassenvariable. Diese wird mit allen Instanzen dieser Klasse geteilt.
+    @@species = "H. sapiens"
+
+    # type of name is String
+    @name: String
+
+    # Grundlegender Intialisierer
+    # Weise das Argument der Instanz-Variable "name" zu
+    # Wenn kein Alter angegeben wird, wird der Default (hier 0) genommen.
+    def initialize(@name, @age = 0)
+    end
+
+    # Einfache Setter-Methode
+    def name=(name)
+        @name = name
+    end
+
+    # einfache Getter-Methode
+    def name
+        @name
+    end
+
+    # Die obere Funktionalität kann mit der property-Methode gekapselt werden:
+    property :name
+
+    # Getter/Setter-Methoden können auch individuell erstellt werden:
+    getter :name
+    setter :name
+    
+    # eine Klassenmethode verwendet `self` um sich von Instanzmethoden zu 
+    # unterscheiden. Diese kann lediglich von einer Klasse aufgerufen werden,
+    # nicht von einer Instanz.
+    def self.say(msg)
+        puts msg
+    end
+
+    def species
+        @@species
+    end
+end
+
+
+# Eine Klasse instanzieren
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Lass uns ein paar Methoden aufrufen
+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"
+
+# Rufe die Klassenmethode auf
+Human.say("Hi")     # => gibt Hi aus und gibt `nil` zurück
+
+# Variablen, welche mit @ starten, sind im Scope der Instanz
+class TestClass
+    @var = "Ich bin eine Instanzvariable"
+end
+
+# Variablen, welche mit @@ starten, sind im Scope der Klasse
+class TestClass
+    @@var = "Ich bin eine Klassenvariable"
+end
+
+# Variablen, welche mit einem Großbuchstaben starten, sind Konstanten.
+Var = "Ich bin eine Konstante"
+Var = "Ich kann nicht aktualisiert werden." # Die Konstante Var wurde bereits
+                                            # initialisiert.
+
+# In Crystal ist Class auch ein Objekt. Dadurch können Klassen Instanzvariablen
+# haben. Klassenvariablen werden mit der Klasse und allen Subklassen geteilt.
+
+# Basisklasse
+class Human
+    @@foo = 0
+
+    def self.foo
+        @@foo
+    end
+
+    def self.foo=(value)
+        @@foo = value
+    end
+end
+
+# abgeleitete Klasse
+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
+
+# Wenn ein Modul mit include eingeschlossen wird, so werden die Methoden an die
+# Instanzen gebunden.
+# Wenn eine Klasse mit einem Modul erweitert wird, so werden die Methoden an die
+# Klasse selbst gebunden.
+
+class Person 
+    include ModuleExample
+end
+
+class Book
+    extend ModuleExample
+end
+
+Person.foo      # => undefinierte Methode 'foo' für Person:Class
+Person.new.foo  # => 'foo'
+Book.foo        # => 'foo'
+Book.new.foo    # => undefinierte Methode für Book
+
+# Ausnahmebehandlung
+
+# Definiere eine neue Ausnahme
+class MyException < Exception
+end
+
+# Definiere eine weitere Ausnahme
+class MyAnotherException < Exception; end
+
+ex = begin
+    raise MyException.new
+rescue ex1 : IndexError
+    "ex1"
+rescue ex2 : MyException | MyAnotherException
+    "ex2"
+rescue ex3 : Exception
+    "ex3"
+rescue ex4 # fange alle Ausnahmen ab
+    "ex4"
+end
+
+ex # => "ex2"
+```
+
+
+## Weitere Unterlagen
+
+- [offizielle Dokumentation, englisch](https://crystal-lang.org/)
diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown
index 78bb0a6b..662c2e76 100644
--- a/de-de/csharp-de.html.markdown
+++ b/de-de/csharp-de.html.markdown
@@ -1,890 +1,890 @@
----

-language: c#

-contributors:

-    - ["Irfan Charania", "https://github.com/irfancharania"]

-    - ["Max Yankov", "https://github.com/golergka"]

-    - ["Melvyn Laïly", "http://x2a.yt"]

-    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]

-translators:

-    - ["Frederik Ring", "https://github.com/m90"]

-filename: LearnCSharp-de.cs

-lang: de-de

----

-C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden.

-

-[Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx)

-

-```c#

-// Einzeilige Kommentare starten mit zwei Schrägstrichen: //

-/*

-Mehrzeile Kommentare wie in C Schrägstrich / Stern

-*/

-/// <summary>

-/// XML-Kommentare können zur automatisierten Dokumentation verwendet werden

-/// </summary>

-

-// Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt

-using System;

-using System.Collections.Generic;

-using System.Data.Entity;

-using System.Dynamic;

-using System.Linq;

-using System.Linq.Expressions;

-using System.Net;

-using System.Threading.Tasks;

-using System.IO;

-

-// definiert einen Namespace um Code in "packages" zu organisieren

-namespace Learning

-{

-    // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei

-    // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu

-    // handhaben führt aber unweigerlich ins Chaos (wirklich)!

-    public class LearnCSharp

-    {

-        // Zuerst erklärt dieses Tutorial die Syntax-Grundlagen,

-        // wenn du bereits Java oder C++ programmieren kannst:

-        // lies bei "Interessante Features" weiter!

-        public static void Syntax()

-        {

-            // Mit Console.WriteLine kannst du einfachen Text ausgeben:

-            Console.WriteLine("Hallo Welt");

-            Console.WriteLine(

-                "Integer: " + 10 +

-                " Double: " + 3.14 +

-                " Boolean: " + true);

-

-            // Console.Write erzeugt keinen Zeilenumbruch

-            Console.Write("Hallo ");

-            Console.Write("Welt");

-

-            ///////////////////////////////////////////////////

-            // Typen & Variablen

-            ///////////////////////////////////////////////////

-

-            // Deklariere eine Variable mit <Typ> <Name>

-

-            // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl

-            // (-128 <= sbyte <= 127)

-            sbyte fooSbyte = 100;

-

-            // Byte - Vorzeichenlose 8-Bit Ganzzahl

-            // (0 <= byte <= 255)

-            byte fooByte = 100;

-

-            // Short - 16-Bit Ganzzahl

-            // Vorzeichenbehaftet - (-32,768 <= short <= 32,767)

-            // Vorzeichenlos - (0 <= ushort <= 65,535)

-            short fooShort = 10000;

-            ushort fooUshort = 10000;

-

-            // Integer - 32-bit Ganzzahl

-            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)

-            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)

-

-            // Long - 64-bit Ganzzahl

-            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)

-            // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder

-            // uint behandelt. Ein nachgestelltes L markiert den Wert als long

-            // oder ulong.

-

-            // Double - Double-precision 64-bit IEEE 754 Fließkommazahl

-            double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen

-

-            // Float - Single-precision 32-bit IEEE 754 Fließkommazahl

-            float fooFloat = 234.5f; // Genauigkeit: 7 Stellen

-            // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ

-            // float handelt

-

-            // Decimal - ein 128-Bit-Datentyp mit größerer Genauigkeit als

-            // andere Fließkommatypen, und somit bestens geeignet für

-            // die Berechnung von Geld- und Finanzwerten

-            decimal fooDecimal = 150.3m;

-

-            // Boolean - true & false

-            bool fooBoolean = true; // oder false

-

-            // Char - Ein einzelnes 16-Bit Unicode Zeichen

-            char fooChar = 'A';

-

-            // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die

-            // alle Werttypen sind, ist String ein Referenztyp. Strings sind

-            // somit nullable, Werttypen sind dies nicht.

-            string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu";

-            Console.WriteLine(fooString);

-

-            // Jeder Buchstabe eines Strings kann über seinen Index

-            // referenziert werden:

-            char charFromString = fooString[1]; // => 'e'

-            // Strings sind unveränderlich:

-            // `fooString[1] = 'X';` funktioniert nicht

-

-            // Ein Vergleich zweier Strings, unter Berücksichtigung der

-            // aktuellen, sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c

-            // in deutschsprachigen Umgebungen), und ohne Beachtung von

-            // Groß- und Kleinschreibung:

-            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);

-

-            // Formatierung, genau wie "sprintf"

-            string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2);

-

-            // Datumsangaben und Formatierung

-            DateTime fooDate = DateTime.Now;

-            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));

-

-            // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String

-            // schreiben. Um " zu maskieren benutzt man ""

-            string bazString = @"Hier geht es

-zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";

-

-            // Die Keywords const oder readonly kennzeichnen eine

-            // unveränderliche Variable/Konstante. Die Werte von Konstanten

-            // werden übrigens bereits zur Compile-Zeit berechnet.

-            const int HOURS_I_WORK_PER_WEEK = 9001;

-

-            ///////////////////////////////////////////////////

-            // Datenstrukturen

-            ///////////////////////////////////////////////////

-

-            // Arrays - Index beginnt bei Null

-            // Die Größe des Arrays wird bei der Deklaration festgelegt.

-            // Die syntaktische Struktur um ein neues Array zu erzeugen sieht

-            // folgendermaßen aus:

-            // <datatype>[] <varname> = new <datatype>[<array size>];

-            int[] intArray = new int[10];

-

-            // Arrays können auch über ein Array-Literal deklariert werden:

-            int[] y = { 9000, 1000, 1337 };

-

-            // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element

-            Console.WriteLine("intArray @ 0: " + intArray[0]);

-            // Arrays sind veränderbar

-            intArray[1] = 1;

-

-            // Listen

-            // Durch ihre größere Flexibilität kommen Listen in C# weit

-            // häufiger zum Einsatz als Arrays. Eine Liste wird so deklariert:

-            // List<datatype> <varname> = new List<datatype>();

-            List<int> intList = new List<int>();

-            List<string> stringList = new List<string>();

-            List<int> z = new List<int> { 9000, 1000, 1337 };

-            // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen"

-

-            // Listen haben keinen Default-Wert.

-            // Bevor auf einen Index zugegriffen werden kann, muss dieser

-            // auch gesetzt worden sein:

-            intList.Add(1);

-            Console.WriteLine("intList @ 0: " + intList[0]);

-

-            // Andere interessante Datenstrukturen sind:

-            // Stack/Queue

-            // Dictionary (entspricht einer Hash Map)

-            // HashSet

-            // Read-only Collections

-            // Tuple (.Net 4+)

-

-            ///////////////////////////////////////

-            // Operatoren

-            ///////////////////////////////////////

-            Console.WriteLine("\n->Operatoren");

-

-            // kurze Schreibweise um mehrere Deklarationen zusammenzufassen:

-            // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!)

-            int i1 = 1, i2 = 2;

-

-            // Arithmetik funktioniert wie erwartet:

-            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3

-

-            // Modulo

-            Console.WriteLine("11%3 = " + (11 % 3)); // => 2

-

-            // Vergleiche

-            Console.WriteLine("3 == 2? " + (3 == 2)); // => false

-            Console.WriteLine("3 != 2? " + (3 != 2)); // => true

-            Console.WriteLine("3 > 2? " + (3 > 2)); // => true

-            Console.WriteLine("3 < 2? " + (3 < 2)); // => false

-            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true

-            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true

-

-            // Bitweise Operatoren

-            /*

-            ~       Unäres bitweises NICHT

-            <<      Verschieben nach links

-            >>      Verschieben nach rechts

-            &       Bitweises UND

-            ^       Bitweises exklusives ODER

-            |       Bitweises inklusives ODER

-            */

-

-            // Inkremente

-            int i = 0;

-            Console.WriteLine("\n->Inkrement / Dekrement");

-            Console.WriteLine(i++); //i = 1. Post-Inkrement

-            Console.WriteLine(++i); //i = 2. Pre-Inkrement

-            Console.WriteLine(i--); //i = 1. Post-Dekrement

-            Console.WriteLine(--i); //i = 0. Pre-Dekrement

-

-            ///////////////////////////////////////

-            // Kontrollstrukturen

-            ///////////////////////////////////////

-            Console.WriteLine("\n->Kontrollstrukturen");

-

-            // If-Statements funktionieren wie in C

-            int j = 10;

-            if (j == 10)

-            {

-                Console.WriteLine("Ich werde ausgegeben");

-            }

-            else if (j > 10)

-            {

-                Console.WriteLine("Ich nicht");

-            }

-            else

-            {

-                Console.WriteLine("Ich leider auch nicht");

-            }

-

-            // Ternärer Operator

-            // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben:

-            // <condition> ? <true> : <false>

-            int zumVergleich = 17;

-            string isTrue = zumVergleich == 17 ? "Ja" : "Nein";

-

-            // while-Schleife

-            int fooWhile = 0;

-            while (fooWhile < 100)

-            {

-                // Wird 100mal wiederholt, fooWhile 0->99

-                fooWhile++;

-            }

-

-            // do-while-Schleife

-            int fooDoWhile = 0;

-            do

-            {

-                // Wird 100mal wiederholt, fooDoWhile 0->99

-                fooDoWhile++;

-            } while (fooDoWhile < 100);

-

-            //for-Schleifen => for(<start_statement>; <conditional>; <step>)

-            for (int fooFor = 0; fooFor < 10; fooFor++)

-            {

-                // Wird 10mal wiederholt, fooFor 0->9

-            }

-

-            // foreach-Schleife

-            // Die normale Syntax für eine foreach-Schleife lautet:

-            // foreach(<iteratorType> <iteratorName> in <enumerable>)

-            // foreach kann mit jedem Objekt verwendet werden das IEnumerable

-            // oder IEnumerable<T> implementiert. Alle Auflistungs-Typen

-            // (Array, List, Dictionary...) im .NET Framework implementieren

-            // eines dieser beiden Interfaces.

-

-            foreach (char character in "Hallo Welt".ToCharArray())

-            {

-                // Ein Durchgang für jedes Zeichen im String

-            }

-            // (ToCharArray() könnte man hier übrigens auch weglassen,

-            // da String IEnumerable bereits implementiert)

-

-            // Switch Struktur

-            // Ein Switch funktioniert mit byte, short, char und int Datentypen.

-            // Auch Aufzählungstypen können verwendet werden, genau wie

-            // die Klasse String, und ein paar Sonderklassen, die Wrapper für

-            // Primitives sind: Character, Byte, Short und Integer

-            int month = 3;

-            string monthString;

-            switch (month)

-            {

-                case 1:

-                    monthString = "Januar";

-                    break;

-                case 2:

-                    monthString = "Februar";

-                    break;

-                case 3:

-                    monthString = "März";

-                    break;

-                // Man kann für mehrere Fälle auch das selbe Verhalten

-                // definieren. Jeder Block muss aber mit einem break-Statement

-                // abgeschlossen werden. Einzelne Fälle können über

-                // `goto case x` erreicht werden

-                case 6:

-                case 7:

-                case 8:

-                    monthString = "Sommer!!";

-                    break;

-                default:

-                    monthString = "Irgendein anderer Monat";

-                    break;

-            }

-

-            ///////////////////////////////////////

-            // Umwandlung von Datentypen und Typecasting

-            ///////////////////////////////////////

-

-            // Umwandlung

-

-            // von String nach Integer

-            // bei einem Fehler wirft diese Code eine Exception

-            int.Parse("123"); //gibt die Ganzzahl 123 zurück

-

-            // TryParse gibt bei einem Fehler den Default-Wert zurück

-            // (im Fall von int: 0)

-            int tryInt;

-            if (int.TryParse("123", out tryInt)) // gibt true oder false zurück

-            {

-                Console.WriteLine(tryInt);       // 123

-            }

-

-            // von Integer nach String

-            // Die Klasse Convert stellt Methoden zur Konvertierung von

-            // unterschiedlichsten Daten zur Verfügung:

-            Convert.ToString(123); // "123"

-            // oder

-            tryInt.ToString(); // "123"

-        }

-

-        ///////////////////////////////////////

-        // Klassen

-        ///////////////////////////////////////

-        public static void Classes()

-        {

-

-            // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen

-            Bicycle trek = new Bicycle();

-

-            // So werden Methoden der Instanz aufgerufen

-            trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen

-            trek.Cadence = 100;

-

-            // ToString ist eine Konvention über die man üblicherweiser

-            // Informationen über eine Instanz erhält

-            Console.WriteLine("Infos zu trek: " + trek.ToString());

-

-            // Wir instantiieren ein neues Hochrad

-            PennyFarthing funbike = new PennyFarthing(1, 10);

-            Console.WriteLine("Infos zu funbike: " + funbike.ToString());

-

-            Console.Read();

-        } // Ende der Methode main

-

-        // Main als Konsolenstartpunkt

-        // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen

-        public static void Main(string[] args)

-        {

-            OtherInterestingFeatures();

-        }

-

-        ///////////////////////////////////////

-        // Interessante Features

-        ///////////////////////////////////////

-

-        // Methodensignaturen

-

-        public // Sichtbarkeit

-        static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz)

-        int // Typ des Rückgabewerts,

-        MethodSignatures(

-            // Erstes Argument, erwartet int

-            int maxCount,

-            // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird

-            int count = 0,

-            int another = 3,

-            // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats)

-            params string[] otherParams

-        )

-        {

-            return -1;

-        }

-

-        // Methoden können überladen werden, solange sie eindeutige

-        // Signaturen haben

-        public static void MethodSignatures(string maxCount)

-        {

-        }

-

-        // Generische Typen

-        // Die Typen für TKey und TValue werden erst beim Aufruf der Methode

-        // festgelegt. Diese Methode emuliert z.B. SetDefault aus 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;

-        }

-

-        // Möglichen Typen lassen sich auch über ihr Interface beschränken:

-        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>

-        {

-            // Da T ein IEnumerable ist können wir foreach benutzen

-            foreach (var item in toPrint)

-            {

-                // Item ist ein int

-                Console.WriteLine(item.ToString());

-            }

-        }

-

-        public static void OtherInterestingFeatures()

-        {

-            // Optionale Parameter

-            MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings");

-            // setzt explizit einen bestimmten Parameter, andere werden übersprungen

-            MethodSignatures(3, another: 3);

-

-            // Erweiterungsmethoden

-            int i = 3;

-            i.Print(); // Weiter unten definiert

-

-            // Nullables - perfekt für die Interaktion mit

-            // Datenbanken / Rückgabewerten

-            // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?

-            // nullable gemacht werden: <type>? <varname> = <value>

-            int? nullable = null; // Die explizite Langform wäre Nullable<int>

-            Console.WriteLine("Mein Nullable: " + nullable);

-            bool hasValue = nullable.HasValue; // true wenn nicht null

-

-            // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall

-            // dass die Variable null ist festzulegen.

-            int notNullable = nullable ?? 0; // 0

-

-            // Implizit typisierte Variablen

-            // Man kann auch den Typ einer Variable auch vom Compiler

-            // bestimmen lassen:

-            var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren";

-            magic = 9; // funktioniert nicht da magic vom Typ String ist

-

-            // Generics

-            var phonebook = new Dictionary<string, string>() {

-                {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu

-            };

-

-            // Hier könnte man auch unser generisches SetDefault von

-            // weiter oben benutzen:

-            Console.WriteLine(SetDefault<string,string>(phonebook, "Xaver", "kein Telefon")); // kein Telefon

-            // TKey und TValue müssen nicht zwingend angegeben werden, da sie

-            // auch implizit vom Compiler ermittelt werden können

-            Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67

-

-            // Lambdas - konzise Syntax für Inline-Funktionen

-            Func<int, int> square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert

-            Console.WriteLine(square(3)); // 9

-

-            // Disposables - einfaches Management von nicht verwalteten Ressourcen

-            // So gut wie alle Objekte die auf nicht verwaltete Ressourcen

-            // (Dateien, Geräte, ...) zugreifen, implementieren das Interface

-            // IDisposable. Das using Statement stellt sicher dass die vom

-            // IDisposable benutzten Ressourcen nach der Benutzung wieder

-            // freigegeben werden:

-            using (StreamWriter writer = new StreamWriter("log.txt"))

-            {

-                writer.WriteLine("Alles bestens!");

-                // Am Ende des Codeblocks werden die Ressourcen wieder

-                // freigegeben - auch im Falle einer Exception

-            }

-

-            // Parallel Klasse

-            // 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>();

-

-            // Für jeden Request wird ein neuer Thread erzeugt, der nächste

-            // Schritt wird erst nach Beendigung aller Tasks ausgeführt

-            Parallel.ForEach(websites,

-                // maximal 3 Threads gleichzeitig

-                new ParallelOptions() {MaxDegreeOfParallelism = 3},

-                website =>

-            {

-                // Hier folgt eine langwierige, asynchrone Operation

-                using (var r = WebRequest.Create(new Uri(website)).GetResponse())

-                {

-                    responses[website] = r.ContentType;

-                }

-            });

-

-            // Dieser Code wird erst nach Beendigung aller Requests ausgeführt

-            foreach (var key in responses.Keys)

-            {

-                Console.WriteLine("{0}:{1}", key, responses[key]);

-            }

-

-            // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten)

-            dynamic student = new ExpandoObject();

-            // hier muss keine Typ angegeben werden

-            student.FirstName = "Christian";

-

-            // Einem solchen Objekt kann man sogar Methoden zuordnen.

-            // Das Beispiel gibt einen String zurück und erwartet einen String

-            student.Introduce = new Func<string, string>(

-                (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo));

-            Console.WriteLine(student.Introduce("Bettina"));

-

-            // IQueryable<T> - So gut wie alle Aufzählungstypen implementieren

-            // dieses Interface, welches eine Vielzahl von funktionalen Methoden

-            // wie Map / Filter / Reduce zur Verfügung stellt:

-            var bikes = new List<Bicycle>();

-            // sortiert die Liste

-            bikes.Sort();

-            // sortiert nach Anzahl Räder

-            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels));

-            var result = bikes

-                // diese Filter können auch aneinandergehängt werden

-                .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück)

-                .Where(b => b.IsBroken && b.HasTassles)

-                // diese Zuordnung gibt ein IQueryable<String> zurück

-                .Select(b => b.ToString());

-

-            // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert

-            var sum = bikes.Sum(b => b.Wheels);

-

-            // So erzeugt man ein implizit typisiertes Objekt, basierend auf

-            // den Parametern der Elemente:

-            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });

-            // Auch wenn wir es hier nicht demonstrieren können:

-            // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead,

-            // da der Compiler in der Lage ist, die passenden Typen zu erkennen.

-            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))

-            {

-                Console.WriteLine(bikeSummary.Name);

-            }

-

-            // AsParallel-Methode

-            // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert

-            // LINQ und parallele Operationen:

-            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);

-            // Diese Berechnung passiert parallel! Benötigte Threads werden

-            // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt.

-            // Ein Traum für die Verarbeitung von großen Datenmengen

-            // auf mehreren Cores!

-

-            // LINQ - bildet einen Datenspeicher auf IQueryable<T> Objekte ab

-            // LinqToSql beispielsweise speichert und liest aus einer

-            // SQL-Datenbank, LinqToXml aus einem XML-Dokument.

-            // LINQ-Operationen werden "lazy" ausgeführt.

-            var db = new BikeRepository();

-

-            // Die verzögerte Ausführung ist optimal für Datenbankabfragen

-            var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage

-            // Es können noch mehr Filter hinzugefügt werden (auch mit

-            // Bedingungen) - ideal für z.B. "erweiterte Suchen"

-            if (42 > 6)

-            {

-                filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage

-            }

-

-            var query = filter

-                .OrderBy(b => b.Wheels)

-                .ThenBy(b => b.Name)

-                .Select(b => b.Name); // auch hier: immer noch keine Abfrage

-

-            // Erst hier wird die Datenbankabfrage wirklich ausgeführt,

-            // limitiert auf die Elemente die der foreach-Loop verwendet

-            foreach (string bike in query)

-            {

-                Console.WriteLine(result);

-            }

-

-        }

-

-    } // Ende der Klasse LearnCSharp

-

-    // Eine .cs-Datei kann auch mehrere Klassen enthalten

-

-    public static class Extensions

-    {

-        // Erweiterungsmethoden

-        public static void Print(this object obj)

-        {

-            Console.WriteLine(obj.ToString());

-        }

-    }

-

-    // Syntax zur Deklaration einer Klasse:

-    // <public/private/protected/internal> class <class name>{

-    //    // Datenfelder, Konstruktoren und Methoden leben alle

-    //    // innerhalb dieser Deklaration

-    // }

-

-    public class Bicycle

-    {

-        // Felder/Variablen der Klasse "Bicycle"

-        // Das Keyword public macht das Member von überall zugänglich

-        public int Cadence

-        {

-            get // get definiert eine Methode um die Eigenschaft abzurufen

-            {

-                return _cadence;

-            }

-            set // set definiert eine Methode um die Eigenschaft zu setzen

-            {

-                _cadence = value; // value ist der dem Setter übergebene Wert

-            }

-        }

-        private int _cadence;

-

-        // Das Keyword protected macht das Member nur für die Klasse selbst

-        // und ihre Subklassen zugänglich

-        protected virtual int Gear

-        {

-            get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird

-            set;

-        }

-

-        // Das Keyword internal macht das Member innerhalb der Assembly zugänglich

-        internal int Wheels

-        {

-            get;

-            private set; // get/set kann auch über Keywords modifiziert werden

-        }

-

-        int _speed; // Member ohne vorangestellte Keywords sind standardmäßig

-                    // private, sie sind nur innerhalb der Klasse zugänglich.

-                    // Man kann aber natürlich auch das Keyword private benutzen.

-        private string Name { get; set; }

-

-        // Ein Enum ist ein klar definierter Satz an benannten Konstanten.

-        // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu

-        // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für

-        // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint,

-        // long, oder ulong. Alle Werte in einem Enum sind eindeutig.

-        public enum BikeBrand

-        {

-            Colnago,

-            EddyMerckx,

-            Bianchi = 42, // so kann man den Wert explizit setzen

-            Kynast // 43

-        }

-        // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist,

-        // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren

-

-        // Nachdem das Enum deklariert ist, können wir den Typen verwenden:

-        public BikeBrand Brand;

-

-        // Als static gekennzeichnete Member gehören dem Typ selbst,

-        // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem

-        // Objekt benutzen

-        // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!");

-        static public int BicyclesCreated = 0;

-

-        // readonly-Werte werden zur Laufzeit gesetzt

-        // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor

-        // festgelegt werden

-        readonly bool _hasCardsInSpokes = false; // readonly und private

-

-        // Konstruktoren bestimmen was bei einer Instantiierung passiert.

-        // Das ist ein Default-Konstruktor:

-        public Bicycle()

-        {

-            // Member der Klasse können über das Keyword this erreicht werden

-            this.Gear = 1;

-            // oft ist das aber gar nicht nötig

-            Cadence = 50;

-            _speed = 5;

-            Name = "Bonanzarad";

-            Brand = BikeBrand.Kynast;

-            BicyclesCreated++;

-        }

-

-        // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente):

-        public Bicycle(int startCadence, int startSpeed, int startGear,

-                       string name, bool hasCardsInSpokes, BikeBrand brand)

-            : base() // ruft zuerst den "base"-Konstruktor auf

-        {

-            Gear = startGear;

-            Cadence = startCadence;

-            _speed = startSpeed;

-            Name = name;

-            _hasCardsInSpokes = hasCardsInSpokes;

-            Brand = brand;

-        }

-

-        // Konstruktoren können aneinandergehängt werden:

-        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :

-            this(startCadence, startSpeed, 0, "richtig große Räder", true, brand)

-        {

-        }

-

-        // Syntax für Methoden:

-        // <public/private/protected> <return type> <function name>(<args>)

-

-        // Klassen können Getter und Setter für Werte definieren,

-        // oder diese Werte direkt als Eigenschaft implementieren

-        // (in C# der bevorzugte Weg)

-

-        // Parameter von Methoden können Default-Werte haben.

-        // "SpeedUp" kann man also auch ohne Parameter aufrufen:

-        public void SpeedUp(int increment = 1)

-        {

-            _speed += increment;

-        }

-

-        public void SlowDown(int decrement = 1)

-        {

-            _speed -= decrement;

-        }

-

-        // Eigenschaften mit get/set

-        // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu

-        // empfehlen. Diese können Getter und Setter haben, oder auch nur

-        // einen Getter bzw. einen Setter

-        private bool _hasTassles; // private Variable

-        public bool HasTassles // öffentliches Interface

-        {

-            get { return _hasTassles; }

-            set { _hasTassles = value; }

-        }

-

-        // Das kann man auch kürzer schreiben:

-        // Dieser Syntax erzeugt automatisch einen hinterlegten Wert,

-        // (entsprechend `private bool _isBroken`) der gesetzt

-        // bzw. zurückgegeben wird:

-        public bool IsBroken { get; private set; }

-        public int FrameSize

-        {

-            get;

-            // für Getter und Setter kann der Zugriff auch einzeln

-            // beschränkt werden, FrameSize kann also nur von innerhalb

-            // der Klasse "Bicycle" gesetzt werden

-            private set;

-        }

-

-        // Diese Methode gibt eine Reihe an Informationen über das Objekt aus:

-        public virtual string ToString()

-        {

-            return "Gang: " + Gear +

-                    " Kadenz: " + Cadence +

-                    " Geschwindigkeit: " + _speed +

-                    " Name: " + Name +

-                    " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") +

-                    "\n------------------------------\n"

-                    ;

-        }

-

-        // Auch Methoden können als static gekennzeichnet werden, nützlich

-        // beispielsweise für Helper-Methoden

-        public static bool DidWeCreateEnoughBicyclesYet()

-        {

-            // In einer statischen Methode können wir natürlich auch nur

-            // statische Member der Klasse referenzieren

-            return BicyclesCreated > 9000;

-        }

-        // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee

-        // sein die Klasse selbst als static zu kennzeichnen

-

-    } // Ende der Klasse "Bicycle"

-

-    // "PennyFarthing" ist eine Unterklasse von "Bicycle"

-    class PennyFarthing : Bicycle

-    {

-        // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder

-        // mit riesigem Vorderrad. Sie haben keine Gangschaltung.)

-

-        // hier wird einfach der Elternkonstruktor aufgerufen

-        public PennyFarthing(int startCadence, int startSpeed) :

-            base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx)

-        {

-        }

-

-        protected override int Gear

-        {

-            get

-            {

-                return 0;

-            }

-            set

-            {

-                throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!");

-            }

-        }

-

-        public override string ToString()

-        {

-            string result = "Hochrad ";

-            result += base.ToString(); // ruft die "base"-Version der Methode auf

-            return result;

-        }

-    }

-

-    // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen

-    // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung:

-    interface IJumpable

-    {

-        // Alle Member eines Interfaces sind implizit public

-        void Jump(int meters);

-    }

-

-    interface IBreakable

-    {

-        // Interfaces können Eigenschaften, Methoden und Events definieren

-        bool Broken { get; }

-    }

-

-    // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige

-    // Anzahl von Interfaces implementieren

-    class MountainBike : Bicycle, IJumpable, IBreakable

-    {

-        int damage = 0;

-

-        public void Jump(int meters)

-        {

-            damage += meters;

-        }

-

-        public bool Broken

-        {

-            get

-            {

-                return damage > 100;

-            }

-        }

-    }

-

-    // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her.

-    // EntityFramework Code First ist großartig

-    // (ähnlich zu Ruby's ActiveRecord, aber bidirektional)

-    // http://msdn.microsoft.com/de-de/data/jj193542.aspx

-    public class BikeRepository : DbSet

-    {

-        public BikeRepository()

-            : base()

-        {

-        }

-

-        public DbSet<Bicycle> Bikes { get; set; }

-    }

-} // Ende des Namespaces

-```

-

-## In dieser Ãœbersicht nicht enthalten sind die Themen:

-

- * Flags

- * Attributes

- * Statische Eigenschaften

- * Exceptions, Abstraction

- * ASP.NET (Web Forms/MVC/WebMatrix)

- * Winforms

- * Windows Presentation Foundation (WPF)

-

-## Zum Weiterlesen gibt es viele gute Anlaufpunkte:

-

- * [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/overview/exploring-webmatrix)

- * [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/de-de/library/vstudio/ff926074.aspx)

+---
+language: C#
+contributors:
+    - ["Irfan Charania", "https://github.com/irfancharania"]
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Melvyn Laïly", "http://x2a.yt"]
+    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+translators:
+    - ["Frederik Ring", "https://github.com/m90"]
+filename: LearnCSharp-de.cs
+lang: de-de
+---
+C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden.
+
+[Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Einzeilige Kommentare starten mit zwei Schrägstrichen: //
+/*
+Mehrzeile Kommentare wie in C Schrägstrich / Stern
+*/
+/// <summary>
+/// XML-Kommentare können zur automatisierten Dokumentation verwendet werden
+/// </summary>
+
+// Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// definiert einen Namespace um Code in "packages" zu organisieren
+namespace Learning
+{
+    // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei
+    // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu
+    // handhaben führt aber unweigerlich ins Chaos (wirklich)!
+    public class LearnCSharp
+    {
+        // Zuerst erklärt dieses Tutorial die Syntax-Grundlagen,
+        // wenn du bereits Java oder C++ programmieren kannst:
+        // lies bei "Interessante Features" weiter!
+        public static void Syntax()
+        {
+            // Mit Console.WriteLine kannst du einfachen Text ausgeben:
+            Console.WriteLine("Hallo Welt");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+            // Console.Write erzeugt keinen Zeilenumbruch
+            Console.Write("Hallo ");
+            Console.Write("Welt");
+
+            ///////////////////////////////////////////////////
+            // Typen & Variablen
+            ///////////////////////////////////////////////////
+
+            // Deklariere eine Variable mit <Typ> <Name>
+
+            // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Vorzeichenlose 8-Bit Ganzzahl
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - 16-Bit Ganzzahl
+            // Vorzeichenbehaftet - (-32,768 <= short <= 32,767)
+            // Vorzeichenlos - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Integer - 32-bit Ganzzahl
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - 64-bit Ganzzahl
+            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)
+            // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder
+            // uint behandelt. Ein nachgestelltes L markiert den Wert als long
+            // oder ulong.
+
+            // Double - Double-precision 64-bit IEEE 754 Fließkommazahl
+            double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen
+
+            // Float - Single-precision 32-bit IEEE 754 Fließkommazahl
+            float fooFloat = 234.5f; // Genauigkeit: 7 Stellen
+            // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ
+            // float handelt
+
+            // Decimal - ein 128-Bit-Datentyp mit größerer Genauigkeit als
+            // andere Fließkommatypen, und somit bestens geeignet für
+            // die Berechnung von Geld- und Finanzwerten
+            decimal fooDecimal = 150.3m;
+
+            // Boolean - true & false
+            bool fooBoolean = true; // oder false
+
+            // Char - Ein einzelnes 16-Bit Unicode Zeichen
+            char fooChar = 'A';
+
+            // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die
+            // alle Werttypen sind, ist String ein Referenztyp. Strings sind
+            // somit nullable, Werttypen sind dies nicht.
+            string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu";
+            Console.WriteLine(fooString);
+
+            // Jeder Buchstabe eines Strings kann über seinen Index
+            // referenziert werden:
+            char charFromString = fooString[1]; // => 'e'
+            // Strings sind unveränderlich:
+            // `fooString[1] = 'X';` funktioniert nicht
+
+            // Ein Vergleich zweier Strings, unter Berücksichtigung der
+            // aktuellen, sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c
+            // in deutschsprachigen Umgebungen), und ohne Beachtung von
+            // Groß- und Kleinschreibung:
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // Formatierung, genau wie "sprintf"
+            string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Datumsangaben und Formatierung
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String
+            // schreiben. Um " zu maskieren benutzt man ""
+            string bazString = @"Hier geht es
+zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";
+
+            // Die Keywords const oder readonly kennzeichnen eine
+            // unveränderliche Variable/Konstante. Die Werte von Konstanten
+            // werden übrigens bereits zur Compile-Zeit berechnet.
+            const int HOURS_I_WORK_PER_WEEK = 9001;
+
+            ///////////////////////////////////////////////////
+            // Datenstrukturen
+            ///////////////////////////////////////////////////
+
+            // Arrays - Index beginnt bei Null
+            // Die Größe des Arrays wird bei der Deklaration festgelegt.
+            // Die syntaktische Struktur um ein neues Array zu erzeugen sieht
+            // folgendermaßen aus:
+            // <datatype>[] <varname> = new <datatype>[<array size>];
+            int[] intArray = new int[10];
+
+            // Arrays können auch über ein Array-Literal deklariert werden:
+            int[] y = { 9000, 1000, 1337 };
+
+            // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+            // Arrays sind veränderbar
+            intArray[1] = 1;
+
+            // Listen
+            // Durch ihre größere Flexibilität kommen Listen in C# weit
+            // häufiger zum Einsatz als Arrays. Eine Liste wird so deklariert:
+            // List<datatype> <varname> = new List<datatype>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 };
+            // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen"
+
+            // Listen haben keinen Default-Wert.
+            // Bevor auf einen Index zugegriffen werden kann, muss dieser
+            // auch gesetzt worden sein:
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+            // Andere interessante Datenstrukturen sind:
+            // Stack/Queue
+            // Dictionary (entspricht einer Hash Map)
+            // HashSet
+            // Read-only Collections
+            // Tuple (.Net 4+)
+
+            ///////////////////////////////////////
+            // Operatoren
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operatoren");
+
+            // kurze Schreibweise um mehrere Deklarationen zusammenzufassen:
+            // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!)
+            int i1 = 1, i2 = 2;
+
+            // Arithmetik funktioniert wie erwartet:
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Modulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Vergleiche
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+            // Bitweise Operatoren
+            /*
+            ~       Unäres bitweises NICHT
+            <<      Verschieben nach links
+            >>      Verschieben nach rechts
+            &       Bitweises UND
+            ^       Bitweises exklusives ODER
+            |       Bitweises inklusives ODER
+            */
+
+            // Inkremente
+            int i = 0;
+            Console.WriteLine("\n->Inkrement / Dekrement");
+            Console.WriteLine(i++); //i = 1. Post-Inkrement
+            Console.WriteLine(++i); //i = 2. Pre-Inkrement
+            Console.WriteLine(i--); //i = 1. Post-Dekrement
+            Console.WriteLine(--i); //i = 0. Pre-Dekrement
+
+            ///////////////////////////////////////
+            // Kontrollstrukturen
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Kontrollstrukturen");
+
+            // If-Statements funktionieren wie in C
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("Ich werde ausgegeben");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("Ich nicht");
+            }
+            else
+            {
+                Console.WriteLine("Ich leider auch nicht");
+            }
+
+            // Ternärer Operator
+            // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben:
+            // <condition> ? <true> : <false>
+            int zumVergleich = 17;
+            string isTrue = zumVergleich == 17 ? "Ja" : "Nein";
+
+            // while-Schleife
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                // Wird 100mal wiederholt, fooWhile 0->99
+                fooWhile++;
+            }
+
+            // do-while-Schleife
+            int fooDoWhile = 0;
+            do
+            {
+                // Wird 100mal wiederholt, fooDoWhile 0->99
+                fooDoWhile++;
+            } while (fooDoWhile < 100);
+
+            //for-Schleifen => for(<start_statement>; <conditional>; <step>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                // Wird 10mal wiederholt, fooFor 0->9
+            }
+
+            // foreach-Schleife
+            // Die normale Syntax für eine foreach-Schleife lautet:
+            // foreach(<iteratorType> <iteratorName> in <enumerable>)
+            // foreach kann mit jedem Objekt verwendet werden das IEnumerable
+            // oder IEnumerable<T> implementiert. Alle Auflistungs-Typen
+            // (Array, List, Dictionary...) im .NET Framework implementieren
+            // eines dieser beiden Interfaces.
+
+            foreach (char character in "Hallo Welt".ToCharArray())
+            {
+                // Ein Durchgang für jedes Zeichen im String
+            }
+            // (ToCharArray() könnte man hier übrigens auch weglassen,
+            // da String IEnumerable bereits implementiert)
+
+            // Switch Struktur
+            // Ein Switch funktioniert mit byte, short, char und int Datentypen.
+            // Auch Aufzählungstypen können verwendet werden, genau wie
+            // die Klasse String, und ein paar Sonderklassen, die Wrapper für
+            // Primitives sind: Character, Byte, Short und Integer
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "Januar";
+                    break;
+                case 2:
+                    monthString = "Februar";
+                    break;
+                case 3:
+                    monthString = "März";
+                    break;
+                // Man kann für mehrere Fälle auch das selbe Verhalten
+                // definieren. Jeder Block muss aber mit einem break-Statement
+                // abgeschlossen werden. Einzelne Fälle können über
+                // `goto case x` erreicht werden
+                case 6:
+                case 7:
+                case 8:
+                    monthString = "Sommer!!";
+                    break;
+                default:
+                    monthString = "Irgendein anderer Monat";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Umwandlung von Datentypen und Typecasting
+            ///////////////////////////////////////
+
+            // Umwandlung
+
+            // von String nach Integer
+            // bei einem Fehler wirft diese Code eine Exception
+            int.Parse("123"); //gibt die Ganzzahl 123 zurück
+
+            // TryParse gibt bei einem Fehler den Default-Wert zurück
+            // (im Fall von int: 0)
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // gibt true oder false zurück
+            {
+                Console.WriteLine(tryInt);       // 123
+            }
+
+            // von Integer nach String
+            // Die Klasse Convert stellt Methoden zur Konvertierung von
+            // unterschiedlichsten Daten zur Verfügung:
+            Convert.ToString(123); // "123"
+            // oder
+            tryInt.ToString(); // "123"
+        }
+
+        ///////////////////////////////////////
+        // Klassen
+        ///////////////////////////////////////
+        public static void Classes()
+        {
+
+            // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen
+            Bicycle trek = new Bicycle();
+
+            // So werden Methoden der Instanz aufgerufen
+            trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen
+            trek.Cadence = 100;
+
+            // ToString ist eine Konvention über die man üblicherweiser
+            // Informationen über eine Instanz erhält
+            Console.WriteLine("Infos zu trek: " + trek.ToString());
+
+            // Wir instantiieren ein neues Hochrad
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("Infos zu funbike: " + funbike.ToString());
+
+            Console.Read();
+        } // Ende der Methode main
+
+        // Main als Konsolenstartpunkt
+        // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        ///////////////////////////////////////
+        // Interessante Features
+        ///////////////////////////////////////
+
+        // Methodensignaturen
+
+        public // Sichtbarkeit
+        static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz)
+        int // Typ des Rückgabewerts,
+        MethodSignatures(
+            // Erstes Argument, erwartet int
+            int maxCount,
+            // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird
+            int count = 0,
+            int another = 3,
+            // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats)
+            params string[] otherParams
+        )
+        {
+            return -1;
+        }
+
+        // Methoden können überladen werden, solange sie eindeutige
+        // Signaturen haben
+        public static void MethodSignatures(string maxCount)
+        {
+        }
+
+        // Generische Typen
+        // Die Typen für TKey und TValue werden erst beim Aufruf der Methode
+        // festgelegt. Diese Methode emuliert z.B. SetDefault aus 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;
+        }
+
+        // Möglichen Typen lassen sich auch über ihr Interface beschränken:
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // Da T ein IEnumerable ist können wir foreach benutzen
+            foreach (var item in toPrint)
+            {
+                // Item ist ein int
+                Console.WriteLine(item.ToString());
+            }
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // Optionale Parameter
+            MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings");
+            // setzt explizit einen bestimmten Parameter, andere werden übersprungen
+            MethodSignatures(3, another: 3);
+
+            // Erweiterungsmethoden
+            int i = 3;
+            i.Print(); // Weiter unten definiert
+
+            // Nullables - perfekt für die Interaktion mit
+            // Datenbanken / Rückgabewerten
+            // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?
+            // nullable gemacht werden: <type>? <varname> = <value>
+            int? nullable = null; // Die explizite Langform wäre Nullable<int>
+            Console.WriteLine("Mein Nullable: " + nullable);
+            bool hasValue = nullable.HasValue; // true wenn nicht null
+
+            // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall
+            // dass die Variable null ist festzulegen.
+            int notNullable = nullable ?? 0; // 0
+
+            // Implizit typisierte Variablen
+            // Man kann auch den Typ einer Variable auch vom Compiler
+            // bestimmen lassen:
+            var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren";
+            magic = 9; // funktioniert nicht da magic vom Typ String ist
+
+            // Generics
+            var phonebook = new Dictionary<string, string>() {
+                {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu
+            };
+
+            // Hier könnte man auch unser generisches SetDefault von
+            // weiter oben benutzen:
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Xaver", "kein Telefon")); // kein Telefon
+            // TKey und TValue müssen nicht zwingend angegeben werden, da sie
+            // auch implizit vom Compiler ermittelt werden können
+            Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67
+
+            // Lambdas - konzise Syntax für Inline-Funktionen
+            Func<int, int> square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert
+            Console.WriteLine(square(3)); // 9
+
+            // Disposables - einfaches Management von nicht verwalteten Ressourcen
+            // So gut wie alle Objekte die auf nicht verwaltete Ressourcen
+            // (Dateien, Geräte, ...) zugreifen, implementieren das Interface
+            // IDisposable. Das using Statement stellt sicher dass die vom
+            // IDisposable benutzten Ressourcen nach der Benutzung wieder
+            // freigegeben werden:
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Alles bestens!");
+                // Am Ende des Codeblocks werden die Ressourcen wieder
+                // freigegeben - auch im Falle einer Exception
+            }
+
+            // Parallel Klasse
+            // 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>();
+
+            // Für jeden Request wird ein neuer Thread erzeugt, der nächste
+            // Schritt wird erst nach Beendigung aller Tasks ausgeführt
+            Parallel.ForEach(websites,
+                // maximal 3 Threads gleichzeitig
+                new ParallelOptions() {MaxDegreeOfParallelism = 3},
+                website =>
+            {
+                // Hier folgt eine langwierige, asynchrone Operation
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // Dieser Code wird erst nach Beendigung aller Requests ausgeführt
+            foreach (var key in responses.Keys)
+            {
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+            }
+
+            // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten)
+            dynamic student = new ExpandoObject();
+            // hier muss keine Typ angegeben werden
+            student.FirstName = "Christian";
+
+            // Einem solchen Objekt kann man sogar Methoden zuordnen.
+            // Das Beispiel gibt einen String zurück und erwartet einen String
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Bettina"));
+
+            // IQueryable<T> - So gut wie alle Aufzählungstypen implementieren
+            // dieses Interface, welches eine Vielzahl von funktionalen Methoden
+            // wie Map / Filter / Reduce zur Verfügung stellt:
+            var bikes = new List<Bicycle>();
+            // sortiert die Liste
+            bikes.Sort();
+            // sortiert nach Anzahl Räder
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels));
+            var result = bikes
+                // diese Filter können auch aneinandergehängt werden
+                .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück)
+                .Where(b => b.IsBroken && b.HasTassles)
+                // diese Zuordnung gibt ein IQueryable<String> zurück
+                .Select(b => b.ToString());
+
+            // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert
+            var sum = bikes.Sum(b => b.Wheels);
+
+            // So erzeugt man ein implizit typisiertes Objekt, basierend auf
+            // den Parametern der Elemente:
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Auch wenn wir es hier nicht demonstrieren können:
+            // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead,
+            // da der Compiler in der Lage ist, die passenden Typen zu erkennen.
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+            {
+                Console.WriteLine(bikeSummary.Name);
+            }
+
+            // AsParallel-Methode
+            // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert
+            // LINQ und parallele Operationen:
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // Diese Berechnung passiert parallel! Benötigte Threads werden
+            // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt.
+            // Ein Traum für die Verarbeitung von großen Datenmengen
+            // auf mehreren Cores!
+
+            // LINQ - bildet einen Datenspeicher auf IQueryable<T> Objekte ab
+            // LinqToSql beispielsweise speichert und liest aus einer
+            // SQL-Datenbank, LinqToXml aus einem XML-Dokument.
+            // LINQ-Operationen werden "lazy" ausgeführt.
+            var db = new BikeRepository();
+
+            // Die verzögerte Ausführung ist optimal für Datenbankabfragen
+            var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage
+            // Es können noch mehr Filter hinzugefügt werden (auch mit
+            // Bedingungen) - ideal für z.B. "erweiterte Suchen"
+            if (42 > 6)
+            {
+                filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage
+            }
+
+            var query = filter
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // auch hier: immer noch keine Abfrage
+
+            // Erst hier wird die Datenbankabfrage wirklich ausgeführt,
+            // limitiert auf die Elemente die der foreach-Loop verwendet
+            foreach (string bike in query)
+            {
+                Console.WriteLine(result);
+            }
+
+        }
+
+    } // Ende der Klasse LearnCSharp
+
+    // Eine .cs-Datei kann auch mehrere Klassen enthalten
+
+    public static class Extensions
+    {
+        // Erweiterungsmethoden
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Syntax zur Deklaration einer Klasse:
+    // <public/private/protected/internal> class <class name>{
+    //    // Datenfelder, Konstruktoren und Methoden leben alle
+    //    // innerhalb dieser Deklaration
+    // }
+
+    public class Bicycle
+    {
+        // Felder/Variablen der Klasse "Bicycle"
+        // Das Keyword public macht das Member von überall zugänglich
+        public int Cadence
+        {
+            get // get definiert eine Methode um die Eigenschaft abzurufen
+            {
+                return _cadence;
+            }
+            set // set definiert eine Methode um die Eigenschaft zu setzen
+            {
+                _cadence = value; // value ist der dem Setter übergebene Wert
+            }
+        }
+        private int _cadence;
+
+        // Das Keyword protected macht das Member nur für die Klasse selbst
+        // und ihre Subklassen zugänglich
+        protected virtual int Gear
+        {
+            get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird
+            set;
+        }
+
+        // Das Keyword internal macht das Member innerhalb der Assembly zugänglich
+        internal int Wheels
+        {
+            get;
+            private set; // get/set kann auch über Keywords modifiziert werden
+        }
+
+        int _speed; // Member ohne vorangestellte Keywords sind standardmäßig
+                    // private, sie sind nur innerhalb der Klasse zugänglich.
+                    // Man kann aber natürlich auch das Keyword private benutzen.
+        private string Name { get; set; }
+
+        // Ein Enum ist ein klar definierter Satz an benannten Konstanten.
+        // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu
+        // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für
+        // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint,
+        // long, oder ulong. Alle Werte in einem Enum sind eindeutig.
+        public enum BikeBrand
+        {
+            Colnago,
+            EddyMerckx,
+            Bianchi = 42, // so kann man den Wert explizit setzen
+            Kynast // 43
+        }
+        // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist,
+        // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren
+
+        // Nachdem das Enum deklariert ist, können wir den Typen verwenden:
+        public BikeBrand Brand;
+
+        // Als static gekennzeichnete Member gehören dem Typ selbst,
+        // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem
+        // Objekt benutzen
+        // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!");
+        static public int BicyclesCreated = 0;
+
+        // readonly-Werte werden zur Laufzeit gesetzt
+        // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor
+        // festgelegt werden
+        readonly bool _hasCardsInSpokes = false; // readonly und private
+
+        // Konstruktoren bestimmen was bei einer Instantiierung passiert.
+        // Das ist ein Default-Konstruktor:
+        public Bicycle()
+        {
+            // Member der Klasse können über das Keyword this erreicht werden
+            this.Gear = 1;
+            // oft ist das aber gar nicht nötig
+            Cadence = 50;
+            _speed = 5;
+            Name = "Bonanzarad";
+            Brand = BikeBrand.Kynast;
+            BicyclesCreated++;
+        }
+
+        // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente):
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand)
+            : base() // ruft zuerst den "base"-Konstruktor auf
+        {
+            Gear = startGear;
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name;
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Konstruktoren können aneinandergehängt werden:
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "richtig große Räder", true, brand)
+        {
+        }
+
+        // Syntax für Methoden:
+        // <public/private/protected> <return type> <function name>(<args>)
+
+        // Klassen können Getter und Setter für Werte definieren,
+        // oder diese Werte direkt als Eigenschaft implementieren
+        // (in C# der bevorzugte Weg)
+
+        // Parameter von Methoden können Default-Werte haben.
+        // "SpeedUp" kann man also auch ohne Parameter aufrufen:
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // Eigenschaften mit get/set
+        // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu
+        // empfehlen. Diese können Getter und Setter haben, oder auch nur
+        // einen Getter bzw. einen Setter
+        private bool _hasTassles; // private Variable
+        public bool HasTassles // öffentliches Interface
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // Das kann man auch kürzer schreiben:
+        // Dieser Syntax erzeugt automatisch einen hinterlegten Wert,
+        // (entsprechend `private bool _isBroken`) der gesetzt
+        // bzw. zurückgegeben wird:
+        public bool IsBroken { get; private set; }
+        public int FrameSize
+        {
+            get;
+            // für Getter und Setter kann der Zugriff auch einzeln
+            // beschränkt werden, FrameSize kann also nur von innerhalb
+            // der Klasse "Bicycle" gesetzt werden
+            private set;
+        }
+
+        // Diese Methode gibt eine Reihe an Informationen über das Objekt aus:
+        public virtual string ToString()
+        {
+            return "Gang: " + Gear +
+                    " Kadenz: " + Cadence +
+                    " Geschwindigkeit: " + _speed +
+                    " Name: " + Name +
+                    " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Auch Methoden können als static gekennzeichnet werden, nützlich
+        // beispielsweise für Helper-Methoden
+        public static bool DidWeCreateEnoughBicyclesYet()
+        {
+            // In einer statischen Methode können wir natürlich auch nur
+            // statische Member der Klasse referenzieren
+            return BicyclesCreated > 9000;
+        }
+        // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee
+        // sein die Klasse selbst als static zu kennzeichnen
+
+    } // Ende der Klasse "Bicycle"
+
+    // "PennyFarthing" ist eine Unterklasse von "Bicycle"
+    class PennyFarthing : Bicycle
+    {
+        // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder
+        // mit riesigem Vorderrad. Sie haben keine Gangschaltung.)
+
+        // hier wird einfach der Elternkonstruktor aufgerufen
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!");
+            }
+        }
+
+        public override string ToString()
+        {
+            string result = "Hochrad ";
+            result += base.ToString(); // ruft die "base"-Version der Methode auf
+            return result;
+        }
+    }
+
+    // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen
+    // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung:
+    interface IJumpable
+    {
+        // Alle Member eines Interfaces sind implizit public
+        void Jump(int meters);
+    }
+
+    interface IBreakable
+    {
+        // Interfaces können Eigenschaften, Methoden und Events definieren
+        bool Broken { get; }
+    }
+
+    // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige
+    // Anzahl von Interfaces implementieren
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her.
+    // EntityFramework Code First ist großartig
+    // (ähnlich zu Ruby's ActiveRecord, aber bidirektional)
+    // http://msdn.microsoft.com/de-de/data/jj193542.aspx
+    public class BikeRepository : DbSet
+    {
+        public BikeRepository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // Ende des Namespaces
+```
+
+## In dieser Ãœbersicht nicht enthalten sind die Themen:
+
+ * Flags
+ * Attributes
+ * Statische Eigenschaften
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Zum Weiterlesen gibt es viele gute Anlaufpunkte:
+
+ * [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/overview/exploring-webmatrix)
+ * [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/de-de/library/vstudio/ff926074.aspx)
diff --git a/de-de/dynamic-programming-de.html.markdown b/de-de/dynamic-programming-de.html.markdown
index 58568b3b..9cf461d0 100644
--- a/de-de/dynamic-programming-de.html.markdown
+++ b/de-de/dynamic-programming-de.html.markdown
@@ -56,6 +56,7 @@ wie `largest_sequences_so_far` und dessen Index würde eine Menge Zeit sparen.
 
 Ein ähnliches Konzept könnte auch bei der Suche nach dem längsten Weg
 in gerichteten azyklischen Graphen angewandt werden.
+
 ```python
 for i=0 to n-1
     LS[i]=1
diff --git a/de-de/elixir-de.html.markdown b/de-de/elixir-de.html.markdown
index 254cca51..4acb8e23 100644
--- a/de-de/elixir-de.html.markdown
+++ b/de-de/elixir-de.html.markdown
@@ -1,423 +1,423 @@
----

-language: elixir

-contributors:

-    - ["Joao Marques", "http://github.com/mrshankly"]

-translators:

-    - ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]

-filename: learnelixir-de.ex

-lang: de-de

----

-

-Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll 

-kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt 

-viele Features mit. 

-

-```ruby

-

-# Einzeilige Kommentare werden mit der Raute gesetzt.

-

-# Es gibt keine mehrzeiligen Kommentare;

-# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander 

-# zu setzen (so wie hier).

-

-# Mit 'iex' ruft man die Elixir-Shell auf.

-# Zum kompilieren von Modulen dient der Befehl 'elixirc'.

-

-# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt

-# installiert wurde.

-

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

-## -- Basistypen

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

-

-# Es gibt Nummern:

-3    # Integer

-0x1F # Integer

-3.0  # Float

-

-# Für bessere Lesbarkeit des Codes können Unterstriche "_" als Trennzeichen verwendet werden

-1_000_000 == 1000000  # Integer

-1_000.567 == 1000.567 # Float

-

-# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem 

-# ':'.

-:hello # Atom

-

-# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.

-{1,2,3} # Tupel

-

-# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen

-# werden:

-elem({1, 2, 3}, 0) # => 1

-

-# Listen sind als verkettete Listen implementiert.

-[1, 2, 3] # list

-

-# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:

-[ kopf | rest ] = [1,2,3]

-kopf # => 1

-rest # => [2, 3]

-

-# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'

-# (Musterabgleich) und keine Zuweisung.

-# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.

-# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen

-# werden.

-

-# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht 

-# zusammenpassen. 

-# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an

-# Elementen:

-{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}

-

-# Es gibt außerdem 'binaries', 

-<<1,2,3>> # binary.

-

-# Strings und 'char lists'

-"hello" # String

-'hello' # Char-Liste

-

-# ... und mehrzeilige Strings

-"""

-Ich bin ein 

-mehrzeiliger String.

-"""

-#=> "Ich bin ein\nmehrzeiliger String.\n"

-

-# Alles Strings werden in UTF-8 enkodiert:

-"héllò" #=> "héllò"

-

-# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach

-# Listen.

-<<?a, ?b, ?c>> #=> "abc"

-[?a, ?b, ?c]   #=> 'abc'

-

-# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.

-?a #=> 97

-

-# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'

-[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"

-

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

-## -- Operatoren

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

-

-# Einfache Arithmetik

-1 + 1  #=> 2

-10 - 5 #=> 5

-5 * 2  #=> 10

-10 / 2 #=> 5.0

-

-# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.

-

-# Für Division mit ganzzahligen Ergebnis gibt es 'div'

-div(10, 2) #=> 5

-

-# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'

-rem(10, 3) #=> 1

-

-# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese

-# Operatoren erwarten einen Boolean als erstes Argument. 

-true and true #=> true

-false or true #=> true

-# 1 and true    #=> ** (ArgumentError) argument error

-

-# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs 

-# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.

-1 || true  #=> 1

-false && 1 #=> false

-nil && 20  #=> nil

-

-!true #=> false

-

-# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,

-# `<` und `>` 

-1 == 1 #=> true

-1 != 1 #=> false

-1 < 2  #=> true

-

-# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:

-1 == 1.0  #=> true

-1 === 1.0 #=> false

-

-# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:

-1 < :hello #=> true

-

-# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:

-# number < atom < reference < functions < port < pid < tuple < list < bitstring

-

-# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a

-# total ordering is well defined is important." 

-

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

-## -- Kontrollstrukturen

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

-

-# Es gibt die `if`-Verzweigung

-if false do

-  "Dies wird nie jemand sehen..."

-else

-  "...aber dies!"

-end

-

-# ...und ebenso `unless`

-unless true do

-  "Dies wird nie jemand sehen..."

-else

-  "...aber dies!"

-end

-

-# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir

-# arbeiten damit.

-

-# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.

-case {:one, :two} do

-  {:four, :five} ->

-    "Das wird nicht passen"

-  {:one, x} ->

-    "Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."

-  _ ->

-    "Dieser Fall greift immer."

-end

-

-# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert

-# nicht weiter verwendet wird.

-# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:

-[kopf | _] = [1,2,3]

-kopf #=> 1

-

-# Für bessere Lesbarkeit können wir auch das Folgende machen:

-[kopf | _rest] = [:a, :b, :c]

-kopf #=> :a

-

-# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man

-# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.

-cond do

-  1 + 1 == 3 ->

-    "Ich werde nie aufgerufen."

-  2 * 5 == 12 ->

-    "Ich auch nicht."

-  1 + 2 == 3 ->

-    "Aber ich!"

-end

-

-# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert. 

-cond do

-  1 + 1 == 3 ->

-    "Ich werde nie aufgerufen."

-  2 * 5 == 12 ->

-    "Ich auch nicht."

-  true ->

-    "Aber ich! (dies ist im Grunde ein 'else')"

-end

-

-# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.

-# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,

-# egal ob zuvor ein Wert gefangen wurde.

-try do

-  throw(:hello)

-catch

-  nachricht -> "#{nachricht} gefangen."

-after

-  IO.puts("Ich bin die 'after'-Klausel.")

-end

-#=> Ich bin die 'after'-Klausel.

-# ":hello gefangen"

-

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

-## -- Module und Funktionen

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

-

-# Anonyme Funktionen (man beachte den Punkt)

-square = fn(x) -> x * x end

-square.(5) #=> 25

-

-# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben

-# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'

-# eingeführt:

-f = fn

-  x, y when x > 0 -> x + y

-  x, y -> x * y

-end

-

-f.(1, 3)  #=> 4

-f.(-1, 3) #=> -3

-

-# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen

-# Geltungsbereich ('scope') verfügbar.

-is_number(10)    #=> true

-is_list("hello") #=> false

-elem({1,2,3}, 0) #=> 1

-

-# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines

-# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu

-# definieren.

-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

-

-# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'

-# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen

-# werden: elixirc math.ex

-

-# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine

-# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen

-# werden; eine private Funktion kann nur lokal angesprochen werden.

-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)

-

-# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:

-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

-

-# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger

-# Bestandteil von 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-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso

-# ist es möglich eigene Attribute hinzuzufügen.

-defmodule MyMod do

-  @moduledoc """

-  Dies ist ein eingebautes Attribut in einem Beispiel-Modul

-  """

-

-  @my_data 100 # Dies ist ein selbst-definiertes Attribut.

-  IO.inspect(@my_data) #=> 100

-end

-

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

-## -- 'Records' und Ausnahmebehandlung

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

-

-# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen

-# Namen zuzuweisen.

-defrecord Person, name: nil, age: 0, height: 0

-

-joe_info = Person.new(name: "Joe", age: 30, height: 180)

-#=> Person[name: "Joe", age: 30, height: 180]

-

-# Zugriff auf den Wert von 'name'

-joe_info.name #=> "Joe"

-

-# Den Wert von 'age' überschreiben

-joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]

-

-# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,

-# um Ausnahmen beziehungsweise Fehler zu behandeln. 

-try do

-  raise "Irgendein Fehler."

-rescue

-  RuntimeError -> "Laufzeit-Fehler gefangen."

-  _error -> "Und dies fängt jeden Fehler."

-end

-

-# Alle Ausnahmen haben das Attribut 'message'

-try do

-  raise "ein Fehler"

-rescue

-  x in [RuntimeError] ->

-    x.message

-end

-

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

-## -- Nebenläufigkeit

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

-

-# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles

-# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei

-# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen. 

-

-# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die

-# wiederum eine Funktion als Argument entgegen nimmt.

-f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>

-spawn(f) #=> #PID<0.40.0>

-

-# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann

-# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um 

-# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir

-# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem 

-# 'receive'-Mechanismus sichergestellt:

-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

-

-# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion

-# in der Shell mit, etwa so:

-pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>

-

-# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck

-# erfüllt:

-pid <- {:rectangle, 2, 3}

-#=> Area = 6

-#   {:rectangle,2,3}

-

-pid <- {:circle, 2}

-#=> Area = 12.56000000000000049738

-#   {:circle,2}

-

-# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man

-# die aktuelle pid herausfinden.

-self() #=> #PID<0.27.0>

-

-```

-

-## Referenzen und weitere Lektüre

-

-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)

-* [Elixir Documentation](http://elixir-lang.org/docs/master/)

-* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert

-* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong

+---
+language: Elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+translators:
+    - ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]
+filename: learnelixir-de.ex
+lang: de-de
+---
+
+Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll 
+kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt 
+viele Features mit. 
+
+```ruby
+
+# Einzeilige Kommentare werden mit der Raute gesetzt.
+
+# Es gibt keine mehrzeiligen Kommentare;
+# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander 
+# zu setzen (so wie hier).
+
+# Mit 'iex' ruft man die Elixir-Shell auf.
+# Zum kompilieren von Modulen dient der Befehl 'elixirc'.
+
+# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt
+# installiert wurde.
+
+## ---------------------------
+## -- Basistypen
+## ---------------------------
+
+# Es gibt Nummern:
+3    # Integer
+0x1F # Integer
+3.0  # Float
+
+# Für bessere Lesbarkeit des Codes können Unterstriche "_" als Trennzeichen verwendet werden
+1_000_000 == 1000000  # Integer
+1_000.567 == 1000.567 # Float
+
+# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem 
+# ':'.
+:hello # Atom
+
+# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.
+{1,2,3} # Tupel
+
+# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen
+# werden:
+elem({1, 2, 3}, 0) # => 1
+
+# Listen sind als verkettete Listen implementiert.
+[1, 2, 3] # list
+
+# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:
+[ kopf | rest ] = [1,2,3]
+kopf # => 1
+rest # => [2, 3]
+
+# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'
+# (Musterabgleich) und keine Zuweisung.
+# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.
+# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen
+# werden.
+
+# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht 
+# zusammenpassen. 
+# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an
+# Elementen:
+{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Es gibt außerdem 'binaries', 
+<<1,2,3>> # binary.
+
+# Strings und 'char lists'
+"hello" # String
+'hello' # Char-Liste
+
+# ... und mehrzeilige Strings
+"""
+Ich bin ein 
+mehrzeiliger String.
+"""
+#=> "Ich bin ein\nmehrzeiliger String.\n"
+
+# Alles Strings werden in UTF-8 enkodiert:
+"héllò" #=> "héllò"
+
+# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach
+# Listen.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.
+?a #=> 97
+
+# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'
+[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"
+
+## ---------------------------
+## -- Operatoren
+## ---------------------------
+
+# Einfache Arithmetik
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.
+
+# Für Division mit ganzzahligen Ergebnis gibt es 'div'
+div(10, 2) #=> 5
+
+# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'
+rem(10, 3) #=> 1
+
+# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese
+# Operatoren erwarten einen Boolean als erstes Argument. 
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs 
+# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+
+!true #=> false
+
+# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,
+# `<` und `>` 
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:
+1 < :hello #=> true
+
+# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:
+# number < atom < reference < functions < port < pid < tuple < list < bitstring
+
+# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a
+# total ordering is well defined is important." 
+
+## ---------------------------
+## -- Kontrollstrukturen
+## ---------------------------
+
+# Es gibt die `if`-Verzweigung
+if false do
+  "Dies wird nie jemand sehen..."
+else
+  "...aber dies!"
+end
+
+# ...und ebenso `unless`
+unless true do
+  "Dies wird nie jemand sehen..."
+else
+  "...aber dies!"
+end
+
+# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir
+# arbeiten damit.
+
+# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.
+case {:one, :two} do
+  {:four, :five} ->
+    "Das wird nicht passen"
+  {:one, x} ->
+    "Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."
+  _ ->
+    "Dieser Fall greift immer."
+end
+
+# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert
+# nicht weiter verwendet wird.
+# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:
+[kopf | _] = [1,2,3]
+kopf #=> 1
+
+# Für bessere Lesbarkeit können wir auch das Folgende machen:
+[kopf | _rest] = [:a, :b, :c]
+kopf #=> :a
+
+# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man
+# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.
+cond do
+  1 + 1 == 3 ->
+    "Ich werde nie aufgerufen."
+  2 * 5 == 12 ->
+    "Ich auch nicht."
+  1 + 2 == 3 ->
+    "Aber ich!"
+end
+
+# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert. 
+cond do
+  1 + 1 == 3 ->
+    "Ich werde nie aufgerufen."
+  2 * 5 == 12 ->
+    "Ich auch nicht."
+  true ->
+    "Aber ich! (dies ist im Grunde ein 'else')"
+end
+
+# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.
+# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,
+# egal ob zuvor ein Wert gefangen wurde.
+try do
+  throw(:hello)
+catch
+  nachricht -> "#{nachricht} gefangen."
+after
+  IO.puts("Ich bin die 'after'-Klausel.")
+end
+#=> Ich bin die 'after'-Klausel.
+# ":hello gefangen"
+
+## ---------------------------
+## -- Module und Funktionen
+## ---------------------------
+
+# Anonyme Funktionen (man beachte den Punkt)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben
+# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'
+# eingeführt:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen
+# Geltungsbereich ('scope') verfügbar.
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines
+# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu
+# definieren.
+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
+
+# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'
+# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen
+# werden: elixirc math.ex
+
+# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine
+# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen
+# werden; eine private Funktion kann nur lokal angesprochen werden.
+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)
+
+# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:
+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
+
+# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger
+# Bestandteil von 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-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso
+# ist es möglich eigene Attribute hinzuzufügen.
+defmodule MyMod do
+  @moduledoc """
+  Dies ist ein eingebautes Attribut in einem Beispiel-Modul
+  """
+
+  @my_data 100 # Dies ist ein selbst-definiertes Attribut.
+  IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- 'Records' und Ausnahmebehandlung
+## ---------------------------
+
+# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen
+# Namen zuzuweisen.
+defrecord Person, name: nil, age: 0, height: 0
+
+joe_info = Person.new(name: "Joe", age: 30, height: 180)
+#=> Person[name: "Joe", age: 30, height: 180]
+
+# Zugriff auf den Wert von 'name'
+joe_info.name #=> "Joe"
+
+# Den Wert von 'age' überschreiben
+joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]
+
+# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,
+# um Ausnahmen beziehungsweise Fehler zu behandeln. 
+try do
+  raise "Irgendein Fehler."
+rescue
+  RuntimeError -> "Laufzeit-Fehler gefangen."
+  _error -> "Und dies fängt jeden Fehler."
+end
+
+# Alle Ausnahmen haben das Attribut 'message'
+try do
+  raise "ein Fehler"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+
+## ---------------------------
+## -- Nebenläufigkeit
+## ---------------------------
+
+# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles
+# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei
+# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen. 
+
+# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die
+# wiederum eine Funktion als Argument entgegen nimmt.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann
+# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um 
+# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir
+# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem 
+# 'receive'-Mechanismus sichergestellt:
+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
+
+# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion
+# in der Shell mit, etwa so:
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck
+# erfüllt:
+pid <- {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+pid <- {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man
+# die aktuelle pid herausfinden.
+self() #=> #PID<0.27.0>
+
+```
+
+## Referenzen und weitere Lektüre
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert
+* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong
diff --git a/de-de/elm-de.html.markdown b/de-de/elm-de.html.markdown
index 08832327..a6a8cd88 100644
--- a/de-de/elm-de.html.markdown
+++ b/de-de/elm-de.html.markdown
@@ -343,7 +343,7 @@ $ elm reactor
 -- Starte das REPL (read-eval-print-loop).
 $ elm repl
 
--- Bibliotheken werden durch den Github-Nutzernamen und ein Repository identifiziert.
+-- Bibliotheken werden durch den GitHub-Nutzernamen und ein Repository identifiziert.
 -- Installieren einer neuen Bibliothek.
 $ elm package install elm-lang/html
 -- Diese wird der elm-package.json Datei hinzugefügt.
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index 0896f513..3065a033 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -385,6 +385,4 @@ $ 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 9409e181..1b09a1e1 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -82,7 +82,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
     // nicht-ASCII Literal.  Go Quelltext ist UTF-8 kompatibel.
     g := 'Σ' // Ein Runen-Typ, alias int32, gebraucht für unicode code points.
 
-    f := 3.14195 // float64, eine IEEE-754 64-bit Dezimalzahl
+    f := 3.14159 // float64, eine IEEE-754 64-bit Dezimalzahl
     c := 3 + 4i  // complex128, besteht intern aus zwei float64-er
 
     // "var"-Syntax mit Initalwert
@@ -308,13 +308,13 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 ```
 
 ## Weitere Resourcen
-Informationen zu Go findet man auf der [offiziellen Go Webseite](http://golang.org/).
+Informationen zu Go findet man auf der [offiziellen Go Webseite](https://go.dev/).
 Dort gibt es unter anderem ein Tutorial und interaktive Quelltext-Beispiele, vor
 allem aber Dokumentation zur Sprache und den Paketen.
 
 Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
 kurz und gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
-ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/)
+ist außerdem der Quelltext der [Go standard Bibliothek](https://go.dev/src/)
 einzusehen. Dieser kann als Referenz für leicht zu verstehendes und im idiomatischen Stil
 verfasstes Go dienen. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
-in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
+in der [offiziellen Dokumentation von Go](https://go.dev/pkg/).
diff --git a/de-de/javascript-de.html.markdown b/de-de/javascript-de.html.markdown
index f817ee9f..a71d4316 100644
--- a/de-de/javascript-de.html.markdown
+++ b/de-de/javascript-de.html.markdown
@@ -1,525 +1,525 @@
----

-language: javascript

-contributors:

-    - ["Leigh Brenecki", "https://leigh.net.au"]

-translators:

-    - ["ggb", "http://www.ideen-und-soehne.de"]

-filename: learnjavascript-de.js

-lang: de-de

----

-

-(Anmerkungen des Original-Autors:)

-JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprünglich war es als einfachere Skriptsprache für Websites gedacht, ergänzend zu Java, das für komplexere Webanwendungen verwendet wird. Die enge Integration in Websites und der in Browser eingebaute Support der Sprache haben dafür gesorgt, dass JavaScript weit häufiger für Web-Frontends verwendet wird als Java.

-

-Dabei ist JavaScript inzwischen nicht mehr auf Browser beschränkt: Node.js, ein Projekt, das eine eigene Laufzeitumgebung auf Grundlage von Google Chromes V8 mitbringt, wird derzeit immer populärer.

-

-Feedback ist herzlich Willkommen! Der ursprüngliche Autor ist unter [@excitedleigh](https://twitter.com/excitedleigh) oder [l@leigh.net.au](mailto:l@leigh.net.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de).

-

-```js

-// Kommentare werden wie in C gesetzt: Einzeilige Kommentare starten mit zwei 

-// Slashes

-/* während mehrzeilige Kommentare mit einem 

-Slash und einem Stern anfangen und enden */

-

-// Statements können mit einem Semikolon beendet werden

-machWas();

-

-// ...müssen sie aber nicht, weil Semikola automatisch eingefügt werden, wenn 

-// eine neue Zeile beginnt, abgesehen von einigen Ausnahmen.

-machWas()

-

-// Obwohl wir uns für den Anfang nicht um diese Ausnahmen kümmern müssen ist 

-// es besser die Semikola immer zu setzen.

-

-///////////////////////////////////

-// 1. Nummern, Strings und Operationen

-

-// JavaScript hat einen Nummern-Typ (64-bit IEEE 754 double).

-3; // = 3

-1.5; // = 1.5

-

-// Beinahe alle grundlegenden arithmetischen Operationen arbeiten wie erwartet.

-1 + 1; // = 2

-0.1 + 0.2; // = 0.30000000000000004

-10 * 2; // = 20

-35 / 5; // = 7

-

-// Division funktioniert auch mit einem Ergebnis nach dem Komma.

-5 / 2; // = 2.5

-

-// Bit-weise Operationen sind auch möglich; wenn eine Bit-weise Operation 

-// ausgeführt wird, wird die Fließkomma-Zahl in einen 32-bit Integer (mit 

-// Vorzeichen) umgewandelt.

-1 << 2; // = 4

-

-// Die Rangfolge der Operationen kann mit Klammern erzwungen werden.

-(1 + 3) * 2; // = 8

-

-// Es gibt drei spezielle, nicht-reale Nummern-Werte:

-Infinity; // Ergebnis von z. B. 1 / 0

--Infinity; // Ergebnis von z. B. -1 / 0

-NaN; // Ergebnis von z. B. 0 / 0

-

-// Es gibt auch einen Boolean-Typ (für Wahrheitswerte).

-true;

-false;

-

-// Strings werden mit ' oder " erzeugt.

-'abc';

-"Hello, world";

-

-// Für die Negation wird das ! benutzt.

-!true; // = false

-!false; // = true

-

-// Gleichheit wird mit === geprüft.

-1 === 1; // = true

-2 === 1; // = false

-

-// Ungleichheit wird mit !== überprüft.

-1 !== 1; // = false

-2 !== 1; // = true

-

-// Andere Vergleichsoperatoren sind

-1 < 10; // = true

-1 > 10; // = false

-2 <= 2; // = true

-2 >= 2; // = true

-

-// Strings können mit + verbunden 

-"Hello " + "world!"; // = "Hello world!"

-

-// und mit < und > verglichen werden.

-"a" < "b"; // = true

-

-// Für den Vergleich von Werten mit "==" wird eine Typumwandlung erzwungen...

-"5" == 5; // = true

-

-// ...solange man nicht === verwendet.

-"5" === 5; // = false

-

-// Auf einzelne Buchstaben innerhalb eines Strings kann mit der Methode 

-// 'charAt' zugegriffen werden

-"This is a string".charAt(0);  // = "T"

-

-// Die Methode 'substring' gibt Teilbereiche eines Strings zurück

-"Hello world".substring(0, 5); // = "Hello"

-

-// 'length' ist eine Eigenschaft und wird folglich ohne '()' benutzt

-"Hello".length; // = 5

-

-// Es gibt außerdem die Werte 'null' und 'undefined'

-null; // wird verwendet um einen vorsätzlich gewählten 'Nicht'-Wert anzuzeigen

-undefined; // wird verwendet um anzuzeigen, dass der Wert (aktuell) nicht 

-           // verfügbar ist (obwohl genau genommen undefined selbst einen Wert 

-           // darstellt)

-

-// false, null, undefined, NaN, 0 und "" sind 'falsy', d. h. alles andere ist 

-// wahr. Man beachte, dass 0 falsch und "0" wahr ist, obwohl 0 == "0".

-

-///////////////////////////////////

-// 2. Variablen, Arrays und Objekte

-

-// Variablen werden mit dem Schlüsselwort 'var' und einem frei wählbaren 

-// Bezeichner deklariert. JavaScript ist dynamisch typisiert, so dass man einer

-// Variable keinen Typ zuweisen muss. Die Zuweisung verwendet ein einfaches =.

-var einWert = 5;

-

- // Wenn man das Schlüsselwort 'var' weglässt, bekommt man keinen Fehler

-einAndererWert = 10;

-

-// ...aber die Variable wird im globalen Kontext erzeugt, nicht in dem Kontext,

-// in dem sie erzeugt wurde.

-

-// Variablen die erzeugt wurden ohne ihnen einen Wert zuzuweisen, erhalten den

-// Wert 'undefined'.

-var einDritterWert; // = undefined

-

-// Es existiert eine Kurzform, um mathematische Operationen mit Variablen 

-// auszuführen:

-einWert += 5; // äquivalent zu einWert = einWert + 5; einWert ist nun also 10

-einWert *= 10; // einWert ist nach dieser Operation 100

-

-// Und es existiert eine weitere, sogar noch kürzere Form, um 1 zu addieren 

-// oder zu subtrahieren

-einWert++; // nun ist einWert 101

-einWert--; // wieder 100

-

-// Arrays sind geordnete Listen von Werten irgendeines Typs

-var myArray = ["Hello", 45, true];

-

-// Auf einzelne Elemente eines Arrays kann zugegriffen werden, in dem der Index

-// in eckigen Klammern hinter das Array geschrieben werden. Die Indexierung 

-// beginnt bei 0.

-myArray[1]; // = 45

-

-// Arrays haben keine feste Länge

-myArray.push("World");

-myArray.length; // = 4

-

-// und sind veränderlich

-myArray[3] = "Hello";

-

-// Die Objekte in JavaScript entsprechen 'dictionaries' oder 'maps' in anderen 

-// Sprachen: es handelt sich um ungeordnete Schlüssel-Wert-Paare.

-var myObj = { key1: "Hello", key2: "World" };

-

-// Schlüssel sind Strings, aber es werden keine Anführungszeichen benötigt, 

-// sofern es sich um reguläre JavaScript-Bezeichner handelt. Werte können von

-// jedem Typ sein.

-var myObj = { myKey: "myValue", "my other key": 4 };

-

-// Auf Attribute von Objekten kann ebenfalls mit eckigen Klammern zugegriffen

-// werden,

-myObj["my other key"]; // = 4

-

-// ... oder in dem man die Punkt-Notation verwendet, vorausgesetzt es handelt 

-// sich bei dem Schlüssel um einen validen Bezeichner.

-myObj.myKey; // = "myValue"

-

-// Objekte sind veränderlich, Werte können verändert und neue Schlüssel 

-// hinzugefügt werden.

-myObj.myThirdKey = true;

-

-// Der Zugriff auf einen noch nicht definierten Schlüssel, liefert ein 

-// undefined.

-myObj.myFourthKey; // = undefined

-

-///////////////////////////////////

-// 3. Logik und Kontrollstrukturen

-

-// Die if-Struktur arbeitet, wie man es erwartet.

-var count = 1;

-if (count == 3){

-    // wird evaluiert, wenn count gleich 3 ist

-} else if (count == 4) {

-    // wird evaluiert, wenn count gleich 4 ist

-} else {

-    // wird evaluiert, wenn es weder 3 noch 4 ist

-}

-

-// Genauso 'while'.

-while (true) {

-    // Eine unendliche Schleife!

-}

-

-// Do-while-Scheifen arbeiten wie while-Schleifen, abgesehen davon, dass sie 

-// immer mindestens einmal ausgeführt werden.

-var input;

-do {

-    input = getInput();

-} while ( !isValid( input ) )

-

-// Die for-Schleife arbeitet genau wie in C und Java:

-// Initialisierung; Bedingung, unter der die Ausführung fortgesetzt wird; 

-// Iteration.

-for ( var i = 0; i < 5; i++ ) {

-    // wird 5-mal ausgeführt

-}

-

-// '&&' ist das logische und, '||' ist das logische oder

-if (house.size == "big" && house.colour == "blue"){

-    house.contains = "bear";

-    // Die Größe des Hauses ist groß und die Farbe blau.

-}

-if (colour == "red" || colour == "blue"){

-    // Die Farbe ist entweder rot oder blau.

-}

-

-// Die Auswertung von '&&' und '||' erfolgt so, dass abgebrochen wird, wenn die

-// Bedingung erfüllt ist (bei oder) oder nicht-erfüllt ist (bei und). Das ist 

-// nützlich, um einen Default-Wert zu setzen.

-var name = otherName || "default";

-

-// Ein 'switch' Statement prüft Gleichheit mit ===

-// ohne ein 'break' nach jedem Fall

-// werden auch die Fälle nach dem korrekten aufgerufen

-grade = 'B';

-switch (grade) {

-  case 'A':

-    console.log("Great job");

-    break;

-  case 'B':

-    console.log("OK job");

-    break;

-  case 'C':

-    console.log("You can do better");

-    break;

-  default:

-    console.log("Oy vey");

-    break;

-}

-

-///////////////////////////////////

-// 4. Funktionen, Geltungsbereich und Closures

-

-// In JavaScript werden Funktionen mit dem Schlüsselwort 'function' deklariert.

-function myFunction(thing){

-    return thing.toUpperCase();

-}

-myFunction("foo"); // = "FOO"

-

-// Vorsicht: der Ausdruck der den Rückgabewert einer Funktion bildet muss

-// auf der selben Zeile beginnen auf der auch das 'return' Keyword steht

-// Sonst wird hier ein automatisches Semikolon eingefügt und die Funktion

-// gibt 'undefined' zurück

-function myFunction()

-{

-    return // <- Hier wird automatisch ein Semikolon eingefügt

-    {

-        thisIsAn: 'object literal'

-    }

-}

-myFunction(); // = undefined

-

-// In JavaScript sind Funktionen 'Bürger erster Klasse', also können sie wie 

-// Variablen verwendet und als Parameter anderen Funktionen übergeben werden 

-// - zum Beispiel, um einen 'event handler' zu 'beliefern'.

-function myFunction() {

-    // wird ausgeführt, nachdem 5 Sekunden vergangen sind

-}

-setTimeout(myFunction, 5000);

-

-// Funktionen können auch deklariert werden, ohne ihnen einen Namen zuzuweisen.

-// Es ist möglich diese anonymen Funktionen direkt als (oder im) Argument 

-// einer anderen Funktion zu definieren.

-setTimeout(function(){

-    // wird ausgeführt, nachdem 5 Sekunden vergangen sind

-}, 5000);

-

-// JavaScript hat einen Geltungsbereich, der sich auf Funktionen erstreckt: 

-// Funktionen haben ihren eigenen Geltungsbereich, andere Blöcke nicht.

-if(true) {

-    var i = 5;

-}

-i; // = 5 - nicht undefined, wie man es von einer Sprache erwarten würde, die 

-   // ihren Geltungsbereich nach Blöcken richtet

-

-// Daraus ergibt sich ein bestimmtes Muster für sofort-ausführbare, anonyme 

-// Funktionen, die es vermeiden, dass der globale Geltungsbereich von Variablen

-// 'verschmutzt' wird.

-(function(){

-    var temporary = 5;

-    // Auf eine Variable im globalen Geltungsbereich kann zugegriffen werden, 

-    // sofern sie im globalen Objekt definiert ist (in einem Webbrowser ist 

-    // dies immer das 'window'-Objekt, in anderen Umgebungen, bspw. Node.js, 

-    // kann das anders aussehen). 

-    window.permanent = 10;

-})();

-temporary; // wirft einen ReferenceError

-permanent; // = 10

-

-// Eines der mächtigsten Charakteristika von JavaScript sind Closures. Wird 

-// eine Funktion innerhalb einer anderen Funktion definiert, dann hat die 

-// innere Funktion Zugriff auf alle Variablen der äußeren Funktion, sogar dann,

-// wenn die äußere Funktion beendet wurde.

-function sayHelloInFiveSeconds(name){

-    var prompt = "Hello, " + name + "!";

-    function inner(){

-        alert(prompt);

-    }

-    setTimeout(inner, 5000);

-    // setTimeout wird asynchron ausgeführt. Also wird sayHelloInFiveSeconds 

-    // sofort verlassen und setTimeout wird die innere Funktion 'im nachhinein' 

-    // aufrufen. Dennoch: Weil sayHelloInFiveSeconds eine Hülle um die innere 

-    // Funktion bildet, hat die innere Funktion immer noch Zugriff auf die 

-    // Variable prompt.

-}

-sayHelloInFiveSeconds("Adam");  // wird nach 5 Sekunden ein Popup mit der 

-                                // Nachricht "Hello, Adam!" öffnen.

-

-///////////////////////////////////

-// 5. Mehr über Objekte, Konstruktoren und Prototypen

-

-// Objekte können Funktionen enthalten.

-var myObj = {

-    myFunc: function(){

-        return "Hello world!";

-    }

-};

-myObj.myFunc(); // = "Hello world!"

-

-// Wenn Funktionen aufgerufen werden, die zu einem Objekt gehören, können sie 

-// auf das eigene Objekt mit dem Schlüsselwort 'this' zugreifen.

-myObj = {

-    myString: "Hello world!",

-    myFunc: function(){

-        return this.myString;

-    }

-};

-myObj.myFunc(); // = "Hello world!"

-

-// Worauf 'this' gesetzt wird, ist davon abhängig, wie die Funktion aufgerufen 

-// wird, nicht wo sie definiert wurde. Unsere Funktion wird daher nicht 

-// funktionieren, sofern sie außerhalb des Kontextes des Objekts aufgerufen 

-// wird.

-var myFunc = myObj.myFunc;

-myFunc(); // = undefined

-

-// Umgekehrt ist es möglich eine Funktion einem Objekt zuzuweisen und dadurch 

-// Zugriff auf den this-Kontext zu erhalten, sogar dann, wenn die Funktion dem

-// Objekt nach dessen Definition zugewiesen wird.

-var myOtherFunc = function(){

-    return this.myString.toUpperCase();

-}

-myObj.myOtherFunc = myOtherFunc;

-myObj.myOtherFunc(); // = "HELLO WORLD!"

-

-// Mit den Methoden 'call' und 'apply' kann der Kontext eines Funktionsaufrufs

-// verändert werden

-

-var anotherFunc = function(s){

-    return this.myString + s;

-}

-anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"

-

-// 'apply' funktioniert beiahe identisch, erwartet die übergebenen Argumente

-// aber in einem Array

-

-anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"

-

-// Das ist hilfreich wenn man einer Funktion eine beliebige Zahl Argumente

-// übergeben kann

-

-Math.min(42, 6, 27); // = 6

-Math.min([42, 6, 27]); // = NaN (uh-oh!)

-Math.min.apply(Math, [42, 6, 27]); // = 6

-

-// 'call' und 'apply' beeinflussen aber nur den spezifischen Aufruf.

-// Um den Kontext einer Funktion dauerhaft zu ändern wird 'bind' benutzt.

-

-var boundFunc = anotherFunc.bind(myObj);

-boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"

-

-// Mit 'bind' lassen sich Funktionen auch teilweise anwenden / "curryen".

-var product = function(a, b){ return a * b; }

-var doubler = product.bind(this, 2);

-doubler(8); // = 16

-

-// Wenn eine Funktion mit dem Schlüsselwort 'new' aufgerufen wird, dann wird 

-// ein neues Objekt erzeugt. Funktionen, die darauf ausgelegt sind in dieser 

-// Art aufgerufen zu werden, werden Konstruktoren genannt.

-var MyConstructor = function(){

-    this.myNumber = 5;

-}

-myNewObj = new MyConstructor(); // = {myNumber: 5}

-myNewObj.myNumber; // = 5

-

-// Jedes JavaScript-Objekt hat einen Prototyp. Wenn man versucht auf eine 

-// Eigenschaft des Objekts zuzugreifen, das nicht im Objekt selbst existiert,

-// schaut der Interpreter in dessen Prototyp nach.

-

-// Einige JavaScript-Implementierungen erlauben den direkten Zugriff auf den 

-// Prototyp eines Objekts durch die magische Eigenschaft __proto__. Obwohl das

-// nützlich ist, um  Prototypen im Allgemeinen zu erklären, ist das nicht Teil

-// des Standards; zum Standard-Weg der Nutzung von Prototypen kommen wir 

-// später.

-var myObj = {

-    myString: "Hello world!",

-};

-var myPrototype = {

-    meaningOfLife: 42,

-    myFunc: function(){

-        return this.myString.toLowerCase()

-    }

-};

-myObj.__proto__ = myPrototype;

-myObj.meaningOfLife; // = 42

-

-// Das funktioniert auch bei Funktionen.

-myObj.myFunc(); // = "hello world!"

-

-// Sollte die Eigenschaft nicht im Prototypen des Objekts enthalten sein, dann

-// wird im Prototypen des Prototypen nachgesehen und so weiter.

-myPrototype.__proto__ = {

-    myBoolean: true

-};

-myObj.myBoolean; // = true

-

-// Dafür wird nichts hin und her kopiert; jedes Objekt speichert eine Referenz

-// auf seinen Prototypen. Das heißt wenn der Prototyp geändert wird, dann 

-// werden die Änderungen überall sichtbar.

-myPrototype.meaningOfLife = 43;

-myObj.meaningOfLife; // = 43

-

-// Es wurde bereits erwähnt, dass __proto__ nicht zum Standard gehört und es 

-// gibt ebenso keinen Standard-Weg, um den Prototyp eines existierenden Objekts

-// zu ändern. Es gibt dennoch zwei Wege, wie man ein neues Objekt mit einem 

-// gegebenen Prototypen erzeugt.

-

-// Der erste Weg ist die Methode Object.create, die eine jüngere Ergänzung des

-// JavaScript-Standards ist und daher noch nicht in allen Implementierungen 

-// verfügbar.

-var myObj = Object.create(myPrototype);

-myObj.meaningOfLife; // = 43

-

-// Der zweite Weg, der immer funktioniert, hat mit den Konstruktoren zu tun. 

-// Konstruktoren haben eine Eigenschaft, die Prototyp heißt.  Dabei handelt es

-// sich *nicht* um den Prototypen der Konstruktor-Funktion; stattdessen handelt

-// es sich um den Prototypen, der einem neuen Objekt mitgegeben wird, wenn es 

-// mit dem Konstruktor und dem Schlüsselwort 'new' erzeugt wird.

-MyConstructor.prototype = {

-    getMyNumber: function(){

-        return this.myNumber

-    }

-};

-var myNewObj2 = new MyConstructor();

-myNewObj2.getMyNumber(); // = 5

-

-// Alle primitiven Typen, also strings und numbers, haben auch Konstruktoren, 

-// die zu dem Typ äquivalente Wrapper-Objekte erzeugen. 

-var myNumber = 12;

-var myNumberObj = new Number(12);

-myNumber == myNumberObj; // = true

-

-// Genau genommen: Sie sind nicht exakt äquivalent.

-typeof myNumber; // = 'number'

-typeof myNumberObj; // = 'object'

-myNumber === myNumberObj; // = false

-if (0){

-    // Dieser Teil wird nicht ausgeführt, weil 0 'falsy' ist.

-}

-

-// Das Wrapper-Objekt und die regulären, eingebauten Typen, teilen sich einen 

-// Prototyp; so ist es möglich zum Beispiel einem String weitere Funktionen 

-// hinzuzufügen.

-String.prototype.firstCharacter = function(){

-    return this.charAt(0);

-}

-"abc".firstCharacter(); // = "a"

-

-// Diese Tatsache wird häufig bei einer Methode mit dem Namen 'polyfilling'

-// verwendet: Dabei wird ein neues Feature von JavaScript in einer älteren 

-// Untermenge der Sprache integriert, so dass bestimmte Funktionen auch in 

-// älteren Umgebungen und Browsern verwendet werden können.

-

-// Ein Beispiel: Es wurde erwähnt, dass die Methode Object.create nicht in 

-// allen Umgebungen verfügbar ist - wir können sie dennoch verwenden, mit einem

-// 'polyfill':

-if (Object.create === undefined){ // überschreib nichts, was eventuell bereits

-                                  // existiert

-    Object.create = function(proto){

-        // erstelle einen vorübergehenden Konstruktor mit dem richtigen

-        // Prototypen

-        var Constructor = function(){};

-        Constructor.prototype = proto;

-        // verwende es dann, um ein neues Objekt mit einem passenden 

-        // Prototypen zurückzugeben

-        return new Constructor();

-    }

-}

-```

-

-## Zur weiteren Lektüre (englisch)

-

-Das [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) bietet eine ausgezeichnete Dokumentation für die Verwendung von JavaScript im Browser. Es ist außerdem ein Wiki und ermöglicht es damit anderen zu helfen, wenn man selbst ein wenig Wissen angesammelt hat.

-

-MDN's [A re-introduction to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) führt sehr viele der hier vorgestellten Konzepte im Detail aus. 

-

-Dieses Tutorial hat nur die Sprache JavaScript vorgestellt; um mehr über den  Einsatz in Websites zu lernen, ist es ein guter Start etwas über das [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) zu lernen.

-

-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) ist eine tiefgehende Einführung in die kontra-intuitiven Parts der Sprache.

-

-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) ist ein Klassiker unter den Referenzen.

-

-Zusätzlich zu direkten Beiträgen zu diesem Artikel ist der Inhalt in Anlehnung an Louie Dinh's Python-Tutorial auf dieser Seite und das [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) des Mozilla Developer Network entstanden.

+---
+language: javascript
+contributors:
+    - ["Leigh Brenecki", "https://leigh.net.au"]
+translators:
+    - ["ggb", "http://www.ideen-und-soehne.de"]
+filename: learnjavascript-de.js
+lang: de-de
+---
+
+(Anmerkungen des Original-Autors:)
+JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprünglich war es als einfachere Skriptsprache für Websites gedacht, ergänzend zu Java, das für komplexere Webanwendungen verwendet wird. Die enge Integration in Websites und der in Browser eingebaute Support der Sprache haben dafür gesorgt, dass JavaScript weit häufiger für Web-Frontends verwendet wird als Java.
+
+Dabei ist JavaScript inzwischen nicht mehr auf Browser beschränkt: Node.js, ein Projekt, das eine eigene Laufzeitumgebung auf Grundlage von Google Chromes V8 mitbringt, wird derzeit immer populärer.
+
+Feedback ist herzlich Willkommen! Der ursprüngliche Autor ist unter [@excitedleigh](https://twitter.com/excitedleigh) oder [l@leigh.net.au](mailto:l@leigh.net.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de).
+
+```js
+// Kommentare werden wie in C gesetzt: Einzeilige Kommentare starten mit zwei 
+// Slashes
+/* während mehrzeilige Kommentare mit einem 
+Slash und einem Stern anfangen und enden */
+
+// Statements können mit einem Semikolon beendet werden
+machWas();
+
+// ...müssen sie aber nicht, weil Semikola automatisch eingefügt werden, wenn 
+// eine neue Zeile beginnt, abgesehen von einigen Ausnahmen.
+machWas()
+
+// Obwohl wir uns für den Anfang nicht um diese Ausnahmen kümmern müssen ist 
+// es besser die Semikola immer zu setzen.
+
+///////////////////////////////////
+// 1. Nummern, Strings und Operationen
+
+// JavaScript hat einen Nummern-Typ (64-bit IEEE 754 double).
+3; // = 3
+1.5; // = 1.5
+
+// Beinahe alle grundlegenden arithmetischen Operationen arbeiten wie erwartet.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Division funktioniert auch mit einem Ergebnis nach dem Komma.
+5 / 2; // = 2.5
+
+// Bit-weise Operationen sind auch möglich; wenn eine Bit-weise Operation 
+// ausgeführt wird, wird die Fließkomma-Zahl in einen 32-bit Integer (mit 
+// Vorzeichen) umgewandelt.
+1 << 2; // = 4
+
+// Die Rangfolge der Operationen kann mit Klammern erzwungen werden.
+(1 + 3) * 2; // = 8
+
+// Es gibt drei spezielle, nicht-reale Nummern-Werte:
+Infinity; // Ergebnis von z. B. 1 / 0
+-Infinity; // Ergebnis von z. B. -1 / 0
+NaN; // Ergebnis von z. B. 0 / 0
+
+// Es gibt auch einen Boolean-Typ (für Wahrheitswerte).
+true;
+false;
+
+// Strings werden mit ' oder " erzeugt.
+'abc';
+"Hello, world";
+
+// Für die Negation wird das ! benutzt.
+!true; // = false
+!false; // = true
+
+// Gleichheit wird mit === geprüft.
+1 === 1; // = true
+2 === 1; // = false
+
+// Ungleichheit wird mit !== überprüft.
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Andere Vergleichsoperatoren sind
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings können mit + verbunden 
+"Hello " + "world!"; // = "Hello world!"
+
+// und mit < und > verglichen werden.
+"a" < "b"; // = true
+
+// Für den Vergleich von Werten mit "==" wird eine Typumwandlung erzwungen...
+"5" == 5; // = true
+
+// ...solange man nicht === verwendet.
+"5" === 5; // = false
+
+// Auf einzelne Buchstaben innerhalb eines Strings kann mit der Methode 
+// 'charAt' zugegriffen werden
+"This is a string".charAt(0);  // = "T"
+
+// Die Methode 'substring' gibt Teilbereiche eines Strings zurück
+"Hello world".substring(0, 5); // = "Hello"
+
+// 'length' ist eine Eigenschaft und wird folglich ohne '()' benutzt
+"Hello".length; // = 5
+
+// Es gibt außerdem die Werte 'null' und 'undefined'
+null; // wird verwendet um einen vorsätzlich gewählten 'Nicht'-Wert anzuzeigen
+undefined; // wird verwendet um anzuzeigen, dass der Wert (aktuell) nicht 
+           // verfügbar ist (obwohl genau genommen undefined selbst einen Wert 
+           // darstellt)
+
+// false, null, undefined, NaN, 0 und "" sind 'falsy', d. h. alles andere ist 
+// wahr. Man beachte, dass 0 falsch und "0" wahr ist, obwohl 0 == "0".
+
+///////////////////////////////////
+// 2. Variablen, Arrays und Objekte
+
+// Variablen werden mit dem Schlüsselwort 'var' und einem frei wählbaren 
+// Bezeichner deklariert. JavaScript ist dynamisch typisiert, so dass man einer
+// Variable keinen Typ zuweisen muss. Die Zuweisung verwendet ein einfaches =.
+var einWert = 5;
+
+ // Wenn man das Schlüsselwort 'var' weglässt, bekommt man keinen Fehler
+einAndererWert = 10;
+
+// ...aber die Variable wird im globalen Kontext erzeugt, nicht in dem Kontext,
+// in dem sie erzeugt wurde.
+
+// Variablen die erzeugt wurden ohne ihnen einen Wert zuzuweisen, erhalten den
+// Wert 'undefined'.
+var einDritterWert; // = undefined
+
+// Es existiert eine Kurzform, um mathematische Operationen mit Variablen 
+// auszuführen:
+einWert += 5; // äquivalent zu einWert = einWert + 5; einWert ist nun also 10
+einWert *= 10; // einWert ist nach dieser Operation 100
+
+// Und es existiert eine weitere, sogar noch kürzere Form, um 1 zu addieren 
+// oder zu subtrahieren
+einWert++; // nun ist einWert 101
+einWert--; // wieder 100
+
+// Arrays sind geordnete Listen von Werten irgendeines Typs
+var myArray = ["Hello", 45, true];
+
+// Auf einzelne Elemente eines Arrays kann zugegriffen werden, in dem der Index
+// in eckigen Klammern hinter das Array geschrieben werden. Die Indexierung 
+// beginnt bei 0.
+myArray[1]; // = 45
+
+// Arrays haben keine feste Länge
+myArray.push("World");
+myArray.length; // = 4
+
+// und sind veränderlich
+myArray[3] = "Hello";
+
+// Die Objekte in JavaScript entsprechen 'dictionaries' oder 'maps' in anderen 
+// Sprachen: es handelt sich um ungeordnete Schlüssel-Wert-Paare.
+var myObj = { key1: "Hello", key2: "World" };
+
+// Schlüssel sind Strings, aber es werden keine Anführungszeichen benötigt, 
+// sofern es sich um reguläre JavaScript-Bezeichner handelt. Werte können von
+// jedem Typ sein.
+var myObj = { myKey: "myValue", "my other key": 4 };
+
+// Auf Attribute von Objekten kann ebenfalls mit eckigen Klammern zugegriffen
+// werden,
+myObj["my other key"]; // = 4
+
+// ... oder in dem man die Punkt-Notation verwendet, vorausgesetzt es handelt 
+// sich bei dem Schlüssel um einen validen Bezeichner.
+myObj.myKey; // = "myValue"
+
+// Objekte sind veränderlich, Werte können verändert und neue Schlüssel 
+// hinzugefügt werden.
+myObj.myThirdKey = true;
+
+// Der Zugriff auf einen noch nicht definierten Schlüssel, liefert ein 
+// undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Logik und Kontrollstrukturen
+
+// Die if-Struktur arbeitet, wie man es erwartet.
+var count = 1;
+if (count == 3){
+    // wird evaluiert, wenn count gleich 3 ist
+} else if (count == 4) {
+    // wird evaluiert, wenn count gleich 4 ist
+} else {
+    // wird evaluiert, wenn es weder 3 noch 4 ist
+}
+
+// Genauso 'while'.
+while (true) {
+    // Eine unendliche Schleife!
+}
+
+// Do-while-Scheifen arbeiten wie while-Schleifen, abgesehen davon, dass sie 
+// immer mindestens einmal ausgeführt werden.
+var input;
+do {
+    input = getInput();
+} while ( !isValid( input ) )
+
+// Die for-Schleife arbeitet genau wie in C und Java:
+// Initialisierung; Bedingung, unter der die Ausführung fortgesetzt wird; 
+// Iteration.
+for ( var i = 0; i < 5; i++ ) {
+    // wird 5-mal ausgeführt
+}
+
+// '&&' ist das logische und, '||' ist das logische oder
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+    // Die Größe des Hauses ist groß und die Farbe blau.
+}
+if (colour == "red" || colour == "blue"){
+    // Die Farbe ist entweder rot oder blau.
+}
+
+// Die Auswertung von '&&' und '||' erfolgt so, dass abgebrochen wird, wenn die
+// Bedingung erfüllt ist (bei oder) oder nicht-erfüllt ist (bei und). Das ist 
+// nützlich, um einen Default-Wert zu setzen.
+var name = otherName || "default";
+
+// Ein 'switch' Statement prüft Gleichheit mit ===
+// ohne ein 'break' nach jedem Fall
+// werden auch die Fälle nach dem korrekten aufgerufen
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+///////////////////////////////////
+// 4. Funktionen, Geltungsbereich und Closures
+
+// In JavaScript werden Funktionen mit dem Schlüsselwort 'function' deklariert.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Vorsicht: der Ausdruck der den Rückgabewert einer Funktion bildet muss
+// auf der selben Zeile beginnen auf der auch das 'return' Keyword steht
+// Sonst wird hier ein automatisches Semikolon eingefügt und die Funktion
+// gibt 'undefined' zurück
+function myFunction()
+{
+    return // <- Hier wird automatisch ein Semikolon eingefügt
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// In JavaScript sind Funktionen 'Bürger erster Klasse', also können sie wie 
+// Variablen verwendet und als Parameter anderen Funktionen übergeben werden 
+// - zum Beispiel, um einen 'event handler' zu 'beliefern'.
+function myFunction() {
+    // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}
+setTimeout(myFunction, 5000);
+
+// Funktionen können auch deklariert werden, ohne ihnen einen Namen zuzuweisen.
+// Es ist möglich diese anonymen Funktionen direkt als (oder im) Argument 
+// einer anderen Funktion zu definieren.
+setTimeout(function(){
+    // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}, 5000);
+
+// JavaScript hat einen Geltungsbereich, der sich auf Funktionen erstreckt: 
+// Funktionen haben ihren eigenen Geltungsbereich, andere Blöcke nicht.
+if(true) {
+    var i = 5;
+}
+i; // = 5 - nicht undefined, wie man es von einer Sprache erwarten würde, die 
+   // ihren Geltungsbereich nach Blöcken richtet
+
+// Daraus ergibt sich ein bestimmtes Muster für sofort-ausführbare, anonyme 
+// Funktionen, die es vermeiden, dass der globale Geltungsbereich von Variablen
+// 'verschmutzt' wird.
+(function(){
+    var temporary = 5;
+    // Auf eine Variable im globalen Geltungsbereich kann zugegriffen werden, 
+    // sofern sie im globalen Objekt definiert ist (in einem Webbrowser ist 
+    // dies immer das 'window'-Objekt, in anderen Umgebungen, bspw. Node.js, 
+    // kann das anders aussehen). 
+    window.permanent = 10;
+})();
+temporary; // wirft einen ReferenceError
+permanent; // = 10
+
+// Eines der mächtigsten Charakteristika von JavaScript sind Closures. Wird 
+// eine Funktion innerhalb einer anderen Funktion definiert, dann hat die 
+// innere Funktion Zugriff auf alle Variablen der äußeren Funktion, sogar dann,
+// wenn die äußere Funktion beendet wurde.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout wird asynchron ausgeführt. Also wird sayHelloInFiveSeconds 
+    // sofort verlassen und setTimeout wird die innere Funktion 'im nachhinein' 
+    // aufrufen. Dennoch: Weil sayHelloInFiveSeconds eine Hülle um die innere 
+    // Funktion bildet, hat die innere Funktion immer noch Zugriff auf die 
+    // Variable prompt.
+}
+sayHelloInFiveSeconds("Adam");  // wird nach 5 Sekunden ein Popup mit der 
+                                // Nachricht "Hello, Adam!" öffnen.
+
+///////////////////////////////////
+// 5. Mehr über Objekte, Konstruktoren und Prototypen
+
+// Objekte können Funktionen enthalten.
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Wenn Funktionen aufgerufen werden, die zu einem Objekt gehören, können sie 
+// auf das eigene Objekt mit dem Schlüsselwort 'this' zugreifen.
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Worauf 'this' gesetzt wird, ist davon abhängig, wie die Funktion aufgerufen 
+// wird, nicht wo sie definiert wurde. Unsere Funktion wird daher nicht 
+// funktionieren, sofern sie außerhalb des Kontextes des Objekts aufgerufen 
+// wird.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Umgekehrt ist es möglich eine Funktion einem Objekt zuzuweisen und dadurch 
+// Zugriff auf den this-Kontext zu erhalten, sogar dann, wenn die Funktion dem
+// Objekt nach dessen Definition zugewiesen wird.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+// Mit den Methoden 'call' und 'apply' kann der Kontext eines Funktionsaufrufs
+// verändert werden
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+// 'apply' funktioniert beiahe identisch, erwartet die übergebenen Argumente
+// aber in einem Array
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+// Das ist hilfreich wenn man einer Funktion eine beliebige Zahl Argumente
+// übergeben kann
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// 'call' und 'apply' beeinflussen aber nur den spezifischen Aufruf.
+// Um den Kontext einer Funktion dauerhaft zu ändern wird 'bind' benutzt.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+// Mit 'bind' lassen sich Funktionen auch teilweise anwenden / "curryen".
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Wenn eine Funktion mit dem Schlüsselwort 'new' aufgerufen wird, dann wird 
+// ein neues Objekt erzeugt. Funktionen, die darauf ausgelegt sind in dieser 
+// Art aufgerufen zu werden, werden Konstruktoren genannt.
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Jedes JavaScript-Objekt hat einen Prototyp. Wenn man versucht auf eine 
+// Eigenschaft des Objekts zuzugreifen, das nicht im Objekt selbst existiert,
+// schaut der Interpreter in dessen Prototyp nach.
+
+// Einige JavaScript-Implementierungen erlauben den direkten Zugriff auf den 
+// Prototyp eines Objekts durch die magische Eigenschaft __proto__. Obwohl das
+// nützlich ist, um  Prototypen im Allgemeinen zu erklären, ist das nicht Teil
+// des Standards; zum Standard-Weg der Nutzung von Prototypen kommen wir 
+// später.
+var myObj = {
+    myString: "Hello world!",
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Das funktioniert auch bei Funktionen.
+myObj.myFunc(); // = "hello world!"
+
+// Sollte die Eigenschaft nicht im Prototypen des Objekts enthalten sein, dann
+// wird im Prototypen des Prototypen nachgesehen und so weiter.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Dafür wird nichts hin und her kopiert; jedes Objekt speichert eine Referenz
+// auf seinen Prototypen. Das heißt wenn der Prototyp geändert wird, dann 
+// werden die Änderungen überall sichtbar.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// Es wurde bereits erwähnt, dass __proto__ nicht zum Standard gehört und es 
+// gibt ebenso keinen Standard-Weg, um den Prototyp eines existierenden Objekts
+// zu ändern. Es gibt dennoch zwei Wege, wie man ein neues Objekt mit einem 
+// gegebenen Prototypen erzeugt.
+
+// Der erste Weg ist die Methode Object.create, die eine jüngere Ergänzung des
+// JavaScript-Standards ist und daher noch nicht in allen Implementierungen 
+// verfügbar.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Der zweite Weg, der immer funktioniert, hat mit den Konstruktoren zu tun. 
+// Konstruktoren haben eine Eigenschaft, die Prototyp heißt.  Dabei handelt es
+// sich *nicht* um den Prototypen der Konstruktor-Funktion; stattdessen handelt
+// es sich um den Prototypen, der einem neuen Objekt mitgegeben wird, wenn es 
+// mit dem Konstruktor und dem Schlüsselwort 'new' erzeugt wird.
+MyConstructor.prototype = {
+    getMyNumber: function(){
+        return this.myNumber
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+
+// Alle primitiven Typen, also strings und numbers, haben auch Konstruktoren, 
+// die zu dem Typ äquivalente Wrapper-Objekte erzeugen. 
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Genau genommen: Sie sind nicht exakt äquivalent.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // Dieser Teil wird nicht ausgeführt, weil 0 'falsy' ist.
+}
+
+// Das Wrapper-Objekt und die regulären, eingebauten Typen, teilen sich einen 
+// Prototyp; so ist es möglich zum Beispiel einem String weitere Funktionen 
+// hinzuzufügen.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Diese Tatsache wird häufig bei einer Methode mit dem Namen 'polyfilling'
+// verwendet: Dabei wird ein neues Feature von JavaScript in einer älteren 
+// Untermenge der Sprache integriert, so dass bestimmte Funktionen auch in 
+// älteren Umgebungen und Browsern verwendet werden können.
+
+// Ein Beispiel: Es wurde erwähnt, dass die Methode Object.create nicht in 
+// allen Umgebungen verfügbar ist - wir können sie dennoch verwenden, mit einem
+// 'polyfill':
+if (Object.create === undefined){ // überschreib nichts, was eventuell bereits
+                                  // existiert
+    Object.create = function(proto){
+        // erstelle einen vorübergehenden Konstruktor mit dem richtigen
+        // Prototypen
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // verwende es dann, um ein neues Objekt mit einem passenden 
+        // Prototypen zurückzugeben
+        return new Constructor();
+    }
+}
+```
+
+## Zur weiteren Lektüre (englisch)
+
+Das [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) bietet eine ausgezeichnete Dokumentation für die Verwendung von JavaScript im Browser. Es ist außerdem ein Wiki und ermöglicht es damit anderen zu helfen, wenn man selbst ein wenig Wissen angesammelt hat.
+
+MDN's [A re-introduction to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) führt sehr viele der hier vorgestellten Konzepte im Detail aus. 
+
+Dieses Tutorial hat nur die Sprache JavaScript vorgestellt; um mehr über den  Einsatz in Websites zu lernen, ist es ein guter Start etwas über das [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) zu lernen.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) ist eine tiefgehende Einführung in die kontra-intuitiven Parts der Sprache.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) ist ein Klassiker unter den Referenzen.
+
+Zusätzlich zu direkten Beiträgen zu diesem Artikel ist der Inhalt in Anlehnung an Louie Dinh's Python-Tutorial auf dieser Seite und das [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) des Mozilla Developer Network entstanden.
diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
index 1bae332c..3674f2f5 100644
--- a/de-de/make-de.html.markdown
+++ b/de-de/make-de.html.markdown
@@ -1,263 +1,263 @@
----

-category: tool

-tool: make

-contributors:

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

-    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

-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äftigt 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, dass 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, dass 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)

-

+---
+category: tool
+tool: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+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äftigt 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, dass 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, dass 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/nix-de.html.markdown b/de-de/nix-de.html.markdown
index ffe8dffc..a55a91c7 100644
--- a/de-de/nix-de.html.markdown
+++ b/de-de/nix-de.html.markdown
@@ -356,6 +356,9 @@ with builtins; [
 
 * [Susan Potter - Nix Cookbook - Nix By Example]
   (https://ops.functionalalgebra.com/nix-by-example/)
-  
+
+* [Zero to Nix - Nix Tutorial]
+  (https://zero-to-nix.com/)
+
 * [Rommel Martinez - A Gentle Introduction to the Nix Family]
   (https://web.archive.org/web/20210121042658/https://ebzzry.io/en/nix/#nix)
diff --git a/de-de/pug-de.html.markdown b/de-de/pug-de.html.markdown
index c86494ce..ce31c648 100644
--- a/de-de/pug-de.html.markdown
+++ b/de-de/pug-de.html.markdown
@@ -162,13 +162,13 @@ case bestellungsStatus
 //- <p class="warn">Deine Bestellung steht noch aus</p>
 
 //- --INCLUDE--
-//- File path -> "includes/nav.png"
+//- File path -> "includes/nav.pug"
 h1 Firmenname
 nav
   a(href="index.html") Home
   a(href="about.html") Ãœber uns
 
-//- Dateipfad -> "index.png"
+//- Dateipfad -> "index.pug"
 html
   body
     include includes/nav.pug
@@ -205,4 +205,4 @@ mixin comment(name, kommentar)
 ### Zusätzliche Ressourcen
 - [The Site](https://pugjs.org/)
 - [The Docs](https://pugjs.org/api/getting-started.html)
-- [Github Repo](https://github.com/pugjs/pug)
+- [GitHub Repo](https://github.com/pugjs/pug)
diff --git a/de-de/pyqt-de.html.markdown b/de-de/pyqt-de.html.markdown
index 93ee20d4..3b9b6ebb 100644
--- a/de-de/pyqt-de.html.markdown
+++ b/de-de/pyqt-de.html.markdown
@@ -21,7 +21,7 @@ Diese Version wurde in pyqt erstellt.
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
 	# Erschafft ein Anwendungsobjekt.
     app = QtGui.QApplication(sys.argv)
@@ -48,10 +48,10 @@ if __name__ == '__main__':
 
 Damit wir weitere fortgeschrittene Funktionen in **pyqt** verwenden können,
 müssen wir anfangen zusätzliche Elemente zu bauen.
-Hier zeigen wir wie man eine Dialog Popup Box einführt. 
+Hier zeigen wir wie man eine Dialog Popup Box einführt.
 Diese ist nützlich, um den Benutzer eine Entscheidung zu bestätigen oder um Informationen anzuzeigen.
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -70,7 +70,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Diese Funktion soll ein Dialogfenster mit einem Knopf erschaffen.
 # Der Knopf wartet bis er geklickt wird und beendet das Programm
 def showdialog():
diff --git a/de-de/qt-de.html.markdown b/de-de/qt-de.html.markdown
index 480030fe..7d287cab 100644
--- a/de-de/qt-de.html.markdown
+++ b/de-de/qt-de.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: Qt Framework
-language: c++
+language: C++
 filename: learnqt-de.cpp
 contributors:
     - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
diff --git a/de-de/rst-de.html.markdown b/de-de/rst-de.html.markdown
index 072299f5..0eb2b6bf 100644
--- a/de-de/rst-de.html.markdown
+++ b/de-de/rst-de.html.markdown
@@ -86,14 +86,14 @@ erstellt werden, aber ich empfehle dir dafür die komplette Dokumentation zu les
 
 Es gibt mehrere Möglichkeiten um Links zu machen:
 
-- Wenn man einen Unterstrich hinter einem Wort hinzufügt: Github_ Zusätzlich 
+- Wenn man einen Unterstrich hinter einem Wort hinzufügt: GitHub_ Zusätzlich 
 muss man die Zielurl nach dem Text hinzufügen. 
 (Dies hat den Vorteil, dass man keine unnötigen Urls in lesbaren Text einfügt.
 - Wenn man die vollständige Url eingibt : https://github.com/
 (Dies wird automatisch in ein Link konvertiert.)
-- Wenn man es mehr Markdown ähnlich eingibt: `Github <https://github.com/>`_ .
+- Wenn man es mehr Markdown ähnlich eingibt: `GitHub <https://github.com/>`_ .
 
-.. _Github https://github.com/
+.. _GitHub https://github.com/
 
 ```
 
diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown
index 8025a8c0..23571377 100644
--- a/de-de/ruby-de.html.markdown
+++ b/de-de/ruby-de.html.markdown
@@ -685,4 +685,4 @@ _(z.T. auf Englisch)_
 - [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/) - Eine ältere [freie Ausgabe](http://ruby-doc.com/docs/ProgrammingRuby/) ist online verfügbar.
 - [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Ein von der Community erstellter Ruby coding style guide.
-- [Try Ruby](http://tryruby.org) - Lerne die Grundlagen der Ruby Programmiersprache, interaktiv im Browser.
+- [Try Ruby](https://try.ruby-lang.org/) - Lerne die Grundlagen der Ruby Programmiersprache, interaktiv im Browser.
diff --git a/de-de/rust-de.html.markdown b/de-de/rust-de.html.markdown
index faa4ec2b..6208db68 100644
--- a/de-de/rust-de.html.markdown
+++ b/de-de/rust-de.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["P1start", "http://p1start.github.io/"]
 translators:
@@ -255,7 +255,7 @@ fn main() {
 
     // `for` Schleife/Iterationen
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 8abf9a14..d0b4eb9d 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -3,95 +3,92 @@ category: tool
 tool: vim
 lang: de-de
 contributors:
-    - ["RadhikaG", "https://github.com/RadhikaG"]
+- ["RadhikaG", "https://github.com/RadhikaG"]
 translators:
-    - ["caminsha", "https://github.com/caminsha"]
+- ["caminsha", "https://github.com/caminsha"]
 filename: LearnVim-de.txt
 ---
 
-
 [Vim](http://www.vim.org)
 (Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
-Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt 
-wurde.
-Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten
-einer Datei.
+Texteditor, welcher mit Fokus auf Geschwindigkeit und Produktivität entwickelt
+wurde. Vim hat viele Keybindings für ein schnelles navigieren und schnelles
+bearbeiten einer Datei.
 
 ## Grundlagen, um in Vim zu navigieren
 
 ```
-    vim <filename>   # Öffne <filename> in Vim
-    :help <topic>    # Open up built-in help docs about <topic> if any exists
-    :help <topic>    # Öffne die eingebaute Hilfe zum Thema  <topic>, wenn
-                     # es existiert
-    :q               # Schließe vim
-    :w               # Speichere diese Datei
-    :wq              # Speichere diese Datei und schließe vim
-    ZZ               # Speichere diese Datei und schließe vim
-    :q!              # Schließe vim ohne die Datei zu speichern
-                     # ! *zwingt* die Ausführung von :q,
-                     # daher wird die Datei nicht gespeichert.
-    ZQ               # Beende vim ohne die Datei zu speichern
-    :x               # Speichere die Datei und beende vim
-                     # Dies ist eine kürzere Version von :wq
-
-    u                # Änderung rückgängig machen
-    CTRL+R           # Änderung wiederherstellen
-
-    h                # Den Cursor um ein Zeichen nach links bewegen
-    j                # Den Cursor eine Zeile nach unten bewegen
-    k                # Den Cursor eine Zeile nach oben bewegen
-    l                # Den Cursor um ein Zeichen nach rechts bewegen
-
-    Ctrl+B 	         # Gehe eine Bildschirmanzeige zurück
-    Ctrl+F 	         # Gehe eine Bildschirmanzeige vorwärts
-    Ctrl+D 	         # Gehe eine halbe Bildschirmanzeige vorwärts
-    Ctrl+U           # Gehe eine halbe Bildschirmanzeige zurück
-
-    # Navigieren innerhalb einer Zeile
-
-    0                # Navigiere zum Anfang der Zeile
-    $                # Navigiere zum Ende der Zeile
-    ^                # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
-
-    # Im Text suchen
-
-    /word            # Hebt alle Ergebnisse nach dem Cursor hervor
-    ?word            # Hebt alle Ergebnisse vor dem Cursor hervor
-    n                # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
-    N                # Bewegt den Cursor zum vorherigen Ergebnis der Suche
-
-    :%s/foo/bar/g    # Ersetze "foo" durch "bar" in allen Zeilen
-    :s/foo/bar/g     # Ersetze "foo" durch "bar" in der aktuellen Zeile
-    :%s/\n/\r/g      # Ersetze das newline-Zeichen bei allen Zeilen durch
-                     # ein carriage return
-
-    # Zu einzelnen Zeichen springen
-
-    f<character>     # Springe vorwärts und auf dem Zeichen  <character>
-    t<character>     # Springe vorwärts und lande vor dem Zeichen <character>
-
-    # Zum Beispiel,
-    f<               # Springe vorwärts und lande auf <
-    t<               # Springe vorwärts und lande vor <
-
-    # Wortweise navigieren
-
-    w                # Springe um ein Wort vorwärts
-    b                # Gehe ein Wort zurück
-    e                # Springe zum Ende des aktuellen Wortes
-
-    # Weitere Befehle, um zu navigieren
-
-    gg               # Gehe an den Start der Datei
-    G                # Gehe an das Ende der Datei
-    :NUM             # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
-    H                # Navigiere zum Start der aktuellen Bildschirmanzeige
-    M                # Navigiere in die Mitte der aktuellen Bildschirmanzeige
-    L                # Navigiere an das Ende der aktuellen Bildschirmanzeige
+vim <filename>   # Öffne <filename> in Vim
+:help <topic>    # Öffne die eingebaute Hilfe zum Thema  <topic>, wenn
+                 # es existiert
+:q               # Schließe vim
+:w               # Speichere diese Datei
+:wq              # Speichere diese Datei und schließe vim
+ZZ               # Speichere diese Datei und schließe vim
+:q!              # Schließe vim ohne die Datei zu speichern
+                 # ! *zwingt* die Ausführung von :q,
+                 # daher wird die Datei nicht gespeichert.
+ZQ               # Beende vim ohne die Datei zu speichern
+:x               # Speichere die Datei und beende vim
+                 # Dies ist eine kürzere Version von :wq
+
+u                # Änderung rückgängig machen
+CTRL+R           # Änderung wiederherstellen
+
+h                # Den Cursor um ein Zeichen nach links bewegen
+j                # Den Cursor eine Zeile nach unten bewegen
+k                # Den Cursor eine Zeile nach oben bewegen
+l                # Den Cursor um ein Zeichen nach rechts bewegen
+
+Ctrl+B           # Gehe eine Bildschirmanzeige zurück
+Ctrl+F           # Gehe eine Bildschirmanzeige vorwärts
+Ctrl+D           # Gehe eine halbe Bildschirmanzeige vorwärts
+Ctrl+U           # Gehe eine halbe Bildschirmanzeige zurück
+
+# Navigieren innerhalb einer Zeile
+
+0                # Navigiere zum Anfang der Zeile
+$                # Navigiere zum Ende der Zeile
+^                # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
+
+# Im Text suchen
+
+/word            # Hebt alle Ergebnisse nach dem Cursor hervor
+?word            # Hebt alle Ergebnisse vor dem Cursor hervor
+n                # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
+N                # Bewegt den Cursor zum vorherigen Ergebnis der Suche
+
+:%s/foo/bar/g    # Ersetze "foo" durch "bar" in allen Zeilen
+:s/foo/bar/g     # Ersetze "foo" durch "bar" in der aktuellen Zeile
+:%s/\n/\r/g      # Ersetze das newline-Zeichen bei allen Zeilen durch
+                 # ein carriage return
+
+# Zu einzelnen Zeichen springen
+
+f<character>     # Springe vorwärts und auf dem Zeichen  <character>
+t<character>     # Springe vorwärts und lande vor dem Zeichen <character>
+
+# Zum Beispiel,
+f<               # Springe vorwärts und lande auf <
+t<               # Springe vorwärts und lande vor <
+
+# Wortweise navigieren
+
+w                # Springe um ein Wort vorwärts
+b                # Gehe ein Wort zurück
+e                # Springe zum Ende des aktuellen Wortes
+
+# Weitere Befehle, um zu navigieren
+
+gg               # Gehe an den Start der Datei
+G                # Gehe an das Ende der Datei
+:NUM             # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
+H                # Navigiere zum Start der aktuellen Bildschirmanzeige
+M                # Navigiere in die Mitte der aktuellen Bildschirmanzeige
+L                # Navigiere an das Ende der aktuellen Bildschirmanzeige
 ```
 
-## Hilfsdokumente:
+## Hilfsdokumente
 
 Vim hat eine eingebaute Dokumentation, welche mit `:help <topic>` aufgerufen
 werden kann.
@@ -99,34 +96,33 @@ Zum Beispiel öffnet `:help navigation` die Dokumentation über das Navigieren
 
 `:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard-
 Hilfsdialog an, welcher den Start mit vim einfacher macht.
-that aims to make getting started with vim more approachable!
 
-## Modi:
+## Modi
 
 Vim basiert auf dem Konzept von **modes**.
 
-- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und Befehle eingeben
+- Command Mode - Vims erster Modus, hier kann man navigieren und Befehle eingeben
 - Insert Mode  - Wird verwendet, um Änderungen in der Datei zu machen.
-- Visual Mode  - Wird verwendet, um Text zu markieren und Operationen durchzuführen
+- Visual Mode  - Wird verwendet, um Text zu markieren und diesen zu verändern
 - Ex Mode      - Wird verwendet, um im ':'-Prompt Befehle einzugeben
 
 ```
-    i                # Führt vim in den Insert Mode, vor der Cursorposition
-    a                # Führt vim in den Insert Mode, nach der Cursorposition
-    v                # Führt vim in den Visual Mode
-    :                # Führt vim in den Ex Mode
-    <esc>            # Führt zurück in den Command Mode, egal in welchem Mode
-                     # man sich gerade befindet.
-
-    # Kopieren und einfügen von Text
-
-    y                # Kopiere alles, was im Moment ausgewählt ist
-    yy               # Kopiert die aktuelle Zeile
-    d                # Löscht alles, was im Moment ausgewählt ist
-    dd               # Löscht die aktuelle Zeile
-    p                # Fügt den kopierten Text nach dem Cursor ein
-    P                # Fügt den kopierten Text vor dem Cursor ein
-    x                # Löscht das Zeichen unter dem Cursor
+i                # Führt vim in den Insert Mode, vor der Cursorposition
+a                # Führt vim in den Insert Mode, nach der Cursorposition
+v                # Führt vim in den Visual Mode
+:                # Führt vim in den Ex Mode
+<esc>            # Führt zurück in den Command Mode, egal in welchem Mode
+                 # man sich gerade befindet.
+
+# Kopieren und einfügen von Text
+
+y                # Kopiere alles, was im Moment ausgewählt ist
+yy               # Kopiert die aktuelle Zeile
+d                # Löscht alles, was im Moment ausgewählt ist
+dd               # Löscht die aktuelle Zeile
+p                # Fügt den kopierten Text nach dem Cursor ein
+P                # Fügt den kopierten Text vor dem Cursor ein
+x                # Löscht das Zeichen unter dem Cursor
 ```
 
 ## Die 'Grammatik' von Vim
@@ -141,68 +137,67 @@ Vim kann als Satz von Kommandos angesehen werden, welche im Format
 Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
 
 ```
-    # 'Verb'
-
-    d                # löschen
-    c                # ändern
-    y                # kopieren
-    v                # visuelles auswählen
-
-    # 'Modifiers'
-
-    i                # innerhalb
-    a                # außerhalb
-    NUM              # Nummer (NUM kann irgendeine Zahl sein)
-    f                # Sucht nach etwas und landet darauf
-    t                # Sucht nach etwas und stoppt davor
-    /                # Suche eine Zeichenfolge ab dem Cursor
-    ?                # Suche eine Zeichenfolge vor dem Cursor
-
-    # 'Nouns'
-
-    w                # Wort
-    s                # Satz
-    p                # Abschnitt
-    b                # Block
-
-    # Beispielsätze resp. Kommandos
-
-    d2w              # lösche zwei Wörter
-    cis              # Ändere innerhalb des Satzes.
-    yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt, 
-                     # in welchem du bist)
-    ct<              # Ändere bis zur spitzen Klammer
-                     # Ändere den Text von deiner aktuellen Cursorposition bis
-                     # zur nächsten spitzen Klammer
-    d$               # Lösche bis zum Ende der Zeile
+# 'Verb'
+
+d                # löschen
+c                # ändern
+y                # kopieren
+v                # visuelles auswählen
+
+# 'Modifiers'
+
+i                # innerhalb
+a                # außerhalb
+NUM              # Nummer (NUM kann irgendeine Zahl sein)
+f                # Sucht nach etwas und landet darauf
+t                # Sucht nach etwas und stoppt davor
+/                # Suche eine Zeichenfolge ab dem Cursor
+?                # Suche eine Zeichenfolge vor dem Cursor
+
+# 'Nouns'
+
+w                # Wort
+s                # Satz
+p                # Abschnitt
+b                # Block
+
+# Beispielsätze resp. Kommandos
+
+d2w              # lösche zwei Wörter
+cis              # Ändere innerhalb des Satzes.
+yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
+                 # in welchem du bist)
+ct<              # Ändere bis zur spitzen Klammer
+                 # Ändere den Text von deiner aktuellen Cursorposition bis
+                 # zur nächsten spitzen Klammer
+d$               # Lösche bis zum Ende der Zeile
 ```
 
 ## Einige Shortcuts und Tricks
 
 ```
-    >                # Rücke die Auswahl um einen Block ein
-    <                # Lösche eine Einrückung der Auswahl
-    :earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15 
-                     # Minuten war
-    :later 15m       # den oberen Befehl rückgängig machen
-    ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
-                     # Zuerst dd, dann p
-    .                # Wiederhole die vorherige Aktion
-    :w !sudo tee %   # Speichere die Datei als Root
-    :set syntax=c    # Stelle das Syntax-Highlighting für 'C' ein
-    :sort            # Alle Zeilen sortieren
-    :sort!           # Alle Zeilen rückwärts sortieren
-    :sort u          # Alle Zeilen sortieren und Duplikate entfernen
-    ~                # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
-    u                # Ausgewählten Text zu Kleinschreibung ändern
-    U                # Ausgewählten Text zu Großschreibung ändern
-    
-    # Text-Folding (Textfaltung)
-    zf               # Erstelle eine Faltung des ausgewählten Textes
-    zo               # Öffne die aktuelle Faltung
-    zc               # Schließe die aktuelle Faltung
-    zR               # Öffne alle Faltungen
-    zM               # Schließe alle Faltungen
+>                # Rücke die Auswahl um einen Block ein
+<                # Lösche eine Einrückung der Auswahl
+:earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15 Minuten war
+:later 15m       # den oberen Befehl rückgängig machen
+ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
+                 # Zuerst dd, dann p
+.                # Wiederhole die vorherige Aktion
+:w !sudo tee %   # Speichere die Datei als Root
+:set syntax=c    # Stelle das Syntax-Highlighting für 'C' ein
+:sort            # Alle Zeilen sortieren
+:sort!           # Alle Zeilen rückwärts sortieren
+:sort u          # Alle Zeilen sortieren und Duplikate entfernen
+~                # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
+u                # Ausgewählten Text zu Kleinschreibung ändern
+U                # Ausgewählten Text zu Großschreibung ändern
+
+# Text-Folding (Textfaltung)
+zf               # Erstelle eine Faltung des ausgewählten Textes
+zo               # Öffne die aktuelle Faltung
+zc               # Schließe die aktuelle Faltung
+zR               # Öffne alle Faltungen
+zM               # Schließe alle Faltungen
 ```
 
 ## Makros
@@ -213,9 +208,9 @@ Kommandos, welche du braucht, aufgenommen bis die Aufnahme gestoppt wird.
 Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht.
 
 ```
-    qa               # Starte das Aufnehmen des Makros 'a'
-    q                # Beende das Aufnehmen
-    @a               # Führe das Makro 'a' aus
+qa               # Starte das Aufnehmen des Makros 'a'
+q                # Beende das Aufnehmen
+@a               # Führe das Makro 'a' aus
 ```
 
 ### Konfigurieren mit ~/.vimrc
diff --git a/de-de/visualbasic-de.html.markdown b/de-de/visualbasic-de.html.markdown
new file mode 100644
index 00000000..6194e906
--- /dev/null
+++ b/de-de/visualbasic-de.html.markdown
@@ -0,0 +1,290 @@
+---
+language: Visual Basic
+contributors:
+    - ["Brian Martin", "http://brianmartin.biz"]
+translators:
+    - ["Enno Nagel", "https://github.com/konfekt"]
+filename: learnvisualbasic-de.vb
+lang: de-de
+---
+
+```visualbasic
+Module Modul1
+
+Sub Main()
+  ' Ein kurzer Blick auf Visual Basic-Konsolenanwendungen
+  ' bevor wir tiefer in das Thema eintauchen.
+  ' Das Hochkomma leitet eine Kommentarzeile ein.
+  ' Um dieses Tutorial innerhalb des Visual Basic Compilers zu erkunden,
+  ' habe ich ein Navigationssystem erstellt.
+  ' Dieses System wird im weiteren Verlauf des Tutorials erklärt;
+  ' Sie werden nach und nach verstehen, was das alles bedeutet.
+  Console.Title = ("Lerne X in Y Minuten")
+  Console.WriteLine ("NAVIGATION") 'Anzeige
+  Console.WriteLine ("")
+  Console.ForegroundColor = ConsoleColor.Green
+  Console.WriteLine ("1. Ausgabe von 'Hallo, Welt'")
+  Console.WriteLine ("2. Eingabe 'Hallo, Welt'")
+  Console.WriteLine ("3. ganze Zahlen berechnen")
+  Console.WriteLine ("4. Berechne Dezimalzahlen")
+  Console.WriteLine ("5. ein funktionaler Taschenrechner")
+  Console.WriteLine ("6. 'Do While'-Schleifen verwenden")
+  Console.WriteLine ("7. Verwendung von 'For While'-Schleifen")
+  Console.WriteLine ("8. Bedingte Anweisungen")
+  Console.WriteLine ("9. Ein Getränk auswählen")
+  Console.WriteLine ("50. Ãœber")
+  Console.WriteLine ("Wählen Sie eine Zahl aus der obigen Liste")
+  Dim selection As String = Console.Readline()
+  Select Case auswahl
+    Case "1" 'Ausgabe "Hallo, Welt"
+      Console.Clear() 'Löscht die Konsole und öffnet die private Subroutine
+      AusgabeHalloWelt() 'Öffnet die genannte private Subroutine
+    Case "2" 'Eingabe "hallo, Welt"
+      Console.Clear()
+      EingabeHalloWelt()
+    Case "3" 'Berechne ganze Zahlen
+      Console.Clear()
+      BerechneGanzeZahlen()
+    Case "4" 'Dezimalzahlen berechnen
+      Console.Clear()
+      BerechneDezimalZahlen()
+    Case "5" 'Ein funktionaler Taschenrechner
+      Console.Clear()
+      Taschenrechner()
+    Case "6" 'Verwendung von "Do While"-Schleifen
+      Console.Clear()
+      WhileSchleife()
+    Case "7" 'Verwendung von "For While"-Schleifen
+      Console.Clear()
+      ForSchleife()
+    Case "8" 'Bedingte Anweisungen
+      Console.Clear()
+      BedingteAnweisung()
+    Case "9" 'If/Else-Anweisung
+      Console.Clear()
+      IfElseAnweisung() 'Ein Getränk auswählen
+    Case "50" '"Ãœber" Infobox
+      Console.Clear()
+      Console.Title = ("Lernen Sie X in Y Minuten :: Ãœber")
+      MsgBox ("Tutorial geschrieben von Brian Martin (@BrianMartinn)")
+      Console.Clear()
+      Main()
+      Console.ReadLine()
+
+  End Select
+End Sub
+
+'Eins - Ich habe Zahlen verwendet, um mich durch das obige Navigationssystem zu
+'führen auf das ich später zurückkomme, um es zu implementieren.
+
+'wir verwenden private Unterprogramme, um verschiedene Abschnitte des Programms
+'zu trennen.
+Private Sub AusgabeHalloWelt()
+  'Titel der Konsolenanwendung
+  Console.Title = "Ausgabe 'Hallo, Welt' | Lerne X in Y Minuten"
+  'Verwenden Sie Console.Write("") oder Console.WriteLine(""), um die Ausgabe
+  'anzuzeigen, gefolgt von Console.Read(), oder Console.Readline()
+  'Console.ReadLine() zeigt die Ausgabe auf der Konsole an.
+  Console.WriteLine ("Hallo, Welt")
+  Console.ReadLine()
+End Sub
+
+'Zwei
+Private Sub EingabeHalloWelt()
+  Console.Title = "Hallo, Welt, ich bin.. | Lerne X in Y Minuten"
+  'Variablen
+  'Vom Benutzer eingegebene Daten müssen gespeichert werden.
+  'Variablen beginnen ebenfalls mit Dim und enden mit As VariableType.
+
+  'In diesem Lernprogramm wollen wir Ihren Namen wissen und das Programm
+  'auf ihn antworten.
+  Dim nutzername As String
+  ' Wir verwenden "String", weil es sich um eine textbasierte Variable handelt.
+  Console.WriteLine ("Hallo, wie ist Ihr Name?") 'Frage nach dem Benutzernamen.
+  nutzername = Console.ReadLine() 'Benutzernamen speichern.
+  Console.WriteLine ("Hallo, " + nutzername) 'Ausgabe ist Hallo, Name
+  Console.ReadLine() 'Die obige Ausgabe anzeigen.
+  'Der obige Code stellt Ihnen eine Frage und zeigt die Antwort an.
+  'Neben anderen Variablentypen gibt es Integer, den wir für ganze Zahlen
+  'verwenden werden.
+End Sub
+
+'Drei
+Private Sub BerechneGanzeZahlen()
+  Console.Title = "Berechne ganze Zahlen | Lerne X in Y Minuten"
+  Console.Write ("Erste Zahl: ") 'Schreiben Sie eine ganze Zahl, 1, 2, 104, usw
+  Dim a As Integer = Console.ReadLine()
+  Console.Write ("Zweite Zahl: ") 'Schreiben Sie eine weitere ganze Zahl.
+  Dim b As Integer = Console.ReadLine()
+  Dim c As Integer = a + b
+  Console.WriteLine (c)
+  Console.ReadLine()
+  'Dies ist ein einfacher Taschenrechner
+End Sub
+
+'Vier
+Private Sub BerechneDezimalZahlen()
+  Console.Title = "Berechne mit dem Typ Double | Lerne X in Y Minuten"
+  'Natürlich würden wir gerne Dezimalzahlen addieren.
+  'Also könnten wir von Integer auf Double umstellen.
+
+  'Schreiben Sie eine Bruchzahl, 1.2, 2.4, 50.1, 104.9 usw
+  Console.Write ("Erste Zahl: ")
+  Dim a As Double = Console.Readline()
+  Console.Write ("Zweite Zahl: ") 'Schreiben Sie die zweite Zahl.
+  Dim b As Double = Console.Readline()
+  Dim c As Double = a + b
+  Console.WriteLine (c)
+  Console.ReadLine()
+  'Dieses Programm kann 1.1 und 2.2 addieren
+End Sub
+
+'Fünf
+Private Sub Taschenrechner()
+  Console.Title = "Der Funktionsrechner | Lerne X in Y Minuten"
+  'Wenn Sie aber wollen, dass der Rechner subtrahiert, dividiert,
+  'multipliziert und addiert.
+  'Kopieren Sie den obigen Text und fügen Sie ihn ein.
+  Console.Write ("Erste Zahl: ")
+  Dim a As Double = Console.Readline()
+  Console.Write ("Zweite Zahl: ")
+  Dim b As Integer = Console.Readline()
+  Dim c As Integer = a + b
+  Dim d As Integer = a * b
+  Dim e As Integer = a - b
+  Dim f As Integer = a / b
+
+  'Mit den folgenden Zeilen können wir  die Werte a und b
+  'subtrahieren, multiplizieren und dividieren
+  Console.Write (a.ToString() + " + " + b.ToString())
+  'Wir wollen den Ergebnissen einen linken Rand von 3 Leerzeichen geben.
+  Console.WriteLine (" = " + c.ToString.PadLeft(3))
+  Console.Write (a.ToString() + " * " + b.ToString())
+  Console.WriteLine (" = " + d.ToString.PadLeft(3))
+  Console.Write (a.ToString() + " - " + b.ToString())
+  Console.WriteLine (" = " + e.ToString.PadLeft(3))
+  Console.Write (a.ToString() + " / " + b.ToString())
+  Console.WriteLine (" = " + f.ToString.PadLeft(3))
+  Console.ReadLine()
+
+End Sub
+
+'Sechs
+Private Sub WhileSchleife()
+  'Gleich zur vorherigen privaten Subroutine.
+  'Diesmal fragen wir den Benutzer, ob er fortfahren möchte (ja oder nein?).
+  'Wir verwenden die Do While-Schleife, weil wir nicht wissen, ob der Benutzer
+  'das Programm mehr als einmal verwenden möchte.
+  Console.Title = "Do While-Schleifen verwenden | X in Y Minuten lernen"
+  Dim antwort As String 'Wir verwenden "String", weil die Antwort ein Text ist
+  Do 'Wir beginnen das Programm mit
+    Console.Write ("Erste Zahl: ")
+    Dim a As Double = Console.Readline()
+    Console.Write ("Zweite Zahl: ")
+    Dim b As Integer = Console.Readline()
+    Dim c As Integer = a + b
+    Dim d As Integer = a * b
+    Dim e As Integer = a - b
+    Dim f As Integer = a / b
+
+    Console.Write (a.ToString() + " + " + b.ToString())
+    Console.WriteLine (" = " + c.ToString.PadLeft(3))
+    Console.Write (a.ToString() + " * " + b.ToString())
+    Console.WriteLine (" = " + d.ToString.PadLeft(3))
+    Console.Write (a.ToString() + " - " + b.ToString())
+    Console.WriteLine (" = " + e.ToString.PadLeft(3))
+    Console.Write (a.ToString() + " / " + b.ToString())
+    Console.WriteLine (" = " + f.ToString.PadLeft(3))
+    Console.ReadLine()
+    'Fragen Sie den Benutzer, ob er fortfahren möchte. Unglücklicherweise
+    'werden Groß- und Kleinschreibung unterschieden.
+    Console.Write ("Möchten Sie fortfahren? (j / n)")
+    'Das Programm nimmt die Variable, zeigt sie an und beginnt von vorne.
+    antwort = Console.Readline()
+    'Der Befehl, der diese Variable zum Laufen bringt, ist in diesem Fall "j"
+  Loop While antwort = "j"
+
+End Sub
+
+'Sieben
+Private Sub ForSchleife()
+  'Manchmal muss das Programm nur einmal ausgeführt werden.
+  'In diesem Programm werden wir von 10 loszählen.
+
+  Console.Title = "Mit "For"-Schleifen | X in Y Minuten lernen"
+  'Deklarieren Sie die Variable und ab welcher Zahl in Schritt -1 gezählt
+  'werden soll, Schritt -2, Schritt -3, usw.
+  For i As Integer = 10 To 0 Schritt -1
+    Console.WriteLine (i.ToString) 'Zählerwert anzeigen
+  Next i 'Berechne den neuen Wert
+  Console.WriteLine ("Start") 'Starten wir das Programm, baby!!!!
+  Console.ReadLine() 'BANG!!!! - Vielleicht war ich zu aufgeregt :)
+End Sub
+
+'Acht
+Private Sub BedingteAnweisung()
+  Console.Title = "Bedingte Anweisungen | X in Y Minuten lernen"
+  Dim username As String = Console.Readline()
+  'Aufforderung zur Eingabe des Benutzernamens.
+  Console.WriteLine ("Hallo, wie ist Ihr Name?")
+  username = Console.ReadLine() 'Benutzernamen speichern.
+  If username = "Adam" Then
+    Console.WriteLine ("Hallo, Adam")
+    Console.WriteLine ("Danke, dass Sie diese nützliche Website erstellt haben")
+    Console.ReadLine()
+  Else
+    Console.WriteLine ("Hallo, " + Benutzername)
+    Console.WriteLine ("Haben Sie www.learnxinyminutes.com besucht?")
+    Console.ReadLine() 'Beendet und zeigt die obige Anweisung an.
+  End If
+End Sub
+
+  'Neun
+Private Sub IfElseAnweisung()
+    Console.Title = "If / Else-Anweisung | X in Y Minuten lernen"
+    'Manchmal ist es wichtig, mehr als zwei Alternativen in Betracht zu ziehen.
+    'Manchmal sind einige von ihnen besser.
+    'In diesem Fall brauchen wir mehr als eine "if"-Anweisung.
+    'Eine "if"-Anweisung ist für Verkaufsautomaten geeignet.
+    'Der Benutzer gibt einen Code ein (A1, A2, A3), aus dem er wählen kann.
+    'Alle Auswahlmöglichkeiten können in einer einzigen "if"-Anweisung
+    'kombiniert werden.
+
+    Dim auswahl As String = Console.ReadLine 'Der Wert der Auswahl
+    Console.WriteLine ("A1. für 7Up")
+    Console.WriteLine ("A2. für Fanta")
+    Console.WriteLine ("A3. für Dr. Pepper")
+    Console.WriteLine ("A4. für Coca-Cola")
+    Console.ReadLine()
+  If auswahl = "A1" Dann
+    Console.WriteLine ("7up")
+    Console.ReadLine()
+  ElseIf auswahl = "A2" Then
+    Console.WriteLine ("fanta")
+    Console.ReadLine()
+  ElseIf auswahl = "A3" Then
+    Console.WriteLine ("Dr. Pfeffer")
+    Console.ReadLine()
+  ElseIf auswahl = "A4" Then
+    Console.WriteLine ("Coca-Cola")
+    Console.ReadLine()
+  Else
+    Console.WriteLine ("Ein Produkt auswählen")
+    Console.ReadLine()
+  End If
+
+End Sub
+
+End Module
+```
+
+## Referenzen
+
+Für diejenigen, die mehr wissen wollen, hat Brian Martin ein umfassenderes
+[Visual Basic Tutorial](http://www.vbbootcamp.co.uk/ "Visual Basic Tutorial")
+erstellt.
+
+Die gesamte Syntax sollte gültig sein.
+Kopieren Sie den Code und fügen Sie ihn in den Visual Basic Compiler ein und
+führen Sie das Programm aus (F5).
+
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
index 0332c912..00e4fd94 100644
--- a/de-de/yaml-de.html.markdown
+++ b/de-de/yaml-de.html.markdown
@@ -112,7 +112,7 @@ python_komplexe_Zahlen: !!python/komplex 1+2j
 ####################
 
 # Strings und Zahlen sind nicht die einzigen Skalare, welche YAML versteht.
-# ISO-formatierte Datumsangaben and Zeiangaben können ebenso geparsed werden.
+# ISO-formatierte Datumsangaben and Zeitangaben können ebenso geparsed werden.
 DatumZeit: 2001-12-15T02:59:43.1Z
 DatumZeit_mit_Leerzeichen: 2001-12-14 21:59:43.10 -5
 Datum: 2002-12-14
diff --git a/directx9.html.markdown b/directx9.html.markdown
index b51f418d..586865c8 100644
--- a/directx9.html.markdown
+++ b/directx9.html.markdown
@@ -12,7 +12,7 @@ all began with Direct, such as Direct3D, DirectDraw, DirectMusic, DirectPlay, Di
 Direct3D (the 3D graphics API within DirectX) is widely used in the development of video games for Microsoft
 Windows and the Xbox line of consoles.<sup>[1]</sup>
 
-In this tutorial we will be focusing on DirectX 9, which is not as low-level as it's sucessors, which are aimed at programmers very familiar with how graphics hardware works. It makes a great starting point for learning Direct3D. In this tutorial I will be using the Win32-API for window handling and the DirectX 2010 SDK.
+In this tutorial we will be focusing on DirectX 9, which is not as low-level as it's successors, which are aimed at programmers very familiar with how graphics hardware works. It makes a great starting point for learning Direct3D. In this tutorial I will be using the Win32-API for window handling and the DirectX 2010 SDK.
 
 ## Window creation
 
@@ -125,7 +125,7 @@ bool InitD3D(HWND hWnd) {
     pp.hDeviceWindow = hWnd;                  // associated window handle
     pp.Windowed = true;                       // display in window mode
     pp.Flags = 0;                             // no special flags
-    // Variable to store results of methods to check if everything succeded.
+    // Variable to store results of methods to check if everything succeeded.
     HRESULT result{ };
     result = _d3d->CreateDevice(D3DADAPTER_DEFAULT, // use default graphics card
                                 D3DDEVTYPE_HAL,     // use hardware acceleration
@@ -144,7 +144,7 @@ bool InitD3D(HWND hWnd) {
     viewport.Y = 0;         // ..
     viewport.Width = clientRect.right;   // use the entire window
     viewport.Height = clientRect.bottom; // ..
-    viewport.MinZ = 0.0f;   // minimun view distance
+    viewport.MinZ = 0.0f;   // minimum view distance
     viewport.MaxZ = 100.0f; // maximum view distance
     // Apply the created viewport.
     result = _device->SetViewport(&viewport);
@@ -157,7 +157,7 @@ bool InitD3D(HWND hWnd) {
 // ...
 // Back in our WinMain function we call our initialization function.
 // ...
-// Check if Direct3D initialization succeded, else exit the application.
+// Check if Direct3D initialization succeeded, else exit the application.
 if (!InitD3D(hWnd))
     return -1;
         
@@ -197,7 +197,7 @@ Let's create a vertex buffer to store the vertices for our triangle
 #include <vector>
 // First we declare a new ComPtr holding a vertex buffer.
 ComPtr<IDirect3DVertexBuffer9> _vertexBuffer{ };
-// Lets define a funtion to calculate the byte size of a std::vector
+// Lets define a function to calculate the byte size of a std::vector
 template <typename T>
 unsigned int GetByteSize(const std::vector<T>& vec) {
     return sizeof(vec[0]) * vec.size();
@@ -253,7 +253,7 @@ if (!InitD3D(hWnd))
     return -1;
 // Define the vertices we need to draw a triangle.
 // Values are declared in a clockwise direction else Direct3D would cull them.
-// If you want to diable culling just call:
+// If you want to disable culling just call:
 // _device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
 std::vector<VStruct> vertices {
     // Bottom left
@@ -274,7 +274,7 @@ if (!(_vertexBuffer = CreateBuffer(vertices)))
 Before we can use the vertex buffer to draw our primitives, we first need to set up the matrices.
 
 ```cpp
-// Lets create a new funtions for the matrix transformations.
+// Lets create a new functions for the matrix transformations.
 bool SetupTransform() {
     // Create a view matrix that transforms world space to
     // view space.
@@ -338,7 +338,7 @@ if (FAILED(result))
 // Create a world transformation matrix and set it to an identity matrix.
 D3DXMATRIX world{ };
 D3DXMatrixIdentity(&world);
-// Create a scalation matrix scaling our primitve by 10 in the x,
+// Create a scalation matrix scaling our primitive by 10 in the x,
 // 10 in the y and keeping the z direction.
 D3DXMATRIX scaling{ };
 D3DXMatrixScaling(&scaling, // matrix to scale
@@ -499,7 +499,7 @@ std::vector<D3DVERTEXELEMENT9> vertexDeclDesc {
       0,                     // byte offset from the struct beginning
       D3DDECLTYPE_FLOAT3,    // data type (3d float vector)
       D3DDECLMETHOD_DEFAULT, // tessellator operation
-      D3DDECLUSAGE_POSTION,  // usage of the data
+      D3DDECLUSAGE_POSITION,  // usage of the data
       0 },                   // index (multiples usage of the same type)
     { 0,
       12,                    // byte offset (3 * sizeof(float) bytes)
diff --git a/docker.html.markdown b/docker.html.markdown
index 1dad267a..ec6abe7e 100644
--- a/docker.html.markdown
+++ b/docker.html.markdown
@@ -1,147 +1,281 @@
----

-language: docker

-filename: docker.bat

-contributors:

-    - ["Ruslan López", "http://javapro.org/"]

-    - ["Michael Chen", "https://github.com/ML-Chen"]

----

-

-```bat

-:: download, install and run hello-world image

-docker run hello-world

-

-:: if this is the first time you should be able to see the message

-:: Unable to find image 'hello-world:latest' locally

-:: latest: Pulling from library/hello-world

-:: 1b930d010525: Pull complete                                                                                          

-::   Digest: sha256:4fe721ccc2e8dc7362278a29dc660d833570ec2682f4e4194f4ee23e415e1064

-:: Status: Downloaded newer image for hello-world:latest

-:: 

-:: Hello from Docker!

-:: This message shows that your installation appears to be working correctly.

-:: 

-:: To generate this message, Docker took the following steps:

-:: 1. The Docker client contacted the Docker daemon.

-:: 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

-::     (amd64)

-:: 3. The Docker daemon created a new container from that image which runs the

-::     executable that produces the output you are currently reading.

-:: 4. The Docker daemon streamed that output to the Docker client, which sent it

-::     to your terminal.

-:: 

-:: To try something more ambitious, you can run an Ubuntu container with:

-::  $ docker run -it ubuntu bash

-:: 

-:: Share images, automate workflows, and more with a free Docker ID:

-::  https://hub.docker.com/

-:: 

-:: For more examples and ideas, visit:

-:: https://docs.docker.com/get-started/

-

-:: now let's see currently running images

-docker ps

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            

-::   NAMES

-

-:: let's see the images we have ran previously

-docker ps -a

-

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS     

-::          NAMES

-:: 4a76281f9c53        hello-world         "/hello"            2 minutes ago       Exited (0) 2 minutes ago             

-::          happy_poincare

-:: the name part is generated automatically so it probably will be different for you

-

-:: let's remove our previously generated image

-docker rm happy_poincare

-

-:: let's test if it was really deleted

-docker ps -a

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            

-::   NAMES

-

-:: specify a custom name for the container

-docker run --name test_container hello-world

-:: Hello from Docker!

-:: This message shows that your installation appears to be working correctly.

-:: 

-:: To generate this message, Docker took the following steps:

-::  1. The Docker client contacted the Docker daemon.

-::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

-::     (amd64)

-::  3. The Docker daemon created a new container from that image which runs the

-::     executable that produces the output you are currently reading.

-::  4. The Docker daemon streamed that output to the Docker client, which sent it

-::     to your terminal.

-:: 

-:: To try something more ambitious, you can run an Ubuntu container with:

-:: $ docker run -it ubuntu bash

-:: 

-:: Share images, automate workflows, and more with a free Docker ID:

-::  https://hub.docker.com/

-:: 

-:: For more examples and ideas, visit:

-::  https://docs.docker.com/get-started/

-

-docker ps -a

-:: CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                         PORTS

-::               NAMES

-:: d345fe1a4f41        hello-world         "/hello"            About a minute ago   Exited (0) About a minute ago       

-::                test_container

-:: as you can see the name is now what we have specified

-

-:: retrieve logs from a named container

-docker logs test_container

-:: Hello from Docker!

-:: This message shows that your installation appears to be working correctly.

-:: 

-:: To generate this message, Docker took the following steps:

-::  1. The Docker client contacted the Docker daemon.

-::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

-::     (amd64)

-::  3. The Docker daemon created a new container from that image which runs the

-::     executable that produces the output you are currently reading.

-::  4. The Docker daemon streamed that output to the Docker client, which sent it

-::     to your terminal.

-:: 

-:: To try something more ambitious, you can run an Ubuntu container with:

-:: $ docker run -it ubuntu bash

-:: 

-:: Share images, automate workflows, and more with a free Docker ID:

-::  https://hub.docker.com/

-:: 

-:: For more examples and ideas, visit:

-::  https://docs.docker.com/get-started/

-

-docker rm test_container

-

-docker run ubuntu

-::  Unable to find image 'ubuntu:latest' locally

-::  latest: Pulling from library/ubuntu

-::  2746a4a261c9: Pull complete                                                                                         

-::                                                        4c1d20cdee96: Pull complete                                                                                                                                                 0d3160e1d0de: Pull complete                                                                                                                                                 c8e37668deea: Pull complete                                                                                                                                                 Digest: sha256:250cc6f3f3ffc5cdaa9d8f4946ac79821aafb4d3afc93928f0de9336eba21aa4

-::  Status: Downloaded newer image for ubuntu:latest

-

-docker ps -a

-::  CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS    

-::           NAMES

-::  c19e9e5b000a        ubuntu              "/bin/bash"         5 seconds ago       Exited (0) 4 seconds ago            

-::           relaxed_nobel

-

-::  running a container in an interactive mode

-docker run -it ubuntu

-::  root@e2cac48323d2:/# uname

-::  Linux

-::  root@e2cac48323d2:/# exit

-::  exit

-

-docker rm relaxed_nobel

-

-docker ps -a

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                          PORTS

-::               NAMES

-:: e2cac48323d2        ubuntu              "/bin/bash"         2 minutes ago       Exited (0) About a minute ago        

-::               nifty_goldwasser

-

-docker rm nifty_goldwasser

-```

+---
+category: tool
+tool: docker
+filename: docker.bat
+contributors:
+    - ["Ruslan López", "http://javapro.org/"]
+    - ["Michael Chen", "https://github.com/ML-Chen"]
+    - ["Akshita Dixit", "https://github.com/akshitadixit"]
+    - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"]
+---
+
+Docker is a tool that helps you build, test, ship and run applications
+seamlessly across various machines. It replicates the environment our software
+needs on any machine. You can get Docker for your machine from
+https://docs.docker.com/get-docker/
+
+It has grown in popularity over the last decade due to being lightweight and
+fast as compared to virtual-machines that are bulky and slow. Unlike VMs, docker
+does not need a full blown OS of its own to be loaded to start and does not
+compete for resources other than what the application it is running will use.
+VMs on the other hand are pretty resource intensive on our processors, disks and
+memory hence running multiple VMs for various applications becomes a challenge
+in a limited capacity architecture.
+
+<pre>
+┌────────────────────────� ┌───────────────────────�
+│      ┌───────────�     │ │      ┌───────────�    │
+│      │   App     │     │ │      │   App     │    │
+│      └───────────┘     │ │      └───────────┘    │
+│  ┌────────� ┌────────� │ │  ┌────────� ┌───────� │
+│  │  Libs  │ │  Deps  │ │ │  │  Libs  │ │  Deps │ │
+│  └────────┘ └────────┘ │ │  └────────┘ └───────┘ │
+│  ┌───────────────────� │ │  ┌──────────────────� │
+│  │      Guest OS     │ │ │  │     Guest OS     │ │
+│  └───────────────────┘ │ │  └──────────────────┘ │
+│           VM1          │ │           VM2         │
+└────────────────────────┘ └───────────────────────┘
+┌──────────────────────────────────────────────────�
+│                     Hypervisor                   │
+└──────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────�
+│                      Host OS                     │
+└──────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────�
+│             Hardware Infrastructure              │
+└──────────────────────────────────────────────────┘
+              (VM based architecture)
+
+┌────────────────────────� ┌───────────────────────�
+│      ┌───────────�     │ │      ┌───────────�    │
+│      │   App     │     │ │      │   App     │    │
+│      └───────────┘     │ │      └───────────┘    │
+│  ┌────────� ┌────────� │ │  ┌────────� ┌───────� │
+│  │  Libs  │ │  Deps  │ │ │  │  Libs  │ │  Deps │ │
+│  └────────┘ └────────┘ │ │  └────────┘ └───────┘ │
+│        Container1      │ │       Container2      │
+└────────────────────────┘ └───────────────────────┘
+┌──────────────────────────────────────────────────�
+│                       Docker                     │
+└──────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────�
+│                        OS                        │
+└──────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────�
+│             Hardware Infrastructure              │
+└──────────────────────────────────────────────────┘
+            (Docker based architecture)
+
+</pre>
+
+Couple of terms we will encounter frequently are Docker Images and Docker
+Containers. Images are packages or templates of containers all stored in a
+container registry such as [Docker Hub](https://hub.docker.com/). Containers
+are standalone, executable instances of these images which include code,
+runtime, system tools, system libraries and settings - everything required to
+get the software up and running. Coming to Docker, it follows a client-server
+architecture wherein the CLI client communicates with the server component,
+which here is, the Docker Engine using RESTful API to issue commands.
+
+## The Docker CLI
+```bash
+# after installing Docker from https://docs.docker.com/get-docker/
+# To list available commands, either run `docker` with no parameters or execute
+# `docker help`
+$ docker
+
+>>> docker [OPTIONS] COMMAND [ARG...]
+       docker [ --help | -v | --version ]
+
+    A self-sufficient runtime for containers.
+
+    Options:
+        --config string      Location of client config files (default "/root/.docker")
+    -c, --context string     Name of the context to use to connect to the daemon (overrides DOCKER_HOST env var and default context set with "docker context use")
+    -D, --debug              Enable debug mode
+        --help               Print usage
+    -H, --host value         Daemon socket(s) to connect to (default [])
+    -l, --log-level string   Set the logging level ("debug"|"info"|"warn"|"error"|"fatal") (default "info")
+        --tls                Use TLS; implied by --tlsverify
+        --tlscacert string   Trust certs signed only by this CA (default "/root/.docker/ca.pem")
+        --tlscert string     Path to TLS certificate file (default "/root/.docker/cert.pem")
+        --tlskey string      Path to TLS key file (default "/root/.docker/key.pem")
+        --tlsverify          Use TLS and verify the remote
+    -v, --version            Print version information and quit
+
+    Commands:
+        attach    Attach to a running container
+        # […]
+
+$ docker run hello-world
+# `docker run <container-name>` is used to run a container, it will pull the
+# images from Docker Hub if they don't already exist in your system. Here the
+# docker client connects to the daemon which in turn pulls the "hello-world"
+# image from the Docker Hub. The daemon then builds a new container from the
+# image which runs the executable that produces the output streamed back to the
+# client that we see on our terminals.
+
+$ docker run -d ubuntu sleep 60s
+# The -d (or --detach) flag is when we want to run a container in the background
+# and return back to the terminal. Here we detach an ubuntu container from the
+# terminal, the output should be the id and the command exits. If we check
+# running containers, we should still see ours there:
+# CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS         PORTS     NAMES
+# 133261b4894a   ubuntu    "sleep 60s"   3 seconds ago   Up 2 seconds             vigorous_gould
+
+$ docker run <container-id> -p 3000:8000
+# The -p (or --publish) flag is used to expose port 8000 inside the container to
+# port 3000 outside the container. This is because the app inside the container
+# runs in isolation, hence the port 8000 where the app runs is private to the
+# container.
+
+$ docker run -i
+# or
+$ docker run -it
+# Docker runs our containers in a non-interactive mode i.e. they do not accept
+# inputs or work dynamically while running. The -i flag keeps input open to the
+# container, and the -t flag creates a pseudo-terminal that the shell can attach
+# to (can be combined as -it)
+
+$ docker ps -a
+# The `docker ps` command only shows running containers by default. To see all
+# containers, use the -a (or --all) flag
+# Running the above command should output something similar in the terminal:
+# CONTAINER ID   IMAGE         COMMAND    CREATED         STATUS                     PORTS     NAMES
+# 82f84bf6912b   hello-world   "/hello"   9 minutes ago   Exited (0) 9 minutes ago             eloquent_sammet
+
+
+$ docker stop hello-world
+# or
+$ docker start hello-world 
+# The stop command simply stops one or more containers, and the start command
+# starts the container(s) up again! `docker start -a ubuntu` will attach our
+# detached container back to the terminal i.e. runs in the foreground
+
+$ docker create alpine
+# `docker create` creates a new container for us with the image specified (here,
+# alpine), the container does not auto-start unlike `docker run`. This command
+# is used to set up a container configuration and then `docker start` to shoot
+# it up when required. Note that the status is "Created":
+# CONTAINER ID   IMAGE         COMMAND       CREATED             STATUS           PORTS     NAMES
+# 4c71c727c73d   alpine        "/bin/sh"     29 seconds ago      Created                   naughty_ritchie
+
+$ docker rm 82f84
+# Removes one or more containers using their container ID.
+# P.S.: we can use only the first few characters of the entire ID to identify
+# containers
+
+$ docker images
+# Displays all images and their information, created here means the latest image
+# tag updated on Docker Hub:
+# REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
+# ubuntu        latest    a8780b506fa4   9 days ago      77.8MB
+# alpine        latest    9c6f07244728   3 months ago    5.54MB
+# hello-world   latest    feb5d9fea6a5   13 months ago   13.3kB
+
+$ docker rmi 
+# Removes one or more images from your system which do not have their instances
+# (or containers as we know them) running. If the image has an attached
+# container, either delete the container first or use the -f (or --force) flag
+# to forcefully delete both the container and image.
+
+$ docker pull busybox
+# The pull command downloads the specified image on our system from Docker Hub.
+
+$ docker exec -it 7b272 bash
+# This command is used to run a command in the running container's default
+# directory. Here 7b272 was our ubuntu container and the above command would
+# help us interact with the container by opening a bash session.
+
+$ docker logs <container-id>
+# Displays the information logged by the specified container
+# root@7b27222e4bb7:/# whoami
+# root
+# root@7b27222e4bb7:/# pwd
+# /
+# root@7b27222e4bb7:/# ls
+# bin  boot  dev  etc  home  lib  lib32  lib64 libx3 srv  sys  tmp  usr  var
+# root@7b27222e4bb7:/# exit
+# exit
+
+# More commands can be found at https://docs.docker.com/engine/reference/commandline/docker/
+```
+## The Dockerfile
+The Dockerfile is a blueprint of a Docker image. We can mention the artifacts
+from our application along with their configurations into this file in the 
+specific syntax to let anyone create a Docker image of our application.
+
+### A few things to keep in mind:
+* It is always strictly named `Dockerfile` without any extensions
+* We have to build our custom image on top of some already available Docker base 
+image. (there is an empty image called `scratch` which literally lets you build
+an image from scratch)
+* All capitalised commands are part of the syntax, they are not case-sensitive
+but used like a convention
+* Below is a sample Dockerfile but you can read in depth from the [official docs](https://docs.docker.com/engine/reference/builder/).
+
+```Dockerfile
+FROM <base-image>
+# define base image
+
+ENV USERNAME='admin'\
+    PWD='****'
+# optionally define environmental variables
+
+RUN apt-get update
+# run linux commands inside container env, does not affect host env
+# This executes during the time of image creation
+
+COPY <src> <target>
+# executes on the host, copies files from src (usually on the host) to target
+# on the container
+
+ENTRYPOINT ["some-script.sh"]
+# executes an entire script as an entrypoint
+
+CMD [<args>,...]
+# always part of dockerfile, introduces entry point linux command e.g. 
+# `CMD node server.js`
+# This executes after image creation only when the container from the image
+# is running.
+```
+### Build your images
+Use the `docker build` command after wrapping your application into a Docker
+image to run ( or build) it.
+
+```bash
+
+$ docker build <path-to-dockerfile>
+# used to build an image from the specified Dockerfile
+# instead of path we could also specify a URL
+# -t tag is optional and used to name and tag your images for e.g.
+# `$ docker build -t my-image:0.1 ./home/app`
+# rebuild images everytime you make changes in the dockerfile
+```
+
+## Push your image to DockerHub
+If you want your application's Docker image to be made publicly available for
+any Docker user, you might wanna push it to the [Docker Hub](https://hub.docker.com/) which is a
+registry of Docker images. Make sure you have an account with a username and
+password on Docker Hub.
+
+When pushing an image to Docker Hub, we must specify our Docker Hub username
+as part of the source image name. We need to create the target image with the
+tag name of username/image-name much like GitHub repositories. 
+
+```bash
+$ docker login
+# to login to Docker Hub using your username and password
+
+$ docker tag <src-image>[:<src-tag>] <target-image>[:<target-tag>]
+# this tags a local src-image to a public target-image
+# e.g. `docker tag my-sample-app:1.0.0  akshitadixit/my-sample-app`
+# if tags are not specified, they're defaulted to `latest`
+
+$ docker push <target-image>[:<target-tag>]
+# uploads our image to Docker Hub
+# e.g. `docker push akshitadixit/my-sample-app`
+# this image will be accessible under your profile's repositories as
+# `https://hub.docker.com/r/username/image-name`
+
+```
diff --git a/dynamic-programming.html.markdown b/dynamic-programming.html.markdown
index 3e3c0413..ff053384 100644
--- a/dynamic-programming.html.markdown
+++ b/dynamic-programming.html.markdown
@@ -59,5 +59,3 @@ for i=0 to n-1
   * [Optimal Substructure Property](https://www.geeksforgeeks.org/dynamic-programming-set-2-optimal-substructure-property/)
   * [How to solve a DP problem](https://www.geeksforgeeks.org/solve-dynamic-programming-problem/)
 * [How to write DP solutions](https://www.quora.com/Are-there-any-good-resources-or-tutorials-for-dynamic-programming-DP-besides-the-TopCoder-tutorial/answer/Michal-Danilák)
-
-And a [quiz](https://www.commonlounge.com/discussion/cdbbfe83bcd64281964b788969247253) to test your knowledge.
diff --git a/easylang.html.markdown b/easylang.html.markdown
new file mode 100644
index 00000000..ba33dbf2
--- /dev/null
+++ b/easylang.html.markdown
@@ -0,0 +1,221 @@
+---
+language: Easylang
+contributors:
+    - ["chkas", "https://github.com/chkas"]
+filename: easylang.el
+---
+
+**Easylang** is a simple programming language with built-in graphical functions and an easy-to-use and offline usable browser IDE. Its simple syntax and semantics make it well suited as a teaching and learning programming language. You can also use it to write graphical applications that you can embed in a web page. 
+
+*Easylang* is statically typed and has as data types only strings and numbers (floating point), resizeable arrays of strings and numbers and arrays of arrays.
+
+[The browser IDE](https://easylang.online/ide/) includes various tutorials, including one for beginners.
+
+```
+print "Hello world"
+#
+# number variable (64 bit floating point)
+#
+h = 3.14
+print h
+#
+# string variable
+#
+str$ = "monkey"
+# strings can grow
+str$ &= " circus" 
+print str$
+#
+# blocks end with 'end' or a dot, a newline has no
+# other meaning than a space
+#
+for i = 1 to 5
+  sum += i * i
+.
+print sum
+#
+# functions have value and reference
+# parameters, no return values
+#
+func gcd a b . res .
+  # a and b are value parameters
+  # res is a reference parameter
+  while b <> 0
+    # h is a local variable, because 
+    # it is first used in the function
+    h = b
+    b = a mod b
+    a = h
+  .
+  res = a
+.
+call gcd 120 35 r
+print r
+#
+# strings can be concatenated and numbers are
+# automatically converted to strings
+#
+print "1 + 2 = " & 1 + 2
+#
+# array of numbers
+#
+a[] = [ 2.1 3.14 3 ]
+#
+# arrays can grow
+a[] &= 4
+print a[]
+#
+# arrays, strings and numbers are copied by value
+#
+b[] = a[]
+a[] &= 4
+print a[] ; print b[]
+#
+# array swapping ist fast
+#
+swap a[] b[]
+print a[] ; print b[]
+# 
+# array of strings
+#
+fruits$[] = [ "apple" "banana" "orange" ]
+#
+# for-in iterates over the elements of an array
+#
+for fruit$ in fruits$[]
+  print fruit$
+.
+#
+# strings are also used for single characters
+#
+letters$[] = str_chars "ping"
+print letters$[]
+letters$[1] = "o"
+print str_join letters$[]
+#
+# 2-dimensional arrays are arrays of arrays
+# this defines 3 arrays with length 4
+#
+len a[][] 3
+for i range len a[][]
+  len a[i][] 4
+.
+a[1][2] = 99
+print a[][]
+#
+# builtin functions
+if sin 90 = 1
+  print "angles are in degree"
+.
+print pow 2 8
+# seconds since 1970
+print floor sys_time
+# random numbers
+print randomf
+print random 6 + 1
+# 
+# hour and minutes
+print substr time_str sys_time 11 5
+# 
+print str_ord "A"
+print str_chr 65
+# 
+# set number format
+numfmt 0 4
+print sqrt 2
+print pi
+print logn 10
+# 
+a$[] = str_split "10,15,22" ","
+print a$[]
+print 2 * number a$[0]
+print len a$[]
+print len "Hello"
+#
+# With 'break n' you can leave nested loops and a function
+#
+names$[] = [ ]
+func name2id name$ . id .
+  for id range len names$[]
+    if names$[id] = name$
+      # leave loop and function
+      break 2
+    .
+  .
+  names$[] &= name$
+.
+call name2id "alice" id ; print id
+call name2id "bob" id ; print id
+call name2id "alice" id ; print i
+#
+# with 'repeat' you can make loops, which you can leave
+# in the loop body using 'until'
+#
+sum = 0
+repeat
+  s$ = input
+  until s$ = ""
+  sum += number s$
+.
+print "sum: " & sum
+#
+# "input" reads a string from the "input_data" section, 
+# if it exists, otherwise via a prompt.
+#
+input_data
+10
+-2
+6
+```
+
+Built-in graphic primitives and event-driven programming
+
+```
+# simple drawing with the mouse
+# 
+set_linewidth 4
+set_color 900
+# the colors are coded from 0 to 999, with 
+# the left digit specifying the red component,
+# the middle digit the green component and
+# the right digit the blue component. 
+# 
+on mouse_down
+  down = 1
+  move_pen mouse_x mouse_y
+  # moves the drawing pen to the actual mouse position
+  draw_circle 2
+.
+on mouse_up
+  down = 0
+.
+on mouse_move
+  if down = 1
+    draw_line mouse_x mouse_y
+  .
+.
+```
+
+```
+# an animated pendulum
+#
+on animate
+  # The animate event occurs after each screen refresh.
+  #
+  clear_screen
+  move_pen 50 50
+  draw_circle 1
+  x = 50 + 40 * sin ang
+  y = 50 - 40 * cos ang
+  draw_line x y
+  draw_circle 5
+  vel += sin ang / 5
+  ang += vel
+.
+ang = 10
+```
+
+* [More about Easylang](https://easylang.online/)
+
+* [Source code](https://github.com/chkas/easylang)
+
diff --git a/el-gr/ocaml-gr.html.markdown b/el-gr/ocaml-gr.html.markdown
new file mode 100644
index 00000000..9a15b2d3
--- /dev/null
+++ b/el-gr/ocaml-gr.html.markdown
@@ -0,0 +1,381 @@
+---
+language: OCaml
+filename: learnocaml-gr.ml
+contributors:
+    - ["Daniil Baturin", "http://baturin.org/"]
+translators:
+    - ["Chariton Charitonidis", "https://github.com/haritonch"]
+lang: el-gr
+---
+
+Η OCaml είναι μία strictly evaluated συνα�τησιακή γλώσσα με κάποια στοιχεία
+π�οστακτικο� π�ογ�αμματισμο�.
+
+Μαζί με την StandardML και τις διαλέκτους της, ανήκει στην οικογένεια ML γλωσσών.
+Η F# είναι επίσης α�κετά επι��εασμένη από την OCaml.
+
+Ακ�ιβώς όπως η StandardML, η OCaml διαθέτει έναν interpreter, που μπο�εί να
+χ�ησιμοποιηθεί διαδ�αστικά, αλλά και έναν compiler.
+Το εκτελέσιμο α�χείο του interpreter κανονικά έχει το όνομα "ocaml" και ο compiler
+έχει το όνομα "ocamlopt".
+Υπά�χει και ένας bytecode compiler "ocamlc", αλλά δεν υπά�χουν πολλοί λόγοι να το
+χ�ησιμοποιήσει κάποιος.
+
+Είναι ισχυ�ά και στατικά τυποποιημένη. Πα�'όλα αυτά , δεν χ�ειάζεται ο
+π�ογ�αμματιστής να δηλώνει τους τ�πους, καθώς συμπε�ασμός τ�πων γίνεται με τον
+αλγό�ιθμο του συστήματος τ�πων Hindley-Milner. Αυτό κάνει τις δηλώσεις τ�πων μη
+αναγκαίες στις πε�ισσότε�ες πε�ιπτώσεις, αλλά μπο�εί να είναι δ�σκολο στην α�χή.
+
+Όταν είμαστε στο toplevel της OCaml (read-eval-print-loop), η OCaml τυπώνει τον
+τ�πο που συμπε�αίνει όταν εισάγουμε μια έκφ�αση.
+
+```
+# let inc x = x	+ 1 ;;
+val inc : int -> int = <fun>
+# let a = 99 ;;
+val a : int = 99
+```
+Για ένα source α�χείο μπο�ο�με να χ�ησιμοποιο�με την εντολή
+"ocamlc -i /path/to/file.ml" στο terminal για να τυπώσει όλα τα ονόματα και
+τους τ�πους.
+
+```
+$ cat sigtest.ml
+let inc x = x + 1
+let add x y = x + y
+
+let a = 1
+
+$ ocamlc -i ./sigtest.ml
+val inc : int -> int
+val add : int -> int -> int
+val a : int
+```
+
+Σημειώστε ότι τα type signatures των συνα�τήσεων με πολλά ο�ίσματα είναι
+γ�αμμένα σε curried form. Μια συνά�τηση με πολλά ο�ίσματα μπο�εί να
+αναπα�ασταθεί ως σ�νθεση συνα�τήσεων με μόνο ένα ό�ισμα.
+Η "f(x,y) = x + y" από το πα�άδειγμα, όταν εφα�μόζεται στα ο�ίσματα 2 και 3
+είναι ισοδ�ναμη με την εφα�μογή της "f0(y) = 2 + y" στο 3. Γι' αυτό έχει τ�πο
+"int -> int -> int".
+
+
+```ocaml
+(*** Comments ***)
+
+(* Τα σχόλια πε�ικλείονται σε (* και *). Μπο�ο�ν να είναι και εμφωλευμένα *)
+
+(* Δεν υπά�χει ειδικό σ�μβολο για σχόλια μιας γ�αμμής *)
+
+
+(*** Μεταβλητές και Συνα�τήσεις ***)
+
+(* Οι εκφ�άσεις διαχω�ίζονται από διπλό semicolon, ";;".
+   Σε πολλές πε�ιπτώσεις είναι πε�ιττό, αλλά εδώ θα το χ�ησιμοποιο�με σε
+   κάθε έκφ�αση για ευκολότε�ο copy-paste στο interpreter shell.
+   Το να χ�ησιμοποιο�με πε�ιττά ;; σε α�χεία κώδικα θεω�είται συνήθως
+   κακό στυλιστικά. *)
+
+(* Οι δηλώσεις μεταβλητών και συνα�τήσεων χ�ησιμοποιο�ν το keyword "let" *)
+let x = 10 ;;
+
+(* Η OCaml επιτ�έπει χα�ακτή�ες μονών εισαγωγικών σε identifiers.
+   το μονό εισαγωγικό δεν έχει κάποια σημασία σε αυτή την πε�ίπτωση,
+   χ�ησιμοποιείται συνήθως σε πε�ιπτώσεις που σε άλλες γλώσσες χ�ησιμοποιο�με
+   ονόματα όπως "foo_tmp". *)
+let foo = 1 ;;
+let foo' = foo * 2 ;;
+
+(* Από τη στιγμή που ο compiler της OCaml συμπε�αίνει τους τ�πους αυτόματα,
+   κανονικά δεν χ�ειάζεται να δηλώνουμε �ητά τον τ�πο ο�ισμάτων. Πα�'όλα αυτά
+   μπο�ο�με να το κάνουμε αν θέλουμε ή χ�ειάζεται *)
+let inc_int (x: int) : int = x + 1 ;;
+
+(* Μία από αυτές τις πε�ιπτώσεις που είναι αναγκαίο να δηλώσουμε �ητά τ�πους
+   είναι για να λ�σουμε την αμφισημία μεταξ� δ�ο record types που έχουν πεδία με
+   όμοια ονόματα. Η εναλλακτική είναι να βάλουμε αυτο�ς τους τ�πους σε modules,
+   αλλά και τα δ�ο αυτά θέματα είναι εκτός του σκοπο� αυτο� το μαθήματος. *)
+
+(* Π�έπει να δηλώνουμε ότι μία συνά�τηση είναι αναδ�ομική με "rec". *)
+let rec factorial n =
+    if n = 0 then 1
+    else n * factorial (n-1)
+;;
+
+(* H εφα�μογή συνα�τήσεων συνήθως δεν χ�ειάζεται πα�ενθέσεις γ��ω από ο�ίσματα *)
+let fact_5 = factorial 5 ;;
+
+(* ...εκτός αν τα ο�ίσματα είναι εκφ�άσεις *)
+let fact_4 = factorial (5-1) ;;
+let sqr2 = sqr (-2) ;;
+
+(* Κάθε συνά�ητση π�έπει να έχει τουλάχιστον ένα ό�ισμα.
+   Από τη στιγμή που κάποιες συνα�τήσεις, από τη φ�ση τους, δεν παί�νουν κάποιο
+   ό�ισμα, υπά�χει ο τ�πος "unit" που έχει μόνο μία τιμή,
+   την οποία γ�άφουμε ως "()". *)
+let print_hello () = print_endline "hello world" ;;
+
+(* Π�οσέχετε ότι π�έπει να γ�άφουμε το "()" ως ό�ισμα και όταν την καλο�με. *)
+print_hello () ;;
+
+(* Το να καλο�με μια συνά�τηση με λιγότε�α ο�ίσματα από όσα δέχεται
+   δεν π�οκαλεί π�όβλημα, απλά πα�άγει μια νέα συνά�τηση. *)
+let make_inc x y = x + y ;; (* make_inc is int -> int -> int *)
+let inc_2 = make_inc 2 ;;   (* inc_2 is int -> int *)
+inc_2 3 ;; (* Αποτιμάται σε 5 *)
+
+(* Μπο�ο�με να χ�ησιμοποιο�με πολλές εκφ�άσεις στο σώμα μιας συνά�τησης.
+   Η αποτίμηση της τελευταίας έκφ�ασης είναι η τιμή που επιστ�έφει η συνά�τηση.
+   Όλες οι ενδιάμεσες εκφ�άσεις π�έπει να είναι τ�που "unit".
+   Αυτό είναι ιδιαίτε�α χ�ήσιμο όταν γ�άφουμε σε π�οστακτικό στυλ, η απλο�στε�η
+   μο�φή αυτο� είναι η εισαγωγή ενός debug print. *)
+let print_and_return x =
+    print_endline (string_of_int x);
+    x
+;;
+
+(* Ως συνα�τησιακή γλώσσα η OCaml δεν έχει "procedures" (διαδικασίες).
+   Κάθε συνά�τηση π�έπει να επιστ�έφει κάτι. Οπότε, συνα�τήσεις που δεν
+   επιστ�έφουν κάτι και καλο�νται μόνο για τις πα�ενέ�γειες τους,
+   όπως η print_endline, επιστ�έφουν τιμή τ�που "unit". *)
+
+
+(* Οι ο�ισμοί μπο�ο�ν να γίνουν αλυσιδωτά με τη δομή "let ... in".
+   Αυτό είναι πε�ίπου το ίδιο με το να αναθέτουμε τιμές σε πολλές μεταβλητές
+   π�ιν τις χ�ησιμοποιήσουμε σε εκφ�άσεις σε π�οστακτικές γλώσσες. *)
+let x = 10 in
+let y = 20 in
+x + y ;;
+
+(* Εναλλακτικά μπο�ο�με να χ�ησιμποιο�με τη δομή "let ... and ... in".
+   Αυτό είναι εξαι�ετικά χ�ήσιμο για αμοιβαία αποκλειόμενες συνα�τήσεις,
+   όπυ με "let .. in", ο compiler θα πα�απονιόταν για unbound values *)
+let rec
+  is_even = function
+  | 0 -> true
+  | n -> is_odd (n-1)
+and
+  is_odd = function
+  | 0 -> false
+  | n -> is_even (n-1)
+;;
+
+(* Οι ανώνυμες συνα�τήσεις χ�ησιμοποιο�ν την εξής σ�νταξη: *)
+let my_lambda = fun x -> x * x ;;
+
+(*** Τελεστές ***)
+
+(* Δεν υπά�χει ιδιαίτε�η διάκ�ιση ανάμεσα σε τελεστές και συνα�τήσεις.
+   Κάθε τελεστής μπο�εί να κληθεί ως συνά�τηση. *)
+
+(+) 3 4  (* Same as 3 + 4 *)
+
+(* Υπά�χει ένας α�ιθμός built-in τελεστών. Ένα ασυνήθιστο χα�ακτη�ιστικό είναι
+   ότι η OCaml δεν μπο�εί να κάνει έμμεση μετατ�οπή τ�πων
+   ανάμεσα σε ακε�αίους και floats, επίσης, χ�ησιμοποιεί διαφο�ετικο�ς τελεστές
+   για τους floats (α�ιθμο�ς κινητής υποδιαστολής) *)
+12 + 3 ;; (* Π�όσθεση ακε�αίων. *)
+12.0 +. 3.0 ;; (* Π�όσθεση κινητής υποδιαστολής. *)
+
+12 / 3 ;; (* Διαί�εση ακε�αίων. *)
+12.0 /. 3.0 ;; (* Διαί�εση κινητής υποδιαστολής. *)
+5 mod 2 ;; (* Υπόλοιπο. *)
+
+(* Το ενός-ο�ίσματος μείον είναι αξιοσημείωτη εξαί�εση, είναι πολυμο�φικό.
+   Ωστόσο, έχει καθα�ές μο�φές ακε�αίων και float. *)
+- 3 ;; (* Πολυμο�φικό, ακέ�αιοι *)
+- 4.5 ;; (* Πολυμο�φικό, float *)
+~- 3 (* Μόνο για integer *)
+~- 3.4 (* Type error *)
+~-. 3.4 (* Μόνο για float *)
+
+(* Μπο�ο�με να ο�ίζουμε δικο�ς μας τελεστές ή να ξανα-ο�ίσουμε υπά�χοντες.
+   Σε αντίθεση με την SML ή τη Haskell, μόνο ο�ισμένα σ�μβολα μπο�ο�ν να
+   χ�ησιμοποιηθο�ν για ονόματα τελεστών και το π�ώτο σ�μβολο ο�ίζει την
+   επιμε�ιστικότητα και π�οτε�αιότητα π�άξεων. *)
+let (+) a b = a - b ;; (* και καλή τ�χη στον επόμενο... *)
+
+(* Πιο χ�ήσιμο: ένας τελεστής αντιστ�όφου για floats.
+   οι τελεστές ενός-ο�ίσματος π�έπει να ξεκινο�ν με "~". *)
+let (~/) x = 1.0 /. x ;;
+~/4.0 (* = 0.25 *)
+
+
+(*** Built-in δομές δεδομένων ***)
+
+(* Οι λίστες πε�ικλείονται από αγκ�λες και τα στοιχεία τους
+   διαχω�ίζονται με semicolons. *)
+let my_list = [1; 2; 3] ;;
+
+(* Οι tuples (π�οαι�ετικά) πε�ικλείονται από πα�ενθέσεις, τα στοιχεία τους
+   διαχω�ίζονται με κόμματα. *)
+let first_tuple = 3, 4 ;; (* Έχει τ�πο "int * int". *)
+let second_tuple = (4, 5) ;;
+
+(* Συνέπεια: αν π�οσπαθήσεουμε να διαχω�ίσουμε τα στοιχεία μιας λίστας
+   με κόμματα, θα πά�ουμε μια λίστα με ένα tuple ως στοιχείο.
+   Μπο�εί να την πατήσουμε ε�κολα έτσι. *)
+let bad_list = [1, 2] ;; (* Becomes [(1, 2)] *)
+
+(* Μπ�ο�με να π�οσπελάσουμε στοιχεία μιας λίστας με τη συνά�τηση List.nth. *)
+List.nth my_list 1 ;;
+
+(* Yπά�χουν συνα�τήσεις ανώτε�ης τάξης για λίστες, όπως οι map και filter. *)
+List.map (fun x -> x * 2) [1; 2; 3] ;;
+List.filter (fun x -> x mod 2 = 0) [1; 2; 3; 4] ;;
+
+(* Μπο�ο�με να π�οσθέτουμε στοιχεία στην α�χή μιας λίστας με τον
+   constructor "::", συνήθως αναφέ�εται ως "cons". *)
+1 :: [2; 3] ;; (* Αποτέλεσμα: [1; 2; 3] *)
+
+(* Οι πίνακες Arrays πε�ικλείονται από [| |] *)
+let my_array = [| 1; 2; 3 |] ;;
+
+(* Π�οσπελα�νουμε στοιχεία ενός πίνακα ως εξής: *)
+my_array.(0) ;;
+
+
+(*** Strings και Χα�ακτή�ες ***)
+
+(* Χ�ησιμοποιο�με διπλά εισαγωγικά για τα string literals. *)
+let my_str = "Hello world" ;;
+
+(* Μονά εισαγωγικά για τα literals χα�ακτή�ων. *)
+let my_char = 'a' ;;
+
+(* Τα μονά και τα διπλά εισαγωγικά δεν είναι ισοδ�ναμα. *)
+let bad_str = 'syntax error' ;; (* Syntax error. *)
+
+(* Αυτό μας δίνει ένα string με έναν χα�ακτή�α και όχι εναν χα�ακτή�α. *)
+let single_char_str = "w" ;;
+
+(* Τα strings πα�ατίθενται με τον τελεστή "^". *)
+let some_str = "hello" ^ "world" ;;
+
+(* Τα strings δεν είναι πίνακες από χα�ακτή�ες όπως στην C.
+   Δεν μπο�ο�με να ανακατε�ουμε strings με χα�ακτή�ες σε εκφ�άσεις.
+   Μπο�ο�με να μετατ�έπουμε χα�ακτή�ες σε strings με "String.make 1 my_char".
+   Υπά�χουν πιο βολικές συνα�τήσεις για αυτό το σκοπό σε π�όσθετες βιβλιοθήκες,
+   όπως η Core.Std που μπο�εί να μην έχουν εγκατασταθεί/φο�τωθεί by default. *)
+let ocaml = (String.make 1 'O') ^ "Caml" ;;
+
+(* Υπά�χει και μια συνά�τηση printf. *)
+Printf.printf "%d %s" 99 "bottles of beer" ;;
+
+(* Υπά�χουν και συνα�τήσεις read/write χω�ίς μο�φοποίηση. *)
+print_string "hello world\n" ;;
+print_endline "hello world" ;;
+let line = read_line () ;;
+
+
+(*** User-defined τ�ποι δεδομένων ***)
+
+(* Μπο�ο�με να ο�ίζουμε τ�πους δεδομένων με τη δομή "type some_type".
+   Όπως σε αυτό τον άχ�ηστο τ�πο που αντιγ�άφει τους ακε�αίους: *)
+type my_int = int ;;
+
+(* Πιο ενδιαφέ�οντες τ�ποι πε�ιλαμβάνουν τους λεγόμενους type constructors.
+   Αυτοί π�έπει να ξεκινο�ν με κεφαλαίο γ�άμμα. *)
+type ml = OCaml | StandardML ;;
+let lang = OCaml ;;  (* Έχει τ�πο "ml". *)
+
+(* Οι type constructors δε χ�ειάζεται να είναι κενοί. *)
+type my_number = PlusInfinity | MinusInfinity | Real of float ;;
+let r0 = Real (-3.4) ;; (* Έχει τ�πο "my_number". *)
+
+(* Μπο�ο�ν να χ�ησιμοποιηθο�ν για πολυμο�φική α�ιθμιτική *)
+type number = Int of int | Float of float ;;
+
+(* Σημείο στο επίπεδο, βασικά ένα tuple πε�ιο�ισμένου συγκεκ�ιμένου τ�που *)
+type point2d = Point of float * float ;;
+let my_point = Point (2.0, 3.0) ;;
+
+(* Οι τ�ποι μπο�ο�ν να είναι πα�αμετ�οποιημένοι, όπως σε αυτόν τον τ�πο για
+   λίστες λίστών με οτιδήποτε τ�που στοιχεία. Το 'a μπο�εί να αντικατασταθεί από
+   οποιονδήποτε τ�πο. *)
+type 'a list_of_lists = 'a list list ;;
+type int_list_list = int list_of_lists ;;
+
+(* Οι τ�ποι μπο�ο�ν επίσης να ο�ίζονται αναδ�ομικά. Σαν αυτόν εδώ τον τ�πο που
+   είναι ανάλογος της built in λίστας από ακε�αίους. *)
+type my_int_list = EmptyList | IntList of int * my_int_list ;;
+let l = IntList (1, EmptyList) ;;
+
+
+(*** Ταί�ιασμα Π�οτ�πων - Pattern Matching ***)
+
+(* Το ταί�ιασμα π�οτ�πων είναι κάπως σαν το switch statement σε π�οστακτικές
+   γλώσσες π�ογ�αμματισμο�, αλλά πα�έχει πολ� μεγαλ�τε�η εκφ�αστική ισχ�.
+
+   Πα�όλο που φαίνεται πε�ίπλοκο, στην π�αγματικότητα είναι απλώς ταί�ιασμα
+   ενός ο�ίσματος με μια συγκεκ�ιμένη τιμή, ένα κατηγό�ημα ή έναν type constructor
+   Το σ�στημα τ�πων είναι αυτό που το κάνει τόσο ισχυ�ό. *)
+
+(** Ταί�ιασμα με ακ�ιβείς τιμές.  **)
+
+let is_zero x =
+    match x with
+    | 0 -> true
+    | _ -> false  (* Το "_" σημαίνει "οτιδήποτε άλλο". *)
+;;
+
+(* Εναλλακτικά μπο�ο�με να χ�ησιμοποιο�με το keyword "function". *)
+let is_one = function
+| 1 -> true
+| _ -> false
+;;
+
+(* Ταί�ιασμα με κατηγο�ήματα, γνωστό και ως "guarded pattern matching". *)
+let abs x =
+    match x with
+    | x when x < 0 -> -x
+    | _ -> x
+;;
+
+abs 5 ;; (* 5 *)
+abs (-5) ;; (* 5 πάλι *)
+
+(** Ταί�ιασμα με type constructors **)
+
+type animal = Dog of string | Cat of string ;;
+
+let say x =
+    match x with
+    | Dog x -> x ^ " says woof"
+    | Cat x -> x ^ " says meow"
+;;
+
+say (Cat "Fluffy") ;; (* "Fluffy says meow". *)
+
+(** Διάσχιση δομών δεδομένων με ταί�ιασμα π�οτ�πων **)
+
+(* Οι αναδ�ομικοί τ�ποι μπο�ο�ν να διασχιστο�ν ε�κολα με ταί�ιασμα π�οτ�πων.
+   Ας δο�με πώς μπο�ο�με να διασχίσουμε μια λίστα.
+   Πα�όλο που το built-in cons ("::") μοιάζει με infix τελεστή,
+   στην π�αγματικότητα είναι ένας type constructor και μπο�εί να
+   ται�ιαστεί όπως όλοι οι type constructors. *)
+let rec sum_list l =
+    match l with
+    | [] -> 0
+    | head :: tail -> head + (sum_list tail)
+;;
+
+sum_list [1; 2; 3] ;; (* Αποτιμάται σε 6 *)
+
+(* Η built-in συνταξη των cons εμποδίζει τη δομή λίγο, γι αυτό θα φτιάξουμε
+   το δικό μας τ�πο λίστας για την πα�ουσίαση. *)
+type int_list = Nil | Cons of int * int_list ;;
+let rec sum_int_list l =
+  match l with
+      | Nil -> 0
+      | Cons (head, tail) -> head + (sum_int_list tail)
+;;
+
+let t = Cons (1, Cons (2, Cons (3, Nil))) ;;
+sum_int_list t ;;
+```
+
+## Πε�ισσότε�α για την OCaml
+
+* Επισκεφθείτε την επίσημη σελίδα της OCaml για να κατεβάσετε τον compiler και να διαβάσετε το documentation: <http://ocaml.org/>
+* Δοκιμάστε διαδ�αστικά μαθήματα και έναν web-based interpreter από την OCaml Pro: <http://try.ocamlpro.com/>
diff --git a/el-gr/rust-gr.html.markdown b/el-gr/rust-gr.html.markdown
index 79f210ac..d28e3c2c 100644
--- a/el-gr/rust-gr.html.markdown
+++ b/el-gr/rust-gr.html.markdown
@@ -62,7 +62,7 @@ fn add2(x: i32, y: i32) -> i32 {
 fn main() {
     // Α�ιθμοί //
 
-    // Αμετάβλητη σ�νδεση
+    // Αμετάβλητη δέσμευση (η τιμή που αντιστοιχεί στο όνομα "x" δεν μπο�εί να αλλάξει)
     let x: i32 = 1;
 
     // Καταλήξεις integer/float
@@ -80,7 +80,8 @@ fn main() {
     // Π�άξεις
     let sum = x + y + 13;
 
-    // Μη-αμετάβλητη αξία (με την έννοια ότι μπο�εί να αλλάξει)
+    // Μεταβλητές (με την έννοια των π�οστακτικών γλωσσών π�ογ�αμματισμο�).
+    // Στη Rust η αμετάβλητη δέσμευση είναι στάντα�. Το mut δηλώνει μεταβλητότητα.
     let mut mutable = 1;
     mutable = 4;
     mutable += 2;
@@ -96,7 +97,7 @@ fn main() {
     // A `String` – a heap-allocated string
     let s: String = "καλημέ�α κόσμε".to_string();
 
-    // Ένα κομμάτι αλφα�ιθμητικο� (string slice) – μια μη-μεταβλητή οπτική γωνία π�ος ένα άλλο αλφα�ιθμητικό
+    // Ένα κομμάτι αλφα�ιθμητικο� (string slice) – μια αμετάβλητη οπτική γωνία π�ος ένα άλλο αλφα�ιθμητικό
     // Το αλφα�ιθμητικό μπο�εί να είναι στατικό όπως τα σταθε�ά αλφα�ιθμητικά, ή να πε�ιλαμβάνεται σε ένα άλλο,
     // δυναμικό αντικείμενο (σε αυτή την πε�ίπτωση τη μεταβλητή `s`)
     let s_slice: &str = &s;
@@ -112,7 +113,7 @@ fn main() {
     let mut vector: Vec<i32> = vec![1, 2, 3, 4];
     vector.push(5);
 
-    // Ένα κομμάτι – μια μη-μεταβλητή οπτική γωνία π�ος ένα διάνυσμα ή πίνακα
+    // Ένα κομμάτι – μια αμετάβλητη οπτική γωνία π�ος ένα διάνυσμα ή πίνακα
     // Είναι πα�όμοιο με το κομμάτι αλφα�ιθμητικο� που είδαμε π�οηγουμένως
     let slice: &[i32] = &vector;
 
@@ -121,10 +122,10 @@ fn main() {
 
     // Tuples (πλειάδες) //
 
-    // Ένα tuple είναι μια σταθε�ο� μεγέθους σει�ά από αξίες (πιθανά διαφο�ετικο� τ�που)
+    // Ένα tuple είναι μια σταθε�ο� μεγέθους σει�ά από τιμές (πιθανά διαφο�ετικο� τ�που)
     let x: (i32, &str, f64) = (1, "καλημέ�α", 3.4);
 
-    // Μπο�ο�με να χ�ησιμοποιήσουμε το `let` και ένα tuple για να δώσουμε πολλές αξίες σε πολλές μεταβλητές ταυτόχ�ονα
+    // Μπο�ο�με να χ�ησιμοποιήσουμε το `let` και ένα tuple για να δώσουμε πολλές τιμές σε πολλές μεταβλητές ταυτόχ�ονα
     // (destructuring `let`)
     let (a, b, c) = x;
     println!("{} {} {}", a, b, c); // 1 καλημέ�α 3.4
@@ -185,7 +186,7 @@ fn main() {
         fn bar(&self) -> &T { // Δανειζόμαστε το self
             &self.bar
         }
-        fn bar_mut(&mut self) -> &mut T { // Δανειζόμαστε το self ως μη-αμετάβλητη αξία
+        fn bar_mut(&mut self) -> &mut T { // Γίνεται "μεταβλητός δανεισμός" του self (μπο�ο�με να το τ�οποποιήσουμε)
             &mut self.bar
         }
         fn into_bar(self) -> T { // Εδώ το self καταναλώνεται
@@ -240,9 +241,9 @@ fn main() {
     // 4. Έλεγχος �οής //
     /////////////////////
 
-    // Β�όγχοι `for`
+    // Β�όχοι `for`
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
@@ -253,7 +254,7 @@ fn main() {
     println!("");
     // Τυπώνει `0 1 2 3 4 5 6 7 8 9 `
 
-    // Β�όγχοι `if`
+    // `if` (υπό συνθήκη διακλάδωση)
     if 1 == 1 {
         println!("Τα μαθηματικά δουλε�ουν!");
     } else {
@@ -267,17 +268,17 @@ fn main() {
         "κακό"
     };
 
-    // Β�όγχοι `while`
+    // Β�όχοι `while`
     while 1 == 1 {
         println!("Το σ�μπαν λειτου�γεί κανονικά.");
-        // Μπο�ο�με να βγο�με από το β�όγχο με το `break`
+        // Μπο�ο�με να βγο�με από το β�όχο με το `break`
         break
     }
 
-    // Ατέ�μονος β�όχγος
+    // Ατέ�μονος β�όχος
     loop {
         println!("Καλημέ�α!");
-        // Μπο�ο�με να βγο�με από το β�όγχο με το `break`
+        // Μπο�ο�με να βγο�με από το β�όχο με το `break`
         break
     }
 
@@ -294,11 +295,11 @@ fn main() {
     *now_its_mine += 2;
 
     println!("{}", now_its_mine); // 7
-    // println!("{}", mine); // Αυτό πα�άγει λάθος κατά τη μεταγλώττιση διότι τώ�α ο δείκτης ανοίκει στο `now_its_mine`
+    // println!("{}", mine); // Αυτό πα�άγει λάθος κατά τη μεταγλώττιση διότι τώ�α ο δείκτης ανήκει στο `now_its_mine`
 
     // Reference (αναφο�ά) – ένας αμετάβλητος δείκτης που αναφέ�εται σε άλλα δεδομένα
-    // Όταν μια αναφο�ά δίνεται σε μια αξία, λέμε πως η αξία έχει "δανειστεί".
-    // Όταν μια αξία δανείζεται αμετάβλητα, δεν μπο�εί να είναι mutated (να μεταβληθεί) ή να μετακινηθεί.
+    // Όταν μια αναφο�ά δίνεται σε μια τιμή, λέμε πως η τιμή έχει "δανειστεί".
+    // Όταν μια τιμή δανείζεται αμετάβλητα, δεν μπο�εί να είναι mutated (να μεταβληθεί) ή να μετακινηθεί.
     // Ένας "δανεισμός" πα�αμένει ενε�γός μέχ�ι την τελευταία χ�ήση της μεταβλητής που δανείζεται.
     let mut var = 4;
     var = 3;
@@ -313,13 +314,13 @@ fn main() {
     var = 2; // Η `ref_var` δεν χ�ησιμοποιείται από εδώ και στο εξής, ά�α ο "δανεισμός" τελειώνει
 
     // Μεταβλητή αναφο�ά
-    // Όσο μια αξία είναι μεταβλητά δανεισμένη, πα�αμένει τελείως απ�οσβάσιμη.
+    // Όσο μια τιμή είναι μεταβλητά δανεισμένη, πα�αμένει τελείως απ�οσβάσιμη.
     let mut var2 = 4;
     let ref_var2: &mut i32 = &mut var2;
     *ref_var2 += 2; // Ο αστε�ίσκος (*) χ�ησιμοποιείται ως δείκτης π�ος την μεταβλητά δανεισμένη `var2`
 
     println!("{}", *ref_var2); // 6 , // Αν είχαμε `var2` εδώ θα π�οκαλο�νταν λάθος μεταγλώττισης.
-    // O τ�πος της `ref_var2` είναι &mut i32, ά�α αποθηκε�ει μια αναφο�ά π�ος μια αξία i32, όχι την αξία την ίδια.
+    // O τ�πος της `ref_var2` είναι &mut i32, ά�α αποθηκε�ει μια αναφο�ά π�ος μια τιμή i32, όχι την τιμή την ίδια.
     // var2 = 2; // Λάθος μεταγλώττισης, γιατί η `var2` είναι δανεισμένη.
     ref_var2; // Εντολή no-op (τίποτα δεν εκτελείται από τον επεξε�γαστή), η οποία όμως μετ�άει ως χ�ήση και κ�ατά τον
               // "δανεισμό" ενε�γό
diff --git a/el-gr/vim-gr.html.markdown b/el-gr/vim-gr.html.markdown
index 679a5488..b11b5c33 100644
--- a/el-gr/vim-gr.html.markdown
+++ b/el-gr/vim-gr.html.markdown
@@ -3,7 +3,7 @@ category: tool
 tool: vim
 contributors:
     - ["RadhikaG", "https://github.com/RadhikaG"]
-filename: LearnVim.txt
+filename: LearnVim-gr.txt
 lang: el-gr
 ---
 
diff --git a/elisp.html.markdown b/elisp.html.markdown
index f839dac0..5d98ceff 100644
--- a/elisp.html.markdown
+++ b/elisp.html.markdown
@@ -3,6 +3,7 @@ language: elisp
 contributors:
     - ["Bastien Guerry", "https://bzg.fr"]
     - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
+    - ["rilysh", "https://github.com/rilysh"]
 filename: learn-emacs-lisp.el
 ---
 
@@ -12,11 +13,11 @@ filename: learn-emacs-lisp.el
 ;; First make sure you read this text by Peter Norvig:
 ;; http://norvig.com/21-days.html
 ;;
-;; Then install GNU Emacs 24.3:
+;; Then install latest version of GNU Emacs:
 ;;
 ;; Debian: apt-get install emacs (or see your distro instructions)
-;; OSX: 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
+;; OSX: https://emacsformacosx.com/
+;; Windows: https://ftp.gnu.org/gnu/emacs/windows/
 ;;
 ;; More general information can be found at:
 ;; http://www.gnu.org/software/emacs/#Obtaining
@@ -76,12 +77,12 @@ filename: learn-emacs-lisp.el
 ;; `C-j' inserts the result of the evaluation in the buffer.
 
 ;; `C-xC-e' displays the same result in Emacs bottom line,
-;; called the "minibuffer".  We will generally use `C-xC-e',
+;; called the "echo area". We will generally use `C-xC-e',
 ;; as we don't want to clutter the buffer with useless text.
 
 ;; `setq' stores a value into a variable:
 (setq my-name "Bastien")
-;; `C-xC-e' => "Bastien" (displayed in the mini-buffer)
+;; `C-xC-e' => "Bastien" (displayed in the echo area)
 
 ;; `insert' will insert "Hello!" where the cursor is:
 (insert "Hello!")
@@ -343,3 +344,9 @@ 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
 ```
+
+### Further Reading
+- [GNU Elisp Manual](https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html)
+- [Emacs Wiki](https://www.emacswiki.org/emacs/LearningEmacs)
+- [Emacs Docs](https://emacsdocs.org/docs/elisp/Emacs-Lisp)
+- [Mpre Elisp Docs](https://www.math.utah.edu/docs/info/elisp_22.html)
diff --git a/elixir.html.markdown b/elixir.html.markdown
index 8b80c582..2748a983 100644
--- a/elixir.html.markdown
+++ b/elixir.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "https://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -13,16 +13,15 @@ It's fully compatible with Erlang, but features a more standard syntax
 and many more features.
 
 ```elixir
-
 # Single line comments start with a number symbol.
 
 # There's no multi-line comment,
 # but you can stack multiple comments.
 
-# To use the elixir shell use the `iex` command.
+# To use the Elixir shell use the `iex` command.
 # Compile your modules with the `elixirc` command.
 
-# Both should be in your path if you installed elixir correctly.
+# Both should be in your path if you installed Elixir correctly.
 
 ## ---------------------------
 ## -- Basic types
@@ -33,7 +32,7 @@ and many more features.
 0x1F # integer
 3.0  # float
 
-# Atoms, that are literals, a constant with name. They start with `:`.
+# Atoms are constants whose values are their own name. They start with `:`.
 :hello # atom
 
 # Tuples that are stored contiguously in memory.
@@ -50,7 +49,7 @@ elem({1, 2, 3}, 0) #=> 1
 head #=> 1
 tail #=> [2,3]
 
-# In elixir, just like in Erlang, the `=` denotes pattern matching and
+# In Elixir, just like in Erlang, the `=` denotes pattern matching and
 # not an assignment.
 #
 # This means that the left-hand side (pattern) is matched against a
@@ -83,7 +82,7 @@ string.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` in elixir returns the ASCII integer for the letter `a`
+# `?a` in Elixir returns the ASCII integer for the letter `a`
 ?a #=> 97
 
 # To concatenate lists use `++`, for binaries use `<>`
@@ -116,7 +115,7 @@ genders.gillian #=> "female"
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# In elixir the operator `/` always returns a float.
+# In Elixir the operator `/` always returns a float.
 
 # To do integer division use `div`
 div(10, 2) #=> 5
@@ -174,7 +173,7 @@ else
   "This will"
 end
 
-# Remember pattern matching? Many control-flow structures in elixir rely on it.
+# Remember pattern matching? Many control-flow structures in Elixir rely on it.
 
 # `case` allows us to compare a value against many patterns:
 case {:one, :two} do
@@ -307,7 +306,7 @@ Geometry.area({:circle, 3})       #=> 28.25999999999999801048
 # Geometry.area({:circle, "not_a_number"})
 #=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
 
-# Due to immutability, recursion is a big part of elixir
+# Due to immutability, recursion is a big part of Elixir
 defmodule Recursion do
   def sum_list([head | tail], acc) do
     sum_list(tail, acc + head)
@@ -382,7 +381,7 @@ end
 ## ---------------------------
 
 # Elixir relies on the actor model for concurrency. All we need to write
-# concurrent programs in elixir are three primitives: spawning processes,
+# concurrent programs in Elixir are three primitives: spawning processes,
 # sending messages and receiving messages.
 
 # To start a new process we use the `spawn` function, which takes a function
diff --git a/elm.html.markdown b/elm.html.markdown
index ad80adc9..bc7ba4cc 100644
--- a/elm.html.markdown
+++ b/elm.html.markdown
@@ -224,7 +224,7 @@ List.map : (a -> b) -> List a -> List b
 -- Comparable allows you to order numbers and strings, like a < b.
 -- Appendable things can be combined with a ++ b.
 
-{-- Type Aliases and Union Types --}
+{-- Type Aliases and Custom Types --}
 
 -- When you write a record or tuple, its type already exists.
 -- (Notice that record types use colon and record values use equals.)
@@ -244,28 +244,28 @@ otherOrigin =
 -- But it's still the same type, so you can equate them.
 origin == otherOrigin -- True
 
--- By contrast, defining a union type creates a type that didn't exist before.
--- A union type is so called because it can be one of many possibilities.
--- Each of the possibilities is represented as a "tag".
+-- By contrast, defining a custom type creates a type that didn't exist before.
+-- A custom type is so called because it can be one of many possibilities.
+-- Each of the possibilities is represented as a "type variant".
 type Direction =
   North | South | East | West
 
--- Tags can carry other values of known type. This can work recursively.
+-- Type variants can carry other values of known type. This can work recursively.
 type IntTree =
   Leaf | Node Int IntTree IntTree
--- "Leaf" and "Node" are the tags. Everything following a tag is a type.
+-- "Leaf" and "Node" are the type variants. Everything following a type variant is a type.
 
--- Tags can be used as values or functions.
+-- Type variants can be used as values or functions.
 root : IntTree
 root =
   Node 7 Leaf Leaf
 
--- Union types (and type aliases) can use type variables.
+-- Custom types (and type aliases) can use type variables.
 type Tree a =
   Leaf | Node a (Tree a) (Tree a)
 -- "The type tree-of-a is a leaf, or a node of a, tree-of-a, and tree-of-a."
 
--- Pattern match union tags. The uppercase tags will be matched exactly. The
+-- Pattern match variants in a custom type. The uppercase variants will be matched exactly. The
 -- lowercase variables will match anything. Underscore also matches anything,
 -- but signifies that you aren't using it.
 leftmostElement : Tree a -> Maybe a
@@ -289,7 +289,7 @@ module Name where
 -- By default, everything is exported. You can specify exports explicitly.
 module Name (MyType, myValue) where
 
--- One common pattern is to export a union type but not its tags. This is known
+-- One common pattern is to export a custom type but not its type variants. This is known
 -- as an "opaque type", and is frequently used in libraries.
 
 -- Import code from other modules to use it in this one.
diff --git a/erlang.html.markdown b/erlang.html.markdown
index a9d280d7..62666c3a 100644
--- a/erlang.html.markdown
+++ b/erlang.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: erlang
 contributors:
-    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+    - ["Giovanni Cappellotto", "http://giovanni.curlybrackets.it/"]
 filename: learnerlang.erl
 ---
 
diff --git a/es-es/amd-es.html.markdown b/es-es/amd-es.html.markdown
index 40aa6647..83c705c3 100644
--- a/es-es/amd-es.html.markdown
+++ b/es-es/amd-es.html.markdown
@@ -16,6 +16,7 @@ lang: es-es
 El API del **Módulo de Definición Asíncrono** especifica un mecanismo para definir módulos JavaScript de manera tal que tanto el módulo como sus dependencias puedan ser cargadas de manera asíncrona. Esto es particularmente adecuado para el entorno del navegador donde la carga sincronizada de los módulos genera problemas de rendimiento, usabilidad, depuración y acceso de multi-dominios.
 
 ### Conceptos básicos
+
 ```javascript
 // El API básico de AMD consiste en tan solo dos métodos: `define` y `require`
 // y se basa en la definición y consumo de los módulos:
@@ -137,6 +138,7 @@ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolL
   coolLib.doFancyStuffWith(helpers.transform($('#foo')));
 });
 ```
+
 Las aplicaciones basadas en `require.js` usualmente tendrán un solo punto de entrada (`main.js`) que se pasa a la etiqueta del script `require.js` como un atributo de datos. Será cargado y ejecutado automáticamente al cargar la página:
 
 ```html
@@ -158,16 +160,19 @@ Muchas personas prefieren usar AMD para la organización del código durante el
 `require.js` incluye un script llamado `r.js` (el que probablemente correrás en node.js, aunque Rhino también es soportado) que puede analizar el gráfico de dependencias de tu proyecto, y armar un solo fichero que contenga todos tus módulos (adecuadamente nombrados), minificado y listo para consumo.
 
 Instálalo usando `npm`:
+
 ```shell
 $ npm install requirejs -g
 ```
 
 Ahora puedes alimentarlo con un fichero de configuración:
+
 ```shell
 $ r.js -o app.build.js
 ```
 
 Para nuestro ejemplo anterior el archivo de configuración luciría así:
+
 ```javascript
 /* file : app.build.js */
 ({
@@ -184,6 +189,7 @@ Para nuestro ejemplo anterior el archivo de configuración luciría así:
 ```
 
 Para usar el fichero creado en producción, simplemente intercambia `data-main`:
+
 ```html
 <script src="require.js" data-main="app/main-built"></script>
 ```
diff --git a/es-es/asciidoc-es.html.markdown b/es-es/asciidoc-es.html.markdown
index 6e357915..31406ee1 100644
--- a/es-es/asciidoc-es.html.markdown
+++ b/es-es/asciidoc-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
 lang: es-es
-filename: asciidoc-es.md
+filename: asciidoc-es.adoc
 ---
 
 AsciiDoc es un lenguaje de marcas similar a Markdown que puede ser usado para cualquier uso, desde libros a blogs.
diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index 8da8f024..1ee12956 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -11,8 +11,8 @@ lang: es-es
 
 AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX.
 Es como un Perl restringido, perfecto para tareas de procesamiento de texto y
-otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin 
-puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo 
+otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin
+puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo
 desde un script de shell o usarlo como un lenguaje stand-alone para scripting.
 
 ¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX.
@@ -74,8 +74,8 @@ BEGIN {
 
     # Bloques formados por múltiples líneas usan llaves
     while (a < 10) {
-        print "La concatenación de strings se hace " " con series " 
-	print " de" " strings separados por espacios"
+        print "La concatenación de strings se hace " " con series "
+        print " de" " strings separados por espacios"
         print a
 
         a++
@@ -153,13 +153,13 @@ function arithmetic_functions(a, b, c,     localvar) {
     # Todo es global. No es problema en scripts pequeños, pero sí para
     # scripts más grandes.
 
-    # Hay un work-around (mmm... hack). Los argumentos de las funciones son 
+    # Hay un work-around (mmm... hack). Los argumentos de las funciones son
     # locales para la función, y AWK permite definir más argumentos de función
-    # de los que necesita, por lo que define las variables locales en la 
+    # de los que necesita, por lo que define las variables locales en la
     # declaración como en la función de arriba. Como convención, agrega
-    # espacios en blanco para distinguir los parámetros de la función de las 
-    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una 
-    # variable local.
+    # espacios en blanco para distinguir los parámetros de la función de las
+    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es
+    # una variable local.
 
     # Ahora, a demostrar las funciones aritméticas
 
@@ -196,7 +196,7 @@ function string_functions(    localvar, arr) {
     # Ambas regresan el número de matches remplazados.
     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"
+    gsub("e", ".", localvar) # localvar => "M..t m. at th. bar"
 
     # Buscar una cadena que haga match con una expresión regular
     # index() hace lo mismo, pero no permite expresiones regulares
@@ -222,10 +222,10 @@ function io_functions(    localvar) {
     # También hay printf
     printf("%s %d %d %d\n", "Testing", 1, 2, 3)
 
-    # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un 
-    # handle de archivo cuando use algo que necesite uno. El string que usaste 
-    # para esto puede ser tratada como un handle de archivo para propósitos de I/O.
-    # Esto lo hace similar al scripting de shell:
+    # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un
+    # handle de archivo cuando use algo que necesite uno. El string que usaste
+    # para esto puede ser tratada como un handle de archivo para propósitos
+    # de I/O. Esto lo hace similar al scripting de shell:
 
     print "foobar" >"/tmp/foobar.txt"
 
@@ -247,17 +247,17 @@ function io_functions(    localvar) {
     close("/tmp/foobar.txt")
 }
 
-# Como dije al inicio, los programas en AWK son una colección de patrones y 
+# Como dije al inicio, los programas en AWK son una colección de patrones y
 # acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás
 # procesando líneas desde archivos o stdin.
 
-# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a 
-# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for 
+# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a
+# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for
 # implícito, iterando sobre las líneas de estos archivos. Estos patrones y
 # acciones son como instrucciones switch dentro del ciclo.
 
 /^fo+bar$/ {
-    
+
     # Esta acción se ejecutará por cada línea que haga match con la expresión
     # regular /^fo+bar$/, y será saltada por cualquier línea que no haga match.
     # Vamos a sólo mostrar la línea:
@@ -268,7 +268,7 @@ function io_functions(    localvar) {
     # $0 es el nombre de la línea actual que se está procesando.
     # Se crea automáticamente para ti.
 
-    # Probablemente puedas adivinar que hay otras variables $. Cada línea es 
+    # Probablemente puedas adivinar que hay otras variables $. Cada línea es
     # separada implícitamente antes de que se llame cada acción, justo como lo
     # hace shell. Y, como shell, cada campo puede ser accesado con $.
 
@@ -301,7 +301,7 @@ a > 0 {
 # Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez,
 # y haciendo algo con ella, particularmente separando en un deliminator, es tan
 # común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti
-# sin que tengas que pedirlo. Basta con escribir los patrones y acciones 
+# sin que tengas que pedirlo. Basta con escribir los patrones y acciones
 # basados en lo que esperas de la entrada y lo quieras quieras hacer con ella.
 
 # Aquí está un ejemplo de un script simple, para lo que AWK es perfecto.
@@ -343,7 +343,7 @@ $1 == name {
     nlines++
 }
 
-# Otro patrón especial es END. Va a ejecutarse después de procesar todos los 
+# Otro patrón especial es END. Va a ejecutarse después de procesar todos los
 # archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una
 # entrada a procesar. Se ejecutará después de que todos los archivos hayan sido
 # leídos y procesados según las reglas y acciones que programaste. El propósito
@@ -356,8 +356,10 @@ END {
 }
 
 ```
+
 Más información:
 
 * [Tutorial de AWK](http://www.grymoire.com/Unix/Awk.html)
 * [Página man de AWK](https://linux.die.net/man/1/awk)
-* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html): GNU Awk se encuentra en la mayoría de los sistemas Linux.
+* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html):
+  GNU Awk se encuentra en la mayoría de los sistemas Linux.
diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown
index 2c3762d5..f624d3c7 100644
--- a/es-es/c++-es.html.markdown
+++ b/es-es/c++-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-es.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
@@ -8,6 +8,7 @@ contributors:
     - ["Connor Waters", "http://github.com/connorwaters"]
 translators:
     - ["Gerson Lázaro", "https://gersonlazaro.com"]
+    - ["Diego Ramirez", "https://DiddiLeija.github.io"]
 lang: es-es
 ---
 
@@ -101,8 +102,8 @@ void print(int myInt)
 
 int main()
 {
-    print("Hello"); // Resolves to void print(const char*)
-    print(15); // Resolves to void print(int)
+    print("Hello"); // Corresponde a void print(const char*)
+    print(15); // Corresponde a void print(int)
 }
 
 ////////////////////////////////////
@@ -114,7 +115,7 @@ int main()
 
 void doSomethingWithInts(int a = 1, int b = 4)
 {
-    // Hacer algo con los enteros aqui
+    // Hacer algo con los enteros aquí
 }
 
 int main()
@@ -134,7 +135,7 @@ void invalidDeclaration(int a = 1, int b) // Error!
 // Espacios de nombre
 /////////////////////
 
-// Espacios de nombres proporcionan ámbitos separados para variable, función y
+// Los espacios de nombres proporcionan ámbitos separados para variable, función y
 // otras declaraciones.
 // Los espacios de nombres se pueden anidar.
 
@@ -184,7 +185,7 @@ int main()
 
 #include <iostream> // Incluir para el flujo de entrada/salida
 
-using namespace std; // Los streams estan en std namespace (libreria estandar)
+using namespace std; // Los streams estan en el espacio de nombre std (libreria estandar)
 
 int main()
 {
@@ -208,7 +209,7 @@ int main()
 // Las cadenas en C++ son objetos y tienen muchas funciones
 #include <string>
 
-using namespace std; // Strings también estan en namespace std
+using namespace std; // Las cadenas también estan en el nombre de espacio std
 
 string myString = "Hola";
 string myOtherString = " Mundo";
@@ -252,7 +253,7 @@ fooRef = bar;
 const string& barRef = bar; // Crea una referencia constante a bar.
 // Como en C, los valores constantes (y punteros y referencias) no pueden ser
 // modificados.
-barRef += ". Hola!"; // Error, referencia constante no puede ser modificada.
+barRef += ". Hola!"; // Error, una referencia constante no puede ser modificada.
 
 // Sidetrack: Antes de hablar más sobre referencias, hay que introducir un
 // concepto llamado objeto temporal. Supongamos que tenemos el siguiente código:
@@ -264,7 +265,7 @@ string retVal = tempObjectFun();
 // - Una nueva cadena se construye con el objeto devuelto como argumento al
 // constructor
 // - El objeto devuelto es destruido
-// El objeto devuelto se llama objeto temporal. Objetos temporales son
+// El objeto devuelto se llama objeto temporal. Los 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
@@ -295,7 +296,7 @@ void someFun(string&& s) { ... }  // Referencia a objeto temporal
 
 string foo;
 someFun(foo);  // Llama la función con referencia regular
-someFun(tempObjectFun());  // Llama la versión con referencia temporal
+someFun(tempObjectFun());  // Llama la función con referencia temporal
 
 // Por ejemplo, puedes ver estas dos versiones de constructores para
 // std::basic_string:
@@ -305,7 +306,7 @@ basic_string(basic_string&& other);
 // 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".
+// concepto denominado "movimiento semántico".
 
 ////////////////////////////////////////////
 // Clases y programación orientada a objetos
@@ -322,9 +323,7 @@ class Dog {
     int weight;
 
 // Todos los miembros siguientes de este son públicos
-// Hasta que se encuentre "private" o "protected".
-// All members following this are public
-// until "private:" or "protected:" is found.
+// hasta que se encuentre "private" o "protected".
 public:
 
     // Constructor por defecto
@@ -339,8 +338,8 @@ public:
 
     void setWeight(int dogsWeight);
 	// Funciones que no modifican el estado del objeto
-	// Deben marcarse como const.
-	// Esto le permite llamarlas si se envia una referencia constante al objeto.
+	// deben marcarse como const.
+	// Esto le permite llamarlas si se envía 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
 	// derivadas.
@@ -357,8 +356,8 @@ public:
 	// Esto permite paradigmas potentes como RAII
 	// (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
+	// Si no es virtual, entonces la clase destructora derivada
+	// no será llamada si el objeto se destruye a través de una referencia de
 	// la clase base o puntero.
     virtual ~Dog();
 
@@ -373,7 +372,7 @@ Dog::Dog()
 }
 
 // Objetos (tales como cadenas) deben ser pasados por referencia
-// Si los estas modificando o referencia constante en caso contrario.
+// si los estás modificando, o referencia constante en caso contrario.
 void Dog::setName(const std::string& dogsName)
 {
     name = dogsName;
@@ -413,9 +412,9 @@ class OwnedDog : public Dog {
 	// 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
+	// para una introducción más general si no está familiarizado con el
 	// polimorfismo de subtipo.
-	// La palabra clave override es opcional, pero asegura que estás
+	// La palabra clave override es opcional, pero asegúrate de que estás
 	// reemplazando el método de una clase base.
     void print() const override;
 
@@ -460,8 +459,8 @@ public:
     // pero inicializa el punto al valor por defecto (0, 0)
     Point() { };
 
-    // The following syntax is known as an initialization list
-    // and is the proper way to initialize class member values
+    // La siguiente sintaxis se conoce como lista de inicialización
+    // y es la forma correcta de inicializar los valores de los miembros de la clase
     Point (double a, double b) :
         x(a),
         y(b)
@@ -474,7 +473,7 @@ public:
     Point& operator+=(const Point& rhs);
 
     // También tendría sentido añadir los operadores - y -=,
-   	// Pero vamos a omitirlos por razones de brevedad.
+   	// pero vamos a omitirlos por razones de brevedad.
 };
 
 Point Point::operator+(const Point& rhs) const
@@ -496,7 +495,7 @@ int main () {
     // Llama al operador + de Point
     // Point llama la función + con right como parámetro
     Point result = up + right;
-    // Prints "Result is upright (1,1)"
+    // Imprime "Result is upright (1,1)"
     cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
     return 0;
 }
@@ -525,7 +524,7 @@ public:
 // 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.
+// enteramente en archivos de cabecera.
 
 //Para crear una instancia de una clase de plantilla en la pila:
 Box<int> intBox;
@@ -544,7 +543,7 @@ boxOfBox.insert(intBox);
 
 // A veces verás
 //   template<typename T>
-// en su lugar. La palabra clave "class" y las palabras clave "typename" son
+// en su lugar. La palabra clave "class" y la palabra clave "typename" son
 // mayormente intercambiables en este caso. Para la explicación completa, mira
 //   http://en.wikipedia.org/wiki/Typename
 // (sí, esa palabra clave tiene su propia página de Wikipedia).
@@ -568,7 +567,7 @@ Dog fluffy;
 fluffy.setName("Fluffy")
 barkThreeTimes(fluffy); // Imprime "Fluffy barks" 3 veces.
 
-Los parámetros de la plantilla no tienen que ser las clases:
+// Los parámetros de la plantilla no tienen que ser las clases:
 template<int Y>
 void printMessage() {
   cout << "Aprende C++ en " << Y << " minutos!" << endl;
@@ -604,7 +603,7 @@ printMessage<10>();  // Prints "Aprende C++ rapido en solo 10 minutos!"
 //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_.
+    // No asigne excepciones en el heap usando _new_.
     throw std::runtime_error("Ocurrió un problema");
 }
 
@@ -629,10 +628,10 @@ catch (...)
 // (Adquisición de recursos es inicialización).
 // A menudo se considera el paradigma más poderoso en C++
 // Y el concepto es simple: un constructor de un objeto
-// Adquiere recursos de ese objeto y el destructor les libera.
+// adquiere recursos de ese objeto y el destructor les libera.
 
 // Para entender cómo esto es útil,
-// Considere una función que utiliza un identificador de archivo C:
+// considere una función que utiliza un identificador de archivo C:
 void doSomethingWithAFile(const char* filename)
 {
     // Para empezar, asuma que nada puede fallar.
@@ -691,11 +690,11 @@ bool doSomethingWithAFile(const char* filename)
 
 failure:
     fclose(fh);
-    return false; // Propagate el error
+    return false; // Propaga el error
 }
 
 // Si las funciones indican errores mediante excepciones,
-// Las cosas son un poco más claras, pero pueden optimizarse mas.
+// las cosas son un poco más claras, pero pueden optimizarse más.
 void doSomethingWithAFile(const char* filename)
 {
     FILE* fh = fopen(filename, "r"); // Abrir el archivo en modo lectura
@@ -732,9 +731,9 @@ void doSomethingWithAFile(const std::string& filename)
 
 // Esto tiene ventajas _enormes_:
 // 1. No importa lo que pase,
-//    El recurso (en este caso el manejador de archivo) será limpiado.
+//    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
diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
index cae4349e..ae357d91 100644
--- a/es-es/c-es.html.markdown
+++ b/es-es/c-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c
+language: C
 filename: learnc-es.c
 contributors:
     - ["Adam Bard", "http://adambard.com/"]
diff --git a/es-es/chapel-es.html.markdown b/es-es/chapel-es.html.markdown
new file mode 100644
index 00000000..732ee298
--- /dev/null
+++ b/es-es/chapel-es.html.markdown
@@ -0,0 +1,1219 @@
+---
+language: chapel
+filename: learnchapel.chpl
+contributors:
+    - ["Ian J. Bertolacci", "https://www.cs.arizona.edu/~ianbertolacci/"]
+    - ["Ben Harshbarger", "https://github.com/benharsh/"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+Puede leer todo sobre Chapel en [el sitio web oficial de Chapel de Cray](https://chapel-lang.org).
+En resumen, Chapel es un lenguaje de programación paralela, código abierto, de alta productividad
+desarrolladp en Cray Inc. y está diseñado para ejecutarse en PC multi-nucleos, 
+así como en supercomputadoras multi-kilocore.
+
+
+Puede encontrar más información y asistencia al final de este documento.
+
+```chapel
+// Los comentarios son de estilo de la familia C
+
+// comentario de una línea
+/*
+ comentario de múltiples lineas
+*/
+
+// Impresión básica
+
+write("Hola, ");
+writeln("Mundo!");
+
+// write y writeln pueden tomar una lista de cosas para imprimir.
+// Cada cosa está impresa justo al lado de las demás, ¡así que incluye espacios!
+writeln("hay ", 3, " comas (\",\") en esta línea de código");
+
+// Diferentes canales de salida:
+stdout.writeln("Esto va a la salida estándar, al igual que lo hace writeln()");
+stderr.writeln("Esto va al error estándar");
+
+
+// Las variables no tienen que escribirse explícitamente 
+// mientras el compilador pueda determinar el tipo que contendrá.
+
+// 10 es un entero, asi que myVar es explícitamente un entero
+var myVar = 10;
+myVar = -10;
+var mySecondVar = myVar;
+// var anError; sería un error en tiempo de compilación
+
+// Podemos (y debemos) escribir cosas explícitamente.
+var myThirdVar: real;
+var myFourthVar: real = -1.234;
+myThirdVar = myFourthVar;
+
+// Tipos
+
+// Hay varios tipos básicos.
+var myInt: int = -1000; // Enteros firmados
+var myUint: uint = 1234; // Enteros sin-firmar
+var myReal: real = 9.876; // Números de punto flotante
+var myImag: imag = 5.0i; // Números imaginarios
+var myCplx: complex = 10 + 9i; // Números complejos
+myCplx = myInt + myImag; // Otra manera de formar números complejos
+var myBool: bool = false; // Booleanos
+var myStr: string = "Una cadena..."; // Cadenas
+var singleQuoteStr = 'Otra cadena...'; // Cadena literal con comillas simples
+
+// Algunos tipos pueden tener tamaños.
+var my8Int: int(8) = 10; // Entero de 8 bit (one byte);
+var my64Real: real(64) = 1.516; // Real de 64 bit (8 bytes)
+
+// Conversion de tipos.
+var intFromReal = myReal : int;
+var intFromReal2: int = myReal : int;
+
+// Alias de tipo.
+type chroma = int;        // Tipo de un solo tono
+type RGBColor = 3*chroma; // Tipo que representa un color completo
+var black: RGBColor = (0,0,0);
+var white: RGBColor = (255, 255, 255);
+
+// Constantes y Parámetros
+
+// una variable const es una constante y no se puede cambiar después de
+// establecerla en tiempo de ejecución.
+const almostPi: real = 22.0/7.0;
+
+// Un parámetro es una constante cuyo valor debe conocerse estáticamente 
+// en tiempo de compilación.
+
+param compileTimeConst: int = 16;
+
+// El modificador de configuración permite establecer valores en la línea de comando.
+// Establece valores con --varCmdLineArg=Value o --varCmdLineArg Value en tiempo de ejecución.
+config var varCmdLineArg: int = -123;
+config const constCmdLineArg: int = 777;
+
+// config param se puede configurar en tiempo de compilación.
+// Establece valores con --set paramCmdLineArg=value  en tiempo de compilación.
+config param paramCmdLineArg: bool = false;
+writeln(varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg);
+
+// Referencias
+
+// ref funciona de manera muy similar a una referencia en C ++. En Chapel, 
+// no se puede hacer una referencia como alias a una variable distinta 
+// de la variable con la que se inicializa.
+
+// Aquí, refToActual se refiere a actual.
+var actual = 10;
+ref refToActual = actual;
+writeln(actual, " == ", refToActual); // imprime el mismo valor
+actual = -123; // modificar actual (a lo que refToActual se refiere)
+writeln(actual, " == ", refToActual); // imprime el mismo valor
+refToActual = 99999999; //  modificar a qué se refiere refToActual (que es actual)
+writeln(actual, " == ", refToActual); // imprime el mismo valor
+
+// Operadores
+
+// Operadores matemáticos:
+var a: int, thisInt = 1234, thatInt = 5678;
+a = thisInt + thatInt;  // Adicción
+a = thisInt * thatInt;  // Multiplicación
+a = thisInt - thatInt;  // Substracción
+a = thisInt / thatInt;  // División
+a = thisInt ** thatInt; // Exponenciación
+a = thisInt % thatInt;  // residuo (módulo)
+
+// Operadores logicos:
+var b: bool, thisBool = false, thatBool = true;
+b = thisBool && thatBool; // Lógico y
+b = thisBool || thatBool; // Lógico o
+b = !thisBool;            // Lógico negación
+
+// Operadores relacionales:
+b = thisInt > thatInt;           // Mas grande que
+b = thisInt >= thatInt;          // Mas grande o igual que
+b = thisInt < a && a <= thatInt; // Menor que, y, Menor o igual que
+b = thisInt != thatInt;          // No es igual a
+b = thisInt == thatInt;          // es igual a
+
+// Operadores bit a bit:
+a = thisInt << 10;     // Desplazamiento de bit izquierdo por 10 bits;
+a = thatInt >> 5;      // Desplazamiento de bit derecho por 5 bits;
+a = ~thisInt;          // Negación bit a bit
+a = thisInt ^ thatInt; // bit a bit exclusivo o
+
+// Operadores de asignación compuesta:
+a += thisInt;          // Adición-igual (a = a + thisInt;)
+a *= thatInt;          // Multiplicación-igual (a = a * thatInt;)
+b &&= thatBool;        // Lógico e igual (b = b && thatBool;)
+a <<= 3;               // Desplazamiento a la izquierda igual (a = a << 10;)
+
+// A diferencia de otros lenguajes de familia C, no hay operadores de 
+// pre / post-incremento / decremento, tales como:
+//
+// ++j, --j, j++, j--
+
+// Operador de intercambio:
+var old_this = thisInt;
+var old_that = thatInt;
+thisInt <=> thatInt; // Intercambia los valores de thisInt y thatInt
+writeln((old_this == thatInt) && (old_that == thisInt));
+
+// También se pueden definir sobrecargas del operador, como veremos con los procedimientos.
+
+// Tuplas
+
+// Las tuplas pueden ser del mismo tipo o de diferentes tipos.
+var sameTup: 2*int = (10, -1);
+var sameTup2 = (11, -6);
+var diffTup: (int,real,complex) = (5, 1.928, myCplx);
+var diffTupe2 = (7, 5.64, 6.0+1.5i);
+
+// Se puede acceder a las tuplas usando corchetes o paréntesis,
+// y están indexadas en base 1.
+writeln("(", sameTup[1], ",", sameTup(2), ")");
+writeln(diffTup);
+
+// Las tuplas también se pueden escribir.
+diffTup(1) = -1;
+
+// Los valores de tupla se pueden expandir a sus propias variables.
+var (tupInt, tupReal, tupCplx) = diffTup;
+writeln(diffTup == (tupInt, tupReal, tupCplx));
+
+// También son útiles para imprimit una lista de variables, 
+// como es común en la depuración.
+writeln((a,b,thisInt,thatInt,thisBool,thatBool));
+
+// Flujo de control
+
+// if - then - else funciona como cualquier otro lenguaje de la familia C.
+if 10 < 100 then
+  writeln("All is well");
+
+if -1 < 1 then
+  writeln("Continuando creyendo en la realidad");
+else
+  writeln("¡Envia un matemático!, algo está mal");
+
+// Puedes usar paréntesis si lo prefieres.
+if (10 > 100) {
+  writeln("El Universo está roto, Por favor reinicie el universo.");
+}
+
+if a % 2 == 0 {
+  writeln(a, " es par.");
+} else {
+  writeln(a, " es impar.");
+}
+
+if a % 3 == 0 {
+  writeln(a, " es divisible entre 3.");
+} else if a % 3 == 1 {
+  writeln(a, " es divisible entre 3 con un residuo de 1.");
+} else {
+  writeln(b, " es divisible entre 3 con un residuo de 2.");
+}
+
+// Ternario:  if - then - else en una declaración.
+var maximum = if thisInt < thatInt then thatInt else thisInt;
+
+// las declaraciones select son muy parecidas a las declaraciones switch
+// en otros idiomas. Sin embargo, las declaraciones select no caen 
+// en cascada como en C o Java.
+var inputOption = "anOption";
+select inputOption {
+  when "anOption" do writeln("Escoge 'anOption'");
+  when "otherOption" {
+    writeln("Escoge 'otherOption'");
+    writeln("Que tiene un cuerpo");
+  }
+  otherwise {
+    writeln("Cualquier otra entrada");
+    writeln("El caso otherwise no necesita hacerse si el cuerpo es de una línea");
+  }
+}
+
+// Los bucles while y do-while también se comportan como sus contrapartes en C.
+var j: int = 1;
+var jSum: int = 0;
+while (j <= 1000) {
+  jSum += j;
+  j += 1;
+}
+writeln(jSum);
+
+do {
+  jSum += j;
+  j += 1;
+} while (j <= 10000);
+writeln(jSum);
+
+// Los bucles for son muy parecidos a los de Python porque iteran en un rango. 
+// Los rangos (como la expresión 1..10 a continuación) son un objeto de primera clase
+// en Chapel, y como tal pueden almacenarse en variables.
+for i in 1..10 do write(i, ", ");
+writeln();
+
+var iSum: int = 0;
+for i in 1..1000 {
+  iSum += i;
+}
+writeln(iSum);
+
+for x in 1..10 {
+  for y in 1..10 {
+    write((x,y), "\t");
+  }
+  writeln();
+}
+
+// Rangos y Dominios
+
+// Los bucles y matrices utilizan rangos y dominios para definir un conjunto de índices
+// que se pueden iterar. Los rangos son índices enteros unidimensionales, mientras 
+// que los dominios pueden ser multidimensionales y representan índices 
+// de diferentes tipos.
+
+// Son tipos ciudadanos de primera clase y pueden asignarse a variables.
+var range1to10: range = 1..10;  // 1, 2, 3, ..., 10
+var range2to11 = 2..11; // 2, 3, 4, ..., 11
+var rangeThisToThat: range = thisInt..thatInt; // usando variables
+var rangeEmpty: range = 100..-100; // esto es válido pero no contiene índices
+
+// Los rangos pueden ser ilimitados.
+var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ; // 1, 2, 3, 4, 5, ...
+var rangeNegInfTo1 = ..1; // ..., -4, -3, -2, -1, 0, 1
+
+// Los rangos se pueden andar (y revertir) utilizando el operador by.
+var range2to10by2: range(stridable=true) = 2..10 by 2; // 2, 4, 6, 8, 10
+var reverse2to10by2 = 2..10 by -2; // 10, 8, 6, 4, 2
+
+var trapRange = 10..1 by -1; // No te dejes engañar, esto sigue siendo un rango vacío
+writeln("Size of range ", trapRange, " = ", trapRange.length);
+
+// Note: range(boundedType= ...) and range(stridable= ...) solo son necesarios 
+// si escribimos explícitamente la variable.
+
+// El punto final de un rango se puede determinar utilizando el operador de conteo (#).
+var rangeCount: range = -5..#12; // intervalo de -5 to 6
+
+// Los operadores pueden ser mixtos.
+var rangeCountBy: range(stridable=true) = -5..#12 by 2; // -5, -3, -1, 1, 3, 5
+writeln(rangeCountBy);
+
+// Se pueden consultar las propiedades del rango.
+// En este ejemplo, imprime el primer índice, el último índice, el número de índices,
+// el paso y si 2 se incluye en el rango.
+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 ", ");
+}
+
+// Los dominios rectangulares se definen usando la misma sintaxis de rango, 
+// pero se requiere que estén delimitados (a diferencia de los rangos).
+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
+
+// Los dominios también pueden ser redimensionados
+var resizedDom = {1..10};
+writeln("antes, resizedDom = ", resizedDom);
+resizedDom = {-10..#10};
+writeln("despues, resizedDom = ", resizedDom);
+
+// Los índices pueden iterarse como tuplas.
+for idx in twoDimensions do
+  write(idx, ", ");
+writeln();
+
+// Estas tuplas también pueden ser deconstruidas.
+for (x,y) in twoDimensions {
+  write("(", x, ", ", y, ")", ", ");
+}
+writeln();
+
+// Los dominios asociativos actúan como conjuntos.
+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.sorted());
+
+// Los dominios asociativos también pueden tener una sintaxis literal
+var intSet = {1, 2, 4, 5, 100};
+
+// Tanto los rangos como los dominios se pueden dividir para producir un rango 
+// o dominio con la intersección de los índices.
+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));
+
+var domainA = {1..10, 5..20};
+var domainB = {-5..5, 1..10};
+var domainC = domainA[domainB];
+writeln((domainA, domainB, domainC));
+
+// Matrices
+
+// Las matrices son similares a otros lenguajes.
+// Sus tamaños son definidos usndo dominions que repretsenten sus indices.
+var intArray: [1..10] int;
+var intArray2: [{1..10}] int; // equivalent
+
+// Pueden ser accedidos usando brackets o paréntesis
+for i in 1..10 do
+  intArray[i] = -i;
+writeln(intArray);
+
+// No podemos acceder a intArray[0] porque existe fuera del conjunto de índices,
+// {1..10}, que definimos al principio. 
+// intArray [11] es ilegal por la misma razón.
+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
+
+for i in 1..5 {
+  for j in realDomain.dim(2) {   // Solo use la segunda dimensión del dominio
+    realArray[i,j] = -1.61803 * i + 0.5 * j;  // Acceso usando la lista de índice
+    var idx: 2*int = (i,j);                   // Nota: 'índice' es una palabra reservada
+    realArray[idx] = - realArray[(i,j)];      // Indice usando tuplas
+  }
+}
+
+// Las matrices tienen dominios como miembros y pueden ser iterados de manera normal.
+for idx in realArray.domain {  // De nuevo, idx es una tupla 2*int
+  realArray[idx] = 1 / realArray[idx[1], idx[2]]; // Acceso por tupla y lista
+}
+
+writeln(realArray);
+
+// Los valores de una matriz también se pueden iterar directamente.
+var rSum: real = 0;
+for value in realArray {
+  rSum += value; // Read a value
+  value = rSum;  // Write a value
+}
+writeln(rSum, "\n", realArray);
+
+// Las matrices asociativas (diccionarios) se pueden crear utilizando dominios asociativos.
+var dictDomain: domain(string) = { "one", "two" };
+var dict: [dictDomain] int = ["one" => 1, "two" => 2];
+dict["three"] = 3; // Adiciona 'three' a 'dictDomain' implícitamente
+for key in dictDomain.sorted() do
+  writeln(dict[key]);
+
+// Las matrices se pueden asignar entre sí de diferentes maneras.
+// Estos arreglos se usarán en el ejemplo.
+
+var thisArray : [0..5] int = [0,1,2,3,4,5];
+var thatArray : [0..5] int;
+
+// Primero, simplemente asigna uno al otro. Esto copia esta matriz en
+// thatArray, en lugar de simplemente crear una referencia. Por lo tanto, modificando
+// thisArray tampoco modifica thatArray.
+thatArray = thisArray;
+thatArray[1] = -1;
+writeln((thisArray, thatArray));
+
+// Asigna un segmento de una matriz a un segmento (del mismo tamaño) en el otro.
+thatArray[4..5] = thisArray[1..2];
+writeln((thisArray, thatArray));
+
+// Las operaciones también se pueden promover para trabajar en arreglos. 
+// 'thisPlusThat' también es una matriz.
+var thisPlusThat = thisArray + thatArray;
+writeln(thisPlusThat);
+
+// Continuando, las matrices y los bucles también pueden ser expresiones, donde 
+// la expresión del cuerpo del bucle es el resultado de cada iteración.
+var arrayFromLoop = for i in 1..10 do i;
+writeln(arrayFromLoop);
+
+// Una expresión puede resultar en nada, como cuando se filtra con una expresión if.
+var evensOrFives = for i in 1..10 do if (i % 2 == 0 || i % 5 == 0) then i;
+
+writeln(arrayFromLoop);
+
+// Las expresiones de matriz también se pueden escribir con una notación de paréntesis.
+// Nota: esta sintaxis utiliza el concepto paralelo forall discutido más adelante.
+var evensOrFivesAgain = [i in 1..10] if (i % 2 == 0 || i % 5 == 0) then i;
+
+// They can also be written over the values of the array.
+arrayFromLoop = [value in arrayFromLoop] value + 1;
+
+
+// Procedimientos
+
+// Los procedimientos de Chapel tienen funciones de sintaxis similares en otros idiomas.
+proc fibonacci(n : int) : int {
+  if n <= 1 then return n;
+  return fibonacci(n-1) + fibonacci(n-2);
+}
+
+// Los parámetros de entrada pueden estar sin tipo para crear un procedimiento genérico.
+proc doublePrint(thing): void {
+  write(thing, " ", thing, "\n");
+}
+
+// Se puede inferir el tipo de retorno, siempre que el compilador pueda resolverlo.
+proc addThree(n) {
+  return n + 3;
+}
+
+doublePrint(addThree(fibonacci(20)));
+
+// También es posible tomar un número variable de parámetros.
+proc maxOf(x ...?k) {
+  // x se refiere a una tupla de un tipo, con k elementos
+  var maximum = x[1];
+  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));
+
+// Los procedimientos pueden tener valores de parámetros predeterminados, y
+// los parámetros pueden nombrarse en la llamada, incluso fuera de orden.
+proc defaultsProc(x: int, y: real = 1.2634): (int,real) {
+  return (x,y);
+}
+
+writeln(defaultsProc(10));
+writeln(defaultsProc(x=11));
+writeln(defaultsProc(x=12, y=5.432));
+writeln(defaultsProc(y=9.876, x=13));
+
+// El operador ? se llama operador de consulta y se usa para tomar valores 
+// indeterminados como tuplas o tamaños de matriz y tipos genéricos. 
+// Por ejemplo, tomar matrices como parámetros. 
+
+// El operador de consulta se utiliza para determinar el dominio de A. 
+// Esto es útil para definir el tipo de retorno, aunque no es obligatorio.
+proc invertArray(A: [?D] int): [D] int{
+  for a in A do a = -a;
+  return A;
+}
+
+writeln(invertArray(intArray));
+
+// Podemos consultar el tipo de argumentos a los procedimientos genéricos.
+// Aquí definimos un procedimiento que toma dos argumentos del mismo tipo,
+// pero no definimos cuál es ese tipo.
+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);
+
+// También podemos imponer una forma de polimorfismo con la cláusula where
+// Esto permite que el compilador decida qué función usar. 
+
+// Nota: Eso significa que toda la información debe conocerse en tiempo de compilación. 
+// El modificador param en el argumento se usa para imponer esta restricción.
+proc whereProc(param N : int): void
+ where (N > 0) {
+  writeln("N is greater than 0");
+}
+
+proc whereProc(param N : int): void
+ where (N < 0) {
+  writeln("N is less than 0");
+}
+
+whereProc(10);
+whereProc(-1);
+
+// whereProc(0) daría lugar a un error del compilador porque no hay funciones
+// que satisfagan la condición de la cláusula where. 
+// Podríamos haber definido un whereProc sin una cláusula where que
+// hubiera servido como captura para todos los demás casos (de los cuales solo hay uno).
+
+// Las cláusulas where también se pueden usar para restringir según el tipo de argumento.
+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");
+
+// Intenciones
+
+/* Los modificadores de intención en los argumentos transmiten cómo esos argumentos se pasan al procedimiento.
+
+     * in: copia arg adentro, pero no afuera
+     * out: copia arg, pero no dentro
+     * inout: copia arg adentro, copia arg afuera
+     * ref: pasa arg por referencia
+*/
+proc intentsProc(in inarg, out outarg, inout inoutarg, ref refarg) {
+  writeln("Adentro antes: ", (inarg, outarg, inoutarg, refarg));
+  inarg = inarg + 100;
+  outarg = outarg + 100;
+  inoutarg = inoutarg + 100;
+  refarg = refarg + 100;
+  writeln("Adentro después: ", (inarg, outarg, inoutarg, refarg));
+}
+
+var inVar: int = 1;
+var outVar: int = 2;
+var inoutVar: int = 3;
+var refVar: int = 4;
+writeln("Afuera antes: ", (inVar, outVar, inoutVar, refVar));
+intentsProc(inVar, outVar, inoutVar, refVar);
+writeln("Afuera después: ", (inVar, outVar, inoutVar, refVar));
+
+// Del mismo modo, podemos definir intentos en el tipo de retorno. 
+// refElement devuelve una referencia a un elemento de la matriz. Esto tiene más sentido 
+// práctico para los métodos de clase donde las referencias a elementos en una estructura 
+// de datos se devuelven a través de un método o iterador.
+proc refElement(array : [?D] ?T, idx) ref : T {
+  return array[idx];
+}
+
+var myChangingArray : [1..5] int = [1,2,3,4,5];
+writeln(myChangingArray);
+ref refToElem = refElement(myChangingArray, 5); // Almacena una referencia al elemento en variable de referencia
+writeln(refToElem);
+refToElem = -2; // modifica referencia que, a su vez, modifica el valor real en la matriz
+writeln(refToElem);
+writeln(myChangingArray);
+
+// Definiciones del operador
+
+// Chapel permite que los operadores se sobrecarguen.
+// Podemos definir los operadores unarios:
+// + - ! ~
+// y los operadores binarios:
+// + - * / % ** == <= >= < > << >> & | ˆ by
+// += -= *= /= %= **= &= |= ˆ= <<= >>= <=>
+
+// Exclusivo u operador booleano.
+proc ^(left : bool, right : bool): bool {
+  return (left || right) && !(left && right);
+}
+
+writeln(true  ^ true);
+writeln(false ^ true);
+writeln(true  ^ false);
+writeln(false ^ false);
+
+// Define un operador * en cualquiera de los dos tipos que devuelve una tupla de esos tipos.
+proc *(left : ?ltype, right : ?rtype): (ltype, rtype) {
+  writeln("\tIn our '*' overload!");
+  return (left, right);
+}
+
+writeln(1 * "a"); // Utiliza nuestro * operador.
+writeln(1 * 2);   // Utiliza el operador predeterminado *.
+
+//  Note: Podrías romper todo si te descuidas con tus sobrecargas.
+//  Esto aquí lo romperá todo. No lo hagas
+
+/*
+    proc +(left: int, right: int): int {
+      return left - right;
+    }
+*/
+
+// Iteradores
+
+// Los iteradores son hermanas del procedimiento, y casi todo lo relacionado 
+// con los procedimientos también se aplica a los iteradores. Sin embargo, en lugar de 
+// devolver un solo valor, los iteradores pueden generar múltiples valores en un bucle.
+
+// Esto es útil cuando se necesita un conjunto u orden complicado de iteraciones, 
+// ya que permite que el código que define las iteraciones 
+// se separe del cuerpo del bucle.
+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();
+
+// Los iteradores también pueden ceder condicionalmente, cuyo resultado puede ser nada
+iter absolutelyNothing(N): int {
+  for i in 1..N {
+    if N < i { // Always false
+      yield i;     // Yield statement never happens
+    }
+  }
+}
+
+for i in absolutelyNothing(10) {
+  writeln("Woa there! absolutelyNothing yielded ", i);
+}
+
+// Podemos comprimir dos o más iteradores (que tienen el mismo número de iteraciones) 
+// usando zip () para crear un solo iterador comprimido, donde cada iteración 
+// del iterador comprimido produce una tupla de un valor de cada iterador.
+for (positive, negative) in zip(1..5, -5..-1) do
+  writeln((positive, negative));
+
+// La iteración de la cremallera es bastante importante en la asignación de matrices, 
+// segmentos de matrices y expresiones de matriz / bucle.
+var fromThatArray : [1..#5] int = [1,2,3,4,5];
+var toThisArray : [100..#5] int;
+
+// Algunas operaciones de cierre implementan otras operaciones.
+// La primera declaración y el bucle son equivalentes.
+toThisArray = fromThatArray;
+for (i,j) in zip(toThisArray.domain, fromThatArray.domain) {
+  toThisArray[i] = fromThatArray[j];
+}
+
+// Estos dos pedazos también son equivalentes.
+toThisArray = [j in -100..#5] j;
+writeln(toThisArray);
+
+for (i, j) in zip(toThisArray.domain, -100..#5) {
+  toThisArray[i] = j;
+}
+writeln(toThisArray);
+
+/*
+ Esto es muy importante para entender por qué esta declaración 
+ exhibe un error de tiempo de ejecución.
+*/
+
+/*
+  var iterArray : [1..10] int = [i in 1..10] if (i % 2 == 1) then i;
+*/
+
+// Aunque el dominio de la matriz y la expresión de bucle son del mismo tamaño,
+// el cuerpo de la expresión puede considerarse como un iterador.
+// Debido a que los iteradores pueden producir nada, ese iterador produce un número
+// diferente de cosas que el dominio de la matriz o bucle, que no está permitido.
+
+// Clases
+
+// Las clases son similares a las de C ++ y Java, asignadas en el montón.
+class MyClass {
+
+// Variables miembro
+  var memberInt : int;
+  var memberBool : bool = true;
+
+// Inicializador definido explícitamente. 
+// También obtenemos el inicializador generado por el compilador, con un argumento por campo.
+// Tenga en cuenta que pronto no habrá un inicializador generado por el compilador 
+// cuando definamos los inicializadores explícitamente.
+  proc init(val : real) {
+    this.memberInt = ceil(val): int;
+  }
+
+// Desinicializador explícitamente definido.
+// Si no escribiéramos uno, obtendríamos el desinicializador generado por el compilador, 
+// que tiene un cuerpo vacío.
+  proc deinit() {
+    writeln("MyClass deinitializer called ", (this.memberInt, this.memberBool));
+  }
+
+// Métodos de clase.
+  proc setMemberInt(val: int) {
+    this.memberInt = val;
+  }
+
+  proc setMemberBool(val: bool) {
+    this.memberBool = val;
+  }
+
+  proc getMemberInt(): int{
+    return this.memberInt;
+  }
+
+  proc getMemberBool(): bool {
+    return this.memberBool;
+  }
+} // termina MyClass
+
+// Llame al inicializador generado por el compilador, 
+// utilizando el valor predeterminado para memberBool.
+var myObject = new MyClass(10);
+    myObject = new MyClass(memberInt = 10); // Equivalente
+writeln(myObject.getMemberInt());
+
+// Same, but provide a memberBool value explicitly.
+var myDiffObject = new MyClass(-1, true);
+    myDiffObject = new MyClass(memberInt = -1, memberBool = true); // Equivalente
+writeln(myDiffObject);
+
+// Llame al inicializador que escribimos.
+var myOtherObject = new MyClass(1.95);
+    myOtherObject = new MyClass(val = 1.95); // Equivalente
+writeln(myOtherObject.getMemberInt());
+
+// También podemos definir un operador en nuestra clase,
+// pero la definición tiene que estar fuera de la definición de la clase.
+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);
+
+// Destrucción.
+delete myObject;
+delete myDiffObject;
+delete myOtherObject;
+delete plusObject;
+
+// Las clases pueden heredar de una o más clases primarias
+class MyChildClass : MyClass {
+  var memberComplex: complex;
+}
+
+// Aquí hay un ejemplo de clases genéricas.
+class GenericClass {
+  type classType;
+  var classDomain: domain(1);
+  var classArray: [classDomain] classType;
+
+// Constructor explícito.
+  proc GenericClass(type classType, elements : int) {
+    this.classDomain = {1..#elements};
+  }
+
+// Copiar constructor.
+// Nota: Todavía tenemos que poner el tipo como argumento, pero podemos usar
+// el operador de consulta (?) como predeterminado para el tipo del otro objeto. 
+// Además, podemos aprovechar esto para permitir a nuestro constructor de copias 
+// copiar clases de diferentes tipos y emitir sobre la marcha.
+  proc GenericClass(other : GenericClass(?otherType),
+                     type classType = otherType) {
+    this.classDomain = other.classDomain;
+    // Copiar y Convertir
+    for idx in this.classDomain do this[idx] = other[idx] : classType;
+  }
+
+// Defina la notación de corchetes en un objeto GenericClass
+// para que pueda comportarse como una matriz normal
+// i.e. objVar[i] or objVar(i)
+  proc this(i : int) ref : classType {
+    return this.classArray[i];
+  }
+
+// Definir un iterador implícito para que la clase produzca 
+// valores de la matriz a un bucle
+// i.e. for i in objVar do ...
+  iter these() ref : classType {
+    for i in this.classDomain do
+      yield this[i];
+  }
+} // end GenericClass
+
+// Podemos asignar a la matriz de miembros del objeto usando la notación de 
+// corchete que definimos.
+var realList = new GenericClass(real, 10);
+for i in realList.classDomain do realList[i] = i + 1.0;
+
+// Podemos iterar sobre los valores en nuestra lista con el iterador 
+// que definimos.
+for value in realList do write(value, ", ");
+writeln();
+
+// Haga una copia de realList usando el constructor de copias.
+var copyList = new GenericClass(realList);
+for value in copyList do write(value, ", ");
+writeln();
+
+// Haga una copia de realList y cambie el tipo, también utilizando el constructor de copias.
+var copyNewTypeList = new GenericClass(realList, int);
+for value in copyNewTypeList do write(value, ", ");
+writeln();
+
+
+// Módulos
+
+// Los módulos son la forma en que Chapel administra los espacios de nombres.
+// Los archivos que contienen estos módulos no necesitan ser nombrados después
+// de los módulos (como en Java), pero los archivos implícitamente nombran módulos. 
+// Por ejemplo, este archivo nombra implícitamente el módulo learnChapelInYMinutes
+
+module OurModule {
+
+// Podemos usar módulos dentro de otros módulos.
+// Time es uno de los módulos estándar.
+  use Time;
+
+// Usaremos este procedimiento en la sección de paralelismo.
+  proc countdown(seconds: int) {
+    for i in 1..seconds by -1 {
+      writeln(i);
+      sleep(1);
+    }
+  }
+
+// Es posible crear nidos de módulos arbitrariamente profundos.
+// i.e. submódulos de OurModule
+  module ChildModule {
+    proc foo() {
+      writeln("ChildModule.foo()");
+    }
+  }
+
+  module SiblingModule {
+    proc foo() {
+      writeln("SiblingModule.foo()");
+    }
+  }
+} // end OurModule
+
+// Usando OurModule también usa todos los módulos que usa.
+// Como OurModule usa Time, nosotros también usamos Time.
+use OurModule;
+
+// En este punto no hemos usado ChildModule o SiblingModule, por lo que sus símbolos 
+// (es decir, foo) no están disponibles para nosotros. Sin embargo, los nombres de
+// los módulos están disponibles y podemos llamar explícitamente a foo () a través de ellos.
+SiblingModule.foo();
+OurModule.ChildModule.foo();
+
+// Ahora usamos ChildModule, que permite llamadas no calificadas.
+use ChildModule;
+foo();
+
+// Paralelismo
+
+// En otros idiomas, el paralelismo generalmente se realiza con librerias complicadas
+// y extrañas jerarquías de estructura de clases. 
+// Chapel lo tiene directamente en el idioma.
+
+// Podemos declarar un procedimiento principal, pero todo el código anterior
+// a main todavía se ejecuta.
+proc main() {
+
+// Una declaración de inicio hará girar el cuerpo de esa declaración en una nueva tarea.
+// Una declaración de sincronización garantizará que el progreso de la tarea principal 
+// no avance hasta que los hijos hayan sincronizado nuevamente.
+
+  sync {
+    begin { // Inicio del cuerpo de la nueva tarea.
+      var a = 0;
+      for i in 1..1000 do a += 1;
+      writeln("Done: ", a);
+    } // Fin del nuevo cuerpo de tareas
+    writeln("escindió una tarea!");
+  }
+  writeln("De nuevo juntos");
+
+  proc printFibb(n: int) {
+    writeln("fibonacci(",n,") = ", fibonacci(n));
+  }
+
+// Una declaración de cobegin girará cada declaración del cuerpo en una nueva tarea.
+// Observe aquí que las impresiones de cada declaración pueden ocurrir en 
+// cualquier orden.
+  cobegin {
+    printFibb(20); // nueva tarea
+    printFibb(10); // nueva tarea
+    printFibb(5);  // nueva tarea
+    {
+      // Este es un cuerpo de declaración anidado y, por lo tanto, es una 
+      // declaración única para la declaración principal, ejecutada 
+      // por una sola tarea.
+      writeln("esto se ");
+      writeln("ejecuta");
+      writeln("como un todo");
+    }
+  }
+
+// Un bucle coforall creará una nueva tarea para CADA iteración. 
+// Nuevamente vemos que las impresiones suceden en cualquier orden. 
+// NOTA: ¡coforall debe usarse solo para crear tareas! 
+// ¡Usarlo para iterar sobre una estructura es una muy mala idea!
+  var num_tasks = 10; // Number of tasks we want
+  coforall taskID in 1..#num_tasks {
+    writeln("Hola de tarea# ", taskID);
+  }
+
+// los bucles forall son otro bucle paralelo, pero solo crean un número 
+// menor de tareas, específicamente --dataParTasksPerLocale = número de tareas.
+  forall i in 1..100 {
+    write(i, ", ");
+  }
+  writeln();
+
+// Aquí vemos que hay secciones que están en orden, seguidas de una sección 
+// que no seguiría (por ejemplo, 1, 2, 3, 7, 8, 9, 4, 5, 6,). 
+// Esto se debe a que cada tarea está asumiendo un fragmento del rango 1..10
+// (1..3, 4..6 o 7..9) haciendo ese fragmento en serie, pero cada tarea ocurre en paralelo. 
+// Sus resultados pueden depender de su máquina y configuración
+
+// Para los bucles forall y coforall, la ejecución de la tarea principal 
+// no continuará hasta que todos los hijos se sincronicen.
+
+// los bucles forall son particularmente útiles para la iteración paralela sobre matrices.
+// Hagamos un experimento para ver qué tan rápido es un ciclo paralelo.
+
+  use Time; // Importe el módulo Time para usar objetos de Timer
+  var timer: Timer;
+  var myBigArray: [{1..4000,1..4000}] real; // Gran matriz en la que escribiremos
+
+// Experimento en serie:
+  timer.start(); // Iniciar temporizador
+  for (x,y) in myBigArray.domain { // Iteración en serie
+    myBigArray[x,y] = (x:real) / (y:real);
+  }
+  timer.stop(); // Detener temporizador
+  writeln("Serial: ", timer.elapsed()); // Imprimir tiempo transcurrido
+  timer.clear(); // Limpia el temporizador para bucle paralelo
+
+// Experimento Paralelo:
+  timer.start(); // Iniciar temporizador
+  forall (x,y) in myBigArray.domain { // Iteración paralela
+    myBigArray[x,y] = (x:real) / (y:real);
+  }
+  timer.stop(); // Detener temporizador
+  writeln("Parallel: ", timer.elapsed()); // Imprimir tiempo transcurrido
+  timer.clear();
+
+// Puede que hayas notado que (dependiendo de cuántos núcleos tengas)
+// el ciclo paralelo fue más rápido que el ciclo serial.
+
+// La expresión de bucle estilo corchete descrita mucho antes utiliza
+// implícitamente un bucle forall.
+  [val in myBigArray] val = 1 / val; // Operación paralela
+
+// Las variables atómicas, comunes a muchos idiomas, son aquellas cuyas operaciones
+// ocurren sin interrupciones. Por lo tanto, varios subprocesos pueden modificar
+// las variables atómicas y pueden saber que sus valores son seguros. 
+// Las variables atómicas de la capilla pueden ser de tipo bool, int, uint y real.
+  var uranium: atomic int;
+  uranium.write(238);      // escribir atómicamente una variable
+  writeln(uranium.read()); // leer atómicamente una variable
+
+// Las operaciones atómicas se describen como funciones, por lo que puede definir
+// las suyas propias.
+  uranium.sub(3); // restar atómicamente una variable
+  writeln(uranium.read());
+
+  var replaceWith = 239;
+  var was = uranium.exchange(replaceWith);
+  writeln("El uranio era", was, ", pero ahora es ", replaceWith);
+
+  var isEqualTo = 235;
+  if uranium.compareExchange(isEqualTo, replaceWith) {
+    writeln("El uranio era igual a ", isEqualTo,
+             " pero valor reemplazado por", replaceWith);
+  } else {
+    writeln("uranio no era igual a ", isEqualTo,
+             " así que el valor permanece igual... sea lo que sea");
+  }
+
+  sync {
+    begin { // Tarea del lector
+      writeln("Lector: esperando que el uranio sea ", isEqualTo);
+      uranium.waitFor(isEqualTo);
+      writeln("Lector: el uranio fue configurado (por alguien) para ", isEqualTo);
+    }
+
+    begin { // Tarea de escritor
+      writeln("Escritor: establecerá uranio en el valor ", isEqualTo, " en...");
+      countdown(3);
+      uranium.write(isEqualTo);
+    }
+  }
+
+// las variables de sincronización tienen dos estados: vacío y lleno.
+// Si lee una variable vacía o escribe una variable completa, 
+// se espera hasta que la variable esté llena o vacía nuevamente.
+  var someSyncVar$: sync int; // varName$ Es una convención, no una ley.
+  sync {
+    begin { // Tarea del lector
+      writeln("Lector: esperando leer.");
+      var read_sync = someSyncVar$;
+      writeln("Lector: el valor es ", read_sync);
+    }
+
+    begin { // Tarea de escritor
+      writeln("Escritor: escribirá en...");
+      countdown(3);
+      someSyncVar$ = 123;
+    }
+  }
+
+// las variales individuales solo se pueden escribir una vez. 
+// Una lectura en un solo no escrito da como resultado una espera,
+// pero cuando la variable tiene un valor, puede leerse indefinidamente.
+  var someSingleVar$: single int; // varName$ Es una convención, no una ley.
+  sync {
+    begin { // Tarea del lector
+      writeln("Lector: esperando leer.");
+      for i in 1..5 {
+        var read_single = someSingleVar$;
+        writeln("Lector: iteración ", i,", y el valor es ", read_single);
+      }
+    }
+
+    begin { // Tarea de escritor
+      writeln("Escritor: escribirá en ...");
+      countdown(3);
+      someSingleVar$ = 5; // primero y único escrito.
+    }
+  }
+
+// Aquí hay un ejemplo usando atómica y una variable de sincronización 
+// para crear un mutex de cuenta regresiva
+//  (también conocido como multiplexor).
+  var count: atomic int; // nuestro mostrador
+  var lock$: sync bool;   // la cerradura mutex
+
+  count.write(2);       // Solo deje dos tareas a la vez.
+  lock$.writeXF(true);  // Establezca lock$ en completo (desbloqueado)
+  // Nota: el valor en realidad no importa, solo el estado
+  // (completo: desbloqueado / vacio: bloqueado)
+  // Además, writeXF() llena (F) la variable de sincronización independientemente de su estado (X)
+
+  coforall task in 1..#5 { // Generar tareas
+    // Create a barrier
+    do {
+      lock$;                 // Leer lock$ (espera)
+    } while (count.read() < 1); // Sigue esperando hasta que se abra un lugar
+
+    count.sub(1);          //disminuir el contador
+    lock$.writeXF(true); // Establezca lock$ en completo (señal)
+
+    // 'Trabajo' actual
+    writeln("Tarea #", task, " trabajando");
+    sleep(2);
+
+    count.add(1);        // Incrementa el contador
+    lock$.writeXF(true); // Establezca lock$ en completo (señal)
+  }
+
+// Podemos definir las operaciones + * & | ^ && || min max minloc maxloc
+// sobre una matriz completa usando escaneos y reducciones.
+// Las reducciones aplican la operación en toda la matriz
+// y dan como resultado un valor escalar.
+
+  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' da solo el valor máximo
+
+// maxloc proporciona el valor máximo y el índice del valor máximo.
+// Nota: Tenemos que comprimir la matriz y el dominio junto con el iterador zip.
+  var (theMaxValue, idxOfMax) = maxloc reduce zip(listOfValues,
+                                                  listOfValues.domain);
+
+  writeln((sumOfValues, maxValue, idxOfMax, listOfValues[idxOfMax]));
+
+// Los escaneos aplican la operación de forma incremental y devuelven una matriz
+// con los valores de la operación en ese índice a medida que avanza a través
+// de la matriz desde array.domain.low hasta array.domain.high.
+  var runningSumOfValues = + scan listOfValues;
+  var maxScan = max scan listOfValues;
+  writeln(runningSumOfValues);
+  writeln(maxScan);
+} // end main()
+```
+
+¿Para quién es este tutorial?
+-------------------------
+
+Este tutorial es para personas que desean aprender las cuerdas de chapel sin tener
+que escuchar sobre qué mezcla de fibras son las cuerdas, o cómo fueron trenzadas,
+o cómo las configuraciones de trenzas difieren entre sí. No le enseñará cómo
+desarrollar código increíblemente eficaz, y no es exhaustivo.
+Referirse a [especificación de idioma](https://chapel-lang.org/docs/latest/language/spec.html)(en) y
+a [documentación del módulo](https://chapel-lang.org/docs/latest/)(en) para más detalles.
+
+Ocasionalmente, vuelva aquí en el [website de Chapel](https://chapel-lang.org)
+para ver si se han agregado más temas o se han creado más tutoriales.
+
+### Lo que le falta a este tutorial:
+
+ * Exposición de los [módulos estándar](https://chapel-lang.org/docs/latest/modules/standard.html)
+ * Múltiples configuraciones regionales (sistema de memoria distribuida)
+ * Registros
+ * Iteradores paralelos
+
+¡Sus comentarios, preguntas y descubrimientos son importantes para los desarrolladores!
+-----------------------------------------------------------------------
+
+El lenguaje Chapel todavía está en desarrollo activo, por lo que 
+ocasionalmente hay problemas con el rendimiento y 
+las características del lenguaje.
+
+Cuanta más información brinde al equipo de desarrollo de Chapel 
+sobre los problemas que encuentre o las características que le gustaría ver, 
+mejor será el lenguaje.
+
+
+Hay varias formas de interactuar con los desarrolladores:
++ [Chat de Gitter](https://gitter.im/chapel-lang/chapel)
++ [lista de emails de Sourceforge](https://sourceforge.net/p/chapel/mailman)
+
+Si está realmente interesado en el desarrollo del compilador o en contribuir al proyecto,
+[consulte el repositorio maestro de GitHub](https://github.com/chapel-lang/chapel).
+Está bajo el [La licencia Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0).
+
+Instalar el compilador
+-----------------------
+
+[La documentación oficial de Chapel detalla cómo descargar y compilar el compilador de Chapel.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
+
+Chapel se puede construir e instalar en su máquina promedio 'nix (y cygwin). 
+[Descargue la última versión de lanzamiento](https://github.com/chapel-lang/chapel/releases/)
+y es tan fácil como
+
+ 1. `tar -xvf chapel-<VERSION>.tar.gz`
+ 2. `cd chapel-<VERSION>`
+ 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).
+
+Necesitará `source util/setchplenv.EXT` desde el directorio de Chapel (`$CHPL_HOME`)
+cada vez que se inicie su terminal, por lo que se sugiere que suelte ese comando 
+en un script que se ejecutará al inicio (como .bashrc).
+
+Chapel se instala fácilmente con Brew para OS X
+
+ 1. `brew update`
+ 2. `brew install chapel`
+
+Compilando Código
+--------------
+
+Construye como otros compiladores:
+
+`chpl myFile.chpl -o myExe`
+
+Argumentos notables:
+
+ * `--fast`: habilita varias optimizaciones y deshabilita las comprobaciones 
+ de los límites de la matriz Solo debe habilitarse cuando la aplicación es estable.
+ * `--set <Nombre del Symbolo>=<Valor>`: establece el param de configuracion 
+ `<Nombre del Symbolo>` a `<Valor>`en tiempo de compilación.
+ * `--main-module <Nombre del módulo>`: use el procedimiento main() que se encuentra en el módulo
+    `<Nombre del módulo>` como principal del ejecutable.
+ * `--module-dir <Directorio>`: incluye `<Directorio>` en la ruta de búsqueda del módulo.
diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
index 62935ebe..9f25425c 100644
--- a/es-es/clojure-es.html.markdown
+++ b/es-es/clojure-es.html.markdown
@@ -431,7 +431,7 @@ funciones principales (pertenecientes al core):
 [http://clojuredocs.org/quickref](http://clojuredocs.org/quickref)
 
 4Clojure es una genial forma de mejorar tus habilidades con clojure/FP:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org (sí, de verdad) tiene un buen número de artículos con los que
 iniciarse en Clojure: [http://clojure-doc.org](http://clojure-doc.org)
diff --git a/es-es/css-es.html b/es-es/css-es.html
deleted file mode 100644
index 506a9467..00000000
--- a/es-es/css-es.html
+++ /dev/null
@@ -1,327 +0,0 @@
----
-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 6395f5fd..506a9467 100644
--- a/es-es/css-es.html.markdown
+++ b/es-es/css-es.html.markdown
@@ -1,253 +1,327 @@
 ---
 language: css
-filename: learncss-es.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:
-    - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+    - ["miky ackerman", "https://github.com/mikyackerman"]
 lang: es-es
+filename: learncss-es.css
 ---
 
-Tutorial de CSS en español
+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.
 
-En los primeros días de la web no había elementos visuales, todo
-era texto plano. Pero después, con el desarrollo de los navegadores,
-las páginas con contenido visual empezaron a ser más comunes.
-CSS es el lenguaje estándar que existe para separar el contenido
-(HTML) y el aspecto visual de las páginas web.
+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
 
-Lo que CSS hace es proveer con una sintaxis que te permite apuntar a distintos 
-elementos HTML y asignarles diferentes propiedades visuales.
+Esta guia ha sido escrita con CSS 2 en mente, la cual es extendida por una nueva caracterica de CSS 3.
 
-CSS, como cualquier otro lenguaje, tiene múltiples versiones. Aquí nos enfocamos
-en CSS 2.0. No es la versión más reciente pero sí la más soportada y compatible.
+**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.
 
-**NOTA:** Como los resultados de CSS son efectos visuales, para aprenderlo, 
-necesitarás probar todo tipo de cosas en ambientes como 
-[dabblet](http://dabblet.com/). Este artículo se enfoca, principalmente, en
-la sintaxis y consejos generales.
+## Sintaxis
 
 ```css
-/* ¡Los comentarios aparecen dentro de diagonal-asterisco, justo como esta línea! */
+/* 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.*/
+ 
 
 /* ####################
-   ## SELECTORES
-   ####################*/
-
-/* Generalmente, la sentencia principal en CSS es muy simple. */
-selector { propiedad: valor; /* más propiedades separados por punto y coma...*/ }
-
-/* El selector es usado para apuntar a (seleccionar) un elemento en la página.
+   ## SELECTORS
+   #################### */
 
-¡Puedes apuntar a todos los elementos en la página con el asterisco! */
-* { color:red; }
+/* el selector es usado para apuntar a un elemento de la pagina. */
+selector { property: value; /* more properties...*/ }
 
 /*
-Dado un elemento como este en la página:
+Here is an example element:
 
-<div class='una-clase clase2' id='unaId' attr='valor' />
+<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
 */
 
-/* puedes seleccionar el <div> por el nombre de su clase */
-.una-clase { }
+/* You can target it using one of its CSS classes */
+.class1 { }
 
-/*¡O por sus dos clases! */
-.una-clase.clase2 { }
+/* or both classes! */
+.class1.class2 { }
 
-/* O por el nombre de su elemento */
+/* or its name */
 div { }
 
-/* O por su Id */
-#unaId { }
+/* or its id */
+#anID { }
 
-/* ¡O por el hecho de que tiene un atributo! */
+/* or using the fact that it has an attribute! */
 [attr] { font-size:smaller; }
 
-/* O por el hecho de que el atributo tiene un valor determinado */
-[attr='valor'] { font-size:smaller; }
+/* or that the attribute has a specific value */
+[attr='value'] { font-size:smaller; }
 
-/* Empieza con un valor ('val' en este caso)*/
+/* starts with a value (CSS 3) */
 [attr^='val'] { font-size:smaller; }
 
-/* O termina con un valor ('or' en este caso) */
-[attr$='or'] { 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; }
+
 
-/* O incluso contiene un valor ('lo' en este caso) */
-[attr~='lo'] { 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'] { }
 
-/*Más importante, puedes combinar estos criterios de búsqueda entre sí.
-No debe existir ningún espacio entre estas partes porque hace que el 
-significado cambie.*/
-div.una-clase[attr$='or'] { }
+/* You can select an element which is a child of another element */
+div.some-parent > .class-name { }
 
-/* También puedes seleccionar un elemento HTML basándote en sus padres*/
+/* 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 { }
 
-/* Un elemento que es hijo directo de otro elemento (Seleccionado de la forma que
-vimos anteriormente) */
+/* Warning: the same selector without a space has another meaning.
+   Can you guess what? */
+div.some-parent.class-name { }
 
-div.un-padre > .nombre-clase {}
+/* You may also select an element based on its adjacent sibling */
+.i-am-just-before + .this-element { }
 
-/* O cualquiera de sus ancestros en la jerarquía*/
-/* La siguiente sentencia selecciona a cualquier elemento que tenga una clase
-"nombre-clase" y sea hijo de un div con clase "un-padre" EN CUALQUIER PROFUNDIDAD*/
-div.un-padre .nombre-clase {}
+/* or any sibling preceding it */
+.i-am-any-element-before ~ .this-element { }
 
-/* advertencia: el mismo selector sin espacio tiene otro significado. ¿Puedes
-identificar la diferencia?*/
+/* There are some selectors called pseudo classes that can be used to select an
+   element only when it is in a particular state */
 
-/* También puedes seleccionar un elemento basado en su hermano inmediato previo*/
-.yo-estoy-antes + .este-elemento { }
+/* for example, when the cursor hovers over an element */
+selector:hover { }
 
-/*o cualquier hermano previo */
-.yo-soy-cualquiera-antes ~ .estes-elemento {}
+/* or a link has been visited */
+selector:visited { }
 
-/* Existen algunas pseudo-clases que permiten seleccionar un elemento
-basado en el comportamiendo de la página (a diferencia de la estructura de
-la página) */
+/* or hasn't been visited */
+selected:link { }
 
-/* Por ejemplo, para cuando pasas el mouse por encima de un elemento */
-:hover {}
+/* or an element is in focus */
+selected:focus { }
 
-/* o una liga visitada*/
-:visited {}
+/* any element that is the first child of its parent */
+selector:first-child {}
 
-/* o una liga no visitada aún*/
-:link {}
+/* any element that is the last child of its parent */
+selector:last-child {}
 
-/* o un elemento de un formulario que esté seleccionado */
-:focus {}
+/* 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 */
 
 /* ####################
-   ## PROPIEDADES
-   ####################*/
+   ## PROPERTIES
+   #################### */
 
 selector {
-    
-    /* Unidades */
-    width: 50%; /* en porcentaje */
-    font-size: 2em; /* dos veces el tamaño de la fuente actual */
-    width: 200px; /* en pixeles */
-    font-size: 20pt; /* en puntos */
-    width: 5cm; /* en centimetros */
-    width: 50mm; /* en milimetros */
-    width: 5in; /* en pulgadas */
-    
-    /* Colores */
-    background-color: #F6E;  /* en hexadecimal corto */
-    background-color: #F262E2; /* en hexadecimal largo */
-    background-color: tomato; /* puede ser un color con nombre */
-    background-color: rgb(255, 255, 255); /* en rgb */
-    background-color: rgb(10%, 20%, 50%); /* en rgb percent */
-    background-color: rgba(255, 0, 0, 0.3); /* en rgb semi-transparente (con valor alfa)*/
-    
-    /* Imagenes */
-    background-image: url(/ruta-a-la-imagen/imagen.jpg);
-    
-    /* Fuentes */
+
+    /* 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;
-    font-family: "Courier New"; /* si el nombre contiene espacios, debe ir entre comillas */
-    font-family: "Courier New", Trebuchet, Arial; /* si la primera fuente no se encontró 
-    entonces se busca la seguna, o la tercera, así recursivamente*/
+    /* 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;
 }
-
 ```
 
-## Uso
+## Usage
 
-Guarda cualquier CSS que quieras en un archivo con extensión `.css`.
+Save a CSS stylesheet with the extension `.css`.
 
-```xml
-<!-- Necesitas incluir tu archivo CSS en el elemento <head> de tu HTML: -->
-<link rel='stylesheet' type='text/css' href='ruta/archivoDeEstilos.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'>
 
-<!--
-también puedes incluir CSS dentro del archivo HTML. Esta no es una buena práctica
-y debe ser evitada.
--->
+<!-- You can also include some CSS inline in your markup. -->
 <style>
-   selector { propiedad:valor; }
+   a { color: purple; }
 </style>
 
-<!--
-También se pueden aplicar propiedades al elemento directamente.
-Esta práctica también debe ser evitada a toda costa
--->
-<div style='propiedad:valor;'>
+<!-- Or directly set CSS properties on the element. -->
+<div style="border: 1px solid red;">
 </div>
-
 ```
 
-## Preferencia y orden
+## 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) .
 
-Como te habrás dado cuenta un elemento puede ser seleccionado por más
-de un selector. En este caso alguna de las reglas cobra preferencia
-sobre las otras:
+This process is called cascading, hence the name Cascading Style Sheets.
 
-Dado el siguiente CSS:
+Given the following CSS:
 
 ```css
-/*A*/
-p.clase1[attr='valor']
+/* A */
+p.class1[attr='value']
 
-/*B*/
-p.clase1 {}
+/* B */
+p.class1 { }
 
-/*C*/
-p.clase2 {}
+/* C */
+p.class2 { }
 
-/*D*/
-p {}
+/* D */
+p { }
 
-/*E*/
-p { propiedad: valor !important; }
+/* E */
+p { property: value !important; }
+```
 
+and the following markup:
+
+```html
+<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
 ```
 
-Y el siguiente HTML:
+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;
+}
 
-```xml
-<p style='/*F*/ propiedad:valor;' class='clase1 clase2' attr='valor'>
-</p>
+/* 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;
+  }
+}
 ```
 
-El orden respetado es el siguiente:  
-Recuerda, la preferencia es por cada **property**, no para el bloque completo.
+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-`.
 
-* `E` tiene la preferencia más elevada gracias a la palabra `!important`.  
-	Es recomendado evitar esto a menos que sea estrictamente necesario incluirlo.
-* `F` le sigue, porque es estilo incrustado directamente en el HTML.
-* `A` le sigue, porque es más específico que cualquier otra opción.  
-	más específico = más especificadores. Aquí hay tres especificadores: elemento `p` +   
-	nombre de la clase `clase1` + un atributo `attr='valor'`
-* `C` le sigue. Aunque tiene el mismo número de especificadores como `B`  
-	pero aparece después.
-* Luego va `B`
-* y al final  `D`.
+The `resolution` feature is not supported by older devices, instead use `device-pixel-ratio`.
 
-## Compatibilidad
+Many smartphones and tablets will attempt to render the page as if it were on a desktop unless you provide a `viewport` meta-tag.
 
-La mayoría de las funcionalidades de CSS2 (y gradualmente de CSS3) son compatibles 
-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.
+```html
+<head>
+  <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
+## Compatibility
 
-[QuirksMode CSS](http://www.quirksmode.org/css/) es una excelente referencia para esto.
+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.
 
-## Recursos
+## Resources
 
-* 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/).
+* [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)
 
-## Otras lecturas
+## 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/).
+* [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).
+* [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/docker-es.html.markdown b/es-es/docker-es.html.markdown
new file mode 100644
index 00000000..81e3cefe
--- /dev/null
+++ b/es-es/docker-es.html.markdown
@@ -0,0 +1,167 @@
+---
+language: docker
+filename: docker-es.bat
+contributors:
+    - ["Ruslan López", "http://javapro.org/"]
+    - ["Michael Chen", "https://github.com/ML-Chen"]
+lang: es-es
+---
+
+```bat
+:: descargar, instalar y ejecutar la imágen del hola mundo
+docker run hello-world
+
+:: Si esta es la primera vez, deberíais de poder ver el mensaje
+:: Unable to find image 'hello-world:latest' locally
+:: latest: Pulling from library/hello-world
+:: 1b930d010525: Pull complete                                                                                          
+::   Digest: sha256:4fe721ccc2e8dc7362278a29dc660d833570ec2682f4e4194f4ee23e415e1064
+:: Status: Downloaded newer image for hello-world:latest
+:: 
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+:: 
+:: To generate this message, Docker took the following steps:
+:: 1. The Docker client contacted the Docker daemon.
+:: 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+:: 3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+:: 4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+:: 
+:: To try something more ambitious, you can run an Ubuntu container with:
+::  $ docker run -it ubuntu bash
+:: 
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+:: 
+:: For more examples and ideas, visit:
+:: https://docs.docker.com/get-started/
+:: El susodicho mensaje se podría traducir como:
+:: 
+:: Hola desde Docker!
+:: Este mensaje muestra que su instalación parece estar funcionando crrectamente.
+:: 
+:: Para generar este mensaje, Docker realizó los siguientes pasos:
+:: 1. El cliente de Docker contactó a Docker daemon.
+:: 2. El Docker daemon obtubo la imágen "hello-world" desde Docker Hub.
+::     (amd64)
+:: 3. El Docker daemon creó un nuevo contenedor a partir de esa imagen con la cual ejecuta el
+::     ejecutable que produce la salida que estás leyendo.
+:: 4. El Docker daemon transmitió dicha salida el cliente Docker, el cual
+::     la envió a tu terminal.
+:: 
+:: Para intentar algo más ambicioso, puede correr un contenedor Ubuntu mediante:
+::  $ docker run -it ubuntu bash
+:: 
+:: Comparte imágenes, automatice flujos y más con un Docker ID gratuito:
+::  https://hub.docker.com/
+
+:: ahora veamos las imágenes que se están ejecutando actualmente
+docker ps
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            
+::   NAMES
+
+:: veamos las imágenes que hemos ejecutado previamente
+docker ps -a
+
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS     
+::          NAMES
+:: 4a76281f9c53        hello-world         "/hello"            2 minutes ago       Exited (0) 2 minutes ago             
+::          happy_poincare
+:: la parte del nombre se genera automáticamente, así que probablemente sea diferente para vos
+
+:: eliminemos nuestra imagen previamente generada
+docker rm happy_poincare
+
+:: verifiquemos si realmente fue borrada
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            
+::   NAMES
+
+:: especifiquemos un nombre personalizado para el contenedor
+docker run --name test_container hello-world
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+:: 
+:: To generate this message, Docker took the following steps:
+::  1. The Docker client contacted the Docker daemon.
+::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+::  3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+::  4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+:: 
+:: To try something more ambitious, you can run an Ubuntu container with:
+:: $ docker run -it ubuntu bash
+:: 
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+:: 
+:: For more examples and ideas, visit:
+::  https://docs.docker.com/get-started/
+
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                         PORTS
+::               NAMES
+:: d345fe1a4f41        hello-world         "/hello"            About a minute ago   Exited (0) About a minute ago       
+::                test_container
+:: tal como podeis ver el nombre es el que especificamos
+
+:: obtener los registros de un contenedor nombrado
+docker logs test_container
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+:: 
+:: To generate this message, Docker took the following steps:
+::  1. The Docker client contacted the Docker daemon.
+::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+::  3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+::  4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+:: 
+:: To try something more ambitious, you can run an Ubuntu container with:
+:: $ docker run -it ubuntu bash
+:: 
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+:: 
+:: For more examples and ideas, visit:
+::  https://docs.docker.com/get-started/
+
+docker rm test_container
+
+docker run ubuntu
+::  Unable to find image 'ubuntu:latest' locally
+::  latest: Pulling from library/ubuntu
+::  2746a4a261c9: Pull complete                                                                                         
+::                                                        4c1d20cdee96: Pull complete                                                                                                                                                 0d3160e1d0de: Pull complete                                                                                                                                                 c8e37668deea: Pull complete                                                                                                                                                 Digest: sha256:250cc6f3f3ffc5cdaa9d8f4946ac79821aafb4d3afc93928f0de9336eba21aa4
+::  Status: Downloaded newer image for ubuntu:latest
+
+docker ps -a
+::  CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS    
+::           NAMES
+::  c19e9e5b000a        ubuntu              "/bin/bash"         5 seconds ago       Exited (0) 4 seconds ago            
+::           relaxed_nobel
+
+::  ejecutando un contenedor en modo interactivo
+docker run -it ubuntu
+::  root@e2cac48323d2:/# uname
+::  Linux
+::  root@e2cac48323d2:/# exit
+::  exit
+
+docker rm relaxed_nobel
+
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                          PORTS
+::               NAMES
+:: e2cac48323d2        ubuntu              "/bin/bash"         2 minutes ago       Exited (0) About a minute ago        
+::               nifty_goldwasser
+
+docker rm nifty_goldwasser
+```
diff --git a/es-es/elixir-es.html.markdown b/es-es/elixir-es.html.markdown
index 885165a6..37acf6ad 100644
--- a/es-es/elixir-es.html.markdown
+++ b/es-es/elixir-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -23,10 +23,10 @@ y otras características más.
 # No hay comentarios multilinea,
 # pero se pueden apilar varios comentarios.
 
-# Para usar el shell de elixir se usa el comando `iex`.
+# 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.
+# Ambos deberían estar en la ruta si Elixir se instaló correctamente.
 
 ## ---------------------------
 ## -- Tipos básicos
@@ -55,7 +55,7 @@ elem({1, 2, 3}, 0) #=> 1
 head #=> 1
 tail #=> [2,3]
 
-# En elixir, solo como Erlang, el `=` denota la coincidencia de patrones y
+# 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.
@@ -87,7 +87,7 @@ string.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` en elixir devuelve el valor ASCII para el caracter `a`
+# `?a` en Elixir devuelve el valor ASCII para el caracter `a`
 ?a #=> 97
 
 # Para concatenar listas se usa `++`, para binarios `<>`
@@ -120,7 +120,7 @@ genders.gillian #=> "female"
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# En elixir el operador `/` siempre devuelve un número flotante
+# 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
@@ -175,7 +175,7 @@ else
 end
 
 # Se acuerda de la coincidencia de patrones?
-# Muchas estructuras de control de flujo en elixir confían en ella.
+# Muchas estructuras de control de flujo en Elixir confían en ella.
 
 # `case` permite comparar un valor con muchos patrones:
 case {:one, :two} do
@@ -305,7 +305,7 @@ 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
+# 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)
@@ -380,7 +380,7 @@ end
 ## ---------------------------
 
 # 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,
+# 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`,
diff --git a/es-es/forth-es.html.markdown b/es-es/forth-es.html.markdown
index edc5d38c..61123151 100644
--- a/es-es/forth-es.html.markdown
+++ b/es-es/forth-es.html.markdown
@@ -13,7 +13,7 @@ Forth fue criado por Charles H. Moore en los 70s. Forth es un lenguaje imperativ
 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.
 
-```
+```forth
 \ Este es un comentario
 ( Este es un comentario también pero solo esta usado cuando definiendo palabras. )
 
diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 749365d1..c93584d8 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -410,10 +410,8 @@ $ 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)
+* [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/go-es.html.markdown b/es-es/go-es.html.markdown
index 78267695..17bf4a22 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -88,7 +88,7 @@ saltos de línea.` // mismo tipo cadena
 
 	// Literal no ASCII. Los ficheros fuente de Go son UTF-8.
 	g := 'Σ' // Tipo rune, un alias de int32, alberga un carácter unicode.
-	f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
+	f := 3.14159 // float64, el estándar IEEE-754 de coma flotante 64-bit.
 	c := 3 + 4i  // complex128, representado internamente por dos float64.
 	// Sintaxis var con iniciadores.
 	var u uint = 7 // Sin signo, pero la implementación depende del tamaño
@@ -425,7 +425,7 @@ func consultaAlServidor() {
 ## Más información
 
 La raíz de todas las cosas sobre Go es el
-[sitio web oficial de Go](http://golang.org/).
+[sitio web oficial de Go](https://go.dev/).
 Allí puedes seguir el tutorial, jugar interactivamente y leer mucho más.
 
 La definición del lenguaje es altamente recomendada.  Es fácil de leer y
@@ -433,17 +433,17 @@ sorprendentemente corta (como la definición del lenguaje Go en estos
 días).
 
 Puedes jugar con el código en el
-[parque de diversiones Go](https://play.golang.org/p/ncRC2Zevag).  ¡Trata
+[parque de diversiones Go](https://go.dev/play/p/ncRC2Zevag).  ¡Trata
 de cambiarlo y ejecutarlo desde tu navegador!  Ten en cuenta que puedes
-utilizar [https://play.golang.org]( https://play.golang.org) como un
+utilizar [https://go.dev/play/]( https://go.dev/play/) como un
 [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) para probar
 cosas y el código en el navegador, sin ni siquiera instalar Go.
 
 En la lista de lecturas para estudiantes de Go está el
-[código fuente de la biblioteca estándar](http://golang.org/src/pkg/). 
+[código fuente de la biblioteca estándar](https://go.dev/src/). 
 Ampliamente documentado, que demuestra lo mejor del legible y comprensible
 Go, con su característico estilo y modismos.  ¡O puedes hacer clic en un
-nombre de función en [la documentación](http://golang.org/pkg/) y
+nombre de función en [la documentación](https://go.dev/pkg/) y
 aparecerá el código fuente!
 
 Otro gran recurso para aprender Go está en
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index e4181609..355c7f29 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -28,7 +28,7 @@ En Julia los programas están organizados entorno al [despacho múltiple](http:/
 * [Buen desempeño](http://julialang.org/benchmarks), comparado al de lenguajes **estáticamente compilados** como C.
 * [Gestor de paquetes](http://docs.julialang.org/en/release-0.3/stdlib/pkg) integrado.
 * [Macros tipo Lisp](http://docs.julialang.org/en/release-0.3/manual/metaprogramming/#macros) y otras comodidades para la [meta programación](http://docs.julialang.org/en/release-0.3/manual/metaprogramming).
-* Llamar funciones de otros lenguajes, mediante paquetes como: **Python** ([PyCall](https://github.com/stevengj/PyCall.jl)), [Mathematica](http://github.com/one-more-minute/Mathematica.jl), **Java** ([JavaCall](http://github.com/aviks/JavaCall.jl)), **R** ([Rif](http://github.com/lgautier/Rif.jl) y [RCall](http://github.com/JuliaStats/RCall.jl)) y **Matlab** ([MATLAB](http://github.com/JuliaLang/MATLAB.jl)).
+* Llamar funciones de otros lenguajes, mediante paquetes como: **Python** ([PyCall](https://github.com/stevengj/PyCall.jl)), [Mathematica](http://github.com/one-more-minute/Mathematica.jl), **Java** ([JavaCall](http://github.com/aviks/JavaCall.jl)), **R** ([Rif](http://github.com/lgautier/Rif.jl) y [RCall](http://github.com/JuliaStats/RCall.jl)) y **MATLAB** ([MATLAB](http://github.com/JuliaLang/MATLAB.jl)).
 * [Llamar funciones de C y Fortran](http://docs.julialang.org/en/release-0.3/manual/calling-c-and-fortran-code) **directamente**: sin necesidad de usar envoltorios u APIs especiales.
 * Poderosas características de **línea de comandos** para [gestionar otros procesos](http://docs.julialang.org/en/release-0.3/manual/running-external-programs).
 * Diseñado para la [computación paralela y distribuida](http://docs.julialang.org/en/release-0.3/manual/parallel-computing) **desde el principio**.
diff --git a/es-es/matlab-es.html.markdown b/es-es/matlab-es.html.markdown
index faa3dead..9290e505 100644
--- a/es-es/matlab-es.html.markdown
+++ b/es-es/matlab-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Matlab
+language: MATLAB
 filename: learnmatlab-es.mat
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
@@ -139,7 +139,7 @@ A.d.e = false;
 
 % Vectores
 x = [4 32 53 7 1]
-x(2) % ans = 32, los índices en Matlab comienzan 1, no 0
+x(2) % ans = 32, los índices en MATLAB comienzan 1, no 0
 x(2:3) % ans = 32 53
 x(2:end) % ans = 32 53 7 1
 
@@ -506,7 +506,7 @@ find(x) % Encuentra todos los elementos distintos de cero de x y devuelve sus í
 
 
 % Clases
-% Matlab puede soportar programación orientada a objetos.
+% MATLAB puede soportar programación orientada a objetos.
 % Las clases deben colocarse en un archivo del nombre de la clase con la extensión .m. 
 % Para comenzar, creamos una clase simple para almacenar puntos de referencia de GPS.
 % Comience WaypointClass.m
@@ -528,7 +528,7 @@ classdef WaypointClass % El nombre de la clase.
     end
 
     % Si queremos agregar dos objetos Waypoint juntos sin llamar
-    % a una función especial, podemos sobrecargar la aritmética de Matlab así:
+    % a una función especial, podemos sobrecargar la aritmética de MATLAB así:
     function r = plus(o1,o2)
       r = WaypointClass([o1.latitude] +[o2.latitude], ...
                         [o1.longitude]+[o2.longitude]);
@@ -540,7 +540,7 @@ end
 % Podemos crear un objeto de la clase usando el constructor
 a = WaypointClass(45.0, 45.0)
 
-% Las propiedades de clase se comportan exactamente como estructuras de Matlab.
+% Las propiedades de clase se comportan exactamente como estructuras de MATLAB.
 a.latitude = 70.0
 a.longitude = 25.0
 
@@ -551,15 +551,15 @@ ans = multiplyLatBy(a,3)
 % no necesita ser pasado al método.
 ans = a.multiplyLatBy(a,1/3)
 
-% Las funciones de Matlab pueden sobrecargarse para manejar objetos.
-% En el método anterior, hemos sobrecargado cómo maneja Matlab
+% Las funciones de MATLAB pueden sobrecargarse para manejar objetos.
+% En el método anterior, hemos sobrecargado cómo maneja MATLAB
 % la adición de dos objetos Waypoint.
 b = WaypointClass(15.0, 32.0)
 c = a + b
 
 ```
 
-## Más sobre Matlab
+## Más sobre MATLAB
 
 * [The official website (EN)](http://www.mathworks.com/products/matlab/)
 * [The official MATLAB Answers forum (EN)](http://www.mathworks.com/matlabcentral/answers/)
diff --git a/es-es/powershell-es.html.markdown b/es-es/powershell-es.html.markdown
index 9eb35967..5b12b961 100644
--- a/es-es/powershell-es.html.markdown
+++ b/es-es/powershell-es.html.markdown
@@ -34,7 +34,7 @@ $PSVersionTable
 
 Para obtener ayuda:
 
-```
+```powershell
 # 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'
@@ -51,7 +51,7 @@ Update-Help # Actualiza la ayuda (debe ser ejecutado en una consola elevada como
 
 Acá inicia el tutorial:
 
-```
+```powershell
 # Como ya lo notó, los comentarios empiezan con #
 
 # Ejemplo de un simple hola mundo:
@@ -299,7 +299,7 @@ $Shortcut.Save()
 
 Configurando el shell
 
-```
+```powershell
 # $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)) {
diff --git a/es-es/pyqt-es.html.markdown b/es-es/pyqt-es.html.markdown
index 6d4fdde7..9a5eab8c 100644
--- a/es-es/pyqt-es.html.markdown
+++ b/es-es/pyqt-es.html.markdown
@@ -16,7 +16,7 @@ Esta es una adaptación de la introducción a QT con C++ por [Aleksey Kholovchuk
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
     # Crear el objeto de la aplicación
     app = QtGui.QApplication(sys.argv)
@@ -44,7 +44,7 @@ if __name__ == '__main__':
 Para poder hacer uso de las funciones más avanzades en **pyqt** necesitamos agregar elementos adicionales.
 Aquí mostramos cómo introducir una caja de diálogo popup, útil para permitir al usuario confirmar su decisión o para brindarnos información.
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -63,7 +63,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Esta función debería crear una ventana de diálogo con un botón
 # que espera a recibir un click y luego sale del programa
 def showdialog():
diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index 7deec286..0b21e479 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -328,7 +328,7 @@ dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
 nuestro_iterable = dicc_lleno.keys()
 print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
 
-Podemos recorrerla.
+# Podemos recorrerla.
 for i in nuestro_iterable:
     print(i)    # Imprime uno, dos, tres
 
@@ -388,8 +388,8 @@ keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"}
 
 # Puedes hacer ambas a la vez si quieres
 def todos_los_argumentos(*args, **kwargs):
-    print args
-    print kwargs
+    print(args)
+    print(kwargs)
 """
 todos_los_argumentos(1, 2, a=3, b=4) imprime:
     (1, 2)
@@ -462,10 +462,10 @@ class Humano(object):
 
 # Instancia una clase
 i = Humano(nombre="Ian")
-print i.decir("hi")     # imprime "Ian: hi"
+print(i.decir("hi"))     # imprime "Ian: hi"
 
 j = Humano("Joel")
-print j.decir("hello")  #imprime "Joel: hello"
+print(j.decir("hello"))  #imprime "Joel: hello"
 
 # Llama nuestro método de clase
 i.get_especie() #=> "H. sapiens"
@@ -548,7 +548,7 @@ def pedir(_decir):
 
 
 @pedir
-def say(decir_por_favor=False):
+def decir(decir_por_favor=False):
     mensaje = "¿Puedes comprarme una cerveza?"
     return mensaje, decir_por_favor
 
diff --git a/es-es/r-es.html.markdown b/es-es/r-es.html.markdown
index 2b710b27..850952fa 100644
--- a/es-es/r-es.html.markdown
+++ b/es-es/r-es.html.markdown
@@ -16,7 +16,7 @@ LaTeX.
 
 ```r
 
-# Los comentariso inician con símbolos numéricos.
+# Los comentarios inician con símbolos numéricos.
 
 # No puedes hacer comentarios de múltiples líneas
 # pero puedes agrupar múltiples comentarios de esta manera. 
diff --git a/es-es/raku-es.html.markdown b/es-es/raku-es.html.markdown
index e916d0fd..09341056 100644
--- a/es-es/raku-es.html.markdown
+++ b/es-es/raku-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-name: perl6
+name: Raku
 category: language
 language: Raku
 filename: learnraku-es.raku
diff --git a/es-es/ruby-es.html.markdown b/es-es/ruby-es.html.markdown
index 63a47e89..8b703df1 100644
--- a/es-es/ruby-es.html.markdown
+++ b/es-es/ruby-es.html.markdown
@@ -89,10 +89,10 @@ true || false #=> true
 # Estos son usados como constructores controladores de flujo que encadenan
 # sentencias hasta que una de ellas retorne verdadero o falso
 
-# `has_otra_cosa` solo se llama si `has_algo` retorna verdadero.
-has_algo() and has_otra_cosa()
-# `registra_error` solo se llama si `has_algo` falla
-has_algo() or registra_error()
+# `haz_otra_cosa` solo se llama si `haz_algo` retorna verdadero.
+haz_algo() and haz_otra_cosa()
+# `registra_error` solo se llama si `haz_algo` falla
+haz_algo() or registra_error()
 
 
 # Los strings son objetos
diff --git a/es-es/rust-es.html.markdown b/es-es/rust-es.html.markdown
index b43cb815..b0a3873c 100644
--- a/es-es/rust-es.html.markdown
+++ b/es-es/rust-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["P1start", "http://p1start.github.io/"]
 translators:
@@ -225,7 +225,7 @@ fn main() {
 
     // bucles `for`
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/es-es/self-es.html.markdown b/es-es/self-es.html.markdown
index 11972214..1f985215 100644
--- a/es-es/self-es.html.markdown
+++ b/es-es/self-es.html.markdown
@@ -116,6 +116,7 @@ Las expresiones múltiples son separadas por un punto. ^ retorna inmediatamente.
 ```
 
 Los bloques son ejecutados al enviales el mensaje 'value' y son inherentes (delegados a) sus contextos:
+
 ```
 "returns 0"
 [|x|
diff --git a/es-es/visualbasic-es.html.markdown b/es-es/visualbasic-es.html.markdown
index c677c20f..fb0b1d27 100644
--- a/es-es/visualbasic-es.html.markdown
+++ b/es-es/visualbasic-es.html.markdown
@@ -8,7 +8,7 @@ filename: learnvisualbasic-es.vb
 lang: es-es
 ---
 
-```
+```visualbasic
 Module Module1
 
     Sub Main()
diff --git a/es-es/wolfram-es.html.markdown b/es-es/wolfram-es.html.markdown
index 44ec9e09..6858c286 100644
--- a/es-es/wolfram-es.html.markdown
+++ b/es-es/wolfram-es.html.markdown
@@ -15,7 +15,7 @@ El lenguaje de Wolfram tiene varias interfaces:
 
 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.
 
-```
+```mathematica
 (* Esto es un comentario *)
 
 (* En Mathematica en lugar de utilizar estos comentarios, puede crear una celda de texto
diff --git a/fa-ir/css-fa.html.markdown b/fa-ir/css-fa.html.markdown
index 4e222eb2..93af9132 100644
--- a/fa-ir/css-fa.html.markdown
+++ b/fa-ir/css-fa.html.markdown
@@ -29,21 +29,21 @@ filename: learncss-fa.css
 
 <p dir='rtl'>در CSS همه توضیحات داخل ستاره-بروم نوشته میشوند زیرا CSS دستوری برای توضیحات تک خطی مثل C ندارد</p>
 
-```CSS
+```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
+```css
 selector { property: value; /* more properties...*/ }
 ```
 
 <p dir='rtl'>با است�اده از ستاره می توان برای همه عناصر روی ص�حه استایل تعری� کرد</p>
 
 
-```CSS
+```css
 * { color:red; }
 ```
 
@@ -55,129 +55,129 @@ selector { property: value; /* more properties...*/ }
 <p dir='rtl'>شما میتوانید با است�اده از نام کلاس آنرا انتخاب کنید</p>
 
 
-```CSS
+```css
 .some-class { }
 ```
 
 <p dir='rtl'>یا با است�اده از نام دو کلاس</p>
 
-```CSS
+```css
 .some-class.class2 { }
 ```
 
 <p dir='rtl'>یا با است�اده از نام id</p>
 
-```CSS
+```css
 #someId { }
 ```
 
 <p dir='rtl'>یا با است�اده از نام خود عنصر</p>
 
-```CSS
+```css
 div { }
 ```
 
 <p dir='rtl'>یا با است�اده از `attr`</p>
 
-```CSS
+```css
 [attr] { font-size:smaller; }
 ```
 
 <p dir='rtl'>یا با است�اده از ارزشی که برای `attr` مشخص شده</p>
 
-```CSS
+```css
 [attr='value'] { font-size:smaller; }
 ```
 
 <p dir='rtl'>با است�اده از ارزشی که برای `attr` مشخص شده و آن ارزش با `val` شروع میشود در CSS3</p>
 
-```CSS
+```css
 [attr^='val'] { font-size:smaller; }
 ```
 
 <p dir='rtl'>با است�اده از ارزشی که برای `attr` مشخص شده و آن ارزش با `ue` به پایان میرسد در CSS3</p>
 
-```CSS
+```css
 [attr$='ue'] { font-size:smaller; }
 ```
 
 <p dir='rtl'>یا با انتخاب بوسیله یکی از ارزشهایی که در لیست `otherAttr` بوسیله �اصله از هم جدا شده اند در CSS3</p>
 
-```CSS
+```css
 [attr$='ue'] { font-size:smaller; }
 ```
 
 <p dir='rtl'>یا ارزش(`value`) دقیقاً خود ارزش(`value`) یا بوسیله `-` که یونیکد (U+002D) از حر� بعدی جدا شود</p>
 
-```CSS
+```css
 [otherAttr|='en'] { font-size:smaller; }
 ```
 
 <p dir='rtl'>و مهمتر از همه اینکه میتوان آنها را ترکیب کرد. نکته مهمی که در اینجا باید مد نظر داشته باشید این است که هنگام ترکیب نباید هیچگونه �اصله ای بین آنها قرار گیرد زیرا در این حالت معنای دستور تغییر میکند</p>
 
-```CSS
+```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
+```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
+```css
 div.some-parent .class-name {}
 ```
 
 <p dir='rtl'>نکته ای که در اینجا باید به آن توجه کنید این است که این رستور با �اصله ای بین نام دو کلاس همراه است و با مثال زیر که در بالا هم ذکر شد ت�اوت دارد.</p>
 
-```CSS
+```css
 div.some-parent.class-name {}
 ```
 
 <p dir='rtl'>دستور زیر همه عناصری را که نام کلاس آنها <span dir="ltr">`.this-element`</span> و بلا�اصله بعد از عنصری با مشخصه <span dir="ltr">`.i-am-before`</span> قرار دارد را انتخاب میکند.</p>
 
-```CSS
+```css
 .i-am-before + .this-element { }
 ```
 
 <p dir='rtl'>هر خواهر یا برادری که بعد از <span dir="ltr">`.i-am-before`</span> بیاید در اینجا لازم نیست بلا�اصله بعد از هم قرار بگیرند ولی باید دارای پدر و مادری یکسان باشند.</p>
 
-```CSS
+```css
 .i-am-any-before ~ .this-element {}
 ```
 <p dir='rtl'>در زیر چند نمونه از شبه کلاسها را معر�ی میکنیم که به شما اجازه میدهد عناصر را بر اساس ر�تار آنها در ص�حه انتخاب کنید.</p>
 <p dir='rtl'>برای مثال زمانی که اشاره گر ماوس روی عنصری بر روی ص�حه قرار دارد.</p>
 
-```CSS
+```css
 selector:hover {}
 ```
 
 <p dir='rtl'>یا زمانی از یک لینک بازید کردید.</p>
 
-```CSS
+```css
 selected:visited {}
 ```
 
 <p dir='rtl'>یا زمانی از لینکی بازید نشده است.</p>
 
-```CSS
+```css
 selected:link {}
 ```
 
 <p dir='rtl'>یا زمانی که روی یک عنصر ورودی متمرکز شده.</p>
 
-```CSS
+```css
 selected:focus {}
 ```
 
 <h3 dir='rtl'>واحدها</h3>
 
-```CSS
+```css
 selector {
 
     /* واحدها اندازه */
@@ -247,7 +247,7 @@ selector {
 
 <p dir='rtl'>به مثال زیر توجه کنید:</p>
 
-```CSS
+```css
 /*A*/
 p.class1[attr='value']
 
diff --git a/fa-ir/vim-fa.html.markdown b/fa-ir/vim-fa.html.markdown
new file mode 100644
index 00000000..f1864619
--- /dev/null
+++ b/fa-ir/vim-fa.html.markdown
@@ -0,0 +1,469 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+    - ["Moein Halvaei", "https://github.com/mo1ein"]
+lang: fa-ir
+filename: LearnVim-fa.txt
+---
+
+<p dir="rtl">
+[Vim](http://www.vim.org) (Vi رشدیا�ته) یک کلون از ادیتور مشهور vi است برای unix. ادیتورمتنی‌ست که برای سرعت و ا�زایش بهره‌وری طراحی شده‌ و در همه جا به ویژه در سیستم های unix-based دیده می‌شود. شورتکات کلید های بی‌شماری برای سرعت جهت‌یابی به نقاط ویژه‌ي �ایل ها و تغییر سریع، دارد.
+<br />
+`vimtutor` یک برنامه‌ي عالیست که به شما چگونگی است�اده از `vim` را آموزش می‌دهد.
+این به همراه پکیج های vim هنگام نصب کردن، نصب می‌شود. شما باید بتوانید با ران کردن `vimtutor` در کامندلاین از آموزش ها است�اده کنید. این همه‌ی ویژگی های عمده‌ی `vim` را به شما راهنمایی می‌کند.
+</p>
+<h3>
+	<p dir="rtl">
+مکان‌یابی اولیه vim
+	</p>
+</h3>
+
+
+<p dir="rtl">
+باز کردن `<filename>` در ویم
+</p>
+
+```
+vim <filename>   # Open <filename> in vim
+```
+<p dir="rtl">
+باز کردن help docs های `<topic>` اگر وجود داشته باشد
+</p>
+
+```
+:help <topic>    # Open up built-in help docs about <topic> if any exists 
+```
+```
+:q               # خروج از ویم
+
+:w               # ذخیره کردن �ایل �علی
+
+:wq              # ذخیره کردن و خارج شدن از ویم
+
+ZZ               # ذخیره کردن و خارج شدن از ویم
+
+:q!              # خارج شدن بدون ذخیره کردن �ایل
+
+! *forces* :q to execute, hence quiting vim without saving
+
+ZQ               # خارج شدن بدون ذخیره کردن �ایل
+```
+
+<p dir="rtl">ذخیره کردن و خارج شدن از vim ورژن خلاصه شده‌ی wq:</p>
+
+```
+:x               # Save file and quit vim, shorter version of :wq
+```
+
+<p dir="rtl">برگشت به عقب</p>
+
+```
+ u                # Undo
+```
+
+<p dir="rtl">ر�تن به جلو</p>
+
+```
+CTRL+R           # Redo
+```
+
+<p dir="rtl">راه ر�تن در ص�حه</p>
+
+```
+h                # ر�تن یک کاراکتر به چپ
+
+j                # ر�تن یک کاراکتر به پایین
+
+k                # ر�تن یک کاراکتر به بالا
+
+l                # ر�تن یک کاراکتر به راست
+
+Ctrl+B           # جابه‌جا شدن به عقب به اندازه یک ص�حه
+
+Ctrl+F           # جابه‌جا شدن به جلو به اندازه یک ص�حه
+
+Ctrl+D           # جابه‌جا شدن به جلو به اندازه نص� ص�حه
+
+Ctrl+U           # جابه‌جا شدن به عقب به اندازه نص� ص�حه
+```
+
+<p dir="rtl"><strong>جابه‌جا شدن در خط</strong></p>
+
+```
+0                # ر�تن به اول خط
+$                # ر�تن به آخر خط
+^                # ر�تن به اولین کاراکتر غیرخالی در خط
+```
+
+<p dir="rtl"><strong>جست و جو در متن</strong></p>
+
+```
+/word            # هایلایت کردن همه‌ی کلمه های بعد ک�رسر
+
+?word            # هایلایت کردن همه‌ی کلمه های قبل ک�رسر
+
+n                # جابه‌جایی ک�رسر به کلمه های بعدی پیدا شده
+
+N                # جابه‌جایی ک�رسر به کلمه های قبلی پیدا شده
+```
+
+<p dir="rtl">عوض کردن 'foo' به 'bar' در هر خط از �ایل</p>
+
+```
+:%s/foo/bar/g    # Change 'foo' to 'bar' on every line in the file
+```
+
+<p dir="rtl">عوض کردن 'foo' به 'bar' در خط �علی</p>
+
+```
+:s/foo/bar/g     # Change 'foo' to 'bar' on the current line
+```
+
+<p dir="rtl">جایگزینی کاراکتر های خط جدید با کاراکتر های خط جدید</p>
+
+```
+:%s/\n/\r/g      # Replace new line characters with new line characters
+```
+
+<p dir="rtl"><strong>پرش به کاراکتر ها</strong></p>
+<p dir="rtl">پرش به جلو و قرار گر�تن روی کاراکتر مورد نظر</p>
+
+```
+f<character>     # Jump forward and land on <character>
+```
+
+<p dir="rtl">پرش به جلو و قرار گر�تن قبل کاراکتر مورد نظر</p>
+
+```
+t<character>     # Jump forward and land right before <character>
+```
+
+<p dir="rtl"><strong>برای مثال:</strong></p>
+
+<p dir="rtl">پرش به جلو و قرار گر�تن روی ></p>
+
+```
+f<               # Jump forward and land on <
+```
+
+<p dir="rtl">پرش به جلو و قرار گر�تن قبل از ></p>
+
+```
+t<               # Jump forward and land right before <
+```
+<p dir="rtl"><strong>جابه‌جا شدن با کلمه ها</strong></p>
+
+```
+w                # ر�تن به جلو به اندازه‌ی یک کلمه
+b                # ر�تن به عقب به اندازه‌ی یک کلم
+e                # ر�تن به آخر کلمه‌ی �علی
+```
+<p dir="rtl"><strong>سایر کاراکتر ها برای جابه‌جایی</strong></p>
+<p dir="rtl">ر�تن به اول �ایل</p>
+
+```
+gg               # Go to the top of the file
+```
+<p dir="rtl">ر�تن به آخر �ایل</p>
+
+```
+G                # Go to the bottom of the file
+```
+<p dir="rtl">ر�تن به شماره‌ی خط مورد نظر (NUM شماره است)</p>
+
+```
+:NUM             # Go to line number NUM (NUM is any number)
+```
+<p dir="rtl">ر�تن به اول ص�حه</p>
+
+```
+H                # Move to the top of the screen
+```
+<p dir="rtl">ر�تن به وسط ص�حه</p>
+
+```
+M                # Move to the middle of the screen
+```
+<p dir="rtl">ر�تن به آخر ص�حه</p>
+
+```
+L                # Move to the bottom of the screen
+```
+
+<h3>
+<p dir="rtl"><strong>
+داک های help
+</strong></p>
+</h3>
+
+<p dir="rtl">
+Vim دارای یک help doc داخلی است که می‌توان با help: <topic> به آن دسترسی داشت. برای مثال help navigation: داک مربوط به مکان‌یابی در �ضای کار را به شما نشان می‌دهد! <br /><br />
+help: همچنین می‌تواند بدون option مورد است�اده قرار گیرد.
+این یه صورت یک help پیش‌�رض بالا می‌آید که شروع vim را قابل دسترس تر می‌کند!
+</p>
+
+<h3>
+	<p dir="rtl"><strong>Modes:</strong></p>
+</h3>
+
+<div dir="rtl">
+Vim بر پایه‌ی م�هومی‌ست به نام <strong>modes</strong>
+<br /><br />
+<ul>
+    <li>
+    Command Mode - ویم در این حالت بالا می‌آید،‌ برای مکان‌یابی و نوشتن دستورات است�اده می‌شود
+</li>
+<li>
+    Insert Mode - برای ایجاد تغییر در �ایل شما است�اده می‌شود
+</li>
+<li>
+    Visual Mode - برای هایلایت کردن متن و انجام عملی روی آن ها است�اده می‌شود
+</li>
+<li>
+    Ex Mode - برای وارد کردن دستورات توسط ":" در قسمت پایین است�اده می‌شود
+</li>
+</ul>
+<br />
+</div>
+
+<p dir="rtl">ر�تن به حالت insert, پیش از جایگاه cursor</p>
+
+```
+i                # Puts vim into insert mode, before the cursor position
+```
+<p dir="rtl">ر�تن به حالت insert, پس از جایگاه cursor</p>
+
+```   
+a                # Puts vim into insert mode, after the cursor position
+```
+
+<p dir="rtl">ر�تن به حالت visual</p>
+
+```   
+v                # Puts vim into visual mode
+```
+<p dir="rtl">ر�تن به حالت ex</p>
+
+```
+:                # Puts vim into ex mode
+```
+<p dir="rtl">خروج از همه‌ی حالت ها و ر�تن به حالت command</p>
+
+```    
+<esc>            # 'Escapes' from whichever mode you're in, into Command mode
+```
+<p dir="rtl">کپی و پیست در متن</p>
+
+```
+y                # کپی کردن متن انتخاب شده
+
+yy               # کپی کردن خط �علی
+
+d                # حذ� کردن متن انتخاب شده
+
+dd               # حذ� کردن خط �علی
+
+p                # پیست کردن متن کپی شده پس از جایگاه �علی ک�رسر
+
+P                # پیست کردن متن کپی شده پیش از جایگاه �علی ک�رسر
+
+x                # حذ� کردن یک کاراکتر از جایگاه ک�رسر
+```
+
+<h3>
+<p dir="rtl"><strong>گرامر (Grammer) </strong></p>
+</h3>
+
+<div dir="rtl">
+Vim را می توان به عنوان مجموعه ای از دستورات در قالب (Verb - Modifier - Noun) تصور کرد ، جایی که:
+<br /><br />
+<ul>
+<li>
+    Verb - عمل شما
+</li>
+<li>
+    Modifier - چگونگی انجام عمل شما
+</li>
+<li>
+    Noun - شیئی که عمل شما بر اساس آن عمل می کند
+</li>
+</ul>
+اندکی از مثال های مهم Verbs ,Modifiers, Nouns:
+<br /><br />
+</div>
+
+<p dir="rtl"><strong>�عل ها (Verbs)</strong></p>
+
+```
+d                # حذ�
+c                # تغییر
+y                # کپی
+v                # انتخاب 
+```
+<p dir="rtl"><strong>تغییردهنده ها (Modifiers)</strong></p>
+
+```
+i                # داخل
+a                # اطرا�
+NUM              # شماره (NUM هر شماره‌ای است)
+f                # جست و جو کردن چیزی و متوق� شدن روی آن
+t                # جست و جو کردن چیزی و متوق� شدن قبل از آن
+/                # جست و جو کردن رشته‌ای پس از ک�رسر
+?                # جست و جو کردن رشته‌ای پیش از ک�رسر
+```
+<p dir="rtl"><strong>اسم ها (Nouns)</strong></p>
+
+```
+w                # کلمه
+s                # جمله
+p                # پاراگرا�
+b                # بلوک
+```
+<p dir="rtl"><strong>جمله ها و کامند های نمونه</strong></p>
+
+```
+d2w              # حذ� دو کلمه
+cis              # تغییر داخل جمله
+yip              # کپی داخل پاراگرا� (از پاراگرا�ی که داخل آن هستید کپی کنید)
+ct<              # متن را از جایی که قرار دارید به براکت باز بعدی تغییر دهید
+d$               # حذ� تا پایان
+```
+
+<h3>
+	<p dir="rtl">بعضی از شورتکات ها و تر�ند ها</p>
+</h3>
+
+```
+<!--TODO: Add more!-->
+
+>                # ایجاد دندانه به اندازه یک بلوک
+
+<                # حذ� دندانه به اندازه یک بلوک
+
+:earlier 15m     # برگرداندن همه چیز به ۱۵ دقیقه قبل
+    
+:later 15m       # برعکس کامند قبلی
+    
+ddp              # تغییر مکان خطوط متوالی(dd, then p)
+    
+.                # تکرار دستور قبلی
+    
+:w !sudo tee %   # ذخیره کردن �ایل �علی به عنوان روت
+    
+:set syntax=c    # تنظیم سینتکس هایلایتینگ روی 'c'
+    
+:sort            # مرتب کردن همه‌ی خطوط
+    
+:sort!           # مرتب کردن همه‌ی خطوط به صورت برعکس
+
+:sort u          # مرتب کردن همه‌ی خطوط و پاک کردن تکراری ها
+
+~                # تبدیل متن انتخاب شده به حرو� (اگر بزرگ است، کوچک و اگر کوچک است، بزرگ)
+
+u                # تبدیل متن انتخاب شده به حرو� کوچک
+
+U                # تبدیل متن انتخاب شده به حرو� بزرگ
+
+J                # اتصال خط �علی به خط بعدی
+```
+<h4>
+<p dir="rtl">
+�ولد (Fold)
+</p>
+</h4>
+
+```
+zf               # ایجاد �ولد برای متن انتخاب شده
+zo               # باز کردن �ولد �علی
+zc               # بستن �ولد �علی
+zR               # باز کردن همه‌ی �ولد ها
+zM               # بستن همه‌ی �ولد ها 
+```
+
+<h3>
+<p dir="rtl">
+ماکرو ها (Macros)
+</p>
+</h3>
+
+<p dir="rtl">
+ماکرو ها اساسا عمل های قابل ضبط هستند. زمانی که شما شروع می‌کنید به ضبط ماکرو، هر عمل و دستوری را که است�اده می‌کنید، تا زمانی که ضبط را متوق� کنید، ضبط می‌شود. با �راخوانی ماکرو، دقیقاً همان توالی اعمال و دستورات، دوباره روی متن انتخاب شده اعمال می‌شود. 
+</p>
+
+```
+qa               # Start recording a macro named 'a'
+q                # Stop recording
+@a               # Play back the macro
+```
+<h3>
+<p dir="rtl">
+کان�یگ vimrc./~
+<p>
+</h3>
+
+<p dir="rtl">
+vimrc. �ایلی‌ست که است�اده می‌شود برای کان�یگ vim هنگام بالا آمدن
+<br />
+این‌جا یک نمونه‌ �ایل vimrc. آورده شده:
+</p>
+
+```
+" 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
+```
+
+<h3>
+<p dir="rtl">ر�رنس ها</p>
+</h3>
+
+[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? (St
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)    
diff --git a/fi-fi/go-fi.html.markdown b/fi-fi/go-fi.html.markdown
index af304099..ef88a96e 100644
--- a/fi-fi/go-fi.html.markdown
+++ b/fi-fi/go-fi.html.markdown
@@ -33,7 +33,7 @@ Go tuo mukanaan loistavan oletuskirjaston sekä innokkaan yhteisön.
  rivin kommentti */
 
 // Package -lausekkeella aloitetaan jokainen lähdekooditiedosto.
-// Main on erityinen nimi joka ilmoittaa
+// main on erityinen nimi joka ilmoittaa
 // suoritettavan tiedoston kirjaston sijasta.
 package main
 
@@ -90,7 +90,7 @@ voi sisältää rivinvaihtoja.` // Sama merkkijonotyyppi.
     // Ei-ASCII todellisarvo. Go-lähdekoodi on UTF-8.
 	g := 'Σ' // riimutyyppi, lempinimi int32:lle, sisältää unicode-koodipisteen.
 
-	f := 3.14195 //float64, IEEE-754 64-bittinen liukuluku.
+	f := 3.14159 //float64, IEEE-754 64-bittinen liukuluku.
 	c := 3 + 4i  // complex128, sisäisesti ilmaistu kahdella float64:lla.
 
 	// var -syntaksi alkuarvoilla.
@@ -418,21 +418,21 @@ func requestServer() {
 
 ## Lisää luettavaa
 
-Go-tietämyksen alku ja juuri on sen [virallinen verkkosivu]()(http://golang.org/).
+Go-tietämyksen alku ja juuri on sen [virallinen verkkosivu]()(https://go.dev/).
 Siellä voit seurata oppitunteja, askarrella vuorovaikutteisesti sekä lukea paljon.
-Kierroksen lisäksi [dokumentaatio](https://golang.org/doc/) pitää sisällään tietoa
+Kierroksen lisäksi [dokumentaatio](https://go.dev/doc/) pitää sisällään tietoa
 siistin Go-koodin kirjoittamisesta, pakettien ja komentojen käytöstä sekä julkaisuhistoriasta.
 
 Kielen määritelmä itsessään on suuresti suositeltavissa. Se on helppolukuinen ja
 yllättävän lyhyt (niissä määrin kuin kielimääritelmät nykypäivänä ovat.)
 
-Voit askarrella parissa kanssa [Go playgroundissa](https://play.golang.org/p/tnWMjr16Mm).
-Muuttele sitä ja aja se selaimestasi! Huomaa, että voit käyttää [https://play.golang.org](https://play.golang.org)
+Voit askarrella parissa kanssa [Go playgroundissa](https://go.dev/play/p/tnWMjr16Mm).
+Muuttele sitä ja aja se selaimestasi! Huomaa, että voit käyttää [https://go.dev/play/](https://go.dev/play/)
 [REPL:na](https://en.wikipedia.org/wiki/Read-eval-print_loop) testataksesi ja koodataksesi selaimessasi, ilman Go:n asentamista.
 
-Go:n opiskelijoiden lukulistalla on [oletuskirjaston lähdekoodi](http://golang.org/src/pkg/).
+Go:n opiskelijoiden lukulistalla on [oletuskirjaston lähdekoodi](https://go.dev/src/).
 Kattavasti dokumentoituna se antaa parhaan kuvan helppolukuisesta ja ymmärrettävästä Go-koodista,
--tyylistä ja -tavoista. Voit klikata funktion nimeä [doukumentaatiossa](http://golang.org/pkg/) ja
+-tyylistä ja -tavoista. Voit klikata funktion nimeä [doukumentaatiossa](https://go.dev/pkg/) ja
 lähdekoodi tulee esille!
 
 Toinen loistava paikka oppia on [Go by example](https://gobyexample.com/).
diff --git a/fi-fi/ruby-fi.html.markdown b/fi-fi/ruby-fi.html.markdown
index 52c60182..84a5844f 100644
--- a/fi-fi/ruby-fi.html.markdown
+++ b/fi-fi/ruby-fi.html.markdown
@@ -605,4 +605,4 @@ Something.new.qux # => 'qux'
 - [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
+- [Try Ruby](https://try.ruby-lang.org/) - Rubyn perusteet interaktiivisesti
diff --git a/fish.html.markdown b/fish.html.markdown
new file mode 100644
index 00000000..4b70f883
--- /dev/null
+++ b/fish.html.markdown
@@ -0,0 +1,342 @@
+---
+category: tool
+tool: fish
+contributors:
+    - ["MySurmise", "https://github.com/MySurmise"]
+    - ["Geo Maciolek", "https://github.com/GeoffMaciolek"]
+filename: learn.fish
+---
+
+Fish (**f**riendly **i**nteractive **sh**ell) is the name of an exotic shell. That is a shell with a syntax that is derived from neither the Bourne-Shell nor the C-Shell. 
+
+The advantage of fish is that many features that you want in a modern shell come out-of-the-box, so you don't have to install additional software like zsh and oh-my-zsh.
+
+Examples of these features are autosuggestions, 24-bit colors, Man Page Completions (meaning fish automatically parses your man pages and suggests additional options for your commands) or the ability to make options through a web page (when a GUI is installed).
+
+It was released in February 2005.
+
+- [Read more](https://fishshell.com/docs/current/language.html)
+- [Installation guide](https://github.com/fish-shell/fish-shell#getting-fish)
+
+
+## Guide
+
+Be sure you have the newest fish shell. This was made with version 3.3.0. To test, type:
+
+```
+> fish -v
+```
+
+To start the fish shell, type:
+
+```
+> fish
+```
+
+to exit, type:
+
+```
+> exit
+```
+
+or press <kbd>Ctrl + D</kbd>
+
+Now, right out of the gate, there's one annoying thing in fish. It's the welcome message. Who needs that, right? When your shell is started, just type:
+
+```
+> set -U fish_greeting ""
+```
+
+If you want to execute a single command written in bash, without switching to that shell, you can type:
+
+```
+> bash -c 'echo "fish is better than bash"'
+```
+
+In fish, you can use single or double quotes.
+The escape character is a `\`
+
+You can change your configuration of fish either by editing the config file
+
+```
+> vim ~/.config/fish/config.fish
+```
+
+or by opening the aforementioned web settings:
+
+```
+> fish_config
+```
+
+Adding something to your fish PATH Variable is easy:
+
+```
+> fish_path_add ~/cowsay
+```
+
+Can you do that with bash, huh? No, you always have to look it up... It's just that easy!
+
+But there's more. Most fish-specific commands start, you guessed it, with 'fish'. Just type in `fish` and press <kbd>TAB</kbd>. And there you have one of the many cool features of fish: The autocompletion that **just works.**
+Now you can navigate with <kbd>TAB</kbd>, <kbd>Shift + TAB</kbd> and your Arrow-Keys <kbd>�</kbd><kbd>↑</kbd><kbd>→</kbd><kbd>↓</kbd>.
+
+To get help, contact your local psychiatrist or type `man`. That will bring up the manual for that command, for example:
+
+```
+> man set
+```
+
+If you finally tried fish, you can see something other in fish that's really cool. Everything has cool colors, if you type in something wrong, it is red, without even executing, if you put something in quotes, you see where it ends and why that quote doesn't work, because there's another qoutation mark in the quote at position 26. 
+
+fish has even more cool things, like wildcards.
+For example, type
+
+```
+> ls *.fish
+```
+
+That will list all fish files in your current directory.
+
+You can have multiple wildcards per command or even a recursive wildcard, `**`, which basically means it includes files and directories, that fit.
+For example the following command would return (in your case):
+
+```
+> ls ~/images/**.jpg
+
+~/images/nudes/pewdiepie.jpg
+~/images/nudes/peppa.jpg
+~/images/screenshots/2020-42-69.jpg
+~/images/omegalul.jpg
+```
+
+Of course, you can also pipe the output of a command to another command
+
+```
+>echo sick egg, nadia. no u do really goofy shit.   | grep [udense]
+```
+
+write to a file:
+
+```
+>echo This\ is\ text > file.txt
+```
+
+(noticed the escape character?)
+Add to a file:
+
+```
+>echo This\ is\ a\ line >> file.txt
+>echo This\ is\ a\ second\ line >> file.txt
+```
+
+For Autocompletion, just always press <kbd>TAB</kbd>. You will be surprised how many things fish knows.
+
+To use variables, just type `$VAR`, like in bash.
+
+```
+> echo "My home is $HOME"
+My home is /home/myuser
+```
+
+Here comes a difference between single and double quotes. If you use a variable in single quotes, it will not substitute it.
+
+```
+> echo 'My home is $HOME'
+My home is $HOME
+```
+
+More on variables later.
+
+To execute two commands, separate them with `;`
+
+```
+> echo Lol; echo this is fun
+```
+
+The status code of the last command is stored in `$status`
+
+You can use && for two commands that depend on each other.
+
+```
+> set var lol && echo $var
+```
+
+You can also use `and`  which executes if the previous command was successful, 
+`or` which executes if the previous command was not successful, and `not`
+which inverts the exit status of a command.
+
+For example:
+
+```
+> if not echo It's very late I should not waste my time with this  
+      echo Nobody heard you  
+  end
+```
+
+(You can of course do all of that in the shell)
+
+---
+Now let's start with the scripting part of fish.
+
+As with every shell, you can not only execute commands in the shell, but also as files, saved as a  `.fish` file.
+(You can also execute `.sh` files with fish syntax, but I always use `.fish` for fish-syntax scripts to distinguish them from bash script files)
+
+```fish
+# This is a comment in fish.
+# 
+# If you execute a file without specifying an interpreter, 
+# meaning the software that runs your script, you need to tell the shell, 
+# where that interpreter is. 
+# For fish you just add the following comment as the first line in your script:
+
+#!/bin/fish
+
+# When executing via e.g. fish /path/to/script.fish
+# you don't need that, because you specified fish as an interpreter
+
+# Let's start with variables.
+# for use inside a program, you can use the syntax
+set name = 'My Variable'
+
+# Use...
+set -x name value
+# to eXport, or
+set -e name
+# to Erase
+
+# a variable set with a space doesn't get sent as two arguments, but as one, as you would expect it. 
+set turtlefolder 'Turtle Folder'
+mkdir $turtlefolder
+
+# This will create one folder, as expected, not two, like in bash... 
+# Who would even want that? tHiS iS a fEaTurE, nOt a bUg...
+
+# you can even have lists as variables. This actually makes sense, because if you want to have a variable that would create two folders, you just give mkdir a list of your foldernames.
+
+# you can then count the entries in that list with:
+count $PATH
+
+# Not only is everything awesome, but in fish, everything is also a list. 
+# So $PWD for example is a list of length 1. 
+# To make a list, just give the set command multiple arguments:
+set list entry1 entry2 entry3
+
+# that way you can also append something to an existing variable:
+set PATH $PATH ~/cowsay/
+
+# But, as previously mentioned, we also have a simpler way to do that specifically in fish.
+# As with every Array/List, you can access it with 
+$listvar[2]
+
+# there's also ranges with 
+$listvar[1..5]
+
+# and you can use negative numbers like 
+$listvar[-1]
+# e.g to access the last element.
+
+# You can also do fancy cartesian products when you combine two list variables:
+set a 1 2 3
+set 1 a b c
+echo $a$1
+# Will output : 1a 2a 3a 1b 2b 3b 1c 2c 3c
+
+# Of course, if you separate them, it will see them as two separate arguments and echo them one after the other. THAT is expected behavior @bash.
+
+# There are also other useful things, like command substitutions. For example, when you want to output the returns of two commands in one line. In bash you would do that with
+echo "`ls` is in $PWD" 
+# or 
+echo "$(ls) is in $PWD" 
+
+# if you ask me, that's unnecessary. I always type in the wrong apostrophe. Why not just use two parenthesis, like in fish?
+echo (ls) is in $PWD
+
+# Yep, that easy. And thanks to fish's highlighting you can instantly see, if you typed it in correctly.
+
+# And, as you would expect, if you ask me, your commands don't work in quotes. I mean why bash? Ok I'll stop now. But in fish, just do:
+echo (ls)" is in $PWD"
+# or
+set myvar "The file"(ls -a)" is in the directory $PWD"
+# will make a List with the string and all files. Try it out. Isn't that cool?
+
+# And to separate these variables in separate arguments, just put a space between them:
+
+set myvar "The files" (ls -a) " are in the directory $PWD"
+
+# There's also if, else if, else
+if grep fish /etc/shells
+    echo Found fish
+else if grep bash /etc/shells
+    echo Found bash
+else
+    echo Got nothing
+end
+
+# A little weird is that you compare stuff with one = sign, of course because we don't need it to set variables, but still... and the keyword "test":
+if test $var = "test"
+    echo yes 
+else 
+    echo no
+end
+
+# Of course, there's also switch case with
+switch $OS
+case Linux
+    echo "you're good"
+case Windows
+    echo "install Gentoo"
+case Arch
+    echo "I use arch btw"
+case '*'
+    echo "what OS is $OS, please?"
+end
+
+
+# functions in fish get their arguments through the $argv variable. The syntax is following:
+
+function print
+    echo $argv
+end
+
+# There are also events, like the "fish_exit"-event (What may that be, hmm?).
+
+# You can use them by adding them to the function definition:
+
+function on_exit --on-event fish_exit
+    echo fish is now exiting
+end
+
+# find events with the command
+functions --handlers
+
+
+# You can use the functions command to learn more about, well, functions. 
+# For example you can print the source code of every function:
+functions cd
+functions print
+# or get the names of all functions:
+functions
+
+# There's while Loops, of course
+while test $var = lol
+    echo lol
+end
+
+# for Loops (with wildcards, they are even cooler):
+for image in *.jpg
+    echo $image
+end
+
+# there's an equivalent to the range(0, 5) in Python, so you can also do the standard for loops with numbers:
+
+set files (ls)
+for number in (seq 10)
+    echo "$files[$number] is file number $number"
+end
+
+# Cool!
+
+# The bashrc equivalent is not fishrc, but the previously mentioned config.fish file in ~/.config/fish/
+# To add a function to fish, though, you should create a simple .fish file in that directory. Don't just paste that function in the config.fish. That's ugly. 
+# If you have more, just add it, but those are the most important basics.
+
+```
diff --git a/forth.html.markdown b/forth.html.markdown
index ff094017..4e2f7599 100644
--- a/forth.html.markdown
+++ b/forth.html.markdown
@@ -93,8 +93,8 @@ see square     \ : square dup * ; ok
 
 \ ------------------------------------ Loops -----------------------------------
 
-\ `do` is also a compile-only word.
-: myloop ( -- ) 5 0 do cr ." Hello!" loop ; \ ok
+\ `?do` is also a compile-only word.
+: myloop ( -- ) 5 0 ?do cr ." Hello!" loop ; \ ok
 myloop
 \ Hello!
 \ Hello!
@@ -102,16 +102,17 @@ myloop
 \ Hello!
 \ Hello! ok
 
-\ `do` expects two numbers on the stack: the end number and the start number.
+\ `?do` expects two numbers on the stack: the end number (exclusive) and the
+\ start number (inclusive).
 
 \ We can get the value of the index as we loop with `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
+one-to-12                                 \ 0 1 2 3 4 5 6 7 8 9 10 11 ok
 
-\ `?do` works similarly, except it will skip the loop if the end and start
-\ numbers are equal.
-: squares ( n -- ) 0 ?do i square . loop ;   \ ok
-10 squares                                   \ 0 1 4 9 16 25 36 49 64 81 ok
+\ `do` works similarly, except if start and end are exactly the same it will
+\ loop forever (until arithmetic underflow).
+: loop-forever 1 1 do i square . loop ;     \ ok
+loop-forever                                \ 1 4 9 16 25 36 49 64 81 100 ...
 
 \ Change the "step" with `+loop`:
 : threes ( n n -- ) ?do i . 3 +loop ;    \ ok
diff --git a/fortran.html.markdown b/fortran.html.markdown
new file mode 100644
index 00000000..316f8c87
--- /dev/null
+++ b/fortran.html.markdown
@@ -0,0 +1,457 @@
+---
+language: Fortran
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+filename: learnfortran.f90
+---
+
+Fortran is one of the oldest computer languages. It was developed in the 1950s
+by IBM for numeric calculations (Fortran is an abbreviation 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,
+Fortran 2018 and Fortran 2023.
+
+This overview will discuss the features of Fortran 2008 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
+        end if inner                ! then must name endif statement.
+    end if
+
+    i = 20
+    select case (i)
+    case (0, 1)                     ! cases i == 0 or i == 1
+        j = 0
+    case (2:10)                     ! cases i is 2 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.
+    end do
+
+    ! 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 write a file.
+    open (unit=12, file="records.txt", status="replace")
+    ! 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'}.
+    write (12, "(F10.2,F10.2,F10.2)") c, b, a
+    close (12)
+
+    ! To read a file.
+    open (newunit=m, file="records.txt", status="old")
+    ! The file is referred to by a 'new unit number', an integer that the compiler
+    ! picks for you.
+    read (unit=m, fmt="(3F10.2)") a, b, c
+    close (m)
+
+    ! There are more features available than discussed here and alternative
+    ! variants due to backwards compatibility 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                 ! subvariable fields can no longer declare implicit none
+        integer, intent(in) :: 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.
+        end if
+        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'.
+        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.
+        integer, intent(in) :: a, b, c
+        integer :: func3
+
+        func3 = a*b*c
+
+    end function func3
+
+    subroutine routine(d, e, f)
+        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
+    contains
+        procedure :: info           ! bind a procedure to a type.
+    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.
+        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 create_mycar
+
+    subroutine info(self)
+        class(car), intent(in) :: self
+        ! 'class' keyword used to bind a procedure to a type here.
+
+        print *, "Model     : ", self%model
+        print *, "Colour    : ", self%colour
+        print *, "Weight    : ", self%weight
+        print *, "Dimensions: ", self%dimensions
+
+    end subroutine info
+
+    real pure function real_abs(x)
+        real, intent(in) :: x
+
+        if (x < 0) then
+            real_abs = -x
+        else
+            real_abs = x
+        end if
+
+    end function real_abs
+
+    real pure function complex_abs(z)
+        complex, intent(in) :: 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-lang Organization](https://fortran-lang.org/)
++ [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/fortran95.html.markdown b/fortran95.html.markdown
deleted file mode 100644
index c256bb38..00000000
--- a/fortran95.html.markdown
+++ /dev/null
@@ -1,452 +0,0 @@
----
-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 abbreviation 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 compatibility 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/asymptotic-notation-fr.html.markdown b/fr-fr/asymptotic-notation-fr.html.markdown
index 491dc3c4..fb0a8220 100644
--- a/fr-fr/asymptotic-notation-fr.html.markdown
+++ b/fr-fr/asymptotic-notation-fr.html.markdown
@@ -67,21 +67,21 @@ f(n) = 3log n + 100
 g(n) = log n
 ```
 
-Est-ce que `f(n)` O(g(n))?
-Est-ce que `3 log n + 100` O(log n)?
+Est-ce que `f(n)` est égal à O(g(n))?
+Est-ce que `3 log n + 100` est égal à O(log n)?
 Regardons maintenant la définition de Big-O.
 
 ```
 3log n + 100 <= c * log n
 ```
 
-Existe t-il une paire de constantes c, n<sub>0</sub> qui satisfait cela pour tout n > <sub>0</sub>?
+Existe t-il une paire de constantes c, n<sub>0</sub> qui satisfait cela pour tout n > n<sub>0</sub>?
 
 ```
 3log n + 100 <= 150 * log n, n > 2 (Indéfini avec n = 1)
 ```
 
-Oui ! La définition de Big-O a été satisfaite, donc `f(n)` is O(g(n)).
+Oui ! La définition de Big-O a été satisfaite, donc `f(n)` est égal à O(g(n)).
 
 *Exemple 2*
 
@@ -90,15 +90,15 @@ f(n) = 3*n^2
 g(n) = n
 ```
 
-Est-ce que `f(n)` O(g(n))?
-Est-ce que `3 * n^2` O(n)?
+Est-ce que `f(n)` est égal à O(g(n))?  
+Est-ce que `3 * n^2` est égal à O(n)?
 Regardons de nouveau la définition de Big-O.
 
 ```
 3 * n^2 <= c * n
 ```
 
-Existe t-il une paire de constantes c, n<sub>0</sub> qui satisfait cela pour tout n > <sub>0</sub>?
+Existe t-il une paire de constantes c, n<sub>0</sub> qui satisfait cela pour tout n > n<sub>0</sub>?
 Non, il n'en existe pas. `f(n)` n'est pas égal à O(g(n)).
 
 ### Big-Omega
diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
index 75c48811..bd4e1312 100644
--- a/fr-fr/awk-fr.html.markdown
+++ b/fr-fr/awk-fr.html.markdown
@@ -10,37 +10,49 @@ lang: fr-fr
 
 ---
 
-AWK est un outil standard présent dans chaque système UNIX conforme aux normes POSIX.
-C’est un outil en ligne de commande qui ressemble au Perl et qui est excellent dans les tâches de traitement de fichiers texte.
-Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage de script autonome.
+AWK est un outil standard présent dans chaque système UNIX conforme aux normes
+POSIX. C’est un outil en ligne de commande qui ressemble au Perl et qui est
+excellent dans les tâches de traitement de fichiers texte.
+Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage
+de script autonome.
 
 Pourquoi utiliser AWK au lieu du langage Perl ?
-Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur une très grande partie des systèmes d'exploitation UNIX et Linux. 
-AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour ce qui concerne le traitement de texte simple. Notamment le traitement de ceux qui necéssitent de lire des fichiers ligne par ligne ; chaque ligne comportant des champs séparés par des délimiteur.
-
+Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur
+une très grande partie des systèmes d'exploitation UNIX et Linux.
+AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour
+ce qui concerne le traitement de texte simple. Notamment le traitement de ceux
+qui nécessitent de lire des fichiers ligne par ligne ; chaque ligne comportant
+des champs séparés par des délimiteur.
 
 ```awk
 #!/usr/bin/awk -f
 
 # Les commentaires commencent par un #
 
-
-# les programmes AWK consistent en une collection de règles et d'actions
+# Les programmes AWK consistent en une collection de règles et d'actions.
 règle1 { action; }
 règle2 { action; }
 
 # AWK lit et analyse automatiquement chaque ligne de chaque fichier fourni.
-# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur peut être changer grâce à l'option -F ou être renseigné au début d'un bloc (exemple: FS = " ").
-
-# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le point d’entrée principal du script.
-# A l'opposé de BEGIN, il existe la règle END. Cette règle est présente après chaque fin de fichier (EOF : End Of File).
+# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace
+# (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur
+# peut être changé grâce à l'option -F ou être renseigné au début d'un bloc
+# (exemple: FS = " ").
+
+# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet
+# endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers
+# texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le
+# point d’entrée principal du script.
+# À l'opposé de BEGIN, il existe la règle END. Cette règle est présente après
+# chaque fin de fichier (EOF : End Of File).
 
 BEGIN {
 
     # Les variables sont globales. Pas besoin de les déclarer.
     count = 0;
 
-    # les opérateurs sont identiques au langage C et aux langages similaires (exemple: C#, C++)
+    # Les opérateurs sont identiques au langage C et aux langages similaires
+    # (tels que C#, C++, etc.)
     a = count + 1; # addition
     b = count - 1; # soustraction
     c = count * 1; # multiplication
@@ -59,7 +71,8 @@ BEGIN {
     a++;
     b--;
 
-    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui est retournée
+    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui
+    # est retournée
     ++a;
     --b;
 
@@ -74,7 +87,8 @@ BEGIN {
 
     # Les blocs sont composés d'une multitude de lignes entre accolades
     while (a < 10) {
-        print "La concaténation de chaînes de caractères" " se fait avec des séries de chaînes "    " séparées par des espaces";
+        print "La concaténation de chaînes de caractères" " se fait avec"
+            "des séries de chaînes " "séparées par des espaces";
         print a;
 
         a++;
@@ -106,14 +120,14 @@ BEGIN {
     arr[1] = "bar";
 
     # Vous pouvez aussi initialiser un tableau avec la fonction split()
-
     n = split("foo:bar:baz", arr, ":");
 
     # Il y a aussi les tableaux associatifs
     assoc["foo"] = "bar";
     assoc["bar"] = "baz";
 
-    # et les tableaux multi-dimentions, avec certaines limitations que l'on ne mentionnera pas ici
+    # et les tableaux multi-dimensions, avec certaines limitations que l'on ne
+    # mentionnera pas ici
     multidim[0,0] = "foo";
     multidim[0,1] = "bar";
     multidim[1,0] = "baz";
@@ -123,7 +137,8 @@ BEGIN {
     if ("foo" in assoc)
         print "Fooey!";
 
-    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés d'un tableau
+    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés
+    # d'un tableau
     for (key in assoc)
         print assoc[key];
 
@@ -131,16 +146,16 @@ BEGIN {
     for (argnum in ARGV)
         print ARGV[argnum];
 
-    # Vous pouvez supprimer des éléments d'un tableau
-    # C'est utile pour empêcher AWK de supposer que certains arguments soient des fichiers à traiter.
+    # Vous pouvez supprimer des éléments d'un tableau.
+    # C'est utile pour empêcher AWK de supposer que certains arguments soient
+    # des fichiers à traiter.
     delete ARGV[1];
 
-    # Le nombre d'arguments de la ligne de commande est dans une variable appellée ARGC
+    # Le nombre d'arguments de la ligne de commande est assigné à
+    # la variable ARGC
     print ARGC;
 
-    # AWK inclue trois catégories de fonction.
-    # On les examinera plus tard
-
+    # AWK inclue trois catégories de fonction. On les examinera plus tard.
     return_value = arithmetic_functions(a, b, c);
     string_functions();
     io_functions();
@@ -149,22 +164,24 @@ BEGIN {
 # Voici comment définir une fonction
 function arithmetic_functions(a, b, c,     d) {
 
-    # La partie la plus ennuieuse de AWK est probablement l’absence de variables locales.
-    # Tout est global. Pour les scripts courts, c'est très utile, mais pour les scripts plus longs,
-    # cela peut poser problème.
+    # La partie la plus ennuyeuse de AWK est probablement l’absence de variables
+    # locales. Tout est global. Pour les scripts courts, c'est très utile, mais
+    # pour les scripts plus longs, cela peut poser un problème.
 
-    # Il y a cepandant une solution de contournement (enfin ... une bidouille).
+    # Il y a cependant une solution de contournement (enfin ... une bidouille).
     # Les arguments d'une fonction sont locaux à cette fonction.
-    # Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire.
-    # Il suffit donc de mettre une variable locale dans la déclaration de fonction,
-    # comme ci-dessus. La convention veut que vous mettiez quelques espaces supplémentaires
-    # pour faire la distinction entre les paramètres réels et les variables locales.
-    # Dans cet exemple, a, b et c sont des paramètres réels,
-    # alors que d est simplement une variable locale.
+    # Et AWK vous permet de définir plus d'arguments à la fonction que
+    # nécessaire. Il suffit donc de mettre une variable locale dans la
+    # déclaration de fonction, comme ci-dessus. La convention veut que vous
+    # mettiez quelques espaces supplémentaires pour faire la distinction entre
+    # les paramètres réels et les variables locales.
+    # Dans cet exemple, a, b et c sont des paramètres réels, alors que d est
+    # simplement une variable locale.
 
     # Maintenant, les fonctions arithmétiques
 
-    # La plupart des implémentations de AWK ont des fonctions trigonométriques standards
+    # La plupart des implémentations de AWK ont des fonctions trigonométriques
+    # standards
     localvar = sin(a);
     localvar = cos(a);
     localvar = atan2(b, a); # arc tangente de b / a
@@ -180,10 +197,10 @@ function arithmetic_functions(a, b, c,     d) {
     localvar = int(5.34); # localvar => 5
 
     # Les nombres aléatoires
-    srand(); 
+    srand();
     # L'argument de la fonction srand() est la valeur de départ pour générer
     # les nombres aléatoires . Par défaut, il utilise l'heure du système
-    
+
     localvar = rand(); # Nombre aléatoire entre 0 et 1.
 
     # Maintenant on retourne la valeur
@@ -195,18 +212,21 @@ function string_functions(    localvar, arr) {
     # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
     # dont beaucoup reposent sur des expressions régulières.
 
-    # Chercher et remplacer, la première occurence (sub) ou toutes les occurences (gsub)
+    # Chercher et remplacer, la première occurrence (sub), ou toutes les
+    # occurrences (gsub).
     # Les deux renvoient le nombre de correspondances remplacées
     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"
+    gsub("e", ".", localvar); # localvar => "M..t m. at th. bar"
 
-    # Rechercher une chaîne de caractères qui correspond à une expression régulière
-    # index() fait la même chose, mais n'autorise pas les expressions régulières
+    # Rechercher une chaîne de caractères qui correspond à une expression
+    # régulière index() fait la même chose, mais n'autorise pas les expressions
+    # régulières.
     match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
 
     # Séparer par un délimiteur
-    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+    n = split("foo-bar-baz", arr, "-");
+    # résultat : a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
 
     # Autre astuces utiles
     sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
@@ -226,26 +246,25 @@ function io_functions(    localvar) {
     printf("%s %d %d %d\n", "Testing", 1, 2, 3);
 
     # AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement
-    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a besoin.
-    # La chaîne de caractères que vous avez utilisée pour cela peut être traitée
-    # comme un descripteur de fichier à des fins d'entrée / sortie.
-
+    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a
+    # besoin. La chaîne de caractères que vous avez utilisée pour cela peut être
+    # traitée comme un descripteur de fichier à des fins d'entrée / sortie.
     outfile = "/tmp/foobar.txt";
-
     print "foobar" > outfile;
 
-    # Maintenant, la chaîne de caractères "outfile" est un descripteur de fichier.
-    # Vous pouvez le fermer
+    # Maintenant, la chaîne de caractères "outfile" est un descripteur de
+    # fichier. Vous pouvez le fermer.
     close(outfile);
 
     # Voici comment exécuter quelque chose dans le shell
     system("echo foobar"); # => affiche foobar
 
-    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable locale
+    # Lire quelque chose depuis l'entrée standard et la stocker dans une
+    # variable locale
     getline localvar;
 
-    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une chaine de caractère
-    # que vous fermerez proprement)
+    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une
+    # chaîne de caractère que vous fermerez proprement)
     "echo foobar" | getline localvar # localvar => "foobar"
     close("echo foobar")
 
@@ -256,33 +275,36 @@ function io_functions(    localvar) {
 }
 
 # Comme dit au début, AWK consiste en une collection de règles et d'actions.
-# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont utilisées que si vous traitez 
-# des lignes à partir de fichiers ou l'entrée standard (stdin).
-# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de fichiers à traiter.
-# AWK les traitera tous dans l'ordre. Voyez les comme dans à une boucle implicite,
-# parcourant les lignes de ces fichiers.
-# Ces règles et ces actions ressemblent à des instructions switch dans la boucle.
+# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont
+# utilisées que si vous traitez des lignes à partir de fichiers ou l'entrée
+# standard (stdin).
+# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de
+# fichiers à traiter. AWK les traitera tous dans l'ordre. Voyez les comme dans
+# une boucle implicite, parcourant les lignes de ces fichiers. Ces règles et ces
+# actions ressemblent à des instructions switch dans la boucle.
 
 /^fo+bar$/ {
 
-    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression régulière,
-    # /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond pas.
-    # Imprimons simplement la ligne:
+    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression
+    # régulière, /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond
+    # pas. Imprimons simplement la ligne :
 
     print;
 
     # Pas d'argument ! C'est parce que print a un défaut : $0.
-    # $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement.
+    # $0 est le nom de la ligne en cours de traitement. Il est créé
+    # automatiquement.
 
     # Vous devinez probablement qu'il existe d'autres variables $.
-    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée, comme
-    # le fait le shell. Et, comme le shell, chaque champ est accessible avec un signe dollar
+    # Chaque ligne est divisée implicitement avant que chaque action soit
+    # exécutée, comme le fait le shell. Et, comme le shell, chaque champ est
+    # accessible avec un signe dollar.
 
-     # Ceci affichera les deuxième et quatrième champs de la ligne.
+    # Ceci affichera les deuxième et quatrième champs de la ligne.
     print $2, $4;
 
-    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous aider
-    # à inspecter et traiter chaque ligne. La plus importante est NF
+    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous
+    # aider à inspecter et traiter chaque ligne. La plus importante est NF.
 
     # Affiche le nombre de champs de la ligne
     print NF;
@@ -291,33 +313,33 @@ function io_functions(    localvar) {
     print $NF;
 }
 
-# Chaque règle est en réalité un test conditionel. 
-
+# Chaque règle est en réalité un test conditionnel.
 a > 0 {
     # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
 }
 
-# Les expressions régulières sont également des tests conditionels.
-#Si le test de l'expression régulières n'est pas vrais alors le bloc n'est pas executé
-$0 /^fobar/ { 
-   print "la ligne commance par fobar"  
+# Les expressions régulières sont également des tests conditionnels.
+# Si le test de l'expression régulières n'est pas vrais alors le bloc
+# n'est pas exécuté.
+$0 /^fobar/ {
+   print "la ligne commence par foobar"
 }
 
-# Dans le cas où vous voulez tester votre chaine de caractères sur la ligne en cours de traitement
-# $0 est optionnelle.
-
+# Dans le cas où vous voulez tester votre chaîne de caractères sur la ligne
+# en cours de traitement $0 est optionnelle.
 /^[a-zA-Z0-9]$/ {
     print "La ligne courante ne contient que des caractères alphanumériques.";
 }
 
+# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en
+# fonction de règles établies. Cela est si courant sous UNIX qu'AWK est un
+# langage de script.
 
-# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en fonction de règles établies
-# Cela est si courant sous UNIX qu'AWK est un langage de script.
-
-# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est parfait.
-# Le script lit un nom à partir de l'entrée standard, puis affiche l'âge moyen de toutes les
-# personnes portant ce prénom.
-# Supposons que vous fournissiez comme argument le nom d'un fichier comportant ces données:
+# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est
+# parfait. Le script lit un nom à partir de l'entrée standard, puis affiche
+# l'âge moyen de toutes les personnes portant ce prénom.
+# Supposons que vous fournissiez comme argument le nom d'un fichier comportant
+# ces données :
 #
 # Bob Jones 32
 # Jane Doe 22
@@ -330,24 +352,26 @@ $0 /^fobar/ {
 BEGIN {
 
     # Premièrement, on demande à l'utilisateur le prénom voulu
-    print "Pour quel prénom vouldriez vous savoir l'age moyen ?";
+    print "Pour quel prénom voudriez vous savoir l'age moyen ?";
 
-    # On récupère la ligne à partir de l'entrée standard, pas de la ligne de commande
+    # On récupère la ligne à partir de l'entrée standard, pas de la ligne
+    # de commande :
     getline name < "/dev/stdin";
 }
 
 # Maintenant, pour chaque ligne dont le premier champ est le prénom donné
 $1 == name {
 
-    # Ici, nous avons accès à un certain nombre de variables utiles déjà préchargées :
+    # Ici, nous avons accès à un certain nombre de variables utiles déjà
+    # préchargées :
     # $0 est la ligne entière
     # $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse
     # NF est le nombre de champs et vaut 3
     # NR est le nombre d'enregistrements (lignes) vus jusqu'à présent
     # FILENAME est le nom du fichier en cours de traitement
     # FS est séparateur de champs, ici c'est " " (un espace)
-    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de man.
-    # Pour cela exécutez "man awk" dans votre terminal
+    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de
+    # man. Pour cela exécutez "man awk" dans votre terminal.
 
     # Garder une trace du total accumulé et du nombre de lignes correspondant.
     sum += $3;
@@ -358,9 +382,9 @@ $1 == name {
 # les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui
 # donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers
 # auront été lus et traités conformément aux règles et aux actions que vous
-# avez fournies. Le but est généralement de produire un rapport final
-# ou de faire quelque chose avec l'ensemble des données que vous avez
-# accumulées au cours du script.
+# avez fournies. Le but est généralement de produire un rapport final, ou de
+# faire quelque chose avec l'ensemble des données que vous avez accumulées
+# au cours du script.
 
 
 END {
@@ -369,9 +393,11 @@ END {
 }
 
 ```
+
 Pour plus d'informations :
 
 * [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 est dans la majorité des systèmes Linux.
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
+  GNU Awk est dans la majorité des systèmes Linux.
 * [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown
index c8603756..b96d0ad0 100644
--- a/fr-fr/c++-fr.html.markdown
+++ b/fr-fr/c++-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-fr.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index 65747c0d..6215e0cf 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -427,7 +427,7 @@ plupart des fonctions principales :
 
 4Clojure est une super manière d'augmenter vos compétences en Clojure et
 en programmation fonctionnelle :
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org a pas mal d'article pour débuter :
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
index 58b3f386..b3bf9c3b 100644
--- a/fr-fr/csharp-fr.html.markdown
+++ b/fr-fr/csharp-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c#
+language: C#
 contributors:
     - ["Irfan Charania", "https://github.com/irfancharania"]
     - ["Max Yankov", "https://github.com/golergka"]
diff --git a/fr-fr/elixir-fr.html.markdown b/fr-fr/elixir-fr.html.markdown
index 90cdad7c..f8250e16 100644
--- a/fr-fr/elixir-fr.html.markdown
+++ b/fr-fr/elixir-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
diff --git a/fr-fr/git-fr.html.markdown b/fr-fr/git-fr.html.markdown
index 510459fe..a4d0c185 100644
--- a/fr-fr/git-fr.html.markdown
+++ b/fr-fr/git-fr.html.markdown
@@ -171,6 +171,7 @@ $ git init --help
 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
@@ -466,6 +467,7 @@ Vous pouvez maintenant pull !
 ```bash
 git pull
 ```
+
 `...changes apply...`
 
 Vérifiez maintenant que tout est OK
@@ -574,8 +576,6 @@ $ git rm /chemin/vers/le/fichier/HelloWorld.c
 
 * [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)
diff --git a/fr-fr/go-fr.html.markdown b/fr-fr/go-fr.html.markdown
index 9d8bef70..5468096a 100644
--- a/fr-fr/go-fr.html.markdown
+++ b/fr-fr/go-fr.html.markdown
@@ -32,7 +32,7 @@ communauté active.
  multiligne */
 
 // Un paquet débute avec une clause "package"
-// "Main" est un nom spécial déclarant un paquet de type exécutable plutôt
+// "main" est un nom spécial déclarant un paquet de type exécutable plutôt
 // qu'une bibliothèque
 package main
 
@@ -87,7 +87,7 @@ sauts de ligne.` // Chaîne de caractère.
   g := 'Σ' // type rune, un alias pour le type int32, contenant un caractère
            // unicode.
 
-  f := 3.14195 // float64, un nombre flottant IEEE-754 de 64-bit.
+  f := 3.14159 // float64, un nombre flottant IEEE-754 de 64-bit.
   c := 3 + 4i  // complex128, considéré comme deux float64 par le compilateur.
 
   // Syntaxe "var" avec une valeur d'initialisation.
@@ -422,18 +422,18 @@ func requestServer() {
 
 ## En savoir plus
 
-La référence Go se trouve sur [le site officiel de Go](http://golang.org/).
+La référence Go se trouve sur [le site officiel de Go](https://go.dev/).
 Vous pourrez y suivre le tutoriel interactif et en apprendre beaucoup plus.
 
 Une lecture de la documentation du langage est grandement conseillée. C'est
 facile à lire et très court (comparé aux autres langages).
 
-Vous pouvez exécuter et modifier le code sur [Go playground](https://play.golang.org/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://play.golang.org](https://play.golang.org) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go.
+Vous pouvez exécuter et modifier le code sur [Go playground](https://go.dev/play/p/tnWMjr16Mm). Essayez de le modifier et de l'exécuter à partir de votre navigateur! Prennez en note que vous pouvez utiliser [https://go.dev/play/](https://go.dev/play/) comme un [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) pour tester et coder dans votre navigateur, sans même avoir à installer Go.
 
 Sur la liste de lecteur des étudiants de Go se trouve le [code source de la
-librairie standard](http://golang.org/src/pkg/). Bien documentée, elle démontre
+librairie standard](https://go.dev/src/). Bien documentée, elle démontre
 le meilleur de la clarté de Go, le style ainsi que ses expressions. Sinon, vous
 pouvez cliquer sur le nom d'une fonction dans [la
-documentation](http://golang.org/pkg/) et le code source apparaît!
+documentation](https://go.dev/pkg/) et le code source apparaît!
 
 Une autre excellente ressource pour apprendre est [Go par l'exemple](https://gobyexample.com/).
diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 186859ab..308f1ca8 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -94,7 +94,7 @@ let banta = "Harry", santa = "Hermione";
 
 // L'égalité est === ou ==
 // === compare la valeur exacte 2 === '2' // = false
-// == convertit la valeur pour comparer 2 === '2' // = true
+// == convertit la valeur pour comparer 2 == '2' // = true
 // En général, il vaut mieux utiliser === pour ne pas faire d'erreur.
 1 === 1; // = true
 2 === 1; // = false
diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 1fd22883..f5d6aacc 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -178,7 +178,7 @@ Vous pouvez également utiliser des sous-listes.
 1. Item un
 2. Item deux
 3. Item trois
-   * Sub-item 
+   * Sub-item
    * Sub-item
 4. Item quatre
 ```
@@ -210,7 +210,7 @@ l'intérieur du bloc de code.
 
 ```md
     my_array.each do |item|
-       puts item
+      puts item
     end
 ```
 
@@ -223,13 +223,15 @@ La fonction `run()` ne vous oblige pas à aller courir!
 
 En Markdown GitHub, vous pouvez utiliser des syntaxes spécifiques.
 
-    ```ruby 
-    def foobar
-    puts "Hello world!"
-    end
-    ```
+````md
+```ruby
+def foobar
+  puts "Hello world!"
+end
+```
+````
 
-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 <code>```</code>.
 
 ## Ligne Horizontale
@@ -267,13 +269,13 @@ Markdown supporte aussi les liens relatifs.
 
 Les liens de références sont eux aussi disponibles en Markdown.
 
-<div class="highlight"><code><pre>
-[<span class="nv">Cliquez ici</span>][<span class="ss">link1</span>] pour plus d'information!
-[<span class="nv">Regardez aussi par ici</span>][<span class="ss">foobar</span>] si vous voulez.
+```md
+[Cliquez ici][link1] pour plus d'information!
+[Regardez aussi par ici][foobar] si vous voulez.
 
-[<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Cool!"</span>
-[<span class="nv">foobar</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Génial!"</span>
-</pre></code></div>
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Génial!"
+```
 
 Le titre peut aussi être entouré de guillemets simples, ou de parenthèses, ou
 absent. Les références peuvent être placées où vous voulez dans le document et
@@ -282,11 +284,11 @@ les identifiants peuvent être n'importe quoi tant qu'ils sont uniques.
 Il y a également le nommage implicite qui transforme le texte du lien en
 identifiant.
 
-<div class="highlight"><code><pre>
-[<span class="nv">Ceci</span>][] est un lien.
+```md
+[Ceci][] est un lien.
 
-[<span class="nv">Ceci</span>]:<span class="sx">http://ceciestunlien.com/</span>
-</pre></code></div>
+[Ceci]:http://ceciestunlien.com/
+```
 
 Mais ce n'est pas beaucoup utilisé.
 
@@ -301,12 +303,11 @@ d'un point d'exclamation!
 
 Là aussi, on peut utiliser le mode "références".
 
+```md
+![Ceci est l'attribut ALT de l'image][monimage]
 
-<div class="highlight"><code><pre>
-![<span class="nv">Ceci est l'attribut ALT de l'image</span>][<span class="ss">monimage</span>]
-
-[<span class="nv">monimage</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"si vous voulez un titre, c'est ici."</span>
-</pre></code></div>
+[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
+```
 
 ## Divers
 
@@ -334,7 +335,7 @@ Tapez \*ce texte\*.
 
 ### Touches de clavier
 
-Avec le "Github Flavored Markdown", vous pouvez utiliser la balise `<kdb>`
+Avec le "GitHub Flavored Markdown", vous pouvez utiliser la balise `<kdb>`
 pour représenter une touche du clavier.
 
 ```md
@@ -348,10 +349,10 @@ Les tableaux ne sont disponibles que dans le "GitHub Flavored Markdown" et
 ne sont pas tres agréable d'utilisation. Mais si vous en avez besoin :
 
 ```md
-| Col1 | Col2 | Col3 |
-| :----------- | :------: | ------------: |
-| Alignement Gauche | Centré | Alignement Droite |
-| bla | bla | bla |
+| Col1              | Col2     | Col3              |
+| :---------------- | :------: | ----------------: |
+| Alignement Gauche | Centré   | Alignement Droite |
+| bla               | bla      | bla               |
 ```
 
 ou bien, pour un résultat équivalent :
diff --git a/fr-fr/pyqt-fr.html.markdown b/fr-fr/pyqt-fr.html.markdown
index 6da9a380..7f0f018b 100644
--- a/fr-fr/pyqt-fr.html.markdown
+++ b/fr-fr/pyqt-fr.html.markdown
@@ -14,14 +14,14 @@ lang: fr-fr
 
 Ceci est une adaptation de l'intro C++ à QT par [Aleksey Kholovchuk](https://github.com/vortexxx192
 ), certains exemples du code doivent avoir la même fonctionnalité,
-cette version ayant juste été faite en utilisant pyqt! 
+cette version ayant juste été faite en utilisant pyqt!
 
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
-	# Création de l'objet application 
+	# Création de l'objet application
     app = QtGui.QApplication(sys.argv)
 	# Création d'un widget où notre label sera placé
     w = QtGui.QWidget()
@@ -47,7 +47,7 @@ if __name__ == '__main__':
 Pour obtenir certaines des fonctionnalités les plus avancées de **pyqt** nous devons commencer par chercher à construire des éléments supplémentaires.
 Ici nous voyons comment introduire une boîte de dialogue popup, utile pour demander une confirmation à un utilisateur ou fournir des informations.
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -66,7 +66,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Cette fonction devrait créer une fenêtre de dialogue avec un bouton
 # qui attend d'être cliqué puis quitte le programme
 def showdialog():
diff --git a/fr-fr/rust-fr.html.markdown b/fr-fr/rust-fr.html.markdown
index b3675f5b..6fc0d07d 100644
--- a/fr-fr/rust-fr.html.markdown
+++ b/fr-fr/rust-fr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["P1start", "http://p1start.github.io/"]
 translators:
@@ -221,7 +221,7 @@ fn main() {
 
     // `for` boucles / itération
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
@@ -309,7 +309,7 @@ fn main() {
 
 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
+Langue](http://doc.rust-lang.org/book/index.html) et étudier 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.
 
diff --git a/fr-fr/set-theory-fr.html.markdown b/fr-fr/set-theory-fr.html.markdown
new file mode 100644
index 00000000..d1ac2711
--- /dev/null
+++ b/fr-fr/set-theory-fr.html.markdown
@@ -0,0 +1,132 @@
+---
+category: Algorithms & Data Structures
+name: Set theory
+lang: fr-fr
+contributors: 
+  - ["kieutrang", "https://github.com/kieutrang1729"]
+---
+
+La théorie des ensembles est une branche des mathématiques qui étudie les ensembles, leurs opérations et leurs propriétés.
+
+* Un ensemble est une collection d'éléments disjoints.
+
+## Symboles de base
+
+### Opérateurs
+* l'opérateur réunion, `∪`, signifie "ou" ;
+* l'opérateur intersection, `∩`, signifie "et" ;
+* l'opérateur différence, `\`, signifie "sans", (lire "A moins B") ;
+* l'opérateur complémentaire, `'`, signifie "le complémentaire de" ;
+* l'opérateur croix, `×`, signifie "le produit cartésien de".
+
+### Autres symboles
+* le symbole deux-points, `:`, signifie "tel que" ;
+* le symbole d'appartenance, `∈`, signifie "appartient à" ;
+* le symbole sous-ensemble, `⊆`, signifie "est un sous-ensemble de" ;
+* le symbole sous-ensemble propre, `⊂`, signifie "est un sous-ensemble de mais n'est pas égal à".
+
+### Ensembles importants
+* `∅`, l'ensemble vide, c'est-à-dire l'ensemble ne contenant aucun élément ;
+* `â„•`, l'ensemble des nombres naturels ;
+* `ℤ`, l'ensemble des entiers ;
+* `â„š`, l'ensemble des nombres rationnels ;
+* `�`, l'ensemble des nombres réels.
+
+Quelques mise en gardes sur les ensembles définis ci-dessus:
+1. Même si l'ensemble vide ne contient aucun élément, il est lui-même un sous-ensemble de n'importe quel ensemble.
+2. Il n'y a pas d'accord général sur l'appartenance de zéro dans l'ensemble des nombres naturels, et les livres indiquent explicitement si l'auteur considère le zéro comme nombre naturel ou pas.
+
+
+### Cardinalité
+
+La cardinalité, ou taille, d'un ensemble est déterminée par le nombre d'éléments dans l'ensemble. L'opérateur de cardinalité s'écrit, `| ... |`.
+Par exemple, si `S = { 1, 2, 4 }`, alors `|S| = 3`.
+
+### L'ensemble vide
+* L'ensemble vide peut se définir en compréhension à l'aide d'une propriété qui n'est satisfaite par nul élément, e.g. `∅ = { x : x ≠ x }`, ou `∅ = { x : x ∈ N, x < 0 }`.
+* il n'y a qu'un seul ensemble vide.
+* l'ensemble vide est sous-ensemble de tout ensemble.
+* la cardinalité de l'ensemble vide est 0, ou `|∅| = 0`.
+
+## Notation ensembliste
+
+### Définition par extension
+
+Un ensemble peut être defini en extension par une liste de tous les éléments qui sont contenus dans l'ensemble. Par exemple, `S = { a, b, c, d }`.
+
+Quand le contexte est clair, on peut raccourcir la liste en utilisant des points de suspension. Par exemple, `E = { 2, 4, 6, 8, ... }` est clairement l'ensemble de tous les nombres pairs, contenant un nombre infini des éléments, même si on a explicitement écrit seulement les quatre premiers.
+
+### Définition par compréhension
+
+C'est une notation plus descriptif qui permet de définir un ensemble à l'aide d'un sujet et d'une propriété, et il est noté `S = { sujet : propriété }`. Par exemple,
+
+```
+A = { x : x est une voyelle } = { a, e, i, o, u, y}
+B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+On peut même appliquer une fonction au sujet, e.g.
+
+```
+D = { 2x : x ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+## Relations
+
+### Appartenance
+
+* Si l'élément `a` est dans l'ensemble `A`, on dit que `a` appartient à `A` et on le note `a ∈ A`.
+* Si l'élément `a` n'est pas dans l'ensemble `A`, on dit que `a` n'appartient pas à `A` et on le note `a ∉ A`.
+
+### Égalité
+
+* On dit que deux ensembles `A` et `B` sont égaux s'ils contiennent les mêmes éléments, et on le note `A = B`.
+* Les ensembles n'ont pas de notion d'ordre, par exemple `{ 1, 2, 3, 4 } = { 2, 3, 1, 4 }`.
+* Un élément ne peut apparaître qu'au plus une seule fois - il n'y a jamais de répétition, e.g. `{ 1, 2, 2, 3, 4, 3, 4, 2 } = { 1, 2, 3, 4 }`.
+* Deux ensembles `A` et `B` sont égaux si et seulement si `A ⊆ B` et `B ⊆ A`.
+
+## Ensemble puissance
+* L'ensemble puissance d'un ensemble `A` est l'ensemble contenant tous les sous-ensembles de `A`. Il est noté `P(A)`. Si la cardinalité de `A` est `n`, la cardinalité de `P(A)` est `2^n`.
+
+```
+P(A) = { x : x ⊆ A }
+```
+
+## Opérations ensemblistes
+### Réunion
+La réunion de deux ensembles `A` et `B` est l'ensemble contenant tous les éléments qui appartient à `A` ou à `B`.
+
+```
+A ∪ B = { x : x ∈ A ∪ x ∈ B }
+```
+
+### Intersection
+L'intersection de deux ensembles `A` et `B` est l'ensemble contenant tous les éléments qui appartient à la fois à `A` et à `B`.
+
+```
+A ∩ B = { x : x ∈ A, x ∈ B }
+```
+
+### Différence
+La différence de deux ensembles `A` et `B` est l'ensemble contenant tous les éléments de l'ensemble `A` qui n'appartient pas à `B`.
+
+```
+A \ B = { x : x ∈ A, x ∉ B }
+```
+
+### Différence symétrique
+Le différence symétrique de deux ensembles `A` et `B` est l'ensemble contenant tous les éléments de `A` et `B` qui n'apparaissent pas dans leur intersection.
+
+```
+A △ B = { x : ((x ∈ A) ∩ (x ∉ B)) ∪ ((x ∈ B) ∩ (x ∉ A)) }
+
+A △ B = (A \ B) ∪ (B \ A)
+```
+
+### Produit cartésien
+Le produit cartésien de deux ensembles `A` et `B` est l'ensemble contenant tous les couples dont le premier élément appartient à `A` et le deuxième à `B`.
+
+```
+A × B = { (x, y) | x ∈ A, y ∈ B }
+```
diff --git a/fr-fr/wolfram-fr.html.markdown b/fr-fr/wolfram-fr.html.markdown
index 7b446259..10a37994 100644
--- a/fr-fr/wolfram-fr.html.markdown
+++ b/fr-fr/wolfram-fr.html.markdown
@@ -21,7 +21,7 @@ Ce code d'exemple peut être utilisé et modifié dans ces logiciels. Cependant,
 copier-coller directement dans Mathematica peut causer des problèmes de
 formatage, car il ne contient aucune information de mise en page.
 
-```
+```mathematica
 (* Ceci est un commentaire *)
 
 (* Dans Mathematica, au lieu d'utiliser ces commentaires, vous pouvez créer des
diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown
index c7cb9421..36c33bd1 100644
--- a/fr-fr/yaml-fr.html.markdown
+++ b/fr-fr/yaml-fr.html.markdown
@@ -36,6 +36,7 @@ valeur_numérique: 100
 notation_scientifique: 1e+12
 booléen: true
 valeur_null: null
+une_autre_valeur_null: ~
 clé avec espaces: valeur
 # Bien qu'il ne soit pas nécessaire de mettre les chaînes de caractères
 # entre guillemets, cela reste possible, et parfois utile.
diff --git a/fsharp.html.markdown b/fsharp.html.markdown
index c140d6b1..f1f8e95d 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -33,6 +33,21 @@ let myInt = 5
 let myFloat = 3.14
 let myString = "hello"           // note that no types needed
 
+// Mutable variables
+let mutable a=3
+a <- 4 // a is now 4.
+
+// Somewhat mutable variables
+// Reference cells are storage locations that enable you to create mutable values with reference semantics.
+// See https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/reference-cells
+let xRef = ref 10
+printfn "%d" xRef.Value // 10
+xRef.Value <- 11
+printfn "%d" xRef.Value // 11
+
+let a=[ref 0; ref 1] // somewhat mutable list
+a[0].Value <- 2
+
 // ------ Lists ------
 let twoToFive = [2; 3; 4; 5]     // Square brackets create a list with
                                  // semicolon delimiters.
diff --git a/func.html.markdown b/func.html.markdown
new file mode 100644
index 00000000..da1b2214
--- /dev/null
+++ b/func.html.markdown
@@ -0,0 +1,338 @@
+---
+language: FunC
+filename: learnFunC.fc
+contributors:
+  - ["Ivan Romanovich", "https://t.me/ton_learn"]
+  - ["Kirill Malev", "https://fslabs.io"]
+---
+
+The FunC language is used to program smart contracts on the [The Open Network](https://ton.org) blockchain. Contract logic is executed in TVM, the stack-based TON Virtual Machine.
+
+FunC is a statically typed, which is similar to C.
+
+# Basic syntax, the first Smart Contract — Data Types, Storage, Functions
+
+```c
+;; Single line comment
+
+	{- This is a multi-line comment
+		{- this is a comment in the comment -}
+	-}
+	
+	(int) sum(int a, int b) { 
+    ;; This is a function that gets two integer parameters 
+    ;; and return integer result
+	  return a + b;  
+    ;; All integers are signed and are 257 bit long. Overflow throws exception
+    ;; expressions must end with a semicolon
+	}
+	
+	() f(int i, cell c, slice s, builder b, cont c, tuple t) {
+	  ;; FunC has 7 atomic types: 
+	  ;; int - 257 bit signed integers,
+	  ;; cell - basic for TON opaque data structure,
+      ;; which contains up to 1,023 bits and up to 4 references to other cells,
+	  ;; slice and builder - special objects to read from and write to cells,
+	  ;; continuation - another flavor of cell that contains 
+      ;; ready-to-execute TVM byte-code.
+	  ;; tuple is an ordered collection of up to 255 components,
+      ;; having arbitrary value types, possibly distinct.
+	  ;; Finally tensor type (A,B, ...) is an ordered collection ready for
+      ;; mass assigning like: (int, int) a = (3, 5);
+	  ;; Special case of tensor type is the unit type ().
+	  ;; It represents that a function doesn’t return any value,
+      ;; or has no arguments.
+	}
+	
+	;; During execution, the contract has read access to local context:
+    ;; its storage, balance, time, network config, etc.
+	;; Contract may change its storage and code,
+    ;; and also may send messages to other contracts
+
+	;; Let’s write a counter smart contract that gets a number
+    ;; from an incoming message,
+	;; adds to already stored numbers and stores result in “storage�
+
+	;; For handling special events, smart contracts have reserved methods:
+	;; recv_internal() handles internal messages from other smart contracts
+	;; recv_external() handles external messages from the outside world —
+    ;; e.g., from a user.
+
+	() recv_internal(slice in_msg_body) {
+	  ;; Cells play the role of memory in the stack-based TVM.
+      ;; A cell can be transformed into a slice,
+	  ;; and then the data bits and references to
+      ;; other cells from the cell can be obtained
+	  ;; by loading them from the slice.
+      ;; Data bits and references to other cells can be stored
+	  ;; into a builder, and then the builder can be finalized into a new cell.
+	  ;; recv_internal gets the slice
+      ;; with incoming message data as an argument.
+
+	  ;; As everything else on TON, permanent storage data is stored as a cell.
+	  ;; It can be retrieved via the get_data() method
+	  ;; begin_parse - converts a cell with data into a readable slice
+
+	  slice ds = get_data().begin_parse(); 
+      ;; `.` is a syntax sugar: a.b() is equivalent to b(a)
+
+	  ;; load_uint is a function from the FunC standard library;
+      ;; it loads an unsigned n-bit integer from a slice
+	  int total = ds~load_uint(64); ;; `~` is a "modifying" method:
+	  ;; essentially, it is a syntax sugar: `r = a~b(x)` 
+      ;; is equivalent to (a,r) = b(a,x)
+	  
+	  ;; Now let’s read the incoming value from the message body slice
+	  int n = in_msg_body~load_uint(32);
+
+	  total += n;
+      ;; integers support usual +-*/ operations as well as (+-*/)= syntax sugar
+
+	  ;; In order to keep a store integer value, we need to do four things:
+	  ;; create a Builder for the future cell - begin_cell()
+	  ;; write a value to total - store_uint(value, bit_size)
+	  ;; create a Cell from the Builder - end_cell()
+	  ;; write the resulting cell into permanent storage - set_data()
+
+	  set_data(begin_cell().store_uint(total, 64).end_cell());
+	}
+
+
+
+	;; The FunC program is essentially a list of
+    function declarations/definitions and global variable declarations.
+
+	;; Any function in FunC matches the following pattern:
+	;; [<forall declarator>] <return_type> <function_name>(<comma_separated_function_args>) <specifiers>
+
+
+	;; Specifiers:
+	;; The impure specifier indicates that
+    ;; function calls should not be optimized
+    ;; (whether its result is used or not)
+	;; it is important for methods that change the smart contract data
+    ;; or send messages
+
+	;; The method_id specifier allows you to call a GET function by name
+	
+	;; For instance, we can create a get method for the contract above
+    ;; to allow outside viewers to read counter
+
+	int get_total() method_id {
+	  slice ds = get_data().begin_parse();
+	  int total = ds~load_uint(64);
+
+	  ;; Note that (int) and int is the same,
+      ;; thus brackets in the function declaration
+      ;; and in the return statement are omitted.
+	  return total;
+	}
+	;; Now any observer can read get_total value via lite-client or explorer
+```
+
+# Messages
+
+The actor model is a model of concurrent computation and is at the heart of TON smart contracts. Each smart contract can process one message at a time, change its own state, or send one or several messages. Processing of the message occurs in one transaction, that is, it cannot be interrupted. Messages to one contract are processed consequently one by one. As a result, the execution of each transaction is local and can be parallelized at the blockchain level, which allows for on-demand throughput horizontal scaling and hosting an unlimited number of users and transactions.
+
+```c
+;; For normal internal message-triggered transactions,
+;; before passing control to recv_internal TVM puts the following
+;; elements on stack.
+;;;; Smart contract balance (in nanoTons)
+;;;; Incoming message balance (in nanoTons)
+;;;; Cell with an incoming message
+;;;; Incoming message body, slice type
+;; In turn, recv_internal may use only
+;; the required number of fields (like 1 in the example above or 4 below)
+
+;; Let’s dive into message sending
+
+() recv_internal (
+    int balance, int msg_value, cell in_msg_full, slice in_msg_body) {
+    ;; 
+    ;; Every message has a strict layout, thus by parsing it,
+    ;; we can get the sender’s address
+    ;; first, we need to read some tech flags and
+    ;; then take the address using load_msg_addr
+    ;; function from FunC standard library - ()
+    var cs = in_msg_full.begin_parse();
+    var flags = cs~load_uint(4);
+    slice sender_address = cs~load_msg_addr();
+
+    ;; if we want to send a message, we first need to construct it
+    ;; message serialization in most cases may be reduced to
+    var msg = begin_cell()
+    .store_uint(0x18, 6) ;; tech flags
+    .store_slice(addr)   ;; destination address
+    .store_coins(amount) ;; attached value
+    .store_uint(0, 107) ;; more tech flags :)
+    .store_slice(in_msg_body) ;; just put some payload here
+    .end_cell();
+
+    ;; to send messages, use send_raw_message from the standard library.
+    ;; it accepts two arguments message and mode
+    send_raw_message(msg, 64);
+
+    ;; mode parameter specifies how to process the funds passed into
+    ;; the smart contract with the message and the smart contract funds
+    ;; 64 means send everything from the incoming message — 
+    ;; what’s left after the commission is deducted
+
+    ;; Exceptions can be thrown by conditional primitives throw_if and
+    ;; throw_unless and by unconditional throw
+    ;; by default, it will automatically cause a bounce message with 64 mode
+
+    var some  = 7;
+    throw_if(102, some == 10);
+    ;; Throw exception with code 102 conditionally
+    throw_unless(103, some != 10);
+    ;; Throw exception with code 103 conditionally
+    throw(101);    ;; Throw exception with code 101 unconditionally
+}
+```
+
+# Flow control: Conditional Statements and Loops; Dictionaries
+
+```c
+;; FunC, of course, supports if statements
+
+;;;; usual if-else
+if (flag) {
+    ;;do_something();
+}
+else {
+    ;;do_alternative();
+}
+
+;; If statements are often used as an operation identifier
+;; for a smart contract, for example:
+
+() recv_internal (
+    int balance, int msg_value, cell in_msg_full, slice in_msg_body) {
+    int op = in_msg_body~load_int(32);
+    if (op == 1) {
+    ;; smth here
+    } else {
+    if (op == 2) {
+        ;; smth here
+    } else {
+        ;; smth here
+    }
+    }
+}
+
+;; Loops
+;; FunC supports repeat, while and do { ... } until loops.
+;; for loop is not supported.
+
+;; repeat
+int x = 1;
+repeat(10) {
+    x *= 2;
+}
+;; x = 1024
+
+;; while
+int x = 2;
+while (x < 100) {
+    x = x * x;
+}
+;; x = 256
+
+;; until loops
+int x = 0;
+do {
+    x += 3;
+} until (x % 17 == 0);
+;; x = 51
+
+;; In practice, loops in TON smart contracts are often used to work with
+;;  dictionaries, or as they are also called in TON hashmaps
+
+;; A hashmap is a data structure represented by a tree.
+;; Hashmap maps keys to values ​​of arbitrary type so that
+;; quick lookup and modification are possible. 
+
+;; udict_get_next? from FunC standard library in combination with
+;; the loop will help, go through the dictionary
+
+int key = -1;
+do {
+    (key, slice cs, int f) = dic.udict_get_next?(256, key);
+
+} until (~ f);
+
+;; udict_get_next? - Calculates the minimum key k in the dictionary dict
+;; that is greater than some given value and returns k,
+;; the associated value, and a flag indicating success.
+;; If the dictionary is empty, returns (null, null, 0).
+```
+
+# Functions
+
+```c
+;; Most useful functions are slice reader and builder writer primitives,
+;; storage handlers and sending messages
+
+;; slice begin_parse(cell c) - Converts a cell into a slice
+;; (slice, int) load_int(slice s, int len) - 
+;; Loads a signed len-bit integer from a slice.
+;; (slice, int) load_uint(slice s, int len) - 
+;; Loads a unsigned len-bit integer from a slice.
+;; (slice, slice) load_bits(slice s, int len) - 
+;; Loads the first 0 ≤ len ≤ 1023 bits from slice into a separate slice.
+;; (slice, cell) load_ref(slice s) - Loads the reference cell from the slice.
+
+;; builder begin_cell() - Creates a new empty builder.
+;; cell end_cell(builder b) - Converts a builder into an ordinary cell.
+;; builder store_int(builder b, int x, int len) -
+;; Stores a signed len-bit integer x into b for 0 ≤ len ≤ 257.
+;; builder store_uint(builder b, int x, int len) -
+;; Stores an unsigned len-bit integer x into b for 0 ≤ len ≤ 256.
+;; builder store_slice(builder b, slice s) - Stores slice s into builder b.
+;; builder store_ref(builder b, cell c) -
+;; Stores a reference to cell c into builder b.
+
+;; cell get_data() - Returns the persistent contract storage cell. 
+;; () set_data(cell c) - Sets cell c as persistent contract data.
+
+;; () send_raw_message(cell msg, int mode) -
+;; put message msg into sending queue with mode.
+;; Note, that message will be sent after a successful execution
+;; of the whole transaction
+
+;; Detailed descriptions of all standard functions can be found
+;; in docs https://ton.org/docs/#/func/stdlib
+;; 
+```
+
+## Additional resources
+- [FunC Lessons](https://github.com/romanovichim/TonFunClessons_Eng)
+- [TON Development Onboarding](https://www.tonspace.co)
+- [TON Documentation](https://ton.org/docs/#/)
+- [FunC Documentation](https://ton.org/docs/#/func/overview)
+- [TON Smart Contracts examples](https://github.com/ton-blockchain/ton/tree/master/crypto/smartcont)
+- [Community portal](https://society.ton.org)
+- [Blockchain portal](https://ton.org)
+- [Stackoverflow](https://stackoverflow.com/questions/tagged/ton)
+
+## Social
+- [Developer community](https://t.me/tondev_eng)
+- [TON Learn](https://t.me/ton_learn)
+- [FunC Lessons Channel](https://github.com/romanovichim/TonFunClessons_Eng)
+- [FunC onboarding](https://t.me/func_guide)
+- [Tondev News](https://t.me/tondevnews)
+
+## Useful blogposts
+- [Setting up a TON Development Environment](https://society.ton.org/setting-up-a-ton-development-environment)
+- [Hello World on TON](https://society.ton.org/ton-hello-world-step-by-step-guide-for-writing-your-first-smart-contract-in-func)
+
+
+## Future To Dos
+- Add smart contracts examples
+- Add more posts
+
+
+This file is mostly copied from [TonFunClessons 15 minutes intro](https://github.com/romanovichim/TonFunClessons_Eng/blob/main/13lesson/15min.md).
+
+P.S. If by any chance you're familiar with [Forth](https://learnxinyminutes.com/docs/forth/), you can also take a look at [Fift](https://ton-blockchain.github.io/docs/fiftbase.pdf).
\ No newline at end of file
diff --git a/gdscript.html.markdown b/gdscript.html.markdown
new file mode 100644
index 00000000..0bfac26a
--- /dev/null
+++ b/gdscript.html.markdown
@@ -0,0 +1,325 @@
+---
+language: GDScript
+contributors:
+    - ["Wichamir", "https://github.com/Wichamir/"]
+filename: learngdscript.gd
+---
+
+GDScript is a dynamically typed scripting language made specifically for
+free and open source game engine Godot. GDScript's syntax is similar to
+Python's. Its main advantages are ease of use and tight integration with
+the engine. It's a perfect fit for game development.
+
+## Basics
+
+```nim
+# Single-line comments are written using hash symbol.
+"""
+  Multi-line
+  comments
+  are
+  written
+  using
+  docstrings.
+"""
+
+# Script file is a class in itself and you can optionally define a name for it.
+class_name MyClass
+
+# Inheritance
+extends Node2D
+
+# Member variables
+var x = 8 # int
+var y = 1.2 # float
+var b = true # bool
+var s = "Hello World!" # String
+var a = [1, false, "brown fox"] # Array - similar to list in Python,
+                                # it can hold different types
+                                # of variables at once.
+var d = {
+  "key" : "value",
+  42 : true
+} # Dictionary holds key-value pairs.
+var p_arr = PoolStringArray(["Hi", "there", "!"]) # Pool arrays can
+                                                  # only hold a certain type.
+
+# Built-in vector types:
+var v2 = Vector2(1, 2)
+var v3 = Vector3(1, 2, 3)
+
+# Constants
+const ANSWER_TO_EVERYTHING = 42
+const BREAKFAST = "Spam and eggs!"
+
+# Enums
+enum { ZERO, ONE , TWO, THREE }
+enum NamedEnum { ONE = 1, TWO, THREE }
+
+# Exported variables are visible in the inspector.
+export(int) var age
+export(float) var height
+export var person_name = "Bob" # Export type hints are unnecessary
+                        # if you set a default value.
+
+# Functions
+func foo():
+  pass # pass keyword is a placeholder for future code
+
+func add(first, second):
+  return first + second
+
+# Printing values
+func printing():
+  print("GDScript ", "is ", " awesome.")
+  prints("These", "words", "are", "divided", "by", "spaces.")
+  printt("These", "words", "are", "divided", "by", "tabs.")
+  printraw("This gets printed to system console.")
+
+# Math
+func doing_math():
+  var first = 8
+  var second = 4
+  print(first + second) # 12
+  print(first - second) # 4
+  print(first * second) # 32
+  print(first / second) # 2
+  print(first % second) # 0
+  # There are also +=, -=, *=, /=, %= etc.,
+  # however no ++ or -- operators.
+  print(pow(first, 2)) # 64
+  print(sqrt(second)) # 2
+  printt(PI, TAU, INF, NAN) # built-in constants
+
+# Control flow
+func control_flow():
+  x = 8
+  y = 2 # y was originally a float,
+        # but we can change its type to int
+        # using the power of dynamic typing!
+  
+  if x < y:
+    print("x is smaller than y")
+  elif x > y:
+    print("x is bigger than y")
+  else:
+    print("x and y are equal")
+  
+  var a = true
+  var b = false
+  var c = false
+  if a and b or not c: # alternatively you can use &&, || and !
+    print("This is true!")
+
+  for i in range(20): # GDScript's range is similar to Python's
+    print(i) # so this will print numbers from 0 to 19
+
+  for i in 20: # unlike Python, you can loop over an int directly
+    print(i) # so this will also print numbers from 0 to 19
+
+  for i in ["two", 3, 1.0]: # iterating over an array
+    print(i)
+  
+  while x > y:
+    printt(x, y)
+    y += 1
+
+  x = 2
+  y = 10
+  while x < y:
+    x += 1
+    if x == 6:
+      continue # 6 won't get printed because of continue statement
+    prints("x is equal to:", x)
+    if x == 7:
+      break # loop will break on 7, so 8, 9 and 10 won't get printed
+
+  match x:
+    1:
+      print("Match is similar to switch.")
+    2:
+      print("However you don't need to put cases before each value.")
+    3:
+      print("Furthermore each case breaks on default.")
+      break # ERROR! Break statement is unnecessary!
+    4:
+      print("If you need fallthrough use continue.")
+      continue
+    _:
+      print("Underscore is a default case.")
+  
+  # ternary operator (one line if-else statement)
+  prints("x is", "positive" if x >= 0 else "negative")
+
+# Casting
+func casting_examples():
+  var i = 42
+  var f = float(42) # cast using variables constructor
+  var b = i as bool # or using "as" keyword
+
+# Override functions
+# By a convention built-in overridable functions start with an underscore,
+# but in practice you can override virtually any function.
+
+# _init is called when object gets initialized
+# This is the object's constructor.
+func _init():
+  # Initialize object's internal stuff here.
+  pass
+
+# _ready gets called when script's node and
+# its children have entered the scene tree.
+func _ready():
+  pass
+
+# _process gets called on every frame.
+func _process(delta):
+  # The delta argument passed to this function is a number of seconds,
+  # which passed between the last frame and the current one.
+  print("Delta time equals: ", delta)
+
+# _physics_process gets called on every physics frame.
+# That means delta should be constant.
+func _physics_process(delta):
+  # Simple movement using vector addition and multiplication.
+  var direction = Vector2(1, 0) # or Vector2.RIGHT
+  var speed = 100.0
+  self.global_position += direction * speed * delta
+  # self refers to current class instance
+
+# When overriding you can call parent's function using the dot operator
+# like here:
+func get_children():
+  # Do some additional things here.
+  var r = .get_children() # call parent's implementation
+  return r
+
+# Inner class
+class InnerClass:
+  extends Object
+
+  func hello():
+    print("Hello from inner class!")
+
+func use_inner_class():
+  var ic = InnerClass.new()
+  ic.hello()
+  ic.free() # use free for memory cleanup
+```
+
+## Accessing other nodes in the scene tree
+
+```nim
+extends Node2D
+
+var sprite # This variable will hold the reference.
+
+# You can get references to other nodes in _ready.
+func _ready() -> void:
+  # NodePath is useful for accessing nodes.
+  # Create NodePath by passing String to its constructor:
+  var path1 = NodePath("path/to/something")
+  # Or by using NodePath literal:
+  var path2 = @"path/to/something"
+  # NodePath examples:
+  var path3 = @"Sprite" # relative path, immediate child of the current node
+  var path4 = @"Timers/Firerate" # relative path, child of the child
+  var path5 = @".." # current node's parent
+  var path6 = @"../Enemy" # current node's sibling
+  var path7 = @"/root" # absolute path, equivalent to get_tree().get_root()
+  var path8 = @"/root/Main/Player/Sprite" # absolute path to Player's Sprite
+  var path9 = @"Timers/Firerate:wait_time" # accessing properties
+  var path10 = @"Player:position:x" # accessing subproperties
+
+  # Finally, to get a reference use one of these:
+  sprite = get_node(@"Sprite") as Sprite # always cast to the type you expect
+  sprite = get_node("Sprite") as Sprite # here String gets
+                                        # implicitly casted to NodePath
+  sprite = get_node(path3) as Sprite
+  sprite = get_node_or_null("Sprite") as Sprite
+  sprite = $Sprite as Sprite
+
+func _process(delta):
+  # Now we can reuse the reference in other places.
+  prints("Sprite has global_position of", sprite.global_position)
+
+# Use onready keyword to assign a value to
+# a variable just before _ready executes.
+# This is a commonly used syntax sugar.
+onready var tween = $Tween as Tween
+
+# You can export NodePath, so you can assign it within the inspector.
+export var nodepath = @""
+onready var reference = get_node(nodepath) as Node
+```
+
+## Signals
+
+Signal system is Godot's implementation of the observer programming
+pattern. Here's an example:
+
+```nim
+class_name Player extends Node2D
+
+var hp = 10
+
+signal died() # define signal
+signal hurt(hp_old, hp_new) # signals can take arguments
+
+func apply_damage(dmg):
+  var hp_old = hp
+  hp -= dmg
+  emit_signal("hurt", hp_old, hp) # emit signal and pass arguments
+  if hp <= 0:
+    emit_signal("died")
+
+func _ready():
+  # connect signal "died" to function "_on_death" defined in self
+  self.connect("died", self, "_on_death")
+
+func _on_death():
+  self.queue_free() # destroy Player on death
+```
+
+## Type hints
+
+GDScript can optionally use static typing.
+
+```nim
+extends Node
+
+var x: int # define typed variable
+var y: float = 4.2
+var z := 1.0 # infer type based on default value using := operator
+
+onready var node_ref_typed := $Child as Node
+
+export var speed := 50.0
+
+const CONSTANT := "Typed constant."
+
+func _ready() -> void:
+  # function returns nothing
+  x = "string" # ERROR! Type can't be changed!
+  return
+
+func join(arg1: String, arg2: String) -> String:
+  # function takes two Strings and returns a String
+  return arg1 + arg2
+
+func get_child_at(index: int) -> Node:
+  # function takes an int and returns a Node
+  return get_children()[index]
+
+signal example(arg: int) # ERROR! Signals can't take typed arguments!
+```
+
+## Further Reading
+
+* [Godot's Website](https://godotengine.org/)
+* [Godot Docs](https://docs.godotengine.org/en/stable/)
+* [Getting started with GDScript](https://docs.godotengine.org/en/stable/getting_started/scripting/gdscript/index.html)
+* [NodePath](https://docs.godotengine.org/en/stable/classes/class_nodepath.html)
+* [Signals](https://docs.godotengine.org/en/stable/getting_started/step_by_step/signals.html)
+* [GDQuest](https://www.gdquest.com/)
+* [GDScript.com](https://gdscript.com/)
diff --git a/git.html.markdown b/git.html.markdown
index a40ef01b..9d33225f 100644
--- a/git.html.markdown
+++ b/git.html.markdown
@@ -124,9 +124,12 @@ 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)
+# Set & Print Some Basic Config Variables (Global)
 $ git config --global user.email "MyEmail@Zoho.com"
 $ git config --global user.name "My Name"
+
+$ git config --global user.email
+$ git config --global user.name
 ```
 
 [Learn More About git config.](http://git-scm.com/docs/git-config)
@@ -579,6 +582,19 @@ $ git rm HelloWorld.c
 $ git rm /pather/to/the/file/HelloWorld.c
 ```
 
+### blame
+Examine specific parts of the code's history and find out who was the last author to modify that line.
+
+```bash
+# find the authors on the latest modified lines
+$ git blame google_python_style.vim
+b88c6a1b (Google Python team  2019-12-30 13:45:23 -0800 12) " See the License for the specific language governing permissions and
+b88c6a1b (Google Python team  2019-12-30 13:45:23 -0800 13) " limitations under the License.
+b88c6a1b (Google Python team  2019-12-30 13:45:23 -0800 14) 
+222e6da8 (mshields@google.com 2010-11-29 20:32:06 +0000 15) " Indent Python in the Google way.
+222e6da8 (mshields@google.com 2010-11-29 20:32:06 +0000 16) 
+222e6da8 (mshields@google.com 2010-11-29 20:32:06 +0000 17) setlocal indentexpr=GetGooglePythonIndent(v:lnum)
+```
 ## Further Information
 
 * [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
@@ -597,8 +613,6 @@ $ git rm /pather/to/the/file/HelloWorld.c
 
 * [SalesForce Cheat Sheet](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf)
 
-* [GitGuys](http://www.gitguys.com/)
-
 * [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html)
 
 * [Pro Git](http://www.git-scm.com/book/en/v2)
diff --git a/go.html.markdown b/go.html.markdown
index 5a9214b0..59ba2e4f 100644
--- a/go.html.markdown
+++ b/go.html.markdown
@@ -39,7 +39,7 @@ Go comes with a good standard library and a sizeable community.
 // +build prod, dev, test
 
 // A package clause starts every source file.
-// Main is a special name declaring an executable rather than a library.
+// main is a special name declaring an executable rather than a library.
 package main
 
 // Import declaration declares library packages referenced in this file.
@@ -95,7 +95,7 @@ can include line breaks.` // Same string type.
 	// Non-ASCII literal. Go source is UTF-8.
 	g := 'Σ' // rune type, an alias for int32, holds a unicode code point.
 
-	f := 3.14195 // float64, an IEEE-754 64-bit floating point number.
+	f := 3.14159 // float64, an IEEE-754 64-bit floating point number.
 	c := 3 + 4i  // complex128, represented internally with two float64's.
 
 	// var syntax with initializers.
@@ -130,7 +130,7 @@ can include line breaks.` // Same string type.
 	// Because they are dynamic, slices can be appended to on-demand.
 	// To append elements to a slice, the built-in append() function is used.
 	// First argument is a slice to which we are appending. Commonly,
-	// the array variable is updated in place, as in example below.
+	// the slice variable is updated in place, as in example below.
 	s := []int{1, 2, 3}		// Result is a slice of length 3.
 	s = append(s, 4, 5, 6)	// Added 3 elements. Slice now has length of 6.
 	fmt.Println(s) // Updated slice is now [1 2 3 4 5 6]
@@ -179,7 +179,7 @@ func learnNamedReturns(x, y int) (z int) {
 
 // Go is fully garbage collected. It has pointers but no pointer arithmetic.
 // You can make a mistake with a nil pointer, but not by incrementing a pointer.
-// Unlike in C/Cpp taking and returning an address of a local varible is also safe. 
+// Unlike in C/Cpp taking and returning an address of a local variable is also safe. 
 func learnMemory() (p, q *int) {
 	// Named return values p and q have type pointer to int.
 	p = new(int) // Built-in function new allocates memory.
@@ -190,6 +190,7 @@ func learnMemory() (p, q *int) {
 	return &s[3], &r     // & takes the address of an object.
 }
 
+// Use the aliased math library (see imports, above) 
 func expensiveComputation() float64 {
 	return m.Exp(10)
 }
@@ -356,7 +357,7 @@ func learnInterfaces() {
 // Functions can have variadic parameters.
 func learnVariadicParams(myStrings ...interface{}) {
 	// Iterate each value of the variadic.
-	// The underbar here is ignoring the index argument of the array.
+	// The underscore here is ignoring the index argument of the array.
 	for _, param := range myStrings {
 		fmt.Println("param:", param)
 	}
@@ -455,27 +456,28 @@ func requestServer() {
 
 ## Further Reading
 
-The root of all things Go is the [official Go web site](http://golang.org/).
+The root of all things Go is the [official Go web site](https://go.dev/).
 There you can follow the tutorial, play interactively, and read lots.
-Aside from a tour, [the docs](https://golang.org/doc/) contain information on
+Aside from a tour, [the docs](https://go.dev/doc/) contain information on
 how to write clean and effective Go code, package and command docs, and release history.
 
-The [Go language specification](https://golang.org/ref/spec) itself is highly recommended. It's easy to read
+The [Go language specification](https://go.dev/ref/spec) itself is highly recommended. It's easy to read
 and amazingly short (as language definitions go these days.)
 
-You can play around with the code on [Go playground](https://play.golang.org/p/tnWMjr16Mm). Try to change it and run it from your browser! Note that you can use [https://play.golang.org](https://play.golang.org) as a [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) to test things and code in your browser, without even installing Go.
+You can play around with the code on [Go playground](https://go.dev/play/p/tnWMjr16Mm). Try to change it and run it from your browser! Note that you can use [https://go.dev/play/](https://go.dev/play/) as a [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) to test things and code in your browser, without even installing Go.
 
 On the reading list for students of Go is the [source code to the standard
-library](http://golang.org/src/pkg/). Comprehensively documented, it
+library](https://go.dev/src/). Comprehensively documented, it
 demonstrates the best of readable and understandable Go, Go style, and Go
 idioms. Or you can click on a function name in [the
-documentation](http://golang.org/pkg/) and the source code comes up!
+documentation](https://go.dev/pkg/) and the source code comes up!
 
 Another great resource to learn Go is [Go by example](https://gobyexample.com/).
 
 There are many excellent conference talks and video tutorials on Go available on YouTube, and here are three playlists of the very best, tailored for beginners, intermediate, and advanced Gophers respectively:
-* [Golang University 101](https://www.youtube.com/playlist?list=PLEcwzBXTPUE9V1o8mZdC9tNnRZaTgI-1P) introduces fundamental Go concepts and shows you how to use the Go tools to create and manage Go code
-* [Golang University 201](https://www.youtube.com/playlist?list=PLEcwzBXTPUE_5m_JaMXmGEFgduH8EsuTs) steps it up a notch, explaining important techniques like testing, web services, and APIs
-* [Golang University 301](https://www.youtube.com/watch?v=YHRO5WQGh0k&list=PLEcwzBXTPUE8KvXRFmmfPEUmKoy9LfmAf) dives into more advanced topics like the Go scheduler, implementation of maps and channels, and optimisation techniques
+
+- [Golang University 101](https://www.youtube.com/playlist?list=PLEcwzBXTPUE9V1o8mZdC9tNnRZaTgI-1P) introduces fundamental Go concepts and shows you how to use the Go tools to create and manage Go code
+- [Golang University 201](https://www.youtube.com/playlist?list=PLEcwzBXTPUE_5m_JaMXmGEFgduH8EsuTs) steps it up a notch, explaining important techniques like testing, web services, and APIs
+- [Golang University 301](https://www.youtube.com/playlist?list=PLEcwzBXTPUE8KvXRFmmfPEUmKoy9LfmAf) dives into more advanced topics like the Go scheduler, implementation of maps and channels, and optimisation techniques
 
 Go Mobile adds support for mobile platforms (Android and iOS). You can write all-Go native mobile apps or write a library that contains bindings from a Go package, which can be invoked via Java (Android) and Objective-C (iOS). Check out the [Go Mobile page](https://github.com/golang/go/wiki/Mobile) for more information.
diff --git a/groovy.html.markdown b/groovy.html.markdown
index 0d589c10..89eee3dd 100644
--- a/groovy.html.markdown
+++ b/groovy.html.markdown
@@ -55,6 +55,9 @@ println x
 //Creating an empty list
 def technologies = []
 
+// or create a list with data
+technologies = ["Kotlin", "Swift"]
+
 /*** Adding a elements to the list ***/
 
 // As with Java
@@ -193,7 +196,7 @@ def say(msg = 'Hello', name = 'world') {
 assert 'Hello world!' == say()
 // Right most parameter with default value is eliminated first.
 assert 'Hi world!' == say('Hi')
-assert 'learn groovy' == say('learn', 'groovy')
+assert 'learn groovy!' == say('learn', 'groovy')
 
 /*
   Logical Branching and Looping
diff --git a/hack.html.markdown b/hack.html.markdown
index fb6af8e1..24055503 100644
--- a/hack.html.markdown
+++ b/hack.html.markdown
@@ -1,308 +1,420 @@
 ---
 language: Hack
 contributors:
+    - ["Andrew DiMola", "https://github.com/AndrewDiMola"]
     - ["Stephen Holdaway", "https://github.com/stecman"]
     - ["David Lima", "https://github.com/davelima"]
 filename: learnhack.hh
 ---
 
-Hack is a superset of PHP that runs under a virtual machine called HHVM. Hack
-is almost completely interoperable with existing PHP code and adds a bunch of
-useful features from statically typed languages.
+[Hack](https://hacklang.org/) lets you write code quickly, while also having safety features built in, like static typechecking.
 
-
-Only Hack-specific features are covered here. Details about PHP's syntax are
-available in the [PHP article](http://learnxinyminutes.com/docs/php/) on this site.
+To run Hack code, [install HHVM](https://docs.hhvm.com/hhvm/installation/introduction), the open-source virtual machine.
 
 ```php
-<?hh
-
-// Hack syntax is only enabled for files starting with an <?hh marker
-// <?hh markers cannot be interspersed with HTML the way <?php can be.
-// Using the marker "<?hh //strict" puts the type checker in strict mode.
-
-
-// Scalar parameter type hints
-function repeat(string $word, int $count)
-{
-    $word = trim($word);
-    return str_repeat($word . ' ', $count);
-}
-
-// Type hints for return values
-function add(...$numbers) : int
-{
-    return array_sum($numbers);
-}
-
-// Functions that return nothing are hinted as "void"
-function truncate(resource $handle) : void
-{
-    // ...
-}
-
-// Type hints must explicitly allow being nullable
-function identity(?string $stringOrNull) : ?string
-{
-    return $stringOrNull;
-}
-
-// Type hints can be specified on class properties
-class TypeHintedProperties
-{
-    public ?string $name;
-
-    protected int $id;
-
-    private float $score = 100.0;
-
-    // Hack's type checker enforces that typed properties either have a
-    // default value or are set in the constructor.
-    public function __construct(int $id)
-    {
-        $this->id = $id;
-    }
-}
-
-
-// Concise anonymous functions (lambdas)
-$multiplier = 5;
-array_map($y ==> $y * $multiplier, [1, 2, 3]);
-
-
-// Generics
-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 adds the concept of shapes for defining struct-like arrays with a
-// guaranteed, type-checked set of keys
-type Point2D = shape('x' => int, 'y' => int);
+/* ==================================
+ *           READ THE DOCS!
+ * ==================================
+ */
+
+/* For more information on the Hack language:
+ * - About Hack: https://hacklang.org/
+ * - Documentation: https://docs.hhvm.com/hack/
+ */
+
+/* ==================================
+ *           A NOTE ON PHP
+ * ==================================
+ */
+
+// The Hack language began as a superset of PHP.
+// Since then, the languages have (largely) diverged.
+// You may encounter the .php extension, which is no longer recommended.
+
+/* ==================================
+ *              COMMENTS
+ * ==================================
+ */
+
+// Hack has single-line comments...
+
+/* Multi-line comments...
+ *
+ */
+
+/**
+ * ... and a special syntax for doc comments.
+ *
+ * Use doc comments to summarize the purpose of a definition, function, class or method.
+ */
+
+/* ==================================
+ *             NAMESPACES
+ * ==================================
+ */
+
+// Namespaces contain definitions of classes, interfaces, traits, functions, and constants.
+
+namespace LearnHackinYMinutes {
+
+  /* ==================================
+   *                TYPES
+   * ==================================
+   */
+
+  function demo_hack_types(): void {
+
+    // Hack has five primitive types: bool, int, float, string, and null.
+    $is_helpful = true; // bool
+    $int_value = 10; // int
+    $precise_value = 2.0; // float
+    $hello_world = "Hello World!"; // string
+    $null_string = null; // null
 
-function distance(Point2D $a, Point2D $b) : float
-{
-    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
-}
+    // Create a `shape` with the shape keyword, with a series of field names and values.
+    $my_point = shape('x' => -3, 'y' => 6, 'visible' => true);
 
-distance(
-    shape('x' => -1, 'y' => 5),
-    shape('x' => 2, 'y' => 50)
-);
+    // Create a `tuple` with the tuple keyword, with a series of two or more types as values.
+    $apple_basket = tuple("apples", 25); // different types are OK
+
+    // Use `arraykey` to represent either an integer or string.
+    $the_answer = 42;
+    $is_answer = process_key($the_answer);
+
+    // Similarly, `num` represents either an int or float.
+    $lucky_number = 7;
+    $lucky_square = calculate_square($lucky_number);
+  }
 
+  function process_key(arraykey $the_answer): bool {
+    if ($the_answer is int) {
+      return true;
+    } else {
+      return false;
+    } // true
+  }
+
+  function calculate_square(num $arg)[]: float {
+    return ((float)$arg * $arg);
+  }
+
+  // Enums are limited to int or string (as an Arraykey), or other enum values.
+  enum Permission: string {
+    Read = 'R';
+    Write = 'W';
+    Execute = 'E';
+    Delete = 'D';
+  }
+
+  // In contrast, an enum class can be of any value type!
+  enum class Random: mixed {
+    int X = 42;
+    string S = 'foo';
+  }
+
+  /* ==================================
+   *            HACK ARRAYS
+   * ==================================
+   */
+
+  // The following line lets us use functions in the `C\` namespace.
+  use namespace HH\Lib\C; // the `C` library operates on containers
+
+  function demo_hack_arrays(): void {
 
-// Type aliasing
-//
-// Hack adds a bunch of type aliasing features for making complex types readable
-newtype VectorArray = array<int, Vector<int>>;
+    // vec: ordered
+    $v = vec[1, 2, 3];
+    $letters = vec['a', 'b', 'c'];
 
-// A tuple containing two integers
-newtype Point = (int, int);
+    $letters[0]; // returns 'a'
+    $letters[] = 'd'; // appends 'd'
+
+    // `inout` provides pass-by-reference behavior
+    C\pop_back(inout $letters); // removes 'd'
+    C\pop_front(inout $letters); // removes 'a'
+
+    // keyset: ordered, without duplicates
+    $k = keyset[1, 2, 3]; // values must be int or string
+    $colors = keyset['red', 'blue', 'green'];
+
+    // keyset keys are identical to their values
+    $colors['blue']; // returns 'blue'.
+
+    $colors[] = 'yellow'; // appends 'yellow'
+    unset($colors['red']); // removes 'red'
+
+    //  dict: ordered, by key-value
+    $d = dict['a' => 1, 'b' => 3]; // keys must be int or string
+    $alphabet = dict['a' => 1, 'b' => 2];
 
-function addPoints(Point $p1, Point $p2) : Point
-{
-    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
-}
+    $alphabet['a']; // indexing at 'a' returns `1`
+    $alphabet['c'] = 3; // adds a new key-value pair of `c => 3`
 
-addPoints(
-    tuple(1, 2),
-    tuple(5, 6)
-);
+    unset($alphabet['b']); // removes 'b'
+  }
 
+  /* ==================================
+   *  THE HACK STANDARD LIBRARY (HSL)
+   * ==================================
+   */
+
+  // The Hack Standard Library is a set of functions and classes for the Hack language.
+  // Namespace use declarations are ideally at the top of your file but are placed here for instruction purposes.
+
+  use namespace HH\Lib\Str; // The `Str` library operates on strings
+
+  function demo_hack_standard_library(): void {
+
+    $letters = vec['a', 'b', 'c'];
+    $colors = keyset['red', 'blue', 'green'];
+    $alphabet = dict['a' => 1, 'b' => 2];
+
+    C\contains($letters, 'c'); // checks for a value; returns 'true'
+    C\contains($colors, 'purple'); // checks for a value; returns 'false'
+    C\contains_key($alphabet, 'a'); // checks for a key; returns 'true'
+    C\contains($alphabet, 'd'); // checks for a value; returns 'false'
 
-// First-class enums
-enum RoadType : int
-{
-    Road = 0;
-    Street = 1;
-    Avenue = 2;
-    Boulevard = 3;
-}
+    Str\length("foo"); // returns `3`
+    Str\join(vec['foo', 'bar', 'baz'], '!'); // returns `foo!bar!baz`
+  }
+
+  /* ==================================
+   *           HELLO WORLD!
+   * ==================================
+   */
+
+  use namespace HH\Lib\IO; // the `IO` library is a standard API for input / output
+
+  <<__EntryPoint>> // required attribute for the typical entry/main function
+  async function main(): Awaitable<
+    void,
+  > { // does not need to be named 'main' / is an asynchronous function
+    await IO\request_output()->writeAllAsync(
+      "Hello World!\n",
+    ); // prints 'Hello World'!
+  }
 
-function getRoadType() : RoadType
-{
-    return RoadType::Avenue;
-}
+  /* ==================================
+   *             FUNCTIONS
+   * ==================================
+   */
 
+  // Functions are defined globally.
+  // When a function is defined in a class, we refer to the function as a method.
 
-// Constructor argument promotion
-//
-// To avoid boilerplate property and constructor definitions that only set
-// properties, Hack adds a concise syntax for defining properties and a
-// constructor at the same time.
-class ArgumentPromotion
-{
-    public function __construct(public string $name,
-                                protected int $age,
-                                private bool $isAwesome) {}
-}
+  // Functions have return types (here: `int`) and must return a value of
+  // that type or return no value when a void return type annotation was used.
 
-class WithoutArgumentPromotion
-{
-    public string $name;
+  function add_one(int $x): int {
+    return $x + 1;
+  }
 
-    protected int $age;
+  // Functions can also have defined, default values.
+  function add_value(int $x, int $y = 1): int {
+    return $x + $y;
+  }
 
-    private bool $isAwesome;
+  // Functions can be variadic (unspecified length of arguments).
+  function sum_ints(int $val, int ...$vals): int {
+    $result = $val;
 
-    public function __construct(string $name, int $age, bool $isAwesome)
-    {
-        $this->name = $name;
-        $this->age = $age;
-        $this->isAwesome = $isAwesome;
+    foreach ($vals as $v) {
+      $result += $v;
     }
-}
-
-
-// Co-operative multi-tasking
-//
-// Two new keywords "async" and "await" can be used to perform multi-tasking
-// Note that this does not involve threads - it just allows transfer of control
-async function cooperativePrint(int $start, int $end) : Awaitable<void>
-{
-    for ($i = $start; $i <= $end; $i++) {
-        echo "$i ";
-
-        // Give other tasks a chance to do something
-        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    return $result;
+  }
+
+  // Functions can also be anonymous (defined with the `==>` arrow).
+  // $f = (int $x): int ==> $x + 1;
+
+  /* ==================================
+   *           PIPE OPERATOR
+   * ==================================
+   */
+
+  // The pipe operator, `|>`, evaluates the result of a left-hand expression
+  // and stores the result in `$$`, the predefined pipe variable.
+
+  use namespace HH\Lib\Vec;
+
+  function demo_pipe_operator(): void {
+
+    Vec\sort(Vec\map(vec[2, 1, 3], $a ==> $a * $a)); // vec[1,4,9]
+
+    // the same result, but using the pipe operator and pipe variable:
+    $x = vec[2, 1, 3]
+      |> Vec\map($$, $a ==> $a * $a) // $$ with value vec[2,1,3]
+      |> Vec\sort($$); // $$ with value vec[4,1,9]
+  }
+
+  /* ==================================
+   *             ATTRIBUTES
+   * ==================================
+   */
+
+  // Hack provides built-in attributes that can change runtime or static type checking behavior.
+  // For example, we used the `__EntryPoint` attribute earlier in the "Hello World!" example.
+
+  // As another example, `__Memoize` caches the result of a function.
+  <<__Memoize>>
+  async function do_expensive_task(): Awaitable<string> {
+    $site_contents = await \HH\Asio\curl_exec("http://hacklang.org");
+    return $site_contents;
+  }
+
+  /* ==================================
+   *             CONTEXTS
+   * ==================================
+   */
+
+  // Hack functions are attached to different contexts and capabilities.
+  // A context is a grouping of capabilities; that is, a grouping of permissions.
+
+  // To declare allowed contexts (and capabilities), use the Context List `[]`.
+  // If contexts are not defined, your function includes permissions defined in Hack's `defaults` context.
+
+  // Because the context list is NOT defined, the `defaults` context is implicitly declared.
+  async function implicit_defaults_context(): Awaitable<void> {
+    await IO\request_output()->writeAllAsync(
+      "Hello World!\n",
+    ); // prints 'Hello World'!
+  }
+
+  // In the function below, the context list is defined to have the `defaults` context.
+  // A function can have multiple contexts [context1, context2, ...].
+  // `defaults` includes most of the capabilities defined by the Hack language.
+  async function explicit_defaults_context()[defaults]: Awaitable<void> {
+    await IO\request_output()->writeAllAsync("Hello World!\n");
+  }
+
+  // You can also specify zero contexts to create a pure function (no capabilities).
+  async function empty_context()[]: Awaitable<void> {
+    // The following line is an error, as the function does not have IO capabilities.
+    // await IO\request_output()->writeAllAsync("Hello World!\n");
+  }
+
+  /* ==================================
+   *             GENERICS
+   * ==================================
+   */
+
+  // Generics allow classes or methods to be parameterized to any set of types.
+  // That's pretty cool!
+
+  // Hack typically passes by value: use `inout` to pass by reference.
+  function swap<T>(inout T $input1, inout T $input2): void {
+    $temp = $input1;
+    $input1 = $input2;
+    $input2 = $temp;
+  }
+
+  /* ==================================
+   *             CLASSES
+   * ==================================
+   */
+
+  // Classes provide a way to group functionality and state together.
+  // To define a class, use the `class` keyword. To instantiate, use `new`.
+  // Like other languages, you can use `$this` to refer to the current instance.
+
+  class Counter {
+    private int $i = 0;
+
+    public function increment(): void {
+      $this->i += 1;
     }
-}
-
-// This prints "1 4 7 2 5 8 3 6 9"
-AwaitAllWaitHandle::fromArray([
-    cooperativePrint(1, 3),
-    cooperativePrint(4, 6),
-    cooperativePrint(7, 9)
-])->getWaitHandle()->join();
-
-
-// Attributes
-//
-// Attributes are a form of metadata for functions. Hack provides some
-// special built-in attributes that introduce useful behaviour.
-
-// The __Memoize special attribute causes the result of a function to be cached
-<<__Memoize>>
-function doExpensiveTask() : ?string
-{
-    return file_get_contents('http://example.com');
-}
 
-// The function's body is only executed once here:
-doExpensiveTask();
-doExpensiveTask();
-
-
-// The __ConsistentConstruct special attribute signals the Hack type checker to
-// ensure that the signature of __construct is the same for all subclasses.
-<<__ConsistentConstruct>>
-class ConsistentFoo
-{
-    public function __construct(int $x, float $y)
-    {
-        // ...
+    public function get(): int {
+      return $this->i;
     }
+  }
 
-    public function someMethod()
-    {
-        // ...
+  // Properties and Methods can be static (not requiring instantiation).
+  class Person {
+    public static function favoriteProgrammingLanguage(): string {
+      return "Hack";
     }
-}
+  }
 
-class ConsistentBar extends ConsistentFoo
-{
-    public function __construct(int $x, float $y)
-    {
-        // Hack's type checker enforces that parent constructors are called
-        parent::__construct($x, $y);
+  function demo_hack_classes(): void {
+    // Use `new` to instantiate a class.
+    $c1 = new Counter();
 
-        // ...
-    }
+    // To call a static property or method, use `::`
+    $typical_person = tuple("Andrew", Person::favoriteProgrammingLanguage());
+  }
 
-    // The __Override annotation is an optional signal for the Hack type
-    // checker to enforce that this method is overriding a method in a parent
-    // or trait. If not, this will error.
-    <<__Override>>
-    public function someMethod()
-    {
-        // ...
+  // Abstract class can be defined, but not instantiated directly.
+  abstract class Machine {
+    public function openDoors(): void {
+      return;
     }
-}
-
-class InvalidFooSubclass extends ConsistentFoo
-{
-    // Not matching the parent constructor will cause a type checker 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)
-    {
-        // ...
+    public function closeDoors(): void {
+      return;
     }
-
-    // Using the __Override annotation on a non-overridden method will cause a
-    // type checker 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()
-    {
-        // ...
+  }
+
+  /* ==================================
+   *             INTERFACES
+   * ==================================
+   */
+
+  // A class can implement a set of requirements via an interface.
+  // An interface is a set of method declarations and constants.
+
+  interface Plane {
+    // A constant is a named value. Once defined, the value cannot be changed.
+    const MAX_SPEED = 300;
+    public function fly(): void;
+  }
+
+  /* ==================================
+   *             TRAITS
+   * ==================================
+   */
+
+  // A trait defines properties and method declarations.
+  // Traits are recommended when abstracting code for reuse.
+  // Traits are included in code via the `use` keyword.
+
+  trait Airplane {
+    // Introduce a class or interface requirement with the following syntax:
+    require extends Machine; // abstract class
+    require implements Plane; // interface
+
+    public function takeOff(): void {
+      $this->openDoors();
+      $this->closeDoors();
+      $this->fly();
     }
-}
+  }
 
+  class Spaceship extends Machine implements Plane {
+    use Airplane;
 
-// Traits can implement interfaces (standard PHP does not support this)
-interface KittenInterface
-{
-    public function play() : void;
-}
-
-trait CatTrait implements KittenInterface
-{
-    public function play() : void
-    {
-        // ...
+    public function fly(): void {
+      // fly like the wind
     }
+  }
+
+  /* ==================================
+   *             KEEP READING!
+   * ==================================
+   */
+
+  /*  This is a simplified guide!
+   *  There's much more to learn, including:
+   * - Asynchronous Operations: https://docs.hhvm.com/hack/asynchronous-operations/introduction
+   * - Reified Generics: https://docs.hhvm.com/hack/reified-generics/reified-generics
+   * - XHP: https://docs.hhvm.com/hack/XHP/setup
+   * - ... and more!
+   */
 }
 
-class Samuel
-{
-    use CatTrait;
-}
-
-
-$cat = new Samuel();
-$cat instanceof KittenInterface === true; // True
-
 ```
 
 ## More Information
 
-Visit the [Hack language reference](http://docs.hhvm.com/manual/en/hacklangref.php)
-for detailed explanations of the features Hack adds to PHP, or the [official Hack website](http://hacklang.org/)
-for more general information.
-
-Visit the [official HHVM website](http://hhvm.com/) for HHVM installation instructions.
+Visit the [Hack language reference](http://docs.hhvm.com/hack/) to learn more about the Hack language.
 
-Visit [Hack's unsupported PHP features article](http://docs.hhvm.com/manual/en/hack.unsupported.php)
-for details on the backwards incompatibility between Hack and PHP.
+For more information on HHVM, including installation instructions, visit the [official HHVM website](http://hhvm.com/).
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 328da5c9..edb4121d 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -3,6 +3,7 @@ language: Haskell
 filename: learnhaskell.hs
 contributors:
     - ["Adit Bhargava", "http://adit.io"]
+    - ["Stanislav Modrak", "https://stanislav.gq"]
 ---
 
 Haskell was designed as a practical, purely functional programming
@@ -41,6 +42,8 @@ False
 -- Boolean operations
 not True -- False
 not False -- True
+True && False -- False
+True || False -- True
 1 == 1 -- True
 1 /= 1 -- False
 1 < 10 -- True
@@ -600,6 +603,6 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
 There are two popular ways to install Haskell: The traditional [Cabal-based installation](http://www.haskell.org/platform/), and the newer [Stack-based process](https://www.stackage.org/install).
 
 You can find a much gentler introduction from the excellent
-[Learn you a Haskell](http://learnyouahaskell.com/),
+[Learn you a Haskell](http://learnyouahaskell.com/) (or [up-to-date community version](https://learnyouahaskell.github.io/)),
 [Happy Learn Haskell Tutorial](http://www.happylearnhaskelltutorial.com/) or
 [Real World Haskell](http://book.realworldhaskell.org/).
diff --git a/hd-hd/amd.html.markdown b/hd-hd/amd.html.markdown
index 0a6581d6..b85567c2 100644
--- a/hd-hd/amd.html.markdown
+++ b/hd-hd/amd.html.markdown
@@ -12,6 +12,7 @@ lang: hd
 जावास�क�रिप�ट मॉड�यूल �से मॉड�यूल और इसकी अत�ल�यकालिक निर�भरता से भरा ह�आ है। यह ब�राउज़र पर�यावरण जहां के लि� विशेष रूप से अच�छी तरह से अन�कूल है, और प�रदर�शन , प�रयोज�य, डीबगिंग, और क�रॉस-डोमेन जैसे मॉड�यूल�स को जल�दी सिंक�रनाइज़ लोडिंग करता hai।
 
 ### मूल अवधारणा
+
 ```javascript
 // ब�नियादी ��मडी �पीआई दो तरीकों लेकिन क�छ भी नहीं होते : ` define` और` require`
 // और सभी मॉड�यूल परिभाषा और खपत के बारे में है :
@@ -79,6 +80,7 @@ function require(deps, callback){
 ### Require.js के साथ वास�तविक द�निया के उपयोग
 
 परिचयात�मक उदाहरण के विपरीत, ` require.js` (सबसे लोकप�रिय ��मडी प�स�तकालय ) वास�तव में लागू करता है ** ** Amd ** में  *A * **, आप XHR के माध�यम से  मॉड�यूल और उनकी निर�भरता लोड करने के लि� सक�षम करने के लि� :
+
 ```javascript
 /* file: app/main.js */
 require(['modules/someClass'], function(SomeClass){
@@ -113,6 +115,7 @@ define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
   return SomeClass;
 });
 ```
+
 अपने ` main.js` में डिफ़ॉल�ट पथ मानचित�रण व�यवहार का उपयोग ` requirejs.config ( configObj ) ` में परिवर�तन करने के लि�:
 
 ```javascript
@@ -131,6 +134,7 @@ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolL
   coolLib.doFancyStuffWith(helpers.transform($('#foo')));
 });
 ```
+
 ` require.js` आधारित क�ष�धा आमतौर पर �क डाटा विशेषता के रूप में ` require.js` स�क�रिप�ट टैग को पारित कर दिया है कि �क �कल प�रवेश बिंद� (` main.js` ) होगा। यह स�वचालित रूप से भरी ह�ई है और pageload पर क�रियान�वित किया जा�गा :
 
 ```html
@@ -151,16 +155,19 @@ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolL
 
 (राइनो भी समर�थन किया है, तो आप शायद 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 */
 ({
@@ -177,6 +184,7 @@ $ r.js -o app.build.js
 ```
 
 उत�पादन में बनाया फ़ाइल का उपयोग करने के लि�, बस ` Data-main` स�वैप:
+
 ```html
 <script src="require.js" data-main="app/main-built"></script>
 ```
diff --git a/hd-hd/d.html.markdown b/hd-hd/d.html.markdown
index 96274e2b..f5e0858a 100644
--- a/hd-hd/d.html.markdown
+++ b/hd-hd/d.html.markdown
@@ -126,7 +126,6 @@ class Matrix(uint m, uint n, T = int) {
 }
 
 auto mat = new Matrix!(3, 3);
-
 ```
 
 Classes की बात हो रही है , �क दूसरे के लि� ग�णों के बारे में बात करते हैं। �क संपत�ति
@@ -176,8 +175,8 @@ class MyClass(T, U) {
 void main() {
     auto mc = new MyClass!(int, string)(7, "seven");
 
-   करने के लि� लिखने के लि� मानक प�स�तकालय से
-   // आयात ' stdio ' मॉड�यूल
+    // करने के लि� लिखने के लि� मानक प�स�तकालय से
+    // आयात ' stdio ' मॉड�यूल
     // सांत�वना (आयात �क ग�ंजाइश के लि� स�थानीय हो सकता है) ।
     import std.stdio;
 
@@ -235,22 +234,21 @@ UFCS के साथ, हम �क विधि के रूप में �
 �क विधि के रूप में ग�र�प � की किसी भी अभिव�यक�ति पर क�छ प�रकार �क की है ।
 
 मैं समानता चाहते । समानता की तरह कोई और? ज़रूर त�म करना। चलो क�छ करते हैं!
+
 ```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/hdl.html.markdown b/hdl.html.markdown
index cad07817..6b9a2d80 100644
--- a/hdl.html.markdown
+++ b/hdl.html.markdown
@@ -12,7 +12,7 @@ It is used by circuit designers to simulate circuits and logic prior to wiring a
 HDL allows circuit designers to simulate circuits at a high level without being connected to specific components.
 
 ## Basic building blocks & introduction to the language---
-This programming language is built by simulating hardware chips and wiring. Normal programming functions are replaced with specialized chips that are added to the current wiring desing. Every base chip must be written as it's own file and imported to be used in the current chip, though they may be reused as often as desired.
+This programming language is built by simulating hardware chips and wiring. Normal programming functions are replaced with specialized chips that are added to the current wiring design. Every base chip must be written as it's own file and imported to be used in the current chip, though they may be reused as often as desired.
 
 ```verilog
 // Single line comments start with two forward slashes.
@@ -79,7 +79,7 @@ foo(in=a[0..7], out=c); // C is now a 2 bit internal bus
 
 
 // Note that internally defined busses cannot be subbussed!
-// To access these elements, output or input them seperately:
+// To access these elements, output or input them separately:
 foo(in[0]=false, in[1..7]=a[0..6], out[0]=out1, out[1]=out2);
 // out1 and out2 can then be passed into other circuits within the design.
 
@@ -123,7 +123,7 @@ CHIP And {
     PARTS:
     // Insert I and K into the nand gate and store the output in an internal
     // wire called notOut.
-    Nand(a=i,b=b,out=notOut);
+    Nand(a=i,b=k,out=notOut);
 
     // Use the not gate we constructed to invert notOut and send to the AND
     // output.
@@ -228,4 +228,4 @@ Good luck and happy coding!
 
 * [Hardware Description Language](https://en.wikipedia.org/wiki/Hardware_description_language)
 
-* [HDL Programming Fundamentals](https://www.electronicdesign.com/products/hdl-programming-fundamentals)
\ No newline at end of file
+* [HDL Programming Fundamentals](https://www.electronicdesign.com/products/hdl-programming-fundamentals)
diff --git a/hjson.html.markdown b/hjson.html.markdown
new file mode 100644
index 00000000..6b3cc3ed
--- /dev/null
+++ b/hjson.html.markdown
@@ -0,0 +1,94 @@
+---
+language: Hjson
+filename: learnhjson.hjson
+contributors:
+  - ["MrTeferi", "https://github.com/MrTeferi"]
+lang: en
+---
+
+Hjson is an attempt to make [JSON](https://learnxinyminutes.com/docs/json/) more human readable.
+
+Hjson is a syntax extension to JSON. 
+It's NOT a proposal to replace JSON or to incorporate it into the JSON spec itself. 
+It's intended to be used like a user interface for humans, 
+to read and edit before passing the JSON data to the machine.
+
+Let's take a look at examples to see the key syntax differences!
+
+```
+{
+    # Comments are totally supported!
+    
+    // With forward slashes too!
+    
+    /*
+        Even block style comments, neat!
+    /*
+    
+    # Strings do not require quotes!
+    # Just keep it to a single line
+    human: readable
+    quotes: "are fine too"
+    
+    # Notice that commas are also not required!
+    # If using commas, strings DO require quotes!
+    object: {
+        name: Hjson
+        properties: [
+            readable
+            exciting
+            fun
+        ]
+        with_commas: [
+            "quoted",
+            "quoty",
+            "quote"
+        ]
+        details: ["this", "is", "fine", "too"]
+    }
+    
+    # Multiline quotes with proper whitespace handling are supported!
+    diary:
+        '''
+        I wish JSON was more human readable.
+        If only there was a JSON for my needs!
+        Oh wait.. there is! It's called Hjson.
+        '''
+    
+    # Backslashes are interpreted as an escape character ONLY in quoted strings
+    slash: This will not have a new line\n
+    slash-quoted: "This will definitely have a new line\n"
+
+    # Make sure to use quotes when mixing whitespace with important punctuation
+    example1: "If, you're, going, to, comma in a string, use, quotes!"
+    example2: "Also if you want to use {} or [] or any JSON relevant punctuation!"
+    example3: [because, this, is, totally, BROKEN!]
+    example4: this is technically OK though: {}[],:
+    
+    # Enjoy working with Hjson!
+    party-time: {
+        Hjson-lovers: [
+            me
+            my mom
+            "my dad"
+        ]
+        Hjson-power-level: 9000
+        supported: {
+            python: yes
+            java: yes
+            javascript: yes
+            c++: yes
+            Go: yes
+            C#: yes
+            Rust: yes
+        }
+        partial-support: ["C", "Kotlin", "Ruby", "Rust"]
+    }
+    
+}
+```
+
+## Further Reading
+
+* [Hjson.github.io](https://hjson.github.io/) Main Hjson site including editor support, how-to, etc.
+* [Hjson Packages](https://github.com/hjson/) Various Hjson packages for different applications.
diff --git a/hocon.html.markdown b/hocon.html.markdown
new file mode 100644
index 00000000..67ea30a2
--- /dev/null
+++ b/hocon.html.markdown
@@ -0,0 +1,574 @@
+---
+language: hocon
+filename: learnhocon.conf
+contributors:
+- [TehBrian, 'https://tehbrian.xyz']
+---
+
+Human-Optimized Configuration Object Notation, or HOCON, is a configuration and
+data serialization format designed to be easily editable by humans.
+
+It's a superset of JSON, meaning that any valid JSON is valid HOCON, but it
+differs in being much less pedantic and opinionated. With its flexible yet
+easily determinable syntax, resulting configuration files are often much less
+noisy than some other formats.
+
+Additionally, its support for comments makes it much better suited for
+user-facing configurations than JSON.
+
+```hocon
+// Comments can either look like this,
+# or they can look like this.
+// Anything after // or # is a comment.
+
+##################
+### THE BASICS ###
+##################
+
+# Everything in HOCON is either a key, a value, or a separator.
+# : and = are separators. They separate the key from the value.
+key: value
+another_key = another_value
+
+# You can use either separator with or without whitespace on either side.
+colon1:value
+colon2: value
+colon3 : value
+equals1=value
+equals2= value
+equals3 = value
+# As you'll see, HOCON is very nonrestrictive regarding its syntax style.
+
+# HOCON also isn't opinionated on how keys look.
+THIS_IS_A_VALID_KEY: value
+this-is-also-a-valid-key: value
+keys can have spaces too: value
+or even numbers like 12345: value
+"you can even quote keys if you'd like!": value
+
+# A key, followed by any separator, and then finally a value, is called a field.
+this_entire_line_is: a field
+
+###################
+### VALUE TYPES ###
+###################
+
+# The types that a value can be are string, number, object, array, boolean, and
+# null. Every value type except for array and object are called simple values.
+
+## SIMPLE VALUES ##
+
+quoted_string: "I like quoting my strings."
+unquoted_string: I don't like quoting my strings.
+# Special characters that cannot be used in unquoted strings are:
+# $ " { } [ ] : = , + # ` ^ ? ! @ * &
+# Unquoted strings do not support any kind of escaping. If using one of those
+# special characters is desired, use a quoted string.
+multi-line_string: """
+  This entire thing is a string!
+  One giant, multi-line string.
+  You can put 'single' and "double" quotes without it being invalid.
+"""
+
+number: 123
+negative: -123
+fraction: 3.1415926536
+scientific_notation: 1.2e6 // same as 1.2 * (10^6)
+
+boolean: true # or false
+empty: null
+
+## ARRAYS ##
+
+# Arrays hold lists of values.
+# Values in arrays can be separated with commas..
+array: [ 1, 2, 3, 4, 5 ]
+fibonacci: [1,1,2,3,5,8,13]
+multiples_of_5: [5, 10, 15, 20,] # Notice the trailing comma. That's okay here.
+# or newlines..
+friends: [
+  "Brian"
+  "Sophie"
+  "Maya"
+  "Sabina"
+]
+# or both!
+ingredients: [
+  "Egg",
+  "Sugar",
+  "Oil",
+  "Flour", # Notice the trailing comma. That's okay here too.
+]
+# Once again, HOCON has a very loose syntax. Use whichever style you prefer.
+no newline before or after bracket: ["This"
+  "is"
+  "an"
+  "array!"]
+
+# Just like any other value, arrays can hold other arrays.
+array in array: [ [1, 2, 3], ["a", "b", "c"] ]
+array in array in array: [ [ [1, 2], [8, 9] ], [ ["a", "b" ], ["y", "z"] ] ]
+
+## OBJECTS ##
+
+# Objects hold fields.
+# Just like arrays, fields in objects can be separated with commas..
+object: { key: value, another_key: another_value }
+server_connection: {ip: "127.0.0.1", port: 80}
+first: {letter: a, number: 1,} # Notice the trailing comma.
+# or newlines..
+power_grid: {
+  max_capacity: 15000
+  current_power: 1200
+}
+# or both!
+food_colors: {
+  carrot: orange,
+  pear: green,
+  apple: red,
+  plum: purple,
+  banana: yellow, # Trailing commas are okay here too!
+}
+
+# Arrays can hold objects just like any other value type.
+coworkers: [
+  {
+    name: Jeff
+    age: 27
+  },
+  {
+    name: Henry
+    age: 35
+  },
+  {
+    name: Timmy
+    age: 12
+  }
+]
+
+# The field separator may be omitted if the key is followed by {
+no_separator {
+  key: value
+  speed_of_light: very fast
+  ten: 10
+
+  # Objects can go inside other objects just like any other value.
+  another_object {
+    twenty: 20
+    speed_of_sound: also pretty fast
+  }
+}
+
+# In fact, the entirety of any HOCON document is an actually just an object.
+# That object is called the root object. The only difference between it and any
+# other object is that the curly brackets at the top and bottom of the document
+# may be omitted.
+
+# This means that HOCON documents can be formatted in the same way that
+# regular objects can be formatted, including separating fields with commas
+# rather than with newlines.
+
+# Additionally, while the entirety of a HOCON document can be and is usually an
+# object, it can also be an array. If it is an array, the opening and closing
+# brackets at the top and bottom of the document must be explicitly written.
+
+######################
+### DUPLICATE KEYS ###
+######################
+
+is_happy: false
+# If there is a duplicate key, the new value overrides the previous value.
+is_happy: true
+online_users: [Jacob, Mike]
+# Same with arrays.
+online_users: [Jacob, Mike, Henry]
+
+# For objects, it's a bit different.
+my_car: {
+  color: blue
+  speed: 9001
+  passengers: null
+
+  engine: {
+    running: true
+    temperature: 137
+  }
+}
+# If there is a duplicate key and both values are objects,
+# then the objects are merged.
+my_car: {
+  // These fields are added to the old, previous object.
+  nickname: "My Favorite Car"
+  type: 2-door sedan
+
+  // Since the value of this duplicate key is NOT an object,
+  // it simply overrides the previous value.
+  speed: 60
+  // Same with arrays. They override, not merge.
+  passengers: ["Nate", "Ty"]
+
+  // This object is recursively merged with the other object.
+  engine: {
+    // These two fields are added to the previous object.
+    type: gas
+    oil_level: 10
+    // This field overrides the previous value.
+    temperature: 179
+  }
+}
+
+# Object merging is done two at a time. That is to say, the first two objects
+# merge into one, then that object merges with the next object, and so on.
+
+# Because of this, if you set a field with an object value to a non-object value
+# and then back to an object value, the new object will completely override any
+# previous value.
+
+// Null, a non-object value, completely overrides the object value.
+my_car: null
+
+// Then, this object completely overrides null.
+my_car: {
+  nickname: "My New Car"
+  type: 4-door minivan
+  color: gray
+  speed: 90
+  passengers: ["Ayden", "Liz"]
+}
+
+###########################
+### VALUE CONCATENATION ###
+###########################
+
+## SIMPLE VALUE CONCATENATION ##
+
+# Simple values (all value types except objects and arrays) separated by
+# whitespace are concatenated into a single string. The whitespace between
+# values is preserved.
+number_concatenation: 1 2 3 12.5 -3 2e5 // same as: "1 2 3 12.5 -3 2e5"
+boolean_concat: true false true // "true false true"
+null_concat: null null null // "null null null"
+mixed_concat: 1 true null // "1 true null"
+
+# String value concatenation can appear anywhere that a quoted string can.
+number_concat_in_array: [1 2, 3 4, 5 6] // same as: ["1 2", "3 4", "5 6"]
+
+# In fact, unquoted strings are actually just string value concatenations.
+unquoted_string_concat: his name is jeff // same as: "his name is jeff"
+
+# Going further, even keys that are unquoted strings are actually just string
+# value concatenations.
+this is a key: value // the KEY is the same as: "this is a key"
+# The following field is identical to the field above.
+"this is a key": value
+
+# Quoted strings can also be concatenated. This will be useful later,
+# when we cover substitutions.
+quoted_string_concat: "her"" name" "is ""jenna" // same as: "her name is jenna"
+# Notice that the whitespace (or lack thereof) between values is preserved.
+
+## ARRAY CONCATENATION ##
+
+# Arrays separated by whitespace are merged into a single array.
+array_concat: [1, 2, 3] [4, 5, 6] // same as: [1, 2, 3, 4, 5, 6]
+
+# Arrays cannot be concatenated with a non-array value.
+//array_concat: true [false] results in an error
+//array_concat: 1 [2] results in an error
+
+## OBJECT CONCATENATION ##
+
+# Objects separated by whitespace are merged into a single object.
+# The merge functionality is identical to that of duplicate key object merging.
+lamp: {on: true} {color: tan} // same as: {on: true, color: tan}
+
+# Similarly to arrays, objects cannot be concatenated with a non-object value.
+//object_concat: true {on: false} results in an error
+//object_concat: 1 {number: 2} results in an error
+
+########################
+### PATH EXPRESSIONS ###
+########################
+
+# Path expressions are used to write out a path through the object graph.
+# Think of it as navigating through objects to a specific field.
+# Each object to traverse through is called an element, and each element is
+# separated with a period.
+
+country: {
+  city: {
+    neighborhood: {
+      house: {
+        name: "My House"
+        address: 123 Example Dr.
+      }
+    }
+  }
+}
+# For example, the path to the address of the house could be written as:
+# country.city.neighborhood.house.address
+# Country, city, neighborhood, house, and address are all elements.
+
+# Path expressions are used in two places: substitutions (which will be
+# covered in a moment), and as keys.
+# That's right: keys themselves can also be path expressions.
+foo: {
+  bar: {
+    baz: {
+      number: 12
+    }
+  }
+}
+# Rather than tediously specifying each object, a path expression can be used.
+# The following field represents the same object found above.
+foo.bar.baz.number: 12
+
+# Fields and objects specified with path expressions are merged in the same way
+# that any object is usually merged.
+foo.bar.baz.bool: true
+// the object foo's value is: foo { bar { baz { number: 12, bool: true } } }
+
+#####################
+### SUBSTITUTIONS ###
+#####################
+
+# Substitutions refer to a specific value from some path expression.
+# They're only allowed in values, not keys or nested inside other substitutions.
+
+me: {
+  favorite_animal: parrots
+  favorite_food: cookies
+}
+# The syntax for a substitution is either ${path_expression} or
+# ${?path_expression}. The latter syntax will be discussed in a moment.
+my_fav_animal: ${me.favorite_animal}
+my_fav_food: ${me.favorite_food}
+
+# Substitutions are not parsed inside quoted strings. To get around this,
+# either use an unquoted string or value concatenation.
+animal_announcement: My favorite animal is ${my_fav_animal}
+// the value is: My favorite animal is parrots
+food_announcement: "My favorite food is "${my_fav_food}"!"
+// the value is: "My favorite food is cookies!"
+
+# Substitutions are parsed last in the document. Because of this, you can
+# reference a key that hasn't been defined yet.
+color_announcement: "My favorite color is" ${my_fav_color}"!"
+// the value is: "My favorite color is blue!"
+my_fav_color: blue
+
+# Another effect of substitutions being parsed last is that substitutions will
+# always use the latest, as in last, value assigned in the entire document,
+# which includes merged objects.
+color: green
+their_favorite_color: ${color} // the value is: orange
+color: orange
+
+random_object: {
+  number: 12
+}
+the_number: ${random_object.number} // the value is: 15
+random_object: {
+  number: 15
+}
+
+###############################
+### UNDEFINED SUBSTITUTIONS ###
+###############################
+
+# A substitution using the ${path_expression} syntax with an undefined path
+# expression, meaning a path expression that does not point to a defined value,
+# is invalid and will therefore generate an error.
+//${does.not.exist} will throw an error
+
+# However, an undefined substitution using the ${?path_expression} syntax
+# has different behavior depending on what it is the value of.
+request: {
+  # If it is the value of a field, then the field will not be created.
+  response: ${?does.not.exist} // this field won't be created and does not exist
+  type: HTTP
+}
+
+request: {
+  # Additionally, if it would have overridden a previous value, then the
+  # previous value remains unchanged.
+  type: ${?does.not.exist} // request.type is still HTTP
+}
+
+# If it is a value in an array, then it is simply not added.
+values: [ 172, "Brian", ${?does.not.exist}, null, true, ]
+// the value is: [ 172, "Brian", null, true ]
+
+# If it is part of simple value concatenation, it acts as an empty string.
+final_string: "String One"${?does.not.exist}"String Two"
+// the value is: "String OneString Two"
+
+# If it is part of array concatenation, it acts as an empty array.
+final_array: [ 1, 2, 3 ] ${?does.not.exist} [ 7, 8, 9 ]
+// the value is: [ 1, 2, 3, 7, 8, 9 ]
+
+# If it is part of object concatenation, it acts as an empty object.
+final_array: { a: 1 } ${?does.not.exist} { c: 3 }
+// the value is: { a: 1, c: 3 }
+
+######################################
+### SELF-REFERENTIAL SUBSTITUTIONS ###
+######################################
+
+# Substitutions normally "look forward" and use the final value defined in the
+# document. However, in cases when this would create a cycle, the substitution
+# looks only backwards.
+
+# A field which contains a substitution that points to itself or points to
+# other fields that eventually point back to itself is called a
+# self-referential field.
+letters: "a b c" // the value is: "a b c"
+letters: ${letters}" d" // "a b c d"
+letters: ${letters}" e" // "a b c d e"
+
+PATH: [/bin] // the value is: [/bin]
+PATH: ${PATH} [/usr/bin] // [/bin, /usr/bin]
+PATH: ${PATH} [/usr/local/bin] // [/bin, /usr/bin, /usr/local/bin]
+
+x: "x" // the value is: "x"
+y: ${x}"y" // "xy"
+x: ${y}"z" // "xyz"
+
+##########################
+### += FIELD SEPARATOR ###
+##########################
+
+# In addition to : and =, there actually exists another separator: +=
+# A field separated with += acts as a self-referential array concatenation.
+# In short, it appends an element to a previously defined array.
+
+a: [1]
+b: [1]
+# This field:
+a += 2 // the value is: [1, 2]
+# functions the same as:
+b: ${?b} [2] // the value is: [1, 2]
+
+USERS: [/usr/luke] // the value is: [/usr/luke]
+USERS += /usr/devon // [/usr/luke, /usr/devon]
+USERS += /usr/michael // [/usr/luke, /usr/devon, /usr/michael]
+
+# Since += only appends elements to a previously existing array, if the previous
+# value was not an array, an error will be generated.
+OTHER_USERS: /usr/luke
+//OTHER_USERS += /usr/devon results in an error
+
+# Notice that the underlying substitution syntax used is ${?path}, not ${path}.
+# Recall that, using the ${?} syntax, an undefined substitution in array
+# concatenation acts as an empty array. Because of this, it is perfectly
+# acceptable if the field that is being set is initially undefined.
+//z: [] not necessary
+z += 3 // the value is: [3]
+z += 4 // the value is: [3, 4]
+
+NEW_USERS += /usr/sandra // the value is: [/usr/sandra]
+NEW_USERS += /usr/kennedy // [/usr/sandra, /usr/kennedy]
+NEW_USERS += /usr/robin // [/usr/sandra, /usr/kennedy, /usr/robin]
+
+################
+### INCLUDES ###
+################
+
+# Includes allow you to "import" one HOCON document into another.
+
+# An include statement consists of the unquoted string "include" followed by
+# whitespace and then a resource name, which is one of the following:
+# - a single quoted string which is heuristically interpreted as a URL,
+#   filename, or a Java classpath resource.
+# - url(), file(), or classpath(), with the parentheses surrounding a quoted
+#   string which is either a URL, filename, or classpath resource respectively.
+# - required(), with the parentheses surrounding one of the above.
+include "https://example.com/config.conf"
+include "/foo/bar/config.conf"
+include "config.conf"
+
+include url("https://example.com/config.conf")
+include file("/foo/bar/config.conf")
+include classpath("config.conf")
+
+# If the included file does not exist, it will be silently ignored and act as if
+# it were an empty object. However, if it is wrapped around required(), then
+# parsing will explicitly error if the file cannot be resolved.
+//include required("doesnt_exist.conf") will error
+//include required(url("https://example.com/doesnt_exist.conf")) will error
+//include required(file("doesnt_exist.conf")) will error
+//include required(classpath("doesnt_exist.conf")) will error
+
+# The file specified by the include statement is called the included file, and
+# the file which contains the include statement is called the including file.
+
+# Including a file functions as if you directly replaced the include statement,
+# wherever it may be, with the contents of the included file's root object.
+
+# An included file must have an object as its root value and not an array.
+# If the included file has an array as its root value, then it is invalid and
+# an error will be generated.
+
+# Pretend that the following is in a file called user_config.conf:
+username: RandomUser1337
+auto_login: true
+color_theme: dark
+screensaver: {
+  image: usr/images/screensaver.jpg
+  turn_on_after: 1m
+}
+
+# And then we include that file.
+include file("user_config.conf")
+
+# We can now reference values from that file!
+path_to_user_screensaver: ${screensaver.image} //
+greeting: "Welcome, "${username}"!" // the value is: "Welcome, RandomUser1337!"
+
+# Duplicate keys override as they normally do.
+status: "Auto Login: "${auto_login} // the value is: "Auto Login: true"
+auto_login: false
+status: "Auto Login: "${auto_login} // the value is: "Auto Login: false"
+
+# Object merging is also the same as usual.
+screensaver: {
+  // This gets added to the screensaver object.
+  enable_during_day: false
+  // This overrides the previous value.
+  turn_on_after: 30s
+}
+
+# Include statements can appear in place of a field. Anywhere that a field
+# could appear, an include statement could appear as well.
+
+# Pretend that the following is in a file called server_settings.conf:
+max_connections: 10
+url: example.com
+port: 80
+admin_page: {
+  username: admin
+  password: pass12345
+}
+
+# And then we include that file nested inside another object.
+websites: {
+  my_epic_website: {
+    include file("server_settings.conf")
+  }
+}
+
+# Now, we can reference the contents of server_settings.conf as if they
+# had been written directly into the object my_epic_website.
+server_port: ${websites.my_epic_website.port}
+
+the_password: "The password is: "${websites.my_epic_website.admin_page.password}
+// the value is: The password is: pass12345
+
+max_conn: "Max Connections: "${websites.my_epic_website.max_connections}
+// the value is: Max Connections: 10
+```
+
+### More Resources
+
++ [Official HOCON Specification](https://github.com/lightbend/config/blob/master/HOCON.md)
++ [HOCON Playground](https://hocon-playground.herokuapp.com)
diff --git a/html.html.markdown b/html.html.markdown
index b8212776..e9226a61 100644
--- a/html.html.markdown
+++ b/html.html.markdown
@@ -8,11 +8,11 @@ translators:
     - ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
 ---
 
-HTML stands for HyperText Markup Language.
+HTML stands for Hypertext Markup Language.
 
-It is a language which allows us to write pages for the world wide web.
+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
+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
@@ -171,6 +171,6 @@ HTML is written in files ending with `.html` or `.htm`. The mime type is
 **HTML is NOT a programming language**
 ## 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)
+* [Wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML Tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3Schools](http://www.w3schools.com/html/html_intro.asp)
diff --git a/httpie.html.markdown b/httpie.html.markdown
new file mode 100644
index 00000000..40481dff
--- /dev/null
+++ b/httpie.html.markdown
@@ -0,0 +1,120 @@
+---
+category: tool
+tool: httpie
+contributors:
+  - ["Adaías Magdiel", "https://github.com/AdaiasMagdiel"]
+filename: learn-httpie.sh
+---
+
+HTTPie is a powerful command-line HTTP client designed for easy interaction
+with HTTP servers. It provides a simple and intuitive interface, making it an
+excellent tool for developers, testers, and system administrators.
+
+## Basic Usage
+
+HTTPie follows a simple syntax: http [flags] [METHOD] URL [items].
+
+```bash
+http GET https://api.example.com/posts
+```
+
+You can print the request without sending it by using the `--offline` flag.
+
+```bash
+http --offline https://api.example.com/posts
+```
+
+### URL shortcuts for `localhost`
+
+HTTPie supports a curl-like shorthand for localhost. For instance, ":3000"
+expands to "http://localhost:3000". If the port is omitted, it assumes port 80.
+
+```bash
+http :/users    # http://localhost/users
+http :5000/rss  # http://localhost:5000/rss
+```
+
+### Optional GET and POST
+
+If you don't specify the METHOD, the HTTPie will use:
+
+- GET for requests without body
+- POST for requests with body
+
+```bash
+http https://api.example.com/tags # GET tags
+http https://api.example.com/tags title="Tutorial" slug="tutorial" # POST a new tag
+```
+
+## Querystring Parameters
+
+
+If you're manually adding query string parameters in the terminal, try the
+`param==value` syntax. It avoids shell escaping for & separators and
+automatically URL-escapes special characters in parameter names and values.
+This differs from parameters in the full URL, which HTTPie doesn't modify.
+
+```bash
+http https://api.example.com/search q==httpie per_page==20
+```
+
+## Sending Data
+
+You can send data in various formats such as JSON, form data, or files.
+
+### JSON Data
+
+```bash
+http POST https://api.example.com/posts title="Hello" body="World"
+```
+
+### Form Data
+
+```bash
+http -f POST https://api.example.com/submit name=John email=john@example.com
+```
+
+### Files
+
+```bash
+http --form POST https://api.example.com/upload file@/path/to/file.txt
+```
+
+## Headers and Authentication
+
+HTTPie allows you to set headers and handle authentication easily.
+
+### Headers
+
+```bash
+http GET https://api.example.com/posts Authorization:"Bearer Token" User-Agent:"HTTPie"
+```
+
+### Basic Authentication
+
+```bash
+http -a username:password GET https://api.example.com/protected
+```
+
+### Bearer Authentication
+
+```bash
+https -A bearer -a token https://api.example.com/admin
+```
+
+## Response Handling
+
+HTTPie provides various options for handling responses.
+
+```bash
+http GET https://api.example.com/data Accept:application/json  # Pretty Print JSON
+
+http GET https://api.example.com/image --output image.png      # Save Response to File
+
+http --follow GET https://example.com  # Follow Redirects
+```
+
+## Further Reading
+
+- [Official Documentation](https://httpie.io/docs/cli).
+- [GitHub](https://github.com/httpie).
diff --git a/hu-hu/go-hu.html.markdown b/hu-hu/go-hu.html.markdown
index 638c9489..451f9147 100644
--- a/hu-hu/go-hu.html.markdown
+++ b/hu-hu/go-hu.html.markdown
@@ -89,7 +89,7 @@ func learnTypes() {
     g := 'Σ' // rúna(rune) típus, megegyezik az uint32-vel, egy UTF-8 karaktert
              // tárol
 
-    f := 3.14195 // float64, az IEEE-754 szabványnak megfelelő 64-bites
+    f := 3.14159 // float64, az IEEE-754 szabványnak megfelelő 64-bites
                  // lebegőpontos szám
     c := 3 + 4i  // complex128, belsőleg két float64-gyel tárolva
 
@@ -325,7 +325,7 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 ## További olvasmányok
 
-Minden Go-val kapcsolatos megtaláható a [hivatalos Go weboldalon](http://golang.org/).
+Minden Go-val kapcsolatos megtaláható a [hivatalos Go weboldalon](https://go.dev/).
 Ott követhetsz egy tutorialt, játszhatsz a nyelvvel az interneten, és sok érdekességet olvashatsz.
 
 A nyelv specifikációját kifejezetten érdemes olvasni, viszonylag rövid és sokat tanul belőle az ember.
diff --git a/hu-hu/pythonlegacy-hu.html.markdown b/hu-hu/pythonlegacy-hu.html.markdown
index b5922766..483784ba 100644
--- a/hu-hu/pythonlegacy-hu.html.markdown
+++ b/hu-hu/pythonlegacy-hu.html.markdown
@@ -20,7 +20,7 @@ bele. Tulajdonképpen futtatható pszeudokód.
 Szívesen fogadok visszajelzéseket! Elérsz itt: [@louiedinh](http://twitter.com/louiedinh)
 vagy pedig a louiedinh [kukac] [google email szolgáltatása] címen.
 
-Figyelem: ez a leírás a Python 2.7 verziójára vonatkozok, illetve
+Figyelem: ez a leírás a Python 2.7 verziójára vonatkozik, illetve
 általánosságban a 2.x verziókra. A Python 2.7 azonban már csak 2020-ig lesz
 támogatva, ezért kezdőknek ajánlott, hogy a Python 3-mal kezdjék az
 ismerkedést. A Python 3.x verzióihoz a [Python 3 bemutató](http://learnxinyminutes.com/docs/python/)
diff --git a/hy.html.markdown b/hy.html.markdown
index 1287095f..5eddbf55 100644
--- a/hy.html.markdown
+++ b/hy.html.markdown
@@ -13,8 +13,7 @@ hy to call native python code or python to call native hy code as well
 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
-;; http://try-hy.appspot.com
+;; this gives an gentle introduction to hy
 ;;
 ; Semicolon comments, like other LISPS
 
@@ -175,10 +174,10 @@ True ; => True
 
 ; create lexical bindings with `let', all variables defined thusly
 ; have local scope
-(let [[nemesis {"superman" "lex luther"
+(let [nemesis {"superman" "lex luther"
                 "sherlock" "moriarty"
-                "seinfeld" "newman"}]]
-  (for [(, h v) (.items nemesis)]
+                "seinfeld" "newman"}]
+  (for [[h v] (.items nemesis)]
 	(print (.format "{0}'s nemesis was {1}" h v))))
 
 ;; classes
diff --git a/id-id/asciidoc-id.html.markdown b/id-id/asciidoc-id.html.markdown
index ceb56b92..2843b8be 100644
--- a/id-id/asciidoc-id.html.markdown
+++ b/id-id/asciidoc-id.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Ryan Mavilia", "http://unoriginality.rocks/"]
 translators:
     - ["Rizky Luthfianto", "http://github.com/rilut"]
-filename: asciidoc-id.md
+filename: asciidoc-id.adoc
 lang: id-id
 ---
 
diff --git a/id-id/coffeescript-id.html.markdown b/id-id/coffeescript-id.html.markdown
index 7fa40bb6..fc876184 100644
--- a/id-id/coffeescript-id.html.markdown
+++ b/id-id/coffeescript-id.html.markdown
@@ -16,7 +16,7 @@ dan kompatibel dengan semua *runtime* JavaScript.
 
 Lihat juga [website CoffeeScript](http://coffeescript.org/) yang memiliki tutorial lengkap tentang CoffeeScript.
 
-```CoffeeScript
+```coffeescript
 # CoffeeScript adalah bahasa hipster.
 # Mengikuti tren bahasa modern lainnya.
 # Sehingga, seperti Ruby dan Python, untuk komentar digunakan tanda pagar.
diff --git a/id-id/markdown.html.markdown b/id-id/markdown.html.markdown
index 1ff1963b..22fcb17f 100644
--- a/id-id/markdown.html.markdown
+++ b/id-id/markdown.html.markdown
@@ -54,8 +54,8 @@ __Dan juga teks ini.__
 **_Dan juga ini!_**
 *__Dan ini!__*
 
-<!-- Di markdown ala Github, yang digunakan untuk me-render berkas markdown pada
-Github, kita juga punya coretan: -->
+<!-- Di markdown ala GitHub, yang digunakan untuk me-render berkas markdown pada
+GitHub, kita juga punya coretan: -->
 
 ~~Teks ini dirender dengan coretan.~~
 
@@ -155,7 +155,7 @@ di dalam kode Anda -->
 
 John bahkan tidak tahu apa fungsi dari `go_to()` !
 
-<!-- Di Markdown ala Github, Anda dapat menggunakan syntax spesial untuk kode -->
+<!-- Di Markdown ala GitHub, Anda dapat menggunakan syntax spesial untuk kode -->
 
 \`\`\`ruby <!-- kecuali hapus backlash tersebut ketika melakukannya, hanya ```ruby ! -->
 def foobar
@@ -163,7 +163,7 @@ def foobar
 end
 \`\`\` <!-- Disini juga, tidak ada backslashes, hanya ``` -->
 
-<!-- Teks di atas tidak membutuhkan indentasi, plus Github akan menggunakan syntax
+<!-- Teks di atas tidak membutuhkan indentasi, plus GitHub akan menggunakan syntax
 highlighting dari bahasa yang digunakan setelah ``` -->
 
 <!-- Horizontal rule (<hr />) -->
@@ -236,14 +236,14 @@ Saya ingin mengetik *teks ini dikelilingi tanda bintang* tapi saya tidak mau tek
 miring, jadi saya melakukan: \*teks ini dikelilingi tanda bintang\*.
 
 <!-- Tombol keyboard -->
-<!-- Pada Markdown ala Github, Anda dapat menggunakan tag <kbd> untuk merepresentasikan tombol
+<!-- 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
+<!-- Tabel hanya tersedia pada Markdown ala GitHub dan sedikit merepotkan, namun jika Anda
 sangat menginginkannya: -->
 
 | Kol1         | Kol2     | Kol3          |
diff --git a/id-id/pyqt-id.html.markdown b/id-id/pyqt-id.html.markdown
index c4833d06..a9163326 100644
--- a/id-id/pyqt-id.html.markdown
+++ b/id-id/pyqt-id.html.markdown
@@ -15,10 +15,10 @@ lang: id-id
 
 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
+```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
 # Buat objek aplikasi
     app = QtGui.QApplication(sys.argv)
@@ -45,7 +45,7 @@ if __name__ == '__main__':
 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 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
diff --git a/id-id/rst-id.html.markdown b/id-id/rst-id.html.markdown
index 06d80089..a5070d64 100644
--- a/id-id/rst-id.html.markdown
+++ b/id-id/rst-id.html.markdown
@@ -88,14 +88,14 @@ ini :)
 
 Ada berbagai macam cara untuk membuat tautan:
 
-- Dengan menambahkan garis bawah setelah sebuah huruf : Github_ dan dengan
+- Dengan menambahkan garis bawah setelah sebuah huruf : GitHub_ dan dengan
 menambahkan URL target setelah teks (cara ini mempunyai kelebihan dengan tidak
 memasukkan URL yang tidak penting ke dalam teks yang bisa dibaca).
 - Dengan mengetik URL lengkap yang dapat dipahami : https://github.com (akan
 otomatis diubah menjadi sebuah link)
-- Dengan membuat link seperti di Markdown: `Github <https://github.com/>`_ .
+- Dengan membuat link seperti di Markdown: `GitHub <https://github.com/>`_ .
 
-.. _Github https://github.com/
+.. _GitHub https://github.com/
 
 ```
 
diff --git a/id-id/ruby-id.html.markdown b/id-id/ruby-id.html.markdown
index 28135da1..a94aefb2 100644
--- a/id-id/ruby-id.html.markdown
+++ b/id-id/ruby-id.html.markdown
@@ -619,4 +619,4 @@ Sesuatu.new.qux # => 'qux'
 - [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.
+- [Try Ruby](https://try.ruby-lang.org/) - Pelajari dasar bahasa pemrograman Ruby, secara interaktif di browser.
diff --git a/images/cairo/build.png b/images/cairo/build.png
new file mode 100644
index 00000000..7cadb9ad
--- /dev/null
+++ b/images/cairo/build.png
diff --git a/images/cairo/connect.png b/images/cairo/connect.png
new file mode 100644
index 00000000..86146353
--- /dev/null
+++ b/images/cairo/connect.png
diff --git a/images/cairo/connect2.png b/images/cairo/connect2.png
new file mode 100644
index 00000000..08b00a81
--- /dev/null
+++ b/images/cairo/connect2.png
diff --git a/images/cairo/declare.png b/images/cairo/declare.png
new file mode 100644
index 00000000..5b5196ce
--- /dev/null
+++ b/images/cairo/declare.png
diff --git a/images/cairo/deploy.png b/images/cairo/deploy.png
new file mode 100644
index 00000000..bdb7e53c
--- /dev/null
+++ b/images/cairo/deploy.png
diff --git a/it-it/asciidoc-it.html.markdown b/it-it/asciidoc-it.html.markdown
index 47a57349..eaa2372b 100644
--- a/it-it/asciidoc-it.html.markdown
+++ b/it-it/asciidoc-it.html.markdown
@@ -6,7 +6,7 @@ contributors:
 translators:
     - ["Ale46", "https://github.com/ale46"]
 lang: it-it
-filename: asciidoc-it.md
+filename: asciidoc-it.adoc
 ---
 
 AsciiDoc è un linguaggio di markup simile a Markdown e può essere usato per qualsiasi cosa, dai libri ai blog. Creato nel 2002 da Stuart Rackman, questo linguaggio è semplice ma permette un buon numero di personalizzazioni.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index 449aebfb..a8e0c7b5 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-it.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
diff --git a/it-it/elixir-it.html.markdown b/it-it/elixir-it.html.markdown
index 48afe0c8..ce3e4535 100644
--- a/it-it/elixir-it.html.markdown
+++ b/it-it/elixir-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Luca 'Kino' Maroni", "https://github.com/kino90"]
     - ["Joao Marques", "http://github.com/mrshankly"]
@@ -21,11 +21,11 @@ e molte altre funzionalità.
 # Non esistono commenti multilinea,
 # ma puoi concatenare più commenti.
 
-# Per usare la shell di elixir usa il comando `iex`.
+# Per usare la shell di Elixir usa il comando `iex`.
 # Compila i tuoi moduli con il comando `elixirc`.
 
 # Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato
-# elixir correttamente.
+# Elixir correttamente.
 
 ## ---------------------------
 ## -- Tipi di base
@@ -87,7 +87,7 @@ multi-linea.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` in elixir restituisce il valore ASCII della lettera `a`
+# `?a` in Elixir restituisce il valore ASCII della lettera `a`
 ?a #=> 97
 
 # Per concatenare liste si usa `++`, per binari si usa `<>`
@@ -112,7 +112,7 @@ minore..maggiore = 1..10 # Puoi fare pattern matching anche sugli intervalli
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# In elixir l'operatore `/` restituisce sempre un decimale.
+# In Elixir l'operatore `/` restituisce sempre un decimale.
 
 # Per fare una divisione intera si usa `div`
 div(10, 2) #=> 5
@@ -173,7 +173,7 @@ else
 end
 
 # Ti ricordi il pattern matching?
-# Moltre strutture di controllo di flusso in elixir si basano su di esso.
+# Moltre strutture di controllo di flusso in Elixir si basano su di esso.
 
 # `case` ci permette di confrontare un valore a diversi pattern:
 case {:uno, :due} do
@@ -307,7 +307,7 @@ Geometria.area({:cerchio, 3})       #=> 28.25999999999999801048
 # Geometria.area({:cerchio, "non_un_numero"})
 #=> ** (FunctionClauseError) no function clause matching in Geometria.area/1
 
-# A causa dell'immutabilità dei dati, la ricorsione è molto frequente in elixir
+# A causa dell'immutabilità dei dati, la ricorsione è molto frequente in Elixir
 defmodule Ricorsione do
   def somma_lista([testa | coda], accumulatore) do
     somma_lista(coda, accumulatore + testa)
@@ -382,7 +382,7 @@ end
 ## ---------------------------
 
 # Elixir si basa sul modello degli attori per la concorrenza.
-# Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in elixir
+# Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in Elixir
 # sono tre primitive: creare processi, inviare messaggi e ricevere messaggi.
 
 # Per creare un nuovo processo si usa la funzione `spawn`, che riceve una
@@ -434,7 +434,7 @@ self() #=> #PID<0.27.0>
 
 ## Referenze
 
-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di elixir](http://elixir-lang.org)
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di Elixir](http://elixir-lang.org)
 * [Documentazione Elixir](https://elixir-lang.org/docs.html)
 * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) di Dave Thomas
 * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
diff --git a/it-it/go-it.html.markdown b/it-it/go-it.html.markdown
index 797f6b0b..6f974c91 100644
--- a/it-it/go-it.html.markdown
+++ b/it-it/go-it.html.markdown
@@ -34,7 +34,7 @@ Go include un'ottima libreria standard e ha una community entusiasta.
  su riga multipla */
 
 // In cima ad ogni file è necessario specificare il package.
-// Main è un package speciale che identifica un eseguibile anziché una libreria.
+// 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 
@@ -91,7 +91,7 @@ può 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)
+	f := 3.14159 // float64, un numero in virgola mobile a 64-bit (IEEE-754)
 
 	c := 3 + 4i  // complex128, rappresentato internamente con due float64.
 
@@ -422,9 +422,9 @@ func richiediServer() {
 
 ## Letture consigliate
 
-La risorsa più importante per imparare il Go è il [sito ufficiale di Go](http://golang.org/).
+La risorsa più importante per imparare il Go è il [sito ufficiale di Go](https://go.dev/).
 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
+Oltre al tour, [la documentazione](https://go.dev/doc/) contiene informazioni su
 come scrivere ottimo codice in Go, documentazione sui package e sui comandi, e
 la cronologia delle release.
 
@@ -432,17 +432,17 @@ 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).
+Puoi giocare con il codice visto finora nel [Go playground](https://go.dev/play/p/Am120Xe7qf).
 Prova a cambiarlo e ad eseguirlo dal browser!
-Osserva che puoi usare [https://play.golang.org](https://play.golang.org) come
+Osserva che puoi usare [https://go.dev/play/](https://go.dev/play/) 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 è
+sorgente della libreria standard](https://go.dev/src/). 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
+funzione [nella documentazione](https://go.dev/pkg/) compare il relativo
 codice sorgente!
 
 Un'altra ottima risorsa per imparare è [Go by example](https://gobyexample.com/).
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
index b0a123f1..609d3bb7 100644
--- a/it-it/markdown.html.markdown
+++ b/it-it/markdown.html.markdown
@@ -72,7 +72,7 @@ __Come pure questo.__
 *__E questo!__*
 ```
 
-In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su Github, è presente anche lo stile barrato:
+In GitHub Flavored Markdown, che è utilizzato per renderizzare i file markdown su GitHub, è presente anche lo stile barrato:
 
 ```md
 ~~Questo testo è barrato.~~
@@ -183,7 +183,7 @@ Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vo
 
 ```md
     my_array.each do |item|
-        puts item
+      puts item
     end
 ```
 
@@ -193,14 +193,17 @@ 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
-<pre>
-<code class="highlight">&#x60;&#x60;&#x60;ruby
+In GitHub Flavored Markdown, potete inoltre usare una sintassi speciale per il codice
+
+````md
+```ruby
 def foobar
-    puts "Hello world!"
+  puts "Hello world!"
 end
-&#x60;&#x60;&#x60;</code></pre>
-Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre Github userà l'evidenziazione della sintassi del linguaggio specificato dopo i \`\`\` iniziali
+```
+````
+
+Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre GitHub userà l'evidenziazione della sintassi del linguaggio specificato dopo i \`\`\` iniziali
 
 ## Linea orizzontale
 Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asterischi o trattini, con o senza spazi. 
@@ -253,7 +256,7 @@ Ma non è comunemente usato.
 Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre!
 
 ```md
-![Qeusto è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
+![Questo è 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
@@ -282,7 +285,7 @@ Voglio inserire *questo testo circondato da asterischi* ma non voglio che venga
 ```
 
 ### Combinazioni di tasti
-In Github Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
+In GitHub Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
 
 ```md
 Il tuo computer è crashato? Prova a premere
@@ -290,7 +293,7 @@ Il tuo computer è crashato? Prova a premere
 ```
 
 ### Tabelle
-Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
+Le tabelle sono disponibili solo in GitHub Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
 
 ```md
 | Col1                 | Col2     | Col3               |
@@ -307,4 +310,4 @@ Col 1 | Col2 | Col3
 ```
 
 ---
-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).
+Per altre informazioni, leggete il post ufficiale di John Gruber sulla sintassi [qui](https://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
index 38be8848..2668815f 100644
--- a/it-it/matlab-it.html.markdown
+++ b/it-it/matlab-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Matlab
+language: MATLAB
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
     - ["jamesscottbrown", "http://jamesscottbrown.com"]
@@ -114,7 +114,7 @@ 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) % 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
 
@@ -466,7 +466,7 @@ perms(x) % lista tutte le permutazioni di elementi di x
 
 
 % Classi
-% Matlab supporta la programmazione orientata agli oggetti.
+% 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
@@ -488,7 +488,7 @@ classdef WaypointClass % Il nome della classe.
     end
 
     % Se si vuole aggiungere due oggetti Waypoint insieme senza chiamare
-    % una funzione speciale si può sovradefinire una funzione aritmetica di Matlab come questa:
+    % 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]);
@@ -500,7 +500,7 @@ end
 % 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.
+% Le proprietà della classe si comportano esattamente come una Struttura MATLAB.
 a.latitude = 70.0
 a.longitude = 25.0
 
@@ -511,15 +511,15 @@ ans = multiplyLatBy(a,3)
 % 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
+% 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
+## 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/php-composer-it.html.markdown b/it-it/php-composer-it.html.markdown
new file mode 100644
index 00000000..509ec336
--- /dev/null
+++ b/it-it/php-composer-it.html.markdown
@@ -0,0 +1,193 @@
+---
+category: tool
+tool: composer
+contributors:
+    - ["Brett Taylor", "https://github.com/glutnix"]
+translator:
+    - ["Agostino Fiscale", "https://github.com/agostinofiscale"]
+lang: it-it
+filename: LearnComposer-it.sh
+---
+
+[Composer](https://getcomposer.org/) è uno strumento che ti aiuta a gestire le 
+dipendenze in PHP. Ti permette di dichiarare le librerie utilizzate dal tuo 
+progetto e di installarle/aggiornarle per te.
+
+# Installazione
+
+```sh
+# Se installi l'eseguibile in una cartella...
+curl -sS https://getcomposer.org/installer | php
+# ...dovrai utilizzare questo approccio, invocando Composer in questo modo:
+php composer.phar about
+
+# Se installi l'eseguibile nella directory ~/bin/composer
+# Nota: assicurati che ~/bin si trovi nella variabile di ambiente PATH
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Gli utenti Windows possono seguire le istruzioni per [installarlo su Windows](https://getcomposer.org/doc/00-intro.md#installation-windows).
+
+## Assicuriamoci che il tutto abbia funzionato correttamente
+
+```sh
+# Controlla la versione e la lista delle opzioni disponibili
+composer
+
+# Ottieni ulteriori informazioni riguardanti le opzioni
+composer help require
+
+# Controlla se Composer ha tutto il necessario per funzionare come si deve
+# e se è aggiornato correttamente all'ultima versione disponibile.
+composer diagnose
+composer diag # alias
+
+# Aggiorna Composer all'ultima versione disponibile
+composer self-update
+composer self # alias
+```
+
+# Cominciamo ad usare Composer
+
+Composer memorizza le dipendenze necessarie nel file `composer.json`.
+Puoi editare questo file manualmente, ma è meglio che lasci che Composer se ne 
+occupi per te.
+
+```sh
+# Crea un nuovo progetto nella cartella attuale
+composer init
+# ti verranno chieste delle domande interrative riguardanti il tuo progetto. 
+# Puoi evitare di rispondere almeno che tu non stia sviluppando altri progetti 
+# che che possano dipendere da questo.
+
+# Se il file composer.json esiste già, scarichera' le dipendenze necessarie
+composer install
+
+# Scarica le dipendenze necessarie per l'ambiente di produzione
+composer install --no-dev
+
+# Aggiunge una dipendenza per l'ambiente di produzione
+composer require guzzlehttp/guzzle
+# automaticamente selezionera' l'ultima versione, la scarichera' e la aggiungera'
+# come dipendenza nell'apposito campo del file composer.json.
+
+composer require guzzlehttp/guzzle:6.0.*
+# scarichera' l'ultima versione disponibile corrispondente al pattern (es. 6.0.2)
+# e lo aggiungera' come dipendenza nell'apposito campo del file composer.json.
+
+composer require --dev phpunit/phpunit:~4.5.0
+# aggiungera' la dipendenza nell'ambiente di sviluppo utilizzando l'ultima versione
+# disponibile nel range >=4.5.0 e < 4.6.0.
+
+composer require-dev phpunit/phpunit:^4.5.0
+# aggiungera' la dipendenza nell'ambiente di sviluppo utilizzando l'ultima versione
+# disponibile nel range >=4.5.0 and < 5.0.
+
+# Per ulteriori dettagli riguardo le versioni, vedi [la documentazione di Composer sulle versioni](https://getcomposer.org/doc/articles/versions.md) per ulteriori dettagli
+
+# Per vedere quali pacchetti sono installabili e quali sono gia' stati installati
+composer show
+
+# Per vedere solo quali pacchetti sono gia' stati installati
+composer show --installed
+
+# Per trovare una dipendenza con 'mailgun' nel suo nome o nella descrizione.
+composer search mailgun
+```
+
+[Packagist.org](https://packagist.org/) è il repository principale per i pacchetti
+di Composer.  Cerca qui pacchetti di terze-parti utili per il tuo progetto.
+
+## `composer.json` vs `composer.lock`
+
+Il file `composer.json` memorizza la versione che si preferisce per ogni dipendenza,
+insieme ad altre informazioni.
+
+Il file `composer.lock` memorizza quale versione è stata scaricata per ogni
+dipendenza. Non editare mai questo file.
+
+Se includi il file `composer.lock` nella tua repository git, ogni sviluppatore
+andra' a installare la versione attualmente utilizzata dal tuo progetto per
+ogni dipendenza. Anche quando una nuova versione è stata rilasciata, Composer 
+andra' a installare la versione registrata nel file lock.
+
+```sh
+# Se vuoi aggiornare tutte le dipendenze all'ultima versione che corrisponde al pattern descritto
+composer update
+
+# Se vuoi scaricare l'ultima versione di una particolare dipendenza:
+composer update phpunit/phpunit
+
+# Se vuoi cambiare la versione di una una dipendenza, potresti dover rimuovere
+# quello attualmente selezionato, per poi richiedere quello corretto successivamente,
+# attraverso i seguenti comandi:
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+
+```
+
+## Autoloader
+
+Composer crea una classe autoloader che puoi richiamare nella tua applicazione.
+Puoi creare instanze delle classi tramite il loro namespace.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### PSR-4 Autoloader
+
+Puoi aggiungere i tuoi namespace all'autoloader.
+
+Nel file `composer.json`, aggiungi il campo "autoload":
+
+```json
+{
+  "autoload": {
+    "psr-4": {"Acme\\": "src/"}
+  }
+}
+```
+Questo dira' all'autoloader di controllare ogni risorsa che corrisponde al 
+namespace `\Acme\` all'interno della cartella `src`.
+
+In alternativa puoi usare [PSR-0, una Classmap o una lista di file da includere](https://getcomposer.org/doc/04-schema.md#autoload).
+Inoltre e' possibile anche utilizzare `autoload-dev` dedicato all'ambiente di sviluppo.
+
+Quando aggiungi o modifichi una chiave, dovrai ricompilare l'autoload attraverso:
+
+```sh
+composer dump-autoload
+composer dump # alias
+
+# Ottimizza i pacchetti PSR0 e PSR4 per essere caricati anche con le classmap.
+# Sara' lento, ma migliorera' le performance in produzione.
+composer dump-autoload --optimize --no-dev
+```
+
+# La cache di Composer
+
+```sh
+# Composer utilizzera i pacchetti scaricati anche per i progetti futuri. Per evitare che accada:
+composer clear-cache
+```
+
+# Problemi? 
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Argomenti che non sono stati (ancora) discussi in questo tutorial
+
+* Creare e distribuire pacchetti personali su Packagist.org o altrove
+* Pre- e post- script hooks: eseguire operazioni quando vengono eseguiti degli eventi
+
+### References
+
+* [Composer - Dependency Manager for PHP](https://getcomposer.org/)
+* [Packagist.org](https://packagist.org/)
diff --git a/it-it/pyqt-it.html.markdown b/it-it/pyqt-it.html.markdown
index 7238dd7b..7b5a98c2 100644
--- a/it-it/pyqt-it.html.markdown
+++ b/it-it/pyqt-it.html.markdown
@@ -14,12 +14,12 @@ lang: it-it
 
 Questo è un adattamento sull'introduzione di C ++ a QT di [Aleksey Kholovchuk] (https://github.com/vortexxx192
 ), alcuni degli esempi di codice dovrebbero avere la stessa funzionalità
-che avrebbero se fossero fatte usando pyqt! 
+che avrebbero se fossero fatte usando pyqt!
 
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
 	# Crea un oggetto applicazione
     app = QtGui.QApplication(sys.argv)
@@ -47,7 +47,7 @@ if __name__ == '__main__':
 Per ottenere alcune delle funzionalità più avanzate in **pyqt**, dobbiamo iniziare a cercare di creare elementi aggiuntivi.
 Qui mostriamo come creare una finestra popup di dialogo, utile per chiedere all'utente di confermare una decisione o fornire informazioni
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -66,7 +66,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Questa funzione dovrebbe creare una finestra di dialogo con un pulsante
 # che aspetta di essere cliccato e quindi esce dal programma
 def showdialog():
diff --git a/it-it/qt-it.html.markdown b/it-it/qt-it.html.markdown
index d7469f67..ef829493 100644
--- a/it-it/qt-it.html.markdown
+++ b/it-it/qt-it.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: Qt Framework
-language: c++
+language: C++
 filename: learnqt-it.cpp
 contributors:
     - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
diff --git a/it-it/rst-it.html.markdown b/it-it/rst-it.html.markdown
index a834e899..3885cbd8 100644
--- a/it-it/rst-it.html.markdown
+++ b/it-it/rst-it.html.markdown
@@ -81,11 +81,11 @@ Anche le tabelle più complesse possono essere inserite facilmente (colonne e/o
 
 Esistono diversi modi per creare collegamenti:
 
-- Aggiungendo un underscore dopo una parola: Github_ e aggiungendo l'URL di destinazione dopo il testo (questo metodo ha il vantaggio di non inserire URL non necessari all'interno del testo leggibile).
+- Aggiungendo un underscore dopo una parola: GitHub_ e aggiungendo l'URL di destinazione dopo il testo (questo metodo ha il vantaggio di non inserire URL non necessari all'interno del testo leggibile).
 - Digitando un URL completo: https://github.com/ (verrà automaticamente convertito in un collegamento)
-- Utilizzando una sintassi simile a Markdown: `Github <https://github.com/>`_ .
+- Utilizzando una sintassi simile a Markdown: `GitHub <https://github.com/>`_ .
 
-.. _Github https://github.com/
+.. _GitHub https://github.com/
 
 ```
 
diff --git a/it-it/ruby-it.html.markdown b/it-it/ruby-it.html.markdown
index 295bf28a..1f466cce 100644
--- a/it-it/ruby-it.html.markdown
+++ b/it-it/ruby-it.html.markdown
@@ -650,4 +650,4 @@ Something.new.qux #=> 'qux'
 - [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/) - Una passata [edizione libera](http://ruby-doc.com/docs/ProgrammingRuby/) è disponibile online.
 - [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
-- [Try Ruby](http://tryruby.org) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
+- [Try Ruby](https://try.ruby-lang.org/) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
diff --git a/it-it/rust-it.html.markdown b/it-it/rust-it.html.markdown
index e4b7c33f..acb8b8ba 100644
--- a/it-it/rust-it.html.markdown
+++ b/it-it/rust-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["Carlo Milanesi", "http://github.com/carlomilanesi"]
 lang: it-it
@@ -229,7 +229,7 @@ fn main() {
 
     // Ciclo/iterazione con `for`
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
new file mode 100644
index 00000000..be747e68
--- /dev/null
+++ b/it-it/solidity.html.markdown
@@ -0,0 +1,1069 @@
+---
+language: Solidity
+filename: learnSolidity-it.sol
+contributors:
+  - ["Nemil Dalal", "https://www.nemil.com"]
+  - ["Joseph Chow", ""]
+  - ["Bhoomtawath Plinsut", "https://github.com/varshard"]
+  - ["Shooter", "https://github.com/liushooter"]
+  - ["Patrick Collins", "https://gist.github.com/PatrickAlphaC"]
+translators:
+    - ["Al", "http://github.com/al-ias"]
+lang: it-it
+---
+
+Solidity permette di programmare su [Ethereum](https://www.ethereum.org/), una
+macchina virtuale basata sulla blockchain che consente la creazione e
+l'esecuzione degli smart contract senza che sia richiesta centralizzazione o
+fiducia negli attori coinvolti.
+
+Solidity è un linguaggio di programmazione di contratti tipizzato staticamente e
+ha molte cose in comune con Javascript e C. Come per gli oggetti nella
+programmazione ad oggetti, ogni contratto contiene variabili di stato, funzioni
+e tipi di dato semplici. Tra le funzionalità specifiche dei contratti troviamo
+le clausole (guardie) dei modifier, gli event notifier per i listener, e le
+variabili globali custom.
+
+Come esempi di contratti su Ethereum troviamo sistemi di crowdfunding, voto,
+[finanza decentralizzata](https://defipulse.com/) e aste al buio.
+
+Compiere errori nel codice Solidity può portare a rischi e costi alti, quindi
+bisogna fare attenzione a testare e rilasciare le modifiche lentamente. A
+CAUSA DEI CONTINUI CAMBIAMENTI DI ETHEREUM È IMPROBABILE CHE QUESTO DOCUMENTO
+RESTI AGGIORNATO, QUINDI COSNIGLIAMO DI SEGUIRE LA CHAT ROOM DI SOLIDITY E IL
+BLOG DI ETHEREUM PER TENERSI AGGIORNATI. TUTTO IL CODICE QUI PRESENTE E' FORNITO
+COSÌ COM'È, CON ANNESSI RISCHI SOSTANZIALI DI ERRORI O PATTERN DI PROGRAMMAZIONE
+DEPRECATI. 
+
+A differenza di altri linguaggi, potresti aver bisogno di usare pattern di
+pausing, deprecation e throttling usage per ridurre il rischio. Questo documento
+tratta principalmene la sintassi e quindi esclude molti design pattern in voga.
+
+Visto che Solidity e Ethereum sono in continuo sviluppo, le funzionalità
+sperimentali o beta sono evidenziate e soggette a cambiamenti. Ogni Pull Request
+è ben accetta.
+
+
+# Lavorare con Remix e Metamask
+
+Uno dei modi più semplici di scrivere, distribuire e testare il codice Solidity
+è usare :
+
+1. [L'ambiente di sviluppo online Remix](https://remix.ethereum.org/) 
+2. [Il wallet Metamask](https://metamask.io/).
+
+Per cominciare, [scarichiamo l'estesione per browser di Metamask](https://metamask.io/). 
+
+Una volta installata, potremo iniziare ad usare Remix. Il codice seguente è
+pre-inizializzato, ma prima di addentrarci, diamo un'occhiata a qualche
+trucchetto per iniziare ad usare Remix. Carica tutto il necessario [clickando su questo link](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=f490c0d51141dd0515244db40bbd0c17&runs=200).
+
+1. Scegli il compilatore per Solidity
+
+![Solidity-in-remix](../images/solidity/remix-solidity.png)
+
+2. Apri il file che si caricherà su quel link
+
+![Solidity-choose-file](../images/solidity/remix-choose-file.png)
+
+3. Compila il file
+
+![Solidity-compile](../images/solidity/remix-compile.png)
+
+4. Fai il deploy
+
+![Solidity-deploy](../images/solidity/remix-deploy.png)
+
+5. Smanetta con i contratti
+
+![Solidity-deploy](../images/solidity/remix-interact.png)
+
+Hai distribuito il tuo primo contratto! Congratulazioni!
+
+Potrai testarlo e smanettare con le funzioni già definite. Dai un'occhiata ai
+commenti per scoprire cosa fanno.
+
+
+## Lavorare su una testnet
+
+Distribuire e testare su una testnet è il modo più accurato per mettere alla
+prova i tuoi smart contract in Solidity. Per farlo procuriamoci prima degli ETH
+di test dalla testnet Kovan.
+
+[Entra in questo Gitter Channel](https://gitter.im/kovan-testnet/faucet) e
+scrivici l'indirizzo del tuo wallet Metamask.
+
+Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`.
+
+![Solidity-in-remix](../images/solidity/metamask-kovan.png)
+
+Riceverai degli Ethereum di test gratuiti. Abbiamo bisogno di Ethereum per
+distribuire degli smart contract su una testnet.
+
+Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito
+su un ambiente virtuale fittizio. Quando si lavora su una testnet, possiamo
+davvero monitorare e interagire con i nostri contratti in maniera persistente.
+
+Per distribuire su una testnet, allo step `#4 Fai il deploy`, cambia
+l'`environment` selezionato in `injected web3`. In questo modo verrà usato
+come network su cui fare il deploy qualsiasi network selezionato sul tuo
+Metamask.
+
+![Solidity-in-remix](../images/solidity/remix-testnet.png)
+
+Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di
+cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
+ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso
+di tempo, ti apparirà la stessa interfaccia per il contratto nella parte
+inferiore dello schermo.
+
+
+```javascript
+// Iniziamo con un semplice contratto su una Banca
+// Permette di depositare, prelevare e fare l'estratto conto
+
+// simple_bank.sol (nota l'estensione .sol)
+/* **** INIZIO DELL'ESEMPIO **** */
+
+// Dichiara la versione del compilatore per il file sorgente
+pragma solidity ^0.6.6;
+
+// Inizia con il commento Natspec (i tre slash)
+// viene usato per la documentazione - e per i dati descrittivi per gli elementi
+// dell'interfaccia utente / azioni
+
+/// @title SimpleBank
+/// @author nemild
+
+/* 'contract' somiglia a 'class' in altri linguaggi (ha variabili di classe,
+ereditarietà, etc.) */
+contract SimpleBank { // CapWords
+    // Dichiariamo le variabili di stato fuori dalle funzioni, persisteranno
+    // durante tutta la vita del contratto
+
+    // i dizionari mappano gli indirizzi con i saldi
+    // fai sempre attenzione agli overflow attack che sfruttano i numeri
+    mapping (address => uint) private balances;
+
+    // "private" significa che che altri contratti non possono leggere i
+    // saldi ma le informazioni restano visibili ad altri attori sulla blockchain
+
+    address public owner;
+    // 'public' lo rende leggibile dall'esterno (ma non modificabile) dagli
+    // utenti e dai contratti
+
+    // Gli 'event' pubblicano le azioni in modo che siano ascoltabili da
+    // listener esterni
+    event LogDepositMade(address accountAddress, uint amount);
+
+    // I 'constructor' possono ricevere uno o più parametri; Si può
+    // dichiarare un solo costruttore
+    constructor() public {
+        // 'msg' fornisce i dettagli sul messaggio che è stato mandato al contratto
+        // 'msg.sender' è chi invoca il contratto (l'indirizzo di chi lo crea)
+        owner = msg.sender;
+    }
+
+    /// @notice Deposita ether nella banca
+    /// @return Il saldo dell'utente dopo che è stato effettualto il deposito
+    function deposit() public payable returns (uint) {
+        // Usiamo 'require' per testare gli input dell'utente, 'assert' per gli
+        // invarianti interni. Qui ci assicuriamo di non avere a che fare con
+        // un overflow
+        require((balances[msg.sender] + msg.value) >= balances[msg.sender]);
+
+        balances[msg.sender] += msg.value;
+        // Non servono "this." o "self." con le variabili di stato
+        // Tutti i valori iniziali delle variabili sono impostati automaticamente
+        // al valore di default per quel tipo di dato
+
+        emit LogDepositMade(msg.sender, msg.value); // Fa scattare l'evento
+
+        return balances[msg.sender];
+    }
+
+    /// @notice Preleva ether dalla banca
+    /// @dev Non restituisce gli ether inviati in eccesso
+    /// @param withdrawAmount L'importo che si vuole ritirare
+    /// @return remainingBal
+    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
+        require(withdrawAmount <= balances[msg.sender]);
+
+        // Notiamo come per prima cosa scaliamo i soldi dal saldo, prima di
+        // invarli. Ogni .transfer/.send in questo contratto può chiamare una 
+        // funzione esterna. Questa cosa potrebbe permettere a chi invoca la
+        // funzione di richiedere un importo maggiore del suo saldo usando
+        // una chiamata ricorsiva. Miriamo ad aggiornare lo stato prima che sia
+        // chiamata una funzione esterna, incluse .transfer/.send
+        balances[msg.sender] -= withdrawAmount;
+
+        // Qui lancia automaticamente un errore se fallisce, il che implica
+        // che il saldo (non più aggiornato) viene ripristinato a prima della
+        // transazione
+        msg.sender.transfer(withdrawAmount);
+
+        return balances[msg.sender];
+    }
+
+    /// @notice Recupera il saldo
+    /// @return Il saldo dell'utente
+    // 'view' (ex: constant) impedisce alle funzioni di modificare lo stato
+    // delle variabili; consente alle le funzioni di essere disponibili in
+    // locale/fuori dalla blockchain
+    function balance() view public returns (uint) {
+        return balances[msg.sender];
+    }
+}
+// ** FINE DELL'ESEMPIO **
+
+
+// Passiamo alle basi di Solidity
+
+// 1. TIPI DI DATO E I LORO METODI
+// uint viene usato per gli importi in valuta (non ci sono double o float)
+// e per le date (in unix time)
+uint x;
+
+// int di 256 bit, non possono essere modificati dopo l'istanziazione
+int constant a = 8;
+int256 constant a = 8; // stesso effetto della riga prima, qui viene
+// dichiarato esplicitamente che è di 256 bit
+uint constant VERSION_ID = 0x123A1; // Una costante esadecimale
+// con 'constant', il compilatore rimpiazza ogni occorrenza con il valore
+
+// Tutte le variabili di stato (quelle fuori da una funzione)
+// sono 'interne' di default e accessibili SOLO dall'interno del contratto 
+// e da tutti contratti che le ereditano
+// Bisogna usare esplicitamente 'public' per consentire l'accesso dai contratti 
+// esterni
+int256 public a = 8;
+
+// Per int e uint possiamo esplicitamente assegnare una dimensione tra 8 e 256
+// es. int8, int16, int24
+uint8 b;
+int64 c;
+uint248 e;
+
+// Attenzione a non andare in overflow e a proteggersi dagli attacchi che lo fanno
+// Ad esempio per quanto rigrada l'addizione, conviene fare:
+uint256 c = a + b;
+assert(c >= a); // 'assert' testa gli invarianti interni; require viene usato 
+// per gli input
+// Per altri esempi di problemi comuni con le operazioni aritmentiche, dai una
+// occhiata alla Zeppelin's SafeMath library
+// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
+
+
+// Non ci sono funzioni random built-in, puoi ottenere un numero pseudo-casuale
+// hashando l'ultimo blockhash, o ottenere un numero realmente casuale usando
+// qualcosa come Chainlink VRF. 
+// https://docs.chain.link/docs/get-a-random-number
+
+// Conversione di tipo
+int x = int(b);
+
+bool b = true; // oppure 'var b = true;' per l'inferenza di tipo
+
+// Indirizzi - contengono indirizzi Ethereum di 20 byte/160 bit
+// Non sono consentite operazioni aritmetiche
+address public owner;
+
+// Tipi di account:
+// Contract account: l'indirizzo viene impostato quando lo si crea (funzione con
+// l'indirzzo di chi lo crea, il numero della transazione inviata)
+// External Account: (persona/enitità esterna): l'indirizzo viene creato dalla
+// chiave pubblica
+
+// Aggiungi il campo 'public' per indicare che è pubblico/accessibile dall'esterno
+// un getter viene creato automaticamente, ma NON un setter
+
+// Si possono mandare ether a tutti gli indirizzi
+owner.transfer(SOME_BALANCE); // fallisce e, in tal caso, ripristina
+// lo stato precedente
+
+// Possiamo anche usare la funzione di livello più basso .send, che restituisce
+// false se fallisce
+if (owner.send) {} // RICORDA: metti la send in un 'if' dato che gli indirizzi
+// usati nei contratti hanno delle funzioni, che vengono eseguite quando viene
+// fatta una send, che possono fallire.
+// Inoltre fai attenzione a scalare i saldi PRIMA di provare a fare una send,
+// dato il rischio di chiamate riscorsive che potrebbero prosciugare il contratto
+
+// Possiamo controllare il saldo
+owner.balance; // il saldo del propietario (utente o contratto)
+
+
+// I Byte sono disposibili in dimensioni da 1 a 32
+byte a; // 'byte' è la stessa cosa di 'bytes1'
+bytes2 b;
+bytes32 c;
+
+// Byte con dimensione dinamica
+bytes m; // Un array particolare, la stessa cosa dell'array 'byte[]' (ma scritto stringato)
+// È più dispendioso di byte1-byte32, che di solito sono preferibili
+
+// come bytes, ma non permette di accedere alla lunghezza o all'indice (per ora)
+string n = "hello"; // salvato in UTF8, nota i doppi apici, non singoli
+// le utility function per le stringhe saranno aggiunte in futuro
+// sono preferibili bytes32/bytes, dato che UTF8 occupa più memoria
+
+// Inferenza di tipo
+// 'var' fa inferenza di tipo a seconda del primo assegnamento,
+// non può essere usata tra i parametri di una funzione
+var a = true;
+// da usare con cautela, può inferire un tipo errato
+// es. un int8 quando un contatore dev'essere un int16
+
+// var può essere usata per assegnare una funzione ad una variabile
+function a(uint x) returns (uint) {
+    return x * 2;
+}
+var f = a;
+f(22); // chiamata
+
+// di default, tutte le variabili sono impostate a 0 durante l'istanziazione
+
+
+// Delete può essere chiamato sulla maggior parte dei valori
+// (NON distrugge il valore, ma lo setta a 0, il valore did default)
+uint x = 5;
+
+
+// Destructuring/Tuple
+(x, y) = (2, 7); // assegna/scambia più valori
+
+
+// 2. STRUTTURE DATI
+// Array
+bytes32[5] nicknames; // array statico
+bytes32[] names; // array dinamico
+uint newLength = names.push("John"); // aggiungere un elemento restituisce
+// la nuova dimensione dell'array
+// Dimesione
+names.length; // ottenere la dimensione
+names.length = 1; // la dimensione può essere assegnata (solo per gli array nello storage)
+
+// array multidimensionali
+uint[][5] x; // array con 5 array dinamici (ordine opposto rispetto ad
+// altri linguaggi)
+
+// Dizionari (da un tipo qualsiasi a un tipo qualsiasi)
+mapping (string => uint) public balances;
+balances["charles"] = 1;
+// il risultato balances["ada"] è 0, tutte le chiavi non settate 
+// restituiscono zero
+// 'public' permette che si possa fare questo da un altro contratto:
+contractName.balances("charles"); // restituisce 1
+// 'public' ha creato getter (ma non un setter), come il seguente:
+function balances(string _account) returns (uint balance) {
+    return balances[_account];
+}
+
+//  Mapping annidati
+mapping (address => mapping (address => uint)) public custodians;
+
+// Fare una delete
+delete balances["John"];
+delete balances; // assegna 0 a tutti gli elementi
+
+// Diversamente da altri linguaggi NON si può iterare tra gli elementi di un
+// mapping senza conoscere le chiavi - ma si può costruire una struttura dati a monte
+// che lo faccia
+
+// Strutture dati
+struct Bank {
+    address owner;
+    uint balance;
+}
+Bank b = Bank({
+    owner: msg.sender,
+    balance: 5
+});
+// oppure
+Bank c = Bank(msg.sender, 5);
+
+c.balance = 5; // imposta ad un nuovo valore
+delete b;
+// reimposta, imposta tutte le variabili della struttura a 0, tranne i mapping
+
+// Enumerazioni
+enum State { Created, Locked, Inactive }; // di solito si usano per gli automi a stati finiti
+State public state; // Dichiara una variabile da un enum
+state = State.Created;
+// Le enum possono essere convertite esplicitamente in int
+uint createdState = uint(State.Created); //  0
+
+// Data location: Memory vs. storage vs. calldata - tutti i tipi complessi
+// (array, struct) hanno una data location
+// 'memory' non è persistente, 'storage' sì
+// Il default è 'storage' per varibili locali e di stato; 
+// 'memory' per i parametri delle funzioni
+// Lo stack può contenere poche varaibili locali
+
+// Per la maggior parte dei tipi, si può impostare esplicitamente
+// quale data location usare
+
+
+// 3. Operatori semplici
+// Ci sono operatori logici, a bit e aritmetici
+// Potenza: **
+// Or esclusivo: ^
+// Negazione bitwise: ~
+
+
+// 4. Variabili globali degne di nota
+// ** this **
+this; // indirizzo del contratto
+// di solito si usa per trasferire altrove il saldo rimanente 
+// al termine della vita del contratto 
+this.balance;
+this.someFunction(); // invoca una funzione esterna tramite chiamata,
+// non attraverso un salto interno
+
+// ** msg - Il messaggio corrente ricevuto dal contratto **
+msg.sender; // indirizzo di chi ha inviato msg
+msg.value; // l'importo di ether forniti a questo contratto espresso in "wei",
+// la funzione dovrebbe essere marcata come "payable"
+msg.data; // in bytes, tutti gli argomenti del messaggio
+msg.gas; // 'gas' restante
+
+// ** tx - Questa transazione **
+tx.origin; // l'indirizzo di chi ha avviato questa transazione
+tx.gasprice; // il prezzo del "gas" per la transazione
+
+// ** block - Informazioni sul blocco attuale **
+now; // ora corrente (approssimatamente), alias di block.timestamp (in Unix time)
+// Da notare come può essere manipolata dai miner, quindi da usare con cautela
+
+block.number; // numero del blocco attuale
+block.difficulty; // difficulty del blocco attuale
+block.blockhash(1); // restituisce un bytes32, funziona solo per i 256 blocchi
+// più recenti
+block.gasLimit();
+
+// ** storage - Memoria persistente (in hash) **
+storage['abc'] = 'def'; // mappa da parole di 256 bit a parole di 256 bit
+
+
+// 4. FUNZIONI E ALTRO
+// A. Funzioni
+// Una semplice funzione
+function increment(uint x) returns (uint) {
+    x += 1;
+    return x;
+}
+
+// Le funzioni possono restituire molti valori,
+// e visto che i valori di ritorno vengono dichiarati prima
+// non è richiesta un'instruzione return esplicita
+function increment(uint x, uint y) returns (uint x, uint y) {
+    x += 1;
+    y += 1;
+}
+// Chiama la funzione di cui sopra
+uint (a,b) = increment(1,1);
+
+// 'view' (un alias di 'constant')
+// indica che la funzione non cambia / non può cambiare le variabili persistenti
+// Le funzioni definite con view vengono eseguite localmente, non sulla blockchain
+// N.B. la keyword constant sarà presto deprecata
+uint y = 1;
+
+function increment(uint x) view returns (uint x) {
+    x += 1;
+    y += 1; // questa riga fallirebbe
+    // y è una variabile di stato, e non può essere cambiata in una funzione di view
+}
+
+// 'pure' è più restrittivo di 'view' o 'constant', e non
+// permette nemmeno di leggere le varaibili di stato
+// In realtà è più complicato, per approfondire su
+// view/pure:
+// http://solidity.readthedocs.io/en/develop/contracts.html#view-functions
+
+// Modificatori di visibilità per le funzioni
+// Possono essere messi vicino a 'view' e includono:
+// public - visibile esternamente e internamente (di default per function)
+// external - visible solo esternamente (comprese le chiamate fatte con this.)
+// private - visibile solo dal contratto attuale
+// internal - visibile solo dal contratto attuale, e da quelli che ne derivano
+
+// Di solito è una buona idea marcare esplicitamente ogni funzione
+
+// Le funzioni sono hoisted e si può assegnare una funzione ad una variabile
+function a() {
+    var z = b;
+    b();
+}
+
+function b() {
+
+}
+
+// Tutte le funzioni che ricevono ether devono essere dichiarate come 'payable'
+function depositEther() public payable {
+    balances[msg.sender] += msg.value;
+}
+
+
+// I cicli sono da preferire alla ricorsione
+// (la profondità massima dello stack è 1024)
+// Inoltre, non impostare dei loop senza limiti,
+// perchè potresti raggiungere il limite per il gas
+
+// B. Eventi
+// Gli eventi notificano a terze parti; è facile ispezionare e
+// accedere agli eventi al di fuori della blockchain (con client leggeri);
+// Tipicamente si dichiarano dopo i parametri del contratto
+
+// Tipicamente, sono capitalized - si usa Log come prefisso per esplicitarli
+// meglio ed evitare che si confondano con una chiamata a funzione
+
+// Dichiarazione
+event LogSent(address indexed from, address indexed to, uint amount); 
+// Da notare le prime lettere maiuscole
+
+// Chiamata
+LogSent(from, to, amount);
+
+/**
+
+Una terza parte esterna (entità o contratto), può osservare usando
+la libreria Javascript Web3:
+
+// Quel che se segue è codice Javascript, non Solidity
+Coin.LogSent().watch({}, '', function(error, result) {
+    if (!error) {
+        console.log("Trasferimento valuta: " + result.args.amount +
+            " la valuta è stata mandata da " + result.args.from +
+            " a " + result.args.to + ".");
+        console.log("I saldi ora sono:\n" +
+            "Mittente: " + Coin.balances.call(result.args.from) +
+            "Destinatario: " + Coin.balances.call(result.args.to));
+    }
+}
+**/
+
+// È prassi che un contratto dipenda da un altro (es. che dipenda
+// dai tassi di cambio forniti da un altro contratto)
+
+// C. Modifier
+// I modifier validano gli input per conto dele funzioni verificando ad esempio
+// il saldo minimo o l'autenticazione dell'utente;
+// sono simili alle calusole di guardia di altri linguaggi
+
+// '_' (underscore) viene spesso posizionato nell'ultima riga del body, e indica
+// che la funzione chiamata dev'essere posizionata lì
+modifier onlyAfter(uint _time) { require (now >= _time); _; }
+modifier onlyOwner { require(msg.sender == owner) _; }
+// usate comunemente negli automi a stati finiti
+modifier onlyIfStateA (State currState) { require(currState == State.A) _; }
+
+// Si dichiarano appena dopo la definizione di una funzione
+function changeOwner(newOwner)
+onlyAfter(someTime)
+onlyOwner()
+onlyIfState(State.A)
+{
+    owner = newOwner;
+}
+
+// L'underscore può essere messo prima della fine del body,
+// ma un'istruzione di ritorno esplicita lo salterebbe,
+// quindi è da usare con cautela
+modifier checkValue(uint amount) {
+    _;
+    if (msg.value > amount) {
+        uint amountToRefund = amount - msg.value;
+        msg.sender.transfer(amountToRefund);
+    }
+}
+
+
+// 6. ISTRUZIONI CONDIZIONALI E CICLI
+
+// Troviamo tutte le istruzioni condizionali di base - incluse if/else, for,
+// while, break, continue e return - ma non c'è lo switch
+
+// La sintassi è la stessa di javascript, ma non esiste la conversione di tipo
+// in booleano dai non booleani (bisogna usare gli operatori logici per
+// ottenere il valore boolean)
+
+// Bisogna stare attenti i loop che iterano in base al comportamento
+// dell'utente, dato che i contratti hanno un tetto massimo di gas
+// per blocco di codice e falliranno se lo superano
+// Ad esempio:
+for(uint x = 0; x < refundAddressList.length; x++) {
+    refundAddressList[x].transfer(SOME_AMOUNT);
+}
+
+// Ci sono due errori nel codice precedente:
+// 1. Un fallimento su una transfer impedisce al loop di completare tutti
+// i cicli, bloccando dei soldi;
+// 2. Questo loop potrebbe essere arbitrariamente lungo (si basa sul numero
+// degli utenti che hanno diritto al rimborso), quindi potrebbe fallire sempre
+// se supera il tetto massimo di gas per blocco;
+// Come soluzione, si permette agli utenti di prelevare
+// individualmente dal loro subaccount e segnare il rimborso come riscosso
+// Ad es. preferire pull payments ai push payment
+
+
+// 7. OGGETTI/CONTRATTI
+
+// A. Invocare un contratto esterno
+contract InfoFeed {
+    function info() payable returns (uint ret)  { return 42; }
+}
+
+contract Consumer {
+    InfoFeed feed; // punta ad un contratto sulla blockchain
+
+    // Imposta il feed sull'istanza del contratto esistente
+    function setFeed(address addr) {
+        // fare attenzione alla conversione di tipo automatica;
+        // il costruttore non viene invocato
+        feed = InfoFeed(addr);
+    }
+
+    // Imposta il feed ad una nuova istanza del contratto
+    function createNewFeed() {
+        feed = new InfoFeed(); // viene creata una nuova istanza;
+        // viene invocato il costruttore
+    }
+
+    function callFeed() {
+        // le parentesi finali invocano il contratto, opzionalmente si può
+        // specificare un importo custom di ether o di gas
+        feed.info.value(10).gas(800)();
+    }
+}
+
+// B. ereditarietà
+
+// Conta l'ordine, l'ultimo contratto ereditato (es. 'def') può andare
+// in overriding su parti dei contratti precedentemente ereditati
+contract MyContract is abc, def("a custom argument to def") {
+
+// Funzione in overriding
+    function z() {
+        if (msg.sender == owner) {
+            def.z(); // invoca la funzione overridden da def
+            super.z(); // chiama la funzione overridden del padre
+        }
+    }
+}
+
+// Funzioni astratte
+function someAbstractFunction(uint x);
+// non possono essere compilate, vengono usate nei contratti base/astratti
+// e poi verranno implementate
+
+// C. Import
+
+import "filename";
+import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
+
+
+// 8. ALTRE KEYWORD
+
+// A. Selfdestruct
+// autodistrugge il contratto corrente, inviando i fondi ad un indirizzo
+// (di solito il creatore)
+selfdestruct(SOME_ADDRESS);
+
+// rimuove il codice e quanto in memoria dal blocco corrente e da tutti i blocchi futuri
+// aiuta ad alleggerire i client, ma le informazioni precedenti continueranno
+// a persistere sulla blockchain
+
+// È un pattern comune, permette al proprietario di terminare il contratto
+// e ricevere i fondi rimasti
+function remove() {
+    if(msg.sender == creator) { // Solo il creatore del contratto può farlo
+        selfdestruct(creator); // Cessa l'attività del contratto, trasferisce i fondi
+    }
+}
+
+// Si potrebbe voler disattivare il contratto manualmente, anzichè usare una
+// selfdestruct (gli ether inviati ad un contratto dopo una selfdestruct
+// vengono persi)
+
+
+// 9. NOTE SUL DESIGN DEI CONTRATTI
+
+// A. Offruscamento
+// Tutte le variabili sono pubblicamente visibili sulla blockchain, quindi 
+// qualsiasi informazione privata ha bisogno di essere offruscata (es. hash con una
+// chiave segreta)
+
+// Passi: 1. Impegnarsi pagare una certa cifra, 2. Rivelare l'impegno preso
+keccak256("una_puntata_d_asta", "un segreto"); // impegno
+
+// in futuro, l'invocazione della funzione rivelatrice del contratto
+// mostrerà la puntata con il segreto che produce lo SHA3
+reveal(100, "ilMioSegreto");
+
+// B. Ottimizzazione della memoria (storage)
+// Scrivere dati sulla blockchain può essere costoso visto che vengono 
+// conservati per sempre; siamo incoraggati ad usare la memoria in maniera
+// scaltra (un giorno la compilazione migliorerà, ma per ora è vantaggioso
+// pianificare le strutture dati da usare - e conservarne il minimo possibile
+// sulla blockchain)
+
+// I costi per conservare cose come array multidimensionali sono spesso alti
+// (costa conservare dati - non dichiarare variabili parzialmente vuote)
+
+// C. Accesso ai dati sulla blockchain
+// Non si può impedire alle persone o ai computer di leggere il contenuto
+// o lo stato delle transazioni
+
+// Anche se 'private' non permette agli altri *contratti* di leggere alcune
+// informazioni direttamente, qualsiasi altro attore può leggerle
+// sulla blockchain
+
+// Tutti i dati, dall'inizio, vegono conservati sulla blockchain e
+// tutti possono accedere alle informazioni passate e ai cambiamenti futuri
+
+// D. Oracle e dati esterni
+// Gli oracle consentono di interagire con i tuoi smart contract
+// al di fuori della blockchain. 
+// Vengono usati per ricevere informazioni dal mondo reale, mandare
+// richieste post al mondo reale o vice versa.
+
+// Anche le implementazioni che sfruttano l'ora vengono fatte attraverso
+// gli oracle, visto che i contratti devono essere chiamati direttamente e
+// non possono fare una "subscribe" a un certo orario. 
+// Data la decentralizzazione degli smart contract, vorrai ricevere informazioni
+// in maniera decentralizzata, altrimenti rischi di ricreare l'accentramento
+// che la progettazione degli smart contract si prefigge di prevenire.
+
+// Il modo migliore di ottenere e usare dati decentralizzati già pronti
+// è attraverso i Chainlink Data Feeds
+// https://docs.chain.link/docs/get-the-latest-price
+// Possiamo fare riferimento a certe informazioni della blockchain
+// che sono già state aggregate da più fonti e ridistribuite on-chain,
+// usandole come "banche dati" di fonti di informazione. 
+
+// Puoi vedere altri esempi che effettuano chiamate alle API qui:
+// https://docs.chain.link/docs/make-a-http-get-request
+
+// E ovviamente puoi costruire la tua rete di orace, ma assicurati di sapere
+// quant'è accentrata o decentralizzata la tua applicazione. 
+
+// Mettere su una rete di oracle per conto tuo
+
+// E. Cron Job
+// I contratti devono essere chiamati manualmente per gestire lo scheduling
+// in base all'orario; si può creare un codice esterno che li pinghi reglarmente
+//  oppure fornire degli incentivi (ether) a qualcun'altro che lo faccia
+
+// F. Pattern Observer
+// Un pattern observer permette di iscriversi come osservatore e
+// registrare una funzione che verrà chiamata dall'oracle
+// (N.B. l'oracolo paga perchè sia eseguita quest'azione)
+// Ci sono alcune somoglianze nella registrazione con Pub/sub
+
+// Questo è un contratto astratto che importano sia il client che il server
+// Il client dovrebbe implementarlo
+contract SomeOracleCallback {
+    function oracleCallback(int _value, uint _time, bytes32 info) external;
+}
+
+contract SomeOracle {
+    SomeOracleCallback[] callbacks; // array di tutti gli osservatori iscritti
+
+    // Osservatori iscritti
+    function addSubscriber(SomeOracleCallback a) {
+        callbacks.push(a);
+    }
+
+    function notify(value, time, info) private {
+        for(uint i = 0;i < callbacks.length; i++) {
+            // tutti gli osservatori iscritti dovranno implementare la oracleCallback
+            callbacks[i].oracleCallback(value, time, info);
+        }
+    }
+
+    function doSomething() public {
+        // Codice che fa qualcosa
+
+        // Notifica a tutti gli iscritti
+        notify(_value, _time, _info);
+    }
+}
+
+// Il contratto client può aggiungersi agli iscritti (con addSubscriber) 
+// del contratto SomeOracle, importando SomeOracleCallback
+
+// G. Automi a stati finiti
+// vedi l'esempio sotto che usa enum per lo stato e il modifier inState
+```
+
+Prova l'esempio completo qui sotto [usando remix e la `Javascript VM`](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=3d12cd503dcedfcdd715ef61f786be0b&runs=200)
+
+```javascript
+// *** ESEMPIO: Un esempio di crowdfunding (molto simile a Kickstarter) ***
+// ** START EXAMPLE **
+
+// CrowdFunder.sol
+pragma solidity ^0.6.6;
+
+/// @title CrowdFunder
+/// @author nemild
+contract CrowdFunder {
+    // Variabili impostate alla creazione dal creatore
+    address public creator;
+    address payable public fundRecipient; // il creatore può essere diverso
+    // da chi riceve i fondi, che dev'essere payable
+    uint public minimumToRaise; // è richiesto per chiedere il finanziamento,
+    // altrimenti tutti ricevono un rimborso
+    string campaignUrl;
+    byte version = "1";
+
+    // Strutture dati
+    enum State {
+        Fundraising,
+        ExpiredRefund,
+        Successful
+    }
+    struct Contribution {
+        uint amount;
+        address payable contributor;
+    }
+
+    // Variabili di stato
+    State public state = State.Fundraising; // inizializzato alla creazione
+    uint public totalRaised;
+    uint public raiseBy;
+    uint public completeAt;
+    Contribution[] contributions;
+
+    event LogFundingReceived(address addr, uint amount, uint currentTotal);
+    event LogWinnerPaid(address winnerAddress);
+
+    modifier inState(State _state) {
+        require(state == _state);
+        _;
+    }
+
+    modifier isCreator() {
+        require(msg.sender == creator);
+        _;
+    }
+
+    // Aspetta 24 settimane dopo l'ultimo cambio di stato prima di consentire
+    // che in contratto venga distrutto
+    modifier atEndOfLifecycle() {
+    require(((state == State.ExpiredRefund || state == State.Successful) &&
+        completeAt + 24 weeks < now));
+        _;
+    }
+
+    function crowdFund(
+        uint timeInHoursForFundraising,
+        string memory _campaignUrl,
+        address payable _fundRecipient,
+        uint _minimumToRaise)
+        public
+    {
+        creator = msg.sender;
+        fundRecipient = _fundRecipient;
+        campaignUrl = _campaignUrl;
+        minimumToRaise = _minimumToRaise;
+        raiseBy = now + (timeInHoursForFundraising * 1 hours);
+    }
+
+    function contribute()
+    public
+    payable
+    inState(State.Fundraising)
+    returns(uint256 id)
+    {
+        contributions.push(
+            Contribution({
+                amount: msg.value,
+                contributor: msg.sender
+            }) // usiamo un array per iterare
+        );
+        totalRaised += msg.value;
+
+        emit LogFundingReceived(msg.sender, msg.value, totalRaised);
+
+        checkIfFundingCompleteOrExpired();
+        return contributions.length - 1; // restituisce l'id
+    }
+
+    function checkIfFundingCompleteOrExpired()
+    public
+    {
+        if (totalRaised > minimumToRaise) {
+            state = State.Successful;
+            payOut();
+
+            // qui si può incentivare chi ha provocato il cambiamento di stato
+        } else if ( now > raiseBy )  {
+            state = State.ExpiredRefund; // ora i finanziatori possono avere
+            // il rimborso chiamando getRefund(id)
+        }
+        completeAt = now;
+    }
+
+    function payOut()
+    public
+    inState(State.Successful)
+    {
+        fundRecipient.transfer(address(this).balance);
+        LogWinnerPaid(fundRecipient);
+    }
+
+    function getRefund(uint256 id)
+    inState(State.ExpiredRefund)
+    public
+    returns(bool)
+    {
+        require(contributions.length > id && id >= 0 && contributions[id].amount != 0 );
+
+        uint256 amountToRefund = contributions[id].amount;
+        contributions[id].amount = 0;
+
+        contributions[id].contributor.transfer(amountToRefund);
+
+        return true;
+    }
+
+    function removeContract()
+    public
+    isCreator()
+    atEndOfLifecycle()
+    {
+        selfdestruct(msg.sender);
+        // il creatore riceve tutti i fondi che non sono stati riscossi
+    }
+}
+// ** END EXAMPLE **
+
+```
+
+Qualche altra funzionalità.
+
+```javascript
+// 10. ATRE FUNZIONALITA' NATIVE
+
+// Unità di valuta
+// La valuta viene definita partendo dai wei, l'unità più piccola di Ether
+uint minAmount = 1 wei;
+uint a = 1 finney; // 1 ether == 1000 finney
+// Per altre unità, vedi: http://ether.fund/tool/converter
+
+// Unità temporali
+1 == 1 second
+1 minutes == 60 seconds
+
+// Le unità temporali si possono moltiplicare, visto che non vegono salvate
+// nelle variabili
+uint x = 5;
+(x * 1 days); // 5 giorni
+
+// Attenzione ad usare l'operatore di uguaglianza con i secondi/anni bisestili
+// (sono da preferire maggiore/minore di)
+
+// Crittografia
+// Tutte le stringhe che vengono passate vengono concatenate prima di
+// calcolare l'hash
+sha3("ab", "cd");
+ripemd160("abc");
+sha256("def");
+
+
+// 11.SICUREZZA
+
+// I bug possono essere disastrosi per i contratti Ethereum e anche 
+// i pattern comuni di Solidity potrebbero riverlarsi degli antipattern
+
+// Dai un'occhiata ai link sulla sicurezza alla fine di questo documento
+
+
+// 12. FUNZIONI DI BASSO LIVELLO
+// call - è di basso livello, non viene usata spesso, perchè non è type safe
+successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');
+
+// callcode - Il codice all'indirizzo target viene eseguito *contestualmente*
+// alla chiamata del contratto
+// fornisce le stesse funzionalità di una libreria
+someContractAddress.callcode('function_name');
+
+
+// 13. NOTE SULLO STILE
+// Basate sulla guida allo stile PEP8 di Python
+// Guida completa allo stile: http://solidity.readthedocs.io/en/develop/style-guide.html
+
+// Riassunto veloce:
+// 4 spazi per l'indentazione
+// Due righe per separare la dichiarazione dei contratti
+// (e altre dichirazioni top level)
+// Evitare spazi ai lati interni delle parentesi tonde
+// Si possono omettere le parentesi graffe per statement monolinea (if, for, etc)
+// L'else dovrebbe essere posizionato su una riga a se
+
+// 14. COMMENTI NATSPEC
+// usati per la documentazione, commenti e UI esterne
+
+// Natspec dei contratti - sempre sopra la definizione del contratto
+/// @title Titolo del contratto
+/// @author Nome dell'autore
+
+// Natspec delle funzioni
+/// @notice informazioni su quel che fa la funzione; mostrate quando la funzione viene eseguita
+/// @dev Documentazione della funzione per sviluppatori
+
+// Natspec dei parametri/valori di ritorno delle funzioni
+/// @param someParam Una descrizione di quel che fa il parametro
+/// @return Descrizione del valore di ritorno
+```
+
+## Risorse Aggiuntive
+- [Documentazione di Solidity](https://solidity.readthedocs.org/en/latest/)
+- [Tutorial Chainlink per Principianti](https://docs.chain.link/docs/beginners-tutorial)
+- [Best Practice  per Smart Contract](https://github.com/ConsenSys/smart-contract-best-practices)
+- [Superblocks Lab - Ambiente di sviluppo su browser per Solidity](https://lab.superblocks.com/)
+- [EthFiddle - Il JsFiddle di Solidity](https://ethfiddle.com/)
+- [Solidity Editor su Browser](https://remix.ethereum.org/)
+- [Chat Room Gitter su Solidity](https://gitter.im/ethereum/solidity)
+- [Stategie di Progettazione Modulare per Contratti Ethereum](https://docs.erisindustries.com/tutorials/solidity/)
+- [Documentazione Chainlink](https://docs.chain.link/docs/getting-started)
+
+## Framework di Sviluppo per Smart Contract
+- [Hardhat](https://hardhat.org/)
+- [Brownie](https://github.com/eth-brownie/brownie)
+- [Truffle](https://www.trufflesuite.com/)
+
+## Librerie importanti
+- [Zeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts): Librerie che offrono pattern comuni (crowdfuding, safemath, ecc)
+- [Chainlink](https://github.com/smartcontractkit/chainlink): Codice che permette di interagire con dati esterni
+
+## Contratti di esempio
+- [Dapp Bin](https://github.com/ethereum/dapp-bin)
+- [Esempi Defi](https://github.com/PatrickAlphaC/chainlink_defi)
+- [Solidity per Contratti a Piccoli Passi](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts)
+- [Contratti ConsenSys](https://github.com/ConsenSys/dapp-store-contracts)
+- [Lo stato delle Dapp](http://dapps.ethercasts.com/)
+
+## Sicurezza
+- [Pensando Alla Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Blog Distribuito di Hacking](http://hackingdistributed.com/)
+
+## Stile
+- [Guida allo Stile di Solidity](http://solidity.readthedocs.io/en/latest/style-guide.html): La guida allo stile di Ethereum deriva in gran parte dalla guida allo stile [PEP 8](https://www.python.org/dev/peps/pep-0008/) di Python.
+
+## Editor
+- [Remix](https://remix.ethereum.org/)
+- [Emacs Modalità Solidity](https://github.com/ethereum/emacs-solidity)
+- [Vim Solidity](https://github.com/tomlion/vim-solidity)
+- Snippet per gli Editor ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
+
+## Cose da fare in futuro
+- Nuove keyword: protected, inheritable
+- Lista dei design pattern comuni (throttling, RNG, upgrade di versione)
+-Anti patterns comuni sulla sicurezza
+
+Sentiti libero di mandare una pull request con qualsiasi modifica - o scrivi una mail a nemild -/at-/ gmail
diff --git a/it-it/toml-it.html.markdown b/it-it/toml-it.html.markdown
index 99082048..beb63096 100644
--- a/it-it/toml-it.html.markdown
+++ b/it-it/toml-it.html.markdown
@@ -1,276 +1,276 @@
----

-language: toml

-filename: learntoml-it.toml

-contributors:

-  - ["Alois de Gouvello", "https://github.com/aloisdg"]

-translators:

-  - ["Christian Grasso", "https://grasso.io"]

-lang: it-it

----

-

-TOML è l'acronimo di _Tom's Obvious, Minimal Language_. È un linguaggio per la

-serializzazione di dati, progettato per i file di configurazione.

-

-È un'alternativa a linguaggi come YAML e JSON, che punta ad essere più leggibile

-per le persone. Allo stesso tempo, TOML può essere utilizzato in modo abbastanza

-semplice nella maggior parte dei linguaggi di programmazione, in quanto è

-progettato per essere tradotto senza ambiguità in una hash table.

-

-Tieni presente che TOML è ancora in fase di sviluppo, e la sua specifica non è

-ancora stabile. Questo documento utilizza TOML 0.4.0.

-

-```toml

-# I commenti in TOML sono fatti così.

-

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

-# TIPI SCALARI #

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

-

-# Il nostro oggetto root (corrispondente all'intero documento) sarà una mappa,

-# anche chiamata dizionario, hash o oggetto in altri linguaggi.

-

-# La key, il simbolo di uguale e il valore devono trovarsi sulla stessa riga,

-# eccetto per alcuni tipi di valori.

-key = "value"

-stringa = "ciao"

-numero = 42

-float = 3.14

-boolean = true

-data = 1979-05-27T07:32:00-08:00

-notazScientifica = 1e+12

-"puoi utilizzare le virgolette per la key" = true # Puoi usare " oppure '

-"la key può contenere" = "lettere, numeri, underscore e trattini"

-

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

-# Stringhe #

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

-

-# Le stringhe possono contenere solo caratteri UTF-8 validi.

-# Possiamo effettuare l'escape dei caratteri, e alcuni hanno delle sequenze

-# di escape compatte. Ad esempio, \t corrisponde al TAB.

-stringaSemplice = "Racchiusa tra virgolette. \"Usa il backslash per l'escape\"."

-

-stringaMultiriga = """

-Racchiusa da tre virgolette doppie all'inizio e

-alla fine - consente di andare a capo."""

-

-stringaLiteral = 'Virgolette singole. Non consente di effettuare escape.'

-

-stringaMultirigaLiteral = '''

-Racchiusa da tre virgolette singole all'inizio e

-alla fine - consente di andare a capo.

-Anche in questo caso non si può fare escape.

-Il primo ritorno a capo viene eliminato.

-   Tutti gli altri spazi aggiuntivi

-   vengono mantenuti.

-'''

-

-# Per i dati binari è consigliabile utilizzare Base64 e

-# gestirli manualmente dall'applicazione.

-

-##########

-# Interi #

-##########

-

-## Gli interi possono avere o meno un segno (+, -).

-## Non si possono inserire zero superflui all'inizio.

-## Non è possibile inoltre utilizzare valori numerici

-## non rappresentabili con una sequenza di cifre.

-int1 = +42

-int2 = 0

-int3 = -21

-

-## Puoi utilizzare gli underscore per migliorare la leggibilità.

-## Fai attenzione a non inserirne due di seguito.

-int4 = 5_349_221

-int5 = 1_2_3_4_5     # VALIDO, ma da evitare

-

-#########

-# Float #

-#########

-

-# I float permettono di rappresentare numeri decimali.

-flt1 = 3.1415

-flt2 = -5e6

-flt3 = 6.626E-34

-

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

-# Boolean #

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

-

-# I valori boolean (true/false) devono essere scritti in minuscolo.

-bool1 = true

-bool2 = false

-

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

-# Data/ora #

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

-

-data1 = 1979-05-27T07:32:00Z # Specifica RFC 3339/ISO 8601 (UTC)

-data2 = 1979-05-26T15:32:00+08:00 # RFC 3339/ISO 8601 con offset

-

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

-# TIPI DI COLLECTION #

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

-

-#########

-# Array #

-#########

-

-array1 = [ 1, 2, 3 ]

-array2 = [ "Le", "virgole", "sono", "delimitatori" ]

-array3 = [ "Non", "unire", "tipi", "diversi" ]

-array4 = [ "tutte", 'le stringhe', """hanno lo stesso""", '''tipo''' ]

-array5 = [

-  "Gli spazi vuoti", "sono", "ignorati"

-]

-

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

-# Tabelle #

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

-

-# Le tabelle (o hash table o dizionari) sono collection di coppie key/value.

-# Iniziano con un nome tra parentesi quadre su una linea separata. 

-# Le tabelle vuote (senza alcun valore) sono valide.

-[tabella]

-

-# Tutti i valori che si trovano sotto il nome della tabella

-# appartengono alla tabella stessa (finchè non ne viene creata un'altra).

-# L'ordine di questi valori non è garantito.

-[tabella-1]

-key1 = "una stringa"

-key2 = 123

-

-[tabella-2]

-key1 = "un'altra stringa"

-key2 = 456

-

-# Utilizzando i punti è possibile creare delle sottotabelle.

-# Ogni parte suddivisa dai punti segue le regole delle key per il nome.

-[tabella-3."sotto.tabella"]

-key1 = "prova"

-

-# Ecco l'equivalente JSON della tabella precedente:

-# { "tabella-3": { "sotto.tabella": { "key1": "prova" } } }

-

-# Gli spazi non vengono considerati, ma è consigliabile

-# evitare di usare spazi superflui.

-[a.b.c]            # consigliato

-[ d.e.f ]          # identico a [d.e.f]

-

-# Non c'è bisogno di creare le tabelle superiori per creare una sottotabella.

-# [x] queste

-# [x.y] non

-# [x.y.z] servono

-[x.y.z.w] # per creare questa tabella

-

-# Se non è stata già creata prima, puoi anche creare

-# una tabella superiore più avanti.

-[a.b]

-c = 1

-

-[a]

-d = 2

-

-# Non puoi definire una key o una tabella più di una volta.

-

-# ERRORE

-[a]

-b = 1

-

-[a]

-c = 2

-

-# ERRORE

-[a]

-b = 1

-

-[a.b]

-c = 2

-

-# I nomi delle tabelle non possono essere vuoti.

-[]     # NON VALIDO

-[a.]   # NON VALIDO

-[a..b] # NON VALIDO

-[.b]   # NON VALIDO

-[.]    # NON VALIDO

-

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

-# Tabelle inline #

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

-

-tabelleInline = { racchiuseData = "{ e }", rigaSingola = true }

-punto = { x = 1, y = 2 }

-

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

-# Array di tabelle #

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

-

-# Un array di tabelle può essere creato utilizzando due parentesi quadre.

-# Tutte le tabelle con questo nome saranno elementi dell'array.

-# Gli elementi vengono inseriti nell'ordine in cui si trovano.

-

-[[prodotti]]

-nome = "array di tabelle"

-sku = 738594937

-tabelleVuoteValide = true

-

-[[prodotti]]

-

-[[prodotti]]

-nome = "un altro item"

-sku = 284758393

-colore = "grigio"

-

-# Puoi anche creare array di tabelle nested. Le sottotabelle con doppie

-# parentesi quadre apparterranno alla tabella più vicina sopra di esse.

-

-[[frutta]]

-  nome = "mela"

-

-  [frutto.geometria]

-    forma = "sferica"

-    nota = "Sono una proprietà del frutto"

-

-  [[frutto.colore]]

-    nome = "rosso"

-    nota = "Sono un oggetto di un array dentro mela"

-

-  [[frutto.colore]]

-    nome = "verde"

-    nota = "Sono nello stesso array di rosso"

-

-[[frutta]]

-  nome = "banana"

-

-  [[frutto.colore]]

-    nome = "giallo"

-    nota = "Anche io sono un oggetto di un array, ma dentro banana"

-```

-

-Ecco l'equivalente JSON dell'ultima tabella:

-

-```json

-{

-  "frutta": [

-    {

-      "nome": "mela",

-      "geometria": { "forma": "sferica", "nota": "..."},

-      "colore": [

-        { "nome": "rosso", "nota": "..." },

-        { "nome": "verde", "nota": "..." }

-      ]

-    },

-    {

-      "nome": "banana",

-      "colore": [

-        { "nome": "giallo", "nota": "..." }

-      ]

-    }

-  ]

-}

-```

-

-### Altre risorse

-

-+ [Repository ufficiale di TOML](https://github.com/toml-lang/toml)

+---
+language: toml
+filename: learntoml-it.toml
+contributors:
+  - ["Alois de Gouvello", "https://github.com/aloisdg"]
+translators:
+  - ["Christian Grasso", "https://grasso.io"]
+lang: it-it
+---
+
+TOML è l'acronimo di _Tom's Obvious, Minimal Language_. È un linguaggio per la
+serializzazione di dati, progettato per i file di configurazione.
+
+È un'alternativa a linguaggi come YAML e JSON, che punta ad essere più leggibile
+per le persone. Allo stesso tempo, TOML può essere utilizzato in modo abbastanza
+semplice nella maggior parte dei linguaggi di programmazione, in quanto è
+progettato per essere tradotto senza ambiguità in una hash table.
+
+Tieni presente che TOML è ancora in fase di sviluppo, e la sua specifica non è
+ancora stabile. Questo documento utilizza TOML 0.4.0.
+
+```toml
+# I commenti in TOML sono fatti così.
+
+################
+# TIPI SCALARI #
+################
+
+# Il nostro oggetto root (corrispondente all'intero documento) sarà una mappa,
+# anche chiamata dizionario, hash o oggetto in altri linguaggi.
+
+# La key, il simbolo di uguale e il valore devono trovarsi sulla stessa riga,
+# eccetto per alcuni tipi di valori.
+key = "value"
+stringa = "ciao"
+numero = 42
+float = 3.14
+boolean = true
+data = 1979-05-27T07:32:00-08:00
+notazScientifica = 1e+12
+"puoi utilizzare le virgolette per la key" = true # Puoi usare " oppure '
+"la key può contenere" = "lettere, numeri, underscore e trattini"
+
+############
+# Stringhe #
+############
+
+# Le stringhe possono contenere solo caratteri UTF-8 validi.
+# Possiamo effettuare l'escape dei caratteri, e alcuni hanno delle sequenze
+# di escape compatte. Ad esempio, \t corrisponde al TAB.
+stringaSemplice = "Racchiusa tra virgolette. \"Usa il backslash per l'escape\"."
+
+stringaMultiriga = """
+Racchiusa da tre virgolette doppie all'inizio e
+alla fine - consente di andare a capo."""
+
+stringaLiteral = 'Virgolette singole. Non consente di effettuare escape.'
+
+stringaMultirigaLiteral = '''
+Racchiusa da tre virgolette singole all'inizio e
+alla fine - consente di andare a capo.
+Anche in questo caso non si può fare escape.
+Il primo ritorno a capo viene eliminato.
+   Tutti gli altri spazi aggiuntivi
+   vengono mantenuti.
+'''
+
+# Per i dati binari è consigliabile utilizzare Base64 e
+# gestirli manualmente dall'applicazione.
+
+##########
+# Interi #
+##########
+
+## Gli interi possono avere o meno un segno (+, -).
+## Non si possono inserire zero superflui all'inizio.
+## Non è possibile inoltre utilizzare valori numerici
+## non rappresentabili con una sequenza di cifre.
+int1 = +42
+int2 = 0
+int3 = -21
+
+## Puoi utilizzare gli underscore per migliorare la leggibilità.
+## Fai attenzione a non inserirne due di seguito.
+int4 = 5_349_221
+int5 = 1_2_3_4_5     # VALIDO, ma da evitare
+
+#########
+# Float #
+#########
+
+# I float permettono di rappresentare numeri decimali.
+flt1 = 3.1415
+flt2 = -5e6
+flt3 = 6.626E-34
+
+###########
+# Boolean #
+###########
+
+# I valori boolean (true/false) devono essere scritti in minuscolo.
+bool1 = true
+bool2 = false
+
+############
+# Data/ora #
+############
+
+data1 = 1979-05-27T07:32:00Z # Specifica RFC 3339/ISO 8601 (UTC)
+data2 = 1979-05-26T15:32:00+08:00 # RFC 3339/ISO 8601 con offset
+
+######################
+# TIPI DI COLLECTION #
+######################
+
+#########
+# Array #
+#########
+
+array1 = [ 1, 2, 3 ]
+array2 = [ "Le", "virgole", "sono", "delimitatori" ]
+array3 = [ "Non", "unire", "tipi", "diversi" ]
+array4 = [ "tutte", 'le stringhe', """hanno lo stesso""", '''tipo''' ]
+array5 = [
+  "Gli spazi vuoti", "sono", "ignorati"
+]
+
+###########
+# Tabelle #
+###########
+
+# Le tabelle (o hash table o dizionari) sono collection di coppie key/value.
+# Iniziano con un nome tra parentesi quadre su una linea separata. 
+# Le tabelle vuote (senza alcun valore) sono valide.
+[tabella]
+
+# Tutti i valori che si trovano sotto il nome della tabella
+# appartengono alla tabella stessa (finchè non ne viene creata un'altra).
+# L'ordine di questi valori non è garantito.
+[tabella-1]
+key1 = "una stringa"
+key2 = 123
+
+[tabella-2]
+key1 = "un'altra stringa"
+key2 = 456
+
+# Utilizzando i punti è possibile creare delle sottotabelle.
+# Ogni parte suddivisa dai punti segue le regole delle key per il nome.
+[tabella-3."sotto.tabella"]
+key1 = "prova"
+
+# Ecco l'equivalente JSON della tabella precedente:
+# { "tabella-3": { "sotto.tabella": { "key1": "prova" } } }
+
+# Gli spazi non vengono considerati, ma è consigliabile
+# evitare di usare spazi superflui.
+[a.b.c]            # consigliato
+[ d.e.f ]          # identico a [d.e.f]
+
+# Non c'è bisogno di creare le tabelle superiori per creare una sottotabella.
+# [x] queste
+# [x.y] non
+# [x.y.z] servono
+[x.y.z.w] # per creare questa tabella
+
+# Se non è stata già creata prima, puoi anche creare
+# una tabella superiore più avanti.
+[a.b]
+c = 1
+
+[a]
+d = 2
+
+# Non puoi definire una key o una tabella più di una volta.
+
+# ERRORE
+[a]
+b = 1
+
+[a]
+c = 2
+
+# ERRORE
+[a]
+b = 1
+
+[a.b]
+c = 2
+
+# I nomi delle tabelle non possono essere vuoti.
+[]     # NON VALIDO
+[a.]   # NON VALIDO
+[a..b] # NON VALIDO
+[.b]   # NON VALIDO
+[.]    # NON VALIDO
+
+##################
+# Tabelle inline #
+##################
+
+tabelleInline = { racchiuseData = "{ e }", rigaSingola = true }
+punto = { x = 1, y = 2 }
+
+####################
+# Array di tabelle #
+####################
+
+# Un array di tabelle può essere creato utilizzando due parentesi quadre.
+# Tutte le tabelle con questo nome saranno elementi dell'array.
+# Gli elementi vengono inseriti nell'ordine in cui si trovano.
+
+[[prodotti]]
+nome = "array di tabelle"
+sku = 738594937
+tabelleVuoteValide = true
+
+[[prodotti]]
+
+[[prodotti]]
+nome = "un altro item"
+sku = 284758393
+colore = "grigio"
+
+# Puoi anche creare array di tabelle nested. Le sottotabelle con doppie
+# parentesi quadre apparterranno alla tabella più vicina sopra di esse.
+
+[[frutta]]
+  nome = "mela"
+
+  [frutto.geometria]
+    forma = "sferica"
+    nota = "Sono una proprietà del frutto"
+
+  [[frutto.colore]]
+    nome = "rosso"
+    nota = "Sono un oggetto di un array dentro mela"
+
+  [[frutto.colore]]
+    nome = "verde"
+    nota = "Sono nello stesso array di rosso"
+
+[[frutta]]
+  nome = "banana"
+
+  [[frutto.colore]]
+    nome = "giallo"
+    nota = "Anche io sono un oggetto di un array, ma dentro banana"
+```
+
+Ecco l'equivalente JSON dell'ultima tabella:
+
+```json
+{
+  "frutta": [
+    {
+      "nome": "mela",
+      "geometria": { "forma": "sferica", "nota": "..."},
+      "colore": [
+        { "nome": "rosso", "nota": "..." },
+        { "nome": "verde", "nota": "..." }
+      ]
+    },
+    {
+      "nome": "banana",
+      "colore": [
+        { "nome": "giallo", "nota": "..." }
+      ]
+    }
+  ]
+}
+```
+
+### Altre risorse
+
++ [Repository ufficiale di TOML](https://github.com/toml-lang/toml)
diff --git a/ja-jp/asciidoc.html.markdown b/ja-jp/asciidoc.html.markdown
index 7347589a..af19850a 100644
--- a/ja-jp/asciidoc.html.markdown
+++ b/ja-jp/asciidoc.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
 translators:
     - ["Ryota Kayanuma", "https://github.com/PicoSushi"]
-filename: asciidoc-ja.md
+filename: asciidoc-ja.adoc
 lang: ja-jp
 ---
 
diff --git a/ja-jp/yaml-jp.html.markdown b/ja-jp/yaml-jp.html.markdown
new file mode 100644
index 00000000..28a5d870
--- /dev/null
+++ b/ja-jp/yaml-jp.html.markdown
@@ -0,0 +1,193 @@
+---
+language: yaml
+filename: learnyaml-jp.yaml
+contributors:
+- [Leigh Brenecki, 'https://leigh.net.au']
+- [Suhas SG, 'https://github.com/jargnar']
+translators:
+- [haru, 'https://haru52.com/']
+lang: ja-jp
+---
+
+YAML�データ�シリアライズ用言語��
+人間�直接読�書��や��よ��デザイン�れ����。
+
+YAML�JSON�厳格�スーパーセット��
+改行�インデント�構文的��味を�����Python�似�仕様を追加�����。
+���Python��異�りYAML��インデント�タブ文字を使��������ん。
+
+```yaml
+---  # ドキュメント開始
+
+# YAML�コメント��ん�感���。
+
+##############
+# スカラー型 #
+##############
+
+# （ドキュメント全体を�む）ルートオブジェクト�マップ��り��。
+# �れ�他言語���る辞書型��ッシュ�オブジェクト���等価��。
+キー: 値
+別�キー: 別�値。
+数値: 100
+指数表記: 1e+12
+# 1 �boolean���数値���解釈�れ��。
+# も�boolean���解釈�����場��trueを使���
+boolean: true
+null値: null
+スペースを �む キー: 値
+# 文字列をクォート�囲�必�������注�������。
+# ���囲���も����。
+���: 'クォート�囲�れ�文字列。'
+'キーもクォート�囲���。': "key�中� ':' を使������有用��。"
+シングルクォート: '�� ''1��'' エスケープパターン��り��'
+ダブルクォート: "��多��エスケープパターン��り��：\", \0, \t, \u263A,
+\x0d\x0a == \r\n, ���他�も�り��。"
+# UTF-8/16/32文字�エンコード�れ��る必���り��
+上付�2: \u00B2
+
+# 複数行�文字列�（| を使�）「リテラルブロック��
+# ����（'>' を使�）「折り畳�ブロック����書��������
+リテラルブロック: |
+    ��文章�ブロック全体�「リテラルブロック�キー�値��り�
+    改行����れ��。
+
+    リテラル�インデントを解除�る��続��先頭行�インデント文字数分を
+    �行�テキスト�先頭�ら�り除���。
+
+        「よりインデント�深��行���分�インデントを����� -
+        ��2行�スペース4個分インデント�れ��。
+折り畳�スタイル: >
+    ��文章�ブロック全体�「折り畳�スタイル��値��り��。
+    �����ら�場��全��改行�スペース1個�置���り��。
+
+    直��よ��空行�改行文字�変��れ��。
+
+        「よりインデント�深��行も改行を����� -
+        ��テキスト�2行�����表示�れ��。
+
+##################
+# コレクション型 #
+##################
+
+# 入れ�を表��る��インデントを使���。
+# スペース2個�インデント�好�れ��（�必須���り��ん）。
+入れ��マップ:
+  キー: 値
+  別�キー: 別�値
+  別�入れ��マップ:
+    �ん���: �ん���
+
+# マップ�キー�文字列��る必���り��ん。
+0.25: �数�キー
+
+# 複数行オブジェクト�よ��複雑�キーも使用�能��。
+# ? �後�スペースを入れる���複雑�キー�開始を宣言����。
+? |
+  �れ�キー��
+  複数行�り��
+: ����れ���値��
+
+# YAML��シーケンスを複雑�キー構文�使���も����
+# ����言語パーサー�よ���エラー��る�も�れ��ん
+# 例
+? - マン�ェスター・ユナイテッド
+  - レアル・マドリード
+: [2001-01-01, 2002-02-02]
+
+# シーケンス（リストや�列�等価）��ん�感���
+# （'-' �インデント���カウント������）：
+シーケンス:
+  - アイテム1
+  - アイテム2
+  - 0.5  # シーケンス��異�る型�値を混在��られ��
+  - アイテム4
+  - キー: 値
+    別�キー: 別�値
+  -
+    - �れ�シーケンス��
+    - 別�シーケンス内部
+  - - - 入れ��シーケンス表記�
+      - 折り畳���
+
+# YAML�JSON�スーパーセット����
+# JSON形��マップ�シーケンスを書���も����：
+jsonマップ: {"キー": "値"}
+jsonシーケンス: [3, 2, 1, "発進"]
+クォート�任�: {キー: [3, 2, 1, 発進]}
+
+######################
+# ��他�YAML�機能 #
+######################
+
+# YAML��「アンカー��呼�れる便利�機能も�り��。�れ�よりコンテンツを
+# ドキュメント内�簡��複製����。�れら�キー���らも��値を����：
+アンカー�れ�コンテンツ: &anchor_name ��文字列�2��キー�値��り��。
+他�アンカー: *anchor_name
+
+# アンカー�複製�継承プロパティ���使���
+ベース: &base
+  ��: �ん�����を����
+
+# 記� << �マージキー言語��存型（Merge Key Language-Independent Type）
+# �呼�れ��。�れ�指定�れ�1�以上�マップ�全��キーを�在�マップ�
+# 挿入�る��を示����使�れ��。
+
+foo:
+  <<: *base
+  å¹´é½¢: 10
+
+bar:
+  <<: *base
+  å¹´é½¢: 20
+
+# foo�barも「��： �ん�����を�����を����
+
+# YAML��タグも�り�明示的�型を宣言����。
+明示的�文字列: !!str 0.5
+# 言語特有�タグを実装��パーサーも�り�例��Python�複素数型�使���。
+python�複素数型: !!python/complex 1+2j
+
+# YAML�複雑�キー��言語特有�タグも使���
+? !!python/tuple [5, 7]
+: 五�七
+# Python上� {(5, 7): '五�七'} ���扱�れ��
+
+####################
+# ��他�YAML�型 #
+####################
+
+# 文字列�数値�YAML��解��る唯一�スカラー���り��ん。
+# ISO形��日付や日時リテラルもパース�れ��。
+日時: 2001-12-15T02:59:43.1Z
+スペースを�む日時: 2001-12-14 21:59:43.10 -5
+日付: 2002-12-14
+
+# !!binaryタグ�文字列�実体��イナリblob�base64エンコード表���る��を
+# 示���。
+gifファイル: !!binary |
+  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+  OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+  +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+  AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML��セット型も�り��れ��ん�感���：
+セット:
+  ? アイテム1
+  ? アイテム2
+  ? アイテム3
+���: {アイテム1, アイテム2, アイテム3}
+
+# セット�値�null����マップ��直��セット�以下�等価��：
+セット2:
+  アイテム1: null
+  アイテム2: null
+  アイテム3: null
+
+...  # ドキュメント終了
+```
+
+### 補足資料
+
++ [YAML公�ウェブサイト](https://yaml.org/)
++ [オンラインYAML�リデーター](http://www.yamllint.com/)
diff --git a/janet.html.markdown b/janet.html.markdown
index ec53b018..62ed7331 100644
--- a/janet.html.markdown
+++ b/janet.html.markdown
@@ -18,7 +18,7 @@ As we only have a scant *y* minutes, we'll survey the basics here and
 leave the remaining details for the manual. So please, keep your arms and
 legs inside the vehicle at all times, and on with the scenic tour!
 
-```janet
+```python
 # A comment.
 
 # Some literal values.
@@ -29,9 +29,9 @@ nil
 # Typical style for symbols (identifiers-for / names-of things).
 do-stuff
 pants-on-fire!
-foo->bar  # Evidently for converting foos to bars.
+foo->bar        # Evidently for converting foos to bars.
 fully-charged?
-_  # Usually used as a dummy variable.
+_               # Usually used as a dummy variable.
 
 # Keywords are like symbols that start with a colon, are treated like
 # constants, and are typically used as map keys or pieces of syntax in
@@ -58,10 +58,11 @@ math/e   # => 2.71828
 "hello"
 "hey\tthere"  # contains a tab
 
-# For multi-line strings, use one or more backticks. No escapes allowed.
+# For multi-line strings, use one or more backticks. Backslash-escapes not
+# recognized in these (bytes will be parsed literally).
 ``a long
 multi-line
-string``  # => "a long\nmulti-line\nstring"
+string``    # => "a long\nmulti-line\nstring"
 
 # Strings and data structures in Janet come in two varieties: mutable and
 # immutable. The literal for the mutable variety is written with a `@` in
@@ -72,7 +73,7 @@ string``  # => "a long\nmulti-line\nstring"
 @`a multi-line
 one here`
 
-(string "con" "cat" "enate")  # => "concatenate"
+(string "con" "cat" "enate")   # => "concatenate"
 
 # To get a substring:
 (string/slice "abcdefgh" 2 5)  # => "cde"
@@ -81,7 +82,8 @@ one here`
 
 # See the string library for more (splitting, replacement, etc.)
 
-# Arrays and Tuples ###########################################################
+# Data Structures #############################################################
+# Arrays and Tuples
 # Arrays are mutable, tuples are immutable.
 
 # Arrays (mutable)
@@ -91,18 +93,19 @@ one here`
 # Tuples (immutable)
 # Note that an open paren usually indicates a function call, so if you want a
 # literal tuple with parens, you need to "quote" it (with a starting single
-# quote mark).
+# quote mark)...
 '(4 5 6)
 [4 5 6]  # ... or just use square brackets.
 
-# Tables and Structs (AKA: "maps", "hashmaps", "dictionaries")
+# Tables and Structs (associative data structures)
 @{:a 1 :b 2 :c 3}  # table  (mutable)
 {:a 1 :b 2 :c 3}   # struct (immutable)
 
+# To "pretty-print" these out, use `pp` instead of `print`.
 # More about how to work with arrays/tuples and tables/structs below.
 
 # Bindings ####################################################################
-# ... or "Name Some Things!" (that is, bind a value to a symbol)
+# Bind a value to a symbol.
 (def x 4.7)  # Define a constant, `x`.
 x            # => 4.7
 (quote x)    # => x (the symbol x)
@@ -113,7 +116,7 @@ x            # => 4.7
 (set x 5.6)  # Error, `x` is a constant.
 
 (var y 10)
-(set y 12)  # Works, since `y` was made var.
+(set y 12)  # Works, since `y` was defined using `var`.
 
 # Note that bindings are local to the scope they're called in. `let`
 # creates a local scope and makes some bindings all in one shot:
@@ -151,29 +154,29 @@ insect-friend  # => bee
 (% 5 3)  # =>  2 (remainder)
 (- 5)    # => -5 (or you can just write `-5`)
 
-(++ i)    # increments
+(++ i)    # increments (modifies `i`)
 (-- i)    # decrements
 (+= i 3)  # add 3 to `i`
 (*= i 3)  # triple `i`
 # ... and so on for the other operations on numbers.
 
+# If you don't want to mutate `i`, use `(inc i)` and `(dec i)`.
+
 # Comparison
 # =  <  >  not=  <=  >=
 (< 2 7 12)  # => true
 
 # Functions ###################################################################
 # Call them:
-(- 5 3)  # => 2 (Yes, operators and functions work the same.)
+(- 5 3)                   # => 2 (Operators and functions work the same way.)
 (math/sin (/ math/pi 2))  # => 1
-(range 5)  # => @[0 1 2 3 4]
+(range 5)                 # => @[0 1 2 3 4]
 
 # Create them:
 (defn mult-by-2
   ``First line of docstring.
 
-  Some more of the docstring.
-
-  Possibly more!``
+  Some more of the docstring.``
   [x]
   (print "Hi.")
   (print "Will compute using: " x)
@@ -206,7 +209,7 @@ n  # => 3
 # You might say that function bodies provide an "implicit do".
 
 # Operations on data structures ###############################################
-# (Making all these mutable so we can ... mutate them.)
+# (Making all of these mutable so we can ... mutate them.)
 (def s @"Hello, World!")
 (def a @[:a :b :c :d :e])
 (def t @{:a 1 :b 2})
@@ -216,9 +219,9 @@ n  # => 3
 (length t)  # =>  2
 
 # Getting values:
-(s 7)   # => 87 (which is the code point for "W")
-(a 1)   # => :b
-(t :a)  # => 1
+(s 7)       # => 87 (which is the code point for "W")
+(a 1)       # => :b
+(t :a)      # => 1
 (keys t)    # => @[:a :b]
 (values t)  # => @[1 2]
 
@@ -227,14 +230,14 @@ n  # => 3
 (put a 2 :x)   # @[:a :b :x :d :e]
 (put t :b 42)  # @{:a 1 :b 42}
 
-# Adding & removing values (again, for mutable data structures):
+# Adding and removing values (again, for mutable data structures):
 (buffer/push-string s "??")  # @"HeWlo, World!??"
 (array/push a :f)  # @[:a :b :x :d :e :f]
 (array/pop a)      # => :f, and it's also removed from `a`.
 (put t :x 88)      # @{:a 1 :b 42 :x 88}
 
 # See the manual for a wide variety of functions for working with
-# buffers/strings, arrays/tuples, and tables/struct.
+# buffers/strings, arrays/tuples, and tables/structs.
 
 # Flow control ################################################################
 (if some-condition
@@ -282,7 +285,7 @@ n  # => 3
   {:yar v} (print "matches key :yar! " v)
   {:moo v} (print "matches key :moo! " v)
   {:c   v} (print "matches key :c! "   v)
-  _ (print "no match"))  # => prints "matches key :c! 3"
+  _        (print "no match"))             # => prints "matches key :c! 3"
 
 # Iterating ###################################################################
 # Iterate over an integer range:
@@ -312,7 +315,7 @@ n  # => 3
                (* x x))
              (range 10)))  # => @[0 4 16 36 64]
 
-(reduce + 0 (range 5))  # => 10
+(reduce + 0 (range 5))     # => 10
 
 # ...and lots more (see the API docs).
 
diff --git a/java.html.markdown b/java.html.markdown
index 79769352..7bf3fa0a 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -91,6 +91,9 @@ public class LearnJava {
         int numInt = scanner.nextInt();
 
         // read long input
+        long numLong = scanner.nextLong();
+
+        // read float input
         float numFloat = scanner.nextFloat();
 
         // read double input
@@ -123,6 +126,9 @@ public class LearnJava {
         // <name1> = <name2> = <name3> = <val>
         int barInt1, barInt2, barInt3;
         barInt1 = barInt2 = barInt3 = 1;
+	// Shorthand for multiple declarations
+	int barInt4 = 1, barInt5 = 2; 
+
 
         /*
         *  Variable types
@@ -182,7 +188,7 @@ public class LearnJava {
         //
         // 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
+        // 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);
@@ -304,8 +310,8 @@ public class LearnJava {
         ///////////////////////////////////////
         System.out.println("\n->Operators");
 
-        int i1 = 1, i2 = 2; // Shorthand for multiple declarations
-
+	int i1 = 1, i2 = 2;
+	
         // Arithmetic is straightforward
         System.out.println("1+2 = " + (i1 + i2)); // => 3
         System.out.println("2-1 = " + (i2 - i1)); // => 1
@@ -314,7 +320,7 @@ public class LearnJava {
         System.out.println("1/2.0 = " + (i1 / (double)i2)); // => 0.5
 
         // Modulo
-        System.out.println("11%3 = "+(11 % 3)); // => 2
+        System.out.println("11%3 = " + (11 % 3)); // => 2
 
         // Comparison operators
         System.out.println("3 == 2? " + (3 == 2)); // => false
@@ -368,7 +374,7 @@ public class LearnJava {
 
         // While loop
         int fooWhile = 0;
-        while(fooWhile < 100) {
+        while (fooWhile < 100) {
             System.out.println(fooWhile);
             // Increment the counter
             // Iterated 100 times, fooWhile 0,1,2...99
@@ -383,7 +389,7 @@ public class LearnJava {
             // Increment the counter
             // Iterated 100 times, fooDoWhile 0->99
             fooDoWhile++;
-        } while(fooDoWhile < 100);
+        } while (fooDoWhile < 100);
         System.out.println("fooDoWhile Value: " + fooDoWhile);
 
         // For Loop
@@ -510,10 +516,12 @@ public class LearnJava {
 
         // toString returns this Object's string representation.
         System.out.println("trek info: " + trek.toString());
+    } // End main method
 
+    private static class TestInitialization {
         // 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:
+        // Before Java 11, the Java Language had no syntax for how to create
+        // static Collections in an easy way. Usually you end up like this:
         private static final Set<String> COUNTRIES = new HashSet<String>();
         static {
            COUNTRIES.add("DENMARK");
@@ -521,10 +529,10 @@ public class LearnJava {
            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>() {{
+        // There's a nifty way to achieve the same thing, 
+        // by using something that is called Double Brace Initialization.
+        private static final Set<String> COUNTRIES_DOUBLE_BRACE = 
+        new HashSet<String>() {{
             add("DENMARK");
             add("SWEDEN");
             add("FINLAND");
@@ -535,8 +543,45 @@ public class LearnJava {
         // is called when the anonymous inner class is created.
         // This does not only work for Collections, it works for all
         // non-final classes.
+        
+
+        // Another option was to initialize the Collection from an array,
+        // using Arrays.asList() method:
+        private static final List<String> COUNTRIES_AS_LIST = 
+                        Arrays.asList("SWEDEN", "DENMARK", "NORWAY");
+        // This has one catch: the list we get is internally backed by the array,
+        // and since arrays can't change their size, the list backed by the array
+        // is not resizeable, which means we can't add new elements to it: 
+        public static void main(String[] args) {
+            COUNTRIES.add("FINLAND"); // throws UnsupportedOperationException!
+            // However, we can replace elements by index, just like in array: 
+            COUNTRIES.set(1, "FINLAND");
+            System.out.println(COUNTRIES); // prints [SWEDEN, FINLAND, NORWAY]
+        }
+        // The resizing problem can be circumvented 
+        // by creating another Collection from the List:
+         private static final Set<String> COUNTRIES_SET = 
+                new HashSet<>(Arrays.asList("SWEDEN", "DENMARK", "NORWAY"));
+        // It's perfectly fine to add anything to the Set of COUNTRIES now. 
+    } // End TestInitialization class
+
+    private static class TestJava11Initialization {
+        // Since Java 11, there is a convenient option to initialize Collections:
+        // Set.of() and List.of() methods. 
+        private static final Set<String> COUNTRIES = 
+                Set.of("SWEDEN", "DENMARK", "NORWAY");
+        // There is a massive catch, though: Lists and Sets initialized like this 
+        // 1) are immutable 
+        // 2) can't contain null elements (even check for null elements fails)!
+        public static void main(String[] args) {
+            COUNTRIES.add("FINLAND"); // throws UnsupportedOperationException
+            COUNTRIES.remove("NORWAY"); // throws UnsupportedOperationException 
+            COUNTRIES.contains(null); // throws NullPointerException
+        }
+        private static final Set<String> COUNTRIES_WITH_NULL = 
+                    Set.of("SWEDEN", null, "NORWAY"); // throws NullPointerException
 
-    } // End main method
+    } // End TestJava11Initialization class
 } // End LearnJava class
 
 // You can include other, non-public outer-level classes in a .java file,
diff --git a/javascript.html.markdown b/javascript.html.markdown
index 3c0e6d4f..4e7c5c09 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -105,6 +105,10 @@ false;
 "1, 2, " + 3; // = "1, 2, 3"
 "Hello " + ["world", "!"]; // = "Hello world,!"
 
+// ...which can result in some weird behaviour...
+13 + !0; // 14
+"13" + !0; // '13true'
+
 // and are compared with < and >
 "a" < "b"; // = true
 
@@ -116,10 +120,6 @@ null == undefined; // = true
 "5" === 5; // = false
 null === undefined; // = false
 
-// ...which can result in some weird behaviour...
-13 + !0; // 14
-"13" + !0; // '13true'
-
 // You can access characters in a string with `charAt`
 "This is a string".charAt(0);  // = 'T'
 
@@ -405,7 +405,7 @@ myObj = {
 };
 myObj.myFunc(); // = "Hello world!"
 
-// What this is set to has to do with how the function is called, not where
+// What `this` is set to has to do with how the function is called, not where
 // it's defined. So, our function doesn't work if it isn't called in the
 // context of the object.
 var myFunc = myObj.myFunc;
@@ -590,7 +590,7 @@ if (Object.create === undefined){ // don't overwrite it if it exists
 // ES6 Additions
 
 // The "let" keyword allows you to define variables in a lexical scope, 
-// as opposed to a block scope like the var keyword does.
+// as opposed to a function scope like the var keyword does.
 let name = "Billy";
 
 // Variables defined with let can be reassigned new values.
@@ -620,7 +620,7 @@ function isEven(number) {
 };
 
 // I put the word "equivalent" in double quotes because a function defined
-// using the lambda syntax cannnot be called before the definition.
+// using the lambda syntax cannot be called before the definition.
 // The following is an example of invalid usage:
 
 add(1, 8);
@@ -655,7 +655,7 @@ 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.
 
-[Javascript:Info][11] is a modern javascript tutorial covering the basics (core language and working with a browser)
+[javascript.info][11] is a modern javascript tutorial covering the basics (core language and working with a browser)
 as well as advanced topics with concise explanations.
 
 
@@ -671,6 +671,7 @@ Mozilla Developer Network.
 [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]: https://www.javascripttutorial.net/
 [8]: http://eloquentjavascript.net/
 [10]: http://jstherightway.org/
 [11]: https://javascript.info/
diff --git a/jinja.html.markdown b/jinja.html.markdown
new file mode 100644
index 00000000..7e5b8e96
--- /dev/null
+++ b/jinja.html.markdown
@@ -0,0 +1,270 @@
+---
+language: Jinja
+contributors:
+  - ["Adaías Magdiel", "https://github.com/AdaiasMagdiel"]
+filename: learn-jinja.j2
+---
+
+## Getting Started with Jinja
+
+Jinja is a fast, expressive, and extensible templating engine for Python
+applications.
+
+Jinja includes a lot of functionalities, such as:
+- Template inheritance and inclusion;
+- Defining and importing macros within templates;
+- Security mechanisms to prevent XSS attacks;
+- A sandboxed environment that can safely render untrusted templates;
+- Extensible filters, tests, functions, and even syntax.
+
+A Jinja template is simply a text file. Jinja doesn't require a specific
+extension, but it's common to use `.j2` or `.jinja` to make it easier for
+some IDEs.
+
+There are a few kinds of delimiters. The default Jinja delimiters are configured
+as follows:
+
+- `{% ... %}` for Statements
+- `{{ ... }}` for Expressions to print to the template output
+- `{# ... #}` for Comments not included in the template output
+
+```jinja
+{# This is an example of a comment. #}
+
+{#
+  You can use this syntax
+  to write multiline comments
+  as well.
+#}
+```
+
+
+## VARIABLES
+
+```jinja
+{# You have the option to access variables from the context passed to the template #}
+
+{{ foo }}
+
+{# 
+  Additionally, you can use a dot (.) to access attributes of a variable or
+  use Python syntax, using []
+#}
+
+{{ foo.bar }}
+{{ foo['bar'] }}
+
+{# Within the template, you can define variables as well #}
+
+{% set name = "Magdiel" %}
+{{ name }}
+```
+
+## Loops
+
+```html
+<h1>Members</h1>
+<ul>
+{% for user in users %}
+    <li>{{ user.username }}</li>
+{% endfor %}
+</ul>
+
+
+<div>
+{% for key, value in my_dict.items() %}
+    <p>{{ key }}</p> - <p>{{ value }}</p>
+{% endfor %}
+</div>
+
+
+<div>
+{% for idx, url in enumerate(urls) %}
+    <a href="{{ url }}">Go to url {{ idx + 1 }}</a>
+{% endfor %}
+</div>
+```
+
+## Conditionals
+
+The if statement in Jinja is similar to the if statement in Python. It is
+commonly used to check if a variable is defined, not empty, and not false in
+its most basic form.
+
+```html
+{% if users %}
+<ul>
+{% for user in users %}
+    <li>{{ user.username }}</li>
+{% endfor %}
+</ul>
+{% endif %}
+
+
+{# For multiple branches, elif and else can be used like in Python. #}
+
+
+{% if message.status == "error" %}
+    <p class="text-red-400">{{ message.content }}</p>
+{% elif message.status == "success" %}
+    <p class="text-green-400">{{ message.content }}</p>
+{% else %}
+    <p class="text-blue-400">{{ message.content }}</p>
+{% endif %}
+```
+
+## Template Inheritance
+
+One of the most powerful features of Jinja is template inheritance. You can
+create a base layout with predefined blocks that you can extend in another file
+and override with your own content.
+
+```html
+{# file: base.html.j2 #}
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    {% block head %}
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}{% endblock title %} - Learning Jinja</title>
+    {% endblock head %}
+</head>
+<body>
+    <main>
+        {% block content %}{% endblock %}
+        {# the endblock tag doesn't need the name of the block #}
+    </main>
+</body>
+</html>
+
+
+
+{# file: child.html.j2 #}
+
+{% extends "base.html.j2" %}
+
+{% block head %}
+    {{ super() }}
+    <script>
+        console.log("There's a console.log here")
+    </script>
+{% endblock %}
+
+{% block title %}Home{% endblock %}
+
+{% block content %}
+    <h1>Index</h1>
+    <p>Welcome to my home homepage.</p>
+{% endblock %}
+
+
+
+{# RESULT #}
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Home - Learning Jinja</title>
+    <script>
+        console.log("There's a console.log here")
+    </script>
+</head>
+<body>
+    <main>
+        <h1>Index</h1>
+        <p>Welcome to my home homepage.</p>
+    </main>
+</body>
+</html>
+
+```
+
+### Including Content
+
+You can include content from another template on your current template using
+the `{% include "template/path" %}` tag.
+
+```html
+
+{# file: footer.html.j2 #}
+
+<footer>
+    <p>&copy; 2024 - John Doe</p>
+</footer>
+
+
+
+{# file: index.html.j2 #}
+...
+<body>
+    <main>
+        <h1>Hi! I'm John Doe!</h1>
+    </main>
+    {% include "footer.html.j2" %}
+</body>
+...
+
+
+
+{# RESULT #}
+
+...
+<body>
+    <main>
+        <h1>Hi! I'm John Doe!</h1>
+    </main>
+    <footer>
+        <p>&copy; 2024 - John Doe</p>
+    </footer>
+</body>
+...
+```
+
+Variables passed to the main template can also be used in the include, as the
+included template has access to the context of the main template.
+
+```html
+{# file: greetings.html.j2 #}
+
+<p>I'm the {{ name }} and i like to {{ hobby }}.</p>
+
+
+
+{# file: index.html.j2 #}
+
+{% set name = "Captain Nemo" %}
+{% set hobby = "navigate through the depths of the ocean" %}
+
+<div>
+    {% include "greetings.html.j2" %}
+</div>
+
+
+
+{# RESULT #}
+
+<div>
+    <p>I'm the Captain Nemo and i like to navigate through the depths of the ocean.</p>
+</div>
+```
+
+## Macros
+
+Macros are basically like functions in another languages. You can define macros with or without arguments and reuse them in various parts of your template.
+
+```html
+{% macro input(value="", type="text", placeholder="") -%}
+    <input type="{{ type }}" value="{{ value }}" placeholder="{{ placeholder }}">
+{%- endmacro %}
+
+<p>{{ input(placeholder="Your username") }}</p>
+<p>{{ input(type="password") }}</p>
+```
+
+## Official Documentation
+
+To learn more, access the [official documentation](https://jinja.palletsprojects.com/en/).
diff --git a/jq.html.markdown b/jq.html.markdown
new file mode 100644
index 00000000..dded34cb
--- /dev/null
+++ b/jq.html.markdown
@@ -0,0 +1,910 @@
+---
+category: tool
+tool: jq
+contributors:
+    - ["Jack Kuan", "https://github.com/kjkuan"]
+filename: learnjq.sh
+---
+
+`jq` is a tool for transforming JSON inputs and generating JSON outputs. As a
+programming language, jq supports boolean and arithmetic expressions, object
+and array indexing; it has conditionals, functions, and even exception
+handling... etc.  Knowing jq enables you to easily write small programs that
+can perform complex queries on JSON documents to find answers, make reports, or
+to produce another JSON document for further processing by other programs.
+
+> **NOTE**: This guide demonstrates the use of jq from the command line,
+> specifically, under an environment running the Bash shell.
+
+```bash
+# When running jq from the command line, jq program code can be specified as the
+# first argument after any options to `jq`. We often quote such jq program with
+# single quotes (`'`) to prevent any special interpretation from the command line
+# shell.
+#
+jq -n '# Comments start with # until the end of line.
+       # The -n option sets the input to the value, `null`, and prevents `jq`
+       # from reading inputs from external sources.
+'
+
+# Output:
+# null
+
+
+# By default jq reads from *STDIN* a stream of JSON inputs (values). It
+# processes each input with the jq program (filters) specified at the command
+# line, and prints the outputs of processing each input with the program to
+# *STDOUT*.
+#
+echo '
+  "hello" 123 [
+    "one",
+    "two",
+    "three"
+  ]
+  { "name": "jq" }
+' |
+ jq '.  # <-- the jq program here is the single dot (.), called the identity
+        # operator, which stands for the current input.
+'
+
+# Output:
+# "hello"
+# 123
+# [
+#   "one",
+#   "two",
+#   "three"
+# ]
+# {
+#   "name": "jq"
+# }
+
+
+# Notice that jq pretty-prints the outputs by default, therefore, piping
+# to `jq` is a simple way to format a response from some REST API endpoint
+# that returns JSON. E.g., `curl -s https://freegeoip.app/json/ | jq`
+
+
+# Instead of processing each JSON input with a jq program, you can also
+# ask jq to slurp them up as an array.
+#
+echo '1 "two" 3' | jq -s .
+
+# Output:
+# [
+#   1,
+#   "two",
+#   3
+# ]
+
+
+# Or, treat each line as a string.
+#
+(echo line 1; echo line 2) | jq -R .
+
+# Output:
+# "line 1"
+# "line 2"
+
+
+# Or, combine -s and -R to slurp the input lines into a single string.
+#
+(echo line 1; echo line 2) | jq -sR .
+
+# Output:
+# "line 1\nline2\n"
+
+
+# Inputs can also come from a JSON file specified at the command line:
+#
+echo '"hello"' > hello.json
+jq . hello.json
+
+# Output:
+# "hello"
+
+
+# Passing a value into a jq program can be done with the `--arg` option.
+# Below, `val` is the variable name to bind the value, `123`, to.
+# The variable is then referenced as `$val`.
+#
+jq -n --arg val 123 '$val'  # $val is the string "123" here
+
+# Output:
+# "123"
+
+
+# If you need to pass a JSON value, use `--argjson`
+#
+jq -n --argjson val 123 '$val'  # $val is a number
+
+# Output:
+# 123
+
+
+# Using `--arg` or `--argjson` is an useful way of building JSON output from
+# existing input.
+#
+jq --arg text "$(date; echo "Have a nice day!")" -n '{ "today": $text }'
+
+# Output:
+# {
+#   "today": "Sun Apr 10 09:53:07 PM EDT 2022\nHave a nice day!"
+# }
+
+
+# Instead of outputting values as JSON, you can use the `-r` option to print
+# string values unquoted / unescaped. Non-string values are still printed as
+# JSON.
+#
+echo '"hello" 2 [1, "two", null] {}' | jq -r .
+
+# Output:
+# hello
+# 2
+# [
+#   1,
+#   "two",
+#   null
+# ]
+# {}
+
+
+# Inside a string in jq, `\(expr)` can be used to substitute the output of
+# `expr` into the surrounding string context.
+#
+jq -rn '"1 + 2 = \(1+2)"'
+
+# Output:
+# 1 + 2 = 3
+
+
+# The `-r` option is most useful for generating text outputs to be processed
+# down in a shell pipeline, especially when combined with an intepolated
+# string that is prefixed the `@sh` prefix operator.
+#
+# The `@sh` operator escapes the outputs of `\(...)` inside a string with
+# single quotes so that each resulting string of `\(...)` can be evaluated
+# by the shell as a single word / token / argument without special
+# interpretations.
+#
+env_vars=$(
+    echo '{"var1": "value one", "var2": "value\ntwo"}' \
+     |
+    jq -r '
+      "export " + @sh "var1=\(.var1) var2=\(.var2)"
+      #                     ^^^^^^^^      ^^^^^^^^
+      #                  "'value one'"  "'value\ntwo'"
+      #
+      # NOTE: The + (plus) operator here concatenates strings.
+    '
+)
+echo "$env_vars"
+eval "$env_vars"
+declare -p var1 var2
+
+# Output:
+# export var1='value one' var2='value
+# two'
+# declare -- var1="value one"
+# declare -- var2="value
+# two"
+
+# There are other string `@prefix` operators (e.g., @base64, @uri, @csv, ...)
+# that might be useful to you. See `man jq` for details.
+
+
+# The comma (`,`) operator in jq evaluates each operand and generates multiple
+# outputs:
+#
+jq -n '"one", 2, ["three"], {"four": 4}'
+
+# Output:
+# "one"
+# 2
+# [
+#   "three"
+# ]
+# {
+#   "four": 4
+# }
+
+
+# Any JSON value is a valid jq expression that evaluates to the JSON value
+# itself.
+#
+jq -n '1, "one", [1, 2], {"one": 1}, null, true, false'
+
+# Output:
+# 1
+# "one"
+# [
+#   1,
+#   2
+# ]
+# {
+#   "one": 1
+# }
+# null
+# true
+# false
+
+
+# Any jq expression can be used where a JSON value is expected, even as object
+# keys. (though parenthesis might be required for object keys or values)
+#
+jq -n '[2*3, 8-1, 16/2], {("tw" + "o"): (1 + 1)}'
+
+# Output:
+# [
+#   6,
+#   7,
+#   8
+# ]
+# {
+#   "two": 2
+# }
+
+
+# As a shortcut, if a JSON object key looks like a valid identifier (matching
+# the regex `^[a-zA-Z_][a-zA-Z_0-9]*$`), quotes can be omitted.
+#
+jq -n '{ key_1: "value1" }'
+
+# If a JSON object's key's value is ommited, it is looked up in the current
+# input using the key: (see next example for the meaning of `... | ...`)
+#
+jq -n '{c: 3} | {a: 1, "b", c}'
+
+# Output:
+# {
+#   "a": 1,
+#   "b": null,
+#   "c": 3
+# }
+
+
+# jq programs are more commonly written as a series of expressions (filters)
+# connected by the pipe (`|`) operator, which makes the output of its left
+# filter the input to its right filter.
+#
+jq -n '1 | . + 2 | . + 3'  # first dot is 1; second dot is 3
+
+# Output:
+# 6
+
+# If an expression evaluates to multiple outputs, then jq will iterate through
+# them and propagate each output down the pipeline, and generate multiple
+# outputs in the end.
+#
+jq -n '1, 2, 3 | ., 4 | .'
+
+# Output:
+# 1
+# 4
+# 2
+# 4
+# 3
+# 4
+
+# The flows of the data in the last example can be visualized like this:
+# (number prefixed with `*` indicates the current output)
+#
+# *1,  2,  3 | *1,  4 | *1
+#  1,  2,  3 |  1, *4 | *4
+#  1, *2,  3 | *2,  4 | *2
+#  1,  2,  3 |  2, *4 | *4
+#  1,  2, *3 | *3,  4 | *3
+#  1,  2,  3 |  3, *4 | *4
+#
+#
+# To put it another way, the evaluation of the above example is very similar
+# to the following pieces of code in other programming languages:
+#
+# In Python:
+#
+#   for first_dot in 1, 2, 3:
+#       for second_dot in first_dot, 4:
+#           print(second_dot)
+#
+# In Ruby:
+#
+#   [1, 2, 3].each do |dot|
+#     [dot, 4].each { |dot| puts dot }
+#   end
+#
+# In Javascript:
+#
+#   [1, 2, 3].forEach(dot => {
+#       [dot, 4].forEach(dot => console.log(dot))
+#   })
+#
+
+
+# Below are some examples of array index and object attribute lookups using
+# the `[expr]` operator after an expression. If `expr` is a number then it's
+# an array index lookup; otherwise, it should be a string, in which case it's
+# an object attribute lookup:
+
+# Array index lookup
+#
+jq -n '[2, {"four": 4}, 6][1 - 1]' # => 2
+jq -n '[2, {"four": 4}, 6][0]'     # => 2
+jq -n '[2, {"four": 4}, 6] | .[0]' # => 2
+
+# You can chain the lookups since they are just expressions.
+#
+jq -n '[2, {"four": 4}, 6][1]["fo" + "ur"]' # => 4
+
+# For object attributes, you can also use the `.key` shortcut.
+#
+jq -n '[2, {"four": 4}, 6][1].four'  # => 4
+
+# Use `."key"` if the key is not a valid identifier.
+#
+jq -n '[2, {"f o u r": 4}, 6][1]."f o u r"' # => 4
+
+# Array index lookup returns null if the index is not found.
+#
+jq -n '[2, {"four": 4}, 6][99]' # => null
+
+# Object attribute lookup returns null if the key is not found.
+#
+jq -n '[2, {"four": 4}, 6][1].whatever' # => null
+
+# The alternative operator `//` can be used to provide a default
+# value when the result of the left operand is either `null` or `false`.
+#
+jq -n '.unknown_key // 7' # => 7
+
+# If the thing before the lookup operator (`[expr]`) is neither an array
+# or an object, then you will get an error:
+#
+jq -n '123 | .[0]'     # => jq: error (at <unknown>): Cannot index number with number
+jq -n '"abc" | .name'  # => jq: error (at <unknown>): Cannot index string with string "name"
+jq -n '{"a": 97} | .[0]'    # => jq: error (at <unknown>): Cannot index object with number
+jq -n '[89, 64] | .["key"]' # => jq: error (at <unknown>): Cannot index array with string "key"
+
+# You can, however, append a `?` to a lookup to make jq return `empty`
+# instead when such error happens.
+#
+jq -n '123 | .[0]?'    # no output since it's empty.
+jq -n '"abc" | .name?' # no output since it's empty.
+
+# The alternative operator (`//`) also works with `empty`:
+#
+jq -n '123 | .[0]? // 99'           # => 99
+jq -n '"abc" | .name? // "unknown"' # => "unknown"
+
+# NOTE: `empty` is actually a built-in function in jq.
+# With the nested loop explanation we illustrated earlier before,
+# `empty` is like the `continue` or the `next` keyword that skips
+# the current iteration of the loop in some programming languages.
+
+
+# Strings and arrays can be sliced with the same syntax (`[i:j]`, but no
+# steppings) and semantic as found in the Python programming language:
+#
+#                0   1    2    3    4   5 ... infinite
+#        array = ["a", "b", "c", "d"]
+# -infinite ... -4  -3   -2   -1
+#
+jq -n '["Peter", "Jerry"][1]'            # => "Jerry"
+jq -n '["Peter", "Jerry"][-1]'           # => "Jerry"
+jq -n '["Peter", "Jerry", "Tom"][1:]'    # => ["Jerry", "Tom"]
+jq -n '["Peter", "Jerry", "Tom"][:1+1]'  # => ["Peter", "Jerry"]
+jq -n '["Peter", "Jerry", "Tom"][1:99]'  # => ["Jerry", "Tom"]
+
+
+# If the lookup index or key is ommited then jq iterates through
+# the collection, generating one output value from each iteration.
+#
+# These examples produce the same outputs.
+#
+echo 1 2 3 | jq .
+jq -n '1, 2, 3'
+jq -n '[1, 2, 3][]'
+jq -n '{a: 1, b: 2, c: 3}[]'
+
+# Output:
+# 1
+# 2
+# 3
+
+
+# You can build an array out of multiple outputs.
+#
+jq -n '{values: [{a: 1, b: 2, c: 3}[] | . * 2]}'
+
+# Output:
+# {
+#   "values": [
+#     2,
+#     4,
+#     6
+#   ]
+# }
+
+
+# If multiple outputs are not contained, then we'd get multiple outputs
+# in the end.
+#
+jq -n '{values: ({a: 1, b: 2, c: 3}[] | . * 2)}'
+
+# Output:
+# {
+#   "values": 2
+# }
+# {
+#   "values": 4
+# }
+# {
+#   "values": 6
+# }
+
+
+# Conditional `if ... then ... else ... end` in jq is an expression, so
+# both the `then` part and the `else` part are required. In jq, only
+# two values, `null` and `false`, are false; all other values are true.
+#
+jq -n 'if 1 > 2 | not and 1 <= 2 then "Makes sense" else "WAT?!" end'
+
+# Output
+# "Makes sense"
+
+# Notice that `not` is a built-in function that takes zero arguments,
+# that's why it's used as a filter to negate its input value.
+# We'll talk about functions soon.
+
+# Another example using a conditional:
+#
+jq -n '1, 2, 3, 4, 5 | if . % 2 != 0 then . else empty end'
+
+# Output
+# 1
+# 3
+# 5
+
+# The `empty` above is a built-in function that takes 0 arguments and
+# generates no outputs. Let's see more examples of built-in functions.
+
+# The above conditional example can be written using the `select/1` built-in
+# function (`/1` indicates the number of arguments expected by the function).
+#
+jq -n '1, 2, 3, 4, 5 | select(. % 2 != 0)'  # NOTE: % gives the remainder.
+
+# Output
+# 1
+# 3
+# 5
+
+
+# Function arguments in jq are passed with call-by-name semantic, which
+# means, an argument is not evaulated at call site, but instead, is
+# treated as a lambda expression with the calling context of the call
+# site as its scope for variable and function references used in the
+# expression.
+#
+# In the above example, the expression `. % 2 != 0` is what's passed to
+# `select/1` as the argument, not `true` or `false`, which is what would
+# have been the case had the (boolean) expression was evaluated before it's
+# passed to the function.
+
+
+# The `range/1`, `range/2`, and `range/3` built-in functions generate
+# integers within a given range.
+#
+jq -n '[range(3)]'         # => [0, 1, 2]
+jq -n '[range(0; 4)]'      # => [0, 1, 2, 3]
+jq -n '[range(2; 10; 2)]'  # => [2, 4, 6, 8]
+
+# Notice that `;` (semicolon) is used to separate function arguments.
+
+
+# The `map/1` function applies a given expression to each element of
+# the current input (array) and outputs a new array.
+#
+jq -n '[range(1; 6) | select(. % 2 != 0)] | map(. * 2)'
+
+# Output:
+# [
+#   2,
+#   6,
+#   10
+# ]
+
+# Without using `select/1` and `map/1`, we could have also written the
+# above example like this:
+#
+jq -n '[range(1; 6) | if . % 2 != 0 then . else empty end | . * 2]'
+
+
+# `keys/0` returns an array of keys of the current input. For an object,
+# these are the object's attribute names; for an array, these are the
+# array indices.
+#
+jq -n '[range(2; 10; 2)] | keys'   # => [0, 1, 2, 3]
+jq -n '{a: 1, b: 2, c: 3} | keys'  # => ["a", "b", "c"]
+
+# `values/0` returns an array of values of the current input. For an object,
+# these are the object's attribute values; for an array, these are the
+# elements of the array.
+#
+jq -n '[range(2; 10; 2)] | values'   # => [2, 4, 6, 8]
+jq -n '{a: 1, b: 2, c: 3} | values'  # => [1, 2, 3]
+
+
+# `to_entries/0` returns an array of key-value objects of the current input
+# object.
+#
+jq -n '{a: 1, b: 2, c: 3} | to_entries'
+
+# Output:
+# [
+#   {
+#     "key": "a",
+#     "value": 1
+#   },
+#   {
+#     "key": "b",
+#     "value": 2
+#   },
+#   {
+#     "key": "c",
+#     "value": 3
+#   }
+# ]
+
+
+# Here's how you can turn an object's attribute into environment variables
+# using what we have learned so far.
+#
+env_vars=$(
+    jq -rn '{var1: "1 2  3   4", var2: "line1\nline2\n"}
+            | to_entries[]
+            | "export " + @sh "\(.key)=\(.value)"
+           '
+)
+eval "$env_vars"
+declare -p var1 var2
+
+# Output:
+# declare -x var1="1 2  3   4"
+# declare -x var2="line1
+# line2
+# "
+
+
+# `from_entries/0` is the opposite of `to_entries/0` in that it takes an
+# an array of key-value objects and turn that into an object with keys
+# and values from the `key` and `value` attributes of the objects.
+#
+# It's useful together with `to_entries/0` when you need to iterate and
+# do something to each attribute of an object.
+#
+jq -n '{a: 1, b: 2, c: 3} | to_entries | map(.value *= 2) | from_entries'
+
+# Output:
+# {
+#   "a": 2,
+#   "b": 4,
+#   "c": 6
+# }
+
+
+# The example above can be further shortened with the  `with_entries/1` built-in:
+#
+jq -n '{a: 1, b: 2, c: 3} | with_entries(.value *= 2)'
+
+
+# The `group_by/1` generates an array of groups (arrays) from the current
+# input (array). The classification is done by applying the expression argument
+# to each member of the input array.
+#
+# Let's look at a contrived example (Note that `tostring`, `tonumber`,
+# `length` and `max` are all built-in jq functions. Feel free to look
+# them up in the jq manual):
+#
+# Generate some random numbers.
+numbers=$(echo $RANDOM{,,,,,,,,,,,,,,,,,,,,})
+#
+# Feed the numbers to jq, classifying them into groups and calculating their
+# averages, and finally generate a report.
+#
+echo $numbers | jq -rs '  # Slurp the numbers into an array.
+[
+  [ map(tostring)          # Turn it into an array of strings.
+    | group_by(.[0:1])     # Group the numbers by their first digits.
+    | .[]                  # Iterate through the array of arrays (groups).
+    | map(tonumber)        # Turn each group back to an array of numbers.
+  ] # Finally, contain all groups in an array.
+
+  | sort_by([length, max]) # Sort the groups by their sizes.
+    # If two groups have the same size then the one with the largest
+    # number wins (is bigger).
+
+  | to_entries[]           # Enumerate the array, generating key-value objects.
+  |                        # For each object, generate two lines:
+  "Group \(.key): \(.value | sort | join(" "))"   + "\n" +
+  "Average: \(      .value | (add / length)  )"
+
+] # Contain the group+average lines in an array.
+  # Join the array elements by separator lines (dashes) to produce the report.
+| join("\n" + "-"*78 + "\n")
+'
+
+# Output:
+#
+# Group 0: 3267
+# Average: 3267
+# ------------------------------------------------------------------------------
+# Group 1: 7854
+# Average: 7854
+# ------------------------------------------------------------------------------
+# Group 2: 4415 4447
+# Average: 4431
+# ------------------------------------------------------------------------------
+# Group 3: 681 6426
+# Average: 3553.5
+# ------------------------------------------------------------------------------
+# Group 4: 21263 21361 21801 21832 22947 23523 29174
+# Average: 23128.714285714286
+# ------------------------------------------------------------------------------
+# Group 5: 10373 12698 13132 13924 17444 17963 18934 18979
+# Average: 15430.875
+
+
+# The `add/1` built-in "reduces" an array of values to a single value.
+# You can think of it as sticking the `+` operator in between each value of
+# the collection. Here are some examples:
+#
+jq -n '[1, 2, 3, 4, 5] | add'  # => 15
+jq -n '["a", "b", "c"] | add'  # => "abc"
+
+# `+` concatenates arrays
+jq -n '[["a"], ["b"], ["c"]] | add'
+
+# Output:
+# [
+#   "a",
+#   "b",
+#   "c"
+# ]
+
+# `+` merges objects non-recursively.
+jq -n '[{a: 1, b: {c: 3}}, {b: 2, c: 4}] | add'
+
+# Output:
+# {
+#   "a": 1,
+#   "b": 2,
+#   "c": 4
+# }
+
+
+# jq provides a special syntax for writing an expression that reduces
+# the outputs generated by a given expresion to a single value.
+# It has this form:
+#
+#   reduce outputs_expr as $var (initial_value; reduction_expr)
+#
+# Examples:
+#
+jq -n 'reduce range(1; 6) as $i (0; . + $i)'             # => 15
+jq -n 'reduce (1, 2, 3, 4, 5) as $i (0; . + $i)'         # => 15
+jq -n '[1, 2, 3, 4, 5] | reduce .[] as $i (0; . + $i)'   # => 15
+jq -n '["a", "b", "c"] | reduce .[] as $i (""; . + $i)'  # => "abc"
+
+# Notice the `.` in the `reduction_expr` is the `initial_value` at first,
+# and then it becomes the result of applying the `reduction_expr` as
+# we iterate through the values of `outputs_expr`. The expression:
+#
+#    reduce (1, 2, 3, 4, 5) as $i (0; . + $i)
+#
+# can be thought of as doing:
+#
+#    0 + 1 | . + 2 | . + 3 | . + 4 | . + 5
+#
+
+
+# The `*` operator when used on two objects, merges both recursively.
+# Therefore, to merge JSON objects recursively, you can use `reduce`
+# with the `*` operator. For example:
+#
+echo '
+  {"a": 1,  "b": {"c": 3}}
+  {         "b": {"d": 4}}
+  {"a": 99, "e": 5       }
+' | jq -s 'reduce .[] as $m ({}; . * $m)'
+
+# Output:
+# {
+#   "a": 99,
+#   "b": {
+#     "c": 3,
+#     "d": 4
+#   },
+#   "e": 5
+# }
+
+
+# jq has variable assignment in the form of `expr as $var`, which binds
+# the value of `expr` to `$var`, and `$var` is immutable. Further more,
+# `... as ...` doesn't change the input of the next filter; its introduction
+# in a filter pipeline is only for establishing the binding of a value to a
+# variable, and its scope extends to the filters following its definition.
+# (i.e., to look up a variable's definition, scan to the left of the filter
+# chain from the expression using it until you find the definition)
+#
+jq -rn '[1, 2, 3, 4, 5]
+        | (.[0] + .[-1])      as $sum     # Always put ( ) around the binding `expr` to avoid surprises.
+        | ($sum * length / 2) as $result  # The current input at this step is still the initial array.
+        | "The result is: \($result)"     # Same.
+'
+
+# Output:
+# The result is: 15
+
+
+# With the `expr as $var` form, if multiple values are generated by `expr`
+# then jq will iterate through them and bind each value to `$var` in turn
+# for the rest of the pipeline.
+#
+jq -rn 'range(2; 4) as $i
+        | range(1; 6) as $j
+          | "\($i) * \($j) = \($i * $j)"
+'
+
+# Output:
+# 2 * 1 = 2
+# 2 * 2 = 4
+# 2 * 3 = 6
+# 2 * 4 = 8
+# 2 * 5 = 10
+# 3 * 1 = 3
+# 3 * 2 = 6
+# 3 * 3 = 9
+# 3 * 4 = 12
+# 3 * 5 = 15
+
+
+# It's sometimes useful to bind the initial input to a variable at the
+# start of a program, so that you can refer to it later down the pipeline.
+#
+jq -rn "$(cat <<'EOF'
+    {lookup:  {a: 1, b: 2, c: 3},
+     bonuses: {a: 5, b: 2, c: 9}
+    }
+    | . as $doc
+    | .bonuses
+    | to_entries[]
+    | "\(.key)'s total is \($doc.lookup[.key] + .value)"
+EOF
+)"
+
+# Output:
+# a's total is 6
+# b's total is 4
+# c's total is 12
+
+
+# jq supports destructing during varible binding. This lets you extract values
+# from an array or an object and bind them to variables.
+#
+jq -n '[range(5)] | . as [$first, $second] | $second'
+
+# Output:
+# 1
+
+jq -n '{ name: "Tom", numbers: [1, 2, 3], age: 32}
+       | . as {
+            name: $who,                  # bind .name to $who
+            $name,                       # shorthand for `name: $name`
+            numbers: [$first, $second],
+         }
+       | $name, $second, $first, $who
+'
+
+# Output:
+# "Tom"
+# 2
+# 1
+# "Tom"
+
+
+# In jq, values can be assigned to an array index or object key via the
+# assignment operator, `=`. The same current input is given to both sides
+# of the assignment operator, and the assignment itself evaluates to the
+# current input. In other words, the assignment expression is evaluated
+# for its side effect, and doesn't generate a new output.
+#
+jq -n '.a = 1 | .b = .a + 1'  # => {"a": 1, "b": 2}
+
+# Note that input is `null` due to `jq -n`, so `.` is `null` in the first
+# filter, and assiging to a key under `null` turns it into an object with
+# the key. The same input (now an object) then gets piped to the next filter,
+# which then sets the `b` key to the value of the `a` key plus `1`, which is `2`.
+#
+
+# Another example:
+#
+jq -n '.a=1, .a.b=2'   # => {"a": 1} {"a": {"b": 2}}
+
+# In the above example, two objects are generated because both assignments
+# received `null` as their inputs, and each operand of the comma operator
+# is evaluated independently. Notice also how you can easily generate
+# nested objects.
+
+
+# In addition to the assignment operator, jq also has operators like:
+# `+=`, `-=`, `*=`, and '/=', ... etc. Basically, `a op= b` is a shorthand
+# for `a = a op b`, and they are handy for updating an object attribute or
+# an item in an array based on its current value. Examples:
+#
+jq -n '.a.b.c = 3 | .a.b.c = .a.b.c + 1' # => {"a": {"b": {"c": 4}}}
+jq -n '.a.b.c = 3 | .a.b.c += 1'         # => {"a": {"b": {"c": 4}}}
+
+
+# To delete a value, use `del/1`, which takes a path expression that specifies
+# the locations of the things to be deleted. Example:
+#
+jq -n '{a: 1, b: {c: 2}, d: [3, 4, 5]} | del(.b.c, .d[1]) | .b.x = 6'
+
+# Output:
+# {
+#   "a": 1,
+#   "b": {
+#     "x": 6
+#   },
+#   "d": [
+#     3,
+#     5
+#   ]
+# }
+
+
+# Other than using jq's built-in functions, you can define your own.
+# In fact, many built-in functions are defined using jq (see the link
+# to jq's built-in functions at the end of the doc).
+#
+jq -n '
+    def my_select(expr): if expr then . else empty end;
+    def my_map(expr): [.[] | expr];
+    def sum: reduce .[] as $x (0; . + $x);
+    def my_range($from; $to):
+        if $from >= $to then
+            empty
+        else
+            $from, my_range($from + 1; $to)
+        end
+    ;
+    [my_range(1; 6)] | my_map(my_select(. % 2 != 0)) | sum
+'
+
+# Output:
+# 9
+
+# Some notes about function definitons:
+#
+# - Functions are usually defined at the beginning, so that they are available
+#   to the rest of the jq program.
+#
+# - Each function definion should end with a `;` (semicolon).
+#
+# - It's also possible to define a function within another, though it's not shown here.
+#
+# - Function parameters are separated by `;` (semicolor). This is consistent with
+#   passing multiple arguments when calling a function.
+#
+# - A function can call itself; in fact, jq has TCO (Tail Call Optimization).
+#
+# - `def f($a; $b): ...;` is a shorthand for: `def f(a; b): a as $a | b as $b | ...`
+```
+
+
+## Further Reading
+- https://stedolan.github.io/jq/manual/
+- https://github.com/stedolan/jq/wiki/jq-Language-Description
+- https://github.com/stedolan/jq/wiki/Cookbook
+- https://github.com/stedolan/jq/blob/master/src/builtin.jq
diff --git a/jquery.html.markdown b/jquery.html.markdown
index 18077dca..cdcb89d9 100644
--- a/jquery.html.markdown
+++ b/jquery.html.markdown
@@ -12,8 +12,8 @@ jQuery is a JavaScript library that helps you "do more, write less". It makes ma
 Because jQuery is a JavaScript library you should [learn JavaScript first](https://learnxinyminutes.com/docs/javascript/)
 
 **NOTE**: jQuery has fallen out of the limelight in recent years, since you can achieve the same thing with the vanilla DOM (Document Object Model) API. So the only thing it is used for is a couple of handy features, such as the [jQuery date picker](https://api.jqueryui.com/datepicker) (which actually has a standard, unlike the `<input type="date">` HTML element), and the obvious decrease in the code length.
-```js
 
+```js
 
 ///////////////////////////////////
 // 1. Selectors
diff --git a/json.html.markdown b/json.html.markdown
index 1ccdb5cf..27f6bbe0 100644
--- a/json.html.markdown
+++ b/json.html.markdown
@@ -11,7 +11,7 @@ contributors:
 
 JSON is an extremely simple data-interchange format. As [json.org](https://json.org) says, it is easy for humans to read and write and for machines to parse and generate.
 
-A piece of JSON must represent either:
+A piece of JSON can be any value of the types listed later, but in practice almost always represents either:
 
 * A collection of name/value pairs (`{ }`). In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
 * An ordered list of values (`[ ]`). In various languages, this is realized as an array, vector, list, or sequence.
diff --git a/jsonnet.html.markdown b/jsonnet.html.markdown
index 241caf5f..f077c35b 100644
--- a/jsonnet.html.markdown
+++ b/jsonnet.html.markdown
@@ -131,7 +131,7 @@ assert obj5 == {};
 ```
 
 ## Further Reading
-There are a few but important concepts that are not touched in this exmaple, including:
+There are a few but important concepts that are not touched in this example, including:
 
 - Passing variables from command line: [Parameterize Entire Config](https://jsonnet.org/learning/tutorial.html#parameterize-entire-config)
 - Import other jsonnet libraries/files: [Imports](https://jsonnet.org/learning/tutorial.html#imports)
diff --git a/julia.html.markdown b/julia.html.markdown
index 4d8eb497..336cd2b8 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -356,6 +356,20 @@ intersect(filledSet, otherSet)      # => Set([4, 3, 5])
 union(filledSet, otherSet)          # => Set([4, 2, 3, 5, 6, 1])
 setdiff(Set([1,2,3,4]), Set([2,3,5])) # => Set([4, 1])
 
+# Assignment with `=` attaches a new label to the same value without copying
+a = [1, 2, 3]
+b = a
+# Now `b` and `a` point to the same value, so changing one affects the other:
+a[3] = 5
+b[3]  # => 5
+
+# The `copy()` function can create a shallow copy of an array, dictionary,
+# or other container
+a = [1, 2, 3]
+c = copy(a)
+a[3] = 5
+c[3] # => 3
+
 ####################################################
 ## 3. Control Flow
 ####################################################
diff --git a/kdb+.html.markdown b/kdb+.html.markdown
index 680c01c1..db842726 100644
--- a/kdb+.html.markdown
+++ b/kdb+.html.markdown
@@ -560,7 +560,7 @@ select avg height by sex from t
 / => f  | 160
 / => m  | 177.5
 
-/ If no aggreation function is specified, last is assumed
+/ If no aggregation function is specified, last is assumed
 select by sex from t
 / => sex| name   age height
 / => ---| -----------------
diff --git a/ko-kr/clojure-kr.html.markdown b/ko-kr/clojure-kr.html.markdown
index 1d9e53cd..32a5baf3 100644
--- a/ko-kr/clojure-kr.html.markdown
+++ b/ko-kr/clojure-kr.html.markdown
@@ -377,7 +377,7 @@ Clojuredocs.org는 core 함수들� 대해 다양한 예제와 문서를 보유
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
 4Clojure는 clojure/FP 스킬� 올릴 수 있는 좋� 길입니다:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org는 많고 많� 문서들� 보유하고 있습니다:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/ko-kr/go-kr.html.markdown b/ko-kr/go-kr.html.markdown
index 3012c04f..aed0918e 100644
--- a/ko-kr/go-kr.html.markdown
+++ b/ko-kr/go-kr.html.markdown
@@ -81,7 +81,7 @@ func learnTypes() {
     // non-ASCII 리터럴. Go 소스는 UTF-8로 작성해야 한다.
     g := 'Σ' // 유니코드 코드 ��트를 담고 있고, int32 타입� 가칭(alias)� rune 타입
 
-    f := 3.14195 // float64, an IEEE-754 64-bit 부�소수 타입
+    f := 3.14159 // float64, an IEEE-754 64-bit 부�소수 타입
     c := 3 + 4i  // complex128, 내부�으로는 � 개� float64 타입으로 표현�
 
     // 초기값과 함께 사용하는 var 키워드.
@@ -332,15 +332,15 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 ## � �어볼 것들
 
-Go� 대한 모든 것들� [Go 공� 웹 사�트](http://golang.org/)를 참고하�.
+Go� 대한 모든 것들� [Go 공� 웹 사�트](https://go.dev/)를 참고하�.
 여기�는 따�해볼 튜토리얼, 웹 기반� �터랙티브 실행환경과 많� ��거리들� 있다.
 
 Go 언어 �체� 대한 스펙� �어보기를 �극 추천한다. �기 쉽게 �어있고
 그리 길지는 않다.
 
-Go 소스코드� 대해 좀� 알아보고 싶다면 [Go 표준 ��브러리](http://golang.org/src/pkg/)를
+Go 소스코드� 대해 좀� 알아보고 싶다면 [Go 표준 ��브러리](https://go.dev/src/)를
 분�해보기 바란다. �해하기 쉽게 문서화�어 있고, Go 스타� 그리고 Go�서�
-관례 배우기� 가장 좋� 방법� 것�다. �는 [문서](http://golang.org/pkg/) 안�서
+관례 배우기� 가장 좋� 방법� 것�다. �는 [문서](https://go.dev/pkg/) 안�서
 함수 �름 하나를 �릭해보면 소스코드를 브�우저�서 살펴볼 수� 있다.
 
 Go를 배울수 있는 �하나� 좋� 방법� [Go by example](https://gobyexample.com/).
diff --git a/ko-kr/markdown-kr.html.markdown b/ko-kr/markdown-kr.html.markdown
index 397e9f30..0167f0ff 100644
--- a/ko-kr/markdown-kr.html.markdown
+++ b/ko-kr/markdown-kr.html.markdown
@@ -25,15 +25,18 @@ lang: ko-kr
 
 ## HTML 요소
 HTML� 마�다운� 수�셋입니다. 모든 HTML 파�� 유효한 마�다운��는 것입니다.
+
 ```md
 <!--따�서 주�과 같� HTML 요소들� 마�다운� 사용할 수 있으며, 마�다운 파서� �향�
 받지 않� 것입니다. 하지만 마�다운 파��서 HTML 요소를 만든다면 그 요소� 안�서는
 마�다운 문법� 사용할 수 없습니다.-->
 ```
+
 ## 제목
 
 �스트 앞� 붙�는 우물 정 기호(#)� 갯수� 따� `<h1>`부터 `<h6>`까지� HTML 요소를
 �쉽게 작성할 수 있습니다.
+
 ```md
 # <h1>입니다.
 ## <h2>입니다.
@@ -42,7 +45,9 @@ HTMLì�€ 마í�¬ë‹¤ìš´ì�˜ 수í�¼ì…‹ìž…니다. 모든 HTML 파ì�¼ì�€ 유효한 마í
 ##### <h5>입니다.
 ###### <h6>입니다.
 ```
+
 �한 h1과 h2를 나타내는 다른 방법� 있습니다.
+
 ```md
 h1입니다.
 =============
@@ -50,9 +55,11 @@ h1입니다.
 h2입니다.
 -------------
 ```
+
 ## 간단한 �스트 꾸미기
 
 마�다운으로 쉽게 �스트를 기울�거나 굵게 할 수 있습니다.
+
 ```md
 *기울� �스트입니다.*
 _� �스트� 같습니다._
@@ -64,10 +71,13 @@ __� �스트� 같습니다.__
 **_� �스트� 같습니다._**
 *__�것� 같습니다.__*
 ```
+
 깃헙 전용 마�다운�는 취소선� 있습니다.
+
 ```md
 ~~� �스트�는 취소선� 그려집니다.~~
 ```
+
 ## 문단
 
 문단� 하나 ��� 빈 줄로 구분�는, 한 줄 ��� �접한 �스트입니다.
@@ -103,6 +113,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, ë‘� ê°œ ì�´ìƒ�ì�˜ ë�„ì–´ì“
 
 ## 목�
 순서가 없는 목�� 별표, �하기, 하�픈� �용해 만들 수 있습니다.
+
 ```md
 * �거
 * 저거
@@ -140,6 +151,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, ë‘� ê°œ ì�´ìƒ�ì�˜ ë�„ì–´ì“
 1. 둘
 1. ì…‹
 ```
+
 (위� 예시와 똑같� 나타납니다.)
 
 목� 안� 목�� 올 수� 있습니다.
@@ -176,7 +188,7 @@ x가 없는 박스들� 체��지 않� HTML 체�박스입니다.
 
 ```md
     my_array.each do |item|
-        puts item
+      puts item
     end
 ```
 
@@ -188,12 +200,13 @@ x가 없는 박스들� 체��지 않� HTML 체�박스입니다.
 
 깃헙 전용 마�다운�서는 코드를 나타내기 위해 특별한 문법� 쓸 수 있습니다.
 
-<pre>
-<code class="highlight">&#x60;&#x60;&#x60;ruby
+````md
+```ruby
 def foobar
-    puts "Hello world!"
+  puts "Hello world!"
 end
-&#x60;&#x60;&#x60;</code></pre>
+```
+````
 
 위� 경우� 들여쓰기가 필요없� � 아니� \`\`\` 뒤� 특정해 준 언어� 문법� 따�
 색� 입혀줄 것입니다.
@@ -202,12 +215,14 @@ end
 
 수�선(`<hr/>`)� 셋 ��� 별표나 하�픈� �용해 쉽게 나타낼 수 있습니다.
 �어쓰기가 �함� 수 있습니다.
+
 ```md
 ***
 ---
 - - -
 ****************
 ```
+
 ## ��
 
 마�다운� 장� 중 하나는 ��를 만들기 쉽다는 것입니다. 대괄호 안� 나타낼 �스트를 쓰고
@@ -231,20 +246,24 @@ end
 
 참조하는 �으로 ��를 걸 수� 있습니다.
 
-<pre><code class="highlight">&#x5b;<span class="nv">� </span>][<span class="ss">��</span>]�서 � 알아보세요!
-&#x5b;<span class="nv">�하신다면 </span>][<span class="ss">foobar</span>]� 참고하세요.
+```md
+[� ][��]�서 � 알아보세요!
+[�하신다면 ][foobar]� 참고하세요.
 
-&#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>
+[��]: http://test.com/ "좋아!"
+[foobar]: http://foobar.biz/ "�다!"
+```
 
 제목� 작� 따옴표나 괄호� 들어갈 수� 있고, 완전히 �략할 수� 있습니다. 참조는 문서�
 어� 곳�든 올 수 있고 참조 ID는 유�하다면 무엇�든 � 수 있습니다.
 
 �� �스트를 ID로 사용하는 "묵시� �름"� 있습니다.
 
-<pre><code class="highlight">&#x5b;<span class="nv">�것</span>][]� ��입니다.
+```md
+[�것][]� ��입니다.
 
-&#x5b;<span class="nv">�것</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+[�것]: http://thisisalink.com/
+```
 
 하지만 보통 그렇게 추천하지는 않습니다.
 
@@ -257,9 +276,11 @@ end
 
 참조 방�� 가능합니다.
 
-<pre><code class="highlight">!&#x5b;<span class="nv">alt �성</span>][<span class="ss">�미지</span>]
+```md
+![alt �성][�미지]
 
-&#x5b;<span class="nv">�미지</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"제목� 필요하다면 여기�"</span></code></pre>
+[�미지]: relative/urls/cool/image.jpg "제목� 필요하다면 여기�"
+```
 
 ## 기타
 ### �� ��
@@ -270,9 +291,11 @@ end
 ```
 
 ### �메� �� ��
+
 ```md
 <foo@bar.com>
 ```
+
 ### 탈출 문�
 
 ```md
@@ -292,17 +315,21 @@ end
 ### 표
 
 표는 깃헙 전용 마�다운�서만 쓸 수 있고 다소 복잡하지만, 정� 쓰고 싶으시다면
+
 ```md
 | 1ì—´      | 2ì—´        | 3ì—´       |
 | :--------| :-------: | --------: |
 | 왼쪽 정렬 | 가운� 정렬 | 오른쪽 정렬 |
 | 머시기    | 머시기     | 머시기     |
 ```
+
 혹�
+
 ```md
 1ì—´ | 2ì—´ | 3ì—´
 :-- | :-: | --:
 으악 너무 못�겼어 | 그만 | 둬
 ```
+
 ---
 추가 정보를 위해, 존 그루버� 공� 문법 [(�어) 문서](http://daringfireball.net/projects/markdown/syntax)와 애� 프릿차드� 훌륭한 [(�어) 치트싯](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)� 확�하세요.
diff --git a/ko-kr/yaml-kr.html.markdown b/ko-kr/yaml-kr.html.markdown
index 4b1b29d2..c275c47f 100644
--- a/ko-kr/yaml-kr.html.markdown
+++ b/ko-kr/yaml-kr.html.markdown
@@ -2,19 +2,22 @@
 language: yaml
 filename: learnyaml-kr.yaml
 contributors:
-  - ["Leigh Brenecki", "https://github.com/adambrenecki"]
-  - ["Suhas SG", "https://github.com/jargnar"]
+- ["Leigh Brenecki", "https://github.com/adambrenecki"]
+- ["Suhas SG", "https://github.com/jargnar"]
 translators:
-  - ["Wooseop Kim", "https://github.com/linterpreteur"]
+- ["Wooseop Kim", "https://github.com/linterpreteur"]
+- ["Justin Yang", "https://github.com/justin-themedium"]
 lang: ko-kr
 ---
 
 YAML� �간� �접 쓰고 �� 수 있�� 설계� ��터 �렬화 언어입니다.
 
 YAML� 마치 파��처럼 개행과 들여쓰기� 문법�으로 �미를 준 JSON� 엄격한 수�셋입니다.
-하지만 파��과는 달리 YAML� 탭 문�를 전혀 허용하지 않습니다.
+하지만 파��과는 달리 YAML� 탭 문�를 들여쓰기� 사용하지 않습니다.
 
 ```yaml
+--- # 문서 시작
+
 # YAML� 주�� �런 �입니다.
 
 ############
@@ -22,19 +25,23 @@ YAMLì�€ 마치 파ì�´ì�¬ì²˜ëŸ¼ 개행과 들여쓰기ì—� 문법ì �으로 ì�˜ë¯¸ë
 ############
 
 # 문서 내내 �어질 루트 �체는 맵입니다.
-# 맵� 다른 언어� 딕셔너리, 해시, 혹� �체� 해당�니다.
+# 맵� 다른 언어� 딕셔너리, 해시, 혹� �체� 해당합니다.
 키: 값
 다른_키: 다른 값� 여기 옵니다.
 숫�_값: 100
-# 숫� 1� 값으로 가지기 위해서는 따옴표� 담아야 합니다.
-# 그러지 않는다면 YAML 파서는 그것� 참 값� 가지는 불리언으로 해�할 것입니다.
 과학�_표기법: 1e+12
+# 숫� 1� 불리언� 아닌 값으로 처리�니다. 불리언으로 처리하고 싶다면
+# true를 사용하세요.
 불리언: true
 �_값: null
 �어서 쓴 키: 값
 # 문�열� 따옴표를 칠 필요는 없습니다. 하지만 칠 수� 있습니다.
-하지만: "따옴표� 담� 문�열"
-"키� 따옴표� 담� 수 있습니다.": "키� ':'� 넣고 싶다면 유용합니다."
+하지만: '따옴표� 담� 문�열'
+'키� 따옴표� 담� 수 있습니다.': "키� ':'� 넣고 싶다면 유용합니다."
+작� 따옴표: '는 ''하나''� �스케�프 패턴� 갖습니다'
+� 따옴표: "는 많� 갖습니다. \", \0, \t, \u263A, \x0d\x0a == \r\n, 그리고 �."
+# UTF-8/16/32 문�는 �코딩�어야 합니다.
+첨� 2: \u00B2
 
 # 여러 줄� 문�열� (|� �용한) '리터럴 블�' 혹� (>� �용한) '접� 블�'으로
 # 쓸 수 있습니다.
@@ -59,12 +66,12 @@ YAMLì�€ 마치 파ì�´ì�¬ì²˜ëŸ¼ 개행과 들여쓰기ì—� 문법ì �으로 ì�˜ë¯¸ë
 # 모임 형 #
 ##########
 
-# 중첩� 들여쓰기로 가능합니다.
+# 중첩� 들여쓰기를 사용합니다. 2칸 �어쓰기가 많� 쓰입니다(필수는 아닙니다).
 중첩�_맵:
-    키: 값
-    다른_키: 다른 값
-    다른_중첩�_맵:
-        안녕: 안녕
+  키: 값
+  다른_키: 다른 값
+  다른_중첩�_맵:
+    안녕: 안녕
 
 # 맵� 반드시 문�열 키를 가지는 것� 아닙니다.
 0.25: 실수형 키
@@ -72,28 +79,31 @@ YAMLì�€ 마치 파ì�´ì�¬ì²˜ëŸ¼ 개행과 들여쓰기ì—� 문법ì �으로 ì�˜ë¯¸ë
 # 키는 여러 줄� 걸친 �체와 같� 복합�� 수� 있습니다.
 # ?와 그 뒤� �어쓰기로 복합 키� 시작� 나타냅니다.
 ? |
-    여러 줄짜리
-    키
+  여러 줄짜리
+  키
 : 그리고 그 값
 
-# YAML� 복합 키 문법으로 연�열 간� 매핑� 지�합니다.
+# YAML� 복합 키 문법으로 연�열 간� 매핑� 지�합니다.
 # �부 파서는 지�하지 않� 수 있습니다.
 # 예시
 ? - 맨체스터 유나�티드
   - 레알 마드리드
-: [ 2001-01-01, 2002-02-02 ]
+: [2001-01-01, 2002-02-02]
 
 # 리스트 혹� 배열� 대��는 연�열� 다�과 같습니다.
+# (들여쓰기처럼 '-'를 세는 것� 주�하세요)
 연�열:
-    - 하나
-    - 둘
-    - 0.5 # 연�열� 다른 형� �함 가능
-    - ë„·
-    - 키: 값
-      다른_키: 다른_값
-    -
-        - 연�열 안�
-        - � 다른 연�열
+  - 하나
+  - 둘
+  - 0.5 # 연�열� 다른 형� �함 가능
+  - ë„·
+  - 키: 값
+    다른_키: 다른_값
+  -
+    - 연�열 안�
+    - � 다른 연�열
+  - - - 중첩� 연�열 지시�
+      - 접힘 가능
 
 # YAML� JSON� 수�셋�기 때문�, JSON�으로 맵과 연�열� 작성할 수�
 # 있습니다.
@@ -111,17 +121,19 @@ YAMLì�€ 마치 파ì�´ì�¬ì²˜ëŸ¼ 개행과 들여쓰기ì—� 문법ì �으로 ì�˜ë¯¸ë
 
 # 앵커는 �성� 복제하거나 ��할 수 있습니다.
 기반: &기반
-    �름: 모� �름� 같다
+  �름: 모� �름� 같다
 
-��: &��
-    <<: *기반
-    나�: 10
+# 정규� << 는 병합 키 언어-비종� 타입으로 불립니다. �는 하나
+# �� 지정� 맵� 모든 키가 현재 맵 안으로 삽입�� 나타냅니다.
+��:
+  <<: *기반
+  나�: 10
 
-야옹: &야옹
-    <<: *기반
-    나�: 20
+야옹:
+  <<: *기반
+  나�: 20
 
-# ���와 야옹�는 같� �름, '모� �름� 같다'를 같습니다.
+# ���와 야옹�� '�름: 모� �름� 같다'를 갖습니다.
 
 # �한 YAML�는 명시�으로 형� 선언할 수 있는 태그가 있습니다.
 명시�_문�열: !!str 0.5
@@ -138,8 +150,7 @@ YAMLì�€ 마치 파ì�´ì�¬ì²˜ëŸ¼ 개행과 들여쓰기ì—� 문법ì �으로 ì�˜ë¯¸ë
 # 기타 YAML 형 #
 ###############
 
-# Strings and numbers aren't the only scalars that YAML can understand.
-# YAML� �해할 수 있는 스칼�는 문�열과 수만 있는 것� 아닙니다.
+# YAML� �해할 수 있는 스칼�가 문�열과 수만 있는 것� 아닙니다.
 # ISO 형� 날짜와 시간 리터럴 �한 해��니다.
 시간: 2001-12-15T02:59:43.1Z
 �어쓰기_한_시간: 2001-12-14 21:59:43.10 -5
@@ -148,25 +159,27 @@ YAMLì�€ 마치 파ì�´ì�¬ì²˜ëŸ¼ 개행과 들여쓰기ì—� 문법ì �으로 ì�˜ë¯¸ë
 # !!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=
+  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
+  하나: null
+  둘: null
+  ì…‹: null
+
+... # 문서 �
 ```
 
 ### � �기
 
-+ [(�어) YAML 공� 사�트](http://yaml.org/)
-+ [(�어) 온�� YAML 검사기](http://codebeautify.org/yaml-validator)
++ [(�어) YAML 공� 사�트](https://yaml.org/)
++ [(�어) 온�� YAML 검사기](http://www.yamllint.com/)
diff --git a/kotlin.html.markdown b/kotlin.html.markdown
index 12008074..a6fac518 100644
--- a/kotlin.html.markdown
+++ b/kotlin.html.markdown
@@ -26,7 +26,7 @@ any parameters.
 */
 fun main(args: Array<String>) {
     /*
-    Declaring values is done using either "var" or "val".
+    Declaring variables 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
@@ -297,7 +297,7 @@ fun helloWorld(val name : String) {
         else -> println("none of the above")
     }
 
-    // "when" can be used as a function that returns a value.
+    // "when" can be used as an expression that returns a value.
     var result = when (i) {
         0, 21 -> "0 or 21"
         in 1..20 -> "in the range 1 to 20"
diff --git a/lambda-calculus.html.markdown b/lambda-calculus.html.markdown
index 53a7a7cd..775907c2 100644
--- a/lambda-calculus.html.markdown
+++ b/lambda-calculus.html.markdown
@@ -41,7 +41,7 @@ Evaluation is done via
 which is essentially lexically-scoped substitution.
 
 When evaluating the
-expression `(λx.x)a`, we replace all occurences of "x" in the function's body
+expression `(λx.x)a`, we replace all occurrences of "x" in the function's body
 with "a".
 
 - `(λx.x)a` evaluates to: `a`
@@ -131,7 +131,7 @@ We can convert an expression in the lambda calculus to an expression
 in the SKI combinator calculus:
 
 1. `λx.x = I`
-2. `λx.c = Kc`
+2. `λx.c = Kc` provided that `x` does not occur free in `c`
 3. `λx.(y z) = S (λx.y) (λx.z)`
 
 Take the church number 2 for example:
diff --git a/latex.html.markdown b/latex.html.markdown
index 29a9f638..9edc057e 100644
--- a/latex.html.markdown
+++ b/latex.html.markdown
@@ -95,8 +95,9 @@ to the source code.
 
 Separate paragraphs by empty lines.
 
-You need to add a backslash after abbreviations (if not followed by a comma), because otherwise the spacing after the dot is too large:
-E.g., i.e., etc.\ are are such abbreviations.
+You need to add a tilde after abbreviations (if not followed by a comma) for a
+non-breaking space, because otherwise the spacing after the dot is too large:
+E.g., i.e., etc.~are are such abbreviations.
 
 \section{Lists}
 Lists are one of the easiest things to create in \LaTeX! I need to go shopping
@@ -140,8 +141,7 @@ about!
 Operators are essential parts of a mathematical document:
 trigonometric functions ($\sin$, $\cos$, $\tan$),
 logarithms and exponentials ($\log$, $\exp$),
-limits ($\lim$), etc.\ 
-have pre-defined LaTeX commands.
+limits ($\lim$), etc.~have pre-defined LaTeX commands.
 Let's write an equation to see how it's done:
 $\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
 
@@ -200,24 +200,24 @@ We can also insert Tables in the same way as figures.
 \begin{table}[H]
   \caption{Caption for the Table.}
   % the {} arguments below describe how each row of the table is drawn.
-  % The basic is simple: one letter for each column, to control alignment:
+  % The basics are simple: one letter for each column, to control alignment:
   % basic options are: c, l, r and p for centered, left, right and paragraph
-  % optionnally, you can add a | for a vertical line
+  % optionally, you can add a | for a vertical line
   % See https://en.wikibooks.org/wiki/LaTeX/Tables for more details
   \begin{tabular}{c|cc}  % here it means "centered | vertical line, centered centered"
-    Number &  Last Name & First Name \\ % Column rows are separated by &
+    Number &  First Name & Last Name \\ % Column rows are separated by &
     \hline % a horizontal line
     1 & Biggus & Dickus \\
     2 & Monty & Python
   \end{tabular}
   % it will approximately be displayed like this
-  % Number | Last Name     First Name
+  % Number | First Name     Last Name
   % -------|---------------------------  % because of \hline
   %   1    |   Biggus        Dickus
   %   2    |   Monty         Python
 \end{table}
 
-\section{Getting \LaTeX{} to not compile something (i.e.\ Source Code)}
+\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 with a verbatim
@@ -236,7 +236,7 @@ environment.
 
 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 compile).
+(Yes, this document actually does compile).
 
 Getting to the final document using \LaTeX{} consists of the following
 steps:
@@ -274,13 +274,13 @@ There exists two main types of links: visible URL \\
 % 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 thumbnails in the output pdf document and
+This package also produces list of thumbnails in the output PDF document and
 active links in the table of contents.
 
 \section{Writing in ASCII or other encodings}
 
 By default, historically LaTeX accepts inputs which are pure ASCII (128),
-not even extened ASCII, meaning without accents (à, è etc.) and non-Latin symbols.
+but not extended ASCII, meaning without accents (à, è etc.) and non-Latin symbols.
 
 It is easy to insert accents and basic Latin symbols, with backslash shortcuts
 Like \,c, \'e, \`A, \ae and \oe etc.  % for ç, é, À, etc
@@ -295,8 +295,8 @@ The selected font has to support the glyphs used for your document, you have to
     \usepackage[T1]{fontenc}
 \end{verbatim}
 
-Not that there also exists LuaTeX and XeLaTeX that were designed to have builtin
-support for UTF-8 and case ease your life if you don't write in a latin alphabet.
+Since LuaTeX and XeLaTeX were designed with built-in support for UTF-8, making
+life easier for writing in non-Latin alphabets.
 
 \section{End}
 
@@ -317,6 +317,8 @@ That's all for now!
 
 ## More on LaTeX
 
-* The amazing LaTeX wikibook: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/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/)
 * A quick guide for learning LaTeX: [Learn LaTeX in 30 minutes](https://www.overleaf.com/learn/latex/Learn_LaTeX_in_30_minutes)
+* An interactive platform to learn LaTeX (installationfree) [learnlatex.org/](https://www.learnlatex.org/)
+* Stack Exchange's question and answer site about TeX, LaTeX, ConTeXt, etc. [tex.stackexchange.com](https://tex.stackexchange.com/)
diff --git a/lbstanza.html.markdown b/lbstanza.html.markdown
index 19dc7db7..90e7b7e5 100644
--- a/lbstanza.html.markdown
+++ b/lbstanza.html.markdown
@@ -8,7 +8,7 @@ contributors:
 LB Stanza (or Stanza for short) is a new optionally-typed general purpose programming language from the University of California, Berkeley. Stanza was designed to help programmers tackle the complexity of architecting large programs and significantly increase the productivity of application programmers across the entire software development life cycle.
 
 
-```stanza
+```
 ; this is a comment 
 ;<A>
 This is a block comment 
@@ -193,7 +193,7 @@ while condition[0]:
 for i in 0 to 10 do:  
   vector[i] = i
 
-; stanza also supports named labels which can functin as break or return 
+; stanza also supports named labels which can function as break or return 
 ; statements
 defn another-fn (): 
   label<False> return:
@@ -218,7 +218,7 @@ for (x in xs, y in ys, z in zs) do :
   println("x:%_, y:%_, z:%_" % [x, y, z])
 
 
-;xs, ys, and zs are all "Seqable" meaing they are Seq types (sequences). 
+;xs, ys, and zs are all "Seqable" meaning they are Seq types (sequences). 
 ; the `do` identifier is a special function that just applies the body of
 ; the for loop to each element of the sequence.
 ; 
@@ -268,7 +268,7 @@ is-there = any?({_ == 2.0}, numbers)
 doc: \<doc>
     # Document Strings 
 
-    ```stanza
+    ```
     val you-can = "include code snippets, too" 
     ```
 
@@ -279,4 +279,4 @@ doc: \<doc>
     ```
 \<doc>
 defn docfn () : false 
-```
\ No newline at end of file
+```
diff --git a/ldpl.html.markdown b/ldpl.html.markdown
index 86603d94..449c8670 100644
--- a/ldpl.html.markdown
+++ b/ldpl.html.markdown
@@ -3,6 +3,7 @@ language: LDPL
 filename: learnLDPL.ldpl
 contributors:
     - ["Martín del Río", "https://github.com/lartu"]
+    - ["John Paul Wohlscheid", "https://github.com/JohnBlood"]
 ---
 
 **LDPL** is a powerful, C++ transpiled, open-source programming language designed
@@ -68,7 +69,7 @@ else if myMap:"someIndex" is not equal to 45 then
 else
     display "Else!" crlf
 end if
-# Valid LDPL comparisson operators are
+# Valid LDPL comparison operators are
 # - IS EQUAL TO
 # - IS NOT EQUAL TO
 # - IS LESS THAN
@@ -123,8 +124,8 @@ get random in myNumber # get a random number between 0 and 1
 # files, are divided in sections. The sections found in sub-procedures are
 # the PARAMETERS section, the LOCAL DATA section and the PROCEDURE section.
 # All sections except the PROCEDURE section can be skipped if they aren't
-# used. If no PARAMTERS nor LOCAL DATA sections are used, the PROCEDURE
-# keyword may be omited.
+# used. If no PARAMETERS nor LOCAL DATA sections are used, the PROCEDURE
+# keyword may be omitted.
 sub myFunction
     parameters:
         a is number # LDPL is pass by reference
diff --git a/lua.html.markdown b/lua.html.markdown
index 4a470623..f11d67a8 100644
--- a/lua.html.markdown
+++ b/lua.html.markdown
@@ -17,10 +17,7 @@ filename: learnlua.lua
 -- 1. Variables and flow control.
 ----------------------------------------------------
 
-num = 42  -- All numbers are doubles.
--- Don't freak out, 64-bit doubles have 52 bits for
--- storing exact int values; machine precision is
--- not a problem for ints that need < 52 bits.
+num = 42  -- Numbers can be integer or floating point.
 
 s = 'walternate'  -- Immutable strings like Python.
 t = "double-quotes are also fine"
@@ -58,7 +55,7 @@ foo = anUnknownVariable  -- Now foo = nil.
 aBoolValue = false
 
 -- Only nil and false are falsy; 0 and '' are true!
-if not aBoolValue then print('twas false') end
+if not aBoolValue then print('it was false') end
 
 -- 'or' and 'and' are short-circuited.
 -- This is similar to the a?b:c operator in C/js:
@@ -193,7 +190,7 @@ end
 
 -- A table can have a metatable that gives the table
 -- operator-overloadish behavior. Later we'll see
--- how metatables support js-prototypey behavior.
+-- how metatables support js-prototype behavior.
 
 f1 = {a = 1, b = 2}  -- Represents the fraction a/b.
 f2 = {a = 2, b = 3}
@@ -364,7 +361,7 @@ end)()
 -- locals inside mod.lua are invisible outside it.
 
 -- This works because mod here = M in mod.lua:
-mod.sayHello()  -- Says hello to Hrunkner.
+mod.sayHello() -- Prints: Why hello there Hrunkner
 
 -- This is wrong; sayMyName only exists in mod.lua:
 mod.sayMyName()  -- error
@@ -383,23 +380,30 @@ dofile('mod2.lua')  --> Hi! (runs it again)
 -- loadfile loads a lua file but doesn't run it yet.
 f = loadfile('mod2.lua')  -- Call f() to run it.
 
--- loadstring is loadfile for strings.
-g = loadstring('print(343)')  -- Returns a function.
+-- load is loadfile for strings.
+-- (loadstring is deprecated, use load instead)
+g = load('print(343)')  -- Returns a function.
 g()  -- Prints out 343; nothing printed before now.
 
 --]]
 
 ```
+
+## Community
+
+If you need support join the official Lua [mailing list](https://www.lua.org/lua-l.html), [irc channel](http://lua-users.org/wiki/IrcChannel), or [forum](https://luaforum.com).
+
+
 ## References
 
 I was excited to learn Lua so I could make games
 with the <a href="http://love2d.org/">Love 2D game engine</a>. That's the why.
 
-I started with <a href="https://ebens.me/post/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>.
+I started with <a href="https://ebens.me/posts/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>.
 Next I read the official <a href="http://www.lua.org/pil/contents.html">Programming in Lua</a> book.
 That's the how.
 
-It might be helpful to check out the <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Lua short
+It might be helpful to check out the <a href="http://lua-users.org/wiki/LuaShortReference">Lua short
 reference</a> on lua-users.org.
 
 The main topics not covered are standard libraries:
diff --git a/m.html.markdown b/m.html.markdown
index 96828ae5..46e7313b 100644
--- a/m.html.markdown
+++ b/m.html.markdown
@@ -17,8 +17,8 @@ more fits on one screen without scrolling.
 
 The M database is a hierarchical key-value store designed for high-throughput
 transaction processing. The database is organized into tree structures called
-"globals", which are sparse data structures with parallels to modern formats
-like JSON.
+"globals", (for global variables) which are sparse data structures with parallels
+to modern formats like JSON.
 
 Originally designed in 1966 for the healthcare applications, M continues to be
 used widely by healthcare systems and financial institutions for high-throughput
@@ -26,7 +26,7 @@ real-time applications.
 
 ### Example
 
-Here's an example M program to calculate the Fibonacci series:
+Here's an example M program using expanded syntax to calculate the Fibonacci series:
 
 ```
 fib ; compute the first few Fibonacci terms
@@ -39,28 +39,38 @@ fib ; compute the first few Fibonacci terms
 ```
 
 ### Comments
+Comments in M need at least one space before the comment marker of semicolon.
+Comments that start with at least two semicolons (;;) are guaranteed to be accessible
+within a running program.
 
 ```
-;   Comments start with a semicolon (;)
+ ;   Comments start with a semicolon (;)
 ```
 ### Data Types
 
-M has two data types:
+M has one data type (String) and three interpretations of that string.:
 
 ```
-;   Numbers - no commas, leading and trailing 0 removed.
-;       Scientific notation with 'E'.
-;       Floats with IEEE 754 double-precision values (15 digits of precision)
-;       Examples: 20, 1e3 (stored as 1000), 0500.20 (stored as 500.2)
 ;   Strings - Characters enclosed in double quotes.
 ;       "" is the null string. Use "" within a string for "
 ;       Examples: "hello", "Scrooge said, ""Bah, Humbug!"""
+;
+;   Numbers - no commas, leading and trailing 0 removed.
+;       Scientific notation with 'E'.  (not 'e')
+;       Numbers with at least with IEEE 754 double-precision values (guaranteed 15 digits of precision)
+;       Examples: 20 (stored as 20) , 1e3 (stored as 1000), 0500.20 (stored as 500.2),
+;                 the US National Debt AT sometime on 12-OCT-2020 retrieved from http://www.usdebt.org is 27041423576201.15)
+;                     (required to be stored as at least 27041422576201.10 but most implementations store as 27041432576201.15)
+;
+;   Truthvalues - String interpreted as 0  is used for false and any string interpreted as non-zero (such as 1) for true.
 ```
 ### Commands
 
-Commands are case insensitive, and have a shortened abbreviation, often the first letter. Commands have zero or more arguments,depending on the command. M is whitespace-aware. Spaces are treated as a delimiter between commands and arguments. Each command is separated from its arguments by 1 space. Commands with zero arguments are followed by 2 spaces.
+Commands are case insensitive, and have full form, and a shortened abbreviation, often the first letter. Commands have zero or more arguments,depending on the command. This page includes programs written in this terse syntax. M is whitespace-aware. Spaces are treated as a delimiter between commands and arguments. Each command is separated from its arguments by 1 space. Commands with zero arguments are followed by 2 spaces. (technically these are called argumentless commands)
+
+#### Common Commands from all National and International Standards of M
 
-#### W(rite)
+#### Write (abbreviated as W) 
 
 Print data to the current device.
 
@@ -68,13 +78,19 @@ Print data to the current device.
 WRITE !,"hello world" 
 ```
 
-! is syntax for a new line. Multiple statements can be provided as additional arguments:
+Output Formatting characters:
+
+ The ! character is syntax for a new line.
+ The # character is syntax for a new page.
+ The sequence of the ? character and then a numeric expression is syntax for output of spaces until the number'th colum is printed.
+
+Multiple statements can be provided as additional arguments before the space separators to the next command:
 
 ```
 w !,"foo bar"," ","baz" 
 ```
 
-#### R(ead)
+#### Read (abbreviated as R)
 
 Retrieve input from the user
 
@@ -82,13 +98,13 @@ Retrieve input from the user
 READ var
 r !,"Wherefore art thou Romeo? ",why
 ```
-Multiple arguments can be passed to a read command. Constants are outputted. Variables are retrieved from the user. The terminal waits for the user to enter the first variable before displaying the second prompt.
+As with all M commands, multiple arguments can be passed to a read command. Constants like quoted strings, numbers, and formatting characters are output directly. Values for both global variables and local variables are retrieved from the user. The terminal waits for the user to enter the first variable before displaying the second prompt.
 
 ```
 r !,"Better one, or two? ",lorem," Better two, or three? ",ipsum
 ```
 
-#### S(et)
+#### Set (abbreviated as S)
 
 Assign a value to a variable
 
@@ -100,19 +116,21 @@ w !,centi,!,micro
 ;.01
 ;.00001
 ```
-#### K(ill)
+#### Kill (abbreviated as K)
 
 Remove a variable from memory or remove a database entry from disk.
-
+A database node (global variable) is killed depending on the variable name being prefixed by the caret character (^).
+If it is not, then the local variable is removed from memory. 
+If KILLed, automatic garbage collection occurs.
 ```
 KILL centi
 k micro
 ```
 ### Globals and Arrays
 
-In addition to local variables, M has persistent variables stored to disk called _globals_. Global names must start with a __caret__ (__^__). Globals are the built-in database of M.
+In addition to local variables, M has persistent, shared variables that are the built-in database of M.  They are stored to disk and called _globals_. Global names must start with a __caret__ (__^__). 
 
-Any variable can be an array with the assignment of a _subscript_. Arrays are sparse and do not have a predefined size. Arrays should be visualized like trees, where subscripts are branches and assigned values are leaves. Not all nodes in an array need to have a value. 
+Any variable (local or global) can be an array with the assignment of a _subscript_. Arrays are sparse and do not have a predefined size. Only if data is stored will a value use memory. Arrays should be visualized like trees, where subscripts are branches and assigned values are leaves. Not all nodes in an array need to have a value. 
 
 ```
 s ^cars=20
@@ -128,7 +146,7 @@ w !,^cars("Tesla",1,"Name")
 ; Model 3
 ```
 
-Arrays are automatically sorted in order. Take advantage of the built-in sorting by setting your value of interest as the last child subscript of an array rather than its value.
+The index values of Arrays are automatically sorted in order. There is a catchphrase of "MUMPS means never having to say you are sorting". Take advantage of the built-in sorting by setting your value of interest as the last child subscript of an array rather than its value, and then storing an empty string for that node.
 
 ```
 ; A log of temperatures by date and time
@@ -171,13 +189,14 @@ s ^TEMPS("11/12","1700",43)=""
 #### Order of operations
 
 Operations in M are _strictly_ evaluated left to right. No operator has precedence over any other.
-You should use parentheses to group expressions.
+For example, there is NO order of operations where multiply is evaluated before addition.
+To change this order, just use parentheses to group expressions to be evaluated first.
 
 ```
 w 5+3*20
 ;160
 ;You probably wanted 65
-w 5+(3*20) 
+write 5+(3*20) 
 ```
 
 ### Flow Control, Blocks, & Code Structure
@@ -193,12 +212,12 @@ w !,$$tag^routine(a,b)
 
 M has an execution stack. When all levels of the stack have returned, the program ends. Levels are added to the stack with _do_ commands and removed with _quit_ commands.
 
-#### D(o)
+#### Do (abbreviated as D)
 
 With an argument: execute a block of code & add a level to the stack. 
 
 ```
-d ^routine    ;run a routine from the begining. 
+d ^routine    ;run a routine from the beginning. 
 ;             ;routines are identified by a caret.
 d tag         ;run a tag in the current routine
 d tag^routine ;run a tag in different routine
@@ -216,12 +235,14 @@ if a=1 do
 w "hello"
 ```
 
-#### Q(uit)
+#### Quit (abbreviated as Q)
 Stop executing this block and return to the previous stack level.
-Quit can return a value.
+Quit can return a value, following the comamnd with a single space.
+Quit can stop a loop. remember to follow with two spaces.
+Quit outside a loop will return from the current subroutine followed by two spaces or a linefeed
 
-#### N(ew)
-Clear a given variable's value _for just this stack level_. Useful for preventing side effects.
+#### New (abbreviated as N)
+Hide with a cleared value a given variable's value _for just this stack level_. Useful for preventing side effects.
 
 Putting all this together, we can create a full example of an M routine:
 
@@ -233,20 +254,22 @@ main
     n length,width ; New length and width so any previous value doesn't persist
     w !,"Welcome to RECTANGLE. Enter the dimensions of your rectangle."
     r !,"Length? ",length,!,"Width? ",width
-    d area(length,width)            ;Do a tag
-    s per=$$perimeter(length,width) ;Get the value of a function
+    d area(length,width)            ;Do/Call subroutine using a tag
+    s per=$$perimeter(length,width)      ;Get the value of a function
     w !,"Perimeter: ",per
-    q
+    quit
 
 area(length,width)  ; This is a tag that accepts parameters. 
                     ; It's not a function since it quits with no value.
     w !, "Area: ",length*width
-    q ; Quit: return to the previous level of the stack.
+    q  ; Quit: return to the previous level of the stack.
 
 perimeter(length,width)
-    q 2*(length+width) ; Quits with a value; thus a function
+    q 2*(length+width) ; Returns a value using Quit ; this is a function
 ```
 
+
+
 ### Conditionals, Looping and $Order()
 
 F(or) loops can follow a few different patterns:
@@ -255,13 +278,15 @@ F(or) loops can follow a few different patterns:
 ;Finite loop with counter
 ;f var=start:increment:stop
 
-f i=0:5:25 w i," " ;0 5 10 15 20 25 
+f i=0:5:25 w i," "
+;0 5 10 15 20 25 
 
 ; Infinite loop with counter
 ; The counter will keep incrementing forever. Use a conditional with Quit to get out of the loop.
 ;f var=start:increment 
 
-f j=1:1 w j," " i j>1E3 q ; Print 1-1000 separated by a space
+f j=1:1 w j," " i j>1E3 q
+; Print 1-1000 separated by a space
 
 ;Argumentless for - infinite loop. Use a conditional with Quit.
 ;   Also read as "forever" - f or for followed by two spaces.
@@ -355,7 +380,11 @@ f  s date=$ORDER(^TEMPS(date)) q:date=""  d
 
 ## Further Reading
 
-There's lots more to learn about M. A great short tutorial comes from the University of Northern Iowa and  Professor Kevin O'Kane's [Introduction to the MUMPS Language][1] presentation.
+There's lots more to learn about M. A great short tutorial comes from the University of Northern Iowa and  Professor Kevin O'Kane's [Introduction to the MUMPS Language][1] presentation.  More about M using VistA is at 
+
+Intersystems has some products which are a super-set of the M programming language.
+* [Iris Description Page][5]
+* [Cache Description Page][6]
 
 To install an M interpreter / database on your computer, try a [YottaDB Docker image][2]. 
 
@@ -368,3 +397,5 @@ YottaDB and its precursor, GT.M, have thorough documentation on all the language
 [2]: https://yottadb.com/product/get-started/
 [3]: https://docs.yottadb.com/ProgrammersGuide/langfeat.html
 [4]: http://tinco.pair.com/bhaskar/gtm/doc/books/pg/UNIX_manual/index.html
+[5]: https://www.intersystems.com/products/intersystems-iris/
+[6]: https://en.wikipedia.org/wiki/InterSystems_Caché
diff --git a/make.html.markdown b/make.html.markdown
index eecc96bf..f5352f9e 100644
--- a/make.html.markdown
+++ b/make.html.markdown
@@ -1,246 +1,246 @@
----

-category: tool

-tool: make

-contributors:

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

-    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

-filename: Makefile

----

-

-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 and Linux) despite many competitors and criticisms.

-

-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.

-

-# 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!

-

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

-# 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

-	# use the same quoting rules as in the shell.

-	@cat file0.txt >> file1.txt

-	# @ stops the command from being echoed to stdout.

-	-@echo 'hello'

-	# - means that make will keep going in the case of an error.

-	# Try `make file1.txt` on the commandline.

-

-# A rule can have multiple targets and multiple prerequisites

-file2.txt file3.txt: file0.txt file1.txt

-	touch file2.txt

-	touch file3.txt

-

-# Make will complain about multiple recipes for the same rule. Empty

-# recipes don't count though and can be used to add new dependencies.

-

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

-# Phony Targets

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

-

-# A phony target. Any target that isn't a file.

-# It will never be up to date so make will always try to run it.

-all: maker process

-

-# We can declare things out of order.

-maker:

-	touch ex0.txt ex1.txt

-

-# Can avoid phony rules breaking when a real file has the same name by

-.PHONY: all maker process

-# This is a special target. There are several others.

-

-# A rule with a dependency on a phony target will always run

-ex0.txt ex1.txt: maker

-

-# Common phony targets are: all make clean install ...

-

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

-# Automatic Variables & Wildcards

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

-

-process: file*.txt	#using a wildcard to match filenames

-	@echo $^	# $^ is a variable containing the list of prerequisites

-	@echo $@	# prints the target name

-	#(for multiple target rules, $@ is whichever caused the rule to run)

-	@echo $<	# the first prerequisite listed

-	@echo $?	# only the dependencies that are out of date

-	@echo $+	# all dependencies including duplicates (unlike normal)

-	#@echo $|	# all of the 'order only' prerequisites

-

-# Even if we split up the rule dependency definitions, $^ will find them

-process: ex1.txt file0.txt

-# ex1.txt will be found but file0.txt will be deduplicated.

-

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

-# Patterns

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

-

-# Can teach make how to convert certain files into other files.

-

-%.png: %.svg

-	inkscape --export-png $^

-

-# 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.

-small/%.png: %.svg

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

-

-# make will use the last version for a pattern rule that it finds.

-%.png: %.svg

-	@echo this rule is chosen

-

-# However make will use the first pattern rule that can make the target

-%.png: %.ps

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

-

-# make already has some pattern rules built-in. For instance, it knows

-# how to turn *.c files into *.o files.

-

-# Older makefiles might use suffix rules instead of pattern rules

-.png.ps:

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

-

-# Tell make about the suffix rule

-.SUFFIXES: .png

-

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

-# Variables

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

-# aka. macros

-

-# Variables are basically all string types

-

-name = Ted

-name2="Sarah"

-

-echo:

-	@echo $(name)

-	@echo ${name2}

-	@echo $name    # This won't work, treated as $(n)ame.

-	@echo $(name3) # Unknown variables are treated as empty strings.

-

-# There are 4 places to set variables.

-# In order of priority from highest to lowest:

-# 1: commandline arguments

-# 2: Makefile

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

-# 4: make has some predefined variables

-

-name4 ?= Jean

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

-

-override name5 = David

-# Stops commandline arguments from changing this variable.

-

-name4 +=grey

-# Append values to variable (includes a space).

-

-# Pattern-specific variable values (GNU extension).

-echo: name2 = Sara # True within the matching rule

-	# and also within its remade recursive dependencies

-	# (except it can break when your graph gets too complicated!)

-

-# Some variables defined automatically by make.

-echo_inbuilt:

-	echo $(CC)

-	echo ${CXX}

-	echo $(FC)

-	echo ${CFLAGS}

-	echo $(CPPFLAGS)

-	echo ${CXXFLAGS}

-	echo $(LDFLAGS)

-	echo ${LDLIBS}

-

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

-# Variables 2

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

-

-# The first type of variables are evaluated each time they are used.

-# This can be expensive, so a second type of variable exists which is

-# only evaluated once. (This is a GNU make extension)

-

-var := hello

-var2 ::=  $(var) hello

-#:= and ::= are equivalent.

-

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

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

-

-# This doesn't work

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

-var4 ::= good night

-

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

-# Functions

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

-

-# make has lots of functions available.

-

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

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

-

-# Format is $(func arg0,arg1,arg2...)

-

-# Some examples

-ls:	* src/*

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

-	@echo $(notdir $^)

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

-

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

-# Directives

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

-

-# Include other makefiles, useful for platform specific code

-include foo.mk

-

-sport = tennis

-# Conditional compilation

-report:

-ifeq ($(sport),tennis)

-	@echo 'game, set, match'

-else

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

-endif

-

-# There are also ifneq, ifdef, ifndef

-

-foo = true

-

-ifdef $(foo)

-bar = 'hello'

-endif

-```

-

-### More Resources

-

-+ [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)

+---
+category: tool
+tool: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+filename: Makefile
+---
+
+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 and Linux) despite many competitors and criticisms.
+
+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.
+
+# 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!
+
+#-----------------------------------------------------------------------
+# 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
+	# use the same quoting rules as in the shell.
+	@cat file0.txt >> file1.txt
+	# @ stops the command from being echoed to stdout.
+	-@echo 'hello'
+	# - means that make will keep going in the case of an error.
+	# Try `make file1.txt` on the commandline.
+
+# A rule can have multiple targets and multiple prerequisites
+file2.txt file3.txt: file0.txt file1.txt
+	touch file2.txt
+	touch file3.txt
+
+# Make will complain about multiple recipes for the same rule. Empty
+# recipes don't count though and can be used to add new dependencies.
+
+#-----------------------------------------------------------------------
+# Phony Targets
+#-----------------------------------------------------------------------
+
+# A phony target. Any target that isn't a file.
+# It will never be up to date so make will always try to run it.
+all: maker process
+
+# We can declare things out of order.
+maker:
+	touch ex0.txt ex1.txt
+
+# Can avoid phony rules breaking when a real file has the same name by
+.PHONY: all maker process
+# This is a special target. There are several others.
+
+# A rule with a dependency on a phony target will always run
+ex0.txt ex1.txt: maker
+
+# Common phony targets are: all make clean install ...
+
+#-----------------------------------------------------------------------
+# Automatic Variables & Wildcards
+#-----------------------------------------------------------------------
+
+process: file*.txt	#using a wildcard to match filenames
+	@echo $^	# $^ is a variable containing the list of prerequisites
+	@echo $@	# prints the target name
+	#(for multiple target rules, $@ is whichever caused the rule to run)
+	@echo $<	# the first prerequisite listed
+	@echo $?	# only the dependencies that are out of date
+	@echo $+	# all dependencies including duplicates (unlike normal)
+	#@echo $|	# all of the 'order only' prerequisites
+
+# Even if we split up the rule dependency definitions, $^ will find them
+process: ex1.txt file0.txt
+# ex1.txt will be found but file0.txt will be deduplicated.
+
+#-----------------------------------------------------------------------
+# Patterns
+#-----------------------------------------------------------------------
+
+# Can teach make how to convert certain files into other files.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# 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.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# make will use the last version for a pattern rule that it finds.
+%.png: %.svg
+	@echo this rule is chosen
+
+# However make will use the first pattern rule that can make the target
+%.png: %.ps
+	@echo this rule is not chosen if *.svg and *.ps are both present
+
+# make already has some pattern rules built-in. For instance, it knows
+# how to turn *.c files into *.o files.
+
+# Older makefiles might use suffix rules instead of pattern rules
+.png.ps:
+	@echo this rule is similar to a pattern rule.
+
+# Tell make about the suffix rule
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variables
+#-----------------------------------------------------------------------
+# aka. macros
+
+# Variables are basically all string types
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # This won't work, treated as $(n)ame.
+	@echo $(name3) # Unknown variables are treated as empty strings.
+
+# There are 4 places to set variables.
+# In order of priority from highest to lowest:
+# 1: commandline arguments
+# 2: Makefile
+# 3: shell environment variables - make imports these automatically.
+# 4: make has some predefined variables
+
+name4 ?= Jean
+# Only set the variable if environment variable is not already defined.
+
+override name5 = David
+# Stops commandline arguments from changing this variable.
+
+name4 +=grey
+# Append values to variable (includes a space).
+
+# Pattern-specific variable values (GNU extension).
+echo: name2 = Sara # True within the matching rule
+	# and also within its remade recursive dependencies
+	# (except it can break when your graph gets too complicated!)
+
+# Some variables defined automatically by make.
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variables 2
+#-----------------------------------------------------------------------
+
+# The first type of variables are evaluated each time they are used.
+# This can be expensive, so a second type of variable exists which is
+# only evaluated once. (This is a GNU make extension)
+
+var := hello
+var2 ::=  $(var) hello
+#:= and ::= are equivalent.
+
+# These variables are evaluated procedurally (in the order that they
+# appear), thus breaking with the rest of the language !
+
+# This doesn't work
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------
+
+# make has lots of functions available.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# Format is $(func arg0,arg1,arg2...)
+
+# Some examples
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Directives
+#-----------------------------------------------------------------------
+
+# Include other makefiles, useful for platform specific code
+include foo.mk
+
+sport = tennis
+# Conditional compilation
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# There are also ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+### More Resources
+
++ [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/markdown.html.markdown b/markdown.html.markdown
index cf4286e2..ee213083 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -3,12 +3,13 @@ language: markdown
 contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
     - ["Jacob Ward", "http://github.com/JacobCWard/"]
+    - ["Tomáš Hartman", "https://github.com/tomas-hartman"]
 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 
+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
@@ -17,22 +18,31 @@ specific to a certain parser.
 
 - [HTML Elements](#html-elements)
 - [Headings](#headings)
-- [Simple Text Styles](#simple-text-styles)
+- [Simple text styles](#simple-text-styles)
 - [Paragraphs](#paragraphs)
 - [Lists](#lists)
 - [Code blocks](#code-blocks)
 - [Horizontal rule](#horizontal-rule)
 - [Links](#links)
+  - [Table of contents](#table-of-contents)
 - [Images](#images)
 - [Miscellany](#miscellany)
+  - [Auto-links](#auto-links)
+  - [Auto-links for emails](#auto-links-for-emails)
+  - [Escaping characters](#escaping-characters)
+  - [Keyboard keys](#keyboard-keys)
+  - [Tables](#tables)
+- [Markdownlint](#markdownlint)
+- [Further reading](#further-reading)
 
 ## HTML Elements
+
 Markdown is a superset of HTML, so any HTML file is valid Markdown.
 
 ```md
-<!--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 
+<!--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.-->
 ```
 
@@ -49,6 +59,7 @@ text you want to be in that element by a number of hashes (#).
 ##### This is an <h5>
 ###### This is an <h6>
 ```
+
 Markdown also provides us with two alternative ways of indicating h1 and h2.
 
 ```md
@@ -81,6 +92,7 @@ GitHub, we also have strikethrough:
 ```md
 ~~This text is rendered with strikethrough.~~
 ```
+
 ## Paragraphs
 
 Paragraphs are a one or multiple adjacent lines of text separated by one or
@@ -119,6 +131,7 @@ Block quotes are easy and done with the > character.
 ```
 
 ## Lists
+
 Unordered lists can be made using asterisks, pluses, or hyphens.
 
 ```md
@@ -155,9 +168,10 @@ render the numbers in order, but this may not be a good idea.
 1. Item two
 1. Item three
 ```
-(This renders the same as the above example)
 
-You can also use sublists
+(This renders the same as the example above.)
+
+You can also use sublists.
 
 ```md
 1. Item one
@@ -189,35 +203,36 @@ a line with four spaces or a tab.
 ```
 
 You can also re-tab (or add an additional four spaces) for indentation
-inside your code
+inside your code.
 
 ```md
     my_array.each do |item|
-        puts item
+      puts item
     end
 ```
 
-Inline code can be created using the backtick character `` ` ``
+Inline code can be created using the backtick character `` ` ``.
 
 ```md
 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
+````md
+```ruby
 def foobar
-    puts "Hello world!"
+  puts "Hello world!"
 end
-&#x60;&#x60;&#x60;</code></pre>
+```
+````
 
 The above text doesn't require indenting, plus GitHub will use syntax
-highlighting of the language you specify after the \`\`\`
+highlighting of the language you specify after the opening <code>```</code>.
 
 ## Horizontal rule
 
-Horizontal rules (`<hr/>`) are easily added with three or more asterisks or 
+Horizontal rules (`<hr/>`) are easily added with three or more asterisks or
 hyphens, with or without spaces.
 
 ```md
@@ -235,11 +250,13 @@ the text to display in hard brackets [] followed by the url in parentheses ()
 ```md
 [Click me!](http://test.com/)
 ```
+
 You can also add a link title using quotes inside the parentheses.
 
 ```md
 [Click me!](http://test.com/ "Link to Test.com")
 ```
+
 Relative paths work too.
 
 ```md
@@ -248,11 +265,13 @@ Relative paths work too.
 
 Markdown also supports reference style links.
 
-<pre><code class="highlight">&#x5b;<span class="nv">Click this link</span>][<span class="ss">link1</span>] for more info about it!
-&#x5b;<span class="nv">Also check out this link</span>][<span class="ss">foobar</span>] if you want to.
+```md
+[Click this link][link1] for more info about it!
+[Also check out this link][foobar] if you want to.
 
-&#x5b;<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Cool!"</span>
-&#x5b;<span class="nv">foobar</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Alright!"</span></code></pre>
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Alright!"
+```
 
 The title can also be in single quotes or in parentheses, or omitted
 entirely. The references can be anywhere in your document and the reference IDs
@@ -260,13 +279,35 @@ can be anything so long as they are unique.
 
 There is also "implicit naming" which lets you use the link text as the id.
 
-<pre><code class="highlight">&#x5b;<span class="nv">This</span>][] is a link.
+```md
+[This][] is a link.
 
-&#x5b;<span class="nv">this</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+[This]: http://thisisalink.com/
+```
 
 But it's not that commonly used.
 
+### Table of contents
+
+Some Markdown flavors even make use of the combination of lists, links and
+headings in order to create tables of contents. In this case, heading titles in
+lowercase are prepended with hash (`#`) and are used as link ids. Should the
+heading have multiple words, they will be connected with a hyphen (`-`), that
+also replaces some special characters. (Some other special characters are
+omitted though.)
+
+```md
+- [Heading](#heading)
+- [Another heading](#another-heading)
+- [Chapter](#chapter)
+  - [Subchapter <h3 />](#subchapter-h3-)
+```
+
+Nonetheless, this is a feature that might not be working in all Markdown
+implementations the same way.
+
 ## Images
+
 Images are done the same way as links but with an exclamation point in front!
 
 ```md
@@ -275,10 +316,14 @@ Images are done the same way as links but with an exclamation point in front!
 
 And reference style works as expected.
 
-<pre><code class="highlight">!&#x5b;<span class="nv">This is the alt-attribute.</span>][<span class="ss">myimage</span>]
+```md
+![This is the alt-attribute.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "if you need a title, it's here"
+```
 
-&#x5b;<span class="nv">myimage</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"if you need a title, it's here"</span></code></pre>
 ## Miscellany
+
 ### Auto-links
 
 ```md
@@ -301,13 +346,14 @@ 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 
+In GitHub Flavored Markdown, you can use a `<kbd>` tag to represent keyboard
 keys.
 
 ```md
 Your computer crashed? Try sending a
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 ```
+
 ### Tables
 
 Tables are only available in GitHub Flavored Markdown and are slightly
@@ -319,6 +365,7 @@ cumbersome, but if you really want it:
 | Left-aligned | Centered | Right-aligned |
 | blah         | blah     | blah          |
 ```
+
 or, for the same results
 
 ```md
@@ -327,5 +374,21 @@ Col 1 | Col2 | Col3
 Ugh this is so ugly | make it | stop
 ```
 
+## Markdownlint
+
+In order to simplify work with Markdown and to unify its coding style,
+`Markdownlint` has been created. Available as a
+[separate tool](https://github.com/markdownlint/markdownlint)
+as well as a plugin for some IDEs, it can be used to ensure validity and
+readability of Markdown.
+
 ---
+
+## Further reading
+
 For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+
+If you want to learn more on some major Markdown flavors' features, see:
+
+- [GitHub flavored Markdown](https://docs.github.com/en/github/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax)
+- [GitLab flavored Markdown](https://docs.gitlab.com/ee/user/markdown.html)
diff --git a/matlab.html.markdown b/matlab.html.markdown
index ecf2fc96..b0482d0b 100644
--- a/matlab.html.markdown
+++ b/matlab.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Matlab
+language: MATLAB
 filename: learnmatlab.mat
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
@@ -134,7 +134,7 @@ A.d.e = false;
 
 % Vectors
 x = [4 32 53 7 1]
-x(2) % ans = 32, indices in Matlab start 1, not 0
+x(2) % ans = 32, indices in MATLAB start 1, not 0
 x(2:3) % ans = 32 53
 x(2:end) % ans = 32 53 7 1
 
@@ -502,7 +502,7 @@ find(x) % Finds all non-zero elements of x and returns their indexes, can use co
 
 
 % Classes
-% Matlab can support object-oriented programming. 
+% MATLAB can support object-oriented programming. 
 % Classes must be put in a file of the class name with a .m extension. 
 % To begin, we create a simple class to store GPS waypoints.
 % Begin WaypointClass.m
@@ -524,7 +524,7 @@ classdef WaypointClass % The class name.
     end
 
     % If we want to add two Waypoint objects together without calling
-    % a special function we can overload Matlab's arithmetic like so:
+    % a special function we can overload MATLAB's arithmetic like so:
     function r = plus(o1,o2)
       r = WaypointClass([o1.latitude] +[o2.latitude], ...
                         [o1.longitude]+[o2.longitude]);
@@ -536,7 +536,7 @@ end
 % We can create an object of the class using the constructor
 a = WaypointClass(45.0, 45.0)
 
-% Class properties behave exactly like Matlab Structures.
+% Class properties behave exactly like MATLAB Structures.
 a.latitude = 70.0
 a.longitude = 25.0
 
@@ -547,15 +547,15 @@ ans = multiplyLatBy(a,3)
 % does not need to be passed to the method.
 ans = a.multiplyLatBy(1/3)
 
-% Matlab functions can be overloaded to handle objects. 
-% In the method above, we have overloaded how Matlab handles 
+% MATLAB functions can be overloaded to handle objects. 
+% In the method above, we have overloaded how MATLAB handles 
 % the addition of two Waypoint objects.
 b = WaypointClass(15.0, 32.0)
 c = a + b
 
 ```
 
-## More on Matlab
+## More on MATLAB
 
 * [The official website](http://www.mathworks.com/products/matlab/)
 * [The official MATLAB Answers forum](http://www.mathworks.com/matlabcentral/answers/)
diff --git a/mercurial.html.markdown b/mercurial.html.markdown
index 98658f83..2c06ca77 100644
--- a/mercurial.html.markdown
+++ b/mercurial.html.markdown
@@ -22,13 +22,13 @@ and/or directorie(s) over time.
 
 * Distributed Architecture - Traditionally version control systems such as CVS
 and Subversion are a client server architecture with a central server to
-store the revsion history of a project. Mercurial however is a truly
-distributed architecture, giving each devloper a full local copy of the
+store the revision history of a project. Mercurial however is a truly
+distributed architecture, giving each developer a full local copy of the
 entire development history. It works independently of a central server.
 * Fast - Traditionally version control systems such as CVS and Subversion are a
-client server architecture with a central server to store the revsion history
+client server architecture with a central server to store the revision history
 of a project. Mercurial however is a truly distributed architecture, giving
-each devloper a full local copy of the entire development history. It works
+each developer a full local copy of the entire development history. It works
 independently of a central server.
 * Platform Independent - Mercurial was written to be highly platform
 independent. Much of Mercurial is written in Python, with small performance
@@ -56,7 +56,7 @@ any later version.
 | changeset | Set of changes saved as diffs |
 | diff | Changes between file(s) |
 | tag | A named named revision |
-| parent(s) | Immediate ancestor(s) of a revison |
+| parent(s) | Immediate ancestor(s) of a revision |
 | branch | A child of a revision |
 | head | A head is a changeset with no child changesets |
 | merge | The process of merging two HEADS |
@@ -184,7 +184,7 @@ Commit changes to the given files into the repository.
 # Commit with a message
 $ hg commit -m 'This is a commit message'
 
-# Commit all added / removed files in the currrent tree
+# Commit all added / removed files in the current tree
 $ hg commit -A 'Adding and removing all existing files in the tree'
 
 # amend the parent of the working directory with a new commit that contains the
@@ -341,7 +341,7 @@ $ hg revert -a
 Remove the specified files on the next commit.
 
 ```bash
-# Remove a spcific file
+# Remove a specific file
 $ hg remove go_away.txt
 
 # Remove a group of files by pattern
diff --git a/mercury.html.markdown b/mercury.html.markdown
index f749bac4..6d278ce0 100644
--- a/mercury.html.markdown
+++ b/mercury.html.markdown
@@ -254,7 +254,7 @@ received(crypto(Type, _Wallet, Amount)) = S :-  % _Wallet is named throwaway
 
 * [Mercury Tutorial](https://mercurylang.org/documentation/papers/book.pdf) (pdf link) - a more traditional tutorial with a more relaxed pace
 * [Mercury Crash Course](https://mercury-in.space/crash.html) - a dense example-driven tutorial with Q&A format
-* [Github Wiki Tutorial](https://github.com/Mercury-Language/mercury/wiki/Tutorial)
+* [GitHub Wiki Tutorial](https://github.com/Mercury-Language/mercury/wiki/Tutorial)
 * [Getting Started with Mercury](https://bluishcoder.co.nz/2019/06/23/getting-started-with-mercury.html) - installation and your first steps
   
 ### Documentation
diff --git a/mips.html.markdown b/mips.html.markdown
index 33d4f87c..3add0c5b 100644
--- a/mips.html.markdown
+++ b/mips.html.markdown
@@ -111,7 +111,7 @@ gateways and routers.
     sub $t2, $t0, $t1                       # $t2 = $t0 - $t1
     mul $t2, $t0, $t1                       # $t2 = $t0 * $t1
     div $t2, $t0, $t1                       # $t2 = $t0 / $t1 (Might not be 
-                                            # supported in some versons of MARS)
+                                            # supported in some versions of MARS)
     div $t0, $t1                            # Performs $t0 / $t1. Get the 
                                             # quotient using 'mflo' and 
                                             # remainder using 'mfhi'
@@ -162,7 +162,7 @@ gateways and routers.
     blt $t0, $t1, t0_gt_t1                  # Branches when $t0 < $t1
     ble $t0, $t1, t0_gte_t1                 # Branches when $t0 <= $t1
     bltz $t0, t0_lt0                        # Branches when $t0 < 0
-    slt $s0, $t0, $t1                       # Instruction that sends a signal 
+    slt $s0, $t0, $t1                       # "Set on Less Than"
                                             # when $t0 < $t1 with result in $s0 
                                             # (1 for true)
 
@@ -186,6 +186,7 @@ gateways and routers.
     #   else
     #     max = c;
     # else
+    #   if (b > c)
     #     max = b;
     #   else
     #     max = c;
@@ -193,7 +194,7 @@ gateways and routers.
     # Let $s0 = a, $s1 = b, $s2 = c, $v0 = return register
     ble $s0, $s1, a_LTE_b                   # if(a <= b) branch(a_LTE_b)
     ble $s0, $s2, max_C                     # if(a > b && a <=c) branch(max_C)
-    move $v0, $s1                           # else [a > b && a > c] max = a
+    move $v0, $s0                           # else [a > b && a > c] max = a
     j done                                  # Jump to the end of the program
 
     a_LTE_b:                                # Label for when a <= b
@@ -212,8 +213,9 @@ gateways and routers.
     # instruction to continue its execution
     li $t0, 0
     while:
-      bgt $t0, 10, end_while                # While $t0 is less than 10, 
+      bgt $t0, 9, end_while                 # While $t0 is less than 10, 
                                             # keep iterating
+      #actual loop content would go here
       addi $t0, $t0, 1                      # Increment the value
       j while                               # Jump back to the beginning of 
                                             # the loop
@@ -242,7 +244,7 @@ gateways and routers.
 ## FUNCTIONS ##
   _functions:
     # Functions are callable procedures that can accept arguments and return 
-    values all denoted with labels, like above
+    # values all denoted with labels, like above
 
     main:                                 # Programs begin with main func
       jal return_1                        # jal will store the current PC in $ra
@@ -293,7 +295,7 @@ gateways and routers.
 
       fact_done:
         lw $s0, ($sp)
-        lw $ra, ($sp)                     # Restore the PC
+        lw $ra, 4($sp)                     # Restore the PC
         addi $sp, $sp, 8
 
         jr $ra
@@ -357,7 +359,7 @@ gateways and routers.
   li $t1, 5                                 # Length of the list
 
   loop:
-    bgt $t0, $t1, end_loop
+    bge $t0, $t1, end_loop
 
     lw $a0, ($s0)
     li $v0, 1
diff --git a/mongodb.html.markdown b/mongodb.html.markdown
new file mode 100644
index 00000000..f4e7d709
--- /dev/null
+++ b/mongodb.html.markdown
@@ -0,0 +1,406 @@
+---
+language: MongoDB 
+filename: mongo.js 
+contributors:
+  - ["Raj Piskala", "https://www.rajpiskala.ml/"]
+---
+
+MongoDB is a NoSQL document database for high volume data storage.
+
+MongoDB uses collections and documents for its storage. Each document consists
+of key-value pairs using JSON-like syntax, similar to a dictionary or JavaScript
+object.
+
+Likewise, as MongoDB is a NoSQL database, it uses its own query language, Mongo
+Query Language (MQL) which uses JSON for querying.
+
+## Getting Started
+
+### Installation
+
+MongoDB can either be installed locally following the instructions
+[here](https://docs.mongodb.com/manual/installation/) or you can create a
+remotely-hosted free 512 MB cluster
+[here](https://www.mongodb.com/cloud/atlas/register). Links to videos with
+instructions on setup are at the bottom.
+
+This tutorial assumes that you have the MongoDB Shell from
+[here](https://www.mongodb.com/try/download/shell). You can also download the
+graphical tool, MongoDB Compass, down below from the same link.
+
+### Components
+
+After installing MongoDB, you will notice there are multiple command line tools.
+The three most important of which are:
+
+- `mongod` - The database server which is responsible for managing data and
+  handling queries
+- `mongos` - The sharding router, which is needed if data will be distributed
+  across multiple machines
+- `mongo` - The database shell (using JavaScript) through which we can configure
+  our database
+
+Usually we start the `mongod` process and then use a separate terminal with
+`mongo` to access and modify our collections.
+
+### JSON & BSON
+
+While queries in MongoDB are made using a JSON-like\* format, MongoDB stores its
+documents internally in the Binary JSON (BSON format). BSON is not human
+readable like JSON as it's a binary encoding. However, this allows for end users
+to have access to more types than regular JSON, such as an integer or float
+type. Many other types, such as regular expressions, dates, or raw binary are
+supported too.
+
+[Here](https://docs.mongodb.com/manual/reference/bson-types/) is the full list
+of all types that are supported.
+
+- We refer JSON-like to mean JSON but with these extended types. For example,
+  you can make queries directly with a regular expression or timestamp in
+  MongoDB and you can receive data that has those types too.
+
+```js
+/////////////////////////////////////////////////////////
+/////////////////// Getting Started /////////////////////
+/////////////////////////////////////////////////////////
+
+// Start up the mongo database server
+// NOTE - You will need to do this in a separate terminal as the process will 
+// take over the terminal. You may want to use the --fork option
+mongod // --fork
+
+// Connecting to a remote Mongo server
+// mongo "mongodb+srv://host.ip.address/admin" --username your-username
+
+// Mongoshell has a proper JavaScript interpreter built in
+3 + 2 // 5
+
+// Show available databases
+// MongoDB comes with the following databases built-in: admin, config, local
+show dbs
+
+// Switch to a new database (pre-existing or about to exist)
+// NOTE: There is no "create" command for a database in MongoDB. 
+// The database is created upon data being inserted into a collection
+use employees
+
+// Create a new collection
+// NOTE: Inserting a document will implicitly create a collection anyways,
+// so this is not required
+db.createCollection('engineers')
+db.createCollection('doctors')
+
+// See what collections exist under employees
+show collections
+
+/////////////////////////////////////////////////////////
+// Basic Create/Read/Update/Delete (CRUD) Operations: ///
+/////////////////////////////////////////////////////////
+
+/////////////// Insert (Create) /////////////////////////
+
+// Insert one employee into the database
+// Each insertion returns acknowledged true or false
+// Every document has a unique _id value assigned to it automatically
+db.engineers.insertOne({ name: "Jane Doe", age: 21, gender: 'Female' })
+
+// Insert a list of employees into the `engineers` collection
+// Can insert as an array of objects
+db.engineers.insert([
+  { name: "Foo Bar", age: 25, gender: 'Male' },
+  { name: "Baz Qux", age: 27, gender: 'Other' },
+])
+
+// MongoDB does not enforce a schema or structure for objects
+// Insert an empty object into the `engineers` collection
+db.engineers.insertOne({})
+
+// Fields are optional and do not have to match rest of documents
+db.engineers.insertOne({ name: "Your Name", gender: "Male" })
+
+// Types can vary and are preserved on insertion
+// This can require additional validation in some languages to prevent problems
+db.engineers.insert({ name: ['Foo', 'Bar'], age: 3.14, gender: true })
+
+// Objects or arrays can be nested inside a document
+db.engineers.insertOne({
+  name: "Your Name",
+  gender: "Female",
+  skilledIn: [
+    "MongoDB",
+    "NoSQL",
+  ],
+  "date-of-birth": {
+    "date": 1993-07-20T09:44:18.674Z,
+    "age": 26
+  },
+})
+
+// We can override the _id field
+// Works fine
+db.engineers.insertOne({
+  _id: 1,
+  name: "An Engineer",
+  age: 25,
+  gender: "Female",
+})
+
+// Be careful, as _id must ALWAYS be unique for the collection otherwise 
+// the insertion will fail
+// Fails with a WriteError indicating _id is a duplicate value
+db.engineers.insertOne({
+  _id: 1,
+  name: "Another Engineer",
+  age: 25,
+  gender: "Male",
+})
+
+// Works fine as this is a different collection
+db.doctors.insertOne({
+  _id: 1,
+  name: "Some Doctor",
+  age: 26,
+  gender: "Other",
+})
+
+/////////////////// Find (Read) ////////////////////////
+// Queries are in the form of db.collectionName.find(<filter>)
+// Where <filter> is an object
+
+// Show everything in our database so far, limited to a 
+// maximum of 20 documents at a time
+// Press i to iterate this cursor to the next 20 documents
+db.engineers.find({})
+
+// We can pretty print the result of any find() query
+db.engineers.find({}).pretty()
+
+// MongoDB queries take in a JS object and search for documents with matching 
+// key-value pairs
+// Returns the first document matching query
+// NOTE: Order of insertion is not preserved in the database, output can vary
+db.engineers.findOne({ name: 'Foo Bar' })
+
+// Returns all documents with the matching key-value properties as a cursor 
+// (which can be converted to an array)
+db.engineers.find({ age: 25 })
+
+// Type matters when it comes to queries
+// Returns nothing as all ages above are integer type
+db.engineers.find({ age: '25' })
+
+// find() supports nested objects and arrays just like create()
+db.engineers.find({
+  name: "Your Name",
+  gender: "Female",
+  skilledIn: [
+    "MongoDB",
+    "NoSQL",
+  ],
+  "date-of-birth": {
+    "date": 1993-07-20T09:44:18.674Z,
+    "age": 26
+  },
+})
+
+///////////////////////// Update ////////////////////////
+// Queries are in the form of db.collectionName.update(<filter>, <update>)
+// NOTE: <update> will always use the $set operator.
+// Several operators are covered later on in the tutorial.
+
+// We can update a single object
+db.engineers.updateOne({ name: 'Foo Bar' }, { $set: { name: 'John Doe', age: 100 }})
+
+// Or update many objects at the same time
+db.engineers.update({ age: 25 }, { $set: { age: 26 }})
+
+// We can use { upsert: true } if we would like it to insert if the document doesn't already exist,
+// or to update if it does
+// Returns matched, upserted, modified count
+db.engineers.update({ name: 'Foo Baz' },
+  { $set:
+    {
+      age: 26,
+      gender: 'Other'
+    }
+  },
+  { upsert: true }
+)
+
+/////////////////////// Delete /////////////////////////
+// Queries are in the form of db.collectionName.delete(<filter>)
+
+// Delete first document matching query, always returns deletedCount
+db.engineers.deleteOne({ name: 'Foo Baz' })
+
+// Delete many documents at once
+db.engineers.deleteMany({ gender: 'Male' })
+
+// NOTE: There are two methods db.collection.removeOne(<filter>) and 
+// db.collection.removeMany(<filter>) that also delete objects but have a
+// slightly different return value.
+// They are not included here as they have been deprecated in the NodeJS driver.
+
+/////////////////////////////////////////////////////////
+//////////////////// Operators //////////////////////////
+/////////////////////////////////////////////////////////
+
+// Operators in MongoDB have a $ prefix. For this tutorial, we are only looking 
+// at comparison and logical operators, but there are many other types of
+// operators
+
+//////////////// Comparison Operators ///////////////////
+
+// Find all greater than or greater than equal to some condition
+db.engineers.find({ age: { $gt: 25 }})
+db.engineers.find({ age: { $gte: 25 }})
+
+// Find all less than or less than equal to some condition
+db.engineers.find({ age: { $lt: 25 }})
+db.engineers.find({ age: { $lte: 25 }})
+
+// Find all equal or not equal to
+// Note: the $eq operator is added implicitly in most queries
+db.engineers.find({ age: { $eq: 25 }})
+db.engineers.find({ age: { $ne: 25 }})
+
+// Find all that match any element in the array, or not in the array
+db.engineers.find({ age: { $in: [ 20, 23, 24, 25 ]}})
+db.engineers.find({ age: { $nin: [ 20, 23, 24, 25 ]}})
+
+//////////////// Logical Operators ///////////////////
+
+// Join two query clauses together
+// NOTE: MongoDB does this implicitly for most queries
+db.engineers.find({ $and: [
+  gender: 'Female',
+  age: {
+    $gte: 18
+  }
+]})
+
+// Match either query condition
+db.engineers.find({ $or: [
+  gender: 'Female',
+  age: {
+    $gte: 18
+  }
+]})
+
+// Negates the query
+db.engineers.find({ $not: {
+  gender: 'Female'
+}})
+
+// Must match none of the query conditions
+db.engineers.find({ $nor [
+  gender: 'Female',
+  age: {
+    $gte: 18
+  }
+]})
+
+/////////////////////////////////////////////////////////
+//////////////// Database Operations: ///////////////////
+/////////////////////////////////////////////////////////
+
+// Delete (drop) the employees database
+// THIS WILL DELETE ALL DOCUMENTS IN THE DATABASE!
+db.dropDatabase()
+
+// Create a new database with some data
+use example
+db.test.insertOne({ name: "Testing data, please ignore!", type: "Test" })
+
+// Quit Mongo shell
+exit
+
+// Import/export database as BSON:
+
+// Mongodump to export data as BSON for all databases
+// Exported data is found in under "MongoDB Database Tools/bin/dump"
+// NOTE: If the command is not found, navigate to "MongoDB Database Tools/bin" 
+// and use the executable from there mongodump
+
+// Mongorestore to restore data from BSON
+mongorestore dump
+
+// Import/export database as JSON:
+// Mongoexport to export data as JSON for all databases
+mongoexport --collection=example
+
+// Mongoimport to export data as JSON for all databases
+mongoimport  --collection=example
+```
+
+## Further Reading
+
+### Setup Videos
+
+- [Install MongoDB - Windows 10](https://www.youtube.com/watch?v=85A6m1soKww)
+- [Install MongoDB - Mac](https://www.youtube.com/watch?v=DX15WbKidXY)
+- [Install MongoDB - Linux
+  (Ubuntu)](https://www.youtube.com/watch?v=wD_2pojFWoE)
+
+### Input Validation
+
+From the examples above, if input validation or structure is a concern, I would
+take a look at the following ORMs:
+
+- [Mongoose (Node.js)](https://mongoosejs.com/docs/) - Input validation through
+  schemas that support types, required values, minimum and maximum values.
+- [MongoEngine (Python)](http://mongoengine.org/) - Similar to Mongoose, but I
+  found it somewhat limited in my experience
+- [MongoKit (Python)](https://github.com/namlook/mongokit) - Another great
+  alternative to MongoEngine that I find easier to use than MongoEngine
+
+For statically strongly typed languages (e.g. Java, C++, Rust), input validation
+usually doesn't require a library as they define types and structure at compile
+time.
+
+### Resources
+
+If you have the time to spare, I would strongly recommend the courses on
+[MongoDB University](https://university.mongodb.com/). They're by MongoDB
+themselves and go into much more detail while still being concise. They're a mix
+of videos and quiz questions and this was how I gained my knowledge of MongoDB.
+
+I would recommend the following video series for learning MongoDB:
+
+- [MongoDB Crash Course - Traversy
+  Media](https://www.youtube.com/watch?v=-56x56UppqQ)
+- [MongoDB Tutorial for Beginners -
+  Amigoscode](https://www.youtube.com/watch?v=Www6cTUymCY)
+
+Language-specific ones that I used before:
+
+- [Build A REST API With Node.js, Express, & MongoDB - Web Dev
+  Simplified](https://www.youtube.com/watch?v=fgTGADljAeg)
+- [MongoDB with Python Crash Course - Tutorial for Beginners -
+  FreeCodeCamp](https://www.youtube.com/watch?v=E-1xI85Zog8)
+- [How to Use MongoDB with Java - Random
+  Coder](https://www.youtube.com/watch?v=reYPUvu2Giw)
+- [An Introduction to Using MongoDB with Rust -
+  MongoDB](https://www.youtube.com/watch?v=qFlftfLGwPM)
+
+Most of the information above was cross-referenced with the [MongoDB
+docs](https://www.mongodb.com/). Here are the docs for each section:
+
+- [MongoDB Types](https://docs.mongodb.com/manual/reference/bson-types/) - List
+  of all types that MongoDB supports natively
+- [MongoDB Operators](https://docs.mongodb.com/manual/reference/operator/) -
+  List of operators MongoDB supports natively
+- [MongoDB CRUD](https://docs.mongodb.com/manual/reference/command/nav-crud/) -
+  Commands for create, read, update, delete
+
+If you've been enjoying MongoDB so far and want to explore intermediate
+features, I would look at
+[aggregation](https://docs.mongodb.com/manual/reference/command/nav-aggregation/),
+[indexing](https://docs.mongodb.com/manual/indexes/), and
+[sharding](https://docs.mongodb.com/manual/sharding/).
+
+- Aggregation - useful for creating advanced queries to be executed by the
+  database
+- Indexing allows for caching, which allows for much faster execution of queries
+- Sharding allows for horizontal data scaling and distribution between multiple
+  machines.
diff --git a/montilang.html.markdown b/montilang.html.markdown
index cceb7aa1..14b45d31 100644
--- a/montilang.html.markdown
+++ b/montilang.html.markdown
@@ -170,7 +170,7 @@ printseven
 /# currently, preprocessor statements can be used to make c++-style constants #/
 
 &DEFINE LOOPSTR 20&
-/# must have & on either side with no spaces, 'DEFINE' is case sensative. #/
+/# must have & on either side with no spaces, 'DEFINE' is case sensitive. #/
 /# All statements are scanned and replaced before the program is run, regardless of where the statements are placed #/
 
 FOR LOOPSTR 7 PRINT . ENDFOR /# Prints '7' 20 times. At run, 'LOOPSTR' in source code is replaced with '20' #/ 
@@ -230,4 +230,4 @@ DEL 1 PRINT . /# [1, 3] #/
 ## Extra information
 
 - [MontiLang.ml](http://montilang.ml/)
-- [Github Page](https://github.com/lduck11007/MontiLang)
+- [GitHub Page](https://github.com/lduck11007/MontiLang)
diff --git a/ms-my/clojure-my.html.markdown b/ms-my/clojure-my.html.markdown
index e199c8f4..cfcdeb40 100644
--- a/ms-my/clojure-my.html.markdown
+++ b/ms-my/clojure-my.html.markdown
@@ -413,7 +413,7 @@ Clojuredocs.org mempunyai dokumentasi berserta contoh untuk menggunakan kebanyak
 [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/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org (yup, serius) juga mengandungi beberapa artikel sebagai permulaan:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/neat.html.markdown b/neat.html.markdown
deleted file mode 100644
index f02461ee..00000000
--- a/neat.html.markdown
+++ /dev/null
@@ -1,297 +0,0 @@
----
-language: neat
-contributors:
-    - ["Feep", "https://github.com/FeepingCreature"]
-filename: LearnNeat.nt
----
-
-Neat is basically a smaller version of D1 with some experimental syntax and a focus on terseness without losing the basic C-like syntax.
-
-[Read more here.](https://github.com/FeepingCreature/fcc/wiki)
-
-```c
-// single line comments start with //
-/*
-  multiline comments look like this
-*/
-/+
-  or this
-  /+ these can be nested too, same as D +/
-+/
-
-// Module name. This has to match the filename/directory.
-module LearnNeat;
-
-// Make names from another module visible in this one.
-import std.file;
-// You can import multiple things at once.
-import std.math, std.util;
-// You can even group up imports!
-import std.(process, socket);
-
-// Global functions!
-void foo() { }
-
-// Main function, same as in C.
-// string[] == "array of strings".
-// "string" is just an alias for char[],
-void main(string[] args) {
-  // Call functions with "function expression".
-  writeln "Hello World";
-  // You can do it like in C too... if you really want.
-  writeln ("Hello World");
-  // Declare a variable with "type identifier"
-  string arg = ("Hello World");
-  writeln arg;
-  // (expression, expression) forms a tuple.
-  // There are no one-value tuples though.
-  // So you can always use () in the mathematical sense.
-  // (string) arg; <- is an error
-
-  /*
-    byte: 8 bit signed integer
-      char: 8 bit UTF-8 byte component.
-    short: 16 bit signed integer
-    int: 32 bit signed integer
-    long: 64 bit signed integer
-
-    float: 32 bit floating point
-    double: 64 bit floating point
-    real: biggest native size floating point (80 bit on x86).
-
-    bool: true or false
-  */
-  int a = 5;
-  bool b = true;
-  // as in C, && and || are short-circuit evaluating.
-  b = b && false;
-  assert(b == false);
-  // "" are "format strings". So $variable will be substituted at runtime
-  // with a formatted version of the variable.
-  writeln "$a";
-  // This will just print $a.
-  writeln `$a`;
-  // you can format expressions with $()
-  writeln "$(2+2)";
-  // Note: there is no special syntax for characters.
-  char c = "a";
-  // Cast values by using type: expression.
-  // There are three kinds of casts:
-  // casts that just specify conversions that would be happening automatically
-  // (implicit casts)
-  float f = float:5;
-  float f2 = 5; // would also work
-  // casts that require throwing away information or complicated computation -
-  // those must always be done explicitly
-  // (conversion casts)
-  int i = int:f;
-  // int i = f; // would not work!
-  // and, as a last attempt, casts that just reinterpret the raw data.
-  // Those only work if the types have the same size.
-  string s = "Hello World";
-  // Arrays are (length, pointer) pairs.
-  // This is a tuple type. Tuple types are (type, type, type).
-  // The type of a tuple expression is a tuple type. (duh)
-  (int, char*) array = (int, char*): s;
-  // You can index arrays and tuples using the expression[index] syntax.
-  writeln "pointer is $(array[1]) and length is $(array[0])";
-  // You can slice them using the expression[from .. to] syntax.
-  // Slicing an array makes another array.
-  writeln "$(s[0..5]) World";
-  // Alias name = expression gives the expression a name.
-  // As opposed to a variable, aliases do not have an address
-  // and can not be assigned to. (Unless the expression is assignable)
-  alias range = 0 .. 5;
-  writeln "$(s[range]) World";
-  // You can iterate over ranges.
-  for int i <- range {
-    write "$(s[i])";
-  }
-  writeln " World";
-  // Note that if "range" had been a variable, it would be 'empty' now!
-  // Range variables can only be iterated once.
-  // The syntax for iteration is "expression <- iterable".
-  // Lots of things are iterable.
-  for char c <- "Hello" { write "$c"; }
-  writeln " World";
-  // For loops are "for test statement";
-  alias test = char d <- "Hello";
-  for test write "$d";
-  writeln " World\t\x05"; // note: escapes work
-  // Pointers: function the same as in C, btw. The usual.
-  // Do note: the pointer star sticks with the TYPE, not the VARIABLE!
-  string* p;
-  assert(p == null); // default initializer
-  p = &s;
-  writeln "$(*p)";
-  // Math operators are (almost) standard.
-  int x = 2 + 3 * 4 << 5;
-  // Note: XOR is "xor". ^ is reserved for exponentiation (once I implement that).
-  int y = 3 xor 5;
-  int z = 5;
-  assert(z++ == 5);
-  assert(++z == 7);
-  writeln "x $x y $y z $z";
-  // As in D, ~ concatenates.
-  string hewo = "Hello " ~ "World";
-  // == tests for equality, "is" tests for identity.
-  assert  (hewo == s);
-  assert !(hewo is s);
-  // same as
-  assert  (hewo !is s);
-
-  // Allocate arrays using "new array length"
-  int[] integers = new int[] 10;
-  assert(integers.length == 10);
-  assert(integers[0] == 0); // zero is default initializer
-  integers = integers ~ 5; // This allocates a new array!
-  assert(integers.length == 11);
-
-  // This is an appender array.
-  // Instead of (length, pointer), it tracks (capacity, length, pointer).
-  // When you append to it, it will use the free capacity if it can.
-  // If it runs out of space, it reallocates - but it will free the old array automatically.
-  // This makes it convenient for building arrays.
-  int[auto~] appender;
-  appender ~= 2;
-  appender ~= 3;
-  appender.free(); // same as {mem.free(appender.ptr); appender = null;}
-
-  // Scope variables are automatically freed at the end of the current scope.
-  scope int[auto~] someOtherAppender;
-  // This is the same as:
-  int[auto~] someOtherAppender2;
-  onExit { someOtherAppender2.free; }
-
-  // You can do a C for loop too
-  // - but why would you want to?
-  for (int i = 0; i < 5; ++i) { }
-  // Otherwise, for and while are the same.
-  while int i <- 0..4 {
-    assert(i == 0);
-    break; // continue works too
-  } then assert(false); // if we hadn't break'd, this would run at the end
-  // This is the height of loopdom - the produce-test-consume loop.
-  do {
-    int i = 5;
-  } while (i == 5) {
-    assert(i == 5);
-    break; // otherwise we'd go back up to do {
-  }
-
-  // This is a nested function.
-  // Nested functions can access the surrounding function.
-  string returnS() { return s; }
-  writeln returnS();
-
-  // Take the address of a function using &
-  // The type of a global function is ReturnType function(ParameterTypeTuple).
-  void function() foop = &foo;
-
-  // Similarly, the type of a nested function is ReturnType delegate(ParameterTypeTuple).
-  string delegate() returnSp = &returnS;
-  writeln returnSp();
-  // Class member functions and struct member functions also fit into delegate variables.
-  // In general, delegates are functions that carry an additional context pointer.
-  // ("fat pointers" in C)
-
-  // Allocate a "snapshot" with "new delegate".
-  // Snapshots are not closures! I used to call them closures too,
-  // but then my Haskell-using friends yelled at me so I had to stop.
-  // The difference is that snapshots "capture" their surrounding context
-  // when "new" is used.
-  // This allows things like this
-  int delegate(int) add(int a) {
-    int add_a(int b) { return a + b; }
-    // This does not work - the context of add_a becomes invalid
-    // when add returns.
-    // return &add_a;
-    // Instead:
-    return new &add_a;
-  }
-  int delegate(int) dg = add 2;
-  assert (dg(3) == 5);
-  // or
-  assert (((add 2) 3) == 5);
-  // or
-  assert (add 2 3 == 5);
-  // add can also be written as
-  int delegate(int) add2(int a) {
-    // this is an implicit, nameless nested function.
-    return new λ(int b) { return a + b; }
-  }
-  // or even
-  auto add3(int a) { return new λ(int b) -> a + b; }
-  // hahahaaa
-  auto add4 = λ(int a) -> new λ(int b) -> a + b;
-  assert(add4 2 3 == 5);
-  // If your keyboard doesn't have a λ (you poor sod)
-  // you can use \ too.
-  auto add5 = \(int a) -> new \(int b) -> a + b;
-  // Note!
-  auto nestfun = λ() { } // There is NO semicolon needed here!
-  // "}" can always substitute for "};".
-  // This provides syntactic consistency with built-in statements.
-
-
-  // This is a class.
-  // Note: almost all elements of Neat can be used on the module level
-  //       or just as well inside a function.
-  class C {
-    int a;
-    void writeA() { writeln "$a"; }
-    // It's a nested class - it exists in the context of main().
-    // so if you leave main(), any instances of C become invalid.
-    void writeS() { writeln "$s"; }
-  }
-  C cc = new C;
-  // cc is a *reference* to C. Classes are always references.
-  cc.a = 5; // Always used for property access.
-  auto ccp = &cc;
-  (*ccp).a = 6;
-  // or just
-  ccp.a = 7;
-  cc.writeA();
-  cc.writeS(); // to prove I'm not making things up
-  // Interfaces work same as in D, basically. Or Java.
-  interface E { void doE(); }
-  // Inheritance works same as in D, basically. Or Java.
-  class D : C, E {
-    override void writeA() { writeln "hahahahaha no"; }
-    override void doE() { writeln "eeeee"; }
-    // all classes inherit from Object. (toString is defined in Object)
-    override string toString() { return "I am a D"; }
-  }
-  C cd = new D;
-  // all methods are always virtual.
-  cd.writeA();
-  E e = E:cd; // dynamic class cast!
-  e.doE();
-  writeln "$e"; // all interfaces convert to Object implicitly.
-
-  // Templates!
-  // Templates are parameterized namespaces, taking a type as a parameter.
-  template Templ(T) {
-    alias hi = 5, hii = 8;
-    // Templates always have to include something with the same name as the template
-    // - this will become the template's _value_.
-    // Static ifs are evaluated statically, at compile-time.
-    // Because of this, the test has to be a constant expression,
-    // or something that can be optimized to a constant.
-    static if (types-equal (T, int)) {
-      alias Templ = hi;
-    } else {
-      alias Templ = hii;
-    }
-  }
-  assert(Templ!int == 5);
-  assert(Templ!float == 8);
-}
-```
-
-## Topics Not Covered
-
- * Extended iterator types and expressions
- * Standard library
- * Conditions (error handling)
- * Macros
diff --git a/nim.html.markdown b/nim.html.markdown
index 9730e579..81662630 100644
--- a/nim.html.markdown
+++ b/nim.html.markdown
@@ -3,7 +3,7 @@ language: Nim
 filename: learnNim.nim
 contributors:
     - ["Jason J. Ayala P.", "http://JasonAyala.com"]
-    - ["Dennis Felsing", "http://felsin9.de/nnis/"]
+    - ["Dennis Felsing", "https://dennis.felsing.org"]
 ---
 
 Nim (formerly Nimrod) is a statically typed, imperative programming language
@@ -142,7 +142,7 @@ when compileBadCode:
 # Arrays
 
 type
-  RollCounter = array[DieFaces, int]  # Array's are fixed length and
+  RollCounter = array[DieFaces, int]  # Arrays are fixed length and
   DirNames = array[Direction, string] # indexed by any ordinal type.
   Truths = array[42..44, bool]
 var
diff --git a/nix.html.markdown b/nix.html.markdown
index dde5dbec..677aaf54 100644
--- a/nix.html.markdown
+++ b/nix.html.markdown
@@ -305,6 +305,9 @@ with builtins; [
   ({x, y, ...}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
   #=> "a-b"
 
+  # The entire set can be bound to a variable using `@`
+  (args@{x, y}: args.x + "-" + args.y) { x = "a"; y = "b"; }
+  #=> "a-b"
 
   #  Errors
   #=========================================
@@ -355,7 +358,7 @@ with builtins; [
   # 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)])
+    [filename (readFile filename)])
   #=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ]
 
   # We can also download files into the Nix store.
@@ -373,5 +376,11 @@ with builtins; [
 * [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]
+  (https://ops.functionalalgebra.com/nix-by-example/)
+
+* [Zero to Nix - Nix Tutorial]
+  (https://zero-to-nix.com/)
+
 * [Rommel Martinez - A Gentle Introduction to the Nix Family]
-  (https://ebzzry.io/en/nix/#nix)
+  (https://web.archive.org/web/20210121042658/https://ebzzry.io/en/nix/#nix)
diff --git a/nl-nl/markdown-nl.html.markdown b/nl-nl/markdown-nl.html.markdown
index b5b4681c..0af78d88 100644
--- a/nl-nl/markdown-nl.html.markdown
+++ b/nl-nl/markdown-nl.html.markdown
@@ -52,7 +52,7 @@ __En deze tekst ook!__
 *__En zelfs deze!__*
 
 <!-- In de github versie van markdown, die gebruikt wordt om markdown te renderen
-op Github, is er ook doorstrepen -->
+op GitHub, is er ook doorstrepen -->
 
 ~~Deze tekst wordt doorstreept.~~
 
@@ -142,7 +142,7 @@ Dit item zal aangevinkt zijn in de gerenderde html.
 
 John wist zelfs niet dat de `go_to()` functie bestond!
 
-<!-- In Github Markdown kan je een speciale syntax gebruiken die aangeeft welke
+<!-- 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 ! -->
@@ -151,7 +151,7 @@ def foobar
 end
 \`\`\` <!-- Hier ook, geen backslashes, juist ``` -->
 
-<!-- Voor bovenstaande tekst moet geen tab gebruikt worden. Plus, Github zal syntax
+<!-- Voor bovenstaande tekst moet geen tab gebruikt worden. Plus, GitHub zal syntax
 highlighting gebruiken voor deze specifieke taal. Hier, Ruby.
 
 <!-- Horizontale lijn (<hr />) -->
@@ -215,13 +215,13 @@ 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 -->
+<!-- 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.
+<!-- Tabellen zijn momenteel enkel beschikbaar in GitHub Markdown en zijn redelijk omslachtig.
 Maar als je er echt wilt toevoegen: -->
 
 | Col1             | Col2        | Col3              |
diff --git a/objective-c.html.markdown b/objective-c.html.markdown
index c029c5fb..c179c295 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -387,7 +387,7 @@ if ([myClass respondsToSelector:selectorVar]) { // Checks if class contains meth
 // Implement the methods in an implementation (MyClass.m) file:
 @implementation MyClass {
     long distance; // Private access instance variable
-    NSNumber height;
+    NSNumber *height;
 }
 
 // To access a public variable from the interface file, use '_' followed by variable name:
diff --git a/ocaml.html.markdown b/ocaml.html.markdown
index b631df0a..2c5e13d5 100644
--- a/ocaml.html.markdown
+++ b/ocaml.html.markdown
@@ -3,26 +3,31 @@ language: OCaml
 filename: learnocaml.ml
 contributors:
     - ["Daniil Baturin", "http://baturin.org/"]
+    - ["Stanislav Modrak", "https://stanislav.gq/"]
+    - ["Luke Tong", "https://lukert.me/"]
 ---
-
 OCaml is a strictly evaluated functional language with some imperative
 features.
 
-Along with StandardML and its dialects it belongs to ML language family.
+Along with Standard ML and its dialects it belongs to ML language family.
 F# is also heavily influenced by OCaml.
 
-Just like StandardML, OCaml features both an interpreter, that can be
+Just like Standard ML, OCaml features both an interpreter, that can be
 used interactively, and a compiler.
-The interpreter binary is normally called "ocaml" and the compiler is "ocamlopt".
-There is also a bytecode compiler, "ocamlc", but there are few reasons to use it.
+The interpreter binary is normally called `ocaml` and the compiler is `ocamlopt`.
+There is also a bytecode compiler, `ocamlc`, but there are few reasons to use it.
+
+It also includes a package manager, `opam`, and a build system, `dune`.
 
 It is strongly and statically typed, but instead of using manually written
-type annotations, it infers types of expressions using Hindley-Milner algorithm.
+type annotations, it infers types of expressions using the
+[Hindley-Milner](https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system)
+algorithm.
 It makes type annotations unnecessary in most cases, but can be a major
 source of confusion for beginners.
 
 When you are in the top level loop, OCaml will print the inferred type
-after you enter an expression.
+after you enter an expression
 
 ```
 # let inc x = x	+ 1 ;;
@@ -31,8 +36,8 @@ val inc : int -> int = <fun>
 val a : int = 99
 ```
 
-For a source file you can use "ocamlc -i /path/to/file.ml" command
-to print all names and type signatures.
+For a source file you can use the `ocamlc -i /path/to/file.ml` command
+to print all names and type signatures
 
 ```
 $ cat sigtest.ml
@@ -48,12 +53,12 @@ val a : int
 ```
 
 Note that type signatures of functions of multiple arguments are
-written in curried form. A function that takes multiple arguments can be
+written in [curried](https://en.wikipedia.org/wiki/Currying) form.
+A function that takes multiple arguments can be
 represented as a composition of functions that take only one argument.
-The "f(x,y) = x + y" function from the example above applied to
-arguments 2 and 3 is equivalent to the "f0(y) = 2 + y" function applied to 3.
-Hence the "int -> int -> int" signature.
-
+The `f(x,y) = x + y` function from the example above applied to
+arguments 2 and 3 is equivalent to the `f0(y) = 2 + y` function applied to 3.
+Hence the `int -> int -> int` signature.
 
 ```ocaml
 (*** Comments ***)
@@ -65,13 +70,14 @@ Hence the "int -> int -> int" signature.
 
 (*** Variables and functions ***)
 
-(* Expressions can be separated by a double semicolon symbol, ";;".
+(* Expressions can be separated by a double semicolon ";;".
    In many cases it's redundant, but in this tutorial we use it after
    every expression for easy pasting into the interpreter shell.
    Unnecessary use of expression separators in source code files
    is often considered to be a bad style. *)
 
-(* Variable and function declarations use "let" keyword. *)
+(* Variable and function declarations use the "let" keyword. *)
+(* Variables are immutable by default in OCaml *)
 let x = 10 ;;
 
 (* OCaml allows single quote characters in identifiers.
@@ -109,42 +115,42 @@ let sqr2 = sqr (-2) ;;
    "unit" type for it that has the only one value written as "()" *)
 let print_hello () = print_endline "hello world" ;;
 
-(* Note that you must specify "()" as argument when calling it. *)
+(* Note that you must specify "()" as the argument when calling it. *)
 print_hello () ;;
 
-(* Calling a function with insufficient number of arguments
+(* Calling a function with an insufficient number of arguments
    does not cause an error, it produces a new function. *)
 let make_inc x y = x + y ;; (* make_inc is int -> int -> int *)
 let inc_2 = make_inc 2 ;;   (* inc_2 is int -> int *)
 inc_2 3 ;; (* Evaluates to 5 *)
 
-(* You can use multiple expressions in function body.
+(* You can use multiple expressions in the function body.
    The last expression becomes the return value. All other
    expressions must be of the "unit" type.
    This is useful when writing in imperative style, the simplest
-   form of it is inserting a debug print. *)
+   form of which is inserting a debug print. *)
 let print_and_return x =
     print_endline (string_of_int x);
     x
 ;;
 
 (* Since OCaml is a functional language, it lacks "procedures".
-   Every function must return something. So functions that
-   do not really return anything and are called solely for their
-   side effects, like print_endline, return value of "unit" type. *)
+   Every function must return something. So functions that do not
+   really return anything and are called solely for their side
+   effects, like print_endline, return a value of "unit" type. *)
 
 
-(* Definitions can be chained with "let ... in" construct.
-   This is roughly the same to assigning values to multiple
+(* Definitions can be chained with the "let ... in" construct.
+   This is roughly the same as assigning values to multiple
    variables before using them in expressions in imperative
    languages. *)
 let x = 10 in
 let y = 20 in
 x + y ;;
 
-(* Alternatively you can use "let ... and ... in" construct.
+(* Alternatively you can use the "let ... and ... in" construct.
    This is especially useful for mutually recursive functions,
-   with ordinary "let .. in" the compiler will complain about
+   with ordinary "let ... in" the compiler will complain about
    unbound values. *)
 let rec
   is_even = function
@@ -186,9 +192,9 @@ let my_lambda = fun x -> x * x ;;
 ~-. 3.4 (* Float only *)
 
 (* You can define your own operators or redefine existing ones.
-   Unlike SML or Haskell, only selected symbols can be used
-   for operator names and first symbol defines associativity
-   and precedence rules. *)
+   Unlike Standard ML or Haskell, only certain symbols can be
+   used for operator names and the operator's first symbol determines
+   its associativity and precedence rules. *)
 let (+) a b = a - b ;; (* Surprise maintenance programmers. *)
 
 (* More useful: a reciprocal operator for floats.
@@ -201,7 +207,7 @@ let (~/) x = 1.0 /. x ;;
 
 (* Lists are enclosed in square brackets, items are separated by
    semicolons. *)
-let my_list = [1; 2; 3] ;;
+let my_list = [1; 2; 3] ;; (* Has type "int list". *)
 
 (* Tuples are (optionally) enclosed in parentheses, items are separated
    by commas. *)
@@ -223,6 +229,10 @@ List.filter (fun x -> x mod 2 = 0) [1; 2; 3; 4] ;;
    often referred to as "cons". *)
 1 :: [2; 3] ;; (* Gives [1; 2; 3] *)
 
+(* Remember that the cons :: constructor can only cons a single item to the front
+   of a list. To combine two lists use the append @ operator *)
+[1; 2] @ [3; 4] ;; (* Gives [1; 2; 3; 4] *)
+
 (* Arrays are enclosed in [| |] *)
 let my_array = [| 1; 2; 3 |] ;;
 
@@ -258,7 +268,7 @@ let ocaml = (String.make 1 'O') ^ "Caml" ;;
 (* There is a printf function. *)
 Printf.printf "%d %s" 99 "bottles of beer" ;;
 
-(* Unformatted read and write functions are there too. *)
+(* There's also unformatted read and write functions. *)
 print_string "hello world\n" ;;
 print_endline "hello world" ;;
 let line = read_line () ;;
@@ -291,15 +301,59 @@ let my_point = Point (2.0, 3.0) ;;
 type 'a list_of_lists = 'a list list ;;
 type int_list_list = int list_of_lists ;;
 
+(* These features allow for useful optional types *)
+type 'a option = Some of 'a | None ;;
+let x = Some x ;;
+let y = None ;;
+
 (* Types can also be recursive. Like in this type analogous to
-   built-in list of integers. *)
+   a built-in list of integers. *)
 type my_int_list = EmptyList | IntList of int * my_int_list ;;
 let l = IntList (1, EmptyList) ;;
 
+(* or Trees *)
+type 'a tree =
+   | Empty
+   | Node of 'a tree * 'a * 'a tree
+
+let example_tree: int tree =
+   Node (
+      Node (Empty, 7, Empty),
+      5,
+      Node (Empty, 9, Empty)
+   )
+(*
+   5
+  / \
+ 7   9
+*)
+
+(*** Records ***)
+
+(* A collection of values with named fields *)
+
+type animal = 
+   {
+      name: string;
+      color: string;
+      legs: int;
+   }
+;;
+
+let cow = 
+   {  name: "cow";
+      color: "black and white";
+      legs: 4; 
+   }
+;;
+val cow : animal
+
+cow.name ;;
+- : string = "cow"
 
 (*** Pattern matching ***)
 
-(* Pattern matching is somewhat similar to switch statement in imperative
+(* Pattern matching is somewhat similar to the switch statement in imperative
    languages, but offers a lot more expressive power.
 
    Even though it may look complicated, it really boils down to matching
@@ -311,7 +365,7 @@ let l = IntList (1, EmptyList) ;;
 let is_zero x =
     match x with
     | 0 -> true
-    | _ -> false  (* The "_" pattern means "anything else". *)
+    | _ -> false  (* The "_" means "anything else". *)
 ;;
 
 (* Alternatively, you can use the "function" keyword. *)
@@ -342,6 +396,19 @@ let say x =
 
 say (Cat "Fluffy") ;; (* "Fluffy says meow". *)
 
+(* However, pattern matching must be exhaustive *)
+type color = Red | Blue | Green ;;
+let what_color x = 
+   match x with 
+   | Red -> "color is red"
+   | Blue -> "color is blue"
+   (* Won't compile! You have to add a _ case or a Green case 
+      to ensure all possibilities are accounted for *)
+;;
+(* Also, the match statement checks each case in order.
+   So, if a _ case appears first, none of the 
+   following cases will be reached! *)
+
 (** Traversing data structures with pattern matching **)
 
 (* Recursive types can be traversed with pattern matching easily.
@@ -369,9 +436,75 @@ let rec sum_int_list l =
 let t = Cons (1, Cons (2, Cons (3, Nil))) ;;
 sum_int_list t ;;
 
+(* Heres a function to tell if a list is sorted *)
+let rec is_sorted l = 
+   match l with 
+   | x :: y :: tail -> x <= y && is_sorted (y :: tail)
+   | _ -> true
+;;
+
+is_sorted [1; 2; 3] ;; (* True *)
+(* OCaml's powerful type inference guesses that l is of type int list
+   since the <= operator is used on elements of l *)
+
+(* And another to reverse a list *)
+let rec rev (l: 'a list) : 'a list = 
+  match l with 
+  | [] -> []
+  | x::tl -> (rev tl) @ [x]
+;;
+
+rev [1; 2; 3] ;; (* Gives [3; 2; 1] *)
+(* This function works on lists of any element type *)
+
+(*** Higher Order Functions ***)
+
+(* Functions are first class in OCaml *)
+
+let rec transform (f: 'a -> 'b) (l: 'a list) : 'b list =
+  match l with
+  | [] -> []
+  | head :: tail -> (f head) :: transform f tail
+;;
+
+transform (fun x -> x + 1) [1; 2; 3] ;; (* Gives [2; 3; 4] *)
+
+(** Lets combine everything we learned! **)
+let rec filter (pred: 'a -> bool) (l: 'a list) : 'a list =
+  begin match l with
+  | [] -> []
+  | x :: xs ->
+     let rest = filter pred xs in
+     if pred x then x :: rest else rest
+  end
+;;
+
+filter (fun x -> x < 4) [3; 1; 4; 1; 5] ;; (* Gives [3; 1; 1]) *)
+
+(*** Mutability ***)
+
+(* Records and variables are immutable: you cannot change where a variable points to *)
+
+(* However, you can create mutable polymorphic fields *)
+type counter = { mutable num : int } ;;
+
+let c = { num: 0 } ;;
+c.num ;; (* Gives 0 *)
+c.num <- 1 ;; (* <- operator can set mutable record fields *)
+c.num ;; (* Gives 1 *)
+
+(* OCaml's standard library provides a ref type to make single field mutability easier *)
+type 'a ref = { mutable contents : 'a } ;;
+let counter = ref 0 ;;
+!counter ;; (* ! operator returns x.contents *)
+counter := !counter + 1 ;; (* := can be used to set contents *)
 ```
 
 ## Further reading
 
-* Visit the official website to get the compiler and read the docs: <http://ocaml.org/>
-* Try interactive tutorials and a web-based interpreter by OCaml Pro: <http://try.ocamlpro.com/>
+* Visit the official website to get the compiler and read the docs: [http://ocaml.org/](http://ocaml.org/)
+* Quick tutorial on OCaml: [https://ocaml.org/docs/up-and-running](https://ocaml.org/docs/up-and-running)
+* Complete online OCaml v5 playground: [https://ocaml.org/play](https://ocaml.org/play)
+* An up-to-date (2022) book (with free online version) "Real World OCaml": [https://www.cambridge.org/core/books/real-world-ocaml-functional-programming-for-the-masses/052E4BCCB09D56A0FE875DD81B1ED571](https://www.cambridge.org/core/books/real-world-ocaml-functional-programming-for-the-masses/052E4BCCB09D56A0FE875DD81B1ED571)
+* Online interactive textbook "OCaml Programming: Correct + Efficient + Beautiful" from Cornell University: [https://cs3110.github.io/textbook/cover.html](https://cs3110.github.io/textbook/cover.html)
+* Try interactive tutorials and a web-based interpreter by OCaml Pro: [http://try.ocamlpro.com/](http://try.ocamlpro.com/)
diff --git a/opencv.html.markdown b/opencv.html.markdown
index d1f7ec51..b083feb8 100644
--- a/opencv.html.markdown
+++ b/opencv.html.markdown
@@ -114,13 +114,15 @@ eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
 img = cv2.imread('human.jpg')
 gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
-aces = face_cascade.detectMultiScale(gray, 1.3, 5)
+faces = face_cascade.detectMultiScale(gray, 1.3, 5)
 for (x,y,w,h) in faces:
+    # Draw a rectangle around detected face
     cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
     roi_gray = gray[y:y+h, x:x+w]
     roi_color = img[y:y+h, x:x+w]
     eyes = eye_cascade.detectMultiScale(roi_gray)
     for (ex,ey,ew,eh) in eyes:
+        # Draw a rectangle around detected eyes
         cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
 
 cv2.imshow('img',img)
@@ -138,7 +140,6 @@ cv2.destroyAllWindows()
 * An up-to-date language reference can be found at [https://opencv.org](https://opencv.org)
 * Additional resources may be found at [https://en.wikipedia.org/wiki/OpenCV](https://en.wikipedia.org/wiki/OpenCV)
 * Good OpenCv Tutorials
-    * [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html](https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html)
     * [https://realpython.com/python-opencv-color-spaces](https://realpython.com/python-opencv-color-spaces)
     * [https://pyimagesearch.com](https://pyimagesearch.com)
     * [https://www.learnopencv.com](https://www.learnopencv.com)
diff --git a/opengl.html.markdown b/opengl.html.markdown
index 83ace3e8..f6a9085f 100644
--- a/opengl.html.markdown
+++ b/opengl.html.markdown
@@ -1,765 +1,765 @@
----

-category: tool

-tool: OpenGL

-filename: learnopengl.cpp

-contributors:

-    - ["Simon Deitermann", "s.f.deitermann@t-online.de"]

----

-

-**Open Graphics Library** (**OpenGL**) is a cross-language cross-platform application programming interface

-(API) for rendering 2D computer graphics and 3D vector graphics.<sup>[1]</sup> In this tutorial we will be

-focusing on modern OpenGL from 3.3 and above, ignoring "immediate-mode", Displaylists and

-VBO's without use of Shaders.

-I will be using C++ with SFML for window, image and context creation aswell as GLEW

-for modern OpenGL extensions, though there are many other librarys available.

-

-```cpp

-// Creating an SFML window and OpenGL basic setup.

-#include <GL/glew.h>

-#include <GL/gl.h>

-#include <SFML/Graphics.h>

-#include <iostream>

-

-int main() {

-    // First we tell SFML how to setup our OpenGL context.

-    sf::ContextSettings context{ 24,   // depth buffer bits

-                                  8,   // stencil buffer bits

-                                  4,   // MSAA samples

-                                  3,   // major opengl version

-                                  3 }; // minor opengl version

-    // Now we create the window, enable VSync

-    // and set the window active for OpenGL.

-    sf::Window window{ sf::VideoMode{ 1024, 768 },

-                       "opengl window",

-                       sf::Style::Default,

-		       context };

-    window.setVerticalSyncEnabled(true);

-    window.setActive(true);

-    // After that we initialise GLEW and check if an error occured.

-    GLenum error;

-    glewExperimental = GL_TRUE;

-    if ((err = glewInit()) != GLEW_OK)

-        std::cout << glewGetErrorString(err) << std::endl;

-    // Here we set the color glClear will clear the buffers with.

-    glClearColor(0.0f,    // red

-                 0.0f,    // green

-                 0.0f,    // blue

-                 1.0f);   // alpha

-    // Now we can start the event loop, poll for events and draw objects.

-    sf::Event event{ };

-    while (window.isOpen()) {

-        while (window.pollEvent(event)) {

-            if (event.type == sf::Event::Closed)

-                window.close;

-        }

-        // Tell OpenGL to clear the color buffer

-        // and the depth buffer, this will clear our window.

-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

-        // Flip front- and backbuffer.

-        window.display();

-    }

-    return 0;

-}

-```

-

-## Loading Shaders

-

-After creating a window and our event loop we should create a function,

-that sets up our shader program.

-

-```cpp

-GLuint createShaderProgram(const std::string& vertexShaderPath,

-                           const std::string& fragmentShaderPath) {

-    // Load the vertex shader source.

-    std::stringstream ss{ };

-    std::string vertexShaderSource{ };

-    std::string fragmentShaderSource{ };

-    std::ifstream file{ vertexShaderPath };

-    if (file.is_open()) {

-        ss << file.rdbuf();

-        vertexShaderSource = ss.str();

-        file.close();

-    }

-    // Clear the stringstream and load the fragment shader source.

-    ss.str(std::string{ });

-    file.open(fragmentShaderPath);

-    if (file.is_open()) {

-        ss << file.rdbuf();

-        fragmentShaderSource = ss.str();

-        file.close();

-    }

-    // Create the program.

-    GLuint program = glCreateProgram();

-    // Create the shaders.

-    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);

-    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

-    // Now we can load the shader source into the shader objects and compile them.

-    // Because glShaderSource() wants a const char* const*,

-    // we must first create a const char* and then pass the reference.

-    const char* cVertexSource = vertexShaderSource.c_str();

-    glShaderSource(vertexShader,     // shader

-                   1,                // number of strings

-                   &cVertexSource,   // strings

-                   nullptr);         // length of strings (nullptr for 1)

-    glCompileShader(vertexShader);

-    // Now we have to do the same for the fragment shader.

-    const char* cFragmentSource = fragmentShaderSource.c_str();

-    glShaderSource(fragmentShader, 1, &cFragmentSource, nullptr);

-    glCompileShader(fragmentShader);

-    // After attaching the source and compiling the shaders,

-    // we attach them to the program;

-    glAttachShader(program, vertexShader);

-    glAttachShader(program, fragmentShader);

-    glLinkProgram(program);

-    // After linking the shaders we should detach and delete

-    // them to prevent memory leak.

-    glDetachShader(program, vertexShader);

-    glDetachShader(program, fragmentShader);

-    glDeleteShader(vertexShader);

-    glDeleteShader(fragmentShader);

-    // With everything done we can return the completed program.

-    return program;

-}

-```

-

-If you want to check the compilation log you can add the following between <code>glCompileShader()</code> and <code>glAttachShader()</code>.

-

-```cpp

-GLint logSize = 0;

-std::vector<GLchar> logText{ };

-glGetShaderiv(vertexShader,         // shader

-              GL_INFO_LOG_LENGTH,   // requested parameter

-              &logSize);            // return object

-if (logSize > 0) {

-    logText.resize(logSize);

-    glGetShaderInfoLog(vertexShader,      // shader

-                       logSize,           // buffer length

-                       &logSize,          // returned length

-                       logText.data());   // buffer

-    std::cout << logText.data() << std::endl;

-}

-```

-

-The same is possibile after <code>glLinkProgram()</code>, just replace <code>glGetShaderiv()</code> with <code>glGetProgramiv()</code>

-and <code>glGetShaderInfoLog()</code> with <code>glGetProgramInfoLog()</code>.

-

-```cpp

-// Now we can create a shader program with a vertex and a fragment shader.

-// ...

-glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

-

-GLuint program = createShaderProgram("vertex.glsl", "fragment.glsl");

-

-sf::Event event{ };

-// ...

-// We also have to delete the program at the end of the application.

-// ...

-    }

-    glDeleteProgram(program);	

-    return 0;

-}

-// ...

-```

-

-Ofcourse we have to create the vertex and fragment shader before we can load them,

-so lets create two basic shaders.

-

-**Vertex Shader**

-

-```glsl

-// Declare which version of GLSL we use.

-// Here we declare, that we want to use the OpenGL 3.3 version of GLSL.

-#version 330 core

-// At attribute location 0 we want an input variable of type vec3,

-// that contains the position of the vertex.

-// Setting the location is optional, if you don't set it you can ask for the

-// location with glGetAttribLocation().

-layout(location = 0) in vec3 position;

-// Every shader starts in it's main function.

-void main() {

-    // gl_Position is a predefined variable that holds

-    // the final vertex position.

-    // It consists of a x, y, z and w coordinate.

-    gl_Position = vec4(position, 1.0);

-}

-```

-

-**Fragment Shader**

-

-```glsl

-#version 330 core

-// The fragment shader does not have a predefined variable for

-// the vertex color, so we have to define a output vec4,

-// that holds the final vertex color.

-out vec4 outColor;

-

-void main() {

-    // We simply set the ouput color to red.

-    // The parameters are red, green, blue and alpha.

-    outColor = vec4(1.0, 0.0, 0.0, 1.0);

-}

-```

-

-## VAO and VBO

-Now we need to define some vertex position we can pass to our shaders. Lets define a simple 2D quad.

-

-```cpp

-// The vertex data is defined in a counter-clockwise way,

-// as this is the default front face.

-std::vector<float> vertexData {

-    -0.5f,  0.5f, 0.0f,

-    -0.5f, -0.5f, 0.0f,

-     0.5f, -0.5f, 0.0f,

-     0.5f,  0.5f, 0.0f

-};

-// If you want to use a clockwise definition, you can simply call

-glFrontFace(GL_CW);

-// Next we need to define a Vertex Array Object (VAO).

-// The VAO stores the current state while its active.

-GLuint vao = 0;

-glGenVertexArrays(1, &vao);

-glBindVertexArray(vao);

-// With the VAO active we can now create a Vertex Buffer Object (VBO).

-// The VBO stores our vertex data.

-GLuint vbo = 0;

-glGenBuffers(1, &vbo);

-glBindBuffer(GL_ARRAY_BUFFER, vbo);

-// For reading and copying there are also GL_*_READ and GL_*_COPY,

-// if your data changes more often use GL_DYNAMIC_* or GL_STREAM_*.

-glBufferData(GL_ARRAY_BUFFER,     // target buffer

-             sizeof(vertexData[0]) * vertexData.size(),   // size

-             vertexData.data(),   // data

-             GL_STATIC_DRAW);     // usage

-// After filling the VBO link it to the location 0 in our vertex shader,

-// which holds the vertex position.

-// ...

-// To ask for the attibute location, if you haven't set it:

-GLint posLocation = glGetAttribLocation(program, "position");

-// ..

-glEnableVertexAttribArray(0);

-glVertexAttribPointer(0, 3,       // location and size

-                      GL_FLOAT,   // type of data

-                      GL_FALSE,   // normalized (always false for floats)

-                      0,          // stride (interleaved arrays)

-                      nullptr);   // offset (interleaved arrays)

-// Everything should now be saved in our VAO and we can unbind it and the VBO.

-glBindVertexArray(0);

-glBindBuffer(GL_ARRAY_BUFFER, 0);

-// Now we can draw the vertex data in our render loop.

-// ...

-glClear(GL_COLOR_BUFFER_BIT);

-// Tell OpenGL we want to use our shader program.

-glUseProgram(program);

-// Binding the VAO loads the data we need.

-glBindVertexArray(vao);

-// We want to draw a quad starting at index 0 of the VBO using 4 indices.

-glDrawArrays(GL_QUADS, 0, 4);

-glBindVertexArray(0);

-window.display();

-// ...

-// Ofcource we have to delete the allocated memory for the VAO and VBO at

-// the end of our application.

-// ...

-glDeleteBuffers(1, &vbo);

-glDeleteVertexArrays(1, &vao);

-glDeleteProgram(program);

-return 0;

-// ...

-```

-

-You can find the current code here: [OpenGL - 1](https://pastebin.com/W8jdmVHD).

-

-## More VBO's and Color

-Let's create another VBO for some colors.

-

-```cpp

-std::vector<float> colorData {

-    1.0f, 0.0f, 0.0f,

-    0.0f, 1.0f, 0.0f,

-    0.0f, 0.0f, 1.0f,

-    1.0f, 1.0f, 0.0f

-};

-```

-

-Next we can simply change some previous parameters to create a second VBO for our colors.

-

-```cpp

-// ...

-GLuint vbo[2];

-glGenBuffers(2, vbo);

-glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);

-// ...

-glDeleteBuffers(2, vbo);

-/ ...

-// With these changes made we now have to load our color data into the new VBO

-// ...

-glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);

-

-glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);

-glBufferData(GL_ARRAY_BUFFER, sizeof(colorData[0]) * colorData.size(),

-             colorData.data(), GL_STATIC_DRAW);

-glEnableVertexAttribArray(1);

-glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);

-

-glBindVertexArray(0);  

-// ...

-```

-

-Next we have to change our vertex shader to pass the color data to the fragment shader.<br>

-**Vertex Shader**

-

-```glsl

-#version 330 core

-

-layout(location = 0) in vec3 position;

-// The new location has to differ from any other input variable.

-// It is the same index we need to pass to

-// glEnableVertexAttribArray() and glVertexAttribPointer().

-layout(location = 1) in vec3 color;

-

-out vec3 fColor;

-

-void main() {

-    fColor = color;

-    gl_Position = vec4(position, 1.0);

-}

-```

-

-**Fragment Shader**

-

-```glsl

-#version 330 core

-

-in vec3 fColor;

-

-out vec4 outColor;

-

-void main() {

-    outColor = vec4(fColor, 1.0);

-}

-```

-

-We define a new input variable ```color``` which represents our color data, this data

-is passed on to ```fColor```, which is an output variable of our vertex shader and

-becomes an input variable for our fragment shader.

-It is imporatant that variables passed between shaders have the exact same name

-and type.

-

-## Handling VBO's

-

-```cpp

-// If you want to completely clear and refill a VBO use glBufferData(),

-// just like we did before.

-// ...

-// There are two mains ways to update a subset of a VBO's data.

-// To update a VBO with existing data

-std::vector<float> newSubData {

-	-0.25f, 0.5f, 0.0f

-};

-glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);

-glBufferSubData(GL_ARRAY_BUFFER,      // target buffer

-                0,                    // offset

-                sizeof(newSubData[0]) * newSubData.size(),   // size

-                newSubData.data());   // data

-// This would update the first three values in our vbo[0] buffer.

-// If you want to update starting at a specific location just set the second

-// parameter to that value and multiply by the types size.

-// ...

-// If you are streaming data, for example from a file,

-// it is faster to directly pass the data to the buffer.

-// Other access values are GL_READ_ONLY and GL_READ_WRITE.

-glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);

-// You can static_cast<float*>() the void* to be more safe.

-void* Ptr = glMapBuffer(GL_ARRAY_BUFFER,   // buffer to map

-                        GL_WRITE_ONLY);    // access to buffer

-memcpy(Ptr, newSubData.data(), sizeof(newSubData[0]) * newSubData.size());

-// To copy to a specific location add a destination offset to memcpy().

-glUnmapBuffer(GL_ARRAY_BUFFER);

-// ...

-// There is also a way to copy data from one buffer to another,

-// If we have two VBO's vbo[0] and vbo[1], we can copy like so

-// You can also read from GL_ARRAY_BUFFER.

-glBindBuffer(GL_COPY_READ_BUFFER, vbo[0]);

-// GL_COPY_READ_BUFFER and GL_COPY_WRITE_BUFFER are specifically for

-// copying buffer data.

-glBindBuffer(GL_COPY_WRITE_BUFFER, vbo[1]);

-glCopyBufferSubData(GL_COPY_READ_BUFFER,    // read buffer

-                    GL_COPY_WRITE_BUFFER,   // write buffer

-                    0, 0,                   // read and write offset

-                    sizeof(vbo[0]) * 3);    // copy size

-// This will copy the first three elements from vbo[0] to vbo[1].

-```

-

-## Uniforms

-

-**Fragment Shader**

-

-```glsl

-// Uniforms are variables like in and out, however,

-// we can change them easily by passing new values with glUniform().

-// Lets define a time variable in our fragment shader.

-#version 330 core

-// Unlike a in/out variable we can use a uniform in every shader,

-// without the need to pass it to the next one, they are global.

-// Don't use locations already used for attributes!

-// Uniform layout locations require OpenGL 4.3!

-layout(location = 10) uniform float time;

-

-in vec3 fColor;

-

-out vec4 outColor;

-

-void main() {

-    // Create a sine wave from 0 to 1 based on the time passed to the shader.

-    float factor = (sin(time * 2) + 1) / 2;

-    outColor = vec4(fColor.r * factor, fColor.g * factor, fColor.b * factor, 1.0);

-}

-```

-

-Back to our source code.

-

-```cpp

-// If we haven't set the layout location, we can ask for it.

-GLint timeLocation = glGetUniformLocation(program, "time");

-// ...

-// Also we should define a Timer counting the current time.

-sf::Clock clock{ };

-// In out render loop we can now update the uniform every frame.

-    // ...

-    window.display();

-    glUniform1f(10,   // location

-                clock.getElapsedTime().asSeconds());   // data

-}

-// ...

-```

-

-With the time getting updated every frame the quad should now be changing from

-fully colored to pitch black.

-There are different types of glUniform() you can find simple documentation here:

-[glUniform - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glUniform.xhtml)

-

-## Indexing and IBO's

-

-Element Array Buffers or more commonly Index Buffer Objects (IBO) allow us to use the

-same vertex data again which makes drawing a lot easier and faster. here's an example:

-

-```cpp

-// Lets create a quad from two rectangles.

-// We can simply use the old vertex data from before.

-// First, we have to create the IBO.

-// The index is referring to the first declaration in the VBO.

-std::vector<unsigned int> iboData {

-    0, 1, 2,

-    0, 2, 3

-};

-// That's it, as you can see we could reuse 0 - the top left

-// and 2 - the bottom right.

-// Now that we have our data, we have to fill it into a buffer.

-// Note that this has to happen between the two glBindVertexArray() calls,

-// so it gets saved into the VAO.

-GLuint ibo = 0;

-glGenBufferrs(1, &ibo);

-glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

-glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(iboData[0]) * iboData.size(),

-             iboData.data(), GL_STATIC_DRAW);

-// Next in our render loop, we replace glDrawArrays() with:

-glDrawElements(GL_TRIANGLES, iboData.size(), GL_UNSINGED_INT, nullptr);

-// Remember to delete the allocated memory for the IBO.

-```

-

-You can find the current code here: [OpenGL - 2](https://pastebin.com/R3Z9ACDE).

-

-## Textures

-

-To load out texture we first need a library that loads the data, for simplicity I will be

-using SFML, however there are a lot of librarys for loading image data.

-

-```cpp

-// Lets save we have a texture called "my_tex.tga", we can load it with:

-sf::Image image;

-image.loadFromFile("my_tex.tga");

-// We have to flip the texture around the y-Axis, because OpenGL's texture

-// origin is the bottom left corner, not the top left.

-image.flipVertically();

-// After loading it we have to create a OpenGL texture.

-GLuint texture = 0;

-glGenTextures(1, &texture);

-glBindTexture(GL_TEXTURE_2D, texture);

-// Specify what happens when the coordinates are out of range.

-glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

-glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

-// Specify the filtering if the object is very large.

-glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

-glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

-// Load the image data to the texture.

-glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.getSize().x, image.getSize().y,

-             0, GL_RGBA, GL_UNSIGNED_BYTE, image.getPixelsPtr());

-// Unbind the texture to prevent modifications.

-glBindTexture(GL_TEXTURE_2D, 0);

-// Delete the texture at the end of the application.

-// ...

-glDeleteTextures(1, &texture);

-```

-

-Ofcourse there are more texture formats than only 2D textures,

-You can find further information on parameters here:

-[glBindTexture - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glBindTexture.xhtml)<br>

-[glTexImage2D - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexImage2D.xhtml)<br>

-[glTexParameter - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexParameter.xhtml)<br>

-

-```cpp

-// With the texture created, we now have to specify the UV,

-// or in OpenGL terms ST coordinates.

-std::vector<float> texCoords {

-    // The texture coordinates have to match the triangles/quad

-    // definition.

-    0.0f, 1.0f,	   // start at top-left

-    0.0f, 0.0f,	   // go round counter-clockwise

-    1.0f, 0.0f,

-    1.0f, 1.0f     // end at top-right

-};

-// Now we increase the VBO's size again just like we did for the colors.

-// ...

-GLuint vbo[3];

-glGenBuffers(3, vbo);

-// ...

-glDeleteBuffers(3, vbo);

-// ...

-// Load the texture coordinates into the new buffer.

-glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);

-glBufferData(GL_ARRAY_BUFFER, sizeof(texCoords[0]) * texCoords.size(),

-             texCoords.data(), GL_STATIC_DRAW);

-glEnableVertexAttribArray(2);

-glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, nullptr);

-// Because the VAO does not store the texture we have to bind it before drawing.

-// ...

-glBindVertexArray(vao);

-glBindTexture(GL_TEXTURE_2D, texture);

-glDrawElements(GL_TRIANGLES, iboData.size(), GL_UNSINGED_INT, nullptr);

-// ...

-```

-

-Change the shaders to pass the data to the fragment shader.<br>

-

-**Vertex Shader**

-

-```glsl

-#version 330 core

-

-layout(location = 0) in vec3 position;

-layout(location = 1) in vec3 color;

-layout(location = 2) in vec2 texCoords;

-

-out vec3 fColor;

-out vec2 fTexCoords;

-

-void main() {

-    fColor = color;

-    fTexCoords = texCoords;

-    gl_Position = vec4(position, 1.0);

-}

-```

-

-**Fragment Shader**

-

-```glsl

-#version 330 core

-// sampler2D represents our 2D texture.

-uniform sampler2D tex;

-uniform float time;

-

-in vec3 fColor;

-in vec2 fTexCoords;

-

-out vec4 outColor;

-

-void main() {

-    // texture() loads the current texure data at the specified texture coords,

-    // then we can simply multiply them by our color.

-    outColor = texture(tex, fTexCoords) * vec4(fColor, 1.0);

-}

-```

-

-You can find the current code here: [OpenGL - 3](https://pastebin.com/u3bcwM6q)

-

-## Matrix Transformation

-

-**Vertex Shader**

-

-```glsl

-#version 330 core

-

-layout(location = 0) in vec3 position;

-layout(location = 1) in vec3 color;

-layout(location = 2) in vec2 texCoords;

-// Create 2 4x4 matricies, 1 for the projection matrix

-// and 1 for the model matrix.

-// Because we draw in a static scene, we don't need a view matrix.

-uniform mat4 projection;

-uniform mat4 model;

-

-out vec3 fColor;

-out vec2 fTexCoords;

-

-void main() {

-    fColor = color;

-    fTexCoords = texCoords;

-    // Multiplay the position by the model matrix and then by the

-    // projection matrix.

-    // Beware order of multiplication for matricies!

-    gl_Position = projection * model * vec4(position, 1.0);

-}

-```

-

-In our source we now need to change the vertex data, create a model- and a projection matrix.

-

-```cpp

-// The new vertex data, counter-clockwise declaration.

-std::vector<float> vertexData {  

-    0.0f, 1.0f, 0.0f,   // top left

-    0.0f, 0.0f, 0.0f,   // bottom left

-    1.0f, 0.0f, 0.0f,   // bottom right

-    1.0f, 1.0f, 0.0f    // top right

-};

-// Request the location of our matricies.

-GLint projectionLocation = glGetUniformLocation(program, "projection");

-GLint modelLocation = glGetUniformLocation(program, "model");

-// Declaring the matricies.

-// Orthogonal matrix for a 1024x768 window.

-std::vector<float> projection {  

-    0.001953f,       0.0f,  0.0f, 0.0f,

-         0.0f, -0.002604f,  0.0f, 0.0f,

-         0.0f,       0.0f, -1.0f, 0.0f,

-        -1.0f,       1.0f,  0.0f, 1.0f

-};

-// Model matrix translating to x 50, y 50

-// and scaling to x 200, y 200.

-std::vector<float> model {  

-    200.0f,   0.0f, 0.0f, 0.0f,

-      0.0f, 200.0f, 0.0f, 0.0f,

-      0.0f,   0.0f, 1.0f, 0.0f,

-     50.0f,  50.0f, 0.0f, 1.0f

-};

-// Now we can send our calculated matricies to the program.

-glUseProgram(program);

-glUniformMatrix4fv(projectionLocation,   // location

-                   1,                    // count

-                   GL_FALSE,             // transpose the matrix

-                   projection.data());   // data

-glUniformMatrix4fv(modelLocation, 1, GL_FALSE, model.data());

-glUseProgram(0);

-// The glUniform*() calls have to be done, while the program is bound.

-```

-

-The application should now display the texture at the defined position and size.<br>

-You can find the current code here: [OpenGL - 4](https://pastebin.com/9ahpFLkY)

-

-```cpp

-// There are many math librarys for OpenGL, which create

-// matricies and vectors, the most used in C++ is glm (OpenGL Mathematics).

-// Its a header only library.

-// The same code using glm would look like:

-glm::mat4 projection{ glm::ortho(0.0f, 1024.0f, 768.0f, 0.0f) };

-glUniformMatrix4fv(projectionLocation, 1, GL_FALSE,

-                   glm::value_ptr(projection));

-// Initialise the model matrix to the identity matrix, otherwise every

-// multiplication would be 0.

-glm::mat4 model{ 1.0f };

-model = glm::translate(model, glm::vec3{ 50.0f, 50.0f, 0.0f });

-model = glm::scale(model, glm::vec3{ 200.0f, 200.0f, 0.0f });

-glUniformMatrix4fv(modelLocation, 1, GL_FALSE,

-                   glm::value_ptr(model));

-```

-

-## Geometry Shader

-

-Gemoetry shaders were introduced in OpenGL 3.2, they can produce vertices

-that are send to the rasterizer. They can also change the primitive type e.g.

-they can take a point as an input and output other primitives.

-Geometry shaders are inbetween the vertex and the fragment shader.

-

-**Vertex Shader**

-

-```glsl

-#version 330 core

-

-layout(location = 0) in vec3 position;

-layout(location = 1) in vec3 color;

-// Create an output interface block passed to the next shadaer stage.

-// Interface blocks can be used to structure data passed between shaders.

-out VS_OUT {

-    vec3 color;

-} vs_out;

-

-void main() {

-    vs_out.color = color

-    gl_Position = vec4(position, 1.0);

-}

-```

-

-**Geometry Shader**

-

-```glsl

-#version 330 core

-// The geometry shader takes in points.

-layout(points) in;

-// It outputs a triangle every 3 vertices emitted.

-layout(triangle_strip, max_vertices = 3) out;

-// VS_OUT becomes an input variable in the geometry shader.

-// Every input to the geometry shader in treated as an array.

-in VS_OUT {

-    vec3 color;

-} gs_in[];

-// Output color for the fragment shader.

-// You can also simply define color as 'out vec3 color',

-// If you don't want to use interface blocks.

-out GS_OUT {

-    vec3 color;

-} gs_out;

-

-void main() {

-    // Each emit calls the fragment shader, so we set a color for each vertex.

-    gs_out.color = mix(gs_in[0].color, vec3(1.0, 0.0, 0.0), 0.5);

-    // Move 0.5 units to the left and emit the new vertex.

-    // gl_in[] is the current vertex from the vertex shader, here we only

-    // use 0, because we are receiving points.

-    gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, 0.0);

-    EmitVertex();

-    gs_out.color = mix(gs_in[0].color, vec3(0.0, 1.0, 0.0), 0.5);

-    // Move 0.5 units to the right and emit the new vertex.

-    gl_Position = gl_in[0].gl_Position + vec4(0.5, 0.0, 0.0, 0.0);

-    EmitVertex();

-    gs_out.color = mix(gs_in[0].color, vec3(0.0, 0.0, 1.0), 0.5);

-    // Move 0.5 units up and emit the new vertex.

-    gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.75, 0.0, 0.0);

-    EmitVertex();

-    EndPrimitive();

-}

-```

-

-**Fragment Shader**

-

-```glsl

-in GS_OUT {

-    vec3 color;

-} fs_in;

-

-out vec4 outColor;

-

-void main() {

-    outColor = vec4(fs_in.color, 1.0);

-}

-```

-

-If you now store a single point with a single color in a VBO and draw them,

-you should see a triangle, with your color mixed half way between

-red, green and blue on each vertex.

-

-

-## Quotes

-<sup>[1]</sup>[OpenGL - Wikipedia](https://en.wikipedia.org/wiki/OpenGL)

-

-## Books

-

-- OpenGL Superbible - Fifth Edition (covering OpenGL 3.3)

-- OpenGL Programming Guide - Eighth Edition (covering OpenGL 4.3)

+---
+category: tool
+tool: OpenGL
+filename: learnopengl.cpp
+contributors:
+    - ["Simon Deitermann", "s.f.deitermann@t-online.de"]
+---
+
+**Open Graphics Library** (**OpenGL**) is a cross-language cross-platform application programming interface
+(API) for rendering 2D computer graphics and 3D vector graphics.<sup>[1]</sup> In this tutorial we will be
+focusing on modern OpenGL from 3.3 and above, ignoring "immediate-mode", Displaylists and
+VBO's without use of Shaders.
+I will be using C++ with SFML for window, image and context creation aswell as GLEW
+for modern OpenGL extensions, though there are many other librarys available.
+
+```cpp
+// Creating an SFML window and OpenGL basic setup.
+#include <GL/glew.h>
+#include <GL/gl.h>
+#include <SFML/Graphics.h>
+#include <iostream>
+
+int main() {
+    // First we tell SFML how to setup our OpenGL context.
+    sf::ContextSettings context{ 24,   // depth buffer bits
+                                  8,   // stencil buffer bits
+                                  4,   // MSAA samples
+                                  3,   // major opengl version
+                                  3 }; // minor opengl version
+    // Now we create the window, enable VSync
+    // and set the window active for OpenGL.
+    sf::Window window{ sf::VideoMode{ 1024, 768 },
+                       "opengl window",
+                       sf::Style::Default,
+		       context };
+    window.setVerticalSyncEnabled(true);
+    window.setActive(true);
+    // After that we initialise GLEW and check if an error occurred.
+    GLenum error;
+    glewExperimental = GL_TRUE;
+    if ((err = glewInit()) != GLEW_OK)
+        std::cout << glewGetErrorString(err) << std::endl;
+    // Here we set the color glClear will clear the buffers with.
+    glClearColor(0.0f,    // red
+                 0.0f,    // green
+                 0.0f,    // blue
+                 1.0f);   // alpha
+    // Now we can start the event loop, poll for events and draw objects.
+    sf::Event event{ };
+    while (window.isOpen()) {
+        while (window.pollEvent(event)) {
+            if (event.type == sf::Event::Closed)
+                window.close;
+        }
+        // Tell OpenGL to clear the color buffer
+        // and the depth buffer, this will clear our window.
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        // Flip front- and backbuffer.
+        window.display();
+    }
+    return 0;
+}
+```
+
+## Loading Shaders
+
+After creating a window and our event loop we should create a function,
+that sets up our shader program.
+
+```cpp
+GLuint createShaderProgram(const std::string& vertexShaderPath,
+                           const std::string& fragmentShaderPath) {
+    // Load the vertex shader source.
+    std::stringstream ss{ };
+    std::string vertexShaderSource{ };
+    std::string fragmentShaderSource{ };
+    std::ifstream file{ vertexShaderPath };
+    if (file.is_open()) {
+        ss << file.rdbuf();
+        vertexShaderSource = ss.str();
+        file.close();
+    }
+    // Clear the stringstream and load the fragment shader source.
+    ss.str(std::string{ });
+    file.open(fragmentShaderPath);
+    if (file.is_open()) {
+        ss << file.rdbuf();
+        fragmentShaderSource = ss.str();
+        file.close();
+    }
+    // Create the program.
+    GLuint program = glCreateProgram();
+    // Create the shaders.
+    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
+    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+    // Now we can load the shader source into the shader objects and compile them.
+    // Because glShaderSource() wants a const char* const*,
+    // we must first create a const char* and then pass the reference.
+    const char* cVertexSource = vertexShaderSource.c_str();
+    glShaderSource(vertexShader,     // shader
+                   1,                // number of strings
+                   &cVertexSource,   // strings
+                   nullptr);         // length of strings (nullptr for 1)
+    glCompileShader(vertexShader);
+    // Now we have to do the same for the fragment shader.
+    const char* cFragmentSource = fragmentShaderSource.c_str();
+    glShaderSource(fragmentShader, 1, &cFragmentSource, nullptr);
+    glCompileShader(fragmentShader);
+    // After attaching the source and compiling the shaders,
+    // we attach them to the program;
+    glAttachShader(program, vertexShader);
+    glAttachShader(program, fragmentShader);
+    glLinkProgram(program);
+    // After linking the shaders we should detach and delete
+    // them to prevent memory leak.
+    glDetachShader(program, vertexShader);
+    glDetachShader(program, fragmentShader);
+    glDeleteShader(vertexShader);
+    glDeleteShader(fragmentShader);
+    // With everything done we can return the completed program.
+    return program;
+}
+```
+
+If you want to check the compilation log you can add the following between <code>glCompileShader()</code> and <code>glAttachShader()</code>.
+
+```cpp
+GLint logSize = 0;
+std::vector<GLchar> logText{ };
+glGetShaderiv(vertexShader,         // shader
+              GL_INFO_LOG_LENGTH,   // requested parameter
+              &logSize);            // return object
+if (logSize > 0) {
+    logText.resize(logSize);
+    glGetShaderInfoLog(vertexShader,      // shader
+                       logSize,           // buffer length
+                       &logSize,          // returned length
+                       logText.data());   // buffer
+    std::cout << logText.data() << std::endl;
+}
+```
+
+The same is possible after <code>glLinkProgram()</code>, just replace <code>glGetShaderiv()</code> with <code>glGetProgramiv()</code>
+and <code>glGetShaderInfoLog()</code> with <code>glGetProgramInfoLog()</code>.
+
+```cpp
+// Now we can create a shader program with a vertex and a fragment shader.
+// ...
+glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+
+GLuint program = createShaderProgram("vertex.glsl", "fragment.glsl");
+
+sf::Event event{ };
+// ...
+// We also have to delete the program at the end of the application.
+// ...
+    }
+    glDeleteProgram(program);	
+    return 0;
+}
+// ...
+```
+
+Ofcourse we have to create the vertex and fragment shader before we can load them,
+so lets create two basic shaders.
+
+**Vertex Shader**
+
+```glsl
+// Declare which version of GLSL we use.
+// Here we declare, that we want to use the OpenGL 3.3 version of GLSL.
+#version 330 core
+// At attribute location 0 we want an input variable of type vec3,
+// that contains the position of the vertex.
+// Setting the location is optional, if you don't set it you can ask for the
+// location with glGetAttribLocation().
+layout(location = 0) in vec3 position;
+// Every shader starts in it's main function.
+void main() {
+    // gl_Position is a predefined variable that holds
+    // the final vertex position.
+    // It consists of a x, y, z and w coordinate.
+    gl_Position = vec4(position, 1.0);
+}
+```
+
+**Fragment Shader**
+
+```glsl
+#version 330 core
+// The fragment shader does not have a predefined variable for
+// the vertex color, so we have to define a output vec4,
+// that holds the final vertex color.
+out vec4 outColor;
+
+void main() {
+    // We simply set the output color to red.
+    // The parameters are red, green, blue and alpha.
+    outColor = vec4(1.0, 0.0, 0.0, 1.0);
+}
+```
+
+## VAO and VBO
+Now we need to define some vertex position we can pass to our shaders. Lets define a simple 2D quad.
+
+```cpp
+// The vertex data is defined in a counter-clockwise way,
+// as this is the default front face.
+std::vector<float> vertexData {
+    -0.5f,  0.5f, 0.0f,
+    -0.5f, -0.5f, 0.0f,
+     0.5f, -0.5f, 0.0f,
+     0.5f,  0.5f, 0.0f
+};
+// If you want to use a clockwise definition, you can simply call
+glFrontFace(GL_CW);
+// Next we need to define a Vertex Array Object (VAO).
+// The VAO stores the current state while its active.
+GLuint vao = 0;
+glGenVertexArrays(1, &vao);
+glBindVertexArray(vao);
+// With the VAO active we can now create a Vertex Buffer Object (VBO).
+// The VBO stores our vertex data.
+GLuint vbo = 0;
+glGenBuffers(1, &vbo);
+glBindBuffer(GL_ARRAY_BUFFER, vbo);
+// For reading and copying there are also GL_*_READ and GL_*_COPY,
+// if your data changes more often use GL_DYNAMIC_* or GL_STREAM_*.
+glBufferData(GL_ARRAY_BUFFER,     // target buffer
+             sizeof(vertexData[0]) * vertexData.size(),   // size
+             vertexData.data(),   // data
+             GL_STATIC_DRAW);     // usage
+// After filling the VBO link it to the location 0 in our vertex shader,
+// which holds the vertex position.
+// ...
+// To ask for the attribute location, if you haven't set it:
+GLint posLocation = glGetAttribLocation(program, "position");
+// ..
+glEnableVertexAttribArray(0);
+glVertexAttribPointer(0, 3,       // location and size
+                      GL_FLOAT,   // type of data
+                      GL_FALSE,   // normalized (always false for floats)
+                      0,          // stride (interleaved arrays)
+                      nullptr);   // offset (interleaved arrays)
+// Everything should now be saved in our VAO and we can unbind it and the VBO.
+glBindVertexArray(0);
+glBindBuffer(GL_ARRAY_BUFFER, 0);
+// Now we can draw the vertex data in our render loop.
+// ...
+glClear(GL_COLOR_BUFFER_BIT);
+// Tell OpenGL we want to use our shader program.
+glUseProgram(program);
+// Binding the VAO loads the data we need.
+glBindVertexArray(vao);
+// We want to draw a quad starting at index 0 of the VBO using 4 indices.
+glDrawArrays(GL_QUADS, 0, 4);
+glBindVertexArray(0);
+window.display();
+// ...
+// Ofcource we have to delete the allocated memory for the VAO and VBO at
+// the end of our application.
+// ...
+glDeleteBuffers(1, &vbo);
+glDeleteVertexArrays(1, &vao);
+glDeleteProgram(program);
+return 0;
+// ...
+```
+
+You can find the current code here: [OpenGL - 1](https://pastebin.com/W8jdmVHD).
+
+## More VBO's and Color
+Let's create another VBO for some colors.
+
+```cpp
+std::vector<float> colorData {
+    1.0f, 0.0f, 0.0f,
+    0.0f, 1.0f, 0.0f,
+    0.0f, 0.0f, 1.0f,
+    1.0f, 1.0f, 0.0f
+};
+```
+
+Next we can simply change some previous parameters to create a second VBO for our colors.
+
+```cpp
+// ...
+GLuint vbo[2];
+glGenBuffers(2, vbo);
+glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
+// ...
+glDeleteBuffers(2, vbo);
+/ ...
+// With these changes made we now have to load our color data into the new VBO
+// ...
+glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
+glBufferData(GL_ARRAY_BUFFER, sizeof(colorData[0]) * colorData.size(),
+             colorData.data(), GL_STATIC_DRAW);
+glEnableVertexAttribArray(1);
+glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+glBindVertexArray(0);  
+// ...
+```
+
+Next we have to change our vertex shader to pass the color data to the fragment shader.<br>
+**Vertex Shader**
+
+```glsl
+#version 330 core
+
+layout(location = 0) in vec3 position;
+// The new location has to differ from any other input variable.
+// It is the same index we need to pass to
+// glEnableVertexAttribArray() and glVertexAttribPointer().
+layout(location = 1) in vec3 color;
+
+out vec3 fColor;
+
+void main() {
+    fColor = color;
+    gl_Position = vec4(position, 1.0);
+}
+```
+
+**Fragment Shader**
+
+```glsl
+#version 330 core
+
+in vec3 fColor;
+
+out vec4 outColor;
+
+void main() {
+    outColor = vec4(fColor, 1.0);
+}
+```
+
+We define a new input variable ```color``` which represents our color data, this data
+is passed on to ```fColor```, which is an output variable of our vertex shader and
+becomes an input variable for our fragment shader.
+It is imporatant that variables passed between shaders have the exact same name
+and type.
+
+## Handling VBO's
+
+```cpp
+// If you want to completely clear and refill a VBO use glBufferData(),
+// just like we did before.
+// ...
+// There are two mains ways to update a subset of a VBO's data.
+// To update a VBO with existing data
+std::vector<float> newSubData {
+	-0.25f, 0.5f, 0.0f
+};
+glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
+glBufferSubData(GL_ARRAY_BUFFER,      // target buffer
+                0,                    // offset
+                sizeof(newSubData[0]) * newSubData.size(),   // size
+                newSubData.data());   // data
+// This would update the first three values in our vbo[0] buffer.
+// If you want to update starting at a specific location just set the second
+// parameter to that value and multiply by the types size.
+// ...
+// If you are streaming data, for example from a file,
+// it is faster to directly pass the data to the buffer.
+// Other access values are GL_READ_ONLY and GL_READ_WRITE.
+glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
+// You can static_cast<float*>() the void* to be more safe.
+void* Ptr = glMapBuffer(GL_ARRAY_BUFFER,   // buffer to map
+                        GL_WRITE_ONLY);    // access to buffer
+memcpy(Ptr, newSubData.data(), sizeof(newSubData[0]) * newSubData.size());
+// To copy to a specific location add a destination offset to memcpy().
+glUnmapBuffer(GL_ARRAY_BUFFER);
+// ...
+// There is also a way to copy data from one buffer to another,
+// If we have two VBO's vbo[0] and vbo[1], we can copy like so
+// You can also read from GL_ARRAY_BUFFER.
+glBindBuffer(GL_COPY_READ_BUFFER, vbo[0]);
+// GL_COPY_READ_BUFFER and GL_COPY_WRITE_BUFFER are specifically for
+// copying buffer data.
+glBindBuffer(GL_COPY_WRITE_BUFFER, vbo[1]);
+glCopyBufferSubData(GL_COPY_READ_BUFFER,    // read buffer
+                    GL_COPY_WRITE_BUFFER,   // write buffer
+                    0, 0,                   // read and write offset
+                    sizeof(vbo[0]) * 3);    // copy size
+// This will copy the first three elements from vbo[0] to vbo[1].
+```
+
+## Uniforms
+
+**Fragment Shader**
+
+```glsl
+// Uniforms are variables like in and out, however,
+// we can change them easily by passing new values with glUniform().
+// Lets define a time variable in our fragment shader.
+#version 330 core
+// Unlike a in/out variable we can use a uniform in every shader,
+// without the need to pass it to the next one, they are global.
+// Don't use locations already used for attributes!
+// Uniform layout locations require OpenGL 4.3!
+layout(location = 10) uniform float time;
+
+in vec3 fColor;
+
+out vec4 outColor;
+
+void main() {
+    // Create a sine wave from 0 to 1 based on the time passed to the shader.
+    float factor = (sin(time * 2) + 1) / 2;
+    outColor = vec4(fColor.r * factor, fColor.g * factor, fColor.b * factor, 1.0);
+}
+```
+
+Back to our source code.
+
+```cpp
+// If we haven't set the layout location, we can ask for it.
+GLint timeLocation = glGetUniformLocation(program, "time");
+// ...
+// Also we should define a Timer counting the current time.
+sf::Clock clock{ };
+// In out render loop we can now update the uniform every frame.
+    // ...
+    window.display();
+    glUniform1f(10,   // location
+                clock.getElapsedTime().asSeconds());   // data
+}
+// ...
+```
+
+With the time getting updated every frame the quad should now be changing from
+fully colored to pitch black.
+There are different types of glUniform() you can find simple documentation here:
+[glUniform - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glUniform.xhtml)
+
+## Indexing and IBO's
+
+Element Array Buffers or more commonly Index Buffer Objects (IBO) allow us to use the
+same vertex data again which makes drawing a lot easier and faster. here's an example:
+
+```cpp
+// Lets create a quad from two rectangles.
+// We can simply use the old vertex data from before.
+// First, we have to create the IBO.
+// The index is referring to the first declaration in the VBO.
+std::vector<unsigned int> iboData {
+    0, 1, 2,
+    0, 2, 3
+};
+// That's it, as you can see we could reuse 0 - the top left
+// and 2 - the bottom right.
+// Now that we have our data, we have to fill it into a buffer.
+// Note that this has to happen between the two glBindVertexArray() calls,
+// so it gets saved into the VAO.
+GLuint ibo = 0;
+glGenBufferrs(1, &ibo);
+glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
+glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(iboData[0]) * iboData.size(),
+             iboData.data(), GL_STATIC_DRAW);
+// Next in our render loop, we replace glDrawArrays() with:
+glDrawElements(GL_TRIANGLES, iboData.size(), GL_UNSIGNED_INT, nullptr);
+// Remember to delete the allocated memory for the IBO.
+```
+
+You can find the current code here: [OpenGL - 2](https://pastebin.com/R3Z9ACDE).
+
+## Textures
+
+To load out texture we first need a library that loads the data, for simplicity I will be
+using SFML, however there are a lot of librarys for loading image data.
+
+```cpp
+// Lets save we have a texture called "my_tex.tga", we can load it with:
+sf::Image image;
+image.loadFromFile("my_tex.tga");
+// We have to flip the texture around the y-Axis, because OpenGL's texture
+// origin is the bottom left corner, not the top left.
+image.flipVertically();
+// After loading it we have to create a OpenGL texture.
+GLuint texture = 0;
+glGenTextures(1, &texture);
+glBindTexture(GL_TEXTURE_2D, texture);
+// Specify what happens when the coordinates are out of range.
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+// Specify the filtering if the object is very large.
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+// Load the image data to the texture.
+glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.getSize().x, image.getSize().y,
+             0, GL_RGBA, GL_UNSIGNED_BYTE, image.getPixelsPtr());
+// Unbind the texture to prevent modifications.
+glBindTexture(GL_TEXTURE_2D, 0);
+// Delete the texture at the end of the application.
+// ...
+glDeleteTextures(1, &texture);
+```
+
+Ofcourse there are more texture formats than only 2D textures,
+You can find further information on parameters here:
+[glBindTexture - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glBindTexture.xhtml)<br>
+[glTexImage2D - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexImage2D.xhtml)<br>
+[glTexParameter - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexParameter.xhtml)<br>
+
+```cpp
+// With the texture created, we now have to specify the UV,
+// or in OpenGL terms ST coordinates.
+std::vector<float> texCoords {
+    // The texture coordinates have to match the triangles/quad
+    // definition.
+    0.0f, 1.0f,	   // start at top-left
+    0.0f, 0.0f,	   // go round counter-clockwise
+    1.0f, 0.0f,
+    1.0f, 1.0f     // end at top-right
+};
+// Now we increase the VBO's size again just like we did for the colors.
+// ...
+GLuint vbo[3];
+glGenBuffers(3, vbo);
+// ...
+glDeleteBuffers(3, vbo);
+// ...
+// Load the texture coordinates into the new buffer.
+glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
+glBufferData(GL_ARRAY_BUFFER, sizeof(texCoords[0]) * texCoords.size(),
+             texCoords.data(), GL_STATIC_DRAW);
+glEnableVertexAttribArray(2);
+glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+// Because the VAO does not store the texture we have to bind it before drawing.
+// ...
+glBindVertexArray(vao);
+glBindTexture(GL_TEXTURE_2D, texture);
+glDrawElements(GL_TRIANGLES, iboData.size(), GL_UNSIGNED_INT, nullptr);
+// ...
+```
+
+Change the shaders to pass the data to the fragment shader.<br>
+
+**Vertex Shader**
+
+```glsl
+#version 330 core
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec3 color;
+layout(location = 2) in vec2 texCoords;
+
+out vec3 fColor;
+out vec2 fTexCoords;
+
+void main() {
+    fColor = color;
+    fTexCoords = texCoords;
+    gl_Position = vec4(position, 1.0);
+}
+```
+
+**Fragment Shader**
+
+```glsl
+#version 330 core
+// sampler2D represents our 2D texture.
+uniform sampler2D tex;
+uniform float time;
+
+in vec3 fColor;
+in vec2 fTexCoords;
+
+out vec4 outColor;
+
+void main() {
+    // texture() loads the current texure data at the specified texture coords,
+    // then we can simply multiply them by our color.
+    outColor = texture(tex, fTexCoords) * vec4(fColor, 1.0);
+}
+```
+
+You can find the current code here: [OpenGL - 3](https://pastebin.com/u3bcwM6q)
+
+## Matrix Transformation
+
+**Vertex Shader**
+
+```glsl
+#version 330 core
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec3 color;
+layout(location = 2) in vec2 texCoords;
+// Create 2 4x4 matricies, 1 for the projection matrix
+// and 1 for the model matrix.
+// Because we draw in a static scene, we don't need a view matrix.
+uniform mat4 projection;
+uniform mat4 model;
+
+out vec3 fColor;
+out vec2 fTexCoords;
+
+void main() {
+    fColor = color;
+    fTexCoords = texCoords;
+    // Multiplay the position by the model matrix and then by the
+    // projection matrix.
+    // Beware order of multiplication for matricies!
+    gl_Position = projection * model * vec4(position, 1.0);
+}
+```
+
+In our source we now need to change the vertex data, create a model- and a projection matrix.
+
+```cpp
+// The new vertex data, counter-clockwise declaration.
+std::vector<float> vertexData {  
+    0.0f, 1.0f, 0.0f,   // top left
+    0.0f, 0.0f, 0.0f,   // bottom left
+    1.0f, 0.0f, 0.0f,   // bottom right
+    1.0f, 1.0f, 0.0f    // top right
+};
+// Request the location of our matricies.
+GLint projectionLocation = glGetUniformLocation(program, "projection");
+GLint modelLocation = glGetUniformLocation(program, "model");
+// Declaring the matricies.
+// Orthogonal matrix for a 1024x768 window.
+std::vector<float> projection {  
+    0.001953f,       0.0f,  0.0f, 0.0f,
+         0.0f, -0.002604f,  0.0f, 0.0f,
+         0.0f,       0.0f, -1.0f, 0.0f,
+        -1.0f,       1.0f,  0.0f, 1.0f
+};
+// Model matrix translating to x 50, y 50
+// and scaling to x 200, y 200.
+std::vector<float> model {  
+    200.0f,   0.0f, 0.0f, 0.0f,
+      0.0f, 200.0f, 0.0f, 0.0f,
+      0.0f,   0.0f, 1.0f, 0.0f,
+     50.0f,  50.0f, 0.0f, 1.0f
+};
+// Now we can send our calculated matricies to the program.
+glUseProgram(program);
+glUniformMatrix4fv(projectionLocation,   // location
+                   1,                    // count
+                   GL_FALSE,             // transpose the matrix
+                   projection.data());   // data
+glUniformMatrix4fv(modelLocation, 1, GL_FALSE, model.data());
+glUseProgram(0);
+// The glUniform*() calls have to be done, while the program is bound.
+```
+
+The application should now display the texture at the defined position and size.<br>
+You can find the current code here: [OpenGL - 4](https://pastebin.com/9ahpFLkY)
+
+```cpp
+// There are many math librarys for OpenGL, which create
+// matricies and vectors, the most used in C++ is glm (OpenGL Mathematics).
+// Its a header only library.
+// The same code using glm would look like:
+glm::mat4 projection{ glm::ortho(0.0f, 1024.0f, 768.0f, 0.0f) };
+glUniformMatrix4fv(projectionLocation, 1, GL_FALSE,
+                   glm::value_ptr(projection));
+// Initialise the model matrix to the identity matrix, otherwise every
+// multiplication would be 0.
+glm::mat4 model{ 1.0f };
+model = glm::translate(model, glm::vec3{ 50.0f, 50.0f, 0.0f });
+model = glm::scale(model, glm::vec3{ 200.0f, 200.0f, 0.0f });
+glUniformMatrix4fv(modelLocation, 1, GL_FALSE,
+                   glm::value_ptr(model));
+```
+
+## Geometry Shader
+
+Geometry shaders were introduced in OpenGL 3.2, they can produce vertices
+that are send to the rasterizer. They can also change the primitive type e.g.
+they can take a point as an input and output other primitives.
+Geometry shaders are inbetween the vertex and the fragment shader.
+
+**Vertex Shader**
+
+```glsl
+#version 330 core
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec3 color;
+// Create an output interface block passed to the next shadaer stage.
+// Interface blocks can be used to structure data passed between shaders.
+out VS_OUT {
+    vec3 color;
+} vs_out;
+
+void main() {
+    vs_out.color = color
+    gl_Position = vec4(position, 1.0);
+}
+```
+
+**Geometry Shader**
+
+```glsl
+#version 330 core
+// The geometry shader takes in points.
+layout(points) in;
+// It outputs a triangle every 3 vertices emitted.
+layout(triangle_strip, max_vertices = 3) out;
+// VS_OUT becomes an input variable in the geometry shader.
+// Every input to the geometry shader in treated as an array.
+in VS_OUT {
+    vec3 color;
+} gs_in[];
+// Output color for the fragment shader.
+// You can also simply define color as 'out vec3 color',
+// If you don't want to use interface blocks.
+out GS_OUT {
+    vec3 color;
+} gs_out;
+
+void main() {
+    // Each emit calls the fragment shader, so we set a color for each vertex.
+    gs_out.color = mix(gs_in[0].color, vec3(1.0, 0.0, 0.0), 0.5);
+    // Move 0.5 units to the left and emit the new vertex.
+    // gl_in[] is the current vertex from the vertex shader, here we only
+    // use 0, because we are receiving points.
+    gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, 0.0);
+    EmitVertex();
+    gs_out.color = mix(gs_in[0].color, vec3(0.0, 1.0, 0.0), 0.5);
+    // Move 0.5 units to the right and emit the new vertex.
+    gl_Position = gl_in[0].gl_Position + vec4(0.5, 0.0, 0.0, 0.0);
+    EmitVertex();
+    gs_out.color = mix(gs_in[0].color, vec3(0.0, 0.0, 1.0), 0.5);
+    // Move 0.5 units up and emit the new vertex.
+    gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.75, 0.0, 0.0);
+    EmitVertex();
+    EndPrimitive();
+}
+```
+
+**Fragment Shader**
+
+```glsl
+in GS_OUT {
+    vec3 color;
+} fs_in;
+
+out vec4 outColor;
+
+void main() {
+    outColor = vec4(fs_in.color, 1.0);
+}
+```
+
+If you now store a single point with a single color in a VBO and draw them,
+you should see a triangle, with your color mixed half way between
+red, green and blue on each vertex.
+
+
+## Quotes
+<sup>[1]</sup>[OpenGL - Wikipedia](https://en.wikipedia.org/wiki/OpenGL)
+
+## Books
+
+- OpenGL Superbible - Fifth Edition (covering OpenGL 3.3)
+- OpenGL Programming Guide - Eighth Edition (covering OpenGL 4.3)
diff --git a/openscad.html.markdown b/openscad.html.markdown
new file mode 100644
index 00000000..63570cbe
--- /dev/null
+++ b/openscad.html.markdown
@@ -0,0 +1,117 @@
+---
+language: openscad
+filename: learnopenscad.scad
+contributors:
+    - ["Tom Preston", "https://github.com/tompreston/"]
+---
+
+Draw 3D models with code using [OpenSCAD](https://openscad.org/).
+
+```
+// Comments look like this
+
+// 3D Primitives
+cube(10);
+cube([5, 10, 20]);
+sphere(10);
+
+// Transformations
+translate([20, 0, 0]) cube(10);
+rotate([0, 20, 30]) cube(10);
+
+translate([20, 0, 0]) rotate([0, 20, 30]) cube(10);
+rotate([0, 20, 30]) translate([20, 0, 0]) cube(10);
+
+// Modifiers
+//
+//     * disable
+//     ! show only
+//     # highlight / debug
+//     % transparent / background
+//
+// For example, show only the rotated cube at the origin, before we translate it.
+translate([20, 0, 0]) !rotate([0, 20, 30]) cube(10);
+
+// Formatting
+// The following models are the same. The official docs prefer the second.
+rotate([0, 20, 30]) translate([20, 0, 0]) cube(10);
+
+rotate([0, 20, 30])
+    translate([20, 0, 0])
+    cube(10);
+
+rotate([0, 20, 30]) {
+    translate([20, 0, 0]) {
+        cube(10);
+    }
+}
+
+// Loops
+num_cubes = 5;
+r = 20;
+cube_len = 5;
+
+for (i = [0:num_cubes]) {
+    echo(str("Plot cube ", i));
+    rotate([0, i * 360 / num_cubes, 0])
+        translate([r, 0, 0])
+        cube(cube_len, center=true);
+}
+
+// Boolean operations
+//
+//            union() - the sum of both shapes
+//       difference() - the first shape, minus the second shape
+//     intersection() - only parts of both shapes which intersect
+//
+cube_l = 20;
+cube_w = 10;
+cube_h = 10;
+
+hole_pos_l = 10;
+hole_pos_h = 5;
+hole_r = 3;
+
+difference() {
+    cube([cube_l, cube_w, cube_h]);
+    translate([hole_pos_l, 0, hole_pos_h])
+        rotate([-90, 0, 0])
+        cylinder(cube_w, r=hole_r);
+}
+
+// Functions calculate values
+function inch2mm(i) = i * 25.4;
+
+cube(inch2mm(2));
+
+// Modules create objects you want to use later
+module house(roof="flat", paint=[1,0,0]) {
+    color(paint)
+    if (roof=="flat") {
+        translate([0,-1,0]) cube();
+    } else if (roof=="pitched") {
+        rotate([90,0,0])
+            linear_extrude(height=1)
+            polygon(points=[[0,0],[0,1],[0.5,1.5],[1,1],[1,0]]);
+    }
+    else if (roof=="domical") {
+        translate([0,-1,0]) {
+            translate([0.5,0.5,1])
+                sphere(r=0.5,$fn=20);
+            cube();
+        }
+    }
+}
+
+house("pitched");
+translate([2, 0, 0]) house("domical");
+
+// Import modules and function from other files
+include <filename> // Import the content of the file as if they were written in this file
+use <filename>     // Import modules and functions, but do not execute any commands
+```
+
+## Further Reading
+* Official docs https://openscad.org/documentation.html
+* Cheat sheet https://openscad.org/cheatsheet/index.html
+* Vim bindings https://github.com/sirtaj/vim-openscad
diff --git a/osl.html.markdown b/osl.html.markdown
new file mode 100644
index 00000000..1fe010ec
--- /dev/null
+++ b/osl.html.markdown
@@ -0,0 +1,751 @@
+---
+language: osl
+filename: learnosl.osl
+contributors:
+  - ["Preetham Pemmasani", "https://github.com/Preetham-ai"]
+---
+
+OSL (Open Shading Language) is a programming language designed by Sony for Arnold Renderer used for creating shaders.
+
+[Read more here.](https://raw.githubusercontent.com/imageworks/OpenShadingLanguage/master/src/doc/osl-languagespec.pdf)
+
+```c
+
+
+// Single-line comments start with //
+
+/* Multi line comments are preserved. */
+
+// Statements can be terminated by ;
+divide(1,2);
+
+///////////////
+// 1. Basics //
+///////////////
+
+// Declating variables
+color Blue; // Initializing a variable
+int _num = 3;
+float Num = 3.00;
+float c[3] = {0.1, 0.2, 3.14}; // Array
+
+// Math works as you would expect
+3 + 1;   // 4
+74 - 3;   // 71
+20 * 2; // 40
+75/3;  // 25.0
+
+// And modulo division only works with integers
+10 % 2; // 0
+31 % 4; // 1
+
+// Bitwise operations only works with integers
+- 0 // 1 (Unary Negation)
+~ 00100011 // 11011100 (bitwise Compliment)
+1 << 2; // 4 (shift Left)
+12 >> 1; // 3 (shift Right)
+1 & 0; // 0 (bitwise AND)
+1 | 0; // 1 (bitwise OR)
+1 ^ 1; // 0 (bitwise XOR)
+
+// We also have booleans
+true;
+false;
+
+// Booleans can't be compared to integers
+true == 1 // Error
+false == 0 // Error
+
+// Negation uses the ! symbol
+!0; // 1
+!1; // 0
+!2; // 0
+//... and so on
+
+// Relation Operators are defined like:
+0 == 0 // true (equal to)
+0 != 1 // true (not equal to)
+5 < 3 // false (less then)
+3 <= 3 // true (less than or equal to)
+69 > 69 // false (greater than)
+99 >= 52 // true (greater than or equal)
+
+
+// Functions are same as C and C++
+float sum(float a, float b){
+	return a+b;
+}
+
+int subtract(int a, int b){
+	return a-b;
+}
+
+sum(2,3); // 5
+
+////////////////
+// 2. Shaders //
+////////////////
+
+// Shaders explain the custom behavior of materials and light
+// Shader's syntax is similar to the main function in C
+// The inputs and the outputs should be initialized to default types
+shader multiply(float a = 0.0,
+				float b = 0.0, 
+				output float c = 0.0){
+    c = a*b;
+}
+
+// Double brackets[[ ]] is used to classify metadata of a shader
+surface plastic
+	[[ string help = "Realistic wood shader" ]]
+(
+	color Plastic = color (0.7, 0.5, 0.3) [[ string help = "Base color" ]],
+	float Reflectivity = 0.5 [[ float min = 0, float max = 1 ]],
+){...}
+
+///////////////////////////////////////
+// Metadata Types
+///////////////////////////////////////
+
+[[ string label = "IOR" ]] // Display-name in UI of the parameter
+[[ string help = "Change Refractive Index" ]] // Info about the parameter
+[[ string help = "widget" // Gives widgets to input the parameter
+	string widget = "number" ]] // input float or int
+	string widget = "string" ]] // String input
+	string widget = "boolean" ]] // yes/no (or) 1/0
+	string widget = "popup", options = "smooth|rough" ]] // Drop-down list
+	// enum Drop-down list can also be made
+	string widget = "mapper", options = "smooth:0|rough:1" ]]
+	string widget = "filename" ]] // Input files externally
+	string widget = "null" ]] // null input
+
+[[ float min = 0.0 ]] // Minimum value of parameter
+[[ float max = 0.5 ]] // Maximum value of parameter
+[[ int slider = 3.0   // Adds a slider as an input
+	int slidermin = -1]] // minimum value of the slider
+	int slidermax = 3]] // maximum value of the slider
+	int slidercenter = 2]] // origin value of the slider
+
+[[ float sensitivity = 0.5 ]] // step size for incrementing the parameter
+[[ string URL = www.example.com/ ]] // URL of shader's documentation 
+
+	
+
+// There are different types of shaders
+
+/* Surface shaders determine the basic material properties of a surface and
+how it reacts to light */
+// Light shaders are a type of SURFACE shaders used for emissive objects.
+// Displacement shaders alter the geometry using position and normals.
+// Volume shaders adds a medium like air/smoke/dust into the scene.
+
+volume multiply(float a = 0.0, float b = 0.0, output float c = 0.0){
+    c = 2*a+b; 
+}
+
+////////////////////////////////////////
+// 3. Data Types and Global Variables //
+////////////////////////////////////////
+
+// Data Types
+
+// 1. The void type indicates a function that doesn't return any value
+
+// 2. int (Integer)
+	int x = -12; // Minimum size of 32-bits
+	int new2 = 0x01cf; // Hexadecimal can also be specified
+
+	///////////////////////////////////////
+	// Order of Evaluation
+	///////////////////////////////////////
+
+	// From top to bottom, top has higher precedence
+	//--------------------------//
+	//        Operators         //
+	//--------------------------//
+	// int++, int--             //
+	// ++ int --int - ~ !       //
+	// * / %                    //
+	// + -                      //
+	// << >>                    //
+	// < <= > >=                //
+	// == !=                    //
+	// &                        //
+	// ^                        //
+	// |                        //
+	// &&                       //
+	// ||                       //
+	// ?:                       //
+	// = += -= *= /=            //
+	//--------------------------//
+
+// 3. float (Floating-point number)
+	float A = 2.3; // minimum  IEEE 32-bit float
+	float Z = -4.1e2; // Z = -4.1 * 10^2
+
+	// Order of evaluation is similar to int.
+	// Operations like ( ~ ! % << >> ^ | & && || ) aren't available in float
+
+// 4. string
+	// The syntax is similar to C
+	string new = "Hello World";
+	// some Special characters:
+	/*
+	'\"'; // double quote
+	'\n'; // newline character
+	'\t'; // tab character (left justifies text)
+	'\v'; // vertical tab
+	'\\'; // back slash
+	'\r'; // carriage return
+	'\b'; // backspace character
+	*/
+
+	// Strings are concatenated with whitespace
+	"Hello " "world!"; // "Hello world!"
+	// concat function can also be used
+	string concat ("Hello ","World!"); // "Hello world!"
+
+	// printf function is same as C
+	int i = 18;
+	printf("I am %d years old",i); // I am 18 years old
+
+	// String functions can alse be used
+	int strlen (string s); // gives the length of the string
+	int len = strlen("Hello, World!"); // len = 13
+
+	// startswith returns 1 if string starts with prefix, else returns 0
+	int starts = startswith("The quick brown fox", "The"); // starts = 1
+
+	// endswith returns 1 if string starts with suffix, else returns 0
+	int ends = endswith("The quick brown fox", "fox"); // ends will be 1
+
+// 5. color (Red, Green, Blue)
+	color p = color(0,1,2); // black
+	color q = color(1); // white ( same as color(1,1,1) )
+	color r = color("rgb", 0.23, 0.1, 0.8); // explicitly specify in RGB
+	color s = color("hsv", 0.23, 0.1, 0.8); // specify in HSV
+	// HSV stands for (Hue, Saturation, Luminance)
+	// HSL stands for (Hue, Saturation, Lightness)
+	// YIQ, XYZ and xyY formats can also be used
+	// We can also access the indivudual values of (R,G,B)
+	float Red = p[0]; // 0 (access the red component)
+	float Green = p[1]; // 1 (access the green component)
+	float Blue = p[2]; // 2 (access the blue component)
+
+	// They can also be accessed like this
+	float Red = p.r; // 0 (access the red component)  
+	float Green = p.g; // 1 (access the green component) 
+	float Blue = p.b; // 2 (access the blue component)
+
+	// Math operators work like this with decreasing precedence
+	color C = (3,2,3) * (1,0,0); // (3, 0, 0)
+	color D = (1,1,1) * 255; // (255, 255, 255)
+	color E = (25,5,125) / 5; // (5, 1, 25)
+	color F = (30,40,50) / (3,4,5); // (10, 10, 10)
+	color A = (1,2,3) + (1,0,0); // (2, 2, 3)
+	color B = (1,2,3) - (1,0,0); // (0, 2, 3)
+	// Operators like ( - == != ) are also used
+
+	// Color Functions
+	color blackbody (1500) // Gives color based on temperature (in Kelvin)
+	float luminance (0.5, 0.3, 0.8) // 0.37 gives luminance cd/m^2
+	// Luminance is calculated by 0.2126R+0.7152G+0.0722B
+	color wavelength color (700) // (1, 0, 0) Gives color based on wavelength
+	color transformc ("hsl", "rgb") // converts one system to another
+
+// 6. point (x,y,z) is position of a point in the 3D space
+// 7. vector (x,y,z) has length and direction but no position
+// 8. normal (x,y,z) is a special vector perpendicular to a surface
+	// These Operators are the same as color and have the same precedence
+	L = point(0.5, 0.6, 0.7);
+	M = vector(30, 100, 70);
+	N = normal(0, 0, 1);
+
+	// These 3 types can be assigned to a coordinate system
+	L = point("object", 0.5, 0.6, 0.7); // relative to local space
+	M = vector("common", 30, 100, 70); // relative to world space
+	// There's also ("shader", "world", "camera", "screen", "raster", "NDC")
+
+	float x = L[0]; // 0.5 (access the x-component)  
+	float y = L[1]; // 0.6 (access the y-component)  
+	float z = L[2]; // 0.7 (access the z-component)
+
+	// They can also be accessed like this
+	float x = M.x; // 30 (access the x-component)
+	float y = M.y; // 100 (access the y-component)
+	float z = M.z; // 70 (access the z-component)
+
+	float a = dot ((1,2,3), (1,2,3)); // 14 (Dot Product)
+	vector b = cross ((1,2,3), (1,2,3)); // (0,0,0) (Cross Product)
+	float l = length(L); // 1.085 (length of vector)
+	vector normalize (vector L); // (0.460, 0.552, 0.644) Normalizes the vector
+
+	point p0 = point(1, 2, 3);
+	point p1 = point(4, 5, 6);
+	point Q = point(0, 0, 0);
+
+	// Finding distance between two points
+	float len = distance(point(1, 2, 3), point(4, 5, 6)); // 5.196
+	// Perpendicular distance from Q to line joining P0 and P1
+	float distance (point P0, point P1, point Q); // 2.45
+
+
+// 9. matrix
+	// Used for transforming vectors between different coordinate systems.
+	// They are usually 4x4 (or) 16 floats
+	matrix zero = 0; // makes a 4x4 zero matrix
+	/* 0.0, 0.0, 0.0, 0.0,
+       0.0, 0.0, 0.0, 0.0,
+       0.0, 0.0, 0.0, 0.0,
+       0.0, 0.0, 0.0, 0.0 */
+	
+	matrix ident = 1; // makes a 4x4 identity matrix
+	/* 1.0, 0.0, 0.0, 0.0,
+	   0.0, 1.0, 0.0, 0.0,
+	   0.0, 0.0, 1.0, 0.0,
+	   0.0, 0.0, 0.0, 1.0 */
+		
+	matrix m = 7; // Maked a 4x4 scalar matrix with scaling factor of 7
+	/* 7.0, 0.0, 0.0, 0.0,
+	   0.0, 7.0, 0.0, 0.0,
+	   0.0, 0.0, 7.0, 0.0,
+	   0.0, 0.0, 0.0, 7.0 */
+	
+	float x = m[1][1]; // 7
+	
+	// matrices can be constructed using floats in row-major order
+	// matrices are usually 4x4 with 16 elements
+	matrix myMatrix = matrix(1.0, 0.0, 0.0, 0.0,    // Row 1
+                             0.0, 2.0, 0.0, 0.0,    // Row 2
+                             0.0, 0.0, 3.0, 0.0,    // Row 3
+                             0.0, 0.0, 0.0, 4.0);	// Row 4
+
+	// matrix transformations are easy to implement
+	matrix a = matrix ("shader", 1); // converted shader to common
+	matrix m = matrix ("object", "world"); // converted object to world
+
+	// Operations that can be used with decreasing precedence are:
+	// ( - * / == !=)
+
+	float determinant (matrix M) // 24 (returns the determinant of the matrix)
+	float transpose (matrix M) // returns the transpose of the matrix
+	/* 1.0, 0.0, 0.0, 0.0,
+       0.0, 2.0, 0.0, 0.0,
+       0.0, 0.0, 3.0, 0.0,
+       0.0, 0.0, 0.0, 4.0 */
+
+// 10. array 
+	// Arrays in OSL are similar to C
+	float a[5]; // initialize array a with size 5
+	int b[3] = {90,80,70}; // declare array with size 3
+	int len = arraylength(b); // 3
+	int f = b[1]; // 80
+	float anotherarray[3] = b; // arrays can be copied if same type
+
+// 11. struct (Structures)
+	// Structures in OSL are similar to C and C++.
+	struct RGBA { // Defining a structure
+		color rgb;
+		float alpha;
+	};
+
+	
+	RGBA col; // Declaring a structure
+	RGBA b = { color(0.1, 0.2, 0.3), 1 }; // Can also be declared like this
+
+	r.rgb = color (1, 0, 0); // Assign to one field
+	color c = r.rgb; // Read from a structure field
+
+// 12. closure
+	// Closure is used to store data that aren't considered when it executes.
+	// It cannot be manipulated or read.
+	// A null closure can always be assigned.
+	// OSL currently only supports color as their closure.
+
+	// A few examples of closures are:
+
+	// Diffuse BSDF closures:
+	closure color oren_nayar_diffuse_bsdf(normal N, color alb, float roughness)
+	closure color burley_diffuse_bsdf(normal N, color alb, float roughness);
+
+	// Dielectric BSDF closure:
+	closure color dielectric_bsdf(normal N, vector U, color reflection_tint,
+	    color transmission_tint, float roughness_x, float roughness_y,
+	    float ior, string distribution);
+
+	// Conductor BSDF closure:
+	closure color conductor_bsdf(normal N, vector U, float roughness_x,
+	    float roughness_y, color ior, color extinction, string distribution);
+
+	// Generalized Schlick BSDF closure:
+	closure color generalized_schlick_bsdf(normal N, vector U,
+	    color reflection_tint, color transmission_tint,
+	    float roughness_x, float roughness_y, color f0, color f90,
+	    float exponent, string distribution);
+
+	// Translucent BSDF closure:
+	closure color translucent_bsdf(normal N, color albedo);
+
+	// Transparent BSDF closure:
+	closure color transparent_bsdf();
+
+	// Subsurface BSSRDF closure:
+	closure color subsurface_bssrdf();
+
+	// Sheen BSDF closure:
+	closure color sheen_bsdf(normal N, color albedo, float roughness);
+
+	// Anisotropic VDF closure: (Volumetric)
+	closure color anisotropic_vdf(color albedo, color extinction,
+	    float anisotropy);
+
+	// Medium VDF closure: (Volumetric)
+	closure color medium_vdf(color albedo, float transmission_depth,
+	    color transmission_color, float anisotropy, float ior, int priority);
+
+	closure color uniform edf(color emittance); // Emission closure
+	closure color holdout(); // Holdout Hides objects beneath it
+
+	// BSDFs can be layered using this closure
+	closure color layer (closure color top, closure color base);
+
+
+
+// Global Variables
+// Contains info that the renderer knows
+// These variables need not be declared
+
+point P // Position of the point you are shading
+vector I // Incident ray direction from viewing position to shading position
+normal N // Normal of the surface at P
+normal Ng // Normal of the surface at P irrespective of bump mapping
+float u // UV 2D x - parametric coordinate of geometry
+float v // UV 2D y - parametric coordinate of geometry
+vector dPdu // change of P with respect to u tangent to the surface
+vector dPdv // change of P with respect to v tangent to the surface
+float time // Current time
+float dtime // Time covered
+vector dPdtime // change of P with respect to time
+
+/////////////////////
+// 4. Control flow //
+/////////////////////
+
+// Conditionals in OSL are just like in C or C++.
+
+// If/Else
+if (5>2){
+	int x = s;
+	int l = x;
+}
+else{
+	int x = s + l; 
+}
+
+// 'while' loop
+int i = 0;
+while (i < 5) {
+    i += 1;
+    printf("Current value of i: %d\n", i);
+}
+
+// 'do-while' loop is where test happens after the body of the loop
+int i = 0;
+do {
+    printf("Current value of i: %d\n", i);
+    i += 1;
+} while (i < 5);
+
+// 'for' loop
+for (int i = 0; i < 5; i += 1) {
+    printf("Current value of i: %d\n", i);
+}
+
+/////////////////////
+// 5. Functions //
+/////////////////////
+
+// Math Constants
+	M_PI // π
+	M_PI_35 // π/35
+	m_E // e
+	M_LN2 // ln 2
+	M_SQRT2 // √2
+	M_SQRT1_2 // √(1/2)
+
+// Geometry Functions
+	vector N = vector(0.1, 1, 0.2); // Normal vector
+	vector I = vector(-0.5, 0.2, 0.8); // Incident vector
+
+	// Faceforward tells the direction of vector
+	vector facing_dir = faceforward(N, I); // facing_dir = (-0.5, 0.2, 0.8)
+
+	// faceforward with three arguments
+	vector ref = vector(0.3, -0.7, 0.6); // Reference normal
+	facing_dir = faceforward(N, I, ref); // facing_dir = (0.5, -0.2, -0.8)
+
+	// reflect gives the reflected vector along normal
+	vector refl = reflect(I, N); // refl = (-0.7, -0.4, 1.4)\
+
+	// refract gives the refracted vector along normal
+	float ior = 1.5; // Index of refraction
+	vector refr = refract(I, N, ior); // refr = (-0.25861, 0.32814, 0.96143)
+
+	/* Fresnel computes the Reflection (R) and Transmission (T) vectors, along
+	with the scaling factors for reflected (Kr) and transmitted (Kt) light. */
+	float Kr, Kt;
+	vector R, T;
+	fresnel(I, N, ior, Kr, Kt, R, T);
+/* Kr = 0.03958, Kt = 0.96042
+	R = (-0.19278, -0.07711, 0.33854)
+	T = (-0.25861, 0.32814, 0.96143) */
+
+	// Rotating a point along a given axis
+	point Q = point(1, 0, 0);
+	float angle = radians(90); // 90 degrees
+	vector axis = vector(0, 0, 1);
+	point rotated_point = rotate(Q, angle, axis);
+	// rotated_point = point(0, 1, 0)
+
+	// Rotating a point along a line made by 2 points
+	point P0 = point(0, 0, 0);
+	point P1 = point(1, 1, 0);
+	angle = radians(45); // 45 degrees
+	Q = point(1, 0, 0);
+	rotated_point = rotate(Q, angle, P0, P1);
+	// rotated_point = point(0.707107, 0.707107, 0)
+
+	// Calculating normal of surface at point p
+	point p1 = point(1, 0, 0); // Point on the sphere of radius 1
+	vector normal1 = calculatenormal(p1);
+	// normal1 = vector(1, 0, 0)
+
+	// Transforming units is easy
+	float transformu ("cm", float x) // converts to cm
+	float transformu ("cm", "m", float y) // converts cm to m
+
+// Displacement Functions
+	void displace (float 5); // Displace by 5 amp units
+	void bump (float 10); // Bump by 10 amp units
+
+
+// Noise Generation
+
+	type noise (type noise (string noisetype, float u, float v, ...)); // noise
+	type noise (string noisetype, point p,...); // point instead of coordinates
+	/* some noises are ("perlin", "snoise", "uperlin", "noise", "cell", "hash"
+	"simplex", "usimplex", "gabor", etc) */
+	
+	// Noise Names
+
+	// 1. Perlin Noise (perlin, snoise):
+	// Creates smooth, swirling noise often used for textures.
+	// Range: [-1, 1] (signed)
+	color cloud_texture = noise("perlin", P);
+
+	// 2. Simplex Noise (simplex, usimplex):
+	// Similar to Perlin noise but faster.
+	// Range: [-1, 1] (signed) for simplex, [0, 1] (unsigned) for usimplex
+	float bump_amount = 0.2 * noise("simplex", P * 5.0);
+
+	// 3. UPerlin Noise (uperlin, noise):
+	// Similar to peril
+	// Range: [0, 1] (unsigned)
+	color new_texture = noise("uperlin", P);
+	
+	// 4. Cell Noise (cell):
+	// Creates a blocky, cellular and constant values within each unit block
+	// Range: [0, 1] (unsigned)
+	color new_texture = noise("cell", P);
+
+	// 5. Hash Noise (hash):
+	// Generates random, uncorrelated values at each point.
+	// Range: [0, 1] (unsigned)
+	color new_texture = noise("hash", P);
+
+	// Gabor Noise (gabor) 
+	// Gabor Noise is advanced version of Perin noies and gives more control
+	// Range: [-1, 1] (signed)
+	// Gabor Noise Parameters
+
+	// Anisotropic (default: 0)
+	// Controls anisotropy:
+	// 0: Isotropic (equal frequency in all directions)
+	// 1: Anisotropic with user-defined direction vector (defaults to (1,0,0))
+	/* 2: Hybrid mode,anisotropic along direction vector but radially isotropic
+	perpendicularly. */
+
+	// Direction (default: (1,0,0))
+	// Specifies the direction of anisotropy (used only if anisotropic is 1).
+
+	// bandwidth (default: 1.0)
+	// Controls the frequency range of the noise.
+
+	// impulses (default: 16)
+	// Controls the number of impulses used per cell, affecting detail level.
+
+	// do_filter (default: 1)
+	// Enables/disables antialiasing (filtering).
+
+	result = noise(
+        "gabor",
+        P,
+        "anisotropic", anisotropic,
+        "direction", direction,
+        "bandwidth", bandwidth,
+        "impulses", impulses,
+        "do_filter", do_filter
+    );
+
+	// Specific noises can also be used instead of passing them as types
+	// pnoise is periodic noise
+	float n1 = pnoise("perlin", 0.5, 1.0);
+	// 2D periodic noise with Gabor type
+	float n2 = pnoise("gabor", 0.2, 0.3, 2.0, 3.0);
+	// 2D non-periodic simplex noise
+	float n3 = snoise(0.1, 0.7);
+	// 2D periodic simplex noise
+	type psnoise (float u, float v, float uperiod, float vperiod);
+	float n4 = psnoise(0.4, 0.6, 0.5, 0.25);
+	// 2D cellular noise
+	float n5 = cellnoise(0.2, 0.8);
+	// 2D hash noise
+	int n6 = hash(0.7, 0.3);
+
+// Step Function
+	// Step Functions are used to compare input and threshold
+
+	// The type may be of float, color, point, vector, or normal.
+	type step (type edge, type x); // Returns 1 if x ≥ edge, else 0
+	color checker = step(0.5, P);  // P is a point on the surface
+	/* Pixels with P values below 0.5 will be black, those above or equal will
+	be white */
+	float visibility = step(10, distance(P, light_position));
+	// Light is fully visible within 10 units, completely invisible beyond
+
+	type linearstep (type edge0, type edge1, type x); /* Linearstep Returns 0
+	if x ≤ edge0, and 1 if x ≥ edge1, with linear interpolation */
+	color gradient = linearstep(0, 1, P);
+	// P is a point on the surface between 0 and 1
+	// Color will graduate smoothly from black to white as P moves from 0 to 1
+	float fade = linearstep(0.85, 1, N.z);  // N.z is the z-component
+	// Object edges with normals close to vertical (N.z near 1) will fade out
+	
+	type smoothstep (type edge0, type edge1, type x); /* smoothstep Returns 0
+	if x ≤ edge0, and 1 if x ≥ edge1, with Hermite interpolation */
+	float soft_mask = smoothstep(0.2, 0.8, noise(P));  /* noise(P) is a noisy
+	value between 0 and 1. soft_mask will vary smoothly between 0 and 1 based
+	on noise(P), with a smoother curve than linearstep */
+
+// Splines
+	// Splines are smooth curves based on a set of control points
+
+	/* The type of interpolation ranges from "catmull-rom", "bezier",
+	"bspline", "hermite", "linear", or "constant" */
+
+	// Spline with knot vector
+	float[] knots = {0, 0, 0, 0.25, 0.5, 0.75, 1, 1, 1};
+	point[] controls = {point(0),point(1, 2, 1),point(2, 1, 2),point(3, 3, 1)};
+	spline curve1 = spline("bezier", 0.5, len(knots), controls);
+	// curve1 is a Bezier spline evaluated at u = 0.5
+
+	// Spline with control points
+	spline curve2 = spline("catmull-rom", 0.25, point(0, 0, 0), point(1, 2, 1),
+	                       point(2, 1, 2), point(3, 3, 1));
+	// curve2 is a Catmull-Rom spline evaluated at u = 0.25
+
+	// Constant spline with a single float value
+	float value = 10;
+	u = 0.1;
+	spline curve5 = spline("constant", u, value);
+	// curve5 is a constant spline with value 10 evaluated at u = 0.1
+
+	// Hermite spline with point and vector controls
+	point q0 = point(0, 0, 0), q1 = point(3, 3, 3);
+	vector t0 = vector(1, 0, 0), t1 = vector(-1, 1, 1);
+	u = 0.75;
+	spline curve3 = spline("hermite", u, q0, t0, q1, t1);
+	// curve3 is a Hermite spline evaluated at u = 0.75
+
+	// Linear spline with float controls
+	float f0 = 0, f1 = 1, f2 = 2, f3 = 3;
+	u = 0.4;
+	spline curve4 = spline("linear", u, f0, f1, f2, f3);
+	// curve4 is a linear spline evaluated at u = 0.4
+	
+	// InverseSplines also exist
+	
+	// Inverse spline with control values
+	float y0 = 0, y1 = 1, y2 = 2, y3 = 3;
+	float v = 1.5;
+	float u1 = splineinverse("linear", v, y0, y1, y2, y3);
+	// u1 = 0.5 (linear interpolation between y1 and y2)
+
+	// Inverse spline with knot vector
+	float[] knots = {0, 0, 0, 0.25, 0.5, 0.75, 1, 1, 1};
+	float[] values = {0, 1, 4, 9};
+	v = 6;
+	float u2 = splineinverse("bezier", v, len(knots), values);
+	// u2 = 0.75 (Bezier spline inverse evaluated at v = 6)
+
+	// Inverse spline with constant value
+	v = 10;
+	float u3 = splineinverse("constant", v, 10);
+	// u3 = 0 (since the constant spline always returns 10)
+
+	// Inverse spline with periodic values
+	float y4 = 0, y5 = 1, y6 = 0;
+	v = 0.5;
+	float u4 = splineinverse("periodic", v, y4, y5, y6);
+	// u4 = 0.75 (periodic spline inverse evaluated at v = 0.5)
+
+
+
+// Calculus Operators
+	// Partial derivative of f with respect to x, y and z using Dx, Dy, Dz
+	float a = 3.14;
+	float dx = Dx(a); // partial derivative of a with respect to x
+
+	point p = point(1.0, 2.0, 3.0);
+	vector dp_dx = Dx(p); // partial derivative of p with respect to x
+
+	vector dv_dy = Dy(N); // partial derivative of normal with respect to y
+
+	color c = color(0.5, 0.2, 0.8);
+	color dc_dz = Dz(c); // partial derivative of c with respect to z
+	
+
+	float area (point p) // gives the surface area at the position p 
+
+	float filterwidth (float x) // gives the changes of x in adjacent samples
+
+// Texture Functions
+	// lookup for a texture at coordinates (x,y)
+	color col1 = texture("texture.png", 0.5, 0.2);
+	// Lookup color at (0.5, 0.2) in texture.png
+
+	// 3D lookup for a texture at coordinates (x,y)
+	color col3 = texture3d("texture3d.vdb", point(0.25, 0.5, 0.75));
+
+	// parameters are ("blur","width","wrap","fill","alpha","interp", ...)
+	color col2 = texture("texture.png",1.0,0.75,"blur",0.1,"wrap", "periodic");
+	// Lookup color at (1.0, 0.75) with blur 0.1 and periodic wrap mode
+	
+// Light Functions
+
+	float surfacearea (); // Returns the surface area of area light covers
+	int backfacing (); // Outputs 1 if the normals are backfaced, else 0
+	int raytype (string name); // returns 1 if the ray is a particular raytype
+
+	// Tracing a ray from a position in a direction
+	point pos = point(0, 0, 0); // Starting position of the ray
+	vector dir = vector(0, 0, 1); // Direction of the ray
+	int hit = trace(pos, dir); // returns 1 if it hits, else 0
+
+```
+### Further reading
+
+* [Blender Docs for OSL](https://docs.blender.org/manual/en/latest/render/shader_nodes/osl.html)
+* [C4D Docs for OSL](https://docs.otoy.com/cinema4d//OpenShadingLanguageOSL.html)
+* Open Shading Language on [GitHub](https://github.com/AcademySoftwareFoundation/OpenShadingLanguage)
+* [Official OSL Documentation](https://open-shading-language.readthedocs.io/en/main/)
\ No newline at end of file
diff --git a/p5.html.markdown b/p5.html.markdown
index f6084b98..2588ffc6 100644
--- a/p5.html.markdown
+++ b/p5.html.markdown
@@ -10,40 +10,142 @@ filename: p5.js
 p5.js is a JavaScript library that starts with the original goal of [Processing](https://processing.org), to make coding accessible for artists, designers, educators, and beginners, and reinterprets this for today's web.
 Since p5 is a JavaScript library, you should learn [Javascript](https://learnxinyminutes.com/docs/javascript/) first.
 
+To run p5.js code, you can go to [the online editor](https://editor.p5js.org/).
+
 ```js
 ///////////////////////////////////
 // p5.js has two important functions to work with.
 
 function setup() {
-    // the setup function gets executed just once when the window is loaded
+  // the setup function gets executed just once when the window is loaded
 }
 function draw() {
-    // the draw function gets called every single frame. This means that for a frameRate(30) it would get called 30 times per second.
+  // the draw function gets called every single frame
+  // if the framerate is set to 30, it would get called 30 times every second
 }
 
 // the following code explains all features
 
 function setup() {
-    createCanvas(640, 480); // creates a new canvas element with 640px as width as 480px as height
-    background(128); // changes the background color of the canvas, can accept rgb values like background(100,200,20) else grayscale values like background(0) = black or background(255) = white
+  createCanvas(640, 480); // creates a new canvas element with 640px as width as 480px as height
+  background(128); // sets the background color to rgb(128, 128, 128)
+  // background('#aaf') // you can use hex codes and color names too
 }
 
 function draw() {
-    ellipse(10, 10, 50, 50); // creates a ellipse at the 10px from the left and 10px from the top with width adn height as 50 each, so its basically a circle.
-    //remember in p5.js the origin is at the top-left corner of the canvas
+  background('#f2f2fc'); // usually, you call `background` in draw to clear the screen
+  // creates an ellipse at 10px from the top and 10px from the left, with width and height 37
+  ellipse(10, 10, 37, 37);
+  // remember in p5.js the origin is at the top-left corner of the canvas
+
+  if (mouseIsPressed) {
+    // mouseIsPressed is a boolean variable that is true when the mouse is down, and false otherwise
+
+    fill(0); // fill sets the fill color, which will stay until it is changed
+  } else {
+    fill(255, 255, 255, 240); // fill(a, b, c, d) sets the fill color to rgba(a, b, c, d)
+  }
+
+  ellipse(mouseX, mouseY, 80, 80);
+  // mouseX and mouseY are the x and y position of the mouse, respectively
+  // the above code creates and ellipse under the mouse, and fills it with white or black
+
+
+  // some other 2d primitives (shapes) you can draw:
+  rect(9, 3, 23, 26); // x, y, width, height
+  noFill(); // sets the fill color to transparent
+  triangle(100, 400, 130, 200, 200, 300); // x1, y1, x2, y2, x3, y3
+  point(100, 300); // create a point at x, y
+  // there are more, but they are more complex.
+}
 
-    if (mouseIsPressed) {
-        // mouseIsPressed is a boolean variable that changes to true if the mouse buttton is pressed down at that instant
+/** Bouncing balls animation
+ * You can copy-paste this code into the online editor at
+ * https://editor.p5js.org/
+ */
+class Ball {
+  constructor(x, y, xvel, yvel, radius, col) {
+    this.position = createVector(x, y); // create a p5.Vector object which stores the x and y
+    this.velocity = createVector(xvel, yvel); // make a p5.Vector storing the velocity
+    this.radius = radius;
+    this.col = col; // p5 already uses the word color, so we use col instead
+  }
 
-        fill(0); // fill refers to the innner color or filling color of whatever shape you are going to draw next
-    } else {
-        fill(255); // you can give in rgb values like fill(72, 240, 80) to get colors, else a single values determines the grayscale where fill(255) stands for #FFF(white) and fill(0) stands for #000(black)
+  update() {
+    this.position.add(this.velocity); // you can add vectors with p5.Vector.add(p5.Vector)
+    if (this.position.x + this.radius > width) {
+      // flip the direction the ball is going in if it touches the edge
+      this.velocity.x *= -1;
     }
+    if (this.position.x - this.radius < 0) {
+      this.velocity.x *= -1;
+    }
+    if (this.position.y + this.radius > height) {
+      this.velocity.y *= -1;
+    }
+    if (this.position.y - this.radius < 0) {
+      this.velocity.y *= -1;
+    }
+  }
+
+  render() {
+    // you can figure out what this does by now
+    fill(this.col);
+    ellipse(this.position.x, this.position.y, this.radius);
+  }
+}
+
+let numBalls = 23;
+let balls = [];
+
+function setup() {
+  createCanvas(400, 400); // width, height
+  for (let i = 0; i < numBalls; i++) {
+    let r = random(255); // random number between 0 and 255
+    let g = random(255);
+    let b = random(255);
+
+    balls.push(
+      new Ball(
+        random(30, width), // x position
+        random(height), // y position
+        random(-4, 4), // x velocity
+        random(-4, 4), // y velocity
+        random(4, 10), // radius
+        color(r, g, b) // fill color for the ball
+      )
+    );
+  }
+}
+
+function draw() {
+  background(255);
+  for (let ball of balls) {
+    ball.update();
+    ball.render();
+  }
+}
+
+// So far, we have only seen the default rendering mode.
+// This time, we will use the 'webgl' renderer
 
-    ellipse(mouseX, mouseY, 80, 80);
-    // mouseX is the x-coordinate of the mouse's current position and mouseY is the y-coordinate of the mouse's current position
+function setup() {
+  createCanvas(400, 400, WEBGL); // width, height, rendering mode
+}
+
+function draw() {
+  background(0);
 
-    // the above code creates a circle wherever mouse's current position and fills it either black or white based on the mouseIsPressed
+  stroke('#000');
+  fill('#aaf');
+
+  // rotate around the x, y, and z axes by the frame count divided by 50
+  rotateX(frameCount / 50);
+  rotateY(frameCount / 50);
+  rotateZ(frameCount / 50);
+  // frameCount is a p5.js variable that stores the amount of frames that have passed
+ 
+  box(50, 50, 50); // width, height, depth
 }
 ```
 
@@ -51,3 +153,9 @@ function draw() {
 
 - [p5.js | get started](http://p5js.org/get-started/) The official documentation
 - [Code! Programming for Beginners with p5.js - YouTube](https://www.youtube.com/watch?v=yPWkPOfnGsw&vl=en) Introduction and Coding challenges using Processing and p5.js by Coding Train
+- [The Coding Train](https://codingtra.in/) A website with sketches made in p5 and processing
+
+## Source
+
+- [p5's source code](https://github.com/processing/p5.js)
+- [p5.sound.js source](https://github.com/processing/p5.js-sound)
diff --git a/pascal.html.markdown b/pascal.html.markdown
index a505a38f..fe00791a 100644
--- a/pascal.html.markdown
+++ b/pascal.html.markdown
@@ -12,7 +12,7 @@ source : [wikipedia](https://en.wikipedia.org/wiki/Pascal_(programming_language)
 
 
 
-to compile and run a pascal program you could use a free pascal compiler. [Download Here](https://www.freepascal.org/)
+To compile and run a pascal program you could use a free pascal compiler. [Download Here](https://www.freepascal.org/)
 
 ```pascal
 //Anatomy of a Pascal Program
@@ -23,7 +23,7 @@ to compile and run a pascal program you could use a free pascal compiler. [Downl
 }
 
 //name of the program
-program learn_pascal; //<-- dont forget a semicolon
+program learn_pascal; //<-- don't forget a semicolon
 
 const
     {
@@ -31,7 +31,7 @@ const
     }
 type
     {
-        this is where you should delcare a custom
+        this is where you should declare custom
         data-types
     }
 var
@@ -44,11 +44,11 @@ begin
     {
         area to declare your instruction
     }
-end. // End of a main program area should required a "." symbol
+end. // End of a main program area should require a "." symbol
 ```
 
 ```pascal
-//declaring variable
+//When declaring variables
 //you can do this
 var a:integer;
 var b:integer;
@@ -62,7 +62,7 @@ var a,b : integer;
 
 ```pascal
 program Learn_More;
-//Lets learn about data types and their operations
+//Let's learn about data types and their operations
 
 const
     PI = 3.141592654;
@@ -131,7 +131,7 @@ Begin
     str := 'apple';
     bool := true;
     //pascal is not a case-sensitive language
-    //arithmethic operation
+    //arithmetic operation
     int := 1 + 1; // int = 2 overwriting the previous assignment
     int := int + 1; // int = 2 + 1 = 3;
     int := 4 div 2; //int = 2 division operation where result will be floored
diff --git a/perl.html.markdown b/perl.html.markdown
index 8811dd08..88185e9d 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -217,6 +217,12 @@ open(my $log, ">>", "my.log")     or die "Can't open my.log: $!";
 my $line  = <$in>;
 my @lines = <$in>;
 
+# You can iterate through the lines in a file one at a time with a while loop:
+
+while (my $line = <$in>) {
+  print "Found apples\n" if $line =~ m/apples/;
+}
+
 # You can write to an open filehandle using the standard "print"
 # function.
 
diff --git a/phel.html.markdown b/phel.html.markdown
new file mode 100644
index 00000000..4dc030fa
--- /dev/null
+++ b/phel.html.markdown
@@ -0,0 +1,337 @@
+---
+language: phel
+filename: learnphel.phel
+contributors:
+    - ["Chemaclass", "https://github.com/Chemaclass"]
+---
+
+[Phel](https://phel-lang.org/) is a functional programming language that compiles to PHP.
+It is a dialect of Lisp inspired by Clojure and Janet.
+
+## Features
+- Built on PHP's ecosystem
+- Good error reporting
+- Persistent Datastructures (Lists, Vectors, Maps and Sets)
+- Macros
+- Recursive functions
+- Powerful but simple Syntax
+- REPL
+
+```newlisp
+# Comments begin with a # character and continue until the end of the line. There are no multi-line comments.
+
+# Phel is written in "forms", which are just
+# lists of things inside parentheses, separated by whitespace.
+
+# The first call in a file should be ns, to set the namespace
+(ns learn-phel)
+
+# More basic examples:
+
+# str will create a string out of all its arguments
+(str "Hello" " " "World") #=> "Hello World"
+
+# Math is straightforward
+(+ 1 1) #=> 2
+(- 2 1) #=> 1
+(* 1 2) #=> 2
+(/ 2 1) #=> 2
+
+# Equality is =
+(= 1 1) #=> true
+(= 2 1) #=> false
+
+# You need not for logic, too
+(not true) #=> false
+
+# Nesting forms works as you expect
+(+ 1 (- 3 2)) # = 1 + (3 - 2) => 2
+
+# Phel inherits PHP under the hood, so it can use native PHP (functions and classes) without 
+# any additional cost by using the `php/` prefix to all PHP native functions.
+
+# Types
+#############
+
+# Booleans are similar as the native PHP ones
+
+nil
+true
+false 
+
+# Symbols are used to name functions and variables in Phel
+# For example: symbol, snake_case_symbol, my-module/my-function
+
+# Keywords are like symbols that begin with a colon character. However, they are used as constants rather than a name for something.
+
+:keyword
+:0x0x0x
+::
+
+# Numbers in Phel are equivalent to numbers in PHP
+
+1337 # integer
++1337 # positive integer
+-1337 # negative integer
+
+1.234 # float
++1.234 # positive float
+-1.234 # negative float
+1.2e3 # float
+7E-10 # float
+
+# Strings are surrounded by double quotes. They almost work the same as PHP double quoted strings.
+# A string can be written in multiple lines. The line break character is then ignored by the reader.
+
+"hello world"
+
+"this is\na\nstring"
+
+"this
+is
+a
+string."
+
+"use backslack to escape \" string"
+
+"the dollar must not be escaped: $ or $abc just works"
+
+
+# Collections & Sequences
+#############
+
+# Lists are linked-list data structures, while vectors are array-backed
+(type '(1 2 3)) #=> :list
+(type [1 2 3])  #=> :vector
+
+# A list would be written as just (1 2 3), but we have to quote
+# it to stop the reader thinking it's a function.
+# Also, (list 1 2 3) is the same as '(1 2 3)
+
+# You can produce a (non-lazy) sequence between a range. 
+(range 1 10 2) #=> (range from to step)
+(take 4 (range 10))
+
+# Use cons to add an item to the beginning of a list
+(cons 4 '(1 2 3)) #=> (4 1 2 3)
+
+# Use push to add, and put to replace an item in a vector 
+(push [1 2 3] 4)  #=> (1 2 3 4)
+(put [1 2 3] 1 4) #=> (1 4 3)
+
+# Use concat to add lists or vectors together
+(concat [1 2] '(3 4)) #=> [1 2 3 4]
+
+# Use filter, map to interact with collections
+(map inc [1 2 3])      #=> [2 3 4]
+(filter even? [1 2 3]) #=> [2]
+
+# Use reduce to reduce them. The initial-value is mandatory
+(reduce + 0 [1 2 3 4])
+#=> (+ (+ (+ 1 2) 3) 4)
+#=> 10
+
+(reduce push [] '(3 2 1))
+#=> (push (push (push [] 3) 2) 1)
+#=> [3 2 1]
+
+# Functions
+#############
+
+# Use fn to create new functions
+# A function always returns its last statement
+(fn [] "Hello World") #=> <function>
+
+# You need extra parens to call it
+((fn [] "Hello World")) #=> "Hello World"
+
+# You can bind a value to a symbol using def for definition
+(def x 1)
+x #=> 1
+
+# Variables provide a way to manage mutable state
+(def foo (var 10)) # Define a variable with value 10
+
+# Assign a function to a definition
+(def hello-world (fn [] "Hello World"))
+(hello-world) #=> "Hello World"
+
+# You can shorten this process by using defn
+(defn hello-world [] "Hello World")
+
+# The [] is the list of arguments for the function
+(defn hello [name]
+  (str "Hello " name))
+(hello "Jens") #=> "Hello Jens"
+
+# You can also use this shorthand to create functions
+(def hello2 |(str "Hello " $1))
+(hello2 "Anna") #=> "Hello Anna"
+
+# Functions can pack extra arguments up in a seq for you
+(defn count-args [& args]
+  (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) #=> "You passed 3 args: @[1 2 3]"
+
+# You can mix regular and packed arguments
+(defn hello-count [name & args]
+  (str "Hello " name ", you passed " (count args) " extra args"))
+(hello-count "Jesus" 1 2) #=> "Hello Jesus, you passed 2 extra args"
+
+
+# Maps
+#############
+
+# Hash maps have faster lookups but don't retain key order
+(type {:a 1 :b 2 :c 3})          #=> :hash-map
+(type (hash-map :a 1 :b 2 :c 3)) #=> :hash-map
+
+# Maps can use any hashable type as a key, but usually keywords are best
+# Keywords are like strings with some efficiency bonuses and they start with `:`
+(type :a) #=> :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}
+
+# Retrieve a value from a map by calling it as a function
+(stringmap "a") #=> 1
+(keymap :a)     #=> 1
+
+# Keywords can be used to retrieve their value from a map, too!
+(:b keymap) #=> 2
+
+# Don't try this with strings
+# ("a" stringmap)
+# ...Exception: Call to undefined function a()
+
+# Retrieving a non-present key returns nil
+(stringmap "d") #=> nil
+
+# Use put to add new keys to hash-maps
+(def newkeymap (put keymap :d 4))
+newkeymap #=> {:a 1 :b 2 :c 3 :d 4}
+
+# But remember, phel types are immutable!
+keymap #=> {:a 1 :b 2 :c 3}
+
+# Use unset to remove keys
+(unset keymap :a) #=> {:b 2 :c 3}
+
+# Sets
+#############
+
+# A Set contains unique values in random order
+
+(type (set 1 2 3)) #=> :set
+(set 1 2 3 1 2 3 3 2 1 3 2 1) #=> (set 1 2 3)
+
+# Add a member with push
+(push (set 1 2 3) 4) #=> (set 1 2 3 4)
+
+# Remove one with unset
+(unset (set 1 2 3) 1) #=> (set 2 3)
+
+# Test for existence by using the set as a function
+((set 1 2 3) 1) #=> 1
+((set 1 2 3) 4) #=> nil
+
+# There are more functions like: count, union, intersection, difference, etc
+
+
+# Useful forms
+#############
+
+# `If` conditionals in phel are special forms
+(if false "a" "b") #=> "b"
+(if false "a") #=> nil
+
+# Use let to create temporary bindings
+(let [a 1 b 2]
+  (> a b)) #=> false
+
+# Group statements together with do
+(do
+  (print "Hello")
+  "World") #=> "World" (prints "Hello")
+
+# Functions have an implicit do
+(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")
+
+# So does let
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) #=> "Hello Urkel" (prints "Saying hello to Urkel")
+
+# Use the threading macros (-> and ->>) to express transformations of
+# data more clearly.
+
+# The "Thread-first" macro (->) inserts into each form the result of
+# the previous, as the first argument (second item)
+(->
+   {:a 1 :b 2}
+   (put :c 3)  #=> (put {:a 1 :b 2} :c 3)
+   (unset :b)) #=> (unset (put {:a 1 :b 2} :c 3) :b)
+
+
+# The double arrow does the same thing, but inserts the result of
+# each line at the *end* of the form. This is useful for collection
+# operations in particular:
+(->>
+   (range 10)
+   (map inc)      #=> (map inc (range 10))
+   (filter odd?)) #=> (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
+  (get input 2)       #=> and at the second position, in the same expression
+  (push [4 5 6] input 8 9 10)) #=> or in the middle !
+                               # Result: [4 5 6 4 8 9 10]
+
+# PHP
+#################
+
+# PHP has a huge and useful standard library, and you're able to use
+# all native functions with the prefix `php/`.
+(php/+ 1 2 3)
+
+# With :use you can use different namespaces. Similar as `use` in PHP
+(ns my\module
+  (:use \DateTimeImmutable))
+
+# You can import functions from other phel files with :require
+(ns my\module
+  (:require phel\test :refer [deftest is]))
+
+# Use the class name with a "php/new" to make a new instance
+(php/new \DateTime) # <a date-time object>
+
+# Use php/-> to call methods of an object
+(def d (php/new \DateTime))
+(php/-> d (getTimestamp)) # <a timestamp>
+
+# you can do it in one line too
+(php/-> (php/new \DateTime) (getTimestamp))
+
+# Use php/:: to call static methods
+(php/:: \DateTimeImmutable ATOM) # <a timestamp>
+```
+
+### Further Reading
+
+This is far from exhaustive, but hopefully it's enough to get you on your feet.
+
+Read the full documentation in the website: [https://phel-lang.org/](https://phel-lang.org/documentation/getting-started/)
diff --git a/php.html.markdown b/php.html.markdown
index 57ba29c4..1ef52f68 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -92,9 +92,10 @@ $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.";
+$number = 23;
+$apples = "I have {$number} apples to eat.";   // => I have 23 apples to eat.
+$oranges = "I have ${number} oranges to eat."; // => I have 23 oranges to eat.
+$money = "I have $${number} in the bank.";     // => I have $23 in the bank.
 
 // Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners
 $nowdoc = <<<'END'
@@ -109,7 +110,7 @@ $sgl_quotes
 END;
 
 // String concatenation is done with .
-echo 'This string ' . 'is concatenated';
+echo 'This string ' . 'is concatenated';  // Returns 'This string is concatenated'
 
 // Strings can be passed in as parameters to echo
 echo 'Multiple', 'Parameters', 'Valid';  // Returns 'MultipleParametersValid'
@@ -443,7 +444,7 @@ $bar('C'); // Prints "A - B - C"
 // You can call named functions using strings
 $function_name = 'add';
 echo $function_name(1, 2); // => 3
-// Useful for programatically determining which function to run.
+// Useful for programmatically determining which function to run.
 // Or, use call_user_func(callable $callback [, $parameter [, ... ]]);
 
 
@@ -591,6 +592,12 @@ echo $my_class->property;     // => "public"
 echo $my_class->instanceProp; // => "An instance property"
 $my_class->myMethod();        // => "MyClass"
 
+// Nullsafe operators since PHP 8
+// You can use this when you're unsure if the abstraction of $my_class contains has a property/method
+// it can be used in conjunction with the nullish coalesce operator to ensure proper value
+echo $my_class->invalid_property // An error is thrown
+echo $my_class?->invalid_property // => NULL
+echo $my_class?->invalid_property ?? "public" // => "public"
 
 // Extend classes using "extends"
 class MyOtherClass extends MyClass
diff --git a/powershell.html.markdown b/powershell.html.markdown
index 318bf043..50e1e27e 100644
--- a/powershell.html.markdown
+++ b/powershell.html.markdown
@@ -118,14 +118,15 @@ $False - 5   # => -5
 2 -lt 3 -and 3 -lt 2  # => False
 
 # (-is vs. -eq) -is checks if two objects are the same type.
-# -eq checks if the objects have the same values.
+# -eq checks if the objects have the same values, but sometimes doesn't work
+# as expected.
 # Note: we called '[Math]' from .NET previously without the preceeding
 # namespaces. We can do the same with [Collections.ArrayList] if preferred.
 [System.Collections.ArrayList]$a = @()  # Point a at a new list
 $a = (1,2,3,4)
 $b = $a                                 # => Point b at what a is pointing to
 $b -is $a.GetType()                     # => True, a and b equal same type
-$b -eq $a                               # => True, a and b values are equal
+$b -eq $a                               # => None! See below
 [System.Collections.Hashtable]$b = @{}  # => Point a at a new hash table
 $b = @{'one' = 1 
        'two' = 2}
@@ -154,6 +155,13 @@ $age = 22
 "$name's name is $($name.Length) characters long." 
 # => "Steve's name is 5 characters long."
 
+# Strings can be compared with -eq, but are case insensitive. We can
+# force with -ceq or -ieq.
+"ab" -eq "ab"  # => True
+"ab" -eq "AB"  # => True!
+"ab" -ceq "AB"  # => False
+"ab" -ieq "AB"  # => True
+
 # Escape Characters in Powershell
 # Many languages use the '\', but Windows uses this character for 
 # file paths. Powershell thus uses '`' to escape characters
@@ -274,6 +282,10 @@ $array.AddRange($otherArray)  # Now $array is [1, 2, 3, 4, 5, 6]
 # Examine length with "Count" (Note: "Length" on arrayList = each items length)
 $array.Count  # => 6
 
+# -eq doesn't compare array but extract the matching elements
+$array = 1,2,3,1,1
+$array -eq 1          # => 1,1,1
+($array -eq 1).Count  # => 3
 
 # Tuples are like arrays but are immutable.
 # To use Tuples in powershell, you must use the .NET tuple class.
@@ -574,7 +586,7 @@ Get-Process | Foreach-Object ProcessName | Group-Object
 1..10 | ForEach-Object { "Loop number $PSITEM" }
 1..10 | Where-Object { $PSITEM -gt 5 } | ConvertTo-Json
 
-# A notable pitfall of the pipeline is it's performance when
+# A notable pitfall of the pipeline is its performance when
 # compared with other options.
 # Additionally, raw bytes are not passed through the pipeline,
 # so passing an image causes some issues.
@@ -665,7 +677,7 @@ Powershell as a Tool:
 
 Getting Help:
 
-```Powershell
+```powershell
 # Find commands
 Get-Command about_* # alias: gcm
 Get-Command -Verb Add
@@ -682,7 +694,7 @@ Update-Help # Run as admin
 
 If you are uncertain about your environment:
 
-```Powershell
+```powershell
 Get-ExecutionPolicy -List
 Set-ExecutionPolicy AllSigned
 # Execution policies include:
@@ -696,7 +708,7 @@ help about_Execution_Policies # for more info
 $PSVersionTable
 ```
 
-```Powershell
+```powershell
 # Calling external commands, executables, 
 # and functions with the call operator.
 # Exe paths with arguments passed or containing spaces can create issues.
@@ -802,6 +814,6 @@ Interesting Projects
 * [Oh-My-Posh](https://github.com/JanDeDobbeleer/oh-my-posh) Shell customization similar to the popular Oh-My-Zsh on Mac
 * [PSake](https://github.com/psake/psake) Build automation tool
 * [Pester](https://github.com/pester/Pester) BDD Testing Framework
-* [Jump-Location](https://github.com/tkellogg/Jump-Location) Powershell `cd` that reads your mind
+* [ZLocation](https://github.com/vors/ZLocation) Powershell `cd` that reads your mind
 * [PowerShell Community Extensions](https://github.com/Pscx/Pscx)
 * [More on the Powershell Pipeline Issue](https://github.com/PowerShell/PowerShell/issues/1908)
diff --git a/processing.html.markdown b/processing.html.markdown
index 777c6981..63f10e88 100644
--- a/processing.html.markdown
+++ b/processing.html.markdown
@@ -2,7 +2,7 @@
 language: processing
 filename: learnprocessing.pde
 contributors:
-    - ["Phone Thant Ko", "http://github.com/phonethantko"]
+    - ["Phone Than Ko", "http://github.com/phonethantko"]
     - ["Divay Prakash", "https://github.com/divayprakash"]
 ---
 
@@ -256,7 +256,7 @@ line(x1, y1, z1, x2, y2, z2); // In 3D space
 
 // Triangle
 triangle(x1, y1, x2, y2, x3, y3);
-// Draws a triangle connecting three points defined by coordinate paramters.
+// Draws a triangle connecting three points defined by coordinate parameters.
 
 // Rectangle
 rect(a, b, c, d, [r]); // With optional parameter defining the radius of all corners
@@ -375,7 +375,7 @@ texture(image); // PImage can be passed into arguments for texture-mapping the s
 
 If you want to take things further, there are more things Processing is powered
 for. Rendering models, shaders and whatnot. There's too much to cover in a
-short documentation, so I will leave them out here. Shoud you be interested,
+short documentation, so I will leave them out here. Should you be interested,
 please check out the references.
 
 ```
diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown
index 40c7cd09..886cb253 100644
--- a/pt-br/amd-pt.html.markdown
+++ b/pt-br/amd-pt.html.markdown
@@ -19,6 +19,7 @@ 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:
@@ -122,6 +123,7 @@ define(['daos/coisas', 'modules/algunsHelpers'], function(coisasDao, helpers){
   return AlgumaClasse;
 });
 ```
+
 Para alterar o comportamento padrão de mapeamento de caminho de pastas utilize
 `requirejs.config(configObj)` em seu `main.js`:
 
@@ -141,6 +143,7 @@ require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coo
   coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
 });
 ```
+
 Apps baseados em `require.js` geralmente terão um ú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
@@ -162,16 +165,19 @@ Muitas pessoas preferem usar AMD para sanar a organização do código durante o
 `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 */
 ({
@@ -188,6 +194,7 @@ Para o nosso exemplo acima a configuração pode ser essa:
 ```
 
 Para usar o arquivo gerado, em produção, simplesmente troque o `data-main`:
+
 ```html
 <script src="require.js" data-main="app/main-built"></script>
 ```
diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
index b12c0693..9fca5af0 100644
--- a/pt-br/asciidoc-pt.html.markdown
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["David Lima", "https://github.com/davelima"]
 lang: pt-br
-filename: asciidoc-pt.md
+filename: asciidoc-pt.adoc
 ---
 
 AsciiDoc é uma linguagem de marcação similar ao Markdown e pode ser
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 70d0a01c..02bffc41 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -202,7 +202,7 @@ function string_functions(    localvar, arr) {
     # Ambas retornam o número de instâncias substituídas
     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"
+    gsub("e", ".", localvar) # localvar => "M..t m. at th. bar"
 
     # Localiza um texto que casa com uma expressão regular
     # index() faz a mesma coisa, mas não permite uma expressão regular
@@ -370,8 +370,10 @@ END {
 }
 
 ```
+
 Leituras adicionais (em inglês):
 
 * [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 é encontrado na maioria dos sistemas GNU/Linux.
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
+  GNU AWK é encontrado na maioria dos sistemas GNU/Linux.
diff --git a/pt-br/bc-pt.html.markdown b/pt-br/bc-pt.html.markdown
new file mode 100644
index 00000000..2a412806
--- /dev/null
+++ b/pt-br/bc-pt.html.markdown
@@ -0,0 +1,104 @@
+---
+language: bc
+contributors:
+    - ["Btup"]
+translators:
+    - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: learnbc-pt.bc
+---
+```c
+/*Este é um comentário
+multi-linhas*/
+# Este é um comentário de uma única linha! (em bc GNU).
+
+    /*1. Variáveis e estruturas de controle*/
+num = 45 /*Todas as variáveis apenas salvam dados do tipo double, e
+    você não pode salvar strings diretamente em constantes.*/
+num 45; /*Você pode adicionar ponto-e-vírgula após cada linha.
+    Isto é opcional*/
+/*Blocos são denotados usando os operadores {} (similar ao C):*/
+while(num < 50) {
+    num += 1 /*equivalente a num=num+1.
+    a = a op b é equivalente a a op= b.*/
+}
+/*E existem os operadores ++ (incrementar) e -- (decrementar).*/
+/* Existem 3 tipos especiais de variáveis:
+scale: define a escala de números double.
+ibase: define a base de da entrada.
+obase: define a base da saída.
+*/
+/*Cláusulas If:*/
+hora = read() /*Lê a entrada de um número*/
+
+if(hora < 12) { /*Os operadores são idênticos ao C.*/
+    print "Bom dia\n" /*"print" imprime strings ou variáveis
+	separados por vírgula (,).*/
+} else if(hora == 12) {
+    print "Olá\n"
+    /*Para escapar strings, inicie a string com \.
+    Para deixar o escape de strings mais claros,
+    aqui está uma lista simplificada das strings escapadas
+    que funcionarão com bc:
+    \b: backspace
+    \c: carriage return (enter)
+    \n: newline (nova linha)
+    \t: tab
+    \\: backslash (barra inertida)*/
+} else {
+    /*Variáveis são globais por padrão.*/
+    istoEGlobal = 5
+    /*Para tornar uma variável local, use a palavra-chave "auto" em uma função.*/
+}
+
+/*Todas as variáveis por padrão tem o valor 0*/
+num = variavelEmBranco /*num é igual a 0.*/
+
+/*Assim como no C, "0" é considerado "false"*/
+if(!num) {print "false\n"}
+
+/*Diferente do C, bc não tem o operador ?:. Por exemplo,
+este bloco de código causaria um erro:
+a = (num) ? 1 : 0
+Entretanto, você pode simular da seguinte forma:
+a = (num) && (1) || (0) /*&& é "E", || é "OU"*/
+*/
+
+/*Loops For*/
+num = 0
+for(i = 1; i <= 100; i++) {/*Similar ao loop For do C.*/
+    num += i
+}
+
+    /*2.Funções e arrays*/
+define fac(n) { /*para definir uma função, use "define".*/
+    if(n == 1 || n == 0) {
+        return 1 /*retorna um valor*/
+    }
+    return n * fac(n - 1) /*recursão é permitido*/
+}
+
+/*Closures e funções anônimas não são permitidas*/
+
+num = fac(4) /*24*/
+
+/*Exemplo de variáveis locais:*/
+define x(n) {
+    auto x
+    x = 1
+    return n + x
+}
+x(3) /*4*/
+print x /*A variável "x" não será acessível de fora da função*/
+/*Arrays são equivalentes aos arrays em C.*/
+for(i = 0; i <= 3; i++) {
+    a[i] = 1
+}
+/*Para acessar um array, faça assim:*/
+print a[0], " ", a[1], " ", a[2], " ", a[3], "\n"
+quit /*Adicione essa linha no final do código
+para garantir que o programa encerre. Essa linha é opcional.*/ 
+```
+Aproveite bem essa simples calculadora! (Ou essa linguagem de programação, para ser exato.)
+
+Este programa inteiro foi escrito em GNU bc. Para rodá-lo, use ```bc learnbc-pt.bc```
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 42a29991..ca289001 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-pt.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
@@ -363,7 +363,7 @@ void OwnedDog::print() const
 {
     Dog::print(); // Chame a função de impressão na classe Dog base de
     std::cout << "Dog is owned by " << owner << "\n";
-    // Prints "Dog is <name> and weights <weight>"
+    // Imprime "Dog is <name> and weights <weight>"
     //        "Dog is owned by <owner>"
 }
 
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 4e55f068..22a86376 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
-language: c
-filename: learnc.c
+language: C
+filename: learnc-pt.c
 contributors:
     - ["Adam Bard", "http://adambard.com/"]
     - ["�rpád Goretity", "http://twitter.com/H2CO3_iOS"]
@@ -10,7 +10,6 @@ translators:
     - ["Cássio Böck", "https://github.com/cassiobsilva"]
     - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
 lang: pt-br
-filename: c-pt.el
 ---
 
 Ah, C. Ainda é **a** linguagem de computação de alta performance.
@@ -385,7 +384,6 @@ int main() {
 	// Por exemplo, quando um array é passado para uma função ou é atribuído a um
 	// ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
 	// Exceções: quando o array é o argumento de um operador `&` (endereço-de):
-    // Exceptions: when the array is the argument of the `&` (address-of) operator:
     int arr[10];
     int (*ptr_to_arr)[10] = &arr; // &arr não é do tipo `int *`!
                                   // É do tipo "ponteiro para array" (de `int`s).
diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown
index e40b8fe7..15ad930a 100644
--- a/pt-br/clojure-pt.html.markdown
+++ b/pt-br/clojure-pt.html.markdown
@@ -561,7 +561,7 @@ Caso queira aprender mais:
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
 * 4clojure possui alguns problemas e desafios interessantes para quem quiser treinar clojure ou programação funcional:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 * clojure-doc.org tem um bom número de artigos para iniciantes:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index 384ca325..87e5b3a4 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c#
+language: C#
 filename: csharp-pt.cs
 contributors:
     - ["Robson Alves", "http://robsonalves.net/"]    
@@ -153,7 +153,7 @@ on a new line! ""Wow!"", the masses cried";
             intArray[1] = 1;
 
             // Listas
-            // Listas são usadas frequentemente tanto quanto matriz por serem mais flexiveis
+            // Listas são usadas frequentemente tanto quanto matriz por serem mais flexíveis
             // O formato de declarar uma lista é o seguinte:
             // List<tipodado> <var nome> = new List<tipodado>();
             List<int> intList = new List<int>();
diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index e6dea5b8..e4f55276 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -290,9 +290,9 @@ A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em t
 
 ## Leitura adicional
 
-* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, eo Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, e o Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
 * [Selecionando elementos usando atributos](https://css-tricks.com/almanac/selectors/a/attribute/)
 * [QuirksMode CSS](http://www.quirksmode.org/css/)
 * [Z-Index - O empilhamento context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
-* [SASS](http://sass-lang.com/) e [menos](http://lesscss.org/) para CSS pré-processamento
+* [SASS](http://sass-lang.com/) e [Less](http://lesscss.org/) para CSS pré-processamento
 * [CSS-Tricks](https://css-tricks.com)
diff --git a/pt-br/d-pt.html.markdown b/pt-br/d-pt.html.markdown
new file mode 100644
index 00000000..ae4bab22
--- /dev/null
+++ b/pt-br/d-pt.html.markdown
@@ -0,0 +1,262 @@
+---
+language: D
+filename: learnd-pt.d
+contributors:
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
+    - ["Julio Vanzelli", "https://github.com/JulioVanzelli"]
+lang: pt-br
+---
+
+```d
+// Você sabe o que está por vir...
+module hello;
+
+import std.stdio;
+
+// args é opcional
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido
+sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
+linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até
+abstrações expressivas de alto nível.
+
+D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por
+[Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e
+[Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos!
+
+```d
+import std.stdio;
+
+void main() {
+
+    // Condicionais e loops funcionam como esperado.
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    // 'auto' pode ser usado para inferir tipos.
+    auto n = 1;
+
+    // literais numéricos podem usar '_' como um separador de dígitos para maior clareza.
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+
+    // Por e enquanto são bons, mas em D-land preferimos loops 'foreach'.
+    // O '..' cria um intervalo contínuo, incluindo o primeiro valor
+    // mas excluindo o último.
+    foreach(n; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(n);
+    }
+
+    // Há também 'foreach_reverse' quando você deseja fazer um loop para trás.
+    foreach_reverse(n; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(n);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões
+são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso,
+podemos usar modelos para parametrizar tudo isso em tipos e valores!
+
+```d
+// Aqui, 'T' é um parâmetro de tipo. Pense '<T>' em C++/C#/Java.
+struct LinkedList(T) {
+    T data = null;
+
+    // Usar '!' para instanciar um tipo parametrizado. Mais uma vez, pense '<T>'.
+    LinkedList!(T)* next;
+}
+
+class BinTree(T) {
+    T data = null;
+
+    // Se houver apenas um parâmetro de modelo, podemos omitir os parênteses.
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// Use o alias para criar abreviações para tipos.
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+// Também podemos criar modelos de funções!
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// Use a palavra-chave ref para garantir a passagem por referência. Ou seja, mesmo que 'a' 
+// e 'b' sejam tipos de valor, eles sempre serão passados por referência a 'swap ()'.
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// Com os modelos, também podemos parametrizar valores, não apenas tipos.
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3); // O tipo 'T' foi padronizado como 'int'.
+
+```
+
+Falando em aulas, vamos falar sobre propriedades por um segundo. Uma propriedade
+é aproximadamente uma função que pode agir como um valor I, para que possamos
+ter a sintaxe das estruturas POD (`structure.x = 7`) com a semântica de
+métodos getter e setter (`object.setX (7)`)!
+
+```d
+// Considere uma classe parametrizada nos tipos 'T' e 'U'.
+class MyClass(T, U) {
+    T _data;
+    U _other;
+}
+
+// E os métodos "getter" e "setter", assim:
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+    // Os construtores sempre são chamados de 'this'.
+    this(T t, U u) {
+        // This will call the setter methods below.
+        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;
+    }
+}
+
+// E nós os usamos desta maneira:
+void main() {
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+    // Importe o módulo 'stdio' da biblioteca padrão para gravar no 
+    // console (as importações podem ser locais para um escopo).
+    import std.stdio;
+
+    // Ligue para os getters para buscar os valores.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+    // Ligue para os setters para atribuir novos valores.
+    mc.data = 8;
+    mc.other = "eight";
+
+    // Ligue para os getters novamente para buscar os novos valores.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
+}
+```
+
+Com propriedades, podemos adicionar qualquer quantidade de lógica para
+nossos métodos getter e setter, e mantenha a sintaxe limpa de
+acessando membros diretamente!
+
+Outras guloseimas orientadas a objetos à nossa disposição,
+incluem interfaces, classes abstratas,
+e métodos de substituição. D faz herança como Java:
+Estenda uma classe, implemente quantas interfaces você desejar.
+
+Vimos as instalações OOP de D, mas vamos mudar de marcha. D oferece
+programação funcional com funções de primeira classe, `pura`
+funções e dados imutáveis. Além disso, todos os seus favoritos
+algoritmos funcionais (mapear, filtrar, reduzir e amigos) podem ser
+encontrado no maravilhoso módulo `std.algorithm`!
+
+```d
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // cria uma gama exclusiva de final
+
+void main() {
+    // Queremos imprimir a soma de uma lista de quadrados de ints pares 
+    // de 1 a 100. Fácil!
+
+    // Basta passar expressões lambda como parâmetros de modelo!
+    // Você pode passar qualquer função que desejar, mas as lambdas são convenientes aqui.
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+Observe como conseguimos construir um bom pipeline haskelliano para calcular num?
+Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS).
+Com o UFCS, podemos optar por escrever uma chamada de função como método
+ou chamada de função grátis! Walter escreveu um bom artigo sobre isso
+[aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+Em resumo, você pode chamar funções cujo primeiro parâmetro
+é de algum tipo A em qualquer expressão do tipo A como método.
+
+Eu gosto de paralelismo. Alguém mais gosta de paralelismo? Com certeza. Vamos fazer um pouco!
+
+```d
+// Digamos que queremos preencher uma matriz grande com a raiz quadrada de todos 
+// os números inteiros consecutivos começando de 1 (até o tamanho da matriz), e queremos 
+// fazer isso simultaneamente, aproveitando o número de núcleos que temos 
+// disponível.
+
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+    // Crie sua grande variedade
+    auto arr = new double[1_000_000];
+
+    // Use um índice, acesse todos os elementos da matriz por referência (porque vamos 
+    // mudar cada elemento) e apenas chame paralelo na matriz!
+    foreach(i, ref elem; parallel(arr)) {
+        elem = sqrt(i + 1.0);
+    }
+}
+```
diff --git a/pt-br/dart-pt.html.markdown b/pt-br/dart-pt.html.markdown
index e9d72850..6aff1ac3 100644
--- a/pt-br/dart-pt.html.markdown
+++ b/pt-br/dart-pt.html.markdown
@@ -3,15 +3,16 @@ language: dart
 filename: learndart-pt.dart
 contributors:
     - ["Joao Pedrosa", "https://github.com/jpedrosa/"]
+    - ["Hélio Oliveira", "https://github.com/insign/"]
 translators:
     - ["Junior Damacena", "https://github.com/jdamacena/"]
 lang: pt-br
 ---
 
 Dart é uma novata no reino das linguagens de programação.
-Ela empresta muito de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o Browser.
+Ela absorve muitas teorias de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o navegador.
 
-A característica mais controversa da Dart é a sua Tipagem Opcional, ou seja, não é obrigatório declarar tipos.
+As variáveis em Dart tem tipos, mas não é obrigatório declarar devido à função de [detecção automática](https://dart.dev/guides/language/type-system#type-inference).
 
 ```dart
 import "dart:collection";
diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown
index 4ba78f52..18441ff7 100644
--- a/pt-br/elixir-pt.html.markdown
+++ b/pt-br/elixir-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -20,7 +20,7 @@ e muitos outros recursos.
 # 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`.
+# 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.
@@ -51,7 +51,7 @@ elem({1, 2, 3}, 0) #=> 1
 head #=> 1
 tail #=> [2,3]
 
-# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
+# 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
@@ -85,7 +85,7 @@ linhas.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` em elixir retorna o valor ASCII para a letra `a`
+# `?a` em Elixir retorna o valor ASCII para a letra `a`
 ?a #=> 97
 
 # Para concatenar listas use `++`, para binários use `<>`
@@ -98,7 +98,7 @@ linhas.
 # 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]
+[menor, maior] #=> [1, 10]
 
 ## ---------------------------
 ## -- Operadores
@@ -110,7 +110,7 @@ menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# Em elixir o operador `/` sempre retorna um float.
+# Em Elixir o operador `/` sempre retorna um float.
 
 # Para divisão de inteiros use `div`
 div(10, 2) #=> 5
@@ -167,7 +167,7 @@ else
   "Isso será"
 end
 
-# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
+# Lembra do pattern 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
@@ -296,7 +296,7 @@ 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
+# Devido à imutabilidade, recursão é uma grande parte do Elixir
 defmodule Recursion do
   def sum_list([head | tail], acc) do
     sum_list(tail, acc + head)
@@ -309,7 +309,7 @@ end
 
 Recursion.sum_list([1,2,3], 0) #=> 6
 
-# Módulos do elixir suportam atributos, hpa atributos embutidos e você
+# Módulos do Elixir suportam atributos, hpa atributos embutidos e você
 # pode também adicionar os seus próprios.
 defmodule MyMod do
   @moduledoc """
@@ -361,7 +361,7 @@ end
 ## ---------------------------
 
 # 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,
+# 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
diff --git a/pt-br/emacs-pt.html.markdown b/pt-br/emacs-pt.html.markdown
new file mode 100644
index 00000000..7a86a119
--- /dev/null
+++ b/pt-br/emacs-pt.html.markdown
@@ -0,0 +1,60 @@
+---
+category: tool
+tool: emacs
+filename: emacs.txt
+contributors:
+    - ["Joseph Riad", "https://github.com/Joseph-Riad"]
+translators:
+    - ["André de Santa Gabriel", "https://github.com/andredesanta"]
+lang: pt-br
+---
+
+O Emacs começou sua vida como (https://www.gnu.org/software/emacs/emacs-paper.html) e cresceu
+ao longo dos anos em um ecossistema completo. Muitas tarefas, geralmente
+relegado a um conjunto diversificado de ferramentas pode ser realizado de dentro
+Emacs em uma interface consistente e familiar. Exemplos incluem
+gerenciamento de diretório, visualização de documentos PDF, edição de arquivos via SSH, gerenciamento de
+repos git. Em suma, o Emacs é seu para fazer
+o que você quiser: o espectro de usuários varia daqueles que o usam para
+editar arquivos de texto para puristas extremos que o usam para substituir virtualmente seu
+sistema operacional.
+
+O Emacs é extensível através de um dialeto especializado do Lisp conhecido como Emacs
+Lisp (Elisp), que possui muitas macros voltadas para a edição de texto e
+gerenciamento de buffers de texto. Qualquer tecla (combinação) usada no Emacs está vinculada
+para uma função Emacs Lisp e pode ser remapeado para qualquer outra função,
+incluindo aqueles que você escreve
+você mesmo.
+
+# Conceitos básicos de Emacs
+
+Aqui, discuto alguns conceitos e terminologia básicos do Emacs que podem ser
+confusos para os recém-chegados (especialmente para as pessoas acostumadas à terminologia do Vim):
+
+  - O texto que o Emacs está editando é conhecido como **buffer**
+  
+  - Um buffer não corresponde necessariamente a um arquivo real no disco. Pode ser apenas texto na memória.
+    
+  - Quando um buffer corresponde a um arquivo no disco, dizemos que o buffer está **visitando** esse arquivo.
+  
+  - O Emacs normalmente possui muitos buffers abertos ao mesmo tempo.
+  
+  - A exibição do Emacs pode ser dividida em diferentes **windows**.
+  
+  - Uma janela do sistema operacional para o Emacs é chamada de **frame**. Assim, quando o manual do Emacs fala sobre a abertura de um novo frame, esse essencialmente significa abrir uma nova janela do SO contendo uma (outra) instância do Emacs.
+  
+  - Os conceitos convencionalmente conhecidos como recortar e colar são referido como **killing** e **yanking**, respectivamente no Emacs.
+  
+  - A posição atual do cursor é chamada de **point** no Emacs. Tecnicamente, **point** é definido como a posição imediatamente antes do caractere onde o cursor está atualmente.
+  
+  - Finalmente, cada buffer pode ter vários **modes** associados: o **major mode** e possivelmente vários **minor modes**.
+  
+  - O **major mode** define o principal comportamento do Emacs no buffer atualmente selecionado. Isso pode ser pensado como o tipo de arquivo. Por exemplo, se você estiver editando um arquivo Python, os principais modes é (por padrão) `python-mode`, que faz com que o Emacs destaque a sintaxe Python e idente automaticamente seus blocos de código conforme exigido sintaticamente pelo seu código Python.
+  
+  - **Minor modes** definem mudanças sutis no comportamento e várias alterações menores Os modos podem estar ativos ao mesmo tempo no mesmo buffer. Um exemplo menor modo é o modo flyspell, que destaca automaticamente os erros de ortografia no seu buffer.
+
+# Recursos adicionais
+
+  - [The GNU Emacs Manual](https://www.gnu.org/software/emacs/manual/emacs.html)
+  - [Emacs Stack Exchange](https://emacs.stackexchange.com/)
+  - [Emacs Wiki](https://www.emacswiki.org/emacs/EmacsWiki)
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
index e59ba901..2cc1c337 100644
--- a/pt-br/git-pt.html.markdown
+++ b/pt-br/git-pt.html.markdown
@@ -11,6 +11,7 @@ contributors:
 translators:
   - ["Suzane Sant Ana", "http://github.com/suuuzi"]
   - ["Bruno Volcov", "http://github.com/volcov"]
+  - ["Marcel Ribeiro-Dantas", "http://github.com/mribeirodantas"]
 ---
 
 Git é um sistema distribuido de gestão para código fonte e controle de versões.
@@ -67,7 +68,8 @@ referências e outros.
 
 ### *Working Tree* (componente do repositório)
 
-A *Working Tree* é basicamente a listagem dos diretórios e arquivos do repositório. É chamada também de diretório do projeto.
+A *Working Tree* é basicamente a listagem dos diretórios e arquivos do
+repositório. É chamada também de diretório do projeto.
 
 ### *Index* (componente do diretório .git)
 
@@ -77,28 +79,37 @@ maior controle sobre o que é registado no repositório git.
 
 ### *Commit*
 
-Um *commit** de git é um registo de um cojunto de alterações ou manipulações nos arquivos do projeto.
-Por exemplo, ao adicionar cinco arquivos e remover outros 2, estas alterações
-serão gravadas num *commit* (ou registo). Este *commit* pode então ser enviado
-para outros repositórios ou não!
+Um *commit** de git é um registo de um conjunto de alterações ou manipulações
+nos arquivos do projeto. Por exemplo, ao adicionar cinco arquivos e remover
+outros 2, estas alterações serão gravadas em um *commit* (ou registro). Este
+*commit* pode então ser enviado para outros repositórios, caso você queira.
 
 ### *Branch*
 
-Um *branch* é essencialmente uma referência que aponta para o último *commit*
+Uma *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)
+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
-uma *HEAD* activa.
-*head* é uma referência que aponta para qualquer *commit*. Um repositório pode
-ter um número indefinido de *heads*
+*HEAD* é a referência que aponta para a *branch* em uso. Um repositório só tem
+uma *HEAD* activa. *head* é uma referência que aponta para qualquer *commit*. Um
+repositório pode ter um número indefinido de *heads*.
+
+### Estados no Git
+
+* Modificado (Modified): Ocorreram mudanças em ao menos um arquivo mas essas
+mudanças ainda não foram registradas na base de dados do Git
+* Preparado (Staged): Marca o arquivo como preparado para ser adicionado ao
+próximo commit
+* Consolidado (Committed): As mudanças foram registradas na base de dados do
+Git
 
 ### Recursos conceituais (EN)
 
@@ -109,8 +120,8 @@ ter um número indefinido de *heads*
 
 ### *init*
 
-Cria um repositório Git vazio. As definições, informação guardada e outros do
-repositório git são guardados em uma pasta chamada ".git".
+Cria um repositório Git vazio. As configurações do repositório, e outras
+informações são guardadas em uma pasta dentro do repositório com o nome ".git".
 
 ```bash
 $ git init
@@ -118,23 +129,24 @@ $ git init
 
 ### *config*
 
-Permite configurar as definições, sejam as definições do repositório, sistema
-ou configurações globais.
+Permite configurar o git, seja com respeito a definições deste repositório,
+do sistema ou configurações globais para todos os repositórios.
 
 ```bash
-# Imprime e define algumas variáveis de configuração básicas (global)
-$ git config --global user.email
-$ git config --global user.name
-
+# Define e imprime algumas variáveis de configuração básicas (global)
 $ git config --global user.email "MyEmail@Zoho.com"
 $ git config --global user.name "My Name"
+
+$ git config --global user.email
+$ git config --global user.name
 ```
 
 [Aprenda mais sobre git config. (EN)](http://git-scm.com/docs/git-config)
 
 ### help
 
-Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da semântica.
+Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da
+semântica.
 
 ```bash
 # Ver rapidamente os comandos disponiveis
@@ -148,16 +160,32 @@ $ git help -a
 $ git help add
 $ git help commit
 $ git help init
+# ou git <comando_aqui> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### Ignorando arquivos
+
+É possível intencionalmente ignorar arquivos e pastas. Costuma-se utilizar o
+arquivo .gitignore para fazer o git ignorar a existência de arquivos e pastas
+geralmente utilizados para arquivos privados ou temporários que, de outro modo,
+seriam compartilhados com todos que tem acesso ao repositório.
+
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "chave_privada" >> .gitignore
 ```
 
 ### status
 
-Apresenta as diferenças entre o arquivo *index* (a versão corrente
-do repositório) e o *commit* da *HEAD* atual.
+Apresenta as diferenças entre o arquivo *index* (a versão corrente do
+repositório) e o *commit* da *HEAD* atual.
 
 
 ```bash
-# Apresenta o *branch*, arquivos não monitorados, alterações e outras
+# Apresenta a *branch*, arquivos não monitorados, alterações e outras
 # diferenças
 $ git status
 
@@ -173,35 +201,42 @@ incluidos nos commits!
 
 ```bash
 # adiciona um arquivo no diretório do projeto atual
-$ git add HelloWorld.java
+$ git add OlaMundo.java
 
-# adiciona um arquivo num sub-diretório
-$ git add /path/to/file/HelloWorld.c
+# adiciona um arquivo em um sub-diretório
+$ git add /caminho/para/arquivo/OlaMundo.java
 
 # permite usar expressões regulares!
 $ git add ./*.java
+
+# Você também pode adicionar tudo no seu diretório de trabalho como alterações
+prontas para o próximo commit.
+$ git add -A
 ```
 
+Esse comando apenas adiciona os arquivos no estado de preparados para o próximo
+commit, mas não realiza o commit de fato.
+
 ### branch
 
-Gerencia os *branches*. É possível ver, editar, criar e apagar branches com este
+Gerencia as *branches*. É possível ver, editar, criar e apagar branches com este
 comando.
 
 ```bash
 # listar *branches* existentes e remotos
 $ git branch -a
 
-# criar um novo *branch*
+# criar uma nova *branch*
 $ git branch myNewBranch
 
-# apagar um *branch*
+# apagar uma *branch*
 $ git branch -d myBranch
 
-# alterar o nome de um *branch*
+# alterar o nome de uma *branch*
 # git branch -m <oldname> <newname>
 $ git branch -m myBranchName myNewBranchName
 
-# editar a descrição de um *branch*
+# editar a descrição de uma *branch*
 $ git branch myBranchName --edit-description
 ```
 
@@ -212,18 +247,22 @@ 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
 ```
@@ -231,14 +270,16 @@ $ git push origin --tags
 ### checkout
 
 Atualiza todos os arquivos no diretório do projeto para que fiquem iguais
-à versão do index ou do *branch* especificado.
+à versão do index ou da *branch* especificado.
 
 ```bash
-# Checkout de um repositório - por padrão para o branch master
+# Checkout de um repositório - por padrão para a branch master
 $ git checkout
-# Checkout de um branch especifico
+
+# Checkout de uma branch especifica
 $ git checkout branchName
-# Cria um novo branch e faz checkout para ele.
+
+# Cria uma nova branch e faz checkout para ela.
 # Equivalente a: "git branch <name>; git checkout <name>"
 $ git checkout -b newBranch
 ```
@@ -246,22 +287,41 @@ $ git checkout -b newBranch
 ### clone
 
 Clona ou copia um repositório existente para um novo diretório. Também
-adiciona *branches* de monitoramento remoto para cada *branch* no repositório
-clonado o que permite enviar alterações para um *branch* remoto.
+adiciona *branches* no repositório clonado para cada *branch* no repositório
+remoto o que permite enviar alterações para uma *branch* no repositório remoto.
 
 ```bash
 # Clona learnxinyminutes-docs
 $ git clone https://github.com/adambard/learnxinyminutes-docs.git
+
+# Clone superficial - É mais rápido, mas puxa apenas o último commit
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+
+# Clona apenas uma branch em específica
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
 ```
 
 ### commit
 
-Guarda o conteudo atual do index num novo *commit*. Este *commit* contém
+Guarda o conteúdo atual do index em um novo *commit*. Este *commit* contém
 as alterações feitas e a mensagem criada pelo usuário.
 
 ```bash
-# commit com uma mensagem
-$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+# Realiza um commit com uma mensagem
+$ git commit -m "Adicione a função multipliqueNumeros() em OlaMundo.c"
+
+# Assine um commit com sua chave GPG. Antes disso, você precisa ter
+# configurado a opção user.signkey do git com o comando:
+# git config --global user.signinkey ID_CHAVE_AQUI
+$ git commit -S -m "mensagem do commit aqui"
+
+# Automaticamente adicione como preparados arquivos modificados ou apagados e
+# então realize um commit:
+$ git commit -a -m "Modified foo.php and removed bar.php"
+
+# Altere o último commit (Esse comando cria um novo commit com o conteúdo do
+# commit anterior mais suas novas alterações e sobrescreve o último commit)
+$ git commit --amend -m "Correct message"
 ```
 
 ### diff
@@ -282,7 +342,7 @@ $ git diff HEAD
 
 ### grep
 
-Permite procurar facilmente num repositório
+Permite procurar facilmente em um repositório.
 
 Configurações opcionais:
 
@@ -313,74 +373,158 @@ Apresenta commits do repositório.
 # Apresenta todos os commits
 $ git log
 
-# Apresenta X commits
-$ git log -n 10
+# Apresenta apenas mensagem do commit e referência
+$ git log --oneline
 
 # Apresenta apenas commits de merge
 $ git log --merges
+
+# Apresenta todos os commits representados por um gráfico em ASCII
+$ git log --graph
 ```
 
 ### merge
 
-"Merge" junta as alterações de commits externos com o *branch* atual.
+"Merge" junta as alterações de commits externos com a *branch* atual.
 
 ```bash
-# Junta o branch especificado com o atual
+# Junta a branch especificada com o atual
 $ git merge branchName
 
-# Para gerar sempre um commit ao juntar os branches
+# Para gerar sempre um commit ao juntar as branches
 $ git merge --no-ff branchName
 ```
 
 ### mv
 
-Alterar o nome ou mover um arquivo.
+Altera o nome ou move um arquivo.
 
 ```bash
 # Alterar o nome de um arquivo
-$ git mv HelloWorld.c HelloNewWorld.c
+$ git mv OlaMundo.c OlaNovoMundo.c
 
 # Mover um arquivo
-$ git mv HelloWorld.c ./new/path/HelloWorld.c
+$ git mv OlaMundo.c ./novo/caminho/OlaMundo.c
 
-# Forçar a alteração de nome ou mudança local
-# "existingFile" já existe no directório, será sobrescrito.
+# Forçar a alteração de nome ou mudança de local
+# Se o arquivo já existir no diretório, será sobrescrito.
 $ git mv -f myFile existingFile
 ```
 
 ### pull
 
-Puxa alterações de um repositório e as junta com outro branch
+Puxa alterações de um repositório e as junta com outra branch
 
 ```bash
 # Atualiza o repositório local, juntando as novas alterações
 # do repositório remoto 'origin' e branch 'master'
 # git pull <remote> <branch>
-# git pull => aplica a predefinição => git pull origin master
 $ git pull origin master
 
-# Juntar alterações do branch remote e fazer rebase commits do branch
+# Por padrão, o git irá realizar o pull na branch atual fazendo um merge
+# com as alterações novas na branch remota
+$ git pull
+
+# Juntar alterações da branch remote e fazer rebase commits da branch
 # no repositório local, como: "git pull <remote> <branch>, git rebase <branch>"
 $ git pull origin master --rebase
 ```
 
 ### push
 
-Enviar e juntar alterações de um branch para o seu branch correspondente
-num repositório remoto.
+Enviar e juntar alterações de uma branch para a sua branch correspondente
+em um repositório remoto.
 
 ```bash
 # Envia e junta as alterações de um repositório local
-# para um remoto denominado "origin" no branch "master".
+# para um remoto denominado "origin" na branch "master".
 # git push <remote> <branch>
-# git push => aplica a predefinição => git push origin master
 $ git push origin master
+
+# Por padrão, o git push irá enviar e realizar merge das mudanças da sua branch
+# local com a branch remota
+$ git push
+
+# Para associar a branch local com uma branch específica remota, adicione a
+# flag -u
+$ git push -u origin master
+
+# Agora, sempre que você realizar um push daquela branch local, use o atalho:
+$ git push
 ```
 
+### stash
+
+O objetivo desse comando do git é pegar o estado "sujo" do seu diretório de
+trabalho, que não está pronto (staged), e salvá-lo em um outro lugar para que
+você possa trabalhar no seu repositório do zero, mas sem perder as mudanças que
+fez. Em qualquer outro momento que você quiser, você pode trazer de volta as
+alterações que você tirou dali com o comando stash.
+
+Digamos que você tem feito algumas alterações no seu repositório, mas agora
+você quer realizar um pull do repositório remoto. Como você tem alterações não
+commitadas no seu diretório (ele está "sujo"), você não irá conseguir realizar
+o `git pull` com sucesso. Mas você pode executar o `git stash` para salvar
+essas alterações e conseguir realizar o pull. Depois, você traz de volta.
+
+```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")
+```
+
+Agora você irá conseguir realizar o pull!
+
+```bash
+git pull
+```
+`...changes apply...`
+
+Verifique se está tudo OK com o `git status`
+
+```bash
+$ git status
+# On branch master
+nothing to commit, working directory clean
+```
+
+É possível verificar as alterações que você guardou com cada uso do comando
+`git stash` com o `git stash list`. Como os usos desse comando são guardados
+como em uma pilha, os usos mais recentes estarão no topo.
+
+```bash
+$ git stash list
+stash@{0}: WIP on master: 049d078 added the index file
+stash@{1}: WIP on master: c264051 Revert "added file_size"
+stash@{2}: WIP on master: 21d80a5 added number to log
+```
+
+Agora vamos trazer o que havíamos salvado com o `git stash` de volta para o
+diretório de trabalho.
+
+```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` faz a mesma coisa
+
+Agora podemos voltar a trabalhar no que havíamos deixado de lado!
+
+[Additional Reading.](http://git-scm.com/book/en/v1/Git-Tools-Stashing)
+
 ### rebase (cautela!)
 
-Pega em todas as alterações que foram registadas num branch e volta a
-aplicá-las em outro branch.
+Pega em todas as alterações que foram registadas em uma branch e volta a
+aplicá-las em outra branch.
 *Não deve ser feito rebase de commits que foram enviados para um repositório
 público*
 
@@ -407,31 +551,79 @@ $ git reset
 # sobrescreve o projeto atual
 $ git reset --hard
 
-# Move a head do branch atual para o commit especificado, sem alterar o projeto.
+# Move a head da branch atual para o commit especificado, sem alterar o projeto.
 # todas as alterações ainda existem no projeto
 $ git reset 31f2bb1
 
-# Inverte a head do branch atual para o commit especificado
+# Inverte a head da branch atual para o commit especificado
 # fazendo com que este esteja em sintonia com o diretório do projeto
-# Remove alterações não registadas e todos os commits após o commit especificado
+# Remove alterações não registradas e todos os commits após o commit
+# especificado
 $ git reset --hard 31f2bb1
 ```
 
+### reflog (cuidado!)
+
+O reflog irá listar a maior parte dos comandos que você realizou no git em um
+determinado intervalo de tempo. O intervalo padrão é de 90 dias.
+
+Isso te dá a oportunidade de reverter qualquer comando que você realizou no git
+e que tenha tido consequências indesejadas (por exemplo, se um rebase quebrou
+sua aplicação).
+
+Você pode fazer assim:
+
+1. `git reflog` para listar todos os comandos utilizados no git para o 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. Selecione para onde você quer resetar. No nosso exemplo, seria o commit
+`2e6c386`, ou `HEAD@{5}`
+3. 'git reset --hard HEAD@{5}' esse comando irá resetar o seu repositório para
+aquele ponto (5 commits atrás).
+4. Agora você pode recomeçar o rebase ou apenas deixar como está.
+
+[Leitura complementar](https://git-scm.com/docs/git-reflog)
+
+### revert
+
+O comando revert pode ser utilizado para desfazer um commit. Não deve ser
+confundido com o comando reset que restabelece o estado do repositório para um
+momento anterior. O revert irá criar um novo commit com alterações inversas a
+de um outro commit especificado, portanto revertendo aquelas alterações.
+
+```bash
+# Revertendo um commit específico
+$ git revert <commit>
+```
+
 ### rm
 
-O oposto de git add, git rm remove arquivos do branch atual.
+O oposto de git add, git rm remove arquivos da branch atual.
 
 ```bash
-# remove HelloWorld.c
-$ git rm HelloWorld.c
+# remove OlaMundo.c
+$ git rm OlaMundo.c
 
-# Remove um arquivo de um sub-directório
-$ git rm /pather/to/the/file/HelloWorld.c
+# Remove um arquivo de um sub-diretório
+$ git rm /caminho/para/o/arquivo/OlaMundo.c
 ```
 
-## Informação complementar (EN)
+## Leitura complementar
+
+* [Configurar o Git (GitHub Docs)](https://docs.github.com/pt/get-started/quickstart/set-up-git)
+
+* [Learn Git Branching - the most visual and interactive way to learn Git on the web](http://learngitbranching.js.org/)
 
-* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
+* [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/)
 
 * [git-scm - Video Tutorials](http://git-scm.com/videos)
 
@@ -441,4 +633,10 @@ $ git rm /pather/to/the/file/HelloWorld.c
 
 * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
 
-* [GitGuys](http://www.gitguys.com/)
+* [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html)
+
+* [Pro Git (em Português)](https://www.git-scm.com/book/pt-br/v2)
+
+* [An introduction to Git and GitHub for Beginners (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
+
+* [The New Boston tutorial to Git covering basic commands and workflow](https://www.youtube.com/playlist?list=PL6gx4Cwl9DGAKWClAD_iKpNC0bGHxGhcx)
diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
index 31473ee1..ce10e079 100644
--- a/pt-br/go-pt.html.markdown
+++ b/pt-br/go-pt.html.markdown
@@ -28,7 +28,7 @@ Go vem com uma biblioteca padrão exaustiva e uma comunidade entusiasta.
    várias linhas */
 
 // A cláusula package aparece no início de cada arquivo.
-// Main é um nome especial declarando um executável ao invés de uma biblioteca.
+// main é um nome especial declarando um executável ao invés de uma biblioteca.
 package main
 
 // A cláusula Import declara os pacotes referenciados neste arquivo.
@@ -77,7 +77,7 @@ pode incluir quebras de linha.` // mesmo tipo string
     // literal não-ASCII. A linguagem Go utiliza de raiz a codificação UTF-8.
     g := 'Σ' // tipo rune, um alias para int32, que contém um código unicode
 
-    f := 3.14195 // float64, número de vírgula flutuante de 64bit (IEEE-754)
+    f := 3.14159 // float64, número de vírgula flutuante de 64bit (IEEE-754)
     c := 3 + 4i  // complex128, representado internamente com dois float64s
 
     // Declaração de variáveis, com inicialização.
@@ -295,17 +295,17 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 ## Leitura Recomendada
 
-A principal fonte de informação é o [web site oficial Go](http://golang.org/).
+A principal fonte de informação é o [web site oficial Go](https://go.dev/).
 Lá é possível seguir o tutorial, experimentar de forma iterativa, e ler muito.
 
 A própria especificação da linguagem é altamente recomendada. É fácil de ler e
 incrivelmente curta (em relação ao que é habitual hoje em dia).
 
 Na lista de leitura para os aprendizes de Go deve constar o [código fonte da 
-biblioteca padrão](http://golang.org/src/pkg/). Exaustivamente documentado, é
+biblioteca padrão](https://go.dev/src/). Exaustivamente documentado, é
 a melhor demonstração de código fácil de ler e de perceber, do estilo Go, e da
 sua escrita idiomática. Ou então clique no nome de uma função na [documentação]
-(http://golang.org/pkg/) e veja o código fonte aparecer!
+(https://go.dev/pkg/) e veja o código fonte aparecer!
 
 Outra ótima fonte para aprender Go é o [Go by example](https://gobyexample.com/).
 Apesar de ser em inglês, é possível recodificar os exemplos para aprender sobre
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index 3acfce21..dff3f2e1 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -5,7 +5,8 @@ filename: learngroovy-pt.groovy
 contributors:
     - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
 translators:
-    - ["João Farias", "https://github.com/JoaoGFarias"]
+    - ["João Farias", "https://github.com/joaogfarias"]
+    - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"]
 lang: pt-br
 ---
 
@@ -201,8 +202,16 @@ if(x==1) {
 
 //Groovy também suporta o operador ternário
 def y = 10
-def x = (y > 1) ? "functionou" : "falhou"
-assert x == "functionou"
+def x = (y > 1) ? "funcionou" : "falhou"
+assert x == "funcionou"
+
+//E suporta o 'The Elvis Operator' também!
+//Em vez de usar o operador ternário:
+
+displayName = nome.name ? nome.name : 'Anonimo'
+
+//Podemos escrever:
+displayName = nome.name ?: 'Anonimo'
 
 //Loop 'for'
 //Itera sobre um intervalo (range)
diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown
index 58586522..919c0f4f 100644
--- a/pt-br/latex-pt.html.markdown
+++ b/pt-br/latex-pt.html.markdown
@@ -8,6 +8,7 @@ contributors:
     - ["Svetlana Golubeva", "https://attillax.github.io/"]
 translators:
     - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
+    - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"]
 lang: pt-br
 filename: learn-latex-pt.tex
 ---
@@ -16,10 +17,10 @@ filename: learn-latex-pt.tex
 % Todas as linhas de comentários começam com %
 % Não existem comentários multilinhas
 
-$ LaTeX não é um programa processador de textos "Visual" como
+% LaTeX não é um programa processador de textos "Visual" como
 % MS Word ou OpenOffice Writer
 
-$ Todo comando LaTeX começa com uma barra invertida (\)
+% Todo comando LaTeX começa com uma barra invertida (\)
 
 % Documentos LaTeX começam com a definição do tipo que será % compilado
 % Os tipos de documento podem ser livro, relatório, apresentação, etc.
@@ -37,14 +38,11 @@ $ Todo comando LaTeX começa com uma barra invertida (\)
 \usepackage{float}
 \usepackage{hyperref}
 
-% Para poder usar caracteres acentuados, use o seguinte pacote:
-\usepackage[utf8]{inputenc}
-
 % Podemos definir algumas outras propriedades do documento também!
 \author{Chaitanya Krishna Ande, Colton Kohnke, Sricharan Chiruvolu \& \\
 Svetlana Golubeva}
 \date{\today}
-\title{Aprenda \LaTeX \hspace{1pt} em Y Minutos!}
+\title{Aprenda \LaTeX{} em Y Minutos!}
 
 % Agora estamos prontos para começar o documento
 % Tudo antes dessa linha é chamado "preâmbulo".
@@ -52,6 +50,7 @@ Svetlana Golubeva}
 % Se informarmos os campos author (autores), date (data), "title" (título),
 % LaTeX poderá cria uma página inicial para nós.
 \maketitle
+
 % Se tivermos seções, poderemos criar uma tabela de conteúdo. Para isso,
 % o documento deve ser compilado duas vezes, para que tudo apareça na ordem
 % correta.
@@ -69,7 +68,7 @@ Svetlana Golubeva}
 % Esse comando está disponível para os documentos do tipo artigo (article)
 % e relatório (report).
 \begin{abstract}
- Documentação do \LaTeX \hspace{1pt} escrita em \LaTeX! Nada original!
+ Documentação do \LaTeX{} escrita em \LaTeX! Nada original!
 \end{abstract}
 
 % Comandos para seções são intuitivos. 
@@ -93,11 +92,17 @@ Muito melhor agora.
 Afinal nem todas as seções precisam ser numeradas!
 
 \section{Algumas notas sobre texto}
-%\section{Espaçamento % É necessário mais informação sobre intervalos de espaço.
-\LaTeX \hspace{1pt} geralmente é muito bom sobre colocar texto onde ele deve
+%\section{Espaçamento} % É necessário mais informação sobre intervalos de espaço.
+\LaTeX{} geralmente é muito bom sobre colocar texto onde ele deve
 ser posto. Se 
 uma linha \\ deve \\ ser \\ quebrada \\ adicione \textbackslash\textbackslash
-\hspace{1pt} ao código de seu documento. \\ 
+\hspace{1pt} ao código de seu documento. 
+
+Separe parágrafos por linhas vazias.
+
+Você precisa adicionar um til após abreviações (se não forem seguidas de vírgula)
+para um espaço sem quebra, senão o espaçamento após o ponto será muito largo:
+E.g., i.e., etc.~são exemplos de abreviações.
 
 \section{Listas}
 Listas são uma das coisas mais fáceis de criar no \LaTeX! Preciso fazer compras
@@ -112,21 +117,21 @@ amanhã, então façamos uma lista de compras.
 
   Não é um item da lista, mas faz parte do bloco enumerate.
 
-  \end{enumerate} % Todos os blocos devem ter um final (end{}).
+\end{enumerate} % Todos os blocos devem ter um final (end{}).
 
 \section{Matemática}
 
-Um dos usos iniciais para \LaTeX \hspace{1pt} foi a produção de artigos
+Um dos usos iniciais para \LaTeX{} foi a produção de artigos
 acadêmicos e técnicos. Usualmente nos campos da matemática e ciência. Assim, é
-necessários que consigamos incluir alguns símbolos especiais em nosso texto! \\
+necessários que consigamos incluir alguns símbolos especiais em nosso texto!
 
 A matemática tem muitos símbolos, além dos quais se pode encontrar no teclado;
 símbolos para relações e conjuntos, setas, operadores, e letras gregas, apenas
-para mencionar alguns.\\
+para mencionar alguns.
 
 Conjuntos e relações são essenciais em muitos textos de pesquisa em matemática.
 Aqui está como você pode indicar como todo x que pertence
-a X, $\forall$ x $\in$ X. \\
+a X, $\forall$ x $\in$ X.
 % Perceba que é necessário adicionar os sinais $ antes e depois dos símbolos.
 % Isso é porque quando escrevendo, estamos em modo texto.
 % Mas os símbolos de matemática só existem no modo matemática.
@@ -138,15 +143,14 @@ a X, $\forall$ x $\in$ X. \\
 \[a^2 + b^2 = c^2 \]
 
 Minha letra grega favorita é $\xi$. Eu também gosto da $\beta$, $\gamma$ e $\sigma$.
-Eu ainda não encontrei uma letra grega que o \LaTeX \hspace{1pt} não tenha!\\
+Eu ainda não encontrei uma letra grega que o \LaTeX{} não tenha!\\
 
 Operadores são parte essencial de um documento sobre matemática:
 funções trigonométricas ($\sin$, $\cos$, $\tan$),
 logaritmo e exponencial ($\log$, $\exp$), 
-limites ($\lim$), etc. 
-possuem comandos pré-definidos em LaTex. 
+limites ($\lim$), etc.~possuem comandos pré-definidos em LaTex. 
 Vamos escrever uma equação para ver como se faz:
-$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
 
 Frações (numerador/denominador) podem ser escritas dessa forma:
 
@@ -183,8 +187,10 @@ Somatórios e Integrais são escritas com os comandos sum e int:
 
 \section{Figuras}
 
-Insiramos uma Figura. O local para colocar a figura pode ser difícil
-de determinar. Eu tenho sempre que verificar as opções toda vez.
+Insiramos uma Figura. O local para colocar a figura pode ser difícil de determinar.
+Operações básicas são [t] para o topo, [b] para base, [h] para aqui (aproximadamente).
+Eu tenho sempre que verificar as opções toda vez.
+% Veja https://en.wikibooks.org/wiki/LaTeX/Floats,_Figures_and_Captions para mais detalhes
 
 \begin{figure}[H] % H aqui é uma opção para o local da figura. 
     \centering % centra a figura na página
@@ -201,36 +207,45 @@ Também podemos incluir tabelas da mesma forma que figuras.
 \begin{table}[H]
   \caption{Título para a Tabela.}
   % os argumentos {} abaixo descrevem como cada linha da tabela é desenhada.
-  % Aqui também, Preciso ver isso. Toda. E. Cada. Vez.
+  % O básico é simples: uma letra para cada coluna, para controlar o alinhamento:
+  % Operações básicas são: c, l, r e p para centro, esquerda, direita e parágrafo
+  % opcionalmente, você pode adicionar um | para linha vertical
+  % Veja https://en.wikibooks.org/wiki/LaTeX/Tables para mais detalhes
   \begin{tabular}{c|cc} 
-    Número &  Sobrenome & Primeiro Nome \\ % Colunas são separadas por &
+    Número &  Primeiro Nome & Sobrenome \\ % Colunas são separadas por &
     \hline % uma linha horizontal
     1 & Biggus & Dickus \\
     2 & Monty & Python
   \end{tabular}
+  % Vai ficar mais ou menos assim:
+  % Número | Primeiro Nome  Sobrenome
+  % -------|---------------------------  % por causa do \hline
+  %   1    |   Biggus        Dickus
+  %   2    |   Monty         Python
 \end{table}
 
-\section{Fazendo o \LaTeX \hspace{1pt} não compilar algo (o código fonte)}
+\section{Fazendo o \LaTeX{} não compilar algo (o código fonte)}
 Digamos que precisamos incluir algum código dentro do nosso
-documento \LaTeX \hspace{1pt}, para isso precisamos com o \LaTeX \hspace{1pt}
+documento \LaTeX{}, para isso precisamos com o \LaTeX{}
 não tente interpretar esse texto e que apenas inclua ele no documento. Fazemos
 isso com o bloco verbatim.
 
 % Existem outros pacotes (por exemplo, minty, lstlisting, etc.)
 % mas verbatim é o básico
 \begin{verbatim} 
-  print("Hello World!")
+  print("Olá mundo!")
   a%b; % olha só! Podemos usar os sinais % no bloco verbatim. 
-  random = 4; #decided by fair random dice roll
+  random = 4; #decidido por um lançamento honesto de dado
+  Veja https://www.explainxkcd.com/wiki/index.php/221:_Random_Number
 \end{verbatim}
 
 \section{Compilando} 
 
 Imagino que agora você esteja pensando como compilar esse fantástico documento
-e visualizar a gloriosa glória que é um pdf gerado por \LaTeX \hspace{1pt} pdf.
+e visualizar a gloriosa glória que é um pdf gerado por \LaTeX{} pdf.
 (sim, esse documento é compilável). \\
 
-Finalizando o documento usando \LaTeX \hspace{1pt} consiste nos seguintes passos:
+Finalizando o documento usando \LaTeX{} consiste nos seguintes passos:
   \begin{enumerate}
     \item Escrever o documento em texto puro (o ``código fonte'').
     \item Compilar o código fonte para gerar um pdf. 
@@ -240,7 +255,7 @@ Finalizando o documento usando \LaTeX \hspace{1pt} consiste nos seguintes passos
      \end{verbatim}
   \end{enumerate}
 
-Existem editores de \LaTeX \hspace{1pt} que combinam os passos 1 e 2 no mesmo
+Existem editores de \LaTeX{} que combinam os passos 1 e 2 no mesmo
 sistema de software. Assim, você pode ver o passo 1, mas não o passo 2 por
 completo. Passo 2 estará acontecendo escondido\footnote{Por exemplo, quando usar
 referências (como Equação~\ref{eq:pythagoras}), pode ser necessário executar o
@@ -267,6 +282,27 @@ Existem dois tipos principais de links: URL visíveis \\
 Esse pacote também produz uma lista de thumbnails no documento pdf gerado e
 ativa os links na tabela de conteúdo.
 
+\section{Escrevendo em ASCII ou outras codificações}
+
+Por padrão, historicamente LaTeX aceita entradas que são puro ASCII (128),
+mas não ASCII extendido, o que significa sem acentos (à, è etc.) e símbolos não latinos.
+
+É fácil inserir acentos e símbolos latinos básicos através de atalhos de barra invertida
+como \,c, \'e, \`A, \ae e \oe etc.  % Para ç, é, À, etc
+% Veja https://en.wikibooks.org/wiki/LaTeX/Special_Characters#Escaped_codes para mais detalhes
+
+Para escrever diretamente em UTF-8 quando compilando com pdflatex, use
+\begin{verbatim}
+    \usepackage[utf8]{inputenc}
+\end{verbatim}
+A fonte selecionada precisa suportar os glifos usados em seu documento. Você precisa adicionar
+\begin{verbatim}
+    \usepackage[T1]{fontenc}
+\end{verbatim}
+
+Desde LuaTeX e XeLaTeX, suporte para UTF-8 vem embutido por padrão, tornando a vida muito
+mais fácil para escrever em alfabetos não latinos.
+
 \section{End}
 
 Por enquanto é isso!
@@ -276,7 +312,7 @@ Por enquanto é isso!
 \begin{thebibliography}{1}
   % como em outras listas, o comando \bibitem pode ser usado para itens da lista
   % cada entrada pode ser citada diretamente no corpo do texto
-  \bibitem{latexwiki} The amazing \LaTeX \hspace{1pt} wikibook: {\em 
+  \bibitem{latexwiki} The amazing \LaTeX{} wikibook: {\em 
 https://en.wikibooks.org/wiki/LaTeX}
   \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
 \end{thebibliography}
@@ -289,3 +325,6 @@ https://en.wikibooks.org/wiki/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/)
+* A quick guide for learning LaTeX: [Learn LaTeX in 30 minutes](https://www.overleaf.com/learn/latex/Learn_LaTeX_in_30_minutes)
+* An interactive platform to learn LaTeX (installationfree) [learnlatex.org/](https://www.learnlatex.org/)
+* Stack Exchange's question and answer site about TeX, LaTeX, ConTeXt, etc. [tex.stackexchange.com](https://tex.stackexchange.com/)
diff --git a/pt-br/lua-pt.html.markdown b/pt-br/lua-pt.html.markdown
index 0c75da26..4aaf3a1e 100644
--- a/pt-br/lua-pt.html.markdown
+++ b/pt-br/lua-pt.html.markdown
@@ -2,7 +2,7 @@
 language: Lua
 contributors:
     - ["Tyler Neylon", "http://tylerneylon.com/"]
-filename: learnlua.lua
+filename: learnlua-pt.lua
 translators:
     - ["Iaan Mesquita", "https://github.com/ianitow"]
 lang: pt-br
diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
index cbdebde7..d908435a 100644
--- a/pt-br/make-pt.html.markdown
+++ b/pt-br/make-pt.html.markdown
@@ -1,243 +1,245 @@
----

-category: tool

-tool: make

-contributors:

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

-    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

-filename: Makefile

-

-lang: pt-br

----

-

-Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.

-

-Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.

-

-```make

-

-# Comentários podem ser escritos assim.

-

-# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.

-# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.

-

-# Aviso - use somente TABS para identar em Makefiles, nunca espaços!

-

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

-# Noções básicas

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

-

-# Regras são do formato

-# alvo: <pré-requisito>

-# onde os pré-requisitos são opcionais.

-

-# Uma regra - esta regra só será executada se o arquivo0.txt não existir.

-arquivo0.txt:

-	echo "foo" > arquivo0.txt

-	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.

-	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.

-

-# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.

-arquivo1.txt: arquivo0.txt

-	cat arquivo0.txt > arquivo1.txt

-	# se as mesmas regras de citação do shell.

-	@cat arquivo0.txt >> arquivo1.txt

-	# @ pára o comando de ser ecoado para stdout.

-	-@echo 'hello'

-	# - significa que make continuará em caso de erro.

-	# Experimentar `make arquivo1.txt` na linha de comando.

-

-# Uma regra pode ter vários alvos e vários pré-requisitos

-arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt

-	touch arquivo2.txt

-	touch arquivo3.txt

-

-# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar

-# receitas não contam e podem ser usadas para adicionar novas dependências.

-

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

-# Alvos falsos

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

-

-# Um alvo falso. Qualquer alvo que não seja um arquivo.

-# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.

-all: maker process

-

-# Podemos declarar as coisas fora de ordem.

-maker:

-	touch ex0.txt ex1.txt

-

-# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome

-.PHONY: all maker process

-# Este é um alvo especial. Existem vários outros.

-

-# Uma regra com dependência de um alvo falso sempre será executada

-ex0.txt ex1.txt: maker

-

-# Alvos falsos comuns são: todos fazem instalação limpa ...

-

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

-# Variáveis ​​Automáticas e Curingas

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

-

-process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos

-	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos

-	@echo $@	# imprime o nome do alvo

-	#(fpara várias regras alvo, $@ é o que causou a execução da regra)

-	@echo $<	# o primeiro pré-requisito listado

-	@echo $?	# somente as dependências que estão desatualizadas

-	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)

-	#@echo $|	# todos os pré-requisitos 'somente pedidos'

-

-# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los

-process: ex1.txt arquivo0.txt

-# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.

-

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

-# Padrões

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

-

-# Pode ensinar make a converter certos arquivos em outros arquivos.

-

-%.png: %.svg

-	inkscape --export-png $^

-

-# As regras padrões só farão qualquer coisa se decidirem criar o alvo.

-

-# Os caminhos de diretório são normalmente ignorados quando as regras de

-# padrões são correspondentes. Mas make tentará usar a regra mais

-# apropriada disponível.

-small/%.png: %.svg

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

-

-# make utilizará a última versão para uma regra de padrão que encontrar.

-%.png: %.svg

-	@echo esta regra é escolhida

-

-# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo

-%.png: %.ps

-	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes

-

-# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe

-# como transformar arquivos *.c em arquivos *.o.

-

-# Makefiles antigos podem usar regras de sufixo em vez de regras padrões

-.png.ps:

-	@echo essa regra é semelhante a uma regra de padrão.

-

-# make sobre a regra de sufixo

-.SUFFIXES: .png

-

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

-# Variáveis

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

-# aka. macros

-

-# As variáveis ​​são basicamente todos os tipos de string

-

-name = Ted

-name2="Sarah"

-

-echo:

-	@echo $(name)

-	@echo ${name2}

-	@echo $name    # Isso não funcionará, tratado como $ (n)ame.

-	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.

-

-# Existem 4 lugares para definir variáveis.

-# Em ordem de prioridade, do maior para o menor:

-# 1: argumentos de linha de comando

-# 2: Makefile

-# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.

-# 4: make tem algumas variáveis ​​predefinidas

-

-name4 ?= Jean

-# Somente defina a variável se a variável de ambiente ainda não estiver definida.

-

-override name5 = David

-# Pára os argumentos da linha de comando de alterar essa variável.

-

-name4 +=grey

-# Anexar valores à variável (inclui um espaço).

-

-# Valores variáveis ​​específicos de padrões (extensão GNU).

-echo: name2 = Sara # Verdadeiro dentro da regra de correspondência

-	# e também dentro de suas recursivas dependências

-	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)

-

-# Algumas variáveis ​​definidas automaticamente pelo make

-echo_inbuilt:

-	echo $(CC)

-	echo ${CXX}

-	echo $(FC)

-	echo ${CFLAGS}

-	echo $(CPPFLAGS)

-	echo ${CXXFLAGS}

-	echo $(LDFLAGS)

-	echo ${LDLIBS}

-

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

-# Variáveis 2

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

-

-# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.

-# TIsso pode ser caro, então existe um segundo tipo de variável que é

-# avaliado apenas uma vez. (Esta é uma extensão do GNU make)

-

-var := hello

-var2 ::=  $(var) hello

-#:= e ::= são equivalentes.

-

-# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que

-# aparecem), quebrando assim o resto da línguagem!

-

-# Isso não funciona

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

-var4 ::= good night

-

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

-# Funções

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

-

-# make tem muitas funções disponíveis.

-

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

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

-

-# O formato é $(func arg0,arg1,arg2...)

-

-# Alguns exemplos

-ls:	* src/*

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

-	@echo $(notdir $^)

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

-

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

-# Diretivas

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

-

-# Inclua outros makefiles, úteis para código específico da plataforma

-include foo.mk

-

-sport = tennis

-# Compilação condicional

-report:

-ifeq ($(sport),tennis)

-	@echo 'game, set, match'

-else

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

-endif

-

-# Há também ifneq, ifdef, ifndef

-

-foo = true

-

-ifdef $(foo)

-bar = 'hello'

-endif

-```

-

-### More Resources

-

-+ [documentação gnu make](https://www.gnu.org/software/make/manual/)

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

-+ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)

+---
+category: tool
+tool: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+translators:
+    - ["Rogério Gomes Rio", "https://github.com/rogerlista"]
+filename: Makefile-pt
+
+lang: pt-br
+---
+
+Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.
+
+Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.
+
+```make
+
+# Comentários podem ser escritos assim.
+
+# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.
+# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.
+
+# Aviso - use somente TABS para identar em Makefiles, nunca espaços!
+
+#-----------------------------------------------------------------------
+# Noções básicas
+#-----------------------------------------------------------------------
+
+# Regras são do formato
+# alvo: <pré-requisito>
+# onde os pré-requisitos são opcionais.
+
+# Uma regra - esta regra só será executada se o arquivo0.txt não existir.
+arquivo0.txt:
+	echo "foo" > arquivo0.txt
+	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.
+	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
+
+# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
+arquivo1.txt: arquivo0.txt
+	cat arquivo0.txt > arquivo1.txt
+	# se as mesmas regras de citação do shell.
+	@cat arquivo0.txt >> arquivo1.txt
+	# @ pára o comando de ser ecoado para stdout.
+	-@echo 'hello'
+	# - significa que make continuará em caso de erro.
+	# Experimentar `make arquivo1.txt` na linha de comando.
+
+# Uma regra pode ter vários alvos e vários pré-requisitos
+arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt
+	touch arquivo2.txt
+	touch arquivo3.txt
+
+# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar
+# receitas não contam e podem ser usadas para adicionar novas dependências.
+
+#-----------------------------------------------------------------------
+# Alvos falsos
+#-----------------------------------------------------------------------
+
+# Um alvo falso. Qualquer alvo que não seja um arquivo.
+# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.
+all: maker process
+
+# Podemos declarar as coisas fora de ordem.
+maker:
+	touch ex0.txt ex1.txt
+
+# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome
+.PHONY: all maker process
+# Este é um alvo especial. Existem vários outros.
+
+# Uma regra com dependência de um alvo falso sempre será executada
+ex0.txt ex1.txt: maker
+
+# Alvos falsos comuns são: todos fazem instalação limpa ...
+
+#-----------------------------------------------------------------------
+# Variáveis ​​Automáticas e Curingas
+#-----------------------------------------------------------------------
+
+process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos
+	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos
+	@echo $@	# imprime o nome do alvo
+	#(fpara várias regras alvo, $@ é o que causou a execução da regra)
+	@echo $<	# o primeiro pré-requisito listado
+	@echo $?	# somente as dependências que estão desatualizadas
+	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)
+	#@echo $|	# todos os pré-requisitos 'somente pedidos'
+
+# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los
+process: ex1.txt arquivo0.txt
+# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.
+
+#-----------------------------------------------------------------------
+# Padrões
+#-----------------------------------------------------------------------
+
+# Pode ensinar make a converter certos arquivos em outros arquivos.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# As regras padrões só farão qualquer coisa se decidirem criar o alvo.
+
+# Os caminhos de diretório são normalmente ignorados quando as regras de
+# padrões são correspondentes. Mas make tentará usar a regra mais
+# apropriada disponível.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# make utilizará a última versão para uma regra de padrão que encontrar.
+%.png: %.svg
+	@echo esta regra é escolhida
+
+# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo
+%.png: %.ps
+	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes
+
+# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe
+# como transformar arquivos *.c em arquivos *.o.
+
+# Makefiles antigos podem usar regras de sufixo em vez de regras padrões
+.png.ps:
+	@echo essa regra é semelhante a uma regra de padrão.
+
+# make sobre a regra de sufixo
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variáveis
+#-----------------------------------------------------------------------
+# aka. macros
+
+# As variáveis ​​são basicamente todos os tipos de string
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # Isso não funcionará, tratado como $ (n)ame.
+	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.
+
+# Existem 4 lugares para definir variáveis.
+# Em ordem de prioridade, do maior para o menor:
+# 1: argumentos de linha de comando
+# 2: Makefile
+# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.
+# 4: make tem algumas variáveis ​​predefinidas
+
+name4 ?= Jean
+# Somente defina a variável se a variável de ambiente ainda não estiver definida.
+
+override name5 = David
+# Pára os argumentos da linha de comando de alterar essa variável.
+
+name4 +=grey
+# Anexar valores à variável (inclui um espaço).
+
+# Valores variáveis ​​específicos de padrões (extensão GNU).
+echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
+	# e também dentro de suas recursivas dependências
+	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
+
+# Algumas variáveis ​​definidas automaticamente pelo make
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX}
+	echo $(FC)
+	echo ${CFLAGS}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variáveis 2
+#-----------------------------------------------------------------------
+
+# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.
+# TIsso pode ser caro, então existe um segundo tipo de variável que é
+# avaliado apenas uma vez. (Esta é uma extensão do GNU make)
+
+var := hello
+var2 ::=  $(var) hello
+#:= e ::= são equivalentes.
+
+# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que
+# aparecem), quebrando assim o resto da línguagem!
+
+# Isso não funciona
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funções
+#-----------------------------------------------------------------------
+
+# make tem muitas funções disponíveis.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# O formato é $(func arg0,arg1,arg2...)
+
+# Alguns exemplos
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Diretivas
+#-----------------------------------------------------------------------
+
+# Inclua outros makefiles, úteis para código específico da plataforma
+include foo.mk
+
+sport = tennis
+# Compilação condicional
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# Há também ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+### More Resources
+
++ [documentação gnu make](https://www.gnu.org/software/make/manual/)
++ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)
++ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index dc50cac1..fca864bb 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -6,36 +6,56 @@ translators:
     - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
     - ["Gabriele Luz", "https://github.com/gabrieleluz"]
     - ["Monique Baptista", "https://github.com/bfmonique"]
+    - ["Marcel Ribeiro-Dantas", "https://github.com/mribeirodantas"]
 
-lang: pt-br    
+lang: pt-br
 filename: learnmarkdown-pt.md
 ---
 
-Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e 
-escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também).
-
-Dê-me feedback tanto quanto você quiser! / Sinta-se livre para fazer uma bifurcação (fork) e 
-puxar o projeto (pull request)
+O Markdown foi lançado por John Gruber em 2004. Criado para ser uma sintaxe
+fácil de ler e escrever e que é facilmente convertida em HTML (hoje, suporta
+outros formatos também).
+
+O Markdown varia em termos de implementação de um parser para outro. Esse guia
+irá tentar deixar explícito quando os recursos são universais ou quando são
+específicos para um parser em específico.
+
+- [Elementos HTML](#elementos-html)
+- [Cabeçalhos](#cabeçalhos)
+- [Estilos de texto simples](#estilos-de-texto-simples)
+- [Parágrafos](#parágrafos)
+- [Listas](#listas)
+- [Blocos de código](#blocos-de-código)
+- [Linha Horizontal](#linha-horizontal)
+- [Links](#links)
+  - [Tabela de conteúdo](#tabela-de-conteúdo)
+- [Imagens](#imagens)
+- [Miscelânea](#miscelânea)
+  - [Auto-links](#auto-links)
+  - [Auto-links para e-mails](#auto-links-com-e-mails)
+  - [Escapando caracteres](#escapando-caracteres)
+  - [Teclas do teclado](#teclas-do-teclado)
+  - [Tabelas](#tabelas)
+- [Markdownlint](#markdownlint)
+- [Leitura complementar](#leitura-complementar)
 
 ## Elementos HTML
-Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
+O Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
 um arquivo Markdown válido.
-```md
-<!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é 
-um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML 
-em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
-de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
-não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.-->
-
-<!--A maneira como o Markdown é analisado varia de software para software.
-Este guia vai tentar esclarecer quando as características são universais, ou quando eles são específicos para um determinado interpretador -->
 
+```md
+<!--Isso significa que nós podemos usar elementos HTML em Markdown, como o
+elemento de comentário, e eles não serão afetados pelo analisador de
+remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown,
+você não pode usar sintaxe de remarcação dentro do conteúdo desse elemento.-->
+```
 
 ## Cabeçalhos
 
 Você pode criar elementos HTML `<h1>` até `<h6>` facilmente antecedendo o texto
-que deseja estar nesse elemento por um número de hashes (#)
+que deseja estar nesse elemento por um número de cerquilhas (#).
 
+```md
 # Isto é um cabeçalho <h1>
 ## Isto é um cabeçalho <h2>
 ### Isto é um cabeçalho <h3>
@@ -44,7 +64,7 @@ que deseja estar nesse elemento por um número de hashes (#)
 ###### Isto é um cabeçalho <h6>
 ```
 
-Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2
+Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2.
 
 ```md
 Isto é um cabeçalho h1
@@ -55,21 +75,22 @@ Isto é um cabeçalho h2
 ```
 
 ## Estilos de texto simples
-O texto pode ser facilmente denominado como marcação itálico, negrito ou tachado usando:
+
+O texto pode ser facilmente estilizado como itálico ou negrito usando Markdown.
 
 ```md
 *Este texto está em itálico*
 _E este também está._
 
 **Este texto está em negrito**
-__E este também está._
+__E este também está.__
 
 ***Este texto está em negrito e itálico.***
 **_E este também está_**
-*--Danouse! Este também__*
+*__Danou-se! Este também__*
 ```
 
-Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown 
+No GitHub Flavored Markdown, que é usado para processar arquivos Markdown
 GitHub, nós também temos:
 
 ```md
@@ -77,43 +98,46 @@ GitHub, nós também temos:
 ```
 
 ## Parágrafos
-Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por 
+Os parágrafos estão em uma ou várias linhas adjacentes de texto separadas por 
 uma ou múltiplas linhas em branco.
 
 ```md
 Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
 
 Agora, eu estou no parágrafo 2.
-... Ainda continuo no parágrafo 2! :)
+Ainda continuo no parágrafo 2!
+
 
-Eu estou no parágrafo três.
+Eu estou no parágrafo três!
 ```
 
 Se você quiser inserir uma tag HTML `<br />`, você pode acabar com um parágrafo 
-com dois ou mais espaços e, em seguida, começar um novo parágrafo
+com dois ou mais espaços e, em seguida, começar um novo parágrafo.
 
 ```md
-Termino com dois espaços (destacar-me para vê-los). 
+Termino com dois espaços (selecione essa linha para vê-los). 
 
 Há um <br /> acima de mim!
 ```
 
-
-Bloco de citações são fáceis e feito com o caractere >.
+Blocos de citações são fáceis e feitos com o caractere >.
 
 ```md
 > Este é um bloco de citação. Você pode 
-> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode
-> deixar suas linhas ficarem muito longas e quebrarem por conta própria. Não faz diferença, 
-> desde que eles começam com um `>`.
-	
+> Quebrar manualmente suas linhas e colocar um `>` antes de cada linha ou você
+> pode deixar suas linhas ficarem muito longas e quebrarem por conta própria.
+> Não faz diferença, desde que elas comecem com um `>`.
 
 > Você também pode usar mais de um nível 
 >> De recuo?
+> O quão legal é isso?
+
 ```
 
 ## Listas
-As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens
+
+As listas não ordenadas podem ser feitas usando asteriscos, sinais de positivo
+ou hífens.
 
 ```md
 * Item
@@ -141,18 +165,18 @@ Listas ordenadas são feitas com um número seguido por um ponto.
 3. Item três
 ```
 
-<!-- Você não tem poder para rotular os itens corretamente e a remarcação ainda deixará os 
-itens em ordem, mas isso pode não ser uma boa idéia -->
-
+Você não precisa sequer rotular os itens corretamente e o Markdown ainda
+assim deixará os itens em ordem, mas isso pode não ser uma boa idéia.
 
 ```md
 1. Item um
 1. Item dois
 1. Item três
 ```
+
 (Isto é processado da mesma forma que o exemplo acima)
 
-Você também pode usar sublistas
+Você também pode usar sublistas.
 
 ```md
 1. Item um
@@ -163,63 +187,59 @@ Você também pode usar sublistas
 4. Item quatro
 ```
 
-Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) de HTML
+Existem também listas de tarefas. Isso cria checkboxes (caixas de seleção) do 
+HTML.
 
 ```md
-As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas
-- [ ] Primeira tarefa a completar
+As caixas abaixo sem o 'x' são checkboxes HTML desmarcadas.
+- [ ] Primeira tarefa a completar.
 - [ ] Segunda tarefa a completar
-A caixa de seleção abaixo será exibida como uma checkbox HTML marcada
+A caixa de seleção abaixo será exibida como uma checkbox HTML marcada.
 - [x] Essa tarefa foi completa
-
 ```
 
-
 ## Blocos de código
-Você pode indicar um bloco de código (que utiliza o elemento `<code>`) pelo recuo
-uma linha com quatro espaços ou uma guia
-```md
-	Isto é código
-	É assim, sacou?
-	
-```
 
-Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo 
-dentro do seu código
+Você pode indicar um bloco de código (que utiliza o elemento `<code>`) através
+de indentação com quatro espaços ou uma tabulação.
 
 ```md
-	my_array.each do |item|
-        puts item
-    end	
- ```
+    Isto é código
+    É assim, sacou?
+```
 
-Código embutido pode ser criada usando o caractere de crase `` ` ``
+Você pode também adicionar mais tabulações (ou adicionar mais quatro espaços
+adicionais) para indentação no seu código.
 
 ```md
-John não sabia nem o que o função `goto()` fazia!
+    my_array.each do |item|
+      puts item
+    end
 ```
 
-Em GitHub Flavored Markdown, você pode usar uma sintaxe especial para o código
+Código embutido pode ser criado usando o caractere de crase `` ` ``.
+
 ```md
-	``` ruby
-	def foobar
-    	puts "Hello world!"
-	end
-	```
+John não sabia nem o que a função `go_to()` fazia!
 ```
-=======
-\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ```
-ruby! --> 
+
+No GitHub Flavored Markdown, você pode usar uma sintaxe especial para código.
+
+````md
+```ruby
 def foobar
-    puts "Hello world!"
+  puts "Olá mundo!"
 end
-\`\`\` <!-- Aqui também, não use barras invertidas, apenas ``` -->
+```
+````
 
-O texto acima não requer recuo, além disso o GitHub vai usar a sintaxe highlight da linguagem que você especificar após a \`\`\`.
+O texto acima não requer indentação, além disso o GitHub vai usar o destaque
+de sintaxe da linguagem qeu você especificar após a tag <code>```</code>.
 
 ## Linha Horizontal
-Linhas horizontais são facilmente adicionados com três ou mais asteriscos ou hífens,
-com ou sem espaços.
+
+Linhas horizontais são facilmente adicionadas com três ou mais asteriscos ou
+hífens, com ou sem espaços.
 
 ```md
 ***
@@ -229,17 +249,19 @@ com ou sem espaços.
 ```
 
 ## Links
-Uma das melhores coisas sobre a marcação é o quão fácil é fazer ligações. Colocar 
-o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses ()
+
+Uma das melhores coisas sobre o Mardkwon é o quão fácil é criar links.
+Coloque o texto a ser exibido entre colchetes [] seguido pela url entre
+parênteses ()
 
 ```md
-[Click aqui!](http://test.com/)
+[Clique aqui!](http://test.com/)
 ```
 
-Você também pode adicionar um título link usando aspas dentro dos parênteses
+Você também pode adicionar um título ao link usando aspas dentro dos parênteses.
 
 ```md
-[Click aqui!](http://test.com/ "Link para Test.com")
+[Cliqueaqui!](http://test.com/ "Link para Test.com")
 ```
 
 Caminhos relativos funcionam também.
@@ -248,46 +270,69 @@ Caminhos relativos funcionam também.
 [Ir para música](/música/).
 ```
 
-Markdown também suporta ligações de estilo de referência
+O Markdown também suporta links para referências no texto.
 
 ```md
-[Clique neste link] [link1] para mais informações sobre isso!
-[Além disso, verifique este link] [foobar] se você quiser.
+[Clique nesse link][link1] para mais informações!
+[Também cheque esse link][foobar] se você quiser.
 
 [link1]: http://test.com/ "Legal!"
-[foobar]: http://foobar.biz/ "OK!"
+[link2r]: http://foobar.biz/ "Certo!"
 ```
 
 O título também pode estar entre aspas simples ou entre parênteses, ou omitido 
-inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência 
-pode ser qualquer um, desde que eles são únicos.
+inteiramente. As referências podem estar em qualquer lugar no documento e os
+IDs de referência podem ser qualquer um, desde que eles sejam únicos.
 
-Existe também a "nomeação implicita", que permite que você use o texto do link como o id
+Existe também a "nomeação implícita", que permite que você use o texto do link
+como o id:
 
 ```md
-[Este] [] é um link. 
+[Isso][] é um link.
 
-[este]: http://thisisalink.com/ 
+[Isso]: http://thisisalink.com/
 ```
 
-Mas não são usados normalmente
+Mas geralmente não são usados.
+
+### Tabela de conteúdo
+
+Alguns sabores de Markdown fazem inclusive uso de combinação de listas, links e
+cabeçalhos de modo a criar uma tabela de conteúdo. Nesse caso, títulos em
+cabeçalhos são precedidos de (`#`) e são usados como ids para links. Se o
+cabeçalho consistir de várias palavras, elas serão conectadas por hífens (`-`),
+que também substitui alguns caracteres especiais. (Embora alguns outros
+carácteres especiais sejam omitidos.)
+
+```md
+- [Cabeçalho](#cabecalho)
+- [Um outro cabeçalho](#outro-cabecalho)
+- [Capítulo](#capitulo)
+  - [Subcapítulo <h3 />](#subcapitulo-h3-)
+```
+
+De qualquer modo, esse é um recurso que talvez não funcione em todas as
+implementações do Markdown da mesma forma.
 
 ## Imagens
-As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente!
+
+As imagens são feitas da mesma forma que os links, mas com um ponto de
+exclamação na frente!
 
 ```md
-![Este é pairar-texto (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional") 
+![Este é alt-text (texto alternativo) para minha imagem](http://imgur.com/myimage.jpg "Um título opcional") 
 ```
 
 E estilo de referência funciona como esperado
 
 ```md
-![Este é o pairar-texto.][Myimage] 
+![Esse é o alt-attribute.][myimage]
 
-[myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" 
+[Minha imagem]: relative/urls/cool/image.jpg "se precisar de um título, está aqui"
 ```
 
 ## Miscelânea 
+
 ### Auto-links 
 
 ```md
@@ -303,14 +348,25 @@ E estilo de referência funciona como esperado
 
 ### Escapando caracteres
 
-Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja 
+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 \*.
 
+### Teclas do teclado
+
+No GitHub Flavored Markdown, você pode usar a tag `<kbd>` para representar uma
+tecla do teclado.
+
+```md
+Seu computador travou? Tente apertar
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+
 ### Tabelas 
+
 Tabelas estão disponíveis apenas no GitHub Flavored Markdown e são ligeiramente 
 complicadas, mas se você realmente quer:
-```md
 
+```md
 | Col1         | Col2     | Col3          |
 | :----------- | :------: | ------------: |
 | esquerda-alin| Centrado | direita-alinh |
@@ -325,8 +381,22 @@ Col 1 | Col2 | Col3
 Ugh isso é tão feio | faça isto | parar
 ```
 
-Fim!
+## Markdownlint
+
+De modo a simplificar o trabalho com Markdown e padronizar estilo de código, o
+`Markdownlint` foi criado. Essa ferramenta está disponível como plugin para
+algumas interfaces de desenvolvimento (IDEs) e pode ser utilizada como um
+utilitário para garantir validade e legibilidade do Markdown.
 
 ---
-Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
-e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+
+## Leitura complementar
+
+Para mais informações, confira o post oficial de John Gruber sobre sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax)
+e o do cheatsheet do Adam Pritchard [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+
+Se você quiser aprender mais sobre recursos de alguns sabores específicos de
+Markdown, veja:
+
+- [GitHub flavored Markdown](https://docs.github.com/en/github/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax)
+- [GitLab flavored Markdown](https://docs.gitlab.com/ee/user/markdown.html)
diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index fae17bca..947e0699 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Matlab
+language: MATLAB
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
     - ["jamesscottbrown", "http://jamesscottbrown.com"]
@@ -120,7 +120,7 @@ A.d.e = false;
 
 % Vetores
 x = [4 32 53 7 1]
-x(2) % Resposta = 32, índices no Matlab começam por 1, não 0
+x(2) % Resposta = 32, índices no MATLAB começam por 1, não 0
 x(2:3) % Resposta = 32 53
 x(2:end) % Resposta = 32 53 7 1
 
@@ -479,7 +479,7 @@ perms(x) % Lista todas as permutações de elementos de x
 
 
 % Classes
-% Matlab pode suportar programação orientada a objetos.
+% MATLAB pode suportar programação orientada a objetos.
 % Classes devem ser colocadas em um arquivo de mesmo nome com a extensão *.m
 % Para começar, criamos uma simples classe que armazena posições de GPS
 % Início ClassePosicoesGPS.m
@@ -501,7 +501,7 @@ classdef ClassePosicoesGPS % O nome da classe.
     end
 
     % Se quisermos somar dois objetos de PosicoesGPS juntos sem chamar
-    % uma função especial nós podemos sobrepor a aritmética do Matlab, desta maneira:
+    % uma função especial nós podemos sobrepor a aritmética do MATLAB, desta maneira:
     function r = plus(o1,o2)
       r = ClassePosicoesGPS([o1.latitude] +[o2.latitude], ...
                         [o1.longitude]+[o2.longitude]);
@@ -513,7 +513,7 @@ end
 % Podemos criar um objeto da classe usando o construtor
 a = ClassePosicoesGPS(45.0, 45.0)
 
-% Propriedades da classe se comportam exatamente como estruturas Matlab
+% Propriedades da classe se comportam exatamente como estruturas MATLAB
 a.latitude = 70.0
 a.longitude = 25.0
 
@@ -524,15 +524,15 @@ ans = multiplicarLatPor(a,3)
 % o objeto não precisa ser passado para o método.
 ans = a.multiplicarLatPor(a,1/3)
 
-% Funções do Matlab podem ser sobrepostas para lidar com objetos.
-% No método abaixo, nós sobrepomos a forma como o Matlab lida com a soma de
+% Funções do MATLAB podem ser sobrepostas para lidar com objetos.
+% No método abaixo, nós sobrepomos a forma como o MATLAB lida com a soma de
 % dois objetos PosicoesGPS.
 b = ClassePosicoesGPS(15.0, 32.0)
 c = a + b
 
 ```
 
-## Mais sobre Matlab
+## Mais sobre MATLAB
 
 * O site oficial [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
 * O fórum oficial de respostas: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index e55f1100..7db6a671 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: php-pt.html.markdown
+filename: learnphp-pt.php
 ---
 
 Este documento descreve PHP 5+.
diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
new file mode 100644
index 00000000..5ed2950a
--- /dev/null
+++ b/pt-br/processing-pt.html.markdown
@@ -0,0 +1,480 @@
+---
+language: processing
+filename: learnprocessing.pde
+contributors:
+    - ["Phone Thant Ko", "http://github.com/phonethantko"]
+    - ["Divay Prakash", "https://github.com/divayprakash"]
+translators:
+    - ["Kemel Zaidan", "https://github.com/kemelzaidan"]
+lang: pt-br
+---
+
+## Introdução
+
+Processing é uma linguagem de programação para criação de artes digitais e
+conteúdo multimídia, permitindo que não programadores aprendam os fundamentos 
+da programação computacional em um contexto visual.
+
+Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente
+influenciado por ambas as sintaxes Java e Javascript.
+[Veja mais aqui](https://processing.org/reference/)
+
+A linguagem é tipada estaticamente e também vem com o seu Ambiente de Desenvolvimento
+Integrado (do inglês Integrated Development Environment - IDE) oficial para
+compilar e executar os scripts.
+
+```
+/* ---------
+   Comentários
+   ---------
+*/
+
+// Comentário de linha única começa com //
+
+/*
+   Como o Processing é baseado em Java,
+   a sintaxe para seus comentários é a mesma do Java (como você deve ter notado 
+   acima)!
+   Comentários de várias linhas são agrupados como visto aqui.
+*/
+
+/* ---------------------------------------
+   Escrevendo e executando programas em Processing
+   ---------------------------------------
+*/
+
+// No Processing, o ponto de entrada do programa é uma função chamada setup() 
+// com um tipo de retorno void.
+// Observação! A sintaxe é muito semelhante à do C++.
+void setup() {
+  // Isso imprime a saída clássica "Hello World!" no console quando executado.
+  println("Olá Mundo!"); // Mais uma linguagem com esse maldito ponto e vírgula, não é?
+}
+
+// Normalmente, colocamos todos os códigos estáticos dentro do método setup() 
+// como o próprio nome sugere, uma vez que é executado apenas uma vez.
+// Pode variar da definição das cores de fundo, ou o tamanho da tela.
+background(color); //define a cor do fundo
+size(largura,altura,[renderizador]); // define o tamanho da tela com parâmetro
+// opcional para definir o renderizador
+// Você verá mais sobre isso ao longo deste documento.
+
+// Se você deseja executar os códigos indefinidamente, eles devem ser colocados 
+// dentro do método draw()
+// draw() deve existir caso você queira que o código seja executado 
+// continuamente e, obviamente, só pode haver um método draw().
+int = 0;
+void draw(){
+  // Este bloco de código faz um loop para sempre até parar
+  imprima(i);
+  i++; // Operador de incremento!
+}
+
+// Agora que sabemos como escrever o script de trabalho e como executá-lo,
+// continuaremos a explorar quais tipos de dados e coleções são suportados no
+// Processing.
+
+/* ------------------------
+   Tipos de dados e coleções
+   ------------------------
+*/
+
+// De acordo com as Referências do Processing, ele suporta 8 tipos primitivos
+// de dados da seguinte forma.
+
+boolean valorBoleano = true; // Boleano
+byte valorByteDeA = 23; // Byte
+char valorCharDeA = 'A'; // Caractere
+color valorDeCorBrancoM = color(255, 255, 255); // Cor (especificada usando
+// método color())
+color valorDeCorBrancoH = #FFFFFF; // Cor (especificada usando valor de hash)
+int valor = 5; // Inteiro (Número sem decimais)
+long valorLongo = 2147483648L; // "L" é adicionado ao número para marcá-lo como um longo
+float valorFloat = 1,12345; // Float (números de ponto flutuante de 32 bits)
+double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits)
+
+// NOTA!
+// Embora os tipos de dados "long" e "double" funcionem na linguagem,
+// funções do Processing não usam esses tipos de dados, portanto
+// eles precisam ser convertidos em tipos de dados "int" e "float", 
+// respectivamente, usando a sintaxe (int) e (float) antes de passar para uma 
+// função.
+
+// Existem vários tipos de dados compostos que estão disponíveis por padrão para 
+// uso no Processing.
+// Primeiramente, farei um resumo dos mais usados ​​para economizar tempo.
+
+// String
+// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas 
+// duplas.
+string stringExemplo = "Olá, Processing!";
+// String também pode ser criada a partir de um array de tipos de dados char.
+// Nós vamos discutir array muito em breve.
+char fonte = {'H', 'E', 'L', 'L', 'O'};
+String stringDeFonte = new String(source); // HELLO
+// Como em Java, strings podem ser concatenadas usando o operador "+".
+print("Olá " + "Mundo!"); // Olá Mundo!
+
+// Array
+// Arrays em Processing podem conter quaisquer tipos de dados, incluindo os 
+// próprios objetos. Como os arrays são semelhantes aos objetos, eles devem 
+// ser criados com a palavra-chave "new".
+int[] arrayInt = new int[5];
+int[] arrayIntComValores ​​= {1, 2, 3}; // Você também pode preencher com dados.
+
+// Lista de Arrays
+// As funções são semelhantes às do array; arraylists podem conter qualquer 
+// tipo de dados. A única diferença é que as listas de matrizes são 
+// redimensionadas dinamicamente, pois é uma forma de implementação de matriz 
+// redimensionável da interface "List" do Java .
+ArrayList<Integer> intArrayList = new ArrayList<Integer>();
+
+// Objeto
+// Como é baseado em Java, o Processing suporta programação orientada a objetos.
+// Isso significa que você pode basicamente definir quaisquer tipos de dados de 
+// sua preferência e manipulá-los para suas necessidades.
+// Claro, uma classe tem que ser definida antes para o objeto que você quer.
+// Formato --> NomeClasse NameInstancia
+UmaClasseQualquer meuObjeto // então instancia mais tarde
+//ou
+UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
+
+// O Processing surge com mais coleções (ex. - Dicionários e Listas) por
+// padrão, por uma questão de simplicidade, vou deixá-los fora da discussão aqui.
+
+/* ------------
+   Matemática
+   ------------
+*/
+
+// Aritmética
+1 + 1 // 2
+2 - 1 // 1
+2 * 3 // 6
+3/2 // 1
+3.0 / 2 // 1.5
+3.0% 2 // 1.0
+
+// O Processing também vem com um conjunto de funções que simplificam operações 
+// matemáticas.
+float f = sq(3); // f = 9.0
+float p = pow(3, 3); // p = 27.0
+int a = abs(-13); // a = 13
+int r1 = round(3.1); // r1 = 3
+int r2 = round(3.7); // r2 = 4
+float sr = sqrt(25); // sr = 5.0
+
+// Vetores
+// O Processing fornece uma maneira fácil de implementar vetores em seu ambiente
+// usando a classe PVector. Ela pode descrever um vetor bi ou tridimensional e
+// vem com um conjunto de métodos que são úteis para operações com matrizes.
+// Você pode encontrar mais informações sobre a classe PVector e suas funções 
+// aqui. (https://processing.org/reference/PVector.html)
+
+// Trigonometria
+// O Processing também suporta operações trigonométricas fornecendo um 
+// conjunto de funções. sin(), cos(), tan(), asin(), acos(), atan() e também 
+// degrees() e radians() para conversão conveniente.
+// No entanto, essas funções usam o ângulo em radianos como parâmetro, então é 
+// necessário converter previamente.
+float um = sin(PI/2); // um = 1.0
+// Como você deve ter notado, existe um conjunto de constantes para usos 
+// trigonométricos; PI, HALF_PI, QUARTER_PI e assim por diante...
+
+/* -------------
+   Controle de fluxo
+   -------------
+*/
+
+// Declarações Condicionais
+// Instruções If - A mesma sintaxe das instruções if em Java.
+if (author.getAppearance().equals("quente")) {
+  print("Narcisismo no máximo!");
+} else {
+  // Você pode verificar outras condições aqui.
+  print("Algo está realmente errado aqui!");
+}
+// Um ​​atalho para instruções if-else também pode ser usado.
+int = 3;
+String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
+
+// A estrutura switch-case pode ser usada para verificar várias condições de 
+// forma concisa. É importante usar a instrução break. Se a instrução `break`
+// não existe o programa executa todos os casos a seguir após um caso ser 
+// verdadeiro.
+int valor = 2;
+switch(valor) {
+  case 0:
+    print("Nada!"); // Isso não é executado.
+    break; // Salta para a próxima instrução
+  case 1:
+    print("Chegando lá..."); // Isso novamente não é executado.
+    break;
+  case 2:
+    print("Bravo!"); // Esta linha é executada.
+    break;
+  default:
+    print("Não encontrado!"); // Esta linha é executada se nosso valor for algum outro valor.
+    break;
+}
+
+// Declarações iterativas
+// Declarações For - Novamente, a mesma sintaxe que em Java
+for(int i = 0; i < 5; i++){
+  print(i); // imprime de 0 a 4
+}
+
+// Declarações While - Novamente, nada de novo se você estiver familiarizado com
+// a sintaxe Java.
+int j = 3;
+while(j > 0) {
+  print(j);
+  j--; // Isso é importante para evitar que o código seja executado indefinidamente.
+}
+
+// loop()| noLoop() | redraw() | exit()
+// Estas são mais funções específicas do Processing para configurar o fluxo do 
+// programa.
+loop(); // permite que o método draw() seja executado para sempre enquanto
+noLoop(); // só permite que ele seja executado uma vez.
+redraw(); // executa o método draw() mais uma vez.
+exit(); // Isso para o programa. É útil para programas com draw()
+// rodando continuamente.
+```
+
+## Desenho com Processing
+
+Como você já deve ter entendido o básico da linguagem, vamos agora
+ver a melhor parte do Processing - DESENHAR.
+
+```
+/* ------
+   Formas
+   ------
+*/
+
+// Formas 2D
+
+// Ponto
+point(x, y); // No espaço 2D
+point(x, y, z); // No espaço 3D
+// Desenha um ponto no espaço de coordenadas.
+
+// Linha
+line(x1, y1, x2, y2); // No espaço 2D
+line(x1, y1, z1, x2, y2, z2); // No espaço 3D
+// Desenha uma linha conectando dois pontos definidos por (x1, y1) e (x2, y2).
+
+// Triângulo
+triangle(x1, y1, x2, y2, x3, y3);
+// Desenha um triângulo conectando três pontos definidos por parâmetros de coordenadas.
+
+// Retângulo
+rect(a, b, c, d, [r]); // Com parâmetro opcional definindo o raio de todos os cantos
+rect(a, b, c, d, [te, td, bd, be]); // Com conjunto opcional de parâmetros definindo
+// raio de cada canto
+// Desenha um retângulo com {a, b} como coordenada superior esquerda e c e d como largura
+// e altura respectivamente.
+
+// Quad
+quad(x, y, x2, y2, x3, y3, x4, y4);
+// Desenha um quadrilátero com parâmetros que definem as coordenadas de cada canto
+// ponto.
+
+// Elipse
+ellipse(x, y, largura, altura);
+// Desenha um eclipse no ponto {x, y} com largura e altura especificadas.
+
+// Arco
+arc(x, y, largura, altura, inicio, fim, [modo]);
+// Enquanto os primeiros quatro parâmetros são autoexplicativos,
+// início e fim definem os ângulos que o arco começa e termina (em radianos).
+// O parâmetro opcional [mode] define o preenchimento;
+// PIE dá o contorno de torta, CHORD dá o contorno reto e OPEN é como
+// CHORD porém sem contorno
+
+// Curvas
+// O Processing fornece duas implementações de curvas; usando curve() e 
+// bezier(). Como pretendo manter isso simples, não vou discutir mais detalhes.
+// No entanto, se você quiser implementá-lo em seu sketch, aqui estão as 
+// referências: (https://processing.org/reference/curve_.html)
+// (https://processing.org/reference/bezier_.html)
+
+// Formas 3D
+
+// espaço 3D
+pode ser configurado definindo "P3D" para o parâmetro do renderizador no
+// método size().
+size(largura, altura, P3D);
+// No espaço 3D, você terá que traduzir para a coordenada específica para
+// renderiza as formas 3D.
+
+// Caixa
+box(tamanho); // Cubo com o mesmo comprimento definido pelo tamanho
+box(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente
+
+// Esfera
+sphere(raio); // Seu tamanho é definido usando o parâmetro raio
+// O mecanismo por trás da renderização das esferas é implementado por 
+// triângulos em mosaico. Dito isso, o nível de detalhe sendo renderizado é 
+// controlado pela função sphereDetail(res)
+// Mais informações aqui: (https://processing.org/reference/sphereDetail_.html)
+
+// Formas irregulares
+// E se você quiser desenhar algo que não foi disponibilizado pelo Processing
+// funções?
+// Você pode usar beginShape(), endShape(), vertex(x,y) para definir formas por
+// especificando cada ponto. Mais informações aqui:
+// (https://processing.org/reference/beginShape_.html)
+// Você também pode usar formas personalizadas usando a classe PShape:
+// (https://processing.org/reference/PShape.html)
+
+/* ---------------
+   Transformações
+   ---------------
+*/
+
+// As transformações são particularmente úteis para acompanhar o espaço de 
+// coordenadas e os vértices das formas que você desenhou. Particularmente;
+// métodos de pilha de matrizes; pushMatrix(), popMatrix() e translate(x,y)
+pushMatriz(); // Salva o sistema de coordenadas atual na pilha
+// ... aplique todas as transformações aqui ...
+popMatriz(); // Restaura o sistema de coordenadas salvo
+// Usando-os, o sistema de coordenadas pode ser preservado e visualizado sem
+// causar qualquer conflito.
+
+// Traduzir
+translate(x,y); // Traduz para o ponto{x, y} ou seja - configurando a origem para esse ponto
+translate(x, y, z); // Contraparte 3D da função
+
+// Rotacionar
+rotate(ângulo); // Gira a quantidade especificada pelo parâmetro ângulo
+// Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão: 
+// rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo)
+
+// Escala
+scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o.
+
+/* --------------------
+   Estilo e texturas
+   --------------------
+*/
+
+// Cores
+// Como discuti anteriormente, a cor de fundo pode ser configurada usando a 
+// função background(). Você pode definir a cor de um objeto de antemão e depois
+// passar para a função como um argumento.
+color c = cor(255, 255, 255); // BRANCO!
+// Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado
+//  para HSB usando colorMode(). Leia mais aqui:
+// (https://processing.org/reference/colorMode_.html)
+background(c); // Até agora, a cor de fundo deve ser branca.
+// Você pode usar a função fill() para selecionar a cor para preencher as formas.
+// Tem que ser configurado antes de você começar a desenhar formas para que as 
+// cores fiquem aplicadas.
+fill(color(0, 0, 0));
+// Se você quiser apenas colorir os contornos das formas, você pode usar
+// função stroke().
+stroke(255, 255, 0, 200); // cor do traço definida para amarelo com transparência
+// definido para um valor menor.
+
+// Imagens
+// O Processing pode renderizar imagens e usá-las de várias maneiras. 
+// Principalmente armazenado como Tipo de dados PImage.
+filter(sombreador); // O Processing suporta várias funções de filtro para manipulação de imagens.
+texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas.
+```
+
+Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer. Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma
+documentação curta, então vou deixá-los aqui. Se você se interessar, por favor verifique as referências.
+
+```
+// Antes de prosseguirmos, vou falar um pouco mais sobre como importar bibliotecas
+// para que você possa estender a funcionalidade do Processing para outros horizontes.
+
+/* -------
+   Importações
+   -------
+*/
+
+// As possibilidades do Processing pode ser estendidas ainda mais quando 
+// importamos bibliotecas e pacotes em nossos esboços.
+// A instrução de importação pode ser escrita como abaixo na parte superior 
+// do código-fonte.
+import processing.algumacoisa.*;
+```
+
+## VAC?
+
+Vamos ao código? Vamos sujar as mãos!
+
+Vamos ver um exemplo do openprocessing para visualizar o quanto o Processing é
+capaz de fazer com poucas linhas de código.
+
+Copie o código abaixo em seu IDE do Processing e veja a mágica.
+
+```
+// Isenção de responsabilidade: eu não escrevi este programa porque atualmente 
+// estou ocupado com meu estágio e este sketch é adaptado do openprocessing pois
+//  mostra algo legal com um código simples.
+// Recuperado de: (https://www.openprocessing.org/sketch/559769)
+
+float theta;
+float a;
+float col;
+float num;
+
+void setup() {
+  size(600,600);
+}
+
+void draw() {
+  background(#F2F2F2);
+  translate(width/2, height/2);
+  theta = map(sin(millis()/1000.0), -1, 1, 0, PI/6);
+
+  float num=6;
+  for (int i=0; i<num; i++) {
+    a =350;
+    rotate(TWO_PI/num);
+    branch(a);
+  }
+
+}
+
+void branch(float len) {
+  col=map(len, 0, 90, 150, 255);
+  fill(col, 0, 74);
+  stroke (col, 0, 74);
+  line(0, 0, 0, -len);
+  ellipse(0, -len, 3, 3);
+  len *= 0.7;
+
+  if (len>30) {
+    pushMatrix();
+    translate(0, -30);
+    rotate(theta);
+    branch(len);
+    popMatrix();
+
+    pushMatrix();
+    translate(0, -30);
+    rotate(-theta);
+    branch(len);
+    popMatrix();
+
+  }
+}
+```
+
+A linguagem Processing é fácil de aprender e é particularmente útil para criar
+conteúdo (mesmo em 3D) sem ter que digitar muitos códigos. É tão simples
+que você pode ler o código e ter uma ideia aproximada do fluxo do programa.
+
+No entanto, isso não se aplica quando você introduz bibliotecas externas, pacotes
+e até mesmo suas próprias aulas. (Confie em mim! Projetos em processing podem ficar realmente monstruosos...)
+
+## Alguns recursos úteis
+
+  - [Site do Processing](http://processing.org)
+  - [Sketches em Processing](http://openprocessing.org)
diff --git a/pt-br/pug-pt.html.markdown b/pt-br/pug-pt.html.markdown
new file mode 100644
index 00000000..52eda86a
--- /dev/null
+++ b/pt-br/pug-pt.html.markdown
@@ -0,0 +1,211 @@
+---
+language: Pug
+contributors:
+  - ["Michael Warner", "https://github.com/MichaelJGW"]
+filename: index-pt.pug
+translators:
+  - ["Adaías Magdiel", "https://adaiasmagdiel.com/"]
+lang: pt-br
+---
+
+## Começando com Pug
+
+Pug é uma pequena linguagem que compila para HTML. Possui uma sintaxe limpa 
+com algumas funcionalidades adicionais, como declarações if e loops. Também pode ser utilizada 
+como uma linguagem de templates no lado do servidor para tecnologias como o Node.js.
+
+### The Language
+```pug
+
+//- Comentário de uma linha
+
+//- Comentário de
+    várias linhas
+
+//- ---TAGS---
+//- Básico
+div
+//- <div></div>
+h1
+//- <h1></h1>
+minha-propriaTag
+//- <minha-propriaTag></minha-propriaTag>
+
+//- Tags irmãs
+div
+div
+//- <div></div>
+    <div></div>
+
+//- Tags aninhadas
+div
+  div
+//- <div>
+      <div></div>
+    </div>
+
+//- Textos
+h1 Olá, pessoas
+//- <h1>Olá, pessoas</h1>
+
+//- Texto de várias linhas
+div.
+  Oi,
+  tudo bem?
+//- <div>
+      Oi,
+      tudo bem?
+    </div>
+
+//- ---ATRIBUTOS---
+div(class="minha-class" id="meu-id" meu-proprio-atributo="data" enabled)
+//- <div class="minha-class" id="meu-id" meu-proprio-atributo="data" enabled></div>
+
+//- Abreviações
+span.minha-class
+//- <span class="minha-class"></span>
+.minha-class
+//- <div class="minha-class"></div>
+div#meu-id
+//- <div id="meu-id"></div>
+div#meu-id.minha-class
+//- <div class="minha-class" id="meu-id"></div>
+
+
+//- ---JAVASCRIPT---
+- const lang = "pug";
+
+//- Javascript em várias linhas
+-
+  const lang = "pug";
+  const awesome = true;
+
+//- Classes com Javascript
+- const myClass = ['class1', 'class2', 'class3']
+div(class=myClass)
+//- <div class="class1 class2 class3"></div>
+
+//- Estilos com Javascript
+- const myStyles = {'color':'white', 'background-color':'blue'}
+div(styles=myStyles)
+//- <div styles="{&quot;color&quot;:&quot;white&quot;,&quot;background-color&quot;:&quot;blue&quot;}"></div>
+
+//- Atributos com Javascript
+- const myAttributes = {"src": "photo.png", "alt": "My Photo"}
+img&attributes(myAttributes)
+//- <img src="photo.png" alt="My Photo">
+- let disabled = false
+input(type="text" disabled=disabled)
+//- <input type="text">
+- disabled = true
+input(type="text" disabled=disabled)
+//- <input type="text" disabled>
+
+//- Templates com Javascript
+- const name = "Bob";
+h1 Olá, #{name}
+h1= name
+//- <h1>Olá, Bob</h1>
+//- <h1>Bob</h1>
+
+//- ---LOOPS---
+
+//- 'each' e 'for' tem a mesma função, aqui nós usaremos apenas 'each'.
+
+each value, i in [1,2,3]
+  p=value
+//-
+  <p>1</p>
+  <p>2</p>
+  <p>3</p>
+
+each value, index in [1,2,3]
+  p=value + '-' + index
+//-
+  <p>1-0</p>
+  <p>2-1</p>
+  <p>3-2</p>
+
+each value in []
+  p=value
+//- 
+
+each value in []
+  p=value
+else
+  p Sem valores
+
+//- <p>Sem valores</p>
+
+//- ---CONDICIONAIS---
+
+- const number = 5
+if number < 5
+  p o número é menor do que 5
+else if number > 5
+  p o número é maior do que 5
+else
+  p o número é 5
+//- <p>o número é 5</p>
+
+- const orderStatus = "Aguardando";
+case orderStatus
+  when "Aguardando"
+    p.warn Seu pedido está em espera
+  when "Completado"
+    p.success Seu pedido foi completado.
+  when -1
+    p.error Ocorreu algum erro
+  default
+    p Nenhum registro de pedido encontrado
+//- <p class="warn">Seu pedido está em espera</p>
+
+//- --INCLUINDO CONTEÚDOS--
+//- Caminho do arquivo -> "includes/nav.pug"
+h1 Indústrias ACME
+nav
+  a(href="index.html") Início
+  a(href="about.html") Sobre Nós
+
+//- Caminho do arquivo -> "index.pug"
+html
+  body
+    include includes/nav.pug
+//-
+  <html>
+    <body>
+      <h1>Indústrias ACME</h1>
+      <nav><a href="index.html">Início</a><a href="about.html">Sobre Nós</a></nav>
+    </body>
+  </html>
+
+//- Importando Javascript e CSS
+script
+  include scripts/index.js
+style
+  include styles/theme.css
+
+//- ---MIXIN---
+mixin basic
+  div Olá
++basic
+//- <div>Olá</div>
+
+mixin comment(nome, comentario)
+  div
+    span.comment-name= nome
+    div.comment-text= comentario
++comment("Gil", "Tudo é divino, tudo é maravilhoso")
+//- 
+  <div>
+    <span class="comment-name">Gil</span>
+    <div class="comment-text">Tudo é divino, tudo é maravilhoso</div>
+  </div>
+
+```
+
+
+### Saiba Mais
+- [Site Oficial](https://pugjs.org/)
+- [Documentação](https://pugjs.org/api/getting-started.html)
+- [Repositório no GitHub](https://github.com/pugjs/pug)
diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown
index 40fe82d5..42f744e2 100644
--- a/pt-br/pyqt-pt.html.markdown
+++ b/pt-br/pyqt-pt.html.markdown
@@ -24,7 +24,7 @@ o pyqt!
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
 	# Cria um objeto para a aplicação
     app = QtGui.QApplication(sys.argv)
@@ -54,7 +54,7 @@ outros elementos.
 Aqui mostraremos como criar uma janela popup, muito útil para perguntar ao
 usuário qual decisão tomar ou exibir alguma informação.
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -73,7 +73,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Essa função deve criar uma janela de diálogo com um botão,
 # aguarda ser clicado e encerra o programa
 def showdialog():
diff --git a/pt-br/pythonstatcomp-pt.html.markdown b/pt-br/pythonstatcomp-pt.html.markdown
new file mode 100644
index 00000000..aa532eb4
--- /dev/null
+++ b/pt-br/pythonstatcomp-pt.html.markdown
@@ -0,0 +1,249 @@
+---
+category: tool
+tool: Statistical Computing with Python
+contributors:
+    - ["e99n09", "https://github.com/e99n09"]
+translators:
+    - ["waltercjunior", "https://github.com/waltercjunior"]
+filename: pythonstatcomp-pt.py
+lang: pt-br
+---
+
+Este é um tutorial sobre como fazer algumas tarefas típicas de programação estatística usando Python.
+É destinado basicamente à pessoas familizarizadas com Python e experientes com programação estatística em linguagens como R,
+Stata, SAS, SPSS ou MATLAB.
+
+```python
+
+
+
+# 0. Preparando-se ====
+
+"""  Para começar, instale o seguinte : jupyther, numpy, scipy, pandas, 
+    matplotlib, seaborn, requests.
+    Certifique-se de executar este tutorial utilizando o Jupyther notebook para
+    que você utilize os gráficos embarcados e ter uma fácil consulta à 
+    documentação.
+    O comando para abrir é simplesmente '`jupyter notebook`, quando abrir então
+    clique em 'New -> Python'.
+"""
+
+# 1. Aquisição de dados ====
+
+""" A única razão das pessoas optarem por Python no lugar de R é que pretendem
+    interagir com o ambiente web, copiando páginas diretamente ou solicitando
+    dados utilizando uma API. Você pode fazer estas coisas em R, mas no 
+    contexto de um projeto já usando Python, há uma vantagem em se ater uma
+    linguágem única.
+"""
+
+import requests  # para requisições HTTP (web scraping, APIs)
+import os
+
+# web scraping
+r = requests.get("https://github.com/adambard/learnxinyminutes-docs")
+r.status_code  # se retornou código 200, a requisição foi bem sucedida
+r.text  # código fonte bruto da página
+print(r.text)  # formatado bonitinho
+# salve a o código fonte d apágina em um arquivo:
+os.getcwd()  # verifique qual é o diretório de trabalho
+with open("learnxinyminutes.html", "wb") as f:
+    f.write(r.text.encode("UTF-8"))
+
+# Baixar um arquivo csv
+fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/"
+fn = "pets.csv"
+r = requests.get(fp + fn)
+print(r.text)
+with open(fn, "wb") as f:
+    f.write(r.text.encode("UTF-8"))
+
+""" para mais informações sobre o módulo de solicitações, incluindo API's, veja em
+    http://docs.python-requests.org/en/latest/user/quickstart/
+"""
+
+# 2. Lendo um arquivo formato CSV ====
+
+""" Um pacote de pandas da Wes McKinney lhe dá um objeto 'DataFrame' em Python.
+    Se você já usou R, já deve estar familiarizado com a ideia de "data.frame".
+"""
+
+import pandas as pd
+import numpy as np
+import scipy as sp
+pets = pd.read_csv(fn)
+pets
+#        name  age  weight species
+# 0    fluffy    3      14     cat
+# 1  vesuvius    6      23    fish
+# 2       rex    5      34     dog
+
+""" Usuários R: observe que o Python, como a maioria das linguagens de programação 
+    influenciada pelo C, a indexação começa de 0. Em R, começa a indexar em 1
+    devido à influência do Fortran.
+"""
+
+# duas maneiras diferentes de imprimir uma coluna
+pets.age
+pets["age"]
+
+pets.head(2)  # imprima as 2 primeiras linhas
+pets.tail(1)  # imprima a última linha
+
+pets.name[1]  # 'vesuvius'
+pets.species[0]  # 'cat'
+pets["weight"][2]  # 34
+
+# Em R, você esperaria obter 3 linhas fazendo isso, mas aqui você obtem 2:
+pets.age[0:2]
+# 0    3
+# 1    6
+
+sum(pets.age) * 2  # 28
+max(pets.weight) - min(pets.weight)  # 20
+
+""" Se você está fazendo alguma álgebra linear séria e processamento de 
+    números você pode desejar apenas arrays, não DataFrames. DataFrames são
+    ideais para combinar colunas de diferentes tipos de dados.
+"""
+
+# 3. Gráficos ====
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+# Para fazer a visualiação de dados em Python, use matplotlib
+
+plt.hist(pets.age);
+
+plt.boxplot(pets.weight);
+
+plt.scatter(pets.age, pets.weight)
+plt.xlabel("age")
+plt.ylabel("weight");
+
+# seaborn utiliza a biblioteca do matplotlib e torna os enredos mais bonitos
+
+import seaborn as sns
+
+plt.scatter(pets.age, pets.weight)
+plt.xlabel("age")
+plt.ylabel("weight");
+
+# também existem algumas funções de plotagem específicas do seaborn
+# observe como o seaborn automaticamenteo o eixto x neste gráfico de barras
+sns.barplot(pets["age"])
+
+# Veteranos em R ainda podem usar o ggplot
+from ggplot import *
+ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
+# fonte: https://pypi.python.org/pypi/ggplot
+
+# há até um d3.js veja em: https://github.com/mikedewar/d3py
+
+# 4. Limpeza de dados simples e análise exploratória ====
+
+""" Aqui está um exemplo mais complicado que demonstra dados básicos
+    fluxo de trabalho de limpeza levando à criação de algumas parcelas
+    e a execução de uma regressão linear.
+        O conjunto de dados foi transcrito da Wikipedia à mão. Contém
+    todos os sagrados imperadores romanos e os marcos importantes em suas vidas
+    (birth, death, coronation, etc.).
+        O objetivo da análise será explorar se um relacionamento existe
+    entre o ano de nascimento (birth year) e a expectativa de vida (lifespam)
+    do imperador.
+    Fonte de dados: https://en.wikipedia.org/wiki/Holy_Roman_Emperor
+"""
+
+# carregue alguns dados dos sagrados imperadores romanos
+url = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/hre.csv"
+r = requests.get(url)
+fp = "hre.csv"
+with open(fp, "wb") as f:
+    f.write(r.text.encode("UTF-8"))
+
+hre = pd.read_csv(fp)
+
+hre.head()
+"""
+   Ix      Dynasty        Name        Birth             Death
+0 NaN  Carolingian   Charles I  2 April 742    28 January 814
+1 NaN  Carolingian     Louis I          778       20 June 840
+2 NaN  Carolingian   Lothair I          795  29 September 855
+3 NaN  Carolingian    Louis II          825     12 August 875
+4 NaN  Carolingian  Charles II  13 June 823     6 October 877
+
+       Coronation 1   Coronation 2 Ceased to be Emperor
+0   25 December 800            NaN       28 January 814
+1  11 September 813  5 October 816          20 June 840
+2       5 April 823            NaN     29 September 855
+3        Easter 850     18 May 872        12 August 875
+4   29 December 875            NaN        6 October 877
+"""
+
+# limpar as colunas Birth e Death
+
+import re  # módulo para expressões regulares
+
+rx = re.compile(r'\d+$')  # conincidir com os códigos finais
+
+""" Esta função aplia a expressão reguar a uma coluna de entrada (here Birth,
+    Death), nivela a lista resultante, converte-a em uma lista de objetos, e
+    finalmente converte o tipo do objeto da lista de String para inteiro. para
+    mais informações sobre o que as diferentes partes do código fazer, veja em:
+      - 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
+"""
+
+from functools import reduce
+
+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)
+
+# faça uma coluna infomrnado a idade estimada ("EstAge")
+hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int)
+
+# gráfico de dispersão simples, sem linha de tendência, cor representa dinastia
+sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False)
+
+# use o scipy para executar uma regrassão linear
+from scipy import stats
+(slope, intercept, rval, pval, stderr) = stats.linregress(hre.BirthY, hre.EstAge)
+# código fonte: http://wiki.scipy.org/Cookbook/LinearRegression
+
+# varifique o declive (slope)
+slope  # 0.0057672618839073328
+
+# varifique o valor R^2:
+rval**2  # 0.020363950027333586
+
+# varifique o valor p-value
+pval  # 0.34971812581498452
+
+# use o seaborn para fazer um gráfico de dispersão e traçar a linha de tendência de regrassão linear
+sns.lmplot("BirthY", "EstAge", data=hre)
+
+""" Para mais informações sobre o seaborn, veja
+      - http://web.stanford.edu/~mwaskom/software/seaborn/
+      - https://github.com/mwaskom/seaborn
+    Para mais informações sobre o SciPy, veja
+      - http://wiki.scipy.org/SciPy
+      - http://wiki.scipy.org/Cookbook/
+    Para ver uma versão da análise dos sagrados imperadores romanos usando R, consulte
+      - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
+"""
+
+```
+
+Se você quiser saber mais, obtenha o Python para análise de dados de Wes McKinney. É um excelente recurso e usei-o como referência ao escrever este tutorial.
+
+Você também pode encontrar muitos tutoriais interativos de IPython sobre assuntos específicos de seus interesses, como Cam Davidson-Pilon's <a href="http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/" Title="Programação Probabilística e Métodos Bayesianos para Hackers">Programação Probabilística e Métodos Bayesianos para Hackers</a>.
+
+Mais alguns módulos para pesquisar:
+   - análise de texto e processamento de linguagem natural: nltk, http://www.nltk.org
+   - análise de rede social: igraph, http://igraph.org/python/
diff --git a/pt-br/qt-pt.html.markdown b/pt-br/qt-pt.html.markdown
index 99579c35..f4211e09 100644
--- a/pt-br/qt-pt.html.markdown
+++ b/pt-br/qt-pt.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: Qt Framework
-language: c++
+language: C++
 filename: learnqt-pt.cpp
 contributors:
     - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
diff --git a/pt-br/r-pt.html.markdown b/pt-br/r-pt.html.markdown
new file mode 100644
index 00000000..5c9304ec
--- /dev/null
+++ b/pt-br/r-pt.html.markdown
@@ -0,0 +1,786 @@
+---
+language: R
+contributors:
+    - ["e99n09", "http://github.com/e99n09"]
+    - ["isomorphismes", "http://twitter.com/isomorphisms"]
+    - ["kalinn", "http://github.com/kalinn"]
+translators:
+    - ["Marcel Ribeiro-Dantas", "http://github.com/mribeirodantas"]
+lang: pt-br    
+filename: learnr-pt.r
+---
+
+R é uma linguagem de programação estatística. Ela tem muitas bibliotecas para carregar e limpar conjuntos de dados, executar análises estatísticas e produzir gráficos. Você também pode executar comandos do `R` dentro de um documento LaTeX.
+
+```r
+
+# Comentários começam com o símbolo de Cerquilha, também conhecido como
+# jogo da velha
+
+# Não existe um símbolo especial para comentários em várias linhas
+# mas você pode escrever várias linhas de comentários adicionando a
+# cerquilha (#) ao início de cada uma delas.
+
+# No Windows e Linux, você pode usar CTRL-ENTER para executar uma linha.
+# No MacOS, o equivalente é COMMAND-ENTER
+
+
+
+#############################################################################
+# Coisas que você pode fazer sem entender nada sobre programação
+#############################################################################
+
+# Nesta seção, mostramos algumas das coisas legais que você pode fazer em
+# R sem entender nada de programação. Não se preocupe em entender tudo o
+# que o código faz. Apenas aproveite!
+
+data()	          # navegue pelos conjuntos de dados pré-carregados
+data(rivers)	  # carregue este: "Comprimentos dos principais rios norte-americanos"
+ls()	          # observe que "rivers" apareceu na área de trabalho (workspace)
+head(rivers)	  # dê uma espiada no conjunto de dados
+# 735 320 325 392 524 450
+
+length(rivers)	  # quantos rios foram medidos?
+# 141
+summary(rivers)   # consulte um sumário de estatísticas básicas
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#  135.0   310.0   425.0   591.2   680.0  3710.0
+
+# faça um diagrama de ramos e folhas (uma visualização de dados semelhante a um histograma)
+stem(rivers)
+
+#  A vírgula está 2 dígito(s) à direita do símbolo |
+#
+#   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)) # Observe que os dados não são normais nem log-normais!
+# Tome isso, fundamentalistas da curva normal!
+
+#  O ponto decimal está 1 dígito(s) à esquerda do símbolo |
+#
+#  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
+
+# faça um histograma:
+hist(rivers, col="#333333", border="white", breaks=25)      # brinque com estes parâmetros
+hist(log(rivers), col="#333333", border="white", breaks=25) # você fará mais gráficos mais tarde
+
+# Aqui está outro conjunto de dados que vem pré-carregado. O R tem toneladas deles.
+data(discoveries)
+plot(discoveries, col="#333333", lwd=3, xlab="Ano",
+     main="Número de descobertas importantes por ano")
+plot(discoveries, col="#333333", lwd=3, type = "h", xlab="Ano",
+     main="Número de descobertas importantes por ano")
+
+# Em vez de deixar a ordenação padrão (por ano),
+# também podemos ordenar para ver o que é mais comum:
+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)
+#
+#  O ponto decimal está no símbolo |
+#
+#   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
+
+# Role um dado algumas vezes
+round(runif(7, min=.5, max=6.5))
+# 1 4 6 1 4 6 4
+# Seus números serão diferentes dos meus, a menos que definamos a mesma semente aleatória com o set.seed
+
+# Obtenha 9 números de forma aleatória a partir de uma distribuição normal
+rnorm(9)
+# [1]  0.07528471  1.03499859  1.34809556 -0.82356087  0.61638975 -1.88757271
+# [7] -0.59975593  0.57629164  1.08455362
+
+
+
+##################################################
+# Tipos de dados e aritmética básica
+##################################################
+
+# Agora para a parte orientada a programação do tutorial.
+# Nesta seção você conhecerá os tipos de dados importantes do R:
+# integers, numerics, characters, logicals, e factors.
+# Existem outros, mas estes são o mínimo que você precisa para
+# iniciar.
+
+# INTEGERS
+# Os inteiros de armazenamento longo são escritos com L
+5L # 5
+class(5L) # "integer"
+# (Experimente ?class para obter mais informações sobre a função class().)
+# Em R, todo e qualquer valor, como 5L, é considerado um vetor de comprimento 1
+length(5L) # 1
+# Você pode ter um vetor inteiro com comprimento > 1 também:
+c(4L, 5L, 8L, 3L) # 4 5 8 3
+length(c(4L, 5L, 8L, 3L)) # 4
+class(c(4L, 5L, 8L, 3L)) # "integer"
+
+# NUMERICS
+# Um "numeric" é um número de ponto flutuante de precisão dupla
+5 # 5
+class(5) # "numeric"
+# De novo, tudo em R é um vetor;
+# você pode fazer um vetor numérico com mais de um elemento
+c(3,3,3,2,2,1) # 3 3 3 2 2 1
+# Você também pode usar a notação científica
+5e4 # 50000
+6.02e23 # Número de Avogadro
+1.6e-35 # Comprimento de Planck
+# Você também pode ter números infinitamente grandes ou pequenos
+class(Inf)	# "numeric"
+class(-Inf)	# "numeric"
+# Você pode usar "Inf", por exemplo, em integrate(dnorm, 3, Inf)
+# isso evita as tabelas de escores-Z.
+
+# ARITMÉTICA B�SICA
+# Você pode fazer aritmética com números
+# Fazer aritmética com uma mistura de números inteiros (integers) e com
+# ponto flutuante (numeric) resulta em um numeric
+10L + 66L # 76      # integer mais integer resulta em integer
+53.2 - 4  # 49.2    # numeric menos numeric resulta em numeric
+2.0 * 2L  # 4       # numeric vezes integer resulta em numeric
+3L / 4    # 0.75    # integer dividido por numeric resulta em numeric
+3 %% 2	  # 1       # o resto de dois numeric é um outro numeric
+# Aritmética ilegal produz um "não-é-um-número" (do inglês Not-a-Number):
+0 / 0 # NaN
+class(NaN) # "numeric"
+# Você pode fazer aritmética em dois vetores com comprimento maior que 1,
+# desde que o comprimento do vetor maior seja um múltiplo inteiro do menor
+c(1,2,3) + c(1,2,3) # 2 4 6
+# Como um único número é um vetor de comprimento um, escalares são aplicados
+# elemento a elemento com relação a vetores
+(4 * c(1,2,3) - 2) / 2 # 1 3 5
+# Exceto para escalares, tenha cuidado ao realizar aritmética em vetores com
+# comprimentos diferentes. Embora possa ser feito,
+c(1,2,3,1,2,3) * c(1,2) # 1 4 3 2 2 6
+# ter comprimentos iguais é uma prática melhor e mais fácil de ler
+c(1,2,3,1,2,3) * c(1,2,1,2,1,2) 
+
+# CHARACTERS
+# Não há diferença entre strings e caracteres em R
+"Horatio" # "Horatio"
+class("Horatio") # "character"
+class('H') # "character"
+# São ambos vetores de caracteres de comprimento 1
+# Aqui está um mais longo:
+c('alef', 'bet', 'gimmel', 'dalet', 'he')
+# "alef"   "bet"    "gimmel" "dalet"  "he"
+length(c("Call","me","Ishmael")) # 3
+# Você pode utilizar expressões regulares (regex) em vetores 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 tem vários vetores de caracteres embutidos:
+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"
+
+# LOGICALS
+# Em R, um "logical" é um booleano
+class(TRUE)	# "logical"
+class(FALSE)	# "logical"
+# O comportamento deles é normal
+TRUE == TRUE	# TRUE
+TRUE == FALSE	# FALSE
+FALSE != FALSE	# FALSE
+FALSE != TRUE	# TRUE
+# Dados ausentes (NA) são logical, também
+class(NA)	# "logical"
+# Use | e & para operações lógicas.
+# OR
+TRUE | FALSE	# TRUE
+# AND
+TRUE & FALSE	# FALSE
+# Aplicar | e & a vetores retorna operações lógicas elemento a elemento
+c(TRUE,FALSE,FALSE) | c(FALSE,TRUE,FALSE) # TRUE TRUE FALSE
+c(TRUE,FALSE,TRUE) & c(FALSE,TRUE,TRUE) # FALSE FALSE TRUE
+# Você pode testar se x é TRUE
+isTRUE(TRUE)	# TRUE
+# Aqui obtemos um vetor logical com muitos 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
+
+# FACTORS
+# A classe factor é para dados categóricos
+# Os fatores podem ser ordenados (como as avaliações de crianças) ou
+# não ordenados (como as cores)
+factor(c("azul", "azul", "verde", NA, "azul"))
+#  azul azul verde   <NA>   azul
+# Levels: azul verde
+# Os "levels" são os valores que os dados categóricos podem assumir
+# Observe que os dados ausentes não entram nos levels
+levels(factor(c("verde", "verde", "azul", NA, "azul"))) # "azul" "verde"
+# Se um vetor de factor tem comprimento 1, seus levels também terão comprimento 1
+length(factor("green")) # 1
+length(levels(factor("green"))) # 1
+# Os fatores são comumente vistos em data frames, uma estrutura de dados que abordaremos
+# mais tarde
+data(infert) # "Infertilidade após aborto espontâneo e induzido"
+levels(infert$education) # "0-5yrs"  "6-11yrs" "12+ yrs"
+
+# NULL
+# "NULL" é um valor estranho; use-o para "apagar" um vetor
+class(NULL)	# NULL
+parakeet = c("bico", "penas", "asas", "olhos")
+parakeet
+# [1] "bico"  "penas" "asas"  "olhos"
+parakeet <- NULL
+parakeet
+# NULL
+
+# COERÇÃO DE TIPO
+# Coerção de tipo é quando você força um valor a assumir um tipo diferente
+as.character(c(6, 8)) # "6" "8"
+as.logical(c(1,0,1,1)) # TRUE FALSE  TRUE  TRUE
+# Se você colocar elementos de diferentes tipos em um vetor, coerções estranhas acontecem:
+c(TRUE, 4) # 1 4
+c("cachorro", TRUE, 4) # "cachorro"  "TRUE" "4"
+as.numeric("Bilbo")
+# [1] NA
+# Warning message:
+# NAs introduced by coercion
+
+# Observe também: esses são apenas os tipos de dados básicos
+# Existem muitos outros tipos de dados, como datas, séries temporais, etc.
+
+
+
+##################################################
+# Variáveis, laços, expressões condicionais
+##################################################
+
+# Uma variável é como uma caixa na qual você armazena um valor para uso posterior.
+# Chamamos isso de "atribuir" o valor à variável.
+# Ter variáveis nos permite escrever laços, funções e instruções com condição
+
+# VARI�VEIS
+# Existem muitas maneiras de atribuir valores:
+x = 5 # é possível fazer assim
+y <- "1" # mas é preferível fazer assim
+TRUE -> z # isso funciona, mas é estranho
+
+# LAÇOS
+# Nós temos laços com for
+for (i in 1:4) {
+  print(i)
+}
+# [1] 1
+# [1] 2
+# [1] 3
+# [1] 4
+# Nós temos laços com while
+a <- 10
+while (a > 4) {
+	cat(a, "...", sep = "")
+	a <- a - 1
+}
+# 10...9...8...7...6...5...
+# Tenha em mente que os laços for e while são executados lentamente em R
+# Operações em vetores inteiros (por exemplo, uma linha inteira, uma coluna inteira)
+# ou funções do tipo apply() (discutiremos mais tarde) são mais indicadas
+
+# IF/ELSE
+# Novamente, bastante padrão
+if (4 > 3) {
+	print("4 é maior que 3")
+} else {
+	print("4 não é maior que 3")
+}
+# [1] "4 é maior que 3"
+
+# FUNÇÕES
+# Definidas assim:
+jiggle <- function(x) {
+	x = x + rnorm(1, sd=.1)	# adicione um pouco de ruído (controlado)
+	return(x)
+}
+# Chamada como qualquer outra função R:
+jiggle(5)	# 5±ε. Após set.seed(2716057), jiggle(5)==5.005043
+
+
+
+###########################################################################
+# Estruturas de dados: Vetores, matrizes, data frames e arranjos (arrays)
+###########################################################################
+
+# UNIDIMENSIONAL
+
+# Vamos começar do início, e com algo que você já sabe: vetores.
+vec <- c(8, 9, 10, 11)
+vec	#  8  9 10 11
+# Consultamos elementos específicos utilizando colchetes
+# (Observe que R começa a contar a partir de 1)
+vec[1]		# 8
+letters[18]	# "r"
+LETTERS[13]	# "M"
+month.name[9]	# "September"
+c(6, 8, 7, 5, 3, 0, 9)[3]	# 7
+# Também podemos pesquisar os índices de componentes específicos,
+which(vec %% 2 == 0)	# 1 3
+# pegue apenas as primeiras ou últimas entradas no vetor,
+head(vec, 1)	# 8
+tail(vec, 2)	# 10 11
+# ou descubra se um determinado valor está no vetor
+any(vec == 10) # TRUE
+# Se um índice for além do comprimento de um vetor, você obterá NA:
+vec[6]	# NA
+# Você pode encontrar o comprimento do seu vetor com length()
+length(vec)	# 4
+# Você pode realizar operações em vetores inteiros ou subconjuntos de vetores
+vec * 4	# 32 36 40 44
+vec[2:3] * 5	# 45 50
+any(vec[2:3] == 8) # FALSE
+# e R tem muitas funções internas para sumarizar vetores
+mean(vec)	# 9.5
+var(vec)	# 1.666667
+sd(vec)		# 1.290994
+max(vec)	# 11
+min(vec)	# 8
+sum(vec)	# 38
+# Mais alguns recursos embutidos:
+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
+
+# BIDIMENSIONAL (ELEMENTOS DA MESMA CLASSE)
+
+# Você pode fazer uma matriz com entradas do mesmo tipo assim:
+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
+# Ao contrário de um vetor, a classe de uma matriz é "matrix" independente do que ela contém
+class(mat) # "matrix"
+# Consulte a primeira linha
+mat[1,]	# 1 4
+# Execute uma operação na primeira coluna
+3 * mat[,1]	# 3 6 9
+# Consulte uma célula específica
+mat[3,2]	# 6
+
+# Transponha toda a matriz
+t(mat)
+#      [,1] [,2] [,3]
+# [1,]    1    2    3
+# [2,]    4    5    6
+
+# Multiplicação de matrizes
+mat %*% t(mat)
+#      [,1] [,2] [,3]
+# [1,]   17   22   27
+# [2,]   22   29   36
+# [3,]   27   36   45
+
+# cbind() une vetores em colunas para formar uma matriz
+mat2 <- cbind(1:4, c("cachorro", "gato", "passaro", "cachorro"))
+mat2
+#      [,1] [,2]
+# [1,] "1"  "cachorro"
+# [2,] "2"  "gato"
+# [3,] "3"  "passaro"
+# [4,] "4"  "cachorro"
+class(mat2)	# matrix
+# Mais uma vez, observe o que aconteceu!
+# Como as matrizes devem conter todas as entradas da mesma classe,
+# tudo foi convertido para a classe character
+c(class(mat2[,1]), class(mat2[,2]))
+
+# rbind() une vetores linha a linha para fazer uma 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, tudo da mesma classe. Sem coerções. Muito melhor.
+
+# BIDIMENSIONAL (CLASSES DIFERENTES)
+
+# Para colunas de tipos diferentes, use um data frame
+# Esta estrutura de dados é tão útil para programação estatística,
+# que uma versão dela foi adicionada ao Python através do pacote "pandas".
+
+estudantes <- data.frame(c("Cedric","Fred","George","Cho","Draco","Ginny"),
+                         c(3,2,2,1,0,-1),
+                         c("H", "G", "G", "R", "S", "G"))
+names(estudantes) <- c("nome", "ano", "casa") # nomeie as colunas
+class(estudantes)	# "data.frame"
+estudantes
+#     nome  ano  casa
+# 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(estudantes$ano)	# "numeric"
+class(estudantes[,3])	# "factor"
+# encontre as dimensões
+nrow(estudantes)	# 6
+ncol(estudantes)	# 3
+dim(estudantes)	# 6 3
+# A função data.frame() converte vetores de caracteres em vetores de fator
+# por padrão; desligue isso definindo stringsAsFactors = FALSE quando
+# você criar um data frame
+?data.frame
+
+# Existem muitas maneiras particulares de consultar partes de um data frame,
+# todas sutilmente diferentes
+estudantes$ano	# 3  2  2  1  0 -1
+estudantes[,2]	# 3  2  2  1  0 -1
+estudantes[,"ano"]	# 3  2  2  1  0 -1
+
+# Uma versão extendida da estrutura data.frame é a data.table
+# Se você estiver trabalhando com dados enormes ou em painel, ou precisar mesclar
+# alguns conjuntos de dados, data.table pode ser uma boa escolha. Aqui está um tour
+# relâmpago:
+install.packages("data.table") # baixe o pacote a partir do CRAN
+require(data.table) # carregue ele
+estudantes <- as.data.table(estudantes)
+estudantes # observe a saída ligeiramente diferente
+#      nome  ano  casa
+# 1: Cedric    3     H
+# 2:   Fred    2     G
+# 3: George    2     G
+# 4:    Cho    1     R
+# 5:  Draco    0     S
+# 6:  Ginny   -1     G
+estudantes[nome=="Ginny"] # Consulte estudantes com o nome == "Ginny"
+#     nome  ano  casa
+# 1: Ginny   -1     G
+estudantes[ano==2] # Consulte estudantes com o ano == 2
+#      nome  ano  casa
+# 1:   Fred    2     G
+# 2: George    2     G
+# data.table facilita a fusão de dois conjuntos de dados
+# vamos fazer outro data.table para mesclar com os alunos
+fundadores <- data.table(casa=c("G","H","R","S"),
+                         fundador=c("Godric","Helga","Rowena","Salazar"))
+fundadores
+#     casa fundador
+# 1:     G  Godric
+# 2:     H   Helga
+# 3:     R  Rowena
+# 4:     S Salazar
+setkey(estudantes, casa)
+setkey(fundadores, casa)
+estudantes <- fundadores[estudantes] # mescle os dois conjuntos de dados com base na "casa"
+setnames(estudantes, c("casa","nomeFundadorCasa","nomeEstudante","ano"))
+estudantes[,order(c("nome","ano","casa","nomeFundadorCasa")), with=F]
+#  nomeEstudante  ano  casa nomeFundadorCasa
+# 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
+
+# O data.table torna as tabelas de sumário fáceis
+estudantes[,sum(ano),by=casa]
+#     casa V1
+# 1:     G  3
+# 2:     H  3
+# 3:     R  1
+# 4:     S  0
+
+# Para remover uma coluna de um data.frame ou data.table,
+# atribua a ela o valor NULL
+estudantes$nomeFundadorCasa <- NULL
+estudantes
+#  nomeEstudante  ano  casa
+# 1:        Fred    2     G
+# 2:      George    2     G
+# 3:       Ginny   -1     G
+# 4:      Cedric    3     H
+# 5:         Cho    1     R
+# 6:       Draco    0     S
+
+# Remova uma linha consultando parte dos dados
+# Usando data.table:
+estudantes[nomeEstudante != "Draco"]
+#     casa estudanteNome  ano
+# 1:     G          Fred    2
+# 2:     G        George    2
+# 3:     G         Ginny   -1
+# 4:     H        Cedric    3
+# 5:     R           Cho    1
+# Usando data.frame:
+estudantes <- as.data.frame(estudantes)
+estudantes[estudantes$casa != "G",]
+#    casa nomeFundadorCasa nomeEstudante  ano
+# 4     H            Helga        Cedric    3
+# 5     R           Rowena           Cho    1
+# 6     S          Salazar         Draco    0
+
+# MULTIDIMENSIONAL (TODOS OS ELEMENTOS DE UM TIPO)
+
+# Arranjos (arrays) criam tabelas n-dimensionais
+# Todos os elementos devem ser do mesmo tipo
+# Você pode fazer uma tabela bidimensional (como uma 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
+# Você pode usar array para fazer matrizes tridimensionais também
+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 (MULTIDIMENSIONAIS, POSSIVELMENTE IMPERFEITAS, DE DIFERENTES TIPOS)
+
+# Finalmente, R tem listas (de vetores)
+lista1 <- list(tempo = 1:40)
+lista1$preco = c(rnorm(40,.5*lista1$tempo,4)) # aleatória
+lista1
+# Você pode obter itens na lista assim
+lista1$tempo # um modo
+lista1[["tempo"]] # um outro modo
+lista1[[1]] # e ainda um outro modo
+#  [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
+# Você pode obter itens de uma lista como qualquer outro vetor
+lista1$preco[4]
+
+# Listas não são a estrutura de dados mais eficiente para se trabalhar em R;
+# a menos que você tenha um bom motivo, você deve se ater a data.frames
+# As listas geralmente são retornadas por funções que realizam regressões lineares
+
+##################################################
+# A família de funções apply()
+##################################################
+
+# Lembra de mat?
+mat
+#      [,1] [,2]
+# [1,]    1    4
+# [2,]    2    5
+# [3,]    3    6
+# Use apply(X, MARGIN, FUN) para aplicar a função FUN a uma matriz X
+# sobre linhas (MARGIN = 1) ou colunas (MARGIN = 2)
+# Ou seja, R faz FUN para cada linha (ou coluna) de X, muito mais rápido que um
+# laço for ou while faria
+apply(mat, MAR = 2, jiggle)
+#      [,1] [,2]
+# [1,]    3   15
+# [2,]    7   19
+# [3,]   11   23
+# Outras funções: ?lappy, ?sapply
+
+# Não as deixe te intimidar; todos concordam que essas funções são bem confusas
+
+# O pacote plyr visa substituir (e melhorar!) a família *apply().
+install.packages("plyr")
+require(plyr)
+?plyr
+
+
+
+#########################
+# Carregando dados
+#########################
+
+# "pets.csv" é um arquivo hospedado na internet
+# (mas também poderia tranquilamente ser um arquivo no seu computador)
+require(RCurl)
+pets <- read.csv(textConnection(getURL("https://learnxinyminutes.com/docs/pets.csv")))
+pets
+head(pets, 2) # primeiras duas linhas
+tail(pets, 1) # última linha
+
+# Para salvar um data frame ou matriz como um arquivo .csv:
+write.csv(pets, "pets2.csv") # para criar um novo arquivo .csv
+# Define o diretório de trabalho com setwd(), confirme em qual você está com getwd()
+
+# Experimente ?read.csv e ?write.csv para obter mais informações
+
+
+
+#########################
+# Análise estatística
+#########################
+
+# Regressão linear!
+modeloLinear <- lm(preco  ~ tempo, data = lista1)
+modeloLinear # imprime na tela o resultado da regressão
+# Call:
+# lm(formula = preco ~ tempo, data = lista1)
+# 
+# Coefficients:
+# (Intercept)        tempo  
+#      0.1453       0.4943  
+summary(modeloLinear) # saída mais detalhada da regressão
+# Call:
+# lm(formula = preco ~ tempo, data = lista1)
+#
+# Residuals:
+#     Min      1Q  Median      3Q     Max 
+# -8.3134 -3.0131 -0.3606  2.8016 10.3992 
+#
+# Coefficients:
+#             Estimate Std. Error t value Pr(>|t|)    
+# (Intercept)  0.14527    1.50084   0.097    0.923    
+# tempo        0.49435    0.06379   7.749 2.44e-09 ***
+# ---
+# Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
+#
+# Residual standard error: 4.657 on 38 degrees of freedom
+# Multiple R-squared:  0.6124,	Adjusted R-squared:  0.6022 
+# F-statistic: 60.05 on 1 and 38 DF,  p-value: 2.44e-09
+coef(modeloLinear) # extrai os parâmetros estimados
+# (Intercept)       tempo 
+#   0.1452662   0.4943490 
+summary(modeloLinear)$coefficients # um outro meio de extrair os resultados
+#              Estimate Std. Error    t value     Pr(>|t|)
+# (Intercept) 0.1452662 1.50084246 0.09678975 9.234021e-01
+# tempo       0.4943490 0.06379348 7.74920901 2.440008e-09
+summary(modeloLinear)$coefficients[,4] # the p-values 
+#  (Intercept)        tempo
+# 9.234021e-01 2.440008e-09 
+
+# MODELOS LINEARES GERAIS
+# Regressão logística
+set.seed(1)
+lista1$sucesso = rbinom(length(lista1$tempo), 1, .5) # binário aleatório
+modeloLg <- glm(sucesso  ~ tempo, data = lista1, 
+	family=binomial(link="logit"))
+modeloLg # imprime na tela o resultado da regressão logística
+# Call:  glm(formula = sucesso ~ tempo, 
+#	family = binomial(link = "logit"), data = lista1)
+#
+# Coefficients:
+# (Intercept)        tempo  
+#     0.17018     -0.01321  
+# 
+# Degrees of Freedom: 39 Total (i.e. Null);  38 Residual
+# Null Deviance:	    55.35 
+# Residual Deviance: 55.12 	 AIC: 59.12
+summary(modeloLg) # saída mais detalhada da regressão
+# Call:
+# glm(formula = sucesso ~ tempo, 
+#	family = binomial(link = "logit"), data = lista1)
+
+# Deviance Residuals: 
+#    Min      1Q  Median      3Q     Max  
+# -1.245  -1.118  -1.035   1.202   1.327  
+# 
+# Coefficients:
+#             Estimate Std. Error z value Pr(>|z|)
+# (Intercept)  0.17018    0.64621   0.263    0.792
+# tempo       -0.01321    0.02757  -0.479    0.632
+# 
+# (Dispersion parameter for binomial family taken to be 1)
+#
+#     Null deviance: 55.352  on 39  degrees of freedom
+# Residual deviance: 55.121  on 38  degrees of freedom
+# AIC: 59.121
+# 
+# Number of Fisher Scoring iterations: 3
+
+
+#########################
+# Gráficos
+#########################
+
+# FUNÇÕES DE PLOTAGEM INTEGRADAS
+# Gráficos de dispersão!
+plot(lista1$tempo, lista1$preco, main = "dados falsos")
+# Trace a linha de regressão em um gráfico existente!
+abline(modeloLinear, col = "red")
+# Obtenha uma variedade de diagnósticos legais
+plot(modeloLinear)
+# Histogramas!
+hist(rpois(n = 10000, lambda = 5), col = "thistle")
+# Gráficos de barras!
+barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
+
+# GGPLOT2
+# Mas estes não são nem os mais bonitos dos gráficos no R
+# Experimente o pacote ggplot2 para gráficos diferentes e mais bonitos
+install.packages("ggplot2")
+require(ggplot2)
+?ggplot2
+pp <- ggplot(estudantes, aes(x=casa))
+pp + geom_bar()
+ll <- as.data.table(lista1)
+pp <- ggplot(ll, aes(x=tempo,preco))
+pp + geom_point()
+# ggplot2 tem uma excelente documentação (disponível em http://docs.ggplot2.org/current/)
+
+
+
+```
+
+## Como faço para obter R?
+
+* Obtenha o R e uma interface gráfica para o R em [http://www.r-project.org/](http://www.r-project.org/)
+* [RStudio](http://www.rstudio.com/ide/) é uma outra interface gráfica
diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown
index b2bab214..1080baa4 100644
--- a/pt-br/rust-pt.html.markdown
+++ b/pt-br/rust-pt.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 filename: rust-pt.rs
 contributors:
     - ["Paulo Henrique Rodrigues Pinheiro", "https://about.me/paulohrpinheiro"]
@@ -234,7 +234,7 @@ fn main() {
 
     // `for` laços de repetição/iteração
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
@@ -329,4 +329,3 @@ 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/pt-br/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
index 28df3c59..e5175857 100644
--- a/pt-br/sass-pt.html.markdown
+++ b/pt-br/sass-pt.html.markdown
@@ -4,6 +4,7 @@ filename: learnsass-pt.scss
 contributors:
   - ["Laura Kyle", "https://github.com/LauraNK"]
   - ["Sean Corrales", "https://github.com/droidenator"]
+  - ["Thalles Augusto", "https://github.com/Theslladev"]
 translators:
   - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
   - ["Cássio Böck", "https://github.com/cassiobsilva"]
@@ -16,7 +17,7 @@ Sass (e outros pré-processadores, como [Less](http://lesscss.org/)) ajudam os d
 Sass tem duas opções de sintaxe diferentes para escolher. SCSS, que tem a mesma sintaxe de CSS, mas com os recursos adicionais de Sass. Ou Sass (a sintaxe original), que usa o recuo, em vez de chaves e ponto e vírgula.
 Este tutorial é escrito usando SCSS.
 
-Se você já está familiarizado com CSS3, você será capaz de pegar Sass de forma relativamente rápida. Ele não fornece quaisquer novas opções de estilo, mas sim as ferramentas para escrever sua CSS de forma mais eficiente e fazer a manutenção mais fácilmente.
+Se você já está familiarizado com CSS3, você será capaz de pegar Sass de forma relativamente rápida. Ele não fornece quaisquer novas opções de estilo, mas sim as ferramentas para escrever sua CSS de forma mais eficiente e fazer a manutenção mais facilmente.
 
 ```scss
 
@@ -249,7 +250,7 @@ ul {
 /* '&' será substituído pelo selector pai (parent). */
 /* Você também pode aninhar pseudo-classes. */
 /* Tenha em mente que o excesso de nidificação vai fazer seu código menos sustentável.
-Essas práticas também recomendam não vai mais de 3 níveis de profundidade quando nidificação.
+Essas práticas também recomendam não mais de 3 níveis de profundidade quando nidificação.
 Por exemplo: */
 
 
@@ -379,7 +380,7 @@ body {
 
 /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
    ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
-   de usar valores que você já calculados manualmente. O exemplo abaixo é
+   de usar valores que você já calcula manualmente. O exemplo abaixo é
    de um projeto simples de duas colunas. */
 
 $content-area: 960px;
diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown
index eb821474..0fadf58d 100644
--- a/pt-br/self-pt.html.markdown
+++ b/pt-br/self-pt.html.markdown
@@ -117,6 +117,7 @@ Múltiplas expressões são separadas por ponto final. ^ retorna imediatamente.
 ```
 
 Blocos são realizados (completados) ao enviá-los a mensagem 'value' e herdando (imcumbir a) seus contextos:
+
 ```
 "retorna 0"
 [|x|
diff --git a/pt-br/set-theory-pt.html.markdown b/pt-br/set-theory-pt.html.markdown
new file mode 100644
index 00000000..58fd7979
--- /dev/null
+++ b/pt-br/set-theory-pt.html.markdown
@@ -0,0 +1,129 @@
+---
+category: Algorithms & Data Structures
+name: Set theory
+lang: pt-br
+contributors:
+    - ["Andrew Ryan Davis", "https://github.com/AndrewDavis1191"]
+translators:
+    - ["Bárbara Luz", "https://github.com/barbluz"]
+---
+
+Teoria de conjuntos é uma área da matemática que estuda conjuntos, suas operações e propriedades.
+- Um conjunto é uma coleção de itens disjuntos.
+
+## Símbolos básicos
+
+### Operações
+- a operação de união `∪`, significa "ou"
+- a operação de interseção `∩`, que significa "e"
+- a operação de exclusão `\`, significa "sem" ou "menos"
+- a operação de conjunto complementar `'`, que significa "o inverso de"
+- a operação de produto cartesiano `×`,que significa "o produto cartesiano de"
+
+### Outros símbolos
+- `:` ou `|`, símbolos que significam "tal que"
+- o símbolo de pertencimento `∈`, que significa "pertence a"
+- o símbolo `⊆`, que significa "subconjunto de" (neste caso, o subconjunto pode ser igual ao conjunto)
+- o símbolo `⊂`, que significa "subconjunto próprio" (neste caso, o subconjunto não pode ser igual ao conjunto)
+
+### Conjuntos canônicos
+- `∅`, o conjunto vazio, isto é, o conjunto que não possui itens
+- `ℕ`, o conjunto de todos os números naturais
+- `ℤ`, o conjunto de todos os números inteiros
+- `ℚ`, o conjunto de todos os números racionais
+- `�`, o conjunto de todos os números reais
+
+Existem algumas ressalvas sobre os conjuntos canônicos:
+- Apesar de o conjunto vazio não conter itens, o conjunto vazio é subconjunto de si mesmo (e portanto de todos os outros conjuntos)
+- Matemáticos geralmente não concordam sobre o zero ser um número natural e os livros tipicamente explicitam se o autor considera ou não o zero como um número natural
+
+
+### Cardinalidade
+A cardinalidade (ou tamanho) de um conjunto é determinado pela quantidade de itens no conjunto. O operador de cardinalidade é `|...|`
+
+Por exemplo, se `S = {1, 2, 4}`, então `|S| = 3`.
+
+### O Conjunto Vazio
+- o conjunto vazio pode ser contruído em notação de conjuntos utilizando condições impossíveis, como por exemplo: `∅ = { x : x ≠ x }`, ou `∅ = { x : x ∈ N, x < 0 }`
+- o conjunto vazio é sempre único (ou seja, existe um e apenas um conjunto vazio)
+- o conjunto vazio é subconjunto de todos os conjuntos
+- a cardinalidade do conjunto vazio é `0`, ou seja, `|∅| = 0`.
+
+## Representando conjuntos
+
+### Definição Literal
+Um conjunto pode ser contruído literalmente fornecendo uma lista completa dos itens contigos no conjunto. Por exemplo `S = { a, b, c, d }`
+
+Listas longas podem ser encurtadas com reticências, desde que o contexto seja claro. Por exemplo, `E = { 2, 4, 6, 8, ... }` é claramente o conjunto de todos os números pares, contendo um número infinito de objetos, embora só tenhamos escrito explicitamente quatro deles.
+
+### Definição por compreensão
+Conjuntos também podem ser descritos de uma maneira mais descritiva, baseando-se em sujeito e predicado, de forma tal que `S = {sujeito : predicado}`. Por exemplo:
+
+```
+A = { x : x é uma vogal } = { a, e, i, o, u }         (lê-se x, tal que x é uma vogal)
+B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+Ou pode-se também aplicar uma função ao sujeito, ex:
+```
+D = { 2x : x ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+## Relações
+
+### Pertencimento
+- Se um valor `a` está contido num conjunto `A`, então dizemos que `a` pertence a `A` e denotamos por `a ∈ A`
+- Se o valor `a` não está contido no conjunto `A`, então dizemos que `a` não pertence a `A` e denotamos por `a ∉ A`
+
+### Igualdade
+- Se dois conjuntos contém os mesmos itens, então dizemos que os conjuntos são iguals, ex. `A = B`
+- A ordenação não importa quando vamos avaliar a igualdade, ex: `{ 1, 2, 3, 4 } = { 2, 3, 1, 4 }`
+- Conjuntos são disjuntos, o que significa que os elementos não podem ser repetidos, ex: `{ 1, 2, 2, 3, 4, 3, 4, 2 } = { 1, 2, 3, 4 }`
+- Dois conjuntos `A` e `B` são iguais se, e somente se, `A ⊆ B` e `B ⊆ A`
+
+### Conjuntos especiais
+O Conjunto das Partes
+- Seja `A` um conjunto qualquer. O conjunto que contém todos os possíveis subconjuntos de `A` é chamado "conjunto das partes" e é denotado como `P(A)`. Se o conjunto `A` contém `n` elementos, então o conjunto das partes conterá `2^n` elementos.
+```
+P(A) = { x : x ⊆ A }
+```
+
+## Operações entre dois conjuntos
+
+### União
+Dados dois conjuntos `A` e `B`, a união entre esses dois conjuntos são os itens que aparecem em `A` ou em `B`, denotado por `A ∪ B`.
+
+```
+A ∪ B = { x : x ∈ A ∪ x ∈ B }
+```
+
+### Interseção
+Dados dois conjuntos `A` e `B`, a interseção entre esses dois conjuntos são os itens que aparecem em `A` e em `B`, denotado por `A ∩ B`.
+
+```
+A ∩ B = { x : x ∈ A, x ∈ B }
+```
+
+### Diferença
+Dados dois conjuntos `A` e `B`, o conjunto da diferença entre `A` e `B` são todos os itens de `A` que não pertencem a `B`.
+```
+A \ B = { x : x ∈ A, x ∉ B }
+```
+
+### Diferença simétrica
+Dados dois conjuntos `A` e `B`, a diferença simétrica são todos os itens entre `A` e `B` que não aparecem na interseção desses dois conjuntos.
+
+```
+A △ B = { x : ((x ∈ A) ∩ (x ∉ B)) ∪ ((x ∈ B) ∩ (x ∉ A)) }
+
+A △ B = (A \ B) ∪ (B \ A)
+```
+
+### Produto Cartesiano
+Dados dois conjuntos `A` e `B`, o produto cartesiano de `A` e `B` consiste no conjunto contendo todas as combinações dos itens de `A` e `B`.
+```
+A × B = { (x, y) | x ∈ A, y ∈ B }
+```
+
+
diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
index d4555fa7..c77ff298 100644
--- a/pt-br/solidity-pt.html.markdown
+++ b/pt-br/solidity-pt.html.markdown
@@ -259,7 +259,7 @@ nomes.length; // pega o tamanho
 nomes.length = 1; // tamanhos pode ser alterados (para arrays dinâmicos)
 
 // arrays multidimensionais
-uint x[][5]; // array com 5 arrays dinâmicos como elementos (ordem da maioria
+uint[][5] x; // array com 5 arrays dinâmicos como elementos (ordem da maioria
 // das linguagens)
 
 // Dicionários (qualquer tipo para qualquer tipo)
diff --git a/pt-br/sql-pt.html.markdown b/pt-br/sql-pt.html.markdown
new file mode 100644
index 00000000..0e4631a6
--- /dev/null
+++ b/pt-br/sql-pt.html.markdown
@@ -0,0 +1,119 @@
+---
+language: SQL
+filename: learnsql-pt.sql
+contributors:
+  - ["Bob DuCharme", "http://bobdc.com/"]
+translators:
+  - ["jovinoguerrero", "https://github.com/jovinoguerrero"]
+lang: pt-br
+---
+
+A linguagem de consulta estruturada (SQL em inglês) é uma linguagem padrão ISO para criar e trabalhar com bancos de dados armazenados num conjunto de tabelas. As implementações geralmente adicionam suas próprias extensões à linguagem; [Comparação entre diferentes implementações de SQL](http://troels.arvin.dk/db/rdbms/) é uma boa referência sobre as diferenças entre os diferentes produtos.
+
+As implementações normalmente fornecem uma linha de comando onde se pode digitar os comandos mostrados aqui de forma interativa, e também oferecem uma maneira de executar uma série desses comandos armazenados em um arquivo de script (mostrar que é feito com o prompt interativo é um bom exemplo de algo que não é padronizado - a maioria das implementações SQL suporta as palavras-chave QUIT, EXIT ou ambas).
+
+Vários desses comandos de exemplo assumem que o [banco de dados de funcionários de exemplo MySQL](https://dev.mysql.com/doc/employee/en/) disponível em [github](https://github.com/datacharmer/test_db) já foi carregado. Os arquivos do GitHub são scripts de comandos, semelhantes aos comandos abaixo, que criam e carregam tabelas de dados sobre os funcionários de uma empresa fictícia. A sintaxe para executar esses scripts dependerá da implementação SQL que você está usando. Um aplicativo executado a partir do prompt do sistema operacional geralmente é o normal.
+
+
+```sql
+-- Os comentários começam com dois hífens. Cada comando é encerrado com um
+-- ponto e vírgula.
+
+-- SQL não diferencia maiúsculas de minúsculas em palavras-chave. Os
+-- comandos de exemplo mostrados aqui seguem a convenção de serem escritos
+-- em maiúsculas porque torna mais fácil distingui-los dos nomes dos bancos
+-- de dados, tabelas e colunas.
+
+-- Em seguida, um banco de dados é criado e excluído. Os nomes do banco de
+-- dados e da tabela são sensíveis a maiúsculas de minúsculas.
+CREATE DATABASE someDatabase;
+DROP DATABASE someDatabase;
+
+-- Mostra numa lista todos os bancos de dados disponíveis.
+SHOW DATABASES;
+
+-- Usa um determinado banco de dados existente.
+USE employees;
+
+-- Seleciona todas as filas e colunas da tabela de departamentos no banco
+-- de dados atual. A atividade padrão é o intérprete rolar os resultados
+-- na tela.
+SELECT * FROM departments;
+
+-- Recupera todas as filas da tabela de departamentos, mas apenas as colunas
+-- dept_no e dept_name.
+-- A separação de comandos em várias linhas é permitida.
+SELECT dept_no,
+       dept_name FROM departments;
+
+-- Obtém todas as colunas de departments, mas é limitado a 5 filas.
+SELECT * FROM departments LIMIT 5;
+
+-- Obtém os valores da coluna dept_name da tabela de departments quando
+-- dept_name tem como valor a substring 'en'.
+SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
+
+-- Recupera todas as colunas da tabela de departments onde a coluna
+-- dept_name começa com um 'S' e tem exatamente 4 caracteres depois dele.
+SELECT * FROM departments WHERE dept_name LIKE 'S____';
+
+-- Seleciona os valores dos títulos da tabela de titles, mas não mostra
+-- duplicatas.
+SELECT DISTINCT title FROM titles;
+
+-- Igual ao anterior, mas ordenado por valores de da coluna title (diferencia
+-- maiúsculas de minúsculas).
+SELECT DISTINCT title FROM titles ORDER BY title;
+
+-- Mostra o número de filas da tabela departments.
+SELECT COUNT(*) FROM departments;
+
+-- Mostra o número de filas da tabela departments que contém 'en' como
+-- substring na coluna dept_name.
+SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
+
+-- Uma união (JOIN) de informações de várias tabelas: a tabela titles mostra
+-- quem tem quais cargos laborais, de acordo com seu número de funcionários,
+-- e desde que data até que data. Esta informação é obtida, mas em vez do
+-- número do funcionário é usada como referência cruzada a tabela employee
+-- para obter o nome e sobrenome de cada funcionário (e limita os resultados
+--  a 10 filas).
+SELECT employees.first_name, employees.last_name,
+       titles.title, titles.from_date, titles.to_date
+FROM titles INNER JOIN employees ON
+       employees.emp_no = titles.emp_no LIMIT 10;
+
+-- São listadas todas as tabelas de todas os bancos de dados. As implementações
+-- normalmente fornecem seus próprios comandos para fazer isso com o banco de
+-- dados atualmente em uso.
+SELECT * FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE='BASE TABLE';
+
+-- Cria uma tabela chamada tablename1, com as duas colunas mostradas, a partir
+-- do banco de dados em uso. Há muitas outras opções dísponiveis para a forma
+-- em que se especificam as colunas, por ex. seus tipos de dados.
+CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
+
+-- Insere uma fila de dados na tabela tablename1. É assumido que a tabela foi
+-- definida para aceitar esses valores como adequados.
+INSERT INTO tablename1 VALUES('Richard','Mutt');
+
+-- Em tablename1, se altera o valor de fname para 'John' em todas as filas que
+-- contenham um valor em lname igual a 'Mutt'.
+UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
+
+-- Se excluem as filas da tabela tablename1 em que o valor de lname começa
+-- com 'M'.
+DELETE FROM tablename1 WHERE lname like 'M%';
+
+-- Se excluem as filas da tabela tablename1, deixando a tabla vazia.
+DELETE FROM tablename1;
+
+-- A tabela tablename1, é excluída completamente.
+DROP TABLE tablename1;
+```
+
+# Leitura adicional
+
+* [Codecademy - SQL](https://www.codecademy.com/learn/learn-sql) A good introduction to SQL in a “learn by doing it� format.
+* [Database System Concepts](https://www.db-book.com/) book’s Chapter 3 - Introduction to SQL has an in depth explanation of SQL concepts.
diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown
index 40c3c02c..40c3c02c 100755..100644
--- a/pt-br/stylus-pt.html.markdown
+++ b/pt-br/stylus-pt.html.markdown
diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
index ce3be407..e2130e0a 100644
--- a/pt-br/tmux-pt.html.markdown
+++ b/pt-br/tmux-pt.html.markdown
@@ -59,47 +59,49 @@ As seções tmux acopladas são controladas através de teclas de atalho. (prefi
 ----------------------------------------------------------------------
   (C-b) = Ctrl + b    # Abre a opção de receber comandos(atalhos).
 
-  (M-1) = Meta + 1 -or- Alt + 1
+  (M-1) = Meta + 1 -ou- Alt + 1
 ----------------------------------------------------------------------
 
-  ?           # Lista todos os comandos.
-  :           # Acessa o prompt command do tmux
-  r           # Força a reinicialização do cliente acoplado.
-  c           # Cria uma nova janela.
+  ?                  # Lista todos os comandos.
+  :                  # Acessa o prompt command do tmux
+  r                  # Força a reinicialização do cliente acoplado.
+  c                  # Cria uma nova janela.
 
-  !           # 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.
+  !                  # 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           # Muda para a próxima janela.
-  p           # Muda para a janela anterior.
-  {           # Troca o painel atual pelo anterior.
-  }           # Troca o painel corrent pelo posterior.
+  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.
+  [                  # Entra no modo cópia (Copy Mode) para copiar texto ou ver o histórico.
 
-  s           # Seleciona uma nova seção para o cliente acoplado 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.
+  s                  # Seleciona uma nova seção para o cliente acoplado iterativamente.
+  w                  # Seleciona a janela atual iterativamente.
+  0 to 9             # Seleciona a janela de 0 à 9.
 
-  &           # Encerra a janela atual.
-  x           # Encerra o painel atual.
+  d                  # Separa o cliente atual.
+  D                  # Seleciona um cliente a ser separado.
 
-  Up, Down    # Move para o painel acima, abaixo, a esquerda ou a direita.
+  &                  # Encerra a janela atual.
+  x                  # Encerra o painel atual.
+
+  Up, Down           # Move para o painel acima, abaixo, a esquerda ou a direita.
   Left, Right
 
-  M-1 to M-5  # Organiza os paines:
+  M-1 to M-5         # Organiza os paines:
                        # 1) Horizontalmente de maneira igual
                        # 2) Verticalmente de maineira igual.
                        # 3) Principal horizontalmente
                        # 4) Principal verticamente.
                        # 5) Mosaico
 
-  C-Up, C-Down    # Altera o tamanho do painel atual 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 atual em cinco células.
+  M-Up, M-Down       # Altera o tamanho do painel atual em cinco células.
   M-Left, M-Right
 
 ```
diff --git a/pt-br/toml-pt.html.markdown b/pt-br/toml-pt.html.markdown
new file mode 100644
index 00000000..bdb1decf
--- /dev/null
+++ b/pt-br/toml-pt.html.markdown
@@ -0,0 +1,232 @@
+---
+language: toml
+filename: learntoml-pt.toml
+contributors:
+  - ["Alois de Gouvello", "https://github.com/aloisdg"]
+translators:
+  - ["Adaías Magdiel", "https://adaiasmagdiel.com/"]
+lang: pt-br
+---
+
+TOML significa Tom's Obvious, Minimal Language. É uma linguagem de serialização de dados projetada para ser um formato de arquivo de configuração mínimo que é fácil de ler devido à semântica óbvia.
+
+É uma alternativa ao YAML e JSON. Tem como objetivo ser mais amigável para humanos do que JSON e mais simples que YAML. TOML é projetado para mapear de forma inequívoca para uma tabela de hash e deve ser fácil de converter em estruturas de dados em uma ampla variedade de linguagens.
+
+Cuidado, a especificação do TOML ainda passa por muitas mudanças. Até que seja marcado como 1.0, você deve assumir que é instável e agir de acordo. Este documento segue o TOML v0.4.0.
+
+```toml
+# Comentários em TOML são feitos desta forma.
+
+###################
+# TIPOS ESCALARES #
+###################
+
+# Nosso objeto raiz (que continuará por todo o documento) será um mapa,
+# que é equivalente a um dicionário, hash ou objeto em outras linguagens.
+
+# A chave, o sinal de igual e o valor precisam estar na mesma linha
+# (embora alguns valores possam ser quebrados em várias linhas).
+chave = "valor"
+string = "Olá"
+number = 42
+float = 3.14
+boolean = true
+dateTime = 2002-07-16T20:32:00-03:00
+scientificNotation = 1e+12
+"chaves podem estar entre aspas" = true # Tanto " quanto ' são aceitáveis
+"chaves podem conter" = "letras, números, underscores e hífens"
+
+# Uma chave não pode ser vazia, mas uma chave vazia entre aspas é permitido
+"" = "blank" # V�LIDO mas não é recomendado
+'' = 'blank' # V�LIDO mas não é recomendado
+
+##########
+# String #
+##########
+
+# Todas as strings precisam ter apenas caracteres UTF-8 válidos.
+# Podemos escapar caracteres e alguns deles têm uma sequência de escape compacta.
+# Por exemplo: \t adiciona uma tabulação. Leia a spec para conhecer todos.
+basicString = "São cercadas por aspas. \"Sou digno de citação\". Nome\tJosé."
+
+multiLineString = """
+são cercadas por três aspas
+em cada lado e permitem novas linhas."""
+
+literalString = 'são cercadas por aspas simples. Escape de caracteres não é permitido.'
+
+multiLineString = '''
+são cercadas por três aspas simples em cada lado
+e permitem novas linhas. Escape de caracteres também não é permitido.
+A primeira quebra de linha é removida em strings brutas
+   Todo outro espaço em branco
+   é preservado. #! foi preservado?
+'''
+
+# Para dados binários é recomendado que você use Base64, outra codificação ASCII ou UTF8.
+# A manipulação dessa codificação será específico da aplicação.
+
+############
+# Inteiros #
+############
+
+## Inteiros podem começar com um +, um -, ou nada.
+## Zeros à frente não são permitidos.
+## Formatos em hexadecimal, octal e binário são permitidos.
+## Não são permitidos valores que não podem ser expressados como uma série de dígitos.
+int1 = +42
+int2 = 0
+int3 = -21
+int4 = 0xcafebabe
+int5 = 0o755
+int6 = 0b11011100
+integerRange = 64
+
+## Você pode usar underscores para melhorar a legibilidade.
+## Cada underscore precisa estar entre, pelo menos, um dígito.
+int7 = 5_349_221
+int8 = 1_2_3_4_5     # V�LIDO, mas não é recomendado
+
+#########
+# Float #
+#########
+
+# Floats são inteiros seguidos por uma fração e/ou de um expoente.
+flt1 = 3.1415
+flt2 = -5e6
+flt3 = 6.626E-34
+
+#############
+# Booleanos #
+#############
+
+bool1 = true
+bool2 = false
+booleanosPrecisamEstarEmMinusculo = true
+
+############
+# Datetime #
+############
+
+date1 = 1979-05-27T07:32:00Z # Tempo UTC, seguindo especificação RFC 3339/ISO 8601
+date2 = 1979-05-26T15:32:00+08:00 # com um deslocamento segundo a RFC 3339/ISO 8601
+date3 = 1979-05-27T07:32:00 # sem deslocamento
+date4 = 1979-05-27 # sem as horas e sem deslocamento
+
+####################
+# TIPOS DE COLEÇÃO #
+####################
+
+#########
+# Array #
+#########
+
+array1 = [ 1, 2, 3 ]
+array2 = [ "Vírgulas", "são", "delimitadores" ]
+array3 = [ "Não misture", "tipos", "diferentes" ]
+array4 = [ [ 1.2, 2.4 ], ["todas as", 'strings', """são do mesmo""", '''tipo'''] ]
+array5 = [
+  "Espaços em branco", "são", "ignorados"
+]
+
+##########
+# Tabela #
+##########
+
+# Tabelas (ou tabelas de hash, ou dicionários) é uma coleção de pares chave/valor.
+# Eles aparecem entre colchetes em uma linha separada.
+# Tabelas vazias são permitidas e simplesmente não possuem chave/valor associado.
+[tabela]
+
+# Abaixo disso, e até a próxima tabela ou final do arquivo, estão as chaves/valores dessa tabela.
+# Os pares de chave/valor dentro das tabelas não têm garantia de estar em nenhuma ordem específica.
+[table-1]
+chave1 = "algum texto"
+chave2 = 123
+
+[table-2]
+chave1 = "outro texto"
+chave2 = 456
+
+# Pontos são proibidos em chaves simples porque são usados para indicar tabelas aninhadas.
+# As regras de nomenclatura para cada parte separada por ponto são as mesmas que para chaves.
+[dog."tater.man"]
+type = "pug"
+
+# Na terra do JSON, você teria a seguinte estrutura:
+# { "dog": { "tater.man": { "type": "pug" } } }
+
+# Espaços em branco em torno das partes separadas por pontos são ignorados, de qualquer forma,
+# é sempre recomendado não utilizar espaços em branco desnecessários.
+[a.b.c]            # isso é o recomendado
+[ d.e.f ]          # mesmo que [d.e.f]
+[ j . "Êž" . 'l' ]  # mesmo que [j."Êž".'l']
+
+# Você não precisa especificar todas as super-tabelas se não quiser. TOML sabe
+# como lidar com isso para você.
+# [x] você
+# [x.y] não precisa
+# [x.y.z] disso
+[x.y.z.w] # para isso funcionar
+
+# Mesmo que uma super-tabela não tenha sido definida diretamente e não tenha definido uma
+# chave específica, ainda é possível escrever nela.
+[a.b]
+c = 1
+
+[a]
+d = 2
+
+# Irá gerar o seguinte JSON:
+# { "a": {"b": {"c": 1}, "d": 2 } }
+
+# Você não pode definir uma chave ou tabela mais de uma vez. É inválido fazer isso.
+
+# NÃO FAÇA ISSO
+[a]
+b = 1
+
+[a]
+c = 2
+
+# NEM MESMO ISSO
+[a]
+b = 1
+
+[a.b]
+c = 2
+
+# O nome de todas as tabelas não pode ser vazio.
+[]     # INV�LIDO
+[a.]   # INV�LIDO
+[a..b] # INV�LIDO
+[.b]   # INV�LIDO
+[.]    # INV�LIDO
+
+####################
+# Tabelas em linha #
+####################
+
+tabelasEmLinha = { sãoFechadasCom = "{ e }", precisamEstarEmUmaLinha = true }
+ponto = { x = 1, y = 2 }
+
+####################
+# Array de Tabelas #
+####################
+
+# Um array de tabelas pode ser expresso usando um nome de tabela entre colchetes duplos.
+# Cada tabela com o mesmo nome entre colchetes duplos será um item no array.
+# As tabelas são inseridas na ordem em que são encontradas.
+
+[[produtos]]
+nome = "array de tabelas"
+sku = 738594937
+tabelasVaziasSaoPermitidas = true
+
+[[produtos]]
+
+[[produtos]]
+nome = "Unhas"
+sku = 284758393
+color = "cinza"
+```
diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
index 2a7205cd..dcc72c04 100644
--- a/pt-br/visualbasic-pt.html.markdown
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -8,7 +8,7 @@ lang: pt-br
 filename: learnvisualbasic-pt.vb
 ---
 
-```
+```visualbasic
 Module Module1
 
 module Module1
@@ -28,12 +28,12 @@ module Module1
         Console.WriteLine ("2. Entrada Olá Mundo" )
         Console.WriteLine ("3. Cálculando números inteiros " )
         Console.WriteLine ("4. Calculando números decimais " )
-        Console.WriteLine ("5 . Calculadora de Trabalho " )
+        Console.WriteLine ("5. Calculadora de Trabalho " )
         Console.WriteLine ("6. Usando Do While Loops " )
         Console.WriteLine ("7. Usando Para While Loops " )
-        Console.WriteLine ("8 . Declarações condicionais " )
+        Console.WriteLine ("8. Declarações condicionais " )
         Console.WriteLine ("9. Selecione uma bebida" )
-        Console.WriteLine ("50 . About" )
+        Console.WriteLine ("50. About" )
         Console.WriteLine ("Por favor, escolha um número da lista acima " )
         Seleção Dim As String = Console.ReadLine
         Select A seleção dos casos
@@ -76,7 +76,7 @@ module Module1
     End Sub
 
     ' Um - Eu estou usando números para ajudar com a navegação acima quando eu voltar
-    ' depois de construí-lo .
+    ' depois de construí-lo.
 
     " Nós usamos subs privadas para separar diferentes seções do programa.
     Private Sub HelloWorldOutput ()
@@ -94,12 +94,12 @@ module Module1
         Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes"
         ' Variáveis
         'Os dados inseridos por um usuário precisam ser armazenados.
-        ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType .
+        ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType.
 
         ' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa
         ' Responder ao que é dito.
         Nome de usuário Dim As String
-        " Nós usamos string como string é uma variável de texto baseado .
+        " Nós usamos string como string é uma variável de texto baseado.
         Console.WriteLine (" Olá, Qual é o seu nome? ") ' Peça ao usuário seu nome.
         username = Console.ReadLine () ' armazena o nome do usuário.
         Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >".
@@ -124,10 +124,10 @@ module Module1
     'Quatro
     Sub CalculatingDecimalNumbers particulares ()
         Console.Title = " Calculando com duplo | Saiba X em Y Minutes"
-        ' Claro que gostaria de ser capaz de somar decimais .
+        ' Claro que gostaria de ser capaz de somar decimais.
         " Por isso, poderia mudar o acima de Integer para Double.
 
-        " Digite um número inteiro , 1,2 , 2,4 , 50,1 , 104,9 ect
+        " Digite um número inteiro como 1, 2, 50, 104, etc
         Console.Write ("Primeiro número:")
         Dim a As Double = Console.ReadLine
         Console.Write ("Segundo número:") 'Enter segundo número inteiro.
@@ -141,9 +141,9 @@ module Module1
     ' Cinco
     Private Sub WorkingCalculator ()
         Console.Title = " A Calculadora de Trabalho | Saiba X em Y Minutes"
-        " No entanto, se você gostaria que a calculadora para subtrair, dividir , múltiplos e
+        " No entanto, se você gostaria que a calculadora para subtrair, dividir, múltiplos e
         ' somar.
-        ' Copie e cole o código acima novamente .
+        ' Copie e cole o código acima novamente.
         Console.Write ("Primeiro número:")
         Dim a As Double = Console.ReadLine
         Console.Write ("Segundo número:") 'Enter segundo número inteiro.
@@ -153,7 +153,7 @@ module Module1
         Dim e As Integer = a - b
         Dim f As Integer = a / b
 
-        " Ao adicionar as linhas abaixo , somos capazes de calcular a subtração ,
+        " Ao adicionar as linhas abaixo, somos capazes de calcular a subtração,
         ' multply bem como dividir os valores de a e b
         Console.Gravar ( a.ToString ( ) + " + " + b.ToString ( ) )
         'Queremos pad as respostas para a esquerda por três espaços.
@@ -172,8 +172,8 @@ module Module1
     Sub UsingDoWhileLoops particulares ()
         ' Assim como o sub privado anterior
         ' Desta vez, perguntar se o usuário deseja continuar ( Sim ou Não ? )
-        ' Estamos usando Do While Loop , como não temos certeza se o usuário quer usar o
-        'programa mais de uma vez .
+        ' Estamos usando Do While Loop, como não temos certeza se o usuário quer usar o
+        'programa mais de uma vez.
         Console.Title = " UsingDoWhileLoops | Saiba X em Y Minutes"
         Dim resposta As String ' Nós usamos a variável " String" como a resposta é um texto
         Do ' Começamos o programa com
@@ -195,12 +195,12 @@ module Module1
             Console.Write ( a.ToString () + "/" + b.ToString ())
             Console.WriteLine (" =" + e.ToString.PadLeft (3) )
             Console.ReadLine ()
-            ' Faça a pergunta , se o usuário deseja continuar? Infelizmente,
+            ' Faça a pergunta, se o usuário deseja continuar? Infelizmente,
             "é sensível a maiúsculas.
             Console.Write ( "Deseja continuar? (Sim / não )")
             " O programa pega a variável e imprime e começa de novo.
             answer = Console.ReadLine
-        " O comando para a variável para trabalhar seria , neste caso, " sim "
+        " O comando para a variável para trabalhar seria, neste caso, " sim "
         Loop While resposta = "yes"
 
     End Sub
@@ -233,7 +233,7 @@ module Module1
         outro
             Console.WriteLine (" Olá " + nome do usuário)
             Console.WriteLine (" Você check-out www.learnxinyminutes.com " )
-            Console.ReadLine () ' Fins e imprime a declaração acima .
+            Console.ReadLine () ' Fins e imprime a declaração acima.
         End If
     End Sub
 
@@ -242,15 +242,15 @@ module Module1
     Console.Title = "Se Declaração / Else | Saiba X em Y Minutes"
         'Às vezes é importante ter em conta mais de duas alternativas.
         'Às vezes, há um bom número de outros.
-        'Quando este for o caso , mais do que uma if seria necessária .
-        'Uma instrução if é ótimo para máquinas de venda automática . Quando o usuário digita um código.
-        ' A1 , A2, A3 , ect para selecionar um item.
+        'Quando este for o caso, mais do que uma if seria necessária.
+        'Uma instrução if é ótimo para máquinas de venda automática. Quando o usuário digita um código.
+        ' A1, A2, A3, etc para selecionar um item.
         'Todas as opções podem ser combinadas em uma única if.
 
         Seleção Dim Valor String = Console.ReadLine ' para a seleção
             Console.WriteLine (" A1. Para Soda " )
             Console.WriteLine (" A2. Para Fanta " )
-            Console.WriteLine (" A3 . Para Guaraná" )
+            Console.WriteLine (" A3. Para Guaraná" )
             Console.WriteLine (" A4. Para Coca Diet" )
             Console.ReadLine ()
             Se a seleção = "A1" Então
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 21e9b4bb..b2fb2a7d 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -2,6 +2,7 @@
 language: yaml
 contributors:
   - ["Leigh Brenecki", "https://github.com/adambrenecki"]
+  - [Suhas SG, 'https://github.com/jargnar']
 translators:
   - ["Rodrigo Russo", "https://github.com/rodrigozrusso"]
 filename: learnyaml-pt.yaml
@@ -14,6 +15,8 @@ legível por seres humanos.
 É um superconjunto de JSON, com a adição de identação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
 
 ```yaml
+---  # início do documento
+
 # Comentários em YAML são como este.
 
 ###################
@@ -30,28 +33,32 @@ 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."
+porem: 'Uma string, entre aspas.'
+'Chaves podem estar entre aspas tambem.': "É útil se você quiser colocar um ':' na sua chave."
+aspas simples: 'possuem ''um'' padrão de escape'
+aspas duplas: "possuem vários: \", \0, \t, \u263A, \x0d\x0a == \r\n, e mais."
+# Caracteres UTF-8/16/32 precisam ser codificados
+Superscript dois: \u00B2
 
 # Seqüências de várias linhas podem ser escritas 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.
+  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.
+  O literal continua até 'des-indentar', 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.
+    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.
+  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 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.
+    Linhas 'mais-indentadas' mantém suas novas linhas também -
+    este texto irá aparecer em duas linhas.
 
 ####################
 # TIPOS DE COLEÇÃO #
@@ -59,54 +66,85 @@ estilo_compacto: >
 
 # Texto aninhado é conseguido através de identação.
 um_mapa_aninhado:
-    chave: valor
-    outra_chave: Outro valor
-    outro_mapa_aninhado:
-        ola: ola
+  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.
+# As chaves podem ser complexas, como sequência de várias linhas
+# Utilizando ? seguido por espaço para indicar o começo de uma chave complexa.
 ? |
-    Esta é uma chave
-    que tem várias linhas
+  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.
+# YAML também permite o mapeamento entre sequências com a sintaxe chave complexa
+# Alguns analisadores de linguagem de programação podem reclamar
+# Um exemplo
+? - Manchester United
+  - Real Madrid
+: [2001-01-01, 2002-02-02]
 
 # Sequências (equivalente a listas ou arrays) semelhante a 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
+  - Item 1
+  - Item 2
+  - 0.5 # sequências podem conter tipos diferentes.
+  - Item 4
+  - chave: valor
+    outra_chave: outro_valor
+  -
+    - Esta é uma sequência
+    - dentro de outra sequência
+  - - - Indicadores de sequência aninhadas
+      - podem ser recolhidas
 
 # Como YAML é um super conjunto de JSON, você também pode escrever mapas JSON de estilo e
-# sequencias:
+# sequências:
 mapa_json: {"chave": "valor"}
 json_seq: [3, 2, 1, "decolar"]
+e aspas são opcionais: {chave: [3, 2, 1, decolar]}
 
-##########################
-# RECURSOS EXTRA DO YAML #
-##########################
+###########################
+# RECURSOS EXTRAS 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
+conteudo_ancora: &nome_ancora Essa string irá aparecer como o valor de duas chaves.
+outra_ancora: *nome_ancora
+
+# Âncoras podem ser usadas para dubplicar/herdar propriedades
+base: &base
+  name: Todos possuem o mesmo nome
+
+# O regexp << é chamado Mesclar o Tipo Chave Independente-de-Idioma. É usado para
+# indicar que todas as chaves de um ou mais mapas específicos devam ser inseridos
+# no mapa atual.
+
+foo:
+  <<: *base
+  idade: 10
+
+bar:
+  <<: *base
+  idade: 20
+
+# foo e bar terão o mesmo nome: Todos possuem o mesmo nome
 
 # YAML também tem tags, que você pode usar para declarar explicitamente os tipos.
-string_explicita: !! str 0,5
+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
+numero_complexo_em_python: !!python/complex 1+2j
+
+# Podemos utilizar chaves YAML complexas com tags específicas de linguagem
+? !!python/tuple [5, 7]
+: Fifty Seven
+# Seria {(5, 7): 'Fifty Seven'} em Python
 
 ####################
 # YAML TIPOS EXTRA #
@@ -114,27 +152,34 @@ numero_complexo_em_python: !! python / complex 1 + 2j
 
 # 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
+datetime: 2001-12-15T02:59:43.1Z
+datetime_com_espaços: 2001-12-14 21:59:43.10 -5
+date: 2002-12-14
 
 # A tag !!binary indica que a string é na verdade um base64-encoded (codificado)
 # 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=
+  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
+conjunto:
+  ? item1
+  ? item2
+  ? item3
+ou: {item1, item2, item3}
+
+# Como Python, são apenas conjuntos de mapas com valores nulos; o acima é equivalente a:
+conjunto2:
+  item1: null
+  item2: null
+  item3: null
+
+...  # fim do documento
 ```
+### Mais Recursos
+
++ [Site Oficial do YAML](https://yaml.org/)
++ [Validador YAML Online](http://www.yamllint.com/)
diff --git a/pt-pt/git-pt.html.markdown b/pt-pt/git-pt.html.markdown
index bd0f0fc5..86710a13 100644
--- a/pt-pt/git-pt.html.markdown
+++ b/pt-pt/git-pt.html.markdown
@@ -411,5 +411,3 @@ $ 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)
-
-* [GitGuys](http://www.gitguys.com/)
diff --git a/pt-pt/kotlin-pt.html.markdown b/pt-pt/kotlin-pt.html.markdown
new file mode 100644
index 00000000..47dbb44d
--- /dev/null
+++ b/pt-pt/kotlin-pt.html.markdown
@@ -0,0 +1,473 @@
+---
+language: kotlin
+filename: LearnKotlin-pt.kt
+lang: pt-pt
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators:
+    - ["André Martins", "https://github.com/chriptus13"]
+---
+
+Kotlin é uma linguagem de programação de tipificação estática para a JVM, Android e browser. Ela é 100% interoperável com Java.
+[Lê mais aqui.](https://kotlinlang.org/)
+
+```kotlin
+// Comentários de linha começam com //
+/*
+Comentários de múltiplas linhas são assim.
+*/
+
+// A palavra-chave "package" funciona da mesma forma que em Java.
+package com.learnxinyminutes.kotlin
+
+/*
+O ponto de entrada de um programa em Kotlin é a função chamada "main".
+Esta função tem como único parâmetro um array contendo todos os argumentos passados na linha de comandos.
+Desde a versão 1.3 que esta pode também ser definida sem parâmetros.
+*/
+fun main(args: Array<String>) {
+	/*
+	A declaração de variáveis é feita usando "var" ou "val".
+	Variáveis declaradas com "val" não podem ser redefinidas, já as declaradas com "var" podem.
+	*/
+	val fooVal = 10 // não podemos redefinir mais tarde o valor de fooVal para algo diferente
+	var fooVar = 10
+	fooVar = 20 // fooVar pode ser redefinida
+
+	/*
+	Na maioria dos casos, o Kotlin pode determinar (inferir) o tipo de uma variável,
+	assim não precisamos de o dizer explicitamente sempre.
+	Para especificar o tipo explicitamente fazemos assim:
+	*/
+	val foo: Int = 7
+
+	/*
+	As Strings são representadas de uma forma semelhante ao Java.
+	O escape é feito com barras invertidas.
+	*/
+	val fooString = "A minha String está aqui!"
+	val barString = "Imprimir numa nova linha?\nSem problemas!"
+	val bazString = "Adicionar um tab?\tSem problemas!"
+	println(fooString)
+	println(barString)
+	println(bazString)
+
+	/*
+	Uma raw string é delimitada por aspas triplas (""").
+	Raw strings podem conter caracteres de nova linha ou qualquer outro.
+	*/
+	val fooRawString = """
+fun helloWorld(val name : String) {
+	println("Hello, world!")
+}
+"""
+	println(fooRawString)
+
+	/*
+	As strings podem também conter template expressions.
+	Uma template expression começa com o símbolo do dollar ($).
+	*/
+	val fooTemplateString = "$fooString tem ${fooString.length} caracteres"
+	println(fooTemplateString) // => A minha String está aqui! tem 25 caracteres
+
+	/*
+	Para que uma variável possa ter o valor de null esta tem de ser 
+	especificada explicitamente como nullable.
+	Uma variável pode ser marcada como nullable adicionando um ? ao seu tipo.
+	A variable can be specified as nullable by appending a ? to its type.
+	Usando o operador ?. podemos facilmente aceder a propriedades de 
+	uma variável nullable, se esta for null o resultado da expressão será também ele null.
+	Podemos também usar o operador ?: para especificar um valor alternativo
+	no caso da variavél ser 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
+
+	/*
+	As funções são declaradas usando a palavra-chave "fun".
+	Os parâmetros da função são especificados entre parênteses a seguir ao nome da função.
+	Estes parâmetros podem opcionalmente ter um valor por omissão.
+	O tipo de retorno da função, se necessário, é especificado após os parâmetros.
+	*/
+	fun hello(name: String = "world"): String {
+		return "Hello, $name!"
+	}
+	println(hello("foo")) // => Hello, foo!
+	println(hello(name = "bar")) // => Hello, bar!
+	println(hello()) // => Hello, world!
+
+	/*
+	Para que uma função receba um número variável de parâmetros podemos
+	marcar um, e apenas um, parâmetro com a palavra-chave "vararg".
+	*/
+	fun varargExample(vararg names: Int) {
+		println("Argument has ${names.size} elements")
+	}
+	varargExample() // => A chamada à função tem 0 argumentos
+	varargExample(1) // => A chamada à função tem 1 argumentos
+	varargExample(1, 2, 3) // => A chamada à função tem 3 argumentos
+
+	/*
+	Quando uma função consiste em apenas uma expressão as chavetas podem ser omitidas
+	O corpo da mesma é especificado após o símbolo de igual (=).
+	*/
+	fun odd(x: Int): Boolean = x % 2 == 1
+	println(odd(6)) // => false
+	println(odd(7)) // => true
+
+	// Se o tipo de retorno da função pode ser inferido então não é necessário especificá-lo.
+	fun even(x: Int) = x % 2 == 0
+	println(even(6)) // => true
+	println(even(7)) // => false
+
+	// As funções podem ter outras funções como parâmetros e/ou como retorno.
+	fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+		return {n -> !f.invoke(n)}
+	}
+	// O operador :: pode ser usado para referênciar funções existentes.
+	val notOdd = not(::odd)
+	val notEven = not(::even)
+	/*
+	Expressões lambda podem ser usadas da seguinte forma.
+	Os lambdas quando passados a outras funções podem estar 
+	fora dos parênteses da chamada, caso sejam o último parâmetro.
+	*/
+	val notZero = not {n -> n == 0}
+	/*
+	Se o lambda apenas tiver um parâmetro então a sua
+	declaração pode ser omitida (em conjunto com "->").
+	O nome por omissão do parâmetro será "it".
+	*/
+	val notPositive = not {it > 0}
+	for (i in 0..4) {
+		println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+	}
+
+	// Para declararmos classes usa-se a palavra-chave "class".
+	class ExampleClass(val x: Int) {
+		fun aMethod(y: Int): Int {
+			return x + y
+		}
+
+		infix fun infixMemberFunction(y: Int): Int {
+			return x * y
+		}
+	}
+	/*
+	Para se instanciar uma classe usamos o constructor.
+	De notar que em Kotlin não existe a palavra-chave "new" como no Java.
+	*/
+	val fooExampleClass = ExampleClass(7)
+	// Os métodos da classe podem então ser chamados usando o ponto.
+	println(fooExampleClass.aMethod(4)) // => 11
+	/*
+	Uma função marcada com a palavra-chave "infix" pode ser chamada
+	usando a notação infixa.
+	*/
+	println(fooExampleClass infixMemberFunction 4) // => 28
+
+	/*
+	Data classes são uma forma concisa de criar classes que apenas contêm dados.
+	Neste tipo de classes os métodos "hashCode"/"equals" e "toString" são gerados
+	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)
+
+	// Instâncias deste tipo de classes têm acesso ao método "copy".
+	val fooCopy = fooData.copy(y = 100)
+	println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+	// Os objectos podem ser desconstruídos para variáveis.
+	val (a, b, c) = fooCopy
+	println("$a $b $c") // => 1 100 4
+
+	// desconstrucção dentro de um ciclo "for"
+	for ((a, b, c) in listOf(fooData)) {
+		println("$a $b $c") // => 1 2 4
+	}
+
+	val mapData = mapOf("a" to 1, "b" to 2)
+	// Instâncias de Map.Entry podem também ser desconstruídas.
+	for ((key, value) in mapData) {
+		println("$key -> $value")
+	}
+
+	// A função "with" é semelhante ao bloco "with" do 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)
+
+	/*
+	Podemos criar listas usando a função "listOf".
+	No Kotlin, por padrão, as listas são imútaveis - não podendo 
+	assim adicionar ou remover elementos das mesmas.
+	*/
+	val fooList = listOf("a", "b", "c")
+	println(fooList.size) // => 3
+	println(fooList.first()) // => a
+	println(fooList.last()) // => c
+	// Os elementos de uma lista podem ser acedidos usando o seu índice.
+	println(fooList[1]) // => b
+
+	// Listas mútaveis podem ser criadas usando a função "mutableListOf".
+	val fooMutableList = mutableListOf("a", "b", "c")
+	fooMutableList.add("d")
+	println(fooMutableList.last()) // => d
+	println(fooMutableList.size) // => 4
+
+	// Podemos criar conjuntos usando a função "setOf".
+	val fooSet = setOf("a", "b", "c")
+	println(fooSet.contains("a")) // => true
+	println(fooSet.contains("z")) // => false
+
+	// Podemos criar mapas usando a função "mapOf" e através da função infixa "to".
+	val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+	// Os valores do mapa podem ser acedidos usando a sua chave.
+	println(fooMap["a"]) // => 8
+
+	/*
+	No Kotlin as sequências representam collecções de dados avaliadas de forma lazy.
+	Podemos cirar uma sequência usando a função "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]
+
+	// Um exemplo de uso das sequências para gerar os 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]
+
+	// O Kotlin fornece funções de ordem superior convenientes para a manipulação de colecções.
+	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]}
+
+	// Um ciclo "for" pode ser usado com qualquer coisa que forneça um iterador.
+	for (c in "hello") {
+		println(c)
+	}
+
+	// Um ciclo "while" funciona da mesma forma que em outras linguagens.
+	var ctr = 0
+	while (ctr < 5) {
+		println(ctr)
+		ctr++
+	}
+	do {
+		println(ctr)
+		ctr++
+	} while (ctr < 10)
+
+	/*
+	Um "if" pode ser usado como uma expressão que produz um valor.
+	Por esta razão o operador ternário não é necessário no Kotlin.
+	*/
+	val num = 5
+	val message = if (num % 2 == 0) "even" else "odd"
+	println("$num is $message") // => 5 is odd
+
+	// O bloco "when" pode ser usado como alternativa para cadeias de "if-else if".
+	val i = 10
+	when {
+		i < 7 -> println("first block")
+		fooString.startsWith("hello") -> println("second block")
+		else -> println("else block")
+	}
+
+	// O "when" pode ser usado como um "switch" do Java.
+	when (i) {
+		0, 21 -> println("0 or 21")
+		in 1..20 -> println("in the range 1 to 20")
+		else -> println("none of the above")
+	}
+
+	// O "when" pode também ser usado como expressão para produzir um 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 utilizar o operador "is" para verificar se um objecto é de um certo tipo.
+	Se um objecto passar a verificação do tipo pode ser usado como sendo desse tipo
+	sem conversão explicita, sendo isto chamado de smart cast.
+	*/
+	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
+
+	// Os smart casts funcionam também com o bloco "when".
+	fun smartCastWhenExample(x: Any) = when (x) {
+		is Boolean -> x
+		is Int -> x > 0
+		is String -> x.isNotEmpty()
+		else -> false
+	}
+
+	/*
+	Extensões são uma forma de adicionar funcionalidade a classes existentes.
+	Isto é semelhante aos métodos de extensão do C#.
+	*/
+	fun String.remove(c: Char): String {
+		return this.filter {it != c}
+	}
+	println("Hello, world!".remove('l')) // => Hello, world!
+}
+
+// Enum classes são o equivalente aos tipos enum do Java.
+enum class EnumExample {
+	A, B, C // As constantes da enumeração são separadas por vírgula.
+}
+fun printEnum() = println(EnumExample.A) // => A
+
+/*
+Como cada constante é uma instância da classe enum, 
+estas podem ser inicializadas da seguinte forma:
+*/
+enum class EnumExample(val value: Int) {
+	A(value = 1),
+	B(value = 2),
+	C(value = 3)
+}
+fun printProperty() = println(EnumExample.A.value) // => 1
+
+/*
+Cada constante de enumerações tem propriedades para 
+obter o nome e o ordinal (posição) na respectiva classe.
+*/
+fun printName() = println(EnumExample.A.name) // => A
+fun printPosition() = println(EnumExample.A.ordinal) // => 0
+
+/*
+A palavra-chave "object" pode ser usada para criar objectos singleton.
+Estes não podem ser instânciados, porém podem ser referênciados como uma
+única instância através do seu nome.
+São semelhantes aos objectos singleton do Scala.
+*/
+object ObjectExample {
+	fun hello(): String {
+		return "hello"
+	}
+
+	override fun toString(): String {
+		return "Hello, it's me, ${ObjectExample::class.simpleName}"
+	}
+}
+
+
+fun useSingletonObject() {
+	println(ObjectExample.hello()) // => hello
+	// Em Kotlin o tipo "Any" é a raíz da hierárquia de classes, tal como o tipo "Object" em Java.
+	val someRef: Any = ObjectExample
+	println(someRef) // => Hello, it's me, ObjectExample
+}
+
+
+/* 
+O operador !! serve para realizar um assert de not-null. Este converte qualquer 
+valor nullable para non-null ou lança exceção se o mesmo for null.
+*/
+var b: String? = "abc"
+val l = b!!.length	// lançaria exceção caso "b" fosse null
+
+// O modificador "operator" permite fazer overload dos operadores 
+// [Ver lista de operadores](https://kotlinlang.org/docs/operator-overloading.html)
+data class Counter(var value: Int) {
+	// overload para Counter += Int
+	operator fun plusAssign(increment: Int) {
+		this.value += increment
+	}
+
+	// overload para Counter++ e ++Counter
+	operator fun inc() = Counter(value + 1)
+
+	// overload para Counter + Counter
+	operator fun plus(other: Counter) = Counter(this.value + other.value)
+
+	// overload para Counter * Counter
+	operator fun times(other: Counter) = Counter(this.value * other.value)
+
+	// overload para Counter * Int
+	operator fun times(value: Int) = Counter(this.value * value)
+
+	// overload para Counter in Counter
+	operator fun contains(other: Counter) = other.value == this.value
+
+	// overload para Counter[Int] = Int
+	operator fun set(index: Int, value: Int) {
+		this.value = index + value
+	}
+
+	// overload para invocação da instância Counter
+	operator fun invoke() = println("The value of the counter is $value")
+}
+/* Podemos também dar overload dos operadores através de métodos de extensão */
+// overload para -Counter
+operator fun Counter.unaryMinus() = Counter(-this.value)
+
+fun operatorOverloadingDemo() {
+	var counter1 = Counter(0)
+	var counter2 = Counter(5)
+	counter1 += 7
+	println(counter1) // => Counter(value=7)
+	println(counter1 + counter2) // => Counter(value=12)
+	println(counter1 * counter2) // => Counter(value=35)
+	println(counter2 * 2) // => Counter(value=10)
+	println(counter1 in Counter(5)) // => false
+	println(counter1 in Counter(7)) // => true
+	counter1[26] = 10
+	println(counter1) // => Counter(value=36)
+	counter1() // => The value of the counter is 36
+	println(-counter2) // => Counter(value=-5)
+}
+```
+
+### Leituras Adicionais
+
+* [Tutoriais de Kotlin](https://kotlinlang.org/docs/tutorials/)
+* [Experimenta Kotlin no browser](https://play.kotlinlang.org/)
+* [Recursos adicionais](http://kotlin.link/)
\ No newline at end of file
diff --git a/pug.html.markdown b/pug.html.markdown
index 0187f1e0..21d8db9f 100644
--- a/pug.html.markdown
+++ b/pug.html.markdown
@@ -158,13 +158,13 @@ case orderStatus
 //- <p class="warn">Your order is pending</p>
 
 //- --INCLUDE--
-//- File path -> "includes/nav.png"
+//- File path -> "includes/nav.pug"
 h1 Company Name
 nav
   a(href="index.html") Home
   a(href="about.html") About Us
 
-//- File path -> "index.png"
+//- File path -> "index.pug"
 html
   body
     include includes/nav.pug
@@ -183,9 +183,9 @@ style
   include styles/theme.css
 
 //- ---MIXIN---
-mixin basic()
+mixin basic
   div Hello
-+basic("Bob")
++basic
 //- <div>Hello</div>
 
 mixin comment(name, comment)
@@ -193,7 +193,11 @@ mixin comment(name, comment)
     span.comment-name= name
     div.comment-text= comment
 +comment("Bob", "This is Awesome")
-//- <div>Hello</div>
+//- 
+  <div>
+    <span class="comment-name">Bob</span>
+    <div class="comment-text">This is Awesome</div>
+  </div>
 
 ```
 
@@ -201,4 +205,4 @@ mixin comment(name, comment)
 ### Additional Resources
 - [The Site](https://pugjs.org/)
 - [The Docs](https://pugjs.org/api/getting-started.html)
-- [Github Repo](https://github.com/pugjs/pug)
+- [GitHub Repo](https://github.com/pugjs/pug)
diff --git a/purescript.html.markdown b/purescript.html.markdown
index c848c2a4..1ceaecf9 100644
--- a/purescript.html.markdown
+++ b/purescript.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: purescript
+language: PureScript
 filename: purescript.purs
 contributors:
     - ["Fredrik Dyrkell", "http://www.lexicallyscoped.com"]
@@ -59,9 +59,9 @@ compare 3 2 -- GT
 true && (9 >= 19 || 1 < 2) -- true
 
 -- Strings
-"Hellow" :: String -- "Hellow"
+"Hello" :: String -- "Hello"
 -- Multiline string without newlines, to run in PSCi use "paste" mode.
-"Hellow\
+"Hello\
 \orld" -- "Helloworld"
 -- Multiline string with newlines
 """Hello
diff --git a/pyqt.html.markdown b/pyqt.html.markdown
index 6bdb6488..2b331874 100644
--- a/pyqt.html.markdown
+++ b/pyqt.html.markdown
@@ -11,25 +11,25 @@ contributors:
 
 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! 
+this version just having been done using pyqt!
 
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
-	# Create an application object 
+	# 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 
+	# Add a label to the widget
     b = QtGui.QLabel(w)
-	# Set some text for the label 
+	# Set some text for the label
     b.setText("Hello World!")
-	# Give some size and placement information 
+	# Give some size and placement information
     w.setGeometry(100, 100, 200, 50)
     b.move(50, 20)
-	# Give our window a nice title 
+	# Give our window a nice title
     w.setWindowTitle("PyQt")
 	# Have everything display
     w.show()
@@ -41,10 +41,10 @@ if __name__ == '__main__':
 
 ```
 
-In order to get some of the more advanced features in **pyqt** we need to start looking at building additional elements. 
+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 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -63,7 +63,7 @@ def window():
     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():
diff --git a/python.html.markdown b/python.html.markdown
index 39e60455..9d97e64d 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -9,14 +9,18 @@ contributors:
     - ["Rommel Martinez", "https://ebzzry.io"]
     - ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"]
     - ["caminsha", "https://github.com/caminsha"]
+    - ["Stanislav Modrak", "https://stanislav.gq"]
+    - ["John Paul Wohlscheid", "https://gitpi.us"]
 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.
 
-Note: This article applies to Python 3 specifically. Check out [here](http://learnxinyminutes.com/docs/pythonlegacy/) if you want to learn the old Python 2.7
+Note: This article applies to Python 3 specifically. Check out
+[here](http://learnxinyminutes.com/docs/pythonlegacy/) if you want to learn the
+old Python 2.7
 
 ```python
 
@@ -81,16 +85,29 @@ False - 5   # => -5
 
 # Comparison operators look at the numerical value of True and False
 0 == False  # => True
-1 == True   # => True
+2 > True    # => True
 2 == True   # => False
 -5 != False # => True
 
-# Using boolean logical operators on ints casts them to booleans for evaluation, but their non-cast value is returned
-# Don't mix up with bool(ints) and bitwise and/or (&,|)
+# None, 0, and empty strings/lists/dicts/tuples/sets all evaluate to False.
+# All other values are True
 bool(0)     # => False
+bool("")    # => False
+bool([])    # => False
+bool({})    # => False
+bool(())    # => False
+bool(set()) # => False
 bool(4)     # => True
 bool(-6)    # => True
+
+# Using boolean logical operators on ints casts them to booleans for evaluation,
+# but their non-cast value is returned. Don't mix up with bool(ints) and bitwise
+# and/or (&,|)
+bool(0)     # => False
+bool(2)     # => True
 0 and 2     # => 0
+bool(-5)    # => True
+bool(2)     # => True
 -5 or 0     # => -5
 
 # Equality is ==
@@ -139,10 +156,10 @@ b == a            # => True, a's and b's objects are equal
 # You can find the length of a string
 len("This is a string")  # => 16
 
-# You can also format using f-strings or formatted string literals (in Python 3.6+)
+# Since Python 3.6, you can use f-strings or formatted string literals.
 name = "Reiko"
 f"She said her name is {name}." # => "She said her name is Reiko"
-# You can basically put any Python expression inside the braces and it will be output in the string.
+# Any valid Python expression inside these braces is returned to the string.
 f"{name} is {len(name)} characters long." # => "Reiko is 5 characters long."
 
 # None is an object
@@ -153,14 +170,6 @@ None  # => None
 "etc" is None  # => False
 None is None   # => True
 
-# 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
 ####################################################
@@ -176,7 +185,7 @@ print("Hello, World", end="!")  # => Hello, World!
 input_string_var = input("Enter some data: ") # Returns the data as a string
 
 # There are no declarations, only assignments.
-# Convention is to use lower_case_with_underscores
+# Convention in naming variables is snake_case style
 some_var = 5
 some_var  # => 5
 
@@ -217,7 +226,7 @@ li[4]  # Raises an IndexError
 li[1:3]   # Return list from index 1 to 3 => [2, 4]
 li[2:]    # Return list starting from index 2 => [4, 3]
 li[:3]    # Return list from beginning until index 3  => [1, 2, 4]
-li[::2]   # Return list selecting every second entry => [1, 4]
+li[::2]   # Return list selecting elements with a step size of 2 => [1, 4]
 li[::-1]  # Return list in reverse order => [3, 4, 2, 1]
 # Use any combination of these to make advanced slices
 # li[start:end:step]
@@ -289,7 +298,7 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
 # Note keys for dictionaries have to be immutable types. This is to ensure that
 # the key can be converted to a constant hash value for quick look-ups.
 # Immutable types include ints, floats, strings, tuples.
-invalid_dict = {[1,2,3]: "123"}  # => Raises a TypeError: unhashable type: 'list'
+invalid_dict = {[1,2,3]: "123"}  # => Yield a TypeError: unhashable type: 'list'
 valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.
 
 # Look up values with []
@@ -343,7 +352,7 @@ del filled_dict["one"]  # Removes the key "one" from filled dict
 
 # Sets store ... well sets
 empty_set = set()
-# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
+# Initialize a set with a bunch of values.
 some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}
 
 # Similar to keys of a dictionary, elements of a set have to be immutable.
@@ -415,7 +424,7 @@ for animal in ["dog", "cat", "mouse"]:
 
 """
 "range(number)" returns an iterable of numbers
-from zero to the given number
+from zero up to (but excluding) the given number
 prints:
     0
     1
@@ -449,8 +458,7 @@ for i in range(4, 8, 2):
     print(i)
 
 """
-To loop over a list, and retrieve both the index and the value of each item in the list
-prints:
+Loop over a list to retrieve both the index and the value of each list item:
     0 dog
     1 cat
     2 mouse
@@ -477,10 +485,11 @@ 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                 # Refrain from this, provide a recovery (next example).
 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
+    pass                 # Multiple exceptions can be processed jointly.
+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")
@@ -492,19 +501,20 @@ with open("myfile.txt") as f:
 
 # Writing to a file
 contents = {"aa": 12, "bb": 21}
-with open("myfile1.txt", "w+") as file:
+with open("myfile1.txt", "w") as file:
     file.write(str(contents))        # writes a string to a file
 
-with open("myfile2.txt", "w+") as file:
+import json
+with open("myfile2.txt", "w") as file:
     file.write(json.dumps(contents)) # writes an object to a file
 
 # Reading from a file
-with open('myfile1.txt', "r+") as file:
+with open('myfile1.txt', "r") as file:
     contents = file.read()           # reads a string from a file
 print(contents)
 # print: {"aa": 12, "bb": 21}
 
-with open('myfile2.txt', "r+") as file:
+with open('myfile2.txt', "r") as file:
     contents = json.load(file)       # reads a json object from a file
 print(contents)
 # print: {"aa": 12, "bb": 21}
@@ -516,7 +526,8 @@ print(contents)
 
 filled_dict = {"one": 1, "two": 2, "three": 3}
 our_iterable = filled_dict.keys()
-print(our_iterable)  # => dict_keys(['one', 'two', 'three']). This is an object that implements our Iterable interface.
+print(our_iterable)  # => dict_keys(['one', 'two', 'three']). This is an object
+                     # that implements our Iterable interface.
 
 # We can loop over it.
 for i in our_iterable:
@@ -528,15 +539,16 @@ our_iterable[1]  # Raises a TypeError
 # An iterable is an object that knows how to create an iterator.
 our_iterator = iter(our_iterable)
 
-# Our iterator is an object that can remember the state as we traverse through it.
-# We get the next object with "next()".
+# Our iterator is an object that can remember the state as we traverse through
+# it. We get the next object with "next()".
 next(our_iterator)  # => "one"
 
 # It maintains state as we iterate.
 next(our_iterator)  # => "two"
 next(our_iterator)  # => "three"
 
-# After the iterator has returned all of its data, it raises a StopIteration exception
+# After the iterator has returned all of its data, it raises a
+# StopIteration exception
 next(our_iterator)  # Raises StopIteration
 
 # We can also loop over it, in fact, "for" does this implicitly!
@@ -544,7 +556,7 @@ our_iterator = iter(our_iterable)
 for i in our_iterator:
     print(i)  # Prints one, two, three
 
-# You can grab all the elements of an iterable or iterator by calling list() on it.
+# You can grab all the elements of an iterable or iterator by call of list().
 list(our_iterable)  # => Returns ["one", "two", "three"]
 list(our_iterator)  # => Returns [] because state is saved
 
@@ -591,12 +603,12 @@ all_the_args(1, 2, a=3, b=4) prints:
 """
 
 # When calling functions, you can do the opposite of args/kwargs!
-# Use * to expand tuples and use ** to expand kwargs.
+# Use * to expand args (tuples) and use ** to expand kwargs (dictionaries).
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
-all_the_args(*args)            # equivalent to all_the_args(1, 2, 3, 4)
-all_the_args(**kwargs)         # equivalent to all_the_args(a=3, b=4)
-all_the_args(*args, **kwargs)  # equivalent to all_the_args(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args)            # equivalent: all_the_args(1, 2, 3, 4)
+all_the_args(**kwargs)         # equivalent: all_the_args(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalent: all_the_args(1, 2, 3, 4, a=3, b=4)
 
 # Returning multiple values (with tuple assignments)
 def swap(x, y):
@@ -606,17 +618,19 @@ def swap(x, y):
 x = 1
 y = 2
 x, y = swap(x, y)     # => x = 2, y = 1
-# (x, y) = swap(x,y)  # Again parenthesis have been excluded but can be included.
+# (x, y) = swap(x,y)  # Again the use of parenthesis is optional.
 
-# Function Scope
+# global scope
 x = 5
 
 def set_x(num):
-    # Local var x not the same as global variable x
+    # local scope begins here
+    # local var x not the same as global var x
     x = num    # => 43
     print(x)   # => 43
 
 def set_global_x(num):
+    # global indicates that particular var lives in the global scope
     global x
     print(x)   # => 5
     x = num    # global var x is now set to 6
@@ -624,6 +638,12 @@ def set_global_x(num):
 
 set_x(43)
 set_global_x(6)
+"""
+prints:
+    43
+    5
+    6
+"""
 
 
 # Python has first class functions
@@ -635,6 +655,22 @@ def create_adder(x):
 add_10 = create_adder(10)
 add_10(3)   # => 13
 
+# Closures in nested functions:
+# We can use the nonlocal keyword to work with variables in nested scope which shouldn't be declared in the inner functions.
+def create_avg():
+    total = 0
+    count = 0
+    def avg(n):
+        nonlocal total, count
+        total += n
+        count += 1
+        return total/count
+    return avg
+avg = create_avg()
+avg(3) # => 3.0
+avg(5) # (3+5)/2 => 4.0
+avg(7) # (8+7)/3 => 5.0
+
 # There are also anonymous functions
 (lambda x: x > 2)(3)                  # => True
 (lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
@@ -646,7 +682,7 @@ 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]
 
 # 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
+# List comprehension stores the output as a list (which itself may be nested).
 [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]
 
@@ -665,8 +701,8 @@ 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
+print(ceil(3.7))   # => 4
+print(floor(3.7))  # => 3
 
 # You can import all functions from a module.
 # Warning: this is not recommended
@@ -706,14 +742,16 @@ class Human:
     # Note that the double leading and trailing underscores denote objects
     # 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 special methods (or sometimes called dunder methods)
-    # You should not invent such names on your own.
+    # __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   # the leading underscore indicates the "age" property is 
+                        # intended to be used internally
+                        # do not rely on this to be enforced: it's a hint to other devs
 
     # An instance method. All methods take "self" as the first argument
     def say(self, msg):
@@ -761,7 +799,7 @@ if __name__ == '__main__':
     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
+    # i and j are instances of type Human; i.e., they are Human objects.
 
     # Call our class method
     i.say(i.get_species())          # "Ian: H. sapiens"
@@ -798,8 +836,8 @@ if __name__ == '__main__':
 # "species", "name", and "age", as well as methods, like "sing" and "grunt"
 # from the Human class, but can also have its own unique properties.
 
-# To take advantage of modularization by file you could place the classes above in their own files,
-# say, human.py
+# To take advantage of modularization by file you could place the classes above
+# in their own files, say, human.py
 
 # To import functions from other files use the following format
 # from "filename-without-extension" import "function-or-class"
@@ -856,7 +894,8 @@ if __name__ == '__main__':
     if type(sup) is Superhero:
         print('I am a superhero')
 
-    # Get the Method Resolution search Order used by both getattr() and super()
+    # Get the "Method Resolution Order" used by both getattr() and super()
+    # (the order in which classes are searched for an attribute or method)
     # This attribute is dynamic and can be updated
     print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
                                 # => <class 'human.Human'>, <class 'object'>)
@@ -923,8 +962,8 @@ class Batman(Superhero, Bat):
         # 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".
+        # The use of *args and **kwargs allows for a clean way to pass
+        # arguments, with each parent "peeling a layer of the onion".
         Superhero.__init__(self, 'anonymous', movie=True,
                            superpowers=['Wealthy'], *args, **kwargs)
         Bat.__init__(self, *args, can_fly=False, **kwargs)
@@ -938,8 +977,7 @@ class Batman(Superhero, Bat):
 if __name__ == '__main__':
     sup = Batman()
 
-    # Get the Method Resolution search Order used by both getattr() and super().
-    # This attribute is dynamic and can be updated
+    # The Method Resolution Order
     print(Batman.__mro__)       # => (<class '__main__.Batman'>,
                                 # => <class 'superhero.Superhero'>,
                                 # => <class 'human.Human'>,
@@ -996,42 +1034,76 @@ gen_to_list = list(values)
 print(gen_to_list)  # => [-1, -2, -3, -4, -5]
 
 
-# Decorators
-# In this example `beg` wraps `say`. If say_please is True then it
-# will change the returned message.
-from functools import wraps
+# Decorators are a form of syntactic sugar.
+# They make code easier to read while accomplishing clunky syntax.
 
+# Wrappers are one type of decorator.
+# They're really useful for adding logging to existing functions without needing to modify them.
 
-def beg(target_function):
-    @wraps(target_function)
+def log_function(func):
     def wrapper(*args, **kwargs):
-        msg, say_please = target_function(*args, **kwargs)
-        if say_please:
-            return "{} {}".format(msg, "Please! I am poor :(")
-        return msg
-
+        print("Entering function", func.__name__)
+        result = func(*args, **kwargs)
+        print("Exiting function", func.__name__)
+        return result
     return wrapper
 
+@log_function               # equivalent:
+def my_function(x,y):       # def my_function(x,y):
+    return x+y              #   return x+y
+                            # my_function = log_function(my_function)
+# The decorator @log_function tells us as we begin reading the function definition
+# for my_function that this function will be wrapped with log_function.
+# When function definitions are long, it can be hard to parse the non-decorated
+# assignment at the end of the definition.
 
-@beg
-def say(say_please=False):
-    msg = "Can you buy me a beer?"
-    return msg, say_please
+my_function(1,2) # => "Entering function my_function"
+                 # => "3"
+                 # => "Exiting function my_function"
 
+# But there's a problem.
+# What happens if we try to get some information about my_function?
 
-print(say())                 # Can you buy me a beer?
-print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
-```
+print(my_function.__name__) # => 'wrapper'
+print(my_function.__code__.co_argcount) # => 0. The argcount is 0 because both arguments in wrapper()'s signature are optional.
+
+# Because our decorator is equivalent to my_function = log_function(my_function)
+# we've replaced information about my_function with information from wrapper
+
+# Fix this using functools
+
+from functools import wraps
 
-## Ready For More?
+def log_function(func):
+    @wraps(func) # this ensures docstring, function name, arguments list, etc. are all copied
+                 # to the wrapped function - instead of being replaced with wrapper's info
+    def wrapper(*args, **kwargs):
+        print("Entering function", func.__name__)
+        result = func(*args, **kwargs)
+        print("Exiting function", func.__name__)
+        return result
+    return wrapper
+
+@log_function               
+def my_function(x,y):       
+    return x+y              
+                            
+my_function(1,2) # => "Entering function my_function"
+                 # => "3"
+                 # => "Exiting function my_function"
+
+print(my_function.__name__) # => 'my_function'
+print(my_function.__code__.co_argcount) # => 2
+
+```
 
 ### Free Online
 
 * [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
-* [Ideas for Python Projects](http://pythonpracticeprojects.com)
 * [The Official Docs](https://docs.python.org/3/)
 * [Hitchhiker's Guide to Python](https://docs.python-guide.org/en/latest/)
 * [Python Course](https://www.python-course.eu)
+* [Free Interactive Python Course](http://www.Kikodo.io)
 * [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](https://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
diff --git a/qsharp.html.markdown b/qsharp.html.markdown
index b256043c..04e697a4 100644
--- a/qsharp.html.markdown
+++ b/qsharp.html.markdown
@@ -9,7 +9,7 @@ filename: LearnQSharp.qs
 
 Q# is a high-level domain-specific language which enables developers to write quantum algorithms. Q# programs can be executed on a quantum simulator running on a classical computer and (in future) on quantum computers.
 
-```C#
+```c#
 // Single-line comments start with //
 
 
@@ -29,10 +29,10 @@ using (qs = Qubit[2]) {
 
     // If you want to change the state of a qubit
     // you have to do this by applying quantum gates to the qubit.
-    H(q[0]);    // This changes the state of the first qubit 
+    H(qs[0]);    // This changes the state of the first qubit 
                 // from |0⟩ (the initial state of allocated qubits) 
                 // to (|0⟩ + |1⟩) / sqrt(2).
-    // q[1] = |1⟩; - this does NOT work, you have to manipulate a qubit by using gates.
+    // qs[1] = |1⟩; - this does NOT work, you have to manipulate a qubit by using gates.
 
     // You can apply multi-qubit gates to several qubits.
     CNOT(qs[0], qs[1]);
diff --git a/r.html.markdown b/r.html.markdown
index 79af40ce..a063cc2f 100644
--- a/r.html.markdown
+++ b/r.html.markdown
@@ -4,6 +4,7 @@ contributors:
     - ["e99n09", "http://github.com/e99n09"]
     - ["isomorphismes", "http://twitter.com/isomorphisms"]
     - ["kalinn", "http://github.com/kalinn"]
+    - ["mribeirodantas", "http://github.com/mribeirodantas"]
 filename: learnr.r
 ---
 
@@ -11,7 +12,7 @@ R is a statistical computing language. It has lots of libraries for uploading an
 
 ```r
 
-# Comments start with number symbols.
+# Comments start with hash signs, also known as number symbols (#).
 
 # You can't make multi-line comments,
 # but you can stack multiple comments like so.
@@ -29,13 +30,13 @@ R is a statistical computing language. It has lots of libraries for uploading an
 # R without understanding anything about programming. Do not worry
 # about understanding everything the code does. Just enjoy!
 
-data()	        # browse pre-loaded data sets
-data(rivers)	# get this one: "Lengths of Major North American Rivers"
-ls()	        # notice that "rivers" now appears in the workspace
-head(rivers)	# peek at the data set
+data()          # browse pre-loaded data sets
+data(rivers)    # get this one: "Lengths of Major North American Rivers"
+ls()            # notice that "rivers" now appears in the workspace
+head(rivers)    # peek at the data set
 # 735 320 325 392 524 450
 
-length(rivers)	# how many rivers were measured?
+length(rivers)  # how many rivers were measured?
 # 141
 summary(rivers) # what are some summary statistics?
 #   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
@@ -91,14 +92,15 @@ stem(log(rivers)) # Notice that the data are neither normal nor log-normal!
 #  82 | 2
 
 # make a histogram:
-hist(rivers, col="#333333", border="white", breaks=25) # play around with these parameters
-hist(log(rivers), col="#333333", border="white", breaks=25) # you'll do more plotting later
+hist(rivers, col = "#333333", border = "white", breaks = 25)
+hist(log(rivers), col = "#333333", border = "white", breaks = 25)
+# play around with these parameters, you'll do more plotting later
 
 # Here's another neat data set that comes pre-loaded. R has tons of these.
 data(discoveries)
-plot(discoveries, col="#333333", lwd=3, xlab="Year",
+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",
+plot(discoveries, col = "#333333", lwd = 3, type = "h", xlab = "Year",
      main="Number of important discoveries per year")
 
 # Rather than leaving the default ordering (by year),
@@ -109,7 +111,7 @@ sort(discoveries)
 # [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)
+stem(discoveries, scale = 2)
 #
 #  The decimal point is at the |
 #
@@ -134,7 +136,7 @@ summary(discoveries)
 #    0.0     2.0     3.0     3.1     4.0    12.0
 
 # Roll a die a few times
-round(runif(7, min=.5, max=6.5))
+round(runif(7, min = .5, max = 6.5))
 # 1 4 6 1 4 6 4
 # Your numbers will differ from mine unless we set the same random.seed(31337)
 
@@ -157,69 +159,68 @@ rnorm(9)
 
 # INTEGERS
 # Long-storage integers are written with L
-5L # 5
-class(5L) # "integer"
+5L          # 5
+class(5L)   # "integer"
 # (Try ?class for more information on the class() function.)
 # In R, every single value, like 5L, is considered a vector of length 1
-length(5L) # 1
+length(5L)  # 1
 # You can have an integer vector with length > 1 too:
-c(4L, 5L, 8L, 3L) # 4 5 8 3
-length(c(4L, 5L, 8L, 3L)) # 4
-class(c(4L, 5L, 8L, 3L)) # "integer"
+c(4L, 5L, 8L, 3L)          # 4 5 8 3
+length(c(4L, 5L, 8L, 3L))  # 4
+class(c(4L, 5L, 8L, 3L))   # "integer"
 
 # NUMERICS
 # A "numeric" is a double-precision floating-point number
-5 # 5
-class(5) # "numeric"
+5           # 5
+class(5)    # "numeric"
 # Again, everything in R is a vector;
 # you can make a numeric vector with more than one element
-c(3,3,3,2,2,1) # 3 3 3 2 2 1
+c(3, 3, 3, 2, 2, 1) # 3 3 3 2 2 1
 # You can use scientific notation too
-5e4 # 50000
-6.02e23 # Avogadro's number
-1.6e-35 # Planck length
+5e4         # 50000
+6.02e23     # Avogadro's number
+1.6e-35     # Planck length
 # You can also have infinitely large or small numbers
-class(Inf)	# "numeric"
-class(-Inf)	# "numeric"
+class(Inf)  # "numeric"
+class(-Inf) # "numeric"
 # You might use "Inf", for example, in integrate(dnorm, 3, Inf);
 # this obviates Z-score tables.
 
 # BASIC ARITHMETIC
 # You can do arithmetic with numbers
 # Doing arithmetic on a mix of integers and numerics gives you another numeric
-10L + 66L # 76      # integer plus integer gives integer
-53.2 - 4  # 49.2    # numeric minus numeric gives numeric
-2.0 * 2L  # 4       # numeric times integer gives numeric
-3L / 4    # 0.75    # integer over numeric gives numeric
-3 %% 2	  # 1       # the remainder of two numerics is another numeric
+10L + 66L   # 76    # integer plus integer gives integer
+53.2 - 4    # 49.2  # numeric minus numeric gives numeric
+2.0 * 2L    # 4     # numeric times integer gives numeric
+3L / 4      # 0.75  # integer over numeric gives numeric
+3 %% 2      # 1     # the remainder of two numerics is another numeric
 # Illegal arithmetic yields you a "not-a-number":
-0 / 0 # NaN
-class(NaN) # "numeric"
+0 / 0       # NaN
+class(NaN)  # "numeric"
 # You can do arithmetic on two vectors with length greater than 1,
 # so long as the larger vector's length is an integer multiple of the smaller
-c(1,2,3) + c(1,2,3) # 2 4 6
+c(1, 2, 3) + c(1, 2, 3)     # 2 4 6
 # Since a single number is a vector of length one, scalars are applied 
 # elementwise to vectors
-(4 * c(1,2,3) - 2) / 2 # 1 3 5
+(4 * c(1, 2, 3) - 2) / 2    # 1 3 5
 # Except for scalars, use caution when performing arithmetic on vectors with 
 # different lengths. Although it can be done, 
-c(1,2,3,1,2,3) * c(1,2) # 1 4 3 2 2 6
-# Matching lengths is better practice and easier to read
-c(1,2,3,1,2,3) * c(1,2,1,2,1,2) 
+c(1, 2, 3, 1, 2, 3) * c(1, 2)               # 1 4 3 2 2 6
+# Matching lengths is better practice and easier to read most times
+c(1, 2, 3, 1, 2, 3) * c(1, 2, 1, 2, 1, 2)   # 1 4 3 2 2 6
 
 # CHARACTERS
 # There's no difference between strings and characters in R
-"Horatio" # "Horatio"
-class("Horatio") # "character"
-class('H') # "character"
+"Horatio"           # "Horatio"
+class("Horatio")    # "character"
+class("H")          # "character"
 # Those were both character vectors of length 1
 # Here is a longer one:
-c('alef', 'bet', 'gimmel', 'dalet', 'he')
-# =>
-# "alef"   "bet"    "gimmel" "dalet"  "he"
+c("alef", "bet", "gimmel", "dalet", "he")
+# => "alef"   "bet"    "gimmel" "dalet"  "he"
 length(c("Call","me","Ishmael")) # 3
 # You can do regex operations on character vectors:
-substr("Fortuna multis dat nimis, nulli satis.", 9, 15) # "multis "
+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 has several built-in character vectors:
 letters
@@ -230,32 +231,33 @@ month.abb # "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "D
 
 # LOGICALS
 # In R, a "logical" is a boolean
-class(TRUE)	# "logical"
-class(FALSE)	# "logical"
+                
+class(TRUE)     # "logical"
+class(FALSE)    # "logical"
 # Their behavior is normal
-TRUE == TRUE	# TRUE
-TRUE == FALSE	# FALSE
-FALSE != FALSE	# FALSE
-FALSE != TRUE	# TRUE
+TRUE == TRUE    # TRUE
+TRUE == FALSE   # FALSE
+FALSE != FALSE  # FALSE
+FALSE != TRUE   # TRUE
 # Missing data (NA) is logical, too
-class(NA)	# "logical"
+class(NA)       # "logical"
 # Use | and & for logic operations.
 # OR
-TRUE | FALSE	# TRUE
+TRUE | FALSE    # TRUE
 # AND
-TRUE & FALSE	# FALSE
+TRUE & FALSE    # FALSE
 # Applying | and & to vectors returns elementwise logic operations
-c(TRUE,FALSE,FALSE) | c(FALSE,TRUE,FALSE) # TRUE TRUE FALSE
-c(TRUE,FALSE,TRUE) & c(FALSE,TRUE,TRUE) # FALSE FALSE TRUE
+c(TRUE, FALSE, FALSE) | c(FALSE, TRUE, FALSE)   # TRUE TRUE FALSE
+c(TRUE, FALSE, TRUE) & c(FALSE, TRUE, TRUE)     # FALSE FALSE TRUE
 # You can test if x is TRUE
-isTRUE(TRUE)	# TRUE
+isTRUE(TRUE)    # TRUE
 # Here we get a logical vector with many elements:
-c('Z', 'o', 'r', 'r', 'o') == "Zorro" # FALSE FALSE FALSE FALSE FALSE
-c('Z', 'o', 'r', 'r', 'o') == "Z" # TRUE FALSE FALSE FALSE FALSE
+c("Z", "o", "r", "r", "o") == "Zorro"   # FALSE FALSE FALSE FALSE FALSE
+c("Z", "o", "r", "r", "o") == "Z"       # TRUE FALSE FALSE FALSE FALSE
 
 # FACTORS
 # The factor class is for categorical data
-# Factors can be ordered (like childrens' grade levels) or unordered (like colors)
+# Factors can be ordered (like grade levels) or unordered (like colors)
 factor(c("blue", "blue", "green", NA, "blue"))
 #  blue blue green   <NA>   blue
 # Levels: blue green
@@ -263,31 +265,27 @@ factor(c("blue", "blue", "green", NA, "blue"))
 # Note that missing data does not enter the levels
 levels(factor(c("green", "green", "blue", NA, "blue"))) # "blue" "green"
 # If a factor vector has length 1, its levels will have length 1, too
-length(factor("green")) # 1
+length(factor("green"))         # 1
 length(levels(factor("green"))) # 1
 # Factors are commonly seen in data frames, a data structure we will cover later
-data(infert) # "Infertility after Spontaneous and Induced Abortion"
+data(infert)             # "Infertility after Spontaneous and Induced Abortion"
 levels(infert$education) # "0-5yrs"  "6-11yrs" "12+ yrs"
 
 # NULL
 # "NULL" is a weird one; use it to "blank out" a vector
-class(NULL)	# NULL
+class(NULL) # NULL
 parakeet = c("beak", "feathers", "wings", "eyes")
-parakeet
-# =>
-# [1] "beak"     "feathers" "wings"    "eyes"
+parakeet # "beak"     "feathers" "wings"    "eyes"
 parakeet <- NULL
-parakeet
-# =>
-# NULL
+parakeet # NULL
 
 # TYPE COERCION
 # Type-coercion is when you force a value to take on a different type
-as.character(c(6, 8)) # "6" "8"
-as.logical(c(1,0,1,1)) # TRUE FALSE  TRUE  TRUE
+as.character(c(6, 8))   # "6" "8"
+as.logical(c(1,0,1,1))  # TRUE FALSE  TRUE  TRUE
 # If you put elements of different types into a vector, weird coercions happen:
-c(TRUE, 4) # 1 4
-c("dog", TRUE, 4) # "dog"  "TRUE" "4"
+c(TRUE, 4)          # 1 4
+c("dog", TRUE, 4)   # "dog"  "TRUE" "4"
 as.numeric("Bilbo")
 # =>
 # [1] NA
@@ -309,14 +307,15 @@ as.numeric("Bilbo")
 
 # VARIABLES
 # Lots of way to assign stuff:
-x = 5 # this is possible
-y <- "1" # this is preferred
-TRUE -> z # this works but is weird
+x = 5       # this is possible
+y <- "1"    # this is preferred traditionally
+TRUE -> z   # this works but is weird
+# Refer to the Internet for the behaviors and preferences about them.
 
 # LOOPS
 # We've got for loops
 for (i in 1:4) {
-  print(i)
+	print(i)
 }
 # We've got while loops
 a <- 10
@@ -341,11 +340,11 @@ if (4 > 3) {
 # FUNCTIONS
 # Defined like so:
 jiggle <- function(x) {
-	x = x + rnorm(1, sd=.1)	#add in a bit of (controlled) noise
+	x = x + rnorm(1, sd=.1) # add in a bit of (controlled) noise
 	return(x)
 }
 # Called like any other R function:
-jiggle(5)	# 5±ε. After set.seed(2716057), jiggle(5)==5.005043
+jiggle(5)   # 5±ε. After set.seed(2716057), jiggle(5)==5.005043
 
 
 
@@ -357,39 +356,39 @@ jiggle(5)	# 5±ε. After set.seed(2716057), jiggle(5)==5.005043
 
 # Let's start from the very beginning, and with something you already know: vectors.
 vec <- c(8, 9, 10, 11)
-vec	#  8  9 10 11
+vec     #  8  9 10 11
 # We ask for specific elements by subsetting with square brackets
 # (Note that R starts counting from 1)
-vec[1]		# 8
-letters[18]	# "r"
-LETTERS[13]	# "M"
-month.name[9]	# "September"
-c(6, 8, 7, 5, 3, 0, 9)[3]	# 7
+vec[1]          # 8
+letters[18]     # "r"
+LETTERS[13]     # "M"
+month.name[9]   # "September"
+c(6, 8, 7, 5, 3, 0, 9)[3] # 7
 # We can also search for the indices of specific components,
-which(vec %% 2 == 0)	# 1 3
+which(vec %% 2 == 0) # 1 3
 # grab just the first or last few entries in the vector,
-head(vec, 1)	# 8
-tail(vec, 2)	# 10 11
+head(vec, 1)    # 8
+tail(vec, 2)    # 10 11
 # or figure out if a certain value is in the vector
-any(vec == 10) # TRUE
+any(vec == 10)  # TRUE
 # If an index "goes over" you'll get NA:
-vec[6]	# NA
+vec[6]      # NA
 # You can find the length of your vector with length()
-length(vec)	# 4
+length(vec) # 4
 # You can perform operations on entire vectors or subsets of vectors
-vec * 4	# 16 20 24 28
-vec[2:3] * 5	# 25 30
-any(vec[2:3] == 8) # FALSE
+vec * 4             # 32 36 40 44
+vec[2:3] * 5        # 45 50
+any(vec[2:3] == 8)  # FALSE
 # and R has many built-in functions to summarize vectors
-mean(vec)	# 9.5
-var(vec)	# 1.666667
-sd(vec)		# 1.290994
-max(vec)	# 11
-min(vec)	# 8
-sum(vec)	# 38
+mean(vec)   # 9.5
+var(vec)    # 1.666667
+sd(vec)     # 1.290994
+max(vec)    # 11
+min(vec)    # 8
+sum(vec)    # 38
 # Some more nice built-ins:
-5:15	# 5  6  7  8  9 10 11 12 13 14 15
-seq(from=0, to=31337, by=1337)
+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
@@ -397,7 +396,7 @@ seq(from=0, to=31337, by=1337)
 # TWO-DIMENSIONAL (ALL ONE CLASS)
 
 # You can make a matrix out of entries all of the same type like so:
-mat <- matrix(nrow = 3, ncol = 2, c(1,2,3,4,5,6))
+mat <- matrix(nrow = 3, ncol = 2, c(1, 2, 3, 4, 5, 6))
 mat
 # =>
 #      [,1] [,2]
@@ -405,13 +404,13 @@ mat
 # [2,]    2    5
 # [3,]    3    6
 # Unlike a vector, the class of a matrix is "matrix", no matter what's in it
-class(mat) # => "matrix"
+class(mat)      # "matrix" "array"
 # Ask for the first row
-mat[1,]	# 1 4
+mat[1, ]        # 1 4
 # Perform operation on the first column
-3 * mat[,1]	# 3 6 9
+3 * mat[, 1]    # 3 6 9
 # Ask for a specific cell
-mat[3,2]	# 6
+mat[3, 2]       # 6
 
 # Transpose the whole matrix
 t(mat)
@@ -437,14 +436,14 @@ mat2
 # [2,] "2"  "cat"
 # [3,] "3"  "bird"
 # [4,] "4"  "dog"
-class(mat2)	# matrix
+class(mat2) # matrix
 # Again, note what happened!
 # Because matrices must contain entries all of the same class,
 # everything got converted to the character class
-c(class(mat2[,1]), class(mat2[,2]))
+c(class(mat2[, 1]), class(mat2[, 2]))
 
 # rbind() sticks vectors together row-wise to make a matrix
-mat3 <- rbind(c(1,2,4,5), c(6,7,0,4))
+mat3 <- rbind(c(1, 2, 4, 5), c(6, 7, 0, 4))
 mat3
 # =>
 #      [,1] [,2] [,3] [,4]
@@ -458,11 +457,11 @@ mat3
 # This data structure is so useful for statistical programming,
 # a version of it was added to Python in the package "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"))
+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"
+class(students) # "data.frame"
 students
 # =>
 #     name year house
@@ -472,21 +471,22 @@ students
 # 4    Cho    1     R
 # 5  Draco    0     S
 # 6  Ginny   -1     G
-class(students$year)	# "numeric"
-class(students[,3])	# "factor"
+class(students$year)    # "numeric"
+class(students[,3])     # "factor"
 # find the dimensions
-nrow(students)	# 6
-ncol(students)	# 3
-dim(students)	# 6 3
-# The data.frame() function converts character vectors to factor vectors
-# by default; turn this off by setting stringsAsFactors = FALSE when
-# you create the data.frame
+nrow(students)  # 6
+ncol(students)  # 3
+dim(students)   # 6 3
+# The data.frame() function used to convert character vectors to factor
+# vectors by default; This has changed in R 4.0.0. If your R version is
+# older, turn this off by setting stringsAsFactors = FALSE when you
+# create the data.frame
 ?data.frame
 
 # There are many twisty ways to subset data frames, all subtly unalike
-students$year	# 3  2  2  1  0 -1
-students[,2]	# 3  2  2  1  0 -1
-students[,"year"]	# 3  2  2  1  0 -1
+students$year       # 3  2  2  1  0 -1
+students[, 2]       # 3  2  2  1  0 -1
+students[, "year"]  # 3  2  2  1  0 -1
 
 # An augmented version of the data.frame structure is the data.table
 # If you're working with huge or panel data, or need to merge a few data
@@ -503,19 +503,19 @@ students # note the slightly different print-out
 # 4:    Cho    1     R
 # 5:  Draco    0     S
 # 6:  Ginny   -1     G
-students[name=="Ginny"] # get rows with name == "Ginny"
+students[name == "Ginny"] # get rows with name == "Ginny"
 # =>
 #     name year house
 # 1: Ginny   -1     G
-students[year==2] # get rows with year == 2
+students[year == 2] # get rows with year == 2
 # =>
 #      name year house
 # 1:   Fred    2     G
 # 2: George    2     G
 # data.table makes merging two data sets easy
 # let's make another data.table to merge with students
-founders <- data.table(house=c("G","H","R","S"),
-                       founder=c("Godric","Helga","Rowena","Salazar"))
+founders <- data.table(house   = c("G"     , "H"    , "R"     , "S"),
+                       founder = c("Godric", "Helga", "Rowena", "Salazar"))
 founders
 # =>
 #    house founder
@@ -526,8 +526,8 @@ founders
 setkey(students, house)
 setkey(founders, house)
 students <- founders[students] # merge the two data sets by matching "house"
-setnames(students, c("house","houseFounderName","studentName","year"))
-students[,order(c("name","year","house","houseFounderName")), with=F]
+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
@@ -538,7 +538,7 @@ students[,order(c("name","year","house","houseFounderName")), with=F]
 # 6:       Draco    0     S          Salazar
 
 # data.table makes summary tables easy
-students[,sum(year),by=house]
+students[, sum(year), by = house]
 # =>
 #    house V1
 # 1:     G  3
@@ -571,7 +571,7 @@ students[studentName != "Draco"]
 # 5:     R         Cho    1
 # Using data.frame:
 students <- as.data.frame(students)
-students[students$house != "G",]
+students[students$house != "G", ]
 # =>
 #   house houseFounderName studentName year
 # 4     H            Helga      Cedric    3
@@ -583,13 +583,13 @@ students[students$house != "G",]
 # Arrays creates n-dimensional tables
 # All elements must be of the same type
 # You can make a two-dimensional table (sort of like a matrix)
-array(c(c(1,2,4,5),c(8,9,3,6)), dim=c(2,4))
+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
 # You can use array to make three-dimensional matrices too
-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))
+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
 #
@@ -609,7 +609,7 @@ 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))
 
 # Finally, R has lists (of vectors)
 list1 <- list(time = 1:40)
-list1$price = c(rnorm(40,.5*list1$time,4)) # random
+list1$price = c(rnorm(40, .5*list1$time, 4)) # random
 list1
 # You can get items in the list like so
 list1$time # one way
@@ -682,7 +682,7 @@ write.csv(pets, "pets2.csv") # to make a new .csv file
 #########################
 
 # Linear regression!
-linearModel <- lm(price  ~ time, data = list1)
+linearModel <- lm(price ~ time, data = list1)
 linearModel # outputs result of regression
 # =>
 # Call:
@@ -719,7 +719,7 @@ summary(linearModel)$coefficients # another way to extract results
 #              Estimate Std. Error    t value     Pr(>|t|)
 # (Intercept) 0.1452662 1.50084246 0.09678975 9.234021e-01
 # time        0.4943490 0.06379348 7.74920901 2.440008e-09
-summary(linearModel)$coefficients[,4] # the p-values 
+summary(linearModel)$coefficients[, 4] # the p-values 
 # =>
 #  (Intercept)         time 
 # 9.234021e-01 2.440008e-09 
@@ -728,8 +728,7 @@ summary(linearModel)$coefficients[,4] # the p-values
 # Logistic regression
 set.seed(1)
 list1$success = rbinom(length(list1$time), 1, .5) # random binary
-glModel <- glm(success  ~ time, data = list1, 
-	family=binomial(link="logit"))
+glModel <- glm(success  ~ time, data = list1, family=binomial(link="logit"))
 glModel # outputs result of logistic regression
 # =>
 # Call:  glm(formula = success ~ time, 
@@ -745,8 +744,10 @@ glModel # outputs result of logistic regression
 summary(glModel) # more verbose output from the regression
 # =>
 # Call:
-# glm(formula = success ~ time, 
-#	family = binomial(link = "logit"), data = list1)
+# glm(
+#	formula = success ~ time,
+#	family = binomial(link = "logit"),
+#	data = list1)
 
 # Deviance Residuals: 
 #    Min      1Q  Median      3Q     Max  
@@ -780,7 +781,7 @@ plot(linearModel)
 # Histograms!
 hist(rpois(n = 10000, lambda = 5), col = "thistle")
 # Barplots!
-barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
+barplot(c(1, 4, 5, 1, 2), names.arg = c("red", "blue", "purple", "green", "yellow"))
 
 # GGPLOT2
 # But these are not even the prettiest of R's plots
@@ -788,10 +789,10 @@ barplot(c(1,4,5,1,2), names.arg = c("red","blue","purple","green","yellow"))
 install.packages("ggplot2")
 require(ggplot2)
 ?ggplot2
-pp <- ggplot(students, aes(x=house))
+pp <- ggplot(students, aes(x = house))
 pp + geom_bar()
 ll <- as.data.table(list1)
-pp <- ggplot(ll, aes(x=time,price))
+pp <- ggplot(ll, aes(x = time, price))
 pp + geom_point()
 # ggplot2 has excellent documentation (available http://docs.ggplot2.org/current/)
 
diff --git a/racket.html.markdown b/racket.html.markdown
index 60a895e0..6c40c3c8 100644
--- a/racket.html.markdown
+++ b/racket.html.markdown
@@ -117,16 +117,16 @@ some-var ; => 5
 ;; let* is like let, but allows you to use previous bindings in creating later bindings
 (let* ([x 1]
        [y (+ x 1)])
-       (* x y))
+  (* 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))
+                     (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
@@ -413,7 +413,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (loop 5) ; => i=5, i=6, ...
 
 ;; Similarly, with a named let
-(let loop ((i 0))
+(let loop ([i 0])
   (when (< i 10)
     (printf "i=~a\n" i)
     (loop (add1 i)))) ; => i=0, i=1, ...
@@ -441,17 +441,19 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (for ([i (in-set (set 'x 'y 'z))])
   (displayln i))
 
-(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))])
+(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3))])
   (printf "key:~a value:~a\n" k v))
 
 ;;; More Complex Iterations
 
 ;; Parallel scan of multiple sequences (stops on shortest)
-(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j))
+(for ([i 10] [j '(x y z)]) 
+  (printf "~a:~a\n" i j))
 ; => 0:x 1:y 2:z
 
 ;; Nested loops
-(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j))
+(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
 
 ;; Conditions
@@ -663,8 +665,7 @@ vec ; => #(1 2 3 4)
 
   (define amount 0)
   (define (deposit a) (set! amount (+ amount a)))
-  (define (balance) amount)
-  )
+  (define (balance) amount))
 
 (require 'bank-account)
 (deposit 5)
diff --git a/raku-pod.html.markdown b/raku-pod.html.markdown
index 7e9b6fc3..b008beab 100644
--- a/raku-pod.html.markdown
+++ b/raku-pod.html.markdown
@@ -193,7 +193,7 @@ are C<print>, C<put> and C<say>.
 ### Comments
 
 Although Pod blocks are ignored by the Rakudo Raku compiler, everything
-indentified as a Pod block will be read and interpreted by Pod renderers. In
+identified as a Pod block will be read and interpreted by Pod renderers. In
 order to prevent Pod blocks from being rendered by any renderer, use the
 `=comment` directive.
 
diff --git a/raku.html.markdown b/raku.html.markdown
index 16035615..39bc0e51 100644
--- a/raku.html.markdown
+++ b/raku.html.markdown
@@ -116,15 +116,13 @@ say @array;               # OUTPUT: «a 6 b�»
 # 1.3 Hashes, or key-value Pairs.
 #
 
-=begin comment
-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.
-=end comment
+# 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 = 'a' => 1, 'b' => 2;
 
-# Keys get auto-quoted when the fat comman (`=>`) is used. Trailing commas are
+# Keys get auto-quoted when the fat comma (`=>`) is used. Trailing commas are
 # okay.
 %hash = a => 1, b => 2, ;
 
@@ -144,12 +142,10 @@ my %hash = 'a' => 1, 'b' => 2;
 # The `:` (as in `:is-even`) and `:!` (as `:!is-odd`) constructs are known
 # as the `True` and `False` shortcuts respectively.
 
-=begin comment
-As demonstrated in the example below, you can use {} to get the value from a key.
-If it's a string without spaces, you can actually use the quote-words operator
-(`<>`). Since Raku doesn't have barewords, as Perl does, `{key1}` doesn't work
-though.
-=end comment
+# As demonstrated in the example below, you can use {} to get the value from a key.
+# If it's a string without spaces, you can actually use the quote-words operator
+# (`<>`). Since Raku doesn't have barewords, as Perl does, `{key1}` doesn't work
+# though.
 say %hash{'n'};     # OUTPUT: «2�», gets value associated to key 'n'
 say %hash<is-even>; # OUTPUT: «True�», gets value associated to key 'is-even'
 
@@ -187,13 +183,11 @@ sub return-for {
 }
 say return-for;        # OUTPUT: «Nil�»
 
-=begin comment
-Positional arguments are required by default. To make them optional, use
-the `?` after the parameters' names.
+# Positional arguments are required by default. To make them optional, use
+# the `?` after the parameters' names.
 
-In the following example, the sub `with-optional` returns `(Any)` (Perl's
-null-like value) if no argument is passed. Otherwise, it returns its argument.
-=end comment
+# In the following example, the sub `with-optional` returns `(Any)` (Perl's
+# null-like value) if no argument is passed. Otherwise, it returns its argument.
 sub with-optional( $arg? ) {
     $arg;
 }
@@ -201,13 +195,11 @@ with-optional;     # returns Any
 with-optional();   # returns Any
 with-optional(1);  # returns 1
 
-=begin comment
-You can also give provide a default value when they're not passed. Doing
-this make said parameter optional. Required parameters must come before
-optional ones.
+# You can also give provide a default value when they're not passed. Doing
+# this make said parameter optional. Required parameters must come before
+# optional ones.
 
-In the sub `greeting`, the parameter `$type` is optional.
-=end comment
+# In the sub `greeting`, the parameter `$type` is optional.
 sub greeting( $name, $type = "Hello" ) {
   say "$type, $name!";
 }
@@ -215,22 +207,18 @@ sub greeting( $name, $type = "Hello" ) {
 greeting("Althea");                 # OUTPUT: «Hello, Althea!�»
 greeting("Arthur", "Good morning"); # OUTPUT: «Good morning, Arthur!�»
 
-=begin comment
-You can also, by using a syntax akin to the one of hashes (yay unified syntax!),
-declared named parameters and thus pass named arguments to a subroutine.
-By default, named parameter are optional and will default to `Any`.
-=end comment
+# You can also, by using a syntax akin to the one of hashes (yay unified syntax!),
+# declared named parameters and thus pass named arguments to a subroutine.
+# By default, named parameter are optional and will default to `Any`.
 sub with-named( $normal-arg, :$named ) {
 	say $normal-arg + $named;
 }
 with-named(1, named => 6); # OUTPUT: «7�»
 
-=begin comment
-There's one gotcha to be aware of, here: If you quote your key, Raku
-won't be able to see it at compile time, and you'll have a single `Pair`
-object as a positional parameter, which means the function subroutine
-`with-named(1, 'named' => 6);` fails.
-=end comment
+# There's one gotcha to be aware of, here: If you quote your key, Raku
+# won't be able to see it at compile time, and you'll have a single `Pair`
+# object as a positional parameter, which means the function subroutine
+# `with-named(1, 'named' => 6);` fails.
 with-named(2, :named(5));  # OUTPUT: «7�»
 
 # Similar to positional parameters, you can provide your named arguments with
@@ -241,11 +229,9 @@ sub named-def( :$def = 5 ) {
 named-def;            # OUTPUT: «5»
 named-def(def => 15); # OUTPUT: «15»
 
-=begin comment
-In order to make a named parameter mandatory, you can append `!` to the
-parameter. This is the inverse of `?`, which makes a required parameter
-optional.
-=end comment
+# In order to make a named parameter mandatory, you can append `!` to the
+# parameter. This is the inverse of `?`, which makes a required parameter
+# optional.
 
 sub with-mandatory-named( :$str! )  {
     say "$str!";
@@ -254,33 +240,27 @@ with-mandatory-named(str => "My String"); # OUTPUT: «My String!�»
 # with-mandatory-named;   # runtime error: "Required named parameter not passed"
 # with-mandatory-named(3);# runtime error: "Too many positional parameters passed"
 
-=begin comment
-If a sub takes a named boolean argument, you can use the same "short boolean"
-hash syntax we discussed earlier.
-=end comment
+# If a sub takes a named boolean argument, you can use the same "short boolean"
+# hash syntax we discussed earlier.
 sub takes-a-bool( $name, :$bool ) {
     say "$name takes $bool";
 }
 takes-a-bool('config', :bool);  # OUTPUT: «config takes True�»
 takes-a-bool('config', :!bool); # OUTPUT: «config takes False�»
 
-=begin comment
-Since parenthesis can be omitted when calling a subroutine, you need to use
-`&` in order to distinguish between a call to a sub with no arguments and
-the code object.
+# Since parenthesis can be omitted when calling a subroutine, you need to use
+# `&` in order to distinguish between a call to a sub with no arguments and
+# the code object.
 
-For instance, in this example we must use `&` to store the sub `say-hello`
-(i.e., the sub's code object) in a variable, not a subroutine call.
-=end comment
+# For instance, in this example we must use `&` to store the sub `say-hello`
+# (i.e., the sub's code object) in a variable, not a subroutine call.
 my &s = &say-hello;
 my &other-s = sub { say "Anonymous function!" }
 
-=begin comment
-A sub can have a "slurpy" parameter, or what one'd call a
-"doesn't-matter-how-many" parameter. This is Raku's way of supporting variadic
-functions. For this, you must use `*@` (slurpy) which will "take everything
-else". You can have as many parameters *before* a slurpy one, but not *after*.
-=end comment
+# A sub can have a "slurpy" parameter, or what one'd call a
+# "doesn't-matter-how-many" parameter. This is Raku's way of supporting variadic
+# functions. For this, you must use `*@` (slurpy) which will "take everything
+# else". You can have as many parameters *before* a slurpy one, but not *after*.
 sub as-many($head, *@rest) {
     @rest.join(' / ') ~ " !";
 }
@@ -289,35 +269,29 @@ say as-many('Happy', ['Happy', 'Birthday'], 'Day'); # OUTPUT: «Happy / Birthday
 
 # Note that the splat (the *) did not consume the parameter before it.
 
-=begin comment
-There are other two variations of slurpy parameters in Raku. The previous one
-(namely, `*@`), known as flattened slurpy, flattens passed arguments. The other
-two are `**@` and `+@` known as unflattened slurpy and "single argument rule"
-slurpy respectively. The unflattened slurpy doesn't flatten its listy
-arguments (or Iterable ones).
-=end comment
+# There are other two variations of slurpy parameters in Raku. The previous one
+# (namely, `*@`), known as flattened slurpy, flattens passed arguments. The other
+# two are `**@` and `+@` known as unflattened slurpy and "single argument rule"
+# slurpy respectively. The unflattened slurpy doesn't flatten its listy
+# arguments (or Iterable ones).
 sub b(**@arr) { @arr.perl.say };
 b(['a', 'b', 'c']);             # OUTPUT: «[["a", "b", "c"],]»
 b(1, $('d', 'e', 'f'), [2, 3]); # OUTPUT: «[1, ("d", "e", "f"), [2, 3]]»
 b(1, [1, 2], ([3, 4], 5));      # OUTPUT: «[1, [1, 2], ([3, 4], 5)]�»
 
-=begin comment
-On the other hand, the "single argument rule" slurpy follows the "single argument
-rule" which dictates how to handle the slurpy argument based upon context and
-roughly states that if only a single argument is passed and that argument is
-Iterable, that argument is used to fill the slurpy parameter array. In any
-other case, `+@` works like `**@`.
-=end comment
+# On the other hand, the "single argument rule" slurpy follows the "single argument
+# rule" which dictates how to handle the slurpy argument based upon context and
+# roughly states that if only a single argument is passed and that argument is
+# Iterable, that argument is used to fill the slurpy parameter array. In any
+# other case, `+@` works like `**@`.
 sub c(+@arr) { @arr.perl.say };
 c(['a', 'b', 'c']);             # OUTPUT: «["a", "b", "c"]�»
 c(1, $('d', 'e', 'f'), [2, 3]); # OUTPUT: «[1, ("d", "e", "f"), [2, 3]]�»
 c(1, [1, 2], ([3, 4], 5));      # OUTPUT: «[1, [1, 2], ([3, 4], 5)]�»
 
-=begin comment
-You can call a function with an array using the "argument list flattening"
-operator `|` (it's not actually the only role of this operator,
-but it's one of them).
-=end comment
+# You can call a function with an array using the "argument list flattening"
+# operator `|` (it's not actually the only role of this operator,
+# but it's one of them).
 sub concat3($a, $b, $c) {
     say "$a, $b, $c";
 }
@@ -328,14 +302,12 @@ concat3(|@array); # OUTPUT: «a, b, c�»
 # 3. Containers
 ####################################################
 
-=begin comment
-In Raku, 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 which means that,
-in a function, you'll get an error if you try to mutate one of your
-arguments. If you really need to, you can ask for a mutable container by
-using the `is rw` trait.
-=end comment
+# In Raku, 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 which means that,
+# in a function, you'll get an error if you try to mutate one of your
+# arguments. If you really need to, you can ask for a mutable container by
+# using the `is rw` trait.
 sub mutate( $n is rw ) {
     $n++; # postfix ++ operator increments its argument but returns its old value
 }
@@ -343,32 +315,26 @@ my $m = 42;
 mutate $m; #=> 42, the value is incremented but the old value is returned
 say $m;    # OUTPUT: «43�»
 
-=begin comment
-This works because we are passing the container $m to the `mutate` sub.
-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:
+# This works because we are passing the container $m to the `mutate` sub.
+# 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
-=end comment
+# mutate 42; # Parameter '$n' expected a writable container, but got Int value
 
-=begin comment
-Similar error would be obtained, if a bound variable is passed to
-to the subroutine. In Raku, you bind a value to a variable using the binding
-operator `:=`.
-=end comment
+# Similar error would be obtained, if a bound variable is passed to
+# to the subroutine. In Raku, you bind a value to a variable using the binding
+# operator `:=`.
 my $v := 50; # binding 50 to the variable $v
 # mutate $v;   # Parameter '$n' expected a writable container, but got Int value
 
-=begin comment
-If what you want is a copy instead, use the `is copy` trait which will
-cause the argument to be copied and allow you to modify the argument
-inside the routine without modifying the passed argument.
+# If what you want is a copy instead, use the `is copy` trait which will
+# cause the argument to be copied and allow you to modify the argument
+# inside the routine without modifying the passed argument.
 
-A sub itself returns a container, which means it can be marked as `rw`.
-Alternatively, you can explicitly mark the returned container as mutable
-by using `return-rw` instead of `return`.
-=end comment
+# A sub itself returns a container, which means it can be marked as `rw`.
+# Alternatively, you can explicitly mark the returned container as mutable
+# by using `return-rw` instead of `return`.
 my $x = 42;
 my $y = 45;
 sub x-store is rw { $x }
@@ -390,12 +356,10 @@ say $y; # OUTPUT: «90�»
 # 4.1 if/if-else/if-elsif-else/unless
 #
 
-=begin comment
-Before talking about `if`, we need to know which values are "truthy"
-(represent `True`), and which are "falsey" (represent `False`). Only these
-values are falsey: 0, (), {}, "", Nil, a type (like `Str`, `Int`, etc.) and
-of course, `False` itself. Any other value is truthy.
-=end comment
+# Before talking about `if`, we need to know which values are "truthy"
+# (represent `True`), and which are "falsey" (represent `False`). Only these
+# values are falsey: 0, (), {}, "", Nil, a type (like `Str`, `Int`, etc.) and
+# of course, `False` itself. Any other value is truthy.
 my $number = 5;
 if $number < 5 {
     say "Number is less than 5"
@@ -422,11 +386,9 @@ unless False {
 say "Quite truthy" if True;      # OUTPUT: «Quite truthy�»
 say "Quite falsey" unless False; # OUTPUT: «Quite falsey�»
 
-=begin comment
-The ternary operator (`??..!!`) is structured as follows `condition ??
-expression1 !! expression2` and it returns expression1 if the condition is
-true. Otherwise, it returns expression2.
-=end comment
+# The ternary operator (`??..!!`) is structured as follows `condition ??
+# expression1 !! expression2` and it returns expression1 if the condition is
+# true. Otherwise, it returns expression2.
 my $age = 30;
 say $age > 18 ?? "You are an adult" !! "You are under 18";
 # OUTPUT: «You are an adult�»
@@ -435,11 +397,9 @@ say $age > 18 ?? "You are an adult" !! "You are under 18";
 # 4.2 with/with-else/with-orwith-else/without
 #
 
-=begin comment
-The `with` statement is like `if`, but it tests for definedness rather than
-truth, and it topicalizes on the condition, much like `given` which will
-be discussed later.
-=end comment
+# The `with` statement is like `if`, but it tests for definedness rather than
+# truth, and it topicalizes on the condition, much like `given` which will
+# be discussed later.
 my $s = "raku";
 with   $s.index("r") { say "Found a at $_"      }
 orwith $s.index("k") { say "Found c at $_"      }
@@ -475,6 +435,7 @@ current iteration (unless explicitly named), etc.
 Since other Raku constructs use this variable (as said before, like `for`,
 blocks, `with` statement etc), this means the powerful `when` is not only
 applicable along with a `given`, but instead anywhere a `$_` exists.
+
 =end comment
 
 given "foo bar" {
@@ -589,6 +550,7 @@ The categories are:
 The associativity and precedence list are explained below.
 
 Alright, you're set to go!
+
 =end comment
 
 #
@@ -680,11 +642,9 @@ my @natural = 1..*; # 1 to Infinite! Equivalent to `1..Inf`.
 # You can pass ranges as subscripts and it'll return an array of results.
 say @natural[^10]; # OUTPUT: «1 2 3 4 5 6 7 8 9 10�», doesn't run out of memory!
 
-=begin comment
-NOTE: when reading an infinite list, Raku 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.
-=end comment
+# NOTE: when reading an infinite list, Raku 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 than that are needed.
 
 # An array subscript can also be a closure. It'll be called with the array's
 # length as the argument. The following two examples are equivalent:
@@ -728,7 +688,7 @@ say (0 or False); # OUTPUT: «False�».
 my ($a, $b, $c, $d, $e) = 1, 0, False, True, 'pi';
 say $a && $b && $c; # OUTPUT: «0�», the first falsey value
 say $a && $b && $c; # OUTPUT: «False�», the first falsey value
-say $a && $d && $e; # OUTPUT: «pi�», last operand since everthing before is truthy
+say $a && $d && $e; # OUTPUT: «pi�», last operand since everything before is truthy
 
 # `||` returns the first argument that evaluates to `True`.
 say $b || $a || $d; # OUTPUT: «1�»
@@ -784,7 +744,7 @@ first-of-array(@small); #=> 1
 # Here, `@rest` is `(3,)`, since `$fst` holds the `2`. This results
 # since the length (.elems) of `@rest` is 1.
 sub slurp-in-array(@ [$fst, *@rest]) {
-    say $fst + @rest.elems;           
+    say $fst + @rest.elems;
 }
 slurp-in-array(@tail); # OUTPUT: «3�»
 
@@ -798,16 +758,14 @@ fst(1);    # OUTPUT: «1�»
 # passed") though. After all, the `fst` sub declares only a single positional
 # parameter.
 
-=begin comment
-You can also destructure hashes (and classes, which you'll learn about later).
-The syntax is basically the same as
-`%hash-name (:key($variable-to-store-value-in))`.
-The hash can stay anonymous if you only need the values you extracted.
-
-In order to call the function, you must supply a hash wither created with
-curly braces or with `%()` (recommended). Alternatively, you can pass
-a variable that contains a hash.
-=end comment
+# You can also destructure hashes (and classes, which you'll learn about later).
+# The syntax is basically the same as
+# `%hash-name (:key($variable-to-store-value-in))`.
+# The hash can stay anonymous if you only need the values you extracted.
+
+# In order to call the function, you must supply a hash wither created with
+# curly braces or with `%()` (recommended). Alternatively, you can pass
+# a variable that contains a hash.
 
 sub key-of( % (:value($val), :qua($qua)) ) {
  	say "Got value $val, $qua time" ~~
@@ -826,12 +784,10 @@ sub next-index( $n ) {
 }
 my $new-n = next-index(3); # $new-n is now 4
 
-=begin comment
-This is true for everything, except for the looping constructs (due to
-performance reasons): there's no reason to build a list if we're just going to
-discard all the results. If you still want to build one, you can use the
-`do` statement prefix or the `gather` prefix, which we'll see later:
-=end comment
+# This is true for everything, except for the looping constructs (due to
+# performance reasons): there's no reason to build a list if we're just going to
+# discard all the results. If you still want to build one, you can use the
+# `do` statement prefix or the `gather` prefix, which we'll see later:
 
 sub list-of( $n ) {
  	do for ^$n { $_ }
@@ -857,13 +813,11 @@ my &lambda3 = sub ($argument) {
 	"The argument passed to this lambda is $argument"
 }
 
-=begin comment
-Both pointy blocks and blocks are pretty much the same thing, except that
-the former can take arguments, and that the latter can be mistaken as
-a hash by the parser. That being said, blocks can declare what's known
-as placeholders parameters through the twigils `$^` (for positional
-parameters) and `$:` (for named parameters). More on them later on.
-=end comment
+# Both pointy blocks and blocks are pretty much the same thing, except that
+# the former can take arguments, and that the latter can be mistaken as
+# a hash by the parser. That being said, blocks can declare what's known
+# as placeholders parameters through the twigils `$^` (for positional
+# parameters) and `$:` (for named parameters). More on them later on.
 
 my &mult = { $^numbers * $:times }
 say mult 4, :times(6); #=> «24�»
@@ -876,12 +830,10 @@ my @res1 = map -> $v { $v + 3 }, @nums; # pointy block, explicit parameter
 my @res2 = map { $_ + 3 },       @nums; # block using an implicit parameter
 my @res3 = map { $^val + 3 },    @nums; # block with placeholder parameter
 
-=begin comment
-A sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`):
-A block doesn't have a "function context" (though it can have arguments),
-which means that if you return from it, you're going to return from the
-parent function.
-=end comment
+# A sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`):
+# A block doesn't have a "function context" (though it can have arguments),
+# which means that if you return from it, you're going to return from the
+# parent function.
 
 # Compare:
 sub is-in( @array, $elem ) {
@@ -895,23 +847,19 @@ sub truthy-array( @array ) {
     say 'Hi';
 }
 
-=begin comment
-In the `is-in` sub, the block will `return` out of the `is-in` sub once the
-condition evaluates to `True`, the loop won't be run anymore and the
-following statement won't be executed. The last statement is only executed
-if the block never returns.
-
-On the contrary, the `truthy-array` sub will produce an array of `True` and
-`False`, which will printed, and always execute the last execute statement.
-Thus, the `return` only returns from the anonymous `sub`
-=end comment
+# In the `is-in` sub, the block will `return` out of the `is-in` sub once the
+# condition evaluates to `True`, the loop won't be run anymore and the
+# following statement won't be executed. The last statement is only executed
+# if the block never returns.
 
-=begin comment
-The `anon` declarator can be used to create an anonymous sub from a
-regular subroutine. The regular sub knows its name but its symbol is
-prevented from getting installed in the lexical scope, the method table
-and everywhere else.
-=end comment
+# On the contrary, the `truthy-array` sub will produce an array of `True` and
+# `False`, which will printed, and always execute the last execute statement.
+# Thus, the `return` only returns from the anonymous `sub`
+
+# The `anon` declarator can be used to create an anonymous sub from a
+# regular subroutine. The regular sub knows its name but its symbol is
+# prevented from getting installed in the lexical scope, the method table
+# and everywhere else.
 my $anon-sum = anon sub summation(*@a) { [+] @a }
 say $anon-sum.name;     # OUTPUT: «summation�»
 say $anon-sum(2, 3, 5); # OUTPUT: «10�»
@@ -983,31 +931,27 @@ multi with-or-without-you {
     say "Definitely can't live.";
 }
 
-=begin comment
-This is very, very useful for many purposes, like `MAIN` subs (covered
-later), and even the language itself uses it in several places.
+# This is very, very useful for many purposes, like `MAIN` subs (covered
+# later), and even the language itself uses it in several places.
 
-For example, the `is` trait is actually a `multi sub` named `trait_mod:<is>`,
-and it works off that. Thus, `is rw`, is simply a dispatch to a function with
-this signature `sub trait_mod:<is>(Routine $r, :$rw!) {}`
-=end comment
+# For example, the `is` trait is actually a `multi sub` named `trait_mod:<is>`,
+# and it works off that. Thus, `is rw`, is simply a dispatch to a function with
+# this signature `sub trait_mod:<is>(Routine $r, :$rw!) {}`
 
 ####################################################
 # 7. About types...
 ####################################################
 
-=begin comment
-Raku is gradually typed. This means you can specify the type of your
-variables/arguments/return types, or you can omit the type annotations in
-in which case they'll default to `Any`. Obviously you get access to a few
-base types, like `Int` and `Str`. The constructs for declaring types are
-`subset`, `class`, `role`, etc. which you'll see later.
-
-For now, let us examine `subset` which is a "sub-type" with additional
-checks. For example, "a very big integer is an `Int` that's greater than 500".
-You can specify the type you're subtyping (by default, `Any`), and add
-additional checks with the `where` clause.
-=end comment
+# Raku is gradually typed. This means you can specify the type of your
+# variables/arguments/return types, or you can omit the type annotations in
+# in which case they'll default to `Any`. Obviously you get access to a few
+# base types, like `Int` and `Str`. The constructs for declaring types are
+# `subset`, `class`, `role`, etc. which you'll see later.
+
+# For now, let us examine `subset` which is a "sub-type" with additional
+# checks. For example, "a very big integer is an `Int` that's greater than 500".
+# You can specify the type you're subtyping (by default, `Any`), and add
+# additional checks with the `where` clause.
 subset VeryBigInteger of Int where * > 500;
 
 # Or the set of the whole numbers:
@@ -1025,14 +969,12 @@ my PENFO $yes-penfo = 36;  # OK
 # 8. Scoping
 ####################################################
 
-=begin comment
-In Raku, unlike many scripting languages, (such as Python, Ruby, PHP),
-you must declare your variables before using them. The `my` declarator
-we've used so far 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.
-=end comment
+# In Raku, unlike many scripting languages, (such as Python, Ruby, PHP),
+# you must declare your variables before using them. The `my` declarator
+# we've used so far 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 $file_scoped = 'Foo';
 sub outer {
@@ -1052,17 +994,15 @@ outer()();  # OUTPUT: «Foo Bar�»
 # 9. Twigils
 ####################################################
 
-=begin comment
-There are many special `twigils` (composed sigils) in Raku. Twigils
-define a variable's scope.
-The `*` and `?` twigils work on standard variables:
-    * for dynamic variables
-    ? for compile-time variables
-
-The `!` and the `.` twigils are used with Raku's objects:
-    ! for attributes (instance attribute)
-    . for methods (not really a variable)
-=end comment
+# There are many special `twigils` (composed sigils) in Raku. Twigils
+# define a variable's scope.
+# The `*` and `?` twigils work on standard variables:
+#     * for dynamic variables
+#     ? for compile-time variables
+#
+# The `!` and the `.` twigils are used with Raku's objects:
+#     ! for attributes (instance attribute)
+#     . for methods (not really a variable)
 
 #
 # `*` twigil: Dynamic Scope
@@ -1084,14 +1024,14 @@ sub call_say_dyn {
     my $*dyn_scoped_1 = 25;
 
     # Will change the value of the file scoped variable.
-    $*dyn_scoped_2 = 100;  
+    $*dyn_scoped_2 = 100;
 
     # $*dyn_scoped 1 and 2 will be looked for in the call.
     say_dyn();  # OUTPUT: «25 100�»
 
     # The call to `say_dyn` uses the value of $*dyn_scoped_1 from inside
     # this sub's lexical scope even though the blocks aren't nested (they're
-    # call-nested).                     
+    # call-nested).
 }
 say_dyn();      # OUTPUT: «1 10�»
 
@@ -1109,26 +1049,24 @@ say_dyn();      # OUTPUT: «1 100�»
 # 10. Object Model
 ####################################################
 
-=begin comment
-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 the `method` keyword.
-
-Every attribute that is private uses the `!` twigil. For example: `$!attr`.
-Immutable public attributes use the `.` twigil which creates a read-only
-method named after the attribute. In fact, declaring an attribute with `.`
-is equivalent to declaring the same attribute with `!` and then creating
-a read-only method with the attribute's name. However, this is done for us
-by Raku automatically. The easiest way to remember the `$.` twigil is
-by comparing it to how methods are called.
-
-Raku's object model ("SixModel") is very flexible, and allows you to
-dynamically add methods, change semantics, etc... Unfortunately, these will
-not all be covered here, and you should refer to:
-https://docs.raku.org/language/objects.html.
-=end comment
+# 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 the `method` keyword.
+
+# Every attribute that is private uses the `!` twigil. For example: `$!attr`.
+# Immutable public attributes use the `.` twigil which creates a read-only
+# method named after the attribute. In fact, declaring an attribute with `.`
+# is equivalent to declaring the same attribute with `!` and then creating
+# a read-only method with the attribute's name. However, this is done for us
+# by Raku automatically. The easiest way to remember the `$.` twigil is
+# by comparing it to how methods are called.
+
+# Raku's object model ("SixModel") is very flexible, and allows you to
+# dynamically add methods, change semantics, etc... Unfortunately, these will
+# not all be covered here, and you should refer to:
+# https://docs.raku.org/language/objects.html.
 
 class Human {
     has Str $.name;           # `$.name` is immutable but with an accessor method.
@@ -1196,12 +1134,10 @@ $person1.get-info;      #=> Jord born in Togo and now lives in France. Age: 10
 # 10.1 Object Inheritance
 #
 
-=begin comment
-Raku also has inheritance (along with multiple inheritance). While
-methods are inherited, submethods are not. Submethods are useful for
-object construction and destruction tasks, such as `BUILD`, or methods that
-must be overridden by subtypes. We will learn about `BUILD` later on.
-=end  comment
+# Raku also has inheritance (along with multiple inheritance). While
+# methods are inherited, submethods are not. Submethods are useful for
+# object construction and destruction tasks, such as `BUILD`, or methods that
+# must be overridden by subtypes. We will learn about `BUILD` later on.
 
 class Parent {
   	has $.age;
@@ -1232,13 +1168,11 @@ my Child $Madison .= new(age => 1, name => 'Madison');
 $Madison.talk;            # OUTPUT: «Goo goo ga ga�», due to the overridden method.
 # $Madison.favorite-color # does not work since it is not inherited.
 
-=begin comment
-When you use `my T $var`, `$var` starts off with `T` itself in it, so you can
-call `new` on it. (`.=` is just the dot-call and the assignment operator).
-Thus, `$a .= b` is the same as `$a = $a.b`. Also note that `BUILD` (the method
-called inside `new`) will set parent's properties too, so you can pass `val =>
-5`.
-=end comment
+# When you use `my T $var`, `$var` starts off with `T` itself in it, so you can
+# call `new` on it. (`.=` is just the dot-call and the assignment operator).
+# Thus, `$a .= b` is the same as `$a = $a.b`. Also note that `BUILD` (the method
+# called inside `new`) will set parent's properties too, so you can pass `val =>
+# 5`.
 
 #
 # 10.2 Roles, or Mixins
@@ -1281,15 +1215,13 @@ class Item does PrintableVal {
 # 11. Exceptions
 ####################################################
 
-=begin comment
-Exceptions are built on top of classes, in the package `X` (like `X::IO`).
-In Raku, exceptions are automatically 'thrown':
+# Exceptions are built on top of classes, in the package `X` (like `X::IO`).
+# In Raku, exceptions are automatically 'thrown':
 
-open 'foo';   # OUTPUT: «Failed to open file foo: no such file or directory�»
+# open 'foo';   # OUTPUT: «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.
-=end comment
+# It will also print out what line the error was thrown at
+# and other error info.
 
 # You can throw an exception using `die`. Here it's been commented out to
 # avoid stopping the program's execution:
@@ -1298,58 +1230,48 @@ and other error info.
 # Or more explicitly (commented out too):
 # X::AdHoc.new(payload => 'Error!').throw; # OUTPUT: «Error!�»
 
-=begin comment
-In Raku, `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:
-=end comment
+# In Raku, `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 $uninitialized.defined; # OUTPUT: «False�»
 
-=begin comment
-When using `orelse` it will disarm the exception and alias $_ to that
-failure. This will prevent it to being automatically handled and printing
-lots of scary error messages to the screen. We can use the `exception`
-method on the `$_` variable to access the exception
-=end comment
+# When using `orelse` it will disarm the exception and alias $_ to that
+# failure. This will prevent it to being automatically handled and printing
+# lots of scary error messages to the screen. We can use the `exception`
+# method on the `$_` variable to access the exception
 open 'foo' orelse say "Something happened {.exception}";
 
 # This also works:
 open 'foo' orelse say "Something happened $_";
 # OUTPUT: «Something happened Failed to open file foo: no such file or directory�»
 
-=begin comment
-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.
-=end comment
+# 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.
 
 #
 # 11.1 Using `try` and `CATCH`
 #
 
-=begin comment
-By using `try` and `CATCH` you can contain and handle exceptions without
-disrupting the rest of the program. The `try` block will set the last
-exception to the special variable `$!` (known as the error variable).
-NOTE: This has no relation to $!variables seen inside class definitions.
-=end comment
+# By using `try` and `CATCH` you can contain and handle exceptions without
+# disrupting the rest of the program. The `try` block will set the last
+# exception to the special variable `$!` (known as the error variable).
+# NOTE: This has no relation to $!variables seen inside class definitions.
 
 try open 'foo';
 say "Well, I tried! $!" if defined $!;
 # OUTPUT: «Well, I tried! Failed to open file foo: no such file or directory�»
 
-=begin comment
-Now, what if we want more control over handling the exception?
-Unlike many other languages, in Raku, you put the `CATCH` block *within*
-the block to `try`. Similar to how the `$_` variable was set when we
-'disarmed' the exception with `orelse`, we also use `$_` in the CATCH block.
-NOTE: The `$!` variable is only set *after* the `try` block has caught an
-exception. By default, a `try` block has a `CATCH` block of its own that
-catches any exception (`CATCH { default {} }`).
-=end comment
+# Now, what if we want more control over handling the exception?
+# Unlike many other languages, in Raku, you put the `CATCH` block *within*
+# the block to `try`. Similar to how the `$_` variable was set when we
+# 'disarmed' the exception with `orelse`, we also use `$_` in the CATCH block.
+# NOTE: The `$!` variable is only set *after* the `try` block has caught an
+# exception. By default, a `try` block has a `CATCH` block of its own that
+# catches any exception (`CATCH { default {} }`).
 
 try {
     my $a = (0 %% 0);
@@ -1387,15 +1309,13 @@ try {
 }
 # OUTPUT: «Failed to open file /dir/foo: no such file or directory�»
 
-=begin comment
-There are also some subtleties to exceptions. Some Raku subs return a
-`Failure`, which is a wrapper around an `Exception` object which is
-"unthrown". They're not thrown until you try to use the variables containing
-them 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`).
-=end comment
+# There are also some subtleties to exceptions. Some Raku subs return a
+# `Failure`, which is a wrapper around an `Exception` object which is
+# "unthrown". They're not thrown until you try to use the variables containing
+# them 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`).
 
 my $value = 0/0; # We're not trying to access the value, so no problem.
 try {
@@ -1407,34 +1327,28 @@ try {
   }
 }
 
-=begin comment
-There is also another kind of exception: Control exceptions. 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).
-=end comment
+# There is also another kind of exception: Control exceptions. 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).
 
 ####################################################
 # 12. Packages
 ####################################################
 
-=begin comment
-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.
-=end comment
+# 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 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; # OUTPUT: «[1]�»
 
-=begin comment
-You should not declare packages using the `package` keyword (unlike Perl).
-Instead, use `class Package::Name::Here;` to declare a class, or if you only
-want to export variables/subs, you can use `module` instead.
-=end comment
+# You should not declare packages using the `package` keyword (unlike Perl).
+# Instead, use `class Package::Name::Here;` to declare a class, or if you only
+# want to export variables/subs, you can use `module` instead.
 
 # If `Hello` doesn't exist yet, it'll just be a "stub", that can be redeclared
 # as something else later.
@@ -1460,14 +1374,12 @@ my $actions = JSON::Tiny::Actions.new;
 # 13. Declarators
 ####################################################
 
-=begin comment
-In Raku, you get different behaviors based on how you declare a variable.
-You've already seen `my` and `has`, we'll now explore the others.
+# In Raku, 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` - these declarations happen at `INIT` time -- (see "Phasers" below).
-It's like `my`, but it also creates a package variable. All packagish
-things such as `class`, `role`, etc. are `our` by default.
-=end comment
+# `our` - these declarations happen at `INIT` time -- (see "Phasers" below).
+# It's like `my`, but it also creates a package variable. All packagish
+# things such as `class`, `role`, etc. are `our` by default.
 
 module Var::Increment {
     # NOTE: `our`-declared variables cannot be typed.
@@ -1533,15 +1445,13 @@ for ^5 -> $a {
 # 14. Phasers
 ####################################################
 
-=begin comment
-Phasers in Raku are blocks that happen at determined points of time in
-your 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 (The `CATCH` block 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). Let's have a look!
-=end comment
+# Phasers in Raku are blocks that happen at determined points of time in
+# your 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 (The `CATCH` block 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). Let's have a look!
 
 #
 # 14.1 Compile-time phasers
@@ -1637,14 +1547,11 @@ do-db-stuff();
 # 15. Statement prefixes
 ####################################################
 
-=begin comment
-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
-elsewhere) NOTE: all of these (except start) don't need explicit curly
-braces `{` and `}`.
-
-=end comment
+# 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
+# elsewhere) NOTE: all of these (except start) don't need explicit curly
+# braces `{` and `}`.
 
 #
 # 15.1 `do` - It runs a block or a statement as a term.
@@ -1757,40 +1664,34 @@ quietly { warn 'This is a warning!' }; # No output
 
 my ($p, $q, $r) = (1, 2, 3);
 
-=begin comment
-Given some binary operator § (not a Raku-supported operator), then:
+# Given some binary operator § (not a Raku-supported operator), then:
 
-$p § $q § $r; # with a left-associative  §, this is ($p § $q) § $r
-$p § $q § $r; # with a right-associative §, this is $p § ($q § $r)
-$p § $q § $r; # with a non-associative   §, this is illegal
-$p § $q § $r; # with a chain-associative §, this is ($p § $q) and ($q § $r)§
-$p § $q § $r; # with a list-associative  §, this is `infix:<>`
-=end comment
+# $p § $q § $r; # with a left-associative  §, this is ($p § $q) § $r
+# $p § $q § $r; # with a right-associative §, this is $p § ($q § $r)
+# $p § $q § $r; # with a non-associative   §, this is illegal
+# $p § $q § $r; # with a chain-associative §, this is ($p § $q) and ($q § $r)§
+# $p § $q § $r; # with a list-associative  §, this is `infix:<>`
 
 #
 # 17.2 Unary operators
 #
 
-=begin comment
-Given some unary operator § (not a Raku-supported operator), then:
-§$p§ # with left-associative  §, this is (§$p)§
-§$p§ # with right-associative §, this is §($p§)
-§$p§ # with non-associative   §, this is illegal
-=end comment
+# Given some unary operator § (not a Raku-supported operator), then:
+# §$p§ # with left-associative  §, this is (§$p)§
+# §$p§ # with right-associative §, this is §($p§)
+# §$p§ # with non-associative   §, this is illegal
 
 #
 # 17.3 Create your own operators!
 #
 
-=begin comment
-Okay, you've been reading all of that, so you might want to try something
-more exciting?! I'll tell you a little secret (or not-so-secret):
-In Raku, all operators are actually just funny-looking subroutines.
+# Okay, you've been reading all of that, so you might want to try something
+# more exciting?! I'll tell you a little secret (or not-so-secret):
+# In Raku, all operators are actually just funny-looking subroutines.
 
-You can declare an operator just like you declare a sub. In the following
-example, `prefix` refers to the operator categories (prefix, infix, postfix,
-circumfix, and post-circumfix).
-=end comment
+# You can declare an operator just like you declare a sub. In the following
+# example, `prefix` refers to the operator categories (prefix, infix, postfix,
+# circumfix, and post-circumfix).
 sub prefix:<win>( $winner ) {
 	say "$winner Won!";
 }
@@ -1834,12 +1735,10 @@ say "abc"{1}; # OUTPUT: «b�», after the term `"abc"`, and around the index (
 
 # Post-circumfix is 'after a term, around something'
 
-=begin comment
-This really means a lot -- because everything in Raku uses this.
-For example, to delete a key from a hash, you use the `:delete` adverb
-(a simple named argument underneath). For instance, the following statements
-are equivalent.
-=end comment
+# This really means a lot -- because everything in Raku uses this.
+# For example, to delete a key from a hash, you use the `:delete` adverb
+# (a simple named argument underneath). For instance, the following statements
+# are equivalent.
 my %person-stans =
     'Giorno Giovanna'  => 'Gold Experience',
     'Bruno Bucciarati' => 'Sticky Fingers';
@@ -1848,34 +1747,30 @@ my $key = 'Bruno Bucciarati';
 postcircumfix:<{ }>( %person-stans, 'Giorno Giovanna', :delete );
 # (you can call operators like this)
 
-=begin comment
-It's *all* using the same building blocks! Syntactic categories
-(prefix infix ...), named arguments (adverbs), ..., etc. used to build
-the language - are available to you. Obviously, you're advised against
-making an operator out of *everything* -- with great power comes great
-responsibility.
-=end comment
+# It's *all* using the same building blocks! Syntactic categories
+# (prefix infix ...), named arguments (adverbs), ..., etc. used to build
+# the language - are available to you. Obviously, you're advised against
+# making an operator out of *everything* -- with great power comes great
+# responsibility.
 
 #
 # 17.4 Meta operators!
 #
 
-=begin comment
-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 this. (I'm guessing you don't want to go back at this point but
-let's continue, for the journey is long and enjoyable!).
-
-Meta-operators, as their name suggests, are *composed* operators. Basically,
-they're operators that act on another operators.
-
-The reduce meta-operator is a prefix meta-operator that takes a binary
-function and one or many lists. If it doesn't get passed any argument,
-it either returns a "default value" for this operator (a meaningless value)
-or `Any` if there's none (examples below). Otherwise, it pops an element
-from the list(s) one at a time, and applies the binary function to the last
-result (or the first element of a list) and the popped element.
-=end comment
+# 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 this. (I'm guessing you don't want to go back at this point but
+# let's continue, for the journey is long and enjoyable!).
+
+# Meta-operators, as their name suggests, are *composed* operators. Basically,
+# they're operators that act on another operators.
+
+# The reduce meta-operator is a prefix meta-operator that takes a binary
+# function and one or many lists. If it doesn't get passed any argument,
+# it either returns a "default value" for this operator (a meaningless value)
+# or `Any` if there's none (examples below). Otherwise, it pops an element
+# from the list(s) one at a time, and applies the binary function to the last
+# result (or the first element of a list) and the popped element.
 
 # To sum a list, you could use the reduce meta-operator with `+`, i.e.:
 say [+] 1, 2, 3; # OUTPUT: «6�», equivalent to (1+2)+3.
@@ -1903,13 +1798,11 @@ say [//];   # OUTPUT: «(Any)�»
 sub add($a, $b) { $a + $b }
 say [[&add]] 1, 2, 3; # OUTPUT: «6�»
 
-=begin comment
-The zip meta-operator is an infix meta-operator that 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.
-=end comment
+# The zip meta-operator is an infix meta-operator that 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.
 say (1, 2) Z (3, 4); # OUTPUT: «((1, 3), (2, 4))�»
 say 1..3 Z+ 4..6;    # OUTPUT: «(5, 7, 9)�»
 
@@ -1922,12 +1815,10 @@ say 1..3 Z+ 4..6;    # OUTPUT: «(5, 7, 9)�»
 
 # And to end the operator list:
 
-=begin comment
-The sequence operator (`...`) is one of Raku's most powerful features:
-It's composed by the list (which might include a closure) you want Raku to
-deduce from on the left and a value (or either a predicate or a Whatever Star
-for a lazy infinite list) on the right that states when to stop.
-=end comment
+# The sequence operator (`...`) is one of Raku's most powerful features:
+# It's composed by the list (which might include a closure) you want Raku to
+# deduce from on the left and a value (or either a predicate or a Whatever Star
+# for a lazy infinite list) on the right that states when to stop.
 
 # Basic arithmetic sequence
 my @listv0 = 1, 2, 3...10;
@@ -1954,68 +1845,60 @@ my @fibv1 = 1, 1, -> $a, $b { $a + $b } ... *;
 # Equivalent to the above example but using a block with placeholder parameters.
 my @fibv2 = 1, 1, { $^a + $^b } ... *;
 
-=begin comment
-In the examples with explicit parameters (i.e., $a and $b), $a and $b
-will always take the previous values, meaning that for the Fibonacci sequence,
-they'll start with $a = 1 and $b = 1 (values we set by hand), then $a = 1
-and $b = 2 (result from previous $a + $b), and so on.
-=end comment
+# In the examples with explicit parameters (i.e., $a and $b), $a and $b
+# will always take the previous values, meaning that for the Fibonacci sequence,
+# they'll start with $a = 1 and $b = 1 (values we set by hand), then $a = 1
+# and $b = 2 (result from previous $a + $b), and so on.
 
-=begin comment
 # In the example we use a range as an index to access the sequence. However,
 # it's worth noting that for ranges, once reified, elements aren't re-calculated.
 # That's why, for instance, `@primes[^100]` will take a long time the first
-# time you print it but then it will be instateneous.
-=end comment
+# time you print it but then it will be instantaneous.
 say @fibv0[^10]; # OUTPUT: «1 1 2 3 5 8 13 21 34 55�»
 
 ####################################################
 # 18. Regular Expressions
 ####################################################
 
-=begin comment
-I'm sure a lot of you have been waiting for this one. Well, now that you know
-a good deal of Raku already, we can get started. First off, you'll have to
-forget about "PCRE regexps" (perl-compatible regexps).
-
-IMPORTANT: Don't skip them because you know PCRE. They're different. Some
-things are the same (like `?`, `+`, and `*`), but sometimes the semantics
-change (`|`). Make sure you read carefully, because you might trip over a
-new behavior.
-
-Raku has many features related to RegExps. After all, Rakudo parses itself.
-We're first going to look at the syntax itself, then talk about grammars
-(PEG-like), differences between `token`, `regex` and `rule` declarators,
-and some more. Side note: you still have access to PCRE regexps using the
-`:P5` modifier which we won't be discussing this in this tutorial, though.
-
-In essence, Raku natively implements PEG ("Parsing Expression Grammars").
-The pecking order for ambiguous parses is determined by a multi-level
-tie-breaking test:
- - Longest token matching: `foo\s+` beats `foo` (by 2 or more positions)
- - Longest literal prefix: `food\w*` beats `foo\w*` (by 1)
- - Declaration from most-derived to less derived grammars
-   (grammars are actually classes)
- - Earliest declaration wins
-=end comment
+# I'm sure a lot of you have been waiting for this one. Well, now that you know
+# a good deal of Raku already, we can get started. First off, you'll have to
+# forget about "PCRE regexps" (perl-compatible regexps).
+
+# IMPORTANT: Don't skip them because you know PCRE. They're different. Some
+# things are the same (like `?`, `+`, and `*`), but sometimes the semantics
+# change (`|`). Make sure you read carefully, because you might trip over a
+# new behavior.
+
+# Raku has many features related to RegExps. After all, Rakudo parses itself.
+# We're first going to look at the syntax itself, then talk about grammars
+# (PEG-like), differences between `token`, `regex` and `rule` declarators,
+# and some more. Side note: you still have access to PCRE regexps using the
+# `:P5` modifier which we won't be discussing this in this tutorial, though.
+
+# In essence, Raku natively implements PEG ("Parsing Expression Grammars").
+# The pecking order for ambiguous parses is determined by a multi-level
+# tie-breaking test:
+#  - Longest token matching: `foo\s+` beats `foo` (by 2 or more positions)
+#  - Longest literal prefix: `food\w*` beats `foo\w*` (by 1)
+#  - Declaration from most-derived to less derived grammars
+#    (grammars are actually classes)
+#  - Earliest declaration wins
 say so 'a' ~~ /a/;   # OUTPUT: «True�»
 say so 'a' ~~ / a /; # OUTPUT: «True�», more readable with some spaces!
 
-=begin comment
-In all our examples, we're going to use the smart-matching operator against
-a regexp. We're converting the result using `so` to a Boolean value because,
-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 in the `$/` variable (implicitly lexically-scoped). 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 character of the string. We'll
-explain later how you can do it.
-
-In Raku, you can have any alphanumeric as a literal, everything else has
-to be escaped by using a backslash or quotes.
-=end comment
+# In all our examples, we're going to use the smart-matching operator against
+# a regexp. We're converting the result using `so` to a Boolean value because,
+# 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 in the `$/` variable (implicitly lexically-scoped). 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 character of the string. We'll
+# explain later how you can do it.
+
+# In Raku, you can have any alphanumeric as a literal, everything else has
+# to be escaped by using a backslash or quotes.
 say so 'a|b' ~~ / a '|' b /; # OUTPUT: «True�», it wouldn't mean the same
                              # thing if `|` wasn't escaped.
 say so 'a|b' ~~ / a \| b /;  # OUTPUT: «True�», another way to escape it.
@@ -2030,12 +1913,10 @@ say so 'a b c' ~~ /:s a b c /; #=> `True`, we added the modifier `:s` here.
 say so 'a b c' ~~ / a b c /;   # OUTPUT: «False�»
 say so 'a b c' ~~ / a  b  c /; # OUTPUT: «False»
 
-=begin comment
-NOTE: 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.
-=end comment
+# NOTE: 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':
@@ -2084,7 +1965,7 @@ say so 'abbbbc' ~~ / a  b*  c /; # OUTPUT: «True�»
 say so 'aec' ~~ / a  b*  c /;    # OUTPUT: «False�», "b"(s) are optional, not replaceable.
 
 # `**` - (Unbound) Quantifier
-# If you squint hard enough, you might understand why exponentation is used
+# If you squint hard enough, you might understand why exponentiation is used
 # for quantity.
 say so 'abc' ~~ / a  b**1  c /;         # OUTPUT: «True�», exactly one time
 say so 'abc' ~~ / a  b**1..3  c /;      # OUTPUT: «True�», one to three times
@@ -2157,18 +2038,16 @@ say $/[0]; # OUTPUT: «｢ABC｣ ｢ABC｣�»,
 
 say $0;    # The same as above.
 
-=begin comment
-Our capture is `$0` because it's the first and only one capture in the
-regexp. You might be wondering why it's an array, and the answer is simple:
-Some captures (indexed using `$0`, `$/[0]` or a named one) will be an array
-if and only if they can have more than one element. Thus any capture with
-`*`, `+` and `**` (whatever the operands), but not with `?`.
-Let's use examples to see that:
-
-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.
-=end comment
+# Our capture is `$0` because it's the first and only one capture in the
+# regexp. You might be wondering why it's an array, and the answer is simple:
+# Some captures (indexed using `$0`, `$/[0]` or a named one) will be an array
+# if and only if they can have more than one element. Thus any capture with
+# `*`, `+` and `**` (whatever the operands), but not with `?`.
+# Let's use examples to see that:
+
+# 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.
 say so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; # OUTPUT: «True�»
 say $/[0];   # OUTPUT: «｢ABC｣�»
 say $0.WHAT; # OUTPUT: «(Match)�»
@@ -2187,17 +2066,15 @@ say $0.WHAT; # OUTPUT: «(Array)�», A specific quantifier will always capture
 say $/[0].Str;    # OUTPUT: «hello~�»
 say $/[0][0].Str; # OUTPUT: «~�»
 
-=begin comment
-This stems from a very simple fact: `$/` does not contain strings, integers
-or arrays, it only contains `Match` objects. These contain the `.list`, `.hash`
-and `.Str` methods but you can also just use `match<key>` for hash access
-and `match[idx]` for array access.
-
-In the following example, we can see `$_` is a list of `Match` objects.
-Each of them contain a wealth of information: where the match started/ended,
-the "ast" (see actions later), etc. You'll see named capture below with
-grammars.
-=end comment
+# This stems from a very simple fact: `$/` does not contain strings, integers
+# or arrays, it only contains `Match` objects. These contain the `.list`, `.hash`
+# and `.Str` methods but you can also just use `match<key>` for hash access
+# and `match[idx]` for array access.
+
+# In the following example, we can see `$_` is a list of `Match` objects.
+# Each of them contain a wealth of information: where the match started/ended,
+# the "ast" (see actions later), etc. You'll see named capture below with
+# grammars.
 say $/[0].list.perl; # OUTPUT: «(Match.new(...),).list�»
 
 # Alternation - the `or` of regexes
@@ -2210,19 +2087,17 @@ say so 'ayc' ~~ / a [ b | y ] c /; # OUTPUT: «True�», Obviously enough...
 # always try to match as much as possible in the string.
 say 'foo' ~~ / fo | foo /; # OUTPUT: «foo», instead of `fo`, because it's longer.
 
-=begin comment
-To decide which part is the "longest", it first splits the regex in two parts:
-
-    * The "declarative prefix" (the part that can be statically analyzed)
-    which includes alternations (`|`), conjunctions (`&`), sub-rule calls (not
-    yet introduced), literals, characters classes and quantifiers.
+# To decide which part is the "longest", it first splits the regex in two parts:
+#
+#     * The "declarative prefix" (the part that can be statically analyzed)
+#     which includes alternations (`|`), conjunctions (`&`), sub-rule calls (not
+#     yet introduced), literals, characters classes and quantifiers.
+#
+#     * The "procedural part" includes everything else: back-references,
+#     code assertions, and other things that can't traditionally be represented
+#     by normal regexps.
 
-    * The "procedural part" includes everything else: back-references,
-    code assertions, and other things that can't traditionally be represented
-    by normal regexps.
-
-Then, all the alternatives are tried at once, and the longest wins.
-=end comment
+# Then, all the alternatives are tried at once, and the longest wins.
 
 # Examples:
 # DECLARATIVE | PROCEDURAL
@@ -2243,55 +2118,49 @@ say 'foo' ~~ / fo || foo /; # OUTPUT: «fo�», in this case.
 # 19. Extra: the MAIN subroutine
 ####################################################
 
-=begin comment
-The `MAIN` subroutine is called when you run a Raku file directly. It's
-very powerful, because Raku actually parses the arguments and pass them
-as such to the sub. It also handles named argument (`--foo`) and will even
-go as far as to autogenerate a `--help` flag.
-=end comment
+# The `MAIN` subroutine is called when you run a Raku file directly. It's
+# very powerful, because Raku actually parses the arguments and pass them
+# as such to the sub. It also handles named argument (`--foo`) and will even
+# go as far as to autogenerate a `--help` flag.
 
 sub MAIN($name) {
     say "Hello, $name!";
 }
-=begin comment
-Supposing the code above is in file named cli.raku, then running in the command
-line (e.g., $ raku cli.raku) produces:
-Usage:
- cli.raku <name>
-=end comment
+# Supposing the code above is in file named cli.raku, then running in the command
+# line (e.g., $ raku cli.raku) produces:
+# Usage:
+# cli.raku <name>
 
-=begin comment
-And since MAIN is a regular Raku sub, you can have multi-dispatch:
-(using a `Bool` for the named argument so that we can do `--replace`
-instead of `--replace=1`. The presence of `--replace` indicates truthness
-while its absence falseness). For example:
+# And since MAIN is a regular Raku sub, you can have multi-dispatch:
+# (using a `Bool` for the named argument so that we can do `--replace`
+# instead of `--replace=1`. The presence of `--replace` indicates truthness
+# while its absence falseness). For example:
 
     # convert to IO object to check the file exists
+    =begin comment
     subset File of Str where *.IO.d;
 
     multi MAIN('add', $key, $value, Bool :$replace) { ... }
     multi MAIN('remove', $key) { ... }
     multi MAIN('import', File, Str :$as) { ... } # omitting parameter name
+    =end comment
 
-Thus $ raku cli.raku produces:
-Usage:
-  cli.raku [--replace] add <key> <value>
-  cli.raku remove <key>
-  cli.raku [--as=<Str>] import <File>
+# Thus $ raku cli.raku produces:
+# Usage:
+#   cli.raku [--replace] add <key> <value>
+#   cli.raku remove <key>
+#   cli.raku [--as=<Str>] import <File>
 
-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).
-=end comment
+# 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).
 
 ####################################################
 # 20. APPENDIX A:
 ####################################################
 
-=begin comment
-It's assumed by now you know the Raku basics. This section is just here to
-list some common operations, but which are not in the "main part" of the
-tutorial to avoid bloating it up.
-=end comment
+# It's assumed by now you know the Raku basics. This section is just here to
+# list some common operations, but which are not in the "main part" of the
+# tutorial to avoid bloating it up.
 
 #
 # 20.1 Operators
@@ -2316,14 +2185,12 @@ say Any // Nil // 0 // 5;        # OUTPUT: «0�»
 # its arguments is true
 say True ^^ False;               # OUTPUT: «True�»
 
-=begin comment
-Flip flops. These operators (`ff` and `fff`, equivalent to P5's `..`
-and `...`) are operators that take two predicates to test: They are `False`
-until their left side returns `True`, then are `True` until their right
-side returns `True`. Similar to ranges, you can exclude the iteration when
-it become `True`/`False` by using `^` on either side. Let's start with an
-example :
-=end comment
+# Flip flops. These operators (`ff` and `fff`, equivalent to P5's `..`
+# and `...`) are operators that take two predicates to test: They are `False`
+# until their left side returns `True`, then are `True` until their right
+# side returns `True`. Similar to ranges, you can exclude the iteration when
+# it become `True`/`False` by using `^` on either side. Let's start with an
+# example :
 
 for <well met young hero we shall meet later> {
     # by default, `ff`/`fff` smart-match (`~~`) against `$_`:
@@ -2336,20 +2203,16 @@ for <well met young hero we shall meet later> {
     }
 }
 
-=begin comment
-This will print "young hero we shall meet" (excluding "met"): the flip-flop
-will start returning `True` when it first encounters "met" (but will still
-return `False` for "met" itself, due to the leading `^` on `ff`), until it
-sees "meet", which is when it'll start returning `False`.
-=end comment
+# This will print "young hero we shall meet" (excluding "met"): the flip-flop
+# will start returning `True` when it first encounters "met" (but will still
+# return `False` for "met" itself, due to the leading `^` on `ff`), until it
+# sees "meet", which is when it'll start returning `False`.
 
-=begin comment
-The difference between `ff` (awk-style) and `fff` (sed-style) is that `ff`
-will test its right side right when its left side changes to `True`, and can
-get back to `False` right away (*except* it'll be `True` for the iteration
-that matched) while `fff` will wait for the next iteration to try its right
-side, once its left side changed:
-=end comment
+# The difference between `ff` (awk-style) and `fff` (sed-style) is that `ff`
+# will test its right side right when its left side changes to `True`, and can
+# get back to `False` right away (*except* it'll be `True` for the iteration
+# that matched) while `fff` will wait for the next iteration to try its right
+# side, once its left side changed:
 
 # The output is due to the right-hand-side being tested directly (and returning
 # `True`). "B"s are printed since it matched that time (it just went back to
@@ -2399,7 +2262,7 @@ This information may be a bit older but there are many great examples and
 explanations. Posts stopped at the end of 2015 when the language was declared
 stable and `Raku v6.c` was released.
 
-- Come along on `#raku` at [`irc.freenode.net`](https://webchat.freenode.net/?channels=#raku). The folks here are
+- Come along on `#raku` at [`irc.libera.chat`](https://web.libera.chat/?channel=#raku). The folks here are
 always helpful.
 
 - Check the [source of Raku's functions and
diff --git a/rdf.html.markdown b/rdf.html.markdown
new file mode 100644
index 00000000..5b2105b8
--- /dev/null
+++ b/rdf.html.markdown
@@ -0,0 +1,160 @@
+---
+language: RDF
+filename: learnrdf.ttl
+contributors:
+- ["Bob DuCharme", "http://bobdc.com/"]
+---
+
+RDF (Resource Description Framework) is a [W3C
+standard](https://www.w3.org/TR/2014/REC-rdf11-concepts-20140225/) data
+model. The W3C has standardized several RDF syntaxes; examples below use the
+most popular one, [Turtle](https://www.w3.org/TR/turtle/).
+
+One nice advantage of Turtle files is that if you concatenate any two
+syntactically valid Turtle files, you will have another syntactically valid
+Turtle file. This is one of many things about RDF that ease data integration.
+
+The W3C standard query language for RDF datasets is
+[SPARQL](https://www.w3.org/TR/sparql11-query/).
+
+RDF expresses all facts as three-part {subject, predicate, object} statements
+known as triples. Because the same entity can be the subject of some triples
+and the object of others, a set of triples can represent a graph data
+structure. A large-scale storage system for triples is called a triplestore,
+and falls into the graph database category of NoSQL databases.
+
+RDF subjects and predicates must be URIs (Uniform Resource Identifiers), which
+usually look like URLs but function as identifiers, not locators. The use of
+URIs provides context for resource identifiers to make them unambiguous—for
+example, to tell a book title from a job title.
+
+```
+# The hash symbol is the comment delimiter. 
+
+# Turtle triple statements end with periods like natural language sentences.
+
+# These two triples tell us that the mythical Example Company's
+# employee 134 has a hire date of 2022-11-12 and a family name of Smith:
+
+<http://example.com/emp134> <http://example.com/hireDate> "2022-11-12" .
+<http://example.com/emp134> <http://example.com/familyName> "Smith" .
+
+# Declaring prefixes to stand in for namespaces reduces verbosity. These
+# declarations typically go at the beginning of the file, but the only
+# requirement is that they come before the first use of the prefix they declare.
+
+@prefix ex: <http://example.com/> .
+ex:emp134 ex:hireDate "2022-11-12" .
+ex:emp134 ex:familyName "Smith" .
+
+# A semicolon means that the next triple uses the same subject as the last
+# one. This is handy for listing data about a single resource. The following
+# example means the same thing as the previous one.
+
+@prefix ex: <http://example.com/> .
+ex:emp134 ex:hireDate "2022-11-12" ;
+          ex:familyName "Smith" .
+
+# A comma means that the next triple has the same subject and predicate as
+# the previous one.
+
+ex:emp134 ex:nickname "Smithy", "Skipper", "Big J". 
+
+# Three single or double quote marks at the beginning and end of a value let
+# you define a  multi-line string value.
+
+ex:emp134 ex:description """
+Skipper joined the company in November. 
+
+He always has a joke for everyone.""" . 
+
+# Using URIs from existing standard vocabulary namespaces eases both data
+# integration and interoperability with the large amount of RDF that already
+# exists. Mixing and matching of standard and local custom namespaces is
+# common.
+
+@prefix vcard: <http://www.w3.org/2006/vcard/ns#> .
+ex:emp134 ex:hireDate "2022-11-12" ;
+          vcard:family-name "Smith" .
+
+# Related RDF standards provide vocabularies that are popular for basic
+# facts. The rdfs:label predicate from the RDF Schema standard is a common 
+# way to indicate a human-readable name.
+
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+ex:hireDate rdfs:label "hire date" . 
+
+# String object values can include language codes, making
+# multi-lingual representation of entities easier for applications
+# reading the data (for example, when generating a user interface).
+
+ex:hireDate rdfs:label "hire date"@en, "date d'embauche"@fr  . 
+
+# Representing a triple's object with a URI (or prefixed name) is not required
+# but lets you connect up triples into a graph.
+
+ex:emp134 vcard:family-name "Smith" .
+ex:emp113 vcard:family-name "Jones" ;
+          ex:reportsTo ex:emp134 . 
+
+# Objects can be datatypes from the XML Schema part 2 standard or your own
+# custom datatypes.
+
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+ex:emp134 vcard:family-name "Smith"^^xsd:string ;  # default data type
+          ex:hireDate "2022-11-12"^^xsd:date ;
+          ex:rating "3.5"^^ex:someCustomType . 
+
+# The use of schemas with RDF is optional. Schemas may describe all or a
+# subset of a dataset. They use a vocabulary described by the W3C RDF Schema
+# (RDFS) standard, usually with a prefix of rdfs.
+
+# These schemas are descriptive, to ease the accommodation of new
+# datasets, not proscriptive rules about how new data should be 
+# created. The following declares a class. (Note that RDFS is itself 
+# expressed in triples.)
+
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . 
+ex:Person rdf:type rdfs:Class .
+
+# The following triple means the same as the preceding one but 
+# uses a Turtle shortcut for terseness and more readability.
+
+ex:Person a rdfs:Class .
+
+# That last triple declares that ex:Person is an instance of a class, and the
+# following declares that employee 113 is an instance of the class Employee.
+
+ex:emp113 a ex:Employee . 
+
+# The first triple below is actually unnecessary because a typical
+# RDFS processor will infer from the second one that ex:Employee is a
+# class. (Only a subset of RDF parsers perform RDFS inferencing.)
+
+ex:Employee a rdfs:Class .
+ex:Employee rdfs:subClassOf ex:Person .
+
+# An RDF parser that reads the last four triples shown and understands
+# RDFS will infer that ex:emp113 is an instance of ex:Person, because
+# it's an instance of ex:Employee, a subclass of ex:Person.
+
+# RDFS lets you declare properties and associate them with classes. 
+# Properties are first class resources and don't "belong" to classes 
+# in the object-oriented sense. rdfs:domain means "the following object 
+# class uses the property named by this triple's subject". rdfs:range 
+# means "the property named by this triple's subject will have a value of 
+# the following class or type". 
+
+ex:birthday rdf:type rdf:Property ; 
+            rdfs:domain ex:Person ;
+            rdfs:range xsd:date .
+
+```
+
+## Further Reading
+
+* [RDF Primer — Turtle version](https://www.w3.org/2007/02/turtle/primer/) from the W3C
+* [What is RDF?](https://www.bobdc.com/blog/whatisrdf/) on bobdc.com
+* [What is RDFS?](https://www.bobdc.com/blog/whatisrdfs/) on bobdc.com 
+* [Introduction to RDF and SPARQL](https://data.europa.eu/sites/default/files/d2.1.2_training_module_1.3_introduction_to_rdf_sparql_en_edp.pdf) at data.europa.eu
+
diff --git a/ro-ro/clojure-ro.html.markdown b/ro-ro/clojure-ro.html.markdown
index 32ba9620..77052379 100644
--- a/ro-ro/clojure-ro.html.markdown
+++ b/ro-ro/clojure-ro.html.markdown
@@ -380,7 +380,7 @@ Clojuredocs.org contine documentatie cu exemple pentru majoritatea functiilor de
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
 4Clojure este o metoda excelenta pentru a exersa Clojure/FP (Programarea Functionala):
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org are un numar de article pentru incepatori:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/ro-ro/elixir-ro.html.markdown b/ro-ro/elixir-ro.html.markdown
index 10fec3c5..60500d64 100644
--- a/ro-ro/elixir-ro.html.markdown
+++ b/ro-ro/elixir-ro.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -22,7 +22,7 @@ posibilități.
 # Pentru comentarii pe mai multe linii nu există sintaxă separată,
 # de aceea folosiți mai multe linii cu comentarii.
 
-# Pentru a folosi shell-ul elixir utilizați comanda `iex`.
+# Pentru a folosi shell-ul Elixir utilizați comanda `iex`.
 # Compilați modulele cu comanda `elixirc`.
 
 # Ambele comenzi vor lucra în terminal, dacă ați instalat Elixir corect.
diff --git a/rst.html.markdown b/rst.html.markdown
index 56d54501..c68c1d54 100644
--- a/rst.html.markdown
+++ b/rst.html.markdown
@@ -8,7 +8,7 @@ filename: restructuredtext.rst
 
 RST, Restructured Text, is a file format created by the Python community to write documentation. It is part of [Docutils](https://docutils.sourceforge.io/rst.html).
 
-RST is a markdown language like HTML but is much more lightweight and easier to read.
+RST is a markup language like HTML but is much more lightweight and easier to read.
 
 
 ## Installation
@@ -33,7 +33,7 @@ $ pip install docutils
 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
+.. 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
@@ -80,15 +80,15 @@ France      Paris
 Japan       Tokyo
 =========== ========
 
-More complex tables can be done easily (merged columns and/or rows) but I suggest you to read the complete doc for this :)
+More complex tables 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 of not inserting unnecessary URLs in the visible 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/>`_ .
+- By adding an underscore after a word : GitHub_ and by adding the target URL after the text (this way has the advantage of not inserting unnecessary URLs in the visible 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/
+.. _GitHub: https://github.com/
 
 ```
 
diff --git a/ru-ru/asymptotic-notation-ru.html.markdown b/ru-ru/asymptotic-notation-ru.html.markdown
index 7fd02c47..02ebd205 100644
--- a/ru-ru/asymptotic-notation-ru.html.markdown
+++ b/ru-ru/asymptotic-notation-ru.html.markdown
@@ -1,225 +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://github.com/pru-mike"]

-lang: ru-ru

----

-

-# О-�имволика

-

-## Что �то такое?

-

-О-�имволика, или а�имптотиче�ка� запи�ь, — �то �и�тема �имволов, позвол�юща�

-оценить врем� выполнени� алгоритма, у�танавлива� зави�имо�ть времени выполнени�

-от увеличени� объёма входных данных. Она также изве�тна как оценка

-�ложно�ти алгоритмов. Станет ли алгоритм неверо�тно медленным, когда

-объём входных данных увеличит��? Будет ли алгоритм выполн�ть�� до�таточно бы�тро,

-е�ли объём входных данных возра�тёт? О-�имволика позвол�ет ответить на �ти

-вопро�ы.

-

-## Можно ли по-другому найти ответы на �ти вопро�ы?

-

-Один �по�об — �то под�читать чи�ло �лементарных операций в зави�имо�ти от

-различных объёмов входных данных. Хот� �то и приемлемое решение, тот объём

-работы, которого оно потребует, даже дл� про�тых алгоритмов делает его 

-и�пользование неоправданным.

-

-Другой �по�об — �то измерить, какое врем� алгоритм потребует дл� завершени� на

-различных объёмах входных данных. В то же врем�, точно�ть и отно�ительно�ть

-�того метода (полученное врем� будет отно�ить�� только к той машине, на которой 

-оно вычи�лено) зави�ит от �реды выполнени�: компьютерного аппаратного

-обе�печени�, мощно�ти проце��ора и т.д.

-

-## Виды О-�имволики

-

-В первом разделе �того документа мы определили, что О-�имволика

-позвол�ет оценивать алгоритмы в зави�имо�ти от изменени� размера входных

-данных. Пред�тавим, что алгоритм — �то функци� f, n — размер входных данных и 

-f(n) — врем� выполнени�. Тогда дл� данного алгоритма f � размером входных

-данных 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)), е�ли

-�уще�твуют дей�твительные кон�танты c (c > 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)), е�ли �уще�твуют дей�твительные кон�танты

-c (c > 0) и n<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) выполн�ет��

-дл� _**в�ех**_ кон�тант c > 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)

-выполн�ет�� дл� _**в�ех**_ кон�тант c > 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/)

-

-## С�ылки

-

-* [Оценки времени и�полнени�. Символ O()](http://algolist.manual.ru/misc/o_n.php)

-* [��имптотиче�кий анализ и теори� веро�тно�тей](https://www.lektorium.tv/course/22903)

-

-## С�ылки (англ.)

-

-* [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/)

-

+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Divay Prakash", "http://github.com/divayprakash"]
+translators:
+    - ["pru-mike", "http://github.com/pru-mike"]
+lang: ru-ru
+---
+
+# О-�имволика
+
+## Что �то такое?
+
+О-�имволика, или а�имптотиче�ка� запи�ь, — �то �и�тема �имволов, позвол�юща�
+оценить врем� выполнени� алгоритма, у�танавлива� зави�имо�ть времени выполнени�
+от увеличени� объёма входных данных. Она также изве�тна как оценка
+�ложно�ти алгоритмов. Станет ли алгоритм неверо�тно медленным, когда
+объём входных данных увеличит��? Будет ли алгоритм выполн�ть�� до�таточно бы�тро,
+е�ли объём входных данных возра�тёт? О-�имволика позвол�ет ответить на �ти
+вопро�ы.
+
+## Можно ли по-другому найти ответы на �ти вопро�ы?
+
+Один �по�об — �то под�читать чи�ло �лементарных операций в зави�имо�ти от
+различных объёмов входных данных. Хот� �то и приемлемое решение, тот объём
+работы, которого оно потребует, даже дл� про�тых алгоритмов делает его 
+и�пользование неоправданным.
+
+Другой �по�об — �то измерить, какое врем� алгоритм потребует дл� завершени� на
+различных объёмах входных данных. В то же врем�, точно�ть и отно�ительно�ть
+�того метода (полученное врем� будет отно�ить�� только к той машине, на которой 
+оно вычи�лено) зави�ит от �реды выполнени�: компьютерного аппаратного
+обе�печени�, мощно�ти проце��ора и т.д.
+
+## Виды О-�имволики
+
+В первом разделе �того документа мы определили, что О-�имволика
+позвол�ет оценивать алгоритмы в зави�имо�ти от изменени� размера входных
+данных. Пред�тавим, что алгоритм — �то функци� f, n — размер входных данных и 
+f(n) — врем� выполнени�. Тогда дл� данного алгоритма f � размером входных
+данных 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)), е�ли
+�уще�твуют дей�твительные кон�танты c (c > 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)), е�ли �уще�твуют дей�твительные кон�танты
+c (c > 0) и n<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) выполн�ет��
+дл� _**в�ех**_ кон�тант c > 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)
+выполн�ет�� дл� _**в�ех**_ кон�тант c > 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/)
+
+## С�ылки
+
+* [Оценки времени и�полнени�. Символ O()](http://algolist.manual.ru/misc/o_n.php)
+* [��имптотиче�кий анализ и теори� веро�тно�тей](https://www.lektorium.tv/course/22903)
+
+## С�ылки (англ.)
+
+* [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/binary-search-ru.html.markdown b/ru-ru/binary-search-ru.html.markdown
index 9ed62cb8..ab1a1585 100644
--- a/ru-ru/binary-search-ru.html.markdown
+++ b/ru-ru/binary-search-ru.html.markdown
@@ -55,7 +55,7 @@ def search(arr, x):
 
 ### �а заметку
 
-Суще�твует и друга� форма двоичного пои�ка, котора� можеть быть полезна.
+Суще�твует и друга� форма двоичного пои�ка, котора� может быть полезна.
 
 ## �а почитать
 
diff --git a/ru-ru/c++-ru.html.markdown b/ru-ru/c++-ru.html.markdown
index 3acfafa3..43e9e6a3 100644
--- a/ru-ru/c++-ru.html.markdown
+++ b/ru-ru/c++-ru.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-ru.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
@@ -17,7 +17,7 @@ C++ - компилируемый, Ñ�татичеÑ�ки типизированнÑ
 
 - "лучша� замена C"
 - �зык � поддержкой аб�тракции данных
-- �зык � поддержкой объектно-ориентированого программировани�
+- �зык � поддержкой объектно-ориентированного программировани�
 - �зык � поддержкой обобщенного программировани�
 
 Хот� его �интак�и� может показать�� более трудным или �ложным дл� понимани�, чем в более �овременных �зыках,
diff --git a/ru-ru/c-ru.html.markdown b/ru-ru/c-ru.html.markdown
index cc68d620..a146a76b 100644
--- a/ru-ru/c-ru.html.markdown
+++ b/ru-ru/c-ru.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c
+language: C
 filename: learnc-ru.c
 contributors:
     - ["Adam Bard", "http://adambard.com/"]
@@ -476,7 +476,7 @@ void str_reverse_through_pointer(char *str_in) {
 Е�ли у ва� по�вил�� вопро�, почитайте [compl.lang.c Frequently Asked Questions](http://c-faq.com).
 
 Очень важно и�пользовать правильные от�тупы и �тавить пробелы в нужных ме�тах.
-Читаемый код лучше чем кра�ивый или бы�трый код.
+Читаемый код лучше, чем кра�ивый или бы�трый код.
 Чтобы научить�� пи�ать хороший код, почитайте [Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle).
 
 Также не забывайте, что [Google](http://google.com) и [Яндек�](http://yandex.ru) – ваши хорошие друзь�.
diff --git a/ru-ru/clojure-ru.html.markdown b/ru-ru/clojure-ru.html.markdown
index 19233d23..66986fa0 100644
--- a/ru-ru/clojure-ru.html.markdown
+++ b/ru-ru/clojure-ru.html.markdown
@@ -421,7 +421,7 @@ Clojuredocs.org — �айт документации �зыка � пример
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
 4Clojure — отличный �по�об закрепить навыки программировани� на clojure, реша� задачи вме�те � коллегами �о в�его мира:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org (да, именно) неплохой перечень �татей дл� начинающих:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/ru-ru/common-lisp-ru.html.markdown b/ru-ru/common-lisp-ru.html.markdown
index d5f9bf0e..0490ee30 100644
--- a/ru-ru/common-lisp-ru.html.markdown
+++ b/ru-ru/common-lisp-ru.html.markdown
@@ -14,7 +14,8 @@ Common Lisp - мультипарадигменный �зык программи
 �пектра задач.
 Его ча�тенько называют программируемым �зыком программировани�.
 
-Идеальна� отправна� точка - книга [Common Lisp на практике (перевод)](http://lisper.ru/pcl/).
+Идеальна� отправна� точка - книга
+[Common Lisp на практике (перевод)](https://github.com/pcl-ru/pcl-ru/releases/download/v1.1/pcl-ru.pdf).
 Ещё одна попул�рна� книга [Land of Lisp](http://landoflisp.com/).
 И одна из по�ледних книг [Common Lisp Recipes](http://weitz.de/cl-recipes/) вобрала в �еб� лучшие
 архитектурные решени� на о�нове опыта коммерче�кой работки автора.
@@ -674,7 +675,7 @@ nil                    ; ложь; а ещё пу�той �пи�ок () тож
 ## Дл� чтени�
 
 �а ру��ком
-- [Practical Common Lisp](http://www.gigamonkeys.com/book/)
+- [Practical Common Lisp](https://github.com/pcl-ru/pcl-ru/releases/download/v1.1/pcl-ru.pdf)
 
 �а англий�ком
 - [Practical Common Lisp](http://www.gigamonkeys.com/book/)
@@ -685,7 +686,7 @@ nil                    ; ложь; а ещё пу�той �пи�ок () тож
 
 �а ру��ком
 
-- [Lisper.ru](http://lisper.ru/)
+- [Сообще�тво в Telegram](https://t.me/lisp_forever)
 
 �а англий�ком
 
diff --git a/ru-ru/css-ru.html.markdown b/ru-ru/css-ru.html.markdown
index e0e5e30b..b543bfeb 100644
--- a/ru-ru/css-ru.html.markdown
+++ b/ru-ru/css-ru.html.markdown
@@ -20,12 +20,12 @@ HTML �лементы и определ�ть их внешний вид.
 
 **В�Ж�О:** Так как результатом применени� CSS �вл�ет�� изменение внешнего вида
 �лементов, по�тарайте�ь и�пользовать CSS-пе�очницы при изучении �зыка.
-�апример [dabblet](http://dabblet.com/).
+�апример, [dabblet](http://dabblet.com/).
 В данной �татье ра��матривают�� в первую очередь �интак�и� и общие рекомендации.
 
 
 ```css
-/* Дл� комментариев и�пользует�� �леш-а�тери�к, как на �той �трочке.
+/* Дл� комментариев и�пользует�� �л�ш-а�тери�к, как на �той �трочке.
    В CSS нет одно�трочных комментариев; в�е комментарии запи�ывают�� таким �по�обом */
 
 /* ####################
@@ -104,7 +104,7 @@ div.some-parent.class-name {}
 .i-am-any-before ~ .this-element {}
 
 
-/* Суще�твуют п�евдо-кла��ы, позвол�ющие измен�ть внешний вид �лемента
+/* Суще�твуют п�евдокла��ы, позвол�ющие измен�ть внешний вид �лемента
    в зави�имо�ти от �обытий, произошедших � �лементом */
 
 /* например, когда кур�ор наведен на �лемент */
diff --git a/ru-ru/elixir-ru.html.markdown b/ru-ru/elixir-ru.html.markdown
index c8c2c060..8dd48ba7 100644
--- a/ru-ru/elixir-ru.html.markdown
+++ b/ru-ru/elixir-ru.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
diff --git a/ru-ru/forth-ru.html.markdown b/ru-ru/forth-ru.html.markdown
index 2fc4ad7c..96fa0941 100644
--- a/ru-ru/forth-ru.html.markdown
+++ b/ru-ru/forth-ru.html.markdown
@@ -10,10 +10,10 @@ lang: ru-ru
 
 Форт �оздан Чарлзом Муром в 70-е годы. Это императивный, �тековый �зык программировани� и �реда и�полнени� программ. И�пользовал�� в таких проектах как Open Firmware. Продолжает примен�т�� в проектах. Примен�ет�� в ��С�.
 
-Внимание: �та материал и�пользует реализацию Форта - Gforth, но больша� ча�ть напи�анного будет работать в других �редах.
+Внимание: �тот материал и�пользует реализацию Форта - Gforth, но больша� ча�ть напи�анного будет работать в других �редах.
 
 
-```
+```forth
 \ Это комментарий
 ( Это тоже комментарий, но и�пользует�� дл� предоределённых �лов )
 
diff --git a/ru-ru/go-ru.html.markdown b/ru-ru/go-ru.html.markdown
index 37592258..22249a6e 100644
--- a/ru-ru/go-ru.html.markdown
+++ b/ru-ru/go-ru.html.markdown
@@ -29,7 +29,7 @@ Go - Ñ�то Ñ�зык общего назначениÑ�, целью котороÐ
    комментарий */
 
 // Ключевое �лово package при�ут�твует в начале каждого файла.
-// Main �то �пециальное им�, обозначающее и�полн�емый файл, нежели библиотеку.
+// main �то �пециальное им�, обозначающее и�полн�емый файл, нежели библиотеку.
 package main
 
 // Import предназначен дл� указани� зави�имо�тей �того файла.
@@ -82,7 +82,7 @@ func learnTypes() {
     // Символ не из ASCII. И�ходный код Go в кодировке UTF-8.
     g := 'Σ' // тип rune, �то алиа� дл� типа int32, �одержит �имвол юникода.
 
-    f := 3.14195 // float64, 64-х битное чи�ло � плавающей точкой (IEEE-754).
+    f := 3.14159 // float64, 64-х битное чи�ло � плавающей точкой (IEEE-754).
     c := 3 + 4i  // complex128, внутри �еб� �одержит два float64.
 
     // Синтак�и� var � инициализаци�ми.
@@ -334,12 +334,12 @@ func requestServer() {
 
 ## Что дальше
 
-О�нова в�ех о�нов в Go �то [официальный веб �айт](http://golang.org/).
+О�нова в�ех о�нов в Go �то [официальный веб �айт](https://go.dev/).
 Там можно пройти туториал, поиграть�� � интерактивной �редой Go и почитать
 объёмную документацию.
 
 Дл� живого ознакомлени� рекомендует�� почитать и�ходные коды [�тандартной
-библиотеки Go](http://golang.org/src/pkg/). Отлично задокументированна�, она
+библиотеки Go](https://go.dev/src/). Отлично задокументированна�, она
 �вл�ет�� лучшим и�точником дл� чтени� и понимани� Go, его �тил� и идиом. Либо
-можно, кликнув на имени функции в [документации](http://golang.org/pkg/),
+можно, кликнув на имени функции в [документации](https://go.dev/pkg/),
 перейти к ее и�ходным кодам.
diff --git a/ru-ru/haml-ru.html.markdown b/ru-ru/haml-ru.html.markdown
index c2f8852e..ed823496 100644
--- a/ru-ru/haml-ru.html.markdown
+++ b/ru-ru/haml-ru.html.markdown
@@ -39,7 +39,7 @@ $ haml input_file.haml output_file.html
 / Комментарии
 / -------------------------------------------
 
-/ Комментари начинает�� � �имвола ко�ой черты.
+/ Комментарии начинает�� � �имвола ко�ой черты.
 
 /
   Дл� напи�ани� много�трочного комментари� ра�положите ваш комментарий
@@ -94,7 +94,7 @@ $ haml input_file.haml output_file.html
 / выведет 'Да &amp; да'
 
 /
-  Чтобы выполн�ть Ruby-код без �кранровани�, можно и�пользовать
+  Чтобы выполн�ть Ruby-код без �кранировани�, можно и�пользовать
   "во�клицательный знак" и "равно" (!=)
 
 %p
@@ -196,13 +196,13 @@ $ haml input_file.haml output_file.html
 / -------------------------------------------
 
 /
-  Фильтры передают �в�занный блок тек�та в �оотве�твующую
+  Фильтры передают �в�занный блок тек�та в �оответ�твующую
   фильтрующую программу и возвращают результат в Haml
   Фильтр обозначает�� двоеточием и названием фильтра:
 
 / Markdown filter
 :markdown
-  # Заголовк
+  # Заголовок
 
   Тек�т **внутри** *блока*
 
@@ -221,7 +221,7 @@ $ haml input_file.haml output_file.html
 </script>
 
 /
-  Суще�твует множе�тво типов фильров (:markdown, :javascript, :coffee,
+  Суще�твует множе�тво типов фильтров (:markdown, :javascript, :coffee,
   :css, :ruby и так далее). Вы можете определить �об�твенный фильтр c
   помощью Haml::Filters.
 
diff --git a/ru-ru/haskell-ru.html.markdown b/ru-ru/haskell-ru.html.markdown
index b1b8eb79..aada30c1 100644
--- a/ru-ru/haskell-ru.html.markdown
+++ b/ru-ru/haskell-ru.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: ru-ru
 ---
 
-Haskell разрабатывал��, как чи�тый функциональный �зык программировани�, применимый на практике. Язык изве�тен благодар� �воей �и�теме типов, и "знаменит" благодар� монадам. [Мен�][autor] же Haskell за�тавл�ет возвращать�� к �ебе �нова и �нова именно �воей �легантно�тью и [�][autor] получаю и�тинное удоволь�твие, программиру� на Haskell.
+Haskell разрабатывал��, как чи�тый функциональный �зык программировани�, применимый на практике. Язык изве�тен благодар� �воей �и�теме типов, и "знаменит" благодар� монадам. [Мен�][author] же Haskell за�тавл�ет возвращать�� к �ебе �нова и �нова именно �воей �легантно�тью и [�][author] получаю и�тинное удоволь�твие, программиру� на Haskell.
 
 ```haskell
 -- Одно�трочные комментарии начинают�� � двух дефи�ов
@@ -172,7 +172,7 @@ fib x
 первое определение, к образцу которого
 "подойдет" набор аргументов -}
 fib 1 = 1
-fib 2 = 2
+fib 2 = 1
 fib x = fib (x - 1) + fib (x - 2)
 
 -- Pattern matching дл� кортежей выгл�дит так
@@ -544,4 +544,4 @@ Haskell про�т в у�тановке, забирайте [зде�ь](http:/
 [Learn you a Haskell](http://learnyouahaskell.com/) и
 [Real World Haskell](http://book.realworldhaskell.org/).
 
-[autor]: http://adit.io имеет�� в виду автор оригинального тек�та Adit Bhargava *(примечание переводчика)*
+[author]: http://adit.io имеет�� в виду автор оригинального тек�та Adit Bhargava *(примечание переводчика)*
diff --git a/ru-ru/html-ru.html.markdown b/ru-ru/html-ru.html.markdown
index 120981b9..e18fb8a0 100644
--- a/ru-ru/html-ru.html.markdown
+++ b/ru-ru/html-ru.html.markdown
@@ -8,28 +8,28 @@ translators:
 lang: ru-ru
 ---
 
-HTML ра�шифровывает�� как Hypertext Markup Language(гипертек�товый �зык разметки).
-Это �зык и�пользуют дл� напи�ани� �траниц дл� World Wide Web(в�емирной паутины).
-Это �зык разметки позвол�ет пи�ать веб-�траниц � помощью кода, чтобы определ�ть, 
-как должны быть отображены тек�т и данные.
+HTML ра�шифровывает�� как Hypertext Markup Language (гипертек�товый �зык разметки).
+Этот �зык и�пользуют дл� напи�ани� �траниц дл� World Wide Web (в�емирной паутины).
+Этот �зык разметки позвол�ет опи�ать веб-�траницу � помощью кода, чтобы определить, 
+как на ней должны быть отображены тек�т и данные.
 �а �амом деле, HTML файлы пред�тавл�ют �обой про�тые тек�товые файлы.
-Что такое разметка? Это �по�об организации данных �траницы,
-путем открыти� и закрыти� тегов(помеща� данные внутрь �тих тегов).
-Эта разметка �лужит, чтобы придать значение тек�ту, который он окружает.
+Что такое разметка? Это �по�об организации данных �траницы
+путем открыти� и закрыти� тегов и помещени� данных внутрь �тих тегов.
+Эта разметка �лужит, чтобы придать значение тек�ту, который она окружает.
 Как и в других �зыках программировани�, HTML имеет много вер�ий. Зде�ь мы будем говорить о HTML5.
 
 
 **Примечание:** Вы можете те�тировать различные теги и �лементы по мере продвижени� 
-через учебник на �айте, как [codepen](http://codepen.io/pen/) дл� того, чтобы увидеть 
+через учебник на �айте [codepen](http://codepen.io/pen/) дл� того, чтобы увидеть 
 их вли�ние, пон�ть, как они работают и ознакомить�� � �зыком.
-В данной �татье ра��матривает�� в о�новном HTML �интак�и� и некоторые полезные �оветы.
+В данной �татье ра��матривает�� в о�новном HTML-�интак�и� и некоторые полезные �оветы.
 
 ```html
-<!-- Комментарии заключают�� как �та лини\! -->
+<!-- Это комментарий. -->
 
 <!-- #################### Теги #################### -->
    
-<!-- �иже приведен пример HTML-файл, который мы будем анализировать. -->
+<!-- �иже приведен пример HTML-файла, который мы будем анализировать. -->
 
 <!doctype html>
 	<html>
@@ -39,7 +39,7 @@ HTML раÑ�шифровываетÑ�Ñ� как Hypertext Markup Language(гипеÑ
 		<body>
 			<h1>Привет, мир!</h1>
 			<a href = "http://codepen.io/anon/pen/xwjLbZ">
-				Переходите �юда, чтоб по�мотреть как �то выгл�дит.
+				Переходите �юда, чтобы по�мотреть, как �то выгл�дит.
 			</a>
 			<p>Это параграф.</p>
 			<p>Это другой параграф.</p>
@@ -51,41 +51,41 @@ HTML раÑ�шифровываетÑ�Ñ� как Hypertext Markup Language(гипеÑ
 		</body>
 	</html>
 
-<!-- HTML-файл в�егда начинает�� � указанием браузеру, что �траница �то HTML. -->
+<!-- HTML-файл в�егда начинает�� � указани� браузеру, что �траница — �то HTML. -->
 <!doctype html>
 
-<!-- По�ле �того, �траница начинает�� � <html> тега. -->
+<!-- По�ле �того �траница начинает�� � <html> тега. -->
 <html>
 
-<!-- �траница будет закрыта в конце � помощью тега </html>. -->
+<!-- Страница будет закрыта в конце � помощью тега </html>. -->
 </html>
 
 <!-- �ичто не должно по�вить�� по�ле �того заключительного тега. -->
 
-<!-- Внутри (между открывающим и закрывающим тегами <html> </ html>), мы находим: -->
+<!-- Внутри (между открывающим и закрывающим тегами <html> </ html>) мы находим: -->
 
-<!-- Заголовок определ�ет�� <head> (it он должен быть закрыт </head>). -->
+<!-- Заголовок определ�ет�� <head> (и он должен быть закрыт </head>). -->
 <!-- Заголовок �одержит опи�ание и дополнительную информацию, котора� не отображает��; �то метаданные. -->
 
 <head>
-	<title>Мой �айт</title><!-- Тег <title> указывает браузеру заголовок, чтобы показать в �троке заголовка названи� и вкладки браузера окна. -->
+	<title>Мой �айт</title><!-- Тег <title> указывает браузеру заголовок, который �ледует показать в �троке заголовка названи� и вкладки браузера окна. -->
 </head>
 
-<!-- По�ле �екци� <head>, находит�� �екци� - <body> -->
-<!-- До �того момента, ничего опи�аное не будет отображать�� в окне браузера. -->
-<!-- Мы должны наполнить <body>  �одержанием, которое будет отображать��. -->
+<!-- По�ле �екции <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. -->
+	<!-- Также �уще�твуют другие заголовки от имеющего большее значение <h1> до меньшего <h6>. -->
+	<a href = "http://codepen.io/anon/pen/xwjLbZ">Переходите �юда, чтобы по�мотреть, как �то выгл�дит.</a>
+	<!--гипер��ылка на URL, заданна� атрибутом href="" -->
+	<p>Это параграф.</p> <!-- Тег <p> позвол�ет нам добавл�ть тек�т на �транице HTML. -->
 	<p>Это другой параграф.</p>
 	<ul> <!-- Тег <ul> �оздает маркированный �пи�ок. -->
-	<!-- Дл� того, чтобы иметь пронумерованный �пи�ок лучше и�пользовать <ol> 
-		тогда первый �лемент будет иметь значение 1. дл� второго �лемента, 2. и так далее. -->
-		<li>Это �лемент в не нумерованном �пи�ке (маркированный �пи�ок)</li>
+	<!-- Дл� того, чтобы иметь пронумерованный �пи�ок, лучше и�пользовать <ol> 
+		тогда первый �лемент будет иметь значение 1., дл� второго �лемента 2. и так далее. -->
+		<li>Это �лемент в ненумерованном �пи�ке (маркированный �пи�ок)</li>
 		<li>Это еще один �лемент</li>
 		<li>И �то по�ледний пункт в �пи�ке</li>
 	</ul>
@@ -124,6 +124,6 @@ HTML файлы имеют окончание(ра�ширение) `.html`.
 
 ## Узнать больше
 
-* [википедиа](https://ru.wikipedia.org/wiki/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/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
index c31c6994..4c4fa503 100644
--- a/ru-ru/javascript-ru.html.markdown
+++ b/ru-ru/javascript-ru.html.markdown
@@ -473,7 +473,7 @@ if (0) {
 }
 
 // Впрочем, объекты-обёртки и в�троенные типы имеют общие прототипы,
-// по�тому вы можете ра�ширить функционал �трок, например:
+// по�тому вы можете ра�ширить функционально�ть �трок, например:
 String.prototype.firstCharacter = function() {
     return this.charAt(0);
 }
@@ -504,7 +504,7 @@ if (Object.create === undefined) { // не перезапи�ываем мето
 
 [Mozilla Developer Network](https://developer.mozilla.org/ru/docs/Web/JavaScript) —
 предо�тавл�ет отличную документацию дл� JavaScript, как он и�пользует�� в браузерах.
-Кроме того, �то вики, по�тому, е�ли вы знаете больше, вы можете помочь другим,
+Кроме того, �то вики. По�тому, е�ли вы знаете больше, вы можете помочь другим,
 дел��ь �воими знани�ми.
 
 [JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/ru/) — �то
diff --git a/ru-ru/kotlin-ru.html.markdown b/ru-ru/kotlin-ru.html.markdown
index 85f44c96..6ec52927 100644
--- a/ru-ru/kotlin-ru.html.markdown
+++ b/ru-ru/kotlin-ru.html.markdown
@@ -333,7 +333,7 @@ fun helloWorld(val name : String) {
     }
 
     /*
-    Ра�ширени� - �то �по�об добавить новый функционал к кла��у. 
+    Ра�ширени� - �то �по�об добавить новую функционально�ть к кла��у. 
     Это то же �амое, что методы ра�ширений в C#.
     */
     fun String.remove(c: Char): String {
diff --git a/ru-ru/learnvisualbasic-ru.html.markdown b/ru-ru/learnvisualbasic-ru.html.markdown
index 72e1358c..6242fc42 100644
--- a/ru-ru/learnvisualbasic-ru.html.markdown
+++ b/ru-ru/learnvisualbasic-ru.html.markdown
@@ -8,7 +8,7 @@ filename: learnvisualbasic-ru.vb
 lang: ru-ru
 ---
 
-```vbnet
+```visualbasic
 Module Module1
 
     Sub Main()
diff --git a/ru-ru/linker-ru.html.markdown b/ru-ru/linker-ru.html.markdown
index 7df29c23..14cfd229 100644
--- a/ru-ru/linker-ru.html.markdown
+++ b/ru-ru/linker-ru.html.markdown
@@ -34,11 +34,11 @@ lang: ru-ru
 # Определ�ем точку входа в программу
 ENTRY(Reset_Handler)
 
-# Определ�ем перемнную котора� �одержит адре� вершины �тека
+# Определ�ем переменную котора� �одержит адре� вершины �тека
 _estack = 0x20020000;  
-# Определ�ем перемнную котора� �одержит значение размера кучи  
+# Определ�ем переменную котора� �одержит значение размера кучи  
 _Min_Heap_Size = 0x200;
-# Определ�ем перемнную котора� �одержит значение размера �тека
+# Определ�ем переменную котора� �одержит значение размера �тека
 _Min_Stack_Size = 0x400; 
 
 # Опи�ание карты пам�ти до�тупной дл� данного проце��ора
@@ -50,7 +50,7 @@ _Min_Stack_Size = 0x400;
 # RAM - начинает�� � адре�а 0x20000000 и занимает 128 Кбайт;
 # CCMRAM - начинает�� � адре�а 0x10000000и занимает 64 Кбайт;
 # FLASH - начинает�� � адре�а 0x8000000 занимает 1024 Кбайт;
-# Причем RAM пам�ть до�тупка дл� чтени�, запи�и и и�полнени�.
+# Причем RAM пам�ть до�тупна дл� чтени�, запи�и и и�полнени�.
 # CCMRAM пам�ть до�тупна только на чтение и запи�ь.
 # FLASH пам�ть до�тупна на чтение и и�полнение.
 MEMORY
@@ -70,7 +70,7 @@ SECTIONS
     . = ALIGN(4);
 
 	# Суще�твует опци� --gc-sections, котора� позвол�ет �обирать му�ор из неи�пользуемых 
-	# входных разделов. И е�ли е�ть разделы, которые �борщик му��ора не должен трогать, 
+	# входных разделов. И е�ли е�ть разделы, которые �борщик му�ора не должен трогать, 
 	# то их необходимо указать в каче�тве аргумента функции KEEP() (аналог ключевого �лова 
 	# volatile).
 	# Запи�ь (*(.isr_vector)) означает разделы .isr_vector во в�ех объектных файлах. Т.к. 
@@ -80,8 +80,8 @@ SECTIONS
 	# Выравниваем текущую позицию на границу 4-х байт.
     . = ALIGN(4);
 	
-	# Выражение ">ОБЛ�СТЬ_П�МЯТИ" указывает в какую именно обла�ть пам�ти будет помещенна 
-	# данна� �екци�.	В нашем �лущае �екци� .isr_vector будет размещена во FLASH пам�ти.
+	# Выражение ">ОБЛ�СТЬ_П�МЯТИ" указывает в какую именно обла�ть пам�ти будет помещена 
+	# данна� �екци�.	В нашем �лучае �екци� .isr_vector будет размещена во FLASH пам�ти.
   } >FLASH
 
 # ИТОГО: Секци� .isr_vector, котора� �одержит таблицу векторов прерываний выравнивает�� 
@@ -125,7 +125,7 @@ SECTIONS
 	# Выравниваем текущую позицию на границу 4-х байт.
     . = ALIGN(4);
 
-	# Указываем, что в данной �екции будут хранит�� обла�ти .rodataв�ех
+	# Указываем, что в данной �екции будут хранит�� обла�ти .rodata в�ех
 	# объектных файлов   
     *(.rodata)         
     *(.rodata*)  
@@ -158,13 +158,13 @@ SECTIONS
     _edata = .;    
    
 	# Функци� AT указывает на то, что данный �ектор хранит�� в одной обла�ти пам�ти 
-	# (в нашем �лучае FLASH), а и�полн�ть�� будет из другой оба�ти пам�ти (в нашем �лучае RAM). 
-	# Е�ть два типа адре��ов:
-	# * VMA (Virtual memory address) - �то run-time адре� по которому уомпил�тор ожидает 
+	# (в нашем �лучае FLASH), а и�полн�ть�� будет из другой обла�ти пам�ти (в нашем �лучае RAM). 
+	# Е�ть два типа адре�ов:
+	# * VMA (Virtual memory address) - �то run-time адре� по которому компил�тор ожидает 
 	#	видеть данные.
 	# * LMA (Load memory address) - �то адре� по которому линкер хранит данные.			
 			
-	#Startup должен код �копировать �екцию .data из адре��ов LMA в адре��а VMA.
+	#Startup должен код �копировать �екцию .data из адре�ов LMA в адре�а VMA.
 	
   } >RAM AT> FLASH
 
diff --git a/ru-ru/lua-ru.html.markdown b/ru-ru/lua-ru.html.markdown
index da9ced6a..6bfea4bb 100644
--- a/ru-ru/lua-ru.html.markdown
+++ b/ru-ru/lua-ru.html.markdown
@@ -98,7 +98,7 @@ end
 
 -- Вложенные и анонимные функции �вл�ют�� нормой:
 function adder(x)
-  -- Возращаема� функци� �оздаёт��, когда вызывает�� функци� adder,
+  -- Возвращаема� функци� �оздаёт��, когда вызывает�� функци� adder,
   -- и запоминает значение переменной x:
   return function (y) return x + y end
 end
@@ -363,7 +363,7 @@ end
 
 return M
 
--- Другой файл может и�пользовать функционал mod.lua:
+-- Другой файл может и�пользовать функционально�ть mod.lua:
 local mod = require('mod')  -- Запу�тим файл mod.lua.
 
 -- require - �тандартный �по�об подключени� модулей.
diff --git a/ru-ru/markdown-ru.html.markdown b/ru-ru/markdown-ru.html.markdown
index 579a9a20..fc8614c4 100644
--- a/ru-ru/markdown-ru.html.markdown
+++ b/ru-ru/markdown-ru.html.markdown
@@ -45,7 +45,7 @@ Markdown �вл�ет�� надмноже�твом HTML, по�тому люб
 HTML-�лементов -->
 ```
 
-## Заголовки 
+## Заголовки
 
 HTML-�лементы от <h1> до <h6> размечают�� очень про�то:
 тек�т, который должен �тать заголовком, предвар�ет��
@@ -85,7 +85,7 @@ __И �тот тоже.__
 *__И даже зде�ь!__*
 ```
 
-В Github Flavored Markdown, �тандарте, который и�пользует�� в Github,
+В GitHub Flavored Markdown, �тандарте, который и�пользует�� в GitHub,
 тек�т также можно �делать зачёркнутым:
 
 ```md
@@ -110,7 +110,7 @@ __И �тот тоже.__
 Дл� в�тавки принудительных перено�ов можно завершить абзац двум� дополнительными пробелами:
 
 ```md
-Эта �трока завершает�� двум� пробелами (выделите, чтобы увидеть!).  
+Эта �трока завершает�� двум� пробелами (выделите, чтобы увидеть!).
 
 �ад �той �трокой е�ть <br />!
 ```
@@ -208,7 +208,7 @@ __И �тот тоже.__
 
 ```md
     my_array.each do |item|
-        puts item
+      puts item
     end
 ```
 
@@ -220,18 +220,17 @@ __И �тот тоже.__
 Ван� даже не знал, что делает функци� `go_to()`!
 ```
 
-В Github Flavored Markdown дл� блоков кода можно и�пользовать
+В GitHub Flavored Markdown дл� блоков кода можно и�пользовать
 �пециальный �интак�и�:
 
-<pre>
-<code class="highlight">&#x60;&#x60;&#x60;ruby
+```ruby
 def foobar
-    puts "Привет, мир!"
+  puts "Привет, мир!"
 end
-&#x60;&#x60;&#x60;</code></pre>
+```
 
 Во фрагменте, приведённом выше, от�туп не требует��.
-Кроме того, Github под�ветит �интак�и� �зыка, указанного по�ле \`\`\`
+Кроме того, GitHub под�ветит �интак�и� �зыка, указанного по�ле \`\`\`
 
 ## Горизонтальный разделитель
 
@@ -255,6 +254,7 @@ end
 ```md
 [С�ылка!](http://test.com/)
 ```
+
 Также дл� ��ылки можно указать в�плывающую под�казку (`title`), и�пользу�
 кавычки внутри круглых �кобок:
 
@@ -269,11 +269,13 @@ end
 
 Markdown также позвол�ет размечать ��ылку в виде �но�ки:
 
-<pre><code class="highlight">&#x5b;<span class="nv">Щёлкните �ту ��ылку</span>][<span class="ss">link1</span>] дл� подробной информации!
-&#x5b;<span class="nv">Также по�мотрите �ту ��ылку,</span>][<span class="ss">foobar</span>] е�ли хотите.
+```md
+[Щёлкните �ту ��ылку][link1] дл� подробной информации!
+[Также по�мотрите �ту ��ылку,][foobar] е�ли хотите.
 
-&#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>
+[link1]: http://test.com/ "Круто!"
+[foobar]: http://foobar.biz/ "�ормально!"
+```
 
 `Title` также может быть в одинарных кавычках или круглых �кобках, а также
 от�ут�твовать вов�е. С�ылки на �но�ки могут быть в любом ме�те документа,
@@ -281,9 +283,11 @@ Markdown также позвол�ет размечать ��ылку в вид
 
 Суще�твует также не�вное именование, когда ��ылка �вл�ет�� идентификатором.
 
-<pre><code class="highlight">&#x5b;<span class="nv">Это</span>][] ��ылка.
+```md
+[Это][] ��ылка.
 
-&#x5b;<span class="nv">�то</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+[�то]: http://thisisalink.com/
+```
 
 Правда, �та возможно�ть не очень ра�про�транена.
 
@@ -294,11 +298,15 @@ Markdown также позвол�ет размечать ��ылку в вид
 ```md
 ![�льтернативный тек�т дл� изображени�](http://imgur.com/myimage.jpg "Под�казка")
 ```
-Изображени� тоже могут быть оформлены, как �но�ки.
 
-<pre><code class="highlight">!&#x5b;<span class="nv">Это альтернативный тек�т.</span>][<span class="ss">myimage</span>]
+Изображени� тоже могут быть оформлены как �но�ки.
+
+```md
+![Это альтернативный тек�т.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "Е�ли нужна под�казка, её можно добавить"
+```
 
-&#x5b;<span class="nv">myimage</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"Е�ли нужна под�казка, её можно добавить"</span></code></pre>
 ## Разное
 ### �вто��ылки
 
@@ -322,7 +330,7 @@ Markdown также позвол�ет размечать ��ылку в вид
 ```
 
 ### Клавиши на клавиатуре
-В Github Flavored Markdown дл� пред�тавлени� клавиш на клавиатуре
+В GitHub Flavored Markdown дл� пред�тавлени� клавиш на клавиатуре
 вы можете и�пользовать тег `<kbd>`.
 
 ```md
@@ -341,6 +349,7 @@ Markdown также позвол�ет размечать ��ылку в вид
 | Выравнивание | Выравнивание | Выравнивание |
 | влево        | по центру    | вправо       |
 ```
+
 Или более компактно
 
 ```md
diff --git a/ru-ru/nim-ru.html.markdown b/ru-ru/nim-ru.html.markdown
index 0e08f1bf..09784792 100644
--- a/ru-ru/nim-ru.html.markdown
+++ b/ru-ru/nim-ru.html.markdown
@@ -3,7 +3,7 @@ language: Nim
 filename: learnNim-ru.nim
 contributors:
     - ["Jason J. Ayala P.", "http://JasonAyala.com"]
-    - ["Dennis Felsing", "http://felsin9.de/nnis/"]
+    - ["Dennis Felsing", "https://dennis.felsing.org"]
 translators:
     - ["Nomadic", "https://github.com/n0madic"]
     - ["dvska", "https://github.com/dvska"]
diff --git a/ru-ru/objective-c-ru.html.markdown b/ru-ru/objective-c-ru.html.markdown
index 092c3e2f..6c7d9f6c 100644
--- a/ru-ru/objective-c-ru.html.markdown
+++ b/ru-ru/objective-c-ru.html.markdown
@@ -507,8 +507,8 @@ distance = 18; // СÑ�ылаетÑ�Ñ� на "long distance" из реализацÐ
 @end
 
 // Теперь, е�ли мы хотим �оздать объект Truck - грузовик, мы должны �оздать подкла�� кла��а Car, что
-// изменит функционал Car и позволит ве�ти �еб� подобно грузовику. �о что, е�ли мы хотим только добавить
-// определенный функционал в уже �уще�твующий кла�� Car? �апример - чи�тка автомобил�. Мы про�то �оздадим
+// изменит функционально�ть Car и позволит ве�ти �еб� подобно грузовику. �о что, е�ли мы хотим только добавить
+// определенную функционально�ть в уже �уще�твующий кла�� Car? �апример - чи�тка автомобил�. Мы про�то �оздадим
 // категорию, котора� добавит не�колько методов дл� чи�тки автомобил� в кла�� Car:
 // @interface Им�Файла: Car+Clean.h (Им�БазовогоКла��а+Им�Категории.h)
 #import "Car.h" // Убедите�ь в том, что базовый кла�� импортирован дл� ра�ширени�.
diff --git a/ru-ru/php-ru.html.markdown b/ru-ru/php-ru.html.markdown
index af77a9ca..4a508cfc 100644
--- a/ru-ru/php-ru.html.markdown
+++ b/ru-ru/php-ru.html.markdown
@@ -125,7 +125,7 @@ echo 'Multiple', 'Parameters', 'Valid'; // печатает 'MultipleParametersV
 // и никогда не может быть изменена во врем� выполнени� программы!
 
 // Правильное им� кон�танты начинает�� � буквы или �имвола подчеркивани�
-// и �одержит любое колличе�тво букв, цифр или �имволов подчеркивани�.
+// и �одержит любое количе�тво букв, цифр или �имволов подчеркивани�.
 define("FOO", "something");
 
 // До�туп к кон�танте возможен через пр�мое указание её имени без знака $
@@ -224,7 +224,7 @@ assert($c > $b); // больше
 assert($a <= $b); // меньше или равно
 assert($c >= $d); // больше или равно
 
-// Следующие утверждени� и�тинны, е�ли переменные имеют одинаковые тип.
+// Следующие утверждени� и�тинны, е�ли переменные имеют одинаковый тип.
 assert($c === $d);
 assert($a !== $d);
 assert(1 == '1');
@@ -251,7 +251,7 @@ echo $string + $string; // => 2 (�трока превращает�� в чи�
 $string = 'one';
 echo $string + $string; // => 0
 
-// Приведение типов (type casting) может быть и�пользовано дл� преобразование
+// Приведение типов (type casting) может быть и�пользовано дл� преобразовани�
 // переменной в другой тип
 $boolean = (boolean) 1; // => true
 
@@ -458,7 +458,7 @@ include_once 'my-file.php';
 require 'my-file.php';
 require_once 'my-file.php';
 
-// Дей�твует также как и include(), но е�ли файл не удало�ь подключить,
+// Дей�твует так же как и include(), но е�ли файл не удало�ь подключить,
 // функци� выдает фатальную ошибку
 
 // Содержимое файла my-include.php:
@@ -497,7 +497,7 @@ class MyClass
 
     // Кон�труктор опи�ывает�� � помощью __construct
     public function __construct($instanceProp) {
-        // До�туп к �земпл�ру кла��а � помощью $this
+        // До�туп к �кземпл�ру кла��а � помощью $this
         $this->instanceProp = $instanceProp;
     }
 
@@ -661,7 +661,7 @@ $cls->myTraitMethod(); // �апечатает "I have MyTrait"
 <?php
 
 // По умолчанию, кла��ы �уще�твуют в глобальном про�тран�тве имен и могут быть
-// вызваны � обратным �лешем.
+// вызваны � обратным �л�шем.
 
 $cls = new \MyClass();
 
@@ -762,7 +762,7 @@ echo "Current method is " . __METHOD__;
 echo "Current namespace is " . __NAMESPACE__;
 
 // Возвращает им� текущего трейта.
-// Возвращает только е�ли и�польщует�� внутри трейта.
+// Возвращает только е�ли и�пользует�� внутри трейта.
 echo "Current namespace is " . __TRAIT__;
 
 
@@ -771,7 +771,7 @@ echo "Current namespace is " . __TRAIT__;
 *  
 */
 
-// Про�тую обработку ошибок можно произве�ти �помощью try catch блока.
+// Про�тую обработку ошибок можно произве�ти � помощью try catch блока.
 
 try {
     // Выполн�ем что-то
@@ -779,7 +779,7 @@ try {
     // Обработка и�ключени�
 }
 
-// При и�пользовании try catch блока в обла�ти вилимо�ти, �тоит и�пользовать
+// При и�пользовании try catch блока в обла�ти видимо�ти, �тоит и�пользовать
 // �ледующий подход:
 
 try {
@@ -788,7 +788,7 @@ try {
     // Обработка и�ключени�
 }
 
-// Специальное(ка�томное) и�ключение - exceptions
+// Специальное (ка�томное) и�ключение - exceptions
 
 class MyException extends Exception {}
 
@@ -797,7 +797,7 @@ try {
     $condition = true;
 
     if ($condition) {
-        throw new MyException('Something just happend');
+        throw new MyException('Something just happened');
     }
 
 } catch (MyException $e) {
diff --git a/ru-ru/pyqt-ru.html.markdown b/ru-ru/pyqt-ru.html.markdown
index 24afc03d..a7e14c02 100644
--- a/ru-ru/pyqt-ru.html.markdown
+++ b/ru-ru/pyqt-ru.html.markdown
@@ -11,7 +11,7 @@ translators:
 
 **Qt** - широко изве�тный кро��-платформенный фреймворк дл� разработки программного обе�печени�,
 который может быть и�пользован на различных �офтварных и хардварных платформах без какого-либо
-изменени� в коде. Данный фреймворк при �том обладает мощью и �коро�тью нативных приложений. 
+изменени� в коде. Данный фреймворк при �том обладает мощью и �коро�тью нативных приложений.
 Qt и был изначально напи�ан на *C++*.
 
 Данный тек�т �вл�ет�� адаптацией введени� в Qt на C++ под автор�твом �лек�е� Ковальчука дл� pyqt.
@@ -20,7 +20,7 @@ Qt и был изначально напи�ан на *C++*.
 ```python
 
 def window():
-    # Создайте объект приложени� 
+    # Создайте объект приложени�
     app = QtGui.QApplication(sys.argv)
     # Создайте виджет, где будет находить�� наш лейбл
     w = QtGui.QWidget()
@@ -28,10 +28,10 @@ def window():
     b = QtGui.QLabel(w)
     # Задайте тек�т дл� лейбла
     b.setText("Hello World!")
-    # Задайте информаци� о размере и ра�положении 
+    # Задайте информаци� о размере и ра�положении
     w.setGeometry(100, 100, 200, 50)
     b.move(50, 20)
-    # Задайте заголовок окна 
+    # Задайте заголовок окна
     w.setWindowTitle("PyQt")
     # В�е ранее напи�анное выводит�� на �кран
     w.show()
@@ -43,11 +43,11 @@ if __name__ == '__main__':
 
 ```
 
-Дл� того, чтобы получить более продвинутые функции приложени� в pyqt, нам необходимо 
-обратить внимание на �оздание дополнительных �лементов. �иже пред�тавлено �оздание в�плывающего диалогового окна, которое про�ит пользовател� подтвердить его решение или предо�тавить какую-либо 
+Дл� того чтобы получить более продвинутые функции приложени� в pyqt, нам необходимо
+обратить внимание на �оздание дополнительных �лементов. �иже пред�тавлено �оздание в�плывающего диалогового окна, которое про�ит пользовател� подтвердить его решение или предо�тавить какую-либо
 информацию.
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -67,7 +67,7 @@ def window():
     w.show()
     sys.exit(app.exec_())
 
-Данна� функци� должна �оздавать диалоговое окно � кнопкой, котора� ждет клика по �ебе 
+Данна� функци� должна �оздавать диалоговое окно � кнопкой, котора� ждет клика по �ебе
 и затем завершает программу.
 
 def showdialog():
diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown
index e0e53b9c..e088593e 100644
--- a/ru-ru/python-ru.html.markdown
+++ b/ru-ru/python-ru.html.markdown
@@ -353,7 +353,6 @@ empty_set = set()
 # Да, оно выгл�дит примерно как �ловарь. �у извините, так уж вышло.
 filled_set = {1, 2, 2, 3, 4}  # => {1, 2, 3, 4}
 
-# Similar to keys of a dictionary, elements of a set have to be immutable.
 # Как и ключи �ловар�, �лементы множе�тва должны быть неизмен�емыми.
 invalid_set = {[1], 1}  # => Выбра�ывает ошибку TypeError: unhashable type: 'list'
 valid_set = {(1,), 1}
diff --git a/ru-ru/qt-ru.html.markdown b/ru-ru/qt-ru.html.markdown
index d0a70c9d..15e2c775 100644
--- a/ru-ru/qt-ru.html.markdown
+++ b/ru-ru/qt-ru.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: Qt Framework
-language: c++
+language: C++
 filename: learnqt-ru.cpp
 contributors:
     - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
@@ -80,7 +80,7 @@ int main(int argc, char *argv[]) {
 ```
 Обратите внимание на метод *QObject::connect*. Этот метод �оедин�ет *СИГ��ЛЫ* одного объекта �о *СЛОТ�МИ* другого.
 
-**Сигналы** отправл�ют�� когда � объектами прои�ход�т отпределённые �обыти�, например, �игнал *нажатие* отправл�ет�� когда пользователь нажимает на объект типа QPushButton.
+**Сигналы** отправл�ют�� когда � объектами прои�ход�т определённые �обыти�, например, �игнал *нажатие* отправл�ет��, когда пользователь нажимает на объект типа QPushButton.
 
 **Слоты** �то *дей�тви�*, которые могут быть выполнены в ответ на полученные �игналы.
 
diff --git a/ru-ru/rust-ru.html.markdown b/ru-ru/rust-ru.html.markdown
index 9293a40e..a568ac37 100644
--- a/ru-ru/rust-ru.html.markdown
+++ b/ru-ru/rust-ru.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 
 filename: learnrust-ru.rs
 contributors:
@@ -226,7 +226,7 @@ fn main() {
 
     // `for` loops/iteration
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/ru-ru/sql-ru.html.markdown b/ru-ru/sql-ru.html.markdown
index 7353a175..702a8102 100644
--- a/ru-ru/sql-ru.html.markdown
+++ b/ru-ru/sql-ru.html.markdown
@@ -22,9 +22,9 @@ lang: ru-ru
 поддерживают ключевые �лова QUIT, EXIT или оба).
 
 �екоторые команды ниже предполагают и�пользование
-[демон�трационного образца базы данных �отрудников от MySQL](https://dev.mysql.com/doc/employee/en/), до�тупного на [Github](https://github.com/datacharmer/test_db).
+[демон�трационного образца базы данных �отрудников от MySQL](https://dev.mysql.com/doc/employee/en/), до�тупного на [GitHub](https://github.com/datacharmer/test_db).
 Следовательно, дл� повторени� команд в локальном окружении он должен быть загружен.
-Файлы на github — �то �крипты � командами, которые �хожи � командами ниже,
+Файлы на github — �то �крипты � командами, �хожие � командами ниже,
 которые �оздают и манипулируют таблицами и данными о �отрудниках вымышленной
 компании. Синтак�и� дл� запу�ка �тих �криптов будет зави�еть от и�пользуемой
 вами реализации SQL. Обычно и�пользует�� утилита, запу�каема� из командной
@@ -50,7 +50,7 @@ SHOW DATABASES;
 USE employees;
 
 -- Выбрать в�е �троки и колонки из таблицы «departments» (отделы) текущей базы.
--- В интерактивном режиме обыч	но результат будет выведен на �кран.
+-- В интерактивном режиме обычно результат будет выведен на �кран.
 SELECT * FROM departments;
 
 -- Тот же запро�, что и выше, но выбор только колонок «dept_no» и «dept_name».
diff --git a/ru-ru/swift-ru.html.markdown b/ru-ru/swift-ru.html.markdown
index b1931f9a..bd2d23a0 100644
--- a/ru-ru/swift-ru.html.markdown
+++ b/ru-ru/swift-ru.html.markdown
@@ -622,7 +622,7 @@ class MyShape: Rect {
 // MARK: Прочее
 //
 
-// `extension`s: Добавл�ет ра�ширенный функционал к �уще�твующему типу
+// `extension`s: Добавл�ет ра�ширенную функционально�ть к �уще�твующему типу
 
 // Кла�� Square теперь "�оответ�твует" протоколу `CustomStringConvertible`
 extension Square: CustomStringConvertible {
diff --git a/ru-ru/tmux-ru.html.markdown b/ru-ru/tmux-ru.html.markdown
index aa7545cc..643c48b0 100644
--- a/ru-ru/tmux-ru.html.markdown
+++ b/ru-ru/tmux-ru.html.markdown
@@ -249,4 +249,4 @@ set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] |
 
 [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)
+[Отображение 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
index 09bbb2d1..ad931599 100644
--- a/ru-ru/typescript-ru.html.markdown
+++ b/ru-ru/typescript-ru.html.markdown
@@ -9,8 +9,8 @@ translators:
 filename: learntypescript-ru.ts
 ---
 
-TypeScript — �то �зык программировани�, целью которого �вл�ет�� лёгка� разработка широкома�штабируемых JavaScript-приложений.
-TypeScript добавл�ет в Javascript общие концепции, такие, как кла��ы, модули, интерфей�ы, обобщённое программирование и (опционально) �татиче�кую типизацию.  
+TypeScript — �то �зык программировани�, целью которого �вл�ет�� лёгка� разработка широко ма�штабируемых JavaScript-приложений.
+TypeScript добавл�ет в Javascript общие концепции, такие как кла��ы, модули, интерфей�ы, обобщённое программирование и (опционально) �татиче�кую типизацию.  
 Это надмноже�тво �зыка JavaScript: ве�ь JavaScript-код �вл�ет�� валидным TypeScript-кодом, �ледовательно, может быть добавлен бе�шовно в любой проект. 
 Компил�тор TypeScript генерирует JavaScript-код.
 
diff --git a/ru-ru/vim-ru.html.markdown b/ru-ru/vim-ru.html.markdown
index f43f99eb..60b381e7 100644
--- a/ru-ru/vim-ru.html.markdown
+++ b/ru-ru/vim-ru.html.markdown
@@ -10,7 +10,7 @@ lang: ru-ru
 ---
 
 [Vim](http://www.vim.org)
-(Vi IMproved) �то клон полул�рного тек�тового редактора дл� Unix. Он разработан
+(Vi IMproved) �то клон попул�рного тек�тового редактора дл� Unix. Он разработан
 � целью повышени� �коро�ти и продуктивно�ти и пов�еме�тно и�пользует�� в 
 большин�тво Юник�-подобных �и�тем. В нем имеет�� множе�тво клавиатурных 
 �очетаний дл� бы�трой навигации к определенным точкам в файле и бы�трого 
@@ -167,8 +167,8 @@ Vim можно ра��матривать как набор команд в фо
 ## Макро�ы
 
 Макро�ы �то про�то запи�ываемые дей�тви�.
-Во врем� запи�и макро�ы запоминают **в�е** дей�тви� и команды до тех пор пока 
-запи�ь не будет о�тановлена.При вызове макро� примен�ет ту же �амую по�ледовательно�ть 
+Во врем� запи�и макро�ы запоминают **в�е** дей�тви� и команды до тех пор, пока 
+запи�ь не будет о�тановлена. При вызове макро� примен�ет ту же �амую по�ледовательно�ть 
 дей�твий и команд на выделенном тек�те.
 
 ```
diff --git a/ru-ru/xml-ru.html.markdown b/ru-ru/xml-ru.html.markdown
index bf3f22b0..34e17b9b 100644
--- a/ru-ru/xml-ru.html.markdown
+++ b/ru-ru/xml-ru.html.markdown
@@ -15,7 +15,7 @@ XML - �то �зык разметки, предназначенный дл� х
 * XML-Синтак�и�
 
 ```xml
-<!-- Комментарии в XML выгл�д�т вот так -->
+<!-- Это комментарий. -->
 
 <?xml version="1.0" encoding="UTF-8"?>
 <bookstore>
diff --git a/ru-ru/yaml-ru.html.markdown b/ru-ru/yaml-ru.html.markdown
index ddaed2b6..693848fc 100644
--- a/ru-ru/yaml-ru.html.markdown
+++ b/ru-ru/yaml-ru.html.markdown
@@ -12,7 +12,7 @@ lang: ru-ru
 YAML как �зык �ериализации данных предназначен прежде в�его дл� и�пользовани� людьми.
 
 Это �трогое надмноже�тво JSON � добавлением �интак�иче�ки значимых перено�ов �трок и 
-от�тупов как в Python. Тем не менее, в отличие от Python, YAML запрещает 
+от�тупов как в Python. Тем не менее в отличие от Python, YAML запрещает 
 и�пользование табов дл� от�тупов.
 
 ```yaml
@@ -53,7 +53,7 @@ literal_block: |
         Любые �троки � большим от�тупом �охран�ют о�татки �воего от�тупа -  
         �та �трока будет �одержать дополнительно 4 пробела.
 folded_style: >
-    Ве�ь блок �того тект�а будет значением 'folded_style', но в данном �лучае
+    Ве�ь блок �того тек�та будет значением 'folded_style', но в данном �лучае
     в�е �имволы новой �троки будут заменены пробелами.
 
     Пу�тые �троки будут преобразованы в перено� �троки.
@@ -76,7 +76,7 @@ a_nested_map:
 0.25: a float key
 
 # Ключи также могут быть �ложными, например много�трочными.
-# Мы и�пользуем ? � по�ледующим пробелом чтобы обозначить начало �ложного ключа.
+# Мы и�пользуем ? � по�ледующим пробелом, чтобы обозначить начало �ложного ключа.
 ? |
   Этот ключ
   который �одержит не�колько �трок
@@ -124,7 +124,7 @@ base: &base
   name: Каждый будет иметь одинаковое им�
 
 # Регул�рное выражение << называет�� ключом объединени� незави�имо от типа �зыка.
-# Он и�пользует�� чтобы показать что в�е ключи одного или более �ловарей должны быть
+# Он и�пользует��, чтобы показать что в�е ключи одного или более �ловарей должны быть
 # добавлены в текущий �ловарь.
 
 foo: &foo
@@ -185,5 +185,5 @@ set2:
 
 ### Больше информации
 
-+ [YAML оффициальный веб�айт](http://yaml.org/)
++ [YAML официальный веб�айт](http://yaml.org/)
 + [YAML онлайн валидатор](http://www.yamllint.com/)
diff --git a/ru-ru/zfs-ru.html.markdown b/ru-ru/zfs-ru.html.markdown
new file mode 100644
index 00000000..46a3fbb5
--- /dev/null
+++ b/ru-ru/zfs-ru.html.markdown
@@ -0,0 +1,406 @@
+---
+category: tool
+tool: zfs
+contributors:
+    - ["sarlalian", "http://github.com/sarlalian"]
+    - ["A1EF", "https://github.com/A1EF"]
+filename: LearnZfs-ru.txt
+translators:
+    - ["A1EF", "https://github.com/A1EF"]
+lang: ru-ru
+---
+
+
+[ZFS](http://open-zfs.org/wiki/Main_Page)
+пред�тавл�ет �обой перео�мы�ление �и�темы хранени� данных, комбинирующее в едином ин�трументе
+традиционные файловые �и�темы и �и�темы управлени� томами. ZFS обладает некоторой �пецифичной
+терминологией, котора� отличает её от более традиционных �и�тем хранени� данных, однако имеет
+отличный набор возможно�тей, акцентированных на удоб�тве и�пользовани� �и�темными админи�траторами.
+
+
+## Концепции ZFS
+
+### Виртуальные у�трой�тва
+
+Виртуальное у�трой�тво (VDEV) подобно у�трой�тву RAID, пред�тавл�емого RAID-контроллером.
+Е�ть не�колько типов виртуальных у�трой�тв (VDEV), которые предлагают различные преимуще�тва,
+включа� отказоу�тойчиво�ть и �коро�ть до�тупа. В о�новном виртуальные у�трой�тва (VDEV)
+предо�тавл�ют лучшую отказоу�тойчиво�ть и безопа�но�ть, нежели RAID-контроллеры. �е рекомендует��
+и�пользовать у�тановку RAID � ZFS, по�кольку ZFS ра��читывает непо�ред�твенно управл�ть ди�ками.
+
+Типы виртуальных у�трой�тв (VDEV)
+
+* mirror (поддерживает�� n-кратное зеркалирование)
+* raidz
+	* raidz1 (1-ди�к четно�ти, аналог RAID 5)
+	* raidz2 (2-ди�ка четно�ти, аналог RAID 6)
+	* raidz3 (3-ди�ка четно�ти, нет имеет аналогичного RAID-ма��ива)
+* disk
+* file (не рекомендовано дл� промышленного применени� из-за добавлени� нежелательного промежуточного �ло� иной файловой �и�темы)
+
+Ваши данные ра�предел�ют�� �реди в�ех виртуальных у�трой�тв (VDEV), пред�тавленных в пуле хранени�,
+так что увеличив чи�ло виртуальных у�трой�тв (VDEV), вы увеличите количе�тво IOPS.
+
+### Пулы хранени�
+
+ZFS и�пользует пулы хранени� как аб�тракцию над нижним уровнем провайдера хранени� (VDEV), позвол�� вам отделить видимые пользователю
+файловые �и�темы от физиче�кого их размещени�.
+
+### ZFS дата�еты
+
+ZFS дата�еты подобны традиционным файловым �и�темам, но имеют гораздо больше возможно�тей, обе�печивающих обилие преимуще�тв ZFS.
+Дата�еты поддерживают [Copy on Write](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BF%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%B8_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B8), �напшоты, квоты, �жатие и дедубликацию.
+
+
+### Ограничени�
+
+Один каталог может �одержать до 2^48 файлов, каждый до 16 �к�абайт. Один пул хранени� может �одержать до 256 зеттабайт (2^78) данных
+и может быть ра�пределён по 2^64 у�трой�твам. � один хо�т может иметь 2^64 пула хранени�. Лимиты огромны.
+
+
+## Команды
+
+### Пулы хранени�
+
+Дей�тви�:
+
+* Про�мотр
+* Стату�
+* Удаление
+* Получение/у�тановка �вой�тв
+
+Про�мотр пулов
+
+```bash
+# Создание пула типа raidz
+$ zpool create zroot 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%
+```
+
+Стату� пулов
+
+```bash
+# Получение информации о �тату�е пулов
+$ 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
+
+# Скрабинг пула дл� и�правлени� любых ошибок
+$ 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
+```
+
+Свой�тва пулов
+
+```bash
+
+# Получение �вой�тв пула, �вой�тва могут быть заданы пользователем или �и�темой.
+$ zpool get all zroot
+NAME   PROPERTY                       VALUE                          SOURCE
+zroot  size                           141G                           -
+zroot  capacity                       75%                            -
+zroot  altroot                        -                              default
+zroot  health                         ONLINE                         -
+...
+
+# У�тановка значени� �вой�тва пула
+$ 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
+```
+
+Удаление пула
+
+```bash
+$ zpool destroy test
+```
+
+
+### Дата�еты
+
+Дей�тви�:
+
+* Создание
+* Про�мотр
+* Переименование
+* Удаление
+* Получение/у�тановка �вой�тв
+
+Создание дата�етов
+
+```bash
+# Создание дата�ета
+$ zfs create zroot/root/data
+$ mount | grep data
+zroot/root/data on /data (zfs, local, nfsv4acls)
+
+# Создание дочернего дата�ета
+$ zfs create zroot/root/data/stuff
+$ mount | grep data
+zroot/root/data on /data (zfs, local, nfsv4acls)
+zroot/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
+zroot/win_vm         4.13G  17.9G    64K  -
+```
+
+Про�мотр дата�етов
+
+```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  -
+```
+
+Переименование дата�етов
+
+```bash
+$ zfs rename zroot/root/home zroot/root/old_home
+$ zfs rename zroot/root/new_home zroot/root/home
+```
+
+Удаление дата�ета
+
+```bash
+# Дата�еты не могут быть удалены, е�ли у них имеют�� какие-то �напшоты
+$ zfs destroy zroot/root/home
+```
+
+Получение / у�тановка �вой�тв дата�ета
+
+```bash
+# Получение в�ех �вой�тв
+$ zfs get all zroot/usr/home
+NAME            PROPERTY              VALUE                  SOURCE
+zroot/home      type                  filesystem             -
+zroot/home      creation              Mon Oct 20 14:44 2014  -
+zroot/home      used                  11.9G                  -
+zroot/home      available             94.1G                  -
+zroot/home      referenced            11.9G                  -
+zroot/home      mounted               yes                    -
+...
+
+# Получени� �вой�тва дл� дата�ета
+$ zfs get compression zroot/usr/home
+NAME            PROPERTY     VALUE     SOURCE
+zroot/home      compression  off       default
+
+# У�тановка значени� �вой�тва на дата�ете
+$ zfs set compression=lz4 zroot/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
+...
+```
+
+
+### Снапшоты
+
+ZFS �напшоты -- одна из очень важных о�обенно�тей zfs
+
+* Ме�то, которое они занимают, равно разнице данных между файловой �и�темой и её �напшотом
+* Врем� �оздани� занимает �читанные �екунды
+* Во��тановление на�только бы�тро, на�колько позвол�ет вам запи�ь данных
+* Они очень про�ты в автоматизации
+
+Дей�тви�:
+
+* Создание
+* Удаление
+* Переименование
+* Получение до�тупа к �напшотам
+* Отправка / Получение
+* Клонирование
+
+
+Создание �напшотов
+
+```bash
+# Создание �напшота един�твенного дата�ета
+zfs snapshot zroot/home/sarlalian@now
+
+# Создание �напшота дл� родитель�кого и дочерних дата�етов
+$ zfs snapshot -r zroot/home@now
+$ zfs list -t snapshot
+NAME                       USED  AVAIL  REFER  MOUNTPOINT
+zroot/home@now                 0      -    26K  -
+zroot/home/sarlalian@now       0      -   259M  -
+zroot/home/alice@now           0      -   156M  -
+zroot/home/bob@now             0      -   156M  -
+...
+```
+
+Удаление �напшотов
+
+```bash
+# Как удалить �напшот
+$ zfs destroy zroot/home/sarlalian@now
+
+# Удаление �напшота в родитель�ком и дочерних дата�етах
+$ zfs destroy -r zroot/home/sarlalian@now
+
+```
+
+Переименование �напшотов
+
+```bash
+# Переименование �напшота
+$ zfs rename zroot/home/sarlalian@now zroot/home/sarlalian@today
+$ zfs rename zroot/home/sarlalian@now today
+
+$ zfs rename -r zroot/home@now @yesterday
+```
+
+Получение до�тупа к �папшотам
+
+```bash
+# CD в каталог �напшота
+$ cd /home/.zfs/snapshot/
+```
+
+Отправка и получение
+
+```bash
+# Сохранение �напшота в файл
+$ zfs send zroot/home/sarlalian@now | gzip > backup_file.gz
+
+# Отправка �напшота в другой дата�ет
+$ zfs send zroot/home/sarlalian@now | zfs recv backups/home/sarlalian
+
+# Отправка �напшота на удаленный хо�т
+$ zfs send zroot/home/sarlalian@now | ssh root@backup_server 'zfs recv zroot/home/sarlalian'
+
+# Отправка полного дата�ета �о �напшотами на новый хо�т
+$ zfs send -v -R zroot/home@now | ssh root@backup_server 'zfs recv zroot/home'
+```
+
+Клонирование �напшотов
+
+```bash
+# Клонирование �напшота
+$ zfs clone zroot/home/sarlalian@now zroot/home/sarlalian_new
+
+# Повышение клона, чтобы он больше не зави�ел от �напшота
+$ zfs promote zroot/home/sarlalian_new
+```
+
+### Собираем в�ё вме�те
+
+�иже�ледующий �крипт и�пользует FreeBSD, jails и ZFS дл� автоматизации
+подготовки чи�той копии �тейджинговой базы mysql � живой реплики �лейв-ноды.
+
+```bash
+#!/bin/sh
+
+echo "==== О�тановка �тейджингового �ервера баз данных ===="
+jail -r staging
+
+echo "==== Очи�тка �уще�твующих �тейджингового �ервера и �напшота ===="
+zfs destroy -r zroot/jails/staging
+zfs destroy zroot/jails/slave@staging
+
+echo "==== Фик�аци� базы на �лейве ===="
+echo "FLUSH TABLES WITH READ LOCK;" | /usr/local/bin/mysql -u root -pmyrootpassword -h slave
+
+echo "==== Сохранение �напшота файлов базы �лейва как zroot/jails/slave@staging ===="
+zfs snapshot zroot/jails/slave@staging
+
+echo "==== Запу�к �лейв-ноды �ервера баз данных ===="
+jail -c slave
+
+echo "==== Клонирование �напшота �лейва на �тейджинговый �ервер ===="
+zfs clone zroot/jails/slave@staging zroot/jails/staging
+
+echo "==== У�тановка конфига �тейджингово mysql ===="
+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 "==== �а�тройка �тейджингового файла rc.conf ===="
+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 "==== Запу�к �тейджингово �ервера баз данных ===="
+jail -c staging
+
+echo "==== Отключение �инхронизации �тейджинговой базы � ма�тером ===="
+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/ruby.html.markdown b/ruby.html.markdown
index 4b96b71c..8e5f924a 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -670,4 +670,4 @@ Something.new.qux #=> "qux"
 - [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.
+- [Try Ruby](https://try.ruby-lang.org/) - Learn the basic of Ruby programming language, interactive in the browser.
diff --git a/rust.html.markdown b/rust.html.markdown
index e835de12..526d20d5 100644
--- a/rust.html.markdown
+++ b/rust.html.markdown
@@ -30,6 +30,9 @@ Rust not only fast, but also easy and efficient to code in.
 // This is a comment. Line comments look like this...
 // and extend multiple lines like this.
 
+/* Block comments
+  /* can be nested. */ */
+
 /// Documentation comments look like this and support markdown notation.
 /// # Examples
 ///
@@ -89,11 +92,16 @@ fn main() {
     println!("{} {}", f, x); // 1.3 hello world
 
     // A `String` – a heap-allocated string
+    // Stored as a `Vec<u8>` and always hold a valid UTF-8 sequence, 
+    // which is not null terminated.
     let s: String = "hello world".to_string();
 
     // A string slice – an immutable view into another string
-    // The string buffer can be statically allocated like in a string literal
-    // or contained in another object (in this case, `s`)
+    // 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
+    // the begin and a pointer to the end of a string buffer,
+    // statically allocated or contained in another object (in this case, `s`).
+    // The string slice is like a view `&[u8]` into `Vec<T>`.
     let s_slice: &str = &s;
 
     println!("{} {}", s, s_slice); // hello world hello world
@@ -205,6 +213,21 @@ fn main() {
     let another_foo = Foo { bar: 1 };
     println!("{:?}", another_foo.frobnicate()); // Some(1)
 
+    // Function pointer types // 
+
+    fn fibonacci(n: u32) -> u32 {
+        match n {
+            0 => 1,
+            1 => 1,
+            _ => fibonacci(n - 1) + fibonacci(n - 2),
+        }
+    }
+
+    type FunctionPointer = fn(u32) -> u32;
+
+    let fib : FunctionPointer = fibonacci;
+    println!("Fib: {}", fib(4)); // 5
+
     /////////////////////////
     // 3. Pattern matching //
     /////////////////////////
@@ -236,7 +259,7 @@ fn main() {
 
     // `for` loops/iteration
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/scala.html.markdown b/scala.html.markdown
index 08fd37e4..bb20f624 100644
--- a/scala.html.markdown
+++ b/scala.html.markdown
@@ -302,7 +302,7 @@ do {
 // Recursion is the idiomatic way of repeating an action in Scala (as in most
 // other functional languages).
 // Recursive functions need an explicit return type, the compiler can't infer it.
-// Here it's Unit, which is analagous to a `void` return type in Java
+// Here it's Unit, which is analogous to a `void` return type in Java
 def showNumbersInRange(a: Int, b: Int): Unit = {
   print(a)
   if (a < b)
@@ -481,7 +481,7 @@ class SaintBernard extends Dog {
 	def bite = false
 }  
 
-scala> b  
+scala> val b = new SaintBernard
 res0: SaintBernard = SaintBernard@3e57cd70  
 scala> b.breed  
 res1: String = Saint Bernard  
@@ -599,7 +599,7 @@ List("Dom", "Bob", "Natalia") foreach println
 
 s.map(sq)
 
-val sSquared = s. map(sq)
+val sSquared = s.map(sq)
 
 sSquared.filter(_ < 10)
 
@@ -717,7 +717,7 @@ import scala.collection.immutable.{Map => _, Set => _, _}
 // Java classes can also be imported. Scala syntax can be used
 import java.swing.{JFrame, JWindow}
 
-// Your programs entry point is defined in a scala file using an object, with a
+// Your program's entry point is defined in a scala file using an object, with a
 // single method, main:
 object Application {
   def main(args: Array[String]): Unit = {
diff --git a/sed.html.markdown b/sed.html.markdown
new file mode 100644
index 00000000..3e6d8fc8
--- /dev/null
+++ b/sed.html.markdown
@@ -0,0 +1,285 @@
+---
+category: tool
+tool: sed
+filename: learnsed.sed
+contributors:
+     - ["Diomidis Spinellis", "https://www.spinellis.gr"]
+
+---
+
+__Sed__ is a standard tool on every POSIX-compliant UNIX system.
+It's like an editor, such as Vim, Visual Studio Code, Atom, or Sublime.
+However, rather than typing the commands interactively, you
+provide them on the command line or in a file.
+
+_Sed_'s advantages over an interactive editor is that it can be easily
+used to automate text processing tasks, and that it can process
+efficiently huge (terabyte-sized) files.
+It can perform more complex tasks than _grep_ and for many text
+processing tasks its commands are much shorter than what you would
+write in _awk_, _Perl_, or _Python_.
+
+_Sed_ works by reading a line of text (by default from its standard
+input, unless some files are specified as arguments), processing
+it with the specified commands, and then outputting the result
+on its standard output.
+You can suppress the default output by specifying the `-n` command-line
+argument.
+
+```perl
+#!/usr/bin/sed -f
+# Files that begin with the above line and are given execute permission
+# can be run as regular scripts.
+
+# Comments are like this.
+
+# Commands consist of a single letter and many can be preceded
+# by a specification of the lines to which they apply.
+
+# Delete the input's third line.
+3d
+
+# The same command specified the command line as an argument to sed:
+# sed 3d
+
+# For many commands the specification can consist of two addresses,
+# which select an inclusive range.
+# Addresses can be specified numerically ($ is the last line) or through
+# regular expressions delimited by /.
+
+# Delete lines 1-10
+1,10d
+
+# Lines can also be specified as regular expressions, delimited by /.
+
+# Delete empty lines.
+/^$/d
+
+# Delete blocks starting with SPOILER-BEGIN and ending with SPOILER-END.
+/SPOILER-BEGIN/,/SPOILER-END/d
+
+# A command without an address is applied to all lines.
+
+# List lines in in a visually unambiguous form (e.g. tab appears as \t).
+l
+
+# A command prefixed by ! will apply to non-matching lines.
+# Keep only lines starting with a #.
+/^#/!d
+
+# Below are examples of the most often-used commands.
+
+# Substitute the first occurence in a line of John with Mary.
+s/John/Mary/
+
+# Remove all underscore characters (global substitution).
+s/_//g
+
+# Remove all HTML tags.
+s/<[^>]*>//g
+
+# In the replacement string & is the regular expression matched.
+
+# Put each line inside double quotes.
+s/.*/"&"/
+
+# In the matched regular expression \(pattern\) is used to store
+# a pattern into a buffer.
+# In the replacement string \1 refers to the first pattern, \2 to the second
+# and so on. \u converts the following character to uppercase \l to lowercase.
+
+# Convert snake_case_identifiers into camelCaseIdentifiers.
+s/_\(.\)/\u\1/g
+
+
+# The p (print) command is typically used together with the -n
+# command-line option, which disables the print by default functionality.
+# Output all lines between ``` and ```.
+/```/,/```/p
+
+
+# The y command maps characters from one set to another.
+# Swap decimal and thousand separators (1,234,343.55 becomes 1.234.343,55).
+y/.,/,./
+
+# Quit after printing the line starting with END.
+/^END/q
+
+# You can stop reading here, and still get 80% of sed's benefits.
+# Below are examples of how you can specify multiple sed commands.
+
+# You can apply multiple commands by separating them with a newline or
+# a semicolon.
+
+# Delete the first and the last line.
+1d
+$d
+
+# Delete the first and the last line.
+1d;$d
+
+
+# You can group commands in { } blocks.
+
+# Convert first line to uppercase and print it.
+1 {
+  s/./\u&/g
+  p
+}
+
+# Convert first line to uppercase and print it (less readable one-liner).
+1{s/./\u&/g;p;}
+
+
+# You can also stop reading here, if you're not interested in creating
+# sed script files.
+
+# Below are more advanced commands.  You typically put these in a file
+# rather than specify them on a command line.  If you have to use
+# many of these commands in a script, consider using a general purpose
+# scripting language, such as Python or Perl.
+
+# Append a line containing "profile();" after each line ending with ";".
+/;$/a\
+profile();
+
+# Insert a line containing "profile();" before each line ending with ";".
+/;$/i\
+profile();
+
+# Change each line text inside REDACTED blocks into [REDACTED].
+/REDACTED-BEGIN/,/REDACTED-END/c\
+[REDACTED]
+
+# Replace the tag "<ourstyle>" by reading and outputting the file style.css.
+/<ourstyle>/ {
+  r style.css
+  d
+}
+
+# Change each line inside REDACTED blocks into [REDACTED].
+# Also write (append) a copy of the redacted text in the file redacted.txt.
+/REDACTED-BEGIN/,/REDACTED-END/ {
+  w redacted.txt
+  c\
+  [REDACTED]
+}
+
+# All operations described so far operate on a buffer called "pattern space".
+# In addition, sed offers another buffer called "hold space".
+# The following commands operate on the two, and can be used to keep
+# state or combine multiple lines.
+
+# Replace the contents of the pattern space with the contents of
+# the hold space.
+g
+
+# Append a newline character followed by the contents of the hold
+# space to the pattern space.
+G
+
+# Replace the contents of the hold space with the contents of the
+# pattern space.
+h
+
+# Append a newline character followed by the contents of the
+# pattern space to the hold space.
+H
+
+# Delete the initial segment of the pattern space through the first
+# newline character and start the next cycle.
+D
+
+# Replace the contents of the pattern space with the contents of
+# the hold space.
+g
+
+# Append a newline character followed by the contents of the hold
+# space to the pattern space.
+G
+
+# Replace the contents of the hold space with the contents of the
+# pattern space.
+h
+
+# Append a newline character followed by the contents of the
+# pattern space to the hold space.
+H
+
+# Write the pattern space to the standard output if the default
+# output has not been suppressed, and replace the pattern space
+# with the next line of input.
+n
+
+# Append the next line of input to the pattern space, using an
+# embedded newline character to separate the appended material from
+# the original contents.  Note that the current line number
+# changes.
+N
+
+# Write the pattern space, up to the first newline character to the
+# standard output.
+P
+
+# Swap the contents of the pattern and hold spaces.
+x
+
+# Here is a complete example of some of the buffer commands.
+# Move the file's first line to its end.
+1 {
+  h
+  d
+}
+
+$ {
+  p
+  x
+}
+
+
+# Three sed commands influence a script's control flow
+
+# Name this script position "my_label", to which the "b" and
+# "t" commands may branch.
+:my_label
+
+# Continue executing commands from the position of my_label.
+b my_label
+
+# Branch to the end of the script.
+b
+
+# Branch to my_label if any substitutions have been made since the most
+# recent reading of an input line or execution of a "t" (test) function.
+t my_label
+
+# Here is a complete example of branching
+# Join lines that end with a backspace into a single space-separated one
+
+# Name this position "loop"
+: loop
+# On lines ending with a backslash
+/\\$/ {
+  # Read the next line and append it to the pattern space
+  N
+  # Substitute backslash newline with a space
+  s/\\\n/ /
+  # Branch to the top for testing this line's ending
+  b loop
+}
+```
+
+Further Reading:
+
+* [The Open Group: sed - stream editor](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html)
+  The POSIX standard regarding sed.
+  Follow this for maximum portability.
+* [FreeBSD sed -- stream editor](https://www.freebsd.org/cgi/man.cgi?query=sed&sektion=&n=1)
+  The BSD manual page.
+  This version of sed runs on BSD systems and macOS.
+* [Project GNU: sed, a stream editor](https://www.gnu.org/software/sed/manual/sed.html)
+  The GNU manual page. GNU sed is found on most Linux systems.
+* [Lee E. McMahon: SED -- A Non-interactive Text Editor](https://wolfram.schneider.org/bsd/7thEdManVol2/sed/sed.pdf)
+  The original sed documentation
+* [A collection of sed resources](http://sed.sourceforge.net/)
+* [The sed FAQ](http://sed.sourceforge.net/sedfaq.html)
diff --git a/set-theory.html.markdown b/set-theory.html.markdown
index ae8b5388..144b4bbf 100644
--- a/set-theory.html.markdown
+++ b/set-theory.html.markdown
@@ -2,7 +2,9 @@
 category: Algorithms & Data Structures
 name: Set theory
 contributors:
+    - ["Andrew Ryan Davis", "https://github.com/AndrewDavis1191"]
 ---
+
 Set theory is a branch of mathematics that studies sets, their operations, and their properties.
 
 * A set is a collection of disjoint items.
@@ -13,11 +15,11 @@ Set theory is a branch of mathematics that studies sets, their operations, and t
 * the union operator, `∪`, pronounced "cup", means "or";
 * the intersection operator, `∩`, pronounced "cap", means "and";
 * the exclusion operator, `\`, means "without";
-* the compliment operator, `'`, means "the inverse of";
+* the complement operator, `'`, means "the inverse of";
 * the cross operator, `×`, means "the Cartesian product of".
 
 ### Qualifiers 
-* the colon qualifier, `:`, means "such that";
+* the colon, `:`, or the vertical bar `|` qualifiers are interchangeable and mean "such that";
 * the membership qualifier, `∈`, means "belongs to";
 * the subset qualifier, `⊆`, means "is a subset of";
 * the proper subset qualifier, `⊂`, means "is a subset of but is not equal to".
@@ -59,7 +61,7 @@ Long lists may be shortened with ellipses as long as the context is clear. For e
 Set builder notation is a more descriptive way of constructing a set. It relies on a _subject_ and a _predicate_ such that `S = { subject : predicate }`. For example,
 
 ```
-A = { x : x is a vowel } = { a, e, i, o, u, y}
+A = { x : x is a vowel } = { a, e, i, o, u }
 B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
 C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... }
 ```
@@ -87,7 +89,7 @@ D = { 2x : x ∈ N } = { 0, 2, 4, 6, 8, ... }
 ## Special Sets
 
 ### The Power Set
-* Let `A` be any set. The set that contains all possible subsets of `A` is called a "power set" and is written as `P(A)`. If the set `A` contains `n` elements, then `P(A)` contains `2^N` elements.
+* Let `A` be any set. The set that contains all possible subsets of `A` is called a "power set" and is written as `P(A)`. If the set `A` contains `n` elements, then `P(A)` contains `2^n` elements.
 
 ```
 P(A) = { x : x ⊆ A }
diff --git a/sing.html.markdown b/sing.html.markdown
new file mode 100644
index 00000000..50b52390
--- /dev/null
+++ b/sing.html.markdown
@@ -0,0 +1,446 @@
+---
+name: Sing
+category: language
+language: Sing
+filename: learnsing.sing
+contributors:
+    - ["Maurizio De Girolami", "https://github.com/mdegirolami"]
+---
+
+The purpose of sing is to provide a simple, safe, fast language that 
+can be a good replacement for c++ for high performance applications.
+
+Sing is an easy choice because it compiles to human-quality readable c++.
+
+Because of that, if you work for a while with Sing and, at any time, you discover you don't like Sing anymore, you lose nothing of your work
+because you are left with nice and clean c++ code. 
+
+In some way you can also think Sing as a tool to write c++ in a way that enforces some best practices.
+
+```go
+/* Multi- line comment. 
+    /* It can be nested */ 
+    Use it to remark-out part of the code.
+    It leaves no trace in the intermediate c++ code. 
+    (sing translates into nice human readable c++)
+*/
+
+// Single line comment, can be placed only before a statement or declaration...
+// ...or at the right of the first line of a statement or declaration.
+// single line comments are kept into c++.
+//
+// here we declare if we need to use public declarations from other files. 
+// (in this case from files 'sio', 'sys')
+requires "sio";
+requires "sys";
+
+//
+// A sing function declaration.
+// All the declarations can be made public with the 'public' keyword.
+// All the declarations start with a keyword specifying the type of declaration
+// (in this case fn for function) then follows the name, the arguments and the
+// return type.
+//
+// Each argument starts with a direction qualifyer (in, out, io) which tells if
+// the argument is an input, an output or both...
+// ...then follows the argument name and the type.
+public fn singmain(in argv [*]string) i32
+{
+    // print is from the sio file and sends a string to the console
+    sio.print("Hello World\n");
+
+    // type conversions are allowed in the form of <newtype>(expression).
+    sio.print(string(sum(5, 10)) + "\n");
+
+    // For clarity you can specify after an argument its name separated by ':'.
+    var result i32;
+    recursive_power(10:base, 3:exponent, result);
+
+    // referred here to avoid a 'not used' error.
+    learnTypes();
+
+    // functions can only return a single value of some basic type.
+    return(0);
+}
+
+// You can have as many arguments as you want, comma separated. 
+// You can also omit the 'in' direction qualifyer (it is the default).
+fn sum(arg1 i32, arg2 i32) i32
+{
+    // as 'fn' declares a function, 'let' declares a constant.
+    // With constants, if you place an initializer, you can omit the type.
+    let the_sum = arg1 + arg2;
+
+    return(the_sum);
+}
+
+// Arguments are passed by reference, which means that in the function body you
+// use the argument names to refer to the passed variables.
+// Example: all the functions in the recursion stack access the same 'result'
+// variable, supplied by the singmain function. 
+fn recursive_power(base i32, exponent i32, out result i32) void
+{
+    if (exponent == 0) {
+        result = 1;
+    } else {
+        recursive_power(base, exponent - 1, result);
+        result *= base;
+    }
+}
+
+//**********************************************************
+//
+// TYPES
+//
+//**********************************************************
+fn learnTypes() void
+{
+    // the var keyword declares mutable variables 
+    // in this case an UTF-8 encoded string
+    var my_name string;
+
+    // ints of 8..64 bits size
+    var int0 i8; 
+    var int1 i16; 
+    var int2 i32; 
+    var int3 i64; 
+
+    // uints
+    var uint0 u8;
+    var uint1 u16;
+    var uint2 u32;
+    var uint3 u64;
+
+    // floats
+    var float0 f32;
+    var float1 f64;
+
+    // complex
+    var cmplx0 c64;
+    var cmplx1 c128;
+
+    cmplx0 = 0;
+    cmplx1 = 0;
+
+    // and of course...
+    var bool0 bool;
+
+    // type inference: by default constants are i32, f32, c64
+    let an_int32 = 15;
+    let a_float32 = 15.0;
+    let a_complex = 15.0 + 3i;
+    let a_string = "Hello !";
+    let a_bool = false;
+
+    // To create constant of different types use a conversion-like syntax:
+    // NOTE: this is NOT a conversion. Just a type specification
+    let a_float64 = f64(5.6);
+
+    // in a type definition [] reads as "array of"
+    // in the example []i32 => array of i32.
+    var intarray []i32 = {1, 2, 3};
+
+    // You can specify a length, else the length is given by the initializer
+    // the last initializer is replicated on the extra items
+    var sizedarray [10]i32 = {1, 2, 3};
+
+    // Specify * as the size to get a dynamic array (can change its length)
+    var dyna_array [*]i32;
+
+    // you can append items to a vector invoking a method-like function on it.
+    dyna_array.push_back(an_int32);
+
+    // getting the size of the array. sys.validate() is like assert in c
+    sys.validate(dyna_array.size() == 1); 
+
+    // a map that associates a number to a string. 
+    // "map(x)..." reads "map with key of type x and value of type..." 
+    var a_map map(string)i32;
+
+    a_map.insert("one", 1);
+    a_map.insert("two", 2);
+    a_map.insert("three", 3);
+    let key = "two";
+
+    // note: the second argument of get_safe is the value to be returned 
+    // when the key is not found.
+    sio.print("\nAnd the value is...: " + string(a_map.get_safe(key, -1)));
+
+    // string concatenation
+    my_name = "a" + "b";
+}
+
+// an enum type can only have a value from a discrete set. 
+// can't be converted to/from int !
+enum Stages {first, second, last}
+
+// you can refer to enum values (to assign/compare them)
+// specifying both the typename and tagname separated with the '.' operator
+var current_stage = Stages.first;
+
+
+//**********************************************************
+//
+// POINTERS
+//
+//**********************************************************
+
+// This is a factory for a dynamic vector.
+// In a type declaration '*' reads 'pointer to..'
+// so the return type is 'pointer to a vector of i32'
+fn vectorFactory(first i32, last i32) *[*]i32
+{
+    var buffer [*]i32;
+
+    // fill
+    for (value in first : last) {
+        buffer.push_back(value);
+    }
+
+    // The & operator returns the address of the buffer.
+    // You can only use & on local variables
+    // As you use & on a variable, that variable is allocated on the HEAP.
+    return(&buffer);
+}
+
+fn usePointers() void
+{
+    var bufferptr = vectorFactory(0, 100);
+
+    // you don't need to use the factory pattern to use pointers.
+    var another_buffer [*]i32;
+    var another_bufferptr = &another_buffer;
+
+    // you can dereference a pointer with the * operator
+    // sys.validate is an assertion (causes a signal if the argument is false)
+    sys.validate((*bufferptr)[0] == 0);
+
+    /* 
+    // as all the pointers to a variable exit their scope the variable is
+    // no more accessible and is deleted (freed)
+    */
+}
+
+//**********************************************************
+//
+// CLASSES
+//
+//**********************************************************
+
+// This is a Class. The member variables can be directly initialized here
+class AClass {
+public:
+    var public_var = 100;       // same as any other variable declaration  
+    fn is_ready() bool;         // same as any other function declaration 
+    fn mut finalize() void;     // destructor (called on object deletion)
+private:
+    var private_var string; 
+
+    // Changes the member variables and must be marked as 'mut' (mutable)
+    fn mut private_fun(errmsg string) void;    
+}
+
+// How to declare a member function
+fn AClass.is_ready() bool
+{
+    // inside a member function, members can be accessed thrugh the 
+    // this keyword and the field selector '.'
+    return(this.public_var > 10);
+}
+
+fn AClass.private_fun(errmsg string) void
+{
+    this.private_var = errmsg;
+}
+
+// using a class
+fn useAClass() void
+{
+    // in this way you create a variable of type AClass.
+    var instance AClass;
+
+    // then you can access its members through the '.' operator.
+    if (instance.is_ready()) {
+        instance.public_var = 0;
+    }
+}
+
+//**********************************************************
+//
+// INTERFACES
+//
+//**********************************************************
+
+// You can use polymorphism in sing defining an interface...
+interface ExampleInterface {
+    fn mut eraseAll() void;
+    fn identify_myself() void;
+} 
+
+// and then creating classes which implement the interface
+// NOTE: you don't need (and cannot) re-declare the interface functions
+class Implementer1 : ExampleInterface {
+private:
+    var to_be_erased i32 = 3;
+public:    
+    var only_on_impl1 = 0;
+}
+
+class Implementer2 : ExampleInterface {
+private:
+    var to_be_erased f32 = 3;
+}
+
+fn Implementer1.eraseAll() void
+{
+    this.to_be_erased = 0;
+}
+
+fn Implementer1.identify_myself() void
+{
+    sio.print("\nI'm the terrible int eraser !!\n");
+}
+
+fn Implementer2.eraseAll() void
+{
+    this.to_be_erased = 0;
+}
+
+fn Implementer2.identify_myself() void
+{
+    sio.print("\nI'm the terrible float eraser !!\n");
+}
+
+fn interface_casting() i32
+{
+    // upcasting is automatic (es: *Implementer1 to *ExampleInterface)
+    var concrete Implementer1;
+    var if_ptr *ExampleInterface = &concrete; 
+
+    // you can access interface members with (guess what ?) '.'
+    if_ptr.identify_myself();
+
+    // downcasting requires a special construct 
+    // (see also below the conditional structures)
+    typeswitch(ref = if_ptr) {  
+        case *Implementer1: return(ref.only_on_impl1);
+        case *Implementer2: {}
+        default: return(0);
+    }
+
+    return(1);
+}
+
+// All the loop types
+fn loops() void
+{
+    // while: the condition must be strictly of boolean type
+    var idx = 0;
+    while (idx < 10) {
+        ++idx;
+    }
+
+    // for in an integer range. The last value is excluded
+    // 'it' is local to the loop and must not be previously declared
+    for (it in 0 : 10) {
+    }
+
+    // reverse direction
+    for (it in 10 : 0) {
+    }
+
+    // configurable step. The loop stops when it's >= the final value
+    for (it in 0 : 100 step 3) {
+    }
+
+    // with an auxiliary counter. 
+    // The counter start always at 0 and increments by one at each iteration
+    for (counter, it in 3450 : 100 step -22) {
+    } 
+
+    // value assumes in turn all the values from array
+    var array [*]i32 = {0, 10, 100, 1000};
+    for (value in array) {
+    }
+
+    // as before with auxiliary counter
+    for (counter, value in array) {
+    }
+}
+
+// All the conditional structures
+interface intface {}
+class c0_test : intface {public: fn c0stuff() void;}
+class delegating : intface {}
+
+fn conditionals(in object intface, in objptr *intface) void
+{
+    let condition1 = true;
+    let condition2 = true;
+    let condition3 = true;
+    var value = 30;
+
+    // condition1 must be a boolean.
+    if (condition1) {
+        ++value;    // conditioned statement
+    } 
+
+    // you can chain conditions with else if
+    if (condition1) {
+        ++value;
+    } else if (condition2) {
+        --value;
+    } 
+
+    // a final else runs if any other condition is false
+    if (condition1) {
+        ++value;
+    } else if (condition2) {
+        --value;
+    } else {
+        value = 0;
+    }
+
+    // based on the switch value selects a case statement
+    switch (value) {
+        case 0: sio.print("value is zero"); // a single statement !
+        case 1: {}                          // do nothing
+        case 2:                             // falls through
+        case 3: sio.print("value is more than one");
+        case 4: {                           // a block is a single statement !
+            value = 0;
+            sio.print("how big !!");
+        }
+        default: return;                    // if no one else matches
+    }
+
+    // similar to a switch but selects a case based on argument type.
+    // - object must be a function argument of type interface.
+    // - the case types must be classes implementing the object interface.
+    // - in each case statement, ref assumes the class type of that case.
+    typeswitch(ref = object) {
+        case c0_test: ref.c0stuff();
+        case delegating: {}
+        default: return;
+    }
+
+    // - object must be an interface pointer.
+    // - the case types must be pointers to classes implementing the objptr interface.
+    // - in each case statement, ref assumes the class pointer type of that case.
+    typeswitch(ref = objptr) {
+        case *c0_test: {
+            ref.c0stuff();
+            return;
+        }
+        case *delegating: {}
+        default: sio.print("unknown pointer type !!");
+    } 
+}
+```
+
+## Further Reading
+
+[official Sing web site](https://mdegirolami.wixsite.com/singlang).
+
+If you want to play with sing you are recommended to download the vscode plugin. Please
+follow the instructions at [Getting Started](https://mdegirolami.wixsite.com/singlang/copy-of-interfacing-sing-and-c-2)
diff --git a/sk-sk/elixir-sk.html.markdown b/sk-sk/elixir-sk.html.markdown
index 2401f92e..c9522b49 100644
--- a/sk-sk/elixir-sk.html.markdown
+++ b/sk-sk/elixir-sk.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -14,7 +14,7 @@ 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
+```elixir
 
 # Jednoriadkový komentár za�ína symbolom #
 
@@ -24,7 +24,7 @@ a množstvo funkcií.
 # 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
+# Obe príkazy by sa už mali nachádzať v path pokiaľ ste nainštalovali Elixir
 # správne.
 
 ## ---------------------------
@@ -86,7 +86,7 @@ reťazec.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` v elixire vráti ASCII �íselnú reprezentáciu pre znak `a`
+# `?a` v Elixir vráti ASCII �íselnú reprezentáciu pre znak `a`
 ?a #=> 97
 
 # Pre spájanie zoznamov sa používa `++`, pre binárne typy `<>`
@@ -119,7 +119,7 @@ pohlavia.gillian #=> "žena"
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# V elixire operátor `/` vždy vráti float (reálne �íslo).
+# V Elixir operátor `/` vždy vráti float (reálne �íslo).
 
 # Pre celo�íselné delenie sa používa `div`
 div(10, 2) #=> 5
@@ -182,7 +182,7 @@ else
 end
 
 # Pamätáte sa na pattern matching? Mnoho štruktúr pre riadenie toku v
-# elixire sa spoliehajú práve na pattern matching.
+# Elixir sa spoliehajú práve na pattern matching.
 
 # `case` dovolí nám porovnať hodnotu oproti mnohým vzorom:
 case {:one, :two} do
@@ -314,7 +314,7 @@ 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
+# V�aka nemeniteľnosti (immutability) je rekurzia významnou �asťou Elixir
 defmodule Rekurzia do
   def sumuj_zoznam([hlavicka | schvost], acc) do
     sumuj_zoznam(chvost, acc + hlavicka)
@@ -389,7 +389,7 @@ end
 ## ---------------------------
 
 # 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:
+# potrebné na písanie konkuretných programov v Elixir sú tri primitívy:
 # spawning procesy, posielanie a prijímanie správ.
 
 # Na spustnenie nového procesu použijeme `spawn` funkciu, ktorá má ako
diff --git a/sk-sk/git-sk.html.markdown b/sk-sk/git-sk.html.markdown
index 21741406..1187abc5 100644
--- a/sk-sk/git-sk.html.markdown
+++ b/sk-sk/git-sk.html.markdown
@@ -139,6 +139,7 @@ $ git init --help
 ### ignoruj súbory
 
 Zámerne prestaneš sledovať súbor(y) a zložky. Typicky sa používa pre súkromné a do�asné súbory, ktoré by boli inak zdieľané v repozitári.
+
 ```bash
 $ echo "temp/" >> .gitignore
 $ echo "private_key" >> .gitignore
@@ -172,6 +173,7 @@ $ git add /cesta/k/súboru/HelloWorld.c
 # Môžeš použiť regulárne výrazy!
 $ git add ./*.java
 ```
+
 Tento príkaz len pridáva súbory do staging indexu, necommituje ich do repozitára.
 
 ### branch
@@ -476,6 +478,7 @@ $ git reset 31f2bb1
 # a zosúladí ju s pracovným adresárom (vymaže nekomitnuté zmeny).
 $ git reset --hard 31f2bb1
 ```
+
 ### revert
 
 Vezme naspäť ("od-urobí") commit. Nezamieňaj s resetom, ktorý obnoví stav
@@ -514,8 +517,6 @@ $ git rm /pather/to/the/file/HelloWorld.c
 
 * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
 
-* [GitGuys](http://www.gitguys.com/)
-
 * [Git - jednoducho](http://rogerdudler.github.io/git-guide/index.html)
 
 * [Pro Git](http://www.git-scm.com/book/en/v2)
diff --git a/sk-sk/latex-sk.html.markdown.tex b/sk-sk/latex-sk.html.markdown
index 5e2f9c7f..5e2f9c7f 100644
--- a/sk-sk/latex-sk.html.markdown.tex
+++ b/sk-sk/latex-sk.html.markdown
diff --git a/sk-sk/learn-latex-sk.tex b/sk-sk/learn-latex-sk.tex
deleted file mode 100644
index 5cc7b11f..00000000
--- a/sk-sk/learn-latex-sk.tex
+++ /dev/null
@@ -1,209 +0,0 @@
-% Všetky komentáre za�ínajú s %
-% Viac-riadkové komentáre sa nedajú urobiť
-
-% LaTeX NIE JE WYSIWY ("What You See Is What You Get") software ako MS Word, alebo OpenOffice Writer
-
-% Každý LaTeX príkaz za�ína s opa�ným lomítkom (\)
-
-% LaTeX dokumenty za�ínajú s definíciou typu  kompilovaného dokumentu
-% Ostatné typy sú napríklad kniha (book), správa (report), prezentácia (presentation), at�.
-% Možnosti dokumentu sa píšu do [] zátvoriek. V tomto prípade tam upresňujeme veľkosť (12pt) fontu.
-\documentclass[12pt]{article}
-
-% Ďalej definujeme balí�ky, ktoré dokuemnt používa.
-% Ak chceš zahrnúť grafiku, farebný text, �i zdrojový kód iného jazyka, musíš rozšíriť možnosti LaTeXu dodato�nými balí�kami.
-% Zahŕňam float a caption. Na podporu sloven�iny treba zahrnúť aj utf8 balí�ek.
-\usepackage{caption}
-\usepackage{float}
-\usepackage[utf8]{inputenc}
-% Tu môžme definovať ostatné vlastnosti dokumentu!
-% Autori tohto dokumentu, "\\*" znamená "cho� na nový riadok"
-\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu, \\*Preklad: Terka Slanináková}
-% Vygeneruje dnešný dátum
-\date{\today}
-\title{Nau� sa LaTeX za Y Minút!}
-% Teraz môžme za�ať pracovať na samotnom dokumente.
-% Všetko do tohto riadku sa nazýva "Preambula" ("The Preamble")
-\begin{document} 
-% ak zadáme položky author, date a title, LaTeX vytvorí titulnú stranu.
-\maketitle
-
-% Vä�šina odborných �lánkov má abstrakt, na jeho vytvorenie môžeš použiť preddefinované príkazy.
-% Ten by sa mal zobraziť v logickom poradí, teda po hlavi�ke,
-% no pred hlavnými sekciami tela.. 
-% Tento príkaz je tiež dostupný v triedach article a report.
-% Tzv. makro "abstract" je fixnou sú�asťou LaTeXu, ak chceme použiť abstract
-% a napísať ho po slovensky, musíme ho redefinovať nasledujúcim príkazom
-\renewcommand\abstractname{Abstrakt}
-
-\begin{abstract}
-LaTeX dokumentácia v LaTeXe! Aké netradi�né riešenie cudzieho nápadu!
-\end{abstract}
-
-% Príkazy pre sekciu sú intuitívne
-% Všetky nadpisy sekcií sú pridané automaticky do obsahu.
-\section{Úvod}
-Čaute, volám sa Colton a spolo�ne sa pustíme do skúmania LaTeXu (toho druhého)!
-
-\section{Ďalšia sekcia}
-Toto je text �alšej sekcie. Myslím, že potrebuje podsekciu.
-
-\subsection{Toto je podsekcia} % Podsekcie sú tiež intuitívne.
-Zdá sa mi, že treba �alšiu.
-
-\subsubsection{Pytagoras}
-To je ono!
-\label{subsec:pytagoras}
-
-% Použitím '*' môžeme potla�iť zabudované �íslovanie LaTeXu.
-% Toto funguje aj na iné príkazy. 
-\section*{Toto je ne�íslovaná sekcia} 
-Všetky �íslované byť nemusia!
-
-\section{Nejaké poznámo�ky}
-Zarovnávať veci tam, kde ich chceš mať, je všeobecne ľahké. Ak 
-potrebuješ \\ nový \\ riadok \\ pridaj \textbackslash\textbackslash do 
-zdrojového kódu. \\ 
-
-\section{Zoznamy}
-Zoznamy sú jednou z najjednoduchších vecí vôbec! Treba mi zajtra nakúpiť, urobím si zoznam.
-\begin{enumerate} % "enumerate" spustí �íslovanie prvkov.
-  % \item povie LaTeXu, ako že treba pripo�ítať 1 
-  \item Vlašský šalát.
-  \item 5 rožkov.
-  \item 3 Horalky.
-  % �íslovanie môžeme pozmeniť použitím []
-  \item[koľko?] Stredne veľkých guli�koviek.
-
-  Ja už nie som položka zoznamu, no stále som �asť "enumerate".
-
-\end{enumerate} % Všetky prostredia kon�ia s "end".
-
-\section{Matika}
-
-Jedným z primárnych použití LaTeXu je písanie akademických, �i technických prác. Zvy�ajne za použitia matematiky a vedy. Podpora špeciálnych symbolov preto nemôže chýbať!\\
-
-Matematika má veľa symbolov, omnoho viac, než by klávesnica mohla reprezentovať;
-Množinové a rela�né symboly, šípky, operátory a Grécke písmená sú len malou ukážkou.\\
-
-Množiny a relácie hrajú hlavnú rolu v mnohých matematických �lánkoch.
-Takto napíšeš, že nie�o platí pre všetky x patriace do X, $\forall$ x $\in$ X. \\
-% Všimni si, že som pridal $ pred a po symboloch. Je to 
-% preto, lebo pri písaní sme v textovom móde, 
-% no matematické symboly existujú len v matematickom. 
-% Vstúpime doňho z textového práve '$' znamienkami.
-% Platí to aj opa�ne. Premenná môže byť zobrazená v matematickom móde takisto.
-% Do matematického módu sa dá dostať aj s \[\]
-
-\[a^2 + b^2 = c^2 \]
-
-Moje obľúbené Grécke písmeno je $\xi$. Tiež sa mi pozdávajú $\beta$, $\gamma$ a $\sigma$.
-Ešte som neprišiel na Grécke písmeno, ktoré by LaTeX nepoznal!
-
-Operátory sú dôležitou sú�asťou matematických dokumentov: 
-goniometrické funkcie ($\sin$, $\cos$, $\tan$), 
-logaritmy and exponenciálne výrazy ($\log$, $\exp$), 
-limity ($\lim$), at�. 
-majú pred-definované LaTeXové príkazy. 
-Napíšme si rovnicu, nech vidíme, ako to funguje: \\
-
-$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
-
-Zlomky(Čitateľ-menovateľ) sa píšu v týchto formách:
-
-% 10 / 7
-$^{10}/_{7}$ 
-
-% Relatívne komplexné zlomky sa píšu ako
-% \frac{�itateľ}{menovateľ}
-$\frac{n!}{k!(n - k)!}$ \\
-
-Rovnice tiež môžeme zadať v "rovnicovom prostredí". 
-
-% Takto funguje rovnicové prostredie
-\begin{equation} % vstúpi do matematického módu
-    c^2 = a^2 + b^2.
-    \label{eq:pythagoras} % na odkazovanie
-\end{equation} % všetky \begin príkazy musia mať kone�ný príkaz.
-
-Teraz môžeme odkázať na novovytvorenú rovnicu! 
-Rovn.~\ref{eq:pythagoras} je tiež známa ako Pytagorova Veta, ktorá je tiež predmetom Sekc.~\ref{subsec:pytagoras}. Odkazovať môžme na veľa vecí, napr na: �ísla, rovnice, �i sekcie.
-
-Sumácie a Integrály sa píšu príkazmi sum a int:
-
-% Niektoré preklada�e LaTeXu sa môžu sťažovať na prázdne riadky (ak tam sú)
-% v rovnicovom prostredí.
-\begin{equation} 
-  \sum_{i=0}^{5} f_{i}
-\end{equation} 
-\begin{equation} 
-  \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
-\end{equation} 
-
-\section{Obrázky}
-
-Vloženie obrázku môže byť zložitejšie. Ja si vždy možnosti vloženia pozerám pre každý obrázok.
-\renewcommand\figurename{Obrázok}
-\begin{figure}[H] % H zna�í možnosť zarovnania. 
-    \centering % nacentruje obrázok na stránku
-    % Vloží obrázok na 80% šírky stránky.
-    %\includegraphics[width=0.8\linewidth]{right-triangle.png} 
-    % Zakomentované kvôli kompilácií, použi svoju predstavivosť :).
-    \caption{Pravouhlý trojuholník so stranami $a$, $b$, $c$}
-    \label{fig:right-triangle}
-\end{figure}
-% Opäť, fixné makro "table" nahradíme slovenskou tabuľkou. Pokiaľ preferuješ table, nasledujúci riadok nepridávaj
-\renewcommand\tablename{Tabuľka}
-
-\subsection{Tabuľky}
-Tabuľky sa vkládajú podobne ako obrázky.
-
-\begin{table}[H]
-  \caption{Nadpis tabuľky.}
-  % zátvorky: {} hovoria ako sa vykreslí každý riadok.
-  % Toto si nikdy nepamätám a vždy to musím hľadať. Všetko. Každý. Jeden. Raz!
-  \begin{tabular}{c|cc} 
-    Číslo & Priezvisko & Krstné meno \\ % Stĺpce sú rozdelené $
-    \hline % horizontálna �iara
-    1 & Ladislav & Meliško \\
-    2 & Eva & Máziková
-  \end{tabular}
-\end{table}
-
-% \section{Hyperlinks} % Už �oskoro :)
-
-\section{Prikáž LaTeXu nekompilovať (napr. Zdrojový Kód)}
-Povedzme, že chceme do dokumentu vložiť zdrojový kód, budeme musieť LaTeXu povedať, nech sa ho nesnaží skompilovať, ale nech s ním pracuje ako s textom.
-Toto sa robí vo verbatim prostredí. 
-
-% Tiež sú na to špeciálne balí�ky, (napr. minty, lstlisting, at�.)
-% ale verbatim je to najzákladnejšie, �o môžeš použiť.
-\begin{verbatim} 
-  print("Hello World!")
-  a%b; pozri! Vo verbatime môžme použiť % znamienka. 
-  random = 4; #priradené randomným hodom kockou
-\end{verbatim}
-
-\section{Kompilácia} 
-
-Už by bolo na�ase túto nádheru skompilovať a zhliadnuť jej úžasnú úžasnosť v podobe LaTeX pdfka, �o povieš?
-(áno, tento dokument sa musí kompilovať). \\
-Cesta k finálnemu dokumentu pomocou LaTeXu pozostáva z nasledujúcich krokov:
-  \begin{enumerate}
-    \item Napíš dokument v �istom texte (v "zdrojáku").
-    \item Skompiluj zdroják na získanie pdfka. 
-     Kompilácia by mala vyzerať nasledovne (v Linuxe): \\
-     \begin{verbatim} 
-        $pdflatex learn-latex.tex learn-latex.pdf 
-     \end{verbatim}
-  \end{enumerate}
-
-Mnoho LaTeX editorov kombinuje Krok 1 a Krok 2 v jednom prostredí. Krok 1 teda uvidíš, krok 2 už nie.
-Ten sa deje za oponou. Kompilácia v 2. kroku sa postará o produkciu dokumentu v tebou zadanom formáte.
-
-\section{Koniec}
-
-To je zatiaľ všetko!
-
-% koniec dokumentu
-\end{document}
diff --git a/sl-si/asciidoc-sl.html.markdown b/sl-si/asciidoc-sl.html.markdown
index 52f30fbd..84bb85a1 100644
--- a/sl-si/asciidoc-sl.html.markdown
+++ b/sl-si/asciidoc-sl.html.markdown
@@ -6,7 +6,7 @@ contributors:
 translators:
     - ["Filip Å tamcar", "https://github.com/filips123"]
 lang: sl-si
-filename: asciidoc-sl.md
+filename: asciidoc-sl.adoc
 ---
 
 AsciiDoc je ozna�evalni jezik, ki je podoben Markdownu in ga je mogo�e uporabiti za vse od knjig do spletnih dnevnikov. Jezik, ki ga je leta 2002 ustvaril Stuart Rackham, je preprost, vendar omogo�a veliko prilagoditev.
diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown
index aaa592dc..9c2e870e 100644
--- a/smalltalk.html.markdown
+++ b/smalltalk.html.markdown
@@ -2,16 +2,15 @@
 language: Smalltalk
 filename: smalltalk.st
 contributors:
-    - ["Jigyasa Grover", "https://github.com/jigyasa-grover"]
+    - ["Jigyasa Grover", "https://jigyasa-grover.github.io"]
     - ["tim Rowledge", "tim@rowledge.org"]
 ---
+<blockquote>Every effort has been made in the preparation of this material to ensure the accuracy and completeness of the information presented. However, no guarantee is given nor responsibility taken for errors or omissions. In case of any error, questions or suggestions on reach out to me at <a href="https://jigyasa-grover.github.io" target="_blank">jigyasa-grover.github.io</a> or drop me an e-mail at <a href="mailto:grover.jigyasa1@gmail.com" target="_blank">grover[dot]jigyasa1[at]gmail.com</a>.</blockquote>
 
 - Smalltalk is a fully object-oriented, dynamically typed, reflective programming language with no 'non-object' types.
 - Smalltalk was created as the language to underpin the "new world" of computing exemplified by "human–computer symbiosis."
 - It was designed and created in part for educational use, more so for constructionist learning, at the Learning Research Group (LRG) of Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace, and others during the 1970s.
 
-`Feedback highly appreciated! Reach me at [@jigyasa_grover](https://twitter.com/jigyasa_grover) or send me an e-mail at grover.jigyasa1@gmail.com.`
-
 ## The Basics
 
 ### Everything is an object
@@ -60,7 +59,7 @@ doSomethingWith: argumentObject
 
 Everything here except the `^` involves sending more messages. Event the `ifTrue:` that you might think is a language control structure is just Smalltalk code.
 
-We start by sending `size` to `self`. `self` is the object currently running the code - so in this case it is the myObject we started with. `size` is a very common message that we might anticipate tells us something about how big an object is; you could look it up with the Smalltalk tools very simply. The result we get is then sent the message `>` with the plain old integer 4 (which is an object too; no strange primitive types to pollute the system here) and nobody should be surprised the `>` is a comparison that answers true or false. That boolean (which is actually a Boolean object in Smalltalk) is sent the message `ifTrue:` with the block of code between the `[]` as its argument; obvioulsy a true boolean might be expected to run that block of code and a false to ignore it. 
+We start by sending `size` to `self`. `self` is the object currently running the code - so in this case it is the myObject we started with. `size` is a very common message that we might anticipate tells us something about how big an object is; you could look it up with the Smalltalk tools very simply. The result we get is then sent the message `>` with the plain old integer 4 (which is an object too; no strange primitive types to pollute the system here) and nobody should be surprised the `>` is a comparison that answers true or false. That boolean (which is actually a Boolean object in Smalltalk) is sent the message `ifTrue:` with the block of code between the `[]` as its argument; obviously a true boolean might be expected to run that block of code and a false to ignore it. 
 
 If the block is run then we do some more message sending to the argument object and noting the `^` we return the answer back to our starting point and it gets assigned to `result`. If the block is ignored we seem to run out of code and so `self` is returned and assigned to `result`.
 
@@ -162,7 +161,7 @@ b := (x < 5) xor: (y > 1).             "test if one true and other false"
 b := 5 between: 3 and: 12.             "between (inclusive)"
 b := 123 isKindOf: Number.             "test if object is class or subclass of"
 b := 123 isMemberOf: SmallInteger.     "test if object is type of class"
-b := 123 respondsTo: sqrt.             "test if object responds to message"
+b := 123 respondsTo: #sqrt.             "test if object responds to message"
 b := x isNil.                          "test if object is nil"
 b := x isZero.                         "test if number is zero"
 b := x positive.                       "test if number is positive"
diff --git a/solidity.html.markdown b/solidity.html.markdown
index 251e9008..d40536b4 100644
--- a/solidity.html.markdown
+++ b/solidity.html.markdown
@@ -214,7 +214,7 @@ assert(c >= a); // assert tests for internal invariants; require is used for use
 // https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
 
 
-// No random functions built in, you can get a pseduo-random number by hashing the current blockhash, or get a truely random number using something like Chainlink VRF. 
+// No random functions built in, you can get a pseduo-random number by hashing the current blockhash, or get a truly random number using something like Chainlink VRF. 
 // https://docs.chain.link/docs/get-a-random-number
 
 // Type casting
@@ -278,7 +278,7 @@ f(22); // call
 
 // Delete can be called on most types
 // (does NOT destroy value, but sets value to 0, the initial value)
-uint x = 5;
+delete x;
 
 
 // Destructuring/Tuples
@@ -295,7 +295,7 @@ names.length; // get length
 names.length = 1; // lengths can be set (for dynamic arrays in storage only)
 
 // multidimensional array
-uint x[][5]; // arr with 5 dynamic array elements (opp order of most languages)
+uint[][5] x; // arr with 5 dynamic array elements (opp order of most languages)
 
 // Dictionaries (any type to any other type)
 mapping (string => uint) public balances;
@@ -388,7 +388,7 @@ block.gasLimit();
 storage['abc'] = 'def'; // maps 256 bit words to 256 bit words
 
 
-// 4. FUNCTIONS AND MORE
+// 5. FUNCTIONS AND MORE
 // A. Functions
 // Simple function
 function increment(uint x) returns (uint) {
@@ -396,13 +396,13 @@ function increment(uint x) returns (uint) {
     return x;
 }
 
-// Functions can return many arguments, and by specifying returned arguments
-// name don't need to explicitly return
+// Functions can return many arguments,
+// and by specifying returned arguments name explicit return is not needed
 function increment(uint x, uint y) returns (uint x, uint y) {
     x += 1;
     y += 1;
 }
-// Call previous functon
+// Call previous function
 uint (a,b) = increment(1,1);
 
 // 'view' (alias for 'constant')
@@ -435,7 +435,7 @@ function increment(uint x) view returns (uint x) {
 // Functions hoisted - and can assign a function to a variable
 function a() {
     var z = b;
-    b();
+    z();
 }
 
 function b() {
@@ -494,9 +494,9 @@ Coin.LogSent().watch({}, '', function(error, result) {
 // '_' (underscore) often included as last line in body, and indicates
 // function being called should be placed there
 modifier onlyAfter(uint _time) { require (now >= _time); _; }
-modifier onlyOwner { require(msg.sender == owner) _; }
+modifier onlyOwner { require(msg.sender == owner); _; }
 // commonly used with state machines
-modifier onlyIfStateA (State currState) { require(currState == State.A) _; }
+modifier onlyIfStateA (State currState) { require(currState == State.A); _; }
 
 // Append right after function declaration
 function changeOwner(newOwner)
@@ -646,7 +646,7 @@ reveal(100, "mySecret");
 // All data to start of time is stored in blockchain, so
 // anyone can observe all previous data and changes
 
-// E. Oracles and External Data
+// D. Oracles and External Data
 // Oracles are ways to interact with your smart contracts outside the blockchain. 
 // They are used to get data from the real world, send post requests, to the real world
 // or vise versa.
@@ -654,7 +654,7 @@ reveal(100, "mySecret");
 // Time-based implementations of contracts are also done through oracles, as 
 // contracts need to be directly called and can not "subscribe" to a time. 
 // Due to smart contracts being decentralized, you also want to get your data
-// in a decentralized manner, other your run into the centralized risk that 
+// in a decentralized manner, otherwise you run into the centralized risk that 
 // smart contract design matter prevents. 
 
 // To easiest way get and use pre-boxed decentralized data is with Chainlink Data Feeds
@@ -671,12 +671,12 @@ reveal(100, "mySecret");
 
 // Setting up oracle networks yourself
 
-// D. Cron Job
+// E. Cron Job
 // Contracts must be manually called to handle time-based scheduling; can create external
 // code to regularly ping, or provide incentives (ether) for others to
 //
 
-// E. Observer Pattern
+// F. Observer Pattern
 // An Observer Pattern lets you register as a subscriber and
 // register a function which is called by the oracle (note, the oracle pays
 // for this action to be run)
@@ -714,7 +714,7 @@ contract SomeOracle {
 // Now, your client contract can addSubscriber by importing SomeOracleCallback
 // and registering with Some Oracle
 
-// F. State machines
+// G. State machines
 // see example below for State enum and inState modifier
 ```
 
diff --git a/sorbet.html.markdown b/sorbet.html.markdown
new file mode 100644
index 00000000..9c2e809b
--- /dev/null
+++ b/sorbet.html.markdown
@@ -0,0 +1,1040 @@
+---
+language: sorbet
+filename: learnsorbet.rb
+contributors:
+  - ["Jeremy Kaplan", "https://jdkaplan.dev"]
+---
+
+Sorbet is a type checker for Ruby. It adds syntax for method signatures that
+enable both static and runtime type checking.
+
+The easiest way to see it in action is in the playground at
+[sorbet.run](https://sorbet.run).
+
+Try copying in one of the sections below! Each top-level `class` or `module`
+is independent from the others.
+
+```ruby
+# Every file should have a "typed sigil" that tells Sorbet how strict to be
+# during static type checking.
+#
+# Strictness levels (lax to strict):
+#
+# ignore: Sorbet won't even read the file. This means its contents are not
+# visible during type checking. Avoid this.
+#
+# false: Sorbet will only report errors related to constant resolution. This is
+# the default if no sigil is included.
+#
+# true: Sorbet will report all static type errors. This is the sweet spot of
+# safety for effort.
+#
+# strict: Sorbet will require that all methods, constants, and instance
+# variables have static types.
+#
+# strong: Sorbet will no longer allow anything to be T.untyped, even
+# explicitly. Almost nothing satisfies this.
+
+# typed: true
+
+# Include the runtime type-checking library. This lets you write inline sigs
+# and have them checked at runtime (instead of running Sorbet as RBI-only).
+# These runtime checks happen even for files with `ignore` or `false` sigils.
+require 'sorbet-runtime'
+
+class BasicSigs
+  # Bring in the type definition helpers. You'll almost always need this.
+  extend T::Sig
+
+  # Sigs are defined with `sig` and a block. Define the return value type with
+  # `returns`.
+  #
+  # This method returns a value whose class is `String`. These are the most
+  # common types, and Sorbet calls them "class types".
+  sig { returns(String) }
+  def greet
+    'Hello, World!'
+  end
+
+  # Define parameter value types with `params`.
+  sig { params(n: Integer).returns(String) }
+  def greet_repeat(n)
+    (1..n).map { greet }.join("\n")
+  end
+
+  # Define keyword parameters the same way.
+  sig { params(n: Integer, sep: String).returns(String) }
+  def greet_repeat_2(n, sep: "\n")
+    (1..n).map { greet }.join(sep)
+  end
+
+  # Notice that positional/keyword and required/optional make no difference
+  # here. They're all defined the same way in `params`.
+
+  # For lots of parameters, it's nicer to use do..end and a multiline block
+  # instead of curly braces.
+  sig do
+    params(
+      str: String,
+      num: Integer,
+      sym: Symbol,
+    ).returns(String)
+  end
+  def uhh(str:, num:, sym:)
+    'What would you even do with these?'
+  end
+
+  # For a method whose return value is useless, use `void`.
+  sig { params(name: String).void }
+  def say_hello(name)
+    puts "Hello, #{name}!"
+  end
+
+  # Splats! Also known as "rest parameters", "*args", "**kwargs", and others.
+  #
+  # Type the value that a _member_ of `args` or `kwargs` will have, not `args`
+  # or `kwargs` itself.
+  sig { params(args: Integer, kwargs: String).void }
+  def no_op(*args, **kwargs)
+    if kwargs[:op] == 'minus'
+      args.each { |i| puts(i - 1) }
+    else
+      args.each { |i| puts(i + 1) }
+    end
+  end
+
+  # Most initializers should be `void`.
+  sig { params(name: String).void }
+  def initialize(name:)
+    # Instance variables must have annotated types to participate in static
+    # type checking.
+
+    # The value in `T.let` is checked statically and at runtime.
+    @upname = T.let(name.upcase, String)
+
+    # Sorbet can infer this one!
+    @name = name
+  end
+
+  # Constants also need annotated types.
+  SORBET = T.let('A delicious frozen treat', String)
+
+  # Class variables too.
+  @@the_answer = T.let(42, Integer)
+
+  # Sorbet knows about the `attr_*` family.
+  sig { returns(String) }
+  attr_reader :upname
+
+  sig { params(write_only: Integer).returns(Integer) }
+  attr_writer :write_only
+
+  # You say the reader part and Sorbet will say the writer part.
+  sig { returns(String) }
+  attr_accessor :name
+end
+
+module Debugging
+  extend T::Sig
+
+  # Sometimes it's helpful to know what type Sorbet has inferred for an
+  # expression. Use `T.reveal_type` to make type-checking show a special error
+  # with that information.
+  #
+  # This is most useful if you have Sorbet integrated into your editor so you
+  # can see the result as soon as you save the file.
+
+  sig { params(obj: Object).returns(String) }
+  def debug(obj)
+    T.reveal_type(obj) # Revealed type: Object
+    repr = obj.inspect
+
+    # Remember that Ruby methods can be called without arguments, so you can
+    # save a couple characters!
+    T.reveal_type repr # Revealed type: String
+
+    "DEBUG: " + repr
+  end
+end
+
+module StandardLibrary
+  extend T::Sig
+  # Sorbet provides some helpers for typing the Ruby standard library.
+
+  # Use T::Boolean to catch both `true` and `false`.
+  #
+  # For the curious, this is equivalent to
+  #
+  #     T.type_alias { T.any(TrueClass, FalseClass) }
+  #
+  sig { params(str: String).returns(T::Boolean) }
+  def confirmed?(str)
+    str == 'yes'
+  end
+
+  # Remember that the value `nil` is an instance of NilClass.
+  sig { params(val: NilClass).void }
+  def only_nil(val:); end
+
+  # To avoid modifying standard library classes, Sorbet provides wrappers to
+  # support common generics.
+  #
+  # Here's the full list:
+  # * T::Array
+  # * T::Enumerable
+  # * T::Enumerator
+  # * T::Hash
+  # * T::Range
+  # * T::Set
+  sig { params(config: T::Hash[Symbol, String]).returns(T::Array[String]) }
+  def merge_values(config)
+    keyset = [:old_key, :new_key]
+    config.each_pair.flat_map do |key, value|
+      keyset.include?(key) ? value : 'sensible default'
+    end
+  end
+
+  # Sometimes (usually dependency injection), a method will accept a reference
+  # to a class rather than an instance of the class. Use `T.class_of(Dep)` to
+  # accept the `Dep` class itself (or something that inherits from it).
+  class Dep; end
+
+  sig { params(dep: T.class_of(Dep)).returns(Dep) }
+  def dependency_injection(dep:)
+    dep.new
+  end
+
+  # Blocks, procs, and lambdas, oh my! All of these are typed with `T.proc`.
+  #
+  # Limitations:
+  # 1. All parameters are assumed to be required positional parameters.
+  # 2. The only runtime check is that the value is a `Proc`. The argument types
+  #    are only checked statically.
+  sig do
+    params(
+      data: T::Array[String],
+      blk: T.proc.params(val: String).returns(Integer),
+    ).returns(Integer)
+  end
+  def count(data, &blk)
+    data.sum(&blk)
+  end
+
+  sig { returns(Integer) }
+  def count_usage
+    count(["one", "two", "three"]) { |word| word.length + 1 }
+  end
+
+  # If the method takes an implicit block, Sorbet will infer `T.untyped` for
+  # it. Use the explicit block syntax if the types are important.
+  sig { params(str: String).returns(T.untyped) }
+  def implicit_block(str)
+    yield(str)
+  end
+
+  # If you're writing a DSL and will execute the block in a different context,
+  # use `bind`.
+  sig { params(num: Integer, blk: T.proc.bind(Integer).void).void }
+  def number_fun(num, &blk)
+    num.instance_eval(&blk)
+  end
+
+  sig { params(num: Integer).void }
+  def number_fun_usage(num)
+    number_fun(10) { puts digits.join }
+  end
+
+  # If the block doesn't take any parameters, don't include `params`.
+  sig { params(blk: T.proc.returns(Integer)).returns(Integer) }
+  def doubled_block(&blk)
+    2 * blk.call
+  end
+end
+
+module Combinators
+  extend T::Sig
+  # These methods let you define new types from existing types.
+
+  # Use `T.any` when you have a value that can be one of many types. These are
+  # sometimes known as "union types" or "sum types".
+  sig { params(num: T.any(Integer, Float)).returns(Rational) }
+  def hundreds(num)
+    num.rationalize
+  end
+
+  # `T.nilable(Type)` is a convenient alias for `T.any(Type, NilClass)`.
+  sig { params(val: T.nilable(String)).returns(Integer) }
+  def strlen(val)
+    val.nil? ? -1 : val.length
+  end
+
+  # Use `T.all` when you have a value that must satisfy multiple types. These
+  # are sometimes known as "intersection types". They're most useful for
+  # interfaces (described later), but can also describe helper modules.
+
+  module Reversible
+    extend T::Sig
+    sig { void }
+    def reverse
+      # Pretend this is actually implemented
+    end
+  end
+
+  module Sortable
+    extend T::Sig
+    sig { void }
+    def sort
+      # Pretend this is actually implemented
+    end
+  end
+
+  class List
+    include Reversible
+    include Sortable
+  end
+
+  sig { params(list: T.all(Reversible, Sortable)).void }
+  def rev_sort(list)
+    # reverse from Reversible
+    list.reverse
+    # sort from Sortable
+    list.sort
+  end
+
+  def rev_sort_usage
+    rev_sort(List.new)
+  end
+
+  # Sometimes, actually spelling out the type every time becomes more confusing
+  # than helpful. Use type aliases to make them easier to work with.
+  JSONLiteral = T.type_alias { T.any(Float, String, T::Boolean, NilClass) }
+
+  sig { params(val: JSONLiteral).returns(String) }
+  def stringify(val)
+    val.to_s
+  end
+end
+
+module DataClasses
+  extend T::Sig
+  # Use `T::Struct` to create a new class with type-checked fields. It combines
+  # the best parts of the standard Struct and OpenStruct, and then adds static
+  # typing on top.
+  #
+  # Types constructed this way are sometimes known as "product types".
+
+  class Matcher < T::Struct
+    # Use `prop` to define a field with both a reader and writer.
+    prop :count, Integer
+    # Use `const` to only define the reader and skip the writer.
+    const :pattern, Regexp
+    # You can still set a default value with `default`.
+    const :message, String, default: 'Found one!'
+
+    # This is otherwise a normal class, so you can still define methods.
+
+    # You'll still need to bring `sig` in if you want to use it though.
+    extend T::Sig
+
+    sig { void }
+    def reset
+      self.count = 0
+    end
+  end
+
+  sig { params(text: String, matchers: T::Array[Matcher]).void }
+  def awk(text, matchers)
+    matchers.each(&:reset)
+    text.lines.each do |line|
+      matchers.each do |matcher|
+        if matcher.pattern =~ line
+          Kernel.puts matcher.message
+          matcher.count += 1
+        end
+      end
+    end
+  end
+
+  # Gotchas and limitations
+
+  # 1. `const` fields are not truly immutable. They don't have a writer method,
+  #    but may be changed in other ways.
+  class ChangeMe < T::Struct
+    const :list, T::Array[Integer]
+  end
+
+  sig { params(change_me: ChangeMe).returns(T::Boolean) }
+  def whoops!(change_me)
+    change_me = ChangeMe.new(list: [1, 2, 3, 4])
+    change_me.list.reverse!
+    change_me.list == [4, 3, 2, 1]
+  end
+
+  # 2. `T::Struct` inherits its equality method from `BasicObject`, which uses
+  #    identity equality (also known as "reference equality").
+  class Coordinate < T::Struct
+    const :row, Integer
+    const :col, Integer
+  end
+
+  sig { returns(T::Boolean) }
+  def never_equal!
+    p1 = Coordinate.new(row: 1, col: 2)
+    p2 = Coordinate.new(row: 1, col: 2)
+    p1 != p2
+  end
+
+  # Define your own `#==` method to check the fields, if that's what you want.
+  class Position < T::Struct
+    extend T::Sig
+
+    const :x, Integer
+    const :y, Integer
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other)
+      # There's a real implementation here:
+      # https://github.com/tricycle/sorbet-struct-comparable
+      true
+    end
+  end
+
+  # Use `T::Enum` to define a fixed set of values that are easy to reference.
+  # This is especially useful when you don't care what the values _are_ as much
+  # as you care that the set of possibilities is closed and static.
+  class Crayon < T::Enum
+    extend T::Sig
+
+    # Initialize members with `enums`.
+    enums do
+      # Define each member with `new`. Each of these is an instance of the
+      # `Crayon` class.
+      Red = new
+      Orange = new
+      Yellow = new
+      Green = new
+      Blue = new
+      Violet = new
+      Brown = new
+      Black = new
+      # The default value of the enum is its name in all-lowercase. To change
+      # that, pass a value to `new`.
+      Gray90 = new('light-gray')
+    end
+
+    sig { returns(String) }
+    def to_hex
+      case self
+      when Red   then '#ff0000'
+      when Green then '#00ff00'
+      # ...
+      else            '#ffffff'
+      end
+    end
+  end
+
+  sig { params(crayon: Crayon, path: T::Array[Position]).void }
+  def draw(crayon:, path:)
+    path.each do |pos|
+      Kernel.puts "(#{pos.x}, #{pos.y}) = " + crayon.to_hex
+    end
+  end
+
+  # To get all the values in the enum, use `.values`. For convenience there's
+  # already a `#serialize` to get the enum string value.
+
+  sig { returns(T::Array[String]) }
+  def crayon_names
+    Crayon.values.map(&:serialize)
+  end
+
+  # Use the "deserialize" family to go from string to enum value.
+
+  sig { params(name: String).returns(T.nilable(Crayon)) }
+  def crayon_from_name(name)
+    if Crayon.has_serialized?(name)
+      # If the value is not found, this will raise a `KeyError`.
+      Crayon.deserialize(name)
+    end
+
+    # If the value is not found, this will return `nil`.
+    Crayon.try_deserialize(name)
+  end
+end
+
+module FlowSensitivity
+  extend T::Sig
+  # Sorbet understands Ruby's control flow constructs and uses that information
+  # to get more accurate types when your code branches.
+
+  # You'll see this most often when doing nil checks.
+  sig { params(name: T.nilable(String)).returns(String) }
+  def greet_loudly(name)
+    if name.nil?
+      'HELLO, YOU!'
+    else
+      # Sorbet knows that `name` must be a String here, so it's safe to call
+      # `#upcase`.
+      "HELLO, #{name.upcase}!"
+    end
+  end
+
+  # The nils are a special case of refining `T.any`.
+  sig { params(id: T.any(Integer, T::Array[Integer])).returns(T::Array[String]) }
+  def database_lookup(id)
+    if id.is_a?(Integer)
+      # `ids` must be an Integer here.
+      [id.to_s]
+    else
+      # `ids` must be a T::Array[Integer] here.
+      id.map(&:to_s)
+    end
+  end
+
+  # Sorbet recognizes these methods that narrow type definitions:
+  # * is_a?
+  # * kind_of?
+  # * nil?
+  # * Class#===
+  # * Class#<
+  # * block_given?
+  #
+  # Because they're so common, it also recognizes these Rails extensions:
+  # * blank?
+  # * present?
+  #
+  # Be careful to maintain Sorbet assumptions if you redefine these methods!
+
+  # Have you ever written this line of code?
+  #
+  #     raise StandardError, "Can't happen"
+  #
+  # Sorbet can help you prove that statically (this is known as
+  # "exhaustiveness") with `T.absurd`.  It's extra cool when combined with
+  # `T::Enum`!
+
+  class Size < T::Enum
+    extend T::Sig
+
+    enums do
+      Byte = new('B')
+      Kibibyte = new('KiB')
+      Mebibyte = new('MiB')
+      # "640K ought to be enough for anybody"
+    end
+
+    sig { returns(Integer) }
+    def bytes
+      case self
+        when Byte     then 1 <<  0
+        when Kibibyte then 1 << 10
+        when Mebibyte then 1 << 20
+        else
+          # Sorbet knows you've checked all the cases, so there's no possible
+          # value that `self` could have here.
+          #
+          # But if you _do_ get here somehow, this will raise at runtime.
+          T.absurd(self)
+
+          # If you're missing a case, Sorbet can even tell you which one it is!
+      end
+    end
+  end
+
+  # We're gonna need `puts` and `raise` for this next part.
+  include Kernel
+
+  # Sorbet knows that no code can execute after a `raise` statement because it
+  # "never returns".
+  sig { params(num: T.nilable(Integer)).returns(Integer) }
+  def decrement(num)
+    raise ArgumentError, '¯\_(ツ)_/¯' unless num
+
+    num - 1
+  end
+
+  class CustomError < StandardError; end
+
+  # You can annotate your own error-raising methods with `T.noreturn`.
+  sig { params(message: String).returns(T.noreturn) }
+  def oh_no(message = 'A bad thing happened')
+    puts message
+    raise CustomError, message
+  end
+
+  # Infinite loops also don't return.
+  sig { returns(T.noreturn) }
+  def loading
+    loop do
+      %q(-\|/).each_char do |c|
+        print "\r#{c} reticulating splines..."
+        sleep 1
+      end
+    end
+  end
+
+  # You may run into a situation where Sorbet "loses" your type refinement.
+  # Remember that almost everything you do in Ruby is a method call that could
+  # return a different value next time you call it. Sorbet doesn't assume that
+  # any methods are pure (even those from `attr_reader` and `attr_accessor`).
+  sig { returns(T.nilable(Integer)) }
+  def answer
+    rand > 0.5 ? 42 : nil
+  end
+
+  sig { void }
+  def bad_typecheck
+    if answer.nil?
+      0
+    else
+      # But answer might return `nil` if we call it again!
+      answer + 1
+      # ^ Method + does not exist on NilClass component of T.nilable(Integer)
+    end
+  end
+
+  sig { void }
+  def good_typecheck
+    ans = answer
+    if ans.nil?
+      0
+    else
+      # This time, Sorbet knows that `ans` is non-nil.
+      ans + 1
+    end
+  end
+end
+
+module InheritancePatterns
+  extend T::Sig
+
+  # If you have a method that always returns the type of its receiver, use
+  # `T.self_type`. This is common in fluent interfaces and DSLs.
+  #
+  # Warning: This feature is still experimental!
+  class Logging
+    extend T::Sig
+
+    sig { returns(T.self_type) }
+    def log
+      pp self
+      self
+    end
+  end
+
+  class Data < Logging
+    extend T::Sig
+
+    sig { params(x: Integer, y: String).void }
+    def initialize(x: 0, y: '')
+      @x = x
+      @y = y
+    end
+
+    # You don't _have_ to use `T.self_type` if there's only one relevant class.
+    sig { params(x: Integer).returns(Data) }
+    def setX(x)
+      @x = x
+      self
+    end
+
+    sig { params(y: String).returns(Data) }
+    def setY(y)
+      @y = y
+      self
+    end
+  end
+
+  # Ta-da!
+  sig { params(data: Data).void }
+  def chaining(data)
+    data.setX(1).log.setY('a')
+  end
+
+  # If it's a class method (a.k.a. singleton method), use `T.attached_class`.
+  #
+  # No warning here. This one is stable!
+  class Box
+    extend T::Sig
+
+    sig { params(contents: String, weight: Integer).void }
+    def initialize(contents, weight)
+      @contents = contents
+      @weight = weight
+    end
+
+    sig { params(contents: String).returns(T.attached_class) }
+    def self.pack(contents)
+      new(contents, contents.chars.uniq.length)
+    end
+  end
+
+  class CompanionCube < Box
+    extend T::Sig
+
+    sig { returns(String) }
+    def pick_up
+      "♥#{@contents}�"
+    end
+  end
+
+  sig { returns(String) }
+  def befriend
+    CompanionCube.pack('').pick_up
+  end
+
+  # Sorbet has support for abstract classes and interfaces. It can check that
+  # all the concrete classes and implementations actually define the required
+  # methods with compatible signatures.
+
+  # Here's an abstract class:
+
+  class WorkflowStep
+    extend T::Sig
+
+    # Bring in the inheritance helpers.
+    extend T::Helpers
+
+    # Mark this class as abstract. This means it cannot be instantiated with
+    # `.new`, but it can still be subclassed.
+    abstract!
+
+    sig { params(args: T::Array[String]).void }
+    def run(args)
+      pre_hook
+      execute(args)
+      post_hook
+    end
+
+    # This is an abstract method, which means it _must_ be implemented by
+    # subclasses. Add a signature with `abstract` to an empty method to tell
+    # Sorbet about it.
+    #
+    # If this implementation of the method actually gets called at runtime, it
+    # will raise `NotImplementedError`.
+    sig { abstract.params(args: T::Array[String]).void }
+    def execute(args); end
+
+    # The following non-abstract methods _can_ be implemented by subclasses,
+    # but they're optional.
+
+    sig { void }
+    def pre_hook; end
+
+    sig { void }
+    def post_hook; end
+  end
+
+  class Configure < WorkflowStep
+    extend T::Sig
+
+    sig { void }
+    def pre_hook
+      puts 'Configuring...'
+    end
+
+    # To implement an abstract method, mark the signature with `override`.
+    sig { override.params(args: T::Array[String]).void }
+    def execute(args)
+      # ...
+    end
+  end
+
+  # And here's an interface:
+
+  module Queue
+    extend T::Sig
+
+    # Bring in the inheritance helpers.
+    extend T::Helpers
+
+    # Mark this module as an interface. This adds the following restrictions:
+    # 1. All of its methods must be abstract.
+    # 2. It cannot have any private or protected methods.
+    interface!
+
+    sig { abstract.params(num: Integer).void }
+    def push(num); end
+
+    sig { abstract.returns(T.nilable(Integer)) }
+    def pop; end
+  end
+
+  class PriorityQueue
+    extend T::Sig
+
+    # Include the interface to tell Sorbet that this class implements it.
+    # Sorbet doesn't support implicitly implemented interfaces (also known as
+    # "duck typing").
+    include Queue
+
+    sig { void }
+    def initialize
+      @items = T.let([], T::Array[Integer])
+    end
+
+    # Implement the Queue interface's abstract methods. Remember to use
+    # `override`!
+
+    sig { override.params(num: Integer).void }
+    def push(num)
+      @items << num
+      @items.sort!
+    end
+
+    sig { override.returns(T.nilable(Integer)) }
+    def pop
+      @items.shift
+    end
+  end
+
+  # If you use the `included` hook to get class methods from your modules,
+  # you'll have to use `mixes_in_class_methods` to get them to type-check.
+
+  module Mixin
+    extend T::Helpers
+    interface!
+
+    module ClassMethods
+      extend T::Sig
+
+      sig { void }
+      def whisk
+        'fskfskfsk'
+      end
+    end
+
+    mixes_in_class_methods(ClassMethods)
+  end
+
+  class EggBeater
+    include Mixin
+  end
+
+  EggBeater.whisk # Meringue!
+end
+
+module EscapeHatches
+  extend T::Sig
+
+  # Ruby is a very dynamic language, and sometimes Sorbet can't infer the
+  # properties you already know to be true. Although there are ways to rewrite
+  # your code so Sorbet can prove safety, you can also choose to "break out" of
+  # Sorbet using these "escape hatches".
+
+  # Once you start using `T.nilable`, Sorbet will start telling you _all_ the
+  # places you're not handling nils. Sometimes, you know a value can't be nil,
+  # but it's not practical to fix the sigs so Sorbet can prove it. In that
+  # case, you can use `T.must`.
+  sig { params(maybe_str: T.nilable(String)).returns(String) }
+  def no_nils_here(maybe_str)
+    # If maybe_str _is_ actually nil, this will error at runtime.
+    str = T.must(maybe_str)
+    str.downcase
+  end
+
+  # More generally, if you know that a value must be a specific type, you can
+  # use `T.cast`.
+  sig do
+    params(
+      str_or_ary: T.any(String, T::Array[String]),
+      idx_or_range: T.any(Integer, T::Range[Integer]),
+    ).returns(T::Array[String])
+  end
+  def slice2(str_or_ary, idx_or_range)
+    # Let's say that, for some reason, we want individual characters from
+    # strings or sub-arrays from arrays. The other options are not allowed.
+    if str_or_ary.is_a?(String)
+      # Here, we know that `idx_or_range` must be a single index. If it's not,
+      # this will error at runtime.
+      idx = T.cast(idx_or_range, Integer)
+      [str_or_ary.chars.fetch(idx)]
+    else
+      # Here, we know that `idx_or_range` must be a range. If it's not, this
+      # will error at runtime.
+      range = T.cast(idx_or_range, T::Range[Integer])
+      str_or_ary.slice(range) || []
+    end
+  end
+
+  # If you know that a method exists, but Sorbet doesn't, you can use
+  # `T.unsafe` so Sorbet will let you call it. Although we tend to think of
+  # this as being an "unsafe method call", `T.unsafe` is called on the receiver
+  # rather than the whole expression.
+  sig { params(count: Integer).returns(Date) }
+  def the_future(count)
+    # Let's say you've defined some extra date helpers that Sorbet can't find.
+    # So `2.decades` is effectively `(2*10).years` from ActiveSupport.
+    Date.today + T.unsafe(count).decades
+  end
+
+  # If this is a method on the implicit `self`, you'll have to make that
+  # explicit to use `T.unsafe`.
+  sig { params(count: Integer).returns(Date) }
+  def the_past(count)
+    # Let's say that metaprogramming defines a `now` helper method for
+    # `Time.new`. Using it would normally look like this:
+    #
+    #     now - 1234
+    #
+    T.unsafe(self).now - 1234
+  end
+
+  # There's a special type in Sorbet called `T.untyped`. For any value of this
+  # type, Sorbet will allow it to be used for any method argument and receive
+  # any method call.
+
+  sig { params(num: Integer, anything: T.untyped).returns(T.untyped) }
+  def nothing_to_see_here(num, anything)
+    anything.digits # Is it an Integer...
+    anything.upcase # ... or a String?
+
+    # Sorbet will not be able to infer anything about this return value because
+    # it's untyped.
+    BasicObject.new
+  end
+
+  def see_here
+    # It's actually nil!  This will crash at runtime, but Sorbet allows it.
+    nothing_to_see_here(1, nil)
+  end
+
+  # For a method without a sig, Sorbet infers the type of each argument and the
+  # return value to be `T.untyped`.
+end
+
+# The following types are not officially documented but are still useful. They
+# may be experimental, deprecated, or not supported.
+
+module ValueSet
+  extend T::Sig
+
+  # A common pattern in Ruby is to have a method accept one value from a set of
+  # options. Especially when starting out with Sorbet, it may not be practical
+  # to refactor the code to use `T::Enum`. In this case, you can use `T.enum`.
+  #
+  # Note: Sorbet can't check this statically becuase it doesn't track the
+  # values themselves.
+  sig do
+    params(
+      data: T::Array[Numeric],
+      shape: T.enum([:circle, :square, :triangle])
+    ).void
+  end
+  def plot_points(data, shape: :circle)
+    data.each_with_index do |y, x|
+      Kernel.puts "#{x}: #{y}"
+    end
+  end
+end
+
+module Generics
+  extend T::Sig
+
+  # Generics are useful when you have a class whose method types change based
+  # on the data it contains or a method whose method type changes based on what
+  # its arguments are.
+
+  # A generic method uses `type_parameters` to declare type variables and
+  # `T.type_parameter` to refer back to them.
+  sig do
+    type_parameters(:element)
+      .params(
+        element: T.type_parameter(:element),
+        count: Integer,
+      ).returns(T::Array[T.type_parameter(:element)])
+  end
+  def repeat_value(element, count)
+    count.times.each_with_object([]) do |elt, ary|
+      ary << elt
+    end
+  end
+
+  sig do
+    type_parameters(:element)
+      .params(
+        count: Integer,
+        block: T.proc.returns(T.type_parameter(:element)),
+      ).returns(T::Array[T.type_parameter(:element)])
+  end
+  def repeat_cached(count, &block)
+    elt = block.call
+    ary = []
+    count.times do
+      ary << elt
+    end
+    ary
+  end
+
+  # A generic class uses `T::Generic.type_member` to define type variables that
+  # can be like regular type names.
+  class BidirectionalHash
+    extend T::Sig
+    extend T::Generic
+
+    Left = type_member
+    Right = type_member
+
+    sig { void }
+    def initialize
+      @left_hash = T.let({}, T::Hash[Left, Right])
+      @right_hash = T.let({}, T::Hash[Right, Left])
+    end
+
+    # Implement just enough to make the methods below work.
+
+    sig { params(lkey: Left).returns(T::Boolean) }
+    def lhas?(lkey)
+      @left_hash.has_key?(lkey)
+    end
+
+    sig { params(rkey: Right).returns(T.nilable(Left)) }
+    def rget(rkey)
+      @right_hash[rkey]
+    end
+  end
+
+  # To specialize a generic type, use brackets.
+  sig do
+    params(
+      options: BidirectionalHash[Symbol, Integer],
+      choice: T.any(Symbol, Integer),
+    ).returns(T.nilable(String))
+  end
+  def lookup(options, choice)
+    case choice
+    when Symbol
+      options.lhas?(choice) ? choice.to_s : nil
+    when Integer
+      options.rget(choice).to_s
+    else
+      T.absurd(choice)
+    end
+  end
+
+  # To specialize through inheritance, re-declare the `type_member` with
+  # `fixed`.
+  class Options < BidirectionalHash
+    Left = type_member(fixed: Symbol)
+    Right = type_member(fixed: Integer)
+  end
+
+  sig do
+    params(
+      options: Options,
+      choice: T.any(Symbol, Integer),
+    ).returns(T.nilable(String))
+  end
+  def lookup2(options, choice)
+    lookup(options, choice)
+  end
+
+  # There are other variance annotations you can add to `type_member`, but
+  # they're rarely used.
+end
+```
+
+## Additional resources
+
+- [Official Documentation](https://sorbet.org/docs/overview)
+- [sorbet.run](https://sorbet.run) - Playground
diff --git a/sql.html.markdown b/sql.html.markdown
index 685e522d..834cf00b 100644
--- a/sql.html.markdown
+++ b/sql.html.markdown
@@ -95,7 +95,7 @@ UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
 
 -- Delete rows from the tablename1 table
 -- where the lname value begins with 'M'.
-DELETE FROM tablename1 WHERE lname like 'M%';
+DELETE FROM tablename1 WHERE lname LIKE 'M%';
 
 -- Delete all rows from the tablename1 table, leaving the empty table.
 DELETE FROM tablename1;
diff --git a/sv-se/nix-sv.html.markdown b/sv-se/nix-sv.html.markdown
index 647575fe..9069c286 100644
--- a/sv-se/nix-sv.html.markdown
+++ b/sv-se/nix-sv.html.markdown
@@ -366,6 +366,9 @@ with builtins; [
 
 * [Susan Potter - Nix Cookbook - Nix By Example]
   (https://ops.functionalalgebra.com/nix-by-example/)
-  
+
+* [Zero to Nix - Nix Tutorial]
+  (https://zero-to-nix.com/)
+
 * [Rommel Martinez - A Gentle Introduction to the Nix Family]
   (https://web.archive.org/web/20210121042658/https://ebzzry.io/en/nix/#nix)
diff --git a/swift.html.markdown b/swift.html.markdown
index 39a5cc52..36124e11 100644
--- a/swift.html.markdown
+++ b/swift.html.markdown
@@ -334,7 +334,7 @@ repeat {
 } while i < 5
 
 // The continue statement continues executing a loop at the next iteration
-// The break statement ends a swift or loop immediately
+// The break statement ends a loop immediately
 
 // MARK: - Functions
 
@@ -654,7 +654,7 @@ class Rect: Shape {
     // but still want to run code before and after getting or setting
     // a property, you can use `willSet` and `didSet`
     var identifier: String = "defaultID" {
-        // the `willSet` arg will be the variable name for the new value
+        // the `someIdentifier` arg will be the variable name for the new value
         willSet(someIdentifier) {
             print(someIdentifier)
         }
@@ -679,6 +679,9 @@ class Rect: Shape {
 
 // A simple class `Square` extends `Rect`
 class Square: Rect {
+    // Use a convenience initializer to make calling a designated initializer faster and more "convenient".
+    // Convenience initializers call other initializers in the same class and pass default values to one or more of their parameters.
+    // Convenience initializers can have parameters as well, which are useful to customize the called initializer parameters or choose a proper initializer based on the value passed.
     convenience init() {
         self.init(sideLength: 5)
     }
diff --git a/tact.html.markdown b/tact.html.markdown
new file mode 100644
index 00000000..2cb650ee
--- /dev/null
+++ b/tact.html.markdown
@@ -0,0 +1,603 @@
+---
+language: Tact
+filename: tact.tc
+contributors:
+  - ["Tal Kol", "https://www.orbs.com/"]
+  - ["Kirill Malev", "https://fslabs.io"]
+  - ["Yash Garg", "https://github.com/yash0501"]
+---
+
+Tact language is used to program smart contracts on the
+[The Open Network](https://ton.org) blockchain. Contract logic is executed in
+TVM, the stack-based TON Virtual Machine.
+
+Tact is a statically typed, but language was designed to be friendly for
+developers with JS and Python background.
+
+This page is based on [Tact-by-Example](https://tact-by-example.org/).
+You can use this resource to play around with contracts and check out
+the interactive features.
+
+# Basic syntax, function definition
+
+```c
+// Single line comment
+
+ // This is a multi-line comment
+  // this is a comment in the comment
+
+    get fun greeting(): String {
+    // This is a function that returns "hello world" message
+    // Return type is specified after a colon :
+        return "hello world";
+    }
+```
+
+# A Simple Counter contract
+
+This is a simple counter contract that allows users to increment its value.
+
+This contract has a state variable `val` that persists between contract calls
+
+- the counter value. When persisted, this variable is encoded as `uint32` -
+  a 32-bit unsigned integer. Contracts pay rent in proportion to the amount
+  of persistent space they consume, so compact representations are encouraged.
+
+State variables should be initialized in `init()` that runs on deployment of
+the contract.
+
+## Messages
+
+The actor model is a model of concurrent computation and is at the heart of TON
+smart contracts. Each smart contract can process one message at a time, change
+its own state, or send one or several messages. Processing of the message
+occurs in one transaction, that is, it cannot be interrupted. Messages to one
+contract are processed consequently one by one. As a result, the execution of
+each transaction is local and can be parallelized at the blockchain level,
+which allows for on-demand throughput horizontal scaling and hosting an
+unlimited number of users and transactions.
+
+## Receiving messages
+
+This contract can receive messages from users. Unlike getters that are just
+read-only, messages can do write operations and change the contract's
+persistent state. Incoming messages are processed in receive() methods as
+transactions and cost gas for the sender.
+
+After deploying the contract, send the increment message by pressing the Send
+increment button in order to increase the counter value by one. Afterwards,
+call the getter value() to see that the value indeed changed.
+
+```c
+contract Counter {
+// Tact allows to create a contract
+    // persistent state variable of type Int to hold the counter value
+    val: Int as uint32;
+
+    // initialize the state variable when contract is deployed
+    init() {
+        self.val = 0;
+    }
+
+    // handler for incoming increment messages that change the state
+    receive("increment") {
+        self.val = self.val + 1;
+    }
+
+    // read-only getter for querying the counter value
+    get fun value(): Int {
+        return self.val;
+    }
+}
+```
+
+# The Deployable Trait
+
+Tact doesn't support classical class inheritance, but contracts can implement
+traits. One of the commonly used traits is `Deployable`. It implements a simple
+receiver for the Deploy message which helps deploy contracts in a standard way.
+
+All contracts are deployed by sending them a message. This can be any message,
+but best practice is to designate the special `Deploy`
+message for this purpose.
+
+This message has a single field, `queryId`, which is provided by the deployer
+(normally zero). If the deploy succeeds, the contract will reply with the
+message `DeployOk` and echo the same `queryId` in the response.
+
+If you're using Tact's [auto-generated](https://docs.tact-lang.org/tools/typescript#tact-contract-in-typescript) TypeScript
+classes to deploy, sending the deploy message should look like:
+
+```c
+const msg = { $$type: "Deploy", queryId: 0n };
+ await contract.send(sender, { value: toNano(1) }, msg);
+```
+
+You can see the implementation of the trait [here](https://github.com/tact-lang/tact/blob/main/stdlib/libs/deploy.tact).
+Notice that the file deploy.tact needs to be imported from the standard
+library using the import keyword.
+
+```c
+// this trait has to be imported
+import "@stdlib/deploy";
+
+// the Deployable trait adds a default receiver for the "Deploy" message
+contract Counter with Deployable {
+
+    val: Int as uint32;
+
+    init() {
+        self.val = 0;
+    }
+
+    receive("increment") {
+        self.val = self.val + 1;
+    }
+
+    get fun value(): Int {
+        return self.val;
+    }
+}
+```
+
+# Integers
+
+Tact supports a number of primitive data types that are tailored for
+smart contract use.
+
+`Int` is the primary number type. Math in smart contracts is always done
+with integers and never with floating points since floats are [unpredictable](https://learn.microsoft.com/en-us/cpp/build/why-floating-point-numbers-may-lose-precision).
+
+The runtime type `Int` is always 257-bit signed, so all runtime calculations
+are done at 257-bit. This should be large enough for pretty much anything you
+need as it's large enough to hold the number of atoms in the universe.
+
+Persistent state variables can be initialized inline or inside `init()`.
+If you forget to initialize a state variable, the code will not compile.
+
+## State costs
+
+When encoding `Int` to persistent state, we will usually use smaller
+representations than 257-bit to reduce storage cost.
+The persistent state size is specified in every declaration of
+a state variable after the `as` keyword.
+
+Storing 1000 257-bit integers in state [costs](https://ton.org/docs/develop/smart-contracts/fees#how-to-calculate-fees) about
+0.184 TON per year. Storing 1000 32-bit integers only costs
+0.023 TON per year by comparison.
+
+```c
+import "@stdlib/deploy";
+
+contract Integers with Deployable {
+
+    // contract persistent state variables
+    // integers can be persisted in state in various sizes
+    // range -2^256 to 2^256 - 1 (takes 257 bit = 32 bytes + 1 bit)
+    i1: Int as int257 = 3001;
+    i2: Int as uint256;         // range 0 to 2^256 - 1 (takes 256 bit = 32 bytes)
+    // range -2^255 to 2^255 - 1 (takes 256 bit = 32 bytes)
+    i3: Int as int256 = 17;
+    i4: Int as uint128;         // range 0 to 2^128 - 1 (takes 128 bit = 16 bytes)
+    // range -2^127 to 2^127 - 1 (takes 128 bit = 16 bytes)
+    i5: Int as int128;
+    i6: Int as coins;           // range 0 to 2^120 - 1 (takes 120 bit = 15 bytes)
+    // range 0 to 18,446,744,073,709,551,615 (takes 64 bit = 8 bytes)
+    i7: Int as uint64 = 0x1c4a;
+    // range -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
+    // (takes 64 bit = 8 bytes)
+    i8: Int as int64 = -203;
+    i9: Int as uint32 = 0;      // range 0 to 4,294,967,295 (takes 32 bit = 4 bytes)
+    // range -2,147,483,648 to 2,147,483,647 (takes 32 bit = 4 bytes)
+    i10: Int as int32 = 0;
+    i11: Int as uint16 = 0;     // range 0 to 65,535 (takes 16 bit = 2 bytes)
+    i12: Int as int16 = 0;      // range -32,768 to 32,767 (takes 16 bit = 2 bytes)
+    i13: Int as uint8 = 0;      // range 0 to 255 (takes 8 bit = 1 byte)
+    i14: Int as int8 = 0;       // range -128 to 127 (takes 8 bit = 1 byte)
+
+    init() {
+        // we can define numbers in hex (base 16)
+        self.i2 = 0x83dfd552e6372;
+        self.i4 = 1507998500293440234999; // we can define numbers in decimal
+        self.i5 = pow(10, 9);   // this is 10^9 = 1,000,000,000
+        self.i6 = ton("1.23");  // easy to read coin balances
+        //  (coins type is nano-tons, like cents, just with 9 decimals)
+    }
+
+    receive("show all") {
+        dump(self.i1);
+        dump(self.i2);
+        dump(self.i3);
+        dump(self.i4);
+        dump(self.i5);
+        dump(self.i6);
+        dump(self.i7);
+        dump(self.i8);
+    }
+
+    get fun result(): Int {
+        return self.i1;
+    }
+}
+```
+
+## Bools, Addresses, Strings, Operators and Constants
+
+### Bool
+
+Bool can be used for boolean variables
+
+```js
+b1: Bool = true;
+b2: Bool = false;
+```
+
+### Address
+
+Address is another primitive data type. It represents standard addresses on
+the TON blockchain.
+TON is divided into multiple chains called workchains. One of the internal
+fields of the address is the workchain id:
+0 - The standard workchain, for regular users. Your contracts will be here.
+-1 - The masterchain, usually for validators.
+
+```js
+// bouncable (same foundation wallet)
+a1: Address = address("EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N");
+// non-bounceable (same foundation wallet)
+a2: Address = address("UQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqEBI");
+```
+
+### String
+
+Tact has basic support for strings. Strings support unicode and don't
+have any special escape characters like \n.
+Strings are immutable. Once a sequence of characters is created, this
+sequence cannot be modified.
+If you need to concatenate strings in run-time, you can use a StringBuilder.
+This object handles gas efficiently and supports append() of various types to
+the string.
+
+```js
+s1: String = "hello world";
+sb: StringBuilder = beginString();
+sb.append(self.s1);
+```
+
+### Integer Operations
+
+Addition, subtraction, multiplication, division, modulo,
+shift left and right, minimum and maximum numbers, absolute value
+
+```js
+i: Int = -12; // temporary variable, runtime Int type is always int257
+i = i1 * 3 + (i2 - i); // basic math expressions
+i = i1 % 10; // modulo (remainder after division), 3001 % 10 = 1
+i = i1 / 1000; // integer division (truncation toward zero), 3001 / 1000 = 3
+i = i1 >> 3; // shift right (multiply by 2^n)
+i = i1 << 2; // shift left (divide by 2^n)
+i = min(i2, 11); // minimum between two numbers
+i = max(i2, 66); // maximum between two numbers
+i = abs(-1 * i2); // absolute value
+```
+
+### Constants
+
+Unlike variables, constants cannot change. Their values are
+calculated in compile-time and cannot change during execution.
+
+```js
+const StateUnpaid: Int = 0;
+```
+
+## Getters, Receivers and Messages
+
+### Getters
+
+Getters are special contract functions that allow users to query
+information from the contract.
+Contract methods starting with the prefix get fun are all getters.
+Calling getters is free and does not cost gas.
+Getters are read-only, they cannot change the contract persistent state.
+A contract cannot execute a getter of another contract. Getters are only
+executable by end-users off-chain.
+
+```js
+count: Int as uint32 = 17;
+
+get fun counter(): Int {
+    return self.count;
+}
+```
+
+### Receivers
+
+Contract methods named receive() are the handlers that process
+each incoming message type.
+Tact will automatically route every incoming message to the correct receiver
+listening for it according to its type. A message is only handled by one receiver.
+
+Handler for "increment" textual message - this is a textual string message,
+these cannot carry input arguments
+
+```js
+receive("increment") {
+    self.val = self.val + 1;
+}
+```
+
+### Messages
+
+Messages are defined using the message keyword. They can carry input
+arguments. For integers, you must define the encoding size, just like in
+state variables.
+
+Handler for the "Add" message - this is a binary message that has an input
+argument (amount)
+
+```js
+receive(msg: Add) {
+    self.val = self.val + msg.amount;
+}
+```
+
+## Structs
+
+Structs allow you to combine multiple primitives together in a more semantic way.
+Structs can define complex data types that contain multiple fields of
+different types. They can also be nested.
+
+```js
+// Normal struct
+struct Point {
+    x: Int as int64;
+    y: Int as int64;
+}
+
+// Nested struct
+struct Params {
+    name: String = "Satoshi";   // default value
+    age: Int? = null;           // optional field
+    point: Point;               // nested structs
+}
+```
+
+## Message Sender and Throwing Errors
+
+### Message Sender
+
+Every incoming message is sent from some contract that has
+an address. You can query the address of the message sender by calling sender()
+
+```js
+deployer: Address = sender();
+```
+
+### Errors
+
+When an error is thrown, the transaction reverts. By writing a
+require() on a condition that isn't met
+
+```js
+require(self.val < 5, "Counter is too high");
+```
+
+## Messages Between Contracts, Sending and Receiving TON Coins
+
+### Messages Between Contracts
+
+Different contracts can only communicate with
+each other by sending each other messages.
+
+This example sends a message to the to address with value of 1 TON and body
+of a comment with a string "Hello, World!".
+SendIgnoreErrors means that even when error occurs during message sending
+next messages would be sent anyway.
+
+```js
+let to: Address = ...;
+let value: Int = ton("1");
+send(SendParameters{
+    to: to,                             // address of receiver
+    value: value,                       //  amount of TON you want to send
+    mode: SendIgnoreErrors,             // 8-bit flag configuring how to send message
+    bounce: true,                       // if set to true (default) then message
+                                        // will be bounced back to sender
+    body: "Hello, World!".asComment()   // message body as Cell
+});
+```
+
+### Receiving TONs
+
+You can query the contract balance with myBalance() - note
+that the value is in nano-tons (like cents, just with 9 decimals). The balance
+already contains the incoming message value.
+You can also get the incoming TON balance with context().value
+
+```js
+val: Int as int64 = myBalance()
+// or
+// print how much TON coin were sent with this message
+dump(context().value);
+```
+
+### Sending TONs
+
+We can send any amount of TON to any address just like we created
+a send call between different contracts
+
+Send mode SendRemainingValue will add to the outgoing value any excess left
+from the incoming message after all gas costs are deducted from it.
+
+```js
+amount: Int as coins = ton("1");
+send(SendParameters{
+    to: sender(),
+    bounce: true,
+    value: amount,
+    mode: SendRemainingValue + SendIgnoreErrors
+});
+```
+
+## If/Else statements and Loops
+
+### If
+
+Tact supports if statements in a similar syntax to most programming
+languages. Curly braces are required.
+We can have the else and else if similar to other programming languages.
+
+```js
+if (val > 1000) {
+  dump("larger than 1000");
+} else if (val > 500) {
+  dump("between 500 and 1000");
+} else {
+  dump("smaller than 500");
+}
+```
+
+### Loops
+
+Tact does not support traditional 'for' loops, 'break' and 'continue'
+statements in loops.
+The repeat loop statement input number must fit within an int32.
+
+```js
+// repeat exactly 10 times
+
+repeat (10) {
+    i = i + 1;
+    sum = sum + i;
+}
+
+// While loop
+
+let x: Int = 10;
+while(x > 0) {
+  x = x - 1;
+}
+
+// do-until loop
+
+let x: Int = 10;
+do {
+  x = x - 1;
+} until (x <= 0);
+```
+
+## Functions
+
+Functions in Tact start with the fun keyword. Functions can receive multiple
+input arguments and can optionally return a single output value. You can
+return a struct if you want to return multiple values.
+
+```js
+fun average(a: Int, b: Int): Int {
+    return (a + b) / 2;
+}
+```
+
+## Maps and Arrays
+
+### Maps
+
+Maps are a dictionary type that can hold an arbitrary number of items,
+each under a different key.
+The keys in maps can either be an Int type or an Address type.
+You can check if a key is found in the map by calling the get() method.
+Replace the value under a key by calling the set() method.
+
+```js
+mi1: map<Int, TokenInfo>;           // maps with Int as key
+ma1: map<Address, TokenInfo>;       // maps with Address as key
+```
+
+### Arrays
+
+To create an array, define a map with 'Int' type as key as well as value.
+
+```js
+arr: map<Int, Int>; // this is our array implemented with a map
+```
+
+## Ownable Standard Library
+
+The Ownable trait allows the contract to set an owner role, which can have
+higher priviliges from everybody else.
+For this you would need to import the "@stdlib/ownable" library and inherit
+it in your contract
+
+- Use the self.requireOwner() call to verify that the person making that
+  function call is the owner of contract
+- 'ChangeOwner{newOwner: Address}' message which allows the owner to
+  transfer ownership.
+- Define state variables named 'owner: Address' and 'stopped: Bool' and
+  call 'self.requireNotStopped()' on actions that should be stopped.
+- Define state variables named 'owner: Address' and "stopped: Bool' and
+  call 'self.requireNotStopped()' on actions that should be stopped.
+
+```js
+import "@stdlib/ownable";
+import "@stdlib/deploy";
+
+contract Counter with Deployable, Ownable {
+    owner: Address;
+
+    init() { // initialize a contract with default values like 'constructor'
+        self.owner = sender(); // we can initialize owner to any value we want, the deployer in this case
+        self.val = 0;
+    }
+
+    // this message in only available to the owner
+    receive("double") {
+        self.requireOwner();
+        self.val = self.val * 2;
+    }
+
+    // this message will only work until the contract was stopped
+    receive("increment") {
+        self.requireNotStopped();
+        self.val = self.val + 1;
+    }
+
+    // this message will only work as long as the contract is not stopped
+    receive("increment2") {
+        self.requireNotStopped();
+        self.val = self.val + 1;
+    }
+}
+
+```
+
+## Additional resources
+
+- [TON Documentation](https://ton.org/docs/#/)
+- [Tact Docs](https://docs.tact-lang.org/)
+- [Tact by Example](https://tact-by-example.org/)
+- [Community portal](https://society.ton.org)
+- [Blockchain portal](https://ton.org)
+- [Stackoverflow](https://stackoverflow.com/questions/tagged/ton)
+
+## Social
+
+- [Tact community](https://t.me/tactlang)
+- [Developer community](https://t.me/tondev_eng)
+- [TON Learn](https://t.me/ton_learn)
+- [Tondev News](https://t.me/tondevnews)
+- [TON Technical Updates](https://t.me/thetontech)
+
+## Useful blogposts
+
+- [Setting up a TON Development Environment](https://society.ton.org/setting-up-a-ton-development-environment)
+- [Hello World on TON](https://society.ton.org/ton-hello-world-step-by-step-guide-for-writing-your-first-smart-contract-in-func)
+
+## Future To Dos
+
+- Add smart contracts examples
+- Add more links to documentations
+
+This file is based on [Tact By Example](https://tact-by-example.org).
+
+P.S. If by any chance you're familiar with [Forth](https://learnxinyminutes.com/docs/forth/),
+you can also take a look at [Fift](https://ton-blockchain.github.io/docs/fiftbase.pdf).
diff --git a/tailspin.html.markdown b/tailspin.html.markdown
new file mode 100644
index 00000000..89ccdb1f
--- /dev/null
+++ b/tailspin.html.markdown
@@ -0,0 +1,383 @@
+---
+language: tailspin
+filename: learntailspin.tt
+contributors:
+    - ["Torbjörn Gannholm", "https://github.com/tobega/"]
+
+---
+
+**Tailspin** works with streams of values in pipelines. You may often feel
+that your program is the machine and that the input data is the program.
+
+While Tailspin is unlikely to become mainstream, or even production-ready,
+it will change the way you think about programming in a good way.
+
+```c
+// Comment to end of line
+
+// Process data in a pipeline with steps separated by ->
+// String literals are delimited by single quotes
+// A bang (!) indicates a sink, or end of the pipe
+// OUT is the standard output object, ::write is the message to write output
+'Hello, World!' -> !OUT::write
+
+// Output a newline by just entering it in the string (multiline strings)
+'
+' -> !OUT::write
+// Or output the decimal unicode value for newline (10) between $# and ;
+'$#10;' -> !OUT::write
+
+// Define an immutable named value. Value syntax is very literal.
+def names: ['Adam', 'George', 'Jenny', 'Lucy'];
+
+// Stream the list to process each name. Note the use of $ to get the value.
+// The current value in the pipeline is always just $
+// String interpolation starts with a $ and ends with ;
+$names... -> 'Hello $;!
+' -> !OUT::write
+
+// You can also stream in the interpolation and nest interpolations
+// Note the list indexing with parentheses and the slice extraction
+// Note the use of ~ to signify an exclusive bound to the range
+// Outputs 'Hello Adam, George, Jenny and Lucy!'
+'Hello $names(first);$names(first~..~last)... -> ', $;'; and $names(last);!
+' -> !OUT::write
+
+// Conditionally say different things to different people
+// Matchers (conditional expressions) are delimited by angle brackets
+// A set of matchers, evaluated top down, must be in templates (a function)
+// Here it is an inline templates delimited by \( to \)
+// Note the doubled '' and $$ to get a literal ' and $
+$names... -> \(
+  when <='Adam'> do 'What''s up $;?' !
+  when <='George'> do 'George, where are the $$10 you owe me?' !
+  otherwise 'Hello $;!' !
+\) -> '$;$#10;' -> !OUT::write
+
+// You can also define templates (functions)
+// A lone ! emits the value into the calling pipeline without returning control
+// The # sends the value to be matched by the matchers 
+// Note that templates always take one input value and emit 0 or more outputs
+templates collatz-sequence
+  when <..0> do 'The start seed must be a positive integer' !
+  when <=1> do $!
+// The ?( to ) allows matching a computed value. Can be concatenated as "and"
+  when <?($ mod 2 <=1>)> do
+    $ !
+    3 * $ + 1 -> #
+  otherwise
+    $ !
+    $ ~/ 2 -> #
+end collatz-sequence
+
+// Collatz sequence from random start on one line separated by spaces
+1000 -> SYS::randomInt -> $ + 1 -> collatz-sequence -> '$; ' -> !OUT::write
+'
+' -> !OUT::write
+
+// Collatz sequence formatted ten per line by an indexed list template
+// Note the square brackets creates a list of the enclosed pipeline results
+// The \[i]( to \) defines a templates to apply to each value of a list,
+// the i (or whatever identifier you choose) holds the index
+[1000 -> SYS::randomInt -> $ + 1 -> collatz-sequence]
+-> \[i](
+  when <=1|?($i mod 10 <=0>)> do '$;$#10;' !
+  otherwise '$; ' !
+\)... -> !OUT::write
+
+// A range can have an optional stride
+def odd-numbers: [1..100:2];
+
+// Use mutable state locally. One variable per templates, always called @
+templates product
+  @: $(first);
+  $(first~..last)... -> @: $@ * $;
+  $@ !
+end product
+
+$odd-numbers(6..8) -> product -> !OUT::write
+'
+' -> !OUT::write
+
+// Use processor objects to hold mutable state.
+// Note that the outer @ must be referred to by name in inner contexts
+// A sink templates gives no output and is called prefixed by !
+// A source templates takes no input and is called prefixed by $
+processor Product
+  @: 1;
+  sink accumulate
+    @Product: $@Product * $;
+  end accumulate
+  source result
+    $@Product !
+  end result
+end Product
+
+// The processor is a constructor templates. This one called with $ (no input)
+def multiplier: $Product;
+
+// Call object templates by sending messages with ::
+1..7 -> !multiplier::accumulate
+-1 -> !multiplier::accumulate
+$multiplier::result -> 'The product is $;
+' -> !OUT::write
+
+// Syntax sugar for a processor implementing the collector interface
+1..7 -> ..=Product -> 'The collected product is $;$#10;' -> !OUT::write
+
+// Symbol sets (essentially enums) can be defined for finite sets of values
+data colour #{green, red, blue, yellow}
+
+// Use processor typestates to model state cleanly.
+// The last named mutable state value set determines the typestate
+processor Lamp
+  def colours: $;
+  @Off: 0;
+  state Off
+    source switchOn
+      @On: $@Off mod $colours::length + 1;
+      'Shining a $colours($@On); light$#10;' !
+    end switchOn
+  end Off
+  state On
+    source turnOff
+      @Off: $@On;
+      'Lamp is off$#10;' !
+    end turnOff
+  end On
+end Lamp
+
+def myLamp: [colour#green, colour#blue] -> Lamp;
+
+$myLamp::switchOn -> !OUT::write // Shining a green light
+$myLamp::turnOff -> !OUT::write  // Lamp is off
+$myLamp::switchOn -> !OUT::write // Shining a blue light
+$myLamp::turnOff -> !OUT::write  // Lamp is off
+$myLamp::switchOn -> !OUT::write // Shining a green light
+
+// Use regular expressions to test strings
+['banana', 'apple', 'pear', 'cherry']... -> \(
+  when <'.*a.*'> do '$; contains an ''a''' !
+  otherwise '$; has no ''a''' !
+\) -> '$;
+' -> !OUT::write
+
+// Use composers with regular expressions and defined rules to parse strings
+composer parse-stock-line
+  {inventory-id: <INT> (<WS>), name: <'\w+'> (<WS>), currency: <'.{3}'>,
+    unit-price: <INT> (<WS>?) <parts>?}
+  rule parts: associated-parts: [<part>+]
+  rule part: <'[A-Z]\d+'> (<=','>?)
+end parse-stock-line
+
+'705 gizmo EUR5 A67,G456,B32' -> parse-stock-line -> !OUT::write
+// {associated-parts: [A67, G456, B32], currency: EUR,
+//     inventory-id: 705, name: gizmo, unit-price: 5}
+'
+' -> !OUT::write
+
+// Stream a string to split it into glyphs.
+// A list can be indexed/sliced by an array of indexes
+// Outputs ['h','e','l','l','o'], indexing arrays/lists starts at 1
+['abcdefghijklmnopqrstuvwxyz'...] -> $([8,5,12,12,15]) -> !OUT::write
+'
+' -> !OUT::write
+
+// We have used only raw strings above.
+// Strings can have different types as determined by a tag.
+// Comparing different types is an error, unless a wider type bound is set
+// Type bound is given in ´´ and '' means any string value, tagged or raw
+templates get-string-type
+  when <´''´ '.*'> do '$; is a raw string' !
+  when <´''´ id´'\d+'> do '$; is a numeric id string' !
+  when <´''´ =id´'foo'> do 'id foo found' !
+  when <´''´ id´'.*'> do '$; is an id' !
+  when <´''´ name´'.+'> do '$; is a name' !
+  otherwise '$; is not a name or id, nor a raw string' !
+end get-string-type
+
+[name´'Anna', 'foo', id´'789', city´'London', id´'xzgh', id´'foo']...
+-> get-string-type -> '$;
+' -> !OUT::write
+
+// Numbers can be raw, tagged or have a unit of measure
+// Type .. is any numeric value, tagged, measure or raw
+templates get-number-type
+  when <´..´ =inventory-id´86> do 'inventory-id 86 found' !
+  when <´..´ inventory-id´100..> do '$; is an inventory-id >= 100' !
+  when <´..´ inventory-id´0..|..inventory-id´0> do '$; is an inventory-id' !
+  when <´..´ 0"m"..> do '$; is an m-measure >= 0"m"' !
+  when <´..´ ..0|0..> do '$; is a raw number' !
+  otherwise '$; is not a positive m-measure nor an inventory-id, nor raw' !
+end get-number-type
+
+[inventory-id´86, inventory-id´6, 78"m", 5"s", 99, inventory-id´654]...
+-> get-number-type -> '$;
+' -> !OUT::write
+
+// Measures can be used in arithmetic, "1" is the scalar unit
+// When mixing measures you have to cast to the result measure
+4"m" + 6"m" * 3"1" -> ($ ~/ 2"s")"m/s" -> '$;
+' -> !OUT::write
+
+// Tagged identifiers must be made into raw numbers when used in arithmetic
+// Then you can cast the result back to a tagged identifier if you like
+inventory-id´300 -> inventory-id´($::raw + 1) -> get-number-type -> '$;
+' -> !OUT::write
+
+// Fields get auto-typed, tagging raw strings or numbers by default
+// You cannot assign the wrong type to a field
+def item: { inventory-id: 23, name: 'thingy', length: 12"m" };
+
+'Field inventory-id $item.inventory-id -> get-number-type;
+' -> !OUT::write
+'Field name $item.name -> get-string-type;
+' -> !OUT::write
+'Field length $item.length -> get-number-type;
+' -> !OUT::write
+
+// You can define types and use as type-tests. This also defines a field.
+// It would be an error to assign a non-standard plate to a standard-plate field
+data standard-plate <'[A-Z]{3}[0-9]{3}'>
+
+[['Audi', 'XYZ345'], ['BMW', 'I O U']]... -> \(
+  when <?($(2) <standard-plate>)> do {make: $(1), standard-plate: $(2)}!
+  otherwise {make: $(1), vanity-plate: $(2)}!
+\) -> '$;
+' -> !OUT::write
+
+// You can define union types
+data age <"years"|"months">
+
+[ {name: 'Cesar', age: 20"years"},
+  {name: 'Francesca', age: 19"years"},
+  {name: 'Bobby', age: 11"months"}]...
+-> \(
+// Conditional tests on structures look a lot like literals, with field tests
+  when <{age: <13"years"..19"years">}> do '$.name; is a teenager'!
+  when <{age: <"months">}> do '$.name; is a baby'!
+// You don't need to handle all cases, 'Cesar' will just be ignored
+\) -> '$;
+' -> !OUT::write
+
+// Array/list indexes start at 1 by default, but you can choose
+// Slices return whatever overlaps with the actual array
+[1..5] -> $(-2..2) -> '$;
+' -> !OUT::write // Outputs [1,2]
+0:[1..5] -> $(-2..2) -> '$;
+' -> !OUT::write // Outputs [1,2,3]
+-2:[1..5] -> $(-2..2) -> '$;
+' -> !OUT::write // Outputs [1,2,3,4,5]
+
+// Arrays can have indexes of measures or tagged identifiers
+def game-map: 0"y":[
+  1..5 -> 0"x":[
+    1..5 -> level´1:[
+      1..3 -> {
+        level: $,
+        terrain-id: 6 -> SYS::randomInt,
+        altitude: (10 -> SYS::randomInt)"m"
+      }
+    ]
+  ]
+];
+
+// Projections (indexing) can span several dimensions
+$game-map(3"y"; 1"x"..3"x"; level´1; altitude:) -> '$;
+' -> !OUT::write // Gives a list of three altitude values
+
+// Flatten and do a grouping projection to get stats
+// Count and Max are built-in collector processors
+[$game-map... ... ...] -> $(collect {
+      occurences: Count,
+      highest-on-level: Max&{by: :(altitude:), select: :(level:)}
+    } by $({terrain-id:}))
+-> !OUT::write
+'
+' -> !OUT::write
+
+// Relations are sets of structures/records.
+// Here we get all unique {level:, terrain-id:, altitude:} combinations
+def location-types: {|$game-map... ... ...|};
+
+// Projections can re-map structures. Note § is the relative accessor
+$location-types({terrain-id:, foo: §.level::raw * §.altitude})
+-> '$;
+' -> !OUT::write
+
+// Relational algebra operators can be used on relations
+($location-types join {| {altitude: 3"m"} |})
+-> !OUT::write
+'
+' -> !OUT::write
+
+// Define your own operators for binary operations
+operator (left dot right)
+  $left -> \[i]($ * $right($i)!\)... -> ..=Sum&{of: :()} !
+end dot
+
+([1,2,3] dot [2,5,8]) -> 'dot product: $;
+' -> !OUT::write
+
+// Supply parameters to vary templates behaviour
+templates die-rolls&{sides:}
+  1..$ -> $sides::raw -> SYS::randomInt -> $ + 1 !
+end die-rolls
+
+[5 -> die-rolls&{sides:4}] -> '$;
+' -> !OUT::write
+
+// Pass templates as parameters, maybe with some parameters pre-filled
+source damage-roll&{first:, second:, third:}
+  (1 -> first) + (1 -> second) + (1 -> third) !
+end damage-roll
+
+$damage-roll&{first: die-rolls&{sides:4},
+  second: die-rolls&{sides:6}, third: die-rolls&{sides:20}}
+-> 'Damage done is $;
+' -> !OUT::write
+
+// Write tests inline. Run by --test flag on command line
+// Note the ~ in the matcher means "not",
+// and the array content matcher matches elements < 1 and > 4
+test 'die-rolls'
+  assert [100 -> die-rolls&{sides: 4}] <~[<..~1|4~..>]> 'all rolls 1..4'
+end 'die-rolls'
+
+// Provide modified modules to tests (aka test doubles or mocks)
+// IN is the standard input object and ::lines gets all lines
+source read-numbers
+  $IN::lines -> #
+  when <'\d+'> do $!
+end read-numbers
+
+test 'read numbers from input'
+  use shadowed core-system/
+    processor MockIn
+      source lines
+        [
+          '12a',
+          '65',
+          'abc'
+        ]... !
+      end lines
+    end MockIn
+    def IN: $MockIn;
+  end core-system/
+  assert $read-numbers <=65> 'Only 65 is read'
+end 'read numbers from input'
+
+// You can work with byte arrays
+composer hexToBytes
+  <HEX>
+end hexToBytes
+
+'1a5c678d' -> hexToBytes -> ($ and [x 07 x]) -> $(last-1..last) -> '$;
+' -> !OUT::write // Outputs 0005
+
+```
+
+## Further Reading
+
+- [Main Tailspin site](https://github.com/tobega/tailspin-v0/)
+- [Tailspin language reference](https://github.com/tobega/tailspin-v0/blob/master/TailspinReference.md)
diff --git a/tcl.html.markdown b/tcl.html.markdown
index 1b577b49..51e8651c 100644
--- a/tcl.html.markdown
+++ b/tcl.html.markdown
@@ -308,7 +308,7 @@ set result [+ 5 3]
 set name Neo
 expr {{Bob} eq $name}
 
-# The general operators fall back to string string comparison if numeric
+# The general operators fall back to string comparison if numeric
 # operation isn't feasible:
 expr {{Bob} == $name}
 
diff --git a/tcsh.html.markdown b/tcsh.html.markdown
index e38b7a27..8f8429bc 100644
--- a/tcsh.html.markdown
+++ b/tcsh.html.markdown
@@ -28,23 +28,23 @@ Some more files:
 
 ```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.
+# The first line of the script is a shebang which tells the system how to execute
+# the script: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# TCSH emulates the shebang on systems that don't understand it.
 
-# In most cases you'll use `#!/bin/tcsh -f', because `-f' option does not load
+# 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
+# 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)
+# 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
@@ -65,17 +65,17 @@ 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
+# its special meaning by preceding it with a backslash `\`.
+# This will display the last history commands
 echo !!
-# this will not
+# 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
+# Single quotes prevent expanding special characters too, but some
+# characters like `!` and backslash have higher priority
+# `$` (variable value) will not expand
 echo '$1 tip'
-# `!' (history) will expands
+# `!` (history) will expand
 echo '!!'
 
 # Strings enclosed by back-quotes will be executed and replaced by the result.
@@ -85,16 +85,16 @@ echo `ls`
 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"
+echo "Always executed" || echo "Only executed if the first command fails"
+echo "Always executed" && echo "Only executed if the 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
+# example: creates 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
+# prints the home directory but leaves you where you were
 (cd; pwd); pwd
 
 # Read tcsh man-page documentation
@@ -103,10 +103,10 @@ 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.
+# 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
@@ -122,7 +122,7 @@ set var = `ls`
 
 # Remove a variable
 unset var
-# Prints 1 (true) if the variable `var' exists otherwise prints 0 (false)
+# Prints 1 (true) if the variable `var` exists otherwise prints 0 (false)
 echo $?var
 # Print all variables and their values
 set
@@ -130,10 +130,10 @@ set
 # Prints the contents of 'var'
 echo $var;
 echo "$var";
-# Prints the string `$var'
+# Prints the string `$var`
 echo \$var
 echo '$var'
-# braces can be used to separate variable from the rest when its needed
+# Braces can be used to separate variables from the rest when it is needed
 set num = 12; echo "There ${num}th element"
 
 # Prints the number of characters of the value: 6
@@ -147,7 +147,7 @@ echo $var
 echo $var[*]
 # Print the count of elements: 5
 echo $#var
-# Print indexed element; prints the second element: two
+# Print the indexed element; This prints the second element: two
 echo $var[2]
 # Print range of elements; prints 2nd up to 3rd: two, three
 echo $var[2-3]
@@ -165,8 +165,8 @@ echo $var[-3]
 # $!            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
+# $path, $PATH  the list of directories that will search for an 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
@@ -174,24 +174,24 @@ echo $var[-3]
 # $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
+# $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.
+#               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.
+# TIP: if `$?tcsh` is unset; you run the original `csh` or something else;
+#      try `echo $shell`
+# TIP: `$verbose` is useful for 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
+# h : the directory  t : the filename  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)
@@ -199,8 +199,8 @@ echo $var[-3]
 # 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
+# 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
@@ -232,7 +232,7 @@ echo 'this string' >> 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'
+# Input from keyboard; this stores the input line to variable `x`
 set x = $<
 # Document here;
 cat << LABEL
@@ -243,7 +243,7 @@ LABEL
 (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? "
+echo -n "Enter your name: "
 set name = $<
 echo "Greetings $name"
 
@@ -266,15 +266,15 @@ 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:
+# 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"
+echo "Always executed" || echo "Only executed if the first command fails"
+echo "Always executed" && echo "Only executed if the first command does NOT fail"
 
 # To use && and || with if statements, you don't need multiple pairs of
 # square brackets:
@@ -286,14 +286,14 @@ if ( "$name" == "Daniya" || "$name" == "Zach" ) then
     echo "This will run if $name is Daniya OR Zach."
 endif
 
-# String matching operators ( `=~' and `!~' )
+# 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.
+# 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."
+if ( $user !~ ni[ck]* ) echo "Hey, get out of Nicholas' PC."
 
 # Arithmetic expressions are denoted with the following format:
 @ result = 10 + 5
@@ -302,16 +302,16 @@ echo $result
 # Arithmetic Operators
 # +, -, *, /, %
 #
-# Arithmetic Operators which must be parenthesised
+# Arithmetic Operators which must be parenthesized
 # !, ~, |, &, ^, ~, <<, >>,
 # Compare and logical operators
 #
-# All operators are same as in C.
+# All operators are the 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.
+# in-between; Also, `@` has its own parser, it seems that it works well when
+# the expression is parenthesized, otherwise the primary parser seems to be
+# active. Parentheses require spaces around, this is documented.
 
 # wrong
 @ x = $y+1
@@ -330,32 +330,32 @@ echo $result
 # C's operators ++ and -- are supported if there is not assignment
 @ result ++
 
-# None shell created to do mathematics;
+# No shell was 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
+# The standard Unix's bc as the second option
 # (https://www.gnu.org/software/bc/manual/html_mono/bc.html)
 #
-# The standard Unix's AWK as third option
+# The standard Unix's AWK as the 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.
+# You can also use `Perl`, `PHP`, `python`, 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)
+# in `tcsh` expression (by using octal)
 @ x = ( 011 | 06 ); echo $x
 
-# the same by using `calc' (and using binary as the original req)
+# 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.
+# NOTE: The built-in `filetest` command does the same thing.
 
 #### Boolean operators
 # -r  read access    -w  write access    -x  execute access    -e  existence
@@ -366,23 +366,23 @@ set x = `calc '0b1001 | 0b110'`; echo $x
 # -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 the file `README` exists, display a message
 if ( -e README ) echo "I have already README file"
 
-# if the `less' program is installed, use this instead of `more'
+# If the `less` program is installed, use it instead of `more`
 if ( -e `where less` ) then
-	alias more 'less'
+    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
+# -A  returns the last access time (atime)     -A: returns atime string
+# -U  returns the owner's user ID              -U: returns the owner's user name
+# -G  returns the owner's group ID             -G: returns the owner's group name
 # -P  returns the permissions as octal number  -Pmode returns perm. AND mode
 
-# this will display the date as Unix-time integer: 1498511486
+# this will display the date as a Unix-time integer: 1498511486
 filetest -M README.md
 
 # This will display "Tue Jun 27 00:11:26 2017"
@@ -390,14 +390,14 @@ filetest -M: README.md
 
 # --- Basic Commands ----------------------------------------------------------
 
-# Navigate though file system with `chdir' (cd)
+# Navigate through the filesystem with `chdir` (cd)
 cd path # change working directory
-cd      # change to home directory
-cd -    # change to previous directory
+cd      # change to the home directory
+cd -    # change to the previous directory
 cd ..   # go up one directory
 
 # Examples:
-cd ~/Downloads # go to my `Downloads' directory
+cd ~/Downloads # go to my `Downloads` directory
 
 # Use `mkdir` to create new directories.
 mkdir newdir
@@ -413,7 +413,7 @@ 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
+# (stdin) to the next one. These `pipes` are created with the `|` special
 # character and it is one of the most powerful characteristics of Unix.
 
 # example:
@@ -422,18 +422,18 @@ ls -l | grep key | less
 # 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.
+# the `ls`, the `grep`, and the `less` are Unix programs and they have their
+# own man-page. The `pipe` mechanism is part of the kernel but the syntax
+# and the control is the shell's job, 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
+# NOTE: Windows has the `pipe` mechanism too, but it is buggy and I signed it
+# for all versions until Windows XP SP3 API32 which was the last one that I
+# worked on. Microsoft denied it, but it is a 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
+# 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
@@ -451,10 +451,10 @@ set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz");
 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.
+# NOTE: `okular` is the default application of the 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 Unixes. The `ps2pdf`
+# program is part of the `ghostscript` package that is widely used.
 
 # --- Control Flow ------------------------------------------------------------
 
@@ -468,8 +468,8 @@ set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz");
 #    ...]
 # 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
+# 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.
 #
@@ -477,24 +477,24 @@ set page = tcsh; set loc = (locate -b -n 1 "\\\\"${page}".1.gz");
 #
 # 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.
+# If `expr` evaluates to true, then the command is executed.
+# `command` must be a simple command, not an alias, a pipeline, a command list
+#, or a parenthesized command list. With a few words, avoid using it.
 #
-# BUG: Input/output redirection occurs even if expr is false and command is
-# thus not executed.
+# BUG: Input/output redirection occurs even if expr is false and the command
+# is thus not executed.
 #
 
-# check if we are in non-interactive shell and quit if true
+# check if we are in a 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
+    # 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
@@ -509,37 +509,37 @@ endif
 #
 # 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
+# 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 it's 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
+    echo "$var is a man-page."
+    breaksw
 case *gz:
-	echo "$var is gzipped"
-	breaksw
+    echo "$var is gzipped"
+    breaksw
 default:
-	file $var
+    file $var
 endsw
 
 #### FOREACH-END
 # Syntax:
 # foreach name ( wordlist )
-#	...
+#    ...
 #   [break | continue]
 # end
 #
-# Successively sets the variable `name' to each member of `wordlist' and
+# 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.
+# `end` keyword. The `continue` keyword jumps 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.
+# BUG: `foreach` doesn't ignore here documents when looking for its end.
 
 # example: counting 1 to 10
 foreach i ( `seq 1 10` )
@@ -548,12 +548,12 @@ end
 
 # example: type all files in the list
 foreach f ( a.txt b.txt c.txt )
-	cat $f
+    cat $f
 end
 
 # example: convert wma to ogg
 foreach f ( *.wma )
-	ffmpeg -i "$f" "$f:r".ogg
+    ffmpeg -i "$f" "$f:r".ogg
 end
 
 #### WHILE-END
@@ -562,22 +562,22 @@ end
 #     [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
+# 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 ++
+    echo $num
+    @ num ++
 end
 
 # print all directories of CWD
 set lst = ( * )
 while ( $#lst )
-	if ( -d $lst[1] ) echo $lst[1] is directory
-	shift lst
+    if ( -d $lst[1] ) echo $lst[1] is directory
+    shift lst
 end
 
 # separate command-line arguments to options or parameters
@@ -585,12 +585,12 @@ 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
+    if ( "$lst[1]" =~ '-*' ) then
+        set options = ( $options $lst[1] )
+    else
+        set params = ( $params $lst[1] )
+    endif
+    shift lst
 end
 echo 'options =' $options
 echo 'parameters =' $params
@@ -599,16 +599,16 @@ echo 'parameters =' $params
 # 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.
+# 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'
+# 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` 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.
@@ -637,48 +637,48 @@ alias cd 'cd \!* && ls'
 #!/bin/tcsh -f
 set todo = option1
 if ( $#argv > 0 ) then
-	set todo = $argv[1]
+    set todo = $argv[1]
 endif
 
 switch ( $todo )
 case option1:
-#	...
-	$0 results
-	breaksw
+#    ...
+    $0 results
+    breaksw
 case option2:
-#	...
-	$0 results
-	breaksw
+#    ...
+    $0 results
+    breaksw
 case results:
-	echo "print the results here"
-#	...
-	breaksw
+    echo "print the results here"
+#    ...
+    breaksw
 default:
-	echo "Unknown option: $todo"
-#	exit 0
+    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]
+# otherwise it sets 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]
+    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
+    if ( $todo == $o ) then
+        # found; execute it
+        echo -n $todo > /sys/power/state
+        break
+    endif
 end
 # print help and exit
 echo "usage: $0 [option]"
@@ -691,19 +691,19 @@ echo "available options on kernel: $opts"
 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
+    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 ---------------------------------------------------
 
@@ -711,36 +711,36 @@ 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!
+# * CSH is notorious for its bugs;
+# * It is also famous for its advanced interactive mode.
+# * TCSH is famous for having the most advanced completion subsystem.
+# * TCSH is famous for having the most advanced aliases subsystem; aliases
+#   can take parameters and often be used as functions!
+# * TCSH is well known and preferred by people (me too) because of better
+#   syntax. All shells are using Thomson's syntax with the exception of
+#   [t]csh, fish, and plan9's shells (rc, ex).
+# * It is smaller and consumes far less memory than bash, zsh, and 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).
+# * TCSH still has bugs; fewer, but it does; if you write readable clean code
+#   you'll find none; well almost none... This has to do with the implementation
+#   of csh; that doesn't mean the other shells have a good implementation.
+# * no well-known shell is capable of regular programming; if your script
+#   is getting big, use a programming language, like Python, PHP, or Perl (good
+#   scripting 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
+# Advice:
+# 1. Do not use redirection in single-line IFs (it is well documented bug)
+#    In most cases avoid using 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
+#    A bug of csh was `set x=1` and `set x = 1` worked, but `set x =1` did not!
+# 4. It is well documented that numeric expressions require spaces in between;
+#    also parenthesize 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.
+# 7. Read the man page, `tcsh` has a huge number of options and variables.
 #
 #    I suggest the following options enabled by default
 #    --------------------------------------------------
@@ -770,14 +770,14 @@ end
 #    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: If the `backslash_quote` is set, it may create compatibility issues
+# with other tcsh scripts that were written without it.
 #
-# NOTE: The same for `parseoctal', but it is better to fix the problematic
+# 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)
+# This enables automatic rescanning of `path` directories if needed. (like bash)
 #    set autorehash
 
 #### common aliases
diff --git a/texinfo.html.markdown b/texinfo.html.markdown
new file mode 100644
index 00000000..1b3ed9e2
--- /dev/null
+++ b/texinfo.html.markdown
@@ -0,0 +1,183 @@
+---
+language: Texinfo
+contributors:
+    - ["Julien Lepiller", "https://github.com/roptat"]
+filename: learntexinfo.texi
+---
+
+Texinfo is a documentation format you can use to create various types of
+documents from the same source.  Its main usage is to create documentation
+manuals and info pages for GNU projects.
+
+Texinfo is a markup language that contains text and *@-commands* that specify
+what the generator should do.
+
+## Initial File
+
+A simple example of a simple manual:
+
+```
+\input texinfo
+@setfilename simple-document.info
+@documentencoding UTF-8
+@settitle simple-document
+@c This is a comment
+@c Replace simple-document above (twice) with the actual document title
+
+@c Automake will take care of version.texi
+@include version.texi
+
+@copying
+Copyright @copyright{} YEAR MY NAME
+
+@c GFDL is common for GNU projects
+@quotation
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.3 or
+any later version published by the Free Software Foundation; with no
+Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A
+copy of the license is included in the section entitled ``GNU Free
+Documentation License''.
+@end quotation
+@end copying
+
+@titlepage
+@end titlepage
+
+@c Now starts the actual content
+@contents
+
+@c The first node must always be Top
+@node Top
+@c And we give it a title
+@top simple-document
+
+This document quickly describes Texinfo features.
+
+@c This is the ToC:
+@menu
+* Introduction::           A short summary of the chapter
+
+@detailmenu
+--- The Detailed Node Listing ---
+
+Introduction
+
+* Formatting::             How to format text nicely
+* Links::                  Linking to other resources, pages, or manuals
+
+@end detailmenu
+@end menu
+
+@node Introduction
+@chapter Introduction
+
+Each node must have the same name as the menu item that was defined in the ToC.
+
+@node Formatting
+@section Formatting
+@c Add something to the content index, so people can get here when searching
+@c for something else
+@cindex bold text
+@cindex titles
+
+Similar to chapters, sections must have the same name and appear in the same order.
+
+@subsection This is a subsection title
+@subsubsection This is a sub-subsection title
+
+Each block of text is a paragraph. You can use multiple lines for the paragraph
+like so, only empty lines separate paragraphs.
+
+Common formatting include @emph{emphasis}, @code{inline code}. Specific type of
+text can be marked as well: @file{file.txt}, @option{--learn-fast},
+@command{ls} or @var{variable}. You can escape the command character like
+so: @@, and a newline with a single @@ at the end of the line.
+
+You can add different types of blocks:
+
+@example
+Here is an example
+@end example
+
+@lisp
+'(this is lisp code)
+@end lisp
+
+@itemize
+@item An element in an unordered list
+@item A second element in the same list
+@end itemize
+
+@enumerate
+@item This list is similar
+@item But ordered
+@end enumerate
+
+@quotation
+A quotation block, by someone famous maybe
+@end quotation
+
+@table @asis
+@item element title
+element description
+
+@item second element title
+second element description. Note that the description part can span multiple
+paragraphs, contain other blocks etc. This is usually used as a definition
+list.
+
+@code{@@asis} wraps the element title, and tells Texinfo to use them as-is.
+@end table
+
+@table @code
+@item do-x
+This item title is now wrapped in a code block, as in @code{@@code{do-x}}
+@end table
+
+@c content index can appear at any place in the document, not necessarily after
+@c titles.
+@cindex function definition
+@deffn {Kind of Function} function_name @var{arg1} @var{arg2} @
+  @var{arg3} @var{arg4} [@var{optional5}]
+This text describes the function. Note how we could use multiple lines for the
+function synopsis by escaping the line with a single @@.
+
+This again can contain multiple paragraphs or blocks.
+@end deffn
+
+@node Links
+@section Links
+
+There are various types of links you can use. A simple link to a URL with
+@uref{https://github.com} and optionally with it a title:
+@uref{https://github.com, GitHub}. An email address @email{me@@me.me}.
+A node in this document, @xref{Introduction}. Always use the exact node name
+for that one. @code{xref} will include the text ``see'' before the link. To
+insert something different, use @pxref{Introduction} (``See'') or
+@xref{Introduction} (nothing is inserted). With an additional argument, you
+can change the text of the link, @xref{Introduction, this introduction}.
+
+It is possible to link to external manuals with these commands by adding
+more arguments, as in @code{@@xref{Node name,,, manual-name, link text}},
+@xref{Overview,,, texinfo, Texinfo's manual} for the complete reference
+on Texinfo!
+
+@bye
+```
+
+## How to Use It
+
+With `automake`, all you need to do is to give it the path to your manual
+in `Makefile.am`:
+
+```
+info_TEXINFOS= doc/simple-manual.texi
+```
+
+Then, get your info manual with `make doc/simple-manual.info` or in other formats,
+e.g. HTML with `make doc/simple-manual.html`.
+
+## Readings
+
+- [Official manual](https://www.gnu.org/software/texinfo/manual/texinfo/html_node/)
diff --git a/textile.html.markdown b/textile.html.markdown
index 2b81674a..293e647d 100644
--- a/textile.html.markdown
+++ b/textile.html.markdown
@@ -165,11 +165,11 @@ but again, they use different HTML markup and thus the distinction.
 
 ###. Superscripts and Subscripts use carats and tildes:
 
-Superscripts are 2 ^nd^ to none, but subscripts are CO ~2~ L too.
+Superscripts are 2 ^and^ to none, but subscripts are CO ~2~ L too.
 Note the spaces around the superscripts and subscripts.
 
 To avoid the spaces, add square brackets around them:
-2[^nd^] and CO[~2~]L
+2[^and^] and CO[~2~]L
 
 ###. Insertions and deletions are indicated using -/+ symbols:
 This is -deleted- text and this is +inserted+ text.
@@ -375,7 +375,7 @@ table(tableclass).
 |a|classy|table|
 |a|classy|table|
 
-###. Spanning rows and colums:
+###. Spanning rows and columns:
 A backslash \ is used for a column span:
 
 |\2. spans two cols |
diff --git a/tmux.html.markdown b/tmux.html.markdown
index 1c2c2da3..095e24fb 100644
--- a/tmux.html.markdown
+++ b/tmux.html.markdown
@@ -183,7 +183,7 @@ bind a send-prefix
 ### Theme
 ###########################################################################
 
-# Statusbar Color Palatte
+# Statusbar Color Palette
 set-option -g status-justify left
 set-option -g status-bg black
 set-option -g status-fg white
diff --git a/toml.html.markdown b/toml.html.markdown
index 2b234965..69dfd754 100755..100644
--- a/toml.html.markdown
+++ b/toml.html.markdown
@@ -69,11 +69,15 @@ The first newline is trimmed in raw strings.
 ###########
 
 ## Integers can start with a +, a - or nothing.
-## Leading zeros are not allowed. Hex, octal, and binary forms are not allowed.
+## Leading zeros are not allowed.
+## Hex, octal, and binary forms are allowed.
 ## Values that cannot be expressed as a series of digits are not allowed.
 int1 = +42
 int2 = 0
 int3 = -21
+int4 = 0xdeadbeef
+int5 = 0o755
+int6 = 0b11011100
 integerRange = 64
 
 ## You can use underscores to enhance readability. Each
@@ -225,6 +229,7 @@ sku = 284758393
 color = "gray"
 ```
 The equivalent in JSON would be:
+
 ```json
 { 
   "products": [
@@ -270,8 +275,10 @@ The equivalent in JSON would be:
     note = "I am an array item in banana fruit's table/map"
 
 ```
+
 The equivalent in JSON would be:
-```json
+
+```
 
 {
   "fruit": [
diff --git a/tr-tr/bf-tr.html.markdown b/tr-tr/bf-tr.html.markdown
index e7015cd0..ef46f362 100644
--- a/tr-tr/bf-tr.html.markdown
+++ b/tr-tr/bf-tr.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: bf
-filename: brainfuck-tr
+filename: brainfuck-tr.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io"]
 translators:
diff --git a/tr-tr/c++-tr.html.markdown b/tr-tr/c++-tr.html.markdown
index 9d65cf9c..c944f245 100644
--- a/tr-tr/c++-tr.html.markdown
+++ b/tr-tr/c++-tr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 lang: tr-tr
 filename: learncpp-tr.cpp
 contributors:
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 4ef12527..05531d64 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -1,7 +1,7 @@
 ---
-name: c
+name: C
 category: language
-language: c
+language: C
 filename: learnc-tr.c
 contributors:
     - ["Adam Bard", "http://adambard.com/"]
diff --git a/tr-tr/clojure-tr.html.markdown b/tr-tr/clojure-tr.html.markdown
index 5ebe5ce6..d21947ee 100644
--- a/tr-tr/clojure-tr.html.markdown
+++ b/tr-tr/clojure-tr.html.markdown
@@ -482,7 +482,7 @@ Clojuredocs.org, örneklerle bezenmiş Clojure dökümantasyonu:
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
 4Clojure, interaktif bir ÅŸekilde FP ve Clojure yeteneklerinizi geliÅŸtirmenize olanak veriyor:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org, Başlangıç için bir içeriklere sahip:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 91c7c269..9834be20 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c#
+language: C#
 contributors:
     - ["Irfan Charania", "https://github.com/irfancharania"]
     - ["Max Yankov", "https://github.com/golergka"]
diff --git a/tr-tr/git-tr.html.markdown b/tr-tr/git-tr.html.markdown
index 87c1820c..ad2f2e95 100644
--- a/tr-tr/git-tr.html.markdown
+++ b/tr-tr/git-tr.html.markdown
@@ -587,10 +587,8 @@ $ git rm /pather/to/the/file/HelloWorld.c
 
 * [SalesForce Kopya Kağıdı](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf)
 
-* [GitGuys](http://www.gitguys.com/)
-
 * [Git - Basit bir kılavuz](http://rogerdudler.github.io/git-guide/index.html)
 
 * [Pro Git](http://www.git-scm.com/book/en/v2)
 
-* [Yeni başlayanlar için Git ve Github](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
+* [Yeni başlayanlar için Git ve GitHub](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/tr-tr/sql-tr.html.markdown b/tr-tr/sql-tr.html.markdown
index 54007d32..2e91e9f8 100644
--- a/tr-tr/sql-tr.html.markdown
+++ b/tr-tr/sql-tr.html.markdown
@@ -1,125 +1,125 @@
----

-language: SQL

-contributors:

-  - ["Metin Yalçınkaya", "https://github.com/mtnylnky"]

-lang: tr-tr

-filename: learnsql-tr.sql

----

-

-

-```sql

--- Yorumlar iki tire ile baÅŸlar

-

--- KISITLAR

-Not null -- Bir kolon asla boÅŸ olamaz

-default -- Boş olan yerlere varsayılan bir değer atar

-unique -- Bir kolondaki tüm değerlerin farklı olması kısıtlaması

-primary key -- Bir tablodaki her veri için kimlik bilgisi niteliğindedir

-check -- Bir kolondaki değerlerin belli bir kısıtlamayı sağlamasını sağlar

-

--- Tablo oluÅŸturulur

-CREATE TABLE tablo1 ();

-

--- Tabloyu içerisinde kolonlar ile oluşturma

-CREATE TABLE tablo1(id INTEGER PRIMARY KEY NOT NULL UNIQUE, ad TEXT, soyad TEXT, yas INTEGER);

-

--- TABLO varlığını kontrol eder

-.table

-

--- Veri tabanında olan bütün tabloları görüntüler.

-.schema

-

--- Satır ekle

-INSERT INTO tablo1 ( ad, soyad) VALUES ("Deger1","Deger2");

-

--- Veritabanında tablo üzerindeki verileri görüntüle 

--- Sadece 'ad' gibi sınırlı bir veri için

-SELECT ad FROM tablo1;

--- Bütün veriler için

-SELECT * FROM tablo1;

-

--- Veri güncelleme

-UPDATE tablo1 SET ad = "deger1-2"; WHERE name = "Deger1";

-

--- Satır sil

-DELETE FROM tablo1 WHERE id = 1;

-DELETE FROM tablo1 WHERE ad = "Deger1" OR ad = "Deger2";

-

--- Tabloya sonradan kolon ekleme

-ALTER TABLE tablo1 ADD COLUMN email TEXT;

-

--- Tablodaki kolon adı değiştirme

-EXEC sp_rename ' tablo1.[ad]', Ad, 'COLUMN';

-

--- Tablo adı değiştirme

-ALTER TABLE table1 RENAME TO Table1;

-

--- Tabloyu silme

-DROP TABLE Table1;

-

--- BÄ°R TABLOYU BAÅžKA TABLO KULLANARAK DOLDURMAK

-INSERT INTO Tablo2 SELECT id,ad, soyad, email from Tablo1;

-

--- LIKE KOMUTU

--- Belirli bir kritere göre arama yaparken kullanılır

--- Adı 'A' ile başlayan veriler

-SELECT * FROM tablo1 WHERE adi LIKE "A%";

--- İçinde 'A' olan veriler

-SELECT * FROM tablo1 WHERE adi LIKE "%A%";

-

--- LIMIT KOMUTU

--- Gösterilen satır sayısını sınırlamak için

-SELECT * FROM Tablo1 LIMIT 6;

--- Gösterilen satırları belirli bir noktadan başlamak üzere sınırlamak için

-SELECT * FROM Tablo1 LIMIT 6 OFFSET 3;

-

--- ORDER BY KOMUTU

--- Herhangi bir kolona göre gösterilen değerleri azalan veya artan şekilde sıralamak için

-SELECT kolon FROM tablo1 WHERE yas ORDER BY column1, column2, .. columnN] [ASC | DESC];

-SELECT * FROM Tablo1 ORDER BY yas ASC

-SELECT * FROM Tablo1 ORDER BY yas DESC

-

--- DISTINCT ANAHTAR SÖZCÜĞÜ

--- Bu anahtar sözcükle sadece farklı değerler gösterilir.

-SELECT DISTINCT yas FROM tablo1;

-

--- JOIN KOMUTU

--- CROSS JOIN

--- Cross join bir tablodaki her satırı ikinci tablodaki bir satır ile eşleştirmek için kulanılır.

--- Eğer birinci tabloda x satır ikinci tabloda y satır varsa sonuçta x*y satır olur.

-SELECT ... FROM table1 CROSS JOIN table2 …

-SELECT ad, yas FROM Tablo1 CROSS JOIN Tablo2;

-

--- INNER JOIN

--- Inner join iki tablodaki ortak kolon değerlerini kullanarak bir sonuç üretir.

-SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression …

-SELECT ad, yas FROM Tablo1 INNER JOIN Tablo2 ON Tablo1.ad = Tablo2.soyad;

-

--- OUTER JOIN

--- Outer join iki tablodaki ortak kolon değerlerinin dışında kalanları kullanarak bir sonuç üretir.

-SELECT isci_num, isim, dept FROM Tablo1 LEFT OUTER JOIN Tablo2 ON Tablo1.id = Tablo2.isci_num;

-

--- ÇEKİRDEK FONKSİYONLAR

-COUNT -- Sayma

-AVG -- Ortalama

-ABS -- Mutlak deÄŸer

-SUM -- Toplam

-RANDOM -- Rastgele

-ROUND -- Yuvarlama

-MAX -- Maksimim

-MIN -- Minimum

-UPPER -- Büyük Harf

-LOWER -- Küçük Harf

-LENGTH -- Uzunluk

-CURRENT_TIMESTAMP -- Zaman

-

-SELECT max(yas) FROM Table1;

-SELECT min(yas) FROM Table1;

-SELECT avg(yas) FROM Table1;

-SELECT * From Table1 WHERE yas ==18;

-SELECT sum(yas) FROM Table1;

-SELECT random() AS Random;

-SELECT upper(ad) FROM Table1;

-SELECT lower(ad) FROM Table1;

-SELECT ad, length(ad) FROM Table1;

+---
+language: SQL
+contributors:
+  - ["Metin Yalçınkaya", "https://github.com/mtnylnky"]
+lang: tr-tr
+filename: learnsql-tr.sql
+---
+
+
+```sql
+-- Yorumlar iki tire ile baÅŸlar
+
+-- KISITLAR
+Not null -- Bir kolon asla boÅŸ olamaz
+default -- Boş olan yerlere varsayılan bir değer atar
+unique -- Bir kolondaki tüm değerlerin farklı olması kısıtlaması
+primary key -- Bir tablodaki her veri için kimlik bilgisi niteliğindedir
+check -- Bir kolondaki değerlerin belli bir kısıtlamayı sağlamasını sağlar
+
+-- Tablo oluÅŸturulur
+CREATE TABLE tablo1 ();
+
+-- Tabloyu içerisinde kolonlar ile oluşturma
+CREATE TABLE tablo1(id INTEGER PRIMARY KEY NOT NULL UNIQUE, ad TEXT, soyad TEXT, yas INTEGER);
+
+-- TABLO varlığını kontrol eder
+.table
+
+-- Veri tabanında olan bütün tabloları görüntüler.
+.schema
+
+-- Satır ekle
+INSERT INTO tablo1 ( ad, soyad) VALUES ("Deger1","Deger2");
+
+-- Veritabanında tablo üzerindeki verileri görüntüle 
+-- Sadece 'ad' gibi sınırlı bir veri için
+SELECT ad FROM tablo1;
+-- Bütün veriler için
+SELECT * FROM tablo1;
+
+-- Veri güncelleme
+UPDATE tablo1 SET ad = "deger1-2"; WHERE name = "Deger1";
+
+-- Satır sil
+DELETE FROM tablo1 WHERE id = 1;
+DELETE FROM tablo1 WHERE ad = "Deger1" OR ad = "Deger2";
+
+-- Tabloya sonradan kolon ekleme
+ALTER TABLE tablo1 ADD COLUMN email TEXT;
+
+-- Tablodaki kolon adı değiştirme
+EXEC sp_rename ' tablo1.[ad]', Ad, 'COLUMN';
+
+-- Tablo adı değiştirme
+ALTER TABLE table1 RENAME TO Table1;
+
+-- Tabloyu silme
+DROP TABLE Table1;
+
+-- BÄ°R TABLOYU BAÅžKA TABLO KULLANARAK DOLDURMAK
+INSERT INTO Tablo2 SELECT id,ad, soyad, email from Tablo1;
+
+-- LIKE KOMUTU
+-- Belirli bir kritere göre arama yaparken kullanılır
+-- Adı 'A' ile başlayan veriler
+SELECT * FROM tablo1 WHERE adi LIKE "A%";
+-- İçinde 'A' olan veriler
+SELECT * FROM tablo1 WHERE adi LIKE "%A%";
+
+-- LIMIT KOMUTU
+-- Gösterilen satır sayısını sınırlamak için
+SELECT * FROM Tablo1 LIMIT 6;
+-- Gösterilen satırları belirli bir noktadan başlamak üzere sınırlamak için
+SELECT * FROM Tablo1 LIMIT 6 OFFSET 3;
+
+-- ORDER BY KOMUTU
+-- Herhangi bir kolona göre gösterilen değerleri azalan veya artan şekilde sıralamak için
+SELECT kolon FROM tablo1 WHERE yas ORDER BY column1, column2, .. columnN] [ASC | DESC];
+SELECT * FROM Tablo1 ORDER BY yas ASC
+SELECT * FROM Tablo1 ORDER BY yas DESC
+
+-- DISTINCT ANAHTAR SÖZCÜĞÜ
+-- Bu anahtar sözcükle sadece farklı değerler gösterilir.
+SELECT DISTINCT yas FROM tablo1;
+
+-- JOIN KOMUTU
+-- CROSS JOIN
+-- Cross join bir tablodaki her satırı ikinci tablodaki bir satır ile eşleştirmek için kulanılır.
+-- Eğer birinci tabloda x satır ikinci tabloda y satır varsa sonuçta x*y satır olur.
+SELECT ... FROM table1 CROSS JOIN table2 …
+SELECT ad, yas FROM Tablo1 CROSS JOIN Tablo2;
+
+-- INNER JOIN
+-- Inner join iki tablodaki ortak kolon değerlerini kullanarak bir sonuç üretir.
+SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression …
+SELECT ad, yas FROM Tablo1 INNER JOIN Tablo2 ON Tablo1.ad = Tablo2.soyad;
+
+-- OUTER JOIN
+-- Outer join iki tablodaki ortak kolon değerlerinin dışında kalanları kullanarak bir sonuç üretir.
+SELECT isci_num, isim, dept FROM Tablo1 LEFT OUTER JOIN Tablo2 ON Tablo1.id = Tablo2.isci_num;
+
+-- ÇEKİRDEK FONKSİYONLAR
+COUNT -- Sayma
+AVG -- Ortalama
+ABS -- Mutlak deÄŸer
+SUM -- Toplam
+RANDOM -- Rastgele
+ROUND -- Yuvarlama
+MAX -- Maksimim
+MIN -- Minimum
+UPPER -- Büyük Harf
+LOWER -- Küçük Harf
+LENGTH -- Uzunluk
+CURRENT_TIMESTAMP -- Zaman
+
+SELECT max(yas) FROM Table1;
+SELECT min(yas) FROM Table1;
+SELECT avg(yas) FROM Table1;
+SELECT * From Table1 WHERE yas ==18;
+SELECT sum(yas) FROM Table1;
+SELECT random() AS Random;
+SELECT upper(ad) FROM Table1;
+SELECT lower(ad) FROM Table1;
+SELECT ad, length(ad) FROM Table1;
 ```
\ No newline at end of file
diff --git a/typescript.html.markdown b/typescript.html.markdown
index f7a41ce1..64f5ca5b 100644
--- a/typescript.html.markdown
+++ b/typescript.html.markdown
@@ -2,6 +2,7 @@
 language: TypeScript
 contributors:
     - ["Philippe Vlérick", "https://github.com/pvlerick"]
+    - ["Kiwimoe", "https://github.com/kiwimoe"]
 filename: learntypescript.ts
 ---
 
@@ -48,6 +49,7 @@ let list: Array<number> = [1, 2, 3];
 // For enumerations:
 enum Color { Red, Green, Blue };
 let c: Color = Color.Green;
+console.log(Color[c]); // "Green"
 
 // Lastly, "void" is used in the special case of a function returning nothing
 function bigHorribleAlert(): void {
@@ -237,6 +239,16 @@ if (state.type === "success") {
   console.error(state.message);
 }
 
+// Template Literal Types
+// Use to create complex string types
+type OrderSize = "regular" | "large";
+type OrderItem = "Espresso" | "Cappuccino";
+type Order = `A ${OrderSize} ${OrderItem}`;
+
+let order1: Order = "A regular Cappuccino";
+let order2: Order = "A large Espresso";
+let order3: Order = "A small Espresso"; // Error
+
 // Iterators and Generators
 
 // for..of statement
@@ -280,7 +292,6 @@ foo.baz = 'hello world'
 
 ## Further Reading
  * [TypeScript Official website] (http://www.typescriptlang.org/)
- * [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)
+ * [TypeScript language specifications] (https://github.com/microsoft/TypeScript/blob/main/doc/spec-ARCHIVED.md)
+ * [Learn TypeScript] (https://learntypescript.dev/)
  * [Source Code on GitHub] (https://github.com/Microsoft/TypeScript)
- * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
diff --git a/uk-ua/c-ua.html.markdown b/uk-ua/c-ua.html.markdown
new file mode 100644
index 00000000..56a2b2ad
--- /dev/null
+++ b/uk-ua/c-ua.html.markdown
@@ -0,0 +1,860 @@
+---
+language: C
+filename: learnc-ua.c
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+    - ["�rpád Goretity", "http://twitter.com/H2CO3_iOS"]
+    - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
+    - ["Marco Scannadinari", "https://marcoms.github.io"]
+    - ["Zachary Ferguson", "https://github.io/zfergus2"]
+    - ["himanshu", "https://github.com/himanshu81494"]
+    - ["Joshua Li", "https://github.com/JoshuaRLi"]
+    - ["Dragos B. Chirila", "https://github.com/dchirila"]
+translators:
+    - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+О, C! До�і мова дл� �уча�них обчи�лень у ви�окопродуктивних продуктах.
+
+C це імовірно найбільш низькорівнева мова, �ку будуть викори�товувати більші�ть програмі�тів. Проте, вона компен�ує це не тільки швидкі�тю виконанн�. Як тільки ви оціните її можливі�ть ручного управлінн� пам'�ттю, С зможе відве�ти �аме в ті мі�ц�, в �кі вам потрібно було потрапити.
+
+> **Дещо про прапори компіл�тора**
+>
+> За замовчуванн�м, gcc та clang до�ить тихо інформують про попередженн� та помилки
+> при компіл�ції, хоч це і може бути дуже кори�ною інформацією. Тому рекомендуєть��
+> викори�товувати більш вимогливий компіл�тор. О�ь кілька рекомендацій:
+>
+> `-Wall -Wextra -Werror -O2 -std=c99 -pedantic`
+>
+> За інформацією про ці та інші прапори зверніть�� до головної �торінки man вашого 
+> компіл�тора C (наприклад, `man 1 gcc`) або ж про�то заґуґліть.
+
+
+```c
+// Однор�дкові коментарі починають�� з //
+// Проте вони з'�вили�ь тільки пі�л� С99.
+
+/*
+Багатор�дкові коментарі мають такий вигл�д. І працюють в C89.
+*/
+
+/*
+Багатор�дкові коментарі не можуть вкладати�ь один в одний. 
+/* Будьте обережними */ // коментар закінчуєть�� на цьому р�дку...
+*/ // ...а не на цьому!
+
+// Кон�танта: #define <keyword>
+// �азви кон�тант, �к правило, пишуть�� великими літерами, проте це не вимога
+#define DAYS_IN_YEAR 365
+
+// Ще одним �по�обом оголо�ити кон�танти є переліченн� кон�тант.
+// До речі, в�і вирази мають закінчувати�ь крапкою з комою.
+enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
+// MON отримає значенн� 2 автоматично, TUE дорівнюватиме 3 і т.д.
+
+// Імпортувати заголовки можна за допомогою #include
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// (Заголовки із �тандартної бібліотеки С вказують�� між <кутовими дужками>.)
+// Щоб додати вла�ні заголовки, потрібно викори�товувати "подвійні лапки" 
+// замі�ть кутових:
+//#include "my_header.h"
+
+// Сигнатури функцій попередньо оголошують�� в .h файлах або на початку .� файлів.
+void function_1();
+int function_2(void);
+
+// Потрібно оголо�ити 'прототип функції' перед main(), реалізаці� функцій 
+// відбуваєть�� пі�л� функції main().
+int add_two_ints(int x1, int x2); // прототип функції
+// Варіант `int add_two_ints(int, int);` теж правильний (не потрібно називати 
+// аргументи). Рекомендуєть�� також називати аргументи в прототипі дл� 
+// кращого розумінн�.
+
+// Вхідною точкою програми є функці� під назвою main. Вона повертає чи�ельний тип.
+int main(void) {
+  // реалізаці� програми
+}
+
+// �ргументи командного р�дка, вказані при запу�ку програми, також передають��
+// у функцію main.
+// argc - це кількі�ть переданих аргументів
+// argv — це ма�ив ма�ивів �имволів, що мі�тить �амі аргументи
+// argv[0] - назва програми, argv[1] - перший аргумент, і т.д.
+int main (int argc, char** argv)
+{
+  // printf дозвол�є виве�ти на екран значенн�, вивід - це форматований р�док, 
+  // в даному випадку %d позначає чи�ельне значенн�, \n — це новий р�док
+  printf("%d\n", 0); // => Виводить 0
+
+  ///////////////////////////////////////
+  // Типи
+  ///////////////////////////////////////
+
+  // В�і змінні повинні бути оголошені на початку поточного блоку обла�ті видимо�ті.
+  // В цьому коді вони оголошують�� динамічно. С99-�умі�ні компіл�тори
+  // дозвол�ють оголошенн� близько до мі�ц�, де значенн� викори�товуєть��.
+
+  // int (цілочи�ельний знаковий тип) зазвичай займає 4 байти
+  int x_int = 0;
+
+  // short (цілочи�ельний знаковий тип) зазвичай займає 2 байти
+  // 
+  short x_short = 0;
+
+  // Символьний тип char гарантовано займає 1 байт
+  char x_char = 0;
+  char y_char = 'y'; // Символьні літерали позначають�� ''
+
+  // long (цілочи�ельний знаковий тип) має розмір від 4 до 8 байтів; великі значенн�  
+  // типу long гарантовано займають 8 байтів
+  long x_long = 0;
+  long long x_long_long = 0;
+
+  // Тип float - це зазвичай 32-бітове чи�ло з плаваючою крапкою
+  float x_float = 0.0f; // Суфік� 'f' позначає літерал з плаваючою крапкою
+
+  // Тип double - це зазвийчай 64-бітове чи�ло з плаваючою крапкою
+  double x_double = 0.0; // дій�не чи�ло без �уфік�ів має тип double
+
+  // Цілочи�ельні типи можуть не мати знаку (бути більше, або ж рівними нулю)
+  unsigned short ux_short;
+  unsigned int ux_int;
+  unsigned long long ux_long_long;
+
+  // Char в�ередині одинарних лапок інтерпретують�� �к чи�ла в наборі 
+  // �имволів комп'ютера.
+  '0'; // => 48 в таблиці ASCII.
+  'A'; // => 65 в таблиці ASCII.
+
+  // sizeof(T) повертає розмір змінної типу Т в байтах
+  // sizeof(obj) віддає розмір виразу (змінна, літерал, і т.п.)
+  printf("%zu\n", sizeof(int)); // => 4 (на більшо�ті при�троїв з 4-байтним �ловом)
+
+  // Якщо аргумент оператора `sizeof` — це вираз, тоді його аргументи не оцінюють��
+  // (крім ма�ивів, розмір �ких залежить від змінної).
+  // Значенн�, що повертаєть�� в цьому випадку, - це кон�танта ча�у компіл�ції.
+  int a = 1;
+  // size_t - беззнаковий чи�ельний тип розміром щонайменше 2 байти, �кий
+  // викори�товуєть�� дл� відображенн� розміру об'єкта.
+  size_t size = sizeof(a++); // a++ не оцінюєть��
+  printf("sizeof(a++) = %zu where a = %d\n", size, a);
+  // Виводить "sizeof(a++) = 4 where a = 1" (на 32-бітній архітектурі)
+
+  // Ма�иви повинні бути проініціалізовані з конкретним розміром.
+  char my_char_array[20]; // Цей ма�ив займає 1 * 20 = 20 байтів
+  int my_int_array[20]; // Цей ма�ив займає 4 * 20 = 80 байтів
+  // (припу�каючи 4-байтні чи�ла)
+
+  // Таким чином можна проініціалізувати ма�ив нулем:
+  char my_array[20] = {0};
+  // де "{0}" називаєть�� "ініціалізатором ма�иву".
+  
+  // Зазначте, можна �вно не оголошувати розмір ма�иву, ЯКЩО ви проініціалізуєте 
+  // ма�ив у тому ж р�дку. Тому, на�тупне оголошенн� еквівалентне:
+  char my_array[] = {0};
+  // �ЛЕ, потрібно визначити розмір ма�иву під ча� виконанн�, �к тут:
+  size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]);
+  
+  // ПОПЕРЕДЖЕ��Я �кщо ви вирішили викори�товувати даний підхід, потрібно 
+  // визначити розмір **перед тим**, �к ви почнете передавати ма�ив у функцію
+  // (побачите ди�ку�ію пізніше). Ма�иви перетворюють�� на вказівники при
+  // передачі �к аргументи у функцію, тому попереднє твердженн� буде видавати
+  // хибний результат в�ередині функції.
+
+  // Індек�аці� по ма�иву така ж �ама, �к і в інших мовах програмуванн� або,
+  // �коріше, �к у інших �-подібних мовах.
+  my_array[0]; // => 0
+
+  // Ма�иви незмінні, це про�то ча�тина пам'�ті!
+  my_array[1] = 2;
+  printf("%d\n", my_array[1]); // => 2
+
+  // Ма�иви, розмір �ких залежить від змінної, в С99 (та в С11 �к вибірковий 
+  // функціонал) можуть бути оголошені також. Розмір такого ма�иву не має бути
+  // кон�тантою під ча� компіл�ції:
+  printf("Enter the array size: "); // �питати кори�тувача розмір ма�иву
+  int array_size;
+  fscanf(stdin, "%d", &array_size);
+  int var_length_array[array_size]; // оголо�ити ма�ив
+  printf("sizeof array = %zu\n", sizeof var_length_array);
+
+  // Приклад:
+  // > Enter the array size: 10
+  // > sizeof array = 40
+
+  // Р�дки - це про�то ма�иви �имвольних літералів (char), що закінчують�� NULL 
+  // (0x00) байтом, пред�тавленим у р�дках �к �пеціальний �имвол '\0'.
+  // (�е потрібно включати байт NULL в р�дкові літерали; компіл�тор �ам в�тавл�є
+  // його наприкінці ма�иву.)
+  char a_string[20] = "This is a string";
+  printf("%s\n", a_string); // %s форматує р�док
+
+  printf("%d\n", a_string[16]); // => 0
+  // тобто, байт #17 - це 0 (так �амо, �к і 18-ий, 19-ий, та 20-ий)
+
+  // Якщо між одинарними лапками є букви, тоді це �имвольний літерал.
+  // Він має тип `int`, а не `char` (так і�торично �клало�ь).
+  int cha = 'a'; // добре
+  char chb = 'a'; // також добре (не�вне перетворенн� з int на char)
+
+  // Багатовимірні ма�иви:
+  int multi_array[2][5] = {
+    {1, 2, 3, 4, 5},
+    {6, 7, 8, 9, 0}
+  };
+  // До�туп до елементів:
+  int array_int = multi_array[0][2]; // => 3
+
+  ///////////////////////////////////////
+  // Оператори
+  ///////////////////////////////////////
+
+  // Скороченн� дл� багатьох оголошень:
+  int i1 = 1, i2 = 2;
+  float f1 = 1.0, f2 = 2.0;
+
+  int b, c;
+  b = c = 0;
+
+  // �рифметичні операції
+  i1 + i2; // => 3
+  i2 - i1; // => 1
+  i2 * i1; // => 2
+  i1 / i2; // => 0 (0.5 округлено до 0)
+
+  // Потрібно перетворити хоча б одну з цілочи�ельних змінних на float, щоб 
+  // отримати результат з плаваючою крапкою
+  (float)i1 / i2; // => 0.5f
+  i1 / (double)i2; // => 0.5 // Так �амо і дл� типу double
+  f1 / f2; // => 0.5, з певною точні�тю
+  // Такі обчи�ленн� не є точними
+
+  // Діленн� за модулем також є
+  11 % 3; // => 2, о�тача від діленн�
+
+  // Оператори порівн�нн� ймовірно �хожі, проте в С немає логічного типу.
+  // �атомі�ть викори�товуєть�� int.
+  // (�бо _Bool або bool в C99.)
+  // 0 - хибно (false), в�і інші значенн� - правда (true). Оператори
+  // порівн�нн� завжди повертають 0 або 1.
+  3 == 2; // => 0 (false)
+  3 != 2; // => 1 (true)
+  3 > 2; // => 1
+  3 < 2; // => 0
+  2 <= 2; // => 1
+  2 >= 2; // => 1
+
+  // C - це не Python, порівн�нн� не утворюють ланцюги.
+  // Попередженн�: Р�док нижче �компілюєть��, але він означає `(0 < a) < 2`.
+  // В даному випадку, це 1, тому що (0 < 1).
+  int between_0_and_2 = 0 < a < 2;
+  // �атомі�ть потрібно викори�тати:
+  int between_0_and_2 = 0 < a && a < 2;
+
+  // Логічні оператори з чи�лами
+  !3; // => 0 (Логічне �Е)
+  !0; // => 1
+  1 && 1; // => 1 (Логічне І)
+  0 && 1; // => 0
+  0 || 1; // => 1 (Логічне �БО)
+  0 || 0; // => 0
+
+  // Тернарний вираз з умовою ( ? : )
+  int e = 5;
+  int f = 10;
+  int z;
+  z = (e > f) ? e : f; // => 10 "if e > f return e, else return f."
+
+  // Оператори збільшенн� та зменшенн� на 1:
+  int j = 0;
+  int s = j++; // Повернути j ПОТІМ збільшити j. (s = 0, j = 1)
+  s = ++j; // Збільшити j ПОТІМ повернути j. (s = 2, j = 2)
+  // так �амо і дл� j-- та --j
+
+  // Побітові операції!
+  ~0x0F; // => 0xFFFFFFF0 (побітове запереченн�, "перше доповненн�", результат 
+  // дл� 32-бітного int)
+  0x0F & 0xF0; // => 0x00 (побітове І)
+  0x0F | 0xF0; // => 0xFF (побітове �БО)
+  0x04 ^ 0x0F; // => 0x0B (побітове XOR)
+  0x01 << 1; // => 0x02 (побітовий з�ув вліво (на 1))
+  0x02 >> 1; // => 0x01 (побітовий з�ув вправо (на 1))
+
+  // Будьте обережними при з�уві цілочи�ельних значень зі знаком.  
+  // �а�тупні дії дають невизначений результат:
+  // - з�ув на біт, що зберігає знак чи�ла (int a = 1 << 31)
+  // - з�ув вліво на від'ємне чи�ло (int a = -1 << 2)
+  // - з�ув на чи�ло, що більше за ширину типу 
+  // TODO: LHS
+  // - з�ув на зміщенн�, що >= ширині типу в лівій ча�тині виразу:
+  //   int a = 1 << 32; // �евизначена поведінка, �кщо ширина int 32 біти.
+
+  ///////////////////////////////////////
+  // Структури розгалуженн�
+  ///////////////////////////////////////
+
+  // Оператор умови
+  if (0) {
+    printf("I am never run\n"); // ніколи не буде виконано
+  } else if (0) {
+    printf("I am also never run\n"); // теж ніколи не буде виконано
+  } else {
+    printf("I print\n");	// це буде надруковано
+  }
+
+  // Цикл з передумовою
+  int ii = 0;
+  while (ii < 10) { // БУДЬ-ЯКЕ значенн�, що менше 10 - правда.
+    printf("%d, ", ii++); // ii++ збільшує ii на 1 ПІСЛЯ передачі поточного значенн�.
+  } // => надрукує "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+  printf("\n");
+
+  // Цикл з пі�л�умовою
+  int kk = 0;
+  do {
+    printf("%d, ", kk);
+  } while (++kk < 10); // ++kk збільшує kk на 1 ПЕРЕД передачою поточного значенн�.
+  // => надрукує "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+  printf("\n");
+
+  // Цикл з лічильником
+  int jj;
+  for (jj=0; jj < 10; jj++) {
+    printf("%d, ", jj);
+  } // => виводить "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+  printf("\n");
+
+  // *****Додатково*****:
+  // Цикли та функції обов'�зково повинні мати тіло. Якщо тіло не потрібно:
+  int i;
+  for (i = 0; i <= 5; i++) {
+    ; // викори�товуйте крапку з комою, щоб �имулювати тіло (пу�те твердженн�)
+  }
+  // �бо
+  for (i = 0; i <= 5; i++);
+
+  // Розгалуженн� з множинним вибором: switch()
+  switch (a) {
+  case 0: // значенн� повинні бути *кон�тантними* виразами і мати вбудований тип
+          //(наприклад, переліченн�)
+    printf("Hey, 'a' equals 0!\n");
+    break; // �кщо не викори�тати break, то управлінн� буде передано на�тупному блоку
+  case 1:
+    printf("Huh, 'a' equals 1!\n");
+    break;
+    // Будьте обережними, виконанн� продовжить�� до тих пір, поки
+    // не зу�трінеть�� на�тупний "break".
+  case 3:
+  case 4:
+    printf("Look at that.. 'a' is either 3, or 4\n");
+    break;
+  default:
+    // �кщо вираз a не �півпадає з опи�аними значенн�ми, то виконуєть�� 
+    // блок default
+    fputs("Error!\n", stderr);
+    exit(-1);
+    break;
+  }
+  /*
+  Викори�танн� "goto" в С
+  */
+  typedef enum { false, true } bool;
+  // вводимо таке переліченн�, о�кільки С не має логічного типу до С99
+  bool disaster = false;
+  int i, j;
+  for(i=0;i<100;++i)
+  for(j=0;j<100;++j)
+  {
+    if((i + j) >= 150)
+        disaster = true;
+    if(disaster)
+        goto error;
+  }
+  error :
+  printf("Error occurred at i = %d & j = %d.\n", i, j);
+  /*
+  https://ideone.com/GuPhd6
+  Даний приклад виведе "Error occurred at i = 51 & j = 99."
+  */
+
+  ///////////////////////////////////////
+  // Приведенн� до типів
+  ///////////////////////////////////////
+
+  // Кожне значеннн� в С має тип, але можна переве�ти значенн� з одного типу в 
+  // інший, �кщо потрібно (із де�кими обмеженн�ми).
+
+  int x_hex = 0x01; // Змінним можна при�воювати літерали в ші�тнадц�тковій 
+                    // �и�темі чи�ленн�
+
+  // Приведенн� до типу призведе до �проби зберегти чи�ельне значенн�
+  printf("%d\n", x_hex); // => Виводить 1
+  printf("%d\n", (short) x_hex); // => Виводить 1
+  printf("%d\n", (char) x_hex); // => Виводить 1
+
+  // В данному випадку попередженн� не виникатиме, �кщо значенн� виходить за межі 
+  // значенн� типу
+  printf("%d\n", (unsigned char) 257); // => 1 (мак�имальне значенн� char = 255, 
+  // �кщо char має довжину 8 біт)
+
+  // Дл� того, щоб дізнати�ь мак�имальний розмір `char`, `signed char` або ж 
+  // `unsigned char`, потрібно викори�тати макро�и CHAR_MAX, SCHAR_MAX та UCHAR_MAX
+  // відповідно з <limits.h>. 
+
+  // Вбудовані типи можуть бути приведені до типу із плаваючою крапкою і навпаки.
+  printf("%f\n", (double) 100); // %f завжди перетворює чи�ло на double...
+  printf("%f\n", (float)  100); // ...навіть, �кщо це float.
+  printf("%d\n", (char)100.0);
+
+  ///////////////////////////////////////
+  // Вказівники
+  ///////////////////////////////////////
+
+  // Вказівник - це змінна, що зберігає адре�у у пам'�ті. Оголошенн� вказівника 
+  // також потребує інформації про тип об'єкта, на �кий він вказує. Можна 
+  // отримати адре�у пам'�ті будь-�кої змінної, а потім працювати з нею.
+
+  int x = 0;
+  printf("%p\n", (void *)&x); // Оператор & повертає адре�у змінної у пам'�ті
+  // (%p форматує об'єкт вказівника типу void *)
+  // => Виводить де�ку адре�у в пам'�ті
+
+  // Дл� оголошенн� вказівника потрібно по�тавити * перед його назвою.
+  int *px, not_a_pointer; // px - це вказівник на цілочи�ельне значенн� (int)
+  px = &x; // Зберігає адре�у змінної x в px
+  printf("%p\n", (void *)px); // => Виводить адре�у в пам'�ті
+  printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer));
+  // => Виводить "8, 4" на звичайній 64-бітній �и�темі
+
+  // Щоб прочитати значенн�, �ке зберігаєть�� за адре�ою, на �ку вказує вказівник,
+  // потрібно по�тавити знак * перед назвою змінної. 
+  // Так, * викори�товуєть�� одноча�но і дл� оголошенн� вказівника, і дл� отриманн� 
+  // значенн� за адре�ою. Звучить заплутано, проте тільки �початку.
+  printf("%d\n", *px); // => Виводить 0, значенн� x
+
+  // Можна також змінити значенн�, на �ке по�илаєть�� вказівник.
+  // Тут зверненн� до адре�и обернене у круглі дужки, тому що 
+  // ++ має вищий пріоритет виконанн�, ніж *.
+  (*px)++; // Збільшити значенн�, на �ке вказує px, на 1
+  printf("%d\n", *px); // => Виводить 1
+  printf("%d\n", x); // => Виводить 1
+
+  // Ма�иви зручно викори�товувати дл� виділенн� неперервного блоку пам'�ті.
+  int x_array[20]; // оголошує ма�ив з 20 елементів (розмір можна задати лише один раз)
+  int xx;
+  for (xx = 0; xx < 20; xx++) {
+    x_array[xx] = 20 - xx;
+  } // Ініціалізує x_array значенн�ми 20, 19, 18,... 2, 1
+
+  // Оголо�ити вказівник типу int, �кий по�илаєть�� на ма�ив x_array
+  int* x_ptr = x_array;
+  // x_ptr тепер вказує на перший елемент ма�иву (чи�ло 20).
+  //  
+  // Це працює, тому що при зверненні до імені ма�иву повертаєть�� вказівник 
+  // на перший елемент. �априклад, коли ма�ив передаєть�� у функцію або при�воюєть��
+  // вказівнику, він не�вно приводить�� до вказівника.
+  // Виключенн�: 
+  // - коли вказівник передаєть�� �к аргумент із оператором `&`:
+  int arr[10];
+  int (*ptr_to_arr)[10] = &arr; // &arr �Е має тип `int *`!
+  // Він має тип "вказівник на ма�ив" (з 10 чи�ел).
+  // - коли ма�ив - це р�дковий літерал, що викори�товуєть�� дл� ініціалізації
+  // ма�ив �имволів:
+  char otherarr[] = "foobarbazquirk";
+  // - коли ма�ив - це аргумент операторів `sizeof` або `alignof`:
+  int arraythethird[10];
+  int *ptr = arraythethird; // те ж �аме, що з int *ptr = &arr[0];
+  printf("%zu, %zu\n", sizeof(arraythethird), sizeof(ptr));
+  // Ймовірно, виводить "40, 4" або "40, 8"
+
+  // Інкрементаці� та декрементаці� вказівника залежить від його типу.
+  // (так звана арифметика вказівників)
+  printf("%d\n", *(x_ptr + 1)); // => Виводить 19
+  printf("%d\n", x_array[1]); // => Виводить 19
+
+  // Можна також динамічно виділити по�лідовні блоки в пам'�ті за допомогою
+  // функції malloc зі �тандартної бібліотеки. malloc приймає один аргумент типу
+  // size_t, що опи�ує кількі�ть байтів дл� виділенн� (зазвичай із купи, проте це
+  // може бути неправдою на вбудованих �и�темах - �тандарт С нічого про це не повідомл�є).
+  int *my_ptr = malloc(sizeof(*my_ptr) * 20);
+  for (xx = 0; xx < 20; xx++) {
+    *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
+  } // Проініціалізувати пам'�ть значенн�ми 20, 19, 18, 17... 2, 1 (�к int)
+
+  // Будьте обережними із передачею значень, що надають�� кори�тувачем, в malloc!
+  // Про в��к випадок, викори�товуйте calloc в таких �итуаці�х (�кий, на відміну від 
+  // malloc, також заповнює пам'�ть нул�ми).
+  int* my_other_ptr = calloc(20, sizeof(int));
+
+  // �емає �тандартного �по�обу визначити розмір динамічно виділеного ма�иву в С.
+  // Через це, �кщо ма�иви будуть ча�то передавати�ь в програмі, потрібна інша змінна,
+  // �ка буде від�лідковувати кількі�ть елементів в ма�иві. Детальніше в розділі 
+  // про функції.
+  size_t size = 10;
+  int *my_arr = calloc(size, sizeof(int));
+  // Додати елемент до ма�иву.
+  size++;
+  my_arr = realloc(my_arr, sizeof(int) * size);
+  if (my_arr == NULL) {
+    // �е забувайте перевір�ти результат виконанн� realloc на помилки!
+    return
+  }
+  my_arr[10] = 5;
+
+  // Робота з вказівниками може призводити до неочікуваних і непрогнозованих 
+  // результатів, �кщо звернути�ь до пам'�ті, що не була виділена вами.
+  printf("%d\n", *(my_ptr + 21)); // => Хто зна, що буде виведено. 
+  									// Може навіть вилетіти з помилкою.
+
+  // Пі�л� закінченн� роботи із виділеною за допомогою malloc пам'�ттю, її обов'�зково
+  // потрібно звільнити. Інакше ніхто не зможе нею �кори�тати��, аж поки програма не
+  // завершить �вою роботу (така �итуаці� називаєть�� "витоком пам'�ті").
+  free(my_ptr);
+
+  // Р�дки - це ма�иви �имволів, проте вони найча�тіше пред�тавлені �к 
+  // вказівник на �имвол (тобто, вказівник на перший елемент ма�иву). Вважаєть��
+  // хорошим підходом викори�товувати `const char *', по�илаючи�ь на об'єкт
+  // р�дка, о�кільки його не можна змінити ("foo"[0] = 'a' З�БОРО�Е�О).
+  const char *my_str = "This is my very own string literal";
+  printf("%c\n", *my_str); // => 'T'
+
+  // Це не працюватиме, �кщо р�док - це ма�ив (потенційно �творений за допомогою 
+  // р�дкового літерала), що зберігаєть�� у ча�тині пам'�ті, �ку можна перезапи�увати:
+  char foo[] = "foo";
+  foo[0] = 'a'; // Дозвол�єть��, foo тепер мі�тить "aoo"
+
+  function_1();
+} // Кінець функції main
+
+///////////////////////////////////////
+// Функції
+///////////////////////////////////////
+
+// Синтак�и� оголошенн� функції:
+// <тип поверненн�> <назва функції>(<аргументи>)
+
+int add_two_ints(int x1, int x2)
+{
+  return x1 + x2; // Викори�товуйте return, щоб повернути значенн�
+}
+
+/*
+Дані у функцію передають за значенн�м. Коли функці� викликаєть��, аргументи, що
+передають�� у функцію, копіюють�� з оригіналів (окрім ма�ивів). В�і зміни над 
+значенн�м аргументів в�ередині функції не впливають на значенн� оригіналів.
+
+Викори�товуйте вказівники, �кщо потрібно редагувати безпо�ередньо оригінальні 
+значенн� аргументів.
+
+Приклад: замінити р�док на обернений.
+*/
+
+// void означає, що функці� нічого не повертає
+void str_reverse(char *str_in)
+{
+  char tmp;
+  size_t ii = 0;
+  size_t len = strlen(str_in); // `strlen()` це ча�тина �тандартної бібліотеки С
+                               // Зауважте: довжина, �ку повертає `strlen`, не включає
+                               //           термінальний NULL байт ('\0')
+  for (ii = 0; ii < len / 2; ii++) { // в C99 можна напр�му оголошувати тип `ii` в циклі
+    tmp = str_in[ii];
+    str_in[ii] = str_in[len - ii - 1]; // ii-й �имвол з кінц�
+    str_in[len - ii - 1] = tmp;
+  }
+}
+// Зауважте: дл� викори�танн� strlen() потрібно завантажити файл заголовку string.h
+
+/*
+char c[] = "This is a test.";
+str_reverse(c);
+printf("%s\n", c); // => ".tset a si sihT"
+*/
+/*
+О�кільки можна повертати тільки одну змінну, дл� зміни значенн� більшої 
+кілько�ті змінних можна викори�товувати виклик за по�иланн�м
+*/
+void swapTwoNumbers(int *a, int *b)
+{
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+}
+/*
+int first = 10;
+int second = 20;
+printf("first: %d\nsecond: %d\n", first, second);
+swapTwoNumbers(&first, &second);
+printf("first: %d\nsecond: %d\n", first, second);
+// змінні обмінюють�� значенн�ми
+*/
+
+/*
+Ма�иви завжди передають�� у функції �к вказівники, не зважаючи на тип ма�иву 
+(�татичний чи динамічний). Тому в�ередині функці� не знає про розмір ма�иву.
+*/
+// Розмір ма�иву завжди має передавати�ь разом із ма�ивом!
+void printIntArray(int *arr, size_t size) {
+    int i;
+    for (i = 0; i < size; i++) {
+        printf("arr[%d] is: %d\n", i, arr[i]);
+    }
+}
+/*
+int my_arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+int size = 10;
+printIntArray(my_arr, size);
+// виведе "arr[0] is: 1" і т.д.
+*/
+
+// Ключове �лово extern викори�товуєть��, �кщо в�ередині функції потрібно звернути�ь
+// до змінної, що була оголошена поза функцією.
+int i = 0;
+void testFunc() {
+  extern int i; // викори�товуємо зовнішню змінну i
+}
+
+// Зробити зовнішню змінну приватною у вихідному файлі за допомогою static:
+static int j = 0; // інші файли, що викори�товують testFunc2(), 
+                  // не матимуть до�тупу до змінної j
+void testFunc2() {
+  extern int j;
+}
+// Ключове �лово static робить змінну недо�тупною дл� коду поза даною одиницею 
+// компіл�ції. (�а більшо�ті �и�тем, одиниц� компіл�ції - це файл). 
+// static можна викори�товувати до глобальних змінних, функцій, локальних
+// змінних у функці�х. Локальні змінні, проініціалізовані static, повод�ть
+// �ебе �к глобальні змінні, проте тільки в межах даного файлу. Статичні
+// змінні ініціалізують�� 0, �кщо інше значенн� не було вказане.
+// **Як варіант, функції можна зробити приватними оголо�ивши їх �к static**
+
+///////////////////////////////////////
+// Кори�тувацькі типи та �труктури
+///////////////////////////////////////
+
+// Ключове �лово typedef викори�товуєть��, щоб �творити п�евдонім типу
+typedef int my_type;
+my_type my_type_var = 0;
+
+// Структури - це такі �обі колекції з даними. Пам'�ть дл� полів виділ�єть�� 
+// по�лідовно, в пор�дку їх напи�анн�:
+struct rectangle {
+  int width;
+  int height;
+};
+
+// Проте це не означає, що 
+// sizeof(struct rectangle) == sizeof(int) + sizeof(int)
+// в зв'�зку з вирівнюванн�м пам'�ті [1]
+
+void function_1()
+{
+  struct rectangle my_rec;
+
+  // До�туп до полів �труктури відбуваєть�� через .
+  my_rec.width = 10;
+  my_rec.height = 20;
+
+  // Можна �творити вказівники на �труктуру
+  struct rectangle *my_rec_ptr = &my_rec;
+
+  // Зверненн� до �труктури через вказівник та зміна значень пол�:
+  (*my_rec_ptr).width = 30;
+
+  // �ле є й альтернативний �по�іб звернути�ь до пол� через вказівник, викори�товуючи 
+  // оператор -> (краще читаєть��)
+  my_rec_ptr->height = 10; // Те ж �аме, що (*my_rec_ptr).height = 10;
+}
+
+// Можна викори�тати typedef перед struct
+typedef struct rectangle rect;
+
+int area(rect r)
+{
+  return r.width * r.height;
+}
+
+// Якщо ваша �труктура доволі громіздка, можна звертати�ь до неї через вказівник, 
+// щоб уникнути копіюванн� в�ієї �труктури:
+int areaptr(const rect *r)
+{
+  return r->width * r->height;
+}
+
+///////////////////////////////////////
+// Вказівники на функції
+///////////////////////////////////////
+/*
+Під ча� виконанн� функції знаход�ть�� за відомими адре�ами в пам'�ті. Вказівники 
+на функції - це ті ж �амі вказівники, що зберігають адре�у у пам'�ті, проте можуть
+викори�товувати�ь, щоб викликати функції напр�му і передавати обробники (або функції зі 
+зворотнім зв'�зком). Хоча, �интак�и� �початку може бути доволі незрозумілим.
+
+Приклад: use str_reverse from a pointer
+*/
+void str_reverse_through_pointer(char *str_in) {
+  // Оголо�ити вказівник на функцію під назвою f.
+  void (*f)(char *); // Сигнатура повинна точно �півпадати із цільовою функцією.
+  f = &str_reverse; // При�войте адре�у певної функції (визначаєть�� під ча� виконанн�)
+  // f = str_reverse; повинно працювати також
+  (*f)(str_in); // Виклик функції через вказівник
+  // f(str_in); // Це альтернативний, але теж вірний �интак�и� виклику функції.
+}
+
+/*
+Якщо �игнатури функцій �півпадають, можна при�воїти будь-�ку функцію тому ж 
+�амому вказівнику. Вказівники на функції зазвичай викори�товують�� �к п�евдоніми 
+дл� �прощенн� та покращенн� читабельно�ті коду. Приклад:
+*/
+
+typedef void (*my_fnp_type)(char *);
+
+// Викори�танн� при оголошенні змінної вказівника:
+// ...
+// my_fnp_type f;
+
+
+// Спеціальні �имволи:
+/*
+'\a'; // �имвол попередженн� (дзвінок)
+'\n'; // �имвол нового р�дка
+'\t'; // �имвол табул�ції (вирівнюванн� по лівому краю)
+'\v'; // вертикальна табул�ці�
+'\f'; // нова �торінка
+'\r'; // поверненн� каретки
+'\b'; // �тиранн� о�таннього �имволу
+'\0'; // нульовий �имвол. Зазвичай розташовуєть�� в кінці р�дка.
+//   hello\n\0. \0 викори�товуєть�� дл� позначенн� кінц� р�дка.
+'\\'; // зворотній �леш
+'\?'; // знак питанн�
+'\''; // одинарні лапки
+'\"'; // подвійні лапки
+'\xhh'; // ші�тнадц�ткове чи�ло. �априклад: '\xb' = �имвол вертикальної табул�ції
+'\0oo'; // ві�імкове чи�ло. �априклад: '\013' = �имвол вертикальної табул�ції
+
+// форматуванн� виводу:
+"%d";    // ціле чи�ло (int)
+"%3d";   // ціле чи�ло, щонайменше 3 �имволи (вирівнюванн� по правому краю)
+"%s";    // р�док
+"%f";    // чи�ло з плаваючою крапкою (float)
+"%ld";   // велике ціле чи�ло (long)
+"%3.2f"; // чи�ло з плаваючою крапкою, щонайменше 3 цифри зліва і 2 цифри �права 
+"%7.4s"; // (аналогічно дл� р�дків)
+"%c";    // �имвол
+"%p";    // вказівник. Зазначте: потребує перетворенн� типу на (void *) перед 
+         //                      викори�танн�м у `printf`.
+"%x";    // ші�тнадц�ткове чи�ло
+"%o";    // ві�імкове чи�ло
+"%%";    // друкує %
+*/
+
+///////////////////////////////////////
+// Пор�док виконанн�
+///////////////////////////////////////
+
+//---------------------------------------------------//
+//        Оператори                  | ��оціативні�ть//
+//---------------------------------------------------//
+// () [] -> .                        | зліва направо //
+// ! ~ ++ -- + = *(type)sizeof       | �права наліво //
+// * / %                             | зліва направо //
+// + -                               | зліва направо //
+// << >>                             | зліва направо //
+// < <= > >=                         | зліва направо //
+// == !=                             | зліва направо //
+// &                                 | зліва направо //
+// ^                                 | зліва направо //
+// |                                 | зліва направо //
+// &&                                | зліва направо //
+// ||                                | зліва направо //
+// ?:                                | �права наліво //
+// = += -= *= /= %= &= ^= |= <<= >>= | �права наліво //
+// ,                                 | зліва направо //
+//---------------------------------------------------//
+
+/****************************** Файли заголовків *********************************
+
+Файли заголовків важливі в С. Вони розділ�ють вихідний код та визначенн� на різні 
+файли, що робить їх кращими дл� розумінн�. 
+
+Файли заголовків �интак�ично подібні до вихідних файлів С, проте опи�ують�� у".h"
+файлах. Їх можна додати в код за допомогою директиви #include "example.h", �кщо
+example.h і�нує в тому ж каталозі, що і файл С.
+*/
+
+/* 
+Так можна запобігти тому, що заголовок буде оголошений кілька разів. Така �итуаці�
+виникає у випадку циклічної залежно�ті, тобто коли вмі�т заголовку вже було
+оголошено.                                                         
+*/
+#ifndef EXAMPLE_H /* �кщо EXAMPLE_H ще не оголошено. */
+#define EXAMPLE_H /* Визначити макро� EXAMPLE_H. */
+
+/* 
+Заголовки можна додавати в інші заголовки, таким чином вони разом додають��
+у подальшому.                      
+*/
+#include <string.h>
+
+/* 
+Макро�и можуть бути визначені також у заголовку та викори�товувати�ь у файлах,
+що мі�т�ть цей заголовок. 
+*/
+#define EXAMPLE_NAME "Dennis Ritchie"
+
+/* Макро�и функції також можна визначити.  */
+#define ADD(a, b) ((a) + (b))
+/*
+Зверніть увагу на круглі дужки навколо аргументів! Важливо переконати�ь, що 
+a та b не можна проінтерпретувати інакше. �априклад:
+MUL(x, y) (x * y); 
+MUL(1 + 2, 3) -> (1 + 2 * 3), що є помилкою
+*/
+
+/* Struct та typedef можуть викори�товувати�ь дл� узгоджено�ті між файлами. */
+typedef struct Node
+{
+    int val;
+    struct Node *next;
+} Node;
+
+/* Так �амо і переліченн�. */
+enum traffic_light_state {GREEN, YELLOW, RED};
+
+/* 
+Прототипи функцій також можна оголо�ити так, щоб викори�товувати у кількох 
+файлах. �ле так робити не варто. Краще оголо�ити їх у С файлі.
+*/
+Node createLinkedList(int *vals, int len);
+
+/*
+Окрім вище згаданих випадків, в�і інші визначенн� мають опи�увати�ь у С файлах.
+*/
+
+#endif /* Кінець директиви передкомпіл�ції if. */
+
+```
+## Додаткові матеріали
+
+Кращим по�ібником дл� вивченн� С буде книга автор�тва Дені�а Рітчі (творець С) та Бра�на Кернігана, 
+[K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language).
+�ле обережно з нею, книга �тарезна і мі�тить неточно�ті (ідеї, що вже вважають�� не надто прийн�тними).
+
+Ще одним хорошим ре�ур�ом є книга "Learn C The Hard Way" (на�вна тільки англій�ькою).
+
+�а де�кі ча�ті запитанн� да�ть відповідь англомовний ре�ур� [compl.lang.c Frequently Asked Questions](http://c-faq.com).
+
+�агадаю, що важливо викори�товувати правильні інтервали, від�тупи та загалом мати узгоджений �тиль коду.
+Зручний дл� читанн� код краще, ніж �кладний код або зроблений нашвидкоруч. За прикладом можна звернути�ь до
+[Linux kernel coding style](https://www.kernel.org/doc/Documentation/process/coding-style.rst).
+
+Щодо в�ього іншого, �уґл на допомогу!
+
+[1] [Чому розмір �труктури не дорівнює �умі розмірів її полів? (англ.)](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member)
diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown
index f980f7b1..6f294b1f 100644
--- a/uk-ua/go-ua.html.markdown
+++ b/uk-ua/go-ua.html.markdown
@@ -434,15 +434,15 @@ func requestServer() {
 
 ## Подальше вивченн�
 
-О�новним джерелом в�ієї інформації про Go залишаєть�� [офіційна веб-�торінка](http://golang.org/). Там можна знайти уроки, інтерактивно пограти та багато про що почитати.
-Окрім туру, у [документації](https://golang.org/doc/) мі�тить�� інформаці� �к пи�ати чи�тий та ефективний код на Go, документаці� пакетів та окремих команд, а також і�торі� релізів.
+О�новним джерелом в�ієї інформації про Go залишаєть�� [офіційна веб-�торінка](https://go.dev/). Там можна знайти уроки, інтерактивно пограти та багато про що почитати.
+Окрім туру, у [документації](https://go.dev/doc/) мі�тить�� інформаці� �к пи�ати чи�тий та ефективний код на Go, документаці� пакетів та окремих команд, а також і�торі� релізів.
 
 �адзвичайно рекомендуєть�� ознайомити�ь із визначенн�м мови. Вона легко читаєть�� та на диво коротка (в порівн�нні з іншими �уча�ними мовами).
 
-Можна пограти�ь з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запу�тити із �вого браузера. Поміть, що можна викори�товувати [https://play.golang.org](https://play.golang.org) �к [REPL](https://uk.wikipedia.org/wiki/REPL) до те�тів та коду в твоєму браузері, без в�тановленн� Go.
+Можна пограти�ь з кодом вище на [Go playground](https://go.dev/play/p/tnWMjr16Mm). Спробуй змінити його та запу�тити із �вого браузера. Поміть, що можна викори�товувати [https://go.dev/play/](https://go.dev/play/) �к [REPL](https://uk.wikipedia.org/wiki/REPL) до те�тів та коду в твоєму браузері, без в�тановленн� Go.
 
-В �пи�ку дл� прочитанн� новачкам в Go - [вихідний код �тандартної бібліотеки](http://golang.org/src/pkg/). Код в�ео��жно задокоментований, тому є найкращим прикладом з боку зручного дл� прочитанн� та швидко�ті розумінн� коду на цій мові програмуванн�. Приведений �тиль та ідіоми Go.
-Крім того, можна про�то нати�нути на назву функції в [документації](http://golang.org/pkg/), щоб перейти до її реалізації.
+В �пи�ку дл� прочитанн� новачкам в Go - [вихідний код �тандартної бібліотеки](https://go.dev/src/). Код в�ео��жно задокоментований, тому є найкращим прикладом з боку зручного дл� прочитанн� та швидко�ті розумінн� коду на цій мові програмуванн�. Приведений �тиль та ідіоми Go.
+Крім того, можна про�то нати�нути на назву функції в [документації](https://go.dev/pkg/), щоб перейти до її реалізації.
 
 Іншим прекра�ним по�иланн�м дл� вивченн� Go є [Go by example](https://gobyexample.com/).
 
diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown
index 8d4517fe..2d42e85d 100644
--- a/uk-ua/mips-ua.html.markdown
+++ b/uk-ua/mips-ua.html.markdown
@@ -188,7 +188,7 @@ lang: uk-ua
     # �ехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регі�тр
     ble $s0, $s1, a_LTE_b                   # �кщо (a <= b) розгалуженн�(a_LTE_b)
     ble $s0, $s2, max_C                     # �кщо (a > b && a <=c) розгалуженн�(max_C)
-    move $v0, $s1                           # інакше [a > b && a > c] max = a
+    move $v0, $s0                           # інакше [a > b && a > c] max = a
     j done                                  # Перейти в кінець програми
 
     a_LTE_b:                                # Мітка розгалуженн�, коли a <= b
diff --git a/uk-ua/ruby-ua.html.markdown b/uk-ua/ruby-ua.html.markdown
index 74346dfe..a71c30bc 100644
--- a/uk-ua/ruby-ua.html.markdown
+++ b/uk-ua/ruby-ua.html.markdown
@@ -622,4 +622,4 @@ Something.new.qux # => 'qux'
 - [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.
+- [Try Ruby](https://try.ruby-lang.org/) - Learn the basic of Ruby programming language, interactive in the browser.
diff --git a/uk-ua/rust-ua.html.markdown b/uk-ua/rust-ua.html.markdown
index 4ec2b7c9..4aad0cbb 100644
--- a/uk-ua/rust-ua.html.markdown
+++ b/uk-ua/rust-ua.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["P1start", "http://p1start.github.io/"]
 translators:
@@ -233,7 +233,7 @@ fn main() {
 
     // Цикл `for` 
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/uxntal.html.markdown b/uxntal.html.markdown
new file mode 100644
index 00000000..c56e158a
--- /dev/null
+++ b/uxntal.html.markdown
@@ -0,0 +1,174 @@
+---
+language: uxntal
+contributors:
+    - ["Devine Lu Linvega", "https://wiki.xxiivv.com"]
+filename: learnuxn.tal
+---
+
+Uxntal is a stack-machine assembly language targeting the [Uxn virtual machine](https://wiki.xxiivv.com/site/uxn.html).
+
+Stack machine programming might look at bit odd, as it uses a postfix notation, 
+which means that operators are always found at the end of an operation. For 
+instance, one would write 3 4 + instead of 3 + 4. 
+
+The expression written (5 + 10) * 3 in conventional notation would be 
+written 10 5 + 3 * in reverse Polish notation.
+
+```forth
+( This is a comment )
+
+( All programming in Unxtal is done by manipulating the stack )
+
+#12 ( push a byte )
+#3456 ( push a short )
+
+( Uxn has 32 opcodes, each opcode has 3 possible modes )
+
+POP ( pop a byte )
+POP2 ( pop a short )
+
+( The modes are:
+	[2] The short mode consumes two bytes from the stack.
+	[k] The keep mode does not consume items from the stack.
+	[r] The return mode makes the operator operate on the return-stack. )
+
+#12 #34 ADD ( 46 )
+#12 #34 ADDk ( 12  34  46 )
+
+( The modes can be combined )
+
+#1234 #5678 ADD2k ( 12  34  56  78  68  ac )
+
+( The arithmetic/bitwise opcodes are:
+	ADD SUB MUL DIV
+	AND ORA EOR SFT )
+
+( New opcodes can be created using macros )
+
+%MOD2 { DIV2k MUL2 SUB2 }
+
+#1234 #0421 MOD2 ( 01  b0 )
+
+( ---------------------------------------------------------------------------- )
+
+( A short is simply two bytes, each byte can be manipulated )
+
+#1234 SWP ( 34  12 )
+#1234 #5678 SWP2 ( 56  78  12  34 )
+#1234 #5678 SWP ( 12  34  78  56 )
+
+( Individual bytes of a short can be removed from the stack )
+
+#1234 POP ( 12 )
+#1234 NIP ( 34 )
+
+( The stack opcodes are:
+	POP DUP NIP SWP OVR ROT )
+
+( ---------------------------------------------------------------------------- )
+
+( To compare values on the stack with each other )
+
+#12 #34 EQU ( 00 )
+#12 #12 EQU ( 01 )
+
+( Logic opcodes will put a flag with a value of either 00 or 01 )
+
+#12 #34 LTH 
+#78 #56 GTH 
+	#0101 EQU2 ( 01 )
+
+( The logic opcodes are:
+	EQU NEQ GTH LTH )
+
+( ---------------------------------------------------------------------------- )
+
+( Uxn's accessible memory is as follows: 
+	256 bytes of working stack 
+	256 bytes of return stack
+	65536 bytes of memory
+	256 bytes of IO memory )
+
+( The addressable memory is between 0000-ffff )
+
+#12 #0200 STA ( stored 12 at 0200 in memory )
+#3456 #0201 STA2 ( stored 3456 at 0201 in memory )
+#0200 LDA2 ( 12  34 )
+
+( The zero-page can be addressed with a single byte )
+
+#1234 #80 STZ2 ( stored 12 at 0080, and 34 at 0081 )
+#80 LDZ2 ( 12  34 )
+
+( Devices are ways for Uxn to communicate with the outside world
+	There is a maximum of 16 devices connected to Uxn at once
+	Device bytes are called ports, the Console device uses the 10-1f ports
+	The console's port 18 is called /write )
+
+%EMIT { #18 DEO }
+
+#31 EMIT ( print "1" to console )
+
+( A label is equal to a position in the program )
+@parent ( defines a label "parent" )
+	&child ( defines a sublabel "parent/child" )
+
+( Label positions can be pushed on stack )
+;parent ( push the absolute position, 2 bytes )
+,parent ( push the relative position, 1 byte )
+.parent ( push the zero-page position, 1 byte )
+
+( The memory opcodes are:
+	LDZ STZ LDR STR
+	LDA STA DEI DEO )
+
+( ---------------------------------------------------------------------------- )
+
+( Logic allows to create conditionals )
+
+#12 #34 NEQ ,skip JCN
+	#31 EMIT
+	@skip
+
+( Logic also allows to create for-loops )
+
+#3a #30
+@loop
+	DUP EMIT ( print "123456789" to console )
+	INC GTHk ,loop JCN
+POP2
+
+( Logic also allows to create while-loops )
+
+;word
+@while
+	LDAk EMIT
+	INC2 LDAk ,while JCN
+POP2
+BRK
+
+@word "vermillion $1
+
+( Subroutines can be jumped to with JSR, and returned from with JMP2r )
+
+;word ,print-word JSR
+BRK
+
+@print-word ( word* -- )
+	@while
+		LDAk EMIT
+		INC2 LDAk ,while JCN
+	POP2
+JMP2r
+
+@word "cerulean
+
+( The jump opcodes are: 
+	JMP JCN JSR )
+```
+
+## Ready For More?
+
+* [Uxntal Lessons](https://compudanzas.net/uxn_tutorial.html)
+* [Uxntal Assembly](https://wiki.xxiivv.com/site/uxntal.html)
+* [Uxntal Resources](https://github.com/hundredrabbits/awesome-uxn)
diff --git a/v.html.markdown b/v.html.markdown
new file mode 100644
index 00000000..4f698184
--- /dev/null
+++ b/v.html.markdown
@@ -0,0 +1,229 @@
+---
+language: v
+filename: vlang.v
+contributors:
+    - ["Maou Shimazu", "https://github.com/Maou-Shimazu"]
+---
+
+V is a statically typed compiled programming language 
+designed for building maintainable software.
+
+It's similar to Go and its design has also been influenced by 
+Oberon, Rust, Swift, Kotlin, and Python.
+
+The language promotes writing 
+simple and clear code with minimal abstraction.
+
+Despite being simple, V gives the developer a lot of power. 
+Anything you can do in other languages, you can do in V.
+
+```v
+// Single Line Comment.
+/*
+    Multi Line Comment
+*/
+
+struct User { // Cannot be defined in main, explained later.
+	age  int
+	name string
+	pos int = -1 // custom default value
+}
+// struct method
+fn (u User) can_register() bool {
+	return u.age > 16
+}
+
+struct Parser {
+	token Token
+}
+
+// c like enums
+enum Token {
+	plus
+	minus
+	div
+	mult
+}
+
+// 1. functions
+// language does not use semi colons
+fn add(x int, y int) int {
+	return x + y 
+}
+// can return multiple values
+fn foo() (int, int) {
+	return 2, 3
+}
+
+// function visibility 
+pub fn public_function() { // pub can only be used from a named module.
+}
+
+fn private_function() {
+}
+
+
+
+// Main function
+fn main() {
+	// Anonymous functions can be declared inside other functions:
+	double_fn := fn (n int) int {
+		return n + n
+	}
+	// 2. Variables: they are immutable by default
+	// implicitly typed
+	x := 1
+	// x = 2 // error
+	mut y := 2
+	y = 4
+	name := "John"
+	large_number := i64(9999999999999)
+    println("$x, $y, $name, $large_number") // 1, 4, John, 9999999999999
+
+	// unpacking values from functions.
+	a, b := foo()
+	println("$a, $b") // 2, 3
+	c, _ := foo() // ignore values using `_`
+	println("$c") // 2
+
+	// Numbers
+	u := u16(12)
+	v := 13 + u    // v is of type `u16`
+	r := f32(45.6)
+	q := r + 3.14  // x is of type `f32`
+	s := 75        // a is of type `int` 
+	l := 14.7      // b is of type `f64` 
+	e := u + s     // c is of type `int`
+	d := l + r     // d is of type `f64`
+
+	// Strings
+	mut bob := 'Bob'
+	assert bob[0] == u8(66) // indexing gives a byte, u8(66) == `B`
+	assert bob[1..3] == 'ob'  // slicing gives a string 'ob'
+	bobby := bob + 'by' // + is used to concatenate strings
+	println(bobby) // "Bobby"
+	bob += "by2" // += is used to append to strings
+	println(bob) // "Bobby2"
+
+	//String values are immutable. You cannot mutate elements:
+	//mut s := 'hello 🌎'
+	//s[0] = `H` // not allowed
+
+	//For raw strings, prepend r. Escape handling is not done for raw strings:
+	rstring := r'hello\nworld' // the `\n` will be preserved as two characters
+	println(rstring) // "hello\nworld"
+
+	// string interpolation
+	println('Hello, $bob!') // Hello, Bob!
+	println('Bob length + 10: ${bob.len + 10}!') // Bob length + 10: 13!
+
+	// 3. Arrays
+	mut numbers := [1, 2, 3]
+	println(numbers) // `[1, 2, 3]`
+	numbers << 4 // append elements with <<
+	println(numbers[3]) // `4`
+	numbers[1] = 5
+	println(numbers) // `[1, 5, 3]`
+	// numbers << "John" // error: `numbers` is an array of numbers
+	numbers = [] // array is now empty
+	arr := []int{len: 5, init: -1}
+	// `arr == [-1, -1, -1, -1, -1]`, arr.cap == 5
+
+	number_slices := [0, 10, 20, 30, 40]
+	println(number_slices[1..4]) // [10, 20, 30]
+	println(number_slices[..4]) // [0, 10, 20, 30]
+	println(number_slices[1..]) // [10, 20, 30, 40]
+
+	// 4. structs and enums
+	// struct User {
+	// 	age  int
+	// 	name string
+	//  pos int = -1 // custom default value
+	// }
+	mut users := User{21, 'Bob', 0}
+	println(users.age) // 21
+	
+	// enum Token {
+	// 	plus
+	// 	minus
+	// 	div
+	// 	mult
+	// }
+
+	// struct Parser {
+	// 	token Token
+	// }
+	parser := Parser{}
+	if parser.token == .plus || parser.token == .minus 
+	|| parser.token == .div || parser.token == .mult {
+		// ...
+	}
+
+
+	// 5. Maps
+	number_map := {
+		'one': 1
+		'two': 2
+	}
+	println(number_map) // {'one': 1, 'two': 2}
+	println(number_map["one"]) // 1
+	mut m := map[string]int{} // a map with `string` keys and `int` values
+	m['one'] = 1
+	m['two'] = 2
+	println(m['one']) // "1"
+	println(m['bad_key']) // "0"
+	m.delete('two')
+
+	// 6. Conditionals
+	a_number := 10
+	b_number := 20
+	if a_number < b {
+		println('$a_number < $b_number')
+	} else if a_number > b {
+		println('$a_number > $b_number')
+	} else {
+		println('$a_number == $b_number')
+	}
+	num := 777
+	even_odd := if num % 2 == 0 { 'even' } else { 'odd' }
+	println(even_odd)
+
+	match even_odd {
+		'even' { println('even') }
+		'odd' { println('odd') }
+		else { println('unknown') }
+	} 
+
+	// 7. Loops
+	loops := [1, 2, 3, 4, 5]
+	for lp in loops {
+		println(lp)
+	}
+	loop_names := ['Sam', 'Peter']
+	for i, lname in loop_names {
+		println('$i) $lname')
+		// Output: 0) Sam
+		//         1) Peter
+	}
+	// You can also use break and continue followed by a 
+	// label name to refer to an outer for loop:
+	outer: for i := 4; true; i++ {
+		println(i)
+		for {
+			if i < 7 {
+				continue outer
+			} else {
+				break outer
+			}
+		}
+	}
+}
+
+```
+## Further reading
+
+There are more complex concepts to be learnt in V which are available at the
+official [V documentation](https://github.com/vlang/v/blob/master/doc/docs.md).
+
+You can also find more information about the V language at the [official website](https://vlang.io/)
+or check it out at the [v playground](https://v-wasm.vercel.app/).
\ No newline at end of file
diff --git a/vala.html.markdown b/vala.html.markdown
index 393578b0..739e0fda 100755..100644
--- a/vala.html.markdown
+++ b/vala.html.markdown
@@ -483,10 +483,10 @@ pointer_obj->some_data; // Returns some_data
 delete pointer_obj;
 
 int more = 57;
-int* more_pointer = &i; // & = address-of
+int* more_pointer = &more; // & = address-of
 int indirection_demo = more_pointer*; // indirection
 
-// Profiles: affect which Vala features are avaliable and which libraries the
+// Profiles: affect which Vala features are available and which libraries the
 // C-code will use.
 // - gobject (default)
 // posix
@@ -494,10 +494,10 @@ int indirection_demo = more_pointer*; // indirection
 // Use "--profile=whatever" when compiling.
 
 ```
-* More Vala documentation can be found [here](https://valadoc.org/).
+* More [Vala documentation](https://valadoc.org/).
 * [Alternate construction syntax](https://wiki.gnome.org/Projects/Vala/Tutorial#GObject-Style_Construction) similar to GObject
-* More on contract programming [here](http://en.wikipedia.org/wiki/Contract_programming)
-* Collections library can be found [here](https://wiki.gnome.org/Projects/Vala/Tutorial#Collections)
+* More on [contract programming](http://en.wikipedia.org/wiki/Contract_programming)
+* [Collections library](https://wiki.gnome.org/Projects/Vala/Tutorial#Collections)
 * [Multithreading](https://wiki.gnome.org/Projects/Vala/Tutorial#Multi-Threading)
-* Read about building GUIs with GTK+ and Vala [here](http://archive.is/7C7bw).
-* D-Bus [integration](https://wiki.gnome.org/Projects/Vala/Tutorial#D-Bus_Integration)
+* Read about [building GUIs with GTK+ and Vala](http://archive.is/7C7bw).
+* [D-Bus integration](https://wiki.gnome.org/Projects/Vala/Tutorial#D-Bus_Integration)
diff --git a/vi-vn/git-vi.html.markdown b/vi-vn/git-vi.html.markdown
index 1bcc94a0..47485bd9 100644
--- a/vi-vn/git-vi.html.markdown
+++ b/vi-vn/git-vi.html.markdown
@@ -1,328 +1,328 @@
----

-category: tool

-tool: git

-contributors:

+---
+category: tool
+tool: git
+contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
-    - ["Vinh Nguyen", "https://twitter.com/vinhnx"]

-filename: LearnGit-vi.txt

-lang: vi-vn

----

-

-Git là một hệ quản lý mã nguồn và phiên bản phân tán (distributed version control and source code management system).

-

-Nó làm được đi�u này là do một loạt các snapshot từ đ� án của bạn, và nó hoạt động

-với các snapshot đó để cung cấp cho bạn với chức năng đến phiên bản và

-quản lý mã nguồn của bạn.

-

-## Khái Niệm Versioning

-

-### Version Control là gì?

-

-Version Control là một hệ thống ghi lại những thay đổi ở một tập tin, hay một nhóm các tập tin, theo th�i gian.

-

-### So sánh giữa Centralized Versioning và Distributed Versioning

-

-* Quản lý phiên bản tập trung (Centralized Versioning) tập trung vào việc đồng bộ hóa, theo dõi, và lưu trữ tập tin.

-* Quản lý phiên bản phân tán (Distributed Versioning) tập trung vào việc chia sẻ các thay đổi. Mỗi sự thay đổi có một mã định dạng (id) duy nhất.

-* Các hệ phân tán không có cấu trúc định sẵn. Bạn có thể thay đổi một kiểu SVN, hệ phân tán, với git.

-

-[Thông tin thêm](http://git-scm.com/book/en/Getting-Started-About-Version-Control)

-

-### Tại Sao Dùng Git?

-

-* Có thể hoạt động offline.

-* Cộng tác với nhau rất dễ dàng!

-* Phân nhánh dễ dàng!

-* Trá»™n (Merging)

-* Git nhanh.

-* Git linh hoạt.

-

-## Kiến Trúc Git

-

-

-### Repository

-

-Một nhóm các tập tin, thư mục, các ghi chép trong quá khứ, commit, và heads. Tưởng tượng nó như là một cấu trúc dữ liệu mã nguồn,

-với thuộc tính mà một "nhân tố" mã nguồn cho bạn quy�n truy cập đến lịch sử sửa đổi, và một số thứ khác.

-

-Một git repository bao gồm thư mục .git & tree đang làm việc.

-

-### Thư mục .git (thành phần của một repository)

-

-Thư mục .git chứa tất cả các cấu hình, log, nhánh, HEAD, và hơn nữa.

-[Danh Sách Chi Tiết.](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)

-

-### Tree �ang Làm (thành phần của một repository)

-

-�ây cơ bản là các thư mục và tập tin trong repository của bạn. Nó thư�ng được tham chiếu

-thư mục đang làm việc của bạn

-

-### Chỉ mục (thành phần của một thư mục .git)

-

-Chỉ mục của là một staging area trong git. Nó đơn giản là một lớp riêng biệt với tree đang làm việc của bạn

-từ Git repository. �i�u này cho nhà phát tri�n nhi�u lựa ch�n hơn trong việc xem xét những gì được gửi đến Git

-repository.

-

-### Commit

-

-Một git commit là một snapshot của một nhóm các thay đổi, hoặc các thao tác Working Tree của bạn.

-Ví dụ, nếu bạn thêm 5 tập tin, và xóa 2 tập tin khác, những thay đổi này sẽ được chứa trong

-một commit (hoặc snapshot). Commit này có thể được đẩy đến các repo khác, hoặc không!

-

-### Nhánh

-

-Nhánh thực chất là một con tr� đến commit mới nhất mà bạn vừa thực hiện. Khi bạn commit,

-con tr� này sẽ cập nhật tự động và tr� đến commit mới nhất.

-

-### HEAD và head (thành phần của thư mục .git)

-

-HEAD là một con tr� đến branch hiện tại. Một repo chỉ có một HEAD *đang hoạt động*.

-head là một con tr� đến bất kỳ commit nào. Một repo có thể có nhi�u head.

-

-### Các Tài Nguyên Mang Tính Khái Niệm

-

-* [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/)

-* [Git For Designers](http://hoth.entp.com/output/git_for_designers.html)

-

-

-## Các Lệnh

-

-

-### init

-

-Tạo một repo Git rỗng. Các cài đặt, thông tin lưu trữ... của Git

-được lưu ở một thư mục tên là ".git".

-

-```bash

-$ git init

-```

-

-### config

-

-�ể chỉnh tùy ch�n. Bất kể là cho repo, hay cho hệ thống, hay đi�u chỉnh

-toàn cục (global)

-

-

-

-```bash

-# In Ra & Và Gán Một Số Biến Tùy Chỉnh Cơ Bản (Toàn cục - Global)

-$ git config --global user.email

-$ git config --global user.name

-

-$ git config --global user.email "MyEmail@Zoho.com"

-$ git config --global user.name "My Name"

-```

-

-[Tìm hiểu thêm v� git config.](http://git-scm.com/docs/git-config)

-

-### help

-

-�ể cho bạn lối truy cập nhanh đến một chỉ dẫn cực kỳ chi tiết của từng lệnh. Hoặc chỉ để

-nhắc bạn một số cú pháp.

-

-```bash

-# Xem nhanh các lệnh có sẵn

-$ git help

-

-# Xem tất các các lệnh

-$ git help -a

-

-# Lệnh help riêng biệt - tài liệu ngư�i dùng

-# git help <command_here>

-$ git help add

-$ git help commit

-$ git help init

-```

-

-### status

-

-�ể hiển thị sự khác nhau giữa tập tin index (cơ bản là repo đang làm việc) và HEAD commit

-hiện tại.

-

-

-```bash

-# Sẽ hiển thị nhánh, các tập tin chưa track (chưa commit), các thay đổi và những khác biệt khác

-$ git status

-

-# �ể xem các "tid bits" v� git status

-$ git help status

-```

-

-### add

-

-�ể thêm các tập vào tree/thư mục/repo hiện tại. Nếu bạn không `git add` các tập tin mới đến

-tree/thư mục hiện tại, chúng sẽ không được kèm theo trong các commit!

-

-```bash

-# thêm một file vào thư mục hiện tại

-$ git add HelloWorld.java

-

-# thêm một file vào một thư mục khác

-$ git add /path/to/file/HelloWorld.c

-

-# Hỗ trợ Regular Expression!

-$ git add ./*.java

-```

-

-### branch

-

-Quản lý nhánh (branch). Bạn có thể xem, sửa, tạo, xóa các nhánh bằng cách dùng lệnh này.

-

-```bash

-# liệt kê các branch đang có và ở remote

-$ git branch -a

-

-# tạo branch mới

-$ git branch myNewBranch

-

-# xóa một branch

-$ git branch -d myBranch

-

-# đặt tên lại một branch

-# git branch -m <oldname> <newname>

-$ git branch -m myBranchName myNewBranchName

-

-# chỉnh sửa diễn giải của một branch

-$ git branch myBranchName --edit-description

-```

-

-### checkout

-

-Cập nhật tất cả các file trong tree hiện tại để cho trùng khớp với phiên bản của index, hoặc tree cụ thể.

-

-```bash

-# Checkout (chuyển) một repo - mặc định là nhánh master

-$ git checkout

-# Checkout một nhánh cụ thể

-$ git checkout branchName

-# Tạo một nhánh mới và chuyển đến nó, tương tự: "git branch <name>; git checkout <name>"

-$ git checkout -b newBranch

-```

-

-### clone

-

-Nhân bản, hoặc sao chép, một repo hiện có thành một thư mục mới. Nó cũng thêm

-các branch có remote-tracking cho mỗi branch trong một repo được nhân bản, mà

-cho phép bạn push đến một remote branch.

-

-```bash

-# Nhân bản learnxinyminutes-docs

-$ git clone https://github.com/adambard/learnxinyminutes-docs.git

-```

-

-### commit

-

-Lưu trữ nội dung hiện tại của index trong một "commit" mới. �i�u này cho phép tạo ra thay đổi và một ghi chú tạo ra bởi ngư�i dùng.

-

-```bash

-# commit với một ghi chú

-$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"

-```

-

-### diff

-

-Hiển thị sự khác biệt giữa một file trong thư mục hiện tại, index và commits.

-

-```bash

-# Hiển thị sự khác biệt giữa thư mục hiện tại và index

-$ git diff

-

-# Hiển thị khác biệt giữa index và commit mới nhất.

-$ git diff --cached

-

-# Hiển thị khác biệt giữa thư mục đang làm việc và commit mới nhất

-$ git diff HEAD

-```

-

-### grep

-

-Cho phép bạn tìm kiếm nhanh một repo.

-

-Các tinh chỉnh tùy ch�n:

-

-```bash

-# Cảm ơn Travis Jeffery vì những lệnh này

-# �ặt số của dòng được hiển thị trong kết quả tìm kiếm grep

-$ git config --global grep.lineNumber true

-

-# Làm cho kết quả tìm kiếm dễ đ�c hơn, bao gồm cả gom nhóm

-$ git config --global alias.g "grep --break --heading --line-number"

-```

-

-```bash

-# Tìm "variableName" trong tất cả các file Java

-$ git grep 'variableName' -- '*.java'

-

-# Tìm một dòng mà có chứa "arrayListName" và, "add" hoặc "remove"

-$ git grep -e 'arrayListName' --and \( -e add -e remove \)

-```

-

-Google để xem thêm các ví dụ

-[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)

-

-### log

-

-Hiển thị các commit đến repo.

-

-```bash

-# Hiện tất cả các commit

-$ git log

-

-# Hiện X commit

-$ git log -n 10

-

-# Chỉ hiện các commit đã merge merge commits

-$ git log --merges

-```

-

-### merge

-

-"Trộn" các thay đổi từ commit bên ngoài vào trong nhánh hiện tại.

-

-```bash

-# Merge branch cụ thể vào branch hiện tại.

-$ git merge branchName

-

-# Luôn khởi tạo một merge commit khi trộn (merge)

-$ git merge --no-ff branchName

-```

-

-### mv

-

-�ặt lại tên hoặc di chuyển một file

-

-```bash

-# �ặt lại tên một file

-$ git mv HelloWorld.c HelloNewWorld.c

-

-# Di chuyển một file

-$ git mv HelloWorld.c ./new/path/HelloWorld.c

-

-# Buộc đặt lại tên hoặc di chuyển

-# "existingFile" đã tồn tại trong thự mục, sẽ bị ghi đè

-$ git mv -f myFile existingFile

-```

-

-### pull

-

-Pull v� từ một repo và merge nó vào branch khác.

-

-```bash

-# Cập nhật repo local của bạn, bằng cách merge các thay đổi mới

-# từ remote "origin" và nhánh "master".

-# git pull <remote> <branch>

-# git pull => hoàn toàn mặc định như => git pull origin master

-$ git pull origin master

-

-# Merge các thay đổi từ remote branch và rebase

-# các commit trong branch lên trên local repo, như sau: "git pull <remote> <branch>, git rebase <branch>"

-$ git pull origin master --rebase

-```

-

-### push

-

-push và merge các thay đổi từ một branch đến một remote & branch.

-

+    - ["Vinh Nguyen", "https://twitter.com/vinhnx"]
+filename: LearnGit-vi.txt
+lang: vi-vn
+---
+
+Git là một hệ quản lý mã nguồn và phiên bản phân tán (distributed version control and source code management system).
+
+Nó làm được đi�u này là do một loạt các snapshot từ đ� án của bạn, và nó hoạt động
+với các snapshot đó để cung cấp cho bạn với chức năng đến phiên bản và
+quản lý mã nguồn của bạn.
+
+## Khái Niệm Versioning
+
+### Version Control là gì?
+
+Version Control là một hệ thống ghi lại những thay đổi ở một tập tin, hay một nhóm các tập tin, theo th�i gian.
+
+### So sánh giữa Centralized Versioning và Distributed Versioning
+
+* Quản lý phiên bản tập trung (Centralized Versioning) tập trung vào việc đồng bộ hóa, theo dõi, và lưu trữ tập tin.
+* Quản lý phiên bản phân tán (Distributed Versioning) tập trung vào việc chia sẻ các thay đổi. Mỗi sự thay đổi có một mã định dạng (id) duy nhất.
+* Các hệ phân tán không có cấu trúc định sẵn. Bạn có thể thay đổi một kiểu SVN, hệ phân tán, với git.
+
+[Thông tin thêm](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Tại Sao Dùng Git?
+
+* Có thể hoạt động offline.
+* Cộng tác với nhau rất dễ dàng!
+* Phân nhánh dễ dàng!
+* Trá»™n (Merging)
+* Git nhanh.
+* Git linh hoạt.
+
+## Kiến Trúc Git
+
+
+### Repository
+
+Một nhóm các tập tin, thư mục, các ghi chép trong quá khứ, commit, và heads. Tưởng tượng nó như là một cấu trúc dữ liệu mã nguồn,
+với thuộc tính mà một "nhân tố" mã nguồn cho bạn quy�n truy cập đến lịch sử sửa đổi, và một số thứ khác.
+
+Một git repository bao gồm thư mục .git & tree đang làm việc.
+
+### Thư mục .git (thành phần của một repository)
+
+Thư mục .git chứa tất cả các cấu hình, log, nhánh, HEAD, và hơn nữa.
+[Danh Sách Chi Tiết.](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Tree �ang Làm (thành phần của một repository)
+
+�ây cơ bản là các thư mục và tập tin trong repository của bạn. Nó thư�ng được tham chiếu
+thư mục đang làm việc của bạn
+
+### Chỉ mục (thành phần của một thư mục .git)
+
+Chỉ mục của là một staging area trong git. Nó đơn giản là một lớp riêng biệt với tree đang làm việc của bạn
+từ Git repository. �i�u này cho nhà phát tri�n nhi�u lựa ch�n hơn trong việc xem xét những gì được gửi đến Git
+repository.
+
+### Commit
+
+Một git commit là một snapshot của một nhóm các thay đổi, hoặc các thao tác Working Tree của bạn.
+Ví dụ, nếu bạn thêm 5 tập tin, và xóa 2 tập tin khác, những thay đổi này sẽ được chứa trong
+một commit (hoặc snapshot). Commit này có thể được đẩy đến các repo khác, hoặc không!
+
+### Nhánh
+
+Nhánh thực chất là một con tr� đến commit mới nhất mà bạn vừa thực hiện. Khi bạn commit,
+con tr� này sẽ cập nhật tự động và tr� đến commit mới nhất.
+
+### HEAD và head (thành phần của thư mục .git)
+
+HEAD là một con tr� đến branch hiện tại. Một repo chỉ có một HEAD *đang hoạt động*.
+head là một con tr� đến bất kỳ commit nào. Một repo có thể có nhi�u head.
+
+### Các Tài Nguyên Mang Tính Khái Niệm
+
+* [Git For Computer Scientists](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git For Designers](http://hoth.entp.com/output/git_for_designers.html)
+
+
+## Các Lệnh
+
+
+### init
+
+Tạo một repo Git rỗng. Các cài đặt, thông tin lưu trữ... của Git
+được lưu ở một thư mục tên là ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+�ể chỉnh tùy ch�n. Bất kể là cho repo, hay cho hệ thống, hay đi�u chỉnh
+toàn cục (global)
+
+
+
+```bash
+# In Ra & Và Gán Một Số Biến Tùy Chỉnh Cơ Bản (Toàn cục - Global)
+$ git config --global user.email
+$ git config --global user.name
+
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[Tìm hiểu thêm v� git config.](http://git-scm.com/docs/git-config)
+
+### help
+
+�ể cho bạn lối truy cập nhanh đến một chỉ dẫn cực kỳ chi tiết của từng lệnh. Hoặc chỉ để
+nhắc bạn một số cú pháp.
+
+```bash
+# Xem nhanh các lệnh có sẵn
+$ git help
+
+# Xem tất các các lệnh
+$ git help -a
+
+# Lệnh help riêng biệt - tài liệu ngư�i dùng
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+```
+
+### status
+
+�ể hiển thị sự khác nhau giữa tập tin index (cơ bản là repo đang làm việc) và HEAD commit
+hiện tại.
+
+
+```bash
+# Sẽ hiển thị nhánh, các tập tin chưa track (chưa commit), các thay đổi và những khác biệt khác
+$ git status
+
+# �ể xem các "tid bits" v� git status
+$ git help status
+```
+
+### add
+
+�ể thêm các tập vào tree/thư mục/repo hiện tại. Nếu bạn không `git add` các tập tin mới đến
+tree/thư mục hiện tại, chúng sẽ không được kèm theo trong các commit!
+
+```bash
+# thêm một file vào thư mục hiện tại
+$ git add HelloWorld.java
+
+# thêm một file vào một thư mục khác
+$ git add /path/to/file/HelloWorld.c
+
+# Hỗ trợ Regular Expression!
+$ git add ./*.java
+```
+
+### branch
+
+Quản lý nhánh (branch). Bạn có thể xem, sửa, tạo, xóa các nhánh bằng cách dùng lệnh này.
+
+```bash
+# liệt kê các branch đang có và ở remote
+$ git branch -a
+
+# tạo branch mới
+$ git branch myNewBranch
+
+# xóa một branch
+$ git branch -d myBranch
+
+# đặt tên lại một branch
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# chỉnh sửa diễn giải của một branch
+$ git branch myBranchName --edit-description
+```
+
+### checkout
+
+Cập nhật tất cả các file trong tree hiện tại để cho trùng khớp với phiên bản của index, hoặc tree cụ thể.
+
+```bash
+# Checkout (chuyển) một repo - mặc định là nhánh master
+$ git checkout
+# Checkout một nhánh cụ thể
+$ git checkout branchName
+# Tạo một nhánh mới và chuyển đến nó, tương tự: "git branch <name>; git checkout <name>"
+$ git checkout -b newBranch
+```
+
+### clone
+
+Nhân bản, hoặc sao chép, một repo hiện có thành một thư mục mới. Nó cũng thêm
+các branch có remote-tracking cho mỗi branch trong một repo được nhân bản, mà
+cho phép bạn push đến một remote branch.
+
+```bash
+# Nhân bản learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+```
+
+### commit
+
+Lưu trữ nội dung hiện tại của index trong một "commit" mới. �i�u này cho phép tạo ra thay đổi và một ghi chú tạo ra bởi ngư�i dùng.
+
+```bash
+# commit với một ghi chú
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+```
+
+### diff
+
+Hiển thị sự khác biệt giữa một file trong thư mục hiện tại, index và commits.
+
+```bash
+# Hiển thị sự khác biệt giữa thư mục hiện tại và index
+$ git diff
+
+# Hiển thị khác biệt giữa index và commit mới nhất.
+$ git diff --cached
+
+# Hiển thị khác biệt giữa thư mục đang làm việc và commit mới nhất
+$ git diff HEAD
+```
+
+### grep
+
+Cho phép bạn tìm kiếm nhanh một repo.
+
+Các tinh chỉnh tùy ch�n:
+
+```bash
+# Cảm ơn Travis Jeffery vì những lệnh này
+# �ặt số của dòng được hiển thị trong kết quả tìm kiếm grep
+$ git config --global grep.lineNumber true
+
+# Làm cho kết quả tìm kiếm dễ đ�c hơn, bao gồm cả gom nhóm
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Tìm "variableName" trong tất cả các file Java
+$ git grep 'variableName' -- '*.java'
+
+# Tìm một dòng mà có chứa "arrayListName" và, "add" hoặc "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Google để xem thêm các ví dụ
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Hiển thị các commit đến repo.
+
+```bash
+# Hiện tất cả các commit
+$ git log
+
+# Hiện X commit
+$ git log -n 10
+
+# Chỉ hiện các commit đã merge merge commits
+$ git log --merges
+```
+
+### merge
+
+"Trộn" các thay đổi từ commit bên ngoài vào trong nhánh hiện tại.
+
+```bash
+# Merge branch cụ thể vào branch hiện tại.
+$ git merge branchName
+
+# Luôn khởi tạo một merge commit khi trộn (merge)
+$ git merge --no-ff branchName
+```
+
+### mv
+
+�ặt lại tên hoặc di chuyển một file
+
+```bash
+# �ặt lại tên một file
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Di chuyển một file
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Buộc đặt lại tên hoặc di chuyển
+# "existingFile" đã tồn tại trong thự mục, sẽ bị ghi đè
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Pull v� từ một repo và merge nó vào branch khác.
+
+```bash
+# Cập nhật repo local của bạn, bằng cách merge các thay đổi mới
+# từ remote "origin" và nhánh "master".
+# git pull <remote> <branch>
+# git pull => hoàn toàn mặc định như => git pull origin master
+$ git pull origin master
+
+# Merge các thay đổi từ remote branch và rebase
+# các commit trong branch lên trên local repo, như sau: "git pull <remote> <branch>, git rebase <branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+push và merge các thay đổi từ một branch đến một remote & branch.
+
 ```bash
 # Push và merge các thay đổi từ một repo local đến một
 # remote có tên là "origin" và nhánh "master".
@@ -334,70 +334,68 @@ $ git push origin master
 $ git push -u origin master
 # Từ lúc này, bất cứ khi nào bạn muốn push từ cùng một nhánh local đó, sử dụng lối tắt:
 $ git push 
-```

-

-### rebase (thận tr�ng)

-

-Lấy tất cả các thay đổi mà đã được commit trên một nhánh, và replay (?) chúng trên một nhánh khác.

-*Không rebase các commit mà bạn đã push đến một repo công khai*.

-

-```bash

-# Rebase experimentBranch lên master

-# git rebase <basebranch> <topicbranch>

-$ git rebase master experimentBranch

-```

-

-[��c Thêm.](http://git-scm.com/book/en/Git-Branching-Rebasing)

-

-### reset (thận tr�ng)

-

-Thiết lập lạo HEAD hiện tại đến một trạng thái cụ thể. �i�u này cho phép bạn làm lại các merges,

-pulls, commits, thêm, and hơn nữa. Nó là một lệnh hay nhưng cũng nguy hiểm nếu bạn không

-biết mình đang làm gì.

-

-```bash

-# Thiết lập lại staging area, để trùng với commit mới nhất (để thư mục không thay đổi)

-$ git reset

-

-#  Thiết lập lại staging area, để trùng với commit mới nhất, và ghi đè lên thư mục hiện tại

-$ git reset --hard

-

-# Di chuyển nhánh hiện tại đến một commit cụ thể (để thư mục không thay đổi)

-# tất cả thay đổi vẫn duy trì trong thư mục.

-$ git reset 31f2bb1

-

-# Di chuyển nhánh hiện tại lùi v� một commit cụ thể

-# và làm cho thư mục hiện tại trùng (xóa các thay đổi chưa được commit và tất cả các commit

-# sau một commit cụ thể).

-$ git reset --hard 31f2bb1

-```

-

-### rm

-

-Ngược lại với git add, git rm xóa file từ tree đang làm việc.

-

-```bash

-# xóa HelloWorld.c

-$ git rm HelloWorld.c

-

-# Xóa file từ thư mục khác

-$ git rm /pather/to/the/file/HelloWorld.c

-```

-

-## Thông tin thêm

-

-* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)

-

-* [git-scm - Video Tutorials](http://git-scm.com/videos)

-

-* [git-scm - Documentation](http://git-scm.com/docs)

-

-* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)

-

-* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)

-

-* [GitGuys](http://www.gitguys.com/)
+```
+
+### rebase (thận tr�ng)
+
+Lấy tất cả các thay đổi mà đã được commit trên một nhánh, và replay (?) chúng trên một nhánh khác.
+*Không rebase các commit mà bạn đã push đến một repo công khai*.
+
+```bash
+# Rebase experimentBranch lên master
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[��c Thêm.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (thận tr�ng)
+
+Thiết lập lạo HEAD hiện tại đến một trạng thái cụ thể. �i�u này cho phép bạn làm lại các merges,
+pulls, commits, thêm, and hơn nữa. Nó là một lệnh hay nhưng cũng nguy hiểm nếu bạn không
+biết mình đang làm gì.
+
+```bash
+# Thiết lập lại staging area, để trùng với commit mới nhất (để thư mục không thay đổi)
+$ git reset
+
+#  Thiết lập lại staging area, để trùng với commit mới nhất, và ghi đè lên thư mục hiện tại
+$ git reset --hard
+
+# Di chuyển nhánh hiện tại đến một commit cụ thể (để thư mục không thay đổi)
+# tất cả thay đổi vẫn duy trì trong thư mục.
+$ git reset 31f2bb1
+
+# Di chuyển nhánh hiện tại lùi v� một commit cụ thể
+# và làm cho thư mục hiện tại trùng (xóa các thay đổi chưa được commit và tất cả các commit
+# sau một commit cụ thể).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Ngược lại với git add, git rm xóa file từ tree đang làm việc.
+
+```bash
+# xóa HelloWorld.c
+$ git rm HelloWorld.c
+
+# Xóa file từ thư mục khác
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+## Thông tin thêm
+
+* [tryGit - A fun interactive way to learn Git.](http://try.github.io/levels/1/challenges/1)
+
+* [git-scm - Video Tutorials](http://git-scm.com/videos)
+
+* [git-scm - Documentation](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorials & Workflows](https://www.atlassian.com/git/)
+
+* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
 
 * [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html)
-

+
 
diff --git a/vi-vn/json-vi.html.markdown b/vi-vn/json-vi.html.markdown
index 257216ff..f709b838 100644
--- a/vi-vn/json-vi.html.markdown
+++ b/vi-vn/json-vi.html.markdown
@@ -37,7 +37,7 @@ kiểu dữ liệu cũng như quy chuẩn cú pháp chặt chẽ sử dụng DTD
 
   "các khóa": "phải luôn được đặt trong dấu ngoặc kép",
   "số": 0,
-  "chuỗi kí tự": "Xin chàø. Tất cả kí tự unicode đ�u được chấp nhận, sử dụng với dạng \"kí tự\"."
+  "chuỗi kí tự": "Xin chàø. Tất cả kí tự unicode đ�u được chấp nhận, sử dụng với dạng \"kí tự\".",
   "có đúng không?": true,
   "không có gì": null,
 
diff --git a/vi-vn/markdown-vi.html.markdown b/vi-vn/markdown-vi.html.markdown
index 89b59253..696fe465 100644
--- a/vi-vn/markdown-vi.html.markdown
+++ b/vi-vn/markdown-vi.html.markdown
@@ -48,6 +48,7 @@ bằng cách thêm số lượng dấu thăng (#) đằng trước chuỗi cần
 ##### �ây là đầu mục <h5>
 ###### �ây là đầu mục <h6>
 ```
+
 Markdown còn cung cấp cách khác để tạo đầu mục hạng nhất h1 và hạng nhì h2.
 
 ```md
@@ -79,6 +80,7 @@ Trong cài đặt Markdown để hiển thị file của GitHub,ta còn có gạ
 ```md
 ~~�oạn văn bản này được gạch ngang.~~
 ```
+
 ## �oạn văn
 
 �oạn văn bao gồm một hay nhi�u dòng văn bản liên tiếp nhau được phân cách
@@ -153,6 +155,7 @@ Ta không nhất thiết phải đi�n số thứ thự cho chỉ mục đúng
 1. Mục thứ hai
 1. Mục thứ ba
 ```
+
 (Sẽ hiển thị như ví dụ trước đó)
 
 Ta còn có thể sử dụng danh sách con
@@ -189,7 +192,7 @@ Ta còn có thể thêm dấu nhảy (hoặc thêm vào bốn dấu cách nữa)
 
 ```md
     my_array.each do |item|
-        puts item
+      puts item
     end
 ```
 
@@ -201,12 +204,13 @@ John didn't even know what the `go_to()` function did!
 
 Trong Markdown của GitHub, ta còn có thêm cách để hiển thị code:
 
-<pre>
-<code class="highlight">&#x60;&#x60;&#x60;ruby
+````md
+```ruby
 def foobar
-    puts "Hello world!"
+  puts "Hello world!"
 end
-&#x60;&#x60;&#x60;</code></pre>
+```
+````
 
 The above text doesn't require indenting, plus GitHub will use syntax
 highlighting of the language you specify after the \`\`\`
@@ -231,11 +235,13 @@ Một trong những thứ tốt nhất khi làm việc với Markdown là khả
 ```md
 [Click me!](http://test.com/)
 ```
+
 Ta còn có thể tạo tiêu đ� cho liên kết sử dụng cặp ngoặc nháy bên trong cặp ngoặc tròn
 
 ```md
 [Click me!](http://test.com/ "Link to Test.com")
 ```
+
 �ư�ng dẫn tương đối cũng hoạt động.
 
 ```md
@@ -244,19 +250,23 @@ Ta còn có thể tạo tiêu đ� cho liên kết sử dụng cặp ngoặc nh
 
 Markdown còn hỗ trợ liên kết kiểu tham chiếu.
 
-<pre><code class="highlight">&#x5b;<span class="nv">Nhấn vào đây</span>][<span class="ss">link1</span>] để xem thêm!
-&#x5b;<span class="nv">Ngoài ra nhấn vào đây</span>][<span class="ss">foobar</span>] nếu bạn muốn xem qua.
+```md
+[Nhấn vào đây][link1] để xem thêm!
+[Ngoài ra nhấn vào đây][foobar] nếu bạn muốn xem qua.
 
-&#x5b;<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Tuyệt!"</span>
-&#x5b;<span class="nv">foobar</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Tốt!"</span></code></pre>
+[link1]: http://test.com/ "Tuyệt!"
+[foobar]: http://foobar.biz/ "Tốt!"
+```
 
 Tiêu đ� có thể được đóng trong dấu nháy hay ngoặc đơn, hoặc có thể được b� qua. Tham chiếu có thể được đặt bất kì đâu trong văn bản và ID của tham chiếu có thể là bất kì gì miễn là nó độc nhất.
 
 Ngoài ra còn có kiểu đặt tên ngầm cho phép ta sử dụng đư�ng dẫn làm ID.
 
-<pre><code class="highlight">&#x5b;<span class="nv">This</span>][] is a link.
+```md
+[This][] is a link.
 
-&#x5b;<span class="nv">this</span>]: <span class="sx">http://thisisalink.com/</span></code></pre>
+[this]: http://thisisalink.com/
+```
 
 Nhưng nó không được sử dụng rộng rãi.
 
@@ -270,9 +280,11 @@ Hiển thị ảnh tương tự như liên kết nhưng có thêm dấu chấm t
 
 Và kiểu tham chiếu cũng hoạt động như vậy.
 
-<pre><code class="highlight">!&#x5b;<span class="nv">�ây là thuộc tính alt.</span>][<span class="ss">myimage</span>]
+```md
+![�ây là thuộc tính alt.][myimage]
 
-&#x5b;<span class="nv">myimage</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"�ây là tiêu đ�"</span></code></pre>
+[myimage]: relative/urls/cool/image.jpg "�ây là tiêu đ�"
+```
 
 ## Khác
 
@@ -297,12 +309,13 @@ Khi ta muốn viết *đoạn văn bản này có dấu sao bao quanh* nhưng ta
 
 ### Phím bàn phím
 
-Trong Markdown của Github, ta có thể sử dụng thẻ `<kbd>` để thay cho phím trên bàn phím.
+Trong Markdown của GitHub, ta có thể sử dụng thẻ `<kbd>` để thay cho phím trên bàn phím.
 
 ```md
 Máy treo? Thử bấm tổ hợp
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 ```
+
 ### Bảng biểu
 
 Bảng biểu được hỗ trợ trên Markdown của GitHub, Jira, Trello, v.v và khá khó viết:
@@ -313,6 +326,7 @@ Bảng biểu được hỗ trợ trên Markdown của GitHub, Jira, Trello, v.v
 | Căn trái     | Căn giữa | Căn phải      |
 | blah         | blah     | blah          |
 ```
+
 Hoặc có thể sử dụng kết quả dưới đây
 
 ```md
diff --git a/vi-vn/objective-c-vi.html.markdown b/vi-vn/objective-c-vi.html.markdown
index 4656cf38..b01ce806 100644
--- a/vi-vn/objective-c-vi.html.markdown
+++ b/vi-vn/objective-c-vi.html.markdown
@@ -1,316 +1,316 @@
----

-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 macOS, iOS và các framework tương ứng của h�, Cocoa và Cocoa Touch.

-Nó là một ngôn ngữ lập trình mục đích tổng quát, hướng đối tượng có bổ sung thêm kiểu truy�n thông điệp giống Smalltalk vào ngôn ngữ lập trình C.

-

-```objective-c

-// Chú thích dòng đơn bắt đầu với //

-

-/*

-Chú thích đa dòng trông như thế này.

-*/

-

-// Nhập các headers của framework Foundation với cú pháp #import

-#import <Foundation/Foundation.h>

-#import "MyClass.h"

-

-// �ầu vào chương trình của bạn là một hàm g�i là

-// main với một kiểu trả v� kiểu integer.

-int main (int argc, const char * argv[])

-{

-    // Tạo một autorelease pool để quản lý bộ nhớ vào chương trình

-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

-

-    // Sử dụng hàm NSLog() để in ra các dòng lệnh vào console

-    NSLog(@"Hello World!"); // Print the string "Hello World!"

-

-    ///////////////////////////////////////

-    // Kiểu & Biến (Types & Variables)

-    ///////////////////////////////////////

-

-    // Khai báo số nguyên

-    int myPrimitive1  = 1;

-    long myPrimitive2 = 234554664565;

-

-    // Khai báo đối tượng

-    // �ặt dấu nháy * vào trước tên biến cho khai báo đối tượng strong

-    MyClass *myObject1 = nil;  // Strong

-    id       myObject2 = nil;  // Weak

-    // %@ là một đối tượng

-    // 'miêu tả' ('desciption') là thông lệ để trình bày giá trị của các �ối tượng

-    NSLog(@"%@ và %@", myObject1, [myObject2 description]); // In ra "(null) và (null)"

-

-    // Chuá»—i

-    NSString *worldString = @"World";

-    NSLog(@"Hello %@!", worldString); // In ra "Hello World!"

-

-    // Ký tự literals

-    NSNumber *theLetterZNumber = @'Z';

-    char theLetterZ            = [theLetterZNumber charValue];

-    NSLog(@"%c", theLetterZ);

-

-    // Số nguyên literals

-    NSNumber *fortyTwoNumber = @42;

-    int fortyTwo             = [fortyTwoNumber intValue];

-    NSLog(@"%i", fortyTwo);

-

-    NSNumber *fortyTwoUnsignedNumber = @42U;

-    unsigned int fortyTwoUnsigned    = [fortyTwoUnsignedNumber unsignedIntValue];

-    NSLog(@"%u", fortyTwoUnsigned);

-

-    NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];

-    short fortyTwoShort           = [fortyTwoShortNumber shortValue];

-    NSLog(@"%hi", fortyTwoShort);

-

-    NSNumber *fortyTwoLongNumber = @42L;

-    long fortyTwoLong            = [fortyTwoLongNumber longValue];

-    NSLog(@"%li", fortyTwoLong);

-

-    // Dấu phẩy động (floating point) literals

-    NSNumber *piFloatNumber = @3.141592654F;

-    float piFloat           = [piFloatNumber floatValue];

-    NSLog(@"%f", piFloat);

-

-    NSNumber *piDoubleNumber = @3.1415926535;

-    double piDouble                 = [piDoubleNumber doubleValue];

-    NSLog(@"%f", piDouble);

-

-    // BOOL literals

-    NSNumber *yesNumber = @YES;

-    NSNumber *noNumber  = @NO;

-

-    // �ối tượng Mảng

-    NSArray *anArray      = @[@1, @2, @3, @4];

-    NSNumber *thirdNumber = anArray[2];

-    NSLog(@"Third number = %@", thirdNumber); // In ra "Third number = 3"

-

-    // �ối tượng Từ điển

-    NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };

-    NSObject *valueObject     = aDictionary[@"A Key"];

-    NSLog(@"�ối tượng = %@", valueObject); // In ra "Object = (null)"

-

-    ///////////////////////////////////////

-    // Toán Tử (Operators)

-    ///////////////////////////////////////

-

-    // Các toán tử cũng hoạt động giống như ngôn ngữ C

-    // Ví dụ:

-    2 + 5; // => 7

-    4.2f + 5.1f; // => 9.3f

-    3 == 2; // => 0 (NO)

-    3 != 2; // => 1 (YES)

-    1 && 1; // => 1 (Logical and)

-    0 || 1; // => 1 (Logical or)

-    ~0x0F; // => 0xF0 (bitwise negation)

-    0x0F & 0xF0; // => 0x00 (bitwise AND)

-    0x01 << 1; // => 0x02 (bitwise dịch trái (bởi 1))

-

-    /////////////////////////////////////////////

-    // Cấu Trúc �i�u Khiển (Controls Structures)

-    /////////////////////////////////////////////

-

-    // Câu lệnh If-Else

-    if (NO)

-    {

-        NSLog(@"I am never run");

-    } else if (0)

-    {

-        NSLog(@"I am also never run");

-    } else

-    {

-        NSLog(@"I print");

-    }

-

-    // Câu lệnh 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;

-    }

-

-    // Câu lệnh vòng lặp While

-    int ii = 0;

-    while (ii < 4)

-    {

-        NSLog(@"%d,", ii++); // ii++ tăng dần, sau khi sử dụng giá trị của nó.

-    } // => in ra  "0,"

-      //           "1,"

-      //           "2,"

-      //           "3,"

-

-    // Câu lệnh vòng lặp For

-    int jj;

-    for (jj=0; jj < 4; jj++)

-    {

-        NSLog(@"%d,", jj);

-    } // => in ra  "0,"

-      //           "1,"

-      //           "2,"

-      //           "3,"

-

-    // Câu lệnh Foreach

-    NSArray *values = @[@0, @1, @2, @3];

-    for (NSNumber *value in values)

-    {

-        NSLog(@"%@,", value);

-    } // => in ra  "0,"

-      //           "1,"

-      //           "2,"

-      //           "3,"

-

-    // Câu lệnh Try-Catch-Finally

-    @try

-    {

-        // Your statements here

-        @throw [NSException exceptionWithName:@"FileNotFoundException"

-                            reason:@"Không Tìm Thấy Tập Tin trên Hệ Thống" userInfo:nil];

-    } @catch (NSException * e)

-    {

-        NSLog(@"Exception: %@", e);

-    } @finally

-    {

-        NSLog(@"Finally");

-    } // => in ra  "Exception: Không Tìm Thấy Tập Tin trên Hệ Thống"

-      //           "Finally"

-

-    ///////////////////////////////////////

-    // �ối Tượng (Objects)

-    ///////////////////////////////////////

-

-    // Tạo một thực thể đối tượng bằng cách phân vùng nhớ và khởi tạo đối tượng đó.

-    // Một đối tượng sẽ không thật sự hoạt động cho đến khi cả 2 bước alloc] init] được hoàn thành

-    MyClass *myObject = [[MyClass alloc] init];

-

-    // Mô hình lập trình hướng đối tượng của Objective-C dựa trên việc truy�n thông điệp (message)

-    // và các thực thể đối tượng với nhau.

-    // Trong Objective-C một đối tượng không đơn thuần g�i phương thức; nó truy�n thông điệp.

-    [myObject instanceMethodWithParameter:@"Steve Jobs"];

-

-    // D�n dẹp vùng nhớ mà bạn đã dùng ở chương trình

-    [pool drain];

-

-    // Kết thúc chương trình

-    return 0;

-}

-

-///////////////////////////////////////

-// Lớp và Hàm (Classes & Functions)

-///////////////////////////////////////

-

-// Khai báo lớp của bạn ở một tập tin header (MyClass.h):

-// Cú pháp Khai Báo Lớp:

-// @interface ClassName : ParentClassName <ImplementedProtocols>

-// {

-//    Khai báo biến thành viên;

-// }

-// -/+ (type) Khai báo method;

-// @end

-@interface MyClass : NSObject <MyProtocol>

-{

-    int count;

-    id data;

-    NSString *name;

-}

-// Ký hiệu (notation) tiện ích để tự động khởi tạo public getter và setter

-@property int count;

-@property (copy) NSString *name; // Sao chép đối tượng trong quá trình gán.

-@property (readonly) id data;    // Chỉ khai báo phương thức getter.

-

-// Phương thức

-+/- (return type)methodSignature:(Parameter Type *)parameterName;

-

-// dấu '+' cho phương thức lớp

-+ (NSString *)classMethod;

-

-// dấu '-' cho phương thức thực thể

-- (NSString *)instanceMethodWithParameter:(NSString *)string;

-- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;

-

-@end

-

-// Thực thi các phương thức trong một tập tin thực thi (MyClass.m):

-

-@implementation MyClass

-

-// G�i khi đối tượng được release

-- (void)dealloc

-{

-}

-

-// Phương thức khởi tạo (Constructors) là một cách để tạo các lớp

-// �ây là phương thức khởi tạo mặc định được g�i khi đối tượng được khởi tạo

-- (id)init

-{

-    if ((self = [super init]))

-    {

-        self.count = 1;

-    }

-    return self;

-}

-

-+ (NSString *)classMethod

-{

-    return [[self alloc] init];

-}

-

-- (NSString *)instanceMethodWithParameter:(NSString *)string

-{

-    return @"New string";

-}

-

-- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number

-{

-    return @42;

-}

-

-// Các phương thức được khai báo vào MyProtocol

-- (void)myProtocolMethod

-{

-    // câu lệnh

-}

-

-@end

-

-/*

- * Một protocol khai báo các phương thức mà có thể thực thi bởi bất kỳ lớp nào.

- * Các protocol chính chúng không phải là các lớp. Chúng chỉ đơn giản là định ra giao diện (interface)

- * mà các đối tượng khác có trách nhiệm sẽ thực thi.

- */

-@protocol MyProtocol

-    - (void)myProtocolMethod;

-@end

-

-

-

-```

-## Xem Thêm

-

-+ [Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C)

-

-+ Apple Docs':

-    + [Learning Objective-C](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/)

-

-    + [Programming With Objective-C](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html)

-

-    + [Object-Oriented Programming with Objective-C](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/OOP_ObjC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40005149)

-

-    + [Coding Guidelines for Cocoa](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/CodingGuidelines/CodingGuidelines.html)

-

-+ [iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)

+---
+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 macOS, iOS và các framework tương ứng của h�, Cocoa và Cocoa Touch.
+Nó là một ngôn ngữ lập trình mục đích tổng quát, hướng đối tượng có bổ sung thêm kiểu truy�n thông điệp giống Smalltalk vào ngôn ngữ lập trình C.
+
+```objective-c
+// Chú thích dòng đơn bắt đầu với //
+
+/*
+Chú thích đa dòng trông như thế này.
+*/
+
+// Nhập các headers của framework Foundation với cú pháp #import
+#import <Foundation/Foundation.h>
+#import "MyClass.h"
+
+// �ầu vào chương trình của bạn là một hàm g�i là
+// main với một kiểu trả v� kiểu integer.
+int main (int argc, const char * argv[])
+{
+    // Tạo một autorelease pool để quản lý bộ nhớ vào chương trình
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+
+    // Sử dụng hàm NSLog() để in ra các dòng lệnh vào console
+    NSLog(@"Hello World!"); // Print the string "Hello World!"
+
+    ///////////////////////////////////////
+    // Kiểu & Biến (Types & Variables)
+    ///////////////////////////////////////
+
+    // Khai báo số nguyên
+    int myPrimitive1  = 1;
+    long myPrimitive2 = 234554664565;
+
+    // Khai báo đối tượng
+    // �ặt dấu nháy * vào trước tên biến cho khai báo đối tượng strong
+    MyClass *myObject1 = nil;  // Strong
+    id       myObject2 = nil;  // Weak
+    // %@ là một đối tượng
+    // 'miêu tả' ('desciption') là thông lệ để trình bày giá trị của các �ối tượng
+    NSLog(@"%@ và %@", myObject1, [myObject2 description]); // In ra "(null) và (null)"
+
+    // Chuá»—i
+    NSString *worldString = @"World";
+    NSLog(@"Hello %@!", worldString); // In ra "Hello World!"
+
+    // Ký tự literals
+    NSNumber *theLetterZNumber = @'Z';
+    char theLetterZ            = [theLetterZNumber charValue];
+    NSLog(@"%c", theLetterZ);
+
+    // Số nguyên literals
+    NSNumber *fortyTwoNumber = @42;
+    int fortyTwo             = [fortyTwoNumber intValue];
+    NSLog(@"%i", fortyTwo);
+
+    NSNumber *fortyTwoUnsignedNumber = @42U;
+    unsigned int fortyTwoUnsigned    = [fortyTwoUnsignedNumber unsignedIntValue];
+    NSLog(@"%u", fortyTwoUnsigned);
+
+    NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
+    short fortyTwoShort           = [fortyTwoShortNumber shortValue];
+    NSLog(@"%hi", fortyTwoShort);
+
+    NSNumber *fortyTwoLongNumber = @42L;
+    long fortyTwoLong            = [fortyTwoLongNumber longValue];
+    NSLog(@"%li", fortyTwoLong);
+
+    // Dấu phẩy động (floating point) literals
+    NSNumber *piFloatNumber = @3.141592654F;
+    float piFloat           = [piFloatNumber floatValue];
+    NSLog(@"%f", piFloat);
+
+    NSNumber *piDoubleNumber = @3.1415926535;
+    double piDouble                 = [piDoubleNumber doubleValue];
+    NSLog(@"%f", piDouble);
+
+    // BOOL literals
+    NSNumber *yesNumber = @YES;
+    NSNumber *noNumber  = @NO;
+
+    // �ối tượng Mảng
+    NSArray *anArray      = @[@1, @2, @3, @4];
+    NSNumber *thirdNumber = anArray[2];
+    NSLog(@"Third number = %@", thirdNumber); // In ra "Third number = 3"
+
+    // �ối tượng Từ điển
+    NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
+    NSObject *valueObject     = aDictionary[@"A Key"];
+    NSLog(@"�ối tượng = %@", valueObject); // In ra "Object = (null)"
+
+    ///////////////////////////////////////
+    // Toán Tử (Operators)
+    ///////////////////////////////////////
+
+    // Các toán tử cũng hoạt động giống như ngôn ngữ C
+    // Ví dụ:
+    2 + 5; // => 7
+    4.2f + 5.1f; // => 9.3f
+    3 == 2; // => 0 (NO)
+    3 != 2; // => 1 (YES)
+    1 && 1; // => 1 (Logical and)
+    0 || 1; // => 1 (Logical or)
+    ~0x0F; // => 0xF0 (bitwise negation)
+    0x0F & 0xF0; // => 0x00 (bitwise AND)
+    0x01 << 1; // => 0x02 (bitwise dịch trái (bởi 1))
+
+    /////////////////////////////////////////////
+    // Cấu Trúc �i�u Khiển (Controls Structures)
+    /////////////////////////////////////////////
+
+    // Câu lệnh If-Else
+    if (NO)
+    {
+        NSLog(@"I am never run");
+    } else if (0)
+    {
+        NSLog(@"I am also never run");
+    } else
+    {
+        NSLog(@"I print");
+    }
+
+    // Câu lệnh 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;
+    }
+
+    // Câu lệnh vòng lặp While
+    int ii = 0;
+    while (ii < 4)
+    {
+        NSLog(@"%d,", ii++); // ii++ tăng dần, sau khi sử dụng giá trị của nó.
+    } // => in ra  "0,"
+      //           "1,"
+      //           "2,"
+      //           "3,"
+
+    // Câu lệnh vòng lặp For
+    int jj;
+    for (jj=0; jj < 4; jj++)
+    {
+        NSLog(@"%d,", jj);
+    } // => in ra  "0,"
+      //           "1,"
+      //           "2,"
+      //           "3,"
+
+    // Câu lệnh Foreach
+    NSArray *values = @[@0, @1, @2, @3];
+    for (NSNumber *value in values)
+    {
+        NSLog(@"%@,", value);
+    } // => in ra  "0,"
+      //           "1,"
+      //           "2,"
+      //           "3,"
+
+    // Câu lệnh Try-Catch-Finally
+    @try
+    {
+        // Your statements here
+        @throw [NSException exceptionWithName:@"FileNotFoundException"
+                            reason:@"Không Tìm Thấy Tập Tin trên Hệ Thống" userInfo:nil];
+    } @catch (NSException * e)
+    {
+        NSLog(@"Exception: %@", e);
+    } @finally
+    {
+        NSLog(@"Finally");
+    } // => in ra  "Exception: Không Tìm Thấy Tập Tin trên Hệ Thống"
+      //           "Finally"
+
+    ///////////////////////////////////////
+    // �ối Tượng (Objects)
+    ///////////////////////////////////////
+
+    // Tạo một thực thể đối tượng bằng cách phân vùng nhớ và khởi tạo đối tượng đó.
+    // Một đối tượng sẽ không thật sự hoạt động cho đến khi cả 2 bước alloc] init] được hoàn thành
+    MyClass *myObject = [[MyClass alloc] init];
+
+    // Mô hình lập trình hướng đối tượng của Objective-C dựa trên việc truy�n thông điệp (message)
+    // và các thực thể đối tượng với nhau.
+    // Trong Objective-C một đối tượng không đơn thuần g�i phương thức; nó truy�n thông điệp.
+    [myObject instanceMethodWithParameter:@"Steve Jobs"];
+
+    // D�n dẹp vùng nhớ mà bạn đã dùng ở chương trình
+    [pool drain];
+
+    // Kết thúc chương trình
+    return 0;
+}
+
+///////////////////////////////////////
+// Lớp và Hàm (Classes & Functions)
+///////////////////////////////////////
+
+// Khai báo lớp của bạn ở một tập tin header (MyClass.h):
+// Cú pháp Khai Báo Lớp:
+// @interface ClassName : ParentClassName <ImplementedProtocols>
+// {
+//    Khai báo biến thành viên;
+// }
+// -/+ (type) Khai báo method;
+// @end
+@interface MyClass : NSObject <MyProtocol>
+{
+    int count;
+    id data;
+    NSString *name;
+}
+// Ký hiệu (notation) tiện ích để tự động khởi tạo public getter và setter
+@property int count;
+@property (copy) NSString *name; // Sao chép đối tượng trong quá trình gán.
+@property (readonly) id data;    // Chỉ khai báo phương thức getter.
+
+// Phương thức
++/- (return type)methodSignature:(Parameter Type *)parameterName;
+
+// dấu '+' cho phương thức lớp
++ (NSString *)classMethod;
+
+// dấu '-' cho phương thức thực thể
+- (NSString *)instanceMethodWithParameter:(NSString *)string;
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
+
+@end
+
+// Thực thi các phương thức trong một tập tin thực thi (MyClass.m):
+
+@implementation MyClass
+
+// G�i khi đối tượng được release
+- (void)dealloc
+{
+}
+
+// Phương thức khởi tạo (Constructors) là một cách để tạo các lớp
+// �ây là phương thức khởi tạo mặc định được g�i khi đối tượng được khởi tạo
+- (id)init
+{
+    if ((self = [super init]))
+    {
+        self.count = 1;
+    }
+    return self;
+}
+
++ (NSString *)classMethod
+{
+    return [[self alloc] init];
+}
+
+- (NSString *)instanceMethodWithParameter:(NSString *)string
+{
+    return @"New string";
+}
+
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
+{
+    return @42;
+}
+
+// Các phương thức được khai báo vào MyProtocol
+- (void)myProtocolMethod
+{
+    // câu lệnh
+}
+
+@end
+
+/*
+ * Một protocol khai báo các phương thức mà có thể thực thi bởi bất kỳ lớp nào.
+ * Các protocol chính chúng không phải là các lớp. Chúng chỉ đơn giản là định ra giao diện (interface)
+ * mà các đối tượng khác có trách nhiệm sẽ thực thi.
+ */
+@protocol MyProtocol
+    - (void)myProtocolMethod;
+@end
+
+
+
+```
+## Xem Thêm
+
++ [Wikipedia Objective-C](http://en.wikipedia.org/wiki/Objective-C)
+
++ Apple Docs':
+    + [Learning Objective-C](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/)
+
+    + [Programming With Objective-C](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html)
+
+    + [Object-Oriented Programming with Objective-C](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/OOP_ObjC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40005149)
+
+    + [Coding Guidelines for Cocoa](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/CodingGuidelines/CodingGuidelines.html)
+
++ [iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
diff --git a/vi-vn/xml-vi.html.markdown b/vi-vn/xml-vi.html.markdown
new file mode 100644
index 00000000..7a74c154
--- /dev/null
+++ b/vi-vn/xml-vi.html.markdown
@@ -0,0 +1,170 @@
+---
+language: xml
+filename: learnxml.xml
+contributors:
+  - ['João Farias', 'https://github.com/JoaoGFarias']
+  - ['Rachel Stiyer', 'https://github.com/rstiyer']
+  - ['Deepanshu Utkarsh', 'https://github.com/duci9y']
+translators:
+  - ['Thanh Duy Phan', 'https://github.com/thanhpd']
+lang: vi-vn
+---
+
+XML là ngôn ngữ đánh dấu được thiết kế để lưu trữ và truy�n tải dữ liệu. Nó có thể được đ�c hiểu bởi cả ngư�i và máy.
+
+Không giống như HTML, XML không biểu đạt cách hiển thị hoặc định dạng dữ liệu, chỉ chứa dữ liệu mà thôi.
+
+Có những sự khác biệt rõ ràng giữa **nội dung** và **các đánh dấu**. Nói vắn tắt thì nội dung có thể là bất cứ gì trong khi các đánh dấu được định nghĩa trước.
+
+## Một số định nghĩa và giới thiệu
+
+Các XML Document (Văn bản XML) được cấu thành bởi các _elements (phần tử)_ và chúng có thể có các _attributes (thuộc tính)_ để mô tả, đồng th�i cũng có thể chứa các nội dung theo ngữ cảnh và một hoặc nhi�u phần tử con. Tất cả XML document phải có một phần tử gốc đóng vai trò tổ tiên cho tất cả các phần tử khác trong văn bản.
+
+Các trình phân tích cú pháp XML (XML Parser) được thiết kế để phân tích rất chặt chẽ, và sẽ dừng phân tích các văn bản không đúng định dạng. Vì vậy cần đảm bảo tất cả văn bản XML tuân theo [Các luật cú pháp XML](http://www.w3schools.com/xml/xml_syntax.asp).
+
+```xml
+<!-- �ây là một bình luận. Nó không được phép chứa hai dấu gạch ngang (-) liên tiếp -->
+<!-- Comments can span
+  trải dài nhi�u dòngmultiple lines -->
+
+<!-- Element - Phần tử -->
+<!-- Một element là thành phần XML cơ bản nhất. Có hai loại, thử nhất là rỗng nô -->
+<element1 thuoc-tinh="gia trialue" /> <Các element rỗng không chứa bất kì nội dung gìtent -->
+<!-- và không rỗng nội dung: -->
+<element2 thuoc-tinh="gia tri">Ná»™i dung</element2>
+<!-- Tên của element chỉ được phép chứa chữ cái và chữ số -->
+
+<empty /> <!-- Một element có thể là một element với tag rỗng… -->
+<!-- …không chứa bất cứ nội dung gì và chỉ là markup đơn thuần. -->
+
+<notempty> <!-- Hoặc nó chứa một tag bắt đầu… -->
+  <!-- …nội dung… -->
+</notempty> <!-- và kết thúc với tag đóng. -->
+
+<!-- Tên element phân biệt chữ hoa và thư�ng. -->
+<element />
+<!-- không giống như -->
+<eLEMENT />
+
+<!-- Attribute - Thuộc tính -->
+<!-- Một thuộc tính là một cặp key-value và tồn tại bên trong element. -->
+<element thuoctinh="giatri" thuoctinhkhac="giatrikhac" nhieugiatri="danhsach phanbiet bangdaucach" />
+<!-- Một thuộc tính chỉ xuất hiện một lần trong một element. Nó chỉ chứa một giá trị.
+  Một cách giải quyết là sử dụng danh sách giá trị được phân biệt bởi dấu cách. -->
+
+<!-- Nesting element - Phần tử lồng nhau -->
+<!-- Nội dung một element có thể chứa các element khác -->
+<cha>
+  <con>Text</con>
+  <elementrong />
+</cha>
+<!-- Danh pháp cây tiêu chuẩn được tuân theo. Mỗi phần tử được g�i là một nút.
+   Phần tử cấp trên là cha, phần tử cấp dưới là con.
+   Các element trong cùng một element cha có mức tương đương nhau như anh chị em. -->
+
+<!-- XML bảo lưu dấu cách. -->
+<child>
+  Văn bản
+</child>
+<!-- sẽ không giống như -->
+<child>Văn bản</child>
+```
+
+## Một văn bản XML - XML document
+
+�ây là thứ làm cho XML rất linh hoạt do nó giúp con ngư�i cũng đ�c được. Văn bản sau đây cho ta biết nó định nghĩa một hiệu sách bản ba quyển sách, trong đó có một cuốn tên Learning XML bởi Erik T. Ray. Tất cả những việc này chưa cần phải sử dụng XML Parser.
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- �ây là phần mở đầu, không bắt buộc cần nhưng nên có -->
+<hieusach>
+  <sach danhmuc="NAUAN">
+    <tieude lang="en">Everyday Italian</tieude>
+    <tacgia>Giada De Laurentiis</tacgia>
+    <nam>2005</nam>
+    <giaban>30.00</giaban>
+  </sach>
+  <sach danhmuc="TREEM">
+    <tieude lang="en">Harry Potter</tieude>
+    <tacgia>J K. Rowling</tacgia>
+    <nam>2005</nam>
+    <giaban>29.99</giaban>
+  </sach>
+  <sach danhmuc="WEB">
+    <tieude lang="en">Learning XML</tieude>
+    <tacgia>Erik T. Ray</tacgia>
+    <nam>2003</nam>
+    <giaban>39.95</giaban>
+  </sach>
+</hieusach>
+```
+
+## Tính đúng đắn và việc xác minh
+
+Một văn bản XML là _đúng đắn (well-formed)_ nếu nó có cú pháp chính xác. Ty nhiên, ta có thể thêm nhi�u ràng buộc vào văn bản, sử dụng Document Type Definition (DTD) - �ịnh dạng loại văn bản. Một văn bản mà các phần tử và thuộc tính được khai báo trong một DT� và tuân theo ngữ pháp được đưa ra trong DTD đó được g�i là _valid - được chấp nhận_ và tuân theo DTD bên cạnh việc đúng đắn.
+
+```xml
+<!-- Khai báo DTD lấy từ tệp bên ngoài: -->
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE hieusach SYSTEM "Hieusach.dtd">
+<!-- Khai báo hieusach là phần tử gốc và 'Hieusach.dtd' là đư�ng dẫn
+  tới tệp DTD. -->
+<hieusach>
+  <sach danhmuc="NAUAN">
+    <tieude lang="en">Everyday Italian</tieude>
+    <tacgia>Giada De Laurentiis</tacgia>
+    <nam>2005</nam>
+    <giaban>30.00</giaban>
+  </sach>
+</hieusach>
+
+<!-- Tệp DTD: -->
+<!ELEMENT hieusach (sach+)>
+<!-- Element hieusach có thể chứa một hoặc nhi�u element sach. -->
+<!ELEMENT sach (tieude, giaban)>
+<!-- Mỗi sach cần có các element con tên tieude và giaban. -->
+<!ATTLIST sach danhmuc CDATA "Vanhoc">
+<!-- Mỗi sach cần có một thuộc tính danhmuc. Nếu không có, giá trị mặc định
+  sẽ là 'Vanhoc'. -->
+<!ELEMENT tieude (#PCDATA)>
+<!-- Element tieude chỉ được chứa nội dung dữ liệu kĩ tự được phân tích.
+Nói cách khác, nó có thể
+  chỉ chứa văn bản được phân tích bởi parser và không được phép chứa element con
+  So sánh với CDATA, hay dữ liệu kí tự -->
+<!ELEMENT giaban (#PCDATA)>
+]>
+
+<!-- DTD có thể được khai báo bên trong chính tệp XML.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE hieusach [
+<!ELEMENT hieusach (sach+)>
+<!ELEMENT sach (tieude, giaban)>
+<!ATTLIST sach danhmuc CDATA "Vanhoc">
+<!ELEMENT tieude (#PCDATA)>
+<!ELEMENT giaban (#PCDATA)>
+]>
+
+<hieusach>
+  <sach danhmuc="NAUAN">
+    <tieude lang="en">Everyday Italian</tieude>
+    <giaban>30.00</giaban>
+  </sach>
+</hieusach>
+```
+
+## DTD Compatibility and XML Schema Definitions (Tương thích DTD và định nghĩa XML Schema)
+
+Hỗ trợ cho DTD khá nhi�u do chúng đã quá cũ. Tuy nhiên, nhi�u tính năng hiện đại của XML như namespace không được hỗ trợ bởi DTD. XML Schema Definition (XSD) - �ịnh nghĩa lược đồ XML được coi như sẽ thay thế DTD để định nghĩa cấu trúc ngữ pháp của văn bản XML.
+
+## Tra cứu
+
+- [Validate your XML (Xác minh XML)](http://www.xmlvalidation.com)
+
+## ��c thêm
+
+- [Hướng dẫn XML Schema Definitions](http://www.w3schools.com/schema/)
+- [Hướng dẫn DTD](http://www.w3schools.com/xml/xml_dtd_intro.asp)
+- [Hướng dẫn XML](http://www.w3schools.com/xml/default.asp)
+- [Dùng XPath queries để phân tích cú pháp XML](http://www.w3schools.com/xml/xml_xpath.asp)
diff --git a/vim.html.markdown b/vim.html.markdown
index 55649cb2..fb2fc81f 100644
--- a/vim.html.markdown
+++ b/vim.html.markdown
@@ -3,6 +3,7 @@ category: tool
 tool: vim
 contributors:
     - ["RadhikaG", "https://github.com/RadhikaG"]
+    - ["kaymmm", "https://github.com/kaymmm"]
 filename: LearnVim.txt
 ---
 
@@ -19,70 +20,71 @@ specific points in the file, and for fast editing.
 ## Basics of navigating Vim
 
 ```
-    vim <filename>   # Open <filename> in vim
-    :help <topic>    # Open up built-in help docs about <topic> if any exists
-    :q               # Quit vim
-    :w               # Save current file
-    :wq              # Save file and quit vim
-    ZZ               # Save file and quit vim
-    :q!              # Quit vim without saving file
-                     # ! *forces* :q to execute, hence quiting vim without saving
-    ZQ               # Quit vim without saving file
-    :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
-
-    Ctrl+B 	         # Move back one full screen
-    Ctrl+F 	         # Move forward one full screen
-    Ctrl+D 	         # Move forward 1/2 a screen
-    Ctrl+U           # Move back 1/2 a screen
+    vim <filename>    # Open <filename> in vim
+    :help <topic>     # Open up built-in help docs about <topic> if any exists
+    :q                # Quit vim
+    :w                # Save current file
+    :wq               # Save file and quit vim
+    ZZ                # Save file and quit vim
+    :q!               # Quit vim without saving file
+                      # ! *forces* :q to execute, hence quitting vim without saving
+    ZQ                # Quit vim without saving file
+    :x                # Save file(only when the file is modified) and quit vim
+
+    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
+
+    Ctrl+B            # Move back one full screen
+    Ctrl+F            # Move forward one full screen
+    Ctrl+D            # Move forward 1/2 a screen
+    Ctrl+U            # Move back 1/2 a screen
 
     # Moving within the line
 
-    0                # Move to beginning of line
-    $                # Move to end of line
-    ^                # Move to first non-blank character in 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 occurrences of word after cursor
-    ?word            # Highlights all occurrences of word before cursor
-    n                # Moves cursor to next occurrence of word after search
-    N                # Moves cursor to previous occerence of word
+    /word             # Highlights all occurrences of word after cursor
+    ?word             # Highlights all occurrences of word before cursor
+    n                 # Moves cursor to next occurrence of word after search
+    N                 # Moves cursor to previous occurrence 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
-    :%s/\n/\r/g      # Replace new line characters with new line characters
+    :%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
+    :%s/\n/\r/g       # Replace new line characters with new line characters
+    :'<,'>s/foo/bar/g # Change 'foo' to 'bar on every line in the current visual selection
 
     # Jumping to characters
 
-    f<character>     # Jump forward and land on <character>
-    t<character>     # Jump forward and land right before <character>
+    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 <
+    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
+    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
+    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
 ```
 
 ## Help docs:
@@ -104,21 +106,28 @@ Vim is based on the concept on **modes**.
 - 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
+    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
+                      # Operations use the vim register by default
+                      # Think of it as vim's private clipboard
 
-    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
+                      # Yank ~ copy text into vim register
+    y                 # Yank whatever is selected
+    yy                # Yank the current line
+
+                      # Delete ~ yank text and delete from file
+    d                 # Delete whatever is selected
+    dd                # Delete the current line
+
+    p                 # Paste text in vim register after the current cursor position
+    P                 # Paste text in vim register before the current cursor position
+
+    x                 # Delete character under current cursor position
 ```
 
 ## The 'Grammar' of vim
@@ -135,64 +144,75 @@ A few important examples of 'Verbs', 'Modifiers', and 'Nouns':
 ```
     # 'Verbs'
 
-    d                # Delete
-    c                # Change
-    y                # Yank (copy)
-    v                # Visually select
+    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
+    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
+    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
+    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
-    :set syntax=c    # Set syntax highlighting to 'c'
-    :sort            # Sort all lines
-    :sort!           # Sort all lines in reverse
-    :sort u          # Sort all lines and remove duplicates
-    ~                # Toggle letter case of selected text
-    u                # Selected text to lower case
-    U                # Selected text to upper case
-    J                # Join the current line with the next line
+    >                 # 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
+    :set syntax=c     # Set syntax highlighting to 'c'
+    :sort             # Sort all lines
+    :sort!            # Sort all lines in reverse
+    :sort u           # Sort all lines and remove duplicates
+    ~                 # Toggle letter case of selected text
+    u                 # Selected text to lower case
+    U                 # Selected text to upper case
+    J                 # Join the current line with the next line
     
     # Fold text
-    zf               # Create fold from selected text
-    zo               # Open current fold
-    zc               # Close current fold
-    zR               # Open all folds
-    zM               # Close all folds
+    zf                # Create fold from selected text
+    zd                # Delete fold on the current line
+    zD                # Recursively delete nested or visually selected folds
+    zE                # Eliminate all folds in the window
+    zo                # Open current fold
+    zO                # Recursively open nested or visually selected folds
+    zc                # Close current fold
+    zC                # Recursively close nested or visually selected folds
+    zR                # Open all folds
+    zM                # Close all folds
+    za                # Toggle open/close current fold
+    zA                # Recursively toggle open/close nested fold
+    [z                # Move to the start of the current fold
+    ]z                # Move to the end of the current fold
+    zj                # Move to the start of the next fold
+    zk                # Move to the end of the previous fold
 ```
 
 ## Macros
@@ -203,9 +223,9 @@ 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
+    qa                # Start recording a macro named 'a'
+    q                 # Stop recording
+    @a                # Play back the macro
 ```
 
 ### Configuring ~/.vimrc
diff --git a/vimscript.html.markdown b/vimscript.html.markdown
index c2934af8..04fee6fa 100644
--- a/vimscript.html.markdown
+++ b/vimscript.html.markdown
@@ -11,7 +11,7 @@ contributors:
 " ##############
 "
 " Vim script (also called VimL) is the subset of Vim's ex-commands which
-" supplies a number of features one one would expect from a scripting language,
+" supplies a number of features one would expect from a scripting language,
 " such as values, variables, functions or loops. Always keep in the back of
 " your mind that a Vim script file is just a sequence of ex-commands. It is
 " very common for a script to mix programming-language features and raw
@@ -38,11 +38,11 @@ echo 'Hello' | echo 'world!'
 " Putting a comment after a command usually works
 pwd                   " Displays the current working directory
 
-" Except for some commands it does not; use the command delemiter before the
+" Except for some commands it does not; use the command delimiter before the
 " comment (echo assumes that the quotation mark begins a string)
 echo 'Hello world!'  | " Displays a message
 
-" Line breaks can be escaped by pacing a backslash as the first non-whitespace
+" Line breaks can be escaped by placing a backslash as the first non-whitespace
 " character on the *following* line. Only works in script files, not on the
 " command line
 echo " Hello
@@ -98,7 +98,7 @@ echo  v:false     | " Evaluates to 0 or the string 'v:false'
 " Boolean values can result from comparison of two objects.
 
 echo  x == y             | " Equality by value
-echo  x != y             | " Unequality
+echo  x != y             | " Inequality
 echo  x >  y             | " Greater than
 echo  x >= y             | " Greater than or equal
 echo  x <  y             | " Smaller than
@@ -110,7 +110,7 @@ echo  x isnot y          | " Instance non-identity (lists and dictionaries)
 " echo 'a' < 'b'. Case sensitivity depends on the setting of 'ignorecase'
 "
 " Explicit case-sensitivity is specified by appending '#' (match case) or '?'
-" (ignore case) to the operator. Prefer explicity case sensitivity when writing
+" (ignore case) to the operator. Prefer explicitly case sensitivity when writing
 " portable scripts.
 
 echo  'a' <  'B'         | " True or false depending on 'ignorecase'
@@ -315,7 +315,7 @@ let s:isNumber = {x -> type(x) == type(0)}   | " Local: any name allowed
 " Assign values of list to multiple variables (number of items must match)
 let [x, y] = [1, 2]
 
-" Assign the remainer to a rest variable (note the semicolon)
+" Assign the remainder to a rest variable (note the semicolon)
 let [mother, father; children] = ['Alice', 'Bob', 'Carol', 'Dennis', 'Emily']
 
 
@@ -610,7 +610,7 @@ echo  exists(':Make')              | " Command
 echo  exists("#CursorHold")        | " Auto-command defined for event
 echo  exists("#BufReadPre#*.gz")   | " Event and pattern
 echo  exists("#filetypeindent")    | " Auto-command group
-echo  exists("##ColorScheme")      | " Auto-commnand supported for event
+echo  exists("##ColorScheme")      | " Auto-command supported for event
 
 " Various dynamic values (see |expand()|)
 echo  expand('%')                  | " Current file name
diff --git a/visualbasic.html.markdown b/visualbasic.html.markdown
index 221c1eb3..b79017dc 100644
--- a/visualbasic.html.markdown
+++ b/visualbasic.html.markdown
@@ -5,7 +5,7 @@ contributors:
 filename: learnvisualbasic.vb
 ---
 
-```
+```visualbasic
 Module Module1
 
     Sub Main()
@@ -102,7 +102,8 @@ Module Module1
         Console.WriteLine("Hello, What is your name? ") 'Ask the user their name.
         username = Console.ReadLine() 'Stores the users name.
         Console.WriteLine("Hello " + username) 'Output is Hello 'Their name'
-        Console.ReadLine() 'Outputs the above.
+        Console.ReadLine() 'Pauses the execution for user to read 
+       
         'The above will ask you a question followed by printing your answer.
         'Other variables include Integer and we use Integer for whole numbers.
     End Sub
diff --git a/vyper.html.markdown b/vyper.html.markdown
index fec1a79f..bad0c31e 100644
--- a/vyper.html.markdown
+++ b/vyper.html.markdown
@@ -181,7 +181,7 @@ def _changeTaskStatus( \
         _status: uint256, \
     ):
     # backslashes (\) allow for multi-line code
-    # Natspec comments are particularly helpful for documentation and readibility
+    # Natspec comments are particularly helpful for documentation and readability
     # Natspec can be included using familiar Pythonic docstring syntax
     """
     @notice
@@ -429,16 +429,16 @@ struct Struct:
     owner: address
     _balance: uint256 # balance is a reserved keyword, is a member for addresses
 
-exampleStuct: Struct
+exampleStruct: Struct
 
 @public
 def foo() -> uint256:
-    self.exampleStuct = Struct({owner: msg.sender, _balance: 5})
-    self.exampleStuct._balance = 10
-    self.exampleStuct._balance = 5 # set to new value
-    clear(self.exampleStuct._balance)
-    clear(self.exampleStuct)
-    return self.exampleStuct._balance
+    self.exampleStruct = Struct({owner: msg.sender, _balance: 5})
+    self.exampleStruct._balance = 10
+    self.exampleStruct._balance = 5 # set to new value
+    clear(self.exampleStruct._balance)
+    clear(self.exampleStruct)
+    return self.exampleStruct._balance
 
 
 # Data locations: Memory vs. storage vs. calldata - all complex types (arrays,
@@ -510,7 +510,7 @@ def increment(x: uint256, y: uint256) -> (uint256, uint256):
     y += 1
     return  (x, y)
 
-# Call previous functon
+# Call previous function
 @public
 @constant
 def willCall() -> (uint256, uint256):
@@ -679,7 +679,7 @@ sha3(concat("ab", "cd")) # returns bytes32
 
 # Step 1. Commit
 # Place a commitment by sending output of `sha3()`
-sha3("a secret"); # btyes32 commit
+sha3("a secret"); # bytes32 commit
 sha3(concat("secret", "other secret", "salt")); # commit multiple things
 # The `sha3()` calculation should occur off-chain, only the bytes32
 #   output should be inputted into some `commit()` function
diff --git a/wasm.html.markdown b/wasm.html.markdown
index 81344abe..4de7107f 100644
--- a/wasm.html.markdown
+++ b/wasm.html.markdown
@@ -42,7 +42,7 @@ contributors:
     ;; To set them to a value, we can use <type>.const:
 
     (local.set $int_32 (i32.const 16))
-    (local.set $int_32 (i64.const 128))
+    (local.set $int_64 (i64.const 128))
     (local.set $float_32 (f32.const 3.14))
     (local.set $float_64 (f64.const 1.28))
   )
diff --git a/wolfram.html.markdown b/wolfram.html.markdown
index 5fddbc82..fa8ee078 100644
--- a/wolfram.html.markdown
+++ b/wolfram.html.markdown
@@ -14,7 +14,7 @@ Wolfram Language has several interfaces:
 
 The code in this example can be typed in to any interface and edited with Wolfram Workbench. Loading directly into Mathematica may be awkward because the file contains no cell formatting information (which would make the file a huge mess to read as text) - it can be viewed/edited but may require some setting up.
 
-```
+```mathematica
 (* This is a comment *)
 
 (* In Mathematica instead of using these comments you can create a text cell
diff --git a/xml.html.markdown b/xml.html.markdown
index 2a258d94..630e4c90 100644
--- a/xml.html.markdown
+++ b/xml.html.markdown
@@ -165,7 +165,7 @@ Support for DTDs is ubiquitous because they are so old. Unfortunately, modern XM
 
 ## Further Reading
 
-* [XML Schema Definitions Tutorial](http://www.w3schools.com/schema/)
+* [XML Schema Definitions Tutorial](https://www.w3schools.com/xml/schema_intro.asp)
 * [DTD Tutorial](http://www.w3schools.com/xml/xml_dtd_intro.asp)
 * [XML Tutorial](http://www.w3schools.com/xml/default.asp)
 * [Using XPath queries to parse XML](http://www.w3schools.com/xml/xml_xpath.asp)
diff --git a/yaml.html.markdown b/yaml.html.markdown
index fa7485b8..6901695c 100644
--- a/yaml.html.markdown
+++ b/yaml.html.markdown
@@ -2,8 +2,10 @@
 language: yaml
 filename: learnyaml.yaml
 contributors:
+
 - [Leigh Brenecki, 'https://leigh.net.au']
 - [Suhas SG, 'https://github.com/jargnar']
+
 ---
 
 YAML is a data serialisation language designed to be directly writable and
@@ -17,6 +19,7 @@ YAML doesn't allow literal tab characters for indentation.
 ---  # document start
 
 # Comments in YAML look like this.
+# YAML supports single-line comments.
 
 ################
 # SCALAR TYPES #
@@ -28,11 +31,24 @@ key: value
 another_key: Another value goes here.
 a_number_value: 100
 scientific_notation: 1e+12
-# The number 1 will be interpreted as a number, not a boolean. if you want
-# it to be interpreted as a boolean, use true
+hex_notation: 0x123  # evaluates to 291
+octal_notation: 0123 # evaluates to 83
+
+# The number 1 will be interpreted as a number, not a boolean. 
+# If you want it to be interpreted as a boolean, use true.
 boolean: true
 null_value: null
+another_null_value: ~
 key with spaces: value
+
+# Yes and No (doesn't matter the case) will be evaluated to boolean 
+# true and false values respectively.
+# To use the actual value use single or double quotes.
+no: no            # evaluates to "no": false
+yes: No           # evaluates to "yes": false
+not_enclosed: yes # evaluates to "not_enclosed": true
+enclosed: "yes"   # evaluates to "enclosed": yes
+
 # Notice that strings don't need to be quoted. However, they can be.
 however: 'A string, enclosed in quotes.'
 'Keys can be quoted too.': "Useful if you want to put a ':' in your key."
@@ -41,25 +57,49 @@ double quotes: "have many: \", \0, \t, \u263A, \x0d\x0a == \r\n, and more."
 # UTF-8/16/32 characters need to be encoded
 Superscript two: \u00B2
 
-# Multiple-line strings can be written either as a 'literal block' (using |),
+# Special characters must be enclosed in single or double quotes
+special_characters: "[ John ] & { Jane } - <Doe>"
+
+# Multiple-line strings can be written either as a 'literal block' (using |), 
 # or a 'folded block' (using '>').
+# Literal block turn every newline within the string into a literal newline (\n).
+# Folded block removes newlines within the string.
 literal_block: |
-    This entire block of text will be the value of the 'literal_block' key,
-    with line breaks being preserved.
+  This entire block of text will be the value of the 'literal_block' key,
+  with line breaks being preserved.
 
-    The literal continues until de-dented, and the leading indentation is
-    stripped.
+  The literal continues until de-dented, and the leading indentation is
+  stripped.
 
-        Any lines that are 'more-indented' keep the rest of their indentation -
-        these lines will be indented by 4 spaces.
+      Any lines that are 'more-indented' keep the rest of their indentation -
+      these lines will be indented by 4 spaces.
 folded_style: >
-    This entire block of text will be the value of 'folded_style', but this
-    time, all newlines will be replaced with a single space.
+  This entire block of text will be the value of 'folded_style', but this
+  time, all newlines will be replaced with a single space.
 
-    Blank lines, like above, are converted to a newline character.
+  Blank lines, like above, are converted to a newline character.
 
-        'More-indented' lines keep their newlines, too -
-        this text will appear over two lines.
+      'More-indented' lines keep their newlines, too -
+      this text will appear over two lines.
+
+# |- and >- removes the trailing blank lines (also called literal/block "strip")
+literal_strip: |-
+  This entire block of text will be the value of the 'literal_block' key,
+  with trailing blank line being stripped.
+block_strip: >-
+  This entire block of text will be the value of 'folded_style', but this
+  time, all newlines will be replaced with a single space and 
+  trailing blank line being stripped.
+
+# |+ and >+ keeps trailing blank lines (also called literal/block "keep")
+literal_keep: |+
+  This entire block of text will be the value of the 'literal_block' key,
+  with trailing blank line being kept.
+
+block_keep: >+
+  This entire block of text will be the value of 'folded_style', but this
+  time, all newlines will be replaced with a single space and 
+  trailing blank line being kept.
 
 ####################
 # COLLECTION TYPES #
@@ -87,7 +127,7 @@ a_nested_map:
 # An example
 ? - Manchester United
   - Real Madrid
-: [2001-01-01, 2002-02-02]
+: [ 2001-01-01, 2002-02-02 ]
 
 # Sequences (equivalent to lists or arrays) look like this
 # (note that the '-' counts as indentation):
@@ -98,24 +138,26 @@ a_sequence:
   - Item 4
   - key: value
     another_key: another_value
-  -
-    - This is a sequence
+  - - This is a sequence
     - inside another sequence
   - - - Nested sequence indicators
       - can be collapsed
 
 # Since YAML is a superset of JSON, you can also write JSON-style maps and
 # sequences:
-json_map: {"key": "value"}
-json_seq: [3, 2, 1, "takeoff"]
-and quotes are optional: {key: [3, 2, 1, takeoff]}
+json_map: { "key": "value" }
+json_seq: [ 3, 2, 1, "takeoff" ]
+and quotes are optional: { key: [ 3, 2, 1, takeoff ] }
 
 #######################
 # EXTRA YAML FEATURES #
 #######################
 
 # YAML also has a handy feature called 'anchors', which let you easily duplicate
-# content across your document. Both of these keys will have the same value:
+# content across your document.
+# Anchors identified by & character which define the value.
+# Aliases identified by * character which acts as "see above" command.
+# Both of these keys will have the same value:
 anchored_content: &anchor_name This string will appear as the value of two keys.
 other_anchor: *anchor_name
 
@@ -123,28 +165,35 @@ other_anchor: *anchor_name
 base: &base
   name: Everyone has same name
 
-# The expression << is called Merge Key Language-Independent Type. It is used to
+# The expression << is called 'Merge Key Language-Independent Type'. It is used to
 # indicate that all the keys of one or more specified maps should be inserted
 # into the current map.
-
+# NOTE: If key already exists alias will not be merged
 foo:
-  <<: *base
+  <<: *base # doesn't merge the anchor
   age: 10
-
+  name: John
 bar:
-  <<: *base
+  <<: *base # base anchor will be merged
   age: 20
 
 # foo and bar would also have name: Everyone has same name
 
 # YAML also has tags, which you can use to explicitly declare types.
+# Syntax: !![typeName] [value]
+explicit_boolean: !!bool true
+explicit_integer: !!int 42
+explicit_float: !!float -42.24
 explicit_string: !!str 0.5
+explicit_datetime: !!timestamp 2022-11-17 12:34:56.78 +9
+explicit_null: !!null null
+
 # Some parsers implement language specific tags, like this one for Python's
 # complex number type.
 python_complex_number: !!python/complex 1+2j
 
 # We can also use yaml complex keys with language specific tags
-? !!python/tuple [5, 7]
+? !!python/tuple [ 5, 7 ]
 : Fifty Seven
 # Would be {(5, 7): 'Fifty Seven'} in Python
 
@@ -154,9 +203,10 @@ python_complex_number: !!python/complex 1+2j
 
 # Strings and numbers aren't the only scalars that YAML can understand.
 # ISO-formatted date and datetime literals are also parsed.
-datetime: 2001-12-15T02:59:43.1Z
-datetime_with_spaces: 2001-12-14 21:59:43.10 -5
-date: 2002-12-14
+datetime_canonical: 2001-12-15T02:59:43.1Z
+datetime_space_separated_with_time_zone: 2001-12-14 21:59:43.10 -5
+date_implicit: 2002-12-14
+date_explicit: !!timestamp 2002-12-14
 
 # The !!binary tag indicates that a string is actually a base64-encoded
 # representation of a binary blob.
@@ -171,7 +221,7 @@ set:
   ? item1
   ? item2
   ? item3
-or: {item1, item2, item3}
+or: { item1, item2, item3 }
 
 # Sets are just maps with null values; the above is equivalent to:
 set2:
@@ -186,3 +236,4 @@ set2:
 
 + [YAML official website](https://yaml.org/)
 + [Online YAML Validator](http://www.yamllint.com/)
++ [JSON ⇆ YAML](https://www.json2yaml.com/)
diff --git a/zfs.html.markdown b/zfs.html.markdown
index 6795b1fa..3f5a76b5 100644
--- a/zfs.html.markdown
+++ b/zfs.html.markdown
@@ -3,6 +3,7 @@ category: tool
 tool: zfs
 contributors:
     - ["sarlalian", "http://github.com/sarlalian"]
+    - ["A1EF", "https://github.com/A1EF"]
 filename: LearnZfs.txt
 ---
 
@@ -25,7 +26,6 @@ RAID setup with ZFS, as ZFS expects to directly manage the underlying disks.
 
 Types of VDEV's
 
-* stripe (a single disk, no redundancy)
 * mirror (n-way mirrors supported)
 * raidz
 	* raidz1 (1-disk parity, similar to RAID 5)
@@ -71,7 +71,7 @@ List zpools
 
 ```bash
 # Create a raidz zpool
-$ zpool create bucket raidz1 gpt/zfs0 gpt/zfs1 gpt/zfs2
+$ zpool create zroot raidz1 gpt/zfs0 gpt/zfs1 gpt/zfs2
 
 # List ZPools
 $ zpool list
@@ -160,22 +160,22 @@ Create datasets
 
 ```bash
 # Create dataset
-$ zfs create tank/root/data
+$ zfs create zroot/root/data
 $ mount | grep data
-tank/root/data on /data (zfs, local, nfsv4acls)
+zroot/root/data on /data (zfs, local, nfsv4acls)
 
 # Create child dataset
-$ zfs create tank/root/data/stuff
+$ zfs create zroot/root/data/stuff
 $ mount | grep data
-tank/root/data on /data (zfs, local, nfsv4acls)
-tank/root/data/stuff on /data/stuff (zfs, local, nfsv4acls)
+zroot/root/data on /data (zfs, local, nfsv4acls)
+zroot/root/data/stuff on /data/stuff (zfs, local, nfsv4acls)
 
 
 # Create Volume
 $ zfs create -V zroot/win_vm
 $ zfs list zroot/win_vm
 NAME                 USED  AVAIL  REFER  MOUNTPOINT
-tank/win_vm         4.13G  17.9G    64K  -
+zroot/win_vm         4.13G  17.9G    64K  -
 ```
 
 List datasets
@@ -213,28 +213,28 @@ zroot/var/tmp@daily-2015-10-15
 Rename datasets
 
 ```bash
-$ zfs rename tank/root/home tank/root/old_home
-$ zfs rename tank/root/new_home tank/root/home
+$ zfs rename zroot/root/home zroot/root/old_home
+$ zfs rename zroot/root/new_home zroot/root/home
 ```
 
 Delete dataset
 
 ```bash
 # Datasets cannot be deleted if they have any snapshots
-$ zfs destroy tank/root/home
+$ zfs destroy zroot/root/home
 ```
 
 Get / set properties of a dataset
 
 ```bash
 # Get all properties
-$ 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
+$ zfs get all zroot/usr/home
+NAME            PROPERTY              VALUE                  SOURCE
+zroot/home      type                  filesystem             -
+zroot/home      creation              Mon Oct 20 14:44 2014  -
+zroot/home      used                  11.9G                  -
+zroot/home      available             94.1G                  -
+zroot/home      referenced            11.9G                  -
 zroot/home      mounted               yes                    -
 ...
 
@@ -244,7 +244,7 @@ NAME            PROPERTY     VALUE     SOURCE
 zroot/home      compression  off       default
 
 # Set property on dataset
-$ zfs set compression=gzip-9 mypool/lamb
+$ zfs set compression=lz4 zroot/lamb
 
 # Get a set of properties from all datasets
 $ zfs list -o name,quota,reservation
@@ -283,16 +283,16 @@ Create snapshots
 
 ```bash
 # Create a snapshot of a single dataset
-zfs snapshot tank/home/sarlalian@now
+zfs snapshot zroot/home/sarlalian@now
 
 # Create a snapshot of a dataset and its children
-$ zfs snapshot -r tank/home@now
+$ zfs snapshot -r zroot/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  -
+zroot/home@now                 0      -    26K  -
+zroot/home/sarlalian@now       0      -   259M  -
+zroot/home/alice@now           0      -   156M  -
+zroot/home/bob@now             0      -   156M  -
 ...
 ```
 
@@ -300,10 +300,10 @@ Destroy snapshots
 
 ```bash
 # How to destroy a snapshot
-$ zfs destroy tank/home/sarlalian@now
+$ zfs destroy zroot/home/sarlalian@now
 
 # Delete a snapshot on a parent dataset and its children
-$ zfs destroy -r tank/home/sarlalian@now
+$ zfs destroy -r zroot/home/sarlalian@now
 
 ```
 
@@ -311,10 +311,10 @@ Renaming Snapshots
 
 ```bash
 # Rename a snapshot
-$ zfs rename tank/home/sarlalian@now tank/home/sarlalian@today
-$ zfs rename tank/home/sarlalian@now today
+$ zfs rename zroot/home/sarlalian@now zroot/home/sarlalian@today
+$ zfs rename zroot/home/sarlalian@now today
 
-$ zfs rename -r tank/home@now @yesterday
+$ zfs rename -r zroot/home@now @yesterday
 ```
 
 Accessing snapshots
@@ -328,26 +328,26 @@ Sending and Receiving
 
 ```bash
 # Backup a snapshot to a file
-$ zfs send tank/home/sarlalian@now | gzip > backup_file.gz
+$ zfs send zroot/home/sarlalian@now | gzip > backup_file.gz
 
 # Send a snapshot to another dataset
-$ zfs send tank/home/sarlalian@now | zfs recv backups/home/sarlalian
+$ zfs send zroot/home/sarlalian@now | zfs recv backups/home/sarlalian
 
 # Send a snapshot to a remote host
-$ zfs send tank/home/sarlalian@now | ssh root@backup_server 'zfs recv tank/home/sarlalian'
+$ zfs send zroot/home/sarlalian@now | ssh root@backup_server 'zfs recv zroot/home/sarlalian'
 
 # Send full dataset with snapshots to new host
-$ zfs send -v -R tank/home@now | ssh root@backup_server 'zfs recv tank/home'
+$ zfs send -v -R zroot/home@now | ssh root@backup_server 'zfs recv zroot/home'
 ```
 
 Cloning Snapshots
 
 ```bash
 # Clone a snapshot
-$ zfs clone tank/home/sarlalian@now tank/home/sarlalian_new
+$ zfs clone zroot/home/sarlalian@now zroot/home/sarlalian_new
 
 # Promoting the clone so it is no longer dependent on the snapshot
-$ zfs promote tank/home/sarlalian_new
+$ zfs promote zroot/home/sarlalian_new
 ```
 
 ### Putting it all together
diff --git a/zh-cn/asciidoc-cn.html.markdown b/zh-cn/asciidoc-cn.html.markdown
new file mode 100644
index 00000000..0709e8c1
--- /dev/null
+++ b/zh-cn/asciidoc-cn.html.markdown
@@ -0,0 +1,135 @@
+---
+language: asciidoc
+filename: asciidoc-cn.adoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+    - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+    - ["Liu Yihua", "https://github.com/yihuajack"]
+lang: zh-cn
+---
+
+AsciiDoc 是一�类似于 Markdown 的标记语言，它�以用�写从书到�客的任何东西。它由 Stuart Rackham 在 2002 年�明，它的语言很简�，但�时也�以有丰富的定制。
+
+文档标题
+
+标题是�选的，且��以包�空行。它必须离正文空出至少一个空行。
+
+仅标题
+
+```
+= 文档标题
+
+文档的第一��。
+```
+
+标题和作者
+
+```
+= 文档标题
+张三 <san.zhang@learnxinyminutes.com>
+
+文档开始。
+```
+
+多�作者的情形
+
+```
+= 文档标题
+�四 <si@go.com>; 王五 <wu@yo.com>; 赵六 <xzhao@pirate.com>
+
+有多�作者的文档开始。
+```
+
+版本行（需�作者行）
+
+```
+= 文档标题（第一版）
+土豆人 <chip@crunchy.com>
+v1.0, 2016-01-13
+
+这篇关于炸薯�的文章会很有趣。
+```
+
+段�
+
+```
+段��需�什么特别�作。
+
+在两段之间用一个空行隔开。
+
+当你需��行时，添加一个 +
+你就会得到一个�行符�
+```
+
+文本格�化
+
+```
+_用下划线创建斜体_
+*用星�加粗*
+*_组�起�用更有趣_*
+`用�音符显示等宽字体`
+`*加粗等宽字体*`
+```
+
+节标题
+
+```
+= 第 0 级 （一般�用于文档标题）
+
+== 第 1 级 <h2>
+
+=== 第 2 级 <h3>
+
+==== 第 3 级 <h4>
+
+===== 第 4 级 <h5>
+
+```
+
+列表
+
+用星�创建无�列表。
+
+```
+* 甲
+* ä¹™
+* 丙
+```
+
+用�点创建有�列表。
+
+```
+. 项目 1
+. 项目 2
+. 项目 3
+```
+
+你�以用�外的星�或�点�嵌套最多五次列表。
+
+```
+* 甲 1
+** 甲 2
+*** 甲 3
+**** 甲 4
+***** 甲 5
+
+. 甲 1
+.. 甲 2
+... 甲 3
+.... 甲 4
+..... 甲 5
+```
+
+## 补充�料
+
+处� AsciiDoc 文档有两�工具：
+
+1. [AsciiDoc](http://asciidoc.org/): 原版的 Python 实现，在主� Linux �行版中已附带，目�处于稳定版本维护模�。
+2. [Asciidoctor](http://asciidoctor.org/): 使用 Ruby 的�一�实现，也�以从 Java 和 JavaScript 中使用。它处于积�的开�中，目标是用新特性和输出格�扩展 AsciiDoc 的语法。
+
+以下是 `Asciidoctor` 实现的相关链接：
+
+* [Markdown - AsciiDoc 语法比较](http://asciidoctor.org/docs/user-manual/#comparison-by-example)：并列比较一般 Markdown 和 AsciiDoc 的元素。
+* [入门](http://asciidoctor.org/docs/#get-started-with-asciidoctor)：安装和快速�动指�，帮助构建简�的文档。
+* [Asciidoctor 用户手册](http://asciidoctor.org/docs/user-manual/): 完整的�文档指�，包�语法�考�示例�渲染工具等。
diff --git a/zh-cn/awk-cn.html.markdown b/zh-cn/awk-cn.html.markdown
index 8ee2db2c..02f1f7d5 100644
--- a/zh-cn/awk-cn.html.markdown
+++ b/zh-cn/awk-cn.html.markdown
@@ -179,7 +179,7 @@ function string_functions(    localvar, arr) {
     # 都是返回替�的个数
     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"
+    gsub("e", ".", localvar) # localvar => "M..t m. at th. bar"
 
     # �索匹�正则的字符串
     # index() 也是�索, �支�正则
diff --git a/zh-cn/c++-cn.html.markdown b/zh-cn/c++-cn.html.markdown
index e0d6b6fe..db36ebc4 100644
--- a/zh-cn/c++-cn.html.markdown
+++ b/zh-cn/c++-cn.html.markdown
@@ -1,572 +1,572 @@
----

-language: c++

-filename: learncpp-cn.cpp

-contributors:

-    - ["Steven Basart", "http://github.com/xksteven"]

-    - ["Matt Kline", "https://github.com/mrkline"]

-translators:

-    - ["Arnie97", "https://github.com/Arnie97"]

-lang: zh-cn

----

-

-C++是一�系统编程语言。用它的�明者，

-[Bjarne Stroustrup的�](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote)�说，C++的设计目标是：

-

-- �为“更好的C语言�

-- 支�数�的抽象与�装

-- 支���对象编程

-- 支�泛型编程

-

-C++�供了对硬件的紧密控制（正如C语言一样），

-能够编译为机器语言，由处�器直接执行。

-与此�时，它也�供了泛型�异常和类等高层功能。

-虽然C++的语法�能比�些出现较晚的语言更��，它�然得到了人们的��——

-功能与速度的平衡使C++�为了目�应用最广泛的系统编程语言之一。

-

-```c++

-////////////////

-// 与C语言的比较

-////////////////

-

-// C++_几乎_是C语言的一个超集，它与C语言的基本语法有许多相�之处，

-// 例如��和函数的声明，原生数�类型等等。

-

-// 和C语言一样，在C++中，你的程�会从main()开始执行，

-// 该函数的返回值应当为int型，这个返回值会作为程�的退出状�值。

-// �过，大多数的编译器（gcc，clang等）也接� void main() 的函数原型。

-// （�� http://en.wikipedia.org/wiki/Exit_status �获�更多信�）

-int main(int argc, char** argv)

-{

-    // 和C语言一样，命令行�数通过argc和argv传递。

-    // argc代表命令行�数的数�，

-    // 而argv是一个包�“C语言风格字符串�（char *）的数组，

-    // 其中�个字符串代表一个命令行�数的内容，

-    // 首个命令行�数是调用该程�时所使用的�称。

-    // 如果你�关心命令行�数的值，argc和argv�以被忽略。

-    // 此时，你�以用int main()作为函数原型。

-

-    // 退出状�值为0时，表示程�执行�功

-    return 0;

-}

-

-// 然而，C++和C语言也有一些区别：

-

-// 在C++中，字符字��的大�是一个字节。

-sizeof('c') == 1

-

-// 在C语言中，字符字��的大�与int相�。

-sizeof('c') == sizeof(10)

-

-

-// C++的函数原型与函数定义是严格匹�的

-void func(); // 这个函数�能接�任何�数

-

-// 而在C语言中

-void func(); // 这个函数能接�任�数�的�数

-

-// 在C++中，用nullptr代替C语言中的NULL

-int* ip = nullptr;

-

-// C++也�以使用C语言的标准头文件，

-// 但是需�加上�缀“c�并去掉末尾的“.h�。

-#include <cstdio>

-

-int main()

-{

-    printf("Hello, world!\n");

-    return 0;

-}

-

-///////////

-// 函数�载

-///////////

-

-// C++支�函数�载，你�以定义一组�称相�而�数��的函数。

-

-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�中�得所需的内容。

-    using namespace 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;

-

-   // 在标准输出（终端/显示器）中显示

-   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++还�供了_引用_。

-// 引用是一�特殊的指针类型，一旦被定义就�能�新赋值，并且�能被设置为空值。

-// 使用引用时的语法与原��相�：

-// 也就是说，对引用类型进行解引用时，�需�使用*；

-// 赋值时也�需�用&��地�。

-

-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"。

-fooRef = bar;

-

-const string& barRef = bar; // 建立指�bar的常�引用。

-// 和C语言中一样，（指针和引用）声明为常�时，对应的值�能被修改。

-barRef += ". Hi!"; // 这是错误的，�能修改一个常�引用的值。

-

-///////////////////

-// 类与��对象编程

-///////////////////

-

-// 有关类的第一个示例

-#include <iostream>

-

-// 声明一个类。

-// 类通常在头文件（.h或.hpp）中声明。

-class Dog {

-    // �员��和�员函数默认情况下是�有（private）的。

-    std::string name;

-    int weight;

-

-// 在这个标签之�，所有声明都是公有（public）的，

-// 直到�新指定“private:�（�有继承）或“protected:�（�护继承）为止

-public:

-

-    // 默认的构造器

-    Dog();

-

-    // 这里是�员函数声明的一个例�。

-    // �以注�到，我们在此处使用了std::string，而�是using namespace std

-    // 语�using namespace��应当出现在头文件当中。

-    void setName(const std::string& dogsName);

-

-    void setWeight(int dogsWeight);

-

-    // 如果一个函数�对对象的状�进行修改，

-    // 应当在声明中加上const。

-    // 这样，你就�以对一个以常�方�引用的对象执行该�作。

-    // �时�以注�到，当父类的�员函数需�被�类�写时，

-    // 父类中的函数必须被显�声明为_虚函数（virtual）_。

-    // 考虑到性能方�的因素，函数默认情况下�会被声明为虚函数。

-    virtual void print() const;

-

-    // 函数也�以在class body内部定义。

-    // 这样定义的函数会自动�为内�函数。

-    void bark() const { std::cout << name << " barks!\n" }

-

-    // 除了构造器以外，C++还�供了�构器。

-    // 当一个对象被删除或者脱离其定义域时，它的�构函数会被调用。

-    // 这使得RAII这样的强大范�（��下文）�为�能。

-    // 为了�生出�类�，基类的�构函数必须定义为虚函数。

-    virtual ~Dog();

-

-}; // 在类的定义之�，�加一个分�

-

-// 类的�员函数通常在.cpp文件中实现。

-void Dog::Dog()

-{

-    std::cout << "A dog has been constructed\n";

-}

-

-// 对象（例如字符串）应当以引用的形�传递，

-// 对于�需�修改的对象，最好使用常�引用。

-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";

-}

-

-void 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类中的公有（public）和�护（protected）对象

-class OwnedDog : public Dog {

-

-    void setOwner(const std::string& dogsOwner)

-

-    // �写OwnedDogs类的print方法。

-    // 如果你�熟悉�类多�的�，�以�考这个页�中的概述：

-    // http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B

-

-    // 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(); // 调用基类Dog中的print方法

-    // "Dog is <name> and weights <weight>"

-

-    std::cout << "Dog is owned by " << owner << "\n";

-    // "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

-{

-    // 创建一个新的点，

-    // 其横纵�标分别为这个点与�一点在对应方�上的�标之和。

-    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（Point类型）的“+�方法，并以right作为函数的�数

-    Point result = up + right;

-    // 显示“Result is upright (1,1)�

-    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";

-    return 0;

-}

-

-///////////

-// 异常处�

-///////////

-

-// 标准库中�供了一些基本的异常类型

-// （��http://en.cppreference.com/w/cpp/error/exception）

-// 但是，其他任何类型也�以作为一个异常被拋出

-#include <exception>

-

-// 在_try_代��中拋出的异常�以被��的_catch_�获。

-try {

-    // ��用 _new_关键字在堆上为异常分�空间。

-    throw std::exception("A problem occurred");

-}

-// 如果拋出的异常是一个对象，�以用常�引用��获它

-catch (const std::exception& ex)

-{

-  std::cout << ex.what();

-// �获尚未被_catch_处�的所有错误

-} catch (...)

-{

-    std::cout << "Unknown exception caught";

-    throw; // �新拋出异常

-}

-

-///////

-// RAII

-///////

-

-// RAII指的是“资�获�就是�始化�（Resource Allocation Is Initialization），

-// 它被视作C++中最强大的编程范�之一。

-// 简�说�，它指的是，用构造函数�获�一个对象的资�，

-// 相应的，借助�构函数�释放对象的资�。

-

-// 为了�解这一范�的用处，让我们考虑�个函数使用文件�柄时的情况：

-void doSomethingWithAFile(const char* filename)

-{

-    // 首先，让我们�设一切都会顺利进行。

-

-    FILE* fh = fopen(filename, "r"); // 以�读模�打开文件

-

-    doSomethingWithTheFile(fh);

-    doSomethingElseWithIt(fh);

-

-    fclose(fh); // 关闭文件�柄

-}

-

-// �幸的是，��错误处�机制的引入，事情会�得��。

-// �设fopen函数有�能执行失败，

-// 而doSomethingWithTheFile和doSomethingElseWithIt会在失败时返回错误代�。

-// （虽然异常是C++中处�错误的推�方�，

-// 但是�些程�员，尤其是有C语言背景的，并�认�异常�获机制的作用）。

-// 现在，我们必须检查�个函数调用是��功执行，并在问题�生的时候关闭文件�柄。

-bool doSomethingWithAFile(const char* filename)

-{

-    FILE* fh = fopen(filename, "r"); // 以�读模�打开文件

-    if (fh == nullptr) // 当执行失败是，返回的指针是nullptr

-        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::exception("Could not open the file.");

-

-    try {

-        doSomethingWithTheFile(fh);

-        doSomethingElseWithIt(fh);

-    }

-    catch (...) {

-        fclose(fh); // ��出错的时候文件被正确关闭

-        throw; // 之�，�新抛出这个异常

-    }

-

-    fclose(fh); // 关闭文件

-    // 所有工作顺利完�

-}

-

-// 相比之下，使用C++中的文件�类（fstream）时，

-// fstream会利用自己的�构器�关闭文件�柄。

-// ��离开了�一对象的定义域，它的�构函数就会被自动调用。

-void doSomethingWithAFile(const std::string& filename)

-{

-    // ifstream是输入文件�（input file stream）的简称

-    std::ifstream fh(filename); // 打开一个文件

-

-    // 对文件进行一些�作

-    doSomethingWithTheFile(fh);

-    doSomethingElseWithIt(fh);

-

-} // 文件已�被�构器自动关闭

-

-// 与上�几�方�相比，这�方�有�_明显_的优势：

-// 1. 无论�生了什么情况，资�（此例当中是文件�柄）都会被正确关闭。

-//    ��你正确使用了�构器，就_�会_因为忘记关闭�柄，造�资�的泄�。

-// 2. �以注�到，通过这�方�写出�的代��分简�。

-//    �构器会在��关闭文件�柄，��需�你��心这些�事。

-// 3. 这�方�的代�具有异常安全性。

-//    无论在函数中的何处拋出异常，都�会阻�对文件资�的释放。

-

-// 地�的C++代�应当把RAII的使用扩展到��类型的资�上，包括：

-// - 用unique_ptr和shared_ptr管�的内存

-// - ��数�容器，例如标准库中的链表���（容�自动扩展的数组）�散列表等；

-//   当它们脱离作用域时，�构器会自动释放其中储存的内容。

-// - 用lock_guard和unique_lock实现的互斥

-```

-扩展阅读：

-

-* [CPP Reference](http://cppreference.com/w/cpp) �供了最新的语法�考。

-* �以在 [CPlusPlus](http://cplusplus.com) 找到一些补充资料。

-* �以在 [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb）上找到涵盖语言基础和设置编�环境的教程。

+---
+language: C++
+filename: learncpp-cn.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+translators:
+    - ["Arnie97", "https://github.com/Arnie97"]
+lang: zh-cn
+---
+
+C++是一�系统编程语言。用它的�明者，
+[Bjarne Stroustrup的�](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote)�说，C++的设计目标是：
+
+- �为“更好的C语言�
+- 支�数�的抽象与�装
+- 支���对象编程
+- 支�泛型编程
+
+C++�供了对硬件的紧密控制（正如C语言一样），
+能够编译为机器语言，由处�器直接执行。
+与此�时，它也�供了泛型�异常和类等高层功能。
+虽然C++的语法�能比�些出现较晚的语言更��，它�然得到了人们的��——
+功能与速度的平衡使C++�为了目�应用最广泛的系统编程语言之一。
+
+```c++
+////////////////
+// 与C语言的比较
+////////////////
+
+// C++_几乎_是C语言的一个超集，它与C语言的基本语法有许多相�之处，
+// 例如��和函数的声明，原生数�类型等等。
+
+// 和C语言一样，在C++中，你的程�会从main()开始执行，
+// 该函数的返回值应当为int型，这个返回值会作为程�的退出状�值。
+// �过，大多数的编译器（gcc，clang等）也接� void main() 的函数原型。
+// （�� http://en.wikipedia.org/wiki/Exit_status �获�更多信�）
+int main(int argc, char** argv)
+{
+    // 和C语言一样，命令行�数通过argc和argv传递。
+    // argc代表命令行�数的数�，
+    // 而argv是一个包�“C语言风格字符串�（char *）的数组，
+    // 其中�个字符串代表一个命令行�数的内容，
+    // 首个命令行�数是调用该程�时所使用的�称。
+    // 如果你�关心命令行�数的值，argc和argv�以被忽略。
+    // 此时，你�以用int main()作为函数原型。
+
+    // 退出状�值为0时，表示程�执行�功
+    return 0;
+}
+
+// 然而，C++和C语言也有一些区别：
+
+// 在C++中，字符字��的大�是一个字节。
+sizeof('c') == 1
+
+// 在C语言中，字符字��的大�与int相�。
+sizeof('c') == sizeof(10)
+
+
+// C++的函数原型与函数定义是严格匹�的
+void func(); // 这个函数�能接�任何�数
+
+// 而在C语言中
+void func(); // 这个函数能接�任�数�的�数
+
+// 在C++中，用nullptr代替C语言中的NULL
+int* ip = nullptr;
+
+// C++也�以使用C语言的标准头文件，
+// 但是需�加上�缀“c�并去掉末尾的“.h�。
+#include <cstdio>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+///////////
+// 函数�载
+///////////
+
+// C++支�函数�载，你�以定义一组�称相�而�数��的函数。
+
+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�中�得所需的内容。
+    using namespace 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;
+
+   // 在标准输出（终端/显示器）中显示
+   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++还�供了_引用_。
+// 引用是一�特殊的指针类型，一旦被定义就�能�新赋值，并且�能被设置为空值。
+// 使用引用时的语法与原��相�：
+// 也就是说，对引用类型进行解引用时，�需�使用*；
+// 赋值时也�需�用&��地�。
+
+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"。
+fooRef = bar;
+
+const string& barRef = bar; // 建立指�bar的常�引用。
+// 和C语言中一样，（指针和引用）声明为常�时，对应的值�能被修改。
+barRef += ". Hi!"; // 这是错误的，�能修改一个常�引用的值。
+
+///////////////////
+// 类与��对象编程
+///////////////////
+
+// 有关类的第一个示例
+#include <iostream>
+
+// 声明一个类。
+// 类通常在头文件（.h或.hpp）中声明。
+class Dog {
+    // �员��和�员函数默认情况下是�有（private）的。
+    std::string name;
+    int weight;
+
+// 在这个标签之�，所有声明都是公有（public）的，
+// 直到�新指定“private:�（�有继承）或“protected:�（�护继承）为止
+public:
+
+    // 默认的构造器
+    Dog();
+
+    // 这里是�员函数声明的一个例�。
+    // �以注�到，我们在此处使用了std::string，而�是using namespace std
+    // 语�using namespace��应当出现在头文件当中。
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // 如果一个函数�对对象的状�进行修改，
+    // 应当在声明中加上const。
+    // 这样，你就�以对一个以常�方�引用的对象执行该�作。
+    // �时�以注�到，当父类的�员函数需�被�类�写时，
+    // 父类中的函数必须被显�声明为_虚函数（virtual）_。
+    // 考虑到性能方�的因素，函数默认情况下�会被声明为虚函数。
+    virtual void print() const;
+
+    // 函数也�以在class body内部定义。
+    // 这样定义的函数会自动�为内�函数。
+    void bark() const { std::cout << name << " barks!\n" }
+
+    // 除了构造器以外，C++还�供了�构器。
+    // 当一个对象被删除或者脱离其定义域时，它的�构函数会被调用。
+    // 这使得RAII这样的强大范�（��下文）�为�能。
+    // 为了�生出�类�，基类的�构函数必须定义为虚函数。
+    virtual ~Dog();
+
+}; // 在类的定义之�，�加一个分�
+
+// 类的�员函数通常在.cpp文件中实现。
+void Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// 对象（例如字符串）应当以引用的形�传递，
+// 对于�需�修改的对象，最好使用常�引用。
+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";
+}
+
+void 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类中的公有（public）和�护（protected）对象
+class OwnedDog : public Dog {
+
+    void setOwner(const std::string& dogsOwner)
+
+    // �写OwnedDogs类的print方法。
+    // 如果你�熟悉�类多�的�，�以�考这个页�中的概述：
+    // http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B
+
+    // 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(); // 调用基类Dog中的print方法
+    // "Dog is <name> and weights <weight>"
+
+    std::cout << "Dog is owned by " << owner << "\n";
+    // "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
+{
+    // 创建一个新的点，
+    // 其横纵�标分别为这个点与�一点在对应方�上的�标之和。
+    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（Point类型）的“+�方法，并以right作为函数的�数
+    Point result = up + right;
+    // 显示“Result is upright (1,1)�
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+///////////
+// 异常处�
+///////////
+
+// 标准库中�供了一些基本的异常类型
+// （��http://en.cppreference.com/w/cpp/error/exception）
+// 但是，其他任何类型也�以作为一个异常被拋出
+#include <exception>
+
+// 在_try_代��中拋出的异常�以被��的_catch_�获。
+try {
+    // ��用 _new_关键字在堆上为异常分�空间。
+    throw std::exception("A problem occurred");
+}
+// 如果拋出的异常是一个对象，�以用常�引用��获它
+catch (const std::exception& ex)
+{
+  std::cout << ex.what();
+// �获尚未被_catch_处�的所有错误
+} catch (...)
+{
+    std::cout << "Unknown exception caught";
+    throw; // �新拋出异常
+}
+
+///////
+// RAII
+///////
+
+// RAII指的是“资�获�就是�始化�（Resource Allocation Is Initialization），
+// 它被视作C++中最强大的编程范�之一。
+// 简�说�，它指的是，用构造函数�获�一个对象的资�，
+// 相应的，借助�构函数�释放对象的资�。
+
+// 为了�解这一范�的用处，让我们考虑�个函数使用文件�柄时的情况：
+void doSomethingWithAFile(const char* filename)
+{
+    // 首先，让我们�设一切都会顺利进行。
+
+    FILE* fh = fopen(filename, "r"); // 以�读模�打开文件
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // 关闭文件�柄
+}
+
+// �幸的是，��错误处�机制的引入，事情会�得��。
+// �设fopen函数有�能执行失败，
+// 而doSomethingWithTheFile和doSomethingElseWithIt会在失败时返回错误代�。
+// （虽然异常是C++中处�错误的推�方�，
+// 但是�些程�员，尤其是有C语言背景的，并�认�异常�获机制的作用）。
+// 现在，我们必须检查�个函数调用是��功执行，并在问题�生的时候关闭文件�柄。
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // 以�读模�打开文件
+    if (fh == nullptr) // 当执行失败是，返回的指针是nullptr
+        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::exception("Could not open the file.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // ��出错的时候文件被正确关闭
+        throw; // 之�，�新抛出这个异常
+    }
+
+    fclose(fh); // 关闭文件
+    // 所有工作顺利完�
+}
+
+// 相比之下，使用C++中的文件�类（fstream）时，
+// fstream会利用自己的�构器�关闭文件�柄。
+// ��离开了�一对象的定义域，它的�构函数就会被自动调用。
+void doSomethingWithAFile(const std::string& filename)
+{
+    // ifstream是输入文件�（input file stream）的简称
+    std::ifstream fh(filename); // 打开一个文件
+
+    // 对文件进行一些�作
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // 文件已�被�构器自动关闭
+
+// 与上�几�方�相比，这�方�有�_明显_的优势：
+// 1. 无论�生了什么情况，资�（此例当中是文件�柄）都会被正确关闭。
+//    ��你正确使用了�构器，就_�会_因为忘记关闭�柄，造�资�的泄�。
+// 2. �以注�到，通过这�方�写出�的代��分简�。
+//    �构器会在��关闭文件�柄，��需�你��心这些�事。
+// 3. 这�方�的代�具有异常安全性。
+//    无论在函数中的何处拋出异常，都�会阻�对文件资�的释放。
+
+// 地�的C++代�应当把RAII的使用扩展到��类型的资�上，包括：
+// - 用unique_ptr和shared_ptr管�的内存
+// - ��数�容器，例如标准库中的链表���（容�自动扩展的数组）�散列表等；
+//   当它们脱离作用域时，�构器会自动释放其中储存的内容。
+// - 用lock_guard和unique_lock实现的互斥
+```
+扩展阅读：
+
+* [CPP Reference](http://cppreference.com/w/cpp) �供了最新的语法�考。
+* �以在 [CPlusPlus](http://cplusplus.com) 找到一些补充资料。
+* �以在 [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb）上找到涵盖语言基础和设置编�环境的教程。
diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown
index dbad5030..851f2981 100644
--- a/zh-cn/c-cn.html.markdown
+++ b/zh-cn/c-cn.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c
+language: C
 filename: learnc-cn.c
 contributors:
     - ["Adam Bard", "http://adambard.com/"]
@@ -474,7 +474,7 @@ void testFunc() {
 // 用户自定义类型和结构
 ///////////////////////////////////////
 
-// Typedefs�以创建类型别�
+// typedef �以创建类型别�
 typedef int my_type;
 my_type my_type_var = 0;
 
diff --git a/zh-cn/clojure-cn.html.markdown b/zh-cn/clojure-cn.html.markdown
index fa241384..e98eac2a 100644
--- a/zh-cn/clojure-cn.html.markdown
+++ b/zh-cn/clojure-cn.html.markdown
@@ -362,7 +362,7 @@ Clojuredocs.org有大多数核心函数的文档，还带了示例哦:
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
 4Clojure是个很赞的用�练习clojure/FP技能的地方:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org (你没看错)有很多入门级的文章:
 [http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/zh-cn/clojure-macro-cn.html.markdown b/zh-cn/clojure-macro-cn.html.markdown
index 23b2f203..85b966e9 100644
--- a/zh-cn/clojure-macro-cn.html.markdown
+++ b/zh-cn/clojure-macro-cn.html.markdown
@@ -131,7 +131,7 @@ lang: zh-cn
 
 ; 然而，如果我们希望它在编译期执行，就需�创建�
 (defmacro inline-2 [form]
-  (inline-2-helper form)))
+  (inline-2-helper form))
 
 (macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1)))
 ; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1)
diff --git a/zh-cn/cmake-cn.html.markdown b/zh-cn/cmake-cn.html.markdown
new file mode 100644
index 00000000..dd9961ca
--- /dev/null
+++ b/zh-cn/cmake-cn.html.markdown
@@ -0,0 +1,168 @@
+---
+category: tool
+tool: cmake
+contributors:
+    - ["Bruno Alano", "https://github.com/brunoalano"]
+translators:
+    - ["tx23", "https://github.com/tx23"]
+filename: CMake-cn
+lang: zh-cn
+---
+
+CMake 是一个跨平�且开�的自动化构建系统工具。通过该工具你�以对你的�代�进行测试�编译或创建安装包。
+
+CMake 试图去解决Makefile 跨平�的自动�置问题(��的make解释器有��的命令)，以�链接第三方库时的易用性问题。
+
+CMake是一个�扩展的开�系统，它以�作系统和与编译器无关的方�管�构建过程。与其他许多跨平�系统��的是，
+CMake被设计为与本机的构建环境结�使用。它通过被放置于�个�文件目录下的简��置文件（�为 CMakeLists.txt 的文件）
+�生�常规使用的标准构建文件（比如：Unix 下的 makefiles 文件或 Windows MSVC 中的 projects/workspaces）。
+
+```cmake
+# 在 CMake 中, 这是一�命令
+
+# ��行我们的代�，请执行以下命令：
+#  - mkdir build && cd build
+#  - cmake ..
+#  - make
+# 
+# 通过上述命令，我们将�循最佳实践在�目录中进行编译
+# 在第二行命令中我们请求Cmake 生�新的�赖于系统的Makefile文件。
+# 最�，我们�行本地的make 命令。
+
+#------------------------------------------------------------------------------
+# 基础部分
+#------------------------------------------------------------------------------
+#
+# Cmake文件必须被命令为 “CMakeLists.txt� 。
+
+# 设置生�Makefile的CMake所需最低版本�求
+cmake_minimum_required (VERSION 2.8)
+
+# 当版本�于2.8时，需�加入关键字 FATAL_ERROR。
+cmake_minimum_required (VERSION 2.8 FATAL_ERROR)
+
+# 在这里定义了项目的�称，�时会影�Cmake 生�的目录命�约定。
+# 我们�以将代�的语言作为第二个�数传入。
+project (learncmake C)
+
+# 设置项目的�目录（仅仅是由于惯例）
+set( LEARN_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+set( LEARN_CMAKE_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} )
+
+# 在构建系统中用“semver�风格为我们代�设置当�版本是很有用的。
+set (LEARN_CMAKE_VERSION_MAJOR 1)
+set (LEARN_CMAKE_VERSION_MINOR 0)
+set (LEARN_CMAKE_VERSION_PATCH 0)
+
+# 将��（版本�）��到�代�头
+configure_file (
+  "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
+  "${PROJECT_BINARY_DIR}/TutorialConfig.h"
+)
+
+# 包�目录
+# 在 GCC中, 该语�等�于 "-I" 命令
+include_directories( include )
+
+# 在哪里安装其他库？注�：在此处�供includes路径，�续检查将解决所有其他问题
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# �件
+if ( CONDITION )
+  # 输出�
+
+  # 附带信�
+  message(STATUS "My message")
+
+  # CMake 警告，继续处�
+  message(WARNING "My message")
+
+  # CMake 警告 (dev)，继续处�
+  message(AUTHOR_WARNING "My message")
+
+  # CMake 错误，继续处�但是会跳过生�
+  message(SEND_ERROR "My message")
+
+  # CMake 错误，�止处�和生�
+  message(FATAL_ERROR "My message")
+endif()
+
+if( CONDITION )
+
+elseif( CONDITION )
+
+else( CONDITION )
+
+endif( CONDITION )
+
+# 循环
+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)
+
+
+# 逻辑�算
+if(FALSE AND (FALSE OR TRUE))
+  message("Don't display!")
+endif()
+
+# 将常规，缓存或环境��设置为给定值。
+# 如果指定了PARENT_SCOPE选项，则将在当�作用域上的作用域中设置��
+# `set(<variable> <value>... [PARENT_SCOPE])`
+
+# 如何在带引�和�带引�的�数中引用��？How to reference variables inside quoted and unquoted arguments?
+# 如果未设置��，��引用由��值或空字符串替�。
+${variable_name}
+
+# 清�
+# 设置�文件列表
+set( LEARN_CMAKE_SOURCES 
+  src/main.c
+  src/imagem.c
+  src/pather.c
+)
+
+# 调用编译器
+#
+# ${PROJECT_NAME} � Learn_CMake 
+add_executable( ${PROJECT_NAME} ${LEARN_CMAKE_SOURCES} )
+
+# 链接库
+target_link_libraries( ${PROJECT_NAME} ${LIBS} m )
+
+# 在哪里安装其他库？注�：在此处�供includes路径，�续检查将解决所有其他问题
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# 编译�件 (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()
+
+# 检查 OS
+if( UNIX )
+    set( LEARN_CMAKE_DEFINITIONS
+        "${LEARN_CMAKE_DEFINITIONS} -Wall -Wextra -Werror -Wno-deprecated-declarations -Wno-unused-parameter -Wno-comment" )
+endif()
+```
+
+### 资�
+
++ [CMake tutorial](https://cmake.org/cmake-tutorial/)
++ [CMake documentation](https://cmake.org/documentation/)
++ [Mastering CMake](http://amzn.com/1930934319/)
++ [An Introduction to Modern CMake](https://cliutils.gitlab.io/modern-cmake/)
diff --git a/zh-cn/cobol-cn.html.markdown b/zh-cn/cobol-cn.html.markdown
new file mode 100644
index 00000000..08eb36fb
--- /dev/null
+++ b/zh-cn/cobol-cn.html.markdown
@@ -0,0 +1,192 @@
+---
+language: COBOL
+filename: learn-cn.COB
+contributors:
+    - ["Hyphz", "http://github.com/hyphz/"]
+translators:
+    - ["GOLGO11", "https://github.com/GOLGO11/"]
+lang: zh-cn
+---
+COBOL是一门��商业的语言，它从1960年最�设计以�被修订过数次。它被宣称�然有超过80%的机构在使用它。
+
+```cobol
+      *COBOL. 最好是按照它1985年的标准�编程。 
+      *用附带GnuCOBOL编译器的OpenCobolIDE 4.7.6�编译。
+       
+      *COBOL在�版（COBOL-85）和新版（COBOL-2002以�COBOL-2014）之间有明显的差别。
+      *�版COBOL�求编�的�一到六列是空�的（它们被用�存储穿孔�片的�列�...
+      *第七列的一个“*�符�表示注释的开始。
+      *在�版COBOL中，一�以*开头的注释最长�能�一行，
+      *新版COBOL�需��外的列�补�列�，并且用“*>" �注释，�许在行中开始注释
+      *�版COBOL也强加了对最大行长度的�制
+      *关键字在�版COBOL中必须大写，
+      *但在新版COBOL中�区分大�写
+      *虽然新版COBOL�许你编写大�写混�的代�
+      *但是在大多数情况下编写COBOL代�时全用大写字符
+      *大多数专业的COBOL开�者都是这么�的。
+      *COBOL语�以�点结尾。
+      
+      *COBOL代�被拆�了四个部。
+      *�部按顺�，它们是:
+      *IDENTIFICATION DIVSION.（标识部）
+      *ENVIRONMENT DIVISION.（环境部）
+      *DATA DIVISION.（数�部）
+      *PROCEDURE DIVISION.（过程部）
+
+      *第一步，我们必须给我们的程�一个ID。
+      *Identification division 也能包�其他的值，
+      *但它们都�是程�的元数�。Program-id是唯一一个必须给出的值。
+       IDENTIFICATION DIVISION.
+           PROGRAM-ID.    LEARN.
+           AUTHOR.        JOHN DOE.
+           DATE-WRITTEN.  05/02/2020.
+
+      *让我们�声明一些��。
+      *我们�在DATA DIVISION的WORKING-STORAGE节�完�这个事情。
+      *�个数�项（����）从一个级别编�开始。
+      *然�是数�项的�字，�边�跟�一个picture关键字，
+      *��述这个��将�包�的数�的类型。
+      *几乎所有的COBOL开�者都会把PICTURE简写为PIC。
+      *A代表字�，X代表字�和数字，9代表数字。
+       
+      *举例：
+      01  MYNAME PIC xxxxxxxxxx.    *> �个字符的字符串。
+       
+      *但是�个数那些x会导致错误，
+      *所以以上代��以，并且应该
+      *这样�写：
+      01 MYNAME PIC X(10).
+       
+      *这是几个更多的例�：
+      01  AGE             PIC      9(3).   *> 数字最多三�
+      01  LAST_NAME       PIC      X(10).  *> 字符串最多�个字符
+       
+      *在COBOL里，一行中多个空格和一个空格的效果是一样的， 所以通常
+      *情况下都用多个空格排列代��便于
+      *其他的开�者阅读。
+      01  inyear picture s9(7). *> S 使数字为正数.
+                                 *> 括�里��是��7次9，
+                                 *> �六�数字（�是数组）
+
+      *现在让我们�写一点儿代�。这是一个简�的Hello World程�。
+      IDENTIFICATION DIVISION.
+      PROGRAM-ID. HELLO.
+      DATA DIVISION.
+      WORKING-STORAGE SECTION.
+      01 THE-MESSAGE      PIC X(20).
+      PROCEDURE DIVSION.
+          DISPLAY "STARTING PROGRAM".
+          MOVE "HELLO WORLD" TO THE-MESSAGE.
+          DISPLAY THE-MESSAGE.
+          STOP RUN.
+      
+      *以上的代�会输出：
+      *STARTING PROGRAM
+      *HELLO WORLD
+      
+
+      
+      ********用COBOL�以�数学�算***************
+      ADD 1 TO AGE GIVING NEW-AGE.
+      SUBTRACT 1 FROM COUNT.
+      DIVIDE VAR-1 INTO VAR-2 GIVING VAR-3.
+      COMPUTE TOTAL-COUNT = COUNT1 PLUS COUNT2.
+      
+      
+      *********PERFORM********************
+      *PERFORM关键字�许你跳到代�中其他特殊的代�段，
+      *当这段特殊的代�被执行完�继续回�执行下�的�执行语�。 
+      *你必须把PERFORM这个�写完整，��以缩写它。
+
+      IDENTIFICATION DIVISION.
+      PROGRAM-ID. HELLOCOBOL.
+
+      PROCEDURE DIVISION.
+         FIRST-PARA.
+             DISPLAY 'THIS IS IN FIRST-PARA'.
+         PERFORM THIRD-PARA THRU FOURTH-PARA. *>跳过second-para，执行3rd&4th
+         *> 之�当third和fourth执行完，
+         *> 回到这里继续往下执行直到�到STOP RUN.
+   
+         SECOND-PARA.
+             DISPLAY 'THIS IS IN SECOND-PARA'.
+         STOP RUN.
+   
+         THIRD-PARA.
+             DISPLAY 'THIS IS IN THIRD-PARA'.
+   
+         FOURTH-PARA.
+             DISPLAY 'THIS IS IN FOURTH-PARA'.
+   
+   
+      *当你编译执行以上程�时，它会生�以下结果：
+          THIS IS IN FIRST-PARA
+          THIS IS IN THIRD-PARA
+          THIS IS IN FOURTH-PARA
+          THIS IS IN SECOND-PARA
+          
+          
+      **********用STRING关键字把��组�到一起************
+      
+      *现在是时候学习两个类似的COBOL动�了：string和unstring。.
+
+      *string动��常被用�连接两个或多个字符串（把它们拼在一起）。
+      *没什么特别的，Unstring被用�把一个字符串拆分�两个或多个更�的字符串。       
+      *当你在程�中使用string或unstring时��忘记使用�delimited by“，这个很��。
+      
+      IDENTIFICATION DIVISION.
+      PROGRAM-ID. LEARNING.
+      ENVIRONMENT DIVISION.
+      DATA DIVISION.
+      WORKING-STORAGE SECTION.
+      01 FULL-NAME PIC X(20).
+      01 FIRST-NAME PIC X(13) VALUE "BOB GIBBERISH".
+      01 LAST-NAME PIC X(5) VALUE "COBB".
+      PROCEDURE DIVISION.
+          STRING FIRST-NAME DELIMITED BY SPACE
+            " "
+            LAST-NAME DELIMITED BY SIZE
+            INTO FULL-NAME
+          END-STRING.
+          DISPLAY "THE FULL NAME IS: "FULL-NAME.
+      STOP RUN.
+
+
+      *以上代�将会输出：
+      THE FULL NAME IS: BOB COBB
+
+
+      *让我们�看看为什么是这样。
+
+      *首先，我们在DATA DIVISION声明了所有的��，
+      *包括我们想存储string命令生�的新字符串用到的的��。
+
+      *这个�作过程在PROCEDURE DIVISION完�。
+      *我们从STRING 关键字开始，到END-STRING结�。         
+      *在它们之间我们列出我们想�组���形�更大的主��的过程。
+      *这里，我们组�了FIRST-NAME, 一个空格和LAST-NAME。
+
+      *跟在FIRST-NAME和LAST-NAME��的DELIMITED BY短语告诉程�我们想�在�自��上截�字符的规则。
+      *DELIMITED BY SPACE告诉程�从最开始截�字符直到�到一个空格。
+      *DELIMITED BY SIZE告诉程�截�字符的完整长度。
+      *我们在FIRST-NAME��使用DELIMITED BY SPACE，字符串中的GIBBERISH部分就被忽略了。
+
+      *为了更清楚，改�代�中的第10行如下:
+
+      STRING FIRST-NAME DELIMITED BY SIZE
+
+      *然��新执行程�. 这次的输出��:
+
+      THE FULL NAME IS: BOB GIBBERISH COBB
+
+
+
+
+
+
+```
+
+## 想了解更多�?
+
+* [GnuCOBOL](https://sourceforge.net/projects/open-cobol/)
+
diff --git a/zh-cn/crystal-cn.html.markdown b/zh-cn/crystal-cn.html.markdown
index 14805114..b69ce688 100644
--- a/zh-cn/crystal-cn.html.markdown
+++ b/zh-cn/crystal-cn.html.markdown
@@ -564,4 +564,4 @@ ex #=> "ex2"
 - [官方网站](https://crystal-lang.org/)
 - [官方文档](https://crystal-lang.org/docs/overview/)
 - [在线�行代�](https://play.crystal-lang.org/#/cr)
-- [Github仓库](https://github.com/crystal-lang/crystal)
+- [GitHub仓库](https://github.com/crystal-lang/crystal)
diff --git a/zh-cn/csharp-cn.html.markdown b/zh-cn/csharp-cn.html.markdown
index 971c1be9..b6cc70c0 100644
--- a/zh-cn/csharp-cn.html.markdown
+++ b/zh-cn/csharp-cn.html.markdown
@@ -1,49 +1,68 @@
 ---
-language: c#
+language: C#
 contributors:
     - ["Irfan Charania", "https://github.com/irfancharania"]
     - ["Max Yankov", "https://github.com/golergka"]
     - ["Melvyn Laïly", "http://x2a.yt"]
     - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+    - ["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"]
 translators:
     - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["CatfishWen", "http://catfishwen.github.io"]
 filename: LearnCSharp-cn.cs
 lang: zh-cn
 ---
 
+C#是一�优雅且类型安全的��对象的语言，使开�人员能够构建�行在跨平�的.NET框架上，安全且�壮的应用程�。
 
-C#是一个优雅的�类型安全的��对象语言。使用C#，开�者�以在.NET框架下构建安全��壮的应用程�。
-
-[更多关于C#的介�](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx)
+[更多关于C#的介�](https://learn.microsoft.com/zh-cn/dotnet/csharp/tour-of-csharp/)
 
 ```c#
 // �行注释以 // 开始
 /*
 多行注释是这样的
 */
+
 /// <summary>
-/// XML文档注释
+/// 这是 XML文档注释
+/// �用于生�外部文档或在 IDE 中�供上下文帮助
 /// </summary>
+/// <param name="firstParam">这是 firstParam �数的文档</param>
+/// <returns>这是函数返回值的信�</returns>
+public void MethodOrClassOrOtherWithParsableHelp(string firstParam) { }
 
-// 声明应用用到的命�空间
+// 声明这段��使用到的命�空间
+// 下�的命�空间都是标准 .NET Framework 类库的一部分
 using System;
 using System.Collections.Generic;
-using System.Data.Entity;
 using System.Dynamic;
 using System.Linq;
-using System.Linq.Expressions;
 using System.Net;
 using System.Threading.Tasks;
 using System.IO;
 
-// 定义作用域，将代�组织�包
+// 但是这个并�是标准类库:
+using System.Data.Entity;
+// 为了在下方使用它，你需�添加一个 dll 引用
+// 你�以使用 NuGet 包管�器进行安装
+// `Install-Package EntityFramework`
+
+// 命�空间 Namespaces �用于将一定的代�组织为 “包� 或者 “模��
+// 你�以在其他文件中这样引用：using Learning.CSharp;
+
+// 在 C# 10 以�，你也�以这样定义命�空间。这被称为 file-scoped namespaces（文件范围的命�空间）.
+// namespace Learning.CSharp;
+
 namespace Learning
 {
     // �个 .cs 文件至少需�包�一个和文件�相�的类
-    // 你�以�这么干，但是这样�好。
+    // 你�以�这么干，但是这样并�推�。
     public class LearnCSharp
     {
-        // 基本语法 -  如果你以�用过 Java 或 C++ 的�，�以直接跳到�文「有趣的特性�
+        // 基本语法 - 如果你以�用过 Java 或 C++ 的�，�以直接跳到�文「有趣的特性�
         public static void Syntax() 
         {
             // 使用 Console.WriteLine 打�信�
@@ -53,7 +72,7 @@ namespace Learning
                 " Double: " + 3.14 +
                 " Boolean: " + true);
 
-            // 使用 Console.Write 打�，�带�行符�
+            // 使用 Console.Write 打�将�会�行
             Console.Write("Hello ");
             Console.Write("World");
 
@@ -113,7 +132,7 @@ namespace Learning
             char charFromString = fooString[1]; // => 'e'
             // 字符串��修改:  fooString[1] = 'X' 是行�通的;
 
-            // 根�当�的locale设定比较字符串，大�写��感
+            // 根�当�的区域格�设置比较字符串，大�写��感
             string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
 
             // 基于sprintf的字符串格�化
@@ -123,12 +142,13 @@ namespace Learning
             DateTime fooDate = DateTime.Now;
             Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
 
-            // 使用 @  符��以创建跨行的字符串。使用 "" �表示 "
+            // �字字符串
+            // 使用 @ 符��以创建跨行的字符串。使用 "" �表示 "
             string bazString = @"Here's some stuff
 on a new line! ""Wow!"", the masses cried";
 
-            // 使用const或read-only定义常�
-            // 常�在编译期演算
+            // 使用 const 或 read-only 定义常�
+            // 常�在编译阶段演算
             const int HOURS_I_WORK_PER_WEEK = 9001;
 
             ///////////////////////////////////////////////////
@@ -136,7 +156,7 @@ on a new line! ""Wow!"", the masses cried";
             ///////////////////////////////////////////////////
 
             // 数组 - 从0开始计数
-            // 声明数组时需�确定数组长度
+            // 声明数组时需�指定数组长度
             // 声明数组的格�如下：
             // <datatype>[] <var name> = new <datatype>[<array size>];
             int[] intArray = new int[10];
@@ -155,8 +175,8 @@ on a new line! ""Wow!"", the masses cried";
             // List<datatype> <var name> = new List<datatype>();
             List<int> intList = new List<int>();
             List<string> stringList = new List<string>();
-            List<int> z = new List<int> { 9000, 1000, 1337 }; // i
-            // <>用于泛型 - �考下文
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // �始化
+            // <> 用于泛型 - �考下文
 
             // 列表无默认值
             // 访问列表元素时必须首先添加元素
@@ -164,18 +184,18 @@ on a new line! ""Wow!"", the masses cried";
             Console.WriteLine("intList @ 0: " + intList[0]);
 
             // 其他数�结构：
-            // 堆栈/队列
-            // 字典 (哈希表的实现)
-            // 哈希集�
-            // �读集�
-            // 元组 (.Net 4+)
+            // Stack 堆栈 / Queue 队列
+            // Dictionary 字典 (哈希表的实现)
+            // HashSet 哈希集�
+            // Read-only Collections �读集�
+            // Tuple 元组 (.Net 4+)
 
             ///////////////////////////////////////
             // �作符
             ///////////////////////////////////////
             Console.WriteLine("\n->Operators");
 
-            int i1 = 1, i2 = 2; // 多�声明的简写形�
+            int i1 = 1, i2 = 2; // 声明多个��的简写形�
 
             // 算术直截了当
             Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
@@ -214,7 +234,7 @@ on a new line! ""Wow!"", the masses cried";
             ///////////////////////////////////////
             Console.WriteLine("\n->Control Structures");
 
-            // 类似C的if语�
+            // 类似 C 的 if 语�
             int j = 10;
             if (j == 10)
             {
@@ -239,7 +259,7 @@ on a new line! ""Wow!"", the masses cried";
             int fooWhile = 0;
             while (fooWhile < 100)
             {
-                //迭代 100 次, fooWhile 0->99
+                // 迭代 100 次, fooWhile 0->99
                 fooWhile++;
             }
 
@@ -247,14 +267,21 @@ on a new line! ""Wow!"", the masses cried";
             int fooDoWhile = 0;
             do
             {
-                //迭代 100 次, fooDoWhile 0->99
+                // 迭代 100 次, fooDoWhile 0->99
+                if (false)
+                    continue; // 跳过本次迭代
+
                 fooDoWhile++;
+
+                if (fooDoWhile == 50)
+                    break; // 结�整个循环
+
             } while (fooDoWhile < 100);
 
-            //for 循环结构 => for(<�始�件>; <�件>; <步>)
+            // for 循环结构 => for(<�始�件>; <�件>; <步>)
             for (int fooFor = 0; fooFor < 10; fooFor++)
             {
-                //迭代10次, fooFor 0->9
+                // 迭代10次, fooFor 0->9
             }
 
             // foreach循环
@@ -269,7 +296,7 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             // Switch 语�
-            // switch 适用于 byte�short�char和int 数�类型。
+            // switch 适用于 byte�short�char 和 int 数�类型。
             // �样适用于�枚举的类型
             // 包括字符串类, 以�一些�装了原始值的类：
             // Character�Byte�Short和Integer。
@@ -307,46 +334,63 @@ on a new line! ""Wow!"", the masses cried";
 
             // 转�字符串为整数
             // 转�失败会抛出异常
-            int.Parse("123");//返回整数类型的"123"
+            int.Parse("123"); // 返回整数类型的"123"
 
-            // TryParse会�试转�类型，失败时会返回缺�类型
+            // TryParse 会�试转�类型，失败时会返回缺�类型
             // 例如 0
             int tryInt;
             if (int.TryParse("123", out tryInt)) // Funciton is boolean
                 Console.WriteLine(tryInt);       // 123
 
             // 转�整数为字符串
-            // Convert类�供了一系列便利转�的方法
+            // Convert 类�供了一系列方便转�类型的方法
+
+            // 比如 字符串 与 int 之间
+
+            // 最佳方法
+            bool result = int.TryParse(string, out var integer)
+            int.Parse(string);
+
+            // �推�
             Convert.ToString(123);
-            // or
+
+            // Int 到字符串
             tryInt.ToString();
+
+            // 转�
+            // 显�转� decimal 类型的 15 为 int 类型
+            // 然���转�为 long 类型
+            long x = (int) 15M;
         }
 
         ///////////////////////////////////////
-        // ç±»
+        // 类 - 请�阅文件末尾的定义
         ///////////////////////////////////////
         public static void Classes()
         {
             // �看文件尾部的对象声明
 
-            // 使用new�始化对象
+            // 使用 new �始化对象
             Bicycle trek = new Bicycle();
 
             // 调用对象的方法
-            trek.SpeedUp(3); // 你应该一直使用setter和getter方法
+            trek.SpeedUp(3); // 你应该一直使用 setter 和 getter 方法
             trek.Cadence = 100;
 
             // 查看对象的信�.
             Console.WriteLine("trek info: " + trek.Info());
 
-            // 实例化一个新的Penny Farthing
+            // 实例化一个新的 Penny Farthing 对象
             PennyFarthing funbike = new PennyFarthing(1, 10);
             Console.WriteLine("funbike info: " + funbike.Info());
 
             Console.Read();
         } // 结�main方法
 
-        // 终端程� 终端程�必须有一个main方法作为入�
+        // record 在 C# 9 �以��用, 这基本上是类的语法糖. record 对象是���的 immutable*.
+        public record ARecord(string Csharp);
+
+        // 终端程�入� 终端程�必须有一个 main 方法作为入�
         public static void Main(string[] args)
         {
             OtherInterestingFeatures();
@@ -359,11 +403,11 @@ on a new line! ""Wow!"", the masses cried";
         // 默认方法签�
 
         public // ��性
-        static // �许直接调用类，无需先创建实例
-        int, //返回值
+        static // �许从类直接调用，无需先创建实例
+        int // 返回值类型
         MethodSignatures(
-            int maxCount, // 第一个��，类型为整型
-            int count = 0, // 如果没有传入值，则缺�值为0
+            int maxCount, // 第一个�数，类型为整型
+            int count = 0, // 如果没有传入值，则缺�值为 0
             int another = 3,
             params string[] otherParams // �获其他�数
         )
@@ -371,17 +415,22 @@ on a new line! ""Wow!"", the masses cried";
             return -1;
         }
 
-        // 方法�以��，��签��一样
-        public static void MethodSignature(string maxCount)
+        // 方法�以��，��方法签��一样
+        // 一个�有返回值类型��的方法
+        public static void MethodSignatures(
+            ref int maxCount, // 通过引用传递
+            out int count)
         {
+            // 通过 'count' �数传入的值将在该方法外�留值 15
+            count = 15; // 必须在离开方法之�为 out �数赋值
         }
 
-        //泛型
-        // TKey和TValue类由用用户调用函数时指定。
-        // 以下函数模拟了Python的SetDefault
+        // 泛型
+        // TKey 和 TValue 由用户调用方法时指定
+        // 以下函数模拟了 Python 的 SetDefault
         public static TValue SetDefault<TKey, TValue>(
-            IDictionary<TKey, TValue> dictionary, 
-            TKey key, 
+            IDictionary<TKey, TValue> dictionary,
+            TKey key,
             TValue defaultItem)
         {
             TValue result;
@@ -393,55 +442,125 @@ on a new line! ""Wow!"", the masses cried";
         // 你�以�定传入值的范围
         public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
         {
-            // 我们�以进行迭代，因为T是�枚举的
+            // 我们�以进行迭代，因为 T 是�枚举的
             foreach (var item in toPrint)
-                // ittm为整数
+                // item 为整数
                 Console.WriteLine(item.ToString());
         }
 
+        // YIELD
+        // 使用 "yield" 关键字表明它出现的方法是一个迭代器 Iterator
+        // (这�味�你�以在 foreach 循环中使用它)
+        public static IEnumerable<int> YieldCounter(int limit = 10)
+        {
+            for (var i = 0; i < limit; i++)
+                yield return i;
+        }
+
+        // 你�以这样调用它
+        public static void PrintYieldCounterToConsole()
+        {
+            foreach (var counter in YieldCounter())
+                Console.WriteLine(counter);
+        }
+
+        // 你�以在一个方法中使用多个 "yield return"
+        public static IEnumerable<int> ManyYieldCounter()
+        {
+            yield return 0;
+            yield return 1;
+            yield return 2;
+            yield return 3;
+        }
+
+        // 你也�以使用 "yield break" �止该迭代器
+        // 此方法�会返回从 0 到 limit 的一�值。
+        public static IEnumerable<int> YieldCounterWithBreak(int limit = 10)
+        {
+            for (var i = 0; i < limit; i++)
+            {
+                if (i > limit / 2) yield break;
+                yield return i;
+            }
+        }
+
         public static void OtherInterestingFeatures()
         {
-            // �选�数  
+            // �选�数
             MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
             MethodSignatures(3, another: 3); // 显�指定�数，忽略�选�数
 
+            // 使用 ref 和 out �数
+            int maxCount = 0, count; // ref �数必须有值
+            MethodSignatures(ref maxCount, out count);
+
             // 扩展方法
             int i = 3;
-            i.Print(); // ��下�的定义 
+            i.Print(); // ��下�的定义
 
-            // �为null的类型 对数�库交互�返回值很有用
+            // �为 null 的类型 对数�库交互�返回值很有用
             // 任何值类型 (i.e. �为类) 添加�缀 ? �会�为�为null的值
             // <类型>? <���> = <值>
             int? nullable = null; // Nullable<int> 的简写形�
             Console.WriteLine("Nullable variable: " + nullable);
             bool hasValue = nullable.HasValue; // �为null时返回真
+
             // ?? 是用于指定默认值的语法糖
             // 以防��为null的情况
             int notNullable = nullable ?? 0; // 0
 
+            // ?. 是�一个�空类型的�作符 - 简写 null 检查
+            nullable?.Print(); // 当�空类型值�为 null 的时候调用 Print() 拓展方法
+
             // ��类型推断 - 你�以让编译器推断��类型:
             var magic = "编译器确定magic是一个字符串，所以�然是类型安全的";
-            // magic = 9; // �工作，因为magic是字符串，而�是整数。 
+            // magic = 9; // �工作，因为magic是字符串，而�是整数。
 
             // 泛型
             //
-            var phonebook = new Dictionary<string, string>() { 
+            var phonebook = new Dictionary<string, string>() {
                 {"Sarah", "212 555 5555"} // 在电�簿中加入新�目
             };
 
-            // 调用上�定义为泛型的SETDEFAULT
-            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // 没有电�
-            // 你�用指定TKey�TValue，因为它们会被��地推导出�
+            // 调用上�定义为泛型的 SETDEFAULT
+            Console.WriteLine(SetDefault<string, string>(phonebook, "Shaun", "No Phone")); // No Phone
+            // 你�用指定 TKey�TValue 的类型
+            // 因为它们会被��地推导出�
             Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
 
             // lambda表达� - �许你用一行代��定函数
             Func<int, int> square = (x) => x * x; // 最�一项为返回值
             Console.WriteLine(square(3)); // 9
 
-            // �抛弃的资�管� - 让你很容易地处�未管�的资�
-            // 大多数访问未管�资� (文件�作符�设备上下文, etc.)的对象
-            // 都实现了IDisposable接�。 
-            // using语�会为你清�IDisposable对象。
+            // 错误处� - 应对�确定的世界
+            try
+            {
+                var funBike = PennyFarthing.CreateWithGears(6);
+
+                // 将��执行，因为 CreateWithGears 抛出异常
+                string some = "";
+                if (true) some = null;
+                some.ToLower(); // 抛出 NullReferenceException
+            }
+            catch (NotSupportedException)
+            {
+                Console.WriteLine("Not so much fun now!");
+            }
+            catch (Exception ex) // �获所有其他异常
+            {
+                throw new ApplicationException("It hit the fan", ex);
+                // throw; // �新抛出异常并�留调用堆栈
+            }
+            // catch { } // �获所有没有�获的异常
+            finally
+            {
+                // 在 try 或 catch 之�执行
+            }
+
+            // �抛弃的资�管� - 让你很容易地处�未托管的资�
+            // 大多数访问未托管资� (文件�柄�设备上下文, etc.) 的对象
+            // 都实现了 IDisposable 接�。
+            // using语�会为你清� IDisposable 对象
             using (StreamWriter writer = new StreamWriter("log.txt"))
             {
                 writer.WriteLine("这里没有什么�疑的东西");
@@ -450,29 +569,23 @@ on a new line! ""Wow!"", the masses cried";
             } 
 
             // 并行框架
-            // 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>();
-            
-            // 为�个请求新开一个线程
-            // 在�行下一步��并结果
-            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())
+            // https://learn.microsoft.com/zh-cn/dotnet/standard/parallel-programming/data-parallelism-task-parallel-library
+
+            var words = new List<string> {"dog", "cat", "horse", "pony"};
+
+            Parallel.ForEach(words,
+                new ParallelOptions() { MaxDegreeOfParallelism = 4 },
+                word =>
                 {
-                    responses[website] = r.ContentType;
+                    Console.WriteLine(word);
                 }
-            });
+            );
 
-            // 直到所有的请求完���会�行下�的代�
-            foreach (var key in responses.Keys)
-                Console.WriteLine("{0}:{1}", key, responses[key]);
+            // �行它会产生��的输出
+            // 因为�个线程在��的时间完�
+            // 一些�能的输出是：
+            // cat dog horse pony
+            // dog horse pony cat
 
             // 动�对象（��其他语言使用很方便）
             dynamic student = new ExpandoObject();
@@ -486,10 +599,10 @@ on a new line! ""Wow!"", the masses cried";
             // IQUERYABLE<T> - 几乎所有的集�都实现了它，
             // 带给你 Map / Filter / Reduce 风格的方法
             var bikes = new List<Bicycle>();
-            bikes.Sort(); // Sorts the array
+            bikes.Sort(); // 排� array
             bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // 根�车轮数排�
             var result = bikes
-                .Where(b => b.Wheels > 3) // 筛选 - �以连�使用 （返回IQueryable)
+                .Where(b => b.Wheels > 3) // 筛选 - �以连�使用 （返回 IQueryable)
                 .Where(b => b.IsBroken && b.HasTassles)
                 .Select(b => b.ToString()); // Map - 这里我们使用了select，所以结果是IQueryable<string>
 
@@ -502,19 +615,19 @@ on a new line! ""Wow!"", the masses cried";
                 Console.WriteLine(bikeSummary.Name);
 
             // ASPARALLEL
-            // 邪�的特性 —— 组�了linq和并行�作
+            // 这就是事情开始棘手的地方 —— 组�了 linq 和并行�作
             var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
             // 以上代�会并�地�行。会自动新开线程，分别计算结果。
             // 适用于多核�大数��的场景。
 
-            // LINQ - 将IQueryable<T>映射到存储，延缓执行
+            // LINQ - 映射一组 IQueryable<T> 对象，并延迟执行
             // 例如 LinqToSql 映射数�库, LinqToXml 映射XML文档
             var db = new BikeRespository();
 
-            // 执行被延迟了，这对于查询数�库�说很好
+            // 执行被延迟了，这对于查询数�库�说�常好
             var filter = db.Bikes.Where(b => b.HasTassles); // ��行查询
             if (42 > 6) // 你�以�断地增加筛选，包括有�件的筛选，例如用于“高级�索�功能
-                filter = filter.Where(b => b.IsBroken); // ��行查询 
+                filter = filter.Where(b => b.IsBroken); // ��行查询
 
             var query = filter
                 .OrderBy(b => b.Wheels)
@@ -541,15 +654,64 @@ on a new line! ""Wow!"", the masses cried";
             Console.WriteLine(obj.ToString());
         }
     }
+
+
+    // 委托 和 事件
+    public class DelegateTest
+    {
+        public static int count = 0;
+        public static int Increment()
+        {
+            // 增加 count 然�返回它
+            return ++count;
+        }
+
+        // 委托是一个方法的引用.
+        // �引用 Increment 方法,
+        // 首先声明一个具有相�签�的委托,
+        // i.e. �带�数并返回 int
+        public delegate int IncrementDelegate();
+
+        // 事件也�用于触�委托
+        // 使用委托类型创建事件
+        public static event IncrementDelegate MyEvent;
+
+        static void Main(string[] args)
+        {
+            // 通过实例化委托�引用 Increment 方法
+            // 并将方法本身作为�数传递
+            IncrementDelegate inc = new IncrementDelegate(Increment);
+            Console.WriteLine(inc());  // => 1
+
+            // 委托�以用 + �算符组�
+            IncrementDelegate composedInc = inc;
+            composedInc += inc;
+            composedInc += inc;
+
+            // composedInc 将执行 Increment 3 次
+            Console.WriteLine(composedInc());  // => 4
+
+
+            // 为事件订阅与委托
+            MyEvent += new IncrementDelegate(Increment);
+            MyEvent += new IncrementDelegate(Increment);
+
+            // 触�事件
+            // ie. �行这个事件所有的委托订阅
+            Console.WriteLine(MyEvent());  // => 6
+        }
+    }
+
+
     // 声明类的语法：
     // <public/private/protected/internal> class <类�>{
-    //    //数�字段, 构造器, 内部函数.
-    /     // 在Java中函数被称为方法。
+    //    // 数�字段, 构造器, 内部函数
+    //    // 在Java中函数被称为方法
     // }
 
     public class Bicycle
     {
-        // 自行车的字段���
+        // 自行车的字段/��
         public int Cadence // Public: 任何地方都�以访问
         {
             get // get - 定义获�属性的方法
@@ -558,30 +720,35 @@ on a new line! ""Wow!"", the masses cried";
             }
             set // set - 定义设置属性的方法
             {
-                _cadence = value; // value是被传递给setter的值
+                _cadence = value; // value 是被传递给 setter 的值
             }
         }
         private int _cadence;
 
-        protected virtual int Gear // 类和�类�以访问
+        protected virtual int Gear // Protected: 类和�类�以访问
         {
             get; // 创建一个自动属性，无需�员字段
             set;
         }
 
-        internal int Wheels // Internal:在�一程�集内�以访问
+        internal int Wheels // Internal: 在�一程�集内�以访问
         {
             get;
-            private set; // �以给get/set方法添加修饰符
+            private set; // �以给 get/set 方法添加修饰符
         }
 
-        int _speed; // 默认为private: ��以在这个类内访问，你也�以使用`private`关键�
+        int _speed; // 类中的任何内容默认为 private: ��以在这个类内访问
+                    // 你也�以使用 `private` 关键�显�指定
         public string Name { get; set; }
 
-        // enum类型包�一组常�
+        // 当您想�一个仅返回表达�结果的�读属性时，
+        // 属性还具有特殊的语法
+        public string LongName => Name + " " + _speed + " speed";
+
+        // enum 枚举是一�值类型，由一组命�常�组�
         // 它将�称映射到值（除�特别说明，是一个整型）
-        // enmu元素的类型�以是byte�sbyte�short�ushort�int�uint�long�ulong。
-        // enum�能包�相�的值。
+        // enmu 元素的类型�以是 byte�sbyte�short�ushort�int�uint�long�ulong
+        // enum �能包�相�的值
         public enum BikeBrand
         {
             AIST,
@@ -589,13 +756,32 @@ on a new line! ""Wow!"", the masses cried";
             Electra = 42, //你�以显�地赋值
             Gitane // 43
         }
-        // 我们在Bicycle类中定义的这个类型，所以它是一个内嵌类型。
-        // 这个类以外的代�应当使用`Bicycle.Brand`�引用。
+        // 我们在 Bicycle 类中定义的这个类型，所以它是一个内嵌类型
+        // 这个类以外的代�应当使用 `Bicycle.Brand` �引用
+
+        public BikeBrand Brand; // 声明一个 enum 类型之�，我们�以声明这个类型的字段
+
+        // 使用 FlagsAttribute 定义枚举，表示有多个值�以被匹�
+        // 任何从 Attribute 派生的类都�以用�修饰类型�方法��数等
+        // ��算符 & 和 | �用于 和/或 �作
+
+        [Flags]
+        public enum BikeAccessories
+        {
+            None = 0,
+            Bell = 1,
+            MudGuards = 2, // 需�手动设定值!
+            Racks = 4,
+            Lights = 8,
+            FullPackage = Bell | MudGuards | Racks | Lights
+        }
 
-        public BikeBrand Brand; // 声明一个enum类型之�，我们�以声明这个类型的字段
+        // 用法: aBike.Accessories.HasFlag(Bicycle.BikeAccessories.Bell)
+        // 在 .NET 4 之�: (aBike.Accessories & Bicycle.BikeAccessories.Bell) == Bicycle.BikeAccessories.Bell
+        public BikeAccessories Accessories { get; set; }
 
-        // ��方法的类型为自身，�属于特定的对象。
-        // 你无需引用对象就�以访问他们。
+        // ��方法属于类型自身，�属于特定的对象
+        // 你无需通过对象就�以访问他们
         // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
         static public int BicyclesCreated = 0;
         
@@ -607,7 +793,7 @@ on a new line! ""Wow!"", the masses cried";
         // 下�是一个默认的构造器
         public Bicycle() 
         {
-            this.Gear = 1; // 你�以使用关键�this访问对象的�员
+            this.Gear = 1; // 你�以使用关键� this 访问对象的�员
             Cadence = 50;  // �过你并�总是需�它
             _speed = 5;
             Name = "Bontrager";
@@ -618,7 +804,7 @@ on a new line! ""Wow!"", the masses cried";
         // �一个构造器的例�（包��数）
         public Bicycle(int startCadence, int startSpeed, int startGear,
                        string name, bool hasCardsInSpokes, BikeBrand brand) 
-            : base() // 首先调用base
+            : base() // 显�调用基类的无�构造方法
         {
             Gear = startGear; 
             Cadence = startCadence;
@@ -637,8 +823,9 @@ on a new line! ""Wow!"", the masses cried";
         // 函数语法
         // <public/private/protected> <返回值> <函数�称>(<�数>)
 
-        // 类�以为字段实现 getters 和 setters 方法 for their fields
-        // 或者�以实现属性（C#推�使用这个）
+        // 类�以为其字段实现 getters 和 setters 方法
+        // 或者�以使用属性�装字段（C#推�使用这个）
+
         // 方法的�数�以有默认值
         // 在有默认值的情况下，调用方法的时候�以�略相应的�数
         public void SpeedUp(int increment = 1)
@@ -652,8 +839,8 @@ on a new line! ""Wow!"", the masses cried";
         }
 
         // 属性�以访问和设置值
-        // 当�需�访问数�的时候，考虑使用属性。
-        // 属性�以定义get和set，或者是�时定义两者
+        // 当�需�外部访问数�的时候，考虑使用属性。
+        // 属性�以定义 get 和 set，或者是�时定义两者
         private bool _hasTassles; // private variable
         public bool HasTassles // public accessor
         {
@@ -663,7 +850,7 @@ on a new line! ""Wow!"", the masses cried";
         
         // 你�以在一行之内定义自动属性
         // 这个语法会自动创建�备字段
-        // 你�以给getter或setter设置访问修饰符
+        // 你�以给 getter 或 setter 设置访问修饰符
         // 以便�制它们的访问
         public bool IsBroken { get; private set; }
 
@@ -671,12 +858,29 @@ on a new line! ""Wow!"", the masses cried";
         public int FrameSize
         {
             get;
-            // 你�以给get或set指定访问修饰符
-            // 以下代��味��有Bicycle类�以调用Framesize的set
+            // 你�以给 get 或 set 指定访问修饰符
+            // 以下代��味��有 Bicycle 类�以调用 Framesize 的 set
             private set;
         }
 
-        //显示对象属性的方法
+        // 还�以在对象上定义自定义索引器
+        // 尽管这在本例中并�完全有用, you
+        // 你�以使用 bicycle[0] 返回 "chris" �获得第一项
+        // 或者 bicycle[1] = "lisa" �设定值
+        private string[] passengers = { "chris", "phil", "darren", "regina" };
+
+        public string this[int i]
+        {
+            get {
+                return passengers[i];
+            }
+
+            set {
+                passengers[i] = value;
+            }
+        }
+
+        // 显示对象属性的方法
         public virtual string Info()
         {
             return "Gear: " + Gear +
@@ -698,7 +902,7 @@ on a new line! ""Wow!"", the masses cried";
 
     } //  Bicycle类结�
 
-    // PennyFarthing是Bicycle的一个�类
+    // PennyFarthing 是 Bicycle 的一个�类
     class PennyFarthing : Bicycle
     {
         // (Penny Farthings是一��轮很大的自行车。没有齿轮。）
@@ -717,10 +921,17 @@ on a new line! ""Wow!"", the masses cried";
             }
             set
             {
-                throw new ArgumentException("你��能在PennyFarthing上切�齿轮");
+                throw new ArgumentException("你��能在 PennyFarthing 上切�齿轮");
             }
         }
 
+        public static PennyFarthing CreateWithGears(int gears)
+        {
+            var penny = new PennyFarthing(1, 1);
+            penny.Gear = gears; // 你�能这样�!
+            return penny;
+        }
+
         public override string Info()
         {
             string result = "PennyFarthing bicycle ";
@@ -732,7 +943,7 @@ on a new line! ""Wow!"", the masses cried";
     // 接��包��员的签�，而没有实现。
     interface IJumpable
     {
-        void Jump(int meters); // 所有接��员是��地公开的
+        void Jump(int meters); // 所有接��员是��地公开的 public
     }
 
     interface IBreakable
@@ -741,6 +952,8 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     // 类�能继承一个类，但是�以实现任�数�的接�
+    // 但是基类�称必须是列表中的第一个，所有接�都在��
+    class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
 
@@ -759,41 +972,374 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     /// <summary>
-    /// 连接数�库，一个 LinqToSql的示例。
+    /// 连接数�库，一个 LinqToSql 的示例。
     /// EntityFramework Code First 很棒 (类似 Ruby的 ActiveRecord, �过是��的)
-    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+    /// https://learn.microsoft.com/zh-cn/ef/ef6/modeling/code-first/workflows/new-database
     /// </summary>
-    public class BikeRespository : DbSet
+    public class BikeRepository : DbContext
     {
-        public BikeRespository()
+        public BikeRepository()
             : base()
         {
         }
 
         public DbSet<Bicycle> Bikes { get; set; }
     }
+
+    // 一个类�以通过 partial 关键字分别写在多个 .cs 文件中
+    // A1.cs
+    public partial class A
+    {
+        public static void A1()
+        {
+            Console.WriteLine("Method A1 in class A");
+        }
+    }
+
+    // A2.cs
+    public partial class A
+    {
+        public static void A2()
+        {
+            Console.WriteLine("Method A2 in class A");
+        }
+    }
+
+    // 使用 partial 类 "A"
+    public class Program
+    {
+        static void Main()
+        {
+            A.A1();
+            A.A2();
+        }
+    }
+
+    // 通过在字符串�加上 $ �缀�进行字符串�值
+    // 并用 { 大括� } 包裹��值的表达�
+    // 您还�以将�值字符串和�字字符串与 $@ 组�起�
+    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}");
+
+            string username = "User";
+            Console.WriteLine($@"C:\Users\{username}\Desktop");
+        }
+    }
+
+    // C# 6 新特性
+    class GlassBall : IJumpable, IBreakable
+    {
+        // 自动属性设置�始值
+        public int Damage { get; private set; } = 0;
+
+        // 为仅有 getter 的自动属性设定�始值
+        public string Name { get; } = "Glass ball";
+
+        // 在构造函数中�始化的仅有 getter 的自动属性
+        public string GenieName { get; }
+
+        public GlassBall(string genieName = null)
+        {
+            GenieName = genieName;
+        }
+
+        public void Jump(int meters)
+        {
+            if (meters < 0)
+                // 新的 nameof() 表达�; 编译器将检查标识符是�存在
+                // nameof(x) == "x"
+                // 预防 例如 �数�称已更改但错误消�中未更新
+                throw new ArgumentException("Cannot jump negative amount!", nameof(meters));
+
+            Damage += meters;
+        }
+
+        // 表达�主体 expression-bodied 属性 ...
+        public bool Broken
+            => Damage > 100;
+
+        // ... 刚�
+        public override string ToString()
+            // �值字符串
+            => $"{Name}. Damage taken: {Damage}";
+
+        public string SummonGenie()
+            // Null �件�算符
+            // x?.y 如果 x 为 null 将立�返回 null; y 将�会求值
+            => GenieName?.ToUpper();
+    }
+
+    static class MagicService
+    {
+        private static bool LogException(Exception ex)
+        {
+            // 记录�处的异常
+            return false;
+        }
+
+        public static bool CastSpell(string spell)
+        {
+            try
+            {
+                // �设我们在这里调用 API
+                throw new MagicServiceException("Spell failed", 42);
+
+                // Spell succeeded
+                return true;
+            }
+            // 仅当 Code 为 42（Spell failed）时��获
+            catch(MagicServiceException ex) when (ex.Code == 42)
+            {
+                // Spell failed
+                return false;
+            }
+            // 其他异常，或 MagicServiceException 的 Code �是 42
+            catch(Exception ex) when (LogException(ex))
+            {
+                // 永远�会执行到这�代�
+                // 堆栈未展开
+            }
+            return false;
+            // 请注�，�获 MagicServiceException
+            // 并在 Code �是 42 或 117 时�新抛出是��的
+            // 因为最终的 catch-all �将�会�获�新抛出的异常
+        }
+    }
+
+    public class MagicServiceException : Exception
+    {
+        public int Code { get; }
+
+        public MagicServiceException(string message, int code) : base(message)
+        {
+            Code = code;
+        }
+    }
+
+    public static class PragmaWarning {
+        // 过时的属性
+        [Obsolete("Use NewMethod instead", false)]
+        public static void ObsoleteMethod()
+        {
+            // obsolete code
+        }
+
+        public static void NewMethod()
+        {
+            // new code
+        }
+
+        public static void Main()
+        {
+            ObsoleteMethod(); // CS0618: 'ObsoleteMethod 已过时：使用 NewMethod 代替'
+#pragma warning disable CS0618
+            ObsoleteMethod(); // no warning
+#pragma warning restore CS0618
+            ObsoleteMethod(); // CS0618: 'ObsoleteMethod 已过时：使用 NewMethod 代替'
+        }
+    }
 } // 结� Namespace
+
+using System;
+// C# 6, ��引用
+using static System.Math;
+
+namespace Learning.More.CSharp
+{
+    class StaticUsing
+    {
+        static void Main()
+        {
+            // �使用��引用时..
+            Console.WriteLine("The square root of 4 is {}.", Math.Sqrt(4));
+            // 使用时
+            Console.WriteLine("The square root of 4 is {}.", Sqrt(4));
+        }
+    }
+}
+
+// C# 7 新特性
+// 使用 Nuget 安装 Microsoft.Net.Compilers 最新版
+// 使用 Nuget 安装 System.ValueTuple 最新版
+using System;
+namespace Csharp7
+{
+    // 元组 TUPLES, �构 DECONSTRUCTION 和 弃元 DISCARDS
+    class TuplesTest
+    {
+        public (string, string) GetName()
+        {
+            // 元组中的字段默认命�为 Item1�Item2...
+            var names1 = ("Peter", "Parker");
+            Console.WriteLine(names1.Item2);  // => Parker
+
+            // 字段�以显�命�
+            // 第 1 �声明
+            (string FirstName, string LastName) names2 = ("Peter", "Parker");
+
+            // 第 2 �声明
+            var names3 = (First:"Peter", Last:"Parker");
+
+            Console.WriteLine(names2.FirstName);  // => Peter
+            Console.WriteLine(names3.Last);  // => Parker
+
+            return names3;
+        }
+
+        public string GetLastName() {
+            var fullName = GetName();
+
+            // 元组�以被�构
+            (string firstName, string lastName) = fullName;
+
+            // �构获得的字段�以使用 弃元 _ 丢弃
+            var (_, last) = fullName;
+            return last;
+        }
+
+        // 通过指定�构方法，
+        // �以以相�的方�解构任何类型
+        public int randomNumber = 4;
+        public int anotherRandomNumber = 10;
+
+        public void Deconstruct(out int randomNumber, out int anotherRandomNumber)
+        {
+            randomNumber = this.randomNumber;
+            anotherRandomNumber = this.anotherRandomNumber;
+        }
+
+        static void Main(string[] args)
+        {
+            var tt = new TuplesTest();
+            (int num1, int num2) = tt;
+            Console.WriteLine($"num1: {num1}, num2: {num2}");  // => num1: 4, num2: 10
+
+            Console.WriteLine(tt.GetLastName());
+        }
+    }
+
+    // 模�匹�
+    class PatternMatchingTest
+    {
+        public static (string, int)? CreateLogMessage(object data)
+        {
+            switch(data)
+            {
+                // 使用 when 进行附加过滤
+                case System.Net.Http.HttpRequestException h when h.Message.Contains("404"):
+                    return (h.Message, 404);
+                case System.Net.Http.HttpRequestException h when h.Message.Contains("400"):
+                    return (h.Message, 400);
+                case Exception e:
+                    return (e.Message, 500);
+                case string s:
+                    return (s, s.Contains("Error") ? 500 : 200);
+                case null:
+                    return null;
+                default:
+                    return (data.ToString(), 500);
+            }
+        }
+    }
+
+    // Reference �� / ref 局部��
+    // �许返回对象的引用而�仅仅是其值
+    class RefLocalsTest
+    {
+        // 返回值�标明 ref
+        public static ref string FindItem(string[] arr, string el)
+        {
+            for(int i=0; i<arr.Length; i++)
+            {
+                if(arr[i] == el) {
+                    // 返回引用
+                    return ref arr[i];
+                }
+            }
+            throw new Exception("Item not found");
+        }
+
+        public static void SomeMethod()
+        {
+            string[] arr = {"this", "is", "an", "array"};
+
+            // �在所有地方使用 ref
+            ref string item = ref FindItem(arr, "array");
+            item = "apple";
+            Console.WriteLine(arr[3]);  // => apple
+        }
+    }
+
+    // 本地函数 LOCAL FUNCTIONS
+    class LocalFunctionTest
+    {
+        private static int _id = 0;
+        public int id;
+        public LocalFunctionTest()
+        {
+            id = generateId();
+
+            // 这个本地函数�能在此作用域中被访问
+            int generateId()
+            {
+                return _id++;
+            }
+        }
+
+        public static void AnotherMethod()
+        {
+            var lf1 = new LocalFunctionTest();
+            var lf2 = new LocalFunctionTest();
+            Console.WriteLine($"{lf1.id}, {lf2.id}");  // => 0, 1
+
+            int id = generateId();
+            // error CS0103: 当�上下文中�存在�称“generateId�
+        }
+    }
+}
+
 ```
 
 ## 没有涉�到的主题
+✨ 新的, � 旧的, 🎈 长期支�的, 🔥 跨平�的, � �支�Windows的
+
+ * 特性 Attributes
+
+ * 异步编程
+
+ * Web 开�
+    * ASP.NET Core ✨
+
+ * 桌�应用开� Development
+    * Windows Presentation Foundation (WPF) � 🎈 �
+    * Universal Windows Platform (UWP) ✨ �
+    * Uno Platform 🔥 ✨
+    * WinForms � 🎈 �
+    * Avalonia 🔥 ✨
+    * WinUI ✨ �
 
- * Flags
- * Attributes
- * ��属性
- * Exceptions, Abstraction
- * ASP.NET (Web Forms/MVC/WebMatrix)
- * Winforms
- * Windows Presentation Foundation (WPF)
+ * 跨平�开�
+    * Xamarin.Forms �
+    * MAUI ✨
 
 ## 扩展阅读
 
+ * [C# language reference](https://docs.microsoft.com/dotnet/csharp/language-reference/)
+ * [Learn .NET](https://dotnet.microsoft.com/learn)
+ * [C# Coding Conventions](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/inside-a-program/coding-conventions)
  * [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)
+ * [Programming C# 5.0](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ Pocket Reference](http://shop.oreilly.com/product/9780596519254.do)
  * [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)
+ * [freeCodeCamp - C# Tutorial for Beginners](https://www.youtube.com/watch?v=GhQdlIFylQ8)
diff --git a/zh-cn/docker-cn.html.markdown b/zh-cn/docker-cn.html.markdown
new file mode 100644
index 00000000..ff793ae0
--- /dev/null
+++ b/zh-cn/docker-cn.html.markdown
@@ -0,0 +1,150 @@
+---
+category: tool
+tool: docker
+lang: zh-cn
+filename: docker-cn.bat
+contributors:
+    - ["Ruslan López", "http://javapro.org/"]
+translators:
+    - ["imba-tjd", "https://github.com/imba-tjd/"]
+---
+
+```bat
+:: 下载�安装��行 hello-world 镜�(image)
+docker run hello-world
+
+:: :: 如果这是第一次�行，你应该能�到这些信�
+:: Unable to find image 'hello-world:latest' locally # 在本地找�到镜�xxx
+:: latest: Pulling from library/hello-world
+:: 1b930d010525: Pull complete
+::   Digest: sha256:4fe721ccc2e8dc7362278a29dc660d833570ec2682f4e4194f4ee23e415e1064
+:: Status: Downloaded newer image for hello-world:latest
+::
+:: Hello from Docker! # �自Docker的欢迎
+:: This message shows that your installation appears to be working correctly. # 此信�表明你的安装似乎�功了
+::
+:: To generate this message, Docker took the following steps: # Docker进行了如下步骤�产生此信�
+:: 1. The Docker client contacted the Docker daemon. # Docker客户端�系Docker守护程�
+:: 2. The Docker daemon pulled the "hello-world" image from the Docker Hub. # Docker守护程�从Docker Hub拉�镜�
+::     (amd64)
+:: 3. The Docker daemon created a new container from that image which runs the # Docker守护程�从镜�中创建了一个容器
+::     executable that produces the output you are currently reading. # �行了产生你正在读的输出的�执行文件
+:: 4. The Docker daemon streamed that output to the Docker client, which sent it # Docker守护程�把输出��传输给Docker客户端，�者��到你的终端上
+::     to your terminal.
+::
+:: To try something more ambitious, you can run an Ubuntu container with: # 若��试更强大的东西，你�以用该命令�行Ubuntu容器
+::  $ docker run -it ubuntu bash
+::
+:: Share images, automate workflows, and more with a free Docker ID: # 使用�费的Docker ID�分享镜�，自动化工作�等
+::  https://hub.docker.com/
+::
+:: For more examples and ideas, visit: # 欲获�更多例�和想法，访问
+:: https://docs.docker.com/get-started/
+
+:: 现在�看看当�正�行的镜�
+docker ps
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS
+::   NAMES
+
+:: 看看之��行过的镜�
+docker ps -a
+
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS
+::          NAMES
+:: 4a76281f9c53        hello-world         "/hello"            2 minutes ago       Exited (0) 2 minutes ago
+::          happy_poincare
+:: �字(name)是自动生�的，因此它会和你的��
+
+:: 移除(remove)我们之�生�的镜�
+docker rm happy_poincare
+
+:: 测试是�真的删除了
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS
+::   NAMES
+
+:: 为容器(container)指定自定义�字
+docker run --name test_container hello-world
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+::
+:: To generate this message, Docker took the following steps:
+::  1. The Docker client contacted the Docker daemon.
+::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+::  3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+::  4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+::
+:: To try something more ambitious, you can run an Ubuntu container with:
+:: $ docker run -it ubuntu bash
+::
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+::
+:: For more examples and ideas, visit:
+::  https://docs.docker.com/get-started/
+
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                         PORTS
+::               NAMES
+:: d345fe1a4f41        hello-world         "/hello"            About a minute ago   Exited (0) About a minute ago
+::                test_container
+:: 如你所�，�字现在是我们指定的了
+
+:: 从命�过的容器中获�日志(logs)
+docker logs test_container
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+::
+:: To generate this message, Docker took the following steps:
+::  1. The Docker client contacted the Docker daemon.
+::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+::  3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+::  4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+::
+:: To try something more ambitious, you can run an Ubuntu container with:
+:: $ docker run -it ubuntu bash
+::
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+::
+:: For more examples and ideas, visit:
+::  https://docs.docker.com/get-started/
+
+docker rm test_container
+
+docker run ubuntu
+::  Unable to find image 'ubuntu:latest' locally
+::  latest: Pulling from library/ubuntu
+::  2746a4a261c9: Pull complete
+::                                                        4c1d20cdee96: Pull complete                                                                                                                                                 0d3160e1d0de: Pull complete                                                                                                                                                 c8e37668deea: Pull complete                                                                                                                                                 Digest: sha256:250cc6f3f3ffc5cdaa9d8f4946ac79821aafb4d3afc93928f0de9336eba21aa4
+::  Status: Downloaded newer image for ubuntu:latest
+
+docker ps -a
+::  CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS
+::           NAMES
+::  c19e9e5b000a        ubuntu              "/bin/bash"         5 seconds ago       Exited (0) 4 seconds ago
+::           relaxed_nobel
+
+::  在交互模�(interactive mode)下�行容器
+docker run -it ubuntu
+::  root@e2cac48323d2:/# uname
+::  Linux
+::  root@e2cac48323d2:/# exit
+::  exit
+
+docker rm relaxed_nobel
+
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                          PORTS
+::               NAMES
+:: e2cac48323d2        ubuntu              "/bin/bash"         2 minutes ago       Exited (0) About a minute ago
+::               nifty_goldwasser
+
+docker rm nifty_goldwasser
+```
diff --git a/zh-cn/dynamic-programming-cn.html.markdown b/zh-cn/dynamic-programming-cn.html.markdown
index b75c5404..7864c22a 100644
--- a/zh-cn/dynamic-programming-cn.html.markdown
+++ b/zh-cn/dynamic-programming-cn.html.markdown
@@ -15,7 +15,7 @@ translators:
 
 动�规划是一�实用的技巧，它�以用�解决一系列特定问题。它的�路很简�，如果你对�个给定的输入解决了一个问题，那么你�以�存已有信�，以����计算，节约计算时间。
 
-记�，�有那些没有办法记�历�的�被迫�更多的苦力。(Fibonacci就是一个显然的例�)
+记�，如果忘记历�，就�被迫�更多的苦力。�波那契数列就是一个显然的例�。
 
 ## 解决问题的方�
 
diff --git a/zh-cn/elisp-cn.html.markdown b/zh-cn/elisp-cn.html.markdown
index 3f6ccbcf..a429fcbc 100644
--- a/zh-cn/elisp-cn.html.markdown
+++ b/zh-cn/elisp-cn.html.markdown
@@ -1,345 +1,345 @@
----

-language: elisp

-contributors:

-    - ["Bastien Guerry", "http://bzg.fr"]

-translators:

-    - ["Chenbo Li", "http://binarythink.net"]

-filename: learn-emacs-lisp-zh.el

-lang: zh-cn

----

-

-```scheme

-;; 15分钟学会Emacs Lisp (v0.2a)

-;;（作者：bzg，https://github.com/bzg 

-;;  译者：lichenbo，http://douban.com/people/lichenbo）

-;;

-;; 请先阅读Peter Norvig的一篇好文:

-;; http://norvig.com/21-days.html

-;; （译者注：中文版请�http://blog.youxu.info/21-days/）

-;;

-;; 之�安装GNU Emacs 24.3:

-;;

-;; Debian: apt-get install emacs (视具体�行版而定)

-;; 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

-;;

-;; 更多信��以在这里找到:

-;; http://www.gnu.org/software/emacs/#Obtaining

- 

-;; 很��的警告:

-;;

-;; 按照这个教程�学习并�会对你的电脑有任何��

-;; 除�你自己在学习的过程中愤怒地把它砸了

-;; 如果出现了这�情况，我�会承担任何责任

-;;

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-;; 

-;; 打开emacs

-;;

-;; 按'q'消除欢迎界�

-;;

-;; 现在请注�窗�底部的那一个�色长�

-;;

-;; "*scratch*" 是你现在编辑界�的�字。

-;; 这个编辑界���一个"buffer"。

-;;

-;; �当你打开Emacs时，都会默认打开这个scratch buffer

-;; 此时你并没有在编辑任何文件，而是在编辑一个buffer

-;; 之�你�以将这个buffer�存到一个文件中。

-;; 

-;; 之�的"Lisp interaction" 则是表明我们�以用的�组命令

-;; 

-;; Emacs在�个buffer中都有一组内置的命令

-;; 而当你激活��特定的模�时，就�以使用相应的命令

-;; 这里我们使用`lisp-interaction-mode'，

-;; 这样我们就�以使用内置的Emacs Lisp（以下简称Elisp）命令了。

- 

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-;;

-;; 分�是注释开始的标志

-;;

-;; Elisp 是由符�表达�构�的 (�"s-表达�"或"s�"):

-(+ 2 2)

- 

-;; 这个s�的��是 "对2进行加2�作".

- 

-;; s�周围有括�，而且也�以嵌套:

-(+ 2 (+ 1 1))

- 

-;; 一个s��以包�原�符�或者其他s�

-;; 在上�的例�中，1和2是原�符�

-;; (+ 2 (+ 1 1)) 和 (+ 1 1) 是s�.

- 

-;; 在 `lisp-interaction-mode' 中你�以计算s�.

-;; 把光标移到闭括��，之�按下ctrl+j（以�简写为'C-j'）

- 

-(+ 3 (+ 1 2))

-;;           ^ 光标放到这里

-;; 按下`C-j' 就会输出 6

- 

-;; `C-j' 会在buffer中�入当��算的结果

- 

-;; 而`C-xC-e' 则会在emacs最底部显示结果，也就是被称作"minibuffer"的区域

-;; 为了��把我们的buffer填满无用的结果，我们以�会一直用`C-xC-e'

- 

-;; `setq' �以将一个值赋给一个��

-(setq my-name "Bastien")

-;; `C-xC-e' 输出 "Bastien" (在 mini-buffer 中显示)

- 

-;; `insert' 会在光标处�入字符串:

-(insert "Hello!")

-;; `C-xC-e' 输出 "Hello!"

- 

-;; 在这里我们�传给了insert一个�数"Hello!", 但是

-;; 我们也�以传给它更多的�数，比如2个：

- 

-(insert "Hello" " world!")

-;; `C-xC-e' 输出 "Hello world!"

- 

-;; 你也�以用����代替字符串

-(insert "Hello, I am " my-name)

-;; `C-xC-e' 输出 "Hello, I am Bastien"

- 

-;; 你�以把s�嵌入函数中

-(defun hello () (insert "Hello, I am " my-name))

-;; `C-xC-e' 输出 hello

- 

-;; 现在执行这个函数

-(hello)

-;; `C-xC-e' 输出 Hello, I am Bastien

- 

-;; 函数中空括�的��是我们�需�接�任何�数

-;; 但是我们�能一直总是用my-name这个��

-;; 所以我们现在使我们的函数接�一个��"name"的�数 

- 

-(defun hello (name) (insert "Hello " name))

-;; `C-xC-e' 输出 hello

- 

-;; 现在我们调用这个函数，并且将"you"作为�数传递

- 

-(hello "you")

-;; `C-xC-e' 输出 "Hello you"

- 

-;; �功�

- 

-;; 现在我们�以休�一下

- 

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-;;

-;; 下�我们在新的窗�中新建一个�为 "*test*" 的buffer:

- 

-(switch-to-buffer-other-window "*test*")

-;; `C-xC-e' 这时�幕上会显示两个窗�，而光标此时�于*test* buffer内

- 

-;; 用鼠标�击上�的buffer就会使光标移回。

-;; 或者你�以使用 `C-xo' 使得光标跳到�一个窗�中

- 

-;; 你�以用 `progn'命令将s�结�起�:

-(progn

-  (switch-to-buffer-other-window "*test*")

-  (hello "you"))

-;; `C-xC-e' 此时�幕分为两个窗�，并且在*test* buffer中显示"Hello you"

- 

-;; 现在为了简�，我们需�在�个s���都使用`C-xC-e'�执行，��就��说明了

- 

-;; 记得�以用过鼠标或者`C-xo'回到*scratch*这个buffer。

- 

-;; 清除当�buffer也是常用�作之一：

-(progn

-  (switch-to-buffer-other-window "*test*")

-  (erase-buffer)

-  (hello "there"))

- 

-;; 也�以回到其他的窗�中

-(progn

-  (switch-to-buffer-other-window "*test*")

-  (erase-buffer)

-  (hello "you")

-  (other-window 1))

- 

-;; 你�以用 `let' 将一个值和一个局部��绑定:

-(let ((local-name "you"))

-  (switch-to-buffer-other-window "*test*")

-  (erase-buffer)

-  (hello local-name)

-  (other-window 1))

- 

-;; 这里我们就�需�使用 `progn' 了， 因为 `let' 也�以将很多s�组�起�。

- 

-;; 格�化字符串的方法：

-(format "Hello %s!\n" "visitor")

- 

-;; %s 是字符串��符，这里被"visitor"替代.

-;; \n 是�行符。

- 

-;; 现在我们用格�化的方法��写一下我们的函数:

-(defun hello (name)

-  (insert (format "Hello %s!\n" name)))

- 

-(hello "you")

- 

-;; 我们�用`let'新建�一个函数:

-(defun greeting (name)

-  (let ((your-name "Bastien"))

-    (insert (format "Hello %s!\n\nI am %s."

-                    name       ; the argument of the function

-                    your-name  ; the let-bound variable "Bastien"

-                    ))))

- 

-;; 之�执行:

-(greeting "you")

- 

-;; 有些函数�以和用户交互:

-(read-from-minibuffer "Enter your name: ")

- 

-;; 这个函数会返回在执行时用户输入的信�

- 

-;; 现在我们让`greeting'函数显示你的�字:

-(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 ; the argument of the function

-                    your-name ; the let-bound var, entered at prompt

-                    ))))

- 

-(greeting "Bastien")

- 

-;; 我们让结果在�一个窗�中显示:

-(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)))

- 

-;; 测试一下：

-(greeting "Bastien")

- 

-;; 第二节结�，休�一下�。

- 

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-;;

-;; 我们将一些�字存到列表中：

-(setq list-of-names '("Sarah" "Chloe" "Mathilde"))

- 

-;; 用 `car'��得第一个�字：

-(car list-of-names)

- 

-;; 用 `cdr'�得剩下的�字:

-(cdr list-of-names)

- 

-;; 用 `push'把�字添加到列表的开头:

-(push "Stephanie" list-of-names)

- 

-;; 注�: `car' 和 `cdr' 并�修改列表本身, 但是 `push' �会对列表本身进行�作.

-;; 这个区别是很��的: 有些函数没有任何副作用（比如`car'）

-;; 但还有一些�是有的 (比如 `push').

- 

-;; 我们�对`list-of-names'列表中的�一个元素都使用hello函数:

-(mapcar 'hello list-of-names)

- 

-;; 将 `greeting' 改进，使的我们能够对`list-of-names'中的所有�字执行:

-(defun greeting ()

-    (switch-to-buffer-other-window "*test*")

-    (erase-buffer)

-    (mapcar 'hello list-of-names)

-    (other-window 1))

- 

-(greeting)

- 

-;; 记得我们之�定义的 `hello' 函数�？ 这个函数接�一个�数，�字。

-;; `mapcar' 调用 `hello', 并将`list-of-names'作为�数先�传给`hello'

- 

-;; 现在我们对显示的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)) 将光标移到buffer的开始

-;; (search-forward "Hello") 查找字符串"Hello"

-;; (while x y) 当x返回�个值时执行y这个s�

-;; 当x返回`nil' (空), 退出循环

- 

-(replace-hello-by-bonjour)

- 

-;; 你会看到所有在*test* buffer中出现的"Hello"字样都被��了"Bonjour"

- 

-;; 你也会得到以下错误�示: "Search failed: Hello".

-;;

-;; 如果���这个错误, 你需�告诉 `search-forward' 这个命令是�在

-;; buffer的�个地方�止查找, 并且在什么都没找到时是�应该�给出错误�示

- 

-;; (search-forward "Hello" nil t) �以达到这个�求:

- 

-;; `nil' �数的��是 : 查找并��于�个范围内

-;; `t' �数的��是: 当什么都没找到时，�给出错误�示

- 

-;; 在下�的函数中，我们用到了s�，并且�给出任何错误�示:

- 

-(defun hello-to-bonjour ()

-    (switch-to-buffer-other-window "*test*")

-    (erase-buffer)

-    ;; 为`list-of-names'中的�个�字调用hello

-    (mapcar 'hello list-of-names)

-    (goto-char (point-min))

-    ;; 将"Hello" 替�为"Bonjour"

-    (while (search-forward "Hello" nil t)

-      (replace-match "Bonjour"))

-    (other-window 1))

- 

-(hello-to-bonjour)

- 

-;; 给这些�字加粗:

- 

-(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))

- 

-;; 这个函数使用了 `re-search-forward':

-;; 和查找一个字符串��，你用这个命令�以查找一个模�，�正则表达�

- 

-;; 正则表达� "Bonjour \\(.+\\)!" 的��是:

-;; 字符串 "Bonjour ", 之�跟�

-;; 一组           |  \\( ... \\) 结构

-;; 任�字符       |  . 的�义

-;; 有�能��的   |  + 的�义

-;; 之�跟� "!" 这个字符串

- 

-;; 准备好了？试试看。

- 

-(boldify-names)

- 

-;; `add-text-properties' �以添加文字属性, 比如文字样�

- 

-;; 好的，我们�功了�

- 

-;; 如果你想对一个��或者函数有更多的了解：

-;;

-;; C-h v �� 回车

-;; C-h f 函数 回车

-;;

-;; 阅读Emacs Lisp官方文档:

-;;

-;; C-h i m elisp 回车

-;;

-;; 在线阅读Emacs Lisp文档:

-;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html

- 

-;; 感谢以下�学的建议和�馈:

-;; - Wes Hardaker

-;; - notbob

-;; - Kevin Montuori

-;; - Arne Babenhauserheide

-;; - Alan Schmitt

-;; - spacegoing

-```

-

+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "http://bzg.fr"]
+translators:
+    - ["Chenbo Li", "http://binarythink.net"]
+filename: learn-emacs-lisp-zh.el
+lang: zh-cn
+---
+
+```scheme
+;; 15分钟学会Emacs Lisp (v0.2a)
+;;（作者：bzg，https://github.com/bzg 
+;;  译者：lichenbo，http://douban.com/people/lichenbo）
+;;
+;; 请先阅读Peter Norvig的一篇好文:
+;; http://norvig.com/21-days.html
+;; （译者注：中文版请�http://blog.youxu.info/21-days/）
+;;
+;; 之�安装GNU Emacs 24.3:
+;;
+;; Debian: apt-get install emacs (视具体�行版而定)
+;; 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
+;;
+;; 更多信��以在这里找到:
+;; http://www.gnu.org/software/emacs/#Obtaining
+ 
+;; 很��的警告:
+;;
+;; 按照这个教程�学习并�会对你的电脑有任何��
+;; 除�你自己在学习的过程中愤怒地把它砸了
+;; 如果出现了这�情况，我�会承担任何责任
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 
+;; 打开emacs
+;;
+;; 按'q'消除欢迎界�
+;;
+;; 现在请注�窗�底部的那一个�色长�
+;;
+;; "*scratch*" 是你现在编辑界�的�字。
+;; 这个编辑界���一个"buffer"。
+;;
+;; �当你打开Emacs时，都会默认打开这个scratch buffer
+;; 此时你并没有在编辑任何文件，而是在编辑一个buffer
+;; 之�你�以将这个buffer�存到一个文件中。
+;; 
+;; 之�的"Lisp interaction" 则是表明我们�以用的�组命令
+;; 
+;; Emacs在�个buffer中都有一组内置的命令
+;; 而当你激活��特定的模�时，就�以使用相应的命令
+;; 这里我们使用`lisp-interaction-mode'，
+;; 这样我们就�以使用内置的Emacs Lisp（以下简称Elisp）命令了。
+ 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; 分�是注释开始的标志
+;;
+;; Elisp 是由符�表达�构�的 (�"s-表达�"或"s�"):
+(+ 2 2)
+ 
+;; 这个s�的��是 "对2进行加2�作".
+ 
+;; s�周围有括�，而且也�以嵌套:
+(+ 2 (+ 1 1))
+ 
+;; 一个s��以包�原�符�或者其他s�
+;; 在上�的例�中，1和2是原�符�
+;; (+ 2 (+ 1 1)) 和 (+ 1 1) 是s�.
+ 
+;; 在 `lisp-interaction-mode' 中你�以计算s�.
+;; 把光标移到闭括��，之�按下ctrl+j（以�简写为'C-j'）
+ 
+(+ 3 (+ 1 2))
+;;           ^ 光标放到这里
+;; 按下`C-j' 就会输出 6
+ 
+;; `C-j' 会在buffer中�入当��算的结果
+ 
+;; 而`C-xC-e' 则会在emacs最底部显示结果，也就是被称作"minibuffer"的区域
+;; 为了��把我们的buffer填满无用的结果，我们以�会一直用`C-xC-e'
+ 
+;; `setq' �以将一个值赋给一个��
+(setq my-name "Bastien")
+;; `C-xC-e' 输出 "Bastien" (在 mini-buffer 中显示)
+ 
+;; `insert' 会在光标处�入字符串:
+(insert "Hello!")
+;; `C-xC-e' 输出 "Hello!"
+ 
+;; 在这里我们�传给了insert一个�数"Hello!", 但是
+;; 我们也�以传给它更多的�数，比如2个：
+ 
+(insert "Hello" " world!")
+;; `C-xC-e' 输出 "Hello world!"
+ 
+;; 你也�以用����代替字符串
+(insert "Hello, I am " my-name)
+;; `C-xC-e' 输出 "Hello, I am Bastien"
+ 
+;; 你�以把s�嵌入函数中
+(defun hello () (insert "Hello, I am " my-name))
+;; `C-xC-e' 输出 hello
+ 
+;; 现在执行这个函数
+(hello)
+;; `C-xC-e' 输出 Hello, I am Bastien
+ 
+;; 函数中空括�的��是我们�需�接�任何�数
+;; 但是我们�能一直总是用my-name这个��
+;; 所以我们现在使我们的函数接�一个��"name"的�数 
+ 
+(defun hello (name) (insert "Hello " name))
+;; `C-xC-e' 输出 hello
+ 
+;; 现在我们调用这个函数，并且将"you"作为�数传递
+ 
+(hello "you")
+;; `C-xC-e' 输出 "Hello you"
+ 
+;; �功�
+ 
+;; 现在我们�以休�一下
+ 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; 下�我们在新的窗�中新建一个�为 "*test*" 的buffer:
+ 
+(switch-to-buffer-other-window "*test*")
+;; `C-xC-e' 这时�幕上会显示两个窗�，而光标此时�于*test* buffer内
+ 
+;; 用鼠标�击上�的buffer就会使光标移回。
+;; 或者你�以使用 `C-xo' 使得光标跳到�一个窗�中
+ 
+;; 你�以用 `progn'命令将s�结�起�:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (hello "you"))
+;; `C-xC-e' 此时�幕分为两个窗�，并且在*test* buffer中显示"Hello you"
+ 
+;; 现在为了简�，我们需�在�个s���都使用`C-xC-e'�执行，��就��说明了
+ 
+;; 记得�以用过鼠标或者`C-xo'回到*scratch*这个buffer。
+ 
+;; 清除当�buffer也是常用�作之一：
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "there"))
+ 
+;; 也�以回到其他的窗�中
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "you")
+  (other-window 1))
+ 
+;; 你�以用 `let' 将一个值和一个局部��绑定:
+(let ((local-name "you"))
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello local-name)
+  (other-window 1))
+ 
+;; 这里我们就�需�使用 `progn' 了， 因为 `let' 也�以将很多s�组�起�。
+ 
+;; 格�化字符串的方法：
+(format "Hello %s!\n" "visitor")
+ 
+;; %s 是字符串��符，这里被"visitor"替代.
+;; \n 是�行符。
+ 
+;; 现在我们用格�化的方法��写一下我们的函数:
+(defun hello (name)
+  (insert (format "Hello %s!\n" name)))
+ 
+(hello "you")
+ 
+;; 我们�用`let'新建�一个函数:
+(defun greeting (name)
+  (let ((your-name "Bastien"))
+    (insert (format "Hello %s!\n\nI am %s."
+                    name       ; the argument of the function
+                    your-name  ; the let-bound variable "Bastien"
+                    ))))
+ 
+;; 之�执行:
+(greeting "you")
+ 
+;; 有些函数�以和用户交互:
+(read-from-minibuffer "Enter your name: ")
+ 
+;; 这个函数会返回在执行时用户输入的信�
+ 
+;; 现在我们让`greeting'函数显示你的�字:
+(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 ; the argument of the function
+                    your-name ; the let-bound var, entered at prompt
+                    ))))
+ 
+(greeting "Bastien")
+ 
+;; 我们让结果在�一个窗�中显示:
+(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)))
+ 
+;; 测试一下：
+(greeting "Bastien")
+ 
+;; 第二节结�，休�一下�。
+ 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; 我们将一些�字存到列表中：
+(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
+ 
+;; 用 `car'��得第一个�字：
+(car list-of-names)
+ 
+;; 用 `cdr'�得剩下的�字:
+(cdr list-of-names)
+ 
+;; 用 `push'把�字添加到列表的开头:
+(push "Stephanie" list-of-names)
+ 
+;; 注�: `car' 和 `cdr' 并�修改列表本身, 但是 `push' �会对列表本身进行�作.
+;; 这个区别是很��的: 有些函数没有任何副作用（比如`car'）
+;; 但还有一些�是有的 (比如 `push').
+ 
+;; 我们�对`list-of-names'列表中的�一个元素都使用hello函数:
+(mapcar 'hello list-of-names)
+ 
+;; 将 `greeting' 改进，使的我们能够对`list-of-names'中的所有�字执行:
+(defun greeting ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (mapcar 'hello list-of-names)
+    (other-window 1))
+ 
+(greeting)
+ 
+;; 记得我们之�定义的 `hello' 函数�？ 这个函数接�一个�数，�字。
+;; `mapcar' 调用 `hello', 并将`list-of-names'作为�数先�传给`hello'
+ 
+;; 现在我们对显示的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)) 将光标移到buffer的开始
+;; (search-forward "Hello") 查找字符串"Hello"
+;; (while x y) 当x返回�个值时执行y这个s�
+;; 当x返回`nil' (空), 退出循环
+ 
+(replace-hello-by-bonjour)
+ 
+;; 你会看到所有在*test* buffer中出现的"Hello"字样都被��了"Bonjour"
+ 
+;; 你也会得到以下错误�示: "Search failed: Hello".
+;;
+;; 如果���这个错误, 你需�告诉 `search-forward' 这个命令是�在
+;; buffer的�个地方�止查找, 并且在什么都没找到时是�应该�给出错误�示
+ 
+;; (search-forward "Hello" nil t) �以达到这个�求:
+ 
+;; `nil' �数的��是 : 查找并��于�个范围内
+;; `t' �数的��是: 当什么都没找到时，�给出错误�示
+ 
+;; 在下�的函数中，我们用到了s�，并且�给出任何错误�示:
+ 
+(defun hello-to-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    ;; 为`list-of-names'中的�个�字调用hello
+    (mapcar 'hello list-of-names)
+    (goto-char (point-min))
+    ;; 将"Hello" 替�为"Bonjour"
+    (while (search-forward "Hello" nil t)
+      (replace-match "Bonjour"))
+    (other-window 1))
+ 
+(hello-to-bonjour)
+ 
+;; 给这些�字加粗:
+ 
+(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))
+ 
+;; 这个函数使用了 `re-search-forward':
+;; 和查找一个字符串��，你用这个命令�以查找一个模�，�正则表达�
+ 
+;; 正则表达� "Bonjour \\(.+\\)!" 的��是:
+;; 字符串 "Bonjour ", 之�跟�
+;; 一组           |  \\( ... \\) 结构
+;; 任�字符       |  . 的�义
+;; 有�能��的   |  + 的�义
+;; 之�跟� "!" 这个字符串
+ 
+;; 准备好了？试试看。
+ 
+(boldify-names)
+ 
+;; `add-text-properties' �以添加文字属性, 比如文字样�
+ 
+;; 好的，我们�功了�
+ 
+;; 如果你想对一个��或者函数有更多的了解：
+;;
+;; C-h v �� 回车
+;; C-h f 函数 回车
+;;
+;; 阅读Emacs Lisp官方文档:
+;;
+;; C-h i m elisp 回车
+;;
+;; 在线阅读Emacs Lisp文档:
+;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
+ 
+;; 感谢以下�学的建议和�馈:
+;; - Wes Hardaker
+;; - notbob
+;; - Kevin Montuori
+;; - Arne Babenhauserheide
+;; - Alan Schmitt
+;; - spacegoing
+```
+
diff --git a/zh-cn/elixir-cn.html.markdown b/zh-cn/elixir-cn.html.markdown
index daee8d3c..0ed1d823 100644
--- a/zh-cn/elixir-cn.html.markdown
+++ b/zh-cn/elixir-cn.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
 translators:
diff --git a/zh-cn/fortran-cn.html.markdown b/zh-cn/fortran-cn.html.markdown
new file mode 100644
index 00000000..ab521e0a
--- /dev/null
+++ b/zh-cn/fortran-cn.html.markdown
@@ -0,0 +1,444 @@
+---
+language: Fortran
+filename: learnfortran-cn.f90
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+translators:
+    - ["Corvusnest", "https://github.com/Corvusnest"]
+lang: zh-cn
+---
+
+Fortran 是最��的计算机语言之一。它由 IBM 开�于 1950 年用于数值�算（Fortran 为 "Formula
+Translation" 的缩写）。虽然该语言已年代久远，但目��用于高性能计算，如天气预报。
+该语言�在�续�展，并且基本���下兼容。知�的版本为 Fortran 77, Fortran 90,
+Fortran 95, Fortran 2008, Fortran 2015 和 Fortran 2023。
+
+这篇概�将讨论 Fortran 2008 的一些特�。因为它是目�所广泛采用的标准版本，并且与最新版本的内容
+也基本相�（而 Fortran 77 则是一个�常��的版本）。
+
+```fortran
+! 这是一个注释
+
+program example         ! 声明一个�为 example 的程�
+
+    ! 代��能存在于程��函数��程�或模�中
+    ! 使用缩进�是必需的，但推�使用
+
+    ! 声明��
+    ! =========
+
+    ! 所有的声明必须在语�和表达�之�
+
+    implicit none       ! 防止动�声明��（推��）
+    ! implicit none 推�在�个函数/程�/模�中�新声明...
+
+    ! 注� - Fortran 中对大�写��感
+    real z
+    REAL Z2
+
+    real :: v, x        ! 警告：默认的�始值�决于编译器�
+    real :: a = 3, b = 2E12, c = 0.01
+    integer :: i, j, k = 1, m
+    real, parameter :: PI = 3.1415926535897931    ! 声明一个常数
+    logical :: y = .TRUE., n = .FALSE.            ! 布尔类型
+    complex :: w = (0, 1)                         ! ��虚数
+    character(len=3) :: month                     ! 字符串，长度为 3 个字符
+
+    real :: array(6)                              ! 声明一个包� 6 个实数的数组
+    real, dimension(4) :: arrayb                  ! �一�声明数组的方�
+    integer :: arrayc(-10:10)                     ! 具有自定义索引的数组
+    real :: array2d(3, 2)                         ! 多维数组
+
+    ! 这些分隔符 '::' 并�总是必需的，但推�使用
+
+    ! 还有许多其他的��属性：
+    real, pointer :: p                            ! 声明一个指针
+
+    integer, parameter :: LP = selected_real_kind(20)
+    real(kind=LP) :: d                            ! 长精度��
+
+    ! 警告：在声明过程中�始化��会在函数中造�问题，
+    ! 因为这会自动暗示 'save' 属性，
+    ! 在函数调用之间�存��的值一般情况下，
+    ! 除了常�外，声明和�始化的代�应该分开�
+
+    ! 字符串
+    ! =======
+
+    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."
+    ! 使用 (len=*) �以自动计算长度，但�适用于常�
+
+    str_b = a_str//" keyboard"      ! 使用 // �算符连接字符串
+
+    ! 赋值和算术
+    ! =============
+
+    Z = 1                           ! 对上�声明的�� z 进行赋值（对大�写��感）
+    j = 10 + 2 - 3
+    a = 11.54/(2.3*3.1)
+    b = 2**3                        ! 幂�算
+
+    ! �程控制语�和�作符
+    ! ===================
+
+    ! �行 if 语�
+    if (z == a) b = 4               ! �件始终需�在括�中
+
+    if (z /= a) then                ! z �等于 a
+        ! 其他的比较�作符包括 < > <= >= == /=
+        b = 4
+    else if (z .GT. a) then         ! z 大于 a
+        ! 文本等价于符��作符中的 .LT. .GT. .LE. .GE. .EQ. .NE.
+        b = 6
+    else if (z < a) then            ! 'then' 必须在本行上
+        b = 5                       ! 执行�必须在新的一行上
+    else
+        b = 10
+    end if                          ! end 语��需� 'if'（或�以使用 'endif'）
+
+    if (.NOT. (x < c .AND. v >= a .OR. z == z)) then    ! 布尔�算符
+        inner: if (.TRUE.) then     ! �以对 if 结构命�
+            b = 1
+        end if inner                ! then 必须命�对应的 endif 语�
+    end if
+
+    i = 20
+    select case (i)
+    case (0, 1)                     ! 当 i == 0 或 i == 1 时
+        j = 0
+    case (2:10)                     ! 当 i 在 2 到 10 之间（包括边界）时
+        j = 1
+    case (11:)                      ! 当 i >= 11 时
+        j = 2
+    case default
+        j = 3
+    end select
+
+    month = 'jan'
+    ! �件�以是整数�逻辑�或字符类型
+    ! Select 结构也�以命�
+    monthly:select case(month)
+    case ("jan")
+        j = 0
+    case default
+        j = -1
+    end select monthly
+
+    do i = 2, 10, 2             ! 循环从 2 到 10（包括）以 2 为步长
+        innerloop: do j = 1, 3  ! 循环也�以命�
+            exit                ! 退出循环
+        end do innerloop
+        cycle                   ! 跳到下一个循环迭代
+    end do
+
+    ! 虽然存在 Goto 语�，但它被强烈�推�
+    goto 10
+    stop 1                      ! 立��止代�（并返回指定的�件代�）
+10  j = 201                     ! 这一行被标记为 10 行
+
+    ! 数组
+    ! =====
+    array = (/1, 2, 3, 4, 5, 6/)
+    array = [1, 2, 3, 4, 5, 6]  ! 使用 Fortran 2003 的表示法
+    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 数组索引从 1 开始
+    ! （默认情况下，但对于特定数组�以定义��的索引）
+    v = array(1)                ! �数组的第一个元素
+    v = array2d(2, 2)
+
+    print *, array(3:5)         ! 打�从第三个到第五个元素（包括）
+    print *, array2d(1, :)      ! 打�二维数组的第一列
+
+    array = array*3 + 2         ! �以对数组应用数学表达�
+    array = array*array         ! 数组�作是�元素进行的
+    ! array = array*array2d     ! 这两个数组是�兼容的
+
+    ! 有许多内置函数�用于数组
+    c = dot_product(array, array)   ! 这是点积
+    ! 使用 matmul() 进行矩阵�算
+    c = sum(array)
+    c = maxval(array)
+    print *, minloc(array)
+    c = size(array)
+    print *, shape(array)
+    m = count(array > 0)
+
+    ! 循环数组（通常使用 product() 函数）
+    v = 1
+    do i = 1, size(array)
+        v = v*array(i)
+    end do
+
+    ! �件性地执行�元素赋值
+    array = [1, 2, 3, 4, 5, 6]
+    where (array > 3)
+        array = array + 1
+    elsewhere(array == 2)
+        array = 1
+    elsewhere
+        array = 0
+    end where
+
+    ! �� do 循环是创建数组的紧凑方�
+    array = [(i, i=1, 6)]       ! 创建一个数组 [1,2,3,4,5,6]
+    array = [(i, i=1, 12, 2)]   ! 创建一个数组 [1,3,5,7,9,11]
+    array = [(i**2, i=1, 6)]    ! 创建一个数组 [1,4,9,16,25,36]
+    array = [(4, 5, i=1, 3)]    ! 创建一个数组 [4,5,4,5,4,5]
+
+    ! 输入/输出
+    ! =========
+
+    print *, b                  ! 将�� 'b' 打�到命令行
+
+    ! �以对打�的输出进行格�化
+    print "(I6)", 320           ! 打� '   320'
+    print "(I6.4)", 3           ! 打� '  0003'
+    print "(F6.3)", 4.32        ! 打� ' 4.320'
+
+    ! 字�表示预期的类型，��的数字表示用于打�值的字符数
+    ! 字��以是 I（整数），F（实数），E（工程表示法），
+    ! L（逻辑），A（字符串）...
+    print "(I3)", 3200          ! 打� '***'，因为该数字�适�
+
+    ! �以有多个格�规范
+    print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
+    print "(3I5)", 10, 20, 30                       ! 整数的三次��（字段宽度为 5）
+    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3     ! 格���组�
+
+    ! 我们还�以从终端读�输入
+    read (*, *) v
+    read (*, "(2F6.2)") v, x                        ! 读�两个数字
+
+    ! 写入文件
+    open (unit=12, file="records.txt", status="replace")
+    ! 文件通过 'unit number' 引用，这个数字�以在 9:99 范围内选择
+    ! Status �以是 {'old','replace','new'} 中的一个
+    write (12, "(F10.2,F10.2,F10.2)") c, b, a
+    close (12)
+
+    ! 读�文件
+    open (newunit=m, file="records.txt", status="old")
+    ! 文件通过 'new unit number' 引用，编译器为您选择一个整数
+    read (unit=m, fmt="(3F10.2)") a, b, c
+    close (m)
+
+    ! 还有更多功能�用，超出了本文所讨论的范围，
+    ! 还有由于与旧版本的 Fortran 的��兼容性而存在的替代方案
+
+    ! 内置函数
+    ! ===========
+
+    ! Fortran 大约有 200 个语言内部的函数/�程�
+    ! 例如 -
+    call cpu_time(v)        ! 将 'v' 设置为以秒为��的时间
+    k = ior(i, j)           ! 两个整数的� OR �算
+    v = log10(x)            ! 以 10 为底的对数
+    i = floor(b)            ! 返回�于或等于 x 的最接近的整数
+    v = aimag(w)            ! �数的虚部
+
+    ! 函数和�程�
+    ! ==============
+
+    ! �程��行一些代�，并�以对输入值产生副作用或修改输入值
+
+    call routine(a, c, v)   ! �程�调用
+
+    ! 函数采用一系列输入�数，并返回一个�个值
+    ! �过，输入�数�能�会被修改，并且会执行副作用
+
+    m = func(3, 2, k)       ! 函数调用
+
+    ! 函数调用还�以在表达�中使用
+    print *, func2(3, 2, k)
+
+    ! 一个纯函数是一个�修改其输入�数，
+    ! 也�会引起任何副作用的函数
+    m = func3(3, 2, k)
+
+contains                    ! 包�程�内部定义的�程�的区域
+
+    ! Fortran 有几��微��的方��定义函数
+
+    integer function func(a, b, c)      ! 函数返回一个整数值
+        ! implicit none                 ! ���域�以��声明 implicit none
+        integer, intent(in) :: a, b, c  ! 在函数内部定义输入�数的类型
+
+        if (a >= 2) then
+            func = a + b + c            ! 返回��默认为函数�
+            return                      ! �时�以从函数返回当�值
+        end if
+        func = a + c
+
+        ! 在函数的末尾�需� return 语�
+    end function func
+
+    function func2(a, b, c) result(f)   ! 返回��声明为 'f'
+        integer, intent(in) :: a, b     ! �以声明和强制约定��
+        ! �会被函数修改
+        integer, intent(inout) :: c
+        integer :: f                    ! 函数返回类型在函数内部声明
+        integer :: cnt = 0              ! 注�：�始化暗示��在函数调用之间�存
+        !
+
+        f = a + b - c
+        c = 4                           ! 修改输入��的值
+        cnt = cnt + 1                   ! 计算函数调用的次数
+
+    end function func2
+
+    pure function func3(a, b, c)        ! 纯函数�能有副作用
+        integer, intent(in) :: a, b, c
+        integer :: func3
+
+        func3 = a*b*c
+
+    end function func3
+
+    subroutine routine(d, e, f)
+        real, intent(inout) :: f
+        real, intent(in) :: d, e
+
+        f = 2*d + 3*e + f
+
+    end subroutine routine
+
+end program example                     ! 程�定义结�--------------------------
+
+! 函数和�程�在程�列表之外声明，在程�之间以�模�中声明时，需�使用 interface 声明（�使它们在�一�文件中）（�下�）将它们定义在模�或程�的 'contains' 部分更容易
+
+elemental real function func4(a) result(res)
+! elemental 函数是一个纯函数，它采用标�输入��，
+! 但也�以在数组上独立应用，并返回一个新的数组
+    real, intent(in) :: a
+
+    res = a**2 + 1.0
+
+end function func4
+
+! 模�
+! =======
+
+! 模�是在��用性中将相关的声明�函数和�程�结�在一起的有用方�
+
+module fruit
+
+    real :: apple
+    real :: pear
+    real :: orange
+
+end module fruit
+
+module fruity
+    ! 声明的顺�必须是：模��接����
+    !（也�以在程�中声明模�和接�）
+
+    use fruit, only: apple, pear    ! 使用 fruit 模�中的 apple 和 pear
+    implicit none                   ! 导入模�之�
+
+    private                         ! 将一些内容�有化（默认为公共）
+    ! 显�将一些��/函数声明为公共
+    public :: apple, mycar, create_mycar
+    ! 将一些��/函数声明为模��有（本例中是多余的）
+    private :: func4
+
+    ! 接�
+    ! ========
+    ! 在模�内部（最好放在 'contains' 部分）显�声明外部函数/过程
+    interface
+        elemental real function func4(a) result(res)
+            real, intent(in) :: a
+        end function func4
+    end interface
+
+    ! �以使用命�接�定义�载函数
+    interface myabs
+        ! �以使用 'module procedure' 关键字包括模�内已�定义的函数
+        module procedure real_abs, complex_abs
+    end interface
+
+    ! 派生数�类型
+    ! ==================
+    ! �以创建自定义的结构化数�集�
+    type car
+        character(len=100) :: model
+        real :: weight              !（�克）
+        real :: dimensions(3)       ! �，长度-宽度-高度（米）
+        character :: colour
+    contains
+        procedure :: info           ! 将过程绑定到类型
+    end type car
+
+    type(car) :: mycar              ! 声明自定义类型的��
+    ! 请查看 create_mycar() 程�的用法
+
+    ! 注�：模�中没有�以执行的语�
+
+contains
+
+    subroutine create_mycar(mycar)
+        ! 演示派生数�类型的用法
+        type(car), intent(out) :: mycar
+
+        ! 使用 '%' �算符访问类型元素
+        mycar%model = "Ford Prefect"
+        mycar%colour = 'r'
+        mycar%weight = 1400
+        mycar%dimensions(1) = 5.0   ! 默认索引从 1 开始�
+        mycar%dimensions(2) = 3.0
+        mycar%dimensions(3) = 1.5
+
+    end subroutine create_mycar
+
+    subroutine info(self)
+        class(car), intent(in) :: self
+        ! 使用 'class' 关键字将过程绑定到类型
+
+        print *, "Model     : ", self%model
+        print *, "Colour    : ", self%colour
+        print *, "Weight    : ", self%weight
+        print *, "Dimensions: ", self%dimensions
+
+    end subroutine info
+
+    real pure function real_abs(x)
+        real, intent(in) :: x
+
+        if (x < 0) then
+            real_abs = -x
+        else
+            real_abs = x
+        end if
+
+    end function real_abs
+
+    real pure function complex_abs(z)
+        complex, intent(in) :: z
+        ! 长行�以使用继续字符 '&' 进行延续
+
+        complex_abs = sqrt(real(z)**2 + &
+                           aimag(z)**2)
+
+    end function complex_abs
+
+end module fruity
+
+```
+
+### 更多资�
+
+了解更多的 Fortran 信�:
+
++ [wikipedia](https://en.wikipedia.org/wiki/Fortran)
++ [Fortran-lang Organization](https://fortran-lang.org/)
++ [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/zh-cn/fortran95-cn.html.markdown b/zh-cn/fortran95-cn.html.markdown
deleted file mode 100644
index e28d309f..00000000
--- a/zh-cn/fortran95-cn.html.markdown
+++ /dev/null
@@ -1,435 +0,0 @@
----
-language: Fortran
-filename: learnfortran-cn.f95
-contributors:
-    - ["Robert Steed", "https://github.com/robochat"]
-translators:
-    - ["Corvusnest", "https://github.com/Corvusnest"]
-lang: zh-cn
----
-
-Fortran 是最��的计算机语言之一。它由IBM开�于1950年用于数值�算（Fortran 为 "Formula
-Translation" 的缩写）。虽然该语言已年代久远，但目��用于高性能计算，如天气预报。
-该语言�在�续�展，并且基本���下兼容。知�的版本为 Fortran 77, Fortran 90,
-Fortran 95, Fortran 2003, Fortran 2008 与 Fortran 2015。
-
-这篇概�将讨论 Fortran 95 的一些特�。因为它是目�所广泛采用的标准版本，并且与最新版本的内容
-也基本相�（而 Fortran 77 则是一个�常��的版本）。
-
-```fortran
-
-! 这是一行注释
-
-
-program example   !声明一个�� example 的程�
-
-    ! 代��能放在程��函数��程�或者模�内部
-    ! 推�使用缩进，但�是必须的。
-
-    ! 声明��
-    ! ===================
-
-    ! 所有的声明必须放在语�与表达�之�
-
-    implicit none    !阻止��的��声明 (推�!)
-    ! Implicit none 必须在�一个 函数/程�/模� 中进行声明
-
-    ! ��  - Fortran 对大�写��感
-    real z
-    REAL Z2
-
-    real :: v,x    ! 警告: 默认值�决于编译器!    
-    real :: a = 3, b=2E12, c = 0.01
-    integer :: i, j, k=1, m
-    real, parameter :: PI = 3.1415926535897931    !声明一个常�
-    logical :: y = .TRUE. , n = .FALSE.    !布尔值
-    complex :: w = (0,1)    !sqrt(-1) (译注: 定义�数，此为-1的平方根)
-    character (len=3) :: month    !长度为3的字符串
-
-    real :: array(6)     !声明长度为6的浮点数数组
-    real, dimension(4) :: arrayb    !声明数组的�一�方法
-    integer :: arrayc(-10:10)   !有�自定义索引的数组
-    real :: array2d(3,2)    !多维数组
-
-    ! 分隔符 '::' 并�总是必�的，但推�使用
-
-    ! 还存在很多其他的��特�:
-    real, pointer :: p    !声明一个指针
-
-    integer, parameter :: LP = selected_real_kind(20)
-    real (kind = LP) :: d    !长精度��
-
-    ! 警告：在声明期间�始化��将导致在函数内�生问题，因为这将自动具备了 “save� 属性，
-    ! 因此��的值在函数的多次调用期间将被存储。一般�说，除了常�，应分开声明与�始化�
-
-    ! 字符串
-    ! =======
-
-    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."
-    !�以通过使用 (len=*) �自动判断长度，但�对常�有效
-
-    str_b = a_str // " keyboard"    !通过 // �作符�连接字符串
-
-
-    ! 任务与计算
-    ! =======================
-
-    Z = 1    !�之�声明的�� z 赋值 (大�写��感).
-    j = 10 + 2 - 3
-    a = 11.54  /  (2.3 * 3.1)
-    b = 2**3    !幂
-
-
-    ! 控制�程语� 与 �作符
-    ! ===================================
-
-    !�行 if 语�
-    if (z == a) b = 4  !判别�永远需�放在圆括�内
-
-    if (z /= a) then !z �等于 a
-    ! 其他的比较�算符： < > <= >= == /=
-      b = 4
-    else if (z .GT. a) then !z 大于(Greater) a
-    ! 文本形�的比较�算符: .LT. .GT. .LE. .GE. .EQ. .NE.  
-      b = 6
-    else if (z < a) then !'then' 必须放在该行
-      b = 5 !执行部分必须放在新的一行里
-    else
-      b = 10
-    end if !结�语�需� 'if' (也�以用 'endif').
-
-
-    if (.NOT. (x < c .AND. v >= a .OR. z == z)) then   !布尔�作符
-      inner: if (.TRUE.) then    !�以为 if 结构命�
-        b = 1
-      endif inner    !接下�必须命� endif 语�.
-    endif
-
-
-    i = 20
-    select case (i)
-      case (0)    !当 i == 0
-        j=0
-      case (1:10)    !当 i 为 1 到 10 之内 ( 1 <= i <= 10 )
-        j=1
-      case (11:)    !当 i>=11
-        j=2
-      case default
-        j=3
-    end select
-
-
-    month = 'jan'
-    ! 状�值�以为整数�布尔值或者字符类型
-    ! Select 结构�样�以被命�
-    monthly: select case (month)
-      case ("jan")
-         j = 0
-      case default
-         j = -1
-    end select monthly
-
-    do i=2,10,2    !从2到10(包�2和10)以2为步进值循环
-      innerloop: do j=1,3    !循环�样�以被命�
-        exit    !跳出循环
-      end do innerloop
-    cycle    !��跳入下一次循环
-    enddo
-
-
-    ! Goto 语�是存在的，但强烈�建议使用
-    goto 10    
-    stop 1    !立��止程� (返回一个设定的状��).
-10  j = 201    !这一行被标注为 10 行 （line 10）
-
-
-    ! 数组
-    ! ======
-    array = (/1,2,3,4,5,6/)
-    array = [1,2,3,4,5,6]    !当使用 Fortran 2003 版本.
-    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 数组索引起始于 1
-    ! (默认下如此，也�以为数组定义��的索引起始)
-    v = array(1)    !获�数组的第一个元素
-    v = array2d(2,2)
-
-    print *, array(3:5)    !打�从第3到第五5之内的所有元素
-    print *, array2d(1,:)    !打�2维数组的第一列
-
-    array = array*3 + 2    !�为数组设置数学表达�
-    array = array*array    !数组�作支�元素级(�作) (element-wise)
-    !array = array*array2d    !这两类数组并�是�一个维度的
-
-    ! 有很多内置的数组�作函数
-    c = dot_product(array,array)    !点乘 (点积)
-    ! 用 matmul() �进行矩阵�算.
-    c = sum(array)
-    c = maxval(array)
-    print *, minloc(array)
-    c = size(array)
-    print *, shape(array)
-    m = count(array > 0)
-
-    ! �历一个数组 (一般使用 Product() 函数).
-    v = 1
-    do i = 1, size(array)
-        v = v*array(i)
-    end do
-
-    ! 有�件地执行元素级�作
-    array = [1,2,3,4,5,6]
-    where (array > 3)
-        array = array + 1
-    elsewhere (array == 2)
-        array = 1
-    elsewhere
-        array = 0
-    end where
-
-    ! ��DO循环�以很方便地创建数组
-    array = [ (i, i = 1,6) ]    !创建数组 [1,2,3,4,5,6]
-    array = [ (i, i = 1,12,2) ]    !创建数组 [1,3,5,7,9,11]
-    array = [ (i**2, i = 1,6) ]    !创建数组  [1,4,9,16,25,36]
-    array = [ (4,5, i = 1,3) ]    !创建数组 [4,5,4,5,4,5]
-
-
-    ! 输入/输出
-    ! ============
-
-    print *, b    !�命令行打��� 'b'
-
-    ! 我们�以格�化输出
-    print "(I6)", 320    !打� '   320'
-    print "(I6.4)", 3    !打� '  0003'
-    print "(F6.3)", 4.32    !打� ' 4.320'
-
-
-    ! 该字�与数值规定了给定的数值与字符所用于打�输出的类型与格�
-    ! 字��为 I (整数), F (浮点数), E (工程格�),
-    ! L (逻辑/布尔值), A (字符) ...
-    print "(I3)", 3200    !如果数值无法符�格�将打� '***'
-
-    ! �以�时设定多�格�
-    print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
-    print "(3I5)", 10, 20, 30    !连续打�3个整数 (字段宽度 = 5).
-    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3   !连续分组格�
-
-    ! 我们也�以从终端读�输入
-    read *, v
-    read "(2F6.2)", v, x    !读�2个数值
-
-    ! 读�文件
-    open(unit=11, file="records.txt", status="old")
-    ! 文件被引用带有一个��数 'unit', 为一个�值范围在9-99的整数
-    ! 'status' �以为 {'old','replace','new'} 其中之一
-    read(unit=11, fmt="(3F10.2)") a, b, c
-    close(11)
-
-    ! 写入一个文件
-    open(unit=12, file="records.txt", status="replace")
-    write(12, "(F10.2,F10.2,F10.2)") c, b, a
-    close(12)
-    ! 在讨论范围之外的还有更多的细节与�用功能，并于�版本的 Fortran ��兼容
-
-
-    ! 内置函数
-    ! ==================
-
-    ! Fortran 拥有大约 200 个内置函数/�程�
-    ! 例�
-    call cpu_time(v)    !以秒为��设置时间
-    k = ior(i,j)    !2个整数的�或�算
-    v = log10(x)    !以10为底的log�算
-    i = floor(b)    !返回一个最接近的整数�于或等于x (地�数)
-    v = aimag(w)    !�数的虚数部分
-
-
-    ! 函数与�程�
-    ! =======================
-
-    ! 一个�程�会根�输入值�行一些代�并会导致副作用 (side-effects) 或修改输入值
-    ! (译者注: 副作用是指对�程�/函数外的环境产生影�，如修改��)
-
-    call routine(a,c,v)    !调用�程�
-
-    ! 一个函数会根�输入的一系列数值�返回一个�独的值
-    ! 但输入值�然�能被修改以�产生副作用
-
-    m = func(3,2,k)  !调用函数
-
-    ! 函数�以在表达�内被调用
-    Print *, func2(3,2,k)
-
-    ! 一个纯函数�会去修改输入值或产生副作用
-    m = func3(3,2,k)
-
-
-contains ! 用于定义程�内部的副程�(sub-programs)的区域
-
-    ! Fortran 拥有一些��的方法去定义函数
-
-    integer function func(a,b,c)    !一个返回一个整数的函数
-        implicit none   !最好也在函数内将�蓄模�关闭 (implicit none)
-        integer :: a,b,c !输入值类型定义在函数内部
-        if (a >= 2) then
-            func = a + b + c !返回值默认为函数�
-            return !�以在函数内任�时间返回当�值
-        endif
-        func = a + c
-        ! 在函数的结尾�需�返回语�
-    end function func
-
-
-    function func2(a,b,c) result(f)    !将返回值声明为 'f'
-        implicit none
-        integer, intent(in) :: a,b    !�以声明让��无法被函数修改
-        integer, intent(inout) :: c
-        integer :: f     !函数的返回值类型在函数内声明
-        integer :: cnt = 0    !注� - ��的�始化��将在函数的多次调用间被存储
-        f = a + b - c
-        c = 4    !�动一个输入��的值
-        cnt  = cnt + 1    !记录函数的被调用次数
-    end function func2
-
-
-    pure function func3(a,b,c)  !一个没有副作用的纯函数
-        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   ! 函数定义完毕 -----------------------
-
-! 函数与�程�的外部声明对于生�程�清��说，需�一个接�声明（�使它们在�一个�文件内）(�下)
-! 使用 'contains' �以很容易地在模�或程�内定义它们
-
-elemental real function func4(a) result(res)
-! 一个元函数(elemental function) 为一个纯函数使用一个标�输入值
-! 但�时也�以用在一个数组并对其中的元素分别处�，之�返回一个新的数组
-    real, intent(in) :: a
-    res = a**2 + 1.0
-end function func4
-
-
-! 模�
-! =======
-
-! 模��分适�于存放与�用相关�的一组声明�函数与�程�
-
-module fruit
-    real :: apple
-    real :: pear
-    real :: orange
-end module fruit
-
-
-module fruity
-
-    ! 声明必须按照顺�: 模��接����
-    ! (�样�在程�内声明模�和接�)
-
-    use fruit, only: apple, pear    ! 使用�自于 fruit 模�的 apple 和 pear
-    implicit none    !在模�导入�声明
-
-    private    !使得模�内容为�有(private)(默认为公共 public)
-    ! 显�声明一些��/函数为公共
-    public :: apple,mycar,create_mycar
-    ! 声明一些��/函数为�有(在当�情况下没必�)(译注: 因为��声明了模�全局 private)
-    private :: func4
-
-    ! 接�
-    ! ==========
-    ! 在模�内显�声明一个外部函数/程�
-    ! 一般最好将函数/程�放进 'contains' 部分内
-    interface
-        elemental real function func4(a) result(res)
-            real, intent(in) :: a
-        end function func4
-    end interface
-
-    ! �载函数�以通过已命�的接��定义
-    interface myabs
-        ! �以通过使用 'module procedure' 关键��包�一个已在模�内定义的函数
-        module procedure real_abs, complex_abs
-    end interface
-
-    ! 派生数�类型
-    ! ==================
-    ! �创建自定义数�结构
-    type car
-        character (len=100) :: model
-        real :: weight    !(公斤 kg)
-        real :: dimensions(3)    !例: 长宽高(米)
-        character :: colour
-    end type car
-
-    type(car) :: mycar    !声明一个自定义类型的��
-    ! 用法具体查看 create_mycar()
-
-    ! 注: 模�内没有�执行的语�
-
-contains
-
-    subroutine create_mycar(mycar)
-        ! 展示派生数�类型的使用
-        implicit none
-        type(car),intent(out) :: mycar
-
-        ! 通过 '%' �作符�访问(派生数�)类型的元素
-        mycar%model = "Ford Prefect"
-        mycar%colour = 'r'
-        mycar%weight = 1400
-        mycar%dimensions(1) = 5.0    !索引默认起始值为 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
-        ! 过长的一行代��通过延续符 '&' ��行
-        complex_abs = sqrt(real(z)**2 + &
-                                         aimag(z)**2)
-    end function complex_abs
-
-
-end module fruity
-
-```
-
-### 更多资�
-
-了解更多的 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/zh-cn/gdscript-cn.html.markdown b/zh-cn/gdscript-cn.html.markdown
new file mode 100644
index 00000000..7c731533
--- /dev/null
+++ b/zh-cn/gdscript-cn.html.markdown
@@ -0,0 +1,317 @@
+---
+language: GDScript
+contributors:
+    - ["Wichamir", "https://github.com/Wichamir/"]
+translators:
+    - ["ShiftWatchOut", "https://github.com/ShiftWatchOut"]
+filename: learngdscript-cn.gd
+lang: zh-cn
+---
+
+GDScript 是一�动�类型的脚本语言，专门为�费开�游�引擎 Godot 制作。 GDScript 的语法类似 Python。
+它的主�优点是易于使用和与引擎深度集�。 它�常适�游�开�。
+
+## 基础
+
+```nim
+# �行注释使用 # �书写。
+"""
+  多行
+  注释
+  是
+  使用
+  文档字符串(docstring)
+  书写。
+"""
+
+# 脚本文件本身默认是一个类，文件�为类�，您也�以为其定义其他�称。
+class_name MyClass
+
+# 继承
+extends Node2D
+
+# �员��
+var x = 8 # æ•´åž‹
+var y = 1.2 # 浮点型
+var b = true # 布尔型
+var s = "Hello World!" # 字符串
+var a = [1, false, "brown fox"] # 数组(Array) - 类似于 Python 的列表(list),
+                                # 它�以�时�存��类型的��。
+var d = {
+  "key" : "value",
+  42 : true
+} # 字典包�键值对。
+var p_arr = PoolStringArray(["Hi", "there", "!"]) # 池数组�能包��一类型。
+                                                  # 放入其他类型会被转�为目标类型
+
+# 内置��类型:
+var v2 = Vector2(1, 2)
+var v3 = Vector3(1, 2, 3)
+
+# 常�
+const ANSWER_TO_EVERYTHING = 42
+const BREAKFAST = "Spam and eggs!"
+
+# 枚举
+enum { ZERO, ONE , TWO, THREE }
+enum NamedEnum { ONE = 1, TWO, THREE }
+
+# 导出的��将在检查器中��。
+export(int) var age
+export(float) var height
+export var person_name = "Bob" # 如果设置了默认值，则�需�类型注解。
+
+# 函数
+func foo():
+  pass # pass 关键字是未书写的代�的��符
+
+func add(first, second):
+  return first + second
+
+# 打�值
+func printing():
+  print("GDScript ", "简直", "棒呆了")
+  prints("这", "些", "字", "被", "空", "格", "分", "割")
+  printt("这", "些", "字", "被", "制", "表", "符", "分", "割")
+  printraw("这��将被打�到系统控制�。")
+
+# æ•°å­¦
+func doing_math():
+  var first = 8
+  var second = 4
+  print(first + second) # 12
+  print(first - second) # 4
+  print(first * second) # 32
+  print(first / second) # 2
+  print(first % second) # 0
+  # 还有 +=, -=, *=, /=, %= 等�作符，但并没有 ++ 和 -- .
+  print(pow(first, 2)) # 64
+  print(sqrt(second)) # 2
+  printt(PI, TAU, INF, NAN) # 内置常�
+
+# 控制�
+func control_flow():
+  x = 8
+  y = 2 # y 最�被设为一个浮点数，
+        # 但我们�以利用语言�供的动�类型能力将它的类型�为整型�
+  
+  if x < y:
+    print("x �于 y")
+  elif x > y:
+    print("x 大于 y")
+  else:
+    print("x 等于 y")
+  
+  var a = true
+  var b = false
+  var c = false
+  if a and b or not c: # 你也�以用 &&, || 和 !
+    print("看到这�说明上�的�件判断为真�")
+
+  for i in range(20): # GDScript 有类似 Python 的 range 函数
+    print(i) # 所以这�将打�从 0 到 19 的数字
+
+  for i in 20: # 与 Python 略有��的是，你�以直接用一个整型数开始循环
+    print(i) # 所以这行代�也将打�从 0 到 19 的数字
+
+  for i in ["two", 3, 1.0]: # �历数组
+    print(i)
+  
+  while x > y:
+    printt(x, y)
+    y += 1
+
+  x = 2
+  y = 10
+  while x < y:
+    x += 1
+    if x == 6:
+      continue # continue 语�使 x 等于 6 时，程�跳过这次循环��的代�，�会打� 6。
+    prints("x 等于：", x)
+    if x == 7:
+      break # 循环将在 x 等于 7 处跳出，�续所有循环��执行，因此�会打� 8�9 和 10
+
+  match x:
+    1:
+      print("match 很�其他语言中的 switch.")
+    2:
+      print("但是，您�需�在�个值之�写一个 case 关键字。")
+    3:
+      print("此外，��情况都会默认跳出。")
+      break # 错误���在 match 里用 break 语��
+    4:
+      print("如果您需�跳过�续代�，这里也使用 continue 关键字。")
+      continue
+    _:
+      print("下划线分支，在其他分支都�满足时，在这里书写默认的逻辑。")
+  
+  # 三元�算符 (写在一行的 if-else 语�)
+  prints("x 是", "正值" if x >= 0 else "负值")
+
+# 类型转�
+func casting_examples():
+  var i = 42
+  var f = float(42) # 使用��构造函数强制转�
+  var b = i as bool # 或使用 as 关键字
+
+# �载函数
+# 通常，我们�会�载以下划线开头的内置函数，
+# 但实际上您�以�载几乎任何函数。
+
+# _init 在对象�始化时被调用。
+# 这是对象的构造函数。
+func _init():
+  # 在此处�始化对象的内部属性。
+  pass
+
+# _ready 在脚本节点�其�节点进入场景树时被调用。
+func _ready():
+  pass
+
+# _process 在�一帧上都被调用。
+func _process(delta):
+  # 传递给此函数的 delta �数是时间，�从上一帧到当�帧�过的秒数。
+  print("Delta 时间为：", delta)
+
+# _physics_process 在�个物�帧上都被调用。
+# 这�味� delta 应该是�定的。
+func _physics_process(delta):
+  # 使用��加法和乘法进行简�移动。
+  var direction = Vector2(1, 0) # 或使用 Vector2.RIGHT
+  var speed = 100.0
+  self.global_position += direction * speed * delta
+  # self 指�当�类的实例
+
+# �载函数时，您�以使用 . �算符调用父函数
+# like here:
+func get_children():
+  # 在这里�一些�外的事情。
+  var r = .get_children() # 调用父函数的实现
+  return r
+
+# 内部类
+class InnerClass:
+  extends Object
+
+  func hello():
+    print("�自内部类的 Hello�")
+
+func use_inner_class():
+  var ic = InnerClass.new()
+  ic.hello()
+  ic.free() # �以自行释放内存
+```
+
+## 访问场景树中其他节点
+
+```nim
+extends Node2D
+
+var sprite # 该��将用��存引用。
+
+# 您�以在 _ready 中获�对其他节点的引用。
+func _ready() -> void:
+  # NodePath 对于访问节点很有用。
+  # 将 String 传递给其构造函数�创建 NodePath：
+  var path1 = NodePath("path/to/something")
+  # 或者使用 NodePath 字��:
+  var path2 = @"path/to/something"
+  # NodePath 示例:
+  var path3 = @"Sprite" # 相对路径，当�节点的直接�节点
+  var path4 = @"Timers/Firerate" # 相对路径，�节点的�节点
+  var path5 = @".." # 当�节点的父节点
+  var path6 = @"../Enemy" # 当�节点的兄弟节点
+  var path7 = @"/root" # �对路径，等价于 get_tree().get_root()
+  var path8 = @"/root/Main/Player/Sprite" # Player 的 Sprite 的�对路径
+  var path9 = @"Timers/Firerate:wait_time" # 访问属性
+  var path10 = @"Player:position:x" # 访问�属性
+
+  # 最�，获�节点引用�以使用以下方法:
+  sprite = get_node(@"Sprite") as Sprite # 始终转�为您期望的类型
+  sprite = get_node("Sprite") as Sprite # 这里 String 被��转�为 NodePath
+  sprite = get_node(path3) as Sprite
+  sprite = get_node_or_null("Sprite") as Sprite
+  sprite = $Sprite as Sprite
+
+func _process(delta):
+  # 现在我们就�以在别处使用 sprite 里�存的引用了。
+  prints("Sprite 有一个全局�置 ", sprite.global_position)
+
+# 在 _ready 执行之�，使用 onready 关键字为��赋值。
+# 这是一�常用的语法糖。
+onready var tween = $Tween as Tween
+
+# 您�以导出这个 NodePath，以便在检查器中给它赋值。
+export var nodepath = @""
+onready var reference = get_node(nodepath) as Node
+```
+
+## 信�(Signals)
+
+信�系统是 Godot 对观察者编程模�的实现。例�如下:
+
+```nim
+class_name Player extends Node2D
+
+var hp = 10
+
+signal died() # 定义一个信�
+signal hurt(hp_old, hp_new) # 信��以带�数
+
+func apply_damage(dmg):
+  var hp_old = hp
+  hp -= dmg
+  emit_signal("hurt", hp_old, hp) # �出信�并传递�数
+  if hp <= 0:
+    emit_signal("died")
+
+func _ready():
+  # 将信� "died" 连接到 self 中定义的 _on_death 函数
+  self.connect("died", self, "_on_death")
+
+func _on_death():
+  self.queue_free() # 死亡时销� Player
+```
+
+## 类型注解
+
+GDScript �以选择性地使用��类型。
+
+```nim
+extends Node
+
+var x: int # 定义带有类型的��
+var y: float = 4.2
+var z := 1.0 # 使用 := �算符根�默认值推断类型
+
+onready var node_ref_typed := $Child as Node
+
+export var speed := 50.0
+
+const CONSTANT := "Typed constant."
+
+func _ready() -> void:
+  # 此函数�返回任何东西
+  x = "string" # 错误���更改类型�
+  return
+
+func join(arg1: String, arg2: String) -> String:
+  # 此函数接�两个 String 并返回一个 String。
+  return arg1 + arg2
+
+func get_child_at(index: int) -> Node:
+  # 此函数接�一个 int 并返回一个 Node
+  return get_children()[index]
+
+signal example(arg: int) # 错误�信��能接�类型�数�
+```
+
+## 延展阅读
+
+* [Godot's Website](https://godotengine.org/)
+* [Godot Docs](https://docs.godotengine.org/en/stable/)
+* [Getting started with GDScript](https://docs.godotengine.org/en/stable/getting_started/scripting/gdscript/index.html)
+* [NodePath](https://docs.godotengine.org/en/stable/classes/class_nodepath.html)
+* [Signals](https://docs.godotengine.org/en/stable/getting_started/step_by_step/signals.html)
+* [GDQuest](https://www.gdquest.com/)
+* [GDScript.com](https://gdscript.com/)
\ No newline at end of file
diff --git a/zh-cn/git-cn.html.markdown b/zh-cn/git-cn.html.markdown
index 63d740a1..9dfbbb93 100644
--- a/zh-cn/git-cn.html.markdown
+++ b/zh-cn/git-cn.html.markdown
@@ -370,5 +370,3 @@ $ git rm /pather/to/the/file/HelloWorld.c
 * [Atlassian Git - 教程与工作�程](https://www.atlassian.com/git/)
 
 * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
-
-* [GitGuys](http://www.gitguys.com/)
diff --git a/zh-cn/go-cn.html.markdown b/zh-cn/go-cn.html.markdown
index 2953acf3..a2b71761 100644
--- a/zh-cn/go-cn.html.markdown
+++ b/zh-cn/go-cn.html.markdown
@@ -22,7 +22,7 @@ Go语言有�常棒的标准库，还有一个充满热情的社区。
     注释 */
 
 // 导入包的��在�个�文件的开头。
-// Main比较特殊，它用�声明�执行文件，而�是一个库。
+// main比较特殊，它用�声明�执行文件，而�是一个库。
 package main
 
 // Import语�声明了当�文件引用的包。
@@ -35,7 +35,7 @@ import (
     "strconv"   // 字符串转�
 )
 
-// 函数声明：Main是程�执行的入�。
+// 函数声明：main是程�执行的入�。
 // �管你喜欢还是�喜欢，�正Go就用了花括��包�函数体。
 func main() {
     // 往标准输出打�一行。
@@ -78,10 +78,10 @@ func learnTypes() {
     // �ascii字符。Go使用UTF-8编�。
     g := 'Σ' // rune类型，int32的别�，使用UTF-8编�
 
-    f := 3.14195 // float64类型，IEEE-754 64�浮点数
+    f := 3.14159 // float64类型，IEEE-754 64�浮点数
     c := 3 + 4i  // complex128类型，内部使用两个float64表示
 
-    // Var���以直接�始化。
+    // var���以直接�始化。
     var u uint = 7  // unsigned 无符���，但是实现�赖int型��的长度
     var pi float32 = 22. / 7
 
@@ -141,7 +141,7 @@ func learnTypes() {
 // �用写return一个�就能将函数内指定�称的��返回
 func learnNamedReturns(x, y int) (z int) {
     z = x * y
-    return // z is implicit here, because we named it earlier.
+    return // ��返回z，因为��指定了它。
 }
 
 // Go全�支�垃圾回收。Go有指针，但是�支�指针�算。
@@ -161,7 +161,7 @@ func expensiveComputation() int {
 }
 
 func learnFlowControl() {
-    // If需�花括�，括�就�了
+    // if需�花括�，括�就�了
     if true {
         fmt.Println("这��肯定被执行")
     }
@@ -392,15 +392,15 @@ func requestServer() {
 
 ## 更进一步
 
-关于Go的一切你都�以在[Go官方网站](http://golang.org/)找到。
+关于Go的一切你都�以在[Go官方网站](https://go.dev/)找到。
 在那里你�以获得教程�考，在线试用，和更多的资料。
-在简�的�试过�，在[官方文档](https://golang.org/doc/)那里你会得到你所需�的所有资料�关于编写代�的规范�库和命令行工具的文档与Go的版本历�。
+在简�的�试过�，在[官方文档](https://go.dev/doc/)那里你会得到你所需�的所有资料�关于编写代�的规范�库和命令行工具的文档与Go的版本历�。
 
 强烈推�阅读语言定义部分，很简�而且很简��（赶时髦�）
 
-你还�以�往[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在线体验中心](https://go.dev/play/p/tnWMjr16Mm)进，在�览器里修改并�行这些代�，一定�试一试哦�你�以将[https://go.dev/play/](https://go.dev/play/)当作一个[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还�阅读Go[标准库的�代�](https://go.dev/src/)，全部文档化了，�读性�常好，�以学到go，go style和go idioms。在[文档](https://go.dev/pkg/)中点击函数�，�代�就出�了�
 
 [Go by example](https://gobyexample.com/)也是一个学习的好地方。
 
diff --git a/zh-cn/java-cn.html.markdown b/zh-cn/java-cn.html.markdown
index 1de7f3e6..53a423a8 100644
--- a/zh-cn/java-cn.html.markdown
+++ b/zh-cn/java-cn.html.markdown
@@ -190,7 +190,7 @@ public class LearnJava {
         {
             //System.out.println(fooWhile);
             //增加计数器
-            //�历99次， fooWhile 0->99
+            //�历100次， fooWhile 0->99
             fooWhile++;
         }
         System.out.println("fooWhile Value: " + fooWhile);
@@ -201,7 +201,7 @@ public class LearnJava {
         {
             //System.out.println(fooDoWhile);
             //增加计数器
-            //�历99次, fooDoWhile 0->99
+            //�历100次, fooDoWhile 0->99
             fooDoWhile++;
         }while(fooDoWhile < 100);
         System.out.println("fooDoWhile Value: " + fooDoWhile);
diff --git a/zh-cn/json-cn.html.markdown b/zh-cn/json-cn.html.markdown
index 73d3eb57..f5842c07 100644
--- a/zh-cn/json-cn.html.markdown
+++ b/zh-cn/json-cn.html.markdown
@@ -8,24 +8,30 @@ filename: learnjson-cn.json
 lang: zh-cn
 ---
 
-因为JSON是一个�其简�的数�交�格�，本教程最有�能�为有�以�最简�的
-Learn X in Y Minutes。
+JSON是一个�其简�的数�交�格�。按[json.org](https://json.org)说的，它对人类易读易写，对机器易解�易生�。
 
-纯正的JSON实际上没有注释，但是大多数解�器都
-接�C-风格(//, /\* \*/)的注释。为了兼容性，最好��在其中写这样形�的注释。
+一段JSON�以是下文列出的类型的任�值，但实际一般按以下两�方�之一呈现：
+
+* 一个键值对的集�(`{ }`)。按��语言，这�能被�解为对象/记录/结构体/字典/哈希表/有键列表/关�数组
+* 一个有�的值列表(`[ ]`)。按��语言，这�能被�解为数组/��/列表/�列
+
+纯正的JSON实际上没有注释，但是大多数解�器都接�C-风格(//, /\* \*/)的注释。一些解�器还容许trailing comma，�最�一个数组元素或最�一个对象属性之�的逗�。�过为了兼容性最好��。
 
 因此，本教程的一切都会是100%有效的JSON。幸�，它的表达能力很丰富。
 
 支�的数�类型：
 
-- 字符串: "hello", "\"A quote.\"", "\u0abe", "Newline.\n"
-- æ•°å­—: 23, 0.11, 12e10, 3.141e-10, 1.23e+4
-- 对象: { "key": "value" }
-- 数组: ["Values"]
-- 其他: true, false, null
+* 字符串：`"hello"`�`"\"A quote.\""`�`"\u0abe"`�`"Newline.\n"`
+* 数字：`23`�`0.11`�`12e10`�`3.141e-10`�`1.23e+4`
+* 对象：`{ "key": "value" }`
+* 数组：`["Values"]`
+* 其它：`true`�`false`�`null`
 
 ```json
 {
+  "key": "value",
+
+  "keys": "must always be enclosed in double quotes",
   "numbers": 0,
   "strings": "Hellø, wørld. All unicode is allowed, along with \"escaping\".",
   "has bools?": true,
@@ -55,6 +61,23 @@ Learn X in Y Minutes。
     ]
   ],
 
-  "that was short": "And, you're done. You now know everything JSON has to offer."
+  "alternative style": {
+    "comment": "check this out!"
+  , "comma position": "doesn't matter, if it's before the next key, it's valid"
+  , "another comment": "how nice"
+  },
+
+
+
+  "whitespace": "Does not matter.",
+
+
+
+  "that was short": "And done. You now know everything JSON has to offer."
 }
 ```
+
+## 进一步阅读
+
+* [JSON.org](https://www.json.org/json-zh.html) 完美图解JSON的一切
+* [JSON Tutorial](https://www.youtube.com/watch?v=wI1CWzNtE-M) 简�介�
diff --git a/zh-cn/lua-cn.html.markdown b/zh-cn/lua-cn.html.markdown
index 6736dc2a..6fd10a32 100644
--- a/zh-cn/lua-cn.html.markdown
+++ b/zh-cn/lua-cn.html.markdown
@@ -391,7 +391,8 @@ dofile('mod2')  --> Hi! (�次�行，与require��)
 f = loadfile('mod2')  -- Calling f() runs mod2.lua. 
 
 -- loadstring是loadfile的字符串版本。 
-g = loadstring('print(343)')  --返回一个函数。 
+-- (loadstring已弃用, 使用load代替)
+g = load('print(343)')  --返回一个函数。
 g()  -- 打�343; 在此之�什么也�打�。 
 
 --]] 
diff --git a/zh-cn/markdown-cn.html.markdown b/zh-cn/markdown-cn.html.markdown
index 707d6927..23f27dda 100644
--- a/zh-cn/markdown-cn.html.markdown
+++ b/zh-cn/markdown-cn.html.markdown
@@ -147,7 +147,6 @@ GitHub 也支æŒ� Markdown，在 GitHub çš„ Markdown 解æž�器中，我们å�¯ä»¥ä
 - 项目
 - 项目
 - 最�一个项目
-
 ```
 
 有��列�由数字加上点 `.` �实现
@@ -188,6 +187,7 @@ GitHub 也支æŒ� Markdown，在 GitHub çš„ Markdown 解æž�器中，我们å�¯ä»¥ä
 下�这个选择框将会是选中状�
 - [x] 这个任务已�完�
 ```
+
 - [ ] 你看完了这个任务（注：此选择框是无法直接更改的，��用状�。）
 
 ## 代��
@@ -204,7 +204,7 @@ GitHub 也支æŒ� Markdown，在 GitHub çš„ Markdown 解æž�器中，我们å�¯ä»¥ä
 
 ```md
     my_array.each do |item|
-        puts item
+      puts item
     end
 ```
 
@@ -216,12 +216,13 @@ John 甚至�知� `go_to()` 函数是干嘛的!
 
 在GitHub的 Markdown（GitHub Flavored Markdown）解�器中，你�以使用特殊的语法表示代��
 
-<pre>
-<code class="highlight">&#x60;&#x60;&#x60;ruby
+````md
+```ruby
 def foobar
-    puts "Hello world!"
+  puts "Hello world!"
 end
-&#x60;&#x60;&#x60;</code></pre>
+```
+````
 
 以上代��需�缩进，而且 GitHub 会根�\`\`\`�指定的语言�进行语法高亮显示
 
@@ -246,7 +247,6 @@ Markdown 最棒的地方就是便æ�·çš„书写链接。把链接文字放在中æ‹
 
 ```md
 [点我点我!](http://test.com/)
-
 ```
 
 你也�以在�括�内使用引�，为链接加上一个标题（title）
@@ -345,6 +345,7 @@ Markdown�样支�引用形�的链接
 | 我是左对�    | 居个中    | �对�       |
 | 注�          | 冒       | �           |
 ```
+
 好�，强行对�字符是很难的。但是，至少比下�这�写法好一点——
 
 ```md
@@ -352,6 +353,7 @@ Markdown�样支�引用形�的链接
 :-- | :-: | --:
 这真的太丑了 | ��能 | �����
 ```
+
 真的是*看�令人头晕*
 
 
diff --git a/zh-cn/matlab-cn.html.markdown b/zh-cn/matlab-cn.html.markdown
index d215755c..bb1ab79a 100644
--- a/zh-cn/matlab-cn.html.markdown
+++ b/zh-cn/matlab-cn.html.markdown
@@ -1,504 +1,504 @@
----

-language: Matlab

-filename: matlab-cn.m

-contributors:

-    - ["mendozao", "http://github.com/mendozao"]

-    - ["jamesscottbrown", "http://jamesscottbrown.com"]

-translators:

-    - ["sunxb10", "https://github.com/sunxb10"]

-lang: zh-cn

-

----

-

-MATLAB 是 MATrix LABoratory（矩阵实验室）的缩写。

-它是一�功能强大的数值计算语言，在工程和数学领域中应用广泛。

-

-如果您有任何需��馈或交�的内容，请�系本教程作者：

-[@the_ozzinator](https://twitter.com/the_ozzinator) 

-或 [osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com)。

-

-```matlab

-% 以百分�作为注释符

-

-%{

-多行注释

-�以

-这样

-表示

-%}

-

-% 指令�以��跨行，但需�在跨行处用 '...' 标明：

- a = 1 + 2 + ...

- + 4

-

-% �以在MATLAB中直接��作系统�出指令

-!ping google.com

-

-who  % 显示内存中的所有��

-whos  % 显示内存中的所有��以�它们的类型

-clear  % 清除内存中的所有��

-clear('A')  % 清除指定的��

-openvar('A')  % 在��编辑器中编辑指定��

-

-clc  % 清除命令窗�中显示的所有指令

-diary  % 将命令窗�中的内容写入本地文件

-ctrl-c  % 终止当�计算

-

-edit('myfunction.m')  % 在编辑器中打开指定函数或脚本

-type('myfunction.m')  % 在命令窗�中打�指定函数或脚本的��

-

-profile on  % 打开 profile 代�分�工具

-profile off % 关闭 profile 代�分�工具

-profile viewer  % 查看 profile 代�分�工具的分�结果

-

-help command    % 在命令窗�中显示指定命令的帮助文档

-doc command     % 在帮助窗�中显示指定命令的帮助文档

-lookfor command  % 在所有 MATLAB 内置函数的头部注释�的第一行中�索指定命令

-lookfor command -all  % 在所有 MATLAB 内置函数的整个头部注释�中�索指定命令

-

-

-% 输出格�

-format short    % 浮点数�留 4 ��数

-format long     % 浮点数�留 15 ��数

-format bank     % 金�格�，浮点数��留 2 ��数

-fprintf('text') % 在命令窗�中显示 "text"

-disp('text')    % 在命令窗�中显示 "text"

-

-

-% ��与表达�

-myVariable = 4  % 命令窗�中将新创建的��

-myVariable = 4; % 加上分��使命令窗�中�显示当�语�执行结果

-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

-

-

-% 调用函数有两�方�：

-% 标准函数语法：

-load('myFile.mat', 'y') % �数放在括�内，以英文逗�分隔

-% 指令语法:

-load myFile.mat y   % �加括�，以空格分隔�数

-% 注�在指令语法中�数�需�加引�：在这�语法下，所有输入�数都�能是文本文字，

-% �能是��的具体值，�样也�能是输出��

-[V,D] = eig(A);  % 这�函数调用无法转��等价的指令语法

-[~,D] = eig(A);  % 如果结果中�需� D 而�需� V 则�以这样写

-

-

-

-% 逻辑�算

-1 > 5  % �，ans = 0

-10 >= 10  % 真，ans = 1

-3 ~= 4  % �等于 -> ans = 1

-3 == 3  % 等于 -> ans = 1

-3 > 1 && 4 > 1  % 与 -> ans = 1

-3 > 1 || 4 > 1  % 或 -> ans = 1

-~1  % � -> ans = 0

-

-% 逻辑�算�直接应用于矩阵，�算结果也是矩阵

-A > 5

-% 对矩阵中�个元素�逻辑�算，若为真，则在�算结果的矩阵中对应�置的元素就是 1

-A( A > 5 )

-% 如此返回的��，其元素就是 A 矩阵中所有逻辑�算为真的元素

-

-% 字符串

-a = 'MyString'

-length(a)  % ans = 8

-a(2)  % ans = y

-[a,a]  % ans = MyStringMyString

-b = '字符串'  % MATLAB目�已��以支�包括中文在内的多�文字

-length(b)  % ans = 3

-b(2)  % ans = 符

-[b,b]  % ans = 字符串字符串

-

-

-% 元组（cell 数组）

-a = {'one', 'two', 'three'} 

-a(1)  % ans = 'one' - 返回一个元组

-a{1}  % ans = one - 返回一个字符串

-

-

-% 结构体

-A.b = {'one','two'};

-A.c = [1 2];

-A.d.e = false;

-

-

-% ��

-x = [4 32 53 7 1] 

-x(2)  % ans = 32，MATLAB中��的下标索引从1开始，�是0

-x(2:3)  % ans = 32 53

-x(2:end)  % ans = 32 53 7 1

-

-x = [4; 32; 53; 7; 1]  % 列��

-

-x = [1:10]  % x = 1 2 3 4 5 6 7 8 9 10

-

-

-% 矩阵

-A = [1 2 3; 4 5 6; 7 8 9] 

-% 以分�分隔��的行，以空格或逗�分隔�一行中的��元素

-% A =

-

-%     1     2     3

-%     4     5     6

-%     7     8     9

-

-A(2,3) % ans = 6，A(row, column)

-A(6) % ans = 8 

-% （��地将 A 的三列首尾相接组�一个列��，然��其下标为 6 的元素）

-

-

-A(2,3) = 42  % 将第 2 行第 3 列的元素设为 42

-% A =

-

-%     1     2     3

-%     4     5     42

-%     7     8     9

-

-A(2:3,2:3)  % �原矩阵中的一�作为新矩阵

-%ans =

-

-%     5     42

-%     8     9

-

-A(:,1)  % 第 1 列的所有元素

-%ans =

-

-%     1

-%     4

-%     7

-

-A(1,:)  % 第 1 行的所有元素

-%ans =

-

-%     1     2     3

-

-[A ; A]  % 将两个矩阵上下相接构�新矩阵

-%ans =

-

-%     1     2     3

-%     4     5    42

-%     7     8     9

-%     1     2     3

-%     4     5    42

-%     7     8     9

-

-% 等价于 

-vertcat(A, A);

-

-

-[A , A]  % 将两个矩阵左�相接构�新矩阵

-

-%ans =

-

-%     1     2     3     1     2     3

-%     4     5    42     4     5    42

-%     7     8     9     7     8     9

-

-% 等价于

-horzcat(A, A);

-

-

-A(:, [3 1 2])  % �新排布原矩阵的�列

-%ans =

-

-%     3     1     2

-%    42     4     5

-%     9     7     8

-

-size(A)  % 返回矩阵的行数和列数，ans = 3 3

-

-A(1, :) =[]  % 删除矩阵的第 1 行

-A(:, 1) =[]  % 删除矩阵的第 1 列

-

-transpose(A)  % 矩阵（�共轭）转置，等价于 A.' （注��有个点）

-ctranspose(A)  % 矩阵的共轭转置（对矩阵中的�个元素�共轭�数），等价于 A'

-

-

-% 元素�算 vs. 矩阵�算

-% �独�算符就是对矩阵整体进行矩阵�算

-% 在�算符加上英文�点就是对矩阵中的元素进行元素计算

-% 示例如下：

-A * B  % 矩阵乘法，�求 A 的列数等于 B 的行数

-A .* B  % 元素乘法，�求 A 和 B 形状一致，�两矩阵行列数完全一致

-        % 元素乘法的结果是与 A 和 B 形状一致的矩阵

-        % 其�个元素等于 A 对应�置的元素乘 B 对应�置的元素

-

-% 以下函数中，函数�以 m 结尾的执行矩阵�算，其余执行元素�算： 

-exp(A)  % 对矩阵中�个元素�指数�算

-expm(A)  % 对矩阵整体�指数�算

-sqrt(A)  % 对矩阵中�个元素�开方�算

-sqrtm(A)  % 对矩阵整体�开方�算（�试图求出一个矩阵，该矩阵与自身的乘积等于 A 矩阵）

-

-

-% 绘图

-x = 0:0.1:2*pi; % 生�一��，其元素从 0 开始，以 0.1 的间隔一直递增到 2*pi

-                % 其中 pi 为圆周率

-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 轴范围是从 0 到 2*pi，y 轴范围是从 -1 到 1

-

-plot(x,y1,'-',x,y2,'--',x,y3,':')  % 在�一张图中绘制多�曲线

-legend('Line 1 label', 'Line 2 label')  % 为图片加注图例

-% 图例数�应当�于或等于实际绘制的曲线数目，从 plot 绘制的第一�曲线开始对应

-

-% 在�一张图上绘制多�曲线的�一�方法：

-% 使用 hold on，令系统�留�次绘图结果并在其上直接�加新的曲线，

-% 如果没有 hold on，则�个 plot 都会首先清除之�的绘图结果�进行绘制。

-% 在 hold on 和 hold off 中�以放置任�多的 plot 指令，

-% 它们和 hold on �最�一个 plot 指令的结果都将显示在�一张图中。

-plot(x, y1)

-hold on

-plot(x, y2)

-plot(x, y3)

-plot(x, y4)

-hold off

-

-loglog(x, y)  % 对数—对数绘图

-semilogx(x, y)  % �对数（x 轴对数）绘图

-semilogy(x, y)  % �对数（y 轴对数）绘图

-

-fplot (@(x) x^2, [2,5])  % 绘制函数 x^2 在 [2, 5] 区间的曲线

-

-grid on  % 在绘制的图中显示网格，使用 grid off ��消网格显示

-axis square  % 将当��标系设定为正方形（��在图形显示上�轴等长）

-axis equal  % 将当��标系设定为相等（��在实际数值上�轴等长）

-

-scatter(x, y);  % 散点图

-hist(x);  % 直方图

-

-z = sin(x);

-plot3(x,y,z);  % 绘制三维曲线

-

-pcolor(A)  % 伪彩色图（热图）

-contour(A)  % 等高线图

-mesh(A)  % 网格曲�图

-

-h = figure  % 创建新的图片对象并返回其�柄 h

-figure(h)  % 将�柄 h 对应的图片作为当�图片

-close(h)  % 关闭�柄 h 对应的图片

-close all  % 关闭 MATLAB 中所用打开的图片

-close  % 关闭当�图片

-

-shg  % 显示图形窗�

-clf clear  % 清除图形窗�中的图�，并�置图�属性

-

-% 图�属性�以通过图��柄进行设定

-% 在创建图�时�以�存图��柄以便于设置

-% 也�以用 gcf 函数返回当�图�的�柄 

-h = plot(x, y);  % 在创建图�时显�地�存图��柄

-set(h, 'Color', 'r')

-% 颜色代�：

-%   'y' 黄色，'m' 洋红，'c' �色

-%   'r' 红色，'g' 绿色，'b' �色

-%   'w' 白色，'k' 黑色

-set(h, 'Color', [0.5, 0.5, 0.4])

-% 也�以使用 RGB 值指定颜色

-set(h, 'LineStyle', '--')

-% 线型代�：'--' 实线，'---' 虚线，':' 点线，'-.' 点划线，'none' �划线

-get(h, 'LineStyle')

-% 获�当��柄的线型

-

-

-% 用 gca 函数返回当�图�的�标轴�柄

-set(gca, 'XDir', 'reverse');  % 令 x 轴��

-

-% 用 subplot 指令创建平铺排列的多张�图

-subplot(2,3,1);  % 选择 2 x 3 排列的�图中的第 1 张图

-plot(x1); title('First Plot')  % 在选中的图中绘图

-subplot(2,3,2);  % 选择 2 x 3 排列的�图中的第 2 张图

-plot(x2); title('Second Plot')  % 在选中的图中绘图

-

-

-% �调用函数或脚本，必须��它们在你的当�工作目录中

-path  % 显示当�工作目录

-addpath /path/to/dir  % 将指定路径加入到当�工作目录中

-rmpath /path/to/dir  % 将指定路径从当�工作目录中删除

-cd /path/to/move/into  % 以制定路径作为当�工作目录

-

-

-% ����存到 .mat 格�的本地文件

-save('myFileName.mat')  % �存当�工作空间中的所有�� 

-load('myFileName.mat')  % 将指定文件中的��载入到当�工作空间 

-

-

-% .m 脚本文件

-% 脚本文件是一个包�多� MATLAB 指令的外部文件，以 .m 为�缀�

-% 使用脚本文件�以��在命令窗�中��输入冗长的指令

-

-

-% .m 函数文件

-% 与脚本文件类似，�样以 .m 作为�缀�

-% 但函数文件�以接�用户输入的�数并返回�算结果

-% 并且函数拥有自己的工作空间（��域），�必担心���称冲�

-% 函数文件的�称应当与其所定义的函数的�称一致

-% 比如下�例�中函数文件就应命�为 double_input.m

-% 使用 'help double_input.m' �返回函数定义中第一行注释信�

-function output = double_input(x) 

-    % double_input(x) 返回 x 的 2 �

-    output = 2*x;

-end

-double_input(6)  % ans = 12 

-

-

-% �样还�以定义�函数和内嵌函数

-% �函数与主函数放在�一个函数文件中，且�能被这个主函数调用

-% 内嵌函数放在�一个函数体内，�以直接访问被嵌套函数的�个��

-

-

-% 使用匿�函数�以�必创建 .m 函数文件

-% 匿�函数适用于快速定义�函数以便传递给�一指令或函数（如绘图�积分�求根�求�值等）

-% 下�示例的匿�函数返回输入�数的平方根，�以使用�柄 sqr 进行调用：

-sqr = @(x) x.^2;

-sqr(10) % ans = 100

-doc function_handle % find out more

-

-

-% 接�用户输入

-a = input('Enter the value: ')

-

-

-% 从文件中读�数�

-fopen(filename)

-% 类似函数还有 xlsread（excel 文件）�importdata（CSV 文件）�imread（图�文件）

-

-

-% 输出

-disp(a)  % 在命令窗�中打��� a 的值

-disp('Hello World')  % 在命令窗�中打�字符串

-fprintf  % 按照指定格�在命令窗�中打�内容

-

-% �件语�（if 和 elseif 语�中的括�并�必需，但推�加括���混淆）

-if (a > 15)

-    disp('Greater than 15')

-elseif (a == 23)

-    disp('a is 23')

-else

-    disp('neither condition met')

-end

-

-% 循环语�

-% 注�：对��或矩阵使用循环语�进行元素�历的效率很低��

-% 注�：��有�能，就尽�使用��或矩阵的整体�算�代�元素循环�历��

-% MATLAB 在开�时对��和矩阵�算�了专门优化，���和矩阵整体�算的效率高于循环语�

-for k = 1:5

-    disp(k)

-end

-    

-k = 0;  

-while (k < 5)

-    k = k + 1;

-end

-

-

-% 程��行计时：'tic' 是计时开始，'toc' 是计时结�并打�结果

-tic

-A = rand(1000);

-A*A*A*A*A*A*A;

-toc

-

-

-% 链接 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 代表具体版本�

-% 这里的 mysql-connector-java-5.1.xx-bin.jar �从 http://dev.mysql.com/downloads/connector/j/ 下载

-conn = database(dbname, username, password, driver, dburl); 

-sql = ['SELECT * from table_name where id = 22']  % SQL 语�

-a = fetch(conn, sql)  % a �包�所需数�

-

-

-% 常用数学函数

-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  % �匀分布的伪�机浮点数

-randi  % �匀分布的伪�机整数

-randn  % 正�分布的伪�机浮点数

-

-% 常用常数

-pi

-NaN

-inf

-

-% 求解矩阵方程（如果方程无解，则返回最�二乘近似解）

-% \ �作符等价于 mldivide 函数，/ �作符等价于 mrdivide 函数

-x=A\b  % 求解 Ax=b，比先求逆�左乘 inv(A)*b 更加高效�准确

-x=b/A  % 求解 xA=b

-

-inv(A)  % 逆矩阵

-pinv(A)  % 伪逆矩阵

-

-

-% 常用矩阵函数

-zeros(m, n)  % m x n 阶矩阵，元素全为 0

-ones(m, n)  % m x n 阶矩阵，元素全为 1

-diag(A)  % 返回矩阵 A 的对角线元素

-diag(x)  % 构造一个对角阵，对角线元素就是�� x 的�元素 

-eye(m, n)  % m x n 阶��矩阵

-linspace(x1, x2, n)  % 返回介于 x1 和 x2 之间的 n 个等�节点

-inv(A)  % 矩阵 A 的逆矩阵

-det(A)  % 矩阵 A 的行列�

-eig(A)  % 矩阵 A 的特�值和特���

-trace(A)  % 矩阵 A 的迹（�对角线元素之和），等价于 sum(diag(A))

-isempty(A)  % 测试 A 是�为空

-all(A)  % 测试 A 中所有元素是�都� 0 或都为真（逻辑值）

-any(A)  % 测试 A 中是�有元素� 0 或为真（逻辑值）

-isequal(A, B)  % 测试 A 和 B是�相等

-numel(A)  % 矩阵 A 的元素个数

-triu(x)  % 返回 x 的上三角这部分

-tril(x)  % 返回 x 的下三角这部分

-cross(A, B)  % 返回 A 和 B 的�积（矢�积�外积）

-dot(A, B)  % 返回 A 和 B 的点积（数�积�内积），�求 A 和 B 必须等长

-transpose(A)  % 矩阵（�共轭）转置，等价于 A.' （注��有个点）

-fliplr(A)  % 将一个矩阵左�翻转

-flipud(A)  % 将一个矩阵上下翻转

-

-% 矩阵分解

-[L, U, P] = lu(A)   % LU 分解：PA = LU，L 是下三角阵，U 是上三角阵，P 是置�阵

-[P, D]    = eig(A)  % 特�值分解：AP = PD

-                    %   D 是由特�值构�的对角阵，P 的�列就是对应的特���

-[U, S, V] = svd(X)  % 奇异值分解：XV = US

-                    %   U 和 V 是酉矩阵，S 是由奇异值构�的�正定实数对角阵

-

-% 常用��函数

-max     % 最大值

-min     % 最�值 

-length  % 元素个数

-sort    % 按��排列 

-sum     % �元素之和 

-prod    % �元素之积

-mode    % ä¼—æ•°

-median  % 中�数 

-mean    % 平�值 

-std     % 标准差

-perms(x) % x 元素的全排列

-

-```

-

-## 相关资料

-

-* 官方网页：[MATLAB - 技术计算语言 - MATLAB & Simulink](https://ww2.mathworks.cn/products/matlab.html)

-* 官方论�：[MATLAB Answers - MATLAB Central](https://ww2.mathworks.cn/matlabcentral/answers/)

+---
+language: MATLAB
+filename: matlab-cn.m
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+translators:
+    - ["sunxb10", "https://github.com/sunxb10"]
+lang: zh-cn
+
+---
+
+MATLAB 是 MATrix LABoratory（矩阵实验室）的缩写。
+它是一�功能强大的数值计算语言，在工程和数学领域中应用广泛。
+
+如果您有任何需��馈或交�的内容，请�系本教程作者：
+[@the_ozzinator](https://twitter.com/the_ozzinator) 
+或 [osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com)。
+
+```matlab
+% 以百分�作为注释符
+
+%{
+多行注释
+�以
+这样
+表示
+%}
+
+% 指令�以��跨行，但需�在跨行处用 '...' 标明：
+ a = 1 + 2 + ...
+ + 4
+
+% �以在MATLAB中直接��作系统�出指令
+!ping google.com
+
+who  % 显示内存中的所有��
+whos  % 显示内存中的所有��以�它们的类型
+clear  % 清除内存中的所有��
+clear('A')  % 清除指定的��
+openvar('A')  % 在��编辑器中编辑指定��
+
+clc  % 清除命令窗�中显示的所有指令
+diary  % 将命令窗�中的内容写入本地文件
+ctrl-c  % 终止当�计算
+
+edit('myfunction.m')  % 在编辑器中打开指定函数或脚本
+type('myfunction.m')  % 在命令窗�中打�指定函数或脚本的��
+
+profile on  % 打开 profile 代�分�工具
+profile off % 关闭 profile 代�分�工具
+profile viewer  % 查看 profile 代�分�工具的分�结果
+
+help command    % 在命令窗�中显示指定命令的帮助文档
+doc command     % 在帮助窗�中显示指定命令的帮助文档
+lookfor command  % 在所有 MATLAB 内置函数的头部注释�的第一行中�索指定命令
+lookfor command -all  % 在所有 MATLAB 内置函数的整个头部注释�中�索指定命令
+
+
+% 输出格�
+format short    % 浮点数�留 4 ��数
+format long     % 浮点数�留 15 ��数
+format bank     % 金�格�，浮点数��留 2 ��数
+fprintf('text') % 在命令窗�中显示 "text"
+disp('text')    % 在命令窗�中显示 "text"
+
+
+% ��与表达�
+myVariable = 4  % 命令窗�中将新创建的��
+myVariable = 4; % 加上分��使命令窗�中�显示当�语�执行结果
+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
+
+
+% 调用函数有两�方�：
+% 标准函数语法：
+load('myFile.mat', 'y') % �数放在括�内，以英文逗�分隔
+% 指令语法:
+load myFile.mat y   % �加括�，以空格分隔�数
+% 注�在指令语法中�数�需�加引�：在这�语法下，所有输入�数都�能是文本文字，
+% �能是��的具体值，�样也�能是输出��
+[V,D] = eig(A);  % 这�函数调用无法转��等价的指令语法
+[~,D] = eig(A);  % 如果结果中�需� D 而�需� V 则�以这样写
+
+
+
+% 逻辑�算
+1 > 5  % �，ans = 0
+10 >= 10  % 真，ans = 1
+3 ~= 4  % �等于 -> ans = 1
+3 == 3  % 等于 -> ans = 1
+3 > 1 && 4 > 1  % 与 -> ans = 1
+3 > 1 || 4 > 1  % 或 -> ans = 1
+~1  % � -> ans = 0
+
+% 逻辑�算�直接应用于矩阵，�算结果也是矩阵
+A > 5
+% 对矩阵中�个元素�逻辑�算，若为真，则在�算结果的矩阵中对应�置的元素就是 1
+A( A > 5 )
+% 如此返回的��，其元素就是 A 矩阵中所有逻辑�算为真的元素
+
+% 字符串
+a = 'MyString'
+length(a)  % ans = 8
+a(2)  % ans = y
+[a,a]  % ans = MyStringMyString
+b = '字符串'  % MATLAB目�已��以支�包括中文在内的多�文字
+length(b)  % ans = 3
+b(2)  % ans = 符
+[b,b]  % ans = 字符串字符串
+
+
+% 元组（cell 数组）
+a = {'one', 'two', 'three'} 
+a(1)  % ans = 'one' - 返回一个元组
+a{1}  % ans = one - 返回一个字符串
+
+
+% 结构体
+A.b = {'one','two'};
+A.c = [1 2];
+A.d.e = false;
+
+
+% ��
+x = [4 32 53 7 1] 
+x(2)  % ans = 32，MATLAB中��的下标索引从1开始，�是0
+x(2:3)  % ans = 32 53
+x(2:end)  % ans = 32 53 7 1
+
+x = [4; 32; 53; 7; 1]  % 列��
+
+x = [1:10]  % x = 1 2 3 4 5 6 7 8 9 10
+
+
+% 矩阵
+A = [1 2 3; 4 5 6; 7 8 9] 
+% 以分�分隔��的行，以空格或逗�分隔�一行中的��元素
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % ans = 6，A(row, column)
+A(6) % ans = 8 
+% （��地将 A 的三列首尾相接组�一个列��，然��其下标为 6 的元素）
+
+
+A(2,3) = 42  % 将第 2 行第 3 列的元素设为 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3)  % �原矩阵中的一�作为新矩阵
+%ans =
+
+%     5     42
+%     8     9
+
+A(:,1)  % 第 1 列的所有元素
+%ans =
+
+%     1
+%     4
+%     7
+
+A(1,:)  % 第 1 行的所有元素
+%ans =
+
+%     1     2     3
+
+[A ; A]  % 将两个矩阵上下相接构�新矩阵
+%ans =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% 等价于 
+vertcat(A, A);
+
+
+[A , A]  % 将两个矩阵左�相接构�新矩阵
+
+%ans =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% 等价于
+horzcat(A, A);
+
+
+A(:, [3 1 2])  % �新排布原矩阵的�列
+%ans =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A)  % 返回矩阵的行数和列数，ans = 3 3
+
+A(1, :) =[]  % 删除矩阵的第 1 行
+A(:, 1) =[]  % 删除矩阵的第 1 列
+
+transpose(A)  % 矩阵（�共轭）转置，等价于 A.' （注��有个点）
+ctranspose(A)  % 矩阵的共轭转置（对矩阵中的�个元素�共轭�数），等价于 A'
+
+
+% 元素�算 vs. 矩阵�算
+% �独�算符就是对矩阵整体进行矩阵�算
+% 在�算符加上英文�点就是对矩阵中的元素进行元素计算
+% 示例如下：
+A * B  % 矩阵乘法，�求 A 的列数等于 B 的行数
+A .* B  % 元素乘法，�求 A 和 B 形状一致，�两矩阵行列数完全一致
+        % 元素乘法的结果是与 A 和 B 形状一致的矩阵
+        % 其�个元素等于 A 对应�置的元素乘 B 对应�置的元素
+
+% 以下函数中，函数�以 m 结尾的执行矩阵�算，其余执行元素�算： 
+exp(A)  % 对矩阵中�个元素�指数�算
+expm(A)  % 对矩阵整体�指数�算
+sqrt(A)  % 对矩阵中�个元素�开方�算
+sqrtm(A)  % 对矩阵整体�开方�算（�试图求出一个矩阵，该矩阵与自身的乘积等于 A 矩阵）
+
+
+% 绘图
+x = 0:0.1:2*pi; % 生�一��，其元素从 0 开始，以 0.1 的间隔一直递增到 2*pi
+                % 其中 pi 为圆周率
+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 轴范围是从 0 到 2*pi，y 轴范围是从 -1 到 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':')  % 在�一张图中绘制多�曲线
+legend('Line 1 label', 'Line 2 label')  % 为图片加注图例
+% 图例数�应当�于或等于实际绘制的曲线数目，从 plot 绘制的第一�曲线开始对应
+
+% 在�一张图上绘制多�曲线的�一�方法：
+% 使用 hold on，令系统�留�次绘图结果并在其上直接�加新的曲线，
+% 如果没有 hold on，则�个 plot 都会首先清除之�的绘图结果�进行绘制。
+% 在 hold on 和 hold off 中�以放置任�多的 plot 指令，
+% 它们和 hold on �最�一个 plot 指令的结果都将显示在�一张图中。
+plot(x, y1)
+hold on
+plot(x, y2)
+plot(x, y3)
+plot(x, y4)
+hold off
+
+loglog(x, y)  % 对数—对数绘图
+semilogx(x, y)  % �对数（x 轴对数）绘图
+semilogy(x, y)  % �对数（y 轴对数）绘图
+
+fplot (@(x) x^2, [2,5])  % 绘制函数 x^2 在 [2, 5] 区间的曲线
+
+grid on  % 在绘制的图中显示网格，使用 grid off ��消网格显示
+axis square  % 将当��标系设定为正方形（��在图形显示上�轴等长）
+axis equal  % 将当��标系设定为相等（��在实际数值上�轴等长）
+
+scatter(x, y);  % 散点图
+hist(x);  % 直方图
+
+z = sin(x);
+plot3(x,y,z);  % 绘制三维曲线
+
+pcolor(A)  % 伪彩色图（热图）
+contour(A)  % 等高线图
+mesh(A)  % 网格曲�图
+
+h = figure  % 创建新的图片对象并返回其�柄 h
+figure(h)  % 将�柄 h 对应的图片作为当�图片
+close(h)  % 关闭�柄 h 对应的图片
+close all  % 关闭 MATLAB 中所用打开的图片
+close  % 关闭当�图片
+
+shg  % 显示图形窗�
+clf clear  % 清除图形窗�中的图�，并�置图�属性
+
+% 图�属性�以通过图��柄进行设定
+% 在创建图�时�以�存图��柄以便于设置
+% 也�以用 gcf 函数返回当�图�的�柄 
+h = plot(x, y);  % 在创建图�时显�地�存图��柄
+set(h, 'Color', 'r')
+% 颜色代�：
+%   'y' 黄色，'m' 洋红，'c' �色
+%   'r' 红色，'g' 绿色，'b' �色
+%   'w' 白色，'k' 黑色
+set(h, 'Color', [0.5, 0.5, 0.4])
+% 也�以使用 RGB 值指定颜色
+set(h, 'LineStyle', '--')
+% 线型代�：'--' 实线，'---' 虚线，':' 点线，'-.' 点划线，'none' �划线
+get(h, 'LineStyle')
+% 获�当��柄的线型
+
+
+% 用 gca 函数返回当�图�的�标轴�柄
+set(gca, 'XDir', 'reverse');  % 令 x 轴��
+
+% 用 subplot 指令创建平铺排列的多张�图
+subplot(2,3,1);  % 选择 2 x 3 排列的�图中的第 1 张图
+plot(x1); title('First Plot')  % 在选中的图中绘图
+subplot(2,3,2);  % 选择 2 x 3 排列的�图中的第 2 张图
+plot(x2); title('Second Plot')  % 在选中的图中绘图
+
+
+% �调用函数或脚本，必须��它们在你的当�工作目录中
+path  % 显示当�工作目录
+addpath /path/to/dir  % 将指定路径加入到当�工作目录中
+rmpath /path/to/dir  % 将指定路径从当�工作目录中删除
+cd /path/to/move/into  % 以制定路径作为当�工作目录
+
+
+% ����存到 .mat 格�的本地文件
+save('myFileName.mat')  % �存当�工作空间中的所有�� 
+load('myFileName.mat')  % 将指定文件中的��载入到当�工作空间 
+
+
+% .m 脚本文件
+% 脚本文件是一个包�多� MATLAB 指令的外部文件，以 .m 为�缀�
+% 使用脚本文件�以��在命令窗�中��输入冗长的指令
+
+
+% .m 函数文件
+% 与脚本文件类似，�样以 .m 作为�缀�
+% 但函数文件�以接�用户输入的�数并返回�算结果
+% 并且函数拥有自己的工作空间（��域），�必担心���称冲�
+% 函数文件的�称应当与其所定义的函数的�称一致
+% 比如下�例�中函数文件就应命�为 double_input.m
+% 使用 'help double_input.m' �返回函数定义中第一行注释信�
+function output = double_input(x) 
+    % double_input(x) 返回 x 的 2 �
+    output = 2*x;
+end
+double_input(6)  % ans = 12 
+
+
+% �样还�以定义�函数和内嵌函数
+% �函数与主函数放在�一个函数文件中，且�能被这个主函数调用
+% 内嵌函数放在�一个函数体内，�以直接访问被嵌套函数的�个��
+
+
+% 使用匿�函数�以�必创建 .m 函数文件
+% 匿�函数适用于快速定义�函数以便传递给�一指令或函数（如绘图�积分�求根�求�值等）
+% 下�示例的匿�函数返回输入�数的平方根，�以使用�柄 sqr 进行调用：
+sqr = @(x) x.^2;
+sqr(10) % ans = 100
+doc function_handle % find out more
+
+
+% 接�用户输入
+a = input('Enter the value: ')
+
+
+% 从文件中读�数�
+fopen(filename)
+% 类似函数还有 xlsread（excel 文件）�importdata（CSV 文件）�imread（图�文件）
+
+
+% 输出
+disp(a)  % 在命令窗�中打��� a 的值
+disp('Hello World')  % 在命令窗�中打�字符串
+fprintf  % 按照指定格�在命令窗�中打�内容
+
+% �件语�（if 和 elseif 语�中的括�并�必需，但推�加括���混淆）
+if (a > 15)
+    disp('Greater than 15')
+elseif (a == 23)
+    disp('a is 23')
+else
+    disp('neither condition met')
+end
+
+% 循环语�
+% 注�：对��或矩阵使用循环语�进行元素�历的效率很低��
+% 注�：��有�能，就尽�使用��或矩阵的整体�算�代�元素循环�历��
+% MATLAB 在开�时对��和矩阵�算�了专门优化，���和矩阵整体�算的效率高于循环语�
+for k = 1:5
+    disp(k)
+end
+    
+k = 0;  
+while (k < 5)
+    k = k + 1;
+end
+
+
+% 程��行计时：'tic' 是计时开始，'toc' 是计时结�并打�结果
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+
+% 链接 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 代表具体版本�
+% 这里的 mysql-connector-java-5.1.xx-bin.jar �从 http://dev.mysql.com/downloads/connector/j/ 下载
+conn = database(dbname, username, password, driver, dburl); 
+sql = ['SELECT * from table_name where id = 22']  % SQL 语�
+a = fetch(conn, sql)  % a �包�所需数�
+
+
+% 常用数学函数
+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  % �匀分布的伪�机浮点数
+randi  % �匀分布的伪�机整数
+randn  % 正�分布的伪�机浮点数
+
+% 常用常数
+pi
+NaN
+inf
+
+% 求解矩阵方程（如果方程无解，则返回最�二乘近似解）
+% \ �作符等价于 mldivide 函数，/ �作符等价于 mrdivide 函数
+x=A\b  % 求解 Ax=b，比先求逆�左乘 inv(A)*b 更加高效�准确
+x=b/A  % 求解 xA=b
+
+inv(A)  % 逆矩阵
+pinv(A)  % 伪逆矩阵
+
+
+% 常用矩阵函数
+zeros(m, n)  % m x n 阶矩阵，元素全为 0
+ones(m, n)  % m x n 阶矩阵，元素全为 1
+diag(A)  % 返回矩阵 A 的对角线元素
+diag(x)  % 构造一个对角阵，对角线元素就是�� x 的�元素 
+eye(m, n)  % m x n 阶��矩阵
+linspace(x1, x2, n)  % 返回介于 x1 和 x2 之间的 n 个等�节点
+inv(A)  % 矩阵 A 的逆矩阵
+det(A)  % 矩阵 A 的行列�
+eig(A)  % 矩阵 A 的特�值和特���
+trace(A)  % 矩阵 A 的迹（�对角线元素之和），等价于 sum(diag(A))
+isempty(A)  % 测试 A 是�为空
+all(A)  % 测试 A 中所有元素是�都� 0 或都为真（逻辑值）
+any(A)  % 测试 A 中是�有元素� 0 或为真（逻辑值）
+isequal(A, B)  % 测试 A 和 B是�相等
+numel(A)  % 矩阵 A 的元素个数
+triu(x)  % 返回 x 的上三角这部分
+tril(x)  % 返回 x 的下三角这部分
+cross(A, B)  % 返回 A 和 B 的�积（矢�积�外积）
+dot(A, B)  % 返回 A 和 B 的点积（数�积�内积），�求 A 和 B 必须等长
+transpose(A)  % 矩阵（�共轭）转置，等价于 A.' （注��有个点）
+fliplr(A)  % 将一个矩阵左�翻转
+flipud(A)  % 将一个矩阵上下翻转
+
+% 矩阵分解
+[L, U, P] = lu(A)   % LU 分解：PA = LU，L 是下三角阵，U 是上三角阵，P 是置�阵
+[P, D]    = eig(A)  % 特�值分解：AP = PD
+                    %   D 是由特�值构�的对角阵，P 的�列就是对应的特���
+[U, S, V] = svd(X)  % 奇异值分解：XV = US
+                    %   U 和 V 是酉矩阵，S 是由奇异值构�的�正定实数对角阵
+
+% 常用��函数
+max     % 最大值
+min     % 最�值 
+length  % 元素个数
+sort    % 按��排列 
+sum     % �元素之和 
+prod    % �元素之积
+mode    % ä¼—æ•°
+median  % 中�数 
+mean    % 平�值 
+std     % 标准差
+perms(x) % x 元素的全排列
+
+```
+
+## 相关资料
+
+* 官方网页：[MATLAB - 技术计算语言 - MATLAB & Simulink](https://ww2.mathworks.cn/products/matlab.html)
+* 官方论�：[MATLAB Answers - MATLAB Central](https://ww2.mathworks.cn/matlabcentral/answers/)
diff --git a/zh-cn/mips-cn.html.markdown b/zh-cn/mips-cn.html.markdown
new file mode 100644
index 00000000..4f9ea7da
--- /dev/null
+++ b/zh-cn/mips-cn.html.markdown
@@ -0,0 +1,334 @@
+---
+language: "MIPS Assembly"
+filename: MIPS-cn.asm
+contributors:
+    - ["Stanley Lim", "https://github.com/Spiderpig86"]
+translators:
+    - ["Liu Yihua", "https://github.com/yihuajack"]
+lang: zh-cn
+---
+
+MIPS（Microprocessor without Interlocked Pipeline Stages）汇编语言是为了��约翰·雷洛伊·亨尼西于1981年设计的 MIPS 微处�器范�而设计的，这些 RISC 处�器用于嵌入�系统，例如网关和路由器。
+
+[阅读更多](https://en.wikipedia.org/wiki/MIPS_architecture)
+
+```asm
+# 注释用一个 '#' 表示
+
+# 一行中 '#' 之�的所有文本都会被汇编器的�法分�器忽略
+
+# 程�通常包� .data 和 .text 部分
+
+.data # 数�存储在内存中（在RAM中分�）
+      # 类似于高级语言中的��
+
+  # 声明�循（ 标签: .类型 值 ）的声明形�
+  hello_world: .asciiz "Hello World\n"      # 声明一个 null 结�的字符串
+  num1: .word 42                            # 整数被视为字
+                                            # （32�值）
+
+  arr1: .word 1, 2, 3, 4, 5                 # 字数组
+  arr2: .byte 'a', 'b'                      # 字符数组（�个1字节）
+  buffer: .space 60                         # 在 RAM 中分�空间
+                                            # （�清除为0）
+
+  # 数�类型的大�
+  _byte: .byte 'a'                          # 1字节
+  _halfword: .half 53                       # 2字节
+  _word: .word 3                            # 4字节
+  _float: .float 3.14                       # 4字节
+  _double: .double 7.0                      # 8字节
+
+  .align 2                                  # 数�的内存对�
+                                            # 其中数字（应是2的幂）表示几字节对�
+                                            # .align 2 表示字对�（因为 2^2 = 4 字节）
+
+.text                                       # 这部分包括指令和程�逻辑
+.globl _main                                # 声明一个全局指令标签
+                                            # 其他文件都�以访问
+
+  _main:                                    # MIPS 程�按顺�执行指令
+                                            # 这�标签下的代�将首先执行
+
+    # 打� "hello world"
+    la $a0, hello_world                     # 加载存储在内存中的字符串地�
+    li $v0, 4                               # 加载 syscall 的值
+                                            # （数字代表�执行哪个 syscall）
+    syscall                                 # 使用给定的�数（$a0）执行指定的 syscall
+
+    # 寄存器（用于在程�执行期间�存数�）
+    # $t0 - $t9                             # 临时寄存器，用于过程内部的中间计算
+                                            # （过程调用时��存）
+
+    # $s0 - $s7                             # �留寄存器（被�留的寄存器，过程调用时�存）
+                                            # 通常�存在栈中
+
+    # $a0 - $a3                             # �数寄存器，用于传递过程的�数
+    # $v0 - $v1                             # 返回寄存器，用于�调用过程返回值
+
+    # 存�指令
+    la $t0, label                           # 将内存中由 label 指定的值的地��制到寄存器 $t0 中
+    lw $t0, label                           # 从内存中�制一个字
+    lw $t1, 4($s0)                          # 从寄存器中存储的地��制一个字
+                                            # �移�为4字节（地� + 4）
+    lb $t2, label                           # 把一个字节�制到寄存器 $t2 的低阶部分
+    lb $t2, 0($s0)                          # 从 $s0 的�地��制一个字节
+                                            # �移�为0
+    # ��也适用于 'lh' （��字）
+
+    sw $t0, label                           # 将字存储到由 label 映射的内存地�中
+    sw $t0, 8($s0)                          # 将字存储到 $s0 指定的地�中
+                                            # �移�为8字节
+    # ��也适用于 'sb' （存字）和 'sh' （存�字）。'sa'�存在
+
+### æ•°å­¦ ###
+  _math:
+    # 记��将值加载到寄存器中
+    lw $t0, num                             # 从数�部分
+    li $t0, 5                               # 或者从一个立�数（常数）
+    li $t1, 6
+    add $t2, $t0, $t1                       # $t2 = $t0 + $t1
+    sub $t2, $t0, $t1                       # $t2 = $t0 - $t1
+    mul $t2, $t0, $t1                       # $t2 = $t0 * $t1
+    div $t2, $t0, $t1                       # $t2 = $t0 / $t1
+                                            # （MARS 的�些版本�能�支�）
+    div $t0, $t1                            # 执行 $t0 / $t1。
+                                            # 用 'mflo' 得商，用 'mfhi' 得余数
+
+    # 移�
+    sll $t0, $t0, 2                         # 按�左移立�数（常数值）2
+    sllv $t0, $t1, $t2                      # 根�一个寄存器中的��值左移相应�
+    srl $t0, $t0, 5                         # 按��移
+                                            # （��留符�，用0符�扩展）
+    srlv $t0, $t1, $t2                      # 根�一个寄存器中的��值�移相应�
+    sra $t0, $t0, 7                         # 按算术��移（�留符�）
+    srav $t0, $t1, $t2                      # 根�一个寄存器中的��值�移相应算数�
+
+    # 按��算符
+    and $t0, $t1, $t2                       # 按�与
+    andi $t0, $t1, 0xFFF                    # 用立�数按�与
+    or $t0, $t1, $t2                        # 按�或
+    ori $t0, $t1, 0xFFF                     # 用立�数按�或
+    xor $t0, $t1, $t2                       # 按�异或
+    xori $t0, $t1, 0xFFF                    # 用立�数按�异或
+    nor $t0, $t1, $t2                       # 按�或�
+
+## 分支 ##
+  _branching:
+    # 分支指令的基本格�通常�循 <指令> <寄存器1> <寄存器2> <标签>
+    # 如果给定的�件求值为真，则跳转到标签
+    # 有时��编写�件逻辑更容易，如下�的简�的 if 语�示例所示
+
+    beq $t0, $t1, reg_eq                    # 如果 $t0 == $t1，则跳转到 reg_eq
+                                            # �则执行下一行
+    bne $t0, $t1, reg_neq                   # 当 $t0 != $t1 时跳转
+    b branch_target                         # ��件分支，总会执行
+    beqz $t0, req_eq_zero                   # 当 $t0 == 0 时跳转
+    bnez $t0, req_neq_zero                  # 当 $t0 != 0 时跳转
+    bgt $t0, $t1, t0_gt_t1                  # 当 $t0 > $t1 时跳转
+    bge $t0, $t1, t0_gte_t1                 # 当 $t0 >= $t1 时跳转
+    bgtz $t0, t0_gt0                        # 当 $t0 > 0 时跳转
+    blt $t0, $t1, t0_gt_t1                  # 当 $t0 < $t1 时跳转
+    ble $t0, $t1, t0_gte_t1                 # 当 $t0 <= $t1 时跳转
+    bltz $t0, t0_lt0                        # 当 $t0 < 0 时跳转
+    slt $s0, $t0, $t1                       # 当 $t0 < $t1 时结果为 $s0 （1为真）
+
+    # 简�的 if 语�
+    # if (i == j)
+    #     f = g + h;
+    #  f = f - i;
+
+    # 让 $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
+    bne $s3, $s4, L1 # if (i !=j)
+    add $s0, $s1, $s2 # f = g + h
+
+    L1:
+      sub $s0, $s0, $s3 # f = f - i
+    
+    # 下�是一个求3个数的最大值的例�
+    # 从 Java 到 MIPS 逻辑的直接翻译：
+    # if (a > b)
+    #   if (a > c)
+    #     max = a;
+    #   else
+    #     max = c;
+    # else
+    #     max = b;
+    #   else
+    #     max = c;
+
+    # 让 $s0 = a, $s1 = b, $s2 = c, $v0 = 返回寄存器
+    ble $s0, $s1, a_LTE_b                   # 如果 (a <= b) 跳转到 (a_LTE_b)
+    ble $s0, $s2, max_C                     # 如果 (a > b && a <= c) 跳转到 (max_C)
+    move $v0, $s0                           # �则 [a > b && a > c] max = a
+    j done                                  # 跳转到程�结�
+
+    a_LTE_b:                                # 当 a <= b 时的标签
+      ble $s1, $s2, max_C                   # 如果 (a <= b && b <= c) 跳转到 (max_C)
+      move $v0, $s1                         # 如果 (a <= b && b > c) max = b
+      j done                                # 跳转到 done
+
+    max_C:
+      move $v0, $s2                         # max = c
+
+    done:                                   # 程�结�
+
+## 循环 ##
+  _loops:
+    # 循环的基本结构是一个退出�件和一个继续执行的跳转指令
+    li $t0, 0
+    while:
+      bgt $t0, 10, end_while                # 当 $t0 �于 10，��迭代
+      addi $t0, $t0, 1                      # 累加值
+      j while                               # 跳转回循环开始
+    end_while:
+
+    # 二维矩阵�历
+    # �设 $a0 存储整数 3 × 3 矩阵的地�
+    li $t0, 0                               # 计数器 i
+    li $t1, 0                               # 计数器 j
+    matrix_row:
+      bgt $t0, 3, matrix_row_end
+
+      matrix_col:
+        bgt $t1, 3, matrix_col_end
+
+        # 执行一些东西
+
+        addi $t1, $t1, 1                  # 累加列计数器
+      matrix_col_end:
+
+      # 执行一些东西
+
+      addi $t0, $t0, 1
+    matrix_row_end:
+
+## 函数 ##
+  _functions:
+    # 函数是�调用的过程，�以接��数并返回所有用标签表示的值，如�所示
+
+    main:                                 # 程�以 main 函数开始
+      jal return_1                        # jal 会把当�程�计数器（PC）存储在 $ra
+                                          # 并跳转到 return_1
+
+      # 如果我们想传入�数呢？
+      # 首先，我们必须将形�传递给�数寄存器
+      li $a0, 1
+      li $a1, 2
+      jal sum                             # 现在我们�以调用函数了
+
+      # 递归怎么样？
+      # 这需�更多的工作
+      # 由于 jal 会自动覆盖�次调用，我们需�确�在 $ra 中�存并��之�的程�计数器
+      li $a0, 3
+      jal fact
+
+      li $v0, 10
+      syscall
+    
+    # 这个函数返回1
+    return_1:
+      li $v0, 1                           # 将值�到返回寄存器 $v0 中
+      jr $ra                              # 跳转回原先的程�计数器继续执行
+
+
+    # 有2个�数的函数
+    sum:
+      add $v0, $a0, $a1
+      jr $ra                              # 返回
+
+    # 求阶乘的递归函数
+    fact:
+      addi $sp, $sp, -8                   # 在栈中分�空间
+      sw $s0, ($sp)                       # 存储�存当�数字的寄存器
+      sw $ra, 4($sp)                      # 存储先�的程�计数器
+
+      li $v0, 1                           # �始化返回值
+      beq $a0, 0, fact_done               # 如果�数为0则完�
+
+      # �则继续递归
+      move $s0, $a0                       # �制 $a0 到 $s0
+      sub $a0, $a0, 1
+      jal fact
+
+      mul $v0, $s0, $v0                   # �乘法
+
+      fact_done:
+        lw $s0, ($sp)
+        lw $ra, ($sp)                     # ��程�计数器
+        addi $sp, $sp, 8
+
+        jr $ra
+
+## � ##
+  _macros:
+    # ��以实现用�个标签替���的代��，这�以增强程�的�读性
+    # 它们��是函数的替代�
+    # 它们必须在使用之�声明
+
+    # 用于打��行符的�（这�以被多次�用）
+    .macro println()
+      la $a0, newline                     # 存储在这里的新行字符串
+      li $v0, 4
+      syscall
+    .end_macro
+
+    println()                             # 汇编器会在�行��制此代��
+
+    # �数�以通过�传入。
+    # 它们由 '%' 符�表示，�以选择起任��字
+    .macro print_int(%num)
+      li $v0, 1
+      lw $a0, %num
+      syscall
+    .end_macro
+    
+    li $t0, 1
+    print_int($t0)
+    
+    # 我们也�以给�传递立�数
+    .macro immediates(%a, %b)
+      add $t0, %a, %b
+    .end_macro
+
+    immediates(3, 5)
+
+    # 以�标签
+    .macro print(%string)
+      la $a0, %string
+      li $v0, 4
+      syscall
+    .end_macro
+
+    print(hello_world)
+
+## 数组 ##
+.data
+  list: .word 3, 0, 1, 2, 6                 # 这是一个字数组
+  char_arr: .asciiz "hello"                 # 这是一个字符数组
+  buffer: .space 128                        # 在内存中分��，�会自动清除
+                                            # 这些内存�彼此对�
+
+.text
+  la $s0, list                              # � list 的地�
+  li $t0, 0                                 # 计数器
+  li $t1, 5                                 # list 的长度
+
+  loop:
+    bgt $t0, $t1, end_loop
+
+    lw $a0, ($s0)
+    li $v0, 1
+    syscall                                 # 打�数字
+
+    addi $s0, $s0, 4                        # 字的大�为4字节
+    addi $t0, $t0, 1                        # 累加
+    j loop
+  end_loop:
+
+## INCLUDE ##
+# 使用 include 语��以将外部文件导入到程�中
+# （它�是将文件中的代�放入 include 语�的�置）
+.include "somefile.asm"
+
+```
diff --git a/zh-cn/nim-cn.html.markdown b/zh-cn/nim-cn.html.markdown
new file mode 100644
index 00000000..fa7d8259
--- /dev/null
+++ b/zh-cn/nim-cn.html.markdown
@@ -0,0 +1,283 @@
+---
+language: Nim
+filename: learnNim-cn.nim
+contributors:
+    - ["Jason J. Ayala P.", "http://JasonAyala.com"]
+    - ["Dennis Felsing", "https://dennis.felsing.org"]
+translators:
+    - ["lzw-723", "https://github.com/lzw-723"]
+lang: zh-cn
+---
+
+Nim(原�Nimrod)是一���类型的命令�编程语言，
+它能在�影��行时效率的情况下为程�员�供强大的功能。
+
+Nim语言高效�有表现力�优雅。
+
+```nim
+# �行注释以一个#开头
+
+#[
+  这是多行注释
+  在Nim语言中，多行注释�以嵌套，以#[开头，以]#结尾
+]#
+
+discard """
+这也�以作为多行注释使用。
+或者用于无法解����的代�
+"""
+
+var                     # 声明(和赋值)��
+  letter: char = 'n'    # 带或�带类型批注
+  lang = "N" & "im"
+  nLength: int = len(lang)
+  boat: float
+  truth: bool = false
+
+ let            # 使用let*一次性*声明和绑定��。
+  legs = 400   # legs是��改�的。
+  arms = 2_000 # _会被忽略，对long类型�常有用。
+  aboutPi = 3.15
+
+const            # 常�在编译时计算。这确�了
+  debug = true   # 性能，在编译时表达�中很有用。
+  compileBadCode = false
+
+when compileBadCode:            # `when`是编译时的`if`
+  legs = legs + 1               # 这个错误永远�会被编译。
+  const input = readline(stdin) # const在编译时必须是已知的。
+
+discard 1 > 2 # 注�：如果表达�的结果未使用，
+              # 编译器会�出警告。`discard`绕过了这一点。
+
+
+#
+# 数�结构
+#
+
+# 元组(Tuple)
+
+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
+
+# �列(Sequence)
+
+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        # 错误�age是int类型�money是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 # Enum通常是“�数�类型
+
+# �范围指定有�的有效范围
+
+type
+  DieFaces = range[1..20] # �有从1到20的int�是有效值
+var
+  my_roll: DieFaces = 13
+
+when compileBadCode:
+  my_roll = 23 # 错误�
+
+# 数组(Array)
+
+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"]
+
+# �用的数�结构包括表�集��列表�队列�压缩�缀树。
+# http://nim-lang.org/docs/lib.html#collections-and-algorithms
+
+#
+# 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
+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!")
+
+#
+# 循环(Iteration)
+#
+
+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)
+
+#
+# 过程(Procedure)
+#
+
+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) = # amount默认是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通过元编程�性能和编译时特性将自己与其他�类分离开�。
+
+## 进阶阅读
+
+* [主页](http://nim-lang.org)
+* [下载](http://nim-lang.org/download.html)
+* [社区](http://nim-lang.org/community.html)
+* [常�问题](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/zh-cn/perl-cn.html.markdown b/zh-cn/perl-cn.html.markdown
index 4421da6e..46c54618 100644
--- a/zh-cn/perl-cn.html.markdown
+++ b/zh-cn/perl-cn.html.markdown
@@ -146,7 +146,7 @@ perlfaq有很多常�问题和相应回答，也�常有对优秀CPAN模�的
 
 #### 深入阅读
 
-    - [perl-tutorial](http://perl-tutorial.org/)
-    - [www.perl.com的learn站点](http://www.perl.org/learn.html)
-    - [perldoc](http://perldoc.perl.org/)
-    - 以� perl 内置的： `perldoc perlintro`
+- [perl-tutorial](http://perl-tutorial.org/)
+- [www.perl.com的learn站点](http://www.perl.org/learn.html)
+- [perldoc](http://perldoc.perl.org/)
+- 以� perl 内置的： `perldoc perlintro`
diff --git a/zh-cn/powershell-cn.html.markdown b/zh-cn/powershell-cn.html.markdown
index 6ab34e9f..875d2e33 100644
--- a/zh-cn/powershell-cn.html.markdown
+++ b/zh-cn/powershell-cn.html.markdown
@@ -13,7 +13,7 @@ PowerShell 是 Windows 平�下的脚本语言�时也是�置管�框架，
 
 与 Bash 最大的��是你大部分�作的东西是对象而�是普通的文本。
 
-[延伸阅读](https://technet.microsoft.com/en-us/library/bb978526.aspx)
+[延伸阅读](https://docs.microsoft.com/zh-cn/powershell/scripting/overview)
 
 如果你�确定你的环境，执行如下�作：
 
@@ -263,7 +263,7 @@ Get-Command ConvertTo-*,ConvertFrom-*
 
 ### 有用的东西
 # æ›´æ–° PATH
-$env:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + 
+$env:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") +
 	";" + [System.Environment]::GetEnvironmentVariable("Path", "User")
 
 # 找到 Python 的 PATH
@@ -319,7 +319,7 @@ if (-not (Test-Path $Profile)) {
 
 尚未涉�
 
-* WMI: Windows 管�规范 (Get-CimInstance)  
+* WMI: Windows 管�规范 (Get-CimInstance)
 * 多任务: Start-Job -scriptBlock {...},
 * 代�签�
 * 远程 (Enter-PSSession/Exit-PSSession; Invoke-Command)
diff --git a/zh-cn/pyqt-cn.html.markdown b/zh-cn/pyqt-cn.html.markdown
index 55e5bbe3..04041c83 100644
--- a/zh-cn/pyqt-cn.html.markdown
+++ b/zh-cn/pyqt-cn.html.markdown
@@ -19,7 +19,7 @@ lang: zh-cn
 ```python
 import sys
 from PyQt4 import QtGui
-    
+
 def window():
     # 创建应用对象
     app = QtGui.QApplication(sys.argv)
@@ -44,7 +44,7 @@ if __name__ == '__main__':
 
 为了�用 pyqt 中一些更高级的功能，我们需�开始学习使用其他控件。下文演示了如何弹出对�框，该对�框在用户确认�作或输入信�等情况下�常用到。
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -62,7 +62,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-    
+
 # 对�框窗�创建函数
 # 当窗�中的按钮被点击时退出本程�
 def showdialog():
diff --git a/zh-cn/python-cn.html.markdown b/zh-cn/python-cn.html.markdown
index 6c5556fc..127f7ad5 100644
--- a/zh-cn/python-cn.html.markdown
+++ b/zh-cn/python-cn.html.markdown
@@ -6,8 +6,10 @@ contributors:
     - ["Andre Polykanine", "https://github.com/Oire"]
 translators:
     - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Maple", "https://github.com/mapleincode"]
 filename: learnpython-cn.py
 lang: zh-cn
+
 ---
 
 Python 是由�多·范罗�姆(Guido Van Rossum)在 90 年代早期设计。
@@ -19,7 +21,6 @@ Python 是由�多·范罗�姆(Guido Van Rossum)在 90 年代早期设计。
 注�：这篇教程是基于 Python 3 写的。如果你想学旧版 Python 2，我们特别有[�一篇教程](http://learnxinyminutes.com/docs/pythonlegacy/)。
 
 ```python
-
 # 用井字符开头的是�行注释
 
 """ 多行字符串用三个引�
@@ -35,50 +36,66 @@ Python 是由�多·范罗�姆(Guido Van Rossum)在 90 年代早期设计。
 3  # => 3
 
 # 算术没有什么出乎�料的
-1 + 1  # => 2
-8 - 1  # => 7
+1 + 1   # => 2
+8 - 1   # => 7
 10 * 2  # => 20
 
 # 但是除法例外，会自动转��浮点数
 35 / 5  # => 7.0
-5 / 3  # => 1.6666666666666667
+10.0 / 3  # => 3.3333333333333335
 
 # 整数除法的结果都是�下�整
-5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # 浮点数也�以
--5 // 3  # => -2
--5.0 // 3.0 # => -2.0
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # 浮点数也�以
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
 
 # 浮点数的�算结果也是浮点数
 3 * 2.0 # => 6.0
 
 # 模除
 7 % 3 # => 1
+# i % j 结果的正负符�会和 j 相�，而�是和 i 相�
+-7 % 3 # => 2
 
-# x的y次方
+# x 的 y 次方
 2**4 # => 16
 
 # 用括�决定优先级
+1 + 3 * 2    # => 7
 (1 + 3) * 2  # => 8
 
-# 布尔值
-True
-False
+# 布尔值 (注�: 首字�大写)
+True   # => True
+False  # => False
 
-# 用not��
-not True  # => False
+# 用 not ��
+not True   # => False
 not False  # => True
 
-# 逻辑�算符，注�and和or都是�写
+# 逻辑�算符，注� and 和 or 都是�写
 True and False # => False
 False or True # => True
 
-# 整数也�以当作布尔值
-0 and 2 # => 0
--5 or 0 # => -5
+# True 和 False 实质上就是数字 1 和0
+True + True # => 2
+True * 8    # => 8
+False - 5   # => -5
+
+# 数值与 True 和 False 之间的比较�算
 0 == False # => True
 2 == True # => False
 1 == True # => True
+-5 != False # => True
+
+# 使用布尔逻辑�算符对数字类型的值进行�算时，会把数值强制转�为布尔值进行�算
+# 但计算结果会返回它们的强制转��的值
+# 注���把 bool(ints) 与��算的 "按�与"�"按�或" (&, |) 混淆
+bool(0)     # => False
+bool(4)     # => True
+bool(-6)    # => True
+0 and 2     # => 0
+-5 or 0     # => -5
 
 # 用==判断相等
 1 == 1  # => True
@@ -94,47 +111,71 @@ False or True # => True
 2 <= 2  # => True
 2 >= 2  # => True
 
+# 判断一个值是�在范围里
+1 < 2 and 2 < 3  # => True
+2 < 3 and 3 < 2  # => False
 # 大�比较�以连起��
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
-# 字符串用�引�引都�以
+# (is 对比 ==) is 判断两个��是�引用�一个对象,
+# 而 == 判断两个对象是��有相�的值
+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 的对象的值相�
+
+
+# 创建字符串�以使用�引�（'）或者�引�（"）
 "这是个字符串"
 '这也是个字符串'
 
-# 用加�连接字符串
+# 字符串�以使用加�连接�新的字符串
 "Hello " + "world!"  # => "Hello world!"
+# ���形�的字符串甚至�以在没有加�的情况下连接
+"Hello " "world!"    # => "Hello world!"
 
 # 字符串�以被当作字符列表
-"This is a string"[0]  # => 'T'
+"Hello world!"[0]  # => 'H'
 
-# 用.format�格�化字符串
-"{} can be {}".format("strings", "interpolated")
+# 你�以获得字符串的长度
+len("This is a string")  # => 16
 
+# 你�以使用 f-strings 格�化字符串（python3.6+）
+name = "Reiko"
+f"She said her name is {name}." # => "She said her name is Reiko"
+# 你�以在大括�内几乎加入任何 python 表达�，表达�的结果会以字符串的形�返回
+f"{name} is {len(name)} characters long." # => "Reiko is 5 characters long."
+
+# 用 .format �格�化字符串
+"{} can be {}".format("strings", "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"
 
-# 如果你的Python3程�也�在Python2.5以下环境�行，也�以用��的格�化语法
+# 如果你的 Python3 程�也�在 Python2.5 以下环境�行，也�以用��的格�化语法
 "%s can be %s the %s way" % ("strings", "interpolated", "old")
 
 # None是一个对象
 None  # => None
 
-# 当与None进行比较时��用 ==，�用is。is是用�比较两个��是�指��一个对象。
+# 当与 None 进行比较时��用 ==，�用 is。is 是用�比较两个��是�指��一个对象。
 "etc" is None  # => False
 None is None  # => True
 
-# None，0，空字符串，空列表，空字典都算是False
-# 所有其他值都是True
+# None，0，空字符串，空列表，空字典，空元组都算是 False
+# 所有其他值都是 True
 bool(0)  # => False
 bool("")  # => False
 bool([]) # => False
 bool({}) # => False
+bool(()) # => False
 
 
 ####################################################
@@ -144,16 +185,26 @@ bool({}) # => False
 # print是内置的打�函数
 print("I'm Python. Nice to meet you!")
 
+# 默认情况下，print 函数会在输出结果�加入一个空行作为结尾
+# �以使用附加�数改�输出结尾
+print("Hello, World", end="!")  # => Hello, World!
+
+# �以很简�的从终端获得输入数�
+input_string_var = input("Enter some data: ") # 返回字符串数值
+
 # 在给��赋值��用��声明
-# 传统的��命�是�写，用下划线分隔��
+# 习惯上��命�是�写，用下划线分隔��
 some_var = 5
 some_var  # => 5
 
 # 访问未赋值的��会抛出异常
 # �考�程控制一段�学习异常处�
-some_unknown_var  # 抛出NameError
+some_unknown_var  # 抛出 NameError
+
+# "if" �以用作表达�，它的作用等�于 C 语言的三元�算符 "?:"
+"yay!" if 0 > 1 else "nay!"  # => "nay!"
 
-# 用列表(list)储存�列
+# 用列表 (list) 储存�列
 li = []
 # 创建列表时也�以�时赋给元素
 other_li = [4, 5, 6]
@@ -173,128 +224,177 @@ li[0]  # => 1
 # �出最�一个元素
 li[-1]  # => 3
 
-# 越界存�会造�IndexError
-li[4]  # 抛出IndexError
+# 越界存�会造� IndexError
+li[4]  # 抛出 IndexError
 
 # 列表有切割语法
-li[1:3]  # => [2, 4]
+li[1:3]    # => [2, 4]
 # �尾
-li[2:]  # => [4, 3]
+li[2:]     # => [4, 3]
 # �头
-li[:3]  # => [1, 2, 4]
+li[:3]     # => [1, 2, 4]
 # 隔一个�一个
-li[::2]   # =>[1, 4]
+li[::2]    # =>[1, 4]
 # 倒排列表
 li[::-1]   # => [3, 4, 2, 1]
 # �以用三个�数的任何组��构建切割
 # li[始:终:步�]
 
-# 用del删除任何一个元素
-del li[2]   # li is now [1, 2, 3]
+# 简�的实现了�层数组的深度�制
+li2 = li[:]  # => li2 = [1, 2, 4, 3] ，但 (li2 is li) 会返回 False
+
+# 用 del 删除任何一个元素
+del li[2]   # li 现在为 [1, 2, 3]
+
+# 删除第一个匹�的元素
+li.remove(2)  # li 现在为 [1, 3]
+li.remove(2)  # 抛出错误 ValueError: 2 is not in the list
+
+# 在指定索引处�入一个新的元素
+li.insert(1, 2)  # li is now [1, 2, 3] again
+
+# 获得列表第一个匹�的值的索引
+li.index(2)  # => 1
+li.index(4)  # 抛出一个 ValueError: 4 is not in the list
 
 # 列表�以相加
-# 注�：li和other_li的值都��
+# 注�：li 和 other_li 的值都��
 li + other_li   # => [1, 2, 3, 4, 5, 6]
 
-# 用extend拼接列表
-li.extend(other_li)   # li现在是[1, 2, 3, 4, 5, 6]
+# 用 "extend()" 拼接列表
+li.extend(other_li)   # li 现在是[1, 2, 3, 4, 5, 6]
 
-# 用in测试列表是�包�值
+# 用 "in" 测试列表是�包�值
 1 in li   # => True
 
-# 用len�列表长度
+# 用 "len()" �列表长度
 len(li)   # => 6
 
 
-# 元组是��改�的�列
+# 元组类似列表，但是��许修改
 tup = (1, 2, 3)
 tup[0]   # => 1
-tup[0] = 3  # 抛出TypeError
+tup[0] = 3  # 抛出 TypeError
+
+# 如果元素数�为 1 的元组必须在元素之�加一个逗�
+# 其他元素数�的元组，包括空元组，都�需�
+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是1，b是2，c是3
+a, b, c = (1, 2, 3)     # 现在 a 是 1，b 是 2，c 是 3
+# 也�以�扩展解包
+a, *b, c = (1, 2, 3, 4)  # 现在 a 是 1, b 是 [2, 3]， c 是 4
 # 元组周围的括�是�以�略的
-d, e, f = 4, 5, 6
+d, e, f = 4, 5, 6 # 元组 4, 5, 6 通过解包被赋值给�� d, e, f
 # 交�两个��的值就这么简�
-e, d = d, e     # 现在d是5，e是4
+e, d = d, e     # 现在 d 是 5，e 是 4
 
 
-# 用字典表达映射关系
+# 字典用�存储 key 到 value 的映射关系
 empty_dict = {}
 # �始化的字典
 filled_dict = {"one": 1, "two": 2, "three": 3}
 
+# 字典的 key 必须为���类型。 这是为了确� key 被转�为唯一的哈希值以用于快速查询
+# ���类型包括整数�浮点�字符串�元组
+invalid_dict = {[1,2,3]: "123"}  # => 抛出 TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}   # 然而 value �以是任何类型
+
 # 用[]�值
 filled_dict["one"]   # => 1
 
-
 # 用 keys 获得所有的键。
-# 因为 keys 返回一个�迭代对象，所以在这里把结果包在 list 里。我们下�会详细介��迭代。
-# 注�：字典键的顺�是�定的，你得到的结果�能和以下��。
-list(filled_dict.keys())   # => ["three", "two", "one"]
+# 因为 keys 返回一个�迭代对象，所以我们需�把它包在 "list()" 里�能转�为列表。
+# 我们下�会详细介��迭代。
+# 注�: 对于版本 < 3.7 的 python, 字典的 key 的排�是无�的。你的�行结果
+# �能与下�的例��符，但是在 3.7 版本，字典中的项会按照他们被�入到字典的顺�进行排�
+list(filled_dict.keys())  # => ["three", "two", "one"] Python 版本 <3.7
+list(filled_dict.keys())  # => ["one", "two", "three"] Python 版本 3.7+
 
+# 用 "values()" 获得所有的值。跟 keys 一样也是�迭代对象，�使用 "list()" �能转�为列表。
+# 注�: 排�顺�和 keys 的情况相�。
 
-# 用values获得所有的值。跟keys一样，�用list包起�，顺�也�能��。
-list(filled_dict.values())   # => [3, 2, 1]
+list(filled_dict.values())  # => [3, 2, 1] Python 版本 < 3.7
+list(filled_dict.values())  # => [1, 2, 3] Python 版本 3.7+
 
 
 # 用in测试一个字典是�包�一个键
 "one" in filled_dict   # => True
 1 in filled_dict   # => False
 
-# 访问�存在的键会导致KeyError
+# 访问�存在的键会导致 KeyError
 filled_dict["four"]   # KeyError
 
-# 用get���KeyError
-filled_dict.get("one")   # => 1
-filled_dict.get("four")   # => None
-# 当键�存在的时候get方法�以返回默认值
+# 用 "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
+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
+# "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  # �一�赋值方法
+filled_dict["four"] = 4        # �一�赋值方法
 
-# 用del删除
-del filled_dict["one"]  # 从filled_dict中把one删除
+# 用 del 删除项
+del filled_dict["one"]  # 从 filled_dict 中把 one 删除
 
 
-# 用set表达集�
+# 用 set 表达集�
 empty_set = set()
 # �始化一个集�，语法跟字典相似。
-some_set = {1, 1, 2, 2, 3, 4}   # some_set现在是{1, 2, 3, 4}
+some_set = {1, 1, 2, 2, 3, 4}   # some_set现在是 {1, 2, 3, 4}
+
+# 类似字典的 keys，set 的元素也必须是���类型
+invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
 
 # �以把集�赋值于��
 filled_set = some_set
 
 # 为集�添加元素
-filled_set.add(5)   # filled_set现在是{1, 2, 3, 4, 5}
+filled_set.add(5)   # filled_set 现在是 {1, 2, 3, 4, 5}
+# 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
 
+# �层集�的深度�制
+filled_set = some_set.copy()  # filled_set 是 {1, 2, 3, 4, 5}
+filled_set is some_set        # => False
 
 ####################################################
 ## 3. �程控制和迭代器
@@ -303,28 +403,30 @@ filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
 # 先�便定义一个��
 some_var = 5
 
-# 这是个if语�。注�缩进在Python里是有�义的
-# �出"some_var比10�"
+# 这是个if语�。注�缩进在Python里是有�义的�
+# 缩进�使用 4 个空格而�是 tabs。
+# 这段代�会打� "some_var is smaller than 10"
 if some_var > 10:
-    print("some_var比10大")
-elif some_var < 10:    # elif�是�选的
-    print("some_var比10�")
-else:                  # else也是�选的
-    print("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循环语��历列表
+用 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(number)"返回数字列表从0到给的数字
+"range(number)" 返回数字列表从 0 到 number 的数字
 打�:
     0
     1
@@ -333,9 +435,41 @@ for animal in ["dog", "cat", "mouse"]:
 """
 for i in range(4):
     print(i)
+    
+"""
+"range(lower, upper)" 会返回一个包�从 lower 到 upper 的数字迭代器
+prints:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
 
 """
-while循环直到�件�满足
+"range(lower, upper, step)" 会返回一个，从 lower 到 upper�并且间隔值为 step 的迭代器。
+如果 step 未传入则会使用默认值 1
+prints:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+
+"""
+�历列表，并且�时返回列表里的�一个元素的索引和数值。
+prints:
+    0 dog
+    1 cat
+    2 mouse
+"""
+animals = ["dog", "cat", "mouse"]
+for i, value in enumerate(animals):
+    print(i, value)
+
+"""
+while 循环直到�件�满足
 打�:
     0
     1
@@ -347,20 +481,51 @@ while x < 4:
     print(x)
     x += 1  # x = x + 1 的简写
 
-# 用try/except�处�异常状况
+
+# 用 try/except �处�异常状况
 try:
-    # 用raise抛出异常
+    # 用 raise 抛出异常
     raise IndexError("This is an index error")
 except IndexError as e:
-    pass    # pass是无�作，但是应该在这里处�错误
+    pass    						 # pass 是无�作，但是应该在这里处�错误
 except (TypeError, NameError):
-    pass    # �以�时处���类的错误
-else:   # else语�是�选的，必须在所有的except之�
+    pass    						 # �以�时处���类的错误
+else:                    # else语�是�选的，必须在所有的except之�
     print("All good!")   # �有当try�行完没有错误的时候这��会�行
+finally:								 # 在任何情况下都会执行
+ 		print("We can clean up resources here")
+
+# 你�以使用 with 语��代替 try/finally 对�作进行结�的�作
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+        
+# 写入文件
+contents = {"aa": 12, "bb": 21}
+with open("myfile1.txt", "w+") as file:
+    file.write(str(contents))        # 写入字符串到文件
+
+with open("myfile2.txt", "w+") as file:
+    file.write(json.dumps(contents)) # 写入对象到文件
+
+# Reading from a file
+with open("myfile1.txt", "r+") as file:
+    contents = file.read()           # 从文件读�字符串
+print(contents)
+# print: {"aa": 12, "bb": 21}
+
+with open("myfile2.txt", "r+") as file:
+    contents = json.load(file)       # 从文件读� json 对象
+print(contents)
+# print: {"aa": 12, "bb": 21}
+
+# Windows 环境调用 open() 读�文件的默认编�为 ANSI，如果需�读� utf-8 编�的文件，
+# 需�指定 encoding �数:
+# open("myfile3.txt", "r+", encoding = "utf-8")
 
 
-# Python�供一个���迭代(iterable)的基本抽象。一个�迭代对象是�以被当作�列
-# 的对象。比如说上�range返回的对象就是�迭代的。
+# Python �供一个���迭代 (iterable) 的基本抽象。一个�迭代对象是�以被当作�列
+# 的对象。比如说上� range 返回的对象就是�迭代的。
 
 filled_dict = {"one": 1, "two": 2, "three": 3}
 our_iterable = filled_dict.keys()
@@ -377,19 +542,24 @@ our_iterable[1]  # 抛出TypeError
 our_iterator = iter(our_iterable)
 
 # 迭代器是一个�以记��历的�置的对象
-# 用__next__�以�得下一个元素
-our_iterator.__next__()  # => "one"
+# 用 "next()" 获得下一个对象
+next(our_iterator)  # => "one"
 
-# �一次调�__next__时会记得�置
-our_iterator.__next__()  # => "two"
-our_iterator.__next__()  # => "three"
+# �一次调� "next()" 时会记得�置
+next(our_iterator)  # => "two"
+next(our_iterator)  # => "three"
 
-# 当迭代器所有元素都�出�，会抛出StopIteration
-our_iterator.__next__() # 抛出StopIteration
+# 当迭代器所有元素都�出�，会抛出 StopIteration
+next(our_iterator) # 抛出 StopIteration
 
-# �以用list一次�出迭代器所有的元素
-list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+# 我们还�以通过�历访问所有的值，实际上，for 内部实现了迭代
+our_iterator = iter(our_iterable)
+for i in our_iterator:
+    print(i)  # �次打� one, two, three
 
+# �以用 list 一次�出迭代器或者�迭代对象所有的元素
+list(filled_dict.keys())  # => 返回 ["one", "two", "three"]
+list(our_iterator)  # => 返回 [] 因为迭代的�置被�存了
 
 
 ####################################################
@@ -399,10 +569,10 @@ list(filled_dict.keys())  # => Returns ["one", "two", "three"]
 # 用def定义新函数
 def add(x, y):
     print("x is {} and y is {}".format(x, y))
-    return x + y    # 用return语�返回
+    return x + y    # 用 return 语�返回
 
 # 调用函数
-add(5, 6)   # => �出"x is 5 and y is 6"并且返回11
+add(5, 6)   # => 打� "x is 5 and y is 6" 并且返回 11
 
 # 也�以用关键字�数�调用函数
 add(y=6, x=5)   # 关键字�数�以用任何顺�
@@ -433,33 +603,43 @@ all_the_args(1, 2, a=3, b=4) prints:
     {"a": 3, "b": 4}
 """
 
-# 调用���数函数时�以�跟上�相�的，用*展开�列，用**展开字典。
+# 调用���数函数时�以�跟上�相�的，用 * 展开元组，用 ** 展开字典。
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
 all_the_args(*args)   # 相当于 all_the_args(1, 2, 3, 4)
 all_the_args(**kwargs)   # 相当于 all_the_args(a=3, b=4)
 all_the_args(*args, **kwargs)   # 相当于 all_the_args(1, 2, 3, 4, a=3, b=4)
 
+# 使用返回多个数值（返回值为元组类型）
+def swap(x, y):
+    return y, x  # 用�带括�的元组的格��返回多个数值
+                 # (注�: 括��需�加，但是也�以加)
+
+x = 1
+y = 2
+x, y = swap(x, y)     # => x = 2, y = 1
+# (x, y) = swap(x,y)  # �上，括��需�加，但是也�以加
 
+    
 # 函数作用域
 x = 5
 
 def setX(num):
-    # 局部作用域的x和全局域的x是��的
+    # 局部作用域的 x 和全局域的 x 是��的
     x = num # => 43
     print (x) # => 43
 
 def setGlobalX(num):
     global x
     print (x) # => 5
-    x = num # 现在全局域的x被赋值
+    x = num   # 现在全局域的 x 被赋值
     print (x) # => 6
 
 setX(43)
 setGlobalX(6)
 
 
-# 函数在Python是一等公民
+# 函数在 Python 是一等公民
 def create_adder(x):
     def adder(y):
         return x + y
@@ -469,39 +649,90 @@ add_10 = create_adder(10)
 add_10(3)   # => 13
 
 # 也有匿�函数
-(lambda x: x > 2)(3)   # => True
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
 
 # 内置的高阶函数
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+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]
 
 # 用列表推导��以简化映射和过滤。列表推导�的返回值是�一个列表。
 [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 '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. ç±»
+## 5. 模�
 ####################################################
 
+# 导入模�
+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
+
+# 你�以导入模�中的所有的函数
+# 警告: 此�作�推�
+from math import *
+
+# 你�以对模��进行简化
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# Python 模�实质上是 Python 文件
+# 你�以自己编写自己的模�，然�导入
+# 模�的�称和文件�相�
+
+# 你�以用 "dir()" 查看模�中定义的函数和字段
+import math
+dir(math)
+
+# 当你的脚本文件所在的文件夹也包�了一个�为 math.py 的 Python 文件
+# 这个 math.py 文件会被代替引入，而�是引入 Python 內建模�中的 math
+# 出现这个情况的原因是本地文件夹的引入优先级�比 Python 內建库引入优先级�高
+
+
+####################################################
+## 6. ç±»
+####################################################
 
-# 定义一个继承object的类
-class Human(object):
+# 我们使用 "class" 语��创建类
+class Human:
 
-    # 类属性，被所有此类的实例共用。
+    # 一个类的字段。 这个字段共享给这个类的所有实例。
     species = "H. sapiens"
 
-    # 构造方法，当实例被�始化时被调用。注��字��的�下划线，这是表明这个属
-    # 性或方法对Python有特殊�义，但是�许用户自行定义。你自己��时�应该用这
-    # �格�。
+    # 构造方法，当实例被�始化时被调用。注��字��的�下划线，这是表明这个属性
+    # 或方法对 Python 有特殊�义，但是�许用户自行定义。
+    # 方法(�能是对象或者属性) 类似: __init__, __str__,__repr__ etc
+    # 都是特殊的方法
+    # 你自己��时�应该用这�格�
     def __init__(self, name):
-        # Assign the argument to the instance's name attribute
+        # 将�数赋值给实例的 name 字段
         self.name = name
 
-    # 实例方法，第一个�数总是self，就是这个实例对象
+        # �始化属性
+        self._age = 0
+
+    # 实例方法，第一个�数总是self，也就是这个实例对象
     def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=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
@@ -511,53 +742,225 @@ class Human(object):
     def grunt():
         return "*grunt*"
 
+    # property 有点类似 getter
+    # 它把方法 age() 转�为��并且�读的属性
+    # 通常情况下，�以�需�编写��的 getter 和 setter。
+    @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 实例
+
+    # �行类方法 (classmethod)
+    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"
+
+    # �行��方法 (staticmethod)
+    print(Human.grunt())            # => "*grunt*"
+
+    # 实例上也�以执行��方法
+    print(i.grunt())                # => "*grunt*"
+
+    # 更新实例的属性
+    i.age = 42
+    # 访问实例的属性
+    i.say(i.age)                    # => "Ian: 42"
+    j.say(j.age)                    # => "Joel: 0"
+    # 删除实例的属性
+    del i.age
+    # i.age                         # => 这会抛出一个错误: AttributeError
+
+
+####################################################
+## 6.1 类的继承
+####################################################
+
+# 继承机制�许�类�以继承父类上的方法和��。
+# 我们�以把 Human 类作为一个基础类或者说��父类，
+# 然�定义一个�为 Superhero 的�类�继承父类上的比如 "species"� "name"� "age" 的属性
+# 和比如 "sing" �"grunt" 这样的方法，�时，也�以定义它自己独有的属性
+
+# 基于 Python 文件模�化的特点，你�以把这个类放在独立的文件中，比如说，human.py。
+
+# �从别的文件导入函数，需�使用以下的语�
+# from "filename-without-extension" import "function-or-class"
+
+from human import Human
+
+# 指定父类作为类�始化的�数
+class Superhero(Human):
+		
+    # 如果�类需�继承所有父类的定义，并且�需��任何的修改，
+    # 你�以直接使用 "pass" 关键字（并且�需�其他任何语�）
+    # 但是在这个例�中会被注释掉，以用�生��一样的�类。
+    # pass
+
+    # �类�以�写父类定义的字段
+    species = 'Superhuman'
+		
+    # �类会自动的继承父类的构造函数包括它的�数，但�时，�类也�以新增�外的�数或者定义，
+    # 甚至去覆盖父类的方法比如说构造函数。
+    # 这个构造函数从父类 "Human" 上继承了 "name" �数，�时�新增了 "superpower" 和
+    # "movie" �数:
+    def __init__(self, name, movie=False,
+                 superpowers=["super strength", "bulletproofing"]):
+
+        # 新增�外类的�数
+        self.fictional = True
+        self.movie = movie
+        # 注���的默认值，因为默认值是共享的
+        self.superpowers = superpowers
+				
+        # "super" 函数让你�以访问父类中被�类�写的方法
+        # 在这个例�中，被�写的是 __init__ 方法
+        # 这个语�是用��行父类的构造函数:
+        super().__init__(name)
+
+    # �写父类中的 sing 方法
+    def sing(self):
+        return 'Dun, dun, DUN!'
+
+    # 新增一个�外的方法
+    def boast(self):
+        for power in self.superpowers:
+            print("I wield the power of {pow}!".format(pow=power))
+
+
+if __name__ == '__main__':
+    sup = Superhero(name="Tick")
+
+    # 检查实例类型
+    if isinstance(sup, Human):
+        print('I am human')
+    if type(sup) is Superhero:
+        print('I am a superhero')
 
-# 构造一个实例
-i = Human(name="Ian")
-print(i.say("hi"))     # �出 "Ian: hi"
+    # 获�方法解�顺� MRO，MRO 被用于 getattr() 和 super()
+    # 这个字段是动�的，并且�以被修改
+    print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
+                                # => <class 'human.Human'>, <class 'object'>)
 
-j = Human("Joel")
-print(j.say("hello"))  # �出 "Joel: hello"
+    # 调用父类的方法并且使用�类的属性
+    print(sup.get_species())    # => Superhuman
 
-# 调用一个类方法
-i.get_species()   # => "H. sapiens"
+    # 调用被�写的方法
+    print(sup.sing())           # => Dun, dun, DUN!
 
-# 改一个共用的类属性
-Human.species = "H. neanderthalensis"
-i.get_species()   # => "H. neanderthalensis"
-j.get_species()   # => "H. neanderthalensis"
+    # 调用 Human 的方法
+    sup.say('Spoon')            # => Tick: Spoon
 
-# 调用��方法
-Human.grunt()   # => "*grunt*"
+    # 调用 Superhero 独有的方法
+    sup.boast()                 # => I wield the power of super strength!
+                                # => I wield the power of bulletproofing!
+
+    # 继承类的字段
+    sup.age = 31
+    print(sup.age)              # => 31
+
+    # Superhero 独有的字段
+    print('Am I Oscar eligible? ' + str(sup.movie))
 
 
 ####################################################
-## 6. 模�
+## 6.2 多�继承
 ####################################################
 
-# 用import导入模�
-import math
-print(math.sqrt(16))  # => 4.0
+# 定义�一个类
+# bat.py
+class Bat:
 
-# 也�以从模�中导入个别值
-from math import ceil, floor
-print(ceil(3.7))  # => 4.0
-print(floor(3.7))   # => 3.0
+    species = 'Baty'
 
-# �以导入一个模�中所有值
-# 警告：�建议这么�
-from math import *
+    def __init__(self, can_fly=True):
+        self.fly = can_fly
 
-# 如此缩写模��字
-import math as m
-math.sqrt(16) == m.sqrt(16)   # => True
+    # 这个类�样有 say 的方法
+    def say(self, msg):
+        msg = '... ... ...'
+        return msg
 
-# Python模�其实就是普通的Python文件。你�以自己写，然�导入，
-# 模�的�字就是文件的�字。
+    # 新增一个独有的方法
+    def sonar(self):
+        return '))) ... ((('
 
-# 你�以这样列出一个模�里所有的值
-import math
-dir(math)
+if __name__ == '__main__':
+    b = Bat()
+    print(b.say('hello'))
+    print(b.fly)
+
+# 现在我们�定义一个类��时继承 Superhero 和 Bat
+# superhero.py
+from superhero import Superhero
+from bat import Bat
+
+# 定义 Batman 作为�类，��时继承 SuperHero 和 Bat
+class Batman(Superhero, Bat):
+
+    def __init__(self, *args, **kwargs):
+        # 通常�继承属性，你必须调用 super:
+        # super(Batman, self).__init__(*args, **kwargs)
+        # 然而在这里我们处�的是多�继承，而 super() �会返回 MRO 列表的下一个基础类。
+        # 因此，我们需�显�调用�始类的 __init__
+        # *args 和 **kwargs 传递�数时更加清晰整�，而对于父类而言�是 “剥了一层洋葱�
+        Superhero.__init__(self, 'anonymous', movie=True,
+                           superpowers=['Wealthy'], *args, **kwargs)
+        Bat.__init__(self, *args, can_fly=False, **kwargs)
+        # �写了 name 字段
+        self.name = 'Sad Affleck'
+
+    def sing(self):
+        return 'nan nan nan nan nan batman!'
+
+
+if __name__ == '__main__':
+    sup = Batman()
+
+    # 获�方法解�顺� MRO，MRO 被用于 getattr() 和 super()
+    # 这个字段是动�的，并且�以被修改
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>,
+                                # => <class 'superhero.Superhero'>,
+                                # => <class 'human.Human'>,
+                                # => <class 'bat.Bat'>, <class 'object'>)
+
+    # 调用父类的方法并且使用�类的属性
+    print(sup.get_species())    # => Superhuman
+
+    # 调用被�写的类
+    print(sup.sing())           # => nan nan nan nan nan batman!
+
+    # 调用 Human 上的方法，(之所以是 Human 而�是 Bat)，是因为继承顺�起了作用
+    sup.say('I agree')          # => Sad Affleck: I agree
+
+    # 调用仅存在于第二个继承的父类的方法
+    print(sup.sonar())          # => ))) ... (((
+
+    # 继承类的属性
+    sup.age = 100
+    print(sup.age)              # => 100
+
+    # 从第二个类上继承字段，并且其默认值被�写
+    print('Can I fly? ' + str(sup.fly)) # => Can I fly? False
 
 
 ####################################################
@@ -582,6 +985,10 @@ for i in double_numbers(range_):
     print(i)
     if i >= 30:
         break
+# 你也�以把一个生�器推导直接转�为列表
+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)
@@ -611,18 +1018,27 @@ print(say())  # Can you buy me a beer?
 print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
 ```
 
-## 想继续学�？
 
-### 线上�费�料（英文）
 
-* [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/)
-* [Python Module of the Week](http://pymotw.com/3/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+### 在线�费�料（英文）
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com/)
+* [The Official Docs](https://docs.python.org/3/)
+* [Hitchhiker’s Guide to Python](https://docs.python-guide.org/en/latest/)
+* [Python Course](https://www.python-course.eu/)
+* [Free Interactive Python Course](http://www.kikodo.io/)
+* [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](https://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](https://cscircles.cemc.uwaterloo.ca/)
+* [Dive Into Python 3](https://www.diveintopython3.net/index.html)
+* [A Crash Course in Python for Scientists](https://nbviewer.jupyter.org/gist/anonymous/5924718)
+* [Python Tutorial for Intermediates](https://pythonbasics.org/)
+* [Build a Desktop App with Python](https://pythonpyqt.com/)
 
 ### 书�（也是英文）
 
diff --git a/zh-cn/qt-cn.html.markdown b/zh-cn/qt-cn.html.markdown
index 8681c85b..1d24f200 100644
--- a/zh-cn/qt-cn.html.markdown
+++ b/zh-cn/qt-cn.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: Qt Framework
-language: c++
+language: C++
 filename: learnqt-cn.cpp
 contributors:
     - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
diff --git a/zh-cn/raylib-cn.html.markdown b/zh-cn/raylib-cn.html.markdown
new file mode 100644
index 00000000..c88aa91e
--- /dev/null
+++ b/zh-cn/raylib-cn.html.markdown
@@ -0,0 +1,147 @@
+---
+category: tool
+tool: raylib
+lang: zh-cn
+filename: learnraylib-cn.c
+contributors:
+    - ["Nikolas Wipper", "https://notnik.cc"]
+translators:
+    - ["lzw-723", "https://github.com/lzw-723"]
+---
+
+**raylib** 是一个跨平��易用的图形库，围绕OpenGL 1.1�2.1�3.3和OpenGL ES 2.0构建。
+虽然它是用C语言编写的，�有超过50���语言的绑定。本教程将使用C语言。
+更确切地说，是C99。
+
+```c
+#include <raylib.h>
+
+int main(void)
+{
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    // 在�始化raylib之�，�以设置标志�
+    SetConfigFlags(FLAG_MSAA_4X_HINT | FLAG_VSYNC_HINT);
+
+    // raylib并��求我们存储任何实例结构
+    // 目�raylib一次�能处�一个窗�
+    InitWindow(screenWidth, screenHeight, "MyWindow");
+
+    // 设置我们的游�以�秒60帧的速度�行
+    SetTargetFPS(60);
+
+    // 设置一个关闭窗�的键。
+    //�以是0，表示没有键
+    SetExitKey(KEY_DELETE);
+
+    // raylib定义了两�类型的相机。Camera3D和Camera2D
+    // Camera是Camera3D的一个类型化定义
+    Camera camera = {
+            .position = {0.0f, 0.0f, 0.0f},
+            .target   = {0.0f, 0.0f, 1.0f},
+            .up       = {0.0f, 1.0f, 0.0f},
+            .fovy     = 70.0f,
+            .type     = CAMERA_PERSPECTIVE
+    };
+
+
+    // raylib支�加载����的文件格�的模型�动画�图�和声音。
+    Model myModel = LoadModel("my_model.obj");
+    Font someFont = LoadFont("some_font.ttf");
+
+    // 创建一个100x100的渲染纹�
+    RenderTexture renderTexture = LoadRenderTexture(100, 100);
+
+    // WindowShouldClose方法检查用户是�正在关闭窗�。
+    // �能用的是快�方��窗�控制或之�设置的关闭窗�键
+    while (!WindowShouldClose())
+    {
+
+        // BeginDrawing方法�在任何绘图�作之�被调用。
+        BeginDrawing();
+        {
+
+            // 为背景设定��颜色
+            ClearBackground(BLACK);
+
+            if (IsKeyDown(KEY_SPACE))
+                DrawCircle(400, 400, 30, GREEN);
+
+            // 简�地绘制文本
+            DrawText("Congrats! You created your first window!",
+                     190, // x
+                     200, // y
+                     20,  // 字体大�
+                     LIGHTGRAY
+            );
+
+            // 大多数函数都有几个版本
+            // 通常�缀为Ex, Pro, V
+            // 或者是Rec�Wires（仅适用于3D）�Lines（仅适用于2D）。
+            DrawTextEx(someFont,
+                       "Text in another font",
+                       (Vector2) {10, 10},
+                       20, // 字体大�
+                       2,  // é—´è·�
+                       LIGHTGRAY);
+
+            // 绘制3D时需�，有2D的等价方法
+            BeginMode3D(camera);
+            {
+
+                DrawCube((Vector3) {0.0f, 0.0f, 3.0f},
+                         1.0f, 1.0f, 1.0f, RED);
+
+                // 绘图时的白色色调将��原�的颜色
+                DrawModel(myModel, (Vector3) {0.0f, 0.0f, 3.0f},
+                          1.0f, // 缩放
+                          WHITE);
+
+            }
+            // 结�3D模�，这样就�以�次普通绘图
+            EndMode3D();
+
+            // 开始在渲染纹�上绘图
+            BeginTextureMode(renderTexture);
+            {
+
+                // 它的行为与刚�调用的`BeginDrawing()`方法相�
+
+                ClearBackground(RAYWHITE);
+
+                BeginMode3D(camera);
+                {
+
+                    DrawGrid(10, // Slices
+                             1.0f // é—´è·�
+                    );
+
+                }
+                EndMode3D();
+
+            }
+            EndTextureMode();
+
+            // 渲染有Texture2D字段的纹�
+            DrawTexture(renderTexture.texture, 40, 378, BLUE);
+
+        }
+        EndDrawing();
+    }
+
+    // �载已载入的对象
+    UnloadFont(someFont);
+    UnloadModel(myModel);
+
+    // 关闭窗�和OpenGL上下文
+    CloseWindow();
+
+    return 0;
+}
+
+```
+
+## 延伸阅读
+raylib有一些[�错的例�](https://www.raylib.com/examples.html)
+如果你�喜欢C语言你也�以看看[raylib的其他语言绑定](https://github.com/raysan5/raylib/blob/master/BINDINGS.md)
diff --git a/zh-cn/red-cn.html.markdown b/zh-cn/red-cn.html.markdown
index 85812990..7fee007e 100644
--- a/zh-cn/red-cn.html.markdown
+++ b/zh-cn/red-cn.html.markdown
@@ -150,11 +150,11 @@ msg: either a > 0 [
 ]
 print ["a 是 " msg lf]
 
-; util
+; until
 ; 循环执行一段代��，直到满足给定的�件为止。
-; util 没有返回值，所以它�能用在表示�中。
+; UNTIL 在最�一次循环执行完最�一个表达��，总是返回真值 'true'。
 c: 5
-util [
+until [
     prin "o"
     c: c - 1
     c = 0    ; 终止循环的�件
@@ -193,15 +193,15 @@ print twice b      ; 输出 6
 
 ## 更进一步
 
-Red 相关的��信�在 [Red 语言主页](http://www.red-lang.org)。
+Red 相关的��信�在 [Red 语言主页](https://www.red-lang.org)。
 
 �代�的 [github 库](https://github.com/red/red)。
 
-Red/System 特性在 [这里](http://static.red-lang.org/red-system-specs-light.html)。
+Red/System 特性在 [这里](https://static.red-lang.org/red-system-specs-light.html)。
 
 想�了解更多关于 Rebol 和 Red 的信�，加入 [Gitter �天室](https://gitter.im/red/red)。如果你无法加入，也�以给我们�[邮件](mailto:red-langNO_SPAM@googlegroups.com)。
 
-也�以在 [Stack Overflow](stackoverflow.com/questions/tagged/red) 上查阅��交问题。
+也�以在 [Stack Overflow](https://stackoverflow.com/questions/tagged/red) 上查阅��交问题。
 
 也许你现在就�试一试 Red ？�以在线�试 [try Rebol and Red site](http://tryrebol.esperconsultancy.nl)。
 
diff --git a/zh-cn/ruby-cn.html.markdown b/zh-cn/ruby-cn.html.markdown
index 9918c022..b0b8b58c 100644
--- a/zh-cn/ruby-cn.html.markdown
+++ b/zh-cn/ruby-cn.html.markdown
@@ -430,7 +430,7 @@ def guests(*array)
   array.each { |guest| puts guest }
 end
 
-# 结构
+# 解构
 
 # 如果函数返回一个数组，在赋值时�以进行拆分：
 def foods
@@ -449,7 +449,7 @@ end
 
 best *ranked_competitors.first(3) #=> Winners are John, Sally, and Dingus.
 
-# 结构�作符也�放在�数里�
+# 解构�作符也�放在�数里�
 def best(first, second, third, *others)
   puts "Winners are #{first}, #{second}, and #{third}."
   puts "There were #{others.count} other participants."
@@ -657,4 +657,4 @@ Something.new.qux # => 'qux'
 - [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.
+- [Try Ruby](https://try.ruby-lang.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 5d3fc693..6bed1650 100644
--- a/zh-cn/rust-cn.html.markdown
+++ b/zh-cn/rust-cn.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["P1start", "http://p1start.github.io/"]
 translators:
@@ -211,7 +211,7 @@ fn main() {
 
     // `for` 循环
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/zh-cn/set-theory-cn.html.markdown b/zh-cn/set-theory-cn.html.markdown
new file mode 100644
index 00000000..13ba2c80
--- /dev/null
+++ b/zh-cn/set-theory-cn.html.markdown
@@ -0,0 +1,138 @@
+---
+category: Algorithms & Data Structures
+name: Set theory
+contributors:
+translators:
+    - ["Tianchen Xu", "https://github.com/lo0b0o"]
+lang: zh-cn
+---
+集�论是数学的一个分支，研究集��它们的�算和它们的性质。
+
+* 集�由���的项组�。
+
+## 基本符�
+
+### �算符
+* 并�算符，`∪`，表示“或�；
+* 交�算符，`∩`，表示“且�；
+* 差�算符，`\`，表示“�包括�；
+* 补�算符，`'`，表示补集;
+* �积�算符，`×`，表示笛�尔积。
+
+### �定�
+* 冒��定�，`:`，表示“使得�；
+* 从属�定�，`∈`，表示“属于�；
+* �集�定�，`⊆`，表示“是……的�集�;
+* 真�集�定�，`⊂`，表示“是……的真�集�。
+
+###  ��的集�
+* `∅`，空集，��包�任何元素的集�；
+* `ℕ`，自然数集；
+* `ℤ`，整数集；
+* `ℚ`，有�数集；
+* `�`，实数集。
+
+关于以上集�，有如下几点需�注�：
+1. 空集是其本身的�集（并且也是任何其他集�的�集），�便空集�包�任何项；
+2. 数学家们对于零是�为自然数的看法通常并�统一，教科书一般会明确说明作者是�认为零是自然数。
+
+### 基数
+
+集�的基数，或者说大�，由该集�中的项目数�决定。基数�算符为 `|...|`。
+
+例如，若 `S = { 1, 2, 4 }`，则 `|S| = 3`。
+
+### 空集
+  
+* �以在集�符�中使用��立的�件�构造空集，例如，`∅ = { x : x ≠ x }`，或 `∅ = { x : x ∈ N, x < 0 }`；
+* 空集总是唯一的（�，有且�有一个空集）；
+* 空集是所有集�的�集；
+* 空集的基数为 0，� `|∅| = 0`。
+
+## 集�的表示
+
+### 集�的�项构造
+
+集��以通过包�其全部项的列表�项生�。例如，`S = { a, b, c, d }`。
+
+��构�集�的项清楚，长列表�以用�略�缩短。例如，`E = { 2, 4, 6, 8, ... }` 显然为所有�数构�的集�，它包�无穷多项，虽然我们�显�写出了其中四项。
+
+### 集�构造器
+
+集�构造器符�是构造集�的一�更具�述性的方�。它�赖于一个主语和一个谓�，使得 `S = { 主语 : 谓� }`。 例如，
+
+```
+A = { x : x 是元音字� } = { a, e, i, o, u, y}
+B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+有时，谓��能会 "� "到主语中，例如，
+
+```
+D = { 2x : x ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+## 关系
+
+### 从属关系
+
+* 如果值 `a` 包�在集� `A` 中，那么我们说 `a` 属于 `A`，并用符�表示为 `a ∈ A`。
+* 如果值 `a` �包�于集� `A` 中，那么我们说 `a` �属于 `A`，并用符�表示为 `a ∉ A`。
+
+### 相等关系
+
+* 如果两个集�包括相�的项，那么我们说这两个集�相等，例如，`A = B`。
+* 集�的相等关系于顺�无关，例如 `{ 1, 2, 3, 4 } = { 2, 3, 1, 4 }`。
+* 集�中的元素�能��，例如 `{ 1, 2, 2, 3, 4, 3, 4, 2 } = { 1, 2, 3, 4 }`。
+* 集� `A` 与 `B` 相等当且仅当 `A ⊆ B` 且 `B ⊆ A`。
+
+## 特殊集�
+
+### 幂集
+
+* 令 `A` 为任�集�。幂集指的是包括了 `A` 的所有�集的集�，记作 `P(A)`。如果集� `A` 由 `2n` 个元素组�，那么 `P(A)` 中有 `2^n` 个元素。
+
+```
+P(A) = { x : x ⊆ A }
+```
+
+## 两个集�的�算
+### 并
+
+给定集� `A` 和 `B`，两个集�的并由出现在 `A` 或 `B` 中的项构�，记作 `A ∪ B`。
+
+```
+A ∪ B = { x : x ∈ A ∪ x ∈ B }
+```
+
+### 交
+
+给定集� `A` 和 `B`，两个集�的交由出现在 `A` 和 `B` 中的项构�，记作 `A ∩ B`。
+
+```
+A ∩ B = { x : x ∈ A, x ∈ B }
+```
+
+### å·®
+给定集� `A` 和 `B`，`A` 对于 `B` 的集�差指的是属于 `A` 但�属于 `B` 的�一项。
+
+```
+A \ B = { x : x ∈ A, x ∉ B }
+```
+
+### 对称差
+给定集� `A` 和 `B`，对称差指的是属于 `A` 或 `B` 但�属于它们交集的所有项。
+
+```
+A △ B = { x : ((x ∈ A) ∩ (x ∉ B)) ∪ ((x ∈ B) ∩ (x ∉ A)) }
+
+A △ B = (A \ B) ∪ (B \ A)
+```
+
+### 笛�尔积
+给定集� `A` 和 `B`，`A` 和 `B` 的笛�尔积由 `A` 和 `B` 的项的所有组�构�。
+
+```
+A × B = { (x, y) | x ∈ A, y ∈ B }
+```
diff --git a/zh-cn/solidity-cn.html.markdown b/zh-cn/solidity-cn.html.markdown
index ec684997..12a532bc 100644
--- a/zh-cn/solidity-cn.html.markdown
+++ b/zh-cn/solidity-cn.html.markdown
@@ -213,7 +213,7 @@ names.length; // 获得数组长度
 names.length = 1; // �以设定长度（仅针对 storage 中的动�数组）
 
 // 多维数组
-uint x[][5]; // 5个动�数组元素的数组(和多数语言的顺�相�)
+uint[][5] x; // 5个动�数组元素的数组(和多数语言的顺�相�)
 
 // 字典类型 (任一类型到其他类型的映射)
 mapping (string => uint) public balances;
diff --git a/zh-cn/sql.html.markdown b/zh-cn/sql-cn.html.markdown
index 9d430bd1..9d430bd1 100644
--- a/zh-cn/sql.html.markdown
+++ b/zh-cn/sql-cn.html.markdown
diff --git a/zh-cn/visualbasic-cn.html.markdown b/zh-cn/visualbasic-cn.html.markdown
index e30041b3..cda7b864 100644
--- a/zh-cn/visualbasic-cn.html.markdown
+++ b/zh-cn/visualbasic-cn.html.markdown
@@ -8,7 +8,7 @@ lang: zh-cn
 filename: learnvisualbasic-cn.vb
 ---
 
-```
+```visualbasic
 Module Module1
 
     Sub Main()
diff --git a/zh-cn/wolfram-cn.html.markdown b/zh-cn/wolfram-cn.html.markdown
new file mode 100644
index 00000000..64990234
--- /dev/null
+++ b/zh-cn/wolfram-cn.html.markdown
@@ -0,0 +1,140 @@
+---
+language: wolfram
+contributors:
+  - ["hyphz", "http://github.com/hyphz/"]
+translators:
+  - ["wuyudi", "http://github.com/wuyudi/"]
+filename: learnwolfram-cn.nb
+lang: zh-cn
+---
+
+Wolfram 语言是最�在 Mathematica 中使用的底层语言，但现在�用于多�场�。
+
+Wolfram 语言有几个界�。
+
+- Raspberry Pi 上的命令行内核界�（就� _The Wolfram Language_），它是交互��行的，�能产生图形输入。
+- _Mathematica_ 是一个丰富的文本/数学编辑器，内置交互�的 Wolfram: 在 "代��元 "上按 shift+Return 键�以创建一个输出�元，输出结果，这�是动�的。
+- _Wolfram Workbench_，这是 Eclipse 与 Wolfram 语言�端的界�。
+
+本例中的代��以在任何界�中输入，并使用 Wolfram Workbench 进行编辑。直接加载到 Mathematica 中�能会很�方便，因为该文件�包��元格格�化信�（这将使该文件作为文本阅读时�得一团糟）--它�以被查看/编辑，但�能需�一些设置。
+
+```mathematica
+(* 这是一个注释 *)
+
+(* 在Mathematica中，您�以创建一个文本�元格，用排版好的文本和图��注释您的代�，而�是使用这些注释 *)
+
+(* 输入一个表达�返回结果 *)
+2*2              (* 4 *)
+5+8              (* 13 *)
+
+(* 调用函数 *)
+(* 注�，函数�（和其他所有东西）是区分大�写的 *)
+Sin[Pi/2]        (* 1 *)
+
+(* 带有一个�数的函数调用的替代语法 *)
+Sin@(Pi/2)       (* 1 *)
+(Pi/2) // Sin    (* 1 *)
+
+(* WL 中的�一�语法都有一些等价的函数调用，�万物皆函数 *)
+Times[2, 2]      (* 4 *)
+Plus[5, 8]       (* 13 *)
+
+(* 第一次使用一个��定义它，并使其�为全局�� *)
+x = 5            (* 5 *)
+x == 5           (* 返回真，C-style 的赋值和相等测试 *)
+x                (* 5 *)
+x = x + 5        (* 10 *)
+x                (* 10 *)
+Set[x, 20]       (* 当我说万物皆函数时 我是认真的 *)
+x                (* 20 *)
+
+(* 因为WL是基于计算机代数系统的, *)
+(* �以使用未定义的��，它们�是阻�了计算 *)
+cow + 5          (* 5 + cow, cow 是未定义的，所以无法进一步计算 *)
+cow + 5 + 10     (* 15 + cow, 它将尽力计算 *)
+%                (* 15 + cow, % 获�最�一次返回的内容 *)
+% - cow          (* 15, 未定义的��cow被消去 *)
+moo = cow + 5    (* �心，moo 现在是一个表达�，�是一个数字! *)
+
+(* 定义一个函数 *)
+Double[x_] := x * 2    (*   注� := 防止对RHS进行�时计算。
+                            而 x ��的 _ 表示没有模�匹�的约��件*)
+Double[10]             (* 20 *)
+Double[Sin[Pi/2]]      (* 2 *)
+Double @ Sin @ (Pi/2)  (* 2, @-syntax ��了闭括�的队列 *)
+(Pi/2) // Sin // Double(* 2, //-syntax 按执行顺�列举了函数 *)
+
+(* 对于命令�编程，使用 ; �分隔语�。 *)
+(* 丢弃 LHS 的任何输出并�行 RHS *)
+MyFirst[] := (Print@"Hello"; Print@"World")  (* 请注�，外侧的�括�是关键
+                                                 ;的优先级低于:= *)
+MyFirst[]                                    (* 你好，世界 *)
+
+(* C-Style 的 For 循环，注：在 Mathematica 中使用 For 循环是低效的 *)
+PrintTo[x_] := For[y=0, y<x, y++, (Print[y])]  (* 开始，测试，自增，循环体 *)
+PrintTo[5]                                     (* 0 1 2 3 4 *)
+
+(* While 循环 *)
+x = 0; While[x < 2, (Print@x; x++)]     (* 带测试和程�体的 while 循环 *)
+
+(* If 和 �件 *)
+x = 8; If[x==8, Print@"Yes", Print@"No"]   (* Condition, true case, else case *)
+Switch[x, 2, Print@"Two", 8, Print@"Yes"]  (* 值匹�风格切� *)
+Which[x==2, Print@"No", x==8, Print@"Yes"] (* Elif风格切� *)
+
+(* 除�数外的��默认为全局��，�使在函数内部也是如此 *)
+y = 10             (* 10, 全局�� y *)
+PrintTo[5]         (* 0 1 2 3 4 *)
+y                  (* 5, 全局的 y 被 PrintTo 内的循环计数器所�用 *)
+x = 20             (* 20, 全局�� x *)
+PrintTo[5]         (* 0 1 2 3 4 *)
+x                  (* 20, PrintTo 中的 x 是一个�数，并自动局部化 *)
+
+(* 局部��使用 Module 元函数声明 *)
+(* 带本地��的版本 *)
+BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
+y = 20             (* 全局�� y *)
+BetterPrintTo[5]   (* 0 1 2 3 4 *)
+y                  (* 20, 那更好 *)
+
+(* 实际上，模��许我们声明任何我们喜欢的作用域 *)
+Module[{count}, count=0;        (* 声明这个��count的作用域 *)
+  (IncCount[] := ++count);      (* 这些函数都在该作用域内 *)
+  (DecCount[] := --count)]
+count              (* count - 全局�� count 未定义 *)
+IncCount[]         (* 1, 使用作用域内的counter�� *)
+IncCount[]         (* 2, incCount �级了它 *)
+DecCount[]         (* 1, decCount 也是 *)
+count              (* count - 这个�字�旧�是全局�� *)
+
+(* Lists *)
+myList = {1, 2, 3, 4}     (* {1, 2, 3, 4} *)
+myList[[1]]               (* 1 - 注�列表索引从 1 开始，而�是从 0 开始。 *)
+Map[Double, myList]       (* {2, 4, 6, 8} - 函数�列表的 map 函数 *)
+Double /@ myList          (* {2, 4, 6, 8} - 以上的缩略语法 *)
+Scan[Print, myList]       (* 1 2 3 4 - 命令�循环 *)
+Fold[Plus, 0, myList]     (* 10 (0+1+2+3+4) *)
+FoldList[Plus, 0, myList] (* {0, 1, 3, 6, 10} - 存值的 Fold *)
+Append[myList, 5]         (* {1, 2, 3, 4, 5} - 注� myList 没有更新 *)
+Prepend[myList, 5]        (* {5, 1, 2, 3, 4} - 如果想让 myList 更新，就加上 "myList = " *)
+Join[myList, {3, 4}]      (* {1, 2, 3, 4, 3, 4} *)
+myList[[2]] = 5          (* {1, 5, 3, 4} - 这确实更新了myList *)
+
+(* 关�，�称字典/哈希值 *)
+myHash = <|"Green" -> 2, "Red" -> 1|>   (* 创建一个关� *)
+myHash[["Green"]]                       (* 2, 使用 *)
+myHash[["Green"]] := 5                  (* 5, æ›´æ–° *)
+myHash[["Puce"]] := 3.5                 (* 3.5, 扩展 *)
+KeyDropFrom[myHash, "Green"]            (* 抹去绿色的键 *)
+Keys[myHash]                            (* {Red, Puce} *)
+Values[myHash]                          (* {1, 3.5} *)
+
+(* � Wolfram 的演示时 你�能�展示这个 *)
+Manipulate[y^2, {y, 0, 20}] (* 返回一个�应�的用户界�，显示y^2
+                               并�许通过滑�在 0-20 之间调整y。
+                               �适用于图形�端 *)
+```
+
+## 想多�点?
+
+- [Wolfram Language Documentation Center](http://reference.wolfram.com/language/)
diff --git a/zh-cn/zfs-cn.html.markdown b/zh-cn/zfs-cn.html.markdown
index fdf5277e..80688fbe 100644
--- a/zh-cn/zfs-cn.html.markdown
+++ b/zh-cn/zfs-cn.html.markdown
@@ -288,6 +288,7 @@ tank/home/sarlalian@now       0      -   259M  -
 tank/home/alice@now           0      -   156M  -
 tank/home/bob@now             0      -   156M  -
 ...
+```
 
 Destroy snapshots （删除快照）
 
@@ -297,7 +298,6 @@ $ zfs destroy tank/home/sarlalian@now
 
 # 删除�一数�集�其�集的快照
 $ zfs destroy -r tank/home/sarlalian@now
-
 ```
 
 Renaming Snapshots （�命�）
diff --git a/zh-tw/elixir-tw.html.markdown b/zh-tw/elixir-tw.html.markdown
index c15f90c1..3dba95b3 100644
--- a/zh-tw/elixir-tw.html.markdown
+++ b/zh-tw/elixir-tw.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -19,10 +19,10 @@ Elixir 是一門建構在 Erlang 虛擬機上的ç�¾ä»£å‡½æ•¸å¼�語言。它完å…
 # 沒有多行註解的功能
 # 但你�以連續使用多個單行
 
-# 用 `iex` 來進入 elixir shell
+# 用 `iex` 來進入 Elixir shell
 # 用 `elixirc` 來編譯你的模組
 
-# 如果你已�功安� elixir 的話，這兩個命令應已在你的 path 下。
+# 如果你已�功安� Elixir 的話，這兩個命令應已在你的 path 下。
 
 ## ---------------------------
 ## -- 基本型別
@@ -50,7 +50,7 @@ elem({1, 2, 3}, 0) #=> 1
 head #=> 1
 tail #=> [2,3]
 
-# 在 elixir 中，就如� Erlang 裡一樣，`=` 代表的是模�比�，而�指派。
+# 在 Elixir 中，就如� Erlang 裡一樣，`=` 代表的是模�比�，而�指派。
 #
 # 這代表將使用左手邊的模� (pattern) 去與�手邊的值進行比�。
 #
@@ -80,7 +80,7 @@ string.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` 在 elixir 中會回傳字� `a` 的 ASCII 整數
+# `?a` 在 Elixir 中會回傳字� `a` 的 ASCII 整數
 ?a #=> 97
 
 # 用 `++` 來�併串列，而�併二進�則�用 `<>`
@@ -105,7 +105,7 @@ lower..upper = 1..10 # �以� range 進行模�比�
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# 在 elixir 中， `/` �算元永�回傳浮點數。
+# 在 Elixir 中， `/` �算元永�回傳浮點數。
 
 # 若需�回傳整數的除法，用 `div`
 div(10, 2) #=> 5
@@ -290,7 +290,7 @@ Geometry.area({:circle, 3})       #=> 28.25999999999999801048
 # Geometry.area({:circle, "not_a_number"})
 #=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
 
-# 由於��變特性 (immutability)，�迴在 elixir 中扮演��的角色。
+# 由於��變特性 (immutability)，�迴在 Elixir 中扮演��的角色。
 defmodule Recursion do
   def sum_list([head | tail], acc) do
     sum_list(tail, acc + head)
@@ -356,7 +356,7 @@ end
 ## -- 平行處�
 ## ---------------------------
 
-# Elixir �� actor 模�來進行平行處�。在 elixir 中�寫出平行處�程�，
+# Elixir �� actor 模�來進行平行處�。在 Elixir 中�寫出平行處�程�，
 # �需�三個基本�素：建立行程，發�訊��接收訊�。
 
 # 我們用 `spawn` 函�來建立行程，它接收一個函�當�數。
diff --git a/zh-tw/perl-tw.html.markdown b/zh-tw/perl-tw.html.markdown
new file mode 100644
index 00000000..55876e2a
--- /dev/null
+++ b/zh-tw/perl-tw.html.markdown
@@ -0,0 +1,328 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl-tw.pl
+contributors:
+    - ["Korjavin Ivan", "http://github.com/korjavin"]
+    - ["Dan Book", "http://github.com/Grinnz"]
+translators:
+    - ["Kang-min Liu", "https://gugod.org"]
+    - ["Shih-Kai Chiu", "https://twitter.com/zard1989"]
+lang: zh-tw
+---
+
+Perl 5 是一款強大且功能�富的程�語言，已經�續發展超� 25 年。
+
+從大型主機到行動�置，Perl 5 能在上百種平�執行，��快速打造產�原型，也��大
+型專案開發。
+
+```perl
+# 註解列皆以井字號為開頭
+
+#### 嚴謹度
+
+use strict;
+use warnings;
+
+# 所有的 perl 程�檔案都應當包�此兩列程�碼。在如變數�稱有拼寫錯誤之時，
+# strict 能使編譯�程失敗。而�於�是將未定義值接到字串中等等易犯之錯誤，
+# warnings 則能�供�當的警告訊�。
+
+#### Perl 變數與其型別
+
+# 變數的開頭皆為一�記（sigil），是為一符號，用以標示其型別。
+# 變數�稱唯有以字�或底線開頭，後接字��數字�底線若干，方為有效。
+
+### 在 Perl 語言中，主�的變數型別有三種：$純��@陣列�%雜湊。
+
+## 純�
+#  一個純�變數，�能�一個值：
+my $animal = "camel";
+my $answer = 42;
+my $display = "You have $answer ${animal}s.\n";
+
+# 純�值�為字串�整數�浮點數。Perl 會自動地在需�之時進行轉�。
+
+# 以單引號括�的字串內容與其字�之值完全相�。而以雙引號括�的字串，
+# 其中則能內�變數與�是這種表示�列字符 "\n" 的控制碼。
+
+## 陣列
+# 一個陣列，�以�下很多值：
+my @animals = ("camel", "llama", "owl");
+my @numbers = (23, 42, 69);
+my @mixed   = ("camel", 42, 1.23);
+
+# 陣列元素的存�，需�角括號。�方的�記為 $ 符號，表示��一個值。
+my $second = $animals[1];
+
+# 欲知陣列之大�，在純�語境之下使用陣列便�。例如，將陣列�到一個純�變數中。
+# �或者是使用 "scalar" 算符。
+
+my $num_animals = @animals;
+print "Number of numbers: ", scalar(@numbers), "\n";
+
+# 陣列也能夠被安�在雙引號字串之內。�內容元素間隔，�設是一個空白字符。
+
+print "We have these numbers: @numbers\n";
+
+# 雙引號字串中，若有�電�郵件地�的部分，會被視為是在內��個陣列的內容物。
+# 請�加留�。
+
+my @example = ('secret', 'array');
+my $oops_email = "foo@example.com"; # 'foosecret array.com'
+my $ok_email = 'foo@example.com';
+
+## 雜湊
+# 一個雜湊，能�下許多�的�與值：
+
+my %fruit_color = ("apple", "red", "banana", "yellow");
+
+# 善用空白與 "=>" 算符，就能將其排得得好看一些：
+
+my %fruit_color = (
+  apple  => "red",
+  banana => "yellow",
+);
+
+# 雜湊元素的存�，需�大括號。�方的�記�為 $ 符號，表示��一個值。
+my $color = $fruit_color{apple};
+
+# 以 "keys" 與 "values" 兩個函數，則�一次�得雜湊中的所有��所有值。
+my @fruits = keys %fruit_color;
+my @colors = values %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 (condition) {
+  ...
+}
+# 這算是�讀性較好的 "if (!condition)"
+
+# 倒��型算是�「很 Perl 的�寫法
+print "Yow!" if $zippy;
+print "We have no bananas" unless $bananas;
+
+#  while
+while (condition) {
+  ...
+}
+
+my $max = 5;
+# 以 for 迴圈，$i 為迭代變數
+for my $i (0 .. $max) {
+  print "index is $i";
+}
+
+for my $element (@elements) {
+  print $element;
+}
+
+map {print} @elements;
+
+# 迭代變數為 $_
+for (@elements) {
+  print;
+}
+
+# �雜湊進行迭代（for 與 foreach 完全相�）
+
+foreach my $key (keys %hash) {
+  print $key, ': ', $hash{$key}, "\n";
+}
+
+# �是「很 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/;         # 將 $x 中第一個出�的 foo �為 bar
+$x =~ s/foo/bar/g;        # 將 $x 中所有出�的 foo �為 bar
+
+#### 檔案與輸出入
+
+# 以 "open" 函�開檔後，便�自檔案輸入或�其輸出
+
+# 讀檔：
+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: $!";
+
+# 使用 "<>" 算符，能�檔案代號進行讀�。在純�語境下，會自檔案代號讀一列內容。
+# 而在串列語境下，�讀入整個檔案。�一列都會�為串列中一項元素。
+
+my $line  = <$in>;
+my @lines = <$in>;
+
+# 以 "print" 函�，則��檔案代號進行輸出。
+
+print $out @lines;
+print $log $msg, "\n";
+
+#### 函�之撰寫
+
+# 撰寫函�很是容易：
+
+sub logger {
+  my $logmessage = shift;
+
+  open my $logfile, ">>", "my.log" or die "Could not open my.log: $!";
+
+  print $logfile $logmessage;
+}
+
+# 之後，使用起來就與內建函�無異：
+
+logger("We have a logger subroutine!");
+
+#### 模組
+
+# 所謂模組，就是一組 Perl 程�碼，由一些函�組�，並�讓其他 Perl 程�碼來利用。
+# 為了讓 perl 能找至，通常模組之副檔� .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 (https://www.cpan.org) 下載下來，���樣的機能讓你
+# 能�於�新發明輪�。�少高人氣模組，如 Exporter，則是與 Perl 一�釋出�散佈。
+# 更多關於 Perl 模組的細節，詳見 perlmod 文件。
+
+#### 物件
+
+# Perl 中的物件，�是個�照，但�時�知�自己屬於哪個類別（package），於是�自身
+# 調用方法（函�）時方知去何處尋找函�本體。在建構�（通常是 "new"）中，都是以
+# "bless" 函�來標記�照與其類別。���，若你使用� Moose 或 Moo 模組的話，這些
+# 都�必自己來（總之請繼續往下讀）。
+
+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
+
+# CPAN 上的 Moose 與 Moo 模組能助你撰寫類別本體。它們�供了建構�，與簡單易懂的
+# 語法能來宣告屬性。�述的類別改寫之後，如下：
+
+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 文件中有詳盡的說明。
+# 此外，perlobj 文件中更涵蓋了底層實�之細節。
+```
+
+#### 常見�答集
+
+perlfaq 是�與答，涵蓋許多常見�題和解法，常常�該用哪些 CPAN 模組有很好的建議。
+
+#### 延伸閱讀
+
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Learn Perl](https://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - 內建函� : `perldoc perlintro`
diff --git a/zig.html.markdown b/zig.html.markdown
new file mode 100644
index 00000000..65fd1e6b
--- /dev/null
+++ b/zig.html.markdown
@@ -0,0 +1,981 @@
+---
+language: zig
+filename: learnzig.zig
+contributors:
+    - ["Philippe Pittoli", "https://karchnu.fr/"]
+---
+
+[Zig][ziglang] aims to be a replacement for the C programming language.
+
+**WARNING**: this document expects you to understand a few basic concepts in computer science, such as pointers, stack and heap memory, etc.
+
+**WARNING**: Zig isn't considered as ready for production. Bugs are expected.
+
+Prior knowledge of C is recommended.
+
+## Quick overview: Zig compared to C
+
+- Syntax is mostly the same, with some improvements (less ambiguity).
+- Zig introduces namespaces.
+- `try` and `catch` mechanism, which is both convenient, efficient and optional.
+- Most of the C undefined behaviors (UBs) are fixed.
+- Compared to C, raw pointers are safer to use and less likely to be needed.
+  * The type system distinguishes between a pointer to a single value, or multiple values, etc.
+  * Slices are preferred, which is a structure with a pointer and a runtime known size, which characterizes most uses of pointers in the first place.
+- Some arbitrary language limitations are removed. For example, enumerations, structures and unions can have functions.
+- Simple access to SIMD operations (basic maths on vectors).
+- Zig provides both low-level features of C and the one provided through compiler extensions.
+  For example: packed structures.
+- An extensive standard library, including data structures and algorithms.
+- Cross-compilation capability is provided by default, without any dependency.
+  Different libc are provided to ease the process.
+  Cross-compilation works from, and to, any operating system and architecture.
+
+## Zig language
+
+```zig
+//! Top-level documentation.
+
+/// Documentation comment.
+
+// Simple comment.
+```
+
+### Hello world.
+
+```zig
+// Import standard library, reachable through the "std" constant.
+const std = @import("std");
+
+// "info" now refers to the "std.log.info" function.
+const info = std.log.info;
+
+// Usual hello world.
+// syntax: [pub] fn <function-name>(<arguments>) <return-type> { <body> }
+pub fn main() void {
+    // Contrary to C functions, Zig functions have a fixed number of arguments.
+    // In C: "printf" takes any number of arguments.
+    // In Zig: std.log.info takes a format and a list of elements to print.
+    info("hello world", .{});  // .{} is an empty anonymous tuple.
+}
+```
+
+### Booleans, integers and float.
+
+```zig
+// Booleans.
+// Keywords are preferred to operators for boolean operations.
+print("{}\n{}\n{}\n", .{
+    true and false,
+    true or false,
+    !true,
+});
+
+// Integers.
+const one_plus_one: i32 = 1 + 1;
+print("1 + 1 = {}\n", .{one_plus_one}); // 2
+
+// Floats.
+const seven_div_three: f32 = 7.0 / 3.0;
+print("7.0 / 3.0 = {}\n", .{seven_div_three}); // 2.33333325e+00
+
+// Integers have arbitrary value lengths.
+var myvar: u10 = 5; // 10-bit unsigned integer
+// Useful for example to read network packets, or complex binary formats.
+
+// Number representation is greatly improved compared to C.
+const one_billion = 1_000_000_000;         // Decimal.
+const binary_mask = 0b1_1111_1111;         // Binary. Ex: network mask.
+const permissions = 0o7_5_5;               // Octal.  Ex: Unix permissions.
+const big_address = 0xFF80_0000_0000_0000; // Hexa.   Ex: IPv6 address.
+
+
+// Overflow operators: tell the compiler when it's okay to overflow.
+var i: u8 = 0;  // "i" is an unsigned 8-bit integer
+i  -= 1;        // runtime overflow error (unsigned value always are positive)
+i -%= 1;        // okay (wrapping operator), i == 255
+
+// Saturation operators: values will stick to their lower and upper bounds.
+var i: u8 = 200;   // "i" is an unsigned 8-bit integer (values: from 0 to 255)
+i  +| 100 == 255   // u8: won't go higher than 255
+i  -| 300 == 0     // unsigned, won't go lower than 0
+i  *| 2   == 255   // u8: won't go higher than 255
+i <<| 8   == 255   // u8: won't go higher than 255
+```
+
+### Arrays.
+
+```zig
+// An array is a well-defined structure with a length attribute (len).
+
+// 5-byte array with undefined content (stack garbage).
+var array1: [5]u8 = undefined;
+
+// 5-byte array with defined content.
+var array2 = [_]u8{ 1, 2, 3, 4, 5 };
+// [_] means the compiler knows the length at compile-time.
+
+// 1000-byte array with defined content (0).
+var array3 = [_]u8{0} ** 1000;
+
+// Another 1000-byte array with defined content.
+// The content is provided by the "foo" function, called at compile-time and
+// allows complex initializations.
+var array4 = [_]u8{foo()} ** 1000;
+
+// In any case, array.len gives the length of the array,
+// array1.len and array2.len produce 5, array3.len and array4.len produce 1000.
+
+
+// Modifying and accessing arrays content.
+
+// Array of 10 32-bit undefined integers.
+var some_integers: [10]i32 = undefined;
+
+some_integers[0] = 30; // first element of the array is now 30
+
+var x = some_integers[0]; // "x" now equals to 30, its type is inferred.
+var y = some_integers[1]; // Second element of the array isn't defined.
+                          // "y" got a stack garbage value (no runtime error).
+
+// Array of 10 32-bit undefined integers.
+var some_integers: [10]i32 = undefined;
+
+var z = some_integers[20]; // index > array size, compilation error.
+
+// At runtime, we loop over the elements of "some_integers" with an index.
+// Index i = 20, then we try:
+try some_integers[i]; // Runtime error 'index out of bounds'.
+                      // "try" keyword is necessary when accessing an array with
+                      // an index, since there is a potential runtime error.
+                      // More on that later.
+```
+
+### Multidimensional arrays.
+
+```zig
+const mat4x4 = [4][4]f32{
+    [_]f32{ 1.0, 0.0, 0.0, 0.0 },
+    [_]f32{ 0.0, 1.0, 0.0, 1.0 },
+    [_]f32{ 0.0, 0.0, 1.0, 0.0 },
+    [_]f32{ 0.0, 0.0, 0.0, 1.0 },
+};
+
+// Access the 2D array then the inner array through indexes.
+try expect(mat4x4[1][1] == 1.0);
+
+// Here we iterate with for loops.
+for (mat4x4) |row, row_index| {
+    for (row) |cell, column_index| {
+        // ...
+    }
+}
+```
+
+### Strings.
+
+```zig
+// Simple string constant.
+const greetings = "hello";
+// ... which is equivalent to:
+const greetings: *const [5:0]u8 = "hello";
+// In words: "greetings" is a constant value, a pointer on a constant array of 5
+// elements (8-bit unsigned integers), with an extra '0' at the end.
+// The extra "0" is called a "sentinel value".
+
+print("string: {s}\n", .{greetings});
+
+// This represents rather faithfully C strings. Although, Zig strings are
+// structures, no need for "strlen" to compute their size.
+// greetings.len == 5
+```
+
+### Slices.
+
+```zig
+// A slice is a pointer and a size, an array without compile-time known size.
+// Slices have runtime out-of-band verifications.
+
+const array = [_]u8{1,2,3,4,5};     // [_] = array with compile-time known size.
+const slice = array[0..array.len];  // "slice" represents the whole array.
+                                    // slice[10] gives a runtime error.
+```
+
+### Pointers.
+
+```zig
+// Pointer on a value can be created with "&".
+const x: i32 = 1;
+const pointer: *i32 = &x;  // "pointer" is a pointer on the i32 var "x".
+print("1 = {}, {}\n", .{x, pointer});
+
+// Pointer values are accessed and modified with ".*".
+if (pointer.* == 1) {
+    print("x value == {}\n", .{pointer.*});
+}
+
+// ".?" is a shortcut for "orelse unreachable".
+const foo = pointer.?; // Get the pointed value, otherwise crash.
+```
+
+### Optional values (?<type>).
+
+```zig
+// An optional is a value than can be of any type or null.
+
+// Example: "optional_value" can either be "null" or an unsigned 32-bit integer.
+var optional_value: ?u32 = null; // optional_value == null
+optional_value = 42;             // optional_value != null
+
+// "some_function" returns ?u32
+var x = some_function();
+if (x) |value| {
+    // In case "some_function" returned a value.
+    // Do something with 'value'.
+}
+```
+
+### Errors.
+
+```zig
+// Zig provides an unified way to express errors.
+
+// Errors are defined in error enumerations, example:
+const Error = error {
+    WatchingAnyNetflixTVShow,
+    BeOnTwitter,
+};
+
+// Normal enumerations are expressed the same way, but with "enum" keyword.
+const SuccessStory = enum {
+    DoingSport,
+    ReadABook,
+};
+
+
+// Error union (!).
+// Either the value "mylife" is an an error or a normal value.
+var mylife: Error!SuccessStory = Error.BeOnTwitter;
+// mylife is an error. Sad.
+
+mylife = SuccessStory.ReadABook;
+// Now mylife is an enum.
+
+
+// Zig ships with many pre-defined errors. Example:
+const value: anyerror!u32 = error.Broken;
+
+
+// Handling errors.
+
+// Some error examples.
+const Error = error {
+    UnExpected,
+    Authentication,
+};
+
+// "some_function" can either return an "Error" or an integer.
+fn some_function() Error!u8 {
+    return Error.UnExpected; // It returns an error.
+}
+
+// Errors can be "catch" without intermediate variable.
+var value = some_function() catch |err| switch(err) {
+    Error.UnExpected     => return err,   // Returns the error.
+    Error.Authentication => unreachable,  // Not expected. Crashes the program.
+    else                 => unreachable,
+};
+
+// An error can be "catch" without giving it a name.
+const unwrapped = some_function() catch 1234; // "unwrapped" = 1234
+
+// "try" is a very handy shortcut for "catch |err| return err".
+var value = try some_function();
+// If "some_function" fails, the current function stops and returns the error.
+// "value" can only have a valid value, the error already is handled with "try".
+```
+
+### Control flow.
+
+```zig
+// Conditional branching.
+
+if (condition) {
+    ...
+}
+else {
+    ...
+}
+
+// Ternary.
+var value = if (condition) x else y;
+
+// Shortcut for "if (x) x else 0"
+var value = x orelse 0;
+
+// If "a" is an optional, which may contain a value.
+if (a) |value| {
+    print("value: {}\n", .{value});
+}
+else {
+    print("'a' is null\n", .{});
+}
+
+// Get a pointer on the value (if it exists).
+if (a) |*value| { value.* += 1; }
+
+
+// Loops.
+
+// Syntax examples:
+//   while (condition) statement
+//   while (condition) : (end-of-iteration-statement) statement
+//
+//   for (iterable) statement
+//   for (iterable) |capture| statement
+//   for (iterable) statement else statement
+
+// Note: loops work the same way over arrays or slices.
+
+// Simple "while" loop.
+while (i < 10) { i += 1; }
+
+// While loop with a "continue expression"
+// (expression executed as the last expression of the loop).
+while (i < 10) : (i += 1) { ... }
+// Same, with a more complex continue expression (block of code).
+while (i * j < 2000) : ({ i *= 2; j *= 3; }) { ... }
+
+// To iterate over a portion of a slice, reslice.
+for (items[0..1]) |value| { sum += value; }
+
+// Loop over every item of an array (or slice).
+for (items) |value| { sum += value; }
+
+// Iterate and get pointers on values instead of copies.
+for (items) |*value| { value.* += 1; }
+
+// Iterate with an index.
+for (items) |value, i| { print("val[{}] = {}\n", .{i, value}); }
+
+// Iterate with pointer and index.
+for (items) |*value, i| { print("val[{}] = {}\n", .{i, value}); value.* += 1; }
+
+
+// Break and continue are supported.
+for (items) |value| {
+    if (value == 0)  { continue; }
+    if (value >= 10) { break;    }
+    // ...
+}
+
+// For loops can also be used as expressions.
+// Similar to while loops, when you break from a for loop,
+// the else branch is not evaluated.
+var sum: i32 = 0;
+// The "for" loop has to provide a value, which will be the "else" value.
+const result = for (items) |value| {
+    if (value != null) {
+        sum += value.?; // "result" will be the last "sum" value.
+    }
+} else 0;                  // Last value.
+```
+
+### Labels.
+
+```zig
+// Labels are a way to name an instruction, a location in the code.
+// Labels can be used to "continue" or "break" in a nested loop.
+outer: for ([_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 }) |_| {
+    for ([_]i32{ 1, 2, 3, 4, 5 }) |_| {
+        count += 1;
+        continue :outer; // "continue" for the first loop.
+    }
+} // count = 8
+outer: for ([_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 }) |_| {
+    for ([_]i32{ 1, 2, 3, 4, 5 }) |_| {
+        count += 1;
+        break :outer; // "break" for the first loop.
+    }
+} // count = 1
+
+
+// Labels can also be used to return a value from a block.
+var y: i32 = 5;
+const x = blk: {
+    y += 1;
+    break :blk y; // Now "x" equals 6.
+};
+// Relevant in cases like "for else" expression (explained in the following).
+
+// For loops can be used as expressions.
+// When you break from a for loop, the else branch is not evaluated.
+// WARNING: counter-intuitive.
+//      The "for" loop will run, then the "else" block will run.
+//      The "else" keyword has to be followed by the value to give to "result".
+//      See later for another form.
+var sum: u8 = 0;
+const result = for (items) |value| {
+    sum += value;
+} else 8; // result = 8
+
+// In this case, the "else" keyword is followed by a value, too.
+// However, the syntax is different: it is labeled.
+// Instead of a value, there is a label followed by a block of code, which
+// allows to do stuff before returning the value (see the "break" invocation).
+const result = for (items) |value| { // First: loop.
+    sum += value;
+} else blk: {                        // Second: "else" block.
+    std.log.info("executed AFTER the loop!", .{});
+    break :blk sum; // The "sum" value will replace the label "blk".
+};
+```
+
+### Switch.
+
+```zig
+// As a switch in C, but slightly more advanced.
+// Syntax:
+//   switch (value) {
+//       pattern => expression,
+//       pattern => expression,
+//       else    => expression
+//   };
+
+// A switch only checking for simple values.
+var x = switch(value) {
+    Error.UnExpected     => return err,
+    Error.Authentication => unreachable,
+    else                 => unreachable,
+};
+
+// A slightly more advanced switch, accepting a range of values:
+const foo: i32 = 0;
+const bar = switch (foo) {
+    0                        => "zero",
+    1...std.math.maxInt(i32) => "positive",
+    else                     => "negative",
+};
+```
+
+### Structures.
+
+```zig
+// Structure containing a single value.
+const Full = struct {
+    number: u16,
+};
+
+// Packed structure, with guaranteed in-memory layout.
+const Divided = packed struct {
+    half1: u8,
+    quarter3: u4,
+    quarter4: u4,
+};
+
+// Point is a constant representing a structure containing two u32, "x" and "y".
+// "x" has a default value, which wasn't possible in C.
+const Point = struct {
+    x: u32 = 1, // default value
+    y: u32,
+};
+
+// Variable "p" is a new Point, with x = 1 (default value) and y = 2.
+var p = Point{ .y = 2 };
+
+// Fields are accessed as usual with the dot notation: variable.field.
+print("p.x: {}\n", .{p.x}); // 1
+print("p.y: {}\n", .{p.y}); // 2
+
+
+// A structure can also contain public constants and functions.
+const Point = struct {
+    pub const some_constant = 30;
+
+    x: u32,
+    y: u32,
+
+    // This function "init" creates a Point and returns it.
+    pub fn init() Point {
+        return Point{ .x = 0, .y = 0 };
+    }
+};
+
+
+// How to access a structure public constant.
+// The value isn't accessed from an "instance" of the structure, but from the
+// constant representing the structure definition (Point).
+print("constant: {}\n", .{Point.some_constant});
+
+// Having an "init" function is rather idiomatic in the standard library.
+// More on that later.
+var p = Point.init();
+print("p.x: {}\n", .{p.x}); // p.x = 0
+print("p.y: {}\n", .{p.y}); // p.y = 0
+
+
+// Structures often have functions to modify their state, similar to
+// object-oriented programming.
+const Point = struct {
+    const Self = @This(); // Refers to its own type (later called "Point").
+
+    x: u32,
+    y: u32,
+
+    // Take a look at the signature. First argument is of type *Self: "self" is
+    // a pointer on the instance of the structure.
+    // This allows the same "dot" notation as in OOP, like "instance.set(x,y)".
+    // See the following example.
+    pub fn set(self: *Self, x: u32, y: u32) void {
+        self.x = x;
+        self.y = y;
+    }
+
+    // Again, look at the signature. First argument is of type Self (not *Self),
+    // this isn't a pointer. In this case, "self" refers to the instance of the
+    // structure, but can't be modified.
+    pub fn getx(self: Self) u32 {
+        return self.x;
+    }
+
+    // PS: two previous functions may be somewhat useless.
+    //     Attributes can be changed directly, no need for accessor functions.
+    //     It was just an example.
+};
+
+// Let's use the previous structure.
+var p = Point{ .x = 0, .y = 0 }; // "p" variable is a Point.
+
+p.set(10, 30); // x and y attributes of "p" are modified via the "set" function.
+print("p.x: {}\n", .{p.x}); // 10
+print("p.y: {}\n", .{p.y}); // 30
+
+// In C:
+//   1. We would have written something like: point_set(p, 10, 30).
+//   2. Since all functions are in the same namespace, it would have been
+//      very cumbersome to create functions with different names for different
+//      structures. Many long names, painful to read.
+//
+// In Zig, structures provide namespaces for their own functions.
+// Different structures can have the same names for their functions,
+// which brings clarity.
+```
+
+### Tuples.
+
+```zig
+// A tuple is a list of elements, possibly of different types.
+
+const foo = .{ "hello", true, 42 };
+// foo.len == 3
+```
+
+### Enumerations.
+
+```zig
+const Type = enum { ok, not_ok };
+
+const CardinalDirections = enum { North, South, East, West };
+const direction: CardinalDirections = .North;
+const x = switch (direction) {
+    // shorthand for CardinalDirections.North
+    .North => true,
+    else => false
+};
+
+// Switch statements need exhaustiveness.
+// WARNING: won't compile. East and West are missing.
+const x = switch (direction) {
+    .North => true,
+    .South => true,
+};
+
+
+// Switch statements need exhaustiveness.
+// Won't compile: East and West are missing.
+const x = switch (direction) {
+    .North => true,
+    .South => true,
+    .East,          // Its value is the same as the following pattern: false.
+    .West => false,
+};
+
+
+// Enumerations are like structures: they can have functions.
+```
+
+### Unions.
+
+```zig
+const Bar = union {
+    boolean: bool,
+    int: i16,
+    float: f32,
+};
+
+// Both syntaxes are equivalent.
+const foo = Bar{ .int = 42 };
+const foo: Bar = .{ .int = 42 };
+
+// Unions, like enumerations and structures, can have functions.
+```
+
+### Tagged unions.
+
+```zig
+// Unions can be declared with an enum tag type, allowing them to be used in
+// switch expressions.
+
+const MaybeEnum = enum {
+    success,
+    failure,
+};
+
+const Maybe = union(MaybeEnum) {
+    success: u8,
+    failure: []const u8,
+};
+
+// First value: success!
+const yay = Maybe{ .success = 42 };
+switch (yay) {
+    .success => |value|     std.log.info("success: {}", .{value}),
+    .failure => |err_msg|   std.log.info("failure: {}", .{err_msg}),
+}
+
+// Second value: failure! :(
+const nay = Maybe{ .failure = "I was too lazy" };
+switch (nay) {
+    .success => |value|     std.log.info("success: {}", .{value}),
+    .failure => |err_msg|   std.log.info("failure: {}", .{err_msg}),
+}
+```
+
+### Defer and errdefer.
+
+```zig
+// Make sure that an action (single instruction or block of code) is executed
+// before the end of the scope (function, block of code).
+// Even on error, that action will be executed.
+// Useful for memory allocations, and resource management in general.
+
+pub fn main() void {
+    // Should be executed at the end of the function.
+    defer print("third!\n", .{});
+
+    {
+        // Last element of its scope: will be executed right away.
+        defer print("first!\n", .{});
+    }
+
+    print("second!\n", .{});
+}
+
+fn hello_world() void {
+    defer print("end of function\n", .{}); // after "hello world!"
+
+    print("hello world!\n", .{});
+}
+
+// errdefer executes the instruction (or block of code) only on error.
+fn second_hello_world() !void {
+    errdefer print("2. something went wrong!\n", .{}); // if "foo" fails.
+    defer    print("1. second hello world\n", .{});    // executed after "foo"
+
+    try foo();
+}
+// Defer statements can be seen as stacked: first one is executed last.
+```
+
+### Memory allocators.
+Memory isn't managed directly in the standard library, instead an "allocator" is asked every time an operation on memory is required.
+Thus, the standard library lets developers handle memory as they need, through structures called "allocators", handling all memory operations.
+
+**NOTE**: the choice of the allocator isn't in the scope of this document.
+A whole book could be written about it.
+However, here are some examples, to get an idea of what you can expect:
+- `page_allocator`.
+  Allocate a whole page of memory each time we ask for some memory.
+  Very simple, very dumb, very wasteful.
+- `GeneralPurposeAllocator`.
+  Get some memory first and manage some buckets of memory in order to
+  reduce the number of allocations.
+  A bit complex. Can be combined with other allocators.
+  Can detect leaks and provide useful information to find them.
+- `FixedBufferAllocator`.
+  Use a fixed buffer to get its memory, don't ask memory to the kernel.
+  Very simple, limited and wasteful (can't deallocate), but very fast.
+- `ArenaAllocator`.
+  Allow to free all allocated memory at once.
+  To use in combinations with another allocator.
+  Very simple way of avoiding leaks.
+
+A first example.
+
+```zig
+// "!void" means the function doesn't return any value except for errors.
+// In this case we try to allocate memory, and this may fail.
+fn foo() !void {
+    // In this example we use a page allocator.
+    var allocator = std.heap.page_allocator;
+
+    // "list" is an ArrayList of 8-bit unsigned integers.
+    // An ArrayList is a contiguous, growable list of elements in memory.
+    var list = try ArrayList(u8).initAllocated(allocator);
+    defer list.deinit(); // Free the memory at the end of the scope. Can't leak.
+    // "defer" allows to express memory release right after its allocation,
+    // regardless of the complexity of the function (loops, conditions, etc.).
+
+    list.add(5); // Some memory is allocated here, with the provided allocator.
+
+    for (list.items) |item| {
+        std.debug.print("item: {}\n", .{item});
+    }
+}
+```
+
+### Memory allocation combined with error management and defer.
+
+```zig
+fn some_memory_allocation_example() !void {
+    // Memory allocation may fail, so we "try" to allocate the memory and
+    // in case there is an error, the current function returns it.
+    var buf = try page_allocator.alloc(u8, 10);
+    // Defer memory release right after the allocation.
+    // Will happen even if an error occurs.
+    defer page_allocator.free(buf);
+
+    // Second allocation.
+    // In case of a failure, the first allocation is correctly released.
+    var buf2 = try page_allocator.alloc(u8, 10);
+    defer page_allocator.free(buf2);
+
+    // In case of failure, both previous allocations are correctly deallocated.
+    try foo();
+    try bar();
+
+    // ...
+}
+```
+
+### Memory allocators: a taste of the standard library.
+
+```zig
+// Allocators: 4 main functions to know
+//   single_value = create (type)
+//   destroy (single_value)
+//   slice = alloc (type, size)
+//   free (slice)
+
+// Page Allocator
+fn page_allocator_fn() !void {
+    var slice = try std.heap.page_allocator.alloc(u8, 3);
+    defer std.heap.page_allocator.free(slice);
+
+    // playing_with_a_slice(slice);
+}
+
+// GeneralPurposeAllocator
+fn general_purpose_allocator_fn() !void {
+    // GeneralPurposeAllocator has to be configured.
+    // In this case, we want to track down memory leaks.
+    const config = .{.safety = true};
+    var gpa = std.heap.GeneralPurposeAllocator(config){};
+    defer _ = gpa.deinit();
+
+    const allocator = gpa.allocator();
+
+    var slice = try allocator.alloc(u8, 3);
+    defer allocator.free(slice);
+
+    // playing_with_a_slice(slice);
+}
+
+// FixedBufferAllocator
+fn fixed_buffer_allocator_fn() !void {
+    var buffer = [_]u8{0} ** 1000; // array of 1000 u8, all initialized at zero.
+    var fba  = std.heap.FixedBufferAllocator.init(buffer[0..]);
+    // Side note: buffer[0..] is a way to create a slice from an array.
+    //            Since the function takes a slice and not an array, this makes
+    //            the type system happy.
+
+    var allocator = fba.allocator();
+
+    var slice = try allocator.alloc(u8, 3);
+    // No need for "free", memory cannot be freed with a fixed buffer allocator.
+    // defer allocator.free(slice);
+
+    // playing_with_a_slice(slice);
+}
+
+// ArenaAllocator
+fn arena_allocator_fn() !void {
+    // Reminder: arena doesn't allocate memory, it uses an inner allocator.
+    // In this case, we combine the arena allocator with the page allocator.
+    var arena = std.heap.arena_allocator.init(std.heap.page_allocator);
+    defer arena.deinit(); // end of function = all allocations are freed.
+
+    var allocator = arena.allocator();
+
+    const slice = try allocator.alloc(u8, 3);
+    // No need for "free", memory will be freed anyway.
+
+    // playing_with_a_slice(slice);
+}
+
+
+// Combining the general purpose and arena allocators. Both are very useful,
+// and their combinations should be in everyone's favorite cookbook.
+fn gpa_arena_allocator_fn() !void {
+    const config = .{.safety = true};
+    var gpa = std.heap.GeneralPurposeAllocator(config){};
+    defer _ = gpa.deinit();
+
+    const gpa_allocator = gpa.allocator();
+
+    var arena = arena_allocator.init(gpa_allocator);
+    defer arena.deinit();
+
+    const allocator = arena.allocator();
+
+    var slice = try allocator.alloc(u8, 3);
+    defer allocator.free(slice);
+
+    // playing_with_a_slice(slice);
+}
+```
+
+### Comptime.
+
+```zig
+// Comptime is a way to avoid the pre-processor.
+// The idea is simple: run code at compilation.
+
+inline fn max(comptime T: type, a: T, b: T) T {
+    return if (a > b) a else b;
+}
+
+var res = max(u64, 1, 2);
+var res = max(f32, 10.50, 32.19);
+
+
+// Comptime: creating generic structures.
+
+fn List(comptime T: type) type {
+    return struct {
+        items: []T,
+
+        fn init()   ... { ... }
+        fn deinit() ... { ... }
+        fn do()     ... { ... }
+    };
+}
+
+const MyList = List(u8);
+
+
+// use
+var list = MyList{
+    .items = ... // memory allocation
+};
+
+list.items[0] = 10;
+```
+
+### Conditional compilation.
+
+```zig
+const available_os = enum { OpenBSD, Linux };
+const myos = available_os.OpenBSD;
+
+
+// The following switch is based on a constant value.
+// This means that the only possible outcome is known at compile-time.
+// Thus, there is no need to build the rest of the possibilities.
+// Similar to the "#ifdef" in C, but without requiring a pre-processor.
+const string = switch (myos) {
+   .OpenBSD => "OpenBSD is awesome!",
+   .Linux => "Linux rocks!",
+};
+
+// Also works in this case.
+const myprint = switch(myos) {
+    .OpenBSD => std.debug.print,
+    .Linux => std.log.info,
+}
+```
+
+### Testing our functions.
+
+```zig
+const std = @import("std");
+const expect = std.testing.expect;
+
+// Function to test.
+pub fn some_function() bool {
+    return true;
+}
+
+// This "test" block can be run with "zig test".
+// It will test the function at compile-time.
+test "returns true" {
+    expect(false == some_function());
+}
+```
+
+### Compiler built-ins.
+The compiler has special functions called "built-ins", starting with an "@".
+There are more than a hundred built-ins, allowing very low-level stuff:
+- compile-time errors, logging, verifications
+- type coercion and conversion, even in an unsafe way
+- alignment management
+- memory tricks (such as getting the byte offset of a field in a struct)
+- calling functions at compile-time
+- including C headers to transparently call C functions
+- atomic operations
+- embed files into the executable (@embedFile)
+- frame manipulations (for async functions, for example)
+- etc.
+
+Example: enums aren't integers, they have to be converted with a built-in.
+
+```zig
+const Value = enum { zero, stuff, blah };
+if (@enumToInt(Value.zero)  == 0) { ... }
+if (@enumToInt(Value.stuff) == 1) { ... }
+if (@enumToInt(Value.blah)  == 2) { ... }
+```
+
+### A few "not yourself in the foot" measures in the Zig language.
+
+- Namespaces: name conflicts are easily avoided.
+  In practice, that means a unified API between different structures (data types).
+- Enumerations aren't integers. Comparing an enumeration to an integer requires a conversion.
+- Explicit casts, coercion exists but is limited.
+  Types are slightly more enforced than in C, just a taste:
+    Pointers aren't integers, explicit conversion is necessary.
+    You won't lose precision by accident, implicit coercions are only authorized in cases where no precision can be lost.
+    Unions cannot be reinterpreted (in a union with an integer and a float, one cannot take a value for another by accident).
+    Etc.
+- Removing most of the C undefined behaviors (UBs), and when the compiler encounters one, it stops.
+- Slice and Array structures are preferred to pointers.
+  Types enforced by the compiler are less prone to errors than pointer manipulations.
+- Numerical overflows produce an error, unless explicitly accepted using wrapping operators.
+- `try` and `catch` mechanism.
+  It's both handy, trivially implemented (simple error enumeration), and it takes almost no space nor computation time.
+- Unused variables are considered to be errors by the compiler.
+- Many pointer types exist in order to represent what is pointed to.
+  Example: is this a single value or an array, is the length known, etc.
+- Structures need a value for their attributes, and it is still possible to give an undefined value (stack garbage), but at least it is explicitly undefined.
+
+
+## Further Reading
+
+For a start, some concepts are presented on [zig.guide][zigguide].
+
+The [official website][zigdoc] provides the reference documentation of the language. The standard library [has its own documentation][zigstd].
+
+[ziglang]: https://ziglang.org
+[zigguide]: https://zig.guide/
+[zigdoc]: https://ziglang.org/documentation/
+[zigstd]: https://ziglang.org/documentation/master/std/