Merge branch 'master' of https://github.com/adambard/learnxinyminutes-docs

139 files changed, 17441 insertions, 1845 deletions

diff --git a/README.markdown b/README.markdown
index 774797d5..94afbcbe 100644
--- a/README.markdown
+++ b/README.markdown
@@ -18,7 +18,7 @@ All contributions are welcome, from the tiniest typo to a brand new article. Tra
 in all languages are welcome (or, for that matter, original articles in any language).
 Send a pull request or open an issue any time of day or night.
 
-**Please tag your issues pull requests with [language/lang-code] at the beginning**
+**Please tag your issues and pull requests with [language/lang-code] at the beginning**
 **(e.g. [python/en] for English Python).** This will help everyone pick out things they
 care about.
 
diff --git a/amd.html.markdown b/amd.html.markdown
index b3237dc7..d7fb41ba 100644
--- a/amd.html.markdown
+++ b/amd.html.markdown
@@ -8,10 +8,10 @@ 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 

+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

diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown
index e1f961f8..a516737e 100644
--- a/asymptotic-notation.html.markdown
+++ b/asymptotic-notation.html.markdown
@@ -72,45 +72,45 @@ for a given function. Say `f(n)` is your algorithm runtime, and `g(n)` is an arb
 you are trying to relate to your algorithm. `f(n)` is O(g(n)), if for any real constant c (c > 0),
 `f(n)` <= `c g(n)` for every input size n (n > 0).
 
-*Example 1*  
+*Example 1*
 
 ```
-f(n) = 3log n + 100  
+f(n) = 3log n + 100
 g(n) = log n
 ```
 
-Is `f(n)` O(g(n))?  
-Is `3 log n + 100` O(log n)?  
+Is `f(n)` O(g(n))?
+Is `3 log n + 100` O(log n)?
 Let's look to the definition of Big-O.
 
 ```
-3log n + 100 <= c * log n  
+3log n + 100 <= c * log n
 ```
 
-Is there some constant c that satisfies this for all n?  
+Is there some constant c that satisfies this for all n?
 
 ```
-3log n + 100 <= 150 * log n, n > 2 (undefined at n = 1)  
+3log n + 100 <= 150 * log n, n > 2 (undefined at n = 1)
 ```
 
 Yes! The definition of Big-O has been met therefore `f(n)` is O(g(n)).
 
-*Example 2*  
+*Example 2*
 
 ```
-f(n) = 3*n^2  
+f(n) = 3*n^2
 g(n) = n
 ```
 
-Is `f(n)` O(g(n))?  
-Is `3 * n^2` O(n)?  
+Is `f(n)` O(g(n))?
+Is `3 * n^2` O(n)?
 Let's look at the definition of Big-O.
 
 ```
-3 * n^2 <= c * n  
+3 * n^2 <= c * n
 ```
 
-Is there some constant c that satisfies this for all n?  
+Is there some constant c that satisfies this for all n?
 No, there isn't. `f(n)` is NOT O(g(n)).
 
 ### Big-Omega
diff --git a/bash.html.markdown b/bash.html.markdown
index 08182c2c..211d2944 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -51,7 +51,7 @@ echo $Variable
 echo "$Variable"
 echo '$Variable'
 # When you use the variable itself — assign it, export it, or else — you write
-# its name without $. If you want to use variable's value, you should use $.
+# its name without $. If you want to use the variable's value, you should use $.
 # Note that ' (single quote) won't expand the variables!
 
 # String substitution in variables
@@ -70,11 +70,11 @@ echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
 
 # Builtin variables:
 # There are some useful builtin variables, like
-echo "Last program return value: $?"
+echo "Last program's return value: $?"
 echo "Script's PID: $$"
-echo "Number of arguments: $#"
-echo "Scripts arguments: $@"
-echo "Scripts arguments separated in different variables: $1 $2..."
+echo "Number of arguments passed to script: $#"
+echo "All arguments passed to script: $@"
+echo "Script's arguments separated into different variables: $1 $2..."
 
 # Reading a value from input:
 echo "What's your name?"
@@ -90,17 +90,26 @@ else
     echo "Your name is your username"
 fi
 
+# NOTE: if $Name is empty, bash sees the above condition as:
+if [ -ne $USER ]
+# which is invalid syntax
+# so the "safe" way to use potentially empty variables in bash is:
+if [ "$Name" -ne $USER ] ...
+# which, when $Name is empty, is seen by bash as:
+if [ "" -ne $USER ] ...
+# which works as expected
+
 # There is also conditional execution
 echo "Always executed" || echo "Only executed if first command fails"
 echo "Always executed" && echo "Only executed if first command does NOT fail"
 
 # To use && and || with if statements, you need multiple pairs of square brackets:
-if [ $Name == "Steve" ] && [ $Age -eq 15 ]
+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" ]
+if [ "$Name" == "Daniya" ] || [ "$Name" == "Zach" ]
 then
     echo "This will run if $Name is Daniya OR Zach."
 fi
@@ -108,8 +117,8 @@ fi
 # Expressions are denoted with the following format:
 echo $(( 10 + 5 ))
 
-# Unlike other programming languages, bash is a shell — so it works in a context
-# of current directory. You can list files and directories in the current
+# Unlike other programming languages, bash is a shell so it works in the context
+# of a current directory. You can list files and directories in the current
 # directory with the ls command:
 ls
 
@@ -252,7 +261,7 @@ grep "^foo.*bar$" file.txt
 grep -c "^foo.*bar$" file.txt
 # if you literally want to search for the string,
 # and not the regex, use fgrep (or grep -F)
-fgrep "^foo.*bar$" file.txt 
+fgrep "^foo.*bar$" file.txt
 
 
 # Read Bash shell builtins documentation with the bash 'help' builtin:
diff --git a/c++.html.markdown b/c++.html.markdown
index 26dfe111..d03092e5 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Matt Kline", "https://github.com/mrkline"]
     - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
 lang: en
 ---
 
@@ -53,11 +54,11 @@ int main(int argc, char** argv)
 
 // However, C++ varies in some of the following ways:
 
-// In C++, character literals are one byte.
-sizeof('c') == 1
+// In C++, character literals are chars
+sizeof('c') == sizeof(char) == 1
 
-// In C, character literals are the same size as ints.
-sizeof('c') == sizeof(10)
+// In C, character literals are ints
+sizeof('c') == sizeof(int)
 
 
 // C++ has strict prototyping
@@ -159,9 +160,9 @@ void foo()
 
 int main()
 {
-    // Includes all symbols from `namesapce 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.
+    // 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.
     using namespace Second;
 
     Second::foo(); // prints "This is Second::foo"
@@ -244,7 +245,13 @@ cout << fooRef; // Prints "I am foo. Hi!"
 // Doesn't reassign "fooRef". This is the same as "foo = bar", and
 //   foo == "I am bar"
 // after this line.
+cout << &fooRef << endl; //Prints the address of foo
 fooRef = bar;
+cout << &fooRef << endl; //Still prints the address of foo
+cout << fooRef;  // Prints "I am bar"
+
+//The address of fooRef remains the same, i.e. it is still referring to foo.
+
 
 const string& barRef = bar; // Create a const reference to bar.
 // Like C, const values (and pointers and references) cannot be modified.
@@ -256,8 +263,8 @@ string tempObjectFun() { ... }
 string retVal = tempObjectFun();
 
 // What happens in the second line is actually:
-//   - a string object is returned from `tempObjectFun`
-//   - a new string is constructed with the returned object as arugment to the
+//   - a string object is returned from tempObjectFun
+//   - a new string is constructed with the returned object as argument to the
 //     constructor
 //   - the returned object is destroyed
 // The returned object is called a temporary object. Temporary objects are
@@ -268,15 +275,15 @@ string retVal = tempObjectFun();
 // code:
 foo(bar(tempObjectFun()))
 
-// assuming `foo` and `bar` exist, the object returned from `tempObjectFun` is
-// passed to `bar`, and it is destroyed before `foo` is called.
+// assuming foo and bar exist, the object returned from tempObjectFun is
+// passed to bar, and it is destroyed before foo is called.
 
 // Now back to references. The exception to the "at the end of the enclosing
 // expression" rule is if a temporary object is bound to a const reference, in
 // which case its life gets extended to the current scope:
 
 void constReferenceTempObjectFun() {
-  // `constRef` gets the temporary object, and it is valid until the end of this
+  // constRef gets the temporary object, and it is valid until the end of this
   // function.
   const string& constRef = tempObjectFun();
   ...
@@ -301,7 +308,71 @@ basic_string(basic_string&& other);
 // Idea being if we are constructing a new string from a temporary object (which
 // is going to be destroyed soon anyway), we can have a more efficient
 // constructor that "salvages" parts of that temporary string. You will see this
-// concept referred to as the move semantic.
+// concept referred to as "move semantics".
+
+/////////////////////
+// Enums
+/////////////////////
+
+// Enums are a way to assign a value to a constant most commonly used for
+// easier visualization and reading of code
+enum ECarTypes
+{
+  Sedan,
+  Hatchback,
+  SUV,
+  Wagon
+};
+
+ECarTypes GetPreferredCarType()
+{
+	return ECarTypes::Hatchback;
+}
+
+// As of C++11 there is an easy way to assign a type to the enum which can be
+// useful in serialization of data and converting enums back-and-forth between 
+// the desired type and their respective constants
+enum ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// The enum is implicitly converted to a uint8_t due to its declared enum type
+	WriteByteToFile(InputCarType);
+}
+
+// On the other hand you may not want enums to be accidentally cast to an integer
+// type or to other enums so it is instead possible to create an enum class which 
+// won't be implicitly converted
+enum class ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// Won't compile even though ECarTypes is a uint8_t due to the enum
+	// being declared as an "enum class"!
+	WriteByteToFile(InputCarType);
+}
 
 //////////////////////////////////////////
 // Classes and object-oriented programming
@@ -349,7 +420,10 @@ public:
     // These are called when an object is deleted or falls out of scope.
     // This enables powerful paradigms such as RAII
     // (see below)
-    // Destructors must be virtual to allow classes to be derived from this one.
+    // The destructor should be virtual if a class is to be derived from;
+    // if it is not virtual, then the derived class' destructor will
+    // not be called if the object is destroyed through a base-class reference
+    // or pointer.
     virtual ~Dog();
 
 }; // A semicolon must follow the class definition.
@@ -394,6 +468,8 @@ int main() {
 // Inheritance:
 
 // This class inherits everything public and protected from the Dog class
+// as well as private but may not directly access private members/methods 
+// without a public or protected method for doing so
 class OwnedDog : public Dog {
 
     void setOwner(const std::string& dogsOwner);
@@ -492,9 +568,10 @@ int main () {
 /////////////////////
 
 // Templates in C++ are mostly used for generic programming, though they are
-// much more powerful than generics constructs in other languages. It also
-// supports explicit and partial specialization, functional-style type classes,
-// and also it's Turing-complete.
+// much more powerful than generic constructs in other languages. They also
+// support explicit and partial specialization and functional-style type
+// classes; in fact, they are a Turing-complete functional language embedded
+// in C++!
 
 // We start with the kind of generic programming you might be familiar with. To
 // define a class or function that takes a type parameter:
@@ -506,7 +583,7 @@ public:
 };
 
 // During compilation, the compiler actually generates copies of each template
-// with parameters substituted, and so the full definition of the class must be
+// with parameters substituted, so the full definition of the class must be
 // present at each invocation. This is why you will see template classes defined
 // entirely in header files.
 
@@ -520,13 +597,13 @@ intBox.insert(123);
 Box<Box<int> > boxOfBox;
 boxOfBox.insert(intBox);
 
-// Up until C++11, you must place a space between the two '>'s, otherwise '>>'
-// will be parsed as the right shift operator.
+// Until C++11, you had to place a space between the two '>'s, otherwise '>>'
+// would be parsed as the right shift operator.
 
 // You will sometimes see
 //   template<typename T>
-// instead. The 'class' keyword and 'typename' keyword are _mostly_
-// interchangeable in this case. For full explanation, see
+// instead. The 'class' keyword and 'typename' keywords are _mostly_
+// interchangeable in this case. For the full explanation, see
 //   http://en.wikipedia.org/wiki/Typename
 // (yes, that keyword has its own Wikipedia page).
 
@@ -582,12 +659,15 @@ try {
     // Do not allocate exceptions on the heap using _new_.
     throw std::runtime_error("A problem occurred");
 }
+
 // Catch exceptions by const reference if they are objects
 catch (const std::exception& ex)
 {
-  std::cout << ex.what();
+    std::cout << ex.what();
+}
+
 // Catches any exception not caught by previous _catch_ blocks
-} catch (...)
+catch (...)
 {
     std::cout << "Unknown exception caught";
     throw; // Re-throws the exception
@@ -597,8 +677,8 @@ catch (const std::exception& ex)
 // RAII
 ///////
 
-// RAII stands for Resource Allocation Is Initialization.
-// It is often considered the most powerful paradigm in C++,
+// RAII stands for "Resource Acquisition Is Initialization".
+// It is often considered the most powerful paradigm in C++
 // and is the simple concept that a constructor for an object
 // acquires that object's resources and the destructor releases them.
 
@@ -619,9 +699,9 @@ void doSomethingWithAFile(const char* filename)
 // Unfortunately, things are quickly complicated by error handling.
 // Suppose fopen can fail, and that doSomethingWithTheFile and
 // doSomethingElseWithIt return error codes if they fail.
-// (Exceptions are the preferred way of handling failure,
-//  but some programmers, especially those with a C background,
-//  disagree on the utility of exceptions).
+//  (Exceptions are the preferred way of handling failure,
+//   but some programmers, especially those with a C background,
+//   disagree on the utility of exceptions).
 // We now have to check each call for failure and close the file handle
 // if a problem occurred.
 bool doSomethingWithAFile(const char* filename)
@@ -735,21 +815,23 @@ class Foo {
   virtual void bar();
 };
 class FooSub : public Foo {
-  virtual void bar();  // overrides Foo::bar!
+  virtual void bar();  // Overrides Foo::bar!
 };
 
 
 // 0 == false == NULL (most of the time)!
 bool* pt = new bool;
-*pt = 0;  // Sets the value points by 'pt' to false.
+*pt = 0; // Sets the value points by 'pt' to false.
 pt = 0;  // Sets 'pt' to the null pointer. Both lines compile without warnings.
 
 // nullptr is supposed to fix some of that issue:
 int* pt2 = new int;
-*pt2 = nullptr;  // Doesn't compile
+*pt2 = nullptr; // Doesn't compile
 pt2 = nullptr;  // Sets pt2 to null.
 
-// But somehow 'bool' type is an exception (this is to make `if (ptr)` compile).
+// There is an exception made for bools.
+// This is to allow you to test for null pointers with if(!ptr),
+// but as a consequence you can assign nullptr to a bool directly!
 *pt = nullptr;  // This still compiles, even though '*pt' is a bool!
 
 
@@ -776,12 +858,12 @@ vector<Foo> v;
 for (int i = 0; i < 10; ++i)
   v.push_back(Foo());
 
-// Following line sets size of v to 0, but destructors don't get called,
+// Following line sets size of v to 0, but destructors don't get called
 // and resources aren't released!
 v.empty();
-v.push_back(Foo());  // New value is copied into the first Foo we inserted in the loop.
+v.push_back(Foo());  // New value is copied into the first Foo we inserted
 
-// Truly destroys all values in v. See section about temporary object for
+// Truly destroys all values in v. See section about temporary objects for
 // explanation of why this works.
 v.swap(vector<Foo>());
 
diff --git a/c.html.markdown b/c.html.markdown
index 8e631de4..3d632eab 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -6,7 +6,8 @@ contributors:
     - ["Á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"]
 ---
 
 Ah, C. Still **the** language of modern high-performance computing.
@@ -27,6 +28,7 @@ Multi-line comments don't nest /* Be careful */  // comment ends on this line...
 */ // ...not this one!
 
 // Constants: #define <keyword>
+// Constants are written in all-caps out of convention, not requirement
 #define DAYS_IN_YEAR 365
 
 // Enumeration constants are also ways to declare constants.
@@ -52,10 +54,21 @@ int function_2(void);
 // Must declare a 'function prototype' before main() when functions occur after
 // your main() function.
 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.
 int main(void) {
+  // your program
+}
+
+// The command line arguments used to run your program are also passed to main
+// argc being the number of arguments - your program's name counts as 1
+// argv is an array of character arrays - containing the arguments themselves
+// argv[0] = name of your program, argv[1] = first argument, etc.
+int main (int argc, char** argv)
+{
   // print output using printf, for "print formatted"
   // %d is an integer, \n is a newline
   printf("%d\n", 0); // => Prints 0
@@ -63,6 +76,9 @@ int main(void) {
   ///////////////////////////////////////
   // Types
   ///////////////////////////////////////
+  
+  // All variables MUST be declared at the top of the current block scope
+  // we declare them dynamically along the code for the sake of the tutorial
 
   // ints are usually 4 bytes
   int x_int = 0;
@@ -130,7 +146,9 @@ int main(void) {
   // can be declared as well. The size of such an array need not be a compile
   // time constant:
   printf("Enter the array size: "); // ask the user for an array size
-  char buf[0x100];
+  int size;
+  fscanf(stdin, "%d", &size);
+  char buf[size];
   fgets(buf, sizeof buf, stdin);
 
   // strtoul parses a string to an unsigned integer
@@ -219,7 +237,7 @@ int main(void) {
   0 || 1; // => 1 (Logical or)
   0 || 0; // => 0
 
-  // Conditional expression ( ? : )
+  // Conditional ternary expression ( ? : )
   int e = 5;
   int f = 10;
   int z;
@@ -289,6 +307,8 @@ int main(void) {
   for (i = 0; i <= 5; i++) {
     ; // use semicolon to act as the body (null statement)
   }
+  // Or
+  for (i = 0; i <= 5; i++);
 
   // branching with multiple choices: switch()
   switch (a) {
@@ -304,7 +324,29 @@ int main(void) {
     exit(-1);
     break;
   }
-
+  /*
+  using "goto" in C
+  */
+  typedef enum { false, true } bool;
+  // for C don't have bool as data type :(
+  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 occured at i = %d & j = %d.\n", i, j);
+  /*
+  https://ideone.com/GuPhd6
+  this will print out "Error occured at i = 52 & j = 99."
+  */
+  
+  
   ///////////////////////////////////////
   // Typecasting
   ///////////////////////////////////////
@@ -403,6 +445,17 @@ int main(void) {
   for (xx = 0; xx < 20; xx++) {
     *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
   } // Initialize memory to 20, 19, 18, 17... 2, 1 (as ints)
+  
+  // Note that there is no standard way to get the length of a
+  // dynamically allocated array in C. Because of this, if your arrays are
+  // going to be passed around your program a lot, you need another variable
+  // to keep track of the number of elements (size) of an array. See the
+  // functions section for more info.
+  int size = 10;
+  int *my_arr = malloc(sizeof(int) * size);
+  // Add an element to the array
+  my_arr = realloc(my_arr, ++size);
+  my_arr[10] = 5;
 
   // Dereferencing memory that you haven't allocated gives
   // "unpredictable results" - the program is said to invoke "undefined behavior"
@@ -470,6 +523,46 @@ char c[] = "This is a test.";
 str_reverse(c);
 printf("%s\n", c); // => ".tset a si sihT"
 */
+/*
+as we can return only one variable
+to change values of more than one variables we use call by reference
+*/
+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);
+// values will be swapped
+*/
+
+/*
+With regards to arrays, they will always be passed to functions
+as pointers. Even if you statically allocate an array like `arr[10]`,
+it still gets passed as a pointer to the first element in any function calls.
+Again, there is no standard way to get the size of a dynamically allocated
+array in C.
+*/
+// Size must be passed!
+// Otherwise, this function has no way of knowing how big the array is.
+void printIntArray(int *arr, int 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);
+// will print "arr[0] is: 1" etc
+*/
 
 // if referring to external variables outside function, must use extern keyword.
 int i = 0;
@@ -626,8 +719,56 @@ typedef void (*my_fnp_type)(char *);
 // ,                                 | left to right //
 //---------------------------------------------------//
 
-```
+/******************************* Header Files **********************************
+
+Header files are an important part of c as they allow for the connection of c 
+source files and can simplify code and definitions by seperating them into 
+seperate files.
+
+Header files are syntaxtically similar to c source files but reside in ".h" 
+files. They can be included in your c source file by using the precompiler 
+command #include "example.h", given that example.h exists in the same directory 
+as the c file.
+*/
+
+/* A safe guard to prevent the header from being defined too many times. This */
+/* happens in the case of circle dependency, the contents of the header is    */
+/* already defined.                                                           */
+#ifndef EXAMPLE_H /* if EXAMPLE_H is not yet defined. */
+#define EXAMPLE_H /* Define the macro EXAMPLE_H. */
+
+/* Other headers can be included in headers and therefore transitively */
+/* included into files that include this header.                       */
+#include <string.h>
 
+/* Like c source files macros can be defined in headers and used in files */
+/* that include this header file.                                         */
+#define EXAMPLE_NAME "Dennis Ritchie"
+/* Function macros can also be defined. */
+#define ADD(a, b) (a + b)
+
+/* Structs and typedefs can be used for consistency between files. */
+typedef struct node
+{
+    int val;
+    struct node *next;
+} Node;
+
+/* So can enumerations. */
+enum traffic_light_state {GREEN, YELLOW, RED};
+
+/* Function prototypes can also be defined here for use in multiple files,  */
+/* but it is bad practice to define the function in the header. Definitions */
+/* should instead be put in a c file.                                       */
+Node createLinkedList(int *vals, int len);
+
+/* Beyond the above elements, other definitions should be left to a c source */
+/* file. Excessive includeds or definitions should, also not be contained in */
+/* a header file but instead put into separate headers or a c file.          */
+
+#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)
diff --git a/chapel.html.markdown b/chapel.html.markdown
index c8489371..7252a3e4 100644
--- a/chapel.html.markdown
+++ b/chapel.html.markdown
@@ -27,7 +27,7 @@ writeln( "There are ", 3, " commas (\",\") in this line of code" );
 stdout.writeln( "This goes to standard output, just like plain writeln() does");
 stderr.writeln( "This goes to standard error" );
 
-// Variables don't have to be explicitly typed as long as 
+// Variables don't have to be explicitly typed as long as
 // the compiler can figure out the type that it will hold.
 var myVar = 10; // 10 is an int, so myVar is implicitly an int
 myVar = -10;
@@ -65,9 +65,9 @@ const almostPi: real = 22.0/7.0;
 param compileTimeConst: int = 16;
 
 // The config modifier allows values to be set at the command line
-// and is much easier than the usual getOpts debacle 
+// and is much easier than the usual getOpts debacle
 // config vars and consts can be changed through the command line at run time
-config var varCmdLineArg: int = -123; 
+config var varCmdLineArg: int = -123;
 config const constCmdLineArg: int = 777;
 // Set with --VarName=Value or --VarName Value at run time
 
@@ -119,9 +119,9 @@ a *= thatInt;          // Times-equals ( a = a * thatInt; )
 b &&= thatBool;        // Logical-and-equals ( b = b && thatBool; )
 a <<= 3;               // Left-bit-shift-equals ( a = a << 10; )
 // and many, many more.
-// Unlike other C family languages there are no 
+// Unlike other C family languages there are no
 // pre/post-increment/decrement operators like
-//  ++j, --j, j++, j-- 
+//  ++j, --j, j++, j--
 
 // Swap operator
 var old_this = thisInt;
@@ -155,7 +155,7 @@ writeln( (a,b,thisInt,thatInt,thisBool,thatBool) );
 
 // Type aliasing
 type chroma = int;        // Type of a single hue
-type RGBColor = 3*chroma; // Type representing a full color 
+type RGBColor = 3*chroma; // Type representing a full color
 var black: RGBColor = ( 0,0,0 );
 var white: RGBColor = ( 255, 255, 255 );
 
@@ -198,7 +198,7 @@ select( inputOption ){
     writeln( "Chose 'otherOption'" );
     writeln( "Which has a body" );
   }
-  otherwise { 
+  otherwise {
     writeln( "Any other Input" );
     writeln( "the otherwise case doesn't need a do if the body is one line" );
   }
@@ -221,7 +221,7 @@ do{
 writeln( jSum );
 
 // For loops are much like those in python in that they iterate over a range.
-// Ranges themselves are types, and can be stuffed into variables 
+// Ranges themselves are types, and can be stuffed into variables
 // (more about that later)
 for i in 1..10 do write( i , ", ") ;
 writeln( );
@@ -240,28 +240,28 @@ for x in 1..10 {
 }
 
 // Ranges and Domains
-// For-loops and arrays both use ranges and domains to 
+// For-loops and arrays both use ranges and domains to
 // define an index set that can be iterated over.
 // Ranges are single dimensional
-// Domains can be multi-dimensional and can 
+// Domains can be multi-dimensional and can
 // represent indices of different types as well.
 // They are first-class citizen types, and can be assigned into variables
 var range1to10: range = 1..10;  // 1, 2, 3, ..., 10
 var range2to11 = 2..11; // 2, 3, 4, ..., 11
 var rangeThistoThat: range = thisInt..thatInt; // using variables
-var rangeEmpty: range = 100..-100 ; // this is valid but contains no indices 
+var rangeEmpty: range = 100..-100 ; // this is valid but contains no indices
 
-// Ranges can be unbounded 
-var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ; 
+// Ranges can be unbounded
+var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ;
 // 1, 2, 3, 4, 5, ...
-// Note: the range(boundedType= ... ) is only 
+// Note: the range(boundedType= ... ) is only
 // necessary if we explicitly type the variable
 
 var rangeNegInfto1 = ..1; // ..., -4, -3, -2, -1, 0, 1
 
 // Ranges can be strided using the 'by' operator.
 var range2to10by2: range(stridable=true) = 2..10 by 2; // 2, 4, 6, 8, 10
-// Note: the range(stridable=true) is only 
+// Note: the range(stridable=true) is only
 // necessary if we explicitly type the variable
 
 // Use by to create a reverse range
@@ -275,9 +275,9 @@ var rangeCountBy: range(stridable=true) = -5..#12 by 2; // -5, -3, -1, 1, 3, 5
 writeln( rangeCountBy );
 
 // Can query properties of the range
-// Print the first index, last index, number of indices, 
+// Print the first index, last index, number of indices,
 // stride, and ask if 2 is include in the range
-writeln( ( rangeCountBy.first, rangeCountBy.last, rangeCountBy.length, 
+writeln( ( rangeCountBy.first, rangeCountBy.last, rangeCountBy.length,
            rangeCountBy.stride, rangeCountBy.member( 2 ) ) );
 
 for i in rangeCountBy{
@@ -307,9 +307,9 @@ var stringSet: domain(string); // empty set of strings
 stringSet += "a";
 stringSet += "b";
 stringSet += "c";
-stringSet += "a"; // Redundant add "a"  
+stringSet += "a"; // Redundant add "a"
 stringSet -= "c"; // Remove "c"
-writeln( stringSet ); 
+writeln( stringSet );
 
 // Both ranges and domains can be sliced to produce a range or domain with the
 // intersection of indices
@@ -332,13 +332,13 @@ var intArray2: [{1..10}] int; //equivalent
 for i in 1..10 do
   intArray[i] = -i;
 writeln( intArray );
-// We cannot access intArray[0] because it exists outside 
+// We cannot access intArray[0] because it exists outside
 // of the index set, {1..10}, we defined it to have.
 // intArray[11] is illegal for the same reason.
 
 var realDomain: domain(2) = {1..5,1..7};
 var realArray: [realDomain] real;
-var realArray2: [1..5,1..7] real;   // Equivalent 
+var realArray2: [1..5,1..7] real;   // Equivalent
 var realArray3: [{1..5,1..7}] real; // Equivalent
 
 for i in 1..5 {
@@ -350,8 +350,8 @@ for i in 1..5 {
 }
 
 // Arrays have domains as members that we can iterate over
-for idx in realArray.domain {  // Again, idx is a 2*int tuple 
-  realArray[idx] = 1 / realArray[idx[1],idx[2]]; // Access by tuple and list   
+for idx in realArray.domain {  // Again, idx is a 2*int tuple
+  realArray[idx] = 1 / realArray[idx[1],idx[2]]; // Access by tuple and list
 }
 
 writeln( realArray );
@@ -377,7 +377,7 @@ var thatArray : [{0..5}] int;
 // Simply assign one to the other.
 // This copies thisArray into thatArray, instead of just creating a reference.
 // Modifying thisArray does not also modify thatArray.
-thatArray = thisArray; 
+thatArray = thisArray;
 thatArray[1] = -1;
 writeln( (thisArray, thatArray) );
 
@@ -389,12 +389,12 @@ writeln( (thisArray, thatArray) );
 var thisPlusThat = thisArray + thatArray;
 writeln( thisPlusThat );
 
-// Arrays and loops can also be expressions, where loop 
+// Arrays and loops can also be expressions, where loop
 // body's expression is the result of each iteration.
 var arrayFromLoop = for i in 1..10 do i;
 writeln( arrayFromLoop );
 
-// An expression can result in nothing, 
+// An expression can result in nothing,
 // such as when filtering with an if-expression
 var evensOrFives = for i in 1..10 do if (i % 2 == 0 || i % 5 == 0) then i;
 
@@ -407,7 +407,7 @@ var evensOrFivesAgain = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i;
 // Or over the values of the array
 arrayFromLoop = [ value in arrayFromLoop ] value + 1;
 
-// Note: this notation can get somewhat tricky. For example: 
+// Note: this notation can get somewhat tricky. For example:
 // evensOrFives = [ i in 1..10 ] if (i % 2 == 0 || i % 5 == 0) then i;
 // would break.
 // The reasons for this are explained in depth when discussing zipped iterators.
@@ -431,7 +431,7 @@ proc addThree( n ) {
 doublePrint( addThree( fibonacci( 20 ) ) );
 
 // Can also take 'unlimited' number of parameters
-proc maxOf( x ...?k ) { 
+proc maxOf( x ...?k ) {
   // x refers to a tuple of one type, with k elements
   var maximum = x[1];
   for i in 2..k do maximum = if (maximum < x[i]) then x[i] else maximum;
@@ -439,7 +439,7 @@ proc maxOf( x ...?k ) {
 }
 writeln( maxOf( 1, -10, 189, -9071982, 5, 17, 20001, 42 ) );
 
-// The ? operator is called the query operator, and is used to take 
+// The ? operator is called the query operator, and is used to take
 // undetermined values (like tuple or array sizes, and generic types).
 
 // Taking arrays as parameters.
@@ -463,7 +463,7 @@ writeln( defaultsProc( x=11 ) );
 writeln( defaultsProc( x=12, y=5.432 ) );
 writeln( defaultsProc( y=9.876, x=13 ) );
 
-// Intent modifiers on the arguments convey how 
+// Intent modifiers on the arguments convey how
 // those arguments are passed to the procedure
 // in: copy arg in, but not out
 // out: copy arg out, but not in
@@ -489,18 +489,18 @@ writeln( "Outside After: ", (inVar, outVar, inoutVar, refVar) );
 // Similarly we can define intents on the return type
 // refElement returns a reference to an element of array
 proc refElement( array : [?D] ?T, idx ) ref : T {
-  return array[ idx ]; // returns a reference to 
+  return array[ idx ]; // returns a reference to
 }
 
 var myChangingArray : [1..5] int = [1,2,3,4,5];
 writeln( myChangingArray );
-// Store reference to element in ref variable 
-ref refToElem = refElement( myChangingArray, 5 ); 
+// Store reference to element in ref variable
+ref refToElem = refElement( myChangingArray, 5 );
 writeln( refToElem );
 refToElem = -2; // modify reference which modifies actual value in array
 writeln( refToElem );
 writeln( myChangingArray );
-// This makes more practical sense for class methods where references to 
+// This makes more practical sense for class methods where references to
 // elements in a data-structure are returned via a method or iterator
 
 // We can query the type of arguments to generic procedures
@@ -520,21 +520,21 @@ genericProc( 1.0+2.0i, 3.0+4.0i );
 
 // We can also enforce a form of polymorphism with the 'where' clause
 // This allows the compiler to decide which function to use.
-// Note: that means that all information needs to be known at compile-time. 
+// Note: that means that all information needs to be known at compile-time.
 // The param modifier on the arg is used to enforce this constraint.
 proc whereProc( param N : int ): void
  where ( N > 0 ) {
-  writeln( "N is greater than 0" );  
+  writeln( "N is greater than 0" );
 }
 
 proc whereProc( param N : int ): void
  where ( N < 0 ) {
-  writeln( "N is less than 0" );  
+  writeln( "N is less than 0" );
 }
 
 whereProc( 10 );
 whereProc( -1 );
-// whereProc( 0 ) would result in a compiler error because there 
+// whereProc( 0 ) would result in a compiler error because there
 // are no functions that satisfy the where clause's condition.
 // We could have defined a whereProc without a where clause that would then have
 // served as a catch all for all the other cases (of which there is only one).
@@ -543,7 +543,7 @@ whereProc( -1 );
 // We can define the unary operators:
 // + - ! ~
 // and the binary operators:
-// + - * / % ** == <= >= < > << >> & | ˆ by 
+// + - * / % ** == <= >= < > << >> & | ˆ by
 // += -= *= /= %= **= &= |= ˆ= <<= >>= <=>
 
 // Boolean exclusive or operator
@@ -569,14 +569,14 @@ Note: You could break everything if you get careless with your overloads.
 This here will break everything. Don't do it.
 proc +( left: int, right: int ): int{
   return left - right;
-} 
+}
 */
 
-// Iterators are a sisters to the procedure, and almost 
+// Iterators are a sisters to the procedure, and almost
 // everything about procedures also applies to iterators
-// However, instead of returning a single value, 
+// However, instead of returning a single value,
 // iterators yield many values to a loop.
-// This is useful when a complicated set or order of iterations is needed but 
+// This is useful when a complicated set or order of iterations is needed but
 // allows the code defining the iterations to be separate from the loop body.
 iter oddsThenEvens( N: int ): int {
   for i in 1..N by 2 do
@@ -601,15 +601,15 @@ for i in absolutelyNothing( 10 ){
   writeln( "Woa there! absolutelyNothing yielded ", i );
 }
 
-// We can zipper together two or more iterators (who have the same number 
-// of iterations)  using zip() to create a single zipped iterator, where each 
-// iteration of the zipped iterator yields a tuple of one value yielded 
+// We can zipper together two or more iterators (who have the same number
+// of iterations)  using zip() to create a single zipped iterator, where each
+// iteration of the zipped iterator yields a tuple of one value yielded
 // from each iterator.
                                  // Ranges have implicit iterators
-for (positive, negative) in zip( 1..5, -5..-1) do 
+for (positive, negative) in zip( 1..5, -5..-1) do
   writeln( (positive, negative) );
 
-// Zipper iteration is quite important in the assignment of arrays, 
+// Zipper iteration is quite important in the assignment of arrays,
 // slices of arrays, and array/loop expressions.
 var fromThatArray : [1..#5] int = [1,2,3,4,5];
 var toThisArray : [100..#5] int;
@@ -629,11 +629,11 @@ for (i, j) in zip( toThisArray.domain, -100..#5 ){
 }
 writeln( toThisArray );
 
-// This is all very important in undestanding why the statement 
+// This is all very important in undestanding why the statement
 // var iterArray : [1..10] int = [ i in 1..10 ] if ( i % 2 == 1 ) then j;
 // exhibits a runtime error.
-// Even though the domain of the array and the loop-expression are 
-// the same size, the body of the expression can be though of as an iterator.
+// Even though the domain of the array and the loop-expression are
+// the same size, the body of the expression can be thought of as an iterator.
 // Because iterators can yield nothing, that iterator yields a different number
 // of things than the domain of the array or loop, which is not allowed.
 
@@ -641,8 +641,8 @@ writeln( toThisArray );
 // They currently lack privatization
 class MyClass {
   // Member variables
-  var memberInt : int; 
-  var memberBool : bool = true; 
+  var memberInt : int;
+  var memberBool : bool = true;
 
   // Classes have default constructors that don't need to be coded (see below)
   // Our explicitly defined constructor
@@ -659,28 +659,28 @@ class MyClass {
   proc setMemberInt( val: int ){
     this.memberInt = val;
   }
-  
+
   proc setMemberBool( val: bool ){
     this.memberBool = val;
   }
 
-  proc getMemberInt( ): int{ 
+  proc getMemberInt( ): int{
     return this.memberInt;
   }
 
   proc getMemberBool( ): bool {
     return this.memberBool;
   }
-  
+
 }
-  
+
 // Construct using default constructor, using default values
 var myObject = new MyClass( 10 );
     myObject = new MyClass( memberInt = 10 ); // Equivalent
 writeln( myObject.getMemberInt( ) );
 // ... using our values
 var myDiffObject = new MyClass( -1, true );
-    myDiffObject = new MyClass( memberInt = -1, 
+    myDiffObject = new MyClass( memberInt = -1,
                                 memberBool = true ); // Equivalent
 writeln( myDiffObject );
 
@@ -689,7 +689,7 @@ var myOtherObject = new MyClass( 1.95 );
     myOtherObject = new MyClass( val = 1.95 ); // Equivalent
 writeln( myOtherObject.getMemberInt( ) );
 
-// We can define an operator on our class as well but 
+// We can define an operator on our class as well but
 // the definition has to be outside the class definition
 proc +( A : MyClass, B : MyClass) : MyClass {
   return new MyClass( memberInt = A.getMemberInt( ) + B.getMemberInt( ),
@@ -715,46 +715,46 @@ class GenericClass {
   type classType;
   var classDomain: domain(1);
   var classArray: [classDomain] classType;
-  
+
   // Explicit constructor
   proc GenericClass( type classType, elements : int ){
     this.classDomain = {1..#elements};
   }
-  
+
   // Copy constructor
-  // Note: We still have to put the type as an argument, but we can 
+  // Note: We still have to put the type as an argument, but we can
   // default to the type of the other object using the query (?) operator
   // Further, we can take advantage of this to allow our copy constructor
   // to copy classes of different types and cast on the fly
-  proc GenericClass( other : GenericClass(?otherType), 
+  proc GenericClass( other : GenericClass(?otherType),
                      type classType = otherType ) {
     this.classDomain = other.classDomain;
     // Copy and cast
-    for idx in this.classDomain do this[ idx ] = other[ idx ] : classType; 
+    for idx in this.classDomain do this[ idx ] = other[ idx ] : classType;
   }
-  
-  // Define bracket notation on a GenericClass 
+
+  // Define bracket notation on a GenericClass
   // object so it can behave like a normal array
   // i.e. objVar[ i ] or objVar( i )
   proc this( i : int ) ref : classType {
     return this.classArray[ i ];
   }
-  
-  // Define an implicit iterator for the class 
+
+  // Define an implicit iterator for the class
   // to yield values from the array to a loop
   // i.e. for i in objVar do ....
   iter these( ) ref : classType {
     for i in this.classDomain do
       yield this[i];
   }
-  
+
 }
 
 var realList = new GenericClass( real, 10 );
-// We can assign to the member array of the object using the bracket 
+// We can assign to the member array of the object using the bracket
 // notation that we defined ( proc this( i: int ){ ... }  )
 for i in realList.classDomain do realList[i] = i + 1.0;
-// We can iterate over the values in our list with the iterator 
+// We can iterate over the values in our list with the iterator
 // we defined ( iter these( ){ ... } )
 for value in realList do write( value, ", " );
 writeln( );
@@ -777,23 +777,23 @@ writeln( );
 module OurModule {
   // We can use modules inside of other modules.
   use Time; // Time is one of the standard modules.
-  
+
   // We'll use this procedure in the parallelism section.
   proc countdown( seconds: int ){
     for i in 1..seconds by -1 {
       writeln( i );
       sleep( 1 );
     }
-  } 
-  
-  // Submodules of OurModule 
+  }
+
+  // Submodules of OurModule
   // It is possible to create arbitrarily deep module nests.
   module ChildModule {
     proc foo(){
       writeln( "ChildModule.foo()");
     }
   }
-  
+
   module SiblingModule {
     proc foo(){
       writeln( "SiblingModule.foo()" );
@@ -806,7 +806,7 @@ module OurModule {
 use OurModule;
 
 // At this point we have not used ChildModule or SiblingModule so their symbols
-// (i.e. foo ) are not available to us. 
+// (i.e. foo ) are not available to us.
 // However, the module names are, and we can explicitly call foo() through them.
 SiblingModule.foo();         // Calls SiblingModule.foo()
 
@@ -821,13 +821,13 @@ foo();   // Less explicit call on ChildModule.foo()
 proc main(){
 
   // Parallelism
-  // In other languages, parallelism is typically done with 
+  // In other languages, parallelism is typically done with
   // complicated libraries and strange class structure hierarchies.
   // Chapel has it baked right into the language.
 
-  // A begin statement will spin the body of that statement off 
+  // A begin statement will spin the body of that statement off
   // into one new task.
-  // A sync statement will ensure that the progress of the main 
+  // A sync statement will ensure that the progress of the main
   // task will not progress until the children have synced back up.
   sync {
     begin { // Start of new task's body
@@ -848,7 +848,7 @@ proc main(){
     printFibb( 20 ); // new task
     printFibb( 10 ); // new task
     printFibb( 5 );  // new task
-    { 
+    {
       // This is a nested statement body and thus is a single statement
       // to the parent statement and is executed by a single task
       writeln( "this gets" );
@@ -867,26 +867,26 @@ proc main(){
   // NOTE! coforall should be used only for creating tasks!
   // Using it to iterating over a structure is very a bad idea!
 
-  // forall loops are another parallel loop, but only create a smaller number 
+  // forall loops are another parallel loop, but only create a smaller number
   // of tasks, specifically --dataParTasksPerLocale=number of task
   forall i in 1..100 {
     write( i, ", ");
   }
   writeln( );
-  // Here we see that there are sections that are in order, followed by 
+  // Here we see that there are sections that are in order, followed by
   // a section that would not follow ( e.g. 1, 2, 3, 7, 8, 9, 4, 5, 6, ).
   // This is because each task is taking on a chunk of the range 1..10
   // (1..3, 4..6, or 7..9) doing that chunk serially, but each task happens
   // in parallel.
   // Your results may depend on your machine and configuration
 
-  // For both the forall and coforall loops, the execution of the 
+  // For both the forall and coforall loops, the execution of the
   // parent task will not continue until all the children sync up.
 
   // forall loops are particularly useful for parallel iteration over arrays.
   // Lets run an experiment to see how much faster a parallel loop is
   use Time; // Import the Time module to use Timer objects
-  var timer: Timer; 
+  var timer: Timer;
   var myBigArray: [{1..4000,1..4000}] real; // Large array we will write into
 
   // Serial Experiment
@@ -906,7 +906,7 @@ proc main(){
   timer.stop( ); // Stop timer
   writeln( "Parallel: ", timer.elapsed( ) ); // Print elapsed time
   timer.clear( );
-  // You may have noticed that (depending on how many cores you have) 
+  // You may have noticed that (depending on how many cores you have)
   // that the parallel loop went faster than the serial loop
 
   // The bracket style loop-expression described
@@ -926,15 +926,15 @@ proc main(){
   writeln( uranium.read() );
 
   var replaceWith = 239;
-  var was = uranium.exchange( replaceWith ); 
+  var was = uranium.exchange( replaceWith );
   writeln( "uranium was ", was, " but is now ", replaceWith );
 
   var isEqualTo = 235;
   if ( uranium.compareExchange( isEqualTo, replaceWith ) ) {
-    writeln( "uranium was equal to ", isEqualTo, 
+    writeln( "uranium was equal to ", isEqualTo,
              " so replaced value with ", replaceWith );
   } else {
-    writeln( "uranium was not equal to ", isEqualTo, 
+    writeln( "uranium was not equal to ", isEqualTo,
              " so value stays the same...  whatever it was" );
   }
 
@@ -960,13 +960,13 @@ proc main(){
     begin { // Reader task
       writeln( "Reader: waiting to read." );
       var read_sync = someSyncVar$;
-      writeln( "value is ", read_sync );
+      writeln( "Reader: value is ", read_sync );
     }
 
     begin { // Writer task
       writeln( "Writer: will write in..." );
       countdown( 3 );
-      someSyncVar$ = 123;    
+      someSyncVar$ = 123;
     }
   }
 
@@ -989,14 +989,14 @@ proc main(){
     }
   }
 
-  // Heres an example of using atomics and a synch variable to create a 
+  // Heres an example of using atomics and a synch variable to create a
   // count-down mutex (also known as a multiplexer)
   var count: atomic int; // our counter
   var lock$: sync bool;   // the mutex lock
 
   count.write( 2 );       // Only let two tasks in at a time.
   lock$.writeXF( true );  // Set lock$ to full (unlocked)
-  // Note: The value doesnt actually matter, just the state 
+  // Note: The value doesnt actually matter, just the state
   // (full:unlocked / empty:locked)
   // Also, writeXF() fills (F) the sync var regardless of its state (X)
 
@@ -1005,10 +1005,10 @@ proc main(){
     do{
       lock$;                 // Read lock$ (wait)
     }while ( count.read() < 1 ); // Keep waiting until a spot opens up
-  
+
     count.sub(1);          // decrement the counter
     lock$.writeXF( true ); // Set lock$ to full (signal)
-  
+
     // Actual 'work'
     writeln( "Task #", task, " doing work." );
     sleep( 2 );
@@ -1027,13 +1027,13 @@ proc main(){
 
   // 'maxloc' gives max value and index of the max value
   // Note: We have to zip the array and domain together with the zip iterator
-  var (theMaxValue, idxOfMax) = maxloc reduce zip(listOfValues, 
+  var (theMaxValue, idxOfMax) = maxloc reduce zip(listOfValues,
                                                   listOfValues.domain);
-                                                
+
   writeln( (sumOfValues, maxValue, idxOfMax, listOfValues[ idxOfMax ] ) );
 
   // Scans apply the operation incrementally and return an array of the
-  // value of the operation at that index as it progressed through the 
+  // value of the operation at that index as it progressed through the
   // array from array.domain.low to array.domain.high
   var runningSumOfValues = + scan listOfValues;
   var maxScan = max scan listOfValues;
@@ -1046,14 +1046,14 @@ Who is this tutorial for?
 -------------------------
 
 This tutorial is for people who want to learn the ropes of chapel without having to hear about what fiber mixture the ropes are, or how they were braided, or how the braid configurations differ between one another.
-It won't teach you how to develop amazingly performant code, and it's not exhaustive. 
+It won't teach you how to develop amazingly performant code, and it's not exhaustive.
 Refer to the [language specification](http://chapel.cray.com/language.html) and the [module documentation](http://chapel.cray.com/docs/latest/) for more details.
 
 Occasionally check back here and on the [Chapel site](http://chapel.cray.com) to see if more topics have been added or more tutorials created.
 
 ### What this tutorial is lacking:
 
- * Exposition of the standard modules
+ * Exposition of the [standard modules](http://chapel.cray.com/docs/latest/modules/modules.html)
  * Multiple Locales (distributed memory system)
  * Records
  * Parallel iterators
@@ -1061,11 +1061,11 @@ Occasionally check back here and on the [Chapel site](http://chapel.cray.com) to
 Your input, questions, and discoveries are important to the developers!
 -----------------------------------------------------------------------
 
-The Chapel language is still in-development (version 1.11.0), so there are occasional hiccups with performance and language features.
+The Chapel language is still in-development (version 1.12.0), so there are occasional hiccups with performance and language features.
 The more information you give the Chapel development team about issues you encounter or features you would like to see, the better the language becomes.
 Feel free to email the team and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman).
 
-If you're really interested in the development of the compiler or contributing to the project, 
+If you're really interested in the development of the compiler or contributing to the project,
 [check out the master Github repository](https://github.com/chapel-lang/chapel).
 It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).
 
@@ -1074,14 +1074,14 @@ Installing the Compiler
 
 Chapel can be built and installed on your average 'nix machine (and cygwin).
 [Download the latest release version](https://github.com/chapel-lang/chapel/releases/)
-and its as easy as 
+and it's as easy as
 
- 1. `tar -xvf chapel-1.11.0.tar.gz`
- 2. `cd chapel-1.11.0`
+ 1. `tar -xvf chapel-1.12.0.tar.gz`
+ 2. `cd chapel-1.12.0`
  3. `make`
  4. `source util/setchplenv.bash # or .sh or .csh or .fish`
 
-You will need to `source util/setchplenv.EXT` from within the Chapel directory (`$CHPL_HOME`) every time your terminal starts so its suggested that you drop that command in a script that will get executed on startup (like .bashrc).
+You will need to `source util/setchplenv.EXT` from within the Chapel directory (`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop that command in a script that will get executed on startup (like .bashrc).
 
 Chapel is easily installed with Brew for OS X
 
@@ -1100,4 +1100,4 @@ Notable arguments:
  * `--fast`: enables a number of optimizations and disables array bounds checks. Should only enable when application is stable.
  * `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>` at compile-time.
  * `--main-module <Module Name>`: use the main() procedure found in the module `<Module Name>` as the executable's main.
- * `--module-dir <Directory>`: includes `<Directory>` in the module search path.
\ No newline at end of file
+ * `--module-dir <Directory>`: includes `<Directory>` in the module search path.
diff --git a/clojure-macros.html.markdown b/clojure-macros.html.markdown
index 9e907a7f..d74f77cf 100644
--- a/clojure-macros.html.markdown
+++ b/clojure-macros.html.markdown
@@ -142,11 +142,11 @@ You'll want to be familiar with Clojure. Make sure you understand everything in
 
 ### Further Reading
 
-Writing Macros from [Clojure for the Brave and True](http://www.braveclojure.com/)  
+Writing Macros from [Clojure for the Brave and True](http://www.braveclojure.com/)
 [http://www.braveclojure.com/writing-macros/](http://www.braveclojure.com/writing-macros/)
 
-Official docs  
+Official docs
 [http://clojure.org/macros](http://clojure.org/macros)
 
-When to use macros?  
+When to use macros?
 [http://dunsmor.com/lisp/onlisp/onlisp_12.html](http://dunsmor.com/lisp/onlisp/onlisp_12.html)
diff --git a/clojure.html.markdown b/clojure.html.markdown
index a125d18f..58e835c9 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -264,6 +264,31 @@ keymap ; => {:a 1, :b 2, :c 3}
   (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} 
+   (assoc :c 3) ;=> (assoc {:a 1 :b 2} :c 3)
+   (dissoc :b)) ;=> (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+
+; This expression could be written as:
+; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; and evaluates to {:a 1 :c 3}
+
+; 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))
+   (into []))    ;=> (into [] (filter odd? (map inc (range 10)))
+                 ; Result: [1 3 5 7 9]
+
 ; Modules
 ;;;;;;;;;;;;;;;
 
diff --git a/coffeescript.html.markdown b/coffeescript.html.markdown
index 4c080bc6..89a29677 100644
--- a/coffeescript.html.markdown
+++ b/coffeescript.html.markdown
@@ -6,8 +6,8 @@ contributors:
 filename: coffeescript.coffee
 ---
 
-CoffeeScript is a little language that compiles one-to-one into the equivalent JavaScript, and there is no interpretation at runtime. 
-As one of the succeeders of JavaScript, CoffeeScript tries its best to output readable, pretty-printed and smooth-running JavaScript codes working well in every JavaScript runtime.
+CoffeeScript is a little language that compiles one-to-one into the equivalent JavaScript, and there is no interpretation at runtime.
+As one of the successors to JavaScript, CoffeeScript tries its best to output readable, pretty-printed and smooth-running JavaScript code, which works well in every JavaScript runtime.
 
 See also [the CoffeeScript website](http://coffeescript.org/), which has a complete tutorial on CoffeeScript.
 
@@ -54,35 +54,35 @@ math =
   square: square
   cube:   (x) -> x * square x
 #=> var math = {
-#  "root": Math.sqrt,
-#  "square": square,
-#  "cube": function(x) { return x * square(x); }
-#}
+#    "root": Math.sqrt,
+#    "square": square,
+#    "cube": function(x) { return x * square(x); }
+#   };
 
 # Splats:
 race = (winner, runners...) ->
   print winner, runners
 #=>race = function() {
-#  var runners, winner;
-#  winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
-#  return print(winner, runners);
-#};
+#    var runners, winner;
+#    winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#    return print(winner, runners);
+#  };
 
 # Existence:
 alert "I knew it!" if elvis?
 #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
 
 # Array comprehensions:
-cubes = (math.cube num for num in list) 
+cubes = (math.cube num for num in list)
 #=>cubes = (function() {
-#	var _i, _len, _results;
-#	_results = [];
+#	  var _i, _len, _results;
+#	  _results = [];
 # 	for (_i = 0, _len = list.length; _i < _len; _i++) {
-#		num = list[_i];
-#		_results.push(math.cube(num));
-#	}
-#	return _results;
-#  })();
+#		  num = list[_i];
+#		  _results.push(math.cube(num));
+#	  }
+#	  return _results;
+# })();
 
 foods = ['broccoli', 'spinach', 'chocolate']
 eat food for food in foods when food isnt 'chocolate'
diff --git a/coldfusion.html.markdown b/coldfusion.html.markdown
new file mode 100644
index 00000000..70804a1e
--- /dev/null
+++ b/coldfusion.html.markdown
@@ -0,0 +1,321 @@
+---
+language: coldfusion
+filename: learncoldfusion.cfm
+contributors:
+    - ["Wayne Boka", "http://wboka.github.io"]
+---
+
+ColdFusion is a scripting language for web development.
+[Read more here.](http://www.adobe.com/products/coldfusion-family.html)
+
+```html
+
+<em>HTML tags have been provided for output readability</em>
+
+<!--- Comments start with "<!---" and end with "--->" --->
+<!---
+    Comments can
+    also
+    span
+    multiple lines
+--->
+
+<!--- CFML tags have a similar format to HTML tags. --->
+<h1>Simple Variables</h1>
+<!--- Variable Declaration: Variables are loosely typed, similar to javascript --->
+<p>Set <b>myVariable</b> to "myValue"</p>
+<cfset myVariable = "myValue" />
+<p>Set <b>myNumber</b> to 3.14</p>
+<cfset myNumber = 3.14 />
+
+<!--- Displaying simple data --->
+<!--- Use <cfoutput> for simple values such as strings, numbers, and expressions --->
+<p>Display <b>myVariable</b>: <cfoutput>#myVariable#</cfoutput></p><!--- myValue --->
+<p>Display <b>myNumber</b>: <cfoutput>#myNumber#</cfoutput></p><!--- 3.14 --->
+
+<hr />
+
+<h1>Complex Variables</h1>
+<!--- Declaring complex variables --->
+<!--- Declaring an array of 1 dimension: literal or bracket notation --->
+<p>Set <b>myArray1</b> to an array of 1 dimension using literal or bracket notation</p>
+<cfset myArray1 = [] />
+<!--- Declaring an array of 1 dimension: function notation --->
+<p>Set <b>myArray2</b> to an array of 1 dimension using function notation</p>
+<cfset myArray2 = ArrayNew(1) />
+
+<!--- Outputting complex variables --->
+<p>Contents of <b>myArray1</b></p>
+<cfdump var="#myArray1#" /> <!--- An empty array object --->
+<p>Contents of <b>myArray2</b></p>
+<cfdump var="#myArray2#" /> <!--- An empty array object --->
+
+<!--- Operators --->
+<!--- Arithmetic --->
+<h1>Operators</h1>
+<h2>Arithmetic</h2>
+<p>1 + 1 = <cfoutput>#1 + 1#</cfoutput></p>
+<p>10 - 7 = <cfoutput>#10 - 7#<br /></cfoutput></p>
+<p>15 * 10 = <cfoutput>#15 * 10#<br /></cfoutput></p>
+<p>100 / 5 = <cfoutput>#100 / 5#<br /></cfoutput></p>
+<p>120 % 5 = <cfoutput>#120 % 5#<br /></cfoutput></p>
+<p>120 mod 5 = <cfoutput>#120 mod 5#<br /></cfoutput></p>
+
+<hr />
+
+<!--- Comparison --->
+<h2>Comparison</h2>
+<h3>Standard Notation</h3>
+<p>Is 1 eq 1? <cfoutput>#1 eq 1#</cfoutput></p>
+<p>Is 15 neq 1? <cfoutput>#15 neq 1#</cfoutput></p>
+<p>Is 10 gt 8? <cfoutput>#10 gt 8#</cfoutput></p>
+<p>Is 1 lt 2? <cfoutput>#1 lt 2#</cfoutput></p>
+<p>Is 10 gte 5? <cfoutput>#10 gte 5#</cfoutput></p>
+<p>Is 1 lte 5? <cfoutput>#1 lte 5#</cfoutput></p>
+
+<h3>Alternative Notation</h3>
+<p>Is 1 == 1? <cfoutput>#1 eq 1#</cfoutput></p>
+<p>Is 15 != 1? <cfoutput>#15 neq 1#</cfoutput></p>
+<p>Is 10 > 8? <cfoutput>#10 gt 8#</cfoutput></p>
+<p>Is 1 < 2? <cfoutput>#1 lt 2#</cfoutput></p>
+<p>Is 10 >= 5? <cfoutput>#10 gte 5#</cfoutput></p>
+<p>Is 1 <= 5? <cfoutput>#1 lte 5#</cfoutput></p>
+
+<hr />
+
+<!--- Control Structures --->
+<h1>Control Structures</h1>
+
+<cfset myCondition = "Test" />
+
+<p>Condition to test for: "<cfoutput>#myCondition#</cfoutput>"</p>
+
+<cfif myCondition eq "Test">
+    <cfoutput>#myCondition#. We're testing.</cfoutput>
+<cfelseif myCondition eq "Production">
+    <cfoutput>#myCondition#. Proceed Carefully!!!</cfoutput>
+<cfelse>
+    myCondition is unknown
+</cfif>
+
+<hr />
+
+<!--- Loops --->
+<h1>Loops</h1>
+<h2>For Loop</h2>
+<cfloop from="0" to="10" index="i">
+	<p>Index equals <cfoutput>#i#</cfoutput></p>
+</cfloop>
+
+<h2>For Each Loop (Complex Variables)</h2>
+
+<p>Set <b>myArray3</b> to [5, 15, 99, 45, 100]</p>
+
+<cfset myArray3 = [5, 15, 99, 45, 100] />
+
+<cfloop array="#myArray3#" index="i">
+	<p>Index equals <cfoutput>#i#</cfoutput></p>
+</cfloop>
+
+<p>Set <b>myArray4</b> to ["Alpha", "Bravo", "Charlie", "Delta", "Echo"]</p>
+
+<cfset myArray4 = ["Alpha", "Bravo", "Charlie", "Delta", "Echo"] />
+
+<cfloop array="#myArray4#" index="s">
+	<p>Index equals <cfoutput>#s#</cfoutput></p>
+</cfloop>
+
+<h2>Switch Statement</h2>
+
+<p>Set <b>myArray5</b> to [5, 15, 99, 45, 100]</p>
+
+<cfset myArray5 = [5, 15, 99, 45, 100] />
+
+<cfloop array="#myArray5#" index="i">
+	<cfswitch expression="#i#">
+		<cfcase value="5,15,45" delimiters=",">
+			<p><cfoutput>#i#</cfoutput> is a multiple of 5.</p>
+		</cfcase>
+		<cfcase value="99">
+			<p><cfoutput>#i#</cfoutput> is ninety-nine.</p>
+		</cfcase>
+		<cfdefaultcase>
+			<p><cfoutput>#i#</cfoutput> is not 5, 15, 45, or 99.</p>
+		</cfdefaultcase> 
+	</cfswitch> 
+</cfloop>
+
+<hr />
+
+<h1>Converting types</h1>
+
+<style>
+	table.table th, table.table td {
+		border: 1px solid #000000;
+		padding: 2px;
+	}
+	
+	table.table th {
+		background-color: #CCCCCC;
+	}
+</style>
+
+<table class="table" cellspacing="0">
+	<thead>
+		<tr>
+			<th>Value</th>
+			<th>As Boolean</th>
+			<th>As number</th>
+			<th>As date-time</th>
+			<th>As string</th>
+		</tr>
+	</thead>
+	<tbody>
+		<tr>
+			<th>"Yes"</th>
+			<td>TRUE</td>
+			<td>1</td>
+			<td>Error</td>
+			<td>"Yes"</td>
+		</tr>
+		<tr>
+			<th>"No"</th>
+			<td>FALSE</td>
+			<td>0</td>
+			<td>Error</td>
+			<td>"No"</td>
+		</tr>
+		<tr>
+			<th>TRUE</th>
+			<td>TRUE</td>
+			<td>1</td>
+			<td>Error</td>
+			<td>"Yes"</td>
+		</tr>
+		<tr>
+			<th>FALSE</th>
+			<td>FALSE</td>
+			<td>0</td>
+			<td>Error</td>
+			<td>"No"</td>
+		</tr>
+		<tr>
+			<th>Number</th>
+			<td>True if Number is not 0; False otherwise.</td>
+			<td>Number</td>
+			<td>See &#34;Date-time values&#34; earlier in this chapter.</td>
+			<td>String representation of the number (for example, &#34;8&#34;).</td>
+		</tr>
+		<tr>
+			<th>String</th>
+			<td>If "Yes", True <br>If "No", False <br>If it can be converted to 0, False <br>If it can be converted to any other number, True</td>
+			<td>If it represents a number (for example, &#34;1,000&#34; or &#34;12.36E-12&#34;), it is converted to the corresponding number.</td>
+			<td>If it represents a date-time (see next column), it is converted to the numeric value of the corresponding date-time object. <br>If it is an ODBC date, time, or timestamp (for example &#34;{ts &#39;2001-06-14 11:30:13&#39;}&#34;, or if it is expressed in a standard U.S. date or time format, including the use of full or abbreviated month names, it is converted to the corresponding date-time value. <br>Days of the week or unusual punctuation result in an error. <br>Dashes, forward-slashes, and spaces are generally allowed.</td>
+			<td>String</td>
+		</tr>
+		<tr>
+			<th>Date</th>
+			<td>Error</td>
+			<td>The numeric value of the date-time object.</td>
+			<td>Date</td>
+			<td>An ODBC timestamp.</td>
+		</tr>
+	</tbody>
+</table>
+
+<hr />
+
+<h1>Components</h1>
+
+<em>Code for reference (Functions must return something to support IE)</em>
+
+<pre>
+&lt;cfcomponent&gt;
+	&lt;cfset this.hello = "Hello" /&gt;
+	&lt;cfset this.world = "world" /&gt;
+
+	&lt;cffunction name="sayHello"&gt;
+		&lt;cfreturn this.hello & ", " & this.world & "!" /&gt;
+	&lt;/cffunction&gt;
+	
+	&lt;cffunction name="setHello"&gt;
+		&lt;cfargument name="newHello" type="string" required="true" /&gt;
+		
+		&lt;cfset this.hello = arguments.newHello /&gt;
+		 
+		&lt;cfreturn true /&gt;
+	&lt;/cffunction&gt;
+	
+	&lt;cffunction name="setWorld"&gt;
+		&lt;cfargument name="newWorld" type="string" required="true" /&gt;
+		
+		&lt;cfset this.world = arguments.newWorld /&gt;
+		 
+		&lt;cfreturn true /&gt;
+	&lt;/cffunction&gt;
+	
+	&lt;cffunction name="getHello"&gt;
+		&lt;cfreturn this.hello /&gt;
+	&lt;/cffunction&gt;
+	
+	&lt;cffunction name="getWorld"&gt;
+		&lt;cfreturn this.world /&gt;
+	&lt;/cffunction&gt;
+&lt;/cfcomponent&gt;
+</pre>
+
+<cfset this.hello = "Hello" />
+<cfset this.world = "world" />
+
+<cffunction name="sayHello">
+	<cfreturn this.hello & ", " & this.world & "!" />
+</cffunction>
+
+<cffunction name="setHello">
+	<cfargument name="newHello" type="string" required="true" />
+	
+	<cfset this.hello = arguments.newHello />
+	 
+	<cfreturn true />
+</cffunction>
+
+<cffunction name="setWorld">
+	<cfargument name="newWorld" type="string" required="true" />
+	
+	<cfset this.world = arguments.newWorld />
+	 
+	<cfreturn true />
+</cffunction>
+
+<cffunction name="getHello">
+	<cfreturn this.hello />
+</cffunction>
+
+<cffunction name="getWorld">
+	<cfreturn this.world />
+</cffunction>
+
+
+<b>sayHello()</b>
+<cfoutput><p>#sayHello()#</p></cfoutput>
+<b>getHello()</b>
+<cfoutput><p>#getHello()#</p></cfoutput>
+<b>getWorld()</b>
+<cfoutput><p>#getWorld()#</p></cfoutput>
+<b>setHello("Hola")</b>
+<cfoutput><p>#setHello("Hola")#</p></cfoutput>
+<b>setWorld("mundo")</b>
+<cfoutput><p>#setWorld("mundo")#</p></cfoutput>
+<b>sayHello()</b>
+<cfoutput><p>#sayHello()#</p></cfoutput>
+<b>getHello()</b>
+<cfoutput><p>#getHello()#</p></cfoutput>
+<b>getWorld()</b>
+<cfoutput><p>#getWorld()#</p></cfoutput>
+```
+
+## Further Reading
+
+The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples.
+
+1. [Coldfusion Reference From Adobe](https://helpx.adobe.com/coldfusion/cfml-reference/topics.html)
diff --git a/common-lisp.html.markdown b/common-lisp.html.markdown
index f9f64d68..63183c1e 100644
--- a/common-lisp.html.markdown
+++ b/common-lisp.html.markdown
@@ -175,7 +175,8 @@ nil                  ; for false - and the empty list
               :age 5))
 *rover* ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5)
 
-(dog-p *rover*) ; => t  ;; ewww)
+(dog-p *rover*) ; => true  #| -p signifies "predicate". It's used to
+                              check if *rover* is an instance of dog. |#
 (dog-name *rover*) ; => "rover"
 
 ;; Dog-p, make-dog, and dog-name are all created by defstruct!
@@ -260,7 +261,7 @@ nil                  ; for false - and the empty list
 
 (defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3)
       :adjustable t :fill-pointer t))
-      
+
 *adjvec* ; => #(1 2 3)
 
 ;; Adding new element:
diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 11c8a654..6d2fd1eb 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -48,7 +48,7 @@ Poznámka: Tento článek je zaměřen na Python 3. Zde se můžete [naučit sta
 -5 // 3      # => -2
 -5.0 // 3.0  # => -2.0
 
-# Pokud použiteje desetinné číslo, výsledek je jím také
+# Pokud použijete desetinné číslo, výsledek je jím také
 3 * 2.0  # => 6.0
 
 # Modulo
@@ -420,7 +420,7 @@ next(iterator)  # Vyhodí StopIteration
 ## 4. Funkce
 ####################################################
 
-# Pro vytvoření nové funkce použijte def
+# Pro vytvoření nové funkce použijte klíčové slovo def
 def secist(x, y):
     print("x je {} a y je {}".format(x, y))
     return x + y  # Hodnoty se vrací pomocí return
@@ -520,7 +520,7 @@ class Clovek(object):
     # podtržítka na začátku a na konci značí, že se jedná o atribut nebo
     # objekt využívaný Pythonem ke speciálním účelům, ale můžete sami
     # definovat jeho chování. Metody jako __init__, __str__, __repr__
-    # a další se nazývají "magické metody". Nikdy nepoužívejte toto
+    # a další se nazývají "magické metody". Nikdy nepoužívejte toto
     # speciální pojmenování pro běžné metody.
     def __init__(self, jmeno):
         # Přiřazení parametru do atributu instance jmeno
diff --git a/csharp.html.markdown b/csharp.html.markdown
index 479b7f01..dfdd98de 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -6,6 +6,8 @@ contributors:
     - ["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"]
 filename: LearnCSharp.cs
 ---
 
@@ -25,7 +27,7 @@ Multi-line comments look like this
 //public void MethodOrClassOrOtherWithParsableHelp() {}
 
 // Specify the namespaces this source code will be using
-// The namespaces below are all part of the standard .NET Framework Class Libary 
+// The namespaces below are all part of the standard .NET Framework Class Libary
 using System;
 using System.Collections.Generic;
 using System.Dynamic;
@@ -48,7 +50,7 @@ namespace Learning.CSharp
     public class LearnCSharp
     {
         // BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before
-        public static void Syntax() 
+        public static void Syntax()
         {
             // Use Console.WriteLine to print lines
             Console.WriteLine("Hello World");
@@ -159,7 +161,7 @@ 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 }; // intialize
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // initialize
             // The <> are for generics - Check out the cool stuff section
 
             // Lists don't default to a value;
@@ -236,7 +238,8 @@ on a new line! ""Wow!"", the masses cried";
             // Ternary operators
             // A simple if/else can be written as follows
             // <condition> ? <true> : <false>
-            string isTrue = (true) ? "True" : "False";
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
 
             // While loop
             int fooWhile = 0;
@@ -370,11 +373,11 @@ on a new line! ""Wow!"", the masses cried";
         //
         // INTERESTING FEATURES
         //
-        
+
         // DEFAULT METHOD SIGNATURES
 
         public // Visibility
-        static // Allows for direct call on class without object 
+        static // Allows for direct call on class without object
         int // Return Type,
         MethodSignatures(
             int maxCount, // First variable, expects an int
@@ -382,7 +385,7 @@ on a new line! ""Wow!"", the masses cried";
             int another = 3,
             params string[] otherParams // captures all other parameters passed to method
         )
-        { 
+        {
             return -1;
         }
 
@@ -392,6 +395,7 @@ on a new line! ""Wow!"", the masses cried";
             ref int maxCount, // Pass by reference
             out int count)
         {
+            //the argument passed in as 'count' will hold the value of 15 outside of this function
             count = 15; // out param must be assigned before control leaves the method
         }
 
@@ -399,8 +403,8 @@ on a new line! ""Wow!"", the masses cried";
         // The classes for TKey and TValue is specified by the user calling this function.
         // This method emulates the SetDefault of Python
         public static TValue SetDefault<TKey, TValue>(
-            IDictionary<TKey, TValue> dictionary, 
-            TKey key, 
+            IDictionary<TKey, TValue> dictionary,
+            TKey key,
             TValue defaultItem)
         {
             TValue result;
@@ -409,7 +413,7 @@ on a new line! ""Wow!"", the masses cried";
             return result;
         }
 
-        // You can narrow down the objects that are passed in 
+        // You can narrow down the objects that are passed in
         public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
         {
             // We can iterate, since T is a IEnumerable
@@ -417,12 +421,48 @@ on a new line! ""Wow!"", the masses cried";
                 // Item is an int
                 Console.WriteLine(item.ToString());
         }
+        
+        // YIELD
+        // Usage of the "yield" keyword indicates that the method it appears in is an Iterator
+        // (this means you can use it in a foreach loop)
+        public static IEnumerable<int> YieldCounter(int limit = 10)
+        {
+            for (var i = 0; i < limit; i++)
+                yield return i;
+        }
+
+        // which you would call like this :
+        public static void PrintYieldCounterToConsole()
+        {
+            foreach (var counter in YieldCounter())
+                Console.WriteLine(counter);
+        }
+        
+        // you can use more than one "yield return" in a method
+        public static IEnumerable<int> ManyYieldCounter()
+        {
+            yield return 0;
+            yield return 1;
+            yield return 2;
+            yield return 3;
+        }
+        
+        // you can also use "yield break" to stop the Iterator
+        // this method would only return half of the values from 0 to limit.
+        public static IEnumerable<int> YieldCounterWithBreak(int limit = 10)
+        {
+            for (var i = 0; i < limit; i++)
+            {
+                if (i > limit/2) yield break;
+                yield return i;
+            }
+        }             
 
         public static void OtherInterestingFeatures()
         {
             // OPTIONAL PARAMETERS
             MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
-            MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
+            MethodSignatures(3, another: 3); // explicitly set a parameter, skipping optional ones
 
             // BY REF AND OUT PARAMETERS
             int maxCount = 0, count; // ref params must have value
@@ -442,6 +482,9 @@ on a new line! ""Wow!"", the masses cried";
             // ?? is syntactic sugar for specifying default value (coalesce)
             // in case variable is null
             int notNullable = nullable ?? 0; // 0
+            
+            // ?. is an operator for null-propagation - a shorthand way of checking for null
+            nullable?.Print(); // Use the Print() extension method if nullable isn't null
 
             // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
             var magic = "magic is a string, at compile time, so you still get type safety";
@@ -449,13 +492,13 @@ on a new line! ""Wow!"", the masses cried";
 
             // GENERICS
             //
-            var phonebook = new Dictionary<string, string>() { 
+            var phonebook = new Dictionary<string, string>() {
                 {"Sarah", "212 555 5555"} // Add some entries to the phone book
             };
 
             // Calling SETDEFAULT defined as a generic above
             Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
-            // nb, you don't need to specify the TKey and TValue since they can be 
+            // nb, you don't need to specify the TKey and TValue since they can be
             // derived implicitly
             Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
 
@@ -490,26 +533,26 @@ on a new line! ""Wow!"", the masses cried";
 
             // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily.
             // Most of objects that access unmanaged resources (file handle, device contexts, etc.)
-            // implement the IDisposable interface. The using statement takes care of 
+            // implement the IDisposable interface. The using statement takes care of
             // cleaning those IDisposable objects for you.
             using (StreamWriter writer = new StreamWriter("log.txt"))
             {
                 writer.WriteLine("Nothing suspicious here");
                 // At the end of scope, resources will be released.
                 // Even if an exception is thrown.
-            } 
+            }
 
             // PARALLEL FRAMEWORK
             // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
-            var websites = new string[] { 
-                "http://www.google.com", "http://www.reddit.com", 
+            var websites = new string[] {
+                "http://www.google.com", "http://www.reddit.com",
                 "http://www.shaunmccarthy.com"
             };
             var responses = new Dictionary<string, string>();
-            
+
             // Will spin up separate threads for each request, and join on them
             // before going to the next step!
-            Parallel.ForEach(websites, 
+            Parallel.ForEach(websites,
                 new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
                 website =>
             {
@@ -533,7 +576,7 @@ on a new line! ""Wow!"", the masses cried";
                 (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
             Console.WriteLine(student.Introduce("Beth"));
 
-            // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of 
+            // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
             // very useful Map / Filter / Reduce style methods
             var bikes = new List<Bicycle>();
             bikes.Sort(); // Sorts the array
@@ -555,8 +598,8 @@ on a new line! ""Wow!"", the masses cried";
             // ASPARALLEL
             // And this is where things get wicked - combines linq and parallel operations
             var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
-            // this will happen in parallel! Threads will automagically be spun up and the 
-            // results divvied amongst them! Amazing for large datasets when you have lots of 
+            // this will happen in parallel! Threads will automagically be spun up and the
+            // results divvied amongst them! Amazing for large datasets when you have lots of
             // cores
 
             // LINQ - maps a store to IQueryable<T> objects, with delayed execution
@@ -574,9 +617,9 @@ on a new line! ""Wow!"", the masses cried";
                 .Select(b => b.Name); // still no query run
 
             // Now the query runs, but opens a reader, so only populates are you iterate through
-            foreach (string bike in query) 
+            foreach (string bike in query)
                 Console.WriteLine(result);
-            
+
 
 
         }
@@ -609,7 +652,7 @@ on a new line! ""Wow!"", the masses cried";
             {
                 return _cadence;
             }
-            set // set - define a method to set a proprety
+            set // set - define a method to set a property
             {
                 _cadence = value; // Value is the value passed in to the setter
             }
@@ -628,7 +671,7 @@ on a new line! ""Wow!"", the masses cried";
             private set; // You can set modifiers on the get/set methods
         }
 
-        int _speed; // Everything is private by default: Only accessible from within this class. 
+        int _speed; // Everything is private by default: Only accessible from within this class.
                     // can also use keyword private
         public string Name { get; set; }
 
@@ -675,7 +718,7 @@ on a new line! ""Wow!"", the masses cried";
 
         // Constructors are a way of creating classes
         // This is a default constructor
-        public Bicycle() 
+        public Bicycle()
         {
             this.Gear = 1; // you can access members of the object with the keyword this
             Cadence = 50;  // but you don't always need it
@@ -687,13 +730,13 @@ on a new line! ""Wow!"", the masses cried";
 
         // This is a specified constructor (it contains arguments)
         public Bicycle(int startCadence, int startSpeed, int startGear,
-                       string name, bool hasCardsInSpokes, BikeBrand brand) 
+                       string name, bool hasCardsInSpokes, BikeBrand brand)
             : base() // calls base first
         {
-            Gear = startGear; 
+            Gear = startGear;
             Cadence = startCadence;
             _speed = startSpeed;
-            Name = name; 
+            Name = name;
             _hasCardsInSpokes = hasCardsInSpokes;
             Brand = brand;
         }
@@ -749,7 +792,7 @@ on a new line! ""Wow!"", the masses cried";
 
         // It's also possible to define custom Indexers on objects.
         // All though this is not entirely useful in this example, you
-        // could do bicycle[0] which yields "chris" to get the first passenger or
+        // could do bicycle[0] which returns "chris" to get the first passenger or
         // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle)
         private string[] passengers = { "chris", "phil", "darren", "regina" };
 
@@ -760,7 +803,7 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             set {
-                return passengers[i] = value;
+                passengers[i] = value;
             }
         }
 
@@ -836,7 +879,8 @@ on a new line! ""Wow!"", the masses cried";
         bool Broken { get; } // interfaces can contain properties as well as methods & events
     }
 
-    // Class can inherit only one other class, but can implement any amount of interfaces
+    // Class can inherit only one other class, but can implement any amount of interfaces, however
+    // the base class name must be the first in the list and all interfaces follow
     class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
@@ -856,7 +900,7 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     /// <summary>
-    /// Used to connect to DB for LinqToSql example. 
+    /// Used to connect to DB for LinqToSql example.
     /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
     /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
     /// </summary>
@@ -869,19 +913,48 @@ on a new line! ""Wow!"", the masses cried";
 
         public DbSet<Bicycle> Bikes { get; set; }
     }
+    
+    // Classes can be split across multiple .cs files
+    // A1.cs
+    public partial class A 
+    {
+        public 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");
+        }
+    }
+    
+    // Program using the partial class "A"
+    public class Program 
+    {
+        static void Main()
+        {
+            A.A1();
+            A.A2();
+        }
+    }
 } // End Namespace
 ```
 
 ## Topics Not Covered
 
  * Attributes
- * async/await, yield, pragma directives
+ * async/await, pragma directives
  * Web Development
  	* ASP.NET MVC & WebApi (new)
  	* ASP.NET Web Forms (old)
  	* WebMatrix (tool)
  * Desktop Development
- 	* Windows Presentation Foundation (WPF) (new) 
+ 	* Windows Presentation Foundation (WPF) (new)
  	* Winforms (old)
 
 ## Further Reading
diff --git a/css.html.markdown b/css.html.markdown
index 7224d80a..d8f30ca3 100644
--- a/css.html.markdown
+++ b/css.html.markdown
@@ -4,25 +4,21 @@ 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"]
 filename: learncss.css
 ---
 
-In the early days of the web there were no visual elements, just pure text. But with the  
-further development of browsers, fully visual web pages also became common.   
-CSS is the standard language that exists to keep the separation between   
-the content (HTML) and the look-and-feel of web pages.
+In the early days of the web there were no visual elements, just pure text. But with further development of web browsers, fully visual web pages also became common.
 
-In short, what CSS does is to provide a syntax that enables you to target   
-different elements on an HTML page and assign different visual properties to them.
+CSS helps maintain separation between the content (HTML) and the look-and-feel of a web page.
 
-Like any other languages, CSS has many versions. Here we focus on CSS2.0,   
-which is not the most recent version, but is the most widely supported and compatible version.
+CSS lets you target different elements on an HTML page and assign different visual properties to them.
 
-**NOTE:** Because the outcome of CSS consists of visual effects, in order to 
-learn it, you need try everything in a 
-CSS playground like [dabblet](http://dabblet.com/).
-The main focus of this article is on the syntax and some general tips.
+This guide has been written for CSS 2, though CSS 3 is fast becoming popular.
 
+**NOTE:** Because CSS produces visual results, in order to learn it, you need try everything in a CSS playground like [dabblet](http://dabblet.com/).
+The main focus of this article is on the syntax and some general tips.
 
 ```css
 /* comments appear inside slash-asterisk, just like this line!
@@ -32,92 +28,103 @@ The main focus of this article is on the syntax and some general tips.
    ## SELECTORS
    #################### */
 
-/* Generally, the primary statement in CSS is very simple */
+/* the selector is used to target an element on a page.
 selector { property: value; /* more properties...*/ }
 
-/* the selector is used to target an element on page.
-
-You can target all elements on the page using asterisk! */
-* { color:red; }
-
 /*
-Given an element like this on the page:
+Here is an example element:
 
-<div class='some-class class2' id='someId' attr='value' otherAttr='en-us foo bar' />
+<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
 */
 
-/* you can target it by its name */
-.some-class { }
+/* You can target it using one of its CSS classes */
+.class1 { }
 
-/* or by both classes! */
-.some-class.class2 { }
+/* or both classes! */
+.class1.class2 { }
 
-/* or by its element name */
+/* or its name */
 div { }
 
 /* or its id */
-#someId { }
+#anID { }
 
-/* or by the fact that it has an attribute! */
+/* 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; }
 
-/* start with a value (CSS3) */
+/* starts with a value (CSS 3) */
 [attr^='val'] { font-size:smaller; }
 
-/* or ends with (CSS3) */
+/* or ends with a value (CSS 3) */
 [attr$='ue'] { font-size:smaller; }
 
-/* or select by one of the values from the whitespace separated list (CSS3) */
-[otherAttr~='foo'] { font-size:smaller; }
+/* or contains a value in a space-separated list */
+[otherAttr~='foo'] { }
+[otherAttr~='bar'] { }
 
-/* or value can be exactly “value” or can begin with “value” immediately followed by “-” (U+002D) */
+/* or contains a value in a dash-separated list, ie, "-" (U+002D) */
 [otherAttr|='en'] { font-size:smaller; }
 
 
-/* and more importantly you can combine these together -- there shouldn't be  
-any space between different parts because that makes it to have another  
-meaning. */
+/* You can concatenate different selectors to create a narrower selector. Don't
+   put spaces between them. */
 div.some-class[attr$='ue'] { }
 
-/* you can also select an element based on its parent. */
+/* 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 { }
 
-/* an element which is direct child of an element (selected the same way) */
-div.some-parent > .class-name {}
+/* There are some selectors called pseudo classes that can be used to select an
+   element when it is in a particular state */
 
-/* or any of its parents in the tree
-   the following basically means any element that has class "class-name"  
-   and is child of a div with class name "some-parent" IN ANY DEPTH */
-div.some-parent .class-name {}
+/* for example, when the cursor hovers over an element */
+selector:hover { }
 
-/* warning: the same selector without space has another meaning.  
-   can you say what? */
-div.some-parent.class-name {}
+/* or a link has been visited */
+selector:visited { }
 
-/* you also might choose to select an element based on its direct  
-   previous sibling */
-.i-am-before + .this-element { }
+/* or hasn't been visited */
+selected:link { }
 
-/* or any sibling before this */
-.i-am-any-before ~ .this-element {}
+/* or an element in focus */
+selected:focus { }
 
-/* There are some pseudo classes that allows you to select an element  
-   based on its page behaviour (rather than page structure) */
+/* any element that is the first child of its parent */
+selector:first-child {}
 
-/* for example for when an element is hovered */
-selector:hover {}
+/* any element that is the last child of its parent */
+selector:last-child {}
 
-/* or a visited link */
-selected:visited {}
+/* Just like pseudo classes, pseudo elements allow you to style certain parts of a document  */
 
-/* or not visited link */
-selected:link {}
+/* matches a virtual first child of the selected element */
+selector::before {}
 
-/* or an input element which is focused */
-selected:focus {}
+/* 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
@@ -125,123 +132,122 @@ selected:focus {}
 
 selector {
     
-    /* Units */
-    width: 50%; /* in percent */
-    font-size: 2em; /* times current font-size */
-    width: 200px; /* in pixels */
-    font-size: 20pt; /* in points */
-    width: 5cm; /* in centimeters */
-    min-width: 50mm; /* in millimeters */
-    max-width: 5in; /* in inches. max-(width|height) */
-    height: 0.2vh; /* times vertical height of browser viewport (CSS3) */
-    width: 0.4vw; /* times horizontal width of browser viewport (CSS3) */
-    min-height: 0.1vmin; /* the lesser of vertical, horizontal dimensions of browser viewport (CSS3) */
-    max-width: 0.3vmax; /* same as above, except the greater of the dimensions (CSS3) */
+    /* 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 */
-    background-color: #F6E;  /* in short hex */
-    background-color: #F262E2; /* in long hex format */
-    background-color: tomato; /* can be a named color */
-    background-color: rgb(255, 255, 255); /* in rgb */
-    background-color: rgb(10%, 20%, 50%); /* in rgb percent */
-    background-color: rgba(255, 0, 0, 0.3); /* in semi-transparent rgb (CSS3) */
-    background-color: transparent; /* see thru */
-    background-color: hsl(0, 100%, 50%); /* hsl format (CSS3). */
-    background-color: hsla(0, 100%, 50%, 0.3); /* Similar to RGBA, specify opacity at end (CSS3) */
-
+    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 hsla percentages with alpha */
     
-    /* Images */
-    background-image: url(/path-to-image/image.jpg); /* quotes inside url() optional */
+    /* Images as backgrounds of elements */
+    background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
     
     /* Fonts */
     font-family: Arial;
-    font-family: "Courier New"; /* if name has space it appears in single or double quotes */
-    font-family: "Courier New", Trebuchet, Arial, sans-serif; /* if first one was not found
-                             browser uses the second font, and so forth */
+    /* 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 any CSS you want in a file with extension `.css`.
+Save a CSS stylesheet with the extension `.css`.
 
 ```xml
-<!-- you need to include the css file in your page's <head>: -->
+<!-- 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. However it is highly  
-recommended to avoid this. -->
+<!-- You can also include some CSS inline in your markup. -->
 <style>
    a { color: purple; }
 </style>
 
-<!-- or directly set CSS properties on the element. 
-This has to be avoided as much as you can. -->
+<!-- Or directly set CSS properties on the element. -->
 <div style="border: 1px solid red;">
 </div>
-
 ```
 
-## Precedence
+## 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. Generally, a rule in a more specific selector take precedence over a less specific one, and a rule occuring later in the stylesheet overwrites a previous one.
 
-As you noticed an element may be targetted by more than one selector. 
-and may have a property set on it in more than one.  
-In these cases, one of the rules takes precedence over others.
+This process is called cascading, hence the name Cascading Style Sheets.
 
 Given the following CSS:
 
 ```css
-/*A*/
+/* A */
 p.class1[attr='value']
 
-/*B*/
-p.class1 {}
+/* B */
+p.class1 { }
 
-/*C*/
-p.class2 {}
+/* C */
+p.class2 { }
 
-/*D*/
-p {}
+/* D */
+p { }
 
-/*E*/
+/* E */
 p { property: value !important; }
-
 ```
 
 and the following markup:
 
 ```xml
-<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
-</p>
+<p style='/*F*/ property:value;' class='class1 class2' attr='value' />
 ```
 
-The precedence of style is as followed:  
-Remember, the precedence is for each **property**, not for the entire block.
+The precedence of style is as follows. Remember, the precedence is for each **property**, not for the entire block.
 
-* `E` has the highest precedence because of the keyword `!important`.  
-    It is recommended to avoid this unless it is strictly necessary to use.
-* `F` is next, because it is inline style.
-* `A` is next, because it is more "specific" than anything else.  
-    more specific = more specifiers. here 3 specifiers: 1 tagname `p` +   
-    class name `class1` + 1 attribute `attr='value'`
-* `C` is next. although it has the same specificness as `B`  
-    but it appears last.
-* Then is `B`
-* and lastly is `D`.
+* `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.
 
 ## Compatibility
 
-Most of the features in CSS2 (and gradually in CSS3) are compatible across  
-all browsers and devices. But it's always vital to have in mind the compatibility 
-of what you use in CSS with your target browsers.
+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.
 
-[QuirksMode CSS](http://www.quirksmode.org/css/) is one of the best sources for this.
+## Resources
 
-To run a quick compatibility check, [CanIUse](http://caniuse.com) is a great resource.
+* To run a quick compatibility check, [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/)
 
 ## 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/d.html.markdown b/d.html.markdown
index daba8020..80c1dc65 100644
--- a/d.html.markdown
+++ b/d.html.markdown
@@ -1,6 +1,6 @@
 ---
-language: D 
-filename: learnd.d 
+language: D
+filename: learnd.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
 lang: en
@@ -18,13 +18,15 @@ void main(string[] args) {
 }
 ```
 
-If you're like me and spend way too much time on the internet, odds are you've heard 
+If you're like me and spend way too much time on the internet, odds are you've heard
 about [D](http://dlang.org/). The D programming language is a modern, general-purpose,
-multi-paradigm language with support for everything from low-level features to 
+multi-paradigm language with support for everything from low-level features to
 expressive high-level abstractions.
 
-D is actively developed by Walter Bright and Andrei Alexandrescu, two super smart, really cool
-dudes. With all that out of the way, let's look at some examples!
+D is actively developed by a large group of super-smart people and is spearheaded by
+[Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) and
+[Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+With all that out of the way, let's look at some examples!
 
 ```c
 import std.stdio;
@@ -36,9 +38,10 @@ void main() {
         writeln(i);
     }
 
-    auto n = 1; // use auto for type inferred variables
-    
-    // Numeric literals can use _ as a digit seperator for clarity
+    // 'auto' can be used for inferring types.
+    auto n = 1;
+
+    // Numeric literals can use '_' as a digit separator for clarity.
     while(n < 10_000) {
         n += n;
     }
@@ -47,13 +50,15 @@ void main() {
         n -= (n / 2);
     } while(n > 0);
 
-    // For and while are nice, but in D-land we prefer foreach
-    // The .. creates a continuous range, excluding the end
-    foreach(i; 1..1_000_000) { 
+    // For and while are nice, but in D-land we prefer 'foreach' loops.
+    // The '..' creates a continuous range, including the first value
+    // but excluding the last.
+    foreach(i; 1..1_000_000) {
         if(n % 2 == 0)
             writeln(i);
     }
 
+    // There's also 'foreach_reverse' when you want to loop backwards.
     foreach_reverse(i; 1..int.max) {
         if(n % 2 == 1) {
             writeln(i);
@@ -69,16 +74,18 @@ are passed to functions by value (i.e. copied) and classes are passed by referen
 we can use templates to parameterize all of these on both types and values!
 
 ```c
-// Here, T is a type parameter. Think <T> from C++/C#/Java
+// Here, 'T' is a type parameter. Think '<T>' from C++/C#/Java.
 struct LinkedList(T) {
     T data = null;
-    LinkedList!(T)* next; // The ! is used to instaniate a parameterized type. Again, think <T> 
+
+    // Use '!' to instantiate a parameterized type. Again, think '<T>'.
+    LinkedList!(T)* next;
 }
 
 class BinTree(T) {
     T data = null;
-    
-    // If there is only one template parameter, we can omit parens
+
+    // If there is only one template parameter, we can omit the parentheses.
     BinTree!T left;
     BinTree!T right;
 }
@@ -93,37 +100,34 @@ enum Day {
     Saturday,
 }
 
-// Use alias to create abbreviations for types
-
+// Use alias to create abbreviations for types.
 alias IntList = LinkedList!int;
 alias NumTree = BinTree!double;
 
 // We can create function templates as well!
-
 T max(T)(T a, T b) {
-    if(a < b) 
+    if(a < b)
         return b;
 
     return a;
 }
 
-// Use the ref keyword to ensure pass by referece.
-// That is, even if a and b are value types, they
-// will always be passed by reference to swap
+// Use the ref keyword to ensure pass by reference. That is, even if 'a' and 'b'
+// are value types, they will always be passed by reference to 'swap()'.
 void swap(T)(ref T a, ref T b) {
     auto temp = a;
 
     a = b;
-    b = temp; 
+    b = temp;
 }
 
-// With templates, we can also parameterize on values, not just types
+// With templates, we can also parameterize on values, not just types.
 class Matrix(uint m, uint n, T = int) {
     T[m] rows;
     T[n] columns;
 }
 
-auto mat = new Matrix!(3, 3); // We've defaulted type T to int
+auto mat = new Matrix!(3, 3); // We've defaulted type 'T' to 'int'.
 
 ```
 
@@ -133,25 +137,24 @@ have the syntax of POD structures (`structure.x = 7`) with the semantics of
 getter and setter methods (`object.setX(7)`)!
 
 ```c
-// Consider a class parameterized on a types T, U
-
+// Consider a class parameterized on types 'T' & 'U'.
 class MyClass(T, U) {
     T _data;
     U _other;
-
 }
 
-// And "getter" and "setter" methods like so
+// And "getter" and "setter" methods like so:
 class MyClass(T, U) {
     T _data;
     U _other;
-    
-    // Constructors are always named `this`
+
+    // Constructors are always named 'this'.
     this(T t, U u) {
+        // This will call the setter methods below.
         data = t;
         other = u;
     }
-    
+
     // getters
     @property T data() {
         return _data;
@@ -161,7 +164,7 @@ class MyClass(T, U) {
         return _other;
     }
 
-    // setters    
+    // setters
     @property void data(T t) {
         _data = t;
     }
@@ -170,16 +173,24 @@ class MyClass(T, U) {
         _other = u;
     }
 }
-// And we use them in this manner
 
+// And we use them in this manner:
 void main() {
-    auto mc = MyClass!(int, string);
+    auto mc = new MyClass!(int, string)(7, "seven");
+
+    // Import the 'stdio' module from the standard library for writing to
+    // console (imports can be local to a scope).
+    import std.stdio;
 
-    mc.data = 7;
-    mc.other = "seven";
-    
-    writeln(mc.data);
-    writeln(mc.other);
+    // Call the getters to fetch the values.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
+
+    // Call the setters to assign new values.
+    mc.data = 8;
+    mc.other = "eight";
+
+    // Call the getters again to fetch the new values.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
 
@@ -193,7 +204,7 @@ and `override`ing methods. D does inheritance just like Java:
 Extend one class, implement as many interfaces as you please.
 
 We've seen D's OOP facilities, but let's switch gears. D offers
-functional programming with first-class functions, `pure` 
+functional programming with first-class functions, `pure`
 functions, and immutable data. In addition, all of your favorite
 functional algorithms (map, filter, reduce and friends) can be
 found in the wonderful `std.algorithm` module!
@@ -205,7 +216,7 @@ import std.range : iota; // builds an end-exclusive range
 void main() {
     // We want to print the sum of a list of squares of even ints
     // from 1 to 100. Easy!
-    
+
     // Just pass lambda expressions as template parameters!
     // You can pass any old function you like, but lambdas are convenient here.
     auto num = iota(1, 101).filter!(x => x % 2 == 0)
@@ -216,12 +227,12 @@ void main() {
 }
 ```
 
-Notice how we got to build a nice Haskellian pipeline to compute num? 
+Notice how we got to build a nice Haskellian pipeline to compute num?
 That's thanks to a D innovation know as Uniform Function Call Syntax.
 With UFCS, we can choose whether to write a function call as a method
 or free function call! Walter wrote a nice article on this
-[here.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) 
-In short, you can call functions whose first parameter 
+[here.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+In short, you can call functions whose first parameter
 is of some type A on any expression of type A as a method.
 
 I like parallelism. Anyone else like parallelism? Sure you do. Let's do some!
diff --git a/dart.html.markdown b/dart.html.markdown
index 34d1c6a8..f7601271 100644
--- a/dart.html.markdown
+++ b/dart.html.markdown
@@ -81,7 +81,7 @@ example5() {
 // Where classBody can include instance methods and variables, but also
 // class methods and variables.
 class Example6Class {
-  var example6InstanceVariable = "Example6 instance variable"; 
+  var example6InstanceVariable = "Example6 instance variable";
   sayIt() {
     print(example6InstanceVariable);
   }
@@ -92,7 +92,7 @@ example6() {
 
 // Class methods and variables are declared with "static" terms.
 class Example7Class {
-  static var example7ClassVariable = "Example7 class variable"; 
+  static var example7ClassVariable = "Example7 class variable";
   static sayItFromClass() {
     print(example7ClassVariable);
   }
@@ -111,7 +111,7 @@ example7() {
 // by default. But arrays and maps are not. They can be made constant by
 // declaring them "const".
 var example8A = const ["Example8 const array"],
-  example8M = const {"someKey": "Example8 const map"}; 
+  example8M = const {"someKey": "Example8 const map"};
 example8() {
   print(example8A[0]);
   print(example8M["someKey"]);
@@ -245,7 +245,7 @@ example18() {
 // Strings with triple single-quotes or triple double-quotes span
 // multiple lines and include line delimiters.
 example19() {
-  print('''Example19 <a href="etc"> 
+  print('''Example19 <a href="etc">
 Example19 Don't can't I'm Etc
 Example19 </a>''');
 }
@@ -272,7 +272,7 @@ example20() {
 class Example21 {
   List<String> _names;
   Example21() {
-    _names = ["a", "b"]; 
+    _names = ["a", "b"];
   }
   List<String> get names => _names;
   set names(List<String> list) {
diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index fb9cd9d4..541d28bb 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -28,18 +28,50 @@ echo Hello, world!
 echo 'Dies ist die erste Zeile'; echo 'Dies die zweite Zeile'
 
 # Variablen deklariert man so:
-VARIABLE="irgendein String"
+Variable="irgendein String"
 
 # Aber nicht so:
-VARIABLE = "irgendein String"
-# Bash wird VARIABLE für einen Befehl halten, den es ausführen soll. Es wird einen Fehler ausgeben, 
+Variable = "irgendein String"
+# Bash wird 'Variable' für einen Befehl halten, den es ausführen soll. Es wird einen Fehler ausgeben, 
 # weil es den Befehl nicht findet. 
 
+# Und so auch nicht:
+Variable= 'Some string'
+# Bash wird 'Variable' wieder für einen Befehl halten, den es ausführen soll. Es wird einen Fehler ausgeben, 
+# Hier wird der Teil 'Variable=' als nur für diesen einen Befehl gültige Zuweisung an die Variable gesehen.
+
 # Eine Variable wird so benutzt:
-echo $VARIABLE
-echo "$VARIABLE"
-# Wenn du eine Variable selbst benutzt – ihr Werte zuweist, sie exportierst oder irgendetwas anders –, 
+echo $Variable
+echo "$Variable"
+echo ${Variable}
+# aber
+echo '$Variable'
+# Wenn du eine Variable selbst benutzt – ihr Werte zuweist, sie exportierst oder irgendetwas anderes –, 
 # dann über ihren Namen ohne $. Aber wenn du ihren zugewiesenen Wert willst, dann musst du $ voranstellen.
+# Beachte: ' (Hochkomma) verhindert das Interpretieren der Variablen
+
+# Ersetzen von Zeichenketten in Variablen
+echo ${Variable/irgendein/neuer}
+# Ersetzt das erste Vorkommen von "irgendein" durch "neuer"
+
+# Teil einer Zeichenkette
+Laenge=7
+echo ${Variable:0:Laenge}
+# Gibt nur die ersten 7 Zeichen zurück
+
+# Standardwert verwenden
+echo ${Foo:-"ErsatzWennLeerOderUngesetzt"}
+# Das funktioniert mit nicht gesetzten Variablen (Foo=) und leeren Zeichenketten (Foo="")
+# Die Zahl 0 (Foo=0) liefert 0.
+# Beachte: der wert der Variablen wird nicht geändert
+
+# Eingebaute Variable (BUILTINS):
+# Einige nützliche Beispiele
+echo "Rückgabewert des letzten Befehls: $?"
+echo "Die PID des skripts: $$"
+echo "Anzahl der Argumente beim Aufruf: $#"
+echo "Alle Argumente beim Aufruf: $@"
+echo "Die Argumente in einzelnen Variablen: $1 $2..."
 
 # Einen Wert aus der Eingabe lesen:
 echo "Wie heisst du?"
@@ -47,14 +79,30 @@ read NAME # Wir mussten nicht mal eine neue Variable deklarieren
 echo Hello, $NAME!
 
 # Wir haben die übliche if-Struktur:
-if true
+# 'man test' liefert weitere Informationen zu Bedingungen
+if [ "$NAME" -ne $USER ]
 then
-    echo "Wie erwartet"
+    echo "Dein Name ist nicht dein Login-Name"
 else
-    echo "Und dies nicht"
+    echo "Dein Name ist dein Login-Name"
+fi
+
+# Es gibt auch bedingte Ausführung
+echo "immer ausgeführt" || echo "Nur ausgeführt wenn der erste Befehl fehlschlägt"
+echo "immer ausgeführt" && echo "Nur ausgeführt wenn der erste Befehl Erfolg hat"
+
+# Um && und || mit if statements zu verwenden, braucht man mehrfache Paare eckiger Klammern:
+if [ $NAME == "Steve" ] && [ $Alter -eq 15 ]
+then
+    echo "Wird ausgeführt wenn $NAME gleich 'Steve' UND $Alter gleich 15."
+fi
+
+if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
+then
+    echo "Wird ausgeführt wenn $NAME gleich 'Daniya' ODER $NAME gleich 'Zach'."
 fi
 
-# Ausdrücke werden im folgenden Format festgehalten:
+# Ausdrücke haben folgendes Format:
 echo $(( 10 + 5 ))
 
 # Anders als andere Programmiersprachen ist Bash eine Shell – es arbeitet also im Kontext von Verzeichnissen.
@@ -69,13 +117,60 @@ ls -l # Liste alle Dateien und Unterverzeichnisse auf einer eigenen Zeile auf
 # txt-Dateien im aktuellen Verzeichnis auflisten:
 ls -l | grep "\.txt"
 
-# Befehle können innerhalb anderer Befehle mit $( ) erstetzt werden:
+# Ein- und Ausgabe können umgeleitet werden (stdin, stdout, and stderr).
+# Von stdin lesen bis "EOF" allein in einer Zeile auftaucht
+# und die Datei hello.py mit den Zeilen zwischen den beiden "EOF"
+# überschreiben:
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Führe hello.py mit verschiedenen Umleitungen von
+# stdin, stdout und stderr aus:
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Die Fehlerausgabe würde die Datei "error.err" überschreiben (falls sie existiert) 
+# verwende ">>" um stattdessen anzuhängen:
+python hello.py >> "output.out" 2>> "error.err"
+
+# Überschreibe output.out, hänge an error.err an und zähle die Zeilen beider Dateien:
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# Führe einen Befehl aus und gib dessen "file descriptor" (zB /dev/fd/123) aus
+# siehe: man fd
+echo <(echo "#helloworld")
+
+# Mehrere Arten, um output.out mit "#helloworld" zu überschreiben:
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# Löschen der Hilfsdateien von oberhalb, mit Anzeige der Dateinamen
+# (mit '-i' für "interactive" erfolgt für jede Date eine Rückfrage)
+rm -v output.out error.err output-and-error.log
+
+# Die Ausgabe von Befehlen kann mit Hilfe von $( ) in anderen Befehlen verwendet weden:
 # Der folgende Befehl zeigt die Anzahl aller Dateien und Unterverzeichnisse
 # im aktuellen Verzeichnis an.
 echo "Dieser Ordner beinhaltet $(ls | wc -l) Dateien und Verzeichnisse."
 
+# Dasselbe kann man mit "backticks" `` erreichen, aber diese können
+# nicht verschachtelt werden. $() ist die empfohlene Methode.
+echo "Dieser Ordner beinhaltet `ls | wc -l` Dateien und Verzeichnisse."
+
 # Bash nutzt einen case-Ausdruck, der sich ähnlich wie switch in Java oder C++ verhält.
-case "$VARIABLE"
+case "$Variable"
 in
     # Liste der Fälle, die unterschieden werden sollen
     0) echo "Hier ist eine Null."
@@ -83,10 +178,106 @@ in
     *) echo "Das ist nicht Null."
 esac
 
-# loops iterieren über die angegebene Zahl von Argumenten:
-# Der Inhalt von $VARIABLE wird dreimal ausgedruckt.
-for $VARIABLE in x y z
+# 'for' Schleifen iterieren über die angegebene Zahl von Argumenten:
+# Der Inhalt von $Variable wird dreimal ausgedruckt.
+for $Variable in {1..3}
 do
-    echo "$VARIABLE"
+    echo "$Variable"
 done
+
+# Oder verwende die "traditionelle 'for'-Schleife":
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Schleifen können auch mit Dateien arbeiten:
+# 'cat' zeigt zuerst file1 an und dann file2
+for Variable in file1 file2
+do
+    cat "$Variable"
+done
+
+# .. oder mit der Ausgabe eines Befehls:
+# Ausgabe des Inhalts jeder Datei, die von 'ls' aufgezählt wird
+for Output in $(ls)
+do
+    cat "$Output"
+done
+
+# while Schleife:
+while [ true ]
+do
+    echo "Schleifenkörper..."
+    break
+done
+
+# Funktionen definieren
+# Definition:
+function foo ()
+{
+    echo "Argumente funktionieren wie bei skripts: $@"
+    echo Und: $1 $2..."
+    echo "Dies ist eine Funktion"
+    return 0
+}
+
+# oder einfacher
+bar ()
+{
+    echo "Auch so kann man Funktionen deklarieren!"
+    return 0
+}
+
+# Aufruf der Funktion:
+foo "My name is" $Name
+
+# Was du noch lernen könntest:
+# Ausgabe der letzten 10 Zeilen von file.txt
+tail -n 10 file.txt
+# Ausgabe der ersten 10 Zeilen von file.txt
+head -n 10 file.txt
+# sortierte Ausgabe von file.txt
+sort file.txt
+# Mehrfachzeilen in sortierten Dateien unterdrücken
+# oder (mit -d) nur diese ausgeben
+uniq -d file.txt
+# Ausgabe nur der ersten Spalte (vor dem ersten ',')
+cut -d ',' -f 1 file.txt
+# ersetze in file.txt jedes vorkommende 'gut' durch 'super' (versteht regex)
+sed -i 's/gut/super/g' file.txt
+# Ausgabe nach stdout aller Zeilen von file.txt, die auf eine regex passen
+# Im Beispiel: Zeilen, die mit "foo" beginnen und mit "bar" enden
+grep "^foo.*bar$" file.txt
+# Mit der Option "-c" wird stattdessen die Anzahl der gefundenen Zeilen ausgegeben
+grep -c "^foo.*bar$" file.txt
+# verwende 'fgrep' oder 'grep -F' wenn du buchstäblich nach den Zeichen
+# suchen willst, ohne sie als regex zu interpretieren
+fgrep "^foo.*bar$" file.txt
+
+# Dokumentation über die in bash eingebauten Befehle
+# bekommst du mit dem eingebauten Befehl 'help'
+help
+help help
+help for
+help return
+help source
+help .
+
+# Das bash-Handbuch liest du mit 'man'
+apropos bash
+man 1 bash
+man bash
+
+# Dann gibt es noch das 'info' System (drücke ? um Hilfe angezeigt zu bekommen)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# info Dokumentation über bash:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
 ```
diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown
index dc77dda0..78bb0a6b 100644
--- a/de-de/csharp-de.html.markdown
+++ b/de-de/csharp-de.html.markdown
@@ -248,7 +248,8 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";
             // Ternärer Operator

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

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

-            string isTrue = true ? "Ja" : "Nein";

+            int zumVergleich = 17;

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

 

             // while-Schleife

             int fooWhile = 0;

@@ -882,8 +883,8 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";
  * [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 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)
\ No newline at end of file
+[C# Coding Conventions](http://msdn.microsoft.com/de-de/library/vstudio/ff926074.aspx)

diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index c7b6ad86..dea329d5 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -18,12 +18,12 @@ Anmerkung des Übersetzers: Einige englische Begriffe wie *Repository*, *Commit*
 
 ### Was ist Versionsverwaltung?
 
-Eine Versionskontrolle erfasst die Änderungen einer Datei oder eines Verzeichnisses im Verlauf der Zeit.
+Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichnisses im Verlauf der Zeit.
 
 ### Zentrale im Vergleich mit verteilter Versionverwaltung
 
-* Zentrale Versionskontrolle konzentriert sich auf das Synchronisieren, Verfolgen und Sichern von Dateien.
-* Verteilte Versionskontrolle konzentriert sich auf das Teilen der Änderungen. Jede Änderung hat eine eindeutige ID.
+* Zentrale Versionsverwaltung konzentriert sich auf das Synchronisieren, Verfolgen und Sichern von Dateien.
+* Verteilte Versionsverwaltung konzentriert sich auf das Teilen der Änderungen. Jede Änderung hat eine eindeutige ID.
 * Verteilte Systeme haben keine vorbestimmte Struktur. Ein SVN-ähnliches, zentrales System wäre mit Git ebenso umsetzbar.
 
 [Weiterführende Informationen](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
@@ -48,7 +48,7 @@ Ein Repository besteht in Git aus dem .git-Verzeichnis und dem Arbeitsverzeichni
 
 ### .git-Verzeichnis (Teil des Repositorys)
 
-Das .git-Verzeichnis enth? alle Einstellung, Logs, Branches, den HEAD und mehr.
+Das .git-Verzeichnis enthält alle Einstellung, Logs, Branches, den HEAD und mehr.
 [Ausführliche Übersicht](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
 
 ### Arbeitsverzeichnis (Teil des Repositorys)
@@ -61,7 +61,7 @@ Der Index ist die die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arb
 
 ### Commit
 
-Ein Commit ist ein Schnappschuss von Uderungen in deinem Arbeitsverzeichnis. Wenn du zum Beispiel 5 Dateien hinzugefügt und 2 andere entfernt hast, werden diese Änderungen im Commit (Schnappschuss) enthalten sein. Dieser Commit kann dann in andere Repositorys gepusht werden. Oder nicht!
+Ein Commit ist ein Schnappschuss von Änderungen in deinem Arbeitsverzeichnis. Wenn du zum Beispiel 5 Dateien hinzugefügt und 2 andere entfernt hast, werden diese Änderungen im Commit (Schnappschuss) enthalten sein. Dieser Commit kann dann in andere Repositories gepusht werden. Oder nicht!
 
 ### Branch
 
@@ -69,7 +69,9 @@ Ein Branch, ein Ast oder Zweig, ist im Kern ein Pointer auf den letzten Commit,
 
 ### HEAD und head (Teil des .git-Verzeichnisses)
 
-HEAD ist ein Pointer auf den aktuellen Branch. Ein Repository hat nur einen *aktiven* HEAD. Ein head ist ein Pointer, der auf ein beliebige Zahl von heads zeigt.
+HEAD ist ein Pointer auf den aktuellen Branch. Ein Repository hat nur einen *aktiven* HEAD. 
+
+Ein *head* ist ein Pointer, der auf einen beliebigen Commit zeigt.  Ein Repository kann eine beliebige Zahl von *heads* enthalten.
 
 ### Konzeptionelle Hintergründe
 
@@ -127,7 +129,7 @@ Zeigt die Unterschiede zwischen Index (im Grunde dein Arbeitsverzeichnis/-reposi
 
 
 ```bash
-# Zeigt den Branch, nicht-verfolgte Dateien, Uderungen und andere Unterschiede an
+# Zeigt den Branch, nicht-verfolgte Dateien, Änderungen und andere Unterschiede an
 $ git status
 
 # Anderes Wissenswertes über git status anzeigen
@@ -151,7 +153,7 @@ $ git add ./*.java
 
 ### branch
 
-Verwalte alle Branches. Du kannst sie mit diesem Befehl ansehen, bearbeiten, neue erschaffen oder löschen.
+Verwalte alle Branches. Du kannst sie mit diesem Befehl ansehen, bearbeiten, neue erzeugen oder löschen.
 
 ```bash
 # Liste alle bestehenden Branches und Remotes auf
@@ -186,7 +188,7 @@ $ git checkout -b newBranch
 
 ### clone
 
-Ein bestehendes Repository in ein neues Verzeichnis klonen oder kopieren. Es fügt außerdem für hedes geklonte Repo remote-tracking Branches hinzu. Du kannst auf diese Remote-Branches pushen.
+Ein bestehendes Repository in ein neues Verzeichnis klonen oder kopieren. Es fügt außerdem für jedes geklonte Repository remote-tracking Branches hinzu. Du kannst auf diese Remote-Branches pushen.
 
 ```bash
 # Klone learnxinyminutes-docs
@@ -288,16 +290,16 @@ $ git mv -f myFile existingFile
 
 ### pull
 
-Führe einen Pull, zieht alle Daten, eines Repositorys und f?? einen Merge mit einem anderen Branch durch.
+Führe einen Pull (zieht alle Daten eines Repositories) aus und führt einen Merge mit einem anderen Branch durch.
 
 ```bash
-# Update deines lokalen Repos, indem ein Merge der neuen Uderungen
-# von den remote-liegenden "origin"- und "master"-Branches durchgef?? wird.
+# Update deines lokalen Repos, indem ein Merge der neuen Änderungen
+# von den remote-liegenden "origin"- und "master"-Branches durchgeführt wird.
 # git pull <remote> <branch>
 # git pull => impliziter Verweis auf origin und master
 $ git pull origin master
 
-# F?? einen Merge von Uderungen eines remote-Branch und ein Rebase
+# Führt einen Merge von Änderungen eines remote-Branch und ein Rebase
 # des Branch-Commits im lokalen Repo durch. Wie: pull <remote> <branch>, git rebase <branch>"
 $ git pull origin master --rebase
 ```
@@ -337,8 +339,8 @@ $ git reset
 # Setze die Staging-Area zurück, um dem letzten Commit zu entsprechen und überschreibe das Arbeitsverzeichnis
 $ git reset --hard
 
-# Bewegt die Spitze des Branches zu dem angegebenen Commit (das Verzeichnis bleibt unber??)
-# Alle Uderungen bleiben im Verzeichnis erhalten
+# Bewegt die Spitze des Branches zu dem angegebenen Commit (das Verzeichnis bleibt unberührt)
+# Alle Änderungen bleiben im Verzeichnis erhalten
 $ git reset 31f2bb1
 
 # Bewegt die Spitze des Branches zurück zu dem angegebenen Commit
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 83d59c8b..7e61bf81 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -3,6 +3,7 @@ language: Go
 filename: learngo-de.go
 contributors:
     - ["Joseph Adams", "https://github.com/jcla1"]
+    - ["Dennis Keller", "https://github.com/denniskeller"]
 lang: de-de
 ---
 Go wurde entwickelt, um Probleme zu lösen. Sie ist zwar nicht der neueste Trend in
@@ -306,13 +307,13 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 ## Weitere Resourcen
 Alles zu Go finden Sie auf der [offiziellen Go Webseite](http://golang.org/).
-Dort können sie der Tutorial folgen, interaktiv Quelltext ausprobieren und viel
+Dort können sie dem Tutorial folgen, interaktiv Quelltext ausprobieren und viel
 Dokumentation lesen.
 
 Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
 kurz und auch gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
 ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/).
-Gut documentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
+Gut dokumentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
 verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
 in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
 
diff --git a/de-de/javascript-de.html.markdown b/de-de/javascript-de.html.markdown
index a295c1c2..f3917506 100644
--- a/de-de/javascript-de.html.markdown
+++ b/de-de/javascript-de.html.markdown
@@ -479,9 +479,6 @@ myNumber === myNumberObj; // = false
 if (0){

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

 }

-if (Number(0)){

-    // Dieser Teil des Codes wird ausgeführt, weil Number(0) zu wahr evaluiert.

-}

 

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

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

diff --git a/de-de/latex-de.html.markdown b/de-de/latex-de.html.markdown
new file mode 100644
index 00000000..2c18b8fd
--- /dev/null
+++ b/de-de/latex-de.html.markdown
@@ -0,0 +1,235 @@
+---
+language: latex
+contributors:
+    - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+translators:
+  - ["Moritz Kammerer", "https://github.com/phxql"]
+lang: de-de
+filename: latex-de.tex
+---
+```
+% Alle Kommentare starten fangen mit % an
+% Es gibt keine Kommentare über mehrere Zeilen
+
+% LateX ist keine "What You See Is What You Get" Textverarbeitungssoftware wie z.B.
+% MS Word oder OpenOffice Writer
+
+% Jedes LateX-Kommando startet mit einem Backslash (\)
+
+% LateX-Dokumente starten immer mit der Definition des Dokuments, die sie darstellen
+% Weitere Dokumententypen sind z.B. book, report, presentations, etc.
+% Optionen des Dokuments stehen zwischen den eckigen Klammern []. In diesem Fall
+% wollen wir einen 12 Punkte-Font verwenden.
+\documentclass[12pt]{article}
+
+% Als nächstes definieren wir die Pakete, die wir verwenden wollen.
+% Wenn du z.B. Grafiken, farbigen Text oder Quelltext in dein Dokument einbetten möchtest,
+% musst du die Fähigkeiten von Latex durch Hinzufügen von Paketen erweitern.
+% Wir verwenden die Pakete float und caption für Bilder.
+\usepackage{caption}
+\usepackage{float}
+
+% Mit diesem Paket können leichter Umlaute getippt werden
+\usepackage[utf8]{inputenc}
+
+% Es können durchaus noch weitere Optione für das Dokument gesetzt werden!
+\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
+\date{\today}
+\title{Learn LaTeX in Y Minutes!}
+
+% Nun kann's losgehen mit unserem Dokument.
+% Alles vor dieser Zeile wird die Preamble genannt.
+\begin{document} 
+% Wenn wir den Autor, das Datum und den Titel gesetzt haben, kann
+% LateX für uns eine Titelseite generieren
+\maketitle
+
+% Die meisten Paper haben ein Abstract. LateX bietet dafür einen vorgefertigen Befehl an.
+% Das Abstract sollte in der logischen Reihenfolge, also nach dem Titel, aber vor dem
+% Inhalt erscheinen.
+% Dieser Befehl ist in den Dokumentenklassen article und report verfügbar.
+\begin{abstract}
+ LateX documentation geschrieben in LateX! Wie ungewöhnlich und garantiert nicht meine Idee!
+\end{abstract}
+
+% Section Befehle sind intuitiv.
+% Alle Titel der sections werden automatisch in das Inhaltsverzeichnis übernommen.
+\section{Einleitung}
+Hi, mein Name ist Moritz und zusammen werden wir LateX erforschen!
+
+\section{Noch eine section}
+Das hier ist der Text für noch eine section. Ich glaube, wir brauchen eine subsection.
+
+\subsection{Das ist eine subsection} % Subsections sind auch ziemlich intuitiv.
+Ich glaube, wir brauchen noch eine.
+
+\subsubsection{Pythagoras}
+So ist's schon viel besser.
+\label{subsec:pythagoras}
+
+% Wenn wir den Stern nach section schreiben, dann unterdrückt LateX die Nummerierung.
+% Das funktioniert auch bei anderen Befehlen.
+\section*{Das ist eine unnummerierte section} 
+Es müssen nicht alle sections nummeriert sein!
+
+\section{Ein paar Notizen}
+LateX ist ziemlich gut darin, Text so zu platzieren, dass es gut aussieht.
+Falls eine Zeile \\ mal \\ woanders \\ umgebrochen \\ werden \\ soll, füge
+\textbackslash\textbackslash in den Code ein.\\
+
+\section{Listen}
+Listen sind eine der einfachsten Dinge in LateX. Ich muss morgen einkaufen gehen,
+also lass uns eine Einkaufsliste schreiben:
+\begin{enumerate} % Dieser Befehl erstellt eine "enumerate" Umgebung.
+  % \item bringt enumerate dazu, eins weiterzuzählen.
+  \item Salat.
+  \item 27 Wassermelonen.
+  \item einen Hasen.
+  % Wir können die Nummer des Eintrags durch [] überschreiben
+  \item[Wie viele?] Mittelgroße Wasserpistolen.
+
+  Kein Listeneintrag, aber immer noch Teil von enumerate.
+
+\end{enumerate} % Alle Umgebungen müssen ein end haben.
+
+\section{Mathe}
+
+Einer der Haupteinsatzzwecke von LateX ist das Schreiben von akademischen
+Artikeln oder Papern. Meistens stammen diese aus dem Bereich der Mathe oder
+anderen Wissenschaften. Und deswegen müssen wir in der Lage sein, spezielle
+Symbole zu unserem Paper hinzuzufügen! \\
+
+Mathe kennt sehr viele Symbole, viel mehr als auf einer Tastatur zu finden sind;
+Symbole für Mengen und relationen, Pfeile, Operatoren und Griechische Buchstaben,
+um nur ein paar zu nennen.\\
+
+Mengen und Relationen spielen eine sehr wichtige Rolle in vielen mathematischen
+Papern. So schreibt man in LateX, dass alle y zu X gehören: $\forall$ y $\in$ X. \\
+
+% Achte auf die $ Zeichen vor und nach den Symbolen. Wenn wir in LateX schreiben,
+% geschieht dies standardmäßig im Textmodus. Die Mathe-Symbole existieren allerdings
+% nur im Mathe-Modus. Wir können den Mathe-Modus durch das $ Zeichen aktivieren und
+% ihn mit $ wieder verlassen. Variablen können auch im Mathe-Modus angezeigt werden.
+
+Mein Lieblingsbuchstabe im Griechischen ist $\xi$. Ich mag auch $\beta$, $\gamma$ und $\sigma$.
+Bis jetzt habe ich noch keinen griechischen Buchstaben gefunden, den LateX nicht kennt!
+
+Operatoren sind ebenfalls wichtige Bestandteile von mathematischen Dokumenten:
+Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$), 
+Logarithmus und Exponenten ($\log$, $\exp$),
+Grenzwerte ($\lim$), etc. haben vordefinierte Befehle.
+Lass uns eine Gleichung schreiben: \\
+
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$\\
+
+Brüche (Zähler / Nenner) können so geschrieben werden:
+
+% 10 / 7
+$^{10}/_{7}$ 
+
+% Komplexere Brüche können so geschrieben werden:
+% \frac{Zähler}{Nenner}
+$\frac{n!}{k!(n - k)!}$ \\
+
+Wir können Gleichungen auch in einer equation Umgebung verwenden.
+
+% Dies zeigt Mathe in einer equation Umgebung an
+\begin{equation} % Aktiviert automatisch den Mathe-Modus.
+    c^2 = a^2 + b^2.
+    \label{eq:pythagoras} % Pythagoras referenzieren
+\end{equation} % Alle \begin Befehle müssen einen \end Befehl besitzen
+
+Wir können nun unsere Gleichung referenzieren!
+Gleichung ~\ref{eq:pythagoras} ist auch als das Theorem des Pythagoras bekannt. Dieses wird in 
+Abschnitt ~\ref{subsec:pythagoras} behandelt. Es können sehr viele Sachen mit Labels versehen werden:
+Grafiken, Gleichungen, Sections, etc.
+
+Summen und Integrale können mit den sum und int Befehlen dargestellt werden:
+
+% Manche LateX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen
+\begin{equation} 
+  \sum_{i=0}^{5} f_{i}
+\end{equation} 
+\begin{equation} 
+  \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
+\end{equation} 
+
+\section{Grafiken}
+
+Lass uns eine Grafik einfügen. Das Platzieren von Grafiken kann etwas trickreich sein.
+Aber keine Sorge, ich muss auch jedes mal nachschauen, welche Option wie wirkt.
+
+\begin{figure}[H] % H ist die Platzierungsoption
+    \centering % Zentriert die Grafik auf der Seite
+    % Fügt eine Grafik ein, die auf 80% der Seitenbreite einnimmt.
+    %\includegraphics[width=0.8\linewidth]{right-triangle.png} 
+    % Auskommentiert, damit es nicht im Dokument auftaucht.
+    \caption{Dreieck mit den Seiten $a$, $b$, $c$}
+    \label{fig:right-triangle}
+\end{figure}
+
+\subsection{Tabellen}
+Wir können Tabellen genauso wie Grafiken einfügen.
+
+\begin{table}[H]
+  \caption{Überschrift der Tabelle.}
+  % Die {} Argumente geben an, wie eine Zeile der Tabelle dargestellt werden soll.
+  % Auch hier muss ich jedes Mal nachschauen. Jedes. einzelne. Mal.  
+  \begin{tabular}{c|cc} 
+    Nummer &  Nachname & Vorname \\ % Spalten werden durch & getrennt
+    \hline % Eine horizontale Linie
+    1 & Biggus & Dickus \\
+    2 & Monty & Python
+  \end{tabular}
+\end{table}
+
+% \section{Links} % Kommen bald!
+
+\section{Verhindern, dass LateX etwas kompiliert (z.B. Quelltext)}
+Angenommen, wir wollen Quelltext in unserem LateX-Dokument. LateX soll 
+in diesem Fall nicht den Quelltext als LateX-Kommandos interpretieren, 
+sondern es einfach ins Dokument schreiben. Um das hinzubekommen, verwenden
+wir eine verbatim Umgebung.
+
+% Es gibt noch weitere Pakete für Quelltexte (z.B. minty, lstlisting, etc.)
+% aber verbatim ist das simpelste.
+\begin{verbatim} 
+  print("Hello World!")
+  a%b; % Schau dir das an! Wir können % im verbatim verwenden!
+  random = 4; #decided by fair random dice roll
+\end{verbatim}
+
+\section{Kompilieren} 
+
+Ich vermute, du wunderst dich, wie du dieses tolle Dokument in ein PDF
+verwandeln kannst. (Ja, dieses Dokument kompiliert wirklich!) \\
+
+Dafür musst du folgende Schritte durchführen:
+  \begin{enumerate}
+    \item Schreibe das Dokument. (den LateX-Quelltext).
+    \item Kompiliere den Quelltext in ein PDF. 
+     Das Kompilieren sieht so ähnlich wie das hier aus (Linux): \\
+     \begin{verbatim} 
+        $pdflatex learn-latex.tex learn-latex.pdf 
+     \end{verbatim}
+  \end{enumerate}
+
+Manche LateX-Editoren kombinieren Schritt 1 und 2. Du siehst also nur Schritt 1 und Schritt
+2 wird unsichtbar im Hintergrund ausgeführt.
+
+Alle Formatierungsoptionen werden in Schritt 1 in den Quelltext geschrieben. Schritt 2 verwendet
+dann diese Informationen und kümmert sich drum, dass das Dokument korrekt erstellt wird.
+
+\section{Ende}
+
+Das war's erst mal!
+
+% Dokument beenden
+\end{document}
+```
+## Mehr Informationen über LateX
+
+* Das tolle LaTeX wikibook: [https://de.wikibooks.org/wiki/LaTeX-Kompendium](https://de.wikibooks.org/wiki/LaTeX-Kompendium)
+* Ein Tutorial (englisch): [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown
new file mode 100644
index 00000000..bdeaa30b
--- /dev/null
+++ b/de-de/ruby-de.html.markdown
@@ -0,0 +1,613 @@
+---
+language: ruby
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+translators:
+  - ["Christian Albrecht", "https://github.com/coastalchief"]
+filename: ruby-de.rb
+lang: de-de
+---
+
+# Dies ist ein Kommentar
+
+=begin
+Dies sind multi-line
+Kommentare. Niemand benutzt
+die wirklich.
+=end
+
+# Objekte - Alles ist ein Objekt
+
+## Zahlen sind Objekte
+```
+3.class #=> Fixnum
+3.to_s #=> "3"
+```
+
+### Simple Arithmetik
+```
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+```
+
+// Arithmetik ist aber eigentlich nur syntaktischer Zucker
+// um eine Methode eines Objekt aufzurufen
+```
+1.+(3) #=> 4
+10.* 5 #=> 50
+```
+
+## Special values sind Objekte
+```
+nil # Nothing to see here
+true # truth
+false # falsehood
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+```
+
+## Objektvergleiche
+### Gleicheit
+```
+1 == 1 #=> true
+2 == 1 #=> false
+```
+### Ungleichheit
+```
+1 != 1 #=> false
+2 != 1 #=> true
+```
+### Neben false selbst, nil ist ein anderer 'falsey' Wert
+```
+!nil   #=> true
+!false #=> true
+!0     #=> false
+```
+### Weitere Vergleiche
+```
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+```
+### Logische Operatoren
+```
+true && false #=> false
+true || false #=> true
+!true #=> false
+```
+
+Es gibt alternative Versionen der logischen Operatoren mit niedrigerer
+Wertigkeit. Diese werden meistens bei Flow-Control eingesetzt, um
+verschiedenen Ausdrücke zu verketten bis einer true oder false zurück
+liefert.
+
+#### and
+##### `do_something_else` wird nur ausgewertet wenn `do_something` true ist.
+do_something() and do_something_else()
+
+#### or
+#####`log_error` wird nur ausgewertet wenn `do_something` false ist.
+do_something() or log_error()
+
+## Strings sind Objekte
+```
+'I am a string'.class #=> String
+"I am a string too".class #=> String
+
+
+platzhalter = 'Ruby'
+"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungsstrichen füllen."
+```
+Einfache Anführungszeichen sollten bevorzugt werden.
+Doppelte Anführungszeichen führen interne Berechnungen durch.
+
+### Strings können verbunden werden, aber nicht mit Zahlen
+```
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+```
+#### Zahl muss in String konvertiert werden
+```
+'hello ' + 3.to_s #=> "hello 3"
+```
+### Text ausgeben
+```
+puts "I'm printing!"
+```
+# Variablen
+## Zuweisungen
+### Diese Zuweisung gibt den zugeordneten Wert zurück
+```
+x = 25 #=> 25
+x #=> 25
+```
+### Damit funktionieren auch mehrfache Zuweisungen
+```
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+```
+## Benennung
+### Konvention ist snake_case 
+```
+snake_case = true
+```
+### Benutze verständliche Variablennamen
+```
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+```
+# Symbols (sind auch Objekte)
+Symbols sind unveränderliche, wiederverwendbare Konstanten, welche intern  
+als integer repräsentiert werden. Sie werden häufig anstelle von Strings  
+verwendet, um sinnvoll Werte zu übermitteln.  
+Symbols werden mit dem Doppelpunkt gekennzeichnet.
+
+```
+:pending.class #=> Symbol
+status = :pending
+status == :pending #=> true
+status == 'pending' #=> false
+status == :approved #=> false
+```
+# Arrays
+
+## Ein Array anlegen
+```
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+```
+
+## Array können verschiedene Typen beinhalten
+```
+[1, 'hello', false] #=> [1, "hello", false]
+```
+
+## Wie bei arithmetischen Ausdrücken auch wird beim Zugriff auf
+## [0] eigentlich die Methode [] des Array Objekts aufgerufen.
+```
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+```
+
+## Arrays können von vorne indiziert werden
+```
+array[0] #=> 1
+array[12] #=> nil
+```
+
+## Arrays können von hinten indiziert werden
+```
+array[-1] #=> 5
+```
+
+## Arrays können mit Stard Index und Länge indiziert werden
+```
+array[2, 3] #=> [3, 4, 5]
+```
+
+## Arrays können mit einer Range indiziert werden
+```
+array[1..3] #=> [2, 3, 4]
+```
+
+## Einen Wert hinzufügen
+```
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+```
+
+## Testen, ob ein Element schon vorhanden ist
+```
+array.include?(1) #=> true
+```
+
+# Hashes 
+Hashes sind das Hauptfeature um Key/Values zu speichern
+
+```
+
+## Ein Hash anlegen
+```
+hash = { 'color' => 'green', 'number' => 5 }
+hash.keys #=> ['color', 'number']
+```
+
+## Wert per key herausfinden
+```
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+hash['nothing here'] #=> nil 
+// Asking a hash for a key that doesn't exist returns nil:
+```
+
+##  Symbols können auch keys sein
+```
+new_hash = { defcon: 3, action: true }
+new_hash.keys #=> [:defcon, :action]
+```
+
+## Testen ob ein Key oder ein Value existiert
+```
+new_hash.has_key?(:defcon) #=> true
+new_hash.has_value?(3) #=> true
+```
+
+### Tip:  Arrays und Hashes sind Enumerable
+### Und haben gemeinsame, hilfreiche Methoden wie:
+### each, map, count, and more
+
+# Kontrolstrukturen
+## if
+```
+if true
+  'if statement'
+elsif false
+  'else if, optional'
+else
+  'else, also optional'
+end
+```
+## for - Allerdings werden for Schleifen nicht oft vewendet.
+```
+for counter in 1..5
+  puts "iteration #{counter}"
+end
+```
+## Stattdessen: "each" Methode und einen Bloch übergeben
+Ein Block ist ein Codeteil, den man einer Methode übergeben kann  
+Ähnelt stark lambdas, anonymen Funktionen oder Closures in anderen  
+Programmiersprachen.
+
+```
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+```
+
+Die each Methode einer Range führt den Block für jedes Element der Range aus.
+
+Dem Block wird ein "counter" parameter übergeben.
+
+### Den Block kann man auch in geschweiften Klammern schreiben
+```
+(1..5).each { |counter| puts "iteration #{counter}" }
+```
+
+### Each kann auch über den Inhalt von Datenstrukturen iterieren
+```
+array.each do |element|
+  puts "#{element} is part of the array"
+end
+hash.each do |key, value|
+  puts "#{key} is #{value}"
+end
+
+counter = 1
+while counter <= 5 do
+  puts "iteration #{counter}"
+  counter += 1
+end
+```
+
+## case
+```
+grade = 'B'
+
+case grade
+when 'A'
+  puts 'Way to go kiddo'
+when 'B'
+  puts 'Better luck next time'
+when 'C'
+  puts 'You can do better'
+when 'D'
+  puts 'Scraping through'
+when 'F'
+  puts 'You failed!'
+else
+  puts 'Alternative grading system, eh?'
+end
+=> "Better luck next time"
+```
+
+### Case können auch ranges
+```
+grade = 82
+case grade
+when 90..100
+  puts 'Hooray!'
+when 80...90
+  puts 'OK job'
+else
+  puts 'You failed!'
+end
+=> "OK job"
+```
+
+# exception handling:
+```
+begin
+  # code here that might raise an exception
+  raise NoMemoryError, 'You ran out of memory.'
+rescue NoMemoryError => exception_variable
+  puts 'NoMemoryError was raised', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'RuntimeError was raised now'
+else
+  puts 'This runs if no exceptions were thrown at all'
+ensure
+  puts 'This code always runs no matter what'
+end
+```
+# Funktionen
+```
+def double(x)
+  x * 2
+end
+```
+## Funktionen (und Blocks) 
+## geben implizit den Wert des letzten Statements zurück
+```
+double(2) #=> 4
+```
+
+### Klammern sind optional wenn das Ergebnis nicht mehdeutig ist
+```
+double 3 #=> 6
+double double 3 #=> 12
+def sum(x, y)
+  x + y
+end
+```
+
+### Methoden Parameter werden per Komma getrennt
+```
+sum 3, 4 #=> 7
+sum sum(3, 4), 5 #=> 12
+```
+
+## yield
+### Alle Methoden haben einen impliziten, optionalen block Parameter
+### Dieser wird mit dem Schlüsselword "yield" aufgerufen
+```
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+surround { puts 'hello world' }
+```
+
+## Einen Block kann man auch einer Methoden übergeben
+### "&" kennzeichnet die Referenz zum übergebenen Block
+```
+def guests(&block)
+  block.call 'some_argument'
+end
+```
+
+### Eine Liste von Parametern kann man auch übergeben,
+### Diese wird in ein Array konvertiert
+### "*" kennzeichnet dies.
+```
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+```
+# Klassen
+## Werden mit dem class Schlüsselwort definiert
+```
+class Human
+```
+
+### Konstruktor bzw. Initializer
+```
+  def initialize(name, age = 0)
+    # Assign the argument to the "name" instance variable for the instance
+    @name = name
+    # If no age given, we will fall back to the default in the arguments list.
+    @age = age
+  end
+```
+
+### setter Methode
+```
+  def name=(name)
+    @name = name
+  end
+```
+### getter Methode
+```
+  def name
+    @name
+  end
+```
+
+#### getter können mit der attr_accessor Methode vereinfacht definiert werden
+```
+  attr_accessor :name
+  # Getter/setter methods can also be created individually like this
+  attr_reader :name
+  attr_writer :name
+  # A class method uses self to distinguish from instance methods.
+  # It can only be called on the class, not an instance.
+  def self.say(msg)
+    puts msg
+  end
+  def species
+    @@species
+  end
+end
+```
+
+## Eine Klasse instanziieren
+```
+jim = Human.new('Jim Halpert')
+dwight = Human.new('Dwight K. Schrute')
+```
+
+## Methodenaufrufe
+```
+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"
+```
+
+## Eine Klassenmethode aufrufen
+```
+Human.say('Hi') #=> "Hi"
+```
+
+## Variable Gültigkeit
+### Variablen die mit "$" starten, gelten global
+```
+$var = "I'm a global var"
+defined? $var #=> "global-variable"
+```
+
+### Variablen die mit "@" starten, gelten für die Instanz
+```
+@var = "I'm an instance var"
+defined? @var #=> "instance-variable"
+```
+
+### Variablen die mit "@@" starten, gelten für die Klasse
+```
+@@var = "I'm a class var"
+defined? @@var #=> "class variable"
+```
+
+### Variablen die mit einem Großbuchstaben anfangen, sind Konstanten
+```
+Var = "I'm a constant"
+defined? Var #=> "constant"
+```
+
+## Class ist auch ein Objekt
+### Hat also auch Instanzvariablen
+### Eine Klassenvariable wird innerhalb der Klasse und Ableitungen geteilt.
+
+### Basis Klasse
+```
+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 # 2
+```
+
+### Eine Klasseninstanzvariable wird nicht geteilt
+```
+class Human
+  @bar = 0
+  def self.bar
+    @bar
+  end
+  def self.bar=(value)
+    @bar = value
+  end
+end
+```
+```
+class Doctor < Human
+end
+```
+```
+Human.bar # 0
+Doctor.bar # nil
+```
+```
+module ModuleExample
+  def foo
+    'foo'
+  end
+end
+```
+### Module einbinden, heisst ihre Methoden an die Instanzen der Klasse zu binden
+### Module erweitern, heisst ihre Mothden an die Klasse selbst zu binden
+```
+class Person
+  include ModuleExample
+end
+```
+```
+class Book
+  extend ModuleExample
+end
+```
+```
+Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => NoMethodError: undefined method `foo'
+```
+### Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird
+```
+  module ConcernExample
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+    module ClassMethods
+      def bar
+        'bar'
+      end
+    end
+    module InstanceMethods
+      def qux
+        'qux'
+      end
+    end
+  end
+  class Something
+    include ConcernExample
+  end
+```
+```
+Something.bar     # => 'bar'
+Something.qux     # => NoMethodError: undefined method `qux'
+Something.new.bar # => NoMethodError: undefined method `bar'
+Something.new.qux # => 'qux'
+```
+
+## Weiterführende Hinweise
+
+//EN  
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
+- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
diff --git a/de-de/ruby-ecosystem-de.html.markdown b/de-de/ruby-ecosystem-de.html.markdown
new file mode 100644
index 00000000..a7e1f75f
--- /dev/null
+++ b/de-de/ruby-ecosystem-de.html.markdown
@@ -0,0 +1,149 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+    - ["Jon Smock", "http://github.com/jonsmock"]
+    - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+  - ["Christian Albrecht", "https://github.com/coastalchief"]
+filename: ruby-ecosystem-de.txt
+lang: de-de
+---
+
+Hier gibt es einen Überblick über die gängigsten Tools zur Verwaltung  
+von verschiedenen Ruby Versionen, Gems und Dependencies.  
+
+## Ruby Managers
+
+Einige Betriebssysteme haben bereits eine Ruby Version vorinstalliert  
+oder bieten sie als Package zum Download an. Die meisten Rubyisten  
+benutzen diese aber eher nicht und wenn, dann um damit einen Ruby  
+Manager zu installieren. Damit kann man komfortabel zwischen den  
+verschiedenen Versionen hin und herspringen.  
+
+Dies sind die beliebtesten:
+
+* [RVM](https://rvm.io/) - Installiert und wechselt zwischen rubies
+  RVM kennt verschiedene Ruby Versionen und hat das Konzept der gemsets,  
+  um gem Abhängigkeiten pro Projekt zu managen.  
+* [ruby-build](https://github.com/sstephenson/ruby-build)  
+  Installiert nur rubies, kann diese aber sehr gut verwalten
+* [rbenv](https://github.com/sstephenson/rbenv) - Wechselt Ruby Versionen.
+  Wird zusammen mit ruby-build benutzt. Hiermit kann man kontrollieren,  
+  wie rubies laden.
+* [chruby](https://github.com/postmodern/chruby) - Wechselt Ruby Versionen.
+  Ähnlich rbenv.
+
+## Ruby Versionen
+
+Ruby wurde von Yukihiro "Matz" Matsumoto vor gut 20 Jahren veröffentlicht.  
+Matz ist nach wie vor in die Entwicklung involviert. Daher kommt auch der  
+Name der Referenzimplementierung: MRI (Matz' Reference Implementation).  
+
+Die aktuellste Version ist **2.2.3** und wurde im August 2015 veröffentlicht!  
+
+Hier eine kurze Versionshistorie:
+
+* 2.0.0 - Release im Februar 2013  -- Release zum 20. Geburtstag der Sprache
+  [Rubies are forever](http://www.heise.de/developer/artikel/Ruby-2-0-als-Geschenk-zum-20-Geburtstag-1808109.html)
+* 1.9.3 - Release im Oktober 2011  
+  [End of Life](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
+* 1.8.7 - Release im Juni 2006  
+  [End of Life](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+Die Veränderung zwischen 1.8.7 und 1.9.x war sehr groß und eine Migration  
+nicht so einfach möglich. Der Versionssprung auf 2.0.0 war verglichen dazu  
+weit weniger dramatisch.  
+Beispielsweise hat 1.9. Encodings und eine Bytecode VM eingeführt.  
+Es gibt immer noch Projekte die auf der stabilen Version 1.8.7 laufen,  
+aber diese sind mittlerweile in der Minderheit. Die meisten Projekte  
+laufen auf 1.9.x oder auf 2.x.
+
+## Ruby Implementierungen
+
+Das Ruby Ecosystem beinhaltet viele verschiedene Implementierungen von Ruby,  
+jedes mit seinen eigenen Vorteilen und verschiedenen Graden von  
+Kompatibilität. Auch wenn alle diese Implementierungen in verschiedenen  
+Sprachen geschrieben sind, sind sie doch **alle Ruby**.  
+Jede Implementierung bietet neben ihren speziellen Features immer auch  
+die Möglichkeit normale ruby Dateien auszuführen.
+
+Am ausgereiftesten und stabilsten:
+
+* [MRI](https://github.com/ruby/ruby) - Geschrieben in C, das ist die Referenz Implementierung.
+  Sie ist 100% kompatibel (mit sich selbst ;-). Alle anderen rubies 
+  bleiben kompatibel mit MRI (siehe [RubySpec](#rubyspec) weiter unten).
+* [JRuby](http://jruby.org/) - Geschrieben in Java and Ruby, Robust und ziemlich schnell.
+  Der größte Vorteil von JRuby ist die Interoperabilität mit JVM/Java und damit die  
+  Benutzung von Ruby im Java Ecosystem.
+* [Rubinius](http://rubini.us/) - Geschrieben in Ruby mit C++ bytecode VM. 
+  Auch sehr ausgereift und schnell. 
+
+Mittel ausgereift / kompatibel:
+
+* [Maglev](http://maglev.github.io/) - Baut auf Gemstone, ein Smalltalk VM.
+  Dieses Projekt versucht das großartige Smalltalk Tooling in die Ruby Welt  
+  zu bringen.
+* [RubyMotion](http://www.rubymotion.com/) - Ruby in der iOS Entwicklung.
+
+Weniger ausgereift/kompatibel:
+
+* [Topaz](http://topazruby.com/) - Geschrieben in RPython (via PyPy)
+  Topaz ist noch ziemlich jung und versucht die schnellste Implementierung  
+  zu werden.
+* [IronRuby](http://ironruby.net/) - Geschrieben in C# für die .NET Plaftform  
+  Das letzte Release von IronRuby ist mittlerweile 5 Jahre her. 
+
+Die Ruby Implementierungen haben ihre eigenen Versionsnummern, sind aber  
+trotzdem immer zu einer MRI Version kompatibel.  
+Viele können sogar zwischen verschiedenen Modi wechseln (1.8 mode -> 1.9 mode)
+
+## RubySpec
+
+Die meisten Ruby Implementierungen vertrauen der [RubySpec](http://rubyspec.org/).  
+sehr stark. Da Ruby keine offizielle Spezifikation hat, hat die  
+Community ausführbare Specs (in Ruby) geschrieben, um so die Kompatibilität  
+zur MRI testen zu können.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) ist der Community Paket Manager von Ruby.  
+RubyGems kommt mit Ruby zusammen, so dass kein extra Tool nötig ist.  
+  
+Ruby Pakete werden "gems" genannt und könnten auf RubyGems.org  
+veröffentlicht werden. Jedes Gem enthält den Source Code und Meta Daten,  
+wie die Versionsnummer, weitere Abhängigkeiten, Autoren und Lizenzen.
+
+## Bundler
+
+[Bundler](http://bundler.io/) ist ein Tool um Abhängigkeiten zwischen  
+Gems aufzulösen und zu managen. Dazu werden diese in einem gemfile  
+zusammengefasst und Bundler kümmert sich darum die Abhängigkeiten  
+untereinander rekursiv aufzulösen. Entweder es klappt und alle gems  
+konnten runtergeladen werden, oder es wird abgebrochen und  
+der Konflikt gemeldet.  
+Zum Beispiel:  
+Wenn Gem A die Version 3 oder höher von Gem Z braucht, aber Gem B  
+von Gem Z die Version 2, dann ist das ein Konflikt.  
+
+# Testing
+
+Test-Driven Development ist ein essentieller Teil der Ruby Kultur.  
+Ruby bringt sein eigenes Unit-Test framework mit, minitest. Darüberhinaus  
+gibt es noch viele weitere Testframeworks mit unterschiedlichsten Zielen:
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Eingebaut in Ruby 1.8
+  "Unit-style" Testframework
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Eingebaut in Ruby 1.9/2.0
+  "Unit-style" Testframework
+* [RSpec](http://rspec.info/) - Ein Testframework welches auf verständliche Testdefinition setzt
+* [Cucumber](http://cukes.info/) - Ein BDD Testframework welches Gherkin tests parsen kann
+
+## Be Nice
+Die Ruby Community ist stolz darauf eine offene, vielfältige und einladende  
+Community zu sein. Es gibt viele aktive Ruby User Gruppen und diverse  
+Ruby Konferenzen. Matz selbst ist so oft es geht dabei.
+
+* [Euruko](http://www.euruko2015.org)
+* [User Groups](https://www.ruby-lang.org/de/community/user-groups/)
+
diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
new file mode 100644
index 00000000..7fd299b4
--- /dev/null
+++ b/de-de/scala-de.html.markdown
@@ -0,0 +1,816 @@
+---
+language: Scala
+contributors:
+    - ["George Petrov", "http://github.com/petrovg"]
+    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Ha-Duong Nguyen", "http://reference-error.org"]
+translators:
+  - ["Christian Albrecht", "https://github.com/coastalchief"]
+filename: learnscala-de.scala
+lang: de-de
+---
+
+Scala ist eine funktionale und objektorientierte Programmiersprache  
+für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben  
+zu erledigen. Scala hat einen akademischen Hintergrund und wurde an  
+der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt.
+
+
+# 0. Umgebung einrichten
+Scala Umgebung einrichten:
+
+1. Scala binaries herunterladen- http://www.scala-lang.org/downloads
+2. Unzip/untar in ein Verzeichnis
+3. das bin Unterverzeichnis der `PATH` Umgebungsvariable hinzufügen
+4. Mit dem Kommando `scala` wird die REPL gestartet und zeigt als Prompt:
+```
+scala>
+```
+
+Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.  
+Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt  
+ausgegeben.  
+Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
+
+# 1. Basics
+
+Einzeilige Kommentare beginnen mit zwei vorwärts Slash
+
+/*
+  Mehrzeilige Kommentare, werden starten 
+  mit Slash-Stern und enden mit Stern-Slash
+*/
+
+// Einen Wert, und eine zusätzliche neue Zeile ausgeben  
+```
+println("Hello world!")
+println(10)
+```
+
+// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben  
+```
+print("Hello world")
+```
+
+// Variablen werden entweder mit var oder val deklariert.  
+// Deklarationen mit val sind immutable, also unveränderlich  
+// Deklarationen mit var sind mutable, also veränderlich  
+// Immutability ist gut.  
+```
+val x = 10 // x ist 10
+x = 20     // error: reassignment to val
+var y = 10
+y = 20     // y ist jetzt 20
+```
+
+Scala ist eine statisch getypte Sprache, auch wenn in dem o.g. Beispiel  
+keine Typen an x und y geschrieben haben.  
+In Scala ist etwas eingebaut, was sich Type Inference nennt. D.h. das der  
+Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine ist,  
+so dass der Typ nicht jedes mal angegeben werden soll.  
+Einen Typ gibt man bei einer Variablendeklaration wie folgt an:  
+```
+val z: Int = 10
+val a: Double = 1.0
+```
+
+// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0  
+```
+val b: Double = 10
+```
+
+// Boolean Werte  
+```
+true
+false
+```
+
+// Boolean Operationen  
+```
+!true         // false
+!false        // true
+true == false // false
+10 > 5        // true
+```
+
+// Mathematische Operationen sind wie gewohnt  
+```
+1 + 1   // 2
+2 - 1   // 1
+5 * 3   // 15
+6 / 2   // 3
+6 / 4   // 1
+6.0 / 4 // 1.5
+```
+
+// Die Auswertung eines Ausdrucks in der REPL gibt den Typ  
+// und das Ergebnis zurück.  
+```
+  scala> 1 + 7
+  res29: Int = 8
+```
+
+Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt  
+von Typ Int ist und einen Wert 0 hat.  
+"res29" ist ein sequentiell generierter name, um das Ergebnis des  
+Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...  
+
+
+"Scala strings werden in doppelten Anführungszeichen eingeschlossen"  
+'a' // A Scala Char  
+// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error  
+  
+// Für Strings gibt es die üblichen Java Methoden  
+```
+"hello world".length
+"hello world".substring(2, 6)
+"hello world".replace("C", "3")
+```
+
+// Zusätzlich gibt es noch extra Scala Methoden  
+// siehe: scala.collection.immutable.StringOps  
+```
+"hello world".take(5)
+"hello world".drop(5)
+```
+
+// String interpolation: prefix "s"  
+```
+val n = 45
+s"We have $n apples" // => "We have 45 apples"
+```
+
+// Ausdrücke im innern von interpolierten Strings gibt es auch  
+```
+val a = Array(11, 9, 6)
+val n = 100
+s"My second daughter is ${a(0) - a(2)} years old."    // => "My second daughter is 5 years old."
+s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
+s"Power of 2: ${math.pow(2, 2)}"                      // => "Power of 2: 4"
+```
+
+// Formatierung der interpolierten Strings mit dem prefix "f"  
+```
+f"Power of 5: ${math.pow(5, 2)}%1.0f"         // "Power of 5: 25"
+f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
+```
+
+// Raw Strings, ignorieren Sonderzeichen.  
+```
+raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
+```
+
+// Manche Zeichen müssen "escaped" werden, z.B.   
+// ein doppeltes Anführungszeichen in innern eines Strings.  
+```
+"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+```
+
+// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht  
+// und Anführungszeichen enthalten kann.  
+```
+val html = """<form id="daform">
+                <p>Press belo', Joe</p>
+                <input type="submit">
+              </form>"""
+```
+
+# 2. Funktionen
+
+// Funktionen werden so definiert  
+//  
+//   def functionName(args...): ReturnType = { body... }  
+//  
+// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck  
+// in einer Funktion der Rückgabewert.  
+```
+def sumOfSquares(x: Int, y: Int): Int = {
+  val x2 = x * x
+  val y2 = y * y
+  x2 + y2
+}
+```
+
+// Die geschweiften Klammern können weggelassen werden, wenn  
+// die Funktion nur aus einem einzigen Ausdruck besteht:  
+```
+def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
+```
+
+// Syntax für Funktionsaufrufe:  
+```
+sumOfSquares(3, 4)  // => 25
+```
+
+// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können  
+// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei  
+// Variablen, auch bei Funktionen greift:  
+```
+def sq(x: Int) = x * x  // Compiler errät, dass der return type Int ist
+```
+
+// Funktionen können default parameter haben:  
+```
+def addWithDefault(x: Int, y: Int = 5) = x + y
+addWithDefault(1, 2) // => 3
+addWithDefault(1)    // => 6
+```
+
+// Anonyme Funktionen sehen so aus:  
+```
+(x: Int) => x * x
+```
+
+// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen   
+// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.  
+// Beachte den Typ "Int => Int", dies beschreibt eine Funktion,  
+// welche Int als Parameter erwartet und Int zurückgibt.  
+```
+val sq: Int => Int = x => x * x
+```
+
+// Anonyme Funktionen benutzt man ganz normal:  
+```
+sq(10)   // => 100
+```
+
+// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,  
+// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,  
+// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge  
+// verwendet werden. Diese anonymen Funktionen werden sehr häufig   
+// verwendet.  
+```
+val addOne: Int => Int = _ + 1  
+val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)  
+addOne(5)      // => 6  
+weirdSum(2, 4) // => 16  
+```
+
+// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung  
+// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus  
+// dem innersten def, welches den return Ausdruck umgibt, zurück.  
+// "return" hat keinen Effekt in anonymen Funktionen:  
+```
+def foo(x: Int): Int = {  
+  val anonFunc: Int => Int = { z =>  
+    if (z > 5)  
+      return z // Zeile macht z zum return Wert von foo  
+    else  
+      z + 2    // Zeile ist der return Wert von anonFunc  
+  }  
+  anonFunc(x)  // Zeile ist der return Wert von foo  
+}  
+```
+
+# 3. Flow Control
+
+## Wertebereiche und Schleifen
+```
+1 to 5
+val r = 1 to 5
+r.foreach(println)
+r foreach println
+(5 to 1 by -1) foreach (println)
+```  
+// Scala ist syntaktisch sehr grosszügig, Semikolons am Zeilenende  
+// sind optional, beim Aufruf von Methoden können die Punkte  
+// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden  
+
+// while Schleife  
+```
+var i = 0
+while (i < 10) { println("i " + i); i += 1 }
+i    // i ausgeben, res3: Int = 10
+```
+
+// Beachte: while ist eine Schleife im klassischen Sinne -  
+// Sie läuft sequentiell ab und verändert die loop-Variable.  
+// While in Scala läuft schneller ab als in Java und die o.g.  
+// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen  
+// und zu parellelisieren.
+
+// Ein do while Schleife  
+```
+do {
+  println("x ist immer noch weniger wie 10")
+  x += 1
+} while (x < 10)
+```
+
+// Endrekursionen sind ideomatisch um sich wiederholende  
+// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen  
+// return Typ, der Compiler kann ihn nicht erraten.  
+// Unit, in diesem Beispiel.  
+```
+def showNumbersInRange(a: Int, b: Int): Unit = {
+  print(a)
+  if (a < b)
+    showNumbersInRange(a + 1, b)
+}
+showNumbersInRange(1, 14)
+```
+
+## Conditionals
+```
+val x = 10
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println ("yeah") else println("nay")
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+```
+
+# 4. Daten Strukturen (Array, Map, Set, Tuples)
+
+## Array
+```
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)
+a(3)
+a(21)    // Exception
+```
+
+## Map - Speichert Key-Value-Paare
+```
+val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+m("fork")
+m("spoon")
+m("bottle")       // Exception
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle")
+```
+## Set - Speichert Unikate, unsortiert (sortiert -> SortedSet)
+```
+val s = Set(1, 3, 7)
+s(0) //false
+s(1) //true
+val s = Set(1,1,3,3,7)
+s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
+```
+## Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
+// Ein Tuple ist keine Collection.  
+```
+(1, 2)
+(4, 3, 2)
+(1, 2, "three")
+(a, 2, "three")
+```
+
+// Hier ist der Rückgabewert der Funktion ein Tuple  
+// Die Funktion gibt das Ergebnis, so wie den Rest zurück.  
+```
+val divideInts = (x: Int, y: Int) => (x / y, x % y)
+divideInts(10, 3)
+```
+
+// Um die Elemente eines Tuples anzusprechen, benutzt man diese  
+// Notation: _._n wobei n der index des Elements ist (Index startet bei 1)  
+```
+val d = divideInts(10, 3)
+d._1
+d._2
+```
+# 5. Objekt Orientierte Programmierung
+
+Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar  
+zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in  
+einem Scala file selten alleine zu finden sind.  
+Die einzigen Top-Level Konstrukte in Scala sind nämlich:  
+
+- Klassen (classes)
+- Objekte (objects)
+- case classes
+- traits
+
+Diesen Sprachelemente wenden wir uns jetzt zu.  
+
+## Klassen
+
+// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen  
+// anderen Sprachen auch. 
+
+// erzeugt Klasse mit default Konstruktor  
+```
+class Hund
+scala> val t = new Hund
+t: Hund = Hund@7103745
+```
+
+// Der Konstruktor wird direkt hinter dem Klassennamen deklariert.  
+```
+class Hund(sorte: String)
+scala> val t = new Hund("Dackel")
+t: Hund = Hund@14be750c
+scala> t.sorte //error: value sorte is not a member of Hund
+```
+
+// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse  
+// Per var wird aus dem Attribut ein veränderliches Feld der Klasse  
+```
+class Hund(val sorte: String)
+scala> val t = new Hund("Dackel")
+t: Hund = Hund@74a85515
+scala> t.sorte
+res18: String = Dackel
+```
+
+// Methoden werden mit def geschrieben  
+```
+def bark = "Woof, woof!"
+```
+
+// Felder und Methoden können public, protected und private sein  
+// default ist public  
+// private ist nur innerhalb des deklarierten Bereichs sichtbar  
+```
+class Hund {
+  private def x = ...
+  def y = ...
+}
+```
+
+// protected ist nur innerhalb des deklarierten und aller  
+// erbenden Bereiche sichtbar  
+```
+class Hund {
+  protected def x = ...
+}
+class Dackel extends Hund {
+  // x ist sichtbar
+}
+```
+##  Object
+Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.  
+"companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so  
+ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse  
+benutzen ohne ein Objekt instanziieren zu müssen.  
+Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn  
+es genauso heisst und in derselben Datei wie die Klasse definiert wurde.  
+```
+object Hund {
+  def alleSorten = List("Pitbull", "Dackel", "Retriever")
+  def createHund(sorte: String) = new Hund(sorte)
+}
+```
+## Case classes
+Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra  
+Funktionalität erweitern. Mit Case Klassen bekommt man ein paar  
+Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.  
+ein companion object mit den entsprechenden Methoden,  
+Hilfsmethoden wie toString(), equals() und hashCode() und auch noch  
+Getter für unsere Attribute (das Angeben von val entfällt dadurch)  
+```
+class Person(val name: String)
+class Hund(val sorte: String, val farbe: String, val halter: Person)
+```
+
+// Es genügt das Schlüsselwort case vor die Klasse zu schreiben.  
+```
+case class Person(name: String)
+case class Hund(sorte: String, farbe: String, halter: Person)
+```
+
+// Für neue Instanzen brauch man kein "new"  
+```
+val dackel = Hund("dackel", "grau", Person("peter"))
+val dogge = Hund("dogge", "grau", Person("peter"))
+  
+```
+// getter  
+```
+dackel.halter  // => Person = Person(peter)
+```
+  
+// equals  
+```
+dogge == dackel  // => false
+```
+  
+// copy  
+// otherGeorge == Person("george", "9876")  
+```
+val otherGeorge = george.copy(phoneNumber = "9876")
+```
+## Traits
+Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp  
+und Methodensignaturen. Scala erlaubt allerdings das teilweise  
+implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.  
+Traits können von anderen Traits oder Klassen erben, aber nur von  
+parameterlosen.  
+```
+trait Hund {
+	def sorte: String
+	def farbe: String
+	def bellen: Boolean = true
+	def beissen: Boolean
+}
+class Bernhardiner extends Hund{
+	val sorte = "Bernhardiner"
+	val farbe = "braun"
+	def beissen = false
+}
+```
+  
+```
+scala> b  
+res0: Bernhardiner = Bernhardiner@3e57cd70  
+scala> b.sorte  
+res1: String = Bernhardiner  
+scala> b.bellen  
+res2: Boolean = true  
+scala> b.beissen  
+res3: Boolean = false  
+```
+
+// Traits können auch via Mixins (Schlüsselwort "with") eingebunden werden  
+```
+trait Bellen {
+	def bellen: String = "Woof"
+}
+trait Hund {
+	def sorte: String
+	def farbe: String
+}
+class Bernhardiner extends Hund with Bellen{
+	val sorte = "Bernhardiner"
+	val farbe = "braun"
+}
+scala> val b = new Bernhardiner
+b: Bernhardiner = Bernhardiner@7b69c6ba
+scala> b.bellen
+res0: String = Woof
+```
+
+# 6. Pattern Matching
+Pattern matching in Scala ist ein sehr nützliches und wesentlich  
+mächtigeres Feature als Vergleichsfunktionen in Java. In Scala  
+benötigt ein case Statement kein "break", ein fall-through gibt es nicht.  
+Mehrere Überprüfungen können mit einem Statement gemacht werden.  
+Pattern matching wird mit dem Schlüsselwort "match" gemacht.  
+```
+val x = ...
+x match {
+  case 2 =>
+  case 3 =>
+  case _ =>
+}
+```
+
+// Pattern Matching kann auf beliebige Typen prüfen  
+```
+val any: Any = ...
+val gleicht = any match {
+  case 2 | 3 | 5 => "Zahl"
+  case "woof" => "String"
+  case true | false => "Boolean"
+  case 45.35 => "Double"
+  case _ => "Unbekannt"
+}
+```
+
+// und auf Objektgleichheit  
+```
+def matchPerson(person: Person): String = person match {
+  case Person("George", nummer) => "George! Die Nummer ist " + number
+  case Person("Kate", nummer)   => "Kate! Die Nummer ist " + nummer
+  case Person(name, nummer)     => "Irgendjemand: " + name + ", Telefon: " + nummer
+}
+```
+
+// Und viele mehr...  
+```
+val email = "(.*)@(.*)".r  // regex
+def matchEverything(obj: Any): String = obj match {
+  // Werte:
+  case "Hello world" => "Got the string Hello world"
+  // Typen:
+  case x: Double => "Got a Double: " + x
+  // Conditions:
+  case x: Int if x > 10000 => "Got a pretty big number!"
+  // Case Classes:
+  case Person(name, number) => s"Got contact info for $name!"
+  // RegEx:
+  case email(name, domain) => s"Got email address $name@$domain"
+  // Tuples:
+  case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+  // Strukturen:
+  case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
+  // Patterns kann man ineinander schachteln:
+  case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+}
+```
+
+// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden  
+// Ganze Funktionen können Patterns sein  
+```
+val patternFunc: Person => String = {
+  case Person("George", number) => s"George's number: $number"
+  case Person(name, number) => s"Random person's number: $number"
+}
+```
+
+# 7. Higher-order functions
+Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden  
+als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen  
+higher-order functions  
+Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für  
+die meisten anderen Collection Typen, sowie andere Klassen in Scala  
+Nennenswerte sind:  
+"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"  
+
+## List
+```
+def isGleichVier(a:Int) = a == 4
+val list = List(1, 2, 3, 4)
+val resultExists4 = list.exists(isEqualToFour)
+```
+
+## map
+// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt  
+// eine neue Liste  
+  
+// Funktion erwartet ein Int und returned ein Int  
+```
+val add10: Int => Int = _ + 10 
+```
+
+// add10 wird auf jedes Element angewendet  
+```
+List(1, 2, 3) map add10 // => List(11, 12, 13)
+```
+
+// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden  
+```
+List(1, 2, 3) map (x => x + 10)
+```
+
+// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion  
+// verwendet. Er wird an die Variable gebunden.  
+```
+List(1, 2, 3) map (_ + 10)
+```
+
+// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,  
+// kann sogar der Unterstrich weggelassen werden.  
+```
+List("Dom", "Bob", "Natalia") foreach println
+```
+
+## filter
+// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet  
+// alle Elemente die auf das Prädikat passen  
+```
+List(1, 2, 3) filter (_ > 2) // => List(3)
+case class Person(name: String, age: Int)
+List(
+  Person(name = "Dom", age = 23),
+  Person(name = "Bob", age = 30)
+).filter(_.age > 25) // List(Person("Bob", 30))
+```
+
+## reduce
+// reduce nimmt zwei Elemente und kombiniert sie zu einem Element,  
+// und zwar solange bis nur noch ein Element da ist.  
+
+## foreach
+// foreach gibt es für einige Collections  
+```
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
+aListOfNumbers foreach (x => println(x))
+aListOfNumbers foreach println
+```
+## For comprehensions
+// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.  
+// Dies ist keine for-Schleife.  
+```
+for { n <- s } yield sq(n)
+val nSquared2 = for { n <- s } yield sq(n)
+for { n <- nSquared2 if n < 10 } yield n
+for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
+```
+
+/////////////////////////////////////////////////
+# 8. Implicits
+/////////////////////////////////////////////////
+
+**ACHTUNG:**  
+Implicits sind ein sehr mächtiges Sprachfeature von Scala. Es sehr einfach  
+sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am  
+besten erst dann benutzen, wenn man versteht wie sie funktionieren.  
+Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle  
+vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles  
+machen kann.  
+Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.  
+
+// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte  
+// zu "implicit Methods" werden.  
+```
+implicit val myImplicitInt = 100
+implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte)
+```
+
+// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion  
+```
+myImplicitInt + 2                   // => 102
+myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
+```
+
+// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein  
+// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von  
+// implicit Funktionsparametern  
+  
+// Diese Funktion hat zwei Parameter: einen normalen und einen implicit  
+```
+def sendGreetings(toWhom: String)(implicit howMany: Int) =
+  s"Hello $toWhom, $howMany blessings to you and yours!"
+```
+
+// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet  
+```
+sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
+```
+
+// Wird der implicit Parameter jedoch weggelassen, wird ein anderer  
+// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im  
+// lexikalischen Scope und im companion object nach einem implicit Wert,  
+// der vom Typ passt, oder  nach einer implicit Methode mit der er in den  
+// geforderten Typ konvertieren kann.  
+  
+// Hier also: "myImplicitInt", da ein Int gesucht wird  
+```
+sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
+```
+
+// bzw. "myImplicitFunction"  
+// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und  
+// dann wird die Methode aufgerufen  
+```
+"Retriever".sorte // => "Golden Retriever"
+```
+
+# 9. Misc
+## Importe
+```
+import scala.collection.immutable.List
+```
+
+// Importiere alle Unterpackages  
+```
+import scala.collection.immutable._
+```
+
+// Importiere verschiedene Klassen mit einem Statement  
+```
+import scala.collection.immutable.{List, Map}
+```
+
+// Einen Import kann man mit '=>' umbenennen  
+```
+import scala.collection.immutable.{List => ImmutableList}
+```
+
+// Importiere alle Klasses, mit Ausnahem von....  
+// Hier ohne: Map and Set:  
+```
+import scala.collection.immutable.{Map => _, Set => _, _}
+```
+## Main 
+```
+object Application {
+  def main(args: Array[String]): Unit = {
+    // stuff goes here.
+  }
+}
+```
+
+## I/O
+// Eine Datei Zeile für Zeile lesen  
+```
+import scala.io.Source
+for(line <- Source.fromFile("myfile.txt").getLines())
+  println(line)
+```
+
+// Eine Datei schreiben  
+```
+val writer = new PrintWriter("myfile.txt")
+writer.write("Schreibe Zeile" + util.Properties.lineSeparator)
+writer.write("Und noch eine Zeile" + util.Properties.lineSeparator)
+writer.close()
+```
+
+## Weiterführende Hinweise 
+
+// DE
+* [Scala Tutorial](https://scalatutorial.wordpress.com)
+* [Scala Tutorial](http://scalatutorial.de)
+
+// EN
+* [Scala for the impatient](http://horstmann.com/scala/)
+* [Twitter Scala school](http://twitter.github.io/scala_school/)
+* [The scala documentation](http://docs.scala-lang.org/)
+* [Try Scala in your browser](http://scalatutorials.com/tour/)
+* [Neophytes Guide to Scala](http://danielwestheide.com/scala/neophytes.html)
+* Join the [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
diff --git a/el-gr/css-gr.html.markdown b/el-gr/css-gr.html.markdown
new file mode 100644
index 00000000..327dc1a0
--- /dev/null
+++ b/el-gr/css-gr.html.markdown
@@ -0,0 +1,243 @@
+---
+language: css
+contributors:
+    - ["Kostas Bariotis", "http://kostasbariotis.com"]
+filename: css-gr.html.markdown
+lang: el-gr
+---
+
+Η αρχική μορφή του Παγκόσμιου Ιστού αποτελούταν απο καθαρό κείμενο, χωρίς οπτικά αντικείμενα. Με το πέρας 
+του χρόνου και την εξέλιξη των Φυλλομετρητών, οι πλούσιες σελίδες, σε οπτικά και πολυμεσικά αντικείμενα, 
+γίναν καθημερινότητα.
+
+Η CSS μας βοηθάει να διαχωρήσουμε το περιεχόμενο της σελίδας μας (HTML) απο την οπτική της περιγραφή.
+
+Με την CSS ορίζουμε οπτικές ιδιότητες (χρώμα, μέγεθος, κλπ) σε HTML αντικείμενα (H1, div, κλπ).
+
+```css
+/* Σχόλια εμφανίζονται εντός καθέτου-αστερίσκου, όπως εδώ. 
+   Δεν υπάρχουν σχόλια μια γραμμής και πολλών. */
+
+/* ####################
+   ## ΚΑΝΟΝΕΣ
+   #################### */
+
+/* ένας κανόνας χρησιμοποιείτε για να στοχεύσουμε ένα αντικείμενο (selector).
+selector { property: value; /* περισσότερες ιδιότητες...*/ }
+
+/*
+Αυτό είναι ενα παράδειγμα αντικειμένου¨
+
+<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
+*/
+
+/* Μπορούμε να το στοχεύσουμε με την χρήση CSS κλάσεων */
+.class1 { }
+
+/* Ή και με τις δύο κλάσεις! */
+.class1.class2 { }
+
+/* Και με το όνομα του */
+div { }
+
+/* Ή με το id του */
+#anID { }
+
+/* Ή με το γεγονός ότι περιέχει ενα attribute */
+[attr] { font-size:smaller; }
+
+/* Ή οτι το attribute αυτό έχει μια συγκεκριμένη τιμή */
+[attr='value'] { font-size:smaller; }
+
+/* Ξεκινάει απο το λεκτικό (CSS 3) */
+[attr^='val'] { font-size:smaller; }
+
+/* Καταλήγει σε αυτο το λεκτικό (CSS 3) */
+[attr$='ue'] { font-size:smaller; }
+
+/* Περιέχει κάποιο λεκτικό */
+[otherAttr~='foo'] { }
+[otherAttr~='bar'] { }
+
+/* περιέχει το λεκτικό σε λίστα χωρισμένη με παύλες, δηλαδή: "-" (U+002D) */
+[otherAttr|='en'] { font-size:smaller; }
+
+
+/* Μπορούμε να προσθέσουμε μεταξύ τους selectors για να δημιουργήσουμε πιο αυστηρούς. 
+  Δεν βάζουμε κενά ανάμεσα. */
+div.some-class[attr$='ue'] { }
+
+/* Μπορούμε να επιλέξουμε αντικείμενα που βρίσκονται μέσα σε άλλα. */
+div.some-parent > .class-name { }
+
+/* Ή κάποιο αντικείμενο απόγονο ανεξαρτήτου του βάθους της σχέσης τους. */
+div.some-parent .class-name { }
+
+/* ΠΡΟΣΟΧΗ: ο ίδιος selector χωρίς κενά έχει άλλο νόημα. (Άσκηση προς τον αναγνώστη) */
+div.some-parent.class-name { }
+
+/* Μπορούμε να επιλέξουμε αντικείμενα με βάση το αμέσως επόμενο αντικείμενο στο ίδιο επίπεδο. */
+.i-am-just-before + .this-element { }
+
+/* Ή οποιοδήποτε αντικείμενο που προηγείται */
+.i-am-any-element-before ~ .this-element { }
+
+/* Με την βοήθεια των ψευδο-κλάσεων μπορούμε να επιλέξουμε αντικείμενα που βρίσκονται σε μια 
+  ορισμένη κατάασταση. */
+
+/* π.χ. όταν ο κέρσορας είναι πάνω απο ένα αντικείμενο */
+selector:hover { }
+
+/* ή ένας υπερσύνδεσμος που πατήθηκε */
+selector:visited { }
+
+/* ή που δεν πατήθηκε */
+selected:link { }
+
+/* ή ένα αντικείμενο που επιλέχθηκε */
+selected:focus { }
+
+/* οποιοδήποτε αντικείμενο είναι το πρώτο παιδί των γονέων του */
+selector:first-child {}
+
+/* οποιοδήποτε αντικείμενο είναι το πρώτοτελευταίο παιδί των γονέων του */
+selector:last-child {}
+
+/* Όπως και με τις ψευδο-κλάσεις, τα ψευδο-αντικείμενα μας επιτρέπουν τα τροποοιήσουμε συγκεκριμένα 
+  κομμάτια της σελίδας */
+
+/* επιλέγει το ψευδο-αντικείμενο ακριβώς πριν απο το αντικείμενο */
+selector::before {}
+
+/* επιλέγει το ψευδο-αντικείμενο ακριβώς μετά απο τον αντικείμενο */
+selector::after {}
+
+/* Σε σωστά σημεία (όχι πολύ ψηλά στην ιεραρχία) ο αστερίσκος μπορείς να χρησιμοποιηθεί για να 
+  επιλέξουμε όλα τα αντικείμενα */
+* { } /* όλα τα αντικείμενα της σελίδας */
+.parent * { } /* όλους τους απόγονους */
+.parent > * { } /* όλους τους απόγονους πρώτου επιπέδου */
+
+/* ####################
+   ## Ιδιότητες
+   #################### */
+
+selector {
+    
+    /* Οι μονάδες μπορούν να είναι είτε απόλυτες είτε σχετικές */
+    
+    /* Σχετικές μονάδες */
+    width: 50%;       /* ποσοστό επί του πλάτους του γονέα */
+    font-size: 2em;   /* πολλαπλασιαστής της αρχικής τιμής του αντικειμένου */
+    font-size: 2rem;  /* ή της τιμής του πρώτου αντικειμένου στην ιεραρχία */
+    font-size: 2vw;   /* πολλαπλαστιαστής του 1% του οπτικού πλάτους */
+    font-size: 2vh;   /* ή τους ύψους */
+    font-size: 2vmin; /* οποιοδήποτε απο αυτα τα δύο είναι το μικρότερο */
+    font-size: 2vmax; /* ή το μεγαλύτερο */
+    
+    /* Απόλυτες μονάδες */
+    width: 200px;     /* pixels */
+    font-size: 20pt;  /* στιγμες */
+    width: 5cm;       /* εκατοστά */
+    min-width: 50mm;  /* χιλιοστά */
+    max-width: 5in;   /* ίντσες */
+    
+    /* Χρώματα */
+    color: #F6E;                 /* σύντομη δεκαεξαδική μορφή */
+    color: #FF66EE;              /* δεκαεξαδική μορφή */
+    color: tomato;               /* χρώμα με το όνομα του (συγκεκριμένα χρώματα) */
+    color: rgb(255, 255, 255);   /* τιμή RGB */
+    color: rgb(10%, 20%, 50%);   /* τιμή RGB με ποσοστά */
+    color: rgba(255, 0, 0, 0.3); /* τιμή RGBA (CSS3) σσ. 0 < a < 1 */
+    color: transparent;          /* όπως και το παραπάνω με a = 0 */
+    color: hsl(0, 100%, 50%);    /* τιμή hsl με ποσοστά (CSS 3) */
+    color: hsla(0, 100%, 50%, 0.3); /* τιμή hsla με ποσοστά και a */
+    
+    /* Εικόνες μπορούν να τοποθετηθούν στον φόντο ενός αντικειμένου */
+    background-image: url(/img-path/img.jpg);
+    
+    /* Γραμματοσειρές */
+    font-family: Arial;
+    /* εάν η γραμματοσειρα περιέχει κενά */
+    font-family: "Courier New";
+    /* εάν η πρώτη γραμματοσειρα δε βρεθεί εγκατεστημένη στο Λειτουργικό Σύστυμα, αυτόματα 
+      επιλέγετε η δεύτερη, κ.κ.ε. */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+}
+```
+
+## Χρήση
+
+Αποθηκεύουμε ένα αρχείο CSS με την επέκταση `.css`.
+
+```xml
+<!-- Πρέπει να συμπεριλάβουμε το αρχείο στην επικεφαλίδα(head) ενος HTML αρχείου.
+  σσ. http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+
+<!-- Μπορούμε να το ενσωματώσουμε -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Ή απευθείας σε κάποιο αντικείμενο (inline) -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Ειδικότητα των κανόνων (Cascading απο το αγγλικό τίτλο Cascading Style Sheets)
+
+Ένα αντικείμενο μπορεί να στοχευθεί απο πολλούς κανόνες και μπορεί η ίδια ιδιότητα να 
+περιλαμβάνετε σε πολλούς κανόνες. Σε αυτές της περιπτώσεις υπερισχύει πάντα ο πιο ειδικός 
+κανόνας και απο αυτούς, αυτός που εμφανίζεται τελευταίος.
+
+```css
+/* A */
+p.class1[attr='value']
+
+/* B */
+p.class1 { }
+
+/* C */
+p.class2 { }
+
+/* D */
+p { }
+
+/* E */
+p { property: value !important; }
+```
+
+```xml
+<p style='/*F*/ property:value;' class='class1 class2' attr='value' />
+```
+
+Η σειρά θα είναι:
+
+* `E` έχει μεγαλύτερο βάρος λόγω του `!important`. Κάλες πρακτικές λένε να το αποφεύγουμε.
+* `F` επόμενο λόγω του inline κανόνα.
+* `A` επόμενο λόγω του το οτι είναι πιο ειδικό. Περιέχει τρεις selectors.
+* `C` επόμενο, λόγω του οτι εμφανίζεται μετα το Β και ας έχει την ίδια ειδικότητα.
+* `B` επόμενο.
+* `D` τελευταίο.
+
+## Συμβατότητα
+
+Τα περισσότερα απο τα παραπάνω ήδη υποστηρίζονται απο τους γνωστούς φυλλομετρητές. Άλλα θα πρέπει 
+πάντα να ελέγχουμε πρωτου τους χρησιμοποιήσουμε.
+
+## Περισσότερα
+
+* Έλεγχος συμβατότητας, [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/)
+
+## Μελέτη
+
+* [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/el-gr/racket-gr.html.markdown b/el-gr/racket-gr.html.markdown
index 4c4576bb..589adfeb 100644
--- a/el-gr/racket-gr.html.markdown
+++ b/el-gr/racket-gr.html.markdown
@@ -31,12 +31,12 @@ H Racket είναι μια γενικού σκοπού, πολυ-υποδειγ�
 
 ;; Τα σχόλια S-expression (εκφράσεις S) comments απορρίπτουν την
 ;; έκφραση που ακολουθεί, δυνατότητα που είναι χρήσιμη για να
-;; κάνουμε σχόλια κάποιες εκφράσεις κατα τη διάρκεια του debugging
+;; κάνουμε σχόλια κάποιες εκφράσεις κατά τη διάρκεια του debugging
 
 #; (αυτή η έκφραση δεν θα εκτελεστεί)
 
 ;; (Αν δεν καταλαβαίνεται τι είναι οι εκφράσεις , περιμένετε... Θα το μάθουμε
-;; πολύ συντομα!)
+;; πολύ σύντομα!)
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -57,8 +57,8 @@ H Racket είναι μια γενικού σκοπού, πολυ-υποδειγ�
 ;; όπου το f είναι η συνάρτηση και τα x y z
 ;; είναι οι όροι που η συνάρτηση δέχεται
 ;; ως ορίσματα. Αν θέλουμε να δημιουργήσουμε
-;; μια λίστα στην κυριολεξία απο δίαφορα δεδομένα,
-;; χρησιμοποιούμε το ' για να το εμποδίσουμε απο το να
+;; μια λίστα στην κυριολεξία από δίαφορα δεδομένα,
+;; χρησιμοποιούμε το ' για να το εμποδίσουμε από το να
 ;; αξιολογηθεί σαν έκφραση. Για παράδειγμα:
 '(+ 1 2) ; => Παραμένει (+ 1 2) και δεν γίνεται η πράξη
 ;; Τώρα , ας κάνουμε μερικές πράξεις
@@ -88,15 +88,15 @@ H Racket είναι μια γενικού σκοπού, πολυ-υποδειγ�
 ;;; Τα αλφαριθμητικά είναι πίνακες χαρακτήρων συγκεκριμένου μήκους
 "Hello, world!"
 "Benjamin \"Bugsy\" Siegel"   ; Το backslash είναι χαρακτήρας διαφυγής
-"Foo\tbar\41\x21\u0021\a\r\n" ; Συμπεριλαμβάνονται οι χαρακτήες διαφυγής της C,
+"Foo\tbar\41\x21\u0021\a\r\n" ; Συμπεριλαμβάνονται οι χαρακτήρες διαφυγής της C,
 							  ; σε Unicode
 "λx:(μα.α→α).xx"              ; Μπορούν να υπάρχουν και Unicode χαρακτήρες
 
-;; Μπορούμε να εννώσουμε αλφαριθμητικά!
+;; Μπορούμε να ενώσουμε αλφαριθμητικά!
 (string-append "Hello " "world!") ; => "Hello world!"
 
-;; Ένα αλφαριθμητικό μπορούμε να το χρησιμοπιησουμε
-;; όπως και μια λίστα απο χαρακτήρες
+;; Ένα αλφαριθμητικό μπορούμε να το χρησιμοποιήσουμε
+;; όπως και μια λίστα από χαρακτήρες
 (string-ref "Apple" 0) ; => #\A ;; Παίρνουμε το πρώτο στοιχείο
 
 ;; Η συνάρτηση format μπορεί να χρησιμοποιηθεί για
@@ -117,18 +117,18 @@ H Racket είναι μια γενικού σκοπού, πολυ-υποδειγ�
 some-var ; => 5
 
 ;; Μπορούμε επίσης να χρησιμοποιήσουμε unicode χαρακτήρες.
-(define ⊆ subset?) ;; Εδώ ουστιαστικά δίνουμε στη ήδη ύπαρχουσα συνάρτηση subset?
+(define ⊆ subset?) ;; Εδώ ουσιαστικά δίνουμε στη ήδη υπάρχουσα συνάρτηση subset?
 				   ;; ένα νέο όνομα ⊆ , και παρακάτω την καλούμε με το νέο της όνομα.
 (⊆ (set 3 2) (set 1 2 3)) ; => #t
 
-;; Αν ζητήσουμε μια μεταβλητή που δεν έχει οριστεί πρίν π.χ
+;; Αν ζητήσουμε μια μεταβλητή που δεν έχει οριστεί πριν π.χ.
 (printf name)
 ;; θα πάρουμε το παρακάτω μήνυμα
 ;name: undefined;
 ;  cannot reference undefined identifier
 ;   context...:
 
-;; Η τοπική δέσμευση : `me' δευσμεύεται με το "Bob" μόνο μέσα στο (let ...)
+;; Η τοπική δέσμευση : `me' δεσμεύεται με το "Bob" μόνο μέσα στο (let ...)
 (let ([me "Bob"])
   "Alice"
   me) ; => "Bob"
@@ -156,7 +156,7 @@ my-pet ; => #<dog>
 ;;; Λίστες
 
 ;; Οι λίστες είναι linked-list δομές δεδομένων,
-;; που έχουν δημιουργηθεί απο ζευγάρια 'cons'
+;; που έχουν δημιουργηθεί από ζευγάρια 'cons'
 ;; και τελειώνουν με 'null' (ή αλλιώς '()) για να
 ;; δηλώσουν ότι αυτό είναι το τέλος της λίστας
 (cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
@@ -191,12 +191,12 @@ my-pet ; => #<dog>
 ;; Τα διανύσματα είναι πίνακες σταθερού μήκους
 #(1 2 3) ; => '#(1 2 3)
 
-;; Χρησιμοποιύμε το `vector-append' για να προσθέσουμε διανύσματα
+;; Χρησιμοποιούμε το `vector-append' για να προσθέσουμε διανύσματα
 (vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
 
 ;;; Σύνολα
 
-;; Δημιουργούμε ένα σύνολο απο μία λίστα
+;; Δημιουργούμε ένα σύνολο από μία λίστα
 (list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3)
 
 ;; Προσθέτουμε έναν αριθμό στο σύνολο χρησιμοποιώντας το `set-add'
@@ -214,10 +214,10 @@ my-pet ; => #<dog>
 ;; Δημιουργήστε ένα αμετάβλητο πίνακα κατακερματισμού
 (define m (hash 'a 1 'b 2 'c 3))
 
-;; Παίρνουμε μια τιμή απο τον πίνακα
+;; Παίρνουμε μια τιμή από τον πίνακα
 (hash-ref m 'a) ; => 1
 
-;; Άν ζητήσουμε μια τιμή που δέν υπάρχει παίρνουμε μία εξαίρεση
+;; Αν ζητήσουμε μια τιμή που δεν υπάρχει παίρνουμε μία εξαίρεση
 ; (hash-ref m 'd) => no value found for key
 
 ;; Μπορούμε να δώσουμε μια default τιμή για τα κλειδιά που λείπουν
@@ -234,7 +234,7 @@ m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3))
 m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
 
 ;; Χρησιμοποιούμε το `hash-remove' για να αφαιρέσουμε
-;; κλειδία
+;; κλειδιά
 (hash-remove m 'a) ; => '#hash((b . 2) (c . 3))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -247,12 +247,12 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
 ;; Μπορούμε επίσης να χρησιμοποιήσουμε το `λ'
 (λ () "Hello World")     ; => Ίδια συνάρτηση
 
-;; Χρησιμοποιύμε τις παρενθέσεις για να καλέσουμε όλες τις συναρτήσεις
+;; Χρησιμοποιούμε τις παρενθέσεις για να καλέσουμε όλες τις συναρτήσεις
 ;; συμπεριλαμβανομένων και των εκφράσεων 'λάμδα'
 ((lambda () "Hello World")) ; => "Hello World"
 ((λ () "Hello World"))      ; => "Hello World"
 
-;; Εκχωρούμε σε μια μετάβλητη την συνάρτηση
+;; Εκχωρούμε σε μια μεταβλητή την συνάρτηση
 (define hello-world (lambda () "Hello World"))
 (hello-world) ; => "Hello World"
 
@@ -302,7 +302,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
   (lambda (name . args)
     (format "Hello ~a, you passed ~a extra args" name (length args))))
 
-;; Και με λέξεις κλειδία
+;; Και με λέξεις κλειδιά
 (define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args)
   (format "~a ~a, ~a extra args" g name (length args)))
 (hello-k)                 ; => "Hello World, 0 extra args"
@@ -347,7 +347,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
 
 (eq? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f
 
-;; Το `eqv?' υποστηρίζει την σύκριση αριθμών αλλα και χαρακτήρων
+;; Το `eqv?' υποστηρίζει την σύγκριση αριθμών αλλά και χαρακτήρων
 ;; Για άλλα ήδη μεταβλητών το `eqv?' και το `eq?' επιστρέφουν το ίδιο.
 (eqv? 3 3.0)                                   ; => #f
 (eqv? (expt 2 100) (expt 2 100))               ; => #t
@@ -365,12 +365,12 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
 (equal? (list 3) (list 3))                                       ; => #t
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 5. Έλεχγος Ροής
+;; 5. Έλεγχος Ροής
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;; Συνθήκες (conditionals)
 
-(if #t               ; έκφραση ελέχγου
+(if #t               ; έκφραση ελέγχου
     "this is true"   ; έκφραση then
     "this is false") ; έκφραση else
 ; => "this is true"
@@ -483,7 +483,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
   (values i (number->string i)))
 ; => '#hash((1 . "1") (2 . "2") (3 . "3"))
 
-;; Υπάρχουν πολλά είδη απο προϋπάρχοντες τρόπους για να συλλέγουμε
+;; Υπάρχουν πολλά είδη από προϋπάρχοντες τρόπους για να συλλέγουμε
 ;; τιμές από τους βρόχους
 
 (for/sum ([i 10]) (* i i)) ; => 285
@@ -491,7 +491,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
 (for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t
 (for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t
 
-;; Και για να χρησιμοποιήσουμε ένα αφθαίρετο συνδιασμό χρησιμοποιούμε
+;; Και για να χρησιμοποιήσουμε ένα αυθαίρετο συνδυασμό χρησιμοποιούμε
 ;; το 'for/fold'
 (for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10
 
@@ -524,17 +524,17 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- δεν υπάρχει `d'
 (set! n (add1 n))
 n ; => 6
 
-;; Χρησιμοποιούμε τα boxes για να δηλώσουμε ρητά ότι μια μεταβητή
-;; θα είναι  mutable (θα μπορεί να αλλάξη η τιμή της)
+;; Χρησιμοποιούμε τα boxes για να δηλώσουμε ρητά ότι μια μεταβλητή
+;; θα είναι  mutable (θα μπορεί να αλλάξει η τιμή της)
 ;; Αυτό είναι παρόμοιο με τους pointers σε άλλες γλώσσες
 (define n* (box 5))
 (set-box! n* (add1 (unbox n*)))
 (unbox n*) ; => 6
 
 
-;; Πολλοί τύποι μεταβλητών στη Racket είναι αμετάβλητοι πχ τα ζεύγη, οι
+;; Πολλοί τύποι μεταβλητών στη Racket είναι αμετάβλητοι π.χ. τα ζεύγη, οι
 ;; λίστες κτλ. Άλλοι υπάρχουν και σε μεταβλητή και σε αμετάβλητη μορφή
-;; πχ αλφαριθμητικά, διανύσματα κτλ
+;; π.χ. αλφαριθμητικά, διανύσματα κτλ.
 (define vec (vector 2 2 3 4))
 (define wall (make-vector 100 'bottle-of-beer))
 ;; Χρησιμοποιούμε το 'vector-set!' για να ανεώσουμε κάποια
@@ -579,7 +579,7 @@ vec ; => #(1 2 3 4)
     (printf fmt (make-string n ch))
     (newline)))
 
-;; Χρησιμοποιομε το 'require' για να πάρουμε όλα τα
+;; Χρησιμοποιουμε το 'require' για να πάρουμε όλα τα
 ;; παρεχόμενα ονόματα από μία ενότητα
 (require 'cake) ; το ' είναι για τοπική υποενότητα
 (print-cake 3)
@@ -634,7 +634,7 @@ vec ; => #(1 2 3 4)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Οι μακροεντολές μας επιτρέπουν να επεκτείνουμε
-;; το συντακτικό μιάς γλώσσας.
+;; το συντακτικό μιας γλώσσας.
 
 ;; Ας προσθέσουμε έναν βρόχο while
 (define-syntax-rule (while condition body ...)
@@ -664,20 +664,20 @@ vec ; => #(1 2 3 4)
 ;;   (set! tmp other)
 ;;   (set! other tmp_1))
 
-;; Αλλά ακόμα υπάρχουν ακόμη μετασχηματισμοί του κώδικα, π.χ:
+;; Αλλά ακόμα υπάρχουν ακόμη μετασχηματισμοί του κώδικα, π.χ.:
 (define-syntax-rule (bad-while condition body ...)
   (when condition
     body ...
     (bad-while condition body ...)))
-;; αυτή η μακροεντολή είναι χαλασμένη: δημιουγεί ατέρμονα βρόχο
+;; αυτή η μακροεντολή είναι χαλασμένη: δημιουργεί ατέρμονα βρόχο
 ;; και αν προσπαθήσουμε να το χρησιμοποιήσουμε, ο μεταγλωττιστής
-;; θα μπεί στον ατέρμονα βρόχο.
+;; θα μπει στον ατέρμονα βρόχο.
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; 10. Συμβόλαια (Contracts)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; Τα συμβόλαια βάζουν περιορισμόυς σε τιμές που προέρχονται
+;; Τα συμβόλαια βάζουν περιορισμούς σε τιμές που προέρχονται
 ;; από ενότητες (modules)
 (module bank-account racket
   (provide (contract-out
@@ -719,7 +719,7 @@ vec ; => #(1 2 3 4)
 (displayln "Hola mundo" out-port)
 (close-output-port out-port)
 
-;; Διαβάζουμε απο αρχείο ξανά
+;; Διαβάζουμε από αρχείο ξανά
 (define in-port (open-input-file "/tmp/tmp.txt"))
 (displayln (read-line in-port))
 ; => "Hello World"
diff --git a/el-gr/scala-gr.html.markdown b/el-gr/scala-gr.html.markdown
index e29c7e70..415fda5c 100644
--- a/el-gr/scala-gr.html.markdown
+++ b/el-gr/scala-gr.html.markdown
@@ -40,7 +40,7 @@ Scala - Η επεκτάσιμη γλώσσα
 
 /*
   Τα σχόλια που επεκτείνονται σε πολλές γραμμές , όπως μπορείτε
-  να δείτε , φαίνοται κάπως έτσι.
+  να δείτε , φαίνονται κάπως έτσι.
 */
 
 // Εκτύπωση με νέα γραμμή στην επόμενη εκτύπωση
@@ -59,12 +59,12 @@ var y = 10
 y = 20  // το y είναι τώρα 20
 
 /*
-  Η Scala είναι στατικού τύπου γλώσσα, εν τούτις προσέξτε ότι στις παραπάνω
+  Η Scala είναι στατικού τύπου γλώσσα, εν τούτοις προσέξτε ότι στις παραπάνω
   δηλώσεις , δεν προσδιορίσαμε κάποιον τύπο. Αυτό συμβαίνει λόγω ενός
   χαρακτηριστικού της Scala που λέγεται συμπερασματολογία τύπων. Στις 
   περισσότερες των περιπτώσεων, ο μεταγλωττιστής της Scala μπορεί να
-  μαντέψει ποιός είναι ο τύπος μιας μεταβλητής. Μπορούμε να δηλώσουμε
-  αναλυτικά τον τύπο μιάς μεταβλητής ως εξής:
+  μαντέψει ποιος είναι ο τύπος μιας μεταβλητής. Μπορούμε να δηλώσουμε
+  αναλυτικά τον τύπο μιας μεταβλητής ως εξής:
 */
 val z: Int = 10
 val a: Double = 1.0
@@ -85,7 +85,7 @@ false
 true == false // false
 10 > 5 // true
 
-// Η αριθμιτική είναι όπως τα συνηθισμένα
+// Η αριθμητική είναι όπως τα συνηθισμένα
 1 + 1 // 2
 2 - 1 // 1
 5 * 3 // 15
@@ -117,14 +117,14 @@ true == false // false
 "Τα αλφαριθμητικά στην Scala περικλείονται από διπλά εισαγωγικά"
 'a' // Ένας χαρακτήρας στην Scala
 // res30: Char = a
-// 'Αλφαριθημτικά με μονά εισαγωγικά δεν υφίστανται <= Αυτό θα προκαλέσει σφάλμα.
+// Αλφαριθημτικά με μονά εισαγωγικά δεν υφίστανται <= Αυτό θα προκαλέσει σφάλμα.
 
 // Τα αλφαριθμητικά έχουν τις συνηθισμένες μεθόδους της Java ορισμένες πάνω τους.
 "hello world".length
 "hello world".substring(2, 6)
 "hello world".replace("C", "3")
 
-// Έχουν επίσης μερικές επιπλένον μεθόδους Scala. 
+// Έχουν επίσης μερικές επιπλέον μεθόδους Scala. 
 // Δείτε επίσης : scala.collection.immutable.StringOps
 "hello world".take(5)
 "hello world".drop(5)
@@ -253,7 +253,7 @@ r foreach println
 var i = 0
 while (i < 10) {  println("i " + i); i+=1  }
 
-while (i < 10) {  println("i " + i); i+=1  }   // Ναι ξανά! Τι συνέβει; Γιατί;
+while (i < 10) {  println("i " + i); i+=1  }   // Ναι ξανά! Τι συνέβη; Γιατί;
 
 i    // Εμφάνισε την τιμή του i. Σημειώστε ότι ένας βρόχος while είναι βρόχος
      // με την κλασική έννοια - εκτελείται σειριακά καθώς αλλάζει η μεταβλητή
@@ -268,8 +268,8 @@ do {
 } while (x < 10)
 
 // Η αναδρομή ουράς είναι ένας ιδιωματικός τρόπος να κάνεις επαναλαμβανόμενα
-// πράγματα στην Scala. Οι αναδρομικές συναρτήσεις απαιτούν να γράφτεί 
-// ρητά ο τύπος που θα επιστρέψουν , αλλιώς ο μεταγλωττιστής δεν μπορεί 
+// πράγματα στην Scala. Οι αναδρομικές συναρτήσεις απαιτούν να γραφτεί 
+// ρητά ο τύπος που θα επιστρέψουν, αλλιώς ο μεταγλωττιστής δεν μπορεί 
 // αλλιώς να τον συνάγει. Παρακάτω είναι μια συνάρτηση που επιστρέφει Unit.
 def showNumbersInRange(a:Int, b:Int):Unit = {
   print(a)
@@ -332,7 +332,7 @@ s(1)
 val divideInts = (x:Int, y:Int) => (x / y, x % y)
 
 divideInts(10,3) // Η συνάρτηση divideInts επιστρέφει το αποτέλεσμα 
-                 // της ακαίρεας διαίρεσης και το υπόλοιπο.
+                 // της ακέραιας διαίρεσης και το υπόλοιπο.
 
 // Για να έχουμε πρόσβαση στα στοιχεία μιας πλειάδας, χρησιμοποιούμε το _._n
 // όπου το n είναι ο δείκτης με βάση το 1 του στοιχείου.
@@ -349,7 +349,7 @@ d._2
 
 /*
   Ότι έχουμε κάνει ως τώρα σε αυτό το tutorial ήταν απλές εκφράσεις
-  (τιμές , συναρτήσεις , κτλ). Αυτές οι εκφράσεις βολεύουν όταν τις
+  (τιμές, συναρτήσεις, κτλ.). Αυτές οι εκφράσεις βολεύουν όταν τις
   γράφουμε στο REPL για γρήγορες δοκιμές, αλλά δεν μπορούν να υπάρχουν
   από μόνες τους σε ένα αρχείο Scala. Για παράδειγμα , δεν μπορούμε να
   έχουμε μόνο ένα "val x = 5" στο αρχείο Scala. Αντί αυτού , τα μόνα
@@ -394,7 +394,7 @@ println(mydog.bark) // => "Woof, woof!"
 // αυτές καθ' αυτές, αλλά η συμπρεριφορά που σχετίζεται με όλα τα instances 
 // της κλάσης πάνε μέσα στο object. Η διαφορά είναι παρόμοια με τις
 // μεθόδους κλάσεων σε σχέση με στατικές μεθόδους σε άλλες γλώσσες.
-// Προσέξτε οτι τα objects και οι κλάσεις μπορούν να έχουν το ίδιο όνομα.
+// Προσέξτε ότι τα objects και οι κλάσεις μπορούν να έχουν το ίδιο όνομα.
 object Dog {
   def allKnownBreeds = List("pitbull", "shepherd", "retriever")
   def createDog(breed: String) = new Dog(breed)
@@ -402,7 +402,7 @@ object Dog {
 
 // Οι κλάσεις περίπτωσης (case classes) είναι που έχουν την επιπλέον 
 // λειτουργικότητα ενσωματωμένη. Μιά συνήθης ερώτηση για αρχάριους στην
-// Scala είναι πότε να χρησιμοπούνται κλάσεις και πότε case κλάσεις.
+// Scala είναι πότε να χρησιμοποιούνται κλάσεις και πότε case κλάσεις.
 // Γενικά οι κλάσεις τείνουν να εστιάζουν στην ενθυλάκωση, τον
 // πολυμορφισμό και τη συμπεριφορά. Οι τιμές μέσα σε αυτές τις κλάσεις 
 // τείνουν να είναι private , και μόνο οι μέθοδοι είναι εκτεθειμένες.
@@ -411,7 +411,7 @@ object Dog {
 // έχουν παρενέργειες.
 case class Person(name: String, phoneNumber: String)
 
-// Δημιουργία ενός instance. Πραρατηρήστε ότι τα case classes 
+// Δημιουργία ενός instance. Παρατηρήστε ότι τα case classes 
 // δεν χρειάζονται την λέξη "new" .
 val george = Person("George", "1234")
 val kate = Person("Kate", "4567")
@@ -419,7 +419,7 @@ val kate = Person("Kate", "4567")
 // Με τα case classes, παίρνεις μερικά προνόμια δωρεάν , όπως:
 george.phoneNumber  // => "1234"
 
-// Ελέχγεται η ισότητα για κάθε πεδίο (δεν χρειάζεται να
+// Ελέγχεται η ισότητα για κάθε πεδίο (δεν χρειάζεται να
 // κάνουμε override στο .equals)
 Person("George", "1234") == Person("Kate", "1236")  // => false
 
@@ -509,7 +509,7 @@ List(1, 2, 3) map (x => x + 10)
 // ένα όρισμα στην ανώνυμη συνάρτηση. Έτσι δεσμεύεται ως η μεταβλητή.
 List(1, 2, 3) map (_ + 10)
 
-// Αν το μπλόκ της ανώνυμης  συνάρτησης ΚΑΙ η συνάρτηση που εφαρμόζεται
+// Αν το μπλοκ της ανώνυμης  συνάρτησης ΚΑΙ η συνάρτηση που εφαρμόζεται
 // (στην περίπτωσή μας το foreach και το println) παίρνουν ένα όρισμα
 // μπορείτε να παραλείψετε την κάτω παύλα.
 List("Dom", "Bob", "Natalia") foreach println
diff --git a/elixir.html.markdown b/elixir.html.markdown
index c8599838..eedeb227 100644
--- a/elixir.html.markdown
+++ b/elixir.html.markdown
@@ -369,6 +369,13 @@ spawn(f) #=> #PID<0.40.0>
 # messages to the process. To do message passing we use the `send` operator.
 # For all of this to be useful we need to be able to receive messages. This is
 # achieved with the `receive` mechanism:
+
+# The `receive do` block is used to listen for messages and process
+# them when they are received. A `receive do` block will only
+# process one received message. In order to process multiple
+# messages, a function with a `receive do` block must recursively
+# call itself to get into the `receive do` block again.
+
 defmodule Geometry do
   def area_loop do
     receive do
@@ -384,6 +391,8 @@ end
 
 # Compile the module and create a process that evaluates `area_loop` in the shell
 pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# Alternatively
+pid = spawn(Geometry, :area_loop, [])
 
 # Send a message to `pid` that will match a pattern in the receive statement
 send pid, {:rectangle, 2, 3}
diff --git a/erlang.html.markdown b/erlang.html.markdown
index 8b67a76a..d6ed7b86 100644
--- a/erlang.html.markdown
+++ b/erlang.html.markdown
@@ -25,6 +25,7 @@ filename: learnerlang.erl
 %% 1. Variables and pattern matching.
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
+% In Erlang new variables are bound with an `=` statement.
 Num = 42.  % All variable names must start with an uppercase letter.
 
 % Erlang has single-assignment variables; if you try to assign a different
@@ -32,9 +33,11 @@ Num = 42.  % All variable names must start with an uppercase letter.
 Num = 43. % ** exception error: no match of right hand side value 43
 
 % In most languages, `=` denotes an assignment statement. In Erlang, however,
-% `=` denotes a pattern-matching operation. `Lhs = Rhs` really means this:
-% evaluate the right side (`Rhs`), and then match the result against the
-% pattern on the left side (`Lhs`).
+% `=` denotes a pattern-matching operation. When an empty variable is used on the
+% left hand side of the `=` operator to is bound (assigned), but when a bound
+% variable is used on the left hand side the following behaviour is observed.
+% `Lhs = Rhs` really means this: evaluate the right side (`Rhs`), and then
+% match the result against the pattern on the left side (`Lhs`).
 Num = 7 * 6.
 
 % Floating-point number.
@@ -289,7 +292,7 @@ calculateArea() ->
       _ ->
         io:format("We can only calculate area of rectangles or circles.")
     end.
-    
+
 % Compile the module and create a process that evaluates `calculateArea` in the
 % shell.
 c(calculateGeometry).
@@ -299,6 +302,39 @@ CalculateArea ! {circle, 2}. % 12.56000000000000049738
 % The shell is also a process; you can use `self` to get the current pid.
 self(). % <0.41.0>
 
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% 5. Testing with EUnit
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+% Unit tests can be written using EUnits's test generators and assert macros
+-module(fib).
+-export([fib/1]).
+-include_lib("eunit/include/eunit.hrl").
+
+fib(0) -> 1;
+fib(1) -> 1;
+fib(N) when N > 1 -> fib(N-1) + fib(N-2).
+
+fib_test_() ->
+    [?_assert(fib(0) =:= 1),
+     ?_assert(fib(1) =:= 1),
+     ?_assert(fib(2) =:= 2),
+     ?_assert(fib(3) =:= 3),
+     ?_assert(fib(4) =:= 5),
+     ?_assert(fib(5) =:= 8),
+     ?_assertException(error, function_clause, fib(-1)),
+     ?_assert(fib(31) =:= 2178309)
+    ].
+
+% EUnit will automatically export to a test() function to allow running the tests
+% in the erlang shell
+fib:test()
+
+% The popular erlang build tool Rebar is also compatible with EUnit
+% ```
+% rebar eunit
+% ```
+
 ```
 
 ## References
diff --git a/es-es/amd-es.html.markdown b/es-es/amd-es.html.markdown
new file mode 100644
index 00000000..7a59ddd6
--- /dev/null
+++ b/es-es/amd-es.html.markdown
@@ -0,0 +1,214 @@
+---
+
+category: tool
+tool: amd
+contributors:
+    - ["Frederik Ring", "https://github.com/m90"]
+
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+filename: learnamd-es.js
+lang: es-es
+---
+
+## Iniciando con AMD
+
+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:
+// `define(id?, dependencias?, fábrica)` define un módulo
+// `require(dependencias, callback)` importa un conjunto de dependencias y
+// las consume al invocar el callback
+
+// Comencemos usando define para definir un nuevo módulo
+// que no posee dependencias. Lo haremos enviando un nombre
+// y una función fábrica para definirla:
+define('awesomeAMD', function(){
+  var isAMDAwesome = function(){
+    return true;
+  };
+  // El valor que regresa la función fábrica del módulo será
+  // lo que los otros módulos o llamados require recibirán cuando
+  // soliciten nuestro módulo `awesomeAMD`.
+  // El valor exportado puede ser cualquier cosa, funciones (constructores),
+  // objetos, primitivos, incluso indefinidos (aunque eso no ayuda mucho).
+  return isAMDAwesome;
+});
+
+// Ahora definamos otro módulo que dependa de nuestro módulo `awesomeAMD`.
+// Observe que ahora hay un argumento adicional que define 
+// las dependencias de nuestro módulo:
+define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
+  // las dependencias serán enviadas a los argumentos de la fábrica
+  // en el orden que sean especificadas
+  var tellEveryone = function(){
+    if (awesomeAMD()){
+      alert('This is sOoOo rad!');
+    } else {
+      alert('Pretty dull, isn\'t it?');
+    }
+  };
+  return tellEveryone;
+});
+
+// Como ya sabemos utilizar define usemos ahora `require` para poner en marcha
+//  nuestro programa. La firma de `require` es `(arrayOfDependencies, callback)`.
+require(['loudmouth'], function(loudmouth){
+  loudmouth();
+});
+
+// Para hacer que este tutorial corra código, vamos a implementar una
+// versión muy básica (no-asíncrona) de AMD justo aquí:
+function define(name, deps, factory){
+  // observa como son manejados los módulos sin dependencias
+  define[name] = require(factory ? deps : [], factory || deps);
+}
+
+function require(deps, callback){
+  var args = [];
+  // primero recuperemos todas las dependencias que necesita
+  // el llamado require
+  for (var i = 0; i < deps.length; i++){
+    args[i] = define[deps[i]];
+  }
+  // satisfacer todas las dependencias del callback
+  return callback.apply(null, args);
+}
+// puedes ver este código en acción aquí: http://jsfiddle.net/qap949pd/
+```
+
+### Uso en el mundo real con require.js
+
+En contraste con el ejemplo introductorio, `require.js` (la librería AMD más popular) implementa la **A** de **AMD**, permitiéndote cargar los módulos y sus dependencias asincrónicamente via XHR:
+
+```javascript
+/* file: app/main.js */
+require(['modules/someClass'], function(SomeClass){
+  // el callback es diferido hasta que la dependencia sea cargada
+  var thing = new SomeClass();
+});
+console.log('So here we are, waiting!'); // esto correrá primero
+```
+
+Por convención, usualmente guardas un módulo en un fichero. `require.js` puede resolver los nombres de los módulos basados en rutas de archivo, de forma que no tienes que nombrar tus módulos, simplemente referenciarlos usando su ubicación. En el ejemplo `someClass` asumimos que se ubica en la carpeta `modules`, relativa a tu `baseUrl` configurada:
+
+* app/
+  * main.js
+  * modules/
+    * someClass.js
+    * someHelpers.js
+    * ...
+  * daos/
+    * things.js
+    * ...
+
+Esto significa que podemos definir `someClass` sin especificar su id de módulo:
+
+```javascript
+/* file: app/modules/someClass.js */
+define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
+  // definición de módulo, por supuesto, ocurrirá también asincrónicamente
+  function SomeClass(){
+    this.method = function(){/**/};
+    // ...
+  }
+  return SomeClass;
+});
+```
+
+Para alterar el comportamiento del mapeo de ruta usa `requirejs.config(configObj)` en tu `main.js`:
+
+```javascript
+/* file: main.js */
+requirejs.config({
+  baseUrl : 'app',
+  paths : {
+    // también puedes cargar módulos desde otras ubicaciones
+    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){
+  // un fichero `main` necesita llamar a require al menos una vez,
+  // de otra forma jamás correrá el código
+  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
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Cien etiquetas de script? Nunca más!</title>
+</head>
+<body>
+  <script src="require.js" data-main="app/main"></script>
+</body>
+</html>
+```
+
+### Optimizar todo un proyecto usando r.js
+
+Muchas personas prefieren usar AMD para la organización del código durante el desarrollo, pero quieren enviar para producción un solo fichero en vez de ejecutar cientos de XHRs en las cargas de página.
+
+`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 */
+({
+  name : 'main', // nombre del punto de entrada
+  out : 'main-built.js', // nombre del fichero donde se escribirá la salida
+  baseUrl : 'app',
+  paths : {
+    // `empty:` le dice a r.js que esto aún debe ser cargado desde el CDN, usando
+    // la ubicación especificada en `main.js`
+    jquery : 'empty:',
+    coolLibFromBower : '../bower_components/cool-lib/coollib'
+  }
+})
+```
+
+Para usar el fichero creado en producción, simplemente intercambia `data-main`:
+```html
+<script src="require.js" data-main="app/main-built"></script>
+```
+
+Un increíblemente detallado [resumen de opciones de generación](https://github.com/jrburke/r.js/blob/master/build/example.build.js) está disponible en el repositorio de GitHub.
+
+### Tópicos no cubiertos en este tutorial
+* [Cargador de plugins / transformaciones](http://requirejs.org/docs/plugins.html)
+* [Cargando y exportando estilos CommonJS](http://requirejs.org/docs/commonjs.html)
+* [Configuración avanzada](http://requirejs.org/docs/api.html#config)
+* [Configuración de Shim (cargando módulos no-AMD)](http://requirejs.org/docs/api.html#config-shim)
+* [Cargando y optimizando CSS con require.js](http://requirejs.org/docs/optimization.html#onecss)
+* [Usando almond.js para construcciones](https://github.com/jrburke/almond)
+
+### Otras lecturas:
+
+* [Especificaciones oficiales](https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [¿Por qué AMD?](http://requirejs.org/docs/whyamd.html)
+* [Definición Universal de Módulos](https://github.com/umdjs/umd)
+
+### Implementaciones:
+
+* [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/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown
new file mode 100644
index 00000000..bcc775e5
--- /dev/null
+++ b/es-es/c++-es.html.markdown
@@ -0,0 +1,829 @@
+---
+language: c++
+filename: learncpp.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+translators:
+    - ["Gerson Lázaro", "https://gersonlazaro.com"]
+lang: es-es
+---
+
+C++ es un lenguaje de programación de sistemas que,
+[de acuerdo a su inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+fue diseñado para
+
+- ser un "mejor C"
+- soportar abstracción de datos
+- soportar programación orientada a objetos
+- soportar programación genérica
+
+Aunque su sintaxis puede ser más difícil o compleja que los nuevos lenguajes, 
+es ampliamente utilizado, ya que compila instrucciones nativas que pueden ser 
+directamente ejecutadas por el procesador y ofrece un estricto control sobre 
+el hardware (como C), mientras ofrece características de alto nivel como 
+genericidad, excepciones, y clases. Esta combinación de velocidad y 
+funcionalidad hace de C ++ uno de los lenguajes de programación más utilizados.
+
+```c++
+////////////////////
+// Comparación con C
+////////////////////
+
+// C ++ es _casi_ un superconjunto de C y comparte su sintaxis básica para las 
+// declaraciones de variables, tipos primitivos y funciones.
+
+// Al igual que en C, el punto de entrada de tu programa es una función llamada 
+// main con un retorno de tipo entero. 
+// Este valor sirve como código de salida del programa.
+// Mira http://en.wikipedia.org/wiki/Exit_status para mayor información.
+int main(int argc, char** argv)
+{
+	// Los argumentos de la línea de comandos se pasan por argc y argv de la 
+	// misma manera que en C.
+	// argc indica el número de argumentos, 
+	// y argv es un arreglo de strings de estilo C (char*) 
+	// representando los argumentos.
+	// El primer argumento es el nombre con el que el programa es llamado.
+	// argc y argv pueden omitirse si no te preocupan los argumentos, 
+	// dejando la definición de la función como int main ()
+
+	// Un estado de salida 0 indica éxito.
+    return 0;
+}
+
+// Sin embargo, C ++ varía en algunas de las siguientes maneras:
+
+// En C++, los caracteres literales son caracteres
+sizeof('c') == sizeof(char) == 1
+
+// En C, los caracteres literales son enteros
+sizeof('c') == sizeof(int)
+
+
+// C++ tiene prototipado estricto
+void func(); // función que no acepta argumentos
+
+// En C
+void func(); // función que puede aceptar cualquier número de argumentos
+
+// Use nullptr en lugar de NULL en C++
+int* ip = nullptr;
+
+// Las cabeceras (headers) estándar de C están disponibles en C ++, 
+// pero tienen el prefijo "c" y no tienen sufijo .h.
+#include <cstdio>
+
+int main()
+{
+    printf("Hola mundo!\n");
+    return 0;
+}
+
+//////////////////////////
+// Sobrecarga de funciones
+//////////////////////////
+
+// C++ soporta sobrecarga de funciones
+// siempre que cada función tenga diferentes parámetros.
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("Mi entero es %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // Resolves to void print(const char*)
+    print(15); // Resolves to void print(int)
+}
+
+////////////////////////////////////
+// Argumentos de función por defecto
+////////////////////////////////////
+
+// Puedes proporcionar argumentos por defecto para una función si no son 
+// proporcionados por quien la llama.
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Hacer algo con los enteros aqui
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Los argumentos predeterminados deben estar al final de la lista de argumentos.
+
+void invalidDeclaration(int a = 1, int b) // Error!
+{
+}
+
+/////////////////////
+// Espacios de nombre
+/////////////////////
+
+// Espacios de nombres proporcionan ámbitos separados para variable, función y 
+// otras declaraciones.
+// Los espacios de nombres se pueden anidar.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("Esto es First::Nested::foo\n");
+        }
+    } // fin del nombre de espacio Nested
+} // fin del nombre de espacio First
+
+namespace Second {
+    void foo()
+    {
+        printf("Esto es Second::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("Este es global: foo\n");
+}
+
+int main()
+{
+
+	// Incluye todos los símbolos del espacio de nombre Second en el ámbito 
+	// actual. Tenga en cuenta que simplemente foo() no funciona, ya que ahora 
+	// es ambigua si estamos llamando a foo en espacio de nombres Second o en
+	// el nivel superior.
+    using namespace Second;
+
+    Second::foo(); // imprime "Esto es Second::foo"
+    First::Nested::foo(); // imprime "Esto es First::Nested::foo"
+    ::foo(); // imprime "Este es global: foo"
+}
+
+/////////////////
+// Entrada/Salida
+/////////////////
+
+// La entrada y salida de C++ utiliza flujos (streams)
+// cin, cout, y cerr representan a stdin, stdout, y stderr.
+// << es el operador de inserción >> es el operador de extracción.
+
+
+#include <iostream> // Incluir para el flujo de entrada/salida
+
+using namespace std; // Los streams estan en std namespace (libreria estandar)
+
+int main()
+{
+   int myInt;
+
+   // Imprime a la stdout (o terminal/pantalla)
+   cout << "Ingresa tu número favorito:\n";
+   // Toma una entrada
+   cin >> myInt;
+
+   // cout puede también ser formateado
+   cout << "Tu número favorito es " << myInt << "\n";
+   // imprime "Tu número favorito es <myInt>"
+
+    cerr << "Usado para mensajes de error";
+}
+////////////////////
+// Cadenas (Strings)
+////////////////////
+
+// Las cadenas en C++ son objetos y tienen muchas funciones
+#include <string>
+
+using namespace std; // Strings también estan en namespace std
+
+string myString = "Hola";
+string myOtherString = " Mundo";
+
+// + es usado para concatenar.
+cout << myString + myOtherString; // "Hola Mundo"
+
+cout << myString + " Tu"; // "Hola Tu"
+
+// Las cadenas en C++ son mutables y tienen valor semántico.
+myString.append(" Perro");
+cout << myString; // "Hola Perro"
+
+
+//////////////
+// Referencias
+//////////////
+
+// Además de punteros como los de C,
+// C++ tiene _references_.
+// Estos tipos de puntero no pueden ser reasignados una vez establecidos
+// Y no pueden ser nulos.
+// También tienen la misma sintaxis que la propia variable:
+// No es necesaria * para eliminar la referencia y
+// & (dirección) no se utiliza para la asignación.
+
+using namespace std;
+
+string foo = "Yo soy foo";
+string bar = "Yo soy bar";
+
+string& fooRef = foo; // Crea una referencia a foo.
+fooRef += ". Hola!"; // Modifica foo través de la referencia
+cout << fooRef; // Imprime "Yo soy foo. Hola!"
+
+// No trate de reasignar "fooRef". Esto es lo mismo que "foo = bar", y
+//   foo == "Yo soy bar"
+// después de esta linea.
+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.
+
+// Sidetrack: Antes de hablar más sobre referencias, hay que introducir un 
+// concepto llamado objeto temporal. Supongamos que tenemos el siguiente código:
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Lo que pasa en la segunda línea es en realidad:
+// - Un objeto de cadena es retornado desde 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
+// creados cada vez que una función devuelve un objeto, y es destruido en el
+// fin de la evaluación de la expresión que encierra (Bueno, esto es lo que la
+// norma dice, pero los compiladores están autorizados a cambiar este 
+// comportamiento. Busca "return value optimization" para ver mas detalles). 
+// Así que en este código:
+foo(bar(tempObjectFun()))
+
+// Suponiendo que foo y bar existen, el objeto retornado de tempObjectFun es
+// pasado al bar, y se destruye antes de llamar foo.
+
+// Ahora, de vuelta a las referencias. La excepción a la regla "en el extremo 
+// de la expresión encerrada" es si un objeto temporal se une a una 
+// referencia constante, en cuyo caso su vida se extiende al ámbito actual:
+
+void constReferenceTempObjectFun() {
+  // ConstRef obtiene el objeto temporal, y es válido hasta el final de esta
+  // función.
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// Otro tipo de referencia introducida en C ++ 11 es específicamente para
+// objetos temporales. No se puede tener una variable de este tipo, pero tiene 
+// prioridad en resolución de sobrecarga:
+
+void someFun(string& s) { ... }  // Referencia regular
+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
+
+// Por ejemplo, puedes ver estas dos versiones de constructores para
+// std::basic_string:
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// La idea es que si estamos construyendo una nueva cadena de un objeto temporal 
+// (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".
+
+////////////////////////////////////////////
+// Clases y programación orientada a objetos
+////////////////////////////////////////////
+
+// Primer ejemplo de clases
+#include <iostream>
+
+// Declara una clase.
+// Las clases son usualmente declaradas en archivos de cabeceras (.h o .hpp)
+class Dog {
+    // Variables y funciones de la clase son privados por defecto.
+    std::string name;
+    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.
+public:
+
+    // Constructor por defecto
+    Dog();
+
+	// Declaraciones de funciones de la clase (implementaciones a seguir)
+    // Nota que usamos std::string aquí en lugar de colocar
+    // using namespace std;
+    // arriba.
+    // Nunca ponga una declaración "using namespace" en un encabezado.
+    void setName(const std::string& dogsName);
+
+    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.
+	// También tenga en cuenta que las funciones deben ser declaradas 
+	// explícitamente como _virtual_ para que sea reemplazada en las clases 
+	// derivadas.
+	// Las funciones no son virtuales por defecto por razones de rendimiento.	
+    virtual void print() const;
+
+    // Las funciones también se pueden definir en el interior 
+    // del cuerpo de la clase.
+	// Funciones definidas como tales están entre líneas automáticamente.
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // Junto a los constructores, C++ proporciona destructores.
+	// Estos son llamados cuando un objeto se elimina o está fuera del ámbito.
+	// 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 
+	// la clase base o puntero.
+    virtual ~Dog();
+
+
+
+}; // Un punto y coma debe seguir la definición de clase.
+
+// Las funciones de una clase son normalmente implementados en archivos .cpp.
+Dog::Dog()
+{
+    std::cout << "Un perro ha sido construido\n";
+}
+
+// Objetos (tales como cadenas) deben ser pasados por referencia
+// Si los estas modificando o referencia constante en caso contrario.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Nota que "virtual" sólo se necesita en la declaración, no en la definición.
+void Dog::print() const
+{
+    std::cout << "El perro es " << name << " y pesa " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    cout << "Adiós " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // imprime "Un perro ha sido construido"
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // imprime "El perro es Barkley y pesa 10 kg"
+    return 0;
+} // imprime "Adiós Barkley"
+
+// Herencia:
+
+// Esta clase hereda todo lo público y protegido de la clase Dog
+class OwnedDog : public Dog {
+
+    void setOwner(const std::string& dogsOwner);
+
+	// 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
+	// polimorfismo de subtipo.
+	// La palabra clave override es opcional, pero asegura que estás
+	// reemplazando el método de una clase base.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Mientras tanto, en el archivo .cpp correspondiente:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Llama a la función de impresión en la clase base Dog
+    std::cout << "El perro es de " << owner << "\n";
+    // Imprime "El perro es <name> y pesa <weight>"
+    //         "El perro es de <owner>"
+}
+
+////////////////////////////////////////////
+// Inicialización y sobrecarga de operadores
+////////////////////////////////////////////
+
+// En C ++ se puede sobrecargar el comportamiento 
+// de los operadores como +, -, *, /, etc.
+// Esto se hace mediante la definición de una función que es llamada
+// cada vez que se utiliza el operador.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Las variables de la clase pueden dar valores por defecto de esta manera.
+    double x = 0;
+    double y = 0;
+
+	// Define un constructor por defecto que no hace nada
+    // 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
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* No hace nada excepto inicializar los valores */ }
+
+    // Sobrecarga el operador +
+    Point operator+(const Point& rhs) const;
+
+    // Sobrecarga el operador +=
+    Point& operator+=(const Point& rhs);
+
+    // También tendría sentido añadir los operadores - y -=,
+   	// Pero vamos a omitirlos por razones de brevedad.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Crea un nuevo punto que es la suma de este y rhs.
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // 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)"
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+/////////////////////////
+// Plantillas (Templates)
+/////////////////////////
+
+// Las plantillas en C++ se utilizan sobre todo en la programación genérica, 
+// a pesar de que son mucho más poderoso que los constructores genéricos 
+// en otros lenguajes. Ellos también soportan especialización explícita y 
+// parcial y clases de tipo estilo funcional; de hecho, son un lenguaje 
+// funcional Turing-completo incrustado en C ++!
+
+// Empezamos con el tipo de programación genérica que podría estar 
+// familiarizado. 
+// Para definir una clase o función que toma un parámetro de tipo:
+template<class T>
+class Box {
+public:
+    // En este caso, T puede ser usado como cualquier otro tipo.
+    void insert(const T&) { ... }
+};
+
+// Durante la compilación, el compilador realmente genera copias de cada 
+// plantilla con parámetros sustituidos, por lo que la definición completa 
+// de la clase debe estar presente en cada invocación. 
+// Es por esto que usted verá clases de plantilla definidas
+// Enteramente en archivos de cabecera.
+
+//Para crear una instancia de una clase de plantilla en la pila:
+Box<int> intBox;
+
+y puedes utilizarlo como era de esperar:
+intBox.insert(123);
+
+// Puedes, por supuesto, anidar plantillas:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// Hasta C++11, había que colocar un espacio entre los dos '>'s, 
+// de lo contrario '>>' serían analizados como el operador de desplazamiento 
+// a la derecha.
+
+
+// A veces verás
+//   template<typename T>
+// en su lugar. La palabra clave "class" y las palabras 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).
+
+// Del mismo modo, una plantilla de función:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Observe que no se especifica nada acerca de los tipos de parámetros aquí. 
+// El compilador generará y comprobará cada invocación de la plantilla, 
+// por lo que la función anterior funciona con cualquier tipo "T" 
+// que tenga un método 'bark' constante!
+
+
+Dog fluffy;
+fluffy.setName("Fluffy")
+barkThreeTimes(fluffy); // Imprime "Fluffy barks" 3 veces.
+
+Los parámetros de la plantilla no tienen que ser las clases:
+template<int Y>
+void printMessage() {
+  cout << "Aprende C++ en " << Y << " minutos!" << endl;
+}
+
+// Y usted puede especializar explícitamente plantillas 
+// para código más eficiente. 
+// Por supuesto, la mayor parte del mundo real que utiliza una especialización 
+// no son tan triviales como esta.
+// Tenga en cuenta que usted todavía tiene que declarar la función (o clase) 
+// como plantilla incluso si ha especificado de forma explícita todos 
+// los parámetros.
+
+template<>
+void printMessage<10>() {
+  cout << "Aprende C++ rapido en solo 10 minutos!" << endl;
+}
+
+printMessage<20>();  // Prints "Aprende C++ en 20 minutos!"
+printMessage<10>();  // Prints "Aprende C++ rapido en solo 10 minutos!"
+
+
+/////////////////////
+// Manejador de excepciones
+/////////////////////
+
+// La biblioteca estándar proporciona algunos tipos de excepción
+// (mira http://en.cppreference.com/w/cpp/error/exception)
+// pero cualquier tipo puede ser lanzado como una excepción
+#include <exception>
+#include <stdexcept>
+
+//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_.
+    throw std::runtime_error("Ocurrió un problema");
+}
+
+// Captura excepciones por referencia const si son objetos
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+********************************************************************************
+// Captura cualquier excepción no capturada por bloques _catch_ anteriores
+catch (...)
+{
+    std::cout << "Excepción desconocida capturada";
+    throw; // Re-lanza la excepción
+}
+
+///////
+// RAII
+///////
+
+// RAII significa "Resource Acquisition Is Initialization"
+// (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.
+
+// Para entender cómo esto es útil,
+// Considere una función que utiliza un identificador de archivo C:
+void doSomethingWithAFile(const char* filename)
+{
+    // Para empezar, asuma que nada puede fallar.
+
+    FILE* fh = fopen(filename, "r"); // Abre el archivo en modo lectura
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Cierra el manejador de archivos
+}
+
+// Por desgracia, las cosas se complican rápidamente por el control de errores.
+// Supongamos que fopen puede fallar, y que doSomethingWithTheFile y
+// DoSomethingElseWithIt retornan códigos de error si fallan.
+// 	(Excepciones son la mejor forma de manejar los fallos,
+// 	 pero algunos programadores, especialmente los que tienen un fondo C,
+// 	 estan en desacuerdo sobre la utilidad de las excepciones).
+// Ahora tenemos que comprobar cada llamado por fallos y cerrar el manejador 
+// del archivo si se ha producido un problema.
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Abre el archivo en modo lectura
+    if (fh == nullptr) // El puntero retornado es nulo o falla.
+        return false; // Reporta el fallo a quien hizo el llamado.
+
+    // Asume que cada función retorna falso si falla
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Cierre el manejador de archivo para que no se filtre.
+        return false; // Propaga el error.
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Cierre el manejador de archivo para que no se filtre.
+        return false; // Propaga el error.
+    }
+
+    fclose(fh); // Cierre el archivo.
+    return true; // Indica que todo funcionó correctamente.
+}
+
+// Programadores C suelen limpiar esto un poco usando 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); // Cierre el archivo.
+    return true; // Indica que todo funcionó correctamente.
+
+failure:
+    fclose(fh);
+    return false; // Propagate el error
+}
+
+// Si las funciones indican errores mediante excepciones,
+// Las cosas son un poco más claras, pero pueden optimizarse mas.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Abrir el archivo en modo lectura
+    if (fh == nullptr)
+        throw std::runtime_error("No puede abrirse el archivo.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Asegúrese de cerrar el archivo si se produce un error.
+        throw; // Luego vuelve a lanzar la excepción.
+    }
+
+    fclose(fh); // Cierra el archivo
+}
+
+// Compare esto con el uso de la clase de flujo de archivos de C++ (fstream)
+// fstream utiliza su destructor para cerrar el archivo.
+// Los destructores son llamados automáticamente 
+// cuando un objeto queda fuera del ámbito.
+void doSomethingWithAFile(const std::string& filename)
+{
+    // ifstream es la abreviatura de el input file stream
+    std::ifstream fh(filename); // Abre el archivo
+
+    // Hacer algo con el archivo
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // El archivo se cierra automáticamente aquí por el destructor
+
+
+// Esto tiene ventajas _enormes_:
+// 1. No importa lo que pase,
+//    El recurso (en este caso el manejador de archivo) será limpiado.
+//    Una vez que escribes el destructor correctamente,
+//    Es _imposible_ olvidar cerrar el identificador y permitir 
+//    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
+//    Sin que tenga que preocuparse por ello.
+// 3. El código es seguro.
+//    Una excepción puede ser lanzado en cualquier lugar de la función
+//    y la limpieza ocurrirá.
+
+// Todo el código idiomático C++ utiliza RAII ampliamente para todos los 
+// recursos.
+// Otros ejemplos incluyen
+// - Memoria usando unique_ptr y shared_ptr
+// - Contenedores (Containers) - la biblioteca estándar linked list,
+//   vector (es decir, array con auto-cambio de tamaño), hash maps, etc.
+//   Destruimos todos sus contenidos de forma automática 
+//   cuando quedan fuera del ámbito.
+// - Mutex utilizando lock_guard y unique_lock
+
+
+/////////////////////
+// Cosas divertidas
+/////////////////////
+
+// Aspectos de C ++ que pueden sorprender a los recién llegados 
+// (e incluso algunos veteranos).
+// Esta sección es, por desgracia, salvajemente incompleta; 
+// C++ es uno de los lenguajes con los que mas facil te disparas en el pie.
+
+// Tu puedes sobreescribir métodos privados!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Sobreescribe Foo::bar!
+};
+
+
+// 0 == false == NULL (La mayoria de las veces)!
+bool* pt = new bool;
+*pt = 0; // Establece los puntos de valor de 'pt' en falso.
+pt = 0;  // Establece 'pt' al apuntador nulo. Ambas lineas compilan sin error.
+
+// nullptr se supone que arregla un poco de ese tema:
+int* pt2 = new int;
+*pt2 = nullptr; // No compila
+pt2 = nullptr;  // Establece pt2 como null.
+
+// Hay una excepción para los valores bool.
+// Esto es para permitir poner a prueba punteros nulos con if (!ptr),
+// pero como consecuencia se puede asignar nullptr a un bool directamente!
+*pt = nullptr;  // Esto todavía compila, a pesar de que '*pt' es un bool!
+
+// '=' != '=' != '='!
+// Llama Foo::Foo(const Foo&) o alguna variante (mira movimientos semanticos) 
+// copia del constructor.
+Foo f2;
+Foo f1 = f2;
+
+// Llama Foo::Foo(const Foo&) o variante, pero solo copia el 'Foo' parte de
+// 'fooSub'. Cualquier miembro extra de 'fooSub' se descarta. Este 
+// comportamiento horrible se llama "Corte de objetos."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Llama a Foo::operator=(Foo&) o variantes.
+Foo f1;
+f1 = f2;
+
+
+// Cómo borrar realmente un contenedor:
+class Foo { ... };
+vector<Foo> v;
+for (int i = 0; i < 10; ++i)
+  v.push_back(Foo());
+// La siguiente línea establece el tamaño de v en 0, 
+// pero los destructores no son llamados y los recursos no se liberan!
+
+v.empty();
+v.push_back(Foo());  // Nuevo valor se copia en el primer Foo que insertamos
+
+// En verdad destruye todos los valores en v. 
+// Consulta la sección acerca de los objetos temporales para la
+// explicación de por qué esto funciona.
+v.swap(vector<Foo>());
+
+```
+Otras lecturas:
+
+Una referencia del lenguaje hasta a la fecha se puede encontrar en
+<http://cppreference.com/w/cpp>
+
+Recursos adicionales se pueden encontrar en <http://cplusplus.com>
diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 73853a9d..18b544b4 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -11,15 +11,15 @@ lang: es-es
 ---
 
 Git es un sistema de control de versiones distribuido diseñado para manejar
-cualquier tipo de proyecto ya sea largos o pequeños, con velocidad y eficiencia.
+cualquier tipo de proyecto, ya sea grande o pequeño, con velocidad y eficiencia.
 
 Git realiza esto haciendo "snapshots" del proyecto, con ello permite
 versionar y administrar nuestro código fuente.
 
 ## Versionamiento, conceptos.
 
-### Que es el control de versiones?
-El control de versiones es un sistema que guarda todos los cambios realizados a
+### Qué es el control de versiones?
+El control de versiones es un sistema que guarda todos los cambios realizados en
 uno o varios archivos, a lo largo del tiempo.
 
 ### Versionamiento centralizado vs Versionamiento Distribuido.
@@ -31,15 +31,15 @@ uno o varios archivos, a lo largo del tiempo.
 + El versionamiento distribuido no tiene una estructura definida, incluso se
   puede mantener el estilo de los repositorios SVN con git.
 
-[Informacion adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
+[Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
 
-### Por que usar Git?
+### Por qué usar Git?
 
 * Se puede trabajar sin conexion.
-* Colaborar con otros es sencillo!.
-* Derivar, Crear ramas del proyecto (aka: Branching) es facil!.
+* ¡Colaborar con otros es sencillo!.
+* Derivar, crear ramas del proyecto (aka: Branching) es fácil.
 * Combinar (aka: Merging)
-* Git es rapido.
+* Git es rápido.
 * Git es flexible.
 
 ## Arquitectura de Git.
@@ -48,10 +48,10 @@ uno o varios archivos, a lo largo del tiempo.
 
 Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
 comits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
-y que sus atributos otorgan  acceso al historial del elemento, ademas de otras
+y que sus atributos otorgan acceso al historial del elemento, además de otras
 cosas.
 
-Un repositorio esta compuesto por la carpeta .git y un "arbol de trabajo".
+Un repositorio esta compuesto por la carpeta .git y un "árbol de trabajo".
 
 ### Directorio .git (componentes del repositorio)
 
@@ -62,38 +62,38 @@ y mas.
 
 ### Directorio de trabajo (componentes del repositorio)
 
-Es basicamente los directorios y archivos dentro del repositorio. La mayorioa de
+Es basicamente los directorios y archivos dentro del repositorio. La mayoría de
 las veces se le llama "directorio de trabajo".
 
-### Inidice (componentes del directorio .git)
+### Índice (componentes del directorio .git)
 
-El inidice es la area de inicio en git. Es basicamente la capa que separa el
-directorio de trabajo, del repositorio en git. Esto otorga a los desarrolladores
-mas poder sobre lo que envia y recibe en el repositorio.
+El índice es el área de inicio en git. Es basicamente la capa que separa el
+directorio de trabajo del repositorio en git. Esto otorga a los desarrolladores
+más poder sobre lo que se envía y se recibe del repositorio.
 
 ### Commit (aka: cambios)
 
 Un commit es una captura de un conjunto de cambios, o modificaciones hechas en
-el directorio de trabajo. Por ejemplo, si se añaden 5 archivos, se remueven 2,
-estos cambios se almacenaran en un commit (aka: captura). Este commit puede ser o
+el directorio de trabajo. Por ejemplo, si se añaden 5 archivos, se eliminan 2,
+estos cambios se almacenarán en un commit (aka: captura). Este commit puede ser o
 no ser enviado (aka: "pusheado") hacia un repositorio.
 
 ### Branch (rama)
 
-Un "branch", es escencialmente un apuntador hacia el ultimo commit (cambio
-registrado) que se ha realizado. A medida que se realizan mas commits, este
-apuntador se actualizara automaticamente hacia el ultimo commit.
+Un "branch", es escencialmente un apuntador hacia el último commit (cambio
+registrado) que se ha realizado. A medida que se realizan más commits, este
+apuntador se actualizará automaticamente hacia el ultimo commit.
 
-### "HEAD" y "head" (component of .git dir)
+### "HEAD" y "head" (componentes del directorio .git)
 
 "HEAD" es un apuntador hacia la rama (branch) que se esta utilizando. Un
 repositorio solo puede tener un HEAD activo. En cambio "head", es un apuntador a
-cualquier commit realizado, un repositorio puede tener cualquier numero de
+cualquier commit realizado, un repositorio puede tener cualquier número de
 "heads".
 
 ### conceptos - recursos.
 
-* [Git para informaticos](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git para informáticos](http://eagain.net/articles/git-for-computer-scientists/)
 * [Git para diseñadores](http://hoth.entp.com/output/git_for_designers.html)
 
 
@@ -102,8 +102,8 @@ cualquier commit realizado, un repositorio puede tener cualquier numero de
 
 ### init
 
-Crear un repositorio de git vacio. Las configuraciones, informacion almacenada y
-demas son almacenadas en el directorio ".git".
+Crear un repositorio de git vacio. Las configuraciones, información almacenada y
+demás son almacenadas en el directorio ".git".
 
 ```bash
 $ git init
@@ -115,7 +115,7 @@ Se utiliza para configurar las opciones ya sea globalmente, o solamente en el
 repositorio.
 
 ```bash
-# Imprime y guarda algunas variables de configuracion basicas. (Globalmente)
+# Imprime y guarda algunas variables de configuracion básicas. (Globalmente)
 $ git config --global user.email
 $ git config --global user.name
 
@@ -123,15 +123,15 @@ $ git config --global user.email "corre@gmail.com"
 $ git config --global user.name "nombre"
 ```
 
-[Mas sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git)
+[Más sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git)
 
 ### help
 
-Otorga un accceso rapido a una guia extremadamente detallada de cada comando en
+Otorga un accceso rápido a una guía extremadamente detallada de cada comando en
 git. O puede ser usada simplemente como un recordatorio de estos.
 
 ```bash
-# Una vista rapido de los comandos disponibles.
+# Una vista rápida de los comandos disponibles.
 $ git help
 
 # Chequear todos los comandos disponibles
@@ -146,12 +146,12 @@ $ git help init
 
 ### status
 
-Muestra las diferencias entre el archivo indice y el commit al cual apunta el
+Muestra las diferencias entre el archivo índice y el commit al cual apunta el
 HEAD actualmente.
 
 
 ```bash
-# Mostrara el "branch", archivos sin añadir a la repo, cambios y otras
+# Mostrará el "branch", archivos sin añadir al repo, cambios y otras
 # diferencias
 $ git status
 
@@ -161,9 +161,9 @@ $ git help status
 
 ### add
 
-Para añadir archivos al arbol (directorio, repositorio) de trabajo. Si no se
-utiliza `git add`, los nuevos archivos no se añadiran al arbol de trabajo, por
-lo que no se incluiran en los commits (cambios).
+Para añadir archivos al árbol (directorio, repositorio) de trabajo. Si no se
+utiliza `git add`, los nuevos archivos no se añadirán al arbol de trabajo, por
+lo que no se incluirán en los commits (cambios).
 
 ```bash
 # Añade un archivo en el directorio de trabajo actual.
@@ -178,31 +178,31 @@ $ git add ./*.py
 
 ### branch
 
-Administra las ramas del repositorios ("branches"). Puedes ver, editar, crear y
+Administra las ramas del repositorio ("branches"). Puedes ver, editar, crear y
 borrar ramas ("branches"), usando este comando.
 
 ```bash
 # lista todas las ramas (remotas y locales)
 $ git branch -a
 
-# Añada una nueva rama ("branch").
+# Añadir una nueva rama ("branch").
 $ git branch branchNueva
 
 # Eliminar una rama.
 $ git branch -d branchFoo
 
-# Renombra una rama.
+# Renombrar una rama.
 # git branch -m <anterior> <nuevo>
 $ git branch -m youngling padawan
 
-# Edita la descripcion de la rama.
+# Editar la descripcion de la rama.
 $ git branch master --edit-description
 ```
 
 ### checkout
 
 Actualiza todos los archivos en el directorio de trabajo para que sean igual que
-las versiones almacenadas en el indice, o en un arbol de trabajo especificado.
+las versiones almacenadas en el índice, o en un árbol de trabajo especificado.
 
 ```bash
 # Despachar un repositorio. - Por defecto la master branch. (la rama principal llamada 'master')
@@ -215,8 +215,8 @@ $ git checkout -b jdei
 
 ### clone
 
-Clona, o copia, una repo existente en un nuevo directorio. Tambien añada el
-seguimiento hacia las ramas existentes del repo que ha sido clonada, lo que
+Clona, o copia, un repositorio existente en un nuevo directorio. También añade el
+seguimiento hacia las ramas existentes del repositorio que ha sido clonado, lo que
 permite subir (push) los archivos hacia una rama remota.
 
 ```bash
@@ -226,60 +226,60 @@ $ git clone https://github.com/jquery/jquery.git
 
 ### commit
 
-Almacena los cambios que almacenados en el indice en un nuevo "commit". Este
-commit contiene los cambios hechos mas un resumen hecho por el desarrollador.
+Almacena el contenido actual del índice en un nuevo "commit". Este
+commit contiene los cambios hechos más un resumen proporcionado por el desarrollador.
 
 ```bash
-# commit with a message
 # realizar un commit y añadirle un mensaje.
 $ git commit -m "jedi anakin wil be - jedis.list"
 ```
 
 ### diff
 
-Muestra las diferencias entre un archivo en el directorio de trabajo, el indice
-y commits.
+Muestra las diferencias entre un archivo en el directorio de trabajo, el índice
+y los commits.
 
 ```bash
-# Muestra la diferencia entre un directorio de trabajo y el indice.
+# Muestra la diferencia entre un directorio de trabajo y el índice.
 $ git diff
 
-# Muestra la diferencia entre el indice y los commits mas recientes.
+# Muestra la diferencia entre el índice y los commits más recientes.
 $ git diff --cached
 
-# Muestra la diferencia entre el directorio de trabajo y el commit mas reciente.
+# Muestra la diferencia entre el directorio de trabajo y el commit más reciente.
 $ git diff HEAD
 ```
 
 ### grep
 
-Permite realizar una busqueda rapida en un repositorio.
+Permite realizar una busqueda rápida en un repositorio.
 
-Configuracion opcionales:
+Configuraciones opcionales:
 
 ```bash
 # Gracias a Travis Jeffery por compartir lo siguiente.
 # Permite mostrar numeros de lineas en la salida de grep.
 $ git config --global grep.lineNumber true
 
-# Realiza una busqueda mas lejible, incluyendo agrupacion.
+# Realiza una búsqueda mas legible, incluyendo agrupación.
 $ git config --global alias.g "grep --break --heading --line-number"
 ```
 
 ```bash
-# Busca por "unaVariable" en todos los archivos ,java
+# Busca por "unaVariable" en todos los archivos .java
 $ git grep 'unaVariable' -- '*.java'
 
-# Busca por una linea que contenga "nombreArreglo" y , "agregar" o "remover"
+# Busca por una línea que contenga "nombreArreglo" y "agregar" o "remover"
 $ git grep -e 'nombreArreglo' --and \( -e agregar -e remover \)
 ```
 
-Mas ejemplos:
-[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+Más ejemplos:
+
+- [Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
 
 ### log
 
-Muestra los commits (cambios) registrados en el repositotrio.
+Muestra los commits (cambios) registrados en el repositorio.
 
 ```bash
 # Muestra todos los commits.
@@ -288,7 +288,7 @@ $ git log
 # Muestra un numero x de commits.
 $ git log -n 10
 
-# Muestra solo los commits que se han combinado en el hisotrial
+# Muestra solo los commits que se han combinado en el historial.
 $ git log --merges
 ```
 
@@ -301,7 +301,7 @@ que se trabaja.
 # Combina la rama especificada en la rama actual.
 $ git merge jediMaster
 
-# Siempre genere un solo merge commit cuando se utilizar merge.
+# Siempre genere un solo merge commit cuando se utiliza merge.
 $ git merge --no-ff jediMaster
 ```
 
@@ -310,7 +310,7 @@ $ git merge --no-ff jediMaster
 Renombra o mueve un archivo
 
 ```bash
-# Renombrando un archivo
+# Renombrando un archivo.
 $ git mv HolaMundo.c AdiosMundo.c
 
 # Moviendo un archivo.
@@ -322,33 +322,31 @@ $ git mv -f archivoA archivoB
 
 ### pull
 
-Sube (Empuja) de un repositorio y lo combina en otro en una rama diferente.
+Trae los cambios de un repositorio y los combina en otro en una rama diferente.
 
 ```bash
-# Actualiza el repositorio local, combinando los nuevos cambios.
+# Actualiza el repositorio local, combinando los nuevos cambios
 # de las ramas remotas "origin" y "master".
-# from the remote "origin" and "master" branch.
 # git pull <remota> <rama>
 $ git pull origin master
 ```
 
 ### push
 
-Push and merge changes from a branch to a remote & branch.
+Envía y combina los cambios de un repositorio local a un repositorio y rama remotos.
 
 ```bash
-# Push and merge changes from a local repo to a
-# Empuja y combina cambios de un repositorio local hacian un repositorio remoto
+# Envía y combina cambios de un repositorio local hacia un repositorio remoto
 # llamados "origin" y "master", respectivamente.
 # git push <remota> <rama>
 # git push => por defecto es lo mismo que poner =>  git push origin master
 $ git push origin master
 ```
 
+### rebase
 
 Toma todos los cambios que fueron registrados en una rama, y los repite dentro
-de otra rama.
-*No reescribe los commits que se han empujado antes a un repositorio publico*
+de otra rama. *No reescribe los commits que se han empujado antes a un repositorio público.*
 
 ```bash
 # Integrar ramaExperimento dentro de la rama "master"
@@ -356,47 +354,47 @@ de otra rama.
 $ git rebase master experimentBranch
 ```
 
-[Informacion adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar)
+[Información adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar)
 
-### reset (precaucion)
+### reset (precaución)
 
-Reinicia el cabezal actual hacia un estado especificado. Esto permite desacer
-combinaciones (merges), pulls, commits, adds y mas. Es un comando util, pero
-tambien peligrosa si no se sabe lo que se hace.
+Reinicia el HEAD actual hacia un estado especificado. Esto permite deshacer
+combinaciones (merges), pulls, commits, adds y más. Es un comando útil, pero
+tambien peligroso si no se sabe lo que se hace.
 
 ```bash
-# Reinica el area principal, con el ultimo cambio registrado. (deja los
+# Reinicia el área principal, con el último cambio registrado. (deja los
 # directorios sin cambios)
 $ git reset
 
-# Reinica el area principal, con el ultimo cambio registrado, y reescribe el
+# Reinicia el área principal, con el último cambio registrado, y reescribe el
 # directorio de trabajo.
 $ git reset --hard
 
 # Mueve la rama actual hacia el commit especificado (no realiza cambios a los
-# directorios), todos los cambios aun existen el directorio.
+# directorios), todos los cambios aún existen el directorio.
 $ git reset 31f2bb1
 
-# Mueve la rama actual devuelta a un commit especificado asi como el
-# directorios (borra todos los cambios que no fueron registros y todos los
-# cambios realizados despues del commit especificado).
+# Mueve la rama actual devuelta a un commit especificado, así como el
+# directorio (borra todos los cambios que no fueron registrados y todos los
+# cambios realizados después del commit especificado).
 $ git reset --hard 31f2bb1
 ```
 
 ### rm
 
-Lo contrario de git add, git rm remueve los archivos del directorio de trabajo
+Lo contrario de git add, git rm elimina los archivos del directorio de trabajo
 actual.
 
 ```bash
-# Remueve FooBar.c
+# Elimina FooBar.c
 $ git rm FooBar.c
 
-# Remueve un archivo de un directorio.
+# Elimina un archivo de un directorio.
 $ git rm /directorio/del/archivo/FooBar.c
 ```
 
-## Informacion Adicional
+## Información Adicional
 
 * [tryGit - Una forma entretenida y rapida de aprender Git.](http://try.github.io/levels/1/challenges/1)
 
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index fd01e7b9..d475cf42 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -16,7 +16,7 @@ con Java para aplicaciones más complejas. Debido a su integracion estrecha con
 web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común 
 para front-end que Java.
 
-JavaScript no sólo se limita a los navegadores web, aunque: Node.js, Un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
+Aunque JavaScript no sólo se limita a los navegadores web: Node.js, Un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
 
 ¡La retroalimentación es bienvenida! Puedes encontrarme en: 
 [@adambrenecki](https://twitter.com/adambrenecki), o
@@ -124,7 +124,7 @@ undefined; // usado para indicar que un valor no está presente actualmente
            // (aunque undefined es un valor en sí mismo)
 
 // false, null, undefined, NaN, 0 y "" es false; todo lo demás es true.
-// Note que 0 is false y "0" es true, a pesar de que 0 == "0".
+// Note que 0 es false y "0" es true, a pesar de que 0 == "0".
 // Aunque 0 === "0" sí es false.
 
 ///////////////////////////////////
@@ -478,9 +478,6 @@ miNumero === miNumeroObjeyo; // = false
 if (0){
     // Este código no se ejecutara porque 0 es false.
 }
-if (Number(0)){
-    // Este código sí se ejecutara, puesto que Number(0) es true.
-}
 
 // Aún así, los objetos que envuelven y los prototipos por defecto comparten
 // un prototipo. así que puedes agregar funcionalidades a un string de la 
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 95a16412..e4181609 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -45,7 +45,7 @@ Esto se basa en la versión `0.3.11`.
 # Los comentarios de una línea comienzan con una almohadilla (o signo de gato).
 
 #=
-  Los commentarios multilínea pueden escribirse
+  Los comentarios multilínea pueden escribirse
   usando '#=' antes de el texto  y '=#'
   después del texto. También se pueden anidar.
 =#
@@ -174,7 +174,7 @@ otraVariable_123! = 6    # => 6
     otra_variable
 
   * Los nombres de los tipos comienzan con una letra mayúscula y separación de
-    palabras se muestra con CamelCase en vez de guion bajo:
+    palabras se muestra con CamelCase en vez de guión bajo:
 
     OtroTipo
 
@@ -214,7 +214,7 @@ matrix = [1 2; 3 4]
      3  4
 =#
 
-# Añadir cosas a la final de un arreglo con push! y append!.
+# Añadir cosas al final de un arreglo con push! y append!.
 push!(a, 1)      # => [1]
 push!(a, 2)      # => [1,2]
 push!(a, 4)      # => [1,2,4]
@@ -237,7 +237,7 @@ a[end]    # => 6
 shift!(a)         # => 1 y a es ahora: [2,4,3,4,5,6]
 unshift!(a, 7)    # => [7,2,4,3,4,5,6]
 
-# Los nombres de funciónes que terminan en exclamaciones indican que modifican
+# Los nombres de funciones que terminan en exclamaciones indican que modifican
 # su o sus argumentos de entrada.
 arr = [5, 4, 6]    # => 3-element Array{Int64,1}: [5,4,6]
 sort(arr)          # => [4,5,6] y arr es todavía: [5,4,6]
@@ -710,7 +710,7 @@ end
 # Sólo define una función del mismo nombre que el tipo y llama al constructor
 # existente para obtener un valor del tipo correcto.
 
-# Este es un constructor externo porque es fuera de la definición del tipo.
+# Este es un constructor externo porque está fuera de la definición del tipo.
 Leon(rugido::String) = Leon("verde", rugido)
 
 type Pantera <: Gato    # Pantera también es un a subtipo de Gato
@@ -730,10 +730,10 @@ end
 ########################
 
 # En Julia, todas las funciones nombradas son funciones genéricas.
-# Esto significa que se construyen a partir de muchos métodosmás pequeños.
+# Esto significa que se construyen a partir de muchos métodos más pequeños.
 # Cada constructor de Leon es un método de la función genérica Leon.
 
-# Por ejemplo, vamos a hacer métodos para para Leon, Pantera, y Tigre de una
+# Por ejemplo, vamos a hacer métodos para Leon, Pantera, y Tigre de una
 # función genérica maullar:
 
 # acceso utilizando notación de puntos
diff --git a/es-es/ruby-es.html.markdown b/es-es/ruby-es.html.markdown
index 66a5d0fe..d8b67fe7 100644
--- a/es-es/ruby-es.html.markdown
+++ b/es-es/ruby-es.html.markdown
@@ -5,8 +5,18 @@ contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
   - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
 translators:
     - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+    - ["Erick Bernal", "http://www.twitter.com/billowkib"]
 lang: es-es
 ---
 
@@ -33,6 +43,8 @@ Tu tampoco deberías
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
 
 # La aritmética es sólo azúcar sintáctico
 # para llamar un método de un objeto
@@ -55,8 +67,6 @@ false.class #=> FalseClass
 # Desigualdad
 1 != 1 #=> false
 2 != 1 #=> true
-!true  #=> false
-!false #=> true
 
 # Además de 'false', 'nil' es otro valor falso
 
@@ -70,14 +80,29 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
+# Operadores lógicos
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Existen versiones alternativas de los operadores lógicos con menor prioridad
+# 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()
+
+
 # Los strings son objetos
 
 'Soy un string'.class #=> String
 "Soy un string también".class #=> String
 
-referente = "usar interpolacion de strings"
+referente = "usar interpolación de strings"
 "Yo puedo #{referente} usando strings de comillas dobles"
-#=> "Yo puedo usar interpolacion de strings usando strings de comillas dobles"
+#=> "Yo puedo usar interpolación de strings usando strings de comillas dobles"
 
 
 # Imprime a la salida estándar
@@ -119,15 +144,16 @@ status == :aprovado #=> false
 # Arreglos
 
 # Esto es un arreglo
-[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+arreglo = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
 # Arreglos pueden contener elementos de distintos tipos
 
-arreglo = [1, "hola", false] #=> => [1, "hola", false]
+[1, "hola", false] #=> => [1, "hola", false]
 
 # Arreglos pueden ser indexados
 # Desde el frente
 arreglo[0] #=> 1
+arreglo.first #=> 1
 arreglo[12] #=> nil
 
 # Tal como la aritmética, el acceso como variable[índice]
@@ -138,15 +164,25 @@ arreglo.[] 12 #=> nil
 
 # Desde el final
 arreglo[-1] #=> 5
+arreglo.last #=> 5
+
+# Con un índice de inicio y longitud
+arreglo[2, 3] #=> [3, 4, 5]
 
-# Con un índice de inicio y final
-arreglo[2, 4] #=> [3, 4, 5]
+# Invertir un arreglo
+a = [1, 2, 3]
+a.reverse! #=> [3, 2, 1]
 
 # O con rango
 arreglo[1..3] #=> [2, 3, 4]
 
 # Añade elementos a un arreglo así
 arreglo << 6 #=> [1, 2, 3, 4, 5, 6]
+# O así
+arreglo.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+#Verifica si un elemento ya existe en ese arreglo
+arreglo.include?(1) #=> true
 
 # Hashes son los diccionarios principales de Ruby con pares llave/valor.
 # Hashes se denotan con llaves:
@@ -161,17 +197,16 @@ hash['numero'] #=> 5
 # Preguntarle a un hash por una llave que no existe retorna 'nil':
 hash['nada aqui'] #=> nil
 
-# Itera sobre un hash con el método 'each':
-hash.each do |k, v|
-  puts "#{k} is #{v}"
-end
-
 # Desde Ruby 1.9, hay una sintaxis especial cuando se usa un símbolo como llave:
 
 nuevo_hash = { defcon: 3, accion: true}
 
 nuevo_hash.keys #=> [:defcon, :accion]
 
+# Verifica la existencia de llaves y valores en el hash
+new_hash.has_key?(:defcon) #=> true
+new_hash.has_value?(3) #=> true
+
 # Tip: Tanto los arreglos como los hashes son Enumerable (enumerables)
 # Comparten muchos métodos útiles tales como 'each', 'map', 'count', y más
 
@@ -194,9 +229,15 @@ end
 #=> iteracion 4
 #=> iteracion 5
 
-# Aunque
-# Nadie usa los ciclos `for`
-# Usa `each`, así:
+# SIN EMBARGO, nadie usa ciclos `for`
+# En su lugar debes usar el método "each" y pasarle un block (bloque).
+# Un bloque es un fragmento código que puedes pasar a métodos como `each`.
+# Es símilar a las funciones lambda, funciones anónimas o `closures` en otros
+# lenguajes de programación.
+#
+# El método `each` de un Range (rango) ejecuta el bloque una vez por cada elemento.
+# Al bloque se le pasa un contador como parametro.
+# Usar el método `each` con un bloque se ve así:
 
 (1..5).each do |contador|
   puts "iteracion #{contador}"
@@ -207,10 +248,27 @@ end
 #=> iteracion 4
 #=> iteracion 5
 
-counter = 1
-while counter <= 5 do
-  puts "iteracion #{counter}"
-  counter += 1
+# También puedes envolver el bloque entre llaves:
+(1..5).each { |counter| puts "iteración #{contador}" }
+
+#El contenido de las estructuras de datos en ruby puede ser iterado usando `each`.
+arreglo.each do |elemento|
+  puts "#{elemento} es parte del arreglo"
+end
+hash.each do |llave, valor|
+  puts "#{llave} es #{valor}"
+end
+
+# Si aún necesitas un índice puedes usar "each_with_index" y definir una variable
+# índice.
+arreglo.each_with_index do |element, index|
+  puts "#{element} tiene la posición #{index} en el arreglo"
+end
+
+contador = 1
+while contador <= 5 do
+  puts "iteracion #{contador}"
+  contador += 1
 end
 #=> iteracion 1
 #=> iteracion 2
@@ -218,6 +276,19 @@ end
 #=> iteracion 4
 #=> iteracion 5
 
+# Hay una gran variedad de otras funciones iterativas útiles en Ruby,
+# por ejemplo `map`, `reduce`,  `inject`, entre otras. Map, por ejemplo,
+# toma el arreglo sobre el cuál está iterando, le hace cambios
+# definidos en el bloque, y retorna un arreglo completamente nuevo.
+arreglo = [1,2,3,4,5]
+duplicado = array.map do |elemento|
+  elemento * 2
+end
+puts duplicado
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
 nota = 'B'
 
 case nota
@@ -234,6 +305,34 @@ when 'F'
 else
   puts "Sistema alternativo de notas, ¿eh?"
 end
+#=> "Mejor suerte para la proxima"
+
+# Los casos también pueden usar rangos
+nota = 82
+
+case nota
+when 90..100
+  puts 'Excelente!'
+when 80..100
+  puts 'Buen trabajo'
+else
+  puts '¡Reprobaste!'
+end
+#=> "Buen trabajo"
+
+# Manejo de excepciones
+begin
+  # código que podría causar excepción
+  raise NoMemoryError, 'Se te acabó la memoria'
+rescue NoMemoryError => variable_de_excepcion
+  puts 'El error NoMemoryError ocurrió', variable_de_excepcion
+rescue RuntimeError => otra_variable_de_excepcion
+  puts 'El error RuntimeError ocurrió'
+else
+  puts 'Esto se ejecuta si ningun error ocurrió'
+ensure
+  puts 'Este código siempre se ejecuta, sin importar que'
+end
 
 # Funciones
 
@@ -244,7 +343,7 @@ end
 # Funciones (y todos los bloques) implícitamente retornan el valor de la última instrucción
 doble(2) #=> 4
 
-# Paréntesis son opcionales cuando el resultado es ambiguo
+# Paréntesis son opcionales cuando el resultado no es ambiguo
 doble 3 #=> 6
 
 doble doble 3 #=> 12
@@ -259,7 +358,7 @@ suma 3, 4 #=> 7
 suma suma(3,4), 5 #=> 12
 
 # yield
-# Todos los métodos tienen un parámetro de bloqueo opcional e implícitp
+# Todos los métodos tienen un parámetro bloque opcional e implícito
 # puede llamarse con la palabra clave 'yield'
 
 def alrededor
@@ -274,6 +373,17 @@ alrededor { puts 'hola mundo' }
 # hola mundo
 # }
 
+# Puedes pasar un bloque a una función
+# '&' representa una referencia a un bloque
+def visitantes(&bloque)
+  bloque.call
+end
+
+# Puedes pasar una lista de argumentos, que serán convertidos en un arreglo
+# Para eso sirve el operador ('*')
+def visitantes(*arreglo)
+  arreglo.each { |visitante| puts visitante }
+end
 
 # Define una clase con la palabra clave 'class'
 class Humano
@@ -299,16 +409,26 @@ class Humano
     @nombre
   end
 
+  # La funcionalidad anterior puede ser encapsulada usando el método attr_accessor
+  # de la siguiente manera
+
+  attr_accessor :name
+
+  # Los métodos de tipo getter y setter también se pueden crear de manera individual
+  # de la siguiente manera
+
+  attr_reader :name
+  attr_writer :name
+
   # Un método de clase usa 'self' (sí mismo) para distinguirse de métodos de instancia.
   # Sólo puede ser llamado en la clase, no por una instancia.
   def self.decir(mensaje)
-    puts "#{mensaje}"
+    puts mensaje
   end
 
   def especie
     @@especie
   end
-
 end
 
 
@@ -328,6 +448,23 @@ dwight.nombre #=> "Dwight K. Schrute"
 # Llama el método de clase
 Humano.decir("Hi") #=> "Hi"
 
+# El alcance de las variables es definido por la manera en que las nombramos.
+# Las variables que inician con $ tienen un alcance global
+$var = "Soy una variable global"
+defined? $var #=> "global-variable"
+
+# Las variables que empiezan con @ tienen un alcance de instancia
+@var = "Soy una variable de instancia"
+defined? @var #=> "instance-variable"
+
+# Variables que empiezan con @@ tienen un alcance de clase
+@@var = "Soy una variable de clase"
+defined? @@var #=> "class variable"
+
+# Las variables que empiezan con letra mayuscula son constantes
+Var = "Soy una constante"
+defined? Var #=> "constant"
+
 # Las clases también son un objeto en ruby. Por lo cual, las clases también pueden tener variables de instancia.
 # Variables de clase son compartidas a través de la clase y todos sus descendientes.
 
@@ -371,7 +508,67 @@ end
 class Doctor < Humano
 end
 
-Human.bar # 0
+Humano.bar # 0
 Doctor.bar # nil
 
+module ModuloEjemplo
+  def foo
+    'foo'
+  end
+end
+
+# Al incluir un módulo sus métodos se comparten con las instancias de la clase
+# Al extender un módulo sus métodos se comparten con la clase misma
+
+class Persona
+  include ModuloEjemplo
+end
+
+class Libro
+  extend ModuloEjemplo
+end
+
+Persona.foo     # => NoMethodError: undefined method `foo' for Persona:Class
+Persona.new.foo # => 'foo'
+Libro.foo       # => 'foo'
+Libro.new.foo   # => NoMethodError: undefined method `foo'
+
+# Las llamadas de retorno (callbacks) son ejecutadas cuando se incluye o
+# extiende un módulo
+module EjemploConcern
+  def self.incluido(base)
+    base.extend(MetodosClase)
+    base.send(:include, MetodosInstancia)
+  end
+
+  module MetodosClase
+    def bar
+      'bar'
+    end
+  end
+
+  module MetodosInstancia
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Algo
+  include EjemploConcern
+end
+
+Algo.bar #=> 'bar'
+Algo.qux #=> NoMethodError: undefined method `qux'
+Algo.new.bar # => NoMethodError: undefined method `bar'
+Algo.new.qux # => 'qux'
 ```
+
+## Recursos adicionales
+- [Aprende Ruby Mediante Ejemplo con Ejercicios](http://www.learneroo.com/modules/61/nodes/338) - Una variante de
+esta referencia con ejercicios en navegador.
+- [Documentación Oficial](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby desde otros lenguajes](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programando Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una
+[edición antigua](http://ruby-doc.com/docs/ProgrammingRuby/) gratuita disponible en línea.
+- [Guía de estilo de Ruby](https://github.com/bbatsov/ruby-style-guide) - Guía de estilo creada por la comunidad.
diff --git a/es-es/tmux-es.html.markdown b/es-es/tmux-es.html.markdown
new file mode 100644
index 00000000..a7354be1
--- /dev/null
+++ b/es-es/tmux-es.html.markdown
@@ -0,0 +1,253 @@
+---
+category: tool
+tool: tmux
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+filename: LearnTmux-es.txt
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+
+[tmux](http://tmux.sourceforge.net)
+es un terminal multiplexor: habilita la creación, acceso y control
+de múltiples terminales controlados desde una sola pantalla. tmux
+puede ser separado de una pantalla y continuar corriendo en el fondo
+y luego ser insertado nuevamente.
+
+
+```
+
+  tmux [command]     # Corre un comando
+                     # 'tmux' sin comandos creará una nueva sesión
+
+    new              # Crea una nueva sesión
+     -s "Session"    # Crea sesión con nombre
+     -n "Window"     # Crea ventana con nombre
+     -c "/dir"       # Comienza en el directorio destino 
+
+    attach           # Adjunta sesión última/disponible
+     -t "#"          # Adjunta sesión destino
+     -d              # Separa la sesión de otras instancias
+
+    ls               # Lista las sesiones abiertas
+     -a              # Lista todas las sesiones abiertas
+
+    lsw              # Lista las ventanas
+     -a              # Lista todas las ventanas
+     -s              # Lista todas las ventanas en la sesión
+
+    lsp              # Lista los páneles
+     -a              # Lista todos los páneles
+     -s              # Lista todos los páneles de la sesión
+     -t              # Lista los páneles de aplicación en el destino
+
+    kill-window      # Cierra la ventana actual
+     -t "#"          # Cierra la ventana destino
+     -a              # Cierra todas las ventanas
+     -a -t "#"       # Cierra todas las ventanas menos el destino
+
+    kill-session     # Cierra la sesión actual
+     -t "#"          # Cierra la sesión destino
+     -a              # Cierra todas las sesiones
+     -a -t "#"       # Cierra todas las sesiones menos el destino
+
+```
+
+
+### Atajos de Teclado
+
+El método para controlar una sesión adjunta tmux es mediante
+combinaciones de teclas llamadas teclas 'Prefijo'.
+
+```
+----------------------------------------------------------------------
+  (C-b) = Ctrl + b    # combinación 'Prefijo' necesaria para usar atajos
+
+  (M-1) = Meta + 1 -o- Alt + 1
+----------------------------------------------------------------------
+
+  ?                  # Lista todos los atajos de teclado
+  :                  # Entra en la línea de comandos tmux
+  r                  # Fuerza el redibujado del cliente adjuntado
+  c                  # Crea una nueva ventana
+
+  !                  # Separa el panel actual fuera de la ventana.
+  %                  # Separa el panel actual en dos, izquierdo y derecho
+  "                  # Separa el panel actual en dos, superior e inferior
+
+  n                  # Cambia a la siguiente ventana
+  p                  # Cambia a la ventana previa
+  {                  # Intercambia el panel actual con el anterior
+  }                  # Intercambia el panel actual con el próximo
+
+  s                  # Selecciona una nueva sesión para el cliente adjuntado
+                     interactivamente
+  w                  # Elegir la ventana actual interactivamente
+  0 al 9             # Seleccionar ventanas 0 al 9
+
+  d                  # Separa el cliente actual
+  D                  # Elige un cliente para separar
+
+  &                  # Cierra la ventana actual
+  x                  # Cierra el panel actual
+
+  Up, Down           # Cambia al panel superior, inferior, izquierdo, o derecho
+  Left, Right
+
+  M-1 to M-5         # Organizar páneles:
+                       # 1) uniformes horizontales
+                       # 2) uniformes verticales
+                       # 3) principal horizontal
+                       # 4) principal vertical
+                       # 5) mozaico
+
+  C-Up, C-Down       # Redimensiona el panel actual en pasos de una celda
+  C-Left, C-Right
+
+  M-Up, M-Down       # Redimensiona el panel actual en pasos de cinco celdas
+  M-Left, M-Right
+
+```
+
+
+### Configurando ~/.tmux.conf
+
+tmux.conf puede usarse para establecer opciones automáticas al arrancar, parecido a como .vimrc o init.el hacen.
+
+```
+# Ejemplo de tmux.conf
+# 2014.10
+
+
+### General
+###########################################################################
+
+# Habilita UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Fuera de pantalla/Historia límite
+set -g history-limit 2048
+
+# Comienzo de índice
+set -g base-index 1
+
+# Ratón
+set-option -g mouse-select-pane on
+
+# Forza recarga de fichero de configuración
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Atajos de teclado
+###########################################################################
+
+# Desvincula C-b como el prefijo por defecto
+unbind C-b
+
+# Establece el nuevo prefijo
+set-option -g prefix `
+
+# Regresa a la ventana previa cuando el prefijo es accionado dos veces
+bind C-a last-window
+bind ` last-window
+
+# Permite intercambiar C-a y ` usando F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Preferencias de atajos
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Moviéndose entre paneles con movimientos de teclas vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Ciclo/Intercambio de Ventana
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# División rápida de paneles
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Activar sesión mas interna (cuando se anida tmux) para enviar comandos
+bind a send-prefix
+
+
+### Temas
+###########################################################################
+
+# Paleta de Colores de la Barra de estado
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Paleta de Colores del Borde del Panel
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Paleta de Colores de Mensajes
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Paleta de Colores de la Ventana
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notificación
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Establece automáticamente títulos de ventanas
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Ajustes de barra de estado
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Muestra indicadores de rendimiento en barra de estado
+# Requiere https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Referencias
+
+[Tmux | Inicio](http://tmux.sourceforge.net)
+
+[Tmux Manual](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Mostrar CPU/MEM % en barra de estado](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
diff --git a/es-es/visualbasic-es.html.markdown b/es-es/visualbasic-es.html.markdown
new file mode 100644
index 00000000..c7f581c0
--- /dev/null
+++ b/es-es/visualbasic-es.html.markdown
@@ -0,0 +1,286 @@
+---
+language: Visual Basic
+contributors:
+    - ["Brian Martin", "http://brianmartin.biz"]
+translators:
+    - ["Adolfo Jayme Barrientos", "https://github.com/fitojb"]
+author: Brian Martin
+author_url: https://github.com/fitojb
+filename: learnvisualbasic-es.vb
+lang: es-es
+---
+
+```vb
+Module Module1
+
+    Sub Main()
+        ' Un vistazo rápido a las aplicaciones de consola de Visual Basic antes
+        ' de que profundicemos en el tema.
+        ' El apóstrofo inicia una línea de comentario.
+        ' Para explorar este tutorial dentro del Compilador de Visual Basic,
+        ' he creado un sistema de navegación.
+        ' Dicho sistema se explicará a medida que avancemos en este
+        ' tutorial; gradualmente entenderás lo que significa todo.
+        Console.Title = ("Aprende X en Y minutos")
+        Console.WriteLine("NAVEGACIÓN") 'Mostrar 
+        Console.WriteLine("")
+        Console.ForegroundColor = ConsoleColor.Green
+        Console.WriteLine("1. Salida «Hola, mundo»")
+        Console.WriteLine("2. Entrada «Hola, mundo»")
+        Console.WriteLine("3. Calcular números enteros")
+        Console.WriteLine("4. Calcular números decimales")
+        Console.WriteLine("5. Una calculadora funcional")
+        Console.WriteLine("6. Uso de bucles «Do While»")
+        Console.WriteLine("7. Uso de bucles «For While»")
+        Console.WriteLine("8. Declaraciones condicionales")
+        Console.WriteLine("9. Selecciona una bebida")
+        Console.WriteLine("50. Acerca de")
+        Console.WriteLine("Elige un número de la lista anterior")
+        Dim selection As String = Console.ReadLine
+        Select Case selection
+            Case "1" 'Salida «hola, mundo»
+                Console.Clear() 'Limpia la consola y abre la subrutina privada
+                SalidaHolaMundo() 'Abre la subrutina privada nombrada
+            Case "2" 'Entrada «hola, mundo»
+                Console.Clear()
+                EntradaHolaMundo()
+            Case "3" 'Calcular números enteros 
+                Console.Clear()
+                CalcularNumerosEnteros()
+            Case "4" 'Calcular números decimales
+                Console.Clear()
+                CalcularNumerosDecimales()
+            Case "5" 'Una calculadora funcional
+                Console.Clear()
+                CalculadoraFuncional()
+            Case "6" 'Uso de bucles «Do While»
+                Console.Clear()
+                UsoBuclesDoWhile()
+            Case "7" 'Uso de bucles «For While»
+                Console.Clear()
+                UsoBuclesFor()
+            Case "8" 'Declaraciones condicionales
+                Console.Clear()
+                DeclaracionCondicional()
+            Case "9" 'Declaración «If/Else»
+                Console.Clear()
+                DeclaracionIfElse() 'Selecciona una bebida
+            Case "50" 'Cuadro de mensaje «Acerca de»
+                Console.Clear()
+                Console.Title = ("Aprende X en Y minutos :: Acerca de")
+                MsgBox("Tutorial escrito por Brian Martin (@BrianMartinn")
+                Console.Clear()
+                Main()
+                Console.ReadLine()
+
+        End Select
+    End Sub
+
+    'Uno - He usado números para guiarme por el sistema de navegación anterior
+    'cuando regrese posteriormente a implementarlo.
+
+    'Usamos subrutinas privadas para separar distintas secciones del programa. 
+    Private Sub SalidaHolaMundo()
+        'Título de la aplicación de consola
+        Console.Title = "Salida «Hola, mundo» | Aprende X en Y minutos"
+        'Usa Console.Write("") o Console.WriteLine("") para mostrar salidas.
+        'Seguido por Console.Read(), o bien, Console.Readline()
+        'Console.ReadLine() muestra la salida en la consola.
+        Console.WriteLine("Hola, mundo")
+        Console.ReadLine()
+    End Sub
+
+    'Dos
+    Private Sub EntradaHolaMundo()
+        Console.Title = "«Hola, mundo, soy...» | Aprende X en Y minutos"
+        ' Variables
+        ' Los datos que introduzca un usuario deben almacenarse.
+        ' Las variables también empiezan por Dim y terminan por As VariableType.
+
+        ' En este tutorial queremos conocer tu nombre y hacer que el programa
+        ' responda a este.
+        Dim nombredeusuario As String
+        'Usamos «string» porque es una variable basada en texto.
+        Console.WriteLine("Hola, ¿cómo te llamas? ") 'Preguntar nombre de usuario.
+        nombredeusuario = Console.ReadLine() 'Almacenar nombre del usuario.
+        Console.WriteLine("Hola, " + nombredeusuario) 'La salida es Hola, nombre
+        Console.ReadLine() 'Muestra lo anterior.
+        'El código anterior te hará una pregunta y mostrará la respuesta.
+        'Entre otras variables está Integer, la cual usaremos para números enteros.
+    End Sub
+
+    'Tres
+    Private Sub CalcularNumerosEnteros()
+        Console.Title = "Calcular números enteros | Aprende X en Y minutos"
+        Console.Write("Primer número: ") 'Escribe un núm. entero, 1, 2, 104, etc
+        Dim a As Integer = Console.ReadLine()
+        Console.Write("Segundo número: ") 'Escribe otro número entero.
+        Dim b As Integer = Console.ReadLine()
+        Dim c As Integer = a + b
+        Console.WriteLine(c)
+        Console.ReadLine()
+        'Lo anterior es una calculadora sencilla
+    End Sub
+
+    'Cuatro
+    Private Sub CalcularNumerosDecimales()
+        Console.Title = "Calcular con tipo doble | Aprende X en Y minutos"
+        'Por supuesto, nos gustaría sumar decimales.
+        'Por ello podríamos cambiar del tipo Integer al Double.
+
+        'Escribe un número fraccionario, 1.2, 2.4, 50.1, 104.9 etc
+        Console.Write("Primer número: ")
+        Dim a As Double = Console.ReadLine
+        Console.Write("Segundo número: ") 'Escribe el segundo número.
+        Dim b As Double = Console.ReadLine
+        Dim c As Double = a + b
+        Console.WriteLine(c)
+        Console.ReadLine()
+        'Este programa puede sumar 1.1 y 2.2
+    End Sub
+
+    'Cinco
+    Private Sub CalculadoraFuncional()
+        Console.Title = "La calculadora funcional | Aprende X en Y minutos"
+        'Pero si quieres que la calculadora reste, divida, multiplique y
+        'sume.
+        'Copia y pega lo anterior.
+        Console.Write("Primer número: ")
+        Dim a As Double = Console.ReadLine
+        Console.Write("Segundo número: ")
+        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
+
+        'Mediante las líneas siguientes podremos restar,
+        'multiplicar y dividir los valores a y b
+        Console.Write(a.ToString() + " + " + b.ToString())
+        'Queremos dar un margen izquierdo de 3 espacios a los resultados.
+        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
+
+    'Seis
+    Private Sub UsoBuclesDoWhile()
+        'Igual que la subrutina privada anterior
+        'Esta vez preguntaremos al usuario si quiere continuar (¿sí o no?)
+        'Usamos el bucle Do While porque no sabemos si el usuario quiere
+        'usar el programa más de una vez.
+        Console.Title = "Uso de bucles «Do While» | Aprende X en Y minutos"
+        Dim respuesta As String 'Usamos la variable «String» porque la resp. es texto
+        Do 'Comenzamos el programa con
+            Console.Write("Primer número: ")
+            Dim a As Double = Console.ReadLine
+            Console.Write("Segundo número: ")
+            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()
+            'Preguntar si el usuario quiere continuar. Desafortunadamente,
+            'distingue entre mayúsculas y minúsculas.
+            Console.Write("¿Quieres continuar? (s / n)")
+            'El programa toma la variable, la muestra y comienza de nuevo.
+            respuesta = Console.ReadLine
+        'La orden que hará funcionar esta variable es en este caso «s»
+        Loop While respuesta = "s"
+
+    End Sub
+
+    'Siete
+    Private Sub UsoBuclesFor()
+        'A veces el programa debe ejecutarse solo una vez.
+        'En este programa contaremos a partir de 10.
+
+        Console.Title = "Uso de bucles «For» | Aprende X en Y minutos"
+        'Declarar Variable y desde qué número debe contar en Step -1,
+        'Step -2, Step -3, etc.
+        For i As Integer = 10 To 0 Step -1 
+            Console.WriteLine(i.ToString) 'Muestra el valor del contador
+        Next i 'Calcular el valor nuevo
+        Console.WriteLine("Iniciar") '¡¡Comencemos el programa, nene!!
+        Console.ReadLine() '¡¡ZAS!! - Quizá me he emocionado bastante :)
+    End Sub
+
+    'Ocho
+    Private Sub DeclaracionCondicional()
+        Console.Title = "Declaraciones condicionales | Aprende X en Y minutos"
+        Dim nombredeUsuario As String = Console.ReadLine
+        Console.WriteLine("Hola, ¿cómo te llamas? ") 'Preguntar nombre de usuario.
+        nombredeUsuario = Console.ReadLine() 'Almacena el nombre de usuario.
+        If nombredeUsuario = "Adam" Then
+            Console.WriteLine("Hola, Adam")
+            Console.WriteLine("Gracias por crear este útil sitio web")
+            Console.ReadLine()
+        Else
+            Console.WriteLine("Hola, " + nombredeUsuario)
+            Console.WriteLine("¿Has visitado www.learnxinyminutes.com?")
+            Console.ReadLine() 'Termina y muestra la declaración anterior.
+        End If
+    End Sub
+
+    'Nueve
+    Private Sub DeclaracionIfElse()
+    Console.Title = "Declaración «If / Else» | Aprende X en Y minutos"
+        'A veces es importante considerar más de dos alternativas.
+        'A veces, algunas de estas son mejores.
+        'Cuando esto sucede, necesitaríamos más de una declaración «if».
+        'Una declaración «if» es adecuada para máquinas expendedoras.
+        'En las que el usuario escribe un código (A1, A2, A3) para elegir.
+        'Pueden combinarse todas las elecciones en una sola declaración «if».
+
+        Dim seleccion As String = Console.ReadLine 'Valor de la selección
+            Console.WriteLine("A1. para 7Up")
+            Console.WriteLine("A2. para Fanta")
+            Console.WriteLine("A3. para Dr. Pepper")
+            Console.WriteLine("A4. para Coca-Cola")
+            Console.ReadLine()
+            If selection = "A1" Then
+                Console.WriteLine("7up")
+                Console.ReadLine()
+            ElseIf selection = "A2" Then
+                Console.WriteLine("fanta")
+                Console.ReadLine()
+            ElseIf selection = "A3" Then
+                Console.WriteLine("dr. pepper")
+                Console.ReadLine()
+            ElseIf selection = "A4" Then
+                Console.WriteLine("coca-cola")
+                Console.ReadLine()
+            Else
+                Console.WriteLine("Selecciona un producto")
+                Console.ReadLine()
+            End If
+
+    End Sub
+
+End Module
+
+```
+
+## Referencias
+
+Aprendí Visual Basic en la aplicación de consola. Esta me permitió entender los principios de la programación para, posteriormente, aprender otros lenguajes con facilidad.
+
+He creado un <a href="http://www.vbbootcamp.co.uk/" Title="Tutorial de Visual Basic">tutorial de Visual Basic</a> más exhaustivo para quienes quieran saber más.
+
+Toda la sintaxis es válida. Copia el código y pégalo en el compilador de Visual Basic y ejecuta (F5) el programa. 
diff --git a/fa-ir/javascript.html.markdown b/fa-ir/javascript.html.markdown
index 5c64d24a..fe3555af 100644
--- a/fa-ir/javascript.html.markdown
+++ b/fa-ir/javascript.html.markdown
@@ -499,9 +499,6 @@ myNumber === myNumberObj; // = false
 if (0){
     // This code won't execute, because 0 is falsy.
 }
-if (Number(0)){
-    // This code *will* execute, because Number(0) is truthy.
-}
 ```
 
 
diff --git a/forth.html.markdown b/forth.html.markdown
index f7c0bf34..b4a5581b 100644
--- a/forth.html.markdown
+++ b/forth.html.markdown
@@ -117,7 +117,7 @@ one-to-12                                 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 ok
 : threes ( n n -- ) ?do i . 3 +loop ;    \ ok
 15 0 threes                             \ 0 3 6 9 12 ok
 
-\ Indefinite loops with `begin` <stuff to do> <flag> `unil`:
+\ Indefinite loops with `begin` <stuff to do> <flag> `until`:
 : death ( -- ) begin ." Are we there yet?" 0 until ;    \ ok
 
 \ ---------------------------- Variables and Memory ----------------------------
@@ -133,7 +133,7 @@ variable age    \ ok
 age @ .    \ 21 ok
 age ?      \ 21 ok
 
-\ Constants are quite simiar, except we don't bother with memory addresses:
+\ Constants are quite similar, except we don't bother with memory addresses:
 100 constant WATER-BOILING-POINT    \ ok
 WATER-BOILING-POINT .               \ 100 ok
 
diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index d3c5a67b..63bc25b5 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -248,7 +248,7 @@ keymap ; => {:a 1, :b 2, :c 3}
 
 ; Il y a encore d'autres fonctions dans l'espace de nom clojure.sets.
 
-; Formes utiles
+; Formes et macros utiles
 ;;;;;;;;;;;;;;;
 
 ; Les constructions logiques en Clojure sont juste des macros, et
@@ -275,6 +275,33 @@ ressemblent à toutes les autres formes:
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+  
+; Utilisez les Threading Macros (-> et ->>) pour exprimer plus
+; clairement vos transformations, en y pensant de manière multi-niveaux.
+
+; La "flèche simple" ou "Thread-first", insère, à chaque niveau
+; de la transformation, la forme courante en la seconde position
+; de la forme suivante, constituant à chaque fois un nouvel étage
+; de transformation. Par exemple:
+(->  
+   {:a 1 :b 2} 
+   (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3)
+   (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+   
+; Cette expression est ré-écrite en:
+; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; et est évaluée en : {:a 1 :c 3}
+
+; La "flèche double" ou "Thread-last" procède de la même manière
+; que "->", mais insère le résultat de la réécriture de chaque
+; étage en dernière position. Par exemple:
+(->>
+   (range 10)
+   (map inc)     ;=> Génère ici (map inc (range 10)
+   (filter odd?) ;=> Génère ici (filter odd? (map inc (range 10))
+   (into []))    ;=> Génère ici (into [] (filter odd? (map inc (range 10))), ce qui est évalué au final à;
+                 ; [1 3 5 7 9]
+
 
 ; Modules
 ;;;;;;;;;;;;;;;
diff --git a/fr-fr/csharp-fr.html.markdown b/fr-fr/csharp-fr.html.markdown
index e51eacc8..58b3f386 100644
--- a/fr-fr/csharp-fr.html.markdown
+++ b/fr-fr/csharp-fr.html.markdown
@@ -239,7 +239,8 @@ sur une nouvelle ligne! ""Wow!"", quel style";
             // Opérateur ternaire
             // Un simple if/else peut s'écrire :
             // <condition> ? <valeur si true> : <valeur si false>
-            string isTrue = (true) ? "True" : "False";
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
 
             // Boucle while
             int fooWhile = 0;
diff --git a/fr-fr/haml-fr.html.markdown b/fr-fr/haml-fr.html.markdown
new file mode 100644
index 00000000..24be8bf9
--- /dev/null
+++ b/fr-fr/haml-fr.html.markdown
@@ -0,0 +1,157 @@
+---
+language: haml
+filename: learnhaml.haml
+contributors:
+  - ["Simon Neveu", "https://github.com/sneveu"]
+  - ["Thibault", "https://github.com/iTech-"]
+lang: fr-fr
+---
+
+Haml est un langage de balisage utilisé majoritairement avec Ruby, qui décrit de manière simple et propre le HTML de n'importe quelle page web sans l'utilisation des traditionnelles lignes de code. Le langage est une alternative très populaire au langage de templates Rails (.erb) et permet d'intégrer du code en Ruby dans votre balisage.
+
+Son but est de réduire le nombre de répétitions dans le balisage en fermant des balises pour vous en se basant sur l'indentation de votre code. Finalement, le balisage est bien structuré, ne contient pas de répétition, est logique et facile à lire.
+
+Vous pouvez aussi utiliser Haml sur un projet indépendant de Ruby, en installant les gems de Haml et en le convertissant en html grâce aux commandes.
+
+$ haml fichier_entree.haml fichier_sortie.html
+
+
+```haml
+/ -------------------------------------------
+/ Indentation 
+/ -------------------------------------------
+
+/
+  A cause de l'importance de l'indentation sur la manière dont votre code sera
+  converti, l'indentation doit être constante à travers votre document. Un 
+  simple changement d'indentation entrainera une erreur. En général, on utilise
+  deux espaces, mais ce genre de décision sur l'indentation vous appartient, du
+  moment que vous vous y tenez.
+
+/ -------------------------------------------
+/ Commentaires
+/ -------------------------------------------
+
+/ Ceci est un commentaire en Haml.
+
+/
+  Pour écrire un commentaire sur plusieurs lignes, indentez votre code
+  commenté en le commençant par un slash
+
+-# Ceci est un commentaire silencieux, qui n'apparaîtra pas dans le fichier
+
+
+/ -------------------------------------------
+/ Eléments HTML
+/ -------------------------------------------
+
+/ Pour écrire vos balises, utilisez un pourcentage suivi du nom de votre balise
+%body
+  %header
+    %nav
+
+/ Remarquez qu'il n'y a aucunes balises fermées. Le code produira alors ceci
+  <body>
+    <header>
+      <nav></nav>
+    </header>
+  </body>
+
+/ La balise div est l'élément par défaut, vous pouvez donc l'écrire comme ceci
+.balise
+
+/ Pour ajouter du contenu à votre balise, ajoutez le texte après sa déclaration
+%h1 Titre contenu
+
+/ Pour écrire du contenu sur plusieurs lignes, imbriquez le
+%p
+  Ce paragraphe contient beaucoup de contenu qui pourrait
+  probablement tenir sur deux lignes séparées.
+
+/
+  Vous pouvez utiliser des caractères html spéciaux en utilisant &=. Cela va
+  convertir les caractères comme &, /, : en leur équivalent HTML. Par exemple
+
+%p
+  &= "Oui & oui"
+
+/ Produira 'Oui &amp; oui'
+
+/ Vous pouvez écrire du contenu html sans qu'il soit converti en utilisant !=
+%p
+  != "Voici comment écrire une balise de paragraphe <p></p>"
+
+/ Cela produira 'Voici comment écrire une balise de paragraphe <p></p>'
+
+/ Une classe CSS peut être ajouté à votre balise en chainant le nom de la classe
+%div.truc.machin
+
+/ ou en utilisant un hash de Ruby
+%div{:class => 'truc machin'}
+
+/ Des attributs pour n'importe quelles balises peuvent être ajoutés au hash
+%a{:href => '#', :class => 'machin', :title => 'Titre machin'}
+
+/ Pour affecter une valeur à un booléen, utilisez 'true' 
+%input{:selected => true}
+
+/ Pour écrire des data-attributes, utilisez le :data avec la valeur d'un hash
+%div{:data => {:attribute => 'machin'}}
+
+
+/ -------------------------------------------
+/ Insérer du Ruby
+/ -------------------------------------------
+
+/
+  Pour transférer une valeur de Ruby comme contenu d'une balise, utilisez le
+  signe égal suivi du code Ruby
+
+%h1= livre.titre
+
+%p
+  = livre.auteur
+  = livre.editeur
+
+
+/ Pour lancer du code Ruby sans le convertir en HTML, utilisez un trait d'union
+- livres = ['livre 1', 'livre 2', 'livre 3']
+
+/ Ceci vous permet de faire des choses géniales comme des blocs Ruby
+- livre.shuffle.each_with_index do |livre, index|
+  %h1= livre 
+
+  if livre do
+    %p Ceci est un livre
+
+/
+  Encore une fois il n'est pas nécessaire d'ajouter une balise fermante, même
+  pour Ruby.
+  L'indentation le fera pour vous.
+
+
+/ -------------------------------------------
+/ Ruby en-ligne / Interpolation en Ruby
+/ -------------------------------------------
+
+/ Inclure une variable Ruby dans une ligne en utilisant #{}
+%p Votre meilleur score est #{record}
+
+
+/ -------------------------------------------
+/ Filtres
+/ -------------------------------------------
+
+/
+  Utilisez les deux points pour définir un filtre Haml, vous pouvez par exemple
+  utiliser un filtre :javascript pour écrire du contenu en-ligne js
+
+:javascript
+  console.log('Ceci est la balise en-ligne <script>');
+
+```
+
+## Lectures complémentaires
+
+- [Qu'est-ce que HAML ?](http://haml.info/) - Une bonne introduction qui explique très bien les avantages d'utiliser HAML.
+- [Documentation officielle](http://haml.info/docs/yardoc/file.REFERENCE.html) - Si vous souhaitez en apprendre plus et aller plus loin.
diff --git a/fr-fr/javascript-fr.html.markdown b/fr-fr/javascript-fr.html.markdown
index 2e18d0be..15478cdb 100644
--- a/fr-fr/javascript-fr.html.markdown
+++ b/fr-fr/javascript-fr.html.markdown
@@ -469,9 +469,6 @@ myNumber === myNumberObj; // = false
 if (0){
     // 0 est falsy, le code ne fonctionnera pas.
 }
-if (Number(0)){
-    // Parce que Number(0) est truthy, le code fonctionnera
-}
 
 // Cependant, vous pouvez ajouter des fonctionnalités aux types de bases grâce à
 // cette particularité.
diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown
index 69f4d8f9..4e31c4bf 100644
--- a/fr-fr/objective-c-fr.html.markdown
+++ b/fr-fr/objective-c-fr.html.markdown
@@ -14,7 +14,7 @@ lang: fr-fr
 
 L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch.
 
-```objective_c
+```objective-c
 // Les commentaires sur une seule ligne commencent par //
 
 /*
diff --git a/fr-fr/php.html.markdown b/fr-fr/php.html.markdown
new file mode 100644
index 00000000..f4eaf396
--- /dev/null
+++ b/fr-fr/php.html.markdown
@@ -0,0 +1,696 @@
+---
+language: PHP
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+translators:
+    - ["Pascal Boutin", "http://pboutin.net/"]
+lang: fr-fr
+---
+
+This document describes PHP 5+.
+
+```php
+ // Le code PHP doit être placé à l'intérieur de balises '<?php'
+
+// Si votre fichier php ne contient que du code PHP, il est
+// généralement recommandé de ne pas fermer la balise '?>'
+
+// Deux barres obliques amorcent un commentaire simple.
+
+# Le dièse aussi, bien que les barres obliques soient plus courantes
+
+/*
+    Les barres obliques et les astérisques peuvent être utilisés
+    pour faire un commentaire multi-lignes.
+*/
+
+// Utilisez "echo" ou "print" afficher une sortie
+print('Hello '); // Affiche "Hello " sans retour à la ligne
+
+// Les parenthèses sont facultatives pour print et echo
+echo "World\n"; // Affiche "World" avec un retour à la ligne
+
+// toutes les instructions doivent se terminer par un point-virgule
+
+// Tout ce qui se trouve en dehors des <?php ?> est automatiquement
+// affiché en sortie
+Hello World Again!
+<?php
+
+
+/************************************
+ * Types & Variables
+ */
+
+// Les noms de variables débutent par le symbole $
+// Un nom de variable valide commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou de soulignés.
+
+// Les valeurs booléenes ne sont pas sensibles à la casse
+$boolean = true;  // ou TRUE ou True
+$boolean = false; // ou FALSE ou False
+
+// Entiers (integers)
+$int1 = 12;   // => 12
+$int2 = -12;  // => -12
+$int3 = 012;  // => 10 (un 0 devant la valeur désigne une valeur octale)
+$int4 = 0x0F; // => 15 (un 0x devant la valeur désigne une valeur hexadécimale)
+
+// Réels (floats, doubles)
+$float = 1.234;
+$float = 1.2e3;
+$float = 7E-10;
+
+// Suppression d'une variable
+unset($int1);
+
+// Arithmétique
+$sum        = 1 + 1; // 2 (addition)
+$difference = 2 - 1; // 1 (soustraction)
+$product    = 2 * 2; // 4 (produit)
+$quotient   = 2 / 1; // 2 (division)
+
+// Arithmétique (raccourcis)
+$number = 0;
+$number += 2;      // Incrémente $number de 2
+echo $number++;    // Affiche 2 (incrémente après l'évaluation)
+echo ++$number;    // Affiche 4 (incrémente avant l'évaluation)
+$number /= $float; // Divise et assigne le quotient à $number
+
+// Les chaînes de caractères (strings) doivent être à
+// l'intérieur d'une paire d'apostrophes
+$sgl_quotes = '$String'; // => '$String'
+
+// Évitez les guillemets sauf pour inclure le contenu d'une autre variable
+$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
+
+// Les caractères spéciaux sont seulement échappés avec des guillemets
+$escaped   = "This contains a \t tab character.";
+$unescaped = 'This just contains a slash and a t: \t';
+
+// En cas de besoin, placez la variable dans des accolades
+$money = "I have $${number} in the bank.";
+
+// Depuis PHP 5.3, Nowdoc peut être utilisé pour faire des chaînes
+// multi-lignes non-interprétées
+$nowdoc = <<<'END'
+Multi line
+string
+END;
+
+// Heredoc peut être utilisé pour faire des chaînes multi-lignes interprétées
+$heredoc = <<<END
+Multi line
+$sgl_quotes
+END;
+
+// La concaténation de chaînes se fait avec un .
+echo 'This string ' . 'is concatenated';
+
+
+/********************************
+ * Constantes
+ */
+
+// Une constante est déclarée avec define()
+// et ne peut jamais être changée durant l'exécution
+
+// un nom valide de constante commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou soulignés.
+define("FOO",     "something");
+
+// on peut accéder à une constante en utilisant directement son nom
+echo 'This outputs '.FOO;
+
+
+/********************************
+ * Tableaux (array)
+ */
+
+// Tous les tableaux en PHP sont associatifs (hashmaps),
+
+// Fonctionne dans toutes les versions de PHP
+$associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
+
+// PHP 5.4 a introduit une nouvelle syntaxe
+$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
+
+echo $associative['One']; // affiche 1
+
+// Dans une liste simple, l'index est automatiquement attribué en tant que clé
+$array = ['One', 'Two', 'Three'];
+echo $array[0]; // => "One"
+
+// Ajoute un élément à la fin du tableau
+$array[] = 'Four';
+
+// Retrait d'un élément du tableau
+unset($array[3]);
+
+/********************************
+ * Affichage
+ */
+
+echo('Hello World!');
+// Affiche Hello World! dans stdout.
+// Stdout est la page web si on exécute depuis un navigateur.
+
+print('Hello World!'); // Pareil à "écho"
+
+// Pour écho, vous n'avez pas besoin des parenthèses
+echo 'Hello World!';
+print 'Hello World!'; // Pour print non plus
+
+$paragraph = 'paragraph';
+
+echo 100;        // Affichez un scalaire directement
+echo $paragraph; // ou des variables
+
+// Si le raccourci de sortie est configuré, ou si votre version de PHP est
+// 5.4.0+, vous pouvez utiliser ceci:
+?>
+<p><?= $paragraph ?></p>
+<?php
+
+$x = 1;
+$y = 2;
+$x = $y; // $x contient maintenant la même valeur que $y
+$z = &$y;
+// $z contient une référence vers $y. Changer la valeur de
+// $z changerait également la valeur de $y, et vice-versa.
+// $x resterait inchangé comme la valeur initiale de $y
+
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+// Affiche le type et la valeur de la variable dans stdout
+var_dump($z); // prints int(0)
+
+// Affiche la variable dans stdout dans un format plus convivial
+print_r($array); // prints: Array ( [0] => One [1] => Two [2] => Three )
+
+/********************************
+ * Logique
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// assert affiche un avertissement dans son argument n'est pas vrai
+
+// Ces comparaisons vont toujours être vraies, même si leurs
+// types ne sont pas les mêmes.
+assert($a == $b); // égalité
+assert($c != $a); // inégalité
+assert($c <> $a); // inégalité (moins courant)
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// Ces comparaisons vont seulement être vraies si les types concordent.
+assert($c === $d);
+assert($a !== $d);
+assert(1 === '1');
+assert(1 !== '1');
+
+// Opérateur 'spaceship' depuis PHP 7
+$a = 100;
+$b = 1000;
+
+echo $a <=> $a; // 0 car ils sont égaux
+echo $a <=> $b; // -1 car $a < $b
+echo $b <=> $a; // 1 car $b > $a
+
+// Les variables peuvent être transtypées dépendamment de leur usage.
+
+$integer = 1;
+echo $integer + $integer; // => 2
+
+$string = '1';
+echo $string + $string; // => 2
+
+$string = 'one';
+echo $string + $string; // => 0
+// Donne 0 car l'opérateur + ne peut pas transtyper la chaîne 'one' en un nombre
+
+// On peut également transtyper manuellement pour utiliser
+// une variable dans un autre type
+
+$boolean = (boolean) 1; // => true
+
+$zero = 0;
+$boolean = (boolean) $zero; // => false
+
+// Il y a également des fonctions dédiées pour transtyper
+$integer = 5;
+$string = strval($integer);
+
+$var = null; // Valeur nulle
+
+
+/********************************
+ * Structures de contrôle
+ */
+
+if (true) {
+    print 'Je suis affiché';
+}
+
+if (false) {
+    print 'Je ne le suis pas';
+} else {
+    print 'Je suis affiché';
+}
+
+if (false) {
+    print 'Je ne suis pas affiché';
+} elseif (true) {
+    print 'Je le suis';
+}
+
+// Opérateur ternaire
+print (false ? 'N\'est pas affiché' : 'L\'est');
+
+// Opérateur ternaire depuis PHP 5.3
+// équivalent de $x ? $x : 'Does'
+$x = false;
+print($x ?: 'Does');
+
+// depuis PHP 7, on peut facilement vérifier si une valeur est nulle
+$a = null;
+$b = 'Hello World';
+echo $a ?? 'a is not set'; // Affiche 'a is not set'
+echo $b ?? 'b is not set'; // Affiche 'Hello World'
+
+
+$x = 0;
+if ($x === '0') {
+    print 'Pas affiché';
+} elseif($x == '1') {
+    print 'Pas affiché';
+} else {
+    print 'Affiché';
+}
+
+
+// Cette syntaxe alternative est particulièrement utile avec du HTML:
+?>
+
+<?php if ($x): ?>
+<p>Ceci est affiché si $x est vrai</p>
+<?php else: ?>
+<p>Ceci est affiché si $x est faux</p>
+<?php endif; ?>
+
+<?php
+
+// On peut également utiliser une condition multiple (switch case)
+switch ($x) {
+    case '0':
+        print 'Les switch font du transtypage implicite';
+        break; // Il est important de déclaré un 'break', sinon les cas
+               // 'two' et 'three' seront évalués
+    case 'two':
+    case 'three':
+        // Si $x == 'two' || $x == 'three'
+        break;
+    default:
+        // Si aucun cas n'a été vrai
+}
+
+// Structures itératives (for, while, do while)
+$i = 0;
+while ($i < 5) {
+    echo $i++;
+}; // Affiche "01234"
+
+echo "\n";
+
+$i = 0;
+do {
+    echo $i++;
+} while ($i < 5); // Affiche "01234"
+
+echo "\n";
+
+for ($x = 0; $x < 10; $x++) {
+    echo $x;
+} // Affiche "0123456789"
+
+echo "\n";
+
+$wheels = ['bicycle' => 2, 'car' => 4];
+
+// Les boucles 'foreach' sont utiles pour parcourir les tableaux
+foreach ($wheels as $wheel_count) {
+    echo $wheel_count;
+} // Affiche "24"
+
+echo "\n";
+
+// Il est également possible d'accéder aux clés du tableau
+foreach ($wheels as $vehicle => $wheel_count) {
+    echo "The $vehicle have $wheel_count wheels";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+    if ($i === 3) {
+        break; // Permet d'arrêter la boucle
+    }
+    echo $i++;
+} // Affiche "012"
+
+for ($i = 0; $i < 5; $i++) {
+    if ($i === 3) {
+        continue; // Permet de passer immédiatement à l'itération suivante
+    }
+    echo $i;
+} // Affiche "0124"
+
+
+/********************************
+ * Fonctions
+ */
+
+// On peut déclarer une fonction avec le mot clé 'function'
+function my_function () {
+  return 'Hello';
+}
+
+echo my_function(); // => "Hello"
+
+
+// Les noms de fonction débutent par le symbole $
+// Un nom de variable valide commence par une lettre ou un souligné,
+// suivi de n'importe quelle lettre, nombre ou de soulignés.
+
+function add ($x, $y = 1) { // $y est facultatif et sa valeur par défaut est 1
+  $result = $x + $y;
+  return $result;
+}
+
+echo add(4); // => 5
+echo add(4, 2); // => 6
+
+// $result n'est pas accessible en dehors de la fonction
+// print $result; // Retourne un avertissement
+
+// Depuis PHP 5.3 on peut déclarer des fonctions anonymes
+$inc = function ($x) {
+  return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+  echo "$x - $y - $z";
+}
+
+// Une fonction peut retourner une fonction
+function bar ($x, $y) {
+  // On peut utiliser 'use' pour passer des variables externes
+  return function ($z) use ($x, $y) {
+    foo($x, $y, $z);
+  };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // Affiche "A - B - C"
+
+// On peut exécuter une fonction par son nom en chaîne de caractères
+$function_name = 'add';
+echo $function_name(1, 2); // => 3
+// Utile pour déterminer par programmation quelle fonction exécuter.
+
+// On peut également utiliser
+call_user_func(callable $callback [, $parameter [, ... ]]);
+
+/********************************
+ * Insertions
+ */
+
+<?php
+// Le PHP se trouvant dans un fichier inclus doit
+// également commencer par une balise PHP.
+
+include 'my-file.php';
+// Le code se trouvant dans my-file.php est maintenant disponible dans
+// le contexte courant. Si le fichier ne peut pas être inclus
+// (ex. non trouvé), un avertissement sera émit.
+
+include_once 'my-file.php';
+// Si le code dans my-file.php a déjà été inclus ailleur, il ne va pas
+// être inclus de nouveau.
+
+require 'my-file.php';
+require_once 'my-file.php';
+// Même comportement que include() mais déclenche une érreur fatale si le fichier ne peux pas être inclus.
+
+// Contenu de my-include.php:
+<?php
+
+return 'Anything you like.';
+// Fin de my-include.php
+
+// include() et require() peuvent également retourner une valeur
+$value = include('my-include.php');
+
+// Les fichiers sont inclus depuis le chemin donné ou, si aucun chemin n'est donné,
+// la configuration 'include_path'. Si le fichier n'est pas trouvé dans le 'include_path',
+// include va finalement vérifier dans le répertoire courant avant d'échouer.
+
+/********************************
+ * Classes
+ */
+
+// Les classes sont définies avec le mot clé 'class'
+
+class MyClass
+{
+    const MY_CONST      = 'value'; // Une constante
+
+    static $staticVar   = 'static';
+
+    // Variables statiques et leur visibilité
+    public static $publicStaticVar = 'publicStatic';
+    // Accessible à l'intérieur de la classe seulement
+    private static $privateStaticVar = 'privateStatic';
+    // Accessible à l'intérieur de la classe et des classes enfants
+    protected static $protectedStaticVar = 'protectedStatic';
+
+    // Les attributs doivent définir leur visibilité
+    public $property = 'public';
+    public $instanceProp;
+    protected $prot = 'protected';
+    private $priv   = 'private';
+
+    // Déclaration d'un constructeur avec __construct
+    public function __construct($instanceProp) {
+        // Access instance variables with $this
+        $this->instanceProp = $instanceProp;
+    }
+
+    // Les méthodes sont déclarés par des fonctions au sein de la classe
+    public function myMethod()
+    {
+        print 'MyClass';
+    }
+
+    // le mot clé 'final' rend la function impossible à surcharger
+    final function youCannotOverrideMe()
+    {
+    }
+
+/*
+ * Les attributs et méthodes statiques peuvent être accédés sans devoir
+ * instancier la classe. Les attributs statiques ne sont pas accessibles depuis
+ * une instance, même si les méthodes statiques le sont.
+ */
+
+    public static function myStaticMethod()
+    {
+        print 'I am static';
+    }
+}
+
+// Les constantes d'une classe peuvent toujours être utilisé de façon statique
+echo MyClass::MY_CONST;    // Outputs 'value';
+
+echo MyClass::$staticVar;  // Retourne 'static';
+MyClass::myStaticMethod(); // Retourne 'I am static';
+
+// On peut instancier une classe en utilisant le mot clé 'new'
+$my_class = new MyClass('An instance property');
+
+// On peut accéder aux attributs/méthodes d'une instance avec ->
+echo $my_class->property;     // => "public"
+echo $my_class->instanceProp; // => "An instance property"
+$my_class->myMethod();        // => "MyClass"
+
+
+// On peut hériter d'une classe en utilisant 'extends'
+class MyOtherClass extends MyClass
+{
+    function printProtectedProperty()
+    {
+        echo $this->prot;
+    }
+
+    // Surcharge d'une méthode
+    function myMethod()
+    {
+        parent::myMethod();
+        print ' > MyOtherClass';
+    }
+}
+
+$my_other_class = new MyOtherClass('Instance prop');
+$my_other_class->printProtectedProperty(); // => Retourne "protected"
+$my_other_class->myMethod();               // Retourne "MyClass > MyOtherClass"
+
+// On peut empêcher qu'une classe soit héritée
+final class YouCannotExtendMe
+{
+}
+
+// On peut utiliser des "méthodes magiques" pour se faire des accesseurs
+class MyMapClass
+{
+    private $property;
+
+    public function __get($key)
+    {
+        return $this->$key;
+    }
+
+    public function __set($key, $value)
+    {
+        $this->$key = $value;
+    }
+}
+
+$x = new MyMapClass();
+echo $x->property; // Va utiliser la méthode __get()
+$x->property = 'Something'; // Va utiliser la méthode __set()
+
+// Les classes peuvent être abstraites (en utilisant le mot clé 'abstract'), ou
+// elle peuvent implémenter une interface (en utilisant le mot clé 'implement').
+
+// Une interface peut être déclarée avec le mot clé 'interface'
+
+interface InterfaceOne
+{
+    public function doSomething();
+}
+
+interface InterfaceTwo
+{
+    public function doSomethingElse();
+}
+
+// Les interfaces peuvent hériter d'autres interfaces
+interface InterfaceThree extends InterfaceTwo
+{
+    public function doAnotherContract();
+}
+
+abstract class MyAbstractClass implements InterfaceOne
+{
+    public $x = 'doSomething';
+}
+
+class MyConcreteClass extends MyAbstractClass implements InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo $x;
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+
+// Les classes peuvent implémenter plusieurs interfaces à la fois
+class SomeOtherClass implements InterfaceOne, InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo 'doSomething';
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+/********************************
+ * Espaces de noms (namespaces)
+ */
+
+// Cette section est séparée, car une déclaration d'espace de nom doit être
+// la première chose que l'on retrouve dans un fichier PHP,
+// imaginons que c'est le cas
+
+<?php
+
+// Par défaut, les classes existent dans l'espace de nom global et peuvent
+// être appelé explicitement avec un antislash.
+
+$cls = new \MyClass();
+
+
+
+// On peut spécifier l'espace de nom d'un fichier comme cela
+namespace My\Namespace;
+
+class MyClass
+{
+}
+
+// (depuis un autre fichier...)
+$cls = new My\Namespace\MyClass;
+
+// Ou depuis un autre espace de nom
+namespace My\Other\Namespace;
+
+use My\Namespace\MyClass;
+
+$cls = new MyClass();
+
+// On peut également utiliser un alias sur un espace de nom
+
+namespace My\Other\Namespace;
+
+use My\Namespace as SomeOtherNamespace;
+
+$cls = new SomeOtherNamespace\MyClass();
+
+*/
+
+```
+
+## Pour plus d'informations
+
+Visitez la [documentation officielle](http://www.php.net/manual/fr).
+
+Si vous êtes intéressé par les bonnes pratiques, visitez
+[PHP The Right Way](http://www.phptherightway.com/) (anglais seulement).
+
+Si vous êtes habitué à utiliser de bons gestionaires de dépendances, regardez
+[Composer](http://getcomposer.org/).
+
+Pour consulter les standards, visitez "the PHP Framework Interoperability Groups"
+[PSR standards](https://github.com/php-fig/fig-standards).
diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 58a036ba..3f6dcabb 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -15,11 +15,11 @@ Je suis tombé amoureux de Python de par la clarté de sa syntaxe. C'est pratiqu
 Vos retours sont grandement appréciés. Vous pouvez me contacter sur Twitter [@louiedinh](http://twitter.com/louiedinh) ou par e-mail: louiedinh [at] [google's email service]
 
 NB: Cet artice s'applique spécifiquement à Python 2.7, mais devrait s'appliquer pour toute version Python 2.x
-Vous pourrez bientôt trouver un article pour Python 3!
+Vous pourrez bientôt trouver un article pour Python 3 en Français. Pour le moment vous pouvez jettez un coup d'oeil à l'article [Python 3 en Anglais](http://learnxinyminutes.com/docs/python3/).
 
 ```python
 # Une ligne simple de commentaire commence par un dièse
-""" Les lignes de commenatires multipes peuvent être écrites
+""" Les lignes de commentaires multipes peuvent être écrites
     en utilisant 3 guillemets ("), et sont souvent utilisées
     pour les commentaires
 """
diff --git a/fr-fr/python3-fr.html.markdown b/fr-fr/python3-fr.html.markdown
new file mode 100644
index 00000000..04d0a55d
--- /dev/null
+++ b/fr-fr/python3-fr.html.markdown
@@ -0,0 +1,723 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+translators:
+    - ["Gnomino", "https://github.com/Gnomino"]
+filename: learnpython3-fr.py
+lang: fr-fr
+---
+
+Python a été créé par Guido Van Rossum au début des années 90. C'est maintenant un des 
+langages les populaires. Je suis tombé amoureux de Python pour la clarté de sa syntaxe.
+C'est tout simplement du pseudo-code exécutable.
+
+L'auteur original apprécierait les retours (en anglais): vous pouvez le contacter sur Twitter à [@louiedinh](http://twitter.com/louiedinh) ou par mail à l'adresse louiedinh [at] [google's email service]
+
+Note : Cet article s'applique spécifiquement à Python 3. Jettez un coup d'oeil [ici](http://learnxinyminutes.com/docs/fr-fr/python-fr/) pour apprendre le vieux Python 2.7
+
+```python
+
+# Un commentaire d'une ligne commence par un dièse
+
+""" Les chaînes de caractères peuvent être écrites
+    avec 3 guillemets doubles ("), et sont souvent
+    utilisées comme des commentaires.
+"""
+
+####################################################
+## 1. Types de données primaires et opérateurs
+####################################################
+
+# On a des nombres
+3  # => 3
+
+# Les calculs sont ce à quoi on s'attend
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+
+# Sauf pour la division qui retourne un float (nombre à virgule flottante)
+35 / 5  # => 7.0
+
+# Résultats de divisions entières tronqués pour les nombres positifs et négatifs
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # works on floats too
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# Quand on utilise un float, le résultat est un float
+3 * 2.0 # => 6.0
+
+# Modulo (reste de la division)
+7 % 3 # => 1
+
+# Exponentiation (x**y, x élevé à la puissance y)
+2**4 # => 16
+
+# Forcer la priorité de calcul avec des parenthèses
+(1 + 3) * 2  # => 8
+
+# Les valeurs booléennes sont primitives
+True
+False
+
+# Négation avec not
+not True  # => False
+not False  # => True
+
+# Opérateurs booléens
+# On note que "and" et "or" sont sensibles à la casse
+True and False #=> False
+False or True #=> True
+
+# Utilisation des opérations booléennes avec des entiers :
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# On vérifie une égalité avec ==
+1 == 1  # => True
+2 == 1  # => False
+
+# On vérifie une inégalité avec !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Autres opérateurs de comparaison
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# On peut enchaîner les comparaisons
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# (is vs. ==) is vérifie si deux variables pointent sur le même objet, mais == vérifie
+# si les objets ont la même valeur.
+a = [1, 2, 3, 4] # a pointe sur une nouvelle liste, [1, 2, 3, 4]
+b = a # b pointe sur a
+b is a # => True, a et b pointent sur le même objet
+b == a # => True, les objets a et b sont égaux
+b = [1, 2, 3, 4] # b pointe sur une nouvelle liste, [1, 2, 3, 4]
+b is a # => False, a et b ne pointent pas sur le même objet
+b == a # => True, les objets a et b ne pointent pas sur le même objet
+
+# Les chaînes (ou strings) sont créées avec " ou '
+"Ceci est une chaine"
+'Ceci est une chaine aussi.'
+
+# On peut additionner des chaînes aussi ! Mais essayez d'éviter de le faire.
+"Hello " + "world!"  # => "Hello world!"
+# On peut aussi le faire sans utiliser '+'
+"Hello " "world!"  # => "Hello world!"
+
+# On peut traîter une chaîne comme une liste de caractères
+"This is a string"[0]  # => 'T'
+
+# .format peut être utilisé pour formatter des chaînes, comme ceci:
+"{} peuvent etre {}".format("Les chaînes", "interpolées")
+
+# On peut aussi réutiliser le même argument pour gagner du temps.
+"{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"
+
+# On peut aussi utiliser des mots clés pour éviter de devoir compter.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+
+# Si votre code doit aussi être compatible avec Python 2.5 et moins,
+# vous pouvez encore utiliser l'ancienne syntaxe :
+"Les %s peuvent être %s avec la %s méthode" % ("chaînes", "interpolées", "vieille")
+
+
+# None est un objet
+None  # => None
+
+# N'utilisez pas "==" pour comparer des objets à None
+# Utilisez plutôt "is". Cela permet de vérifier l'égalité de l'identité des objets.
+"etc" is None  # => False
+None is None  # => True
+
+# None, 0, and les strings/lists/dicts (chaînes/listes/dictionnaires) valent False lorsqu'ils sont convertis en booléens.
+# Toutes les autres valeurs valent True
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Variables et Collections
+####################################################
+
+# Python a une fonction print pour afficher du texte
+print("I'm Python. Nice to meet you!")
+
+# Par défaut, la fonction print affiche aussi une nouvelle ligne à la fin.
+# Utilisez l'argument optionnel end pour changer ce caractère de fin.
+print("Hello, World", end="!") # => Hello, World!
+
+# Pas besoin de déclarer des variables avant de les définir.
+# La convention est de nommer ses variables avec des minuscules_et_underscores
+some_var = 5
+some_var  # => 5
+
+# Tenter d'accéder à une variable non définie lève une exception.
+# Voir Structures de contrôle pour en apprendre plus sur le traitement des exceptions.
+une_variable_inconnue  # Lève une NameError
+
+# Les listes permettent de stocker des séquences
+li = []
+# On peut initialiser une liste pré-remplie
+other_li = [4, 5, 6]
+
+# On ajoute des objets à la fin d'une liste avec .append
+li.append(1)    # li vaut maintenant [1]
+li.append(2)    # li vaut maintenant [1, 2]
+li.append(4)    # li vaut maintenant [1, 2, 4]
+li.append(3)    # li vaut maintenant [1, 2, 4, 3]
+# On enlève le dernier élément avec .pop
+li.pop()        # => 3 et li vaut maintenant [1, 2, 4]
+# Et on le remet
+li.append(3)    # li vaut de nouveau [1, 2, 4, 3]
+
+# Accès à un élément d'une liste :
+li[0]  # => 1
+# Accès au dernier élément :
+li[-1]  # => 3
+
+# Accéder à un élément en dehors des limites lève une IndexError
+li[4]  # Lève une IndexError
+
+# On peut accéder à une intervalle avec la syntaxe "slice"
+# (c'est un rang du type "fermé/ouvert")
+li[1:3]  # => [2, 4]
+# Omettre les deux premiers éléments
+li[2:]  # => [4, 3]
+# Prendre les trois premiers
+li[:3]  # => [1, 2, 4]
+# Sélectionner un élément sur deux
+li[::2]   # =>[1, 4]
+# Avoir une copie de la liste à l'envers
+li[::-1]   # => [3, 4, 2, 1]
+# Pour des "slices" plus élaborées :
+# li[debut:fin:pas]
+
+# Faire une copie d'une profondeur de un avec les "slices"
+li2 = li[:] # => li2 = [1, 2, 4, 3] mais (li2 is li) vaut False.
+
+# Enlever des éléments arbitrairement d'une liste
+del li[2]   # li is now [1, 2, 3]
+
+# On peut additionner des listes
+# Note: les valeurs de li et other_li ne sont pas modifiées.
+li + other_li   # => [1, 2, 3, 4, 5, 6]
+
+# Concaténer des listes avec "extend()"
+li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+
+# Vérifier la présence d'un objet dans une liste avec "in"
+1 in li   # => True
+
+# Examiner la longueur avec "len()"
+len(li)   # => 6
+
+
+# Les tuples sont comme des listes mais sont immuables.
+tup = (1, 2, 3)
+tup[0]   # => 1
+tup[0] = 3  # Lève une TypeError
+
+# Note : un tuple de taille un doit avoir une virgule après le dernier élément,
+# mais ce n'est pas le cas des tuples d'autres tailles, même zéro.
+type((1))  # => <class 'int'>
+type((1,)) # => <class 'tuple'>
+type(())   # => <class 'tuple'>
+
+# On peut utiliser la plupart des opérations des listes sur des tuples.
+len(tup)   # => 3
+tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
+tup[:2]   # => (1, 2)
+2 in tup   # => True
+
+# Vous pouvez décomposer des tuples (ou des listes) dans des variables
+a, b, c = (1, 2, 3)     # a vaut 1, b vaut 2 et c vaut 3
+# Les tuples sont créés par défaut sans parenthèses
+d, e, f = 4, 5, 6
+# Voyez comme il est facile d'intervertir deux valeurs :
+e, d = d, e     # d vaut maintenant 5 et e vaut maintenant 4
+
+
+# Créer un dictionnaire :
+empty_dict = {}
+# Un dictionnaire pré-rempli :
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Note : les clés des dictionnaires doivent être de types immuables.
+# Elles doivent être convertibles en une valeur constante pour une recherche rapide.
+# Les types immuables incluent les ints, floats, strings et tuples.
+invalid_dict = {[1,2,3]: "123"} # => Lève une TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}  # Par contre, les valeurs peuvent être de tout type.
+
+# On trouve une valeur avec []
+filled_dict["one"]   # => 1
+
+# On obtient toutes les clés sous forme d'un itérable avec "keys()" Il faut l'entourer
+# de list() pour avoir une liste Note: l'ordre n'est pas garanti.
+list(filled_dict.keys())   # => ["three", "two", "one"]
+
+
+# On obtient toutes les valeurs sous forme d'un itérable avec "values()". 
+# Là aussi, il faut utiliser list() pour avoir une liste.
+# Note : l'ordre n'est toujours pas garanti.
+list(filled_dict.values())   # => [3, 2, 1]
+
+
+# On vérifie la présence d'une clé dans un dictionnaire avec "in"
+"one" in filled_dict   # => True
+1 in filled_dict   # => False
+
+# L'accès à une clé non-existente lève une KeyError
+filled_dict["four"]   # KeyError
+
+# On utilise "get()" pour éviter la KeyError
+filled_dict.get("one")   # => 1
+filled_dict.get("four")   # => None
+# La méthode get accepte une valeur de retour par défaut en cas de valeur non-existante.
+filled_dict.get("one", 4)   # => 1
+filled_dict.get("four", 4)   # => 4
+
+# "setdefault()" insère une valeur dans un dictionnaire si la clé n'est pas présente.
+filled_dict.setdefault("five", 5)  # filled_dict["five"] devient 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] est toujours 5
+
+# Ajouter à un dictionnaire
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  # une autre méthode
+
+# Enlever des clés d'un dictionnaire avec del
+del filled_dict["one"]  # Enlever la clé "one" de filled_dict.
+
+
+# Les sets stockent des ensembles
+empty_set = set()
+# Initialiser un set avec des valeurs. Oui, ça ressemble aux dictionnaires, désolé.
+some_set = {1, 1, 2, 2, 3, 4}   # some_set est maintenant {1, 2, 3, 4}
+
+# Comme les clés d'un dictionnaire, les éléments d'un set doivent être immuables.
+invalid_set = {[1], 1} # => Lève une TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# On peut changer un set :
+filled_set = some_set
+
+# Ajouter un objet au set :
+filled_set.add(5)   # filled_set vaut maintenant {1, 2, 3, 4, 5}
+
+# Chercher les intersections de deux sets avec &
+other_set = {3, 4, 5, 6}
+filled_set & other_set   # => {3, 4, 5}
+
+# On fait l'union de sets avec |
+filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+
+# On fait la différence de deux sets avec -
+{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+
+# On vérifie la présence d'un objet dans un set avec in
+2 in filled_set   # => True
+10 in filled_set   # => False
+
+
+
+####################################################
+## 3. Structures de contrôle et Itérables
+####################################################
+
+# On crée juste une variable
+some_var = 5
+
+# Voici une condition "si". L'indentation est significative en Python!
+# Affiche: "some_var is smaller than 10"
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:    # La clause elif ("sinon si") est optionelle
+    print("some_var is smaller than 10.")
+else:                  # La clause else ("sinon") l'est aussi.
+    print("some_var is indeed 10.")
+
+
+"""
+Les boucles "for" itèrent sur une liste
+Affiche:
+    chien est un mammifère
+    chat est un mammifère
+    souris est un mammifère
+"""
+for animal in ["chien", "chat", "souris"]:
+    # On peut utiliser format() pour interpoler des chaînes formattées
+    print("{} est un mammifère".format(animal))
+
+"""
+"range(nombre)" retourne un itérable de nombres
+de zéro au nombre donné
+Affiche:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+"range(debut, fin)" retourne un itérable de nombre
+de debut à fin.
+Affiche:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(debut, fin, pas)" retourne un itérable de nombres
+de début à fin en incrémentant de pas.
+Si le pas n'est pas indiqué, la valeur par défaut est 1.
+Affiche:
+    4
+    6
+    8
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
+Les boucles "while" bouclent jusqu'à ce que la condition devienne fausse.
+Affiche:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Raccourci pour x = x + 1
+
+# On gère les exceptions avec un bloc try/except
+try:
+    # On utilise "raise" pour lever une erreur
+    raise IndexError("Ceci est une erreur d'index")
+except IndexError as e:
+    pass    # Pass signifie simplement "ne rien faire". Généralement, on gère l'erreur ici.
+except (TypeError, NameError):
+    pass    # Si besoin, on peut aussi gérer plusieurs erreurs en même temps.
+else:   # Clause optionelle des blocs try/except. Doit être après tous les except.
+    print("Tout va bien!")   # Uniquement si aucune exception n'est levée.
+finally: #  Éxécuté dans toutes les circonstances.
+    print("On nettoie les ressources ici")
+
+# Au lieu de try/finally pour nettoyer les ressources, on peut utiliser with
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# Python offre une abstraction fondamentale : l'Iterable.
+# Un itérable est un objet pouvant être traîté comme une séquence.
+# L'objet retourné par la fonction range() est un itérable.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). C'est un objet qui implémente l'interface Iterable
+
+# On peut boucler dessus
+for i in our_iterable:
+    print(i)    # Affiche one, two, three
+
+# Cependant, on ne peut pas accéder aux éléments par leur adresse.
+our_iterable[1]  # Lève une TypeError
+
+# Un itérable est un objet qui sait créer un itérateur.
+our_iterator = iter(our_iterable)
+
+# Notre itérateur est un objet qui se rappelle de notre position quand on le traverse.
+# On passe à l'élément suivant avec "next()".
+next(our_iterator)  #=> "one"
+
+# Il garde son état quand on itère.
+next(our_iterator)  #=> "two"
+next(our_iterator)  #=> "three"
+
+# Après que l'itérateur a retourné toutes ses données, il lève une exception StopIterator
+next(our_iterator) # Lève une StopIteration
+
+# On peut mettre tous les éléments d'un itérateur dans une liste avec list()
+list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+
+
+####################################################
+## 4. Fonctions
+####################################################
+
+# On utilise "def" pour créer des fonctions
+def add(x, y):
+    print("x est {} et y est {}".format(x, y))
+    return x + y    # On retourne une valeur avec return
+
+# Appel d'une fonction avec des paramètres :
+add(5, 6)   # => affiche "x est 5 et y est 6" et retourne 11
+
+# Une autre manière d'appeller une fonction : avec des arguments
+add(y=6, x=5)   # Les arguments peuvent être dans n'importe quel ordre.
+
+# Définir une fonction qui prend un nombre variable d'arguments
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)   # => (1, 2, 3)
+
+# On peut aussi définir une fonction qui prend un nombre variable de paramètres.
+def keyword_args(**kwargs):
+    return kwargs
+
+# Appelons la pour voir ce qu'il se passe :
+keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+
+
+# On peut aussi faire les deux à la fois :
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) affiche:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# En appelant des fonctions, on peut aussi faire l'inverse :
+# utiliser * pour étendre un tuple de paramètres 
+# et ** pour étendre un dictionnaire d'arguments.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)   # équivalent à foo(1, 2, 3, 4)
+all_the_args(**kwargs)   # équivalent à foo(a=3, b=4)
+all_the_args(*args, **kwargs)   # équivalent à foo(1, 2, 3, 4, a=3, b=4)
+
+# Retourne plusieurs valeurs (avec un tuple)
+def swap(x, y):
+    return y, x # Retourne plusieurs valeurs avec un tuple sans parenthèses.
+                # (Note: on peut aussi utiliser des parenthèses)
+
+x = 1
+y = 2
+x, y = swap(x, y) # => x = 2, y = 1
+# (x, y) = swap(x,y) # Là aussi, rien ne nous empêche d'ajouter des parenthèses
+
+# Portée des fonctions :
+x = 5
+
+def setX(num):
+    # La variable locale x n'est pas la même que la variable globale x
+    x = num # => 43
+    print (x) # => 43
+
+def setGlobalX(num):
+    global x
+    print (x) # => 5
+    x = num # la variable globale x est maintenant 6
+    print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python a des fonctions de première classe
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# Mais aussi des fonctions anonymes
+(lambda x: x > 2)(3)   # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
+
+# TODO - Fix for iterables
+# Il y a aussi des fonctions de base
+map(add_10, [1, 2, 3])   # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+
+# On peut utiliser les compréhensions de listes pour de jolies maps et filtres.
+# Une compréhension de liste stocke la sortie comme une liste qui peut elle même être une liste imbriquée.
+[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# On utilise l'opérateur "classe" pour définir une classe
+class Human:
+
+    # Un attribut de la classe. Il est partagé par toutes les instances de la classe.
+    species = "H. sapiens"
+
+    # L'initialiseur de base. Il est appelé quand la classe est instanciée.
+    # Note : les doubles underscores au début et à la fin sont utilisés pour
+    # les fonctions et attributs utilisés par Python mais contrôlés par l'utilisateur.
+    # Les méthodes (ou objets ou attributs) comme: __init__, __str__,
+    # __repr__ etc. sont appelés méthodes magiques.
+    # Vous ne devriez pas inventer de noms de ce style.
+    def __init__(self, name):
+        # Assigner l'argument à l'attribut de l'instance
+        self.name = name
+
+    # Une méthode de l'instance. Toutes prennent "self" comme premier argument.
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # Une méthode de classe est partagée avec entre les instances
+    # Ils sont appelés avec la classe comme premier argument
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Une méthode statique est appelée sans référence à une instance ni à une classe.
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instantier une classe
+i = Human(name="Ian")
+print(i.say("hi"))     # affiche "Ian: hi"
+
+j = Human("Joel")
+print(j.say("hello"))  # affiche "Joel: hello"
+
+# Appeller notre méthode de classe
+i.get_species()   # => "H. sapiens"
+
+# Changer les attributs partagés
+Human.species = "H. neanderthalensis"
+i.get_species()   # => "H. neanderthalensis"
+j.get_species()   # => "H. neanderthalensis"
+
+# Appeller la méthode statique
+Human.grunt()   # => "*grunt*"
+
+
+####################################################
+## 6. Modules
+####################################################
+
+# On peut importer des modules
+import math
+print(math.sqrt(16))  # => 4
+
+# On peut importer des fonctions spécifiques d'un module
+from math import ceil, floor
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))   # => 3.0
+
+# On peut importer toutes les fonctions d'un module
+# Attention: ce n'est pas recommandé.
+from math import *
+
+# On peut raccourcir un nom de module
+import math as m
+math.sqrt(16) == m.sqrt(16)   # => True
+
+# Les modules Python sont juste des fichiers Python.
+# Vous pouvez écrire les vôtres et les importer. Le nom du module
+# est le nom du fichier.
+
+# On peut voir quels fonctions et objets un module définit
+import math
+dir(math)
+
+
+####################################################
+## 7. Avancé
+####################################################
+
+# Les générateurs aident à faire du code paresseux (lazy)
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# Un générateur crée des valeurs à la volée.
+# Au lieu de générer et retourner toutes les valeurs en une fois, il en crée une à chaque
+# itération.  Cela signifie que les valeurs supérieures à 15 ne seront pas traîtées par
+# double_numbers.
+# Note : range est un générateur aussi. 
+# Créer une liste 1-900000000 prendrait beaucoup de temps
+# On met un underscore à la fin d'un nom de variable normalement réservé par Python.
+range_ = range(1, 900000000)
+# Double tous les nombres jusqu'à ce qu'un nombre >=30 soit trouvé
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decorateurs
+# Dans cet exemple, beg enveloppe say
+# Beg appellera say. Si say_please vaut True le message retourné sera changé
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())  # affiche Can you buy me a beer?
+print(say(say_please=True))  # affiche Can you buy me a beer? Please! I am poor :(
+```
+
+## Prêt pour encore plus ?
+
+### En ligne et gratuit (en anglais)
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+
+### Livres (en anglais)
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown
index a43edf16..c6d06361 100644
--- a/fr-fr/scala.html.markdown
+++ b/fr-fr/scala.html.markdown
@@ -208,6 +208,7 @@ sSquared.reduce (_+_)
 // La fonction filter prend un prédicat (une fonction de type A -> Booléen) et
 // sélectionne tous les éléments qui satisfont ce prédicat
 List(1, 2, 3) filter (_ > 2) // List(3)
+case class Person(name: String, age: Int)
 List(
   Person(name = "Dom", age = 23),
   Person(name = "Bob", age = 30)
@@ -217,6 +218,7 @@ List(
 
 // Scala a une méthode foreach définie pour certaines collections
 // qui prend en argument une fonction renvoyant Unit (une méthode void)
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
 aListOfNumbers foreach (x => println(x))
 aListOfNumbers foreach println
 
@@ -271,11 +273,12 @@ i    // Montre la valeur de i. Notez que while est une boucle au sens classique.
      // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus
      // facile pour comprendre et pour faire la parallélisation
 
+i = 0
 // La boucle do while
 do {
   println("x is still less then 10");
-  x += 1
-} while (x < 10)
+  i += 1
+} while (i < 10)
 
 
 // La récursivité est un moyen idiomatique de faire une chose répétitive en Scala.
@@ -370,7 +373,7 @@ val email(user, domain) = "henry@zkpr.com"
 
 "Les chaînes de caractères Scala sont entourées de doubles guillements"
 'a' // Un caractère de Scala
-'Les simples guillemets n'existent pas en Scala // Erreur
+// 'Les simples guillemets n'existent pas en Scala' // Erreur
 "Les chaînes de caractères possèdent les méthodes usuelles de Java".length
 "Il y a aussi quelques méthodes extra de Scala.".reverse
 
diff --git a/fr-fr/yaml-fr.html.markdown b/fr-fr/yaml-fr.html.markdown
index 43b1df54..1e8296d3 100644
--- a/fr-fr/yaml-fr.html.markdown
+++ b/fr-fr/yaml-fr.html.markdown
@@ -8,113 +8,117 @@ lang: fr-fr
 
 Proposé à l'origine par Clark Evans en Mai 2001, YAML est un un format de 
 représentation de données par sérialisation, conçu pour être aisément 
-éditable et lisible par nous même, les humains.
+modifiable et lisible par nous-mêmes, les humains.
 
-YAML est plus concis que le XML auquel il est parfois comparé par ceux qui le découvre, plus lisible et clair que le CSV, et emprunte beaucoup au JSON dont il est un parent naturel. Toutefois, YAML emprunte également des idées et concepts de chez Python, et s'intègre bien avec bon nombre de langages.
+YAML est plus concis que le XML auquel il est parfois comparé par ceux qui le
+découvre, plus lisible et clair que le CSV, et emprunte beaucoup au JSON dont
+il est un parent naturel. Toutefois, YAML emprunte également des idées et
+concepts de Python, et s'intègre bien avec bon nombre de langages.
+Contrairement à ce dernier, YAML interdit l'utilisation des tabulations.
 
 
 ```yaml
-# les Commentaires sont précédés d'un signe "#", comme cette ligne.
+# Les commentaires sont précédés d'un signe "#", comme cette ligne.
 
 #############
 # SCALAIRES #
 #############
 
-# Les scalaires sont l'ensemble des types YAML qui ne sont pas des collections 
-# ( listes ou tableaux associatifs ).
+# Les scalaires sont l'ensemble des types YAML qui ne sont pas des collections
+# (listes ou tableaux associatifs).
 
-# Notre objet root ( racine ), sera une map ( carte ) et englobera 
-# l'intégralité du document. Cette map est l'équivalent d'un dictionnaire, 
+# Notre objet root (racine), sera une map (carte) et englobera
+# l'intégralité du document. Cette map est l'équivalent d'un dictionnaire,
 # hash ou objet dans d'autres langages.
 clé: valeur
-aurtre_clé: une autre valeur
+autre_clé: une autre valeur
 valeur_numérique: 100
 notation_scientifique: 1e+12
-boolean: true
+booléen: true
 valeur_null: null
 clé avec espaces: valeur
-# Bien qu'il ne soit pas nécessaire d'enfermer les chaînes de caractères 
+# Bien qu'il ne soit pas nécessaire de mettre les chaînes de caractères
 # entre guillemets, cela reste possible, et parfois utile.
 toutefois: "Une chaîne, peut être contenue entre guillemets."
-"Une clé entre guillemets.": "Utile si on veut utiliser ':' dans la clé."
+"Une clé entre guillemets.": "Utile si l'on veut utiliser ':' dans la clé."
 
-# Les chaînes couvrant plusieurs lignes, peuvent être écrites au choix, 
-# comme un 'bloc littéral' ( avec | ) ou bien 'bloc replié' avec ( > ).
+# Les chaînes couvrant plusieurs lignes, peuvent être écrites au choix,
+# comme un "bloc littéral" (avec '|') ou bien un "bloc replié" (avec '>').
 bloc_littéral: |
-    Tout ce bloc de texte sera la valeur de la clé 'bloc_littéral', 
-    avec préservation des retours à la ligne. ( chaque ligne vide à 
-    l'intérieur du même bloc, sera remplacée par "\n\n" )
+    Tout ce bloc de texte sera la valeur de la clé "bloc_littéral", 
+    avec préservation des retours à la ligne.
 
     Le littéral continue jusqu'à ce que l'indentation soit annulée.
 
-        Toutes lignes qui serait "d'avantage indentées" conservent leur 
+        Toutes lignes qui seraient "davantage indentées" conservent leur
         indentation, constituée de 4 espaces.
 bloc_replié: >
-    Tout ce bloc de texte sera la valeur de la clé 'bloc_replié', mais 
-    cette fois ci, toutes les nouvelles lignes deviendront un simple espace.
+    Tout ce bloc de texte sera la valeur de la clé "bloc_replié", mais 
+    cette fois-ci, toutes les nouvelles lignes deviendront un simple espace.
 
-    Les lignes vides, comme ci-dessus, seront converties en caractère "\n".
+    Les lignes vides, comme ci-dessus, seront converties en caractère de
+    nouvelle ligne.
 
-        Les lignes 'plus-indentées' gardent leurs retours à la ligne - 
+        Les lignes "plus-indentées" gardent leurs retours à la ligne -
         ce texte apparaîtra sur deux lignes.
 
 ###############
 # COLLECTIONS #
 ###############
 
-# l'Imbrication est créée par indentation.
+# L'imbrication est créée par indentation.
 une_map_imbriquée:
     clé: valeur
     autre_clé: autre valeur
     autre_map_imbriquée:
         bonjour: bonjour
 
-# les Clés des Maps ne sont pas nécessairement des chaînes de caractères.
-0.25: une clé de type float
+# Les clés des maps ne sont pas nécessairement des chaînes de caractères.
+0.25: une clé de type flottant
 
-# les Clés peuvent également être des objets s'étendant sur plusieurs lignes, 
+# Les clés peuvent également être des objets s'étendant sur plusieurs lignes,
 # en utilisant le signe "?" pour indiquer le début de la clé.
 ? |
-    ceci est une Clé
+    ceci est une clé
     sur de multiples lignes
-: et ceci est sa Valeur
+: et ceci est sa valeur
 
 # YAML autorise aussi l'usage des collections à l'intérieur des clés,
 # mais certains langages de programmation ne le tolère pas si bien.
 
-# les Séquences (équivalent des listes ou tableaux) ressemblent à cela:
+# Les séquences (équivalent des listes ou tableaux) ressemblent à cela :
 une_séquence:
-    - Item 1
-    - Item 2
+    - Objet 1
+    - Objet 2
     - 0.5 # les séquences peuvent contenir des types variés.
-    - Item 4
+    - Objet 4
     - clé: valeur
       autre_clé: autre_valeur
     -
         - Ceci est une séquence
         - dans une autre séquence
 
-# YAML étant un proche parent de JSON, vous pouvez écrire directement 
+# YAML étant un proche parent de JSON, vous pouvez écrire directement
 # des maps et séquences façon JSON
 json_map: {"clé": "valeur"}
 json_seq: [1, 2, 3, "soleil"]
 
-#################################
+################################
 # AUTRES FONCTIONNALITÉES YAML #
-#################################
+################################
 
-# YAML possède une fonctionnalité fort utile nommée 'ancres'. Celle-ci 
+# YAML possède une fonctionnalité fort utile nommée "ancres". Celle-ci
 # vous permet de dupliquer aisément du contenu au sein de votre document.
 
-# Les deux clés suivantes auront la même valeur:
+# Les deux clés suivantes auront la même valeur :
 contenu_ancré: &nom_ancre Cette chaîne sera la valeur des deux clés.
 autre_ancre: *nom_ancre
 
-# Avec les Tags YAML, vous pouvez explicitement déclarer des types de données.
+# Avec les tags YAML, vous pouvez explicitement déclarer des types de données.
 chaine_explicite: !!str 0.5
 
-# Certains parsers implémentent des tags spécifiques à d'autres langages, 
-# comme par exemple le "complex number" de Python.
+# Certains analyseurs syntaxiques (parsers) implémentent des tags spécifiques à
+# d'autres langages, comme par exemple celui des nombres complexes de Python.
 python_complex_number: !!python/complex 1+2j
 
 #####################
@@ -122,7 +126,7 @@ python_complex_number: !!python/complex 1+2j
 #####################
 
 # YAML interprète également les données formatées ISO de type date et datetime,
-# pas seulement les chaînes et nombres. 
+# pas seulement les chaînes et nombres.
 datetime: 2001-12-15T02:59:43.1Z
 datetime_avec_espaces: 2001-12-14 21:59:43.10 -5
 date: 2002-12-14
@@ -135,14 +139,14 @@ fichier_gif: !!binary |
     +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
     AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
 
-# YAML a de même un type "set", qui ressemble à cela:
+# YAML a de même un type "set", semblable à ceci :
 set:
     ? item1
     ? item2
     ? item3
 
 # Comme dans Python, les sets ne sont que des maps contenant des valeurs null ;
-# le set précédent est l'équivalent du suivant:
+# le set précédent est l'équivalent du suivant :
 set2:
     item1: null
     item2: null
@@ -152,6 +156,6 @@ set2:
 
 Quelques références et outils :
 
-- Doc officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*,
+- Documentation officielle [YAML 1.2](http://www.yaml.org/spec/1.2/spec.html) *anglais*,
 - Une [Introduction à YAML](http://sweetohm.net/html/introduction-yaml.html) très bien construite et claire,
-- Un outil pour tester [live](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples.
+- Un outil pour tester [en ligne](http://yaml-online-parser.appspot.com/) la syntaxe YAML, avec des exemples.
diff --git a/fsharp.html.markdown b/fsharp.html.markdown
index 49951c78..76318d7d 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -5,7 +5,7 @@ contributors:
 filename: learnfsharp.fs
 ---
 
-F# is a general purpose functional/OO programming language.  It's free and open source, and runs on Linux, Mac, Windows and more. 
+F# is a general purpose functional/OO programming language.  It's free and open source, and runs on Linux, Mac, Windows and more.
 
 It has a powerful type system that traps many errors at compile time, but it uses type inference so that it reads more like a dynamic language.
 
@@ -90,7 +90,7 @@ let simplePatternMatch =
     | _ -> printfn "x is something else"   // underscore matches anything
 
 // F# doesn't allow nulls by default -- you must use an Option type
-// and then pattern match.  
+// and then pattern match.
 // Some(..) and None are roughly analogous to Nullable wrappers
 let validValue = Some(99)
 let invalidValue = None
@@ -115,39 +115,39 @@ printfn "A string %s, and something generic %A" "hello" [1;2;3;4]
 // into a string, similar to String.Format in C#.
 
 // ================================================
-// More on functions 
+// More on functions
 // ================================================
 
 // F# is a true functional language -- functions are first
-// class entities and can be combined easy to make powerful
+// class entities and can be combined easily to make powerful
 // constructs
 
 // Modules are used to group functions together
 // Indentation is needed for each nested module.
-module FunctionExamples = 
+module FunctionExamples =
 
     // define a simple adding function
     let add x y = x + y
-    
+
     // basic usage of a function
     let a = add 1 2
     printfn "1+2 = %i" a
-    
+
     // partial application to "bake in" parameters
     let add42 = add 42
     let b = add42 1
     printfn "42+1 = %i" b
-    
+
     // composition to combine functions
     let add1 = add 1
     let add2 = add 2
     let add3 = add1 >> add2
     let c = add3 7
     printfn "3+7 = %i" c
-    
+
     // higher order functions
     [1..10] |> List.map add3 |> printfn "new list is %A"
-    
+
     // lists of functions, and more
     let add6 = [add1; add2; add3] |> List.reduce (>>)
     let d = add6 7
@@ -158,54 +158,54 @@ module FunctionExamples =
 // ================================================
 
 // There are three types of ordered collection:
-// * Lists are most basic immutable collection. 
-// * Arrays are mutable and more efficient when needed. 
-// * Sequences are lazy and infinite (e.g. an enumerator). 
+// * Lists are most basic immutable collection.
+// * Arrays are mutable and more efficient when needed.
+// * Sequences are lazy and infinite (e.g. an enumerator).
 //
 // Other collections include immutable maps and sets
 // plus all the standard .NET collections
 
-module ListExamples = 
+module ListExamples =
 
-    // lists use square brackets 
+    // lists use square brackets
     let list1 = ["a";"b"]
     let list2 = "c" :: list1    // :: is prepending
     let list3 = list1 @ list2   // @ is concat
-    
+
     // list comprehensions (aka generators)
-    let squares = [for i in 1..10 do yield i*i] 
+    let squares = [for i in 1..10 do yield i*i]
 
     // prime number generator
     let rec sieve = function
         | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
         | []      -> []
     let primes = sieve [2..50]
-    printfn "%A" primes 
-    
+    printfn "%A" primes
+
     // pattern matching for lists
-    let listMatcher aList = 
+    let listMatcher aList =
         match aList with
-        | [] -> printfn "the list is empty" 
-        | [first] -> printfn "the list has one element %A " first 
-        | [first; second] -> printfn "list is %A and %A" first second 
-        | _ -> printfn "the list has more than two elements"    
+        | [] -> printfn "the list is empty"
+        | [first] -> printfn "the list has one element %A " first
+        | [first; second] -> printfn "list is %A and %A" first second
+        | _ -> printfn "the list has more than two elements"
 
     listMatcher [1;2;3;4]
     listMatcher [1;2]
     listMatcher [1]
-    listMatcher []        
+    listMatcher []
 
     // recursion using lists
-    let rec sum aList = 
+    let rec sum aList =
         match aList with
         | [] -> 0
         | x::xs -> x + sum xs
     sum [1..10]
-    
-    // -----------------------------------------    
-    // Standard library functions 
+
+    // -----------------------------------------
+    // Standard library functions
     // -----------------------------------------
-    
+
     // map
     let add3 x = x + 3
     [1..10] |> List.map add3
@@ -213,68 +213,68 @@ module ListExamples =
     // filter
     let even x = x % 2 = 0
     [1..10] |> List.filter even
-    
+
     // many more -- see documentation
-    
-module ArrayExamples = 
+
+module ArrayExamples =
 
     // arrays use square brackets with bar
     let array1 = [| "a";"b" |]
     let first = array1.[0]        // indexed access using dot
-   
+
     // pattern matching for arrays is same as for lists
-    let arrayMatcher aList = 
+    let arrayMatcher aList =
         match aList with
-        | [| |] -> printfn "the array is empty" 
-        | [| first |] -> printfn "the array has one element %A " first 
-        | [| first; second |] -> printfn "array is %A and %A" first second 
-        | _ -> printfn "the array has more than two elements"    
+        | [| |] -> printfn "the array is empty"
+        | [| first |] -> printfn "the array has one element %A " first
+        | [| first; second |] -> printfn "array is %A and %A" first second
+        | _ -> printfn "the array has more than two elements"
 
     arrayMatcher [| 1;2;3;4 |]
 
     // Standard library functions just as for List
-   
-    [| 1..10 |] 
+
+    [| 1..10 |]
     |> Array.map (fun i -> i+3)
     |> Array.filter (fun i -> i%2 = 0)
     |> Array.iter (printfn "value is %i. ")
-    
-    
-module SequenceExamples = 
+
+
+module SequenceExamples =
 
     // sequences use curly braces
     let seq1 = seq { yield "a"; yield "b" }
-    
-    // sequences can use yield and 
+
+    // sequences can use yield and
     // can contain subsequences
     let strange = seq {
         // "yield! adds one element
         yield 1; yield 2;
-        
+
         // "yield!" adds a whole subsequence
-        yield! [5..10]  
+        yield! [5..10]
         yield! seq {
-            for i in 1..10 do 
+            for i in 1..10 do
               if i%2 = 0 then yield i }}
-    // test                
-    strange |> Seq.toList              
-              
+    // test
+    strange |> Seq.toList
+
 
     // Sequences can be created using "unfold"
     // Here's the fibonacci series
     let fib = Seq.unfold (fun (fst,snd) ->
         Some(fst + snd, (snd, fst + snd))) (0,1)
 
-    // test                        
+    // test
     let fib10 = fib |> Seq.take 10 |> Seq.toList
-    printf "first 10 fibs are %A" fib10     
-   
-    
+    printf "first 10 fibs are %A" fib10
+
+
 // ================================================
-// Data Types 
+// Data Types
 // ================================================
 
-module DataTypeExamples = 
+module DataTypeExamples =
 
     // All data is immutable by default
 
@@ -282,33 +282,33 @@ module DataTypeExamples =
     // -- Use a comma to create a tuple
     let twoTuple = 1,2
     let threeTuple = "a",2,true
-    
+
     // Pattern match to unpack
     let x,y = twoTuple  //sets x=1 y=2
 
-    // ------------------------------------ 
-    // Record types have named fields 
-    // ------------------------------------ 
+    // ------------------------------------
+    // Record types have named fields
+    // ------------------------------------
 
     // Use "type" with curly braces to define a record type
     type Person = {First:string; Last:string}
-    
-    // Use "let" with curly braces to create a record 
+
+    // Use "let" with curly braces to create a record
     let person1 = {First="John"; Last="Doe"}
 
     // Pattern match to unpack
     let {First=first} = person1    //sets first="john"
 
-    // ------------------------------------ 
+    // ------------------------------------
     // Union types (aka variants) have a set of choices
     // Only case can be valid at a time.
-    // ------------------------------------ 
+    // ------------------------------------
 
     // Use "type" with bar/pipe to define a union type
-    type Temp = 
+    type Temp =
         | DegreesC of float
         | DegreesF of float
-        
+
     // Use one of the cases to create one
     let temp1 = DegreesF 98.6
     let temp2 = DegreesC 37.0
@@ -317,29 +317,29 @@ module DataTypeExamples =
     let printTemp = function
        | DegreesC t -> printfn "%f degC" t
        | DegreesF t -> printfn "%f degF" t
-    
-    printTemp temp1 
+
+    printTemp temp1
     printTemp temp2
 
-    // ------------------------------------ 
+    // ------------------------------------
     // Recursive types
-    // ------------------------------------ 
+    // ------------------------------------
 
-    // Types can be combined recursively in complex ways 
+    // Types can be combined recursively in complex ways
     // without having to create subclasses
-    type Employee = 
+    type Employee =
       | Worker of Person
       | Manager of Employee list
 
     let jdoe = {First="John";Last="Doe"}
     let worker = Worker jdoe
-    
-    // ------------------------------------ 
+
+    // ------------------------------------
     // Modelling with types
-    // ------------------------------------ 
-    
+    // ------------------------------------
+
     // Union types are great for modelling state without using flags
-    type EmailAddress = 
+    type EmailAddress =
         | ValidEmailAddress of string
         | InvalidEmailAddress of string
 
@@ -350,40 +350,40 @@ module DataTypeExamples =
 
     // The combination of union types and record types together
     // provide a great foundation for domain driven design.
-    // You can create hundreds of little types that accurately 
+    // You can create hundreds of little types that accurately
     // reflect the domain.
 
     type CartItem = { ProductCode: string; Qty: int }
     type Payment = Payment of float
     type ActiveCartData = { UnpaidItems: CartItem list }
     type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
-        
-    type ShoppingCart = 
+
+    type ShoppingCart =
         | EmptyCart  // no data
         | ActiveCart of ActiveCartData
-        | PaidCart of PaidCartData    
+        | PaidCart of PaidCartData
 
-    // ------------------------------------ 
+    // ------------------------------------
     // Built in behavior for types
-    // ------------------------------------ 
+    // ------------------------------------
 
     // Core types have useful "out-of-the-box" behavior, no coding needed.
     // * Immutability
     // * Pretty printing when debugging
     // * Equality and comparison
     // * Serialization
-        
+
     // Pretty printing using %A
-    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A" 
+    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
              twoTuple person1 temp1 worker
 
     // Equality and comparison built in.
     // Here's an example with cards.
     type Suit = Club | Diamond | Spade | Heart
-    type Rank = Two | Three | Four | Five | Six | Seven | Eight 
-                | Nine | Ten | Jack | Queen | King | Ace    
+    type Rank = Two | Three | Four | Five | Six | Seven | Eight
+                | Nine | Ten | Jack | Queen | King | Ace
 
-    let hand = [ Club,Ace; Heart,Three; Heart,Ace; 
+    let hand = [ Club,Ace; Heart,Three; Heart,Ace;
                  Spade,Jack; Diamond,Two; Diamond,Ace ]
 
     // sorting
@@ -391,27 +391,27 @@ module DataTypeExamples =
     List.max hand |> printfn "high card is %A"
     List.min hand |> printfn "low card is %A"
 
-             
+
 // ================================================
 // Active patterns
 // ================================================
 
-module ActivePatternExamples = 
+module ActivePatternExamples =
 
-    // F# has a special type of pattern matching called "active patterns" 
-    // where the pattern can be parsed or detected dynamically. 
+    // F# has a special type of pattern matching called "active patterns"
+    // where the pattern can be parsed or detected dynamically.
 
     // "banana clips" are the syntax for active patterns
-    
+
     // for example, define an "active" pattern to match character types...
-    let (|Digit|Letter|Whitespace|Other|) ch = 
+    let (|Digit|Letter|Whitespace|Other|) ch =
        if System.Char.IsDigit(ch) then Digit
        else if System.Char.IsLetter(ch) then Letter
        else if System.Char.IsWhiteSpace(ch) then Whitespace
-       else Other         
+       else Other
 
     // ... and then use it to make parsing logic much clearer
-    let printChar ch = 
+    let printChar ch =
       match ch with
       | Digit -> printfn "%c is a Digit" ch
       | Letter -> printfn "%c is a Letter" ch
@@ -424,52 +424,52 @@ module ActivePatternExamples =
     // -----------------------------------
     // FizzBuzz using active patterns
     // -----------------------------------
-    
+
     // You can create partial matching patterns as well
     // Just use undercore in the defintion, and return Some if matched.
     let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
     let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
 
     // the main function
-    let fizzBuzz i = 
+    let fizzBuzz i =
       match i with
-      | MultOf3 & MultOf5 -> printf "FizzBuzz, " 
-      | MultOf3 -> printf "Fizz, " 
-      | MultOf5 -> printf "Buzz, " 
+      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+      | MultOf3 -> printf "Fizz, "
+      | MultOf5 -> printf "Buzz, "
       | _ -> printf "%i, " i
-      
+
     // test
-    [1..20] |> List.iter fizzBuzz 
-    
+    [1..20] |> List.iter fizzBuzz
+
 // ================================================
-// Conciseness 
+// Conciseness
 // ================================================
 
-module AlgorithmExamples = 
+module AlgorithmExamples =
 
-    // F# has a high signal/noise ratio, so code reads 
+    // F# has a high signal/noise ratio, so code reads
     // almost like the actual algorithm
 
     // ------ Example: define sumOfSquares function ------
-    let sumOfSquares n = 
+    let sumOfSquares n =
        [1..n]              // 1) take all the numbers from 1 to n
        |> List.map square  // 2) square each one
        |> List.sum         // 3) sum the results
 
-    // test   
-    sumOfSquares 100 |> printfn "Sum of squares = %A" 
-       
-    // ------ Example: define a sort function ------  
+    // test
+    sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+    // ------ Example: define a sort function ------
     let rec sort list =
        match list with
-       // If the list is empty   
-       | [] ->                            
+       // If the list is empty
+       | [] ->
             []                            // return an empty list
-       // If the list is not empty  
-       | firstElem::otherElements ->      // take the first element    
-            let smallerElements =         // extract the smaller elements    
+       // If the list is not empty
+       | firstElem::otherElements ->      // take the first element
+            let smallerElements =         // extract the smaller elements
                 otherElements             // from the remaining ones
-                |> List.filter (fun e -> e < firstElem) 
+                |> List.filter (fun e -> e < firstElem)
                 |> sort                   // and sort them
             let largerElements =          // extract the larger ones
                 otherElements             // from the remaining ones
@@ -479,13 +479,13 @@ module AlgorithmExamples =
             List.concat [smallerElements; [firstElem]; largerElements]
 
     // test
-    sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A" 
+    sort [1;5;23;18;9;1;3] |> printfn "Sorted = %A"
 
 // ================================================
 // Asynchronous Code
 // ================================================
 
-module AsyncExample = 
+module AsyncExample =
 
     // F# has built-in features to help with async code
     // without encountering the "pyramid of doom"
@@ -495,23 +495,23 @@ module AsyncExample =
     open System.Net
     open System
     open System.IO
-    open Microsoft.FSharp.Control.CommonExtensions   
+    open Microsoft.FSharp.Control.CommonExtensions
 
     // Fetch the contents of a URL asynchronously
-    let fetchUrlAsync url =        
-        async {   // "async" keyword and curly braces 
+    let fetchUrlAsync url =
+        async {   // "async" keyword and curly braces
                   // creates an "async" object
-            let req = WebRequest.Create(Uri(url)) 
-            use! resp = req.AsyncGetResponse()    
+            let req = WebRequest.Create(Uri(url))
+            use! resp = req.AsyncGetResponse()
                 // use! is async assignment
-            use stream = resp.GetResponseStream() 
+            use stream = resp.GetResponseStream()
                 // "use" triggers automatic close()
                 // on resource at end of scope
-            use reader = new IO.StreamReader(stream) 
-            let html = reader.ReadToEnd() 
-            printfn "finished downloading %s" url 
+            use reader = new IO.StreamReader(stream)
+            let html = reader.ReadToEnd()
+            printfn "finished downloading %s" url
             }
-            
+
     // a list of sites to fetch
     let sites = ["http://www.bing.com";
                  "http://www.google.com";
@@ -520,7 +520,7 @@ module AsyncExample =
                  "http://www.yahoo.com"]
 
     // do it
-    sites 
+    sites
     |> List.map fetchUrlAsync  // make a list of async tasks
     |> Async.Parallel          // set up the tasks to run in parallel
     |> Async.RunSynchronously  // start them off
@@ -529,58 +529,58 @@ module AsyncExample =
 // .NET compatability
 // ================================================
 
-module NetCompatibilityExamples = 
+module NetCompatibilityExamples =
 
     // F# can do almost everything C# can do, and it integrates
     // seamlessly with .NET or Mono libraries.
 
     // ------- work with existing library functions  -------
-    
+
     let (i1success,i1) = System.Int32.TryParse("123");
     if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
 
     // ------- Implement interfaces on the fly! -------
-    
+
     // create a new object that implements IDisposable
-    let makeResource name = 
-       { new System.IDisposable 
+    let makeResource name =
+       { new System.IDisposable
          with member this.Dispose() = printfn "%s disposed" name }
 
-    let useAndDisposeResources = 
+    let useAndDisposeResources =
         use r1 = makeResource "first resource"
-        printfn "using first resource" 
+        printfn "using first resource"
         for i in [1..3] do
             let resourceName = sprintf "\tinner resource %d" i
-            use temp = makeResource resourceName 
-            printfn "\tdo something with %s" resourceName 
+            use temp = makeResource resourceName
+            printfn "\tdo something with %s" resourceName
         use r2 = makeResource "second resource"
-        printfn "using second resource" 
-        printfn "done." 
+        printfn "using second resource"
+        printfn "done."
 
     // ------- Object oriented code -------
-    
+
     // F# is also a fully fledged OO language.
     // It supports classes, inheritance, virtual methods, etc.
 
     // interface with generic type
-    type IEnumerator<'a> = 
+    type IEnumerator<'a> =
         abstract member Current : 'a
-        abstract MoveNext : unit -> bool 
+        abstract MoveNext : unit -> bool
 
     // abstract base class with virtual methods
     [<AbstractClass>]
-    type Shape() = 
+    type Shape() =
         //readonly properties
         abstract member Width : int with get
         abstract member Height : int with get
         //non-virtual method
         member this.BoundingArea = this.Height * this.Width
         //virtual method with base implementation
-        abstract member Print : unit -> unit 
+        abstract member Print : unit -> unit
         default this.Print () = printfn "I'm a shape"
 
-    // concrete class that inherits from base class and overrides 
-    type Rectangle(x:int, y:int) = 
+    // concrete class that inherits from base class and overrides
+    type Rectangle(x:int, y:int) =
         inherit Shape()
         override this.Width = x
         override this.Height = y
@@ -590,20 +590,20 @@ module NetCompatibilityExamples =
     let r = Rectangle(2,3)
     printfn "The width is %i" r.Width
     printfn "The area is %i" r.BoundingArea
-    r.Print()        
+    r.Print()
 
     // ------- extension methods  -------
-        
+
     //Just as in C#, F# can extend existing classes with extension methods.
     type System.String with
        member this.StartsWithA = this.StartsWith "A"
 
     //test
     let s = "Alice"
-    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA    
-    
+    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
     // ------- events  -------
-   
+
     type MyButton() =
         let clickEvent = new Event<_>()
 
@@ -615,11 +615,11 @@ module NetCompatibilityExamples =
 
     // test
     let myButton = new MyButton()
-    myButton.OnClick.Add(fun (sender, arg) -> 
+    myButton.OnClick.Add(fun (sender, arg) ->
             printfn "Click event with arg=%O" arg)
 
     myButton.TestEvent("Hello World!")
-        
+
 ```
 
 ## More Information
diff --git a/git.html.markdown b/git.html.markdown
index bf8fce0c..bedc9853 100644
--- a/git.html.markdown
+++ b/git.html.markdown
@@ -5,20 +5,21 @@ contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
     - ["Leo Rudberg" , "http://github.com/LOZORD"]
     - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
 filename: LearnGit.txt
 ---
 
-Git is a distributed version control and source code management system. 
+Git is a distributed version control and source code management system.
 
-It does this through a series of snapshots of your project, and it works 
-with those snapshots to provide you with functionality to version and 
+It does this through a series of snapshots of your project, and it works
+with those snapshots to provide you with functionality to version and
 manage your source code.
 
 ## Versioning Concepts
 
 ### What is version control?
 
-Version control is a system that records changes to a file, or set of files, over time.
+Version control is a system that records changes to a file(s), over time.
 
 ### Centralized Versioning VS Distributed Versioning
 
@@ -42,8 +43,9 @@ Version control is a system that records changes to a file, or set of files, ove
 
 ### Repository
 
-A set of files, directories, historical records, commits, and heads. Imagine it as a source code data structure,
-with the attribute that each source code "element" gives you access to its revision history, among other things.
+A set of files, directories, historical records, commits, and heads. Imagine it
+as a source code data structure, with the attribute that each source code
+"element" gives you access to its revision history, among other things.
 
 A git repository is comprised of the .git directory & working tree.
 
@@ -54,32 +56,38 @@ The .git directory contains all the configurations, logs, branches, HEAD, and mo
 
 ### Working Tree (component of repository)
 
-This is basically the directories and files in your repository. It is often referred to
-as your working directory.
+This is basically the directories and files in your repository. It is often
+referred to as your working directory.
 
 ### Index (component of .git dir)
 
 The Index is the staging area in git. It's basically a layer that separates your working tree
-from the Git repository. This gives developers more power over what gets sent to the Git
-repository.
+from the Git repository. This gives developers more power over what gets sent
+to the Git repository.
 
 ### Commit
 
-A git commit is a snapshot of a set of changes, or manipulations to your Working Tree.
-For example, if you added 5 files, and removed 2 others, these changes will be contained
-in a commit (or snapshot). This commit can then be pushed to other repositories, or not!
+A git commit is a snapshot of a set of changes, or manipulations to your Working
+Tree. For example, if you added 5 files, and removed 2 others, these changes
+will be contained in a commit (or snapshot). This commit can then be pushed to
+other repositories, or not!
 
 ### Branch
 
-A branch is essentially a pointer that points to the last commit you made. As you commit,
-this pointer will automatically update and point to the latest commit.
+A branch is essentially a pointer to the last commit you made. As you go on
+committing, this pointer will automatically update to point the latest commit.
+
+### Tag
+
+A tag is a mark on specific point in history. Typically people use this
+functionality to mark release points (v1.0, and so on)
 
 ### HEAD and head (component of .git dir)
 
 HEAD is a pointer that points to the current branch. A repository only has 1 *active* HEAD.
 head is a pointer that points to any commit. A repository can have any number of heads.
 
-###Stages of Git
+### Stages of Git
 * Modified - Changes have been made to a file but file has not been committed to Git Database yet
 * Staged - Marks a modified file to go into your next commit snapshot
 * Committed - Files have been committed to the Git Database
@@ -95,7 +103,7 @@ head is a pointer that points to any commit. A repository can have any number of
 
 ### init
 
-Create an empty Git repository. The Git repository's settings, stored information, 
+Create an empty Git repository. The Git repository's settings, stored information,
 and more is stored in a directory (a folder) named ".git".
 
 ```bash
@@ -104,15 +112,12 @@ $ git init
 
 ### config
 
-To configure settings. Whether it be for the repository, the system itself, or global
-configurations.
+To configure settings. Whether it be for the repository, the system itself,
+or global configurations ( global config file is `~/.gitconfig` ).
 
 
 ```bash
 # Print & Set Some Basic Config Variables (Global)
-$ git config --global user.email
-$ git config --global user.name
-
 $ git config --global user.email "MyEmail@Zoho.com"
 $ git config --global user.name "My Name"
 ```
@@ -142,10 +147,20 @@ $ git commit --help
 $ git init --help
 ```
 
+### ignore files
+
+To intentionally untrack file(s) & folder(s) from git. Typically meant for
+private & temp files which would otherwise be shared in the repository.
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "private_key" >> .gitignore
+```
+
+
 ### status
 
-To show differences between the index file (basically your working copy/repo) and the current
-HEAD commit.
+To show differences between the index file (basically your working copy/repo)
+and the current HEAD commit.
 
 
 ```bash
@@ -172,7 +187,8 @@ $ git add /path/to/file/HelloWorld.c
 $ git add ./*.java
 ```
 
-This only adds a file to the staging area/index, it doesn't commit it to the working directory/repo.
+This only adds a file to the staging area/index, it doesn't commit it to the
+working directory/repo.
 
 ### branch
 
@@ -196,6 +212,28 @@ $ git branch -m myBranchName myNewBranchName
 $ git branch myBranchName --edit-description
 ```
 
+### tag
+
+Manage your tags
+
+```bash
+# List tags
+$ git tag
+# Create a annotated tag
+# The -m specifies a tagging message,which is stored with the tag.
+# If you don’t specify a message for an annotated tag,
+# Git launches your editor so you can type it in.
+$ git tag -a v2.0 -m 'my version 2.0'
+# Show info about tag
+# That shows the tagger information, the date the commit was tagged,
+# and the annotation message before showing the commit information.
+$ git show v2.0
+# Push a single tag to remote
+$ git push origin v2.0
+# Push a lot of tags to remote
+$ git push origin --tags
+```
+
 ### checkout
 
 Updates all files in the working tree to match the version in the index, or specified tree.
@@ -205,7 +243,8 @@ Updates all files in the working tree to match the version in the index, or spec
 $ git checkout
 # Checkout a specified branch
 $ git checkout branchName
-# Create a new branch & switch to it, like: "git branch <name>; git checkout <name>"
+# Create a new branch & switch to it
+# equivalent to "git branch <name>; git checkout <name>"
 $ git checkout -b newBranch
 ```
 
@@ -218,6 +257,10 @@ to a remote branch.
 ```bash
 # Clone learnxinyminutes-docs
 $ git clone https://github.com/adambard/learnxinyminutes-docs.git
+# shallow clone - faster cloning that pulls only latest snapshot
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+# clone only a specific branch
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
 ```
 
 ### commit
@@ -231,6 +274,9 @@ $ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
 
 # automatically stage modified or deleted files, except new files, and then commit
 $ git commit -a -m "Modified foo.php and removed bar.php"
+
+# change last commit (this deletes previous commit with a fresh commit)
+$ git commit --amend -m "Correct message"
 ```
 
 ### diff
@@ -268,7 +314,7 @@ $ git config --global alias.g "grep --break --heading --line-number"
 $ git grep 'variableName' -- '*.java'
 
 # Search for a line that contains "arrayListName" and, "add" or "remove"
-$ git grep -e 'arrayListName' --and \( -e add -e remove \) 
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
 ```
 
 Google is your friend; for more examples
@@ -282,8 +328,8 @@ Display commits to the repository.
 # Show all commits
 $ git log
 
-# Show X number of commits
-$ git log -n 10
+# Show only commit message & ref
+$ git log --oneline
 
 # Show merge commits only
 $ git log --merges
@@ -303,7 +349,7 @@ $ git merge --no-ff branchName
 
 ### mv
 
-Rename or move a file	
+Rename or move a file
 
 ```bash
 # Renaming a file
@@ -325,9 +371,12 @@ Pulls from a repository and merges it with another branch.
 # Update your local repo, by merging in new changes
 # from the remote "origin" and "master" branch.
 # git pull <remote> <branch>
-# git pull => implicitly defaults to => git pull origin master
 $ git pull origin master
 
+# By default, git pull will update your current branch
+# by merging in new changes from its remote-tracking branch 
+$ git pull
+
 # Merge in changes from remote branch and rebase
 # branch commits onto your local repo, like: "git pull <remote> <branch>, git rebase <branch>"
 $ git pull origin master --rebase
@@ -338,32 +387,37 @@ $ git pull origin master --rebase
 Push and merge changes from a branch to a remote & branch.
 
 ```bash
-# Push and merge changes from a local repo to a 
+# Push and merge changes from a local repo to a
 # remote named "origin" and "master" branch.
 # git push <remote> <branch>
-# git push => implicitly defaults to => git push origin master
 $ git push origin master
 
+# By default, git push will push and merge changes from
+# the current branch to its remote-tracking branch 
+$ git push
+
 # To link up current local branch with a remote branch, add -u flag:
 $ git push -u origin master
 # Now, anytime you want to push from that same local branch, use shortcut:
-$ git push 
+$ git push
 ```
 
 ### stash
 
-Stashing takes the dirty state of your working directory and saves it on a stack of unfinished changes that you can reapply at any time.
+Stashing takes the dirty state of your working directory and saves it on a stack
+of unfinished changes that you can reapply at any time.
 
-Let's say you've been doing some work in your git repo, but you want to pull from the remote.
-Since you have dirty (uncommited) changes to some files, you are not able to run `git pull`.
-Instead, you can run `git stash` to save your changes onto a stack!
+Let's say you've been doing some work in your git repo, but you want to pull
+from the remote. Since you have dirty (uncommited) changes to some files, you
+are not able to run `git pull`. Instead, you can run `git stash` to save your
+changes onto a stack!
 
 ```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") 
+  (To restore them type "git stash apply")
 ```
 
 Now you can pull!
@@ -410,7 +464,7 @@ Now you're ready to get back to work on your stuff!
 
 [Additional Reading.](http://git-scm.com/book/en/v1/Git-Tools-Stashing)
 
-### rebase (caution) 
+### rebase (caution)
 
 Take all changes that were committed on one branch, and replay them onto another branch.
 *Do not rebase commits that you have pushed to a public repo*.
@@ -464,6 +518,8 @@ $ git rm /pather/to/the/file/HelloWorld.c
 
 * [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)
 
 * [git-scm - Documentation](http://git-scm.com/docs)
@@ -477,3 +533,6 @@ $ git rm /pather/to/the/file/HelloWorld.c
 * [Git - the simple guide](http://rogerdudler.github.io/git-guide/index.html)
 
 * [Pro Git](http://www.git-scm.com/book/en/v2)
+
+* [An introduction to Git and GitHub for Beginners (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
+
diff --git a/go.html.markdown b/go.html.markdown
index 34b855e3..a857a76c 100644
--- a/go.html.markdown
+++ b/go.html.markdown
@@ -10,6 +10,7 @@ contributors:
     - ["Quint Guvernator", "https://github.com/qguv"]
     - ["Jose Donizetti", "https://github.com/josedonizetti"]
     - ["Alexej Friesen", "https://github.com/heyalexej"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
 ---
 
 Go was created out of the need to get work done. It's not the latest trend
@@ -115,7 +116,7 @@ can include line breaks.` // Same string type.
 	fmt.Println(s) // Updated slice is now [1 2 3 4 5 6]
 	// To append another slice, instead of list of atomic elements we can
 	// pass a reference to a slice or a slice literal like this, with a
-	// trailing elipsis, meaning take a slice and unpack its elements,
+	// trailing ellipsis, meaning take a slice and unpack its elements,
 	// appending them to slice s.
 	s = append(s, []int{7, 8, 9}...) // Second argument is a slice literal.
 	fmt.Println(s)	// Updated slice is now [1 2 3 4 5 6 7 8 9]
@@ -129,7 +130,7 @@ can include line breaks.` // Same string type.
 	m["one"] = 1
 
 	// Unused variables are an error in Go.
-	// The underbar lets you "use" a variable but discard its value.
+	// The underscore lets you "use" a variable but discard its value.
 	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
 	// Output of course counts as using a variable.
 	fmt.Println(s, c, a4, s3, d2, m)
@@ -164,7 +165,7 @@ func expensiveComputation() float64 {
 }
 
 func learnFlowControl() {
-	// If statements require brace brackets, and do not require parens.
+	// If statements require brace brackets, and do not require parentheses.
 	if true {
 		fmt.Println("told ya")
 	}
@@ -407,6 +408,8 @@ func requestServer() {
 
 The root of all things Go is the [official Go web site](http://golang.org/).
 There you can follow the tutorial, play interactively, and read lots.
+Aside from a tour, [the docs](https://golang.org/doc/) contain information on
+how to write clean and effective Go code, package and command docs, and release history.
 
 The language definition itself is highly recommended. It's easy to read
 and amazingly short (as language definitions go these days.)
@@ -420,3 +423,5 @@ idioms. Or you can click on a function name in [the
 documentation](http://golang.org/pkg/) and the source code comes up!
 
 Another great resource to learn Go is [Go by example](https://gobyexample.com/).
+
+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 519f36ce..492c1ba2 100644
--- a/groovy.html.markdown
+++ b/groovy.html.markdown
@@ -99,7 +99,7 @@ technologies.sort()
 // To sort without mutating original, you can do:
 sortedTechnologies = technologies.sort( false )
 
-/*** Manipulating Lists ***/
+/*** Manipulating Lists ***/e
 
 //Replace all elements in the list
 Collections.replaceAll(technologies, 'Gradle', 'gradle')
@@ -200,6 +200,14 @@ def y = 10
 def x = (y > 1) ? "worked" : "failed"
 assert x == "worked"
 
+//Groovy supports 'The Elvis Operator' too!
+//Instead of using the ternary operator:
+
+displayName = user.name ? user.name : 'Anonymous'
+
+//We can write it:
+displayName = user.name ?: 'Anonymous'
+
 //For loop
 //Iterate over a range
 def x = 0
@@ -422,6 +430,3 @@ Join a [Groovy user group](http://www.groovy-lang.org/usergroups.html)
 [1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
 [2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
 [3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
-
-
-
diff --git a/hack.html.markdown b/hack.html.markdown
index 632fc705..b3d19f8e 100644
--- a/hack.html.markdown
+++ b/hack.html.markdown
@@ -2,6 +2,7 @@
 language: Hack
 contributors:
     - ["Stephen Holdaway", "https://github.com/stecman"]
+    - ["David Lima", "https://github.com/davelima"]
 filename: learnhack.hh
 ---
 
@@ -50,7 +51,7 @@ function identity(?string $stringOrNull) : ?string
 class TypeHintedProperties
 {
     public ?string $name;
-    
+
     protected int $id;
 
     private float $score = 100.0;
@@ -90,7 +91,7 @@ function openBox(Box<int> $box) : int
 
 
 // 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);
@@ -107,7 +108,7 @@ distance(
 
 
 // Type aliasing
-// 
+//
 // Hack adds a bunch of type aliasing features for making complex types readable
 newtype VectorArray = array<int, Vector<int>>;
 
@@ -141,7 +142,7 @@ function getRoadType() : RoadType
 
 
 // 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.
@@ -152,7 +153,7 @@ class ArgumentPromotion
                                 private bool $isAwesome) {}
 }
 
-class WithoutArugmentPromotion
+class WithoutArgumentPromotion
 {
     public string $name;
 
@@ -169,13 +170,13 @@ class WithoutArugmentPromotion
 }
 
 
-// Co-oprerative multi-tasking
-// 
-// Two new keywords "async" and "await" can be used to perform mutli-tasking
+// 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++) { 
+    for ($i = $start; $i <= $end; $i++) {
         echo "$i ";
 
         // Give other tasks a chance to do something
@@ -192,9 +193,9 @@ AwaitAllWaitHandle::fromArray([
 
 
 // Attributes
-// 
+//
 // Attributes are a form of metadata for functions. Hack provides some
-// special built-in attributes that introduce useful behaviour. 
+// special built-in attributes that introduce useful behaviour.
 
 // The __Memoize special attribute causes the result of a function to be cached
 <<__Memoize>>
@@ -247,7 +248,7 @@ class ConsistentBar extends ConsistentFoo
 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"
     //
@@ -258,7 +259,7 @@ class InvalidFooSubclass extends ConsistentFoo
 
     // Using the __Override annotation on a non-overriden 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"
     //
diff --git a/haml.html.markdown b/haml.html.markdown
index aed3dcae..0948e9ef 100644
--- a/haml.html.markdown
+++ b/haml.html.markdown
@@ -62,11 +62,11 @@ $ haml input_file.haml output_file.html
 %h1 Headline copy
 
 / To write multiline content, nest it instead
-%p 
+%p
   This is a lot of content that we could probably split onto two
   separate lines.
 
-/ 
+/
   You can escape html by using the ampersand and equals sign ( &= ). This
   converts html-sensitive characters (&, /, :) into their html encoded
   equivalents. For example
@@ -102,7 +102,7 @@ $ haml input_file.haml output_file.html
 / Inserting Ruby
 / -------------------------------------------
 
-/ 
+/
   To output a Ruby value as the contents of a tag, use an equals sign followed
   by the Ruby code
 
@@ -122,11 +122,36 @@ $ haml input_file.haml output_file.html
 
   if book do
     %p This is a book
+    
+/ Adding ordered / unordered list
+%ul
+  %li
+    =item1
+    =item2
 
 /
   Again, no need to add the closing tags to the block, even for the Ruby.
   Indentation will take care of that for you.
 
+/ -------------------------------------------
+/ Inserting Table with bootstrap classes
+/ -------------------------------------------
+
+%table.table.table-hover
+  %thead
+    %tr
+      %th Header 1
+      %th Header 2
+    
+    %tr
+      %td Value1
+      %td value2
+    
+  %tfoot
+    %tr
+      %td
+        Foot value
+
 
 / -------------------------------------------
 / Inline Ruby / Ruby interpolation
@@ -141,7 +166,7 @@ $ haml input_file.haml output_file.html
 / -------------------------------------------
 
 /
-  Use the colon to define Haml filters, one example of a filter you can 
+  Use the colon to define Haml filters, one example of a filter you can
   use is :javascript, which can be used for writing inline js
 
 :javascript
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 369b1b20..08611e63 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -195,11 +195,11 @@ foo 5 -- 15
 -- function composition
 -- the (.) function chains functions together.
 -- For example, here foo is a function that takes a value. It adds 10 to it,
--- multiplies the result of that by 5, and then returns the final value.
-foo = (*5) . (+10)
+-- multiplies the result of that by 4, and then returns the final value.
+foo = (*4) . (+10)
 
--- (5 + 10) * 5 = 75
-foo 5 -- 75
+-- (5 + 10) * 4 = 60
+foo 5 -- 60
 
 -- fixing precedence
 -- Haskell has another operator called `$`. This operator applies a function 
diff --git a/hu-hu/ruby.html.markdown b/hu-hu/ruby.html.markdown
new file mode 100644
index 00000000..169f2b8e
--- /dev/null
+++ b/hu-hu/ruby.html.markdown
@@ -0,0 +1,555 @@
+---
+language: ruby
+lang: hu-hu
+filenev: learnruby.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  translators:
+  - ["Zsolt Prontvai", "https://github.com/prozsolt"]
+---
+
+```ruby
+# Ez egy komment
+
+=begin
+Ez egy többsoros komment
+Senki sem használja
+Neked sem kellene
+=end
+
+# Először is: Minden objektum
+
+# A számok objektumok
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Néhány alapvető számtani művelet
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+
+# A számtani művelet csak szintaktikus cukor
+# az objektumon történő függvény hívásra
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# A speciális értékek objektumok
+nil # Nincs itt semmi látnivaló
+true # igaz
+false # hamis
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Egyenlőség
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Egyenlőtlenség
+1 != 1 #=> false
+2 != 1 #=> true
+
+# A false-on kívül, nil az egyetlen hamis érték
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Még több összehasonlítás
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Logikai operátorok
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# A logikai operátoroknak alternatív verziójuk is van sokkal kisebb
+# precedenciával. Ezeket arra szánták, hogy több állítást összeláncoljanak
+# amíg egyikük igaz vagy hamis értékkel nem tér vissza.
+
+# `csinalj_valami_mast` csak akkor fut le, ha `csinalj_valamit` igaz értékkel
+# tért vissza.
+csinalj_valamit() and csinalj_valami_mast()
+# `log_error` csak akkor fut le, ha `csinalj_valamit` hamis értékkel
+# tért vissza.
+csinalj_valamit() or log_error()
+
+
+# A sztringek objektumok
+
+'Én egy sztring vagyok'.class #=> String
+"Én is egy sztring vagyok".class #=> String
+
+helykitolto = 'interpolációt használhatok'
+"Sztring #{helykitolto}, ha dupla időzőjelben van a sztringem"
+#=> "Sztring interpolációt használhatok, ha dupla időzőjelben van a sztringem"
+
+# A szimpla idézőjelet preferáljuk, ahol csak lehet,
+# mert a dupla idézőjel extra számításokat végez.
+
+# Kombinálhatunk sztringeket, de nem számokkal
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+
+# kiírás a kimenetre
+puts "Írok"
+
+# Változók
+x = 25 #=> 25
+x #=> 25
+
+# Értékadás az adott értékkel tér vissza
+# Ez azt jelenti, hogy használhatunk többszörös értékadást:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Konvencióból, snake_case változó neveket használj
+snake_case = true
+
+# Leíró változó neveket használj
+ut_a_projekt_gyokerehez = '/jo/nev/'
+ut = '/rossz/nev/'
+
+# A szimbólumok (objektumok)
+# A szimbólumok megváltoztathatatlan, újra felhasználható konstans,
+# mely belsőleg egész számként reprezentált. Sokszor sztring helyett használják,
+# hogy effektíven közvetítsünk konkrét, értelmes értékeket
+
+:fuggoben.class #=> Symbol
+
+statusz = :fuggoben
+
+statusz == :fuggoben #=> true
+
+statusz == 'fuggoben' #=> false
+
+statusz == :jovahagyott #=> false
+
+# Tömbök
+
+# Ez egy tömb
+tomb = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# A tömmbök különböző tipusú dolgokat tartalmazhat
+
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Tömbök indexelhetőek
+# Az elejéről
+tomb[0] #=> 1
+tomb[12] #=> nil
+
+# Akárcsak a számtani műveletek [var] hozzáférés
+# is csak szintaktikus cukor
+# a [] függvény hívására az objektumon
+tomb.[] 0 #=> 1
+tomb.[] 12 #=> nil
+
+# A végéről
+tomb[-1] #=> 5
+
+# Kezdőértékkel és hosszal
+tomb[2, 3] #=> [3, 4, 5]
+
+# Tömb megfordítása
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Vagy tartománnyal
+tomb[1..3] #=> [2, 3, 4]
+
+# Így adhatunk a tömbhöz
+tomb << 6 #=> [1, 2, 3, 4, 5, 6]
+# Vagy így
+tomb.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Ellenőrízük, hogy a tömb tartalmaz egy elemet
+tomb.include?(1) #=> true
+
+# Hash-ek a ruby elsődleges szótárjai kulcs/érték párokkal
+# Hash-eket kapcsos zárójellel jelöljük
+hash = { 'szin' => 'zold', 'szam' => 5 }
+
+hash.keys #=> ['szin', 'szam']
+
+# Hash-ekben könnyen kreshetünk a kulcs segítségével:
+hash['szin'] #=> 'zold'
+hash['szam'] #=> 5
+
+# Nem létező kulcsra keresve nil-t kapunk:
+hash['nincs itt semmi'] #=> nil
+
+# Ruby 1.9-től, egy külnleges szintaxist is használhatunk a szimbólumot
+# használunk kulcsnak
+
+uj_hash = { defcon: 3, action: true }
+
+uj_hash.keys #=> [:defcon, :action]
+
+# Ellenőrizzük, hogy az adott kulcs és érték bene-e van a hash-ben
+uj_hash.has_key?(:defcon) #=> true
+uj_hash.has_value?(3) #=> true
+
+# Tip: A tömbök és hash-ek is felsorolhatóak
+# Sok közös függvényük van, akár az each, map, count, és több
+
+# Kontroll Struktúrák
+
+if true
+  'ha állítás'
+elsif false
+  'különben ha, opcionális'
+else
+  'különben, szintén opcionális'
+end
+
+for szamlalo in 1..5
+  puts "iteracio #{szamlalo}"
+end
+#=> iteracio 1
+#=> iteracio 2
+#=> iteracio 3
+#=> iteracio 4
+#=> iteracio 5
+
+# HOWEVER, No-one uses for loops.
+# Instead you should use the "each" method and pass it a block.
+# A block is a bunch of code that you can pass to a method like "each".
+# It is analogous to lambdas, anonymous functions or closures in other
+# programming languages.
+#
+# The "each" method of a range runs the block once for each element of the range.
+# The block is passed a counter as a parameter.
+# Calling the "each" method with a block looks like this:
+
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+# You can also surround blocks in curly brackets:
+(1..5).each { |counter| puts "iteration #{counter}" }
+
+# The contents of data structures can also be iterated using each.
+array.each do |element|
+  puts "#{element} is part of the array"
+end
+hash.each do |key, value|
+  puts "#{key} is #{value}"
+end
+
+counter = 1
+while counter <= 5 do
+  puts "iteration #{counter}"
+  counter += 1
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+jegy = '4'
+
+case jegy
+when '5'
+  puts 'Kitünő'
+when '4'
+  puts 'Jó'
+when '3'
+  puts 'Közepes'
+when '2'
+  puts 'Elégsége'
+when '1'
+  puts 'Elégtelen'
+else
+  puts 'Alternatív értékelés, hm?'
+end
+#=> "Jó"
+
+# case-ek tartományokat is használhatnak
+jegy = 82
+case jegy
+when 90..100
+  puts 'Hurrá!'
+when 80...90
+  puts 'Jó munka'
+else
+  puts 'Megbuktál!'
+end
+#=> "Jó munka"
+
+# kivétel kezelés:
+begin
+  # kód ami kivételt dobhat
+  raise NoMemoryError, 'Megtelt a memória'
+rescue NoMemoryError => kivetel_valtozo
+  puts 'NoMemoryError-t dobott', kivetel_valtozo
+rescue RuntimeError => mas_kivetel_valtozo
+  puts 'RuntimeError dobott most'
+else
+  puts 'Ez akkor fut ha nem dob kivételt'
+ensure
+  puts 'Ez a kód mindenképpen lefut'
+end
+
+# Függvények
+
+def ketszeres(x)
+  x * 2
+end
+
+# Függvények (és egyébb blokkok) implicit viszatértnek az utolsó értékkel
+ketszeres(2) #=> 4
+
+# Zárójelezés opcionális, ha az eredmény félreérthetetlen
+ketszeres 3 #=> 6
+
+ketszeres ketszeres 3 #=> 12
+
+def osszeg(x, y)
+  x + y
+end
+
+# Függvény argumentumait vesszővel választjuk el.
+osszeg 3, 4 #=> 7
+
+osszeg osszeg(3, 4), 5 #=> 12
+
+# yield
+# Minden függvénynek van egy implicit, opcionális block paramétere
+# 'yield' kulcsszóval hívhatjuk
+
+def korulvesz
+  puts '{'
+  yield
+  puts '}'
+end
+
+korulvesz { puts 'hello world' }
+
+# {
+# hello world
+# }
+
+
+# Fuggvénynek átadhatunk blokkot
+# "&" jelöli az átadott blokk referenciáját
+def vendegek(&block)
+  block.call 'valami_argumentum'
+end
+
+# Argumentum lisát is átadhatunk, ami tömbé lesz konvertálva
+# Erre való a splat operátor ("*")
+def vendegek(*array)
+  array.each { |vendeg| puts vendeg }
+end
+
+# Osztályt a class kulcsszóval definiálhatunk
+class Ember
+
+  # Az osztály változó. Az osztály minden példánnyával megvan osztva
+  @@faj = 'H. sapiens'
+
+  # Alap inicializáló
+  def initialize(nev, kor = 0)
+    # Hozzárendeli az argumentumot a "nev" példány változóhoz
+    @nev = nev
+    # Ha nem adtunk meg kort akkor az alapértemezet értéket fogja használni
+    @kor = kor
+  end
+
+  # Alap setter függvény
+  def nev=(nev)
+    @nev = nev
+  end
+
+  # Alap getter függvény
+  def nev
+    @nev
+  end
+
+  # A fönti funkcionalítást az attr_accessor függvénnyel is elérhetjük
+  attr_accessor :nev
+
+  # Getter/setter függvények egyenként is kreálhatóak
+  attr_reader :nev
+  attr_writer :nev
+
+  # Az osztály függvények "self"-et hasznalnak, hogy megkülönböztessék magukat a
+  # példány függvényektől
+  # Az osztályn hívhatóak, nem a példányon
+  def self.mond(uzenet)
+    puts uzenet
+  end
+
+  def faj
+    @@faj
+  end
+end
+
+
+# Példányosítsuk az osztályt
+jim = Ember.new('Jim Halpert')
+
+dwight = Ember.new('Dwight K. Schrute')
+
+# Hívjunk meg pár függvényt
+jim.faj #=> "H. sapiens"
+jim.nev #=> "Jim Halpert"
+jim.nev = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nev #=> "Jim Halpert II"
+dwight.faj #=> "H. sapiens"
+dwight.nev #=> "Dwight K. Schrute"
+
+# Hívjuk meg az osztály függvényt
+Ember.mond('Hi') #=> "Hi"
+
+# Változók szókjait az elnevezésük definiálja
+# $ kezdetű változók globálisak
+$var = "Én egy globális változó vagyok"
+defined? $var #=> "global-variable"
+
+# Változók amik @-al kezdődnek példány szkópjuk van
+@var = "Én egy példány változó vagyok"
+defined? @var #=> "instance-variable"
+
+# Változók amik @@-al kezdődnek példány szkópjuk van
+@@var = "Én egy osztály változó vagyok"
+defined? @@var #=> "class variable"
+
+# Változók amik nagy betűvel kezdődnek a konstansok
+Var = "Konstans vagyok"
+defined? Var #=> "constant"
+
+# Az osztály is objetum. Tehát az osztálynak lehet példány változója
+# Az osztályváltozón osztozik minden pédány és leszármazott
+
+# Ős osztály
+class Ember
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(ertek)
+    @@foo = ertek
+  end
+end
+
+# Leszarmazott osztály
+class Dolgozo < Ember
+end
+
+Ember.foo # 0
+Dolgozo.foo # 0
+
+Ember.foo = 2 # 2
+Dolgozo.foo # 2
+
+# Az osztálynak példány változóját nem látja az osztály leszármazottja.
+
+class Ember
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(ertek)
+    @bar = ertek
+  end
+end
+
+class Doctor < Ember
+end
+
+Ember.bar # 0
+Doctor.bar # nil
+
+module ModulePelda
+  def foo
+    'foo'
+  end
+end
+
+# Modulok include-olása a fügvényeiket az osztály példányaihoz köti.
+# Modulok extend-elésa a fügvényeiket magához az osztályhoz köti.
+
+class Szemely
+  include ModulePelda
+end
+
+class Konyv
+  extend ModulePelda
+end
+
+Szemely.foo     # => NoMethodError: undefined method `foo' for Szemely:Class
+Szemely.new.foo # => 'foo'
+Konyv.foo       # => 'foo'
+Konyv.new.foo   # => NoMethodError: undefined method `foo'
+
+# Callback-ek végrehajtódnak amikor include-olunk és extend-elünk egy modult
+
+module ConcernPelda
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Valami
+  include ConcernPelda
+end
+
+Valami.bar     # => 'bar'
+Valami.qux     # => NoMethodError: undefined method `qux'
+Valami.new.bar # => NoMethodError: undefined method `bar'
+Valami.new.qux # => 'qux'
+```
+
+## Egyéb források
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338)
+- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - A régebbi [ingyenes változat](http://ruby-doc.com/docs/ProgrammingRuby/) elérhető online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide)
diff --git a/id-id/xml-id.html.markdown b/id-id/xml-id.html.markdown
index 8e8cdf4e..c1e985aa 100644
--- a/id-id/xml-id.html.markdown
+++ b/id-id/xml-id.html.markdown
@@ -5,6 +5,7 @@ contributors:
   - ["João Farias", "https://github.com/JoaoGFarias"]
 translators:
   - ["Rizky Luthfianto", "https://github.com/rilut"]
+lang: id-id
 ---
 
 XML adalah bahasa markup yang dirancang untuk menyimpan dan mengirim data.
diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown
index f892845f..af8823c4 100644
--- a/it-it/bash-it.html.markdown
+++ b/it-it/bash-it.html.markdown
@@ -13,13 +13,14 @@ contributors:
 filename: LearnBash.sh
 translators:
     - ["Robert Margelli", "http://github.com/sinkswim/"]
+    - ["Tommaso Pifferi", "http://github.com/neslinesli93/"]
 lang: it-it
 ---
 
 Bash è il nome della shell di unix, la quale è stata distribuita anche come shell del sistema oprativo GNU e la shell di default su Linux e Mac OS X.
 Quasi tutti gli esempi sottostanti possono fare parte di uno shell script o eseguiti direttamente nella shell.
 
-[Per saperne di piu'.](http://www.gnu.org/software/bash/manual/bashref.html)
+[Per saperne di più.](http://www.gnu.org/software/bash/manual/bashref.html)
 
 ```bash
 #!/bin/bash
@@ -34,32 +35,34 @@ echo Ciao mondo!
 echo 'Questa è la prima riga'; echo 'Questa è la seconda riga'
 
 # Per dichiarare una variabile:
-VARIABILE="Una stringa"
+Variabile="Una stringa"
 
 # Ma non così:
-VARIABILE = "Una stringa"
-# Bash stabilirà che VARIABILE è un comando da eseguire e darà un errore
+Variabile = "Una stringa"
+# Bash stabilirà che Variabile è un comando da eseguire e darà un errore
 # perchè non esiste.
 
 # Usare la variabile:
-echo $VARIABILE
-echo "$VARIABILE"
-echo '$VARIABILE'
+echo $Variabile
+echo "$Variabile"
+echo '$Variabile'
 # Quando usi la variabile stessa - assegnala, esportala, oppure — scrivi
 # il suo nome senza $. Se vuoi usare il valore della variabile, devi usare $.
 # Nota che ' (singolo apice) non espande le variabili!
 
 # Sostituzione di stringhe nelle variabili
-echo ${VARIABILE/Una/A}
+echo ${Variabile/Una/A}
 # Questo sostituirà la prima occorrenza di "Una" con "La"
 
 # Sottostringa di una variabile
-echo ${VARIABILE:0:7}
+Lunghezza=7
+echo ${Variabile:0:Lunghezza}
 # Questo ritornerà solamente i primi 7 caratteri
 
 # Valore di default per la variabile
-echo ${FOO:-"ValoreDiDefaultSeFOOMancaOÈ Vuoto"}
-# Questo funziona per null (FOO=), stringa vuota (FOO=""), zero (FOO=0) ritorna 0
+echo ${Foo:-"ValoreDiDefaultSeFooMancaOppureÈVuoto"}
+# Questo funziona per null (Foo=), stringa vuota (Foo=""), zero (Foo=0) ritorna 0
+# Nota: viene ritornato il valore di default, il contenuto della variabile pero' non cambia.
 
 # Variabili builtin:
 # Ci sono delle variabili builtin molto utili, come
@@ -71,31 +74,40 @@ echo "Argomenti dello script separati in variabili distinte: $1 $2..."
 
 # Leggere un valore di input:
 echo "Come ti chiami?"
-read NOME # Nota che non abbiamo dovuto dichiarare una nuova variabile
-echo Ciao, $NOME!
+read Nome # Nota che non abbiamo dovuto dichiarare una nuova variabile
+echo Ciao, $Nome!
 
 # Classica struttura if:
 # usa 'man test' per maggiori informazioni sulle condizionali
-if [ $NOME -ne $USER ]
+if [ $Nome -ne $USER ]
 then
     echo "Il tuo nome non è lo username"
 else
     echo "Il tuo nome è lo username"
 fi
 
+# Nota: se $Name è vuoto, la condizione precedente viene interpretata come:
+if [ -ne $USER ]
+# che genera un errore di sintassi. Quindi il metodo sicuro per usare
+# variabili che possono contenere stringhe vuote è il seguente:
+if [ "$Name" -ne $USER ] ...
+# che viene interpretato come:
+if [ "" -ne $USER ] ...
+# e dunque funziona correttamente.
+
 # C'è anche l'esecuzione condizionale
 echo "Sempre eseguito" || echo "Eseguito solo se la prima condizione fallisce"
 echo "Sempre eseguito" && echo "Eseguito solo se la prima condizione NON fallisce"
 
 # Per usare && e || con l'if, c'è bisogno di piu' paia di parentesi quadre:
-if [ $NOME == "Steve" ] && [ $ETA -eq 15 ]
+if [ "$Nome" == "Steve" ] && [ "$Eta" -eq 15 ]
 then
-    echo "Questo verrà eseguito se $NOME è Steve E $ETA è 15."
+    echo "Questo verrà eseguito se $Nome è Steve E $Eta è 15."
 fi
 
-if [ $NOME == "Daniya" ] || [ $NOME == "Zach" ]
+if [ "$Nome" == "Daniya" ] || [ "$Nome" == "Zach" ]
 then
-    echo "Questo verrà eseguito se $NAME è Daniya O Zach."
+    echo "Questo verrà eseguito se $Nome è Daniya O Zach."
 fi
 
 # Le espressioni sono nel seguente formato:
@@ -137,7 +149,7 @@ python hello.py > /dev/null 2>&1
 # se invece vuoi appendere usa ">>":
 python hello.py >> "output.out" 2>> "error.err"
 
-# Sovrascrivi output.txt, appendi a error.err, e conta le righe:
+# Sovrascrivi output.out, appendi a error.err, e conta le righe:
 info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
 wc -l output.out error.err
 
@@ -145,7 +157,7 @@ wc -l output.out error.err
 # vedi: man fd
 echo <(echo "#ciaomondo")
 
-# Sovrascrivi output.txt con "#helloworld":
+# Sovrascrivi output.out con "#helloworld":
 cat > output.out <(echo "#helloworld")
 echo "#helloworld" > output.out
 echo "#helloworld" | cat > output.out
@@ -164,7 +176,7 @@ echo "Ci sono $(ls | wc -l) oggetti qui."
 echo "Ci sono `ls | wc -l` oggetti qui."
 
 # Bash utilizza uno statemente case che funziona in maniera simile allo switch in Java e C++:
-case "$VARIABILE" in 
+case "$Variabile" in 
     #Lista di pattern per le condizioni che vuoi soddisfare
     0) echo "C'è uno zero.";;
     1) echo "C'è un uno.";;
@@ -172,10 +184,10 @@ case "$VARIABILE" in
 esac
 
 # I cicli for iterano per ogni argomento fornito:
-# I contenuti di $VARIABILE sono stampati tre volte.
-for VARIABILE in {1..3}
+# I contenuti di $Variabile sono stampati tre volte.
+for Variabile in {1..3}
 do
-    echo "$VARIABILE"
+    echo "$Variabile"
 done
 
 # O scrivilo con il "ciclo for tradizionale":
@@ -186,16 +198,16 @@ done
 
 # Possono essere usati anche per agire su file..
 # Questo eseguirà il comando 'cat' su file1 e file2
-for VARIABILE in file1 file2
+for Variabile in file1 file2
 do
-    cat "$VARIABILE"
+    cat "$Variabile"
 done
 
 # ..o dall'output di un comando
 # Questo eseguirà cat sull'output di ls.
-for OUTPUT in $(ls)
+for Output in $(ls)
 do
-    cat "$OUTPUT"
+    cat "$Output"
 done
 
 # while loop:
@@ -223,7 +235,7 @@ bar ()
 }
 
 # Per chiamare la funzione
-foo "Il mio nome è" $NOME
+foo "Il mio nome è" $Nome
 
 # Ci sono un sacco di comandi utili che dovresti imparare:
 # stampa le ultime 10 righe di file.txt
@@ -245,7 +257,7 @@ grep "^foo.*bar$" file.txt
 grep -c "^foo.*bar$" file.txt
 # se vuoi letteralmente cercare la stringa,
 # e non la regex, usa fgrep (o grep -F)
-fgrep "^foo.*bar$" file.txt 
+fgrep "^foo.*bar$" file.txt
 
 
 # Leggi la documentazione dei builtin di bash con il builtin 'help' di bash:
diff --git a/it-it/brainfuck-it.html.markdown b/it-it/brainfuck-it.html.markdown
index 4999d7e6..08d2ede9 100644
--- a/it-it/brainfuck-it.html.markdown
+++ b/it-it/brainfuck-it.html.markdown
@@ -1,75 +1,72 @@
 ---
-
 language: brainfuck
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Ivan Sala", "http://slavni96.github.io/"]
+    - ["Christian Grasso", "http://chris54721.net"]
 lang: it-it
-
 ---
 
-Brainfuck è un linguaggio di programmazione estremamente minimale,
-ma è ingrado di rappresentare completamente una macchina di turnig,
-e sfrutta solo 8 caratteri.
-[Per saperne di più](http://it.wikipedia.org/wiki/Brainfuck)
+Brainfuck è un linguaggio di programmazione
+[Turing equivalente](https://it.wikipedia.org/wiki/Turing_equivalenza)
+estremamente minimale, composto da solo 8 comandi.
+
+Puoi provarlo nel tuo browser utilizzando
+[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
 
 ```
 
-Qualsiasi carattere che non sia "><+-.,[]" (escludendo gli apici) 
+Qualsiasi carattere diverso da "><+-.,[]" (escludendo gli apici)
 viene ignorato.
-Branfuck è caratterizzato da un array (vettore) di 30,000 celle 
-inizializzare a zero, e un puntatore che punta alla cella corrente.
+Branfuck è caratterizzato da un array di 30,000 celle inizializzate a zero
+e da un puntatore che punta alla cella corrente.
 
-Vi sono solo otto comando:
+Vi sono otto comandi:
 + : Incrementa il valore della cella attuale di uno.
 - : Decrementa il valore della cella attuale di uno.
-> : Sposta il puntatore sulla cella seguente (prossima a destra).
-< : Sposta il puntatore sulla cella precendete (precedente a sinistra).
-. : Stampa il valore in ASCII della cella corrente. (es: 65 = 'A')
-, : Legge un singolo carattere come input per la cella corrente.
-[ : Se il valore della cella corrente è zero, conclude il ciclo 
-    andando alla sua corrispondente ].
+> : Sposta il puntatore sulla cella seguente (sulla destra).
+< : Sposta il puntatore sulla cella precendete (sulla sinistra).
+. : Stampa il valore ASCII della cella corrente. (es. 65 = 'A')
+, : Legge un singolo carattere come input e lo salva nella cella corrente.
+[ : Se il valore della cella corrente è zero, prosegue fino alla ] corrispondente.
     Altrimenti, passa alla prossima istruzione.
 ] : Se il valore della cella corrente è zero, passa alla prossima istruzione.
-    Altrimenti torna indetro fino alla [ corrispondente. 
+    Altrimenti, torna indietro fino alla [ corrispondente.
 
-[ e ] creano un loop (while). Ovviamente dovranno essere bilanciati.
-Per ogni [ dovrà corrispondere una ]
+[ e ] formano un ciclo while. Ovviamente dovranno essere bilanciati.
+(Ad ogni [ dovrà corrispondere una ])
 
-Alcuni semplici esempi di programmi scritti in Brainfuck:
+Ecco alcuni semplici esempi di programmi scritti in Brainfuck:
 
 ++++++ [ > ++++++++++ < - ] > +++++ .
 
-Questo programma stampa in output la lettera 'A'. Priam incrementa
-la cella #1 fino a 6, Quindi la cella #1 viene usata per crare un ciclo.
-Poi, entra in un loop ([) e si sposta alla cella #2.
-Incrementa la cella #2 10 volte, e torna alla cella #1, e la decrementa.
-Questo avviene 6 volte (servono che la cella #1 venga decrementata 6 volte
-per raggiungere lo 0. Quindi passa alla corrispondente ] e prosegue).
+Questo programma stampa in output la lettera 'A'. Prima di tutto, incrementa
+la cella #1 fino al valore 6. La cella #1 verrà utilizzata per il ciclo.
+Poi, entra nel ciclo ([) e si sposta alla cella #2. Incrementa la cella #2 10
+volte, torna alla cella #1, e decrementa quest'ultima.
+Il ciclo si ripete 6 volte (la cella #1 viene decrementata 6 volte prima di
+raggiungere lo 0, quindi prosegue oltre la corrispondente ]).
 
-A questo punto, siamo sulla cella #1, che ha valore 0, 
-la cella #2 ha valore 60 (6*10). Ci spostiamo sulla cella #2, incrementiamo
-per 5 volte, e otteniamo il valore 65, quindi stampaimo il valore della cella
-#2 (.).
-65 è 'A' in ASCII, quindi alla fine viene stampata 'A'.
+A questo punto, siamo sulla cella #1, che ha valore 0, mentre la cella #2 ha
+valore 60. Ci spostiamo sulla cella #2, la incrementiamo per 5 volte, ottenendo
+il valore 65, quindi stampiamo il valore della cella #2.
+Il valore 65 equivale ad 'A' in ASCII, per cui viene stampato 'A' nel terminale.
 
 
 , [ > + < - ] > .
 
-Questo programma legge un carattere come input dall'utente, 
-quindi salva il carattere dentro la cella #1.
-In seguito, incominca a ciclare.
-Si sposta alla cella #², e increementa il valore della cella (#2).
-Quindi torna alla cella #1, e decrementa il valore della cella (#1).
-Questo continua fino a quando la cella #²1 diventa 0, e quindi la cella #2
-avrà il valore iniziale della cella #1.
-Infine, visto che ci troviamo sulla cella #1 alla fine del ciclo, si sposta
-sulla cella #2 e stampa il valore in ASCII.
+Questo programma legge un carattere come input dall'utente, quindi salva il
+carattere nella cella #1. Dopodichè entra in un ciclo. Si sposta alla cella #2,
+incrementa quest'ultima, torna alla cella #1, e decrementa quest'ultima.
+Il ciclo continua fino a quando la cella #1 diventa 0, e quindi la cella #2
+avrà il valore iniziale della cella #1. Infine, visto che ci troviamo sulla
+cella #1 alla fine del ciclo, si sposta sulla cella #2 e stampa il valore in
+ASCII.
 
-Gli spazi nel codice sovrastante, sono presenti solo a scopo di ottenere
-una maggiore leggibilità, si poteva anche scrivere senza:
+Gli spazi nel codice sovrastante sono presenti solo a scopo di ottenere
+una maggiore leggibilità. Lo stesso programma poteva essere scritto senza spazi:
 
 ,[>+<-]>.
 
@@ -77,25 +74,19 @@ Proviamo, adesso, a capire cosa fa invece questo programma:
 
 ,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
 
-Prende due numeri in input e quindi li moltiplica.
+Il programma legge 2 numeri come input dall'utente, e li moltiplica.
 
-Prima prende in input i due numeri (,>,<), quindi inizia un cilclo
-basandosi sulla cella #1.
-Quindi si sposta sulla cella #2, e inizia un altro ciclo condizionato
-dal valore della cella #2, incrementando la cella #3.
+Innanzitutto, legge in input i due numeri. Poi entra nel ciclo più esterno
+basandosi sulla cella #1. Quindi si sposta sulla cella #2, e inizia il ciclo
+più interno basandosi sul valore della cella #2, incrementando la cella #3.
 Arrivati a questo punto abbiamo un problema: alla fine del ciclo interno
-la cella #2 ha valore 0. In questo caso, quando il ciclo esterno rifarà
-partire il ciclo interno, non funzionerà più perchè la cella #2 ha valore 0.
-Per ovviare a questo problema, oltre alla cella 3, incrementiamo anche la cella
-#4, e alla fine di ogni ciclo interno copiala il valore della cella #4 
-nella cella #2, in modo che il ciclo interno 
-possa essere eseguito una altra volta.
-Alla fine la cella #3 contiene il risultato.
+la cella #2 avrà valore 0. Ciò impedirà di eseguire nuovamente il ciclo interno.
+Per ovviare a questo problema, incrementiamo anche la cella #4, e copiamo il
+valore di quest'ultima nella cella #2.
+Il risultato sarà infine contenuto nella cella #3.
 ```
 
-E questo è brainfuck...Non è difficele, vero? 
-Per divertimento adesso puoi scrivere i tuoi programmi in brainfuck,
-oppure puoi scrivere un interprete brainfuck in un altro linguaggio.
-L'interprete è abbastanza semplice da implementare, ma se sei veramente
-masochista prova ad implementare un interprete brainfuck in...
-brainfuck.
+E questo è brainfuck. Non è così difficile, eh? Se vuoi, ora puoi scrivere per
+divertimento altri programmi in brainfuck, oppure scrivere un interprete
+brainfuck in un altro linguaggio. L'interprete è abbastanza semplice da
+implementare, ma se sei veramente masochista, prova ad implementare un interprete brainfuck... in brainfuck.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index e7e1d89e..92ebc165 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -4,6 +4,8 @@ filename: learncpp-it.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
 translators:
     - ["Robert Margelli", "http://github.com/sinkswim/"]
 lang: it-it
@@ -54,11 +56,11 @@ int main(int argc, char** argv)
 
 // Tuttavia, il C++ varia nei seguenti modi:
 
-// In C++, i caratteri come letterali sono da un byte.
-sizeof('c') == 1
+// In C++, i caratteri come letterali sono dei char.
+sizeof('c') == sizeof(char) == 1
 
-// In C, i caratteri come letterali sono della stessa dimensione degli interi.
-sizeof('c') == sizeof(10)
+// In C, i caratteri come letterali sono degli interi.
+sizeof('c') == sizeof(int)
 
 
 // C++ ha prototipizzazione rigida
@@ -160,11 +162,14 @@ void foo()
 
 int main()
 {
-    // Assume che tutto venga dal namespace "Secondo"
-    // a meno che non venga dichiarato altrimenti.
+    // Include tutti i simboli del namespace Secondo nello scope attuale.
+    // Osserva che chiamare semplicemente foo() non va più bene perché è ambiguo:
+    // bisogna specificare se vogliamo chiamare foo definita nel namespace Secondo
+    // o foo definita nel livello principale del programma.
+
     using namespace Secondo;
 
-    foo(); // stampa "Questa è Secondo::foo"
+    Secondo::foo(); // stampa "Questa è Secondo::foo"
     Primo::Annidato::foo(); // stampa "Questa è Primo::Annidato::foo"
     ::foo(); // stampa "Questa è foo globale"
 }
@@ -244,12 +249,137 @@ cout << fooRef; // Stampa "Io sono foo. Ciao!"
 // Non riassegna "fooRef". Questo è come scrivere "foo = bar", e
 //   foo == "Io sono bar"
 // dopo questa riga.
+cout << &fooRef << endl; // Stampa l'indirizzo di foo
 fooRef = bar;
+cout << &fooRef << endl; // Stampa lo stesso l'indirizzo di foo
+cout << fooRef;  // Stampa "Io sono bar"
+
+// L'indirizzo di fooRef rimane lo stesso, ovvero si riferisce ancora a foo.
+
 
 const string& barRef = bar; // Crea un riferimento const a bar.
 // Come in C, i valori const (i puntatori e i riferimenti) non possono essere modificati.
 barRef += ". Ciao!"; // Errore, i riferimenti const non possono essere modificati.
 
+// Facciamo un piccolo excursus: prima di approfondire ancora i riferimenti, è necessario
+// introdurre il concetto di oggetto temporaneo. Supponiamo di avere il seguente codice:
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Nella seconda riga si ha che:
+//   - un oggetto di tipo stringa viene ritornato da tempObjectFun
+//   - viene costruita una nuova stringa, utilizzando l'oggetto ritornato come
+//     argomento per il costruttore
+//   - l'oggetto ritornato da tempObjectFun viene distrutto
+// L'oggetto ritornato da tempObjectFun viene detto oggetto temporaneo.
+// Un oggetto temporaneo viene creato quando una funzione ritorna un oggetto, e viene
+// distrutto quando l'espressione che lo racchiude termina la sua esecuzione - questo
+// comportamento viene definito dallo standard, ma i compilatori possono modificarlo
+// a piacere. Cerca su google "return value optimization" se vuoi approfondire.
+// Dunque nel seguente codice:
+foo(bar(tempObjectFun()))
+
+// dando per scontato che foo e bar esistano, l'oggetto ritornato da tempObjectFun
+// è passato a bar ed è distrutto prima dell'invocazione di foo.
+
+// Tornando ai riferimenti, c'è un'eccezione a quanto appena detto.
+// Infatti un oggetto temporaneo "viene distrutto quando l'espressione
+// che lo racchiude termina la sua esecuzione", tranne quando è legato ad un
+// riferimento di tipo const. In tal caso la sua vita viene estesa per tutto
+// lo scope attuale:
+
+void constReferenceTempObjectFun() {
+    // constRef riceve l'oggetto temporaneo, che non viene distrutto fino
+    // alla fine di questa funzione.
+    const string& constRef = tempObjectFun();
+    ...
+}
+
+// Un altro tipo di riferimento introdotto nel C++11 è specifico per gli
+// oggetti temporanei. Non puoi dichiarare una variabile di quel tipo, ma
+// ha la precedenza nella risoluzione degli overload:
+
+void someFun(string& s) { ... }  // Riferimento normale
+void someFun(string&& s) { ... }  // Riferimento ad un oggetto temporaneo
+
+string foo;
+someFun(foo);  // Chiama la versione con il riferimento normale
+someFun(tempObjectFun());  // Chiama la versione con il riferimento temporaneo
+
+// Ad esempio potrai vedere questi due costruttori per std::basic_string:
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// L'idea è che se noi costruiamo una nuova stringa a partire da un oggetto temporaneo
+// (che in ogni caso verrà distrutto), possiamo avere un costruttore più efficiente
+// che in un certo senso "recupera" parti di quella stringa temporanea.
+// Ci si riferisce a questo concetto come "move semantics".
+
+/////////////////////
+// Enum
+/////////////////////
+
+// Gli enum sono un modo per assegnare un valore ad una costante, e sono
+// principalmente usati per rendere il codice più leggibile.
+enum ETipiMacchine
+{
+  AlfaRomeo,
+  Ferrari,
+  SUV,
+  Panda
+};
+
+ETipiMacchine GetPreferredCarType()
+{
+    return ETipiMacchine::Ferrari;
+}
+
+// Dal C++11 in poi c'è un modo molto semplice per assegnare un tipo ad un enum,
+// che può essere utile per la serializzazione dei dati o per convertire gli enum
+// tra il tipo desiderato e le rispettive costanti.
+enum ETipiMacchine : uint8_t
+{
+  AlfaRomeo, // 0
+  Ferrari, // 1
+  SUV = 254, // 254
+  Ibrida // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+    // Serializza InputValue in un file
+}
+
+void WritePreferredCarTypeToFile(ETipiMacchine InputCarType)
+{
+    // L'enum viene implicitamente convertito ad un uint8_t poiché
+    // è stato dichiarato come tale
+    WriteByteToFile(InputCarType);
+}
+
+// D'altro canto potresti voler evitare che un enum venga accidentalmente convertito
+// in un intero o in un altro tipo, quindi è possibile create una classe enum che
+// impedisce la conversione implicita.
+enum class ETipiMacchine : uint8_t
+{
+  AlfaRomeo, // 0
+  Ferrari, // 1
+  SUV = 254, // 254
+  Ibrida // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+    // Serializza InputValue in un file
+}
+
+void WritePreferredCarTypeToFile(ETipiMacchine InputCarType)
+{
+    // Il compilatore darà errore anche se ETipiMacchine è un uint8_t: questo
+    // perchè abbiamo dichiarato l'enum come "enum class"!
+    WriteByteToFile(InputCarType);
+}
+
 //////////////////////////////////////////////////
 // Classi e programmazione orientata agli oggetti
 /////////////////////////////////////////////////
@@ -296,13 +426,16 @@ public:
     // Questi sono chiamati quando un oggetto è rimosso o esce dalla visibilità.
     // Questo permette paradigmi potenti come il RAII
     // (vedi sotto)
-    // I distruttori devono essere virtual per permettere a classi di essere derivate da questa.
+    // I distruttori devono essere virtual per permettere a classi di essere
+    // derivate da questa; altrimenti, il distruttore della classe derivata
+    // non viene chiamato se l'oggetto viene distrutto tramite un riferimento alla
+    // classe da cui ha ereditato o tramite un puntatore.
     virtual ~Dog();
 
 }; // Un punto e virgola deve seguire la definizione della funzione
 
 // Le funzioni membro di una classe sono generalmente implementate in files .cpp .
-void Cane::Cane()
+Cane::Cane()
 {
     std::cout << "Un cane è stato costruito\n";
 }
@@ -325,7 +458,7 @@ void Cane::print() const
     std::cout << "Il cane è " << nome << " e pesa " << peso << "kg\n";
 }
 
-void Cane::~Cane()
+Cane::~Cane()
 {
     cout << "Ciao ciao " << nome << "\n";
 }
@@ -340,10 +473,12 @@ int main() {
 
 // Ereditarietà:
 
-// Questa classe eredita tutto ciò che è public e protected dalla classe Cane
+// Questa classe eredita tutto ciò che è public e protected dalla classe Cane,
+// ma anche ciò che privato: tuttavia non potrà accedere direttamente a membri/metodi
+// privati se non c'è un metodo pubblico o privato che permetta di farlo.
 class MioCane : public Cane {
 
-    void impostaProprietario(const std::string& proprietarioCane)
+    void impostaProprietario(const std::string& proprietarioCane);
 
     // Sovrascrivi il comportamento della funzione print per tutti i MioCane. Vedi
     // http://it.wikipedia.org/wiki/Polimorfismo_%28informatica%29
@@ -447,6 +582,7 @@ int main () {
 // definire una classe o una funzione che prende un parametro di un dato tipo:
 template<class T>
 class Box {
+public:
     // In questa classe, T può essere usato come qualsiasi tipo.
     void inserisci(const T&) { ... }
 };
@@ -519,19 +655,23 @@ printMessage<10>();  // Stampa "Impara il C++ più velocemente in soli 10 minuti
 // (vedi http://en.cppreference.com/w/cpp/error/exception)
 // ma ogni tipo può essere lanciato come eccezione
 #include <exception>
+#include <stdexcept>
 
 // Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi 
 // handlers _catch_.
 try {
     // Non allocare eccezioni nello heap usando _new_.
-    throw std::exception("È avvenuto un problema");
+    throw std::runtime_error("C'è stato un problema.");
 }
+
 // Cattura le eccezioni come riferimenti const se sono oggetti
 catch (const std::exception& ex)
 {
-  std::cout << ex.what();
+    std::cout << ex.what();
+}
+
 // Cattura ogni eccezioni non catturata dal blocco _catch_ precedente
-} catch (...)
+catch (...)
 {
     std::cout << "Catturata un'eccezione sconosciuta";
     throw; // Rilancia l'eccezione
@@ -541,7 +681,7 @@ catch (const std::exception& ex)
 // RAII
 ///////
 
-// RAII sta per Resource Allocation Is Initialization.
+// RAII sta per "Resource Allocation Is Initialization".
 // Spesso viene considerato come il più potente paradigma in C++.
 // È un concetto semplice: un costruttore di un oggetto
 // acquisisce le risorse di tale oggetto ed il distruttore le rilascia.
@@ -563,9 +703,9 @@ void faiQualcosaConUnFile(const char* nomefile)
 // Sfortunatamente, le cose vengono complicate dalla gestione degli errori.
 // Supponiamo che fopen fallisca, e che faiQualcosaConUnFile e
 // faiQualcosAltroConEsso ritornano codici d'errore se falliscono.
-// (Le eccezioni sono la maniera preferita per gestire i fallimenti,
-//  ma alcuni programmatori, specialmente quelli con un passato in C,
-//  non sono d'accordo con l'utilità delle eccezioni).
+//  (Le eccezioni sono la maniera preferita per gestire i fallimenti,
+//   ma alcuni programmatori, specialmente quelli con un passato in C,
+//   non sono d'accordo con l'utilità delle eccezioni).
 // Adesso dobbiamo verificare che ogni chiamata per eventuali fallimenti e chiudere il gestore di file
 // se un problema è avvenuto.
 bool faiQualcosaConUnFile(const char* nomefile)
@@ -615,7 +755,7 @@ void faiQualcosaConUnFile(const char* nomefile)
 {
     FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura
     if (fh == nullptr)
-        throw std::exception("Non è stato possibile aprire il file.").
+        throw std::runtime_error("Errore nell'apertura del file.");
 
     try {
         faiQualcosaConIlFile(fh);
@@ -678,26 +818,29 @@ class Foo {
   virtual void bar();
 };
 class FooSub : public Foo {
-  virtual void bar();  // sovrascrive Foo::bar!
+  virtual void bar();  // Sovrascrive Foo::bar!
 };
 
 
 // 0 == false == NULL (la maggior parte delle volte)!
 bool* pt = new bool;
-*pt = 0;  // Setta il valore puntato da 'pt' come falso.
+*pt = 0; // Setta il valore puntato da 'pt' come falso.
 pt = 0;  // Setta 'pt' al puntatore null. Entrambe le righe vengono compilate senza warnings.
 
 // nullptr dovrebbe risolvere alcune di quei problemi:
 int* pt2 = new int;
-*pt2 = nullptr;  // Non compila
+*pt2 = nullptr; // Non compila
 pt2 = nullptr;  // Setta pt2 a null.
 
-// Ma in qualche modo il tipo 'bool' è una eccezione (questo è per rendere compilabile `if (ptr)`.
-*pt = nullptr;  // Questo compila, anche se '*pt' è un bool! 
+// C'è un'eccezione per i bool.
+// Questo permette di testare un puntatore a null con if(!ptr), ma
+// come conseguenza non puoi assegnare nullptr a un bool direttamente!
+*pt = nullptr;  // Questo compila, anche se '*pt' è un bool!
 
 
 // '=' != '=' != '='!
-// Chiama Foo::Foo(const Foo&) o qualche variante del costruttore di copia.
+// Chiama Foo::Foo(const Foo&) o qualche variante (vedi "move semantics")
+// del costruttore di copia.
 Foo f2;
 Foo f1 = f2;
 
@@ -711,6 +854,22 @@ Foo f1 = fooSub;
 Foo f1;
 f1 = f2;
 
+
+// Come deallocare realmente le risorse all'interno di un vettore:
+class Foo { ... };
+vector<Foo> v;
+for (int i = 0; i < 10; ++i)
+  v.push_back(Foo());
+
+// La riga seguente riduce la dimensione di v a 0, ma il distruttore non
+// viene chiamato e dunque le risorse non sono deallocate!
+v.empty();
+v.push_back(Foo());  // Il nuovo valore viene copiato nel primo Foo che abbiamo inserito
+
+// Distrugge realmente tutti i valori dentro v. Vedi la sezione riguardante gli
+// oggetti temporanei per capire come mai funziona così.
+v.swap(vector<Foo>());
+
 ```
 Letture consigliate:
 
diff --git a/it-it/coffeescript-it.html.markdown b/it-it/coffeescript-it.html.markdown
index 16eb9bd4..31973369 100644
--- a/it-it/coffeescript-it.html.markdown
+++ b/it-it/coffeescript-it.html.markdown
@@ -4,6 +4,8 @@ contributors:
   - ["Luca 'Kino' Maroni", "http://github.com/kino90"]
   - ["Tenor Biel", "http://github.com/L8D"]
   - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+    - ["Tommaso Pifferi","http://github.com/neslinesli93"]
 filename: coffeescript-it.coffee
 lang: it-it
 ---
@@ -59,34 +61,34 @@ matematica =
   quadrato: quadrato
   cubo:   (x) -> x * quadrato x
 #=> var matematica = {
-#  "radice": Math.sqrt,
-#  "quadrato": quadrato,
-#  "cubo": function(x) { return x * quadrato(x); }
-#}
+#     "radice": Math.sqrt,
+#     "quadrato": quadrato,
+#     "cubo": function(x) { return x * quadrato(x); }
+#   }
 
 # Splats:
 gara = (vincitore, partecipanti...) ->
   print vincitore, partecipanti
 #=>gara = function() {
-#  var partecipanti, vincitore;
-#  vincitore = arguments[0], partecipanti = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
-#  return print(vincitore, partecipanti);
-#};
+#    var partecipanti, vincitore;
+#    vincitore = arguments[0], partecipanti = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#    return print(vincitore, partecipanti);
+#  };
 
 # Esistenza:
 alert "Lo sapevo!" if elvis?
 #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Lo sapevo!"); }
 
 # Comprensione degli Array:
-cubi = (matematica.cubo num for num in lista) 
+cubi = (matematica.cubo num for num in lista)
 #=>cubi = (function() {
-#	var _i, _len, _results;
-#	_results = [];
-# 	for (_i = 0, _len = lista.length; _i < _len; _i++) {
-#		num = lista[_i];
-#		_results.push(matematica.cubo(num));
-#	}
-#	return _results;
+#	   var _i, _len, _results;
+#	   _results = [];
+#    for (_i = 0, _len = lista.length; _i < _len; _i++) {
+#      num = lista[_i];
+#      _results.push(matematica.cubo(num));
+#    }
+#    return _results;
 #  })();
 
 cibi = ['broccoli', 'spinaci', 'cioccolato']
diff --git a/it-it/elixir-it.html.markdown b/it-it/elixir-it.html.markdown
index f5d0c172..60301b1a 100644
--- a/it-it/elixir-it.html.markdown
+++ b/it-it/elixir-it.html.markdown
@@ -4,6 +4,8 @@ contributors:
     - ["Luca 'Kino' Maroni", "https://github.com/kino90"]
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+translators:
+    - ["Tommaso Pifferi","http://github.com/neslinesli93"]
 filename: learnelixir-it.ex
 lang: it-it
 ---
@@ -379,6 +381,12 @@ spawn(f) #=> #PID<0.40.0>
 # Per passare messaggi si usa l'operatore `send`.
 # Perché tutto questo sia utile dobbiamo essere capaci di ricevere messaggi, 
 # oltre ad inviarli. Questo è realizzabile con `receive`:
+
+# Il blocco `receive do` viene usato per mettersi in ascolto di messaggi
+# ed elaborarli quando vengono ricevuti. Un blocco `receive do` elabora
+# un solo messaggio ricevuto: per fare elaborazione multipla di messaggi, 
+# una funzione con un blocco `receive do` al suo intero dovrà chiamare
+# ricorsivamente sé stessa per entrare di nuovo nel blocco `receive do`.
 defmodule Geometria do
   def calcolo_area do
     receive do
@@ -394,6 +402,8 @@ end
 
 # Compila il modulo e crea un processo che esegue `calcolo_area` nella shell
 pid = spawn(fn -> Geometria.calcolo_area() end) #=> #PID<0.40.0>
+# Alternativamente
+pid = spawn(Geometria, :calcolo_area, [])
 
 # Invia un messaggio a `pid` che farà match su un pattern nel blocco in receive 
 send pid, {:rettangolo, 2, 3}
diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown
index 6eabd61f..54602cff 100644
--- a/it-it/java-it.html.markdown
+++ b/it-it/java-it.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Madison Dickson", "http://github.com/mix3d"]
 translators:
     - ["Ivan Sala","http://github.com/slavni96"]
+    - ["Tommaso Pifferi","http://github.com/neslinesli93"]
 lang: it-it
 ---
 
@@ -31,9 +32,9 @@ import java.security.*;
 // Ogni file .java contiene una classe pubblica, con lo stesso nome del file
 public class LearnJava {
 
-    // Un programma deve avere un metodo main come punto di partenza
-    // Ma si possono creare anche file senza main, che però per essere usati
-    // devono essere richiamati da altri file.
+    // Un programma deve avere un metodo main come punto di partenza.
+    // Tuttavia si possono creare anche file senza main, che però
+    // per essere usati devono essere richiamati da altri file.
     public static void main (String[] args) {
 
         // Per stampare a schermo si usa System.out.println
@@ -47,88 +48,157 @@ public class LearnJava {
         System.out.print("Ciao ");
         System.out.print("Mondo ");
 
+        // Per stampare del testo formattato, si puo' usare System.out.printf
+        System.out.printf("pi greco = %.5f", Math.PI); // => pi greco = 3.14159
 
         ///////////////////////////////////////
-        // Tipi e Variabili
+        // Variabili
         ///////////////////////////////////////
-        // Si dichiara una variabile usando <tipo> <nome>
-        // Byte - variabile intera da 8 bit con segno
+
+        /*
+        *  Dichiarazione delle Variabili
+        */
+        // Per dichiarare una variabile basta fare <tipoDato> <nomeVariabile>
+        int fooInt;
+        // Per dichiarare piu' di una variabile dello lo stesso tipo si usa:
+        // <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Inizializzazione delle Variabili
+        */
+
+        // Per inizializzare una variabile si usa
+        // <tipoDato> <nomeVariabile> = <valore>
+        int fooInt = 1;
+        // Per inizializzare piu' di una variabile dello lo stesso tipo
+        // si usa <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3> = <valore>
+        int fooInt1, fooInt2, fooInt3;
+        fooInt1 = fooInt2 = fooInt3 = 1;
+
+        /*
+        *  Tipi di Variabili
+        */
+        // Byte - intero con segno a 8 bit (in complemento a 2)
         // (-128 <= byte <= 127)
         byte fooByte = 100;
 
-        // Short - variabile intera da 18 bit con segno
+        // Short - intero con segno a 16 bit (in complemento a 2)
         // (-32,768 <= short <= 32,767)
         short fooShort = 10000;
 
-        // Integer - variabile intera da 32 bit con segno
+        // Integer - intero con segno a 32 bit (in complemento a 2)
         // (-2,147,483,648 <= int <= 2,147,483,647)
         int fooInt = 1;
 
-        // Long - variabile da 64 bit intera con segno
+        // Long - intero con segno a 64 bit (in complemento a 2)
         // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
         long fooLong = 100000L;
-        // L viene usato per specificare che il valore dalla variabile
-        // e' di tipo "Long", qualsiasi variabile che non viene contrassegnata
-        // e' trattata di base come un intero.
+        // L viene usato per indicare che il valore e' di tipo Long;
+        // altrimenti il valore viene considerato come intero.
 
-        // Nota: Java non dispone di variabili senza segno
+        // Nota: Java non dispone di interi senza segno.
 
-        // Float - variabile piu' precisa, con virgola [numeri reali]
-        // di grandezza 32 bit
+        // Float - Numero in virgola mobile a 32 bit con precisione singola (IEEE 754)
+        // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
-        // f e' usato per specificare che la variabile e'' di tipo "float"
-        // altrimenti di default viene trattata come un "dobule"
+        // f o F indicano the la variabile e' di tipo float;
+        // altrimenti il valore viene considerato come double.
 
-        // Double - ancora piu' precisione la si puo' ottenere con una variabile
-        // Double, con granzezza di 64 bit.
+        // Double - Numero in virgola mobile a 64 bit con precisione doppia (IEEE 754)
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
-        // Boolean - vero & falso
+        // Boolean - Puo' assumere il valore vero (true) o falso (false)
         boolean fooBoolean = true;
         boolean barBoolean = false;
 
-        // Char - un singolo carattere con grandezza 16 bit
+        // Char - Un singolo carattere Unicode a 16-bit
         char fooChar = 'A';
 
-        // final - Costanti, non possono essere riassegnate ad un altro oggetto
-        final int ORE_LAVORATIVE_DI_UNA_SETTIMANA = 9001;
-
-        // String - Stringhe, array di caratteri
-        String fooString = "Ecco una stringa!";
-
-        // \n e' un carattere speciale che permette di andare a capo.
-        String barString = "Andare a capo?\nNessun problema!";
-        // \t e' un carattere speciale che permette di aggiungere un 'Tab'
-        String bazString = "Vuoi inserire tab?\tNessun problema";
+        // Le variabili precedute da final possono essere inizializzate una volta sola,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // pero' e' possibile dichiararle e poi inizializzarle in un secondo momento.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger - Interi a precisione arbitraria
+        //
+        // BigInteger e' un tipo di dato che permette ai programmatori di
+        // gestire interi piu' grandi di 64 bit. Internamente, le variabili
+        // di tipo  BigInteger vengono memorizzate come un vettore di byte e 
+        // vengono manipolate usando funzioni dentro la classe BigInteger.
+        //
+        // Una variabile di tipo BigInteger puo' essere inizializzata usando
+        // un array di byte oppure una stringa.
+        
+        BigInteger fooBigInteger = new BigDecimal(fooByteArray);
+
+        // BigDecimal - Numero con segno, immutabile, a precisione arbitraria
+        //
+        // Una variabile di tipo BigDecimal e' composta da due parti: un intero
+        // a precisione arbitraria detto 'non scalato', e un intero a 32 bit
+        // che rappresenta la 'scala', ovvero la potenza di 10 con cui
+        // moltiplicare l'intero non scalato.
+        //
+        // I BigDecimal permettono un controllo completo sull'arrotondamento
+        // dei numeri. Essi sono molto usati in ambito finanziario, nella
+        // gestione delle valute, e in ogni altro posto in cui serve
+        // precisione esatta.
+        //
+        // Le variabili di tipo BigDecimal possono essere inizializzate con un
+        // int, long, double o String, oppure con un intero non scalato
+        // (di tipo BigInteger) e una scala (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+
+
+        // Stringhe
+        String fooString = "Questa e' la mia stringa!";
+
+        // \n e' un carattere di escape che rappresenta l'andare a capo
+        String barString = "Stampare su una nuova riga?\nNessun problema!";
+        // \t e' un carattere di escape che aggiunge un tab
+        String bazString = "Vuoi aggiungere un tab?\tNessun problema!";
         System.out.println(fooString);
         System.out.println(barString);
         System.out.println(bazString);
 
-        // Vettori [array]
-        //La lunghezza del vettore deve essere decisa quando viene istanziato
-        //Si puo' dichiarare come segue:
-        //<tipodato> [] <nomevariabile> = new <tipodato>[<grandezza vettore>];
-        //<tipodato> <nomevariabile>[] = new <tipodato>[<grandezza vettore>];
-        int [] intArray = new int[10];
-        String [] stringArray = new String[1];
-        boolean boolArray [] = new boolean[100];
-
-        // Un altro modo per dichiarare & inizializzare un vettore
-        int [] y = {9000, 1000, 1337};
-        String nomi [] = {"Andrea", "Bob", "Pippo", "Susan"};
+        // Vettori
+        // La dimensione di un array deve essere decisa in fase di
+        // istanziazione. Per dichiarare un array si puo' fare in due modi:
+        // <tipoDato>[] <nomeVariabile> = new <tipoDato>[<dimensioneArray>];
+        // <tipoDato> <nomeVariabile>[] = new <tipoDato>[<dimensioneArray>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Un altro modo per dichiarare ed insieme inizializzare un vettore.
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Gianni", "Anna", "Luca", "Cristina"};
         boolean bools[] = new boolean[] {true, false, false};
-	
-	// I vettori vengono indicizzati a parire dallo 0
+
+        // Per accedere ad un elemento di un vettore
         System.out.println("intArray @ 0: " + intArray[0]);
 
-        // e' possibile un accesso diretto ad un elemento
+        // I vettori non sono immutabili (ma la loro dimensione si!)
+        // e gli indici partono da 0.
         intArray[1] = 1;
         System.out.println("intArray @ 1: " + intArray[1]); // => 1
 
-        // Altro da vedere:
-        // Liste di array - come i vettori ma piu' funzionali
-        // e la loro grandezza puo' variare in corso di esecuzione
-        // Liste concatenate di memoria
+        // Ci sono altri tipo di dato interessanti.
+        // ArrayList - Simili ai vettori, pero' offrono altre funzionalita',
+        //             e la loro dimensione puo' essere modificata.
+        // LinkedList - Si tratta di una lista linkata doppia, e come tale
+        //              implementa tutte le operazioni del caso.
+        // Map - Un insieme di oggetti che fa corrispondere delle chiavi
+        //       a dei valori. Non permette l'inserimento di chiavi uguali.
+        // HashMap - Questa classe usa una tabella di hash per implementare
+        //           l'interfaccia di tipo Map. Questo permette di effettuare
+        //           operazioni basilari, come inserimento e cancellazione,
+        //           in tempo costante anche su insiemi molto grandi.
 
         ///////////////////////////////////////
         // Operatori
diff --git a/it-it/json-it.html.markdown b/it-it/json-it.html.markdown
index 0c401753..379bad73 100644
--- a/it-it/json-it.html.markdown
+++ b/it-it/json-it.html.markdown
@@ -1,29 +1,36 @@
 ---
-
 language: json
 contributors:
-  	- ["Anna Harren", "https://github.com/iirelu"]
-  	- ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
 translators:
     - ["Robert Margelli", "http://github.com/sinkswim/"]
+    - ["Christian Grasso", "http://chris54721.net"]
 lang: it-it
-
 ---
 
-Dato che JSON è un formato per lo scambio di dati estremamente semplice, questo sarà con molta probabilità
-il più semplice Learn X in Y Minutes.
+JSON è un formato per l'interscambio di dati estremamente semplice, per cui questo sarà
+con molta probabilità il più semplice Learn X in Y Minutes.
 
 Nella sua forma più pura JSON non ha commenti, ma molti parser accettano
 commenti in stile C (//, /\* \*/). Per lo scopo prefissato, tuttavia, tutto sarà
 100% JSON valido. Fortunatamente, si spiega da sè.
 
+I tipi supportati da JSON comprendono: numeri, stringhe, boolean, array, oggetti e null.
+I browser supportati sono: Firefox (Mozilla) 3.5+, Internet Explorer 8+, Google Chrome,
+Opera 10+, Safari 4+.
+I file JSON sono salvati nel formato ".json". Il MIME type per documenti JSON è
+"application/json". Gli svantaggi del JSON includono l'assenza di una definizione dei tipi
+e di una sorta di [DTD](https://it.wikipedia.org/wiki/Document_Type_Definition).
+
 ```json
 {
   "chiave": "valore",
   
   "chiavi": "devono sempre essere racchiuse tra doppi apici",
   "numeri": 0,
-  "stringhe": "Ciaø, møndø. Tutti gli unicode sono permessi, assieme con l \"escaping\".",
+  "stringhe": "Ciaø, møndø. Tutti i caratteri Unicode sono permessi, insieme all'\"escaping\".",
   "ha booleani?": true,
   "il nulla": null,
 
@@ -52,8 +59,8 @@ commenti in stile C (//, /\* \*/). Per lo scopo prefissato, tuttavia, tutto sar�
   ],
   
   "stile alternativo": {
-    "commento": "Guarda quà!"
-  , "posizione della virgola": "non conta - fintantochè è prima del valore, allora è valida"
+    "commento": "Guarda qua!"
+  , "posizione della virgola": "non conta - se è prima della chiave successiva, allora è valida"
   , "un altro commento": "che bello"
   },
 
diff --git a/java.html.markdown b/java.html.markdown
index 928eb39f..38c9e490 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -5,6 +5,9 @@ contributors:
     - ["Jakukyo Friel", "http://weakish.github.io"]
     - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
 filename: LearnJava.java
 ---
 
@@ -31,7 +34,7 @@ import java.security.*;
 // the file.
 public class LearnJava {
 
-    // A program must have a main method as an entry point.
+    // In order to run a java program, it must have a main method as an entry point.
     public static void main (String[] args) {
 
         // Use System.out.println() to print lines.
@@ -45,12 +48,34 @@ public class LearnJava {
         System.out.print("Hello ");
         System.out.print("World");
 
+        // Use System.out.printf() for easy formatted printing.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
 
         ///////////////////////////////////////
-        // Types & Variables
+        // Variables
         ///////////////////////////////////////
 
+        /*
+        *  Variable Declaration
+        */
         // Declare a variable using <type> <name>
+        int fooInt;
+        // Declare multiple variables of the same type <type> <name1>, <name2>, <name3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Variable Initialization
+        */
+
+        // Initialize a variable using <type> <name> = <val>
+        int fooInt = 1;
+        // Initialize multiple variables of same type with same value <type> <name1>, <name2>, <name3> = <val>
+        int fooInt1, fooInt2, fooInt3;
+        fooInt1 = fooInt2 = fooInt3 = 1;
+
+        /*
+        *  Variable types
+        */
         // Byte - 8-bit signed two's complement integer
         // (-128 <= byte <= 127)
         byte fooByte = 100;
@@ -72,11 +97,13 @@ public class LearnJava {
         // Note: Java has no unsigned types.
 
         // Float - Single-precision 32-bit IEEE 754 Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
-        // f is used to denote that this variable value is of type float;
+        // f or F is used to denote that this variable value is of type float;
         // otherwise it is treated as double.
 
         // Double - Double-precision 64-bit IEEE 754 Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
         // Boolean - true & false
@@ -86,8 +113,39 @@ public class LearnJava {
         // Char - A single 16-bit Unicode character
         char fooChar = 'A';
 
-        // final variables can't be reassigned to another object.
+        // final variables can't be reassigned to another object,
         final int HOURS_I_WORK_PER_WEEK = 9001;
+        // but they can be initialized later.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger - Immutable arbitrary-precision integers
+        //
+        // BigInteger is a data type that allows programmers to manipulate
+        // integers longer than 64-bits. Integers are stored as an array of
+        // of bytes and are manipulated using functions built into BigInteger
+        //
+        // BigInteger can be initialized using an array of bytes or a string.
+        
+        BigInteger fooBigInteger = new BigDecimal(fooByteArray);
+
+
+        // BigDecimal - Immutable, arbitrary-precision signed decimal number
+        //
+        // A BigDecimal takes two parts: an arbitrary precision integer 
+        // unscaled value and a 32-bit integer scale
+        //
+        // BigDecimal allows the programmer complete control over decimal
+        // rounding. It is recommended to use BigDecimal with currency values
+        // and where exact decimal precision is required.
+        //
+        // BigDecimal can be initialized with an int, long, double or String
+        // or by initializing the unscaled value (BigInteger) and scale (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+
 
         // Strings
         String fooString = "My String Is Here!";
@@ -127,8 +185,12 @@ public class LearnJava {
         // LinkedLists - Implementation of doubly-linked list. All of the
         //               operations perform as could be expected for a
         //               doubly-linked list.
-        // Maps - A set of objects that maps keys to values. A map cannot
-        //        contain duplicate keys; each key can map to at most one value.
+        // Maps - A set of objects that map keys to values. Map is
+	//        an interface and therefore cannot be instantiated.
+	//        The type of keys and values contained in a Map must
+	//        be specified upon instantiation of the implementing
+        //        class. Each key may map to only one corresponding value,
+        //        and each key may appear only once (no duplicates).
         // HashMaps - This class uses a hashtable to implement the Map
         //            interface. This allows the execution time of basic
         //            operations, such as get and insert element, to remain
@@ -146,6 +208,7 @@ public class LearnJava {
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
         System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
+        System.out.println("1/2 = " + (i1 / (i2*1.0))); // => 0.5
 
         // Modulo
         System.out.println("11%3 = "+(11 % 3)); // => 2
@@ -158,12 +221,17 @@ public class LearnJava {
         System.out.println("2 <= 2? " + (2 <= 2)); // => true
         System.out.println("2 >= 2? " + (2 >= 2)); // => true
 
+        // Boolean operators
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
         // Bitwise operators!
         /*
         ~      Unary bitwise complement
         <<     Signed left shift
-        >>     Signed right shift
-        >>>    Unsigned right shift
+        >>     Signed/Arithmetic right shift
+        >>>    Unsigned/Logical right shift
         &      Bitwise AND
         ^      Bitwise exclusive OR
         |      Bitwise inclusive OR
@@ -187,7 +255,7 @@ public class LearnJava {
 
         // If statements are c-like
         int j = 10;
-        if (j == 10){
+        if (j == 10) {
             System.out.println("I get printed");
         } else if (j > 10) {
             System.out.println("I don't");
@@ -216,14 +284,24 @@ public class LearnJava {
         System.out.println("fooDoWhile Value: " + fooDoWhile);
 
         // For Loop
-        int fooFor;
         // for loop structure => for(<start_statement>; <conditional>; <step>)
-        for (fooFor = 0; fooFor < 10; fooFor++) {
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
             System.out.println(fooFor);
             // Iterated 10 times, fooFor 0->9
         }
         System.out.println("fooFor Value: " + fooFor);
-
+        
+        // Nested For Loop Exit with Label
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // breaks out of outer loop instead of only the inner one
+            }
+          }
+        }
+        
         // For Each Loop
         // The for loop is also able to iterate over arrays as well as objects
         // that implement the Iterable interface.
@@ -255,6 +333,23 @@ public class LearnJava {
                      break;
         }
         System.out.println("Switch Case Result: " + monthString);
+        
+        // Starting in Java 7 and above, switching Strings works like this:
+        String myAnswer = "maybe";
+        switch(myAnswer) {
+            case "yes":
+                System.out.println("You answered yes.");
+                break;
+            case "no":
+                System.out.println("You answered no.");
+                break;
+            case "maybe":
+                System.out.println("You answered maybe.");
+                break;
+            default:
+                System.out.println("You answered " + myAnswer);
+                break;
+        }
 
         // Conditional Shorthand
         // You can use the '?' operator for quick assignments or logic forks.
@@ -306,11 +401,39 @@ public class LearnJava {
         // toString returns this Object's string representation.
         System.out.println("trek info: " + trek.toString());
 
+        // Double Brace Initialization
+        // The Java Language has no syntax for how to create static Collections
+        // in an easy way. Usually you end up in the following way:
+
+        private static final Set<String> COUNTRIES = new HashSet<String>();
+        static {
+           validCodes.add("DENMARK");
+           validCodes.add("SWEDEN");
+           validCodes.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 = HashSet<String>() {{
+            add("DENMARK");
+            add("SWEDEN");
+            add("FINLAND");
+        }}
+
+        // The first brace is creating a new AnonymousInnerClass and the
+        // second one declares an instance initializer block. This block
+        // is called when the anonymous inner class is created.
+        // This does not only work for Collections, it works for all
+        // non-final classes.
+
     } // End main method
 } // End LearnJava class
 
 
-// You can include other, non-public outer-level classes in a .java file
+// You can include other, non-public outer-level classes in a .java file,
+// but it is good practice. Instead split classes into separate files.
 
 
 // Class Declaration Syntax:
@@ -330,6 +453,8 @@ class Bicycle {
     // Constructors are a way of creating classes
     // This is a constructor
     public Bicycle() {
+        // You can also call another constructor:
+        // this(1, 50, 5, "Bontrager");
         gear = 1;
         cadence = 50;
         speed = 5;
@@ -345,13 +470,13 @@ class Bicycle {
         this.name = name;
     }
 
-    // Function Syntax:
+    // Method Syntax:
     // <public/private/protected> <return type> <function name>(<args>)
 
     // Java classes often implement getters and setters for their fields
 
     // Method declaration syntax:
-    // <scope> <return type> <method name>(<args>)
+    // <access modifier> <return type> <method name>(<args>)
     public int getCadence() {
         return cadence;
     }
@@ -382,7 +507,7 @@ class Bicycle {
     }
 
     //Method to display the attribute values of this Object.
-    @Override
+    @Override // Inherited from the Object class.
     public String toString() {
         return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
             " name: " + name;
@@ -417,39 +542,149 @@ class PennyFarthing extends Bicycle {
 
 // Example - Food:
 public interface Edible {
-	public void eat(); // Any class that implements this interface, must
+    public void eat(); // Any class that implements this interface, must
                        // implement this method.
 }
 
 public interface Digestible {
-	public void digest();
+    public void digest();
 }
 
 
 // We can now create a class that implements both of these interfaces.
 public class Fruit implements Edible, Digestible {
+  
     @Override
-	public void eat() {
-		// ...
-	}
+    public void eat() {
+        // ...
+    }
 
     @Override
-	public void digest() {
-		// ...
-	}
+    public void digest() {
+        // ...
+    }
 }
 
 // In Java, you can extend only one class, but you can implement many
 // interfaces. For example:
 public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     InterfaceTwo {
+
     @Override
-	public void InterfaceOneMethod() {
-	}
+    public void InterfaceOneMethod() {
+    }
 
     @Override
-	public void InterfaceTwoMethod() {
-	}
+    public void InterfaceTwoMethod() {
+    }
+
+}
+
+// Abstract Classes
+
+// Abstract Class declaration syntax
+// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
+//     // Constants and variables
+//     // Method declarations
+// }
+
+// Marking a class as abstract means that it contains abstract methods that must
+// be defined in a child class. Similar to interfaces, abstract classes cannot
+// be instantiated, but instead must be extended and the abstract methods
+// defined. Different from interfaces, abstract classes can contain a mixture of
+// concrete and abstract methods. Methods in an interface cannot have a body,
+// unless the method is static, and variables are final by default, unlike an
+// abstract class. Also abstract classes CAN have the "main" method.
+
+public abstract class Animal
+{
+    public abstract void makeSound();
+
+    // Method can have a body
+    public void eat()
+    {
+        System.out.println("I am an animal and I am Eating.");  
+        // Note: We can access private variable here.
+        age = 30;
+    }
+
+    // No need to initialize, however in an interface
+    // a variable is implicitly final and hence has
+    // to be initialized.
+    protected int age;
+
+    public void printAge()
+    {
+        System.out.println(age);  
+    }
+
+    // Abstract classes can have main function.
+    public static void main(String[] args)
+    {
+        System.out.println("I am abstract");
+    }
+}
+
+class Dog extends Animal
+{
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Bark");
+        // age = 30;	==> ERROR!	age is private to Animal
+    }
+
+    // NOTE: You will get an error if you used the
+    // @Override annotation here, since java doesn't allow
+    // overriding of static methods.
+    // What is happening here is called METHOD HIDING.
+    // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// Final Classes
+
+// Final Class declaration syntax
+// <access-level> final <final-class-name> {
+//     // Constants and variables
+//     // Method declarations
+// }
+
+// Final classes are classes that cannot be inherited from and are therefore a
+// final child. In a way, final classes are the opposite of abstract classes
+// because abstract classes must be extended, but final classes cannot be
+// extended.
+public final class SaberToothedCat extends Animal
+{
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Final Methods
+public abstract class Mammal()
+{
+    // Final Method Syntax:
+    // <access modifier> final <return type> <function name>(<args>)
+
+    // Final methods, like, final classes cannot be overridden by a child class,
+    // and are therefore the final implementation of the method.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
 }
 ```
 
diff --git a/javascript.html.markdown b/javascript.html.markdown
index ba2e8ce4..a119be88 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -54,6 +54,11 @@ doStuff()
 // Including uneven division.
 5 / 2; // = 2.5
 
+// And modulo division.
+10 % 2; // = 0
+30 % 4; // = 2
+18.5 % 7; // = 4.5
+
 // Bitwise operations also work; when you perform a bitwise operation your float
 // is converted to a signed int *up to* 32 bits.
 1 << 2; // = 4
@@ -64,7 +69,7 @@ doStuff()
 // There are three special not-a-real-number values:
 Infinity; // result of e.g. 1/0
 -Infinity; // result of e.g. -1/0
-NaN; // result of e.g. 0/0
+NaN; // result of e.g. 0/0, stands for 'Not a Number'
 
 // There's also a boolean type.
 true;
@@ -104,7 +109,7 @@ null == undefined; // = true
 
 // ...unless you use ===
 "5" === 5; // = false
-null === undefined; // = false 
+null === undefined; // = false
 
 // ...which can result in some weird behaviour...
 13 + !0; // 14
@@ -144,6 +149,10 @@ someOtherVar = 10;
 // Variables declared without being assigned to are set to undefined.
 var someThirdVar; // = undefined
 
+// if you wan't to declare a couple of variables, then you could use a comma 
+// separator
+var someFourthVar = 2, someFifthVar = 4;
+
 // There's shorthand for performing math operations on variables:
 someVar += 5; // equivalent to someVar = someVar + 5; someVar is 10 now
 someVar *= 10; // now someVar is 100
@@ -189,7 +198,7 @@ myObj.myFourthKey; // = undefined
 ///////////////////////////////////
 // 3. Logic and Control Structures
 
-// The syntax for this section is almost identical to Java's. 
+// The syntax for this section is almost identical to Java's.
 
 // The `if` structure works as you'd expect.
 var count = 1;
@@ -218,6 +227,26 @@ for (var i = 0; i < 5; i++){
     // will run 5 times
 }
 
+//The For/In statement loops iterates over every property across the entire prototype chain
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18};
+for (var x in person){
+    description += person[x] + " ";
+}
+
+//If only want to consider properties attached to the object itself,
+//and not its prototypes use hasOwnProperty() check
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18};
+for (var x in person){
+    if (person.hasOwnProperty(x)){
+        description += person[x] + " ";
+    }
+}
+
+//for/in should not be used to iterate over an Array where the index order is important.
+//There is no guarantee that for/in will return the indexes in any particular order
+
 // && is logical and, || is logical or
 if (house.size == "big" && house.colour == "blue"){
     house.contains = "bear";
@@ -231,8 +260,8 @@ var name = otherName || "default";
 
 
 // The `switch` statement checks for equality with `===`.
-// use 'break' after each case 
-// or the cases after the correct one will be executed too. 
+// use 'break' after each case
+// or the cases after the correct one will be executed too.
 grade = 'B';
 switch (grade) {
   case 'A':
@@ -262,12 +291,9 @@ myFunction("foo"); // = "FOO"
 // Note that the value to be returned must start on the same line as the
 // `return` keyword, otherwise you'll always return `undefined` due to
 // automatic semicolon insertion. Watch out for this when using Allman style.
-function myFunction()
-{
+function myFunction(){
     return // <- semicolon automatically inserted here
-    {
-        thisIsAn: 'object literal'
-    }
+    {thisIsAn: 'object literal'}
 }
 myFunction(); // = undefined
 
@@ -281,6 +307,12 @@ setTimeout(myFunction, 5000);
 // Note: setTimeout isn't part of the JS language, but is provided by browsers
 // and Node.js.
 
+// Another function provided by browsers is setInterval
+function myFunction(){
+    // this code will be called every 5 seconds
+}
+setInterval(myFunction, 5000);
+
 // Function objects don't even have to be declared with a name - you can write
 // an anonymous function definition directly into the arguments of another.
 setTimeout(function(){
@@ -299,7 +331,7 @@ i; // = 5 - not undefined as you'd expect in a block-scoped language
 // scope.
 (function(){
     var temporary = 5;
-    // We can access the global scope by assiging to the "global object", which
+    // We can access the global scope by assigning to the "global object", which
     // in a web browser is always `window`. The global object may have a
     // different name in non-browser environments such as Node.js.
     window.permanent = 10;
@@ -393,7 +425,7 @@ var doubler = product.bind(this, 2);
 doubler(8); // = 16
 
 // When you call a function with the `new` keyword, a new object is created, and
-// made available to the function via the this keyword. Functions designed to be
+// made available to the function via the `this` keyword. Functions designed to be
 // called like that are called constructors.
 
 var MyConstructor = function(){
@@ -516,12 +548,12 @@ more about how to use JavaScript in web pages, start by learning about the
 [Document Object
 Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
 
-[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) is a variant of this reference with built-in challenges. 
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) is a variant of this reference with built-in challenges.
 
 [JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
 guide of all the counter-intuitive parts of the language.
 
-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) is a classic guide / reference book. 
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) is a classic guide / reference book.
 
 In addition to direct contributors to this article, some content is adapted
 from Louie Dinh's Python tutorial on this site, and the [JS
diff --git a/json.html.markdown b/json.html.markdown
index f57b82b8..cde7bc40 100644
--- a/json.html.markdown
+++ b/json.html.markdown
@@ -4,19 +4,36 @@ filename: learnjson.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Michael Neth", "https://github.com/infernocloud"]
 ---
 
-As JSON is an extremely simple data-interchange format, this is most likely going
-to be the simplest Learn X in Y Minutes ever.
+As JSON is an extremely simple data-interchange format, this is most likely going to be the simplest Learn X in Y Minutes ever.
 
-JSON in its purest form has no actual comments, but most parsers will accept
-C-style (`//`, `/* */`) comments. For the purposes of this, however,  everything is
-going to be 100% valid JSON. Luckily, it kind of speaks for itself.
+JSON in its purest form has no actual comments, but most parsers will accept C-style (`//`, `/* */`) comments. Some parsers also tolerate a trailing comma (i.e. a comma after the last element of an array or the after the last property of an object), but they should be avoided for better compatibility.
+
+For the purposes of this, however, everything is going to be 100% valid JSON. Luckily, it kind of speaks for itself.
+
+A JSON value must be a number, a string, an array, an object, or one of the following 3 literal names: true, false, null.
+
+Supporting browsers are: Firefox 3.5+, Internet Explorer 8.0+, Chrome 1.0+, Opera 10.0+, and Safari 4.0+.
+
+File extension for JSON files is ".json" and the MIME type for JSON text is "application/json".
+
+Many programming languages have support for serializing (encoding) and unserializing (decoding) JSON data into native data structures. Javascript has implicit support for manipulating JSON text as data.
+
+More information can be found at http://www.json.org/
+
+JSON is built on two structures:
+* 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 most languages, this is realized as an array, vector, list, or sequence.
+
+An object with various name/value pairs.
 
 ```json
 {
   "key": "value",
-  
+
   "keys": "must always be enclosed in double quotes",
   "numbers": 0,
   "strings": "Hellø, wørld. All unicode is allowed, along with \"escaping\".",
@@ -46,13 +63,23 @@ going to be 100% valid JSON. Luckily, it kind of speaks for itself.
       [0, 0, 0, 1]
     ]
   ],
-  
+
   "alternative style": {
     "comment": "check this out!"
-  , "comma position": "doesn't matter - as long as its before the value, then its valid"
+  , "comma position": "doesn't matter - as long as it's before the next key, then it's valid"
   , "another comment": "how nice"
-  },
-
-  "that was short": "And, you're done. You now know everything JSON has to offer."
+  }
 }
 ```
+
+A single array of values by itself is also valid JSON.
+
+```json
+[1, 2, 3, "text", true]
+```
+
+Objects can be a part of the array as well.
+
+```json
+[{"name": "Bob", "age": 25}, {"name": "Jane", "age": 29}, {"name": "Jack", "age": 31}]
+```
diff --git a/julia.html.markdown b/julia.html.markdown
index 5ccd6484..cba7cd45 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -14,7 +14,7 @@ This is based on Julia 0.3.
 
 # Single line comments start with a hash (pound) symbol.
 #= Multiline comments can be written
-   by putting '#=' before the text  and '=#' 
+   by putting '#=' before the text  and '=#'
    after the text. They can also be nested.
 =#
 
@@ -81,10 +81,13 @@ false
 # Strings are created with "
 "This is a string."
 
+# Julia has several types of strings, including ASCIIString and UTF8String.
+# More on this in the Types section.
+
 # Character literals are written with '
 'a'
 
-# A string can be indexed like an array of characters
+# Some strings can be indexed like an array of characters
 "This is a string"[1] # => 'T' # Julia indexes from 1
 # However, this is will not work well for UTF8 strings,
 # so iterating over strings is recommended (map, for loops, etc).
@@ -114,11 +117,11 @@ catch e
     println(e)
 end
 
-# Variable names start with a letter.
+# Variable names start with a letter or underscore.
 # After that, you can use letters, digits, underscores, and exclamation points.
 SomeOtherVar123! = 6 # => 6
 
-# You can also use unicode characters
+# You can also use certain unicode characters
 ☃ = 8 # => 8
 # These are especially handy for mathematical notation
 2 * π # => 6.283185307179586
@@ -314,7 +317,7 @@ end
 
 
 # For loops iterate over iterables.
-# Iterable types include Range, Array, Set, Dict, and String.
+# Iterable types include Range, Array, Set, Dict, and AbstractString.
 for animal=["dog", "cat", "mouse"]
     println("$animal is a mammal")
     # You can use $ to interpolate variables or expression into strings
@@ -537,6 +540,17 @@ subtypes(Number) # => 6-element Array{Any,1}:
                  #     Real
 subtypes(Cat) # => 0-element Array{Any,1}
 
+# AbstractString, as the name implies, is also an abstract type
+subtypes(AbstractString)    # 8-element Array{Any,1}:
+                            #  Base.SubstitutionString{T<:AbstractString}
+                            #  DirectIndexString
+                            #  RepString
+                            #  RevString{T<:AbstractString}
+                            #  RopeString
+                            #  SubString{T<:AbstractString}
+                            #  UTF16String
+                            #  UTF8String
+
 # Every type has a super type; use the `super` function to get it.
 typeof(5) # => Int64
 super(Int64) # => Signed
@@ -546,17 +560,21 @@ super(Number) # => Any
 super(super(Signed)) # => Number
 super(Any) # => Any
 # All of these type, except for Int64, are abstract.
+typeof("fire") # => ASCIIString
+super(ASCIIString) # => DirectIndexString
+super(DirectIndexString) # => AbstractString
+# Likewise here with ASCIIString
 
 # <: is the subtyping operator
 type Lion <: Cat # Lion is a subtype of Cat
   mane_color
-  roar::String
+  roar::AbstractString
 end
 
 # You can define more constructors for your type
 # Just define a function of the same name as the type
 # and call an existing constructor to get a value of the correct type
-Lion(roar::String) = Lion("green",roar)
+Lion(roar::AbstractString) = Lion("green",roar)
 # This is an outer constructor because it's outside the type definition
 
 type Panther <: Cat # Panther is also a subtype of Cat
@@ -670,7 +688,7 @@ square_area(l) = l * l      # square_area (generic function with 1 method)
 square_area(5) #25
 
 # What happens when we feed square_area an integer?
-code_native(square_area, (Int32,))  
+code_native(square_area, (Int32,))
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
 	#	Source line: 1              # Prologue
@@ -703,10 +721,10 @@ code_native(square_area, (Float64,))
 	#	    vmulsd  XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
 	#	    pop RBP
 	#	    ret
-	#	
+	#
 # Note that julia will use floating point instructions if any of the
 # arguements are floats.
-# Let's calculate the area of a circle 
+# Let's calculate the area of a circle
 circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
 circle_area(5)                  # 78.53981633974483
 
@@ -737,7 +755,7 @@ code_native(circle_area, (Float64,))
 	#	    vmulsd  XMM0, XMM1, XMM0
 	#	    pop RBP
 	#	    ret
-	#	
+	#
 ```
 
 ## Further Reading
diff --git a/ko-kr/javascript-kr.html.markdown b/ko-kr/javascript-kr.html.markdown
index 4ca3bb5c..9561e80c 100644
--- a/ko-kr/javascript-kr.html.markdown
+++ b/ko-kr/javascript-kr.html.markdown
@@ -387,9 +387,6 @@ myNumber === myNumberObj // = false
 if (0){
     // 0은 거짓이라서 이 코드는 실행되지 않습니다.
 }
-if (Number(0)){
-    // Number(0)은 참이라서 이 코드는 *실행됩니다*.
-}
 
 // 하지만 래퍼 객체와 일반 내장 함수는 프로토타입을 공유하기 때문에 
 // 가령 문자열에 실제로 기능을 추가할 수 있습니다.
diff --git a/latex.html.markdown b/latex.html.markdown
new file mode 100644
index 00000000..9b7b4feb
--- /dev/null
+++ b/latex.html.markdown
@@ -0,0 +1,234 @@
+---
+language: latex
+contributors:
+    - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+filename: learn-latex.tex
+---
+
+```tex
+% All comment lines start with %
+% There are no multi-line comments
+
+% LaTeX is NOT a "What You See Is What You Get" word processing software like
+% MS Word, or OpenOffice Writer
+
+% Every LaTeX command starts with a backslash (\)
+
+% LaTeX documents start with a defining the type of document it's compiling
+% Other document types include book, report, presentations, etc.
+% The options for the document appear in the [] brackets. In this case
+% it specifies we want to use 12pt font.
+\documentclass[12pt]{article}
+
+% Next we define the packages the document uses.
+% If you want to include graphics, colored text, or
+% source code from another language file into your document, 
+% you need to enhance the capabilities of LaTeX. This is done by adding packages. 
+% I'm going to include the float and caption packages for figures.
+\usepackage{caption}
+\usepackage{float}
+
+% We can define some other document properties too!
+\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
+\date{\today}
+\title{Learn LaTeX in Y Minutes!}
+
+% Now we're ready to begin the document
+% Everything before this line is called "The Preamble"
+\begin{document} 
+% if we set the author, date, title fields, we can have LaTeX 
+% create a title page for us.
+\maketitle
+
+% Most research papers have abstract, you can use the predefined commands for this.
+% This should appear in its logical order, therefore, after the top matter,
+% but before the main sections of the body. 
+% This command is available in the document classes article and report.
+\begin{abstract}
+ LaTeX documentation written as LaTeX! How novel and totally not my idea!
+\end{abstract}
+
+% Section commands are intuitive. 
+% All the titles of the sections are added automatically to the table of contents.
+\section{Introduction}
+Hello, my name is Colton and together we're going to explore LaTeX!
+
+\section{Another section}
+This is the text for another section. I think it needs a subsection.
+
+\subsection{This is a subsection} % Subsections are also intuitive.
+I think we need another one
+
+\subsubsection{Pythagoras}
+Much better now.
+\label{subsec:pythagoras}
+
+% By using the asterisk we can suppress LaTeX's inbuilt numbering.
+% This works for other LaTeX commands as well. 
+\section*{This is an unnumbered section} 
+However not all sections have to be numbered!
+
+\section{Some Text notes}
+LaTeX is generally pretty good about placing text where it should go. If 
+a line \\ needs \\ to \\ break \\ you add \textbackslash\textbackslash to 
+the source code. \\ 
+
+\section{Lists}
+Lists are one of the easiest things to create in LaTeX! I need to go shopping
+tomorrow, so let's make a grocery list.
+\begin{enumerate} % This creates an "enumerate" environment.
+  % \item tells the enumerate to increment
+  \item Salad.
+  \item 27 watermelon.
+  \item A single jackrabbit.
+  % we can even override the item number by using []
+  \item[how many?] Medium sized squirt guns.
+
+  Not a list item, but still part of the enumerate.
+
+\end{enumerate} % All environments must have an end.
+
+\section{Math}
+
+One of the primary uses for LaTeX is to produce academic articles or 
+technical papers. Usually in the realm of math and science. As such, 
+we need to be able to add special symbols to our paper! \\
+
+Math has many symbols, far beyond what you can find on a keyboard;
+Set and relation symbols, arrows, operators, and Greek letters to name a few.\\
+
+Sets and relations play a vital role in many mathematical research papers.
+Here's how you state all y that belong to X, $\forall$ x $\in$ X. \\
+% Notice how I needed to add $ signs before and after the symbols. This is 
+% because when writing, we are in text-mode. 
+% However, the math symbols only exist in math-mode. 
+% We can enter math-mode from text mode with the $ signs.
+% The opposite also holds true. Variable can also be rendered in math-mode.
+
+My favorite Greek letter is $\xi$. I also like $\beta$, $\gamma$ and $\sigma$.
+I haven't found a Greek letter that yet that LaTeX doesn't know about!
+
+Operators are essential parts of a mathematical document: 
+trigonometric functions ($\sin$, $\cos$, $\tan$), 
+logarithms and exponentials ($\log$, $\exp$), 
+limits ($\lim$), etc. 
+have per-defined LaTeX commands. 
+Let's write an equation to see how it's done: \\
+
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
+
+Fractions(Numerator-denominators) can be written in these forms:
+
+% 10 / 7
+$^{10}/_{7}$ 
+
+% Relatively complex fractions can be written as
+% \frac{numerator}{denominator}
+$\frac{n!}{k!(n - k)!}$ \\
+
+We can also insert equations in an "equation environment". 
+
+% Display math with the equation 'environment'
+\begin{equation} % enters math-mode
+    c^2 = a^2 + b^2.
+    \label{eq:pythagoras} % for referencing
+\end{equation} % all \begin statements must have an end statement
+
+We can then reference our new equation! 
+Eqn.~\ref{eq:pythagoras} is also known as the Pythagoras Theorem which is also
+the subject of Sec.~\ref{subsec:pythagoras}. A lot of things can be labeled: 
+figures, equations, sections, etc.
+
+Summations and Integrals are written with sum and int commands:
+
+% Some LaTeX compilers will complain if there are blank lines
+% In an equation environment.
+\begin{equation} 
+  \sum_{i=0}^{5} f_{i}
+\end{equation} 
+\begin{equation} 
+  \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
+\end{equation} 
+
+\section{Figures}
+
+Let's insert a Figure. Figure placement can get a little tricky. 
+I definitely have to lookup the placement options each time.
+
+\begin{figure}[H] % H here denoted the placement option. 
+    \centering % centers the figure on the page
+    % Inserts a figure scaled to 0.8 the width of the page.
+    %\includegraphics[width=0.8\linewidth]{right-triangle.png} 
+    % Commented out for compilation purposes. Please use your imagination.
+    \caption{Right triangle with sides $a$, $b$, $c$}
+    \label{fig:right-triangle}
+\end{figure}
+
+\subsection{Table}
+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.
+  % Again, I have to look these up. Each. And. Every. Time.
+  \begin{tabular}{c|cc} 
+    Number &  Last Name & First Name \\ % Column rows are separated by $
+    \hline % a horizontal line
+    1 & Biggus & Dickus \\
+    2 & Monty & Python
+  \end{tabular}
+\end{table}
+
+% \section{Hyperlinks} % Coming soon
+
+\section{Getting LaTeX to not compile something (i.e. Source Code)}
+Let's say we want to include some code into our LaTeX document,
+we would then need LaTeX to not try and interpret that text and
+instead just print it to the document. We do this we a verbatim 
+environment. 
+
+% There are other packages that exist (i.e. minty, lstlisting, etc.)
+% but verbatim is the bare-bones basic one.
+\begin{verbatim} 
+  print("Hello World!")
+  a%b; % look! We can use % signs in verbatim. 
+  random = 4; #decided by fair random dice roll
+\end{verbatim}
+
+\section{Compiling} 
+
+By now you're probably wondering how to compile this fabulous document 
+and look at the glorious glory that is a LaTeX pdf.
+(yes, this document actually does compiles). \\
+Getting to the final document using LaTeX consists of the following steps:
+  \begin{enumerate}
+    \item Write the document in plain text (the "source code").
+    \item Compile source code to produce a pdf. 
+     The compilation step looks something like this (in Linux): \\
+     \begin{verbatim} 
+        $pdflatex learn-latex.tex learn-latex.pdf 
+     \end{verbatim}
+  \end{enumerate}
+
+A number of LaTeX editors combine both Step 1 and Step 2 in the same piece of
+software. So, you get to see Step 1, but not Step 2 completely.
+Step 2 is still happening behind the scenes.
+
+You write all your formatting information in plain text in Step 1.
+The compilation part in Step 2 takes care of producing the document in the
+format you defined in Step 1.
+
+\section{End}
+
+That's all for now!
+
+% end the document
+\end{document}
+```
+
+## More on LaTeX
+
+* The amazing LaTeX wikibook: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX)
+* An actual tutorial: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
diff --git a/livescript.html.markdown b/livescript.html.markdown
index e64f7719..9235f5ce 100644
--- a/livescript.html.markdown
+++ b/livescript.html.markdown
@@ -166,7 +166,7 @@ not false       # => true
 
 ########################################################################
 ## 3. Functions
-########################################################################        
+########################################################################
 
 # Since LiveScript is functional, you'd expect functions to get a nice
 # treatment. In LiveScript it's even more apparent that functions are
@@ -229,7 +229,7 @@ double-minus-one = (- 1) . (* 2)
 
 # Other than the usual `f . g` mathematical formulae, you get the `>>`
 # and `<<` operators, that describe how the flow of values through the
-# functions. 
+# functions.
 double-minus-one = (* 2) >> (- 1)
 double-minus-one = (- 1) << (* 2)
 
@@ -344,7 +344,7 @@ kitten.hug!     # => "*Mei (a cat) is hugged*"
 ## Further reading
 
 There's just so much more to LiveScript, but this should be enough to
-get you started writing little functional things in it. The 
+get you started writing little functional things in it. The
 [official website](http://livescript.net/) has a lot of information on the
 language, and a nice online compiler for you to try stuff out!
 
diff --git a/make.html.markdown b/make.html.markdown
index 75543dcd..563139d1 100644
--- a/make.html.markdown
+++ b/make.html.markdown
@@ -31,7 +31,7 @@ we are using GNU make which is the standard on Linux.
 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. 

+	# 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.

@@ -49,7 +49,7 @@ 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 

+# Make will complain about multiple recipes for the same rule. Empty

 # recipes don't count though and can be used to add new dependencies.

 

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

@@ -115,7 +115,7 @@ small/%.png: %.svg
 %.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 

+# 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

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

 #:= and ::= are equivalent.

 

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

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

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

 

 # This doesn't work

diff --git a/markdown.html.markdown b/markdown.html.markdown
index 6d19710f..2333110f 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -70,7 +70,7 @@ I'm in paragraph three!
 <!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph
 with two or more spaces and then begin a new paragraph. -->
 
-I end with two spaces (highlight me to see them).  
+I end with two spaces (highlight me to see them).
 
 There's a <br /> above me!
 
@@ -97,7 +97,7 @@ or
 + Item
 + One more item
 
-or 
+or
 
 - Item
 - Item
@@ -129,7 +129,7 @@ render the numbers in order, but this may not be a good idea -->
 <!-- There are even task lists. This creates HTML checkboxes. -->
 
 Boxes below without the 'x' are unchecked HTML checkboxes.
-- [ ] First task to complete. 
+- [ ] First task to complete.
 - [ ] Second task that needs done
 This checkbox below will be a checked HTML checkbox.
 - [x] This task has been completed
@@ -160,7 +160,7 @@ def foobar
 end
 \`\`\` <!-- here too, no backslashes, just ``` -->
 
-<-- The above text doesn't require indenting, plus Github will use syntax
+<!-- The above text doesn't require indenting, plus Github will use syntax
 highlighting of the language you specify after the ``` -->
 
 <!-- Horizontal rule (<hr />) -->
@@ -169,7 +169,7 @@ with or without spaces. -->
 
 ***
 ---
-- - - 
+- - -
 ****************
 
 <!-- Links -->
diff --git a/matlab.html.markdown b/matlab.html.markdown
index 00f4c53a..4d97834c 100644
--- a/matlab.html.markdown
+++ b/matlab.html.markdown
@@ -1,12 +1,14 @@
 ---
 language: Matlab
+filename: learnmatlab.mat
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
     - ["jamesscottbrown", "http://jamesscottbrown.com"]
-
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Claudson Martins", "http://github.com/claudsonm"]
 ---
 
-MATLAB stands for MATrix LABoratory. It is a powerful numerical computing language commonly used in engineering and mathematics.  
+MATLAB stands for MATrix LABoratory. It is a powerful numerical computing language commonly used in engineering and mathematics.
 
 If you have any feedback please feel free to reach me at
 [@the_ozzinator](https://twitter.com/the_ozzinator), or
@@ -16,7 +18,7 @@ If you have any feedback please feel free to reach me at
 % Comments start with a percent sign.
 
 %{
-Multi line comments look 
+Multi line comments look
 something
 like
 this
@@ -62,10 +64,10 @@ disp('text') 	% print "text" to the screen
 % Variables & Expressions
 myVariable = 4 	% Notice Workspace pane shows newly created variable
 myVariable = 4; % Semi colon suppresses output to the Command Window
-4 + 6  		% ans = 10 
-8 * myVariable 	% ans = 32 
-2 ^ 3 		% ans = 8 
-a = 2; b = 3; 
+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
 
 % Calling functions can be done in either of two ways:
@@ -73,7 +75,7 @@ c = exp(a)*sin(pi/2) % c = 7.3891
 load('myFile.mat', 'y') % arguments within parantheses, spererated by commas
 % Command syntax:
 load myFile.mat y 	% no parentheses, and spaces instead of commas
-% Note the lack of quote marks in command form: inputs are always passed as 
+% Note the lack of quote marks in command form: inputs are always passed as
 % literal text - cannot pass variable values. Also, can't receive output:
 [V,D] = eig(A);  % this has no equivalent in command form
 [~,D] = eig(A);  % if you only want D and not V
@@ -103,7 +105,7 @@ a(2) % ans = y
 
 
 % Cells
-a = {'one', 'two', 'three'} 
+a = {'one', 'two', 'three'}
 a(1) % ans = 'one' - returns a cell
 char(a(1)) % ans = one - returns a string
 
@@ -113,7 +115,7 @@ A.c = [1 2];
 A.d.e = false;
 
 % Vectors
-x = [4 32 53 7 1] 
+x = [4 32 53 7 1]
 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
@@ -123,7 +125,7 @@ x = [4; 32; 53; 7; 1] % Column vector
 x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
 
 % Matrices
-A = [1 2 3; 4 5 6; 7 8 9] 
+A = [1 2 3; 4 5 6; 7 8 9]
 % Rows are separated by a semicolon; elements are separated with space or comma
 % A =
 
@@ -132,7 +134,7 @@ A = [1 2 3; 4 5 6; 7 8 9]
 %     7     8     9
 
 A(2,3) % ans = 6, A(row, column)
-A(6) % ans = 8 
+A(6) % ans = 8
 % (implicitly concatenates columns into vector, then indexes into that)
 
 
@@ -171,7 +173,7 @@ A(1,:) % All columns in row 1
 %     4     5    42
 %     7     8     9
 
-% this is the same as 
+% this is the same as
 vertcat(A,A);
 
 
@@ -183,7 +185,7 @@ vertcat(A,A);
 %     4     5    42     4     5    42
 %     7     8     9     7     8     9
 
-% this is the same as 
+% this is the same as
 horzcat(A,A);
 
 
@@ -201,21 +203,21 @@ A(:, 1) =[] % Delete the first column of the matrix
 
 transpose(A) % Transpose the matrix, which is the same as:
 A one
-ctranspose(A) % Hermitian transpose the matrix 
+ctranspose(A) % Hermitian transpose the matrix
 % (the transpose, followed by taking complex conjugate of each element)
 
 
 
 
-% Element by Element Arithmetic vs. Matrix Arithmetic 
+% Element by Element Arithmetic vs. Matrix Arithmetic
 % On their own, the arithmetic operators act on whole matrices. When preceded
 % by a period, they act on each element instead. For example:
 A * B % Matrix multiplication
 A .* B % Multiple each element in A by its corresponding element in B
 
-% There are several pairs of functions, where one acts on each element, and 
+% There are several pairs of functions, where one acts on each element, and
 % the other (whose name ends in m) acts on the whole matrix.
-exp(A) % exponentiate each element 
+exp(A) % exponentiate each element
 expm(A) % calculate the matrix exponential
 sqrt(A) % take the square root of each element
 sqrtm(A) %  find the matrix whose square is A
@@ -233,7 +235,7 @@ axis([0 2*pi -1 1]) % x range from 0 to 2*pi, y range from -1 to 1
 plot(x,y1,'-',x,y2,'--',x,y3,':') % For multiple functions on one plot
 legend('Line 1 label', 'Line 2 label') % Label curves with a legend
 
-% Alternative method to plot multiple functions in one plot. 
+% Alternative method to plot multiple functions in one plot.
 % while 'hold' is on, commands add to existing graph rather than replacing it
 plot(x, y)
 hold on
@@ -260,7 +262,7 @@ pcolor(A) % Heat-map of matrix: plot as grid of rectangles, coloured by value
 contour(A) % Contour plot of matrix
 mesh(A) % Plot as a mesh surface
 
-h = figure	% Create new figure object, with handle f
+h = figure	% Create new figure object, with handle h
 figure(h) % Makes the figure corresponding to handle h the current figure
 close(h) % close figure with handle h
 close all % close all open figure windows
@@ -271,9 +273,9 @@ clf clear % clear current figure window, and reset most figure properties
 
 % Properties can be set and changed through a figure handle.
 % You can save a handle to a figure when you create it.
-% The function gcf returns a handle to the current figure 
+% The function gcf returns a handle to the current figure
 h = plot(x, y); % you can save a handle to a figure when you create it
-set(h, 'Color', 'r') 
+set(h, 'Color', 'r')
 % 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
 set(h, 'LineStyle', '--')
  % '--' is solid line, '---' dashed, ':' dotted, '-.' dash-dot, 'none' is no line
@@ -298,8 +300,8 @@ cd /path/to/move/into % change directory
 
 
 % Variables can be saved to .mat files
-save('myFileName.mat') % Save the variables in your Workspace 
-load('myFileName.mat') % Load saved variables into Workspace 
+save('myFileName.mat') % Save the variables in your Workspace
+load('myFileName.mat') % Load saved variables into Workspace
 
 % M-file Scripts
 % A script file is an external file that contains a sequence of statements.
@@ -312,11 +314,11 @@ load('myFileName.mat') % Load saved variables into Workspace
 % Also, they have their own workspace (ie. different variable scope).
 % Function name should match file name (so save this example as double_input.m).
 % 'help double_input.m' returns the comments under line beginning function
-function output = double_input(x) 
+function output = double_input(x)
 	%double_input(x) returns twice the value of x
 	output = 2*x;
 end
-double_input(6) % ans = 12 
+double_input(6) % ans = 12
 
 
 % You can also have subfunctions and nested functions.
@@ -325,10 +327,10 @@ double_input(6) % ans = 12
 % functions, and have access to both its workspace and their own workspace.
 
 % If you want to create a function without creating a new file you can use an
-% anonymous function. Useful when quickly defining a function to pass to 
-% another function (eg. plot with fplot, evaluate an indefinite integral 
+% anonymous function. Useful when quickly defining a function to pass to
+% another function (eg. plot with fplot, evaluate an indefinite integral
 % with quad, find roots with fzero, or find minimum with fminsearch).
-% Example that returns the square of it's input, assigned to to the handle sqr:
+% Example that returns the square of it's input, assigned to the handle sqr:
 sqr = @(x) x.^2;
 sqr(10) % ans = 100
 doc function_handle % find out more
@@ -336,12 +338,12 @@ doc function_handle % find out more
 % User input
 a = input('Enter the value: ')
 
-% Stops execution of file and gives control to the keyboard: user can examine 
+% Stops execution of file and gives control to the keyboard: user can examine
 % or change variables. Type 'return' to continue execution, or 'dbquit' to exit
 keyboard
 
 % Reading in data (also xlsread/importdata/imread for excel/CSV/image files)
-fopen(filename) 
+fopen(filename)
 
 % Output
 disp(a) % Print out the value of variable a
@@ -363,8 +365,8 @@ end
 for k = 1:5
 	disp(k)
 end
-	
-k = 0;	
+
+k = 0;
 while (k < 5)
 	k = k + 1;
 end
@@ -382,7 +384,7 @@ password = 'root';
 driver = 'com.mysql.jdbc.Driver';
 dburl = ['jdbc:mysql://localhost:8889/' dbname];
 javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depends on version, download available at http://dev.mysql.com/downloads/connector/j/
-conn = database(dbname, username, password, driver, dburl); 
+conn = database(dbname, username, password, driver, dburl);
 sql = ['SELECT * from table_name where id = 22'] % Example sql statement
 a = fetch(conn, sql) %a will contain your data
 
@@ -394,7 +396,7 @@ tan(x)
 asin(x)
 acos(x)
 atan(x)
-exp(x) 
+exp(x)
 sqrt(x)
 log(x)
 log10(x)
@@ -426,7 +428,7 @@ pinv(A) % calculate the pseudo-inverse
 zeros(m,n) % m x n matrix of 0's
 ones(m,n) % m x n matrix of 1's
 diag(A) % Extracts the diagonal elements of a matrix A
-diag(x) % Construct a matrix with diagonal elements listed in x, and zeroes elsewhere 
+diag(x) % Construct a matrix with diagonal elements listed in x, and zeroes elsewhere
 eye(m,n) % Identity matrix
 linspace(x1, x2, n) % Return n equally spaced points, with min x1 and max x2
 inv(A) % Inverse of matrix A
@@ -452,18 +454,71 @@ flipud(A) % Flip matrix up to down
 [U,S,V] = svd(X) % SVD: XV = US, U and V are unitary matrices, S has non-negative diagonal elements in decreasing order
 
 % Common vector functions
-max     % largest component 
-min     % smallest component 
+max     % largest component
+min     % smallest component
 length  % length of a vector
-sort    % sort in ascending order 
-sum     % sum of elements 
+sort    % sort in ascending order
+sum     % sum of elements
 prod    % product of elements
 mode	% modal value
-median  % median value 
-mean    % mean value 
+median  % median value
+mean    % mean value
 std     % standard deviation
 perms(x) % list all permutations of elements of x
 
+
+% Classes
+% 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
+classdef WaypointClass % The class name.
+  properties % The properties of the class behave like Structures
+    latitude 
+    longitude 
+  end
+  methods 
+    % This method that has the same name of the class is the constructor. 
+    function obj = WaypointClass(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Other functions that use the Waypoint object
+    function r = multiplyLatBy(obj, n)
+      r = n*[obj.latitude];
+    end
+
+    % If we want to add two Waypoint objects together without calling
+    % 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]);
+    end
+  end
+end
+% End WaypointClass.m
+
+% We can create an object of the class using the constructor
+a = WaypointClass(45.0, 45.0)
+
+% Class properties behave exactly like Matlab Structures.
+a.latitude = 70.0
+a.longitude = 25.0
+
+% Methods can be called in the same way as functions
+ans = multiplyLatBy(a,3)
+
+% The method can also be called using dot notation. In this case, the object 
+% does not need to be passed to the method.
+ans = a.multiplyLatBy(a,1/3)
+
+% 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
diff --git a/neat.html.markdown b/neat.html.markdown
index e99d1e0e..f02461ee 100644
--- a/neat.html.markdown
+++ b/neat.html.markdown
@@ -47,18 +47,18 @@ void main(string[] args) {
   // 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;
@@ -139,14 +139,14 @@ void main(string[] args) {
   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.
@@ -156,13 +156,13 @@ void main(string[] args) {
   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) { }
@@ -178,23 +178,23 @@ void main(string[] args) {
     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.
@@ -232,8 +232,8 @@ void main(string[] args) {
   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.
@@ -268,7 +268,7 @@ void main(string[] args) {
   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) {
diff --git a/nim.html.markdown b/nim.html.markdown
index c9548a1c..79271732 100644
--- a/nim.html.markdown
+++ b/nim.html.markdown
@@ -235,7 +235,7 @@ proc ask(question: string): Answer =
     else: echo("Please be clear: yes or no")
 
 proc addSugar(amount: int = 2) = # Default amount is 2, returns nothing
-  assert(amount > 0 or amount < 9000, "Crazy Sugar")
+  assert(amount > 0 and amount < 9000, "Crazy Sugar")
   for a in 1..amount:
     echo(a, " sugar...")
 
diff --git a/nl-nl/brainfuck-nl.html.markdown b/nl-nl/brainfuck-nl.html.markdown
index cd12b1d0..6062b24c 100644
--- a/nl-nl/brainfuck-nl.html.markdown
+++ b/nl-nl/brainfuck-nl.html.markdown
@@ -15,7 +15,7 @@ minimalistische Turing-complete programmeertaal met maar acht commando's.
 ```
 Elk karakter behalve "><+-.,[]" (en de quotes) wordt genegeerd.
 
-Brainfuck wordt gerepresenteerd door een array met 30,000 cellen die initieel
+Brainfuck wordt gerepresenteerd door een array met 30.000 cellen die initieel
 gevuld is met nullen en een pointer die wijst naar de huidige cel.
 
 Dit zijn de acht commando's:
diff --git a/nl-nl/yaml-nl.html.markdown b/nl-nl/yaml-nl.html.markdown
new file mode 100644
index 00000000..a4a9d5fc
--- /dev/null
+++ b/nl-nl/yaml-nl.html.markdown
@@ -0,0 +1,139 @@
+---
+language: yaml
+filename: learnyaml-nl.yaml
+contributors:
+  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+  - ["Niels van Velzen", "https://nielsvanvelzen.me"]
+lang: nl-nl
+---
+
+YAML is een data serialisatie taal ontworpen om snel te kunnen worden begrepen door mensen.
+
+Het is een strikte superset van JSON en bevat nieuwe regels en een stricte manier van inspringen, zoals bij Python. In tegenstelling tot Python kan je alleen geen tab tekens gebruiken.
+
+```yaml
+# Commentaar in YAML ziet er zo uit
+
+################
+# SCALAR TYPES #
+################
+
+# Ons hoofd object (Wat in het hele document gebruikt wordt) is een map,
+# dit staat gelijk aan een dictionary, hash of object in andere talen.
+sleutel: waarde
+nog_een_sleutel: Een andere waarde
+nummer_waarde: 100
+wetenschappelijke_waarde: 1e+12
+boolean_waarde: true
+null_waarde: null
+sleutel met spaties: waarde
+# Merk op dat strings niet verplicht in quotes moeten, maar dit kan wel.
+quote_waarde: "Een string in quotes"
+"Ook sleutels kunnen in quotes": "Dit is bijvoorbeeld handig als je een dubbelepunt wilt gebruiken in je key"
+
+# Tekst over meerdere lijnen kan je schrijven als een 'letterlijk blok' (met |)
+# Of een 'gevouwen blok' (met >)
+letterlijk_blok: |
+    Dit hele blok met tekst is de waarde van de 'letterlijk_blok' sleutel,
+    met nieuwe lijnen behouden.
+
+    Het blok blijft door gaan tot het geeindigd wordt door korter te inspringen.
+
+        Lijnen die groter zijn ingesprongen behouden dit.
+gevouwen_stijl: >
+    Dit blok met tekst zal de waarde zijn van 'gevouwen_stijl',
+    maar deze keer zullen alle nieuwe lijnen worden vervangen met een spatie.
+
+    Lege lijnen, zoals hierboven, zullen worden vertaald naar een nieuwe lijn.
+
+        Meer ingesprongen lijnen zullen hun nieuwe lijnen ook behouden,
+        deze tekst zal over 2 lijnen te zien zijn.
+
+####################
+# COLLECTION TYPES #
+####################
+
+# Nesten wordt bereikt met inspringen.
+geneste_map:
+    sleutel: waarde
+    andere_sleutel: andere waarde
+    andere_geneste_map:
+        hallo: wereld
+
+# In een map is een sleutel niet verplicht om een string te gebruiken
+0.25: een float als sleutel
+
+# Sleutels kunnen ook meerdere lijnen gebruiken met behulp van het vraagteken
+? |
+    Dit is een sleutel
+    met meerdere lijnen
+: en dit is de waarde
+
+# YAML staat ook collection types toe in sleutels, maar veel programmeertalen
+# zullen hierover klagen.
+
+# Sequences (gelijk aan lijsten of arrays) zien er zo uit:
+een_sequence:
+    - Item 1
+    - Item 2
+    - 0.5 # sequences kunnen meerdere type waardes bevatten.
+    - Item 4
+    - sleutel: waarde
+      andere_sleutel: andere waarde
+    -
+        - Dit is een sequence
+        - in een andere sequence
+
+# Doordat YAML een superset van JSON is kan je ook JSON-stijl mappen en
+# sequences maken:
+json_map: {"sleutel": "waarde"}
+json_seq: [3, 2, 1, "takeoff"]
+
+#######################
+# EXTRA YAML FUNCTIES #
+#######################
+
+# YAML heeft ook een handige functie genaamd 'anchors' (ankers), deze laten je
+# makkelijk de waarde van ergens anders in je document kopieëren. Beide sleutels
+# krijgen dezelfde waarde:
+geankert_content: &anker_naam Deze string zal verschijnen als waarde voor de twee sleutels
+andere_anker: *anker_naam
+
+# YAML heeft ook tags, deze gebruik je om een expliciet type te verklaren
+expliciete_string: !!str 0.5
+# Sommige parsers gebruiken taal specifieke tags, zoals deze voor Python's
+# complexe nummer type:
+python_complex_nummer: !!python/complex 1+2j
+
+####################
+# EXTRA YAML TYPES #
+####################
+
+# Strings en nummer zijn niet de enige types die YAML begrijpt.
+# ISO opgemaakte datum en datumtijd notaties werken ook:
+datumtijd: 2001-12-15T02:59:43.1Z
+datumtijd_met_spaties: 2001-12-14 21:59:43.10 -5
+datum: 2002-12-14
+
+# De !!binary tag geeft aan dat de string een base64-gecodeerde
+# binary blob is.
+gif_bestand: !!binary |
+    R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+    OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+    +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+    AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML heeft ook een set type, dat ziet er zo uit:
+set:
+    ? item1
+    ? item2
+    ? item3
+
+# Zoals in Python zijn sets gewoon mappen met null waardes;
+# bovenstaand is gelijk aan:
+set2:
+    item1: null
+    item2: null
+    item3: null
+```
diff --git a/objective-c.html.markdown b/objective-c.html.markdown
index 91b84b47..f130ea0c 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -5,14 +5,15 @@ contributors:
     - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
     - ["Yannick Loriot", "https://github.com/YannickL"]
     - ["Levi Bostian", "https://github.com/levibostian"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
 filename: LearnObjectiveC.m
 
 ---
 
 Objective-C is the main programming language used by Apple for the OS X and iOS operating systems and their respective frameworks, Cocoa and Cocoa Touch.
-It is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. 
+It is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language.
 
-```objective_c
+```objective-c
 // Single-line comments start with //
 
 /*
@@ -40,15 +41,15 @@ int main (int argc, const char * argv[])
 
     // Use NSLog to print lines to the console
     NSLog(@"Hello World!"); // Print the string "Hello World!"
- 
+
     ///////////////////////////////////////
     // Types & Variables
     ///////////////////////////////////////
-    
+
     // Primitive declarations
     int myPrimitive1  = 1;
     long myPrimitive2 = 234554664565;
-    
+
     // Object declarations
     // Put the * in front of the variable names for strongly-typed object declarations
     MyClass *myObject1 = nil;  // Strong typing
@@ -56,15 +57,15 @@ int main (int argc, const char * argv[])
     // %@ is an object
     // 'description' is a convention to display the value of the Objects
     NSLog(@"%@ and %@", myObject1, [myObject2 description]); // prints => "(null) and (null)"
-    
+
     // String
     NSString *worldString = @"World";
-    NSLog(@"Hello %@!", worldString); // prints => "Hello World!" 
+    NSLog(@"Hello %@!", worldString); // prints => "Hello World!"
     // NSMutableString is a mutable version of the NSString object
     NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];
     [mutableString appendString:@" World!"];
     NSLog(@"%@", mutableString); // prints => "Hello World!"
-    
+
     // Character literals
     NSNumber *theLetterZNumber = @'Z';
     char theLetterZ            = [theLetterZNumber charValue]; // or 'Z'
@@ -74,11 +75,11 @@ int main (int argc, const char * argv[])
     NSNumber *fortyTwoNumber = @42;
     int fortyTwo             = [fortyTwoNumber intValue]; // or 42
     NSLog(@"%i", fortyTwo);
-    
+
     NSNumber *fortyTwoUnsignedNumber = @42U;
     unsigned int fortyTwoUnsigned    = [fortyTwoUnsignedNumber unsignedIntValue]; // or 42
     NSLog(@"%u", fortyTwoUnsigned);
-    
+
     NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
     short fortyTwoShort           = [fortyTwoShortNumber shortValue]; // or 42
     NSLog(@"%hi", fortyTwoShort);
@@ -86,7 +87,7 @@ int main (int argc, const char * argv[])
     NSNumber *fortyOneShortNumber   = [NSNumber numberWithShort:41];
     unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // or 41
     NSLog(@"%u", fortyOneUnsigned);
-    
+
     NSNumber *fortyTwoLongNumber = @42L;
     long fortyTwoLong            = [fortyTwoLongNumber longValue]; // or 42
     NSLog(@"%li", fortyTwoLong);
@@ -100,7 +101,7 @@ int main (int argc, const char * argv[])
     float piFloat           = [piFloatNumber floatValue]; // or 3.141592654f
     NSLog(@"%f", piFloat); // prints => 3.141592654
     NSLog(@"%5.2f", piFloat); // prints => " 3.14"
-    
+
     NSNumber *piDoubleNumber = @3.1415926535;
     double piDouble          = [piDoubleNumber doubleValue]; // or 3.1415926535
     NSLog(@"%f", piDouble);
@@ -110,7 +111,7 @@ int main (int argc, const char * argv[])
     NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
     NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
     // NSDecimalNumber isn't able to use standard +, -, *, / operators so it provides its own:
-    [oneDecNum decimalNumberByAdding:twoDecNum]; 
+    [oneDecNum decimalNumberByAdding:twoDecNum];
     [oneDecNum decimalNumberBySubtracting:twoDecNum];
     [oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
     [oneDecNum decimalNumberByDividingBy:twoDecNum];
@@ -129,8 +130,8 @@ int main (int argc, const char * argv[])
     NSArray *anArray      = @[@1, @2, @3, @4];
     NSNumber *thirdNumber = anArray[2];
     NSLog(@"Third number = %@", thirdNumber); // prints => "Third number = 3"
-    // NSMutableArray is a mutable version of NSArray, allowing you to change 
-    // the items in the array and to extend or shrink the array object. 
+    // NSMutableArray is a mutable version of NSArray, allowing you to change
+    // the items in the array and to extend or shrink the array object.
     // Convenient, but not as efficient as NSArray.
     NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
     [mutableArray addObject:@"Hello"];
@@ -147,7 +148,13 @@ int main (int argc, const char * argv[])
     [mutableDictionary setObject:@"value1" forKey:@"key1"];
     [mutableDictionary setObject:@"value2" forKey:@"key2"];
     [mutableDictionary removeObjectForKey:@"key1"];
-
+    
+    // Change types from Mutable To Immutable
+    //In general [object mutableCopy] will make the object mutable whereas [object copy] will make the object immutable
+    NSMutableDictionary *aMutableDictionary = [aDictionary mutableCopy];
+    NSDictionary *mutableDictionaryChanged = [mutableDictionary copy];
+    
+    
     // Set object
     NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
     NSLog(@"%@", set); // prints => {(Hello, World)} (may be in different order)
@@ -160,7 +167,7 @@ int main (int argc, const char * argv[])
     ///////////////////////////////////////
     // Operators
     ///////////////////////////////////////
-    
+
     // The operators works like in the C language
     // For example:
     2 + 5; // => 7
@@ -205,13 +212,13 @@ int main (int argc, const char * argv[])
             NSLog(@"I print");
         } break;
     }
-    
+
     // While loops statements
     int ii = 0;
     while (ii < 4)
     {
         NSLog(@"%d,", ii++); // ii++ increments ii in-place, after using its value
-    } // prints => "0," 
+    } // prints => "0,"
       //           "1,"
       //           "2,"
       //           "3,"
@@ -221,25 +228,25 @@ int main (int argc, const char * argv[])
     for (jj=0; jj < 4; jj++)
     {
         NSLog(@"%d,", jj);
-    } // prints => "0," 
+    } // prints => "0,"
       //           "1,"
       //           "2,"
       //           "3,"
-     
-    // Foreach statements             
+
+    // Foreach statements
     NSArray *values = @[@0, @1, @2, @3];
     for (NSNumber *value in values)
     {
         NSLog(@"%@,", value);
-    } // prints => "0," 
+    } // prints => "0,"
       //           "1,"
       //           "2,"
       //           "3,"
 
     // Object for loop statement. Can be used with any Objective-C object type
-    for (id item in values) { 
-        NSLog(@"%@,", item); 
-    } // prints => "0," 
+    for (id item in values) {
+        NSLog(@"%@,", item);
+    } // prints => "0,"
       //           "1,"
       //           "2,"
       //           "3,"
@@ -250,7 +257,7 @@ int main (int argc, const char * argv[])
         // Your statements here
         @throw [NSException exceptionWithName:@"FileNotFoundException"
                             reason:@"File Not Found on System" userInfo:nil];
-    } @catch (NSException * e) // use: @catch (id exceptionName) to catch all objects. 
+    } @catch (NSException * e) // use: @catch (id exceptionName) to catch all objects.
     {
         NSLog(@"Exception: %@", e);
     } @finally
@@ -259,17 +266,17 @@ int main (int argc, const char * argv[])
     } // prints => "Exception: File Not Found on System"
       //           "Finally. Time to clean up."
 
-    // NSError objects are useful for function arguments to populate on user mistakes. 
+    // NSError objects are useful for function arguments to populate on user mistakes.
     NSError *error = [NSError errorWithDomain:@"Invalid email." code:4 userInfo:nil];
- 
+
     ///////////////////////////////////////
     // Objects
     ///////////////////////////////////////
-    
+
     // Create an object instance by allocating memory and initializing it
     // An object is not fully functional until both steps have been completed
     MyClass *myObject = [[MyClass alloc] init];
-        
+
     // The Objective-C model of object-oriented programming is based on message
     // passing to object instances
     // In Objective-C one does not simply call a method; one sends a message
@@ -280,7 +287,7 @@ int main (int argc, const char * argv[])
 
     // End of @autoreleasepool
     }
-    
+
     // End the program
     return 0;
 }
@@ -301,9 +308,9 @@ int main (int argc, const char * argv[])
 @interface MyClass : NSObject <MyProtocol> // NSObject is Objective-C's base object class.
 {
     // Instance variable declarations (can exist in either interface or implementation file)
-    int count; // Protected access by default. 
+    int count; // Protected access by default.
     @private id data; // Private access (More convenient to declare in implementation file)
-    NSString *name; 
+    NSString *name;
 }
 // Convenient notation for public access variables to auto generate a setter method
 // By default, setter method name is 'set' followed by @property variable name
@@ -313,7 +320,7 @@ int main (int argc, const char * argv[])
 @property (readonly) NSString *roString; // Use @synthesize in @implementation to create accessor
 // You can customize the getter and setter names instead of using default 'set' name:
 @property (getter=lengthGet, setter=lengthSet:) int length;
- 
+
 // Methods
 +/- (return type)methodSignature:(Parameter Type *)parameterName;
 
@@ -335,7 +342,7 @@ int main (int argc, const char * argv[])
 // To access public variables from the implementation file, @property generates a setter method
 // automatically. Method name is 'set' followed by @property variable name:
 MyClass *myClass = [[MyClass alloc] init]; // create MyClass object instance
-[myClass setCount:10]; 
+[myClass setCount:10];
 NSLog(@"%d", [myClass count]); // prints => 10
 // Or using the custom getter and setter method defined in @interface:
 [myClass lengthSet:32];
@@ -358,7 +365,7 @@ NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Hell
 // as a variable
 // SEL is the data type. @selector() returns a selector from method name provided
 // methodAParameterAsString:andAParameterAsNumber: is method name for method in MyClass
-SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:); 
+SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:);
 if ([myClass respondsToSelector:selectorVar]) { // Checks if class contains method
     // Must put all method arguments into one object to send to performSelector function
     NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
@@ -382,7 +389,7 @@ distance = 18; // References "long distance" from MyClass implementation
 @synthesize roString = _roString; // _roString available now in @implementation
 
 // Called before calling any class methods or instantiating any objects
-+ (void)initialize 
++ (void)initialize
 {
     if (self == [MyClass class]) {
         distance = 0;
@@ -392,7 +399,7 @@ distance = 18; // References "long distance" from MyClass implementation
 // Counterpart to initialize method. Called when an object's reference count is zero
 - (void)dealloc
 {
-    [height release]; // If not using ARC, make sure to release class variable objects 
+    [height release]; // If not using ARC, make sure to release class variable objects
     [super dealloc];  // and call parent class dealloc
 }
 
@@ -407,7 +414,7 @@ distance = 18; // References "long distance" from MyClass implementation
     return self;
 }
 // Can create constructors that contain arguments:
-- (id)initWithDistance:(int)defaultDistance 
+- (id)initWithDistance:(int)defaultDistance
 {
     distance = defaultDistance;
     return self;
@@ -418,7 +425,7 @@ distance = 18; // References "long distance" from MyClass implementation
     return @"Some string";
 }
 
-+ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight 
++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight
 {
     height = defaultHeight;
     return [[self alloc] init];
@@ -434,7 +441,7 @@ distance = 18; // References "long distance" from MyClass implementation
     return @42;
 }
 
-// Objective-C does not have private method declarations, but you can simulate them. 
+// Objective-C does not have private method declarations, but you can simulate them.
 // To simulate a private method, create the method in the @implementation but not in the @interface.
 - (NSNumber *)secretPrivateMethod {
     return @72;
@@ -453,15 +460,15 @@ distance = 18; // References "long distance" from MyClass implementation
 // Categories
 ///////////////////////////////////////
 // A category is a group of methods designed to extend a class. They allow you to add new methods
-// to an existing class for organizational purposes. This is not to be mistaken with subclasses. 
-// Subclasses are meant to CHANGE functionality of an object while categories instead ADD 
+// to an existing class for organizational purposes. This is not to be mistaken with subclasses.
+// Subclasses are meant to CHANGE functionality of an object while categories instead ADD
 // functionality to an object.
 // Categories allow you to:
 // -- Add methods to an existing class for organizational purposes.
 // -- Allow you to extend Objective-C object classes (ex: NSString) to add your own methods.
-// -- Add ability to create protected and private methods to classes. 
-// NOTE: Do not override methods of the base class in a category even though you have the ability 
-// to. Overriding methods may cause compiler errors later between different categories and it 
+// -- Add ability to create protected and private methods to classes.
+// NOTE: Do not override methods of the base class in a category even though you have the ability
+// to. Overriding methods may cause compiler errors later between different categories and it
 // ruins the purpose of categories to only ADD functionality. Subclass instead to override methods.
 
 // Here is a simple Car base class.
@@ -493,8 +500,8 @@ distance = 18; // References "long distance" from MyClass implementation
 @end
 
 // Now, if we wanted to create a Truck object, we would instead create a subclass of Car as it would
-// be changing the functionality of the Car to behave like a truck. But lets say we want to just add 
-// functionality to this existing Car. A good example would be to clean the car. So we would create 
+// be changing the functionality of the Car to behave like a truck. But lets say we want to just add
+// functionality to this existing Car. A good example would be to clean the car. So we would create
 // a category to add these cleaning methods:
 // @interface filename: Car+Clean.h (BaseClassName+CategoryName.h)
 #import "Car.h" // Make sure to import base class to extend.
@@ -518,7 +525,7 @@ distance = 18; // References "long distance" from MyClass implementation
     NSLog(@"Waxed.");
 }
 
-@end 
+@end
 
 // Any Car object instance has the ability to use a category. All they need to do is import it:
 #import "Car+Clean.h" // Import as many different categories as you want to use.
@@ -533,7 +540,7 @@ int main (int argc, const char * argv[]) {
         [mustang turnOn]; // Use methods from base Car class.
         [mustang washWindows]; // Use methods from Car's Clean category.
     }
-    return 0; 
+    return 0;
 }
 
 // Objective-C does not have protected method declarations but you can simulate them.
@@ -547,7 +554,7 @@ int main (int argc, const char * argv[]) {
 //To use protected methods, import the category, then implement the methods:
 #import "Car+Protected.h" // Remember, import in the @implementation file only.
 
-@implementation Car 
+@implementation Car
 
 - (void)lockCar {
     NSLog(@"Car locked."); // Instances of Car can't use lockCar because it's not in the @interface.
@@ -570,8 +577,8 @@ int main (int argc, const char * argv[]) {
 // You can override numOfSides variable or getNumOfSides method to edit them with an extension:
 // @implementation filename: Shape.m
 #import "Shape.h"
-// Extensions live in the same file as the class @implementation. 
-@interface Shape () // () after base class name declares an extension.  
+// Extensions live in the same file as the class @implementation.
+@interface Shape () // () after base class name declares an extension.
 
 @property (copy) NSNumber *numOfSides; // Make numOfSides copy instead of readonly.
 -(NSNumber)getNumOfSides; // Make getNumOfSides return a NSNumber instead of an int.
@@ -579,7 +586,7 @@ int main (int argc, const char * argv[]) {
 
 @end
 // The main @implementation:
-@implementation Shape 
+@implementation Shape
 
 @synthesize numOfSides = _numOfSides;
 
@@ -603,14 +610,14 @@ int main (int argc, const char * argv[]) {
     @property BOOL engineOn; // Adopting class must @synthesize all defined @properties and
     - (void)turnOnEngine; // all defined methods.
 @end
-// Below is an example class implementing the protocol. 
+// Below is an example class implementing the protocol.
 #import "CarUtilities.h" // Import the @protocol file.
 
 @interface Car : NSObject <CarUtilities> // Name of protocol goes inside <>
     // You don't need the @property or method names here for CarUtilities. Only @implementation does.
 - (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // You can use protocols as data too.
 @end
-// The @implementation needs to implement the @properties and methods for the protocol. 
+// The @implementation needs to implement the @properties and methods for the protocol.
 @implementation Car : NSObject <CarUtilities>
 
 @synthesize engineOn = _engineOn; // Create a @synthesize statement for the engineOn @property.
@@ -619,14 +626,14 @@ int main (int argc, const char * argv[]) {
     _engineOn = YES; // how you implement a method, it just requires that you do implement it.
 }
 // You may use a protocol as data as you know what methods and variables it has implemented.
-- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind { 
+- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind {
     [objectOfSomeKind engineOn]; // You have access to object variables
-    [objectOfSomeKind turnOnEngine]; // and the methods inside. 
+    [objectOfSomeKind turnOnEngine]; // and the methods inside.
     [objectOfSomeKind engineOn]; // May or may not be YES. Class implements it however it wants.
 }
 
 @end
-// Instances of Car now have access to the protocol. 
+// Instances of Car now have access to the protocol.
 Car *carInstance = [[Car alloc] init];
 [carInstance setEngineOn:NO];
 [carInstance turnOnEngine];
@@ -655,10 +662,10 @@ if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
 // See the problem is that Sister relies on Brother, and Brother relies on Sister.
 #import "Sister.h"
 
-@protocol Sister; // These lines stop the recursion, resolving the issue. 
+@protocol Sister; // These lines stop the recursion, resolving the issue.
 
 @protocol Brother <NSObject>
- 
+
 - (void)beNiceToSister:(id <Sister>)sister;
 
 @end
@@ -667,24 +674,24 @@ if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
 ///////////////////////////////////////
 // Blocks
 ///////////////////////////////////////
-// Blocks are statements of code, just like a function, that are able to be used as data. 
+// Blocks are statements of code, just like a function, that are able to be used as data.
 // Below is a simple block with an integer argument that returns the argument plus 4.
-int (^addUp)(int n); // Declare a variable to store the block. 
-void (^noParameterBlockVar)(void); // Example variable declaration of block with no arguments. 
+int (^addUp)(int n); // Declare a variable to store the block.
+void (^noParameterBlockVar)(void); // Example variable declaration of block with no arguments.
 // Blocks have access to variables in the same scope. But the variables are readonly and the
-// value passed to the block is the value of the variable when the block is created. 
+// value passed to the block is the value of the variable when the block is created.
 int outsideVar = 17; // If we edit outsideVar after declaring addUp, outsideVar is STILL 17.
 __block long mutableVar = 3; // __block makes variables writable to blocks, unlike outsideVar.
-addUp = ^(int n) { // Remove (int n) to have a block that doesn't take in any parameters. 
+addUp = ^(int n) { // Remove (int n) to have a block that doesn't take in any parameters.
     NSLog(@"You may have as many lines in a block as you would like.");
     NSSet *blockSet; // Also, you can declare local variables.
     mutableVar = 32; // Assigning new value to __block variable.
-    return n + outsideVar; // Return statements are optional. 
+    return n + outsideVar; // Return statements are optional.
 }
-int addUp = add(10 + 16); // Calls block code with arguments. 
+int addUp = addUp(10 + 16); // Calls block code with arguments.
 // Blocks are often used as arguments to functions to be called later, or for callbacks.
-@implementation BlockExample : NSObject 
- 
+@implementation BlockExample : NSObject
+
  - (void)runBlock:(void (^)(NSString))block {
     NSLog(@"Block argument returns nothing and takes in a NSString object.");
     block(@"Argument given to block to execute."); // Calling block.
@@ -696,19 +703,19 @@ int addUp = add(10 + 16); // Calls block code with arguments.
 ///////////////////////////////////////
 // Memory Management
 ///////////////////////////////////////
-/* 
+/*
 For each object used in an application, memory must be allocated for that object. When the application
-is done using that object, memory must be deallocated to ensure application efficiency. 
-Objective-C does not use garbage collection and instead uses reference counting. As long as 
+is done using that object, memory must be deallocated to ensure application efficiency.
+Objective-C does not use garbage collection and instead uses reference counting. As long as
 there is at least one reference to an object (also called "owning" an object), then the object
-will be available to use (known as "ownership"). 
+will be available to use (known as "ownership").
 
 When an instance owns an object, its reference counter is increments by one. When the
 object is released, the reference counter decrements by one. When reference count is zero,
-the object is removed from memory. 
+the object is removed from memory.
 
-With all object interactions, follow the pattern of: 
-(1) create the object, (2) use the object, (3) then free the object from memory. 
+With all object interactions, follow the pattern of:
+(1) create the object, (2) use the object, (3) then free the object from memory.
 */
 
 MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object
@@ -723,11 +730,11 @@ MyClass *newVar = [classVar retain]; // If classVar is released, object is still
 
 // Automatic Reference Counting (ARC)
 // Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC).
-// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC, 
+// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC,
 // you must not use retain, relase, or autorelease
-MyClass *arcMyClass = [[MyClass alloc] init]; 
+MyClass *arcMyClass = [[MyClass alloc] init];
 // ... code using arcMyClass
-// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC, 
+// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC,
 // there is no need. It will insert this release statement for you
 
 // As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong'
@@ -747,4 +754,8 @@ __unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not se
 
 [Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
 
+[Programming with Objective-C for iOS](https://developer.apple.com/library/ios/documentation/General/Conceptual/DevPedia-CocoaCore/ObjectiveC.html)
+
+[Programming with Objective-C for Mac OSX](https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html)
+
 [iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
diff --git a/ocaml.html.markdown b/ocaml.html.markdown
index b0027fea..8faab297 100644
--- a/ocaml.html.markdown
+++ b/ocaml.html.markdown
@@ -34,13 +34,13 @@ For a source file you can use "ocamlc -i /path/to/file.ml" command
 to print all names and type signatures.
 
 ```
-$ cat sigtest.ml 
+$ cat sigtest.ml
 let inc x = x + 1
 let add x y = x + y
 
-let a = 1 
+let a = 1
 
-$ ocamlc -i ./sigtest.ml 
+$ ocamlc -i ./sigtest.ml
 val inc : int -> int
 val add : int -> int -> int
 val a : int
@@ -104,7 +104,7 @@ let fact_4 = factorial (5-1) ;;
 let sqr2 = sqr (-2) ;;
 
 (* Every function must have at least one argument.
-   Since some funcions naturally don't take any arguments, there's 
+   Since some funcions naturally don't take any arguments, there's
    "unit" type for it that has the only one value written as "()" *)
 let print_hello () = print_endline "hello world" ;;
 
@@ -196,7 +196,7 @@ let (~/) x = 1.0 /. x ;;
 ~/4.0 (* = 0.25 *)
 
 
-(*** Built-in datastructures ***)
+(*** Built-in data structures ***)
 
 (* Lists are enclosed in square brackets, items are separated by
    semicolons. *)
@@ -301,7 +301,7 @@ let l = IntList (1, EmptyList) ;;
 (* Pattern matching is somewhat similar to switch statement in imperative
    languages, but offers a lot more expressive power.
 
-   Even though it may look complicated, it really boils down to matching 
+   Even though it may look complicated, it really boils down to matching
    an argument against an exact value, a predicate, or a type constructor.
    The type system is what makes it so powerful. *)
 
@@ -320,7 +320,7 @@ let is_one = function
 ;;
 
 (* Matching predicates, aka "guarded pattern matching". *)
-let abs x = 
+let abs x =
     match x with
     | x when x < 0 -> -x
     | _ -> x
@@ -341,10 +341,10 @@ let say x =
 
 say (Cat "Fluffy") ;; (* "Fluffy says meow". *)
 
-(** Traversing datastructures with pattern matching **)
+(** Traversing data structures with pattern matching **)
 
 (* Recursive types can be traversed with pattern matching easily.
-   Let's see how we can traverse a datastructure of the built-in list type.
+   Let's see how we can traverse a data structure of the built-in list type.
    Even though the built-in cons ("::") looks like an infix operator,
    it's actually a type constructor and can be matched like any other. *)
 let rec sum_list l =
diff --git a/perl.html.markdown b/perl.html.markdown
index 4e172406..1b86f410 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -102,6 +102,8 @@ for (@elements) {
   print;
 }
 
+# the Perlish post-condition way again
+print for @elements;
 
 #### Regular expressions
 
diff --git a/perl6.html.markdown b/perl6.html.markdown
index 8d425f7d..45b15f05 100644
--- a/perl6.html.markdown
+++ b/perl6.html.markdown
@@ -7,13 +7,11 @@ contributors:
     - ["Nami-Doc", "http://github.com/Nami-Doc"]
 ---
 
-Perl 6 is a highly capable, feature-rich programming language made for at 
+Perl 6 is a highly capable, feature-rich programming language made for at
 least the next hundred years.
 
 The primary Perl 6 compiler is called [Rakudo](http://rakudo.org), which runs on
-the JVM and [the MoarVM](http://moarvm.com) and 
-[prior to March 2015](http://pmthium.com/2015/02/suspending-rakudo-parrot/),
-[the Parrot VM](http://parrot.org/).
+the JVM and [the MoarVM](http://moarvm.com).
 
 Meta-note : the triple pound signs are here to denote headlines,
 double paragraphs, and single notes.
@@ -75,7 +73,7 @@ say @array; #=> a 6 b
 #  except they get "flattened" (hash context), removing duplicated keys.
 my %hash = 1 => 2,
            3 => 4;
-my %hash = autoquoted => "key", # keys get auto-quoted
+my %hash = foo => "bar", # keys get auto-quoted
             "some other" => "value", # trailing commas are okay
             ;
 my %hash = <key1 value1 key2 value2>; # you can also create a hash
@@ -96,7 +94,6 @@ say %hash<key2>;   # If it's a string, you can actually use <>
                    # (`{key1}` doesn't work, as Perl6 doesn't have barewords)
 
 ## * Subs (subroutines, or functions in most other languages).
-# Stored in variable, they use `&`.
 sub say-hello { say "Hello, world" }
 
 sub say-hello-to(Str $name) { # You can provide the type of an argument
@@ -107,8 +104,8 @@ sub say-hello-to(Str $name) { # You can provide the type of an argument
 
 ## It can also have optional arguments:
 sub with-optional($arg?) { # the "?" marks the argument optional
-  say "I might return `(Any)` if I don't have an argument passed,
-      or I'll return my argument";
+  say "I might return `(Any)` (Perl's "null"-like value) if I don't have
+        an argument passed, or I'll return my argument";
   $arg;
 }
 with-optional; # returns Any
@@ -125,14 +122,14 @@ hello-to('You'); #=> Hello, You !
 
 ## You can also, by using a syntax akin to the one of hashes (yay unified syntax !),
 ##  pass *named* arguments to a `sub`.
-# They're optional, and will default to "Any" (Perl's "null"-like value).
+# They're optional, and will default to "Any".
 sub with-named($normal-arg, :$named) {
   say $normal-arg + $named;
 }
 with-named(1, named => 6); #=> 7
 # There's one gotcha to be aware of, here:
 # If you quote your key, Perl 6 won't be able to see it at compile time,
-#  and you'll have a single Pair object as a positional paramater,
+#  and you'll have a single Pair object as a positional parameter,
 #  which means this fails:
 with-named(1, 'named' => 6);
 
@@ -143,7 +140,7 @@ sub with-mandatory-named(:$str!)  {
   say "$str !";
 }
 with-mandatory-named(str => "My String"); #=> My String !
-with-mandatory-named; # run time error: "Required named parameter not passed" 
+with-mandatory-named; # run time error: "Required named parameter not passed"
 with-mandatory-named(3); # run time error: "Too many positional parameters passed"
 
 ## If a sub takes a named boolean argument ...
@@ -162,7 +159,7 @@ named-def; #=> 5
 named-def(def => 15); #=> 15
 
 # Since you can omit parenthesis to call a function with no arguments,
-#  you need "&" in the name to capture `say-hello`.
+#  you need "&" in the name to store `say-hello` in a variable.
 my &s = &say-hello;
 my &other-s = sub { say "Anonymous function !" }
 
@@ -173,8 +170,8 @@ sub as-many($head, *@rest) { # `*@` (slurpy) will basically "take everything els
   say @rest.join(' / ') ~ " !";
 }
 say as-many('Happy', 'Happy', 'Birthday'); #=> Happy / Birthday !
-                                           # Note that the splat did not consume
-                                           #  the parameter before.
+                                           # Note that the splat (the *) did not
+                                           # consume the parameter before.
 
 ## You can call a function with an array using the
 # "argument list flattening" operator `|`
@@ -197,7 +194,7 @@ sub mutate($n is rw) {
   say "\$n is now $n !";
 }
 
-# If what you want is a copy instead, use `is copy`.
+# If what you want a copy instead, use `is copy`.
 
 # A sub itself returns a container, which means it can be marked as rw:
 my $x = 42;
@@ -234,7 +231,7 @@ say "Quite truthy" if True;
 # - Ternary conditional, "?? !!" (like `x ? y : z` in some other languages)
 my $a = $condition ?? $value-if-true !! $value-if-false;
 
-# - `given`-`when` looks like other languages `switch`, but much more
+# - `given`-`when` looks like other languages' `switch`, but much more
 # powerful thanks to smart matching and thanks to Perl 6's "topic variable", $_.
 #
 # This variable contains the default argument of a block,
@@ -290,7 +287,7 @@ for @array -> $variable {
 # That means you can use `when` in a `for` just like you were in a `given`.
 for @array {
   say "I've got $_";
-  
+
   .say; # This is also allowed.
         # A dot call with no "topic" (receiver) is sent to `$_` by default
   $_.say; # the above and this are equivalent.
@@ -378,9 +375,11 @@ say join(' ', @array[15..*]); #=> 15 16 17 18 19
 # which is equivalent to:
 say join(' ', @array[-> $n { 15..$n }]);
 
-# You can use that in most places you'd expect, even assigning to an array  
-my @numbers = ^20;  
-my @seq =  3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99
+# You can use that in most places you'd expect, even assigning to an array
+my @numbers = ^20;
+
+# Here numbers increase by "6"; more on `...` operator later.
+my @seq =  3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99;
 @numbers[5..*] = 3, 9 ... *; # even though the sequence is infinite,
                              # only the 15 needed values will be calculated.
 say @numbers; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87
@@ -525,7 +524,7 @@ map(sub ($a, $b) { $a + $b + 3 }, @array); # (here with `sub`)
 # The constructs for declaring types are "class", "role",
 #  which you'll see later.
 
-# For now, let us examinate "subset":
+# For now, let us examine "subset":
 # a "subset" 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),
@@ -608,40 +607,39 @@ sub foo {
   bar(); # call `bar` in-place
 }
 sub bar {
-  say $*foo; # `$*a` will be looked in the call stack, and find `foo`'s,
+  say $*foo; # `$*foo` will be looked in the call stack, and find `foo`'s,
              #  even though the blocks aren't nested (they're call-nested).
              #=> 1
 }
 
 ### Object Model
 
-## Perl 6 has a quite comprehensive object model
 # You declare a class with the keyword `class`, fields with `has`,
-# methods with `method`. Every field to private, and is named `$!attr`,
-# but you have `$.` to get a public (immutable) accessor along with it.
-# (using `$.` is like using `$!` plus a `method` with the same name)
+# methods with `method`. Every attribute that is private is named `$!attr`.
+# Immutable public attributes are named `$.attr`
+#   (you can make them mutable with `is rw`)
 
-# (Perl 6's object model ("SixModel") is very flexible,
+# Perl 6's object model ("SixModel") is very flexible,
 # and allows you to dynamically add methods, change semantics, etc ...
 # (this will not be covered here, and you should refer to the Synopsis).
 
 class A {
   has $.field; # `$.field` is immutable.
                # From inside the class, use `$!field` to modify it.
-  has $.other-field is rw; # You can obviously mark a public field `rw`.
+  has $.other-field is rw; # You can mark a public attribute `rw`.
   has Int $!private-field = 10;
 
   method get-value {
     $.field + $!private-field;
   }
-  
+
   method set-value($n) {
     # $.field = $n; # As stated before, you can't use the `$.` immutable version.
     $!field = $n;   # This works, because `$!` is always mutable.
-    
+
     $.other-field = 5; # This works, because `$.other-field` is `rw`.
   }
-  
+
   method !private-method {
     say "This method is private to the class !";
   }
@@ -656,23 +654,22 @@ $a.other-field = 10; # This, however, works, because the public field
                      #  is mutable (`rw`).
 
 ## Perl 6 also has inheritance (along with multiple inheritance)
-# (though considered a misfeature by many)
 
 class A {
   has $.val;
-  
+
   submethod not-inherited {
     say "This method won't be available on B.";
     say "This is most useful for BUILD, which we'll see later";
   }
-  
+
   method bar { $.val * 5 }
 }
 class B is A { # inheritance uses `is`
   method foo {
     say $.val;
   }
-  
+
   method bar { $.val * 10 } # this shadows A's `bar`
 }
 
@@ -699,20 +696,20 @@ role PrintableVal {
 # you "import" a mixin (a "role") with "does":
 class Item does PrintableVal {
   has $.val;
-  
+
   # When `does`-ed, a `role` literally "mixes in" the class:
   #  the methods and fields are put together, which means a class can access
   #  the private fields/methods of its roles (but not the inverse !):
   method access {
     say $!counter++;
   }
-  
+
   # However, this:
   # method print {}
   # is ONLY valid when `print` isn't a `multi` with the same dispatch.
   # (this means a parent class can shadow a child class's `multi print() {}`,
   #  but it's an error if a role does)
-  
+
   # NOTE: You can use a role as a class (with `is ROLE`). In this case, methods
   # will be shadowed, since the compiler will consider `ROLE` to be a class.
 }
@@ -751,7 +748,7 @@ fail "foo"; # We're not trying to access the value, so no problem.
 try {
   fail "foo";
   CATCH {
-    default { say "It threw because we try to get the fail's value!" }
+    default { say "It threw because we tried to get the fail's value!" }
   }
 }
 
@@ -763,7 +760,7 @@ try {
 ### Packages
 # 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 denomitor)
+#  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 usually don't use packages directly: you use `class Package::Name::Here;`,
@@ -773,7 +770,7 @@ module Hello::World { # Bracketed form
                       #  that can be redeclared as something else later.
   # ... declarations here ...
 }
-module Parse::Text; # file-scoped form
+unit module Parse::Text; # file-scoped form
 grammar Parse::Text::Grammar { # A grammar is a package, which you could `use`
 }
 
@@ -797,10 +794,8 @@ my $actions = JSON::Tiny::Actions.new;
 # You've already seen `my` and `has`, we'll now explore the others.
 
 ## * `our` (happens at `INIT` time -- see "Phasers" below)
-# Along with `my`, there are several others declarators you can use.
-# The first one you'll want for the previous part is `our`.
+# It's like `my`, but it also creates a package variable.
 # (All packagish things (`class`, `role`, etc) are `our` by default)
-# it's like `my`, but it also creates a package variable:
 module Foo::Bar {
   our $n = 1; # note: you can't put a type constraint on an `our` variable
   our sub inc {
@@ -812,7 +807,7 @@ module Foo::Bar {
       say "Can't access me from outside, I'm my !";
     }
   }
-  
+
   say ++$n; # lexically-scoped variables are still available
 }
 say $Foo::Bar::n; #=> 1
@@ -829,7 +824,7 @@ constant why-not = 5, 15 ... *;
 say why-not[^5]; #=> 5 15 25 35 45
 
 ## * `state` (happens at run time, but only once)
-# State variables are only executed one time
+# State variables are only initialized one time
 # (they exist in other langages such as C as `static`)
 sub fixed-rand {
   state $val = rand;
@@ -862,7 +857,7 @@ for ^5 -> $a {
 
 ## * Compile-time phasers
 BEGIN { say "[*] Runs at compile time, as soon as possible, only once" }
-CHECK { say "[*] Runs at compile time, instead as late as possible, only once" }
+CHECK { say "[*] Runs at compile time, as late as possible, only once" }
 
 ## * Run-time phasers
 INIT { say "[*] Runs at run time, as soon as possible, only once" }
@@ -870,10 +865,13 @@ END { say "Runs at run time, as late as possible, only once" }
 
 ## * Block phasers
 ENTER { say "[*] Runs everytime you enter a block, repeats on loop blocks" }
-LEAVE { say "Runs everytime you leave a block, even when an exception happened. Repeats on loop blocks." }
+LEAVE { say "Runs everytime you leave a block, even when an exception
+    happened. Repeats on loop blocks." }
 
-PRE { say "Asserts a precondition at every block entry, before ENTER (especially useful for loops)" }
-POST { say "Asserts a postcondition at every block exit, after LEAVE (especially useful for loops)" }
+PRE { say "Asserts a precondition at every block entry,
+    before ENTER (especially useful for loops)" }
+POST { say "Asserts a postcondition at every block exit,
+    after LEAVE (especially useful for loops)" }
 
 ## * Block/exceptions phasers
 sub {
@@ -891,12 +889,12 @@ for ^5 {
 ## * Role/class phasers
 COMPOSE { "When a role is composed into a class. /!\ NOT YET IMPLEMENTED" }
 
-# They allow for cute trick or clever code ...:
-say "This code took " ~ (time - CHECK time) ~ "s to run";
+# They allow for cute tricks or clever code ...:
+say "This code took " ~ (time - CHECK time) ~ "s to compile";
 
 # ... or clever organization:
 sub do-db-stuff {
-  ENTER $db.start-transaction; # New transaction everytime we enter the sub
+  $db.start-transaction; # start a new transaction
   KEEP $db.commit; # commit the transaction if all went well
   UNDO $db.rollback; # or rollback if all hell broke loose
 }
@@ -1020,7 +1018,7 @@ sub circumfix:<[ ]>(Int $n) {
   $n ** $n
 }
 say [5]; #=> 3125
-         # circumfix is around. Again, not whitespace.
+         # circumfix is around. Again, no whitespace.
 
 sub postcircumfix:<{ }>(Str $s, Int $idx) {
   # post-circumfix is
@@ -1052,9 +1050,9 @@ postcircumfix:<{ }>(%h, $key, :delete); # (you can call operators like that)
 # Basically, they're operators that apply another operator.
 
 ## * Reduce meta-operator
-# It's a prefix meta-operator that takes a binary functions and
+# It's a prefix meta-operator that takes a binary function and
 #  one or many lists. If it doesn't get passed any argument,
-#  it either return a "default value" for this operator
+#  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
@@ -1075,8 +1073,8 @@ say [//] Nil, Any, False, 1, 5; #=> False
 
 
 # Default value examples:
-say [*] (); #=> 1 
-say [+] (); #=> 0 
+say [*] (); #=> 1
+say [+] (); #=> 0
             # meaningless values, since N*1=N and N+0=N.
 say [//];   #=> (Any)
             # There's no "default value" for `//`.
@@ -1089,7 +1087,7 @@ say [[&add]] 1, 2, 3; #=> 6
 # This one is an infix meta-operator than also can be used as a "normal" operator.
 # It takes an optional binary function (by default, it just creates a pair),
 #  and will pop one value off of each array and call its binary function on these
-#  until it runs out of elements. It runs the an array with all these new elements.
+#  until it runs out of elements. It returns an array with all of these new elements.
 (1, 2) Z (3, 4); # ((1, 3), (2, 4)), since by default, the function makes an array
 1..3 Z+ 4..6; # (5, 7, 9), using the custom infix:<+> function
 
@@ -1109,8 +1107,7 @@ say [[&add]] 1, 2, 3; #=> 6
 #  (and might include a closure), and on the right, a value or the predicate
 #  that says when to stop (or Whatever for a lazy infinite list).
 my @list = 1, 2, 3 ... 10; # basic deducing
-#my @list = 1, 3, 6 ... 10; # this throws you into an infinite loop,
-                            #  because Perl 6 can't figure out the end
+#my @list = 1, 3, 6 ... 10; # this dies because Perl 6 can't figure out the end
 my @list = 1, 2, 3 ...^ 10; # as with ranges, you can exclude the last element
                             # (the iteration when the predicate matches).
 my @list = 1, 3, 9 ... * > 30; # you can use a predicate
@@ -1222,7 +1219,7 @@ so 'abbbbbbc' ~~ / a b ** 3..* c /; # `True` (infinite ranges are okay)
 #  they use a more perl6-ish syntax:
 say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa'
 # You can use ranges:
-say 'aeiou' ~~ / a <[ e..w ]> /; #=> 'aeiou'
+say 'aeiou' ~~ / a <[ e..w ]> /; #=> 'ae'
 # Just like in normal regexes, if you want to use a special character, escape it
 #  (the last one is escaping a space)
 say 'he-he !' ~~ / 'he-' <[ a..z \! \  ]> + /; #=> 'he-he !'
@@ -1244,7 +1241,7 @@ so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (the + doesn't replace the left
 so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing
 so 'fooABCABCbar' ~~ / foo [ A B C ] + bar /;
 # The previous line returns `True`.
-# We match the "abc" 1 or more time (the `+` was applied to the group).
+# We match the "ABC" 1 or more time (the `+` was applied to the group).
 
 # But this does not go far enough, because we can't actually get back what
 #  we matched.
@@ -1287,10 +1284,12 @@ say $/[0][0].Str; #=> ~
 
 # 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)
+#  (but you can also just use `match<key>` for hash access
+#    and `match[idx]` for array access)
 say $/[0].list.perl; #=> (Match.new(...),).list
-                     # We can see it's a list of Match objects. Those contain a bunch of infos:
-                     # where the match started/ended, the "ast" (see actions later), etc.
+                     # We can see it's a list of Match objects. Those contain
+                     # a bunch of infos: where the match started/ended,
+                     #    the "ast" (see actions later), etc.
                      # You'll see named capture below with grammars.
 
 ## Alternatives - the `or` of regexps
@@ -1328,14 +1327,14 @@ so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ...
 
 ### Extra: the MAIN subroutime
 # The `MAIN` subroutine is called when you run a Perl 6 file directly.
-# It's very powerful, because Perl 6 actually parses the argument
+# It's very powerful, because Perl 6 actually parses the arguments
 #  and pass them as such to the sub. It also handles named argument (`--foo`)
 #  and will even go as far as to autogenerate a `--help`
 sub MAIN($name) { say "Hello, $name !" }
 # This produces:
 #    $ perl6 cli.pl
 #    Usage:
-#      t.pl <name> 
+#      t.pl <name>
 
 # And since it's a regular Perl 6 sub, you can haz multi-dispatch:
 # (using a "Bool" for the named argument so that we can do `--replace`
@@ -1346,9 +1345,9 @@ multi MAIN('add', $key, $value, Bool :$replace) { ... }
 multi MAIN('remove', $key) { ... }
 multi MAIN('import', File, Str :$as) { ... } # omitting parameter name
 # This produces:
-#    $ perl 6 cli.pl
+#    $ perl6 cli.pl
 #    Usage:
-#      t.pl [--replace] add <key> <value> 
+#      t.pl [--replace] add <key> <value>
 #      t.pl remove <key>
 #      t.pl [--as=<Str>] import (File)
 # As you can see, this is *very* powerful.
@@ -1400,7 +1399,7 @@ for <well met young hero we shall meet later> {
                         #  (explained in details below).
     .say
   }
-  
+
   if rand == 0 ff rand == 1 { # compare variables other than `$_`
     say "This ... probably will never run ...";
   }
@@ -1429,7 +1428,7 @@ for <well met young hero we shall meet later> {
 # A flip-flop can change state as many times as needed:
 for <test start print it stop not printing start print again stop not anymore> {
   .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop",
-                                           #=> "print this printing again"
+                                           #=> "print it print again"
 }
 
 # you might also use a Whatever Star,
@@ -1461,4 +1460,3 @@ If you want to go further, you can:
  - Come along on `#perl6` at `irc.freenode.net`. The folks here are always helpful.
  - Check the [source of Perl 6's functions and classes](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo is mainly written in Perl 6 (with a lot of NQP, "Not Quite Perl", a Perl 6 subset easier to implement and optimize).
  - Read [the language design documents](http://design.perl6.org). They explain P6 from an implementor point-of-view, but it's still very interesting.
-
diff --git a/php.html.markdown b/php.html.markdown
index 52ea2a95..cf9544b3 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -12,7 +12,7 @@ This document describes PHP 5+.
 <?php // PHP code must be enclosed with <?php tags
 
 // If your php file only contains PHP code, it is best practice
-// to omit the php closing tag.
+// to omit the php closing tag to prevent accidental output.
 
 // Two forward slashes start a one-line comment.
 
@@ -103,6 +103,9 @@ END;
 // String concatenation is done with .
 echo 'This string ' . 'is concatenated';
 
+// Strings can be passed in as parameters to echo
+echo 'Multiple', 'Parameters', 'Valid';  // Returns 'MultipleParametersValid'
+
 
 /********************************
  * Constants
@@ -115,8 +118,10 @@ echo 'This string ' . 'is concatenated';
 // followed by any number of letters, numbers, or underscores.
 define("FOO",     "something");
 
-// access to a constant is possible by direct using the choosen name
-echo 'This outputs '.FOO;
+// access to a constant is possible by calling the choosen name without a $
+echo FOO; // Returns 'something'
+echo 'This outputs '.FOO;  // Returns 'This ouputs something'
+
 
 
 /********************************
@@ -141,6 +146,8 @@ echo $array[0]; // => "One"
 
 // Add an element to the end of an array
 $array[] = 'Four';
+// or
+array_push($array, 'Five');
 
 // Remove element from array
 unset($array[3]);
@@ -155,9 +162,9 @@ echo('Hello World!');
 
 print('Hello World!'); // The same as echo
 
-// echo is actually a language construct, so you can drop the parentheses.
+// echo and print are language constructs too, so you can drop the parentheses
 echo 'Hello World!';
-print 'Hello World!'; // So is print
+print 'Hello World!';
 
 $paragraph = 'paragraph';
 
@@ -215,6 +222,18 @@ assert($a !== $d);
 assert(1 === '1');
 assert(1 !== '1');
 
+// 'Spaceship' operator (since PHP 7)
+// Returns 0 if values on either side are equal
+// Returns 1 if value on the left is greater
+// Returns -1 if the value on the right is greater
+
+$a = 100;
+$b = 1000;
+
+echo $a <=> $a; // 0 since they are equal
+echo $a <=> $b; // -1 since $a < $b
+echo $b <=> $a; // 1 since $b > $a
+
 // Variables can be converted between types, depending on their usage.
 
 $integer = 1;
@@ -264,6 +283,18 @@ if (false) {
 // ternary operator
 print (false ? 'Does not get printed' : 'Does');
 
+// ternary shortcut operator since PHP 5.3
+// equivalent of "$x ? $x : 'Does'""
+$x = false;
+print($x ?: 'Does');
+
+// null coalesce operator since php 7
+$a = null;
+$b = 'Does print';
+echo $a ?? 'a is not set'; // prints 'a is not set'
+echo $b ?? 'b is not set'; // prints 'Does print'
+
+
 $x = 0;
 if ($x === '0') {
     print 'Does not print';
@@ -359,7 +390,7 @@ for ($i = 0; $i < 5; $i++) {
 
 // Define a function with "function":
 function my_function () {
-  return 'Hello';
+    return 'Hello';
 }
 
 echo my_function(); // => "Hello"
@@ -368,8 +399,8 @@ echo my_function(); // => "Hello"
 // number of letters, numbers, or underscores.
 
 function add ($x, $y = 1) { // $y is optional and defaults to 1
-  $result = $x + $y;
-  return $result;
+    $result = $x + $y;
+    return $result;
 }
 
 echo add(4); // => 5
@@ -380,21 +411,21 @@ echo add(4, 2); // => 6
 
 // Since PHP 5.3 you can declare anonymous functions;
 $inc = function ($x) {
-  return $x + 1;
+    return $x + 1;
 };
 
 echo $inc(2); // => 3
 
 function foo ($x, $y, $z) {
-  echo "$x - $y - $z";
+    echo "$x - $y - $z";
 }
 
 // Functions can return functions
 function bar ($x, $y) {
-  // Use 'use' to bring in outside variables
-  return function ($z) use ($x, $y) {
-    foo($x, $y, $z);
-  };
+    // Use 'use' to bring in outside variables
+    return function ($z) use ($x, $y) {
+        foo($x, $y, $z);
+    };
 }
 
 $bar = bar('A', 'B');
@@ -406,6 +437,31 @@ echo $function_name(1, 2); // => 3
 // Useful for programatically determining which function to run.
 // Or, use call_user_func(callable $callback [, $parameter [, ... ]]);
 
+
+// You can get the all the parameters passed to a function
+function parameters() {
+    $numargs = func_num_args();
+    if ($numargs > 0) {
+        echo func_get_arg(0) . ' | ';
+    }
+    $args_array = func_get_args();
+    foreach ($args_array as $key => $arg) {
+        echo $key . ' - ' . $arg . ' | ';
+    }
+}
+
+parameters('Hello', 'World'); // Hello | 0 - Hello | 1 - World |
+
+// Since PHP 5.6 you can get a variable number of arguments
+function variable($word, ...$list) {
+	echo $word . " || ";
+	foreach ($list as $item) {
+		echo $item . ' | ';
+	}
+}
+
+variable("Separate", "Hello", "World") // Separate || Hello | World | 
+
 /********************************
  * Includes
  */
@@ -495,7 +551,9 @@ class MyClass
     }
 }
 
+// Class constants can always be accessed statically
 echo MyClass::MY_CONST;    // Outputs 'value';
+
 echo MyClass::$staticVar;  // Outputs 'static';
 MyClass::myStaticMethod(); // Outputs 'I am static';
 
@@ -671,8 +729,80 @@ use My\Namespace as SomeOtherNamespace;
 
 $cls = new SomeOtherNamespace\MyClass();
 
+
+/**********************
+* Late Static Binding
+*
+* /
+
+class ParentClass {
+    public static function who() {
+        echo "I'm a " . __CLASS__ . "\n";
+    }
+    public static function test() {
+        // self references the class the method is defined within
+        self::who();
+        // static references the class the method was invoked on
+        static::who();
+    }
+}
+
+ParentClass::test();
+/*
+I'm a ParentClass
+I'm a ParentClass
+*/
+
+class ChildClass extends ParentClass {
+    public static function who() {
+        echo "But I'm " . __CLASS__ . "\n";
+    }
+}
+
+ChildClass::test();
+/*
+I'm a ParentClass
+But I'm ChildClass
+*/
+
+
+/**********************
+*  Error Handling
+*  
 */
 
+// Simple error handling can be done with try catch block
+
+try {
+    // Do something
+} catch (Exception $e) {
+    // Handle exception
+}
+
+// When using try catch blocks in a namespaced enviroment use the following
+
+try {
+    // Do something
+} catch (\Exception $e) {
+    // Handle exception
+}
+
+// Custom exceptions
+
+class MyException extends Exception {}
+
+try {
+
+    $condition = true;
+
+    if ($condition) {
+        throw new MyException('Something just happend');
+    }
+
+} catch (MyException $e) {
+    // Handle my exception
+}
+
 ```
 
 ## More Information
diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/python-pl.html.markdown
index c3e8287a..ade1d7ca 100644
--- a/pl-pl/python-pl.html.markdown
+++ b/pl-pl/python-pl.html.markdown
@@ -125,7 +125,7 @@ not False  # => True
 # Ta metoda jest obecnie polecana:
 "{0} są {1}".format("napisy", "fajne")
 # Jeśli nie chce ci się liczyć użyj słów kluczowych.
-"{imie} chce zjeść {jadlo}".format(imie="Bob", jasno="lasagne")
+"{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron")
 
 # None jest obiektem
 None  # => None
@@ -158,7 +158,7 @@ print "Jestem Python. Miło poznać!"
 print("Ja też jestem Python! ")
 
 # Nie trzeba deklarować zmiennych przed przypisaniem.
-jakas_zmienna = 5    # Konwencja mówi: używaj małych znaków i podłogi _
+jakas_zmienna = 5    # Konwencja mówi: używaj małych znaków i kładki _
 jakas_zmienna  # => 5
 
 # Próba dostępu do niezadeklarowanej zmiennej da błąd.
diff --git a/pt-br/brainfuck-pt.html.markdown b/pt-br/brainfuck-pt.html.markdown
index c7ce55ee..9e4b458d 100644
--- a/pt-br/brainfuck-pt.html.markdown
+++ b/pt-br/brainfuck-pt.html.markdown
@@ -5,10 +5,11 @@ contributors:
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Suzane Sant Ana", "http://github.com/suuuzi"]
+    - ["Rodrigo Muniz", "http://github.com/muniz95"]
 lang: pt-br
 ---
 
-Brainfuck (em letras minúsculas, eceto no início de frases) é uma linguagem de
+Brainfuck (em letras minúsculas, exceto no início de frases) é uma linguagem de
 programação Turing-completa extremamente simples com apenas 8 comandos.
 
 ```
@@ -18,7 +19,7 @@ Brainfuck é representado por um vetor com 30 000 células inicializadas em zero
 e um ponteiro de dados que aponta para a célula atual.
 
 Existem 8 comandos:
-+ : Incrementa o vaor da célula atual em 1.
++ : Incrementa o valor da célula atual em 1.
 - : Decrementa o valor da célula atual em 1.
 > : Move o ponteiro de dados para a célula seguinte (célula à direita).
 < : Move o ponteiro de dados para a célula anterior (célula à esquerda).
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index 61625ebe..61e267f5 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -304,7 +304,7 @@ void Dog::Dog()
 }
 
 // Objetos (como strings) devem ser passados por referência
-// se você está modificando-os ou referência const se você não é.
+// se você pretende modificá-los, ou com const caso contrário.
 void Dog::setName(const std::string& dogsName)
 {
     name = dogsName;
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 451df4f3..43688724 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
 translators:
     - ["João Farias", "https://github.com/JoaoGFarias"]
+    - ["Elton Viana", "https://github.com/eltonvs"]
 lang: pt-br
 filename: c-pt.el
 ---
@@ -139,13 +140,13 @@ int main() {
     int var_length_array[size]; // declara o VLA
     printf("sizeof array = %zu\n", sizeof var_length_array);
 
-	//Uma possível saída para esse programa seria:
-    // > Entre o tamanho do array:: 10
+    // Uma possível saída para esse programa seria:
+    // > Entre o tamanho do array: 10
     // > sizeof array = 40
 
 	// String são apenas arrays de caracteres terminados por um 
-	// byte NUL (0x00), representado em string pelo caracter especial '\0'.
-	// (Não precisamos incluir o byte NUL em literais de string; o compilador
+	// byte nulo (0x00), representado em string pelo caracter especial '\0'.
+	// (Não precisamos incluir o byte nulo em literais de string; o compilador
 	// o insere ao final do array para nós.)
     char uma_string[20] = "Isto é uma string"; 
 	// Observe que 'é' não está na tabela ASCII
@@ -153,8 +154,8 @@ int main() {
 	// Porém, comentários podem conter acentos 
     printf("%s\n", uma_string); // %s formata a string
 
-    printf("%d\n", uma_string[16]); // => 0
-    // i.e., byte #17 é 0 (assim como 18, 19, e 20)
+    printf("%d\n", uma_string[17]); // => 0
+    // i.e., byte #18 é 0 (assim como o 19°, 20°, 21°...)
 
 	// Se temos caracteres entre aspas simples, temos um caracter literal.
 	// Seu tipo é `int`, *não* `char` (por razões históricas).
@@ -220,11 +221,11 @@ int main() {
     0 || 1; // => 1 (Ou lógico)
     0 || 0; // => 0
 
-    //Expressão condicional ( ? : )
+    //Expressão condicional ternária ( ? : )
     int a = 5;
     int b = 10;
     int z;
-    z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b." 
+    z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b."
 
     //Operadores de incremento e decremento:
     char *s = "iLoveC";
@@ -290,6 +291,8 @@ int main() {
     for (i = 0; i <= 5; i++) {
         ; // Use ponto e vírgula para agir como um corpo (declaração nula)
     }
+    // Ou
+    for (i = 0; i <= 5; i++);
 
 	// Criando branchs com escolhas múltiplas: switch()
     switch (alguma_expressao_integral) {
diff --git a/pt-br/clojure-macros-pt.html.markdown b/pt-br/clojure-macros-pt.html.markdown
new file mode 100644
index 00000000..dbc0c25c
--- /dev/null
+++ b/pt-br/clojure-macros-pt.html.markdown
@@ -0,0 +1,154 @@
+---
+language: clojure
+filename: learnclojure-pt.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Raphael Bezerra do Nascimento"]
+lang: pt-br
+---
+
+Como todas as Lisps, a inerente [homoiconicity](https://en.wikipedia.org/wiki/Homoiconic)
+do Clojure lhe dá acesso a toda a extensão da linguagem 
+para escrever rotinas de geração de código chamados "macros". Macros fornecem uma poderosa forma de adequar a linguagem 
+às suas necessidades.
+
+Pórem Tenha cuidado. É considerado má pratica escrever uma macro quando uma função vai fazer. Use uma macro apenas 
+quando você precisar do controle sobre quando ou se os argumentos para um formulário será avaliado.
+
+Você vai querer estar familiarizado com Clojure. Certifique-se de entender tudo em 
+[Clojure em Y Minutos](/docs/clojure/).
+
+```clojure
+;; Defina uma macro utilizando defmacro. Sua macro deve ter como saida uma lista que possa
+;; ser avaliada como codigo Clojure.
+;;
+;; Essa macro é a mesma coisa que se você escrever (reverse "Hello World")
+(defmacro my-first-macro []
+  (list reverse "Hello World"))
+
+;; Inspecione o resultado de uma macro utilizando macroexpand or macroexpand-1.
+;;
+;; Note que a chamada deve utilizar aspas simples.
+(macroexpand '(my-first-macro))
+;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World")
+
+;; Você pode avaliar o resultad de macroexpand diretamente:
+(eval (macroexpand '(my-first-macro)))
+; -> (\d \l \o \r \W \space \o \l \l \e \H)
+
+;; mas você deve usar esse mais suscinto, sintax como de função:
+(my-first-macro)  ; -> (\d \l \o \r \W \space \o \l \l \e \H)
+
+;; Você pode tornar as coisas mais faceis pra você, utilizando a sintaxe de citação mais suscinta
+;; para criar listas nas suas macros:
+(defmacro my-first-quoted-macro []
+  '(reverse "Hello World"))
+
+(macroexpand '(my-first-quoted-macro))
+;; -> (reverse "Hello World")
+;; Note que reverse não é mais uma função objeto, mas um simbolo.
+
+;; Macros podem ter argumentos.
+(defmacro inc2 [arg]
+  (list + 2 arg))
+
+(inc2 2) ; -> 4
+
+;; Mas se você tentar fazer isso com uma lista entre aspas simples, você vai receber um erro, por que o 
+;; argumento irá entra aspas simples também. Para contornar isso, Clojure prover uma maneira de utilizar aspas simples 
+;; em macros: `. Dentro `, você pode usar ~ para chegar ao escopo externo.
+(defmacro inc2-quoted [arg]
+  `(+ 2 ~arg))
+
+(inc2-quoted 2)
+
+;; Você pode usar os argumentos de destruturação habituais. Expandir lista de variaveis usando ~@
+(defmacro unless [arg & body]
+  `(if (not ~arg)
+     (do ~@body))) ; Lembrar o do!
+
+(macroexpand '(unless true (reverse "Hello World")))
+;; ->
+;; (if (clojure.core/not true) (do (reverse "Hello World")))
+
+;; (unless) avalia e retorna seu corpo, se o primeiro argumento é falso.
+;; caso contrario, retorna nil
+
+(unless true "Hello") ; -> nil
+(unless false "Hello") ; -> "Hello"
+
+;; Usado sem cuidados, macros podem fazer muito mal por sobreporem suas variaveis
+(defmacro define-x []
+  '(do
+     (def x 2)
+     (list x)))
+
+(def x 4)
+(define-x) ; -> (2)
+(list x) ; -> (2)
+
+;;s Para evitar isso, use gensym para receber um identificador unico
+(gensym 'x) ; -> x1281 (ou outra coisa)
+
+(defmacro define-x-safely []
+  (let [sym (gensym 'x)]
+    `(do
+       (def ~sym 2)
+       (list ~sym))))
+
+(def x 4)
+(define-x-safely) ; -> (2)
+(list x) ; -> (4)
+
+;; Você pode usar # dentro de ` para produzir uma gensym para cada simbolo automaticamente
+(defmacro define-x-hygenically []
+  `(do
+     (def x# 2)
+     (list x#)))
+
+(def x 4)
+(define-x-hygenically) ; -> (2)
+(list x) ; -> (4)
+
+;; É típico o uso de funções de auxilio com macros. Vamos criar um pouco
+;; Vamos criar um pouco para nos ajudar a suportar uma sintaxe aritmética inline (estupida)
+(declare inline-2-helper)
+(defn clean-arg [arg]
+  (if (seq? arg)
+    (inline-2-helper arg)
+    arg))
+
+(defn apply-arg
+  "Given args [x (+ y)], return (+ x y)"
+  [val [op arg]]
+  (list op val (clean-arg arg)))
+
+(defn inline-2-helper
+  [[arg1 & ops-and-args]]
+  (let [ops (partition 2 ops-and-args)]
+    (reduce apply-arg (clean-arg arg1) ops)))
+
+;; Podemos testar isso imediatamente, sem criar uma macro
+(inline-2-helper '(a + (b - 2) - (c * 5))) ; -> (- (+ a (- b 2)) (* c 5))
+
+; Entretanto, temos que tornar isso uma macro caso quisermos que isso seja rodado em tempo de compilação
+(defmacro inline-2 [form]
+  (inline-2-helper form)))
+
+(macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1)))
+; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1)
+
+(inline-2 (1 + (3 / 2) - (1 / 2) + 1))
+; -> 3 (Na verdade, 3N, desde que o numero ficou convertido em uma fração racional com /
+
+### Leitura adicional
+
+Escrevendo Macros de [Clojure para o Brave e True](http://www.braveclojure.com/)
+[http://www.braveclojure.com/writing-macros/](http://www.braveclojure.com/writing-macros/)
+
+Documentos oficiais 
+[http://clojure.org/macros](http://clojure.org/macros)
+
+Quando utilizar macros? 
+[http://dunsmor.com/lisp/onlisp/onlisp_12.html](http://dunsmor.com/lisp/onlisp/onlisp_12.html)
diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
new file mode 100644
index 00000000..ed6f6c4c
--- /dev/null
+++ b/pt-br/css-pt.html.markdown
@@ -0,0 +1,257 @@
+---
+language: css
+filename: learncss-pt.css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+    - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+Nos primeiros dias da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornou comum.
+
+CSS ajuda a manter a separação entre o conteúdo (HTML) e o look-and-feel de uma página web.
+
+CSS permite atingir diferentes elementos em uma página HTML e atribuir diferentes propriedades visuais para eles.
+
+Este guia foi escrito para CSS2, embora CSS3 está rapidamente se tornando popular.
+
+**NOTA:** Porque CSS produz resultados visuais, a fim de aprender, você precisa tentar de tudo em um playground CSS como [dabblet](http://dabblet.com/).
+O foco principal deste artigo é sobre a sintaxe e algumas dicas gerais.
+
+```css
+/* Comentários aparecem dentro do slash-asterisk, tal como esta linha!
+   não há "comentários de uma linha"; este é o único estilo de comentário * /
+
+/* ####################
+   ## SELETORES
+   #################### */
+
+/* O seletor é usado para direcionar um elemento em uma página.
+   seletor { propriedade: valor; / * Mais propriedades ... * / }
+
+/*
+Abaixo um elemento de exemplo:
+
+<div class='class1 class2' id='anID' attr='value' otherAttr='pt-br foo bar' />
+*/
+
+/* Você pode direciona-lo usando uma das suas classes CSS */
+.class1 { }
+
+/* ou ambas as classes! */
+.class1.class2 { }
+
+/* ou o seu nome */
+div { }
+
+/* ou o seu id */
+#anID { }
+
+/* ou utilizando o fator de que tem um atributo!*/
+[attr] { font-size:smaller; }
+
+/* ou que o atributo tem um valor específico */
+[attr='value'] { font-size:smaller; }
+
+/* começa com um valor (CSS 3) */
+[attr^='val'] { font-size:smaller; }
+
+/* ou terminando com um valor (CSS 3) */
+[attr$='ue'] { font-size:smaller; }
+
+
+/* Ou contém um valor em uma lista separada por espaços */
+[otherAttr ~ = 'foo'] {}
+[otherAttr ~ = 'bar'] {}
+
+/* Ou contém um valor em uma lista separada por hífen, ou seja, "-" (U + 002D) */
+[otherAttr | = 'en'] {font-size: smaller; }
+
+
+/* Você pode concatenar diferentes seletores para criar um seletor mais estreito. Não
+   colocar espaços entre eles. */
+classe div.some [attr $ = 'ue'] {}
+
+/* Você pode selecionar um elemento que é filho de outro elemento */
+div.some-parent> .class-name {}
+
+/* Ou um descendente de um outro elemento. As crianças são os descendentes diretos de
+   seu elemento pai, apenas um nível abaixo da árvore. Pode ser qualquer descendentes
+   nivelar por baixo da árvore. */
+div.some-parent class-name {}
+
+/* Atenção: o mesmo seletor sem espaço tem um outro significado.
+   Você consegue adivinhar o que? */
+div.some-parent.class-name {}
+
+/* Você também pode selecionar um elemento com base em seu irmão adjacente */
+.i am just-antes + .Este elemento {}
+
+/* Ou qualquer irmão que o precede */
+.i am-qualquer-elemento antes ~ .Este elemento {}
+
+/* Existem alguns selectores chamado pseudo classes que podem ser usados para selecionar um
+   elemento quando ele está em um determinado estado */
+
+/* Por exemplo, quando o cursor passa sobre um elemento */
+seletor:hover {}
+
+/* Ou um link foi visitado */
+seletor:visited {}
+
+/* Ou não tenha sido visitado */
+seletor:link {}
+
+/* Ou um elemento em foco */
+seletor:focus {}
+
+/* Qualquer elemento que é o primeiro filho de seu pai */
+seletor:first-child {}
+
+/* Qualquer elemento que é o último filho de seu pai */
+seletor:last-child {}
+
+/* Assim como pseudo classes, pseudo elementos permitem que você estilo certas partes de um documento */
+
+/* Corresponde a um primeiro filho virtual do elemento selecionado */
+seletor::before {}
+
+/* Corresponde a um último filho virtual do elemento selecionado */
+seletor::after {}
+
+/* Nos locais apropriados, um asterisco pode ser utilizado como um curinga para selecionar todos
+   elemento */
+* {} /* */ Todos os elementos
+.parent * {} /* */ todos os descendentes
+.parent> * {} /* */ todas as crianças
+
+/* ####################
+   ## PROPRIEDADES
+   #################### */
+
+seletor {
+
+    /* Unidades de comprimento pode ser absoluta ou relativa. */
+
+    /* Unidades relativas */
+    width: 50%; /* Percentagem de largura elemento pai */
+    font-size: 2em; /* Múltiplos de font-size original de elemento */
+    font-size: 2rem; /* Ou do elemento raiz font-size */
+    font-size: 2vw; /* Múltiplos de 1% da largura da janela de exibição (CSS 3) */
+    font-size: 2vh; /* Ou a sua altura */
+    font-size: 2vmin; /* Qualquer um de VH ou um VW é menor */
+    font-size: 2vmax; /* Ou superior */
+
+    /* Unidades absolutas */
+    width: 200px; /* píxeis */
+    font-size: 20pt; /* Pontos */
+    width: 5cm; /* Centímetros */
+    min-width: 50mm; /* Milímetros */
+    max-width: 5 polegadas; /* Polegadas */
+
+    /* Cores */
+    color: # F6E; /* Formato hexadecimal curto */
+    color: # FF66EE; /* Formato hexadecimal longo */
+    color: tomato; /* Uma cor nomeada */
+    color: rgb (255, 255, 255); /* Como valores rgb */
+    cor: RGB (10%, 20%, 50%); /* Como porcentagens rgb */
+    cor: rgba (255, 0, 0, 0,3); /* Como valores RGBA (CSS 3) NOTA: 0 <a <1 */
+    color: transparent; /* Equivale a definir o alfa a 0 */
+    cor: HSL (0, 100%, 50%); /* Como porcentagens HSL (CSS 3) */
+    cor: HSLA (0, 100%, 50%, 0,3); /* Como porcentagens HSLA com alfa */
+
+    /* Imagens como fundos de elementos */
+    background-image: url (/img-path/img.jpg); /* Citações dentro url () opcional */
+
+    /* Fontes */
+    font-family: Arial;
+    /* Se o nome da família de fonte tem um espaço, deve ser citado */
+    font-family: "Courier New";
+    /* Se o primeiro não for encontrada, o navegador usa o próximo, e assim por diante */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
+}
+```
+
+## Uso
+
+Guardar uma folha de estilo CSS com a extensão `.css`.
+
+```xml
+<!-- Você precisa incluir o arquivo css no da sua página <head>. Isto é o
+     método recomendado. Consulte http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+
+<!-- Você também pode incluir alguns CSS inline na sua marcação. -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- Ou diretamente definir propriedades CSS no elemento. -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Precedência ou Cascata
+
+Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
+
+Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata.
+
+Dado o seguinte CSS:
+
+```css
+/* UMA */
+p.class1[attr="value"]
+
+/* B */
+p.class1 {}
+
+/* C */
+p.class2 {}
+
+/* D */
+p { }
+
+/* E */
+p { property: value !important; }
+```
+
+e a seguinte marcação:
+
+```xml
+<p style='/*F*/ property:value;' class='class1 class2' attr='value' />
+```
+
+A precedência de estilo é a seguinte. Lembre-se, a precedência é para cada  **propriedade**, não para todo o bloco.
+
+* `E` tem a precedência mais alta por causa de uma palavra-chave`!important`. É recomendável que você evitar seu uso.
+* `F` é a próxima, porque é um estilo interno.
+* `A` é a próxima, porque é mais" específico "do que qualquer outra coisa. Tem 3 especificadores: O nome do elemento `p`, o seu `class1` classe, um atributo `attr='value'`.
+* `C` está próximo, mesmo que ele tenha a mesma especificidade que `B`. Isso é porque ele aparece depois de `B`.
+* `B` é o próximo.
+* `D` é a última.
+
+## Compatibilidade
+
+A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
+
+## Recursos
+
+* Para executar uma verificação de compatibilidade rápida, [CanIUse](http://caniuse.com).
+* CSS Playground [Dabblet](http://dabblet.com/).
+* [Documentação CSS Mozilla Developer Rede](https://developer.mozilla.org/en-US/docs/Web/CSS)
+* [Codrops 'Referência CSS](http://tympanus.net/codrops/css_reference/)
+
+## Leitura adicional
+
+* [Entendendo Estilo Precedência em CSS: Especificidade, Herança, eo 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
+* [CSS-Tricks](https://css-tricks.com)
diff --git a/pt-br/hack-pt.html.markdown b/pt-br/hack-pt.html.markdown
new file mode 100644
index 00000000..7c938149
--- /dev/null
+++ b/pt-br/hack-pt.html.markdown
@@ -0,0 +1,316 @@
+---
+language: Hack
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+    - ["David Lima", "https://github.com/davelima"]
+translators:
+    - ["David Lima", "https://github.com/davelima"]
+lang: pt-br
+filename: learnhack-pt.hh
+---
+
+Hack é uma linguagem baseada no PHP e roda numa máquina virtual chamada HHVM.
+Hack é quase completamente interoperável com códigos PHP existentes e adiciona
+alguns recursos úteis de linguagens estaticamente tipadas.
+
+Somente recursos específicos da linguagem Hack serão abordados aqui. Detalhes
+sobre a sintaxe do PHP estão disponíveis no
+[artigo PHP](http://learnxinyminutes.com/docs/php/) neste site.
+
+```php
+<?hh
+
+// A sintaxe do Hack é ativada apenas em arquivos que comecem com <?hh
+// Marcadores <?hh não podem ser incluídos em páginas HTML, diferente de <?php.
+// Usar o marcador "<?hh //strict" coloca o verificador de tipo no modo estrito.
+
+
+// Indução de tipo de parâmetros escalares
+function repeat(string $palavra, int $contagem)
+{
+    $palavra = trim($palavra);
+    return str_repeat($palavra . ' ', $contagem);
+}
+
+// Indução de tipo para valores de retorno
+function add(...$numeros) : int
+{
+    return array_sum($numeros);
+}
+
+// Funções que não retornam nada são induzidas com "void"
+function truncate(resource $recurso) : void
+{
+    // ...
+}
+
+// Induções de tipo devem permitir nulos de forma explícita
+function identity(?string $stringOuNulo) : ?string
+{
+    return $stringOuNulo;
+}
+
+// Induções de tipo podem ser especificadas em propriedades de classes
+class PropriedadesComTipos
+{
+    public ?string $nome;
+    
+    protected int $id;
+
+    private float $pontuacao = 100.0;
+
+    // O verificador de tipos do Hack reforça que propriedades tipadas devem
+    // ter um valor padrão ou devem ser definidos no construtor
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Funções anônimas (lambdas)
+$multiplicador = 5;
+array_map($y ==> $y * $multiplicador, [1, 2, 3]);
+
+
+// Genéricos
+class Caixa<T>
+{
+    protected T $dados;
+
+    public function __construct(T $dados) {
+        $this->dados = $dados;
+    }
+
+    public function pegaDados(): T {
+        return $this->dados;
+    }
+}
+
+function abreCaixa(Caixa<int> $caixa) : int
+{
+    return $caixa->pegaDados();
+}
+
+
+// Formas
+//
+// Hack adiciona o conceito de formas para definir arrays com uma estrutura
+// e tipos de dados garantidos
+type Point2D = shape('x' => int, 'y' => int);
+
+function distancia(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distancia(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Pseudônimos de tipos
+//
+// Hack adiciona vários recursos para criação de pseudônimos, tornando tipos complexos
+// mais fáceis de entender
+newtype VectorArray = array<int, Vector<int>>;
+
+// Um tuple contendo dois inteiros
+newtype Point = (int, int);
+
+function adicionaPontos(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+adicionaPontos(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// enums em classes
+enum TipoDePista : int
+{
+    Estrada = 0;
+    Rua = 1;
+    Alameda = 2;
+    Avenida = 3;
+}
+
+function getTipoDePista() : TipoDePista
+{
+    return TipoDePista::Alameda;
+}
+
+
+// Especificação de argumentos no construtor (Argument Promotion)
+// 
+// Para evitar que propriedades sejam definidas em mais de um lugar, e
+// construtores que só definem propriedades, o Hack adiciona uma sintaxe para
+// definir as propriedades e o construtor ao mesmo tempo.
+class ArgumentPromotion
+{
+    public function __construct(public string $nome,
+                                protected int $idade,
+                                private bool $legal) {}
+}
+
+class SemArgumentPromotion
+{
+    public string $nome;
+
+    protected int $idade;
+
+    private bool $legal;
+
+    public function __construct(string $nome, int $idade, bool $legal)
+    {
+        $this->nome = $nome;
+        $this->idade = $idade;
+        $this->legal = $legal;
+    }
+}
+
+
+// Multi-tarefas cooperativo
+//
+// Duas novas palavras-chave ("async" e "await") podem ser usadas para
+// trabalhar com multi-tarefas.
+// Obs. Isto não envolve threads - apenas permite a transferência de controle
+async function printCooperativo(int $inicio, int $fim) : Awaitable<void>
+{
+    for ($i = $inicio; $i <= $fim; $i++) { 
+        echo "$i ";
+
+        // Permite que outras tarefas façam algo
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Imprime "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    printCooperativo(1, 3),
+    printCooperativo(4, 6),
+    printCooperativo(7, 9)
+])->getWaitHandle()->join();
+
+
+// Atributos
+//
+// Atributos são uma forma de definir metadados para funções.
+// Hack tem alguns atributos especiais que possuem comportamentos úteis.
+
+// O atributo especial __Memoize faz com que o resultado da função fique em cache
+<<__Memoize>>
+function tarefaDemorada() : ?string
+{
+    return file_get_contents('http://exemplo.com');
+}
+
+// O corpo da função só é executado uma vez aqui:
+tarefaDemorada();
+tarefaDemorada();
+
+
+// O atributo especial __ConsistentConstruct faz com que o Hack certifique-se
+// de que a assinatura do construtor seja a mesma em todas as subclasses
+<<__ConsistentConstruct>>
+class FooConsistente
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function algumMetodo()
+    {
+        // ...
+    }
+}
+
+class BarConsistente extends FooConsistente
+{
+    public function __construct(int $x, float $y)
+    {
+        // O verificador de tipos do Hack exige que os construtores pai
+        // sejam chamados
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // A anotação __Override é uma anotação opcional que faz com que o
+    // verificador de tipos do Hack sobrescreva um método em uma classe pai
+    // ou um trait. Sem __Override, definir este método causará um erro,
+    // pois ele já foi definido na classe pai (FooConsistente):
+    <<__Override>>
+    public function algumMetodo()
+    {
+        // ...
+    }
+}
+
+class SubclasseFooInvalida extends FooConsistente
+{
+    // Caso o construtor não combine com o construtor da classe pai, o
+    // verificador de tipos acusará um erro:
+    //
+    //  "Este objeto é incompatível com o objeto FooConsistente porque algum(ns)
+    //   dos seus métodos são incompatíveis"
+    //  
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Usar a anotação __Override em um método que não existe na classe pai
+    // causará um erro do verificador de tipos:
+    //  "SubclasseFooInvalida::outroMetodo() está marcada para sobrescrever;
+    //   nenhuma definição não-privada foi encontrada ou a classe pai foi
+    //   definida em código não-<?hh"
+    //  
+    <<__Override>>
+    public function outroMetodo()
+    {
+        // ...
+    }
+}
+
+
+// Traits podem implementar interfaces (não suportado pelo PHP)
+interface InterfaceGatinho
+{
+    public function brinca() : void;
+}
+
+trait TraitGato implements InterfaceGatinho
+{
+    public function brinca() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use TraitGato;
+}
+
+
+$gato = new Samuel();
+$gato instanceof InterfaceGatinho === true; // True
+
+```
+
+## Mais informações
+
+Visite a [documentação do Hack](http://docs.hhvm.com/manual/en/hacklangref.php)
+para ver explicações detalhadas dos recursos que Hack adiciona ao PHP, ou o [site oficial do Hack](http://hanlang.org/)
+para outras informações.
+
+Visite o [site oficial do HHVM](http://hhvm.com/) para aprender a instalar o HHVM.
+
+Visite [este artigo](http://docs.hhvm.com/manual/en/hack.unsupported.php) para ver
+os recursos do PHP que o Hack não suporta e ver incompatibilidades entre Hack e PHP.
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
new file mode 100644
index 00000000..406042fa
--- /dev/null
+++ b/pt-br/javascript-pt.html.markdown
@@ -0,0 +1,547 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+    - ["Willian Justen", "http://willianjusten.com.br"]
+lang: pt-br
+---
+
+JavaScript foi criada por Brendan Eich, funcionário da Netscape na época, em 1995. Ela
+foi originalmente criada para ser uma linguagem de script para websites,
+complementando o uso de Java para aplicações web mais complexas, mas a sua
+integração com páginas web e seu suporte nativo nos browsers fez com que
+ela se tornasse mais comum que Java no frontend web.
+
+Javascript não é somente limitada a browsers web, existindo o Node.js,
+que é um projeto que fornece um interpretador baseado no motor V8 do Google 
+Chrome e está se tornando cada vez mais famoso.
+
+Feedback são muito apreciados! Você me encontrar em
+[@adambrenecki](https://twitter.com/adambrenecki), ou
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// Comentários são como em C. Comentários de uma linha começam com duas barras,
+/* e comentários de múltplas linhas começam com barra-asterisco
+   e fecham com asterisco-barra */
+
+// comandos podem ser terminados com  ;
+facaAlgo();
+
+// ... mas eles não precisam ser, o ponto-e-vírgula é automaticamente
+// inserido quando há uma nova linha, exceto alguns casos.
+facaAlgo()
+
+// Como esses casos podem causar resultados inesperados, vamos continuar 
+// a usar ponto-e-vírgula neste guia.
+
+///////////////////////////////////
+// 1. Números, Strings e Operadores
+
+// Javascript tem um tipo de número (que é o 64-bit IEEE 754 double).
+// Doubles tem uma mantissa 52-bit, que é suficiente para guardar inteiros
+// acima de 9✕10¹⁵ precisamente.
+3; // = 3
+1.5; // = 1.5
+
+// A aritmética básica funciona como seria de se esperar.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Inclusive divisão desigual.
+5 / 2; // = 2.5
+
+// Operadores Bitwise também funcionam; quando você faz uma operação bitwise
+// seu float é convertido para um int de até 32 bits.
+1 << 2; // = 4
+
+// A precedência é aplicada com parênteses.
+(1 + 3) * 2; // = 8
+
+// Existem três especiais valores não-é-número-real:
+Infinity; // resultado de 1/0
+-Infinity; // resultado de -1/0
+NaN; // resultado de 0/0
+
+// Existe também o tipo booleano.
+true;
+false;
+
+// Strings são criados com ' ou ".
+'abc';
+"Olá, mundo";
+
+// Negação usa o símbolo !
+!true; // = false
+!false; // = true
+
+// Igualdade é o sinal de ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Desigualdade é o sinal de !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Mais comparações
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings são concatenadas com +
+"Olá " + "mundo!"; // = "Olá mundo!"
+
+// e comparadas com < e >
+"a" < "b"; // = true
+
+// A comparação de tipos não é feita com o uso de ==...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...a menos que use ===
+"5" === 5; // = false
+null === undefined; // = false 
+
+// ...isso pode resultar em comportamentos estranhos...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Você pode acessar caracteres de uma String usando o `charAt`
+"Isto é uma String".charAt(0);  // = 'I'
+
+// ...ou usar `substring` para pegar pedaços maiores.
+"Olá mundo".substring(0, 3); // = "Olá"
+
+// `length` é uma propriedade, portanto não use ().
+"Olá".length; // = 3
+
+// Existe também o `null` e o `undefined`.
+null;      // usado para indicar um valor não considerado
+undefined; // usado para indicar um valor que não é a atualmente definido
+           // (entretando `undefined` é considerado de fato um valor
+
+// false, null, undefined, NaN, 0 and "" são valores falsos;
+// qualquer outro valor é verdadeiro
+// Note que 0 é falso e "0" é verdadeiro, até mesmo 0 == "0".
+
+///////////////////////////////////
+// 2. Variáveis, Arrays e Objetos
+
+// Variáveis são declaradas com a palavra-chave `var`. O Javascript é 
+// dinâmicamente tipado, portanto você não precisa especificar o tipo.
+// Atribuições usam um simples caracter de `=`.
+var someVar = 5;
+
+// se você deixar de colocar a palavra-chave var, você não irá receber um erro...
+someOtherVar = 10;
+
+// ...mas sua variável será criada no escopo global, não no escopo em que você
+// definiu ela.
+
+// Variáveis declaradas sem receberem um valor são definidas como `undefined`.
+var someThirdVar; // = undefined
+
+// Existe um shorthand para operações matemáticas em variáveis:
+someVar += 5; // equivalente a someVar = someVar + 5; someVar é 10 agora
+someVar *= 10; // agora someVar é 100
+
+// e um para adição e subtração de 1
+someVar++; // agora someVar é 101
+someVar--; // volta para 100
+
+// Arrays são listas ordenadas de valores, de qualquer tipo.
+var myArray = ["Olá", 45, true];
+
+// Seus membros podem ser acessados usando a sintaxe de colchetes.
+// O indíce de um Array começa pelo 0.
+myArray[1]; // = 45
+
+// Arrays são mutáveis e de tamanho variável.
+myArray.push("World");
+myArray.length; // = 4
+
+// Adicionar/modificar em um índice específico
+myArray[3] = "Hello";
+
+// Objetos de Javascript são equivalentes aos dicionários ou maps de outras
+// linguagens: uma coleção não ordenada de pares chave-valor.
+var myObj = {chave1: "Olá", chave2: "Mundo"};
+
+// Chaves são strings, mas as aspas não são necessárias se elas são
+// identificadores válidos no Javascript. Valores podem ser de qualquer tipo.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Atributos de objetos também podem ser acessados com a sintaxe de colchetes.
+myObj["my other key"]; // = 4
+
+// ... ou usando a sintaxe de ponto, passando a chave que é um identificador
+// válido.
+myObj.myKey; // = "myValue"
+
+// Objetos são mutáveis, valores podem ser modificados e novas chaves 
+// adicionadas.
+myObj.myThirdKey = true;
+
+// Se você tentar acessar um valor que não foi determinado ainda, você irá
+// receber `undefined`.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Lógica e Estruturas de Controle
+
+// A sintaxe para essa seção é quase idêntica a maioria das linguagens.
+
+// The `if` structure works as you'd expect.
+// A estrutura `if` funciona como deveria ser.
+var count = 1
+if (count == 3){
+    // executa se count é 3
+} else if (count == 4){
+    // executa se count é 4
+} else {
+    // executa se count não é 3 nem 4
+}
+
+// Como se faz um `while`.
+while (true){
+    // Um loop infinito!
+}
+
+// Os loops do-while são como os loops de while, exceto quando eles sempre
+// executam pelo menos uma vez.
+do {
+    input = getInput();
+} while (!isValid(input))
+
+// The `for` loop is the same as C and Java:
+// initialisation; continue condition; iteration.
+
+// O loop `for` é o mesmo de C e Java:
+// inicialização, condição para continuar; iteração
+for (var i = 0; i < 5; i++){
+    // vai rodar cinco vezes
+}
+
+// && é o `e` lógico , || é o `ou` lógico
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+}
+if (cor == "red" || cor == "blue"){
+    // cor é vermelha OU azul
+}
+
+// && e || "pequeno circuito", é útil para determinar valores padrões.
+var name = otherName || "padrão";
+
+// O `switch` checa pela igualdade com `===`.
+// Use `break` após cada `case`
+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. Funções, Escopos e Closures
+
+// Funções Javascript são declaradas com a palavra-chave `function`.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Repare que o valor a ser retornado deve começar na mesma linha que
+// a palavra-chave `return`, senão você sempre irá retornar `undefined` 
+// visto que o ponto-e-vírgula é inserido automáticamente nas quebras de 
+// linha. Preste atenção quando usar o estilo Allman.
+function myFunction()
+{
+    return // <- ponto-e-vírgula adicionado automaticamente aqui
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// Funções Javascript são objetos de primeira classe, portanto elas podem
+// ser atribuídas a nomes de variáveis e serem passadas para outras funções
+// como argumentos - por exemplo, quando criamos um manipulador de eventos:
+function myFunction(){
+    // este código será chamado em 5 segundos
+}
+setTimeout(myFunction, 5000);
+// Nota: `setTimeout` não é parte da linguagem Javascript, mas é provido pelos
+// browsers e o Node.js.
+
+// Objetos de funções não precisam nem serem declarados com nome - você pode 
+// escrever a definição de uma função anônima diretamente nos argumentos de 
+// outra função.
+setTimeout(function(){
+    // este código será chamado em 5 segundos
+}, 5000);
+
+// O Javascript tem escopo de função; as funções tem seu próprio escopo, 
+// mas outros blocos não.
+if (true){
+    var i = 5;
+}
+i; // = 5 - não `undefined` como você esperaria numa linguagem de blogo-escopo
+
+// Isso levou a padrão comum chamado de IIFE (Imediately Invoked Function 
+// Expression) ou (Expressão de Função Invocada Imediatamente), que previne
+// que variáveis temporárias vazem para o escopo global.
+(function(){
+    var temporary = 5;
+    // Nós podemos acessar o escopo global definindo o "objeto global", que
+    // no browser vai ser sempre `window`. O objeto global pode ter um nome
+    // diferente para ambiente não-browser como o Node.js.
+    window.permanent = 10;
+})();
+temporary; // levanta um erro de referência inexiste
+permanent; // = 10
+
+// Uma das principais características do Javascript é a closure. Que é
+// uma função definida dentro de outra função, a função interna pode acessar
+// todas as variáveis da função externa, mesmo depois da função de fora
+// finalizar sua execução.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+
+    // Funções internas são colocadas no escopo local por padrão, assim como
+    // se fossem declaradas com `var`. 
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // `setTimeout` é assíncrono, portanto a função `sayHelloInFiveSeconds`
+    // vai sair imediatamente, e o `setTimeout` irá chamar a interna depois.
+    // Entretanto. como a interna é fechada dentro de "sayHelloInFiveSeconds",
+    // a interna permanece podendo acessar a variável `prompt` quando depois
+    // de chamada.
+}
+sayHelloInFiveSeconds("Adam"); // Vai abrir um popup com "Hello, Adam!" em 5s
+
+///////////////////////////////////
+// 5. Mais sobre Objetos; Construtores e Prototypes
+
+// Objetos podem conter funções.
+var myObj = {
+    myFunc: function(){
+        return "Olá mundo!";
+    }
+};
+myObj.myFunc(); // = "Olá mundo!"
+
+// Quando uma função ligada a um objeto é chamada, ela pode acessar o objeto
+// da qual foi ligada usando a palavra-chave `this`. 
+myObj = {
+    myString: "Olá mundo!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Olá mundo!"
+
+// O `this` só funciona para dentro do escopo do objeto, portanto, se chamarmos 
+// um método do objeto fora de seu escopo, este não irá funcionar.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Inversamente, uma função pode ser atribuída a um objeto e ganhar a acesso
+// através do `this`, até mesmo se ela não for chamada quando foi definida.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "OLÁ MUNDO!"
+
+// Nós podemos também especificar um contexto onde a função irá executar, 
+// usando o `call` ou `apply`.
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " E Olá Lua!"); // = "Olá mundo! E Olá Lua!"
+
+// A função `apply` é praticamente a mesma coisa,  mas ela pega um array
+// como lista de argumentos.
+
+anotherFunc.apply(myObj, [" E Olá Sol!"]); // = "Olá mundo! E Olá Sol!"
+
+// Isto é util quando trabalhamos com uma função que aceita uma sequência de
+// argumentos e você quer passar um array.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Mas, o `call` e `apply` são somente temporários. Quando você quiser que 
+// permaneça sempre no escopo, use `bind`.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" E Olá Saturno!"); // = "Olá mundo! E Olá Saturno!"
+
+// `bind` também pode ser usado para parcialmente aplicar (curry) uma função.
+
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Quando você invoca uma função com a palavra-chave `new`, um novo objeto
+// é criado, e fica disponível para a função pela palavra-chave `this`. 
+// Funções são desenhadas para serem invocadas como se invocam os construtores.
+
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Todo objeto JavaScript possui um `prototype`. Quando você tenta acessar 
+// uma propriedade de um objeto que não existe no objeto atual, o interpretador
+// vai olhar imediatamente para o seu prototype.
+
+// Algumas implementações em JS deixam você acessar o objeto prototype com a 
+// propriedade mágica `__proto__`. Enquanto isso é util para explicar 
+// prototypes, não é parte de um padrão; nós vamos falar de algumas formas de 
+// usar prototypes depois.
+
+var myObj = {
+    myString: "Olá Mundo!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// This works for functions, too.
+// Isto funciona para funções, também.
+myObj.myFunc(); // = "olá mundo!"
+
+// É claro, se sua propriedade não está em seu prototype, 
+// o prototype do prototype será procurado e por aí vai.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Não há cópia envolvida aqui; cada objeto guarda uma referência do
+// prototype. Isso significa que podemos alterar o prototype e nossas mudanças
+// serão refletidas em qualquer lugar.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+
+// Nós mencionamos que o `__proto__` não é uma forma padrão, e não há uma 
+// forma padrão de mudar o prototype de um objeto já existente. Entretanto, 
+// existem duas formas de se criar um objeto com um dado prototype.
+
+// A primeira forma é `Object.create`, que é uma adição recente do JS,
+// e ainda não está disponível em todas as implementações.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// A segunda forma, que funciona em qualquer lugar, é feita com construtores.
+// Construtores tem uma propriedade chamada prototype. Este *não* é o prototype
+// do construtor em si; ao invés disso, ele é o prototype dos novos objetos
+// criados pelo construtor.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Tipos originais da linguagem como strings e números também possuem
+// construtores equivalentes. 
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Exceto, que eles não são totalmente equivalentes.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // O código não vai executar, porque 0 é um valor falso.
+}
+
+// Entretanto, esses objetos encapsulados e as funções originais compartilham
+// um mesmo prototype, portanto você pode adicionar funcionalidades a uma string,
+// por exemplo.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Esse fato é usado para criar os chamados `polyfills`, que implementam
+// uma nova característica do Javascript em uma versão mais velha, para que
+// assim funcionem em ambientes mais velhos como browsers ultrapassados.
+
+// Havíamos mencionado que `Object.create` não estava ainda disponível em 
+// todos as implementações, mas nós podemos usá-lo com esse polyfill:
+if (Object.create === undefined){ // don't overwrite it if it exists
+    Object.create = function(proto){
+        // faz um construtor temporário com o prototype certo
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // então utiliza o new para criar um objeto prototype apropriado
+        return new Constructor();
+    }
+}
+```
+
+## Leitura Adicional
+
+O [Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) dispõe de uma
+excelente documentação sobre Javascript e seu uso nos browsers. E mais, 
+é uma wiki, portanto conforme você vai aprendendo, mais você pode ir ajudando
+os outros compartilhando do seu conhecimento.
+
+[Uma re-introdução do JavaScript pela MDN]
+(https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+cobre muito dos conceitos abordados aqui em mais detalhes. Este guia fala
+somente sobre a linguagem JavaScript em si; se você quiser aprender mais
+sobre e como usar o JavaScript em páginas na web, comece aprendendo sobre
+[Document Object
+Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Aprenda Javascript por Exemplos e com Desafios](http://www.learneroo.com/modules/64/nodes/350) é uma
+variação desse guia com desafios.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) é um guia 
+profundo de todas as partes do JavaScript.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) é o guia clássico
+/ livro de referência. 
+
+Parte desse artigo foi adaptado do tutorial de Python do Louie Dinh que está
+nesse site e do [Tutorial de JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+da Mozilla Developer Network.
diff --git a/pt-br/json-pt.html.markdown b/pt-br/json-pt.html.markdown
index fc63b126..e4f10a61 100644
--- a/pt-br/json-pt.html.markdown
+++ b/pt-br/json-pt.html.markdown
@@ -35,7 +35,7 @@ tudo o que é vai ser 100% JSON válido. Felizmente, isso meio que fala por si.
     "array": [0, 1, 2, 3, "Arrays podem ter qualquer coisa em si.", 5],
 
     "outro objeto": {
-      "ccomentário": "Estas coisas podem ser aninhadas, muito úteis."
+      "comentário": "Estas coisas podem ser aninhadas, muito úteis."
     }
   },
 
diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
new file mode 100644
index 00000000..eb660d4c
--- /dev/null
+++ b/pt-br/matlab-pt.html.markdown
@@ -0,0 +1,540 @@
+---
+language: Matlab
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+translators:
+    - ["Claudson Martins", "https://github.com/claudsonm"]
+lang: pt-br
+filename: learnmatlab-pt.mat
+
+---
+
+MATLAB significa MATrix LABoratory. É uma poderosa linguagem de computação numérica geralmente utilizada em engenharia e matemática.
+
+Se você tem algum feedback, por favor fique a vontade para me contactar via
+[@the_ozzinator](https://twitter.com/the_ozzinator), ou
+[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
+
+```matlab
+% Comentários iniciam com um sinal de porcentagem
+
+%{
+Comentários de múltiplas linhas
+parecem
+com
+algo assim
+%}
+
+% Comandos podem ocupar várinhas linhas, usando '...':
+ a = 1 + 2 + ...
+ + 4
+
+% Comandos podem ser passados para o sistema operacional
+!ping google.com
+
+who % Exibe todas as variáveis na memória
+whos % Exibe todas as variáveis na memória, com seus tipos
+clear % Apaga todas as suas variáveis da memória
+clear('A') % Apaga uma variável em particular
+openvar('A') % Abre a variável no editor de variável
+
+clc % Apaga o conteúdo escrito na sua janela de comando
+diary % Alterna o conteúdo escrito na janela de comando para um arquivo de texto
+ctrl-c % Aborta a computação atual
+
+edit('minhafuncao.m') % Abre a função/script no editor
+type('minhafuncao.m') % Imprime o código-fonte da função/script na janela de comando
+
+profile on    % Ativa o perfil de código
+profile off 	% Desativa o perfil de código
+profile viewer 	% Visualiza os resultados na janela de Profiler
+
+help comando 	% Exibe a documentação do comando na janela de comando
+doc comando 	% Exibe a documentação do comando na janela de ajuda
+lookfor comando % Procura por comando na primeira linha comentada de todas as funções
+lookfor comando -all % Procura por comando em todas as funções
+
+
+% Formatação de saída
+format short 	% 4 casas decimais em um número flutuante
+format long 	% 15 casas decimais
+format bank 	% 2 dígitos após o ponto decimal - para cálculos financeiros
+fprintf('texto') % Imprime na tela "texto"
+disp('texto') 	% Imprime na tela "texto"
+
+% Variáveis & Expressões
+minhaVariavel = 4  % O painel Workspace mostra a variável recém-criada
+minhaVariavel = 4; % Ponto e vírgula suprime a saída para a janela de comando
+4 + 6  		% Resposta = 10
+8 * minhaVariavel 	% Resposta = 32
+2 ^ 3 		% Resposta = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+% A chamada de funções pode ser feita por uma das duas maneiras:
+% Sintaxe de função padrão:
+load('arquivo.mat', 'y') % Argumentos entre parênteses, separados por vírgula
+% Sintaxe de comando:
+load arquivo.mat y 	% Sem parênteses, e espaços ao invés de vírgulas
+% Observe a falta de aspas na forma de comando: entradas são sempre passadas
+% como texto literal - não pode passar valores de variáveis.
+% Além disso, não pode receber saída:
+[V,D] = eig(A);  % Isto não tem um equivalente na forma de comando
+[~,D] = eig(A);  % Se você só deseja D e não V
+
+
+
+% Operadores Lógicos e Relacionais
+1 > 5 % Resposta = 0
+10 >= 10 % Resposta = 1
+3 ~= 4 % Diferente de -> Resposta = 1
+3 == 3 % Igual a -> Resposta = 1
+3 > 1 && 4 > 1 % E -> Resposta = 1
+3 > 1 || 4 > 1 % OU -> Resposta = 1
+~1 % NOT -> Resposta = 0
+
+% Operadores Lógicos e Relacionais podem ser aplicados a matrizes
+A > 5
+% Para cada elemento, caso seja verdade, esse elemento será 1 na matriz retornada
+A( A > 5 )
+% Retorna um vetor com os elementos de A para os quais a condição é verdadeira
+
+% Cadeias de caracteres (Strings)
+a = 'MinhaString'
+length(a) % Resposta = 11
+a(2) % Resposta = i
+[a,a] % Resposta = MinhaStringMinhaString
+
+
+% Vetores de células
+a = {'um', 'dois', 'três'}
+a(1) % Resposta = 'um' - retorna uma célula
+char(a(1)) % Resposta = um - retorna uma string
+
+% Estruturas
+A.b = {'um','dois'};
+A.c = [1 2];
+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:3) % Resposta = 32 53
+x(2:end) % Resposta = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % Vetor coluna
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+
+% Matrizes
+A = [1 2 3; 4 5 6; 7 8 9]
+% Linhas são separadas por um ponto e vírgula;
+% Elementos são separados com espaço ou vírgula
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % Resposta = 6, A(linha, coluna)
+A(6) % Resposta = 8
+% (implicitamente encadeia as colunas do vetor, e então as indexa)
+
+
+A(2,3) = 42 % Atualiza a linha 2 coluna 3 com o valor 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3) % Cria uma nova matriz a partir da antiga
+%Resposta =
+
+%     5     42
+%     8     9
+
+A(:,1) % Todas as linhas na coluna 1
+%Resposta =
+
+%     1
+%     4
+%     7
+
+A(1,:) % Todas as colunas na linha 1
+%Resposta =
+
+%     1     2     3
+
+[A ; A] % Concatenação de matrizes (verticalmente)
+%Resposta =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% Isto é o mesmo de
+vertcat(A,A);
+
+
+[A , A] % Concatenação de matrizes (horizontalmente)
+
+%Resposta =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% Isto é o mesmo de
+horzcat(A,A);
+
+
+A(:, [3 1 2]) % Reorganiza as colunas da matriz original
+%Resposta =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A) % Resposta = 3 3
+
+A(1, :) =[] % Remove a primeira linha da matriz
+A(:, 1) =[] % Remove a primeira coluna da matriz
+
+transpose(A) % Transposta a matriz, que é o mesmo de:
+A one
+ctranspose(A) % Transposta a matriz
+% (a transposta, seguida pelo conjugado complexo de cada elemento)
+
+
+
+
+% Aritmética Elemento por Elemento vs. Aritmética com Matriz
+% Naturalmente, os operadores aritméticos agem em matrizes inteiras. Quando
+% precedidos por um ponto, eles atuam em cada elemento. Por exemplo:
+A * B % Multiplicação de matrizes
+A .* B % Multiplica cada elemento em A por seu correspondente em B
+
+% Existem vários pares de funções nas quais uma atua sob cada elemento, e a
+% outra (cujo nome termina com m) age na matriz por completo.
+exp(A) % Exponencia cada elemento
+expm(A) % Calcula o exponencial da matriz
+sqrt(A) % Tira a raiz quadrada de cada elemento
+sqrtm(A) %  Procura a matriz cujo quadrado é A
+
+
+% Gráficos
+x = 0:.10:2*pi; % Vetor que começa em 0 e termina em 2*pi com incrementos de 0,1
+y = sin(x);
+plot(x,y)
+xlabel('eixo x')
+ylabel('eixo y')
+title('Gráfico de y = sin(x)')
+axis([0 2*pi -1 1]) % x vai de 0 a 2*pi, y vai de -1 a 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % Para várias funções em um só gráfico
+legend('Descrição linha 1', 'Descrição linha 2') % Curvas com uma legenda
+
+% Método alternativo para traçar várias funções em um só gráfico:
+% Enquanto 'hold' estiver ativo, os comandos serão adicionados ao gráfico
+% existente ao invés de o substituirem.
+plot(x, y)
+hold on
+plot(x, z)
+hold off
+
+loglog(x, y) % Plotar em escala loglog
+semilogx(x, y) % Um gráfico com eixo x logarítmico
+semilogy(x, y) % Um gráfico com eixo y logarítmico
+
+fplot (@(x) x^2, [2,5]) % Plotar a função x^2 para x=2 até x=5
+
+grid on % Exibe as linhas de grade; Oculta com 'grid off'
+axis square % Torna quadrada a região dos eixos atuais
+axis equal % Taxa de proporção onde as unidades serão as mesmas em todas direções
+
+scatter(x, y); % Gráfico de dispersão ou bolha
+hist(x); % Histograma
+
+z = sin(x);
+plot3(x,y,z); % Plotar em espaço em 3D
+
+pcolor(A) % Mapa de calor da matriz: traça uma grade de retângulos, coloridos pelo valor
+contour(A) % Plotar de contorno da matriz
+mesh(A) % Plotar malha 3D
+
+h = figure	% Cria uma nova figura objeto, com identificador h
+figure(h) % Cria uma nova janela de figura com h
+close(h) % Fecha a figura h
+close all % Fecha todas as janelas de figuras abertas
+close % Fecha a janela de figura atual
+
+shg % Traz uma janela gráfica existente para frente, ou cria uma nova se necessário
+clf clear % Limpa a janela de figura atual e redefine a maioria das propriedades da figura
+
+% Propriedades podem ser definidas e alteradas através de um identificador.
+% Você pode salvar um identificador para uma figura ao criá-la.
+% A função gcf retorna o identificador da figura atual
+h = plot(x, y); % Você pode salvar um identificador para a figura ao criá-la
+set(h, 'Color', 'r')
+% 'y' amarelo; 'm' magenta, 'c' ciano, 'r' vermelho, 'g' verde, 'b' azul, 'w' branco, 'k' preto
+set(h, 'LineStyle', '--')
+ % '--' linha sólida, '---' tracejada, ':' pontilhada, '-.' traço-ponto, 'none' sem linha
+get(h, 'LineStyle')
+
+
+% A função gca retorna o identificador para os eixos da figura atual
+set(gca, 'XDir', 'reverse'); % Inverte a direção do eixo x
+
+% Para criar uma figura que contém vários gráficos use subplot, o qual divide
+% a janela de gráficos em m linhas e n colunas.
+subplot(2,3,1); % Seleciona a primeira posição em uma grade de 2-por-3
+plot(x1); title('Primeiro Plot') % Plota algo nesta posição
+subplot(2,3,2); % Seleciona a segunda posição na grade
+plot(x2); title('Segundo Plot') % Plota algo ali
+
+
+% Para usar funções ou scripts, eles devem estar no caminho ou na pasta atual
+path % Exibe o caminho atual
+addpath /caminho/para/pasta % Adiciona o diretório ao caminho
+rmpath /caminho/para/pasta % Remove o diretório do caminho
+cd /caminho/para/mudar % Muda o diretório
+
+
+% Variáveis podem ser salvas em arquivos *.mat
+save('meuArquivo.mat') % Salva as variáveis do seu Workspace
+load('meuArquivo.mat') % Carrega as variáveis em seu Workspace
+
+% Arquivos M (M-files)
+% Um arquivo de script é um arquivo externo contendo uma sequência de instruções.
+% Eles evitam que você digite os mesmos códigos repetidamente na janela de comandos.
+% Possuem a extensão *.m
+
+% Arquivos M de Funções (M-file Functions)
+% Assim como scripts e têm a mesma extensão *.m
+% Mas podem aceitar argumentos de entrada e retornar uma saída.
+% Além disso, possuem seu próprio workspace (ex. diferente escopo de variáveis).
+% O nome da função deve coincidir com o nome do arquivo (salve o exemplo como dobra_entrada.m)
+% 'help dobra_entrada.m' retorna os comentários abaixo da linha de início da função
+function output = dobra_entrada(x)
+	%dobra_entrada(x) retorna duas vezes o valor de x
+	output = 2*x;
+end
+dobra_entrada(6) % Resposta = 12
+
+
+% Você também pode ter subfunções e funções aninhadas.
+% Subfunções estão no mesmo arquivo da função primária, e só podem ser chamados
+% por funções dentro do arquivo. Funções aninhadas são definidas dentro de
+% outras funções, e têm acesso a ambos workspaces.
+
+% Se você quer criar uma função sem criar um novo arquivo, você pode usar uma
+% função anônima. Úteis para definir rapidamente uma função para passar a outra
+% função (ex. plotar com fplot, avaliar uma integral indefinida com quad,
+% procurar raízes com fzero, ou procurar mínimo com fminsearch).
+% Exemplo que retorna o quadrado de sua entrada, atribuído ao identificador sqr:
+sqr = @(x) x.^2;
+sqr(10) % Resposta = 100
+doc function_handle % Saiba mais
+
+% Entrada do usuário
+a = input('Digite o valor: ')
+
+% Para a execução do arquivo e passa o controle para o teclado: o usuário pode
+% examinar ou alterar variáveis. Digite 'return' para continuar a execução, ou 'dbquit' para sair
+keyboard
+
+% Leitura de dados (ou xlsread/importdata/imread para arquivos excel/CSV/imagem)
+fopen(nomedoarquivo)
+
+% Saída
+disp(a) % Imprime o valor da variável a
+disp('Olá Mundo') % Imprime a string
+fprintf % Imprime na janela de comandos com mais controle
+
+% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática)
+if (a > 15)
+	disp('Maior que 15')
+elseif (a == 23)
+	disp('a é 23')
+else
+	disp('Nenhuma condição reconheceu')
+end
+
+% Estruturas de Repetição
+% Nota: fazer o loop sobre elementos de um vetor/matriz é lento!
+% Sempre que possível, use funções que atuem em todo o vetor/matriz de uma só vez.
+for k = 1:5
+	disp(k)
+end
+
+k = 0;
+while (k < 5)
+	k = k + 1;
+end
+
+% Tempo de Execução de Código (Timing Code Execution): 'toc' imprime o tempo
+% passado desde que 'tic' foi chamado.
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+% Conectando a uma base de dados MySQL
+dbname = 'nome_base_de_dados';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+%Abaixo, o xx depende da versão, download disponível em http://dev.mysql.com/downloads/connector/j/
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar');
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * FROM nome_tabela WHERE id = 22'] % Exemplo de uma consulta SQL
+a = fetch(conn, sql) %a will contain your data
+
+
+% Funções Matemáticas Comuns
+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 % Números pseudo-aleatórios uniformemente distribuídos
+randi % Inteiros pseudo-aleatórios uniformemente distribuídos
+randn % Números pseudo-aleatórios normalmente distribuídos
+
+% Constantes Comuns
+pi
+NaN
+inf
+
+% Resolvendo equações matriciais (se não houver solução, retorna uma solução de mínimos quadrados)
+% Os operadores \ e / são equivalentes às funções mldivide e mrdivide
+x=A\b % Resolve Ax=b. Mais rápido e numericamente mais preciso do que inv(A)*b.
+x=b/A % Resolve xA=b
+
+inv(A) % Calcula a matriz inversa
+pinv(A) % Calcula a pseudo-inversa
+
+% Funções Matriciais Comuns
+zeros(m,n) % Matriz de zeros m x n
+ones(m,n) % Matriz de 1's m x n
+diag(A) % Extrai os elementos diagonais da matriz A
+diag(x) % Constrói uma matriz com os elementos diagonais listados em x, e zero nas outras posições
+eye(m,n) % Matriz identidade
+linspace(x1, x2, n) % Retorna n pontos igualmente espaçados, com min x1 e max x2
+inv(A) % Inverso da matriz A
+det(A) % Determinante da matriz A
+eig(A) % Valores e vetores próprios de A
+trace(A) % Traço da matriz - equivalente a sum(diag(A))
+isempty(A) % Testa se a matriz está vazia
+all(A) % Testa se todos os elementos são diferentes de zero ou verdadeiro
+any(A) % Testa se algum elemento é diferente de zero ou verdadeiro
+isequal(A, B) % Testa a igualdade de duas matrizes
+numel(A) % Número de elementos na matriz
+triu(x) % Retorna a parte triangular superior de x
+tril(x) % Retorna a parte triangular inferior de x
+cross(A,B) %  Retorna o produto cruzado das matrizes A e B
+dot(A,B) % Retorna o produto escalar de duas matrizes (devem possuir mesmo tamanho)
+transpose(A) % Retorna a matriz transposta de A
+fliplr(A) % Inverte a matriz da esquerda para a direita
+flipud(A) % Inverte a matriz de cima para baixo
+
+% Fatorações de Matrizes
+% Decomposição LU: PA = LU,L é triangular inferior, U é triangular superior, P é a matriz de permutação
+[L, U, P] = lu(A)
+% Decomposição em Autovalores: AP = PD, colunas de P são autovetores e as diagonais de D são autovalores
+[P, D] = eig(A)
+% SVD: XV = US, U e V são matrizes unitárias, S possui elementos não negativos na diagonal em ordem decrescente
+[U,S,V] = svd(X)
+
+% Funções Vetoriais Comuns
+max     % Maior componente
+min     % Menor componente
+length  % Tamanho do vetor
+sort    % Ordena em orcer ascendente
+sum     % Soma de elementos
+prod    % Produto de elementos
+mode	% Valor modal
+median  % Valor mediano
+mean    % Valor médio
+std     % Desvio padrão
+perms(x) % Lista todas as permutações de elementos de x
+
+
+% Classes
+% 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
+classdef ClassePosicoesGPS % O nome da classe.
+  properties % As propriedades da classe comportam-se como estruturas
+    latitude 
+    longitude 
+  end
+  methods 
+    % Este método que tem o mesmo nome da classe é o construtor.
+    function obj = ClassePosicoesGPS(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Outras funções que usam os objetos de PosicoesGPS
+    function r = multiplicarLatPor(obj, n)
+      r = n*[obj.latitude];
+    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:
+    function r = plus(o1,o2)
+      r = ClassePosicoesGPS([o1.latitude] +[o2.latitude], ...
+                        [o1.longitude]+[o2.longitude]);
+    end
+  end
+end
+% End ClassePosicoesGPS.m
+
+% Podemos criar um objeto da classe usando o construtor
+a = ClassePosicoesGPS(45.0, 45.0)
+
+% Propriedades da classe se comportam exatamente como estruturas Matlab
+a.latitude = 70.0
+a.longitude = 25.0
+
+% Métodos podem ser chamados da mesma forma que funções
+ans = multiplicarLatPor(a,3)
+
+% O método também pode ser chamado usando a notação de ponto. Neste caso,
+% 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
+% dois objetos PosicoesGPS.
+b = ClassePosicoesGPS(15.0, 32.0)
+c = a + b
+
+```
+
+## 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/sass-pt.html.markdown b/pt-br/sass-pt.html.markdown
new file mode 100644
index 00000000..105896b2
--- /dev/null
+++ b/pt-br/sass-pt.html.markdown
@@ -0,0 +1,477 @@
+---
+language: sass
+filename: learnsass-pt.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+translators:
+  - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+Sass é uma linguagem de extensão CSS que adiciona recursos, como variáveis, aninhamento, mixins e muito mais.
+Sass (e outros pré-processadores, como [Less](http://lesscss.org/)) ajudam os desenvolvedores a escrever código de fácil manutenção e DRY (Do not Repeat Yourself).
+
+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.
+
+```scss
+
+
+// Comentários de linha única são removidos quando Sass é compilado para CSS.
+
+/* Comentários multi-line são preservados. */
+
+
+
+/*Variáveis
+==============================*/
+
+
+
+/* É possível armazenar um valor CSS (tais como a cor) de uma variável.
+Use o símbolo "$" para criar uma variável. */
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Você pode usar as variáveis em toda a sua folha de estilo.
+Agora, se você quer mudar a cor, você só tem que fazer a mudança uma vez. */
+
+body {
+	background-color: $primary-color;
+	color: $secondary-color;
+	font-family: $body-font;
+}
+
+/* Quando compilar ficaria assim: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/ * Este é muito mais fácil de manter do que ter de mudar a cor
+cada vez que aparece em toda a sua folha de estilo. * /
+
+
+
+
+/*Mixins
+==============================*/
+
+
+
+/* Se você achar que você está escrevendo o mesmo código para mais de um
+elemento, você pode querer armazenar esse código em um mixin.
+
+Use a diretiva '@mixin', além de um nome para o seu mixin. */
+
+@mixin center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Você pode usar o mixin com '@include' e o nome mixin. */
+
+div {
+	@include center;
+	background-color: $primary-color;
+}
+
+/* Apoś compilar ficaria assim: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+
+/* Você pode usar mixins para criar uma propriedade estenográfica. */
+
+@mixin size($width, $height) {
+	width: $width;
+	height: $height;
+}
+
+/* O que você pode invocar passando argumentos de largura e altura. */
+
+.rectangle {
+	@include size(100px, 60px);
+}
+
+.square {
+	@include size(40px, 40px);
+}
+
+/* Isso compilado ficará assim: */
+.rectangle {
+  width: 100px;
+  height: 60px;
+}
+
+.square {
+  width: 40px;
+  height: 40px;
+}
+
+
+
+/*Funções
+==============================*/
+
+
+
+/* Sass fornece funções que podem ser utilizados para realizar uma variedade de
+    tarefas. Considere o seguinte */
+
+/* Funções pode ser chamado usando seu nome e passando o
+    argumentos necessários */
+body {
+  width: round(10.25px);
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25)
+}
+
+/* Compiles to: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* You may also define your own functions. Functions are very similar to
+   mixins. When trying to choose between a function or a mixin, remember
+   that mixins are best for generating CSS while functions are better for
+   logic that might be used throughout your Sass code. The examples in
+   the Math Operators' section are ideal candidates for becoming a reusable
+   function. */
+
+/* This function will take a target size and the parent size and calculate
+   and return the percentage */
+
+/* Você também pode definir suas próprias funções. As funções são muito semelhantes aos
+   mixins. Ao tentar escolher entre uma função ou um mixin, lembre-
+   que mixins são os melhores para gerar CSS enquanto as funções são melhores para
+   lógica que pode ser usado em todo o seu código Sass. Os exemplos
+   seção Operadores Math 'são candidatos ideais para se tornar um reutilizável
+   função. */
+
+/* Esta função terá um tamanho de destino eo tamanho do pai e calcular
+   e voltar a percentagem */
+
+@function calculate-percentage($target-size, $parent-size) {
+  @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+  width: $main-content;
+}
+
+.sidebar {
+  width: calculate-percentage(300px, 960px);
+}
+
+/* Compila para: */
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+
+
+/* Extend (Herança)
+============================== */
+
+
+
+/*Extend é uma maneira de compartilhar as propriedades de um seletor com outro. */
+
+.display {
+	@include size(5em, 5em);
+	border: 5px solid $secondary-color;
+}
+
+.display-success {
+	@extend .display;
+	border-color: #22df56;
+}
+
+/* Compiles to: */
+.display, .display-success {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F;
+}
+
+.display-success {
+  border-color: #22df56;
+}
+
+/* Ampliando uma declaração CSS é preferível a criação de um mixin
+   por causa da maneira agrupa as classes que todos compartilham
+   o mesmo estilo base. Se isso for feito com um mixin, a largura,
+   altura, e a borda seria duplicado para cada instrução que
+   o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
+   adicionar inchaço desnecessário para os arquivos criados pelo compilador Sass. */
+
+
+
+/*Assentamento
+==============================*/
+
+
+
+/ * Sass permite seletores ninhos dentro seletores * /
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #FF0000;
+	}
+}
+
+/* '&' será substituído pelo selector pai. */
+/* 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.
+Por exemplo: */
+
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: red;
+
+		&:hover {
+		  background-color: blue;
+		}
+
+		a {
+		  color: white;
+		}
+	}
+}
+
+/* Compila para: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/*Parciais e Importações
+==============================*/
+
+
+/* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass
+   código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
+   Parciais não são geradas em CSS. */
+
+
+
+/* Considere o seguinte CSS que nós vamos colocar em um arquivo chamado _reset.css */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Sass offers @import which can be used to import partials into a file.
+   This differs from the traditional CSS @import statement which makes
+   another HTTP request to fetch the imported file. Sass takes the
+   imported file and combines it with the compiled code. */
+
+/* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
+   Isso difere da declaração CSS @import tradicional, que faz
+   outra solicitação HTTP para buscar o arquivo importado. Sass converte os
+   importadas arquivo e combina com o código compilado. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compiles to: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/*Placeholder Selectors
+==============================*/  
+
+
+
+/* Placeholders are useful when creating a CSS statement to extend. If you
+   wanted to create a CSS statement that was exclusively used with @extend,
+   you can do so using a placeholder. Placeholders begin with a '%' instead
+   of '.' or '#'. Placeholders will not appear in the compiled CSS. */
+
+/* Os espaços reservados são úteis na criação de uma declaração CSS para ampliar. Se você
+   queria criar uma instrução CSS que foi usado exclusivamente com @extend,
+   Você pode fazer isso usando um espaço reservado. Espaços reservados começar com um '%' em vez
+   de '.' ou '#'. Espaços reservados não aparece no CSS compilado. * /
+
+%content-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  @extend %content-window;
+  background-color: #0000ff;
+}
+
+/* Compilado para: */
+
+.message-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  background-color: #0000ff;
+}
+
+
+
+/*Operações Math
+============================== * /
+
+
+/* Sass provides the following operators: +, -, *, /, and %. These can
+   be useful for calculating values directly in your Sass files instead
+   of using values that you've already calculated by hand. Below is an example
+   of a setting up a simple two column design. */
+
+/* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
+   ser úteis para calcular os valores diretamente no seu Sass arquivos em vez
+   de usar valores que você já calculados pela mão. Abaixo está um exemplo
+   de uma criação de um projeto simples de duas colunas. * /
+
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: $main-size;
+}
+
+.sidebar {
+  width: $sidebar-size;
+}
+
+.gutter {
+  width: $gutter;
+}
+
+/* Compiles to: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+
+
+## SASS ou Sass?
+Alguma vez você já se perguntou se Sass é um acrônimo ou não? Você provavelmente não tem, mas vou dizer-lhe de qualquer maneira. O nome do idioma é uma palavra, "Sass", e não uma sigla.
+Porque as pessoas estavam constantemente a escrevê-lo como "SASS", o criador da linguagem de brincadeira chamou de "StyleSheets Sintaticamente Incríveis".
+
+
+## Prática Sass
+Se você quiser jogar com Sass em seu navegador, vá para [SassMeister](http://sassmeister.com/).
+Você pode usar uma sintaxe, basta ir para as configurações e selecionar Sass ou SCSS.
+
+
+## Compatibilidade
+
+Sass pode ser usado em qualquer projeto, desde que você tenha um programa para compilá-lo
+em CSS. Você vai querer verificar se o CSS que você está usando é compatível
+com os seus navegadores de destino.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) e [CanIUse](http://caniuse.com) são ótimos recursos para verificação de compatibilidade.
+
+
+## Leitura
+* [Official Documentation](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) fornece tutoriais (iniciante avançados) e artigos.
diff --git a/pt-br/swift-pt.html.markdown b/pt-br/swift-pt.html.markdown
index 72a57e4a..e840b8cf 100644
--- a/pt-br/swift-pt.html.markdown
+++ b/pt-br/swift-pt.html.markdown
@@ -221,7 +221,7 @@ println("Gas price: \(price)")
 
 // Número variável de argumentos
 func setup(numbers: Int...) {
-    // its an array
+    // é um array
     let number = numbers[0]
     let argCount = numbers.count
 }
diff --git a/pt-br/tmux-pt.html.markdown b/pt-br/tmux-pt.html.markdown
new file mode 100644
index 00000000..9d5bf292
--- /dev/null
+++ b/pt-br/tmux-pt.html.markdown
@@ -0,0 +1,254 @@
+---
+category: tool
+tool: tmux
+contributors:
+    - ["mdln", "https://github.com/mdln"]
+translators:
+    - ["Luis Custodio", "http://luiscustodio.com"]
+lang: pt-br
+filename: LearnTmux-pt.txt
+---
+
+O [tmux](http://tmux.sourceforge.net)
+é um multiplexador de terminal, ele permite que terminais sejam criados,
+acessados e controlados a partir de uma unica instância. tmux pode ser separado
+de uma tela e continuar rodando no plano de fundo e depois ser reacoplado à
+instância (ou tela original).
+
+```
+
+  tmux [command]     # Roda um [comando]
+                     # 'tmux' sem comandos irá criar uma nova seção
+
+    new              # Cria uma nova seção
+     -s "Nome"       # Cria uma nova seção com nome "Nome"
+     -n "Janela"     # Cria uma janela com o nome "Janela"
+     -c "/dir"       # Inícia em uma pasta específica
+
+    attach           # Reacopla a última seção disponível
+     -t "#"          # Reacopla a seção com nome "#"
+     -d              # Separa (Desacopla) a sessaão de outras instâncias.
+
+    ls               # Lista todas as seções
+     -a              # Lista todas as seções abertas
+
+    lsw              # Lista as janelas
+     -a              # Lista todas as janelas
+     -s              # Lista todas janleas em uma seção
+
+    lsp              # Lista os painéis
+     -a              # Lista todos os painéis
+     -s              # Lista todos os painéis em uma seção
+     -t "#"          # Lista os painéis baseado no nome "#"
+
+    kill-window      # Encerrar a janela corrente
+     -t "#"          # Encerrar a janela baseado no nome "#"
+     -a              # Encerrar todas as janelas
+     -a -t "#"       # Encerrar todas as janelas exceto a com nome "#"
+
+    kill-session     # Encerrar seção corrente
+     -t "#"          # Encerrar seção com nome "#"
+     -a              # Encerrar todas as seções
+     -a -t "#"       # Encerrar todas as seções exceto a com nome "#"
+
+```
+
+
+### Teclas de atalhos (comandos)
+
+A maneira de controllar uma seção tmux acoplada é através de uma
+combinação de teclas de prefixo.
+
+```
+----------------------------------------------------------------------
+  (C-b) = Ctrl + b    # Combinação de prefixos para usar comandos(atalhos).
+
+  (M-1) = Meta + 1 -or- Alt + 1
+----------------------------------------------------------------------
+
+  ?           # Lista todos os comandos.
+  :           # Acessa o lugar (prompt command) para receber comandos do tmux
+  r           # Força a redefiniçao do cliente acoplado.
+  c           # Cria uma nova janela.
+
+  !           # Retira o painel corrente da janela.
+  %           # Divide o painel corrente em dois para a esquerda e direita.
+  "           # Divide o painel corrente em dois para cima e para baixo.
+
+  n           # Move para a próxima janela.
+  p           # Move para a janela anterior.
+  {           # Troca o painel corrente pelo anterior.
+  }           # Troca o painel corrent pelo posterior.
+
+  s           # Seleciona uma nova seção para o cliente acoplado iterativamente.
+  w           # Seleciona a janela corrente iterativamente.
+  0 to 9      # Seleciona a janela de 0 à 9.
+
+  d           # Separa o cliente atual.
+  D           # Seleciona um cliente a ser separado.
+
+  &           # Encerra a janela corrente.
+  x           # Encerra o painel corrente.
+
+  Up, Down    # Move para o painel acima, abaixo, a esquerda ou a direita.
+  Left, Right
+
+  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 corrente baseado em uma célula.
+  C-Left, C-Right
+
+  M-Up, M-Down    # Altera o tamanho do painel corrente baseado em cinco células.
+  M-Left, M-Right
+
+```
+
+
+### Configurando ~/.tmux.conf
+
+Existe um arquivo chamado tmux.conf, ele pode ser usado para definir opções no
+ momento de inicialização, da mesma maneira que .vimrc, init.el, .bash_profile são usados.
+
+
+```
+# Exemplo de tmux.conf
+# 2014.10
+
+
+### General
+###########################################################################
+
+# Habilita UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Limite da história de comandos
+set -g history-limit 2048
+
+# Indíce de inicialização
+set -g base-index 1
+
+# Mouse
+set-option -g mouse-select-pane on
+
+# Recarregar o arquivo de configuração sem a necessidade de reiniciar o programa
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Teclas de atalho
+###########################################################################
+
+# Desvincular C-b como prefixo padrão.
+unbind C-b
+
+# Define um novo prefixo padrão.
+set-option -g prefix `
+
+# Definir prefixos que podem ser usados para voltar para a janela anterior.
+bind C-a last-window
+bind ` last-window
+
+# Fazer com que F11 e F12 alterem o comportamento de C-a e `
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Preferencia de teclas de atalho
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Mover enter paineis com teclas de orientaçao do vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Iterar entre as Janelas
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Iterar entre os painéis
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+# Habilitar a sub-seção a enviar comandos.
+bind a send-prefix
+
+
+### Theme
+###########################################################################
+
+# Paleta de cores para a barra de status
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Paleta de cores para bordas do painel
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Palta de cores para mensagem
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Paleta de cores para janela de status
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notificações
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Definir automaticamente o título de janelas
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Ajustes na barra de status
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Mostrar indicativos de performance na barra de status
+# Requires https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Referências
+
+[Tmux | Início](http://tmux.sourceforge.net)
+
+[Manual Tmux (em inglês)](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Mostrar CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
+
+Possui uma sugestão? Uma correção, talvez? Abra um issue no Repositório GitHub, ou então faça um pull request.
diff --git a/pt-pt/scala-pt.html.markdown b/pt-pt/scala-pt.html.markdown
new file mode 100644
index 00000000..a4c1c02b
--- /dev/null
+++ b/pt-pt/scala-pt.html.markdown
@@ -0,0 +1,651 @@
+---
+language: Scala
+filename: learnscala-pt.scala
+contributors:
+    - ["George Petrov", "http://github.com/petrovg"]
+    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Ha-Duong Nguyen", "http://reference-error.org"]
+translators:
+    - ["João Costa", "http://joaocosta.eu"]
+lang: pt-pt
+---
+
+Scala - a linguagem escalável
+
+```scala
+
+/*
+  Prepare tudo:
+
+  1) Faça Download do Scala - http://www.scala-lang.org/downloads
+  2) Faça unzip/untar para onde preferir e coloque o subdirectório `bin` na
+     variável de ambiente `PATH`
+  3) Inicie a REPL de Scala correndo o comando `scala`. Deve aparecer:
+
+  scala>
+
+  Isto é chamado de REPL (Read-Eval-Print Loop / Lê-Avalia-Imprime Repete).
+  Pode escrever qualquer expressão de Scala e o resultado será imprimido.
+  Vamos mostrar ficheiros de Scala mais à frente neste tutorial mas, para já,
+  vamos começar com os básicos.
+
+*/
+
+
+/////////////////////////////////////////////////
+// 1. Basicos
+/////////////////////////////////////////////////
+
+// Uma linha de comentários é marcada com duas barras
+
+/*
+  Comentários de multiplas linhas, como se pode ver neste exemplo, são assim.
+*/
+
+// Imprimir, forçando uma nova linha no final
+println("Hello world!")
+println(10)
+
+// Imprimir, sem forçar uma nova linha no final
+print("Hello world")
+
+// Valores são declarados com var ou val.
+// As declarações val são imutáveis, enquanto que vars são mutáveis.
+// A immutabilidade é uma propriedade geralmente vantajosa.
+val x = 10 // x é agora 10
+x = 20     // erro: reatribuição de um val
+var y = 10
+y = 20     // y é agora 12
+
+/*
+  Scala é uma linguagem estaticamente tipada, no entanto, nas declarações acima
+  não especificamos um tipo. Isto é devido a uma funcionalidade chamada
+  inferência de tipos. Na maior parte dos casos, o compilador de scala consegue
+  inferir qual o tipo de uma variável, pelo que não o temos de o declarar sempre.
+  Podemos declarar o tipo de uma variável da seguinte forma:
+*/
+val z: Int = 10
+val a: Double = 1.0
+
+// Note a conversão automática de Int para Double: o resultado é 10.0, não 10
+val b: Double = 10
+
+// Valores booleanos
+true
+false
+
+// Operações booleanas
+!true         // false
+!false        // true
+true == false // false
+10 > 5        // true
+
+// A matemática funciona da maneira habitual
+1 + 1   // 2
+2 - 1   // 1
+5 * 3   // 15
+6 / 2   // 3
+6 / 4   // 1
+6.0 / 4 // 1.5
+
+
+// Avaliar expressões na REPL dá o tipo e valor do resultado
+
+1 + 7
+
+/* A linha acima resulta em:
+
+  scala> 1 + 7
+  res29: Int = 8
+
+  Isto significa que o resultado de avaliar 1 + 7 é um objecto do tipo Int com
+  o valor 8.
+
+  Note que "res29" é um nome de uma variavel gerado sequencialmente para
+  armazenar os resultados das expressões que escreveu, por isso o resultado
+  pode ser ligeiramente diferente.
+*/
+
+"Strings em scala são rodeadas por aspas"
+'a' // Um caracter de Scala
+// 'Strings entre plicas não existem' <= Isto causa um erro
+
+// Strings tem os métodos de Java habituais definidos
+"olá mundo".length
+"olá mundo".substring(2, 6)
+"olá mundo".replace("á", "é")
+
+// Para além disso, também possuem métodos de Scala.
+// Ver: scala.collection.immutable.StringOps
+"olá mundo".take(5)
+"olá mundo".drop(5)
+
+// Interpolação de Strings: repare no prefixo "s"
+val n = 45
+s"Temos $n maçãs" // => "Temos 45 maçãs"
+
+// Expressões dentro de Strings interpoladas também são possíveis
+val a = Array(11, 9, 6)
+s"A minha segunda filha tem ${a(0) - a(2)} anos." // => "A minha segunda filha tem 5 anos."
+s"Temos o dobro de ${n / 2.0} em maçãs."          // => "Temos o dobro de 22.5 em maçãs."
+s"Potência de 2: ${math.pow(2, 2)}"               // => "Potência de 2: 4"
+
+// Strings interpoladas são formatadas com o prefixo "f"
+f"Potência de 5: ${math.pow(5, 2)}%1.0f"     // "Potência de 5: 25"
+f"Raíz quadrada 122: ${math.sqrt(122)}%1.4f" // "Raíz quadrada de 122: 11.0454"
+
+// Strings prefixadas com "raw" ignoram caracteres especiais
+raw"Nova linha: \n. Retorno: \r." // => "Nova Linha: \n. Retorno: \r."
+
+// Alguns caracteres tem de ser "escapados", e.g. uma aspa dentro de uma string:
+"Esperaram fora do  \"Rose and Crown\"" // => "Esperaram fora do "Rose and Crown""
+
+// Strings rodeadas por três aspas podem-se estender por varias linhas e conter aspas
+val html = """<form id="daform">
+                <p>Carrega aqui, Zé</p>
+                <input type="submit">
+              </form>"""
+
+
+/////////////////////////////////////////////////
+// 2. Funções
+/////////////////////////////////////////////////
+
+// Funções são definidas como:
+//
+//   def nomeDaFuncao(args...): TipoDeRetorno = { corpo... }
+//
+// Se vem de linugagens mais tradicionais, repare na omissão da palavra
+// return keyword. Em Scala, a ultima expressão de um bloco é o seu
+// valor de retorno
+def somaQuadrados(x: Int, y: Int): Int = {
+  val x2 = x * x
+  val y2 = y * y
+  x2 + y2
+}
+
+// As { } podem ser omitidas se o corpo da função for apenas uma expressão:
+def somaQuadradosCurto(x: Int, y: Int): Int = x * x + y * y
+
+// A sintaxe para chamar funções deve ser familiar:
+somaQuadrados(3, 4)  // => 25
+
+// Na maior parte dos casos (sendo funções recursivas a principal excepção), o
+// tipo de retorno da função pode ser omitido, sendo que a inferencia de tipos
+// é aplicada aos valores de retorno
+def quadrado(x: Int) = x * x  // O compilador infere o tipo de retorno Int
+
+// Funções podem ter parâmetros por omissão:
+def somaComOmissão(x: Int, y: Int = 5) = x + y
+somaComOmissão(1, 2) // => 3
+somaComOmissão(1)    // => 6
+
+
+// Funções anónimas são definidas da seguinte forma:
+(x: Int) => x * x
+
+// Ao contrário de defs, o tipo de input de funções anónimas pode ser omitido
+// se o contexto o tornar óbvio. Note que o tipo "Int => Int" representa uma
+// funão que recebe Int e retorna Int.
+val quadrado: Int => Int = x => x * x
+
+// Funcões anónimas são chamadas como funções normais:
+quadrado(10)   // => 100
+
+// Se cada argumento de uma função anónima for usado apenas uma vez, existe
+// uma forma ainda mais curta de os definir. Estas funções anónumas são
+// extremamente comuns, como será visto na secção sobre estruturas de dados.
+val somaUm: Int => Int = _ + 1
+val somaEstranha: (Int, Int) => Int = (_ * 2 + _ * 3)
+
+somaUm(5)          // => 6
+somaEstranha(2, 4) // => 16
+
+
+// O código return existe em Scala, mas apenas retorna do def mais interior
+// que o rodeia.
+// AVISO: Usar return em Scala deve ser evitado, pois facilmente leva a erros.
+// Não tem qualquer efeito em funções anónimas, por exemplo:
+def foo(x: Int): Int = {
+  val funcAnon: Int => Int = { z =>
+    if (z > 5)
+      return z // Esta linha faz com que z seja o retorno de foo!
+    else
+      z + 2    // Esta linha define o retorno de funcAnon
+  }
+  funcAnon(x)  // Esta linha define o valor de retorno de foo
+}
+
+
+/////////////////////////////////////////////////
+// 3. Controlo de fluxo
+/////////////////////////////////////////////////
+
+1 to 5
+val r = 1 to 5
+r.foreach(println)
+
+r foreach println
+// NB: Scala é bastante brando no que toca a pontos e parentisis - estude as
+// regras separadamente. Isto permite escrever APIs e DSLs bastante legiveis
+
+(5 to 1 by -1) foreach (println)
+
+// Ciclos while
+var i = 0
+while (i < 10) { println("i " + i); i += 1 }
+
+while (i < 10) { println("i " + i); i += 1 }   // Sim, outra vez. O que aconteceu? Porquê?
+
+i    // Mostra o valor de i. Note que o while é um ciclo no sentido clássico -
+     // executa sequencialmente enquanto muda uma variável. Ciclos while são
+     // rápidos, por vezes até mais que ciclos de Java, mas combinadores e
+     // compreensões (usados anteriormente) são mais fáceis de entender e
+     // paralelizar
+
+// Um ciclo do while
+i = 0
+do {
+  println("i ainda é menor que 10")
+  i += 1
+} while (i < 10)
+
+// A forma idiomática em Scala de definir acções recorrentes é através de
+// recursão em cauda.
+// Funções recursivas necessitam de um tipo de retorno definido explicitamente.
+// Neste caso, é Unit.
+def mostraNumerosEntre(a: Int, b: Int): Unit = {
+  print(a)
+  if (a < b)
+    mostraNumerosEntre(a + 1, b)
+}
+mostraNumerosEntre(1, 14)
+
+
+// Condicionais
+
+val x = 10
+
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println ("yeah") else println("nay")
+
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+
+
+/////////////////////////////////////////////////
+// 4. Estruturas de dados
+/////////////////////////////////////////////////
+
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)
+a(3)
+a(21)    // Lança uma excepção
+
+val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+m("fork")
+m("spoon")
+m("bottle")       // Lança uma excepção
+
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle")
+
+val s = Set(1, 3, 7)
+s(0)
+s(1)
+
+/* Veja a documentação de mapas de scala em -
+ * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ * e verifique que a consegue aceder
+ */
+
+
+// Tuplos
+
+(1, 2)
+
+(4, 3, 2)
+
+(1, 2, "três")
+
+(a, 2, "três")
+
+// Porquê ter isto?
+val divideInts = (x: Int, y: Int) => (x / y, x % y)
+
+divideInts(10, 3) // A função divideInts returna o resultado e o resto
+
+// Para aceder aos elementos de um tuplo, pode-se usar _._n, onde n é o indice
+// (começado em 1) do elemento
+val d = divideInts(10, 3)
+
+d._1
+
+d._2
+
+
+/////////////////////////////////////////////////
+// 5. Programação Orientada a Objectos
+/////////////////////////////////////////////////
+
+/*
+  Aparte: Até agora tudo o que fizemos neste tutorial foram expressões simples
+  (valores, funções, etc). Estas expressões são suficientes para executar no
+  interpretador da linha de comandos para testes rápidos, mas não podem existir
+  isoladas num ficheiro de Scala. Por exemplo, não é possivel correr um
+  ficheiro scala que apenas contenha "val x = 5". Em vez disso, as únicas
+  construções de topo permitidas são:
+
+  - object
+  - class
+  - case class
+  - trait
+
+  Vamos agora explicar o que são:
+*/
+
+// Classes são semelhantes a classes noutras linguagens. Os argumentos do
+// construtor são declarados após o nome da classe, sendo a inicialização feita
+// no corpo da classe.
+class Cão(rc: String) {
+  // Código de construção
+  var raça: String = rc
+
+  // Define um método chamado "ladra", que retorna uma String
+  def ladra = "Woof, woof!"
+
+  // Valores e métodos são assumidos como públicos, mas é possivel usar
+  // os códigos "protected" and "private".
+  private def dormir(horas: Int) =
+    println(s"Vou dormir por $horas horas")
+
+  // Métodos abstractos são métodos sem corpo. Se descomentarmos a próxima
+  // linha, a classe Cão é declarada como abstracta
+  //   abstract class Cão(...) { ... }
+  // def persegue(oQue: String): String
+}
+
+val oMeuCão = new Cão("greyhound")
+println(oMeuCão.raça)  // => "greyhound"
+println(oMeuCão.ladra) // => "Woof, woof!"
+
+
+// O termo "object" cria um tipo e uma instancia singleton desse tipo. É comum
+// que classes de Scala possuam um "objecto companheiro", onde o comportamento
+// por instância é capturado nas classes, equanto que o comportamento
+// relacionado com todas as instancias dessa classe ficam no objecto.
+// A diferença é semelhante a métodos de classes e métodos estáticos noutras
+// linguagens. Note que objectos e classes podem ter o mesmo nome.
+object Cão {
+  def raçasConhecidas = List("pitbull", "shepherd", "retriever")
+  def criarCão(raça: String) = new Cão(raça)
+}
+
+
+// Case classes são classes com funcionalidades extra incluidas. Uma questão
+// comum de iniciantes de scala é quando devem usar classes e quando devem usar
+// case classes. A linha é difusa mas, em geral, classes tendem a concentrar-se
+// em encapsulamento, polimorfismo e comportamento. Os valores nestas classes
+// tendem a ser privados, sendo apenas exposotos métodos. O propósito principal
+// das case classes é armazenarem dados imutáveis. Geralmente possuem poucos
+// métods, sendo que estes raramente possuem efeitos secundários.
+case class Pessoa(nome: String, telefone: String)
+
+// Cria uma nova instancia. De notar que case classes não precisam de "new"
+val jorge = Pessoa("Jorge", "1234")
+val cátia = Pessoa("Cátia", "4567")
+
+// Case classes trazem algumas vantagens de borla, como acessores:
+jorge.telefone  // => "1234"
+
+// Igualdade por campo (não é preciso fazer override do .equals)
+Pessoa("Jorge", "1234") == Pessoa("Cátia", "1236")  // => false
+
+// Cópia simples
+// outroJorge == Person("jorge", "9876")
+val outroJorge = jorge.copy(telefone = "9876")
+
+// Entre outras. Case classes também suportam correspondência de padrões de
+// borla, como pode ser visto de seguida.
+
+
+// Traits em breve!
+
+
+/////////////////////////////////////////////////
+// 6. Correspondência de Padrões
+/////////////////////////////////////////////////
+
+// A correspondência de padrões é uma funcionalidade poderosa e bastante
+// utilizada em Scala. Eis como fazer correspondência de padrões numa case class:
+// Nota: Ao contrário de outras linguagens, cases em scala não necessitam de
+// breaks, a computação termina no primeiro sucesso.
+
+def reconhecePessoa(pessoa: Pessoa): String = pessoa match {
+  // Agora, especifique os padrões:
+  case Pessoa("Jorge", tel) => "Encontramos o Jorge! O seu número é " + tel
+  case Pessoa("Cátia", tel) => "Encontramos a Cátia! O seu número é " + tel
+  case Pessoa(nome, tel)    => "Econtramos alguém : " + nome + ", telefone : " + tel
+}
+
+val email = "(.*)@(.*)".r  // Define uma regex para o próximo exemplo.
+
+// A correspondência de padrões pode parecer familiar aos switches em linguagens
+// derivadas de C, mas é muto mais poderoso. Em Scala, é possível fazer
+// correspondências com muito mais:
+def correspondeTudo(obj: Any): String = obj match {
+  // Pode-se corresponder valores:
+  case "Olá mundo" => "Recebi uma string Olá mundo."
+
+  // Corresponder por tipo:
+  case x: Double => "Recebi um Double: " + x
+
+  // Corresponder tendo em conta condições especificas:
+  case x: Int if x > 10000 => "Recebi um número bem grande!"
+
+  // Fazer correspondências com case classes (visto anteriormente):
+  case Pessoa(nome, tel) => s"Recebi o contacto para $nome!"
+
+  // Fazer correspondência com expressões regulares:
+  case email(nome, dominio) => s"Recebi o endereço de email $nome@$dominio"
+
+  // Corresponder tuplos:
+  case (a: Int, b: Double, c: String) => s"Recebi o tuplo: $a, $b, $c"
+
+  // Corresponder estruturas de dados:
+  case List(1, b, c) => s"Recebi uma lista de 3 elementos começada em 1: 1, $b, $c"
+
+  // Combinar padrões:
+  case List(List((1, 2, "YAY"))) => "Recebi uma lista de lista de triplo"
+}
+
+// Na realidade, é possível fazer correspondência com qualquer objecto que
+// defina o método "unapply". Esta funcionalidade é tão poderosa que permite
+// definir funções sob a forma de padrões:
+val funcPaddrao: Pessoa => String = {
+  case Pessoa("Jorge", tel) => s"Número do Jorge: $tel"
+  case Pessoa(nome, tel)    => s"Número de alguém: $tel"
+}
+
+
+/////////////////////////////////////////////////
+// 7. Programação Funcional
+/////////////////////////////////////////////////
+
+// Scala permite que funções e métodos retornem, ou recebam como parámetros,
+// outras funções ou métodos
+
+val soma10: Int => Int = _ + 10 // Função que recebe um Int e retorna um Int
+List(1, 2, 3) map soma10 // List(11, 12, 13) - soma10 é aplicado a cada elemento
+
+// Funções anónimas também podem ser usadas
+List(1, 2, 3) map (x => x + 10)
+
+// Sendo que o símbolo _ também pode ser usado se a função anónima só receber
+// um argumento. Este fica com o valor da variável
+List(1, 2, 3) map (_ + 10)
+
+// Se tanto o bloco como a função apenas receberem um argumento, o próprio
+// _ pode ser omitido
+List("Dom", "Bob", "Natalia") foreach println
+
+
+// Combinadores
+
+s.map(quadrado)
+
+val sQuadrado = s.map(quadrado)
+
+sQuadrado.filter(_ < 10)
+
+sQuadrado.reduce (_+_)
+
+// O método filter recebe um predicado (uma função de A => Boolean) e escolhe
+// todos os elementos que satisfazem o predicado
+List(1, 2, 3) filter (_ > 2) // List(3)
+case class Pessoa(nome: String, idade: Int)
+List(
+  Pessoa(nome = "Dom", idade = 23),
+  Pessoa(nome = "Bob", idade = 30)
+).filter(_.idade > 25) // List(Pessoa("Bob", 30))
+
+
+// O método foreach recebe uma função de A => Unit, executando essa função em
+// cada elemento da colecção
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
+aListOfNumbers foreach (x => println(x))
+aListOfNumbers foreach println
+
+// Compreensões For
+
+for { n <- s } yield quadrado(n)
+
+val nQuadrado2 = for { n <- s } yield quadrado(n)
+
+for { n <- nQuadrado2 if n < 10 } yield n
+
+for { n <- s; nQuadrado = n * n if nQuadrado < 10} yield nQuadrado
+
+/* Nota: isto não são ciclos for: A semântica de um ciclo é 'repetir', enquanto
+   que uma compreensão define a relação entre dois conjuntos de dados. */
+
+
+/////////////////////////////////////////////////
+// 8. Implicitos
+/////////////////////////////////////////////////
+
+/* AVISO IMPORTANTE: Implicitos são um conjunto de funcionalidades muito
+ * poderosas em Scala, que podem ser fácilmente abusadas. Iniciantes devem
+ * resistir a tentação de usá-los até que compreendam não só como funcionam,
+ * mas também as melhores práticas. Apenas incluimos esta secção no tutorial
+ * devido a estes serem tão comuns em bibliotecas de Scala que muitas delas
+ * se tornam impossíveis de usar sem conhecer implicitos. Este capítulo serve
+ * para compreender como trabalhar com implicitos, não como declará-los.
+*/
+
+// Qualquer valor (vals, funções, objectos, etc) pode ser declarado como
+// implicito usando a palavra "implicit". Vamos usar a classe Cão da secção 5
+// nestes exemplos
+
+implicit val oMeuIntImplicito = 100
+implicit def aMinhaFunçãoImplicita(raça: String) = new Cão("Golden " + raça)
+
+// Por si só, a palavra implicit não altera o comportamento de um valor, sendo
+// que estes podem ser usados da forma habitual.
+oMeuIntImplicito + 2                   // => 102
+aMinhaFunçãoImplicita("Pitbull").raça // => "Golden Pitbull"
+
+// A diferença é que estes valores podem ser utilizados quando outro pedaço de
+// código "necessite" de uma valor implicito. Um exemplo são argumentos
+// implicitos de funções:
+def enviaCumprimentos(aQuem: String)(implicit quantos: Int) =
+  s"Olá $aQuem, $quantos cumprimentos para ti e para os teus!"
+
+// Se dermos um valor a "quantos", a função comporta-se normalmente
+enviaCumprimentos("João")(1000)  // => "Olá João, 1000 cumprimentos para ti e para os teus!"
+
+// Mas, se omitirmos o parâmetro implicito, um valor implicito do mesmo tipo é
+// usado, neste caso, "oMeuInteiroImplicito"
+enviaCumprimentos("Joana")  // => "Olá Joana, 100 cumprimentos para ti e para os teus!"
+
+// Parâmentros implicitos de funções permitem-nos simular classes de tipos de
+// outras linguagens funcionais. Isto é tão comum que tem a sua própria notação.
+// As seguintes linhas representam a mesma coisa
+// def foo[T](implicit c: C[T]) = ...
+// def foo[T : C] = ...
+
+
+// Outra situação em que o compilador prouca um implicito é se encontrar uma
+// expressão
+//    obj.método(...)
+// mas "obj" não possuir um método chamado "método". Neste cso, se houver uma
+// conversão implicita A => B, onde A é o tipo de obj, e B possui um método
+// chamado "método", a conversão é aplicada. Ou seja, tendo
+// aMinhaFunçãoImplicita definida, podemos dizer
+"Retriever".raça // => "Golden Retriever"
+"Sheperd".ladra  // => "Woof, woof!"
+
+// Neste caso, a String é primeiro convertida para Cão usando a nossa funão,
+// sendo depois chamado o método apropriado. Esta é uma funcionalidade
+// incrivelmente poderosa, sendo que deve ser usada com cautela. Na verdade,
+// ao definir a função implicita, o compilador deve lançar um aviso a insisitir
+// que só deve definir a função se souber o que está a fazer.
+
+
+/////////////////////////////////////////////////
+// 9. Misc
+/////////////////////////////////////////////////
+
+// Importar coisas
+import scala.collection.immutable.List
+
+// Importar todos os "sub pacotes"
+import scala.collection.immutable._
+
+// Importar multiplas classes numa linha
+import scala.collection.immutable.{List, Map}
+
+// Renomear uma classe importada usando '=>'
+import scala.collection.immutable.{List => ImmutableList}
+
+// Importar todas as classes excepto algumas. Set e Map são excluidos:
+import scala.collection.immutable.{Map => _, Set => _, _}
+
+// O ponto de entrada de um programa em Scala é definido por un ficheiro .scala
+// com um método main:
+object Aplicação {
+  def main(args: Array[String]): Unit = {
+    // código aqui.
+  }
+}
+
+// Ficheiros podem conter várias classes o objectos. Compilar com scalac
+
+
+
+
+// Input e output
+
+// Ler um ficheiro linha a linha
+import scala.io.Source
+for(linha <- Source.fromFile("ficheiro.txt").getLines())
+  println(linha)
+
+// Escrever um ficheiro usando o PrintWriter de Java
+val writer = new PrintWriter("ficheiro.txt")
+writer.write("Escrevendo linha por linha" + util.Properties.lineSeparator)
+writer.write("Outra linha aqui" + util.Properties.lineSeparator)
+writer.close()
+
+```
+
+## Mais recursos
+
+* [Scala for the impatient](http://horstmann.com/scala/)
+* [Twitter Scala school](http://twitter.github.io/scala_school/)
+* [The scala documentation](http://docs.scala-lang.org/)
+* [Try Scala in your browser](http://scalatutorials.com/tour/)
+* Join the [Scala user group](https://groups.google.com/forum/#!forum/scala-user)
diff --git a/purescript.html.markdown b/purescript.html.markdown
index 6bff7545..6d8cfbb9 100644
--- a/purescript.html.markdown
+++ b/purescript.html.markdown
@@ -2,40 +2,49 @@
 language: purescript
 contributors:
     - ["Fredrik Dyrkell", "http://www.lexicallyscoped.com"]
+    - ["Thimoteus", "https://github.com/Thimoteus"]
 ---
 
 PureScript is a small strongly, statically typed language compiling to Javascript.
 
 * Learn more at [http://www.purescript.org/](http://www.purescript.org/)
-* Documentation: [http://docs.purescript.org/en/latest/](http://docs.purescript.org/en/latest/)
+* Documentation: [http://pursuit.purescript.org/](http://pursuit.purescript.org/)
 * Book: Purescript by Example, [https://leanpub.com/purescript/](https://leanpub.com/purescript/)
 
+All the noncommented lines of code can be run in the PSCI REPL, though some will
+require the `--multi-line-mode` flag.
+
 ```haskell
 
 --
 -- 1. Primitive datatypes that corresponds to their Javascript
 -- equivalents at runtime.
 
+import Prelude
 -- Numbers
-1 + 7*5 :: Number -- 36
+1.0 + 7.2*5.5 :: Number -- 40.6
+-- Ints
+1 + 2*5 :: Int -- 11
 -- Types are inferred, so the following works fine
-9 / 2.5 + 4.4 -- 8
+9.0/2.5 + 4.4 -- 8.0
+-- But Ints and Numbers don't mix, so the following won't
+5/2 + 2.5 -- Expression 2.5 does not have type Int
 -- Hexadecimal literals
 0xff + 1 -- 256
 -- Unary negation
 6 * -3 -- -18
 6 * negate 3 -- -18
--- Modulus
-3 % 2 -- 1
-4 % 2 -- 0
+-- Modulus, from purescript-math (Math)
+3.0 % 2.0 -- 1.0
+4.0 % 2.0 -- 0.0
 -- Inspect the type of an expression in psci
-:t 9 / 2.5 + 4.4 -- Prim.Number
+:t 9.5/2.5 + 4.4 -- Prim.Number
 
 -- Booleans
 true :: Boolean -- true
 false :: Boolean -- false
 -- Negation
-not true --false
+not true -- false
 23 == 23 -- true
 1 /= 4 -- true
 1 >= 4 -- false
@@ -49,19 +58,22 @@ true && (9 >= 19 || 1 < 2) -- true
 
 -- Strings
 "Hellow" :: String -- "Hellow"
--- Multiline string
+-- Multiline string without newlines, to run in psci use the --multi-line-mode flag
 "Hellow\
 \orld" -- "Helloworld"
+-- Multiline string with newlines
+"""Hello 
+world""" -- "Hello\nworld"
 -- Concatenate
 "such " ++ "amaze" -- "such amaze"
 
 --
 -- 2. Arrays are Javascript arrays, but must be homogeneous
 
-[1,1,2,3,5,8] :: [Number] -- [1,1,2,3,5,8]
-[true, true, false] :: [Boolean] -- [true,true,false]
+[1,1,2,3,5,8] :: Array Number -- [1,1,2,3,5,8]
+[true, true, false] :: Array Boolean -- [true,true,false]
 -- [1,2, true, "false"] won't work
--- `Cannot unify Prim.Number with Prim.Boolean`
+-- `Cannot unify Prim.Int with Prim.Boolean`
 -- Cons (prepend)
 1 : [2,4,3] -- [1,2,4,3]
 
@@ -70,12 +82,12 @@ true && (9 >= 19 || 1 < 2) -- true
 
 -- Safe access return Maybe a
 head [1,2,3] -- Just (1)
-tail [3,2,1] -- Just ([2,1]) 
+tail [3,2,1] -- Just ([2,1])
 init [1,2,3] -- Just ([1,2])
 last [3,2,1] -- Just (1)
 -- Random access - indexing
 [3,4,5,6,7] !! 2 -- Just (5)
--- Range 
+-- Range
 1..5 -- [1,2,3,4,5]
 length [2,2,2] -- 3
 drop 3 [5,4,3,2,1] -- [2,1]
@@ -84,91 +96,95 @@ append [1,2,3] [4,5,6] -- [1,2,3,4,5,6]
 
 --
 -- 3. Records are Javascript objects, with zero or more fields, which
--- can have different types
+-- can have different types.
+-- In psci you have to write `let` in front of the function to get a
+-- top level binding.
 let book = {title: "Foucault's pendulum", author: "Umberto Eco"}
 -- Access properties
 book.title -- "Foucault's pendulum"
 
-getTitle b = b.title
+let getTitle b = b.title
 -- Works on all records with a title (but doesn't require any other field)
 getTitle book -- "Foucault's pendulum"
 getTitle {title: "Weekend in Monaco", artist: "The Rippingtons"} -- "Weekend in Monaco"
+-- Can use underscores as shorthand
+_.title book -- "Foucault's pendulum"
 -- Update a record
-changeTitle b t = b {title = t}
-changeTitle book "Ill nome della rosa" -- {title: "Ill nome della
-  -- rosa", author: "Umberto Eco"}
+let changeTitle b t = b {title = t}
+getTitle (changeTitle book "Ill nome della rosa") -- "Ill nome della rosa"
 
 --
 -- 4. Functions
-sumOfSquares x y = x*x+y*y
+-- In psci's multiline mode
+let sumOfSquares :: Int -> Int -> Int
+    sumOfSquares x y = x*x + y*y
 sumOfSquares 3 4 -- 25
--- In psci you have to write `let` in front of the function to get a
--- top level binding
-mod x y = x % y
-mod 3 2 -- 1
+let myMod x y = x % y
+myMod 3.0 2.0 -- 1.0
 -- Infix application of function
 3 `mod` 2 -- 1
 
--- function application have higher precedence than all other
+-- function application has higher precedence than all other
 -- operators
 sumOfSquares 3 4 * sumOfSquares 4 5 -- 1025
 
 -- Conditional
-abs' n = if n>=0 then n else -n
+let abs' n = if n>=0 then n else -n
 abs' (-3) -- 3
 
 -- Guarded equations
-abs n | n >= 0    = n
-      | otherwise = -n
+let abs'' n | n >= 0    = n
+            | otherwise = -n
 
 -- Pattern matching
 
--- Note the type signature, input is an array of numbers The pattern
--- matching destructures and binds the array into parts
-first :: [Number] -> Number
-first (x:_) = x
-first [3,4,5] -- 3
-second :: [Number] -> Number
-second (_:y:_) = y 
-second [3,4,5] -- 4
-sumTwo :: [Number] -> [Number]
-sumTwo (x:y:rest) = (x+y) : rest 
-sumTwo [2,3,4,5,6] -- [5,4,5,6]
-
--- sumTwo doesn't handle when the array is empty or just have one
--- element in which case you get an error
+-- Note the type signature, input is a list of numbers. The pattern matching
+-- destructures and binds the list into parts.
+-- Requires purescript-lists (Data.List)
+let first :: forall a. List a -> a
+    first (Cons x _) = x
+first (toList [3,4,5]) -- 3
+let second :: forall a. List a -> a
+    second (Cons _ (Cons y _)) = y
+second (toList [3,4,5]) -- 4
+let sumTwo :: List Int -> List Int
+    sumTwo (Cons x (Cons y rest)) = x + y : rest
+fromList (sumTwo (toList [2,3,4,5,6])) :: Array Int -- [5,4,5,6]
+
+-- sumTwo doesn't handle when the list is empty or there's only one element in
+-- which case you get an error.
 sumTwo [1] -- Failed pattern match
 
 -- Complementing patterns to match
 -- Good ol' Fibonacci
-fib 1 = 1
-fib 2 = 2
-fib x = fib (x-1) + fib (x-2)
+let fib 1 = 1
+    fib 2 = 2
+    fib x = fib (x-1) + fib (x-2)
 fib 10 -- 89
 
 -- Use underscore to match any, where you don't care about the binding name
-isZero 0 = true
-isZero _ = false
+let isZero 0 = true
+    isZero _ = false
 
 -- Pattern matching on records
-ecoTitle {author = "Umberto Eco", title = t} = Just t
-ecoTitle _ = Nothing
+let ecoTitle {author = "Umberto Eco", title = t} = Just t
+    ecoTitle _ = Nothing
 
 ecoTitle book -- Just ("Foucault's pendulum")
 ecoTitle {title: "The Quantum Thief", author: "Hannu Rajaniemi"} -- Nothing
 -- ecoTitle requires both field to type check:
-ecoTitle {title: "The Quantum Thief"} -- Object does not have property author
+ecoTitle {title: "The Quantum Thief"} -- Object lacks required property "author"
 
 -- Lambda expressions
 (\x -> x*x) 3 -- 9
-(\x y -> x*x + y*y) 4 5 -- 41 
-sqr = \x -> x*x
+(\x y -> x*x + y*y) 4 5 -- 41
+let sqr = \x -> x*x
 
 -- Currying
-add x y = x + y -- is equivalent with
-add = \x -> (\y -> x+y)
-add3 = add 3
-:t add3 -- Prim.Number -> Prim.Number
+let myAdd x y = x + y -- is equivalent with
+let myAdd' = \x -> \y -> x + y
+let add3 = myAdd 3
+:t add3 -- Prim.Int -> Prim.Int
 
 -- Forward and backward function composition
 -- drop 3 followed by taking 5
@@ -177,9 +193,9 @@ add3 = add 3
 (drop 3 <<< take 5) (1..20) -- [4,5]
 
 -- Operations using higher order functions
-even x = x % 2 == 0
+let even x = x `mod` 2 == 0
 filter even (1..10) -- [2,4,6,8,10]
-map (\x -> x+11) (1..5) -- [12,13,14,15,16]
+map (\x -> x + 11) (1..5) -- [12,13,14,15,16]
 
 -- Requires purescript-foldable-traversabe (Data.Foldable)
 
@@ -187,7 +203,7 @@ foldr (+) 0 (1..10) -- 55
 sum (1..10) -- 55
 product (1..10) -- 3628800
 
--- Testing with predicate 
+-- Testing with predicate
 any even [1,2,3] -- true
 all even [1,2,3] -- false
 
diff --git a/python.html.markdown b/python.html.markdown
index 352f7349..42a52bcf 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -4,6 +4,7 @@ contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
     - ["Amin Bandali", "http://aminbandali.com"]
     - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["evuez", "http://github.com/evuez"]
 filename: learnpython.py
 ---
 
@@ -14,7 +15,13 @@ executable pseudocode.
 Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
 
 Note: This article applies to Python 2.7 specifically, but should be applicable
-to Python 2.x. For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
+to Python 2.x. Python 2.7 is reachong end of life and will stop beeign maintained in 2020,
+it is though recommended to start learnign Python with Python 3.
+For Python 3.x, take a look at the [Python 3 tutorial](http://learnxinyminutes.com/docs/python3/).
+
+It is also possible to write Python code which is compatible with Python 2.7 and 3.x at the same time,
+using Python [`__future__` imports](https://docs.python.org/2/library/__future__.html). `__future__` imports
+allow you to write Python 3 code that will run on Python 2, so check out the Python 3 tutorial.
 
 ```python
 
@@ -52,6 +59,12 @@ to Python 2.x. For Python 3.x, take a look at the [Python 3 tutorial](http://lea
 -5 // 3  # => -2
 -5.0 // 3.0 # => -2.0
 
+# Note that we can also import division module(Section 6 Modules)
+# to carry out normal division with just one '/'.
+from __future__ import division
+11/4    # => 2.75  ...normal division
+11//4   # => 2 ...floored division  
+
 # Modulo operation
 7 % 3 # => 1
 
@@ -142,7 +155,13 @@ bool("")  # => False
 ####################################################
 
 # Python has a print statement
-print "I'm Python. Nice to meet you!"
+print "I'm Python. Nice to meet you!" # => I'm Python. Nice to meet you!
+
+# Simple way to get input data from console
+input_string_var = raw_input("Enter some data: ") # Returns the data as a string
+input_var = input("Enter some data: ") # Evaluates the data as python code
+# Warning: Caution is recommended for input() method usage
+# Note: In python 3, input() is deprecated and raw_input() is renamed to input()
 
 # No need to declare variables before assigning to them.
 some_var = 5    # Convention is to use lower_case_with_underscores
@@ -153,6 +172,7 @@ some_var  # => 5
 some_other_var  # Raises a name error
 
 # if can be used as an expression
+# Equivalent of C's '?:' ternary operator
 "yahoo!" if 3 > 2 else 2  # => "yahoo!"
 
 # Lists store sequences
@@ -198,7 +218,7 @@ li[::-1]   # => [3, 4, 2, 1]
 
 # Remove arbitrary elements from a list with "del"
 del li[2]   # li is now [1, 2, 3]
-r
+
 # You can add lists
 li + other_li   # => [1, 2, 3, 4, 5, 6]
 # Note: values for li and for other_li are not modified.
@@ -206,6 +226,17 @@ li + other_li   # => [1, 2, 3, 4, 5, 6]
 # Concatenate lists with "extend()"
 li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
 
+# Remove first occurrence of a value
+li.remove(2)  # li is now [1, 3, 4, 5, 6]
+li.remove(2)  # Raises a ValueError as 2 is not in the list
+
+# Insert an element at a specific index
+li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again
+
+# Get the index of the first item found
+li.index(2)  # => 3
+li.index(7)  # Raises a ValueError as 7 is not in the list
+
 # Check for existence in a list with "in"
 1 in li   # => True
 
@@ -297,6 +328,15 @@ filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
 # Do set difference with -
 {1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
 
+# Do set symmetric difference with ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# Check if set on the left is a superset of set on the right
+{1, 2} >= {1, 2, 3} # => False
+
+# Check if set on the left is a subset of set on the right
+{1, 2} <= {1, 2, 3} # => True
+
 # Check for existence in a set with in
 2 in filled_set   # => True
 10 in filled_set   # => False
@@ -448,19 +488,19 @@ def pass_all_the_args(*args, **kwargs):
 # Function Scope
 x = 5
 
-def setX(num):
+def set_x(num):
     # Local var x not the same as global variable x
     x = num # => 43
     print x # => 43
 
-def setGlobalX(num):
+def set_global_x(num):
     global x
     print x # => 5
     x = num # global var x is now set to 6
     print x # => 6
 
-setX(43)
-setGlobalX(6)
+set_x(43)
+set_global_x(6)
 
 # Python has first class functions
 def create_adder(x):
@@ -473,9 +513,12 @@ add_10(3)   # => 13
 
 # There are also anonymous functions
 (lambda x: x > 2)(3)   # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
 
 # There are built-in higher order functions
 map(add_10, [1, 2, 3])   # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
+
 filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 
 # We can use list comprehensions for nice maps and filters
@@ -501,6 +544,10 @@ class Human(object):
         # Assign the argument to the instance's name attribute
         self.name = name
 
+        # Initialize property
+        self.age = 0
+
+
     # An instance method. All methods take "self" as the first argument
     def say(self, msg):
         return "{0}: {1}".format(self.name, msg)
@@ -516,6 +563,23 @@ class Human(object):
     def grunt():
         return "*grunt*"
 
+    # A property is just like a getter.
+    # It turns the method age() into an read-only attribute
+    # of the same name.
+    @property
+    def age(self):
+        return self._age
+
+    # This allows the property to be set
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # This allows the property to be deleted
+    @age.deleter
+    def age(self):
+        del self._age
+
 
 # Instantiate a class
 i = Human(name="Ian")
@@ -535,6 +599,16 @@ j.get_species()   # => "H. neanderthalensis"
 # Call the static method
 Human.grunt()   # => "*grunt*"
 
+# Update the property
+i.age = 42
+
+# Get the property
+i.age # => 42
+
+# Delete the property
+del i.age
+i.age  # => raises an AttributeError
+
 
 ####################################################
 ## 6. Modules
@@ -633,7 +707,7 @@ print say(say_please=True)  # Can you buy me a beer? Please! I am poor :(
 * [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
-* [The Official Docs](http://docs.python.org/2.6/)
+* [The Official Docs](http://docs.python.org/2/)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
 * [Python Module of the Week](http://pymotw.com/2/)
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
diff --git a/python3.html.markdown b/python3.html.markdown
index b3acb122..2398e7ac 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -4,6 +4,8 @@ contributors:
     - ["Louie Dinh", "http://pythonpracticeprojects.com"]
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["evuez", "http://github.com/evuez"]
 filename: learnpython3.py
 ---
 
@@ -32,50 +34,50 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
 3  # => 3
 
 # Math is what you would expect
-1 + 1  # => 2
-8 - 1  # => 7
+1 + 1   # => 2
+8 - 1   # => 7
 10 * 2  # => 20
 
-# Except division which returns floats by default
+# Except division which returns floats, real numbers, by default
 35 / 5  # => 7.0
 
 # Result of integer division truncated down both for positive and negative.
-5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # works on floats too
--5 // 3  # => -2
--5.0 // 3.0 # => -2.0
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # works on floats too
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
 
 # When you use a float, results are floats
-3 * 2.0 # => 6.0
+3 * 2.0  # => 6.0
 
 # Modulo operation
-7 % 3 # => 1
+7 % 3  # => 1
 
-# Exponentiation (x to the yth power)
-2**4 # => 16
+# Exponentiation (x**y, x to the yth power)
+2**4  # => 16
 
 # Enforce precedence with parentheses
 (1 + 3) * 2  # => 8
 
-# Boolean values are primitives
+# Boolean values are primitives (Note: the capitalization)
 True
 False
 
 # negate with not
-not True  # => False
+not True   # => False
 not False  # => True
 
 # Boolean Operators
 # Note "and" and "or" are case-sensitive
-True and False #=> False
-False or True #=> True
+True and False  # => False
+False or True   # => True
 
 # Note using Bool operators with ints
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-1 == True #=> True
+0 and 2     # => 0
+-5 or 0     # => -5
+0 == False  # => True
+2 == True   # => False
+1 == True   # => True
 
 # Equality is ==
 1 == 1  # => True
@@ -95,6 +97,16 @@ False or True #=> True
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
+# (is vs. ==) is checks if two variable refer to the same object, but == checks
+# if the objects pointed to have the same values.
+a = [1, 2, 3, 4]  # Point a at a new list, [1, 2, 3, 4]
+b = a             # Point b at what a is pointing to
+b is a            # => True, a and b refer to the same object
+b == a            # => True, a's and b's objects are equal
+b = [1, 2, 3, 4]  # Point a at a new list, [1, 2, 3, 4]
+b is a            # => False, a and b do not refer to the same object
+b == a            # => True, a's and b's objects are equal
+
 # Strings are created with " or '
 "This is a string."
 'This is also a string.'
@@ -102,24 +114,24 @@ False or True #=> True
 # Strings can be added too! But try not to do this.
 "Hello " + "world!"  # => "Hello world!"
 # Strings can be added without using '+'
-"Hello " "world!"  # => "Hello world!"
+"Hello " "world!"    # => "Hello world!"
 
 # A string can be treated like a list of characters
 "This is a string"[0]  # => 'T'
 
 # .format can be used to format strings, like this:
-"{} can be {}".format("strings", "interpolated")
+"{} can be {}".format("Strings", "interpolated")  # => "Strings can be interpolated"
 
 # You can repeat the formatting arguments to save some typing.
 "{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"
+# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
 
 # You can use keywords if you don't want to count.
-"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")  # => "Bob wants to eat lasagna"
 
 # If your Python 3 code also needs to run on Python 2.5 and below, you can also
 # still use the old style of formatting:
-"%s can be %s the %s way" % ("strings", "interpolated", "old")
+"%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
 
 
 # None is an object
@@ -128,14 +140,14 @@ None  # => None
 # Don't use the equality "==" symbol to compare objects to None
 # Use "is" instead. This checks for equality of object identity.
 "etc" is None  # => False
-None is None  # => True
+None is None   # => True
 
 # None, 0, and empty strings/lists/dicts all evaluate to False.
 # All other values are True
-bool(0)  # => False
+bool(0)   # => False
 bool("")  # => False
-bool([]) #=> False
-bool({}) #=> False
+bool([])  # => False
+bool({})  # => False
 
 
 ####################################################
@@ -143,7 +155,15 @@ bool({}) #=> False
 ####################################################
 
 # Python has a print function
-print("I'm Python. Nice to meet you!")
+print("I'm Python. Nice to meet you!")  # => I'm Python. Nice to meet you!
+
+# By default the print function also prints out a newline at the end.
+# Use the optional argument end to change the end character.
+print("Hello, World", end="!")  # => Hello, World!
+
+# Simple way to get input data from console
+input_string_var = input("Enter some data: ") # Returns the data as a string
+# Note: In earlier versions of Python, input() method was named as raw_input()
 
 # No need to declare variables before assigning to them.
 # Convention is to use lower_case_with_underscores
@@ -170,7 +190,7 @@ li.pop()        # => 3 and li is now [1, 2, 4]
 li.append(3)    # li is now [1, 2, 4, 3] again.
 
 # Access a list like you would any array
-li[0]  # => 1
+li[0]   # => 1
 # Look at the last element
 li[-1]  # => 3
 
@@ -179,52 +199,74 @@ li[4]  # Raises an IndexError
 
 # You can look at ranges with slice syntax.
 # (It's a closed/open range for you mathy types.)
-li[1:3]  # => [2, 4]
+li[1:3]   # => [2, 4]
 # Omit the beginning
-li[2:]  # => [4, 3]
+li[2:]    # => [4, 3]
 # Omit the end
-li[:3]  # => [1, 2, 4]
+li[:3]    # => [1, 2, 4]
 # Select every second entry
 li[::2]   # =>[1, 4]
 # Return a reversed copy of the list
-li[::-1]   # => [3, 4, 2, 1]
+li[::-1]  # => [3, 4, 2, 1]
 # Use any combination of these to make advanced slices
 # li[start:end:step]
 
+# Make a one layer deep copy using slices
+li2 = li[:]  # => li2 = [1, 2, 4, 3] but (li2 is li) will result in false.
+
 # Remove arbitrary elements from a list with "del"
-del li[2]   # li is now [1, 2, 3]
+del li[2]  # li is now [1, 2, 3]
+
+# Remove first occurrence of a value
+li.remove(2)  # li is now [1, 3]
+li.remove(2)  # Raises a ValueError as 2 is not in the list
+
+# Insert an element at a specific index
+li.insert(1, 2)  # li is now [1, 2, 3] again
+
+# Get the index of the first item found
+li.index(2)  # => 3
+li.index(4)  # Raises a ValueError as 4 is not in the list
 
 # You can add lists
 # Note: values for li and for other_li are not modified.
-li + other_li   # => [1, 2, 3, 4, 5, 6]
+li + other_li  # => [1, 2, 3, 4, 5, 6]
 
 # Concatenate lists with "extend()"
-li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]
 
 # Check for existence in a list with "in"
-1 in li   # => True
+1 in li  # => True
 
 # Examine the length with "len()"
-len(li)   # => 6
+len(li)  # => 6
 
 
 # Tuples are like lists but are immutable.
 tup = (1, 2, 3)
-tup[0]   # => 1
+tup[0]      # => 1
 tup[0] = 3  # Raises a TypeError
 
+# Note that a tuple of length one has to have a comma after the last element but
+# tuples of other lengths, even zero, do not.
+type((1))   # => <class 'int'>
+type((1,))  # => <class 'tuple'>
+type(())    # => <class 'tuple'>
+
 # You can do most of the list operations on tuples too
-len(tup)   # => 3
-tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
-tup[:2]   # => (1, 2)
-2 in tup   # => True
+len(tup)         # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]          # => (1, 2)
+2 in tup         # => True
 
 # You can unpack tuples (or lists) into variables
-a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
+a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
+# You can also do extended unpacking
+a, *b, c = (1, 2, 3, 4)  # a is now 1, b is now [2, 3] and c is now 4
 # Tuples are created by default if you leave out the parentheses
 d, e, f = 4, 5, 6
 # Now look how easy it is to swap two values
-e, d = d, e     # d is now 5 and e is now 4
+e, d = d, e  # d is now 5 and e is now 4
 
 
 # Dictionaries store mappings
@@ -232,71 +274,96 @@ empty_dict = {}
 # Here is a prefilled dictionary
 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'
+valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.
+
 # Look up values with []
-filled_dict["one"]   # => 1
+filled_dict["one"]  # => 1
 
 # Get all keys as an iterable with "keys()". We need to wrap the call in list()
 # to turn it into a list. We'll talk about those later.  Note - Dictionary key
 # ordering is not guaranteed. Your results might not match this exactly.
-list(filled_dict.keys())   # => ["three", "two", "one"]
+list(filled_dict.keys())  # => ["three", "two", "one"]
 
 
 # Get all values as an iterable with "values()". Once again we need to wrap it
 # in list() to get it out of the iterable. Note - Same as above regarding key
 # ordering.
-list(filled_dict.values())   # => [3, 2, 1]
+list(filled_dict.values())  # => [3, 2, 1]
 
 
 # Check for existence of keys in a dictionary with "in"
-"one" in filled_dict   # => True
-1 in filled_dict   # => False
+"one" in filled_dict  # => True
+1 in filled_dict      # => False
 
 # Looking up a non-existing key is a KeyError
-filled_dict["four"]   # KeyError
+filled_dict["four"]  # KeyError
 
 # Use "get()" method to avoid the KeyError
-filled_dict.get("one")   # => 1
-filled_dict.get("four")   # => None
+filled_dict.get("one")      # => 1
+filled_dict.get("four")     # => None
 # The get method supports a default argument when the value is missing
 filled_dict.get("one", 4)   # => 1
-filled_dict.get("four", 4)   # => 4
+filled_dict.get("four", 4)  # => 4
 
 # "setdefault()" inserts into a dictionary only if the given key isn't present
 filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
 filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
 
 # Adding to a dictionary
-filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
-#filled_dict["four"] = 4  #another way to add to dict
+filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4        #another way to add to dict
 
 # Remove keys from a dictionary with del
 del filled_dict["one"]  # Removes the key "one" from filled dict
 
+# From Python 3.5 you can also use the additional unpacking options
+{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
+{'a': 1, **{'a': 2}}  # => {'a': 2}
+
+
 
 # Sets store ... well sets
 empty_set = set()
 # Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
-some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
+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.
+invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
 
 # Can set new variables to a set
 filled_set = some_set
 
 # Add one more item to the set
-filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
 
 # Do set intersection with &
 other_set = {3, 4, 5, 6}
-filled_set & other_set   # => {3, 4, 5}
+filled_set & other_set  # => {3, 4, 5}
 
 # Do set union with |
-filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
 
 # Do set difference with -
-{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
+
+# Do set symmetric difference with ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# Check if set on the left is a superset of set on the right
+{1, 2} >= {1, 2, 3} # => False
+
+# Check if set on the left is a subset of set on the right
+{1, 2} <= {1, 2, 3} # => True
 
 # Check for existence in a set with in
 2 in filled_set   # => True
-10 in filled_set   # => False
+10 in filled_set  # => False
+
 
 
 ####################################################
@@ -352,6 +419,18 @@ for i in range(4, 8):
     print(i)
 
 """
+"range(lower, upper, step)" returns an iterable of numbers
+from the lower number to the upper number, while incrementing
+by step. If step is not indicated, the default value is 1.
+prints:
+    4
+    6
+    8
+"""
+for i in range(4, 8, 2):
+    print(i)
+"""
+
 While loops go until a condition is no longer met.
 prints:
     0
@@ -369,14 +448,14 @@ try:
     # Use "raise" to raise an error
     raise IndexError("This is an index error")
 except IndexError as e:
-    pass    # Pass is just a no-op. Usually you would do recovery here.
+    pass                 # Pass is just a no-op. Usually you would do recovery here.
 except (TypeError, NameError):
-    pass    # Multiple exceptions can be handled together, if required.
-else:   # Optional clause to the try/except block. Must follow all except blocks
+    pass                 # Multiple exceptions can be handled together, if required.
+else:                    # Optional clause to the try/except block. Must follow all except blocks
     print("All good!")   # Runs only if the code in try raises no exceptions
-finally: #  Execute under all circumstances
+finally:                 #  Execute under all circumstances
     print("We can clean up resources here")
- 		 
+
 # Instead of try/finally to cleanup resources you can use a with statement
 with open("myfile.txt") as f:
     for line in f:
@@ -388,11 +467,11 @@ with open("myfile.txt") as f:
 
 filled_dict = {"one": 1, "two": 2, "three": 3}
 our_iterable = filled_dict.keys()
-print(our_iterable) #=> range(1,10). 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:
-    print(i)    # Prints one, two, three
+    print(i)  # Prints one, two, three
 
 # However we cannot address elements by index.
 our_iterable[1]  # Raises a TypeError
@@ -402,17 +481,17 @@ 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()".
-next(our_iterator)  #=> "one"
+next(our_iterator)  # => "one"
 
 # It maintains state as we iterate.
-next(our_iterator)  #=> "two"
-next(our_iterator)  #=> "three"
+next(our_iterator)  # => "two"
+next(our_iterator)  # => "three"
 
 # After the iterator has returned all of its data, it gives you a StopIterator Exception
-next(our_iterator) # Raises StopIteration
+next(our_iterator)  # Raises StopIteration
 
 # You can grab all the elements of an iterator by calling list() on it.
-list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+list(filled_dict.keys())  # => Returns ["one", "two", "three"]
 
 
 ####################################################
@@ -422,20 +501,20 @@ list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
 # Use "def" to create new functions
 def add(x, y):
     print("x is {} and y is {}".format(x, y))
-    return x + y    # Return values with a return statement
+    return x + y  # Return values with a return statement
 
 # Calling functions with parameters
-add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+add(5, 6)  # => prints out "x is 5 and y is 6" and returns 11
 
 # Another way to call functions is with keyword arguments
-add(y=6, x=5)   # Keyword arguments can arrive in any order.
+add(y=6, x=5)  # Keyword arguments can arrive in any order.
 
 # You can define functions that take a variable number of
 # positional arguments
 def varargs(*args):
     return args
 
-varargs(1, 2, 3)   # => (1, 2, 3)
+varargs(1, 2, 3)  # => (1, 2, 3)
 
 # You can define functions that take a variable number of
 # keyword arguments, as well
@@ -443,7 +522,7 @@ def keyword_args(**kwargs):
     return kwargs
 
 # Let's call it to see what happens
-keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
 
 
 # You can do both at once, if you like
@@ -460,27 +539,36 @@ all_the_args(1, 2, a=3, b=4) prints:
 # Use * to expand tuples and use ** to expand kwargs.
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
-all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
-all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
-all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args)            # equivalent to foo(1, 2, 3, 4)
+all_the_args(**kwargs)         # equivalent to foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # equivalent to foo(1, 2, 3, 4, a=3, b=4)
 
+# Returning multiple values (with tuple assignments)
+def swap(x, y):
+    return y, x  # Return multiple values as a tuple without the parenthesis.
+                 # (Note: parenthesis have been excluded but can be included)
+
+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.
 
 # Function Scope
 x = 5
 
-def setX(num):
+def set_x(num):
     # Local var x not the same as global variable x
-    x = num # => 43
-    print (x) # => 43
+    x = num    # => 43
+    print (x)  # => 43
 
-def setGlobalX(num):
+def set_global_x(num):
     global x
-    print (x) # => 5
-    x = num # global var x is now set to 6
-    print (x) # => 6
+    print (x)  # => 5
+    x = num    # global var x is now set to 6
+    print (x)  # => 6
 
-setX(43)
-setGlobalX(6)
+set_x(43)
+set_global_x(6)
 
 
 # Python has first class functions
@@ -493,25 +581,28 @@ add_10 = create_adder(10)
 add_10(3)   # => 13
 
 # There are also anonymous functions
-(lambda x: x > 2)(3)   # => True
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
 
 # TODO - Fix for iterables
 # There are built-in higher order functions
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+map(add_10, [1, 2, 3])          # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
 
 # We can use list comprehensions for nice maps and filters
 # List comprehension stores the output as a list which can itself be a nested list
-[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
-[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
+[add_10(i) for i in [1, 2, 3]]         # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]  # => [6, 7]
 
 ####################################################
 ## 5. Classes
 ####################################################
 
 
-# We subclass from object to get a class.
-class Human(object):
+# We use the "class" operator to get a class
+class Human:
 
     # A class attribute. It is shared by all instances of this class
     species = "H. sapiens"
@@ -526,6 +617,9 @@ class Human(object):
         # Assign the argument to the instance's name attribute
         self.name = name
 
+        # Initialize property
+        self.age = 0
+
     # An instance method. All methods take "self" as the first argument
     def say(self, msg):
         return "{name}: {message}".format(name=self.name, message=msg)
@@ -541,6 +635,23 @@ class Human(object):
     def grunt():
         return "*grunt*"
 
+    # A property is just like a getter.
+    # It turns the method age() into an read-only attribute
+    # of the same name.
+    @property
+    def age(self):
+        return self._age
+
+    # This allows the property to be set
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # This allows the property to be deleted
+    @age.deleter
+    def age(self):
+        del self._age
+
 
 # Instantiate a class
 i = Human(name="Ian")
@@ -550,15 +661,26 @@ j = Human("Joel")
 print(j.say("hello"))  # prints out "Joel: hello"
 
 # Call our class method
-i.get_species()   # => "H. sapiens"
+i.get_species()  # => "H. sapiens"
 
 # Change the shared attribute
 Human.species = "H. neanderthalensis"
-i.get_species()   # => "H. neanderthalensis"
-j.get_species()   # => "H. neanderthalensis"
+i.get_species()  # => "H. neanderthalensis"
+j.get_species()  # => "H. neanderthalensis"
 
 # Call the static method
-Human.grunt()   # => "*grunt*"
+Human.grunt()    # => "*grunt*"
+
+# Update the property
+i.age = 42
+
+# Get the property
+i.age # => 42
+
+# Delete the property
+del i.age
+i.age  # => raises an AttributeError
+
 
 
 ####################################################
@@ -571,8 +693,8 @@ print(math.sqrt(16))  # => 4
 
 # You can get specific functions from a module
 from math import ceil, floor
-print(ceil(3.7))  # => 4.0
-print(floor(3.7))   # => 3.0
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
 
 # You can import all functions from a module.
 # Warning: this is not recommended
@@ -580,7 +702,7 @@ from math import *
 
 # You can shorten module names
 import math as m
-math.sqrt(16) == m.sqrt(16)   # => True
+math.sqrt(16) == m.sqrt(16)  # => True
 
 # Python modules are just ordinary python files. You
 # can write your own, and import them. The name of the
@@ -605,8 +727,6 @@ def double_numbers(iterable):
 # Instead of generating and returning all values at once it creates one in each
 # iteration.  This means values bigger than 15 wont be processed in
 # double_numbers.
-# Note range is a generator too. Creating a list 1-900000000 would take lot of
-# time to be made
 # We use a trailing underscore in variable names when we want to use a name that
 # would normally collide with a python keyword
 range_ = range(1, 900000000)
@@ -641,7 +761,7 @@ def say(say_please=False):
     return msg, say_please
 
 
-print(say())  # Can you buy me a beer?
+print(say())                 # Can you buy me a beer?
 print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
 ```
 
@@ -658,6 +778,9 @@ print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 * [Python Course](http://www.python-course.eu/index.php)
 * [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
 
 ### Dead Tree
 
diff --git a/pythonstatcomp.html.markdown b/pythonstatcomp.html.markdown
new file mode 100644
index 00000000..78b62e33
--- /dev/null
+++ b/pythonstatcomp.html.markdown
@@ -0,0 +1,234 @@
+---
+language: Statistical computing with Python
+contributors:
+    - ["e99n09", "https://github.com/e99n09"]
+filename: pythonstatcomp.py
+---
+
+This is a tutorial on how to do some typical statistical programming tasks using Python. It's intended for people basically familiar with Python and experienced at statistical programming in a language like R, Stata, SAS, SPSS, or MATLAB.
+
+```python
+
+# 0. Getting set up ====
+
+""" Get set up with IPython and pip install the following: numpy, scipy, pandas,
+    matplotlib, seaborn, requests.
+        Make sure to do this tutorial in the IPython notebook so that you get
+    the inline plots and easy documentation lookup.
+"""
+
+# 1. Data acquisition ====
+
+""" One reason people choose Python over R is that they intend to interact a lot
+    with the web, either by scraping pages directly or requesting data through
+    an API. You can do those things in R, but in the context of a project
+    already using Python, there's a benefit to sticking with one language.
+"""
+
+import requests # for HTTP requests (web scraping, APIs)
+import os
+
+# web scraping
+r = requests.get("https://github.com/adambard/learnxinyminutes-docs")
+r.status_code # if 200, request was successful
+r.text # raw page source
+print(r.text) # prettily formatted
+# save the page source in a file:
+os.getcwd() # check what's the working directory
+f = open("learnxinyminutes.html","wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+# downloading a csv
+fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/"
+fn = "pets.csv"
+r = requests.get(fp + fn)
+print(r.text)
+f = open(fn,"wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+""" for more on the requests module, including APIs, see
+    http://docs.python-requests.org/en/latest/user/quickstart/
+"""
+
+# 2. Reading a CSV file ====
+
+""" Wes McKinney's pandas package gives you 'DataFrame' objects in Python. If
+    you've used R, you will be familiar with the idea of the "data.frame" already.
+"""
+
+import pandas as pd, numpy as np, 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
+
+""" R users: note that Python, like most normal programming languages, starts
+    indexing from 0. R is the unusual one for starting from 1.
+"""
+
+# two different ways to print out a column
+pets.age
+pets["age"]
+
+pets.head(2) # prints first 2 rows
+pets.tail(1) # prints last row
+
+pets.name[1] # 'vesuvius'
+pets.species[0] # 'cat'
+pets["weight"][2] # 34
+
+# in R, you would expect to get 3 rows doing this, but here you get 2:
+pets.age[0:2]
+# 0    3
+# 1    6
+
+sum(pets.age)*2 # 28
+max(pets.weight) - min(pets.weight) # 20
+
+""" If you are doing some serious linear algebra and number-crunching, you may
+    just want arrays, not DataFrames. DataFrames are ideal for combining columns
+    of different types.
+"""
+
+# 3. Charts ====
+
+import matplotlib as mpl, matplotlib.pyplot as plt
+%matplotlib inline
+
+# To do data vizualization in Python, use matplotlib
+
+plt.hist(pets.age);
+
+plt.boxplot(pets.weight);
+
+plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");
+
+# seaborn sits atop matplotlib and makes plots prettier
+
+import seaborn as sns
+
+plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");
+
+# there are also some seaborn-specific plotting functions
+# notice how seaborn automatically labels the x-axis on this barplot
+sns.barplot(pets["age"])
+
+# R veterans can still use ggplot
+from ggplot import *
+ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
+# source: https://pypi.python.org/pypi/ggplot
+
+# there's even a d3.js port: https://github.com/mikedewar/d3py
+
+# 4. Simple data cleaning and exploratory analysis ====
+
+""" Here's a more complicated example that demonstrates a basic data
+    cleaning workflow leading to the creation of some exploratory plots
+    and the running of a linear regression.
+        The data set was transcribed from Wikipedia by hand. It contains
+    all the Holy Roman Emperors and the important milestones in their lives
+    (birth, death, coronation, etc.).
+        The goal of the analysis will be to explore whether a relationship
+    exists between emperor birth year and emperor lifespan.
+    data source: https://en.wikipedia.org/wiki/Holy_Roman_Emperor
+"""
+
+# load some data on Holy Roman Emperors
+url = "https://raw.githubusercontent.com/e99n09/R-notes/master/data/hre.csv"
+r = requests.get(url)
+fp = "hre.csv"
+f = open(fp,"wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+hre = pd.read_csv(fp)
+
+hre.head()
+"""
+   Ix      Dynasty        Name        Birth             Death Election 1  
+0 NaN  Carolingian   Charles I  2 April 742    28 January 814        NaN   
+1 NaN  Carolingian     Louis I          778       20 June 840        NaN   
+2 NaN  Carolingian   Lothair I          795  29 September 855        NaN   
+3 NaN  Carolingian    Louis II          825     12 August 875        NaN   
+4 NaN  Carolingian  Charles II  13 June 823     6 October 877        NaN   
+
+  Election 2      Coronation 1   Coronation 2 Ceased to be Emperor  
+0        NaN   25 December 800            NaN       28 January 814   
+1        NaN  11 September 813  5 October 816          20 June 840   
+2        NaN       5 April 823            NaN     29 September 855   
+3        NaN        Easter 850     18 May 872        12 August 875   
+4        NaN   29 December 875            NaN        6 October 877   
+
+  Descent from whom 1 Descent how 1 Descent from whom 2 Descent how 2  
+0                 NaN           NaN                 NaN           NaN  
+1           Charles I           son                 NaN           NaN  
+2             Louis I           son                 NaN           NaN  
+3           Lothair I           son                 NaN           NaN  
+4             Louis I           son                 NaN           NaN  
+"""
+
+# clean the Birth and Death columns
+
+import re # module for regular expressions
+
+rx = re.compile(r'\d+$') # match trailing digits
+
+""" This function applies the regular expression to an input column (here Birth,
+    Death), flattens the resulting list, converts it to a Series object, and
+    finally converts the type of the Series object from string to integer. For
+    more information into what different parts of the code do, see:
+      - https://docs.python.org/2/howto/regex.html
+      - http://stackoverflow.com/questions/11860476/how-to-unlist-a-python-list
+      - http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html
+"""
+def extractYear(v):
+    return(pd.Series(reduce(lambda x,y: x+y,map(rx.findall,v),[])).astype(int))
+
+hre["BirthY"] = extractYear(hre.Birth)
+hre["DeathY"] = extractYear(hre.Death)
+
+# make a column telling estimated age
+hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int)
+
+# simple scatterplot, no trend line, color represents dynasty
+sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False);
+
+# use scipy to run a linear regression
+from scipy import stats
+(slope,intercept,rval,pval,stderr)=stats.linregress(hre.BirthY,hre.EstAge)
+# code source: http://wiki.scipy.org/Cookbook/LinearRegression
+
+# check the slope
+slope # 0.0057672618839073328
+
+# check the R^2 value:
+rval**2 # 0.020363950027333586
+
+# check the p-value
+pval # 0.34971812581498452
+
+# use seaborn to make a scatterplot and plot the linear regression trend line
+sns.lmplot("BirthY", "EstAge", data=hre);
+
+""" For more information on seaborn, see
+      - http://web.stanford.edu/~mwaskom/software/seaborn/
+      - https://github.com/mwaskom/seaborn
+    For more information on SciPy, see
+      - http://wiki.scipy.org/SciPy
+      - http://wiki.scipy.org/Cookbook/
+    To see a version of the Holy Roman Emperors analysis using R, see
+      - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
+"""
+```
+
+If you want to learn more, get _Python for Data Analysis_ by Wes McKinney. It's a superb resource and I used it as a reference when writing this tutorial.
+
+You can also find plenty of interactive IPython tutorials on subjects specific to your interests, like Cam Davidson-Pilon's <a href="http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/" Title="Probabilistic Programming and Bayesian Methods for Hackers">Probabilistic Programming and Bayesian Methods for Hackers</a>.
+
+Some more modules to research:
+   - text analysis and natural language processing: nltk, http://www.nltk.org
+   - social network analysis: igraph, http://igraph.org/python/
diff --git a/r.html.markdown b/r.html.markdown
index 3d0b9b9e..61fc7a01 100644
--- a/r.html.markdown
+++ b/r.html.markdown
@@ -16,7 +16,8 @@ R is a statistical computing language. It has lots of libraries for uploading an
 # You can't make multi-line comments,
 # but you can stack multiple comments like so.
 
-# in Windows or Mac, hit COMMAND-ENTER to execute a line
+# in Windows you can use CTRL-ENTER to execute a line.
+# on Mac it is COMMAND-ENTER
 
 
 
@@ -37,8 +38,8 @@ head(rivers)	# peek at the data set
 length(rivers)	# how many rivers were measured?
 # 141
 summary(rivers) # what are some summary statistics?
-#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
-#  135.0   310.0   425.0   591.2   680.0  3710.0 
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#  135.0   310.0   425.0   591.2   680.0  3710.0
 
 # make a stem-and-leaf plot (a histogram-like data visualization)
 stem(rivers)
@@ -55,14 +56,14 @@ stem(rivers)
 #  14 | 56
 #  16 | 7
 #  18 | 9
-#  20 | 
+#  20 |
 #  22 | 25
 #  24 | 3
-#  26 | 
-#  28 | 
-#  30 | 
-#  32 | 
-#  34 | 
+#  26 |
+#  28 |
+#  30 |
+#  32 |
+#  34 |
 #  36 | 1
 
 stem(log(rivers)) # Notice that the data are neither normal nor log-normal!
@@ -71,7 +72,7 @@ stem(log(rivers)) # Notice that the data are neither normal nor log-normal!
 #  The decimal point is 1 digit(s) to the left of the |
 #
 #  48 | 1
-#  50 | 
+#  50 |
 #  52 | 15578
 #  54 | 44571222466689
 #  56 | 023334677000124455789
@@ -86,7 +87,7 @@ stem(log(rivers)) # Notice that the data are neither normal nor log-normal!
 #  74 | 84
 #  76 | 56
 #  78 | 4
-#  80 | 
+#  80 |
 #  82 | 2
 
 # make a histogram:
@@ -109,7 +110,7 @@ sort(discoveries)
 # [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)
-# 
+#
 #  The decimal point is at the |
 #
 #   0 | 000000000
@@ -123,14 +124,14 @@ stem(discoveries, scale=2)
 #   8 | 0
 #   9 | 0
 #  10 | 0
-#  11 | 
+#  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 
+#   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
+#    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))
@@ -274,7 +275,7 @@ class(NULL)	# NULL
 parakeet = c("beak", "feathers", "wings", "eyes")
 parakeet
 # =>
-# [1] "beak"     "feathers" "wings"    "eyes"    
+# [1] "beak"     "feathers" "wings"    "eyes"
 parakeet <- NULL
 parakeet
 # =>
@@ -291,7 +292,7 @@ as.numeric("Bilbo")
 # =>
 # [1] NA
 # Warning message:
-# NAs introduced by coercion 
+# NAs introduced by coercion
 
 # Also note: those were just the basic data types
 # There are many more data types, such as for dates, time series, etc.
@@ -431,10 +432,10 @@ mat %*% t(mat)
 mat2 <- cbind(1:4, c("dog", "cat", "bird", "dog"))
 mat2
 # =>
-#      [,1] [,2]   
-# [1,] "1"  "dog"  
-# [2,] "2"  "cat"  
-# [3,] "3"  "bird" 
+#      [,1] [,2]
+# [1,] "1"  "dog"
+# [2,] "2"  "cat"
+# [3,] "3"  "bird"
 # [4,] "4"  "dog"
 class(mat2)	# matrix
 # Again, note what happened!
diff --git a/racket.html.markdown b/racket.html.markdown
index e345db8b..0fe3f030 100644
--- a/racket.html.markdown
+++ b/racket.html.markdown
@@ -285,7 +285,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (= 3 3.0) ; => #t
 (= 2 1)   ; => #f
 
-;; `eq?' returns #t if 2 arguments refer to the same object (in memory), 
+;; `eq?' returns #t if 2 arguments refer to the same object (in memory),
 ;; #f otherwise.
 ;; In other words, it's a simple pointer comparison.
 (eq? '() '()) ; => #t, since there exists only one empty list in memory
@@ -320,7 +320,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (eqv? (string-append "foo" "bar") (string-append "foo" "bar"))   ; => #f
 
 ;; `equal?' supports the comparison of the following datatypes:
-;; strings, byte strings, pairs, mutable pairs, vectors, boxes, 
+;; strings, byte strings, pairs, mutable pairs, vectors, boxes,
 ;; hash tables, and inspectable structures.
 ;; for other datatypes, `equal?' and `eqv?' return the same result.
 (equal? 3 3.0)                                                   ; => #f
diff --git a/red.html.markdown b/red.html.markdown
index f33060c4..05da3c3f 100644
--- a/red.html.markdown
+++ b/red.html.markdown
@@ -8,31 +8,31 @@ contributors:
 ---
 
 
-Red was created out of the need to get work done, and the tool the author wanted to use, the language of REBOL, had a couple of drawbacks. 
+Red was created out of the need to get work done, and the tool the author wanted to use, the language of REBOL, had a couple of drawbacks.
 It was not Open Sourced at that time and it is an interpreted language, what means that it is on average slow compared to a compiled language.
 
 Red, together with its C-level dialect Red/System, provides a language that covers the entire programming space you ever need to program something in.
-Red is a language heavily based on the language of REBOL. Where Red itself reproduces the flexibility of the REBOL language, the underlying language Red will be built upon, 
-Red/System, covers the more basic needs of programming like C can, being closer to the metal. 
+Red is a language heavily based on the language of REBOL. Where Red itself reproduces the flexibility of the REBOL language, the underlying language Red will be built upon,
+Red/System, covers the more basic needs of programming like C can, being closer to the metal.
 
-Red will be the world's first Full Stack Programming Language. This means that it will be an effective tool to do (almost) any programming task on every level 
-from the metal to the meta without the aid of other stack tools. 
-Furthermore Red will be able to cross-compile Red source code without using any GCC like toolchain 
+Red will be the world's first Full Stack Programming Language. This means that it will be an effective tool to do (almost) any programming task on every level
+from the metal to the meta without the aid of other stack tools.
+Furthermore Red will be able to cross-compile Red source code without using any GCC like toolchain
 from any platform to any other platform. And it will do this all from a binary executable that is supposed to stay under 1 MB.
 
 Ready to learn your first Red?
 
 ```
-All text before the header will be treated as comment, as long as you avoid using the 
-word "red" starting with a capital "R" in this pre-header text. This is a temporary 
-shortcoming of the used lexer but most of the time you start your script or program 
-with the header itself. 
-The header of a red script is the capitalized word "red" followed by a 
+All text before the header will be treated as comment, as long as you avoid using the
+word "red" starting with a capital "R" in this pre-header text. This is a temporary
+shortcoming of the used lexer but most of the time you start your script or program
+with the header itself.
+The header of a red script is the capitalized word "red" followed by a
 whitespace character followed by a block of square brackets [].
-The block of brackets can be filled with useful information about this script or 
+The block of brackets can be filled with useful information about this script or
 program: the author's name, the filename, the version, the license, a summary of
 what the program does or any other files it needs.
-The red/System header is just like the red header, only saying "red/System" and 
+The red/System header is just like the red header, only saying "red/System" and
 not "red".
 
 Red []
@@ -49,21 +49,21 @@ comment {
 ; Your program's entry point is the first executable code that is found
 ; no need to restrict this to a 'main' function.
 
-; Valid variable names start with a letter and can contain numbers, 
-; variables containing only capital A thru F and numbers and ending with 'h' are 
-; forbidden, because that is how hexadecimal numbers are expressed in Red and 
+; Valid variable names start with a letter and can contain numbers,
+; variables containing only capital A thru F and numbers and ending with 'h' are
+; forbidden, because that is how hexadecimal numbers are expressed in Red and
 ; Red/System.
 
 ; assign a value to a variable using a colon ":"
 my-name: "Red"
-reason-for-using-the-colon: {Assigning values using the colon makes 
- the equality sign "=" exclusively usable for comparisons purposes, 
- exactly what "=" was intended for in the first place! 
+reason-for-using-the-colon: {Assigning values using the colon makes
+ the equality sign "=" exclusively usable for comparisons purposes,
+ exactly what "=" was intended for in the first place!
  Remember this y = x + 1 and x = 1 => y = 2 stuff from school?
 }
 is-this-name-valid?: true
 
-; print output using print, or prin for printing without a newline or linefeed at the 
+; print output using print, or prin for printing without a newline or linefeed at the
 ; end of the printed text.
 
 prin " My name is " print my-name
@@ -77,20 +77,20 @@ My name is Red
 ;
 ; Datatypes
 ;
-; If you know Rebol, you probably have noticed it has lots of datatypes. Red 
-; does not have yet all those types, but as Red want to be close to Rebol it 
+; If you know Rebol, you probably have noticed it has lots of datatypes. Red
+; does not have yet all those types, but as Red want to be close to Rebol it
 ; will have a lot of datatypes.
-; You can recognize types by the exclamation sign at the end. But beware 
-; names ending with an exclamation sign are allowed. 
-; Some of the available types are integer! string! block! 
-
-; Declaring variables before using them? 
-; Red knows by itself what variable is best to use for the data you want to use it 
-; for. 
-; A variable declaration is not always necessary. 
+; You can recognize types by the exclamation sign at the end. But beware
+; names ending with an exclamation sign are allowed.
+; Some of the available types are integer! string! block!
+
+; Declaring variables before using them?
+; Red knows by itself what variable is best to use for the data you want to use it
+; for.
+; A variable declaration is not always necessary.
 ; It is considered good coding practise to declare your variables,
 ; but it is not forced upon you by Red.
-; You can declare a variable and specify its type. a variable's type determines its 
+; You can declare a variable and specify its type. a variable's type determines its
 ; size in bytes.
 
 ; Variables of integer! type are usually 4 bytes or 32 bits
@@ -101,7 +101,7 @@ my-integer: 0
 type? my-integer
 integer!
 
-; A variable can be initialized using another variable that gets initialized 
+; A variable can be initialized using another variable that gets initialized
 ; at the same time.
 i2: 1 + i1: 1
 
@@ -111,9 +111,9 @@ i2 - i1 ; result 1
 i2 * i1 ; result 2
 i1 / i2 ; result 0 (0.5, but truncated towards 0)
 
-; Comparison operators are probably familiar, and unlike in other languages you 
+; Comparison operators are probably familiar, and unlike in other languages you
 ; only need a single '=' sign for comparison.
-; There is a boolean like type in Red. It has values true and false, but also the 
+; There is a boolean like type in Red. It has values true and false, but also the
 ; values on/off or yes/no can be used
 
 3 = 2 ; result false
@@ -125,15 +125,15 @@ i1 / i2 ; result 0 (0.5, but truncated towards 0)
 
 ;
 ; Control Structures
-; 
+;
 ; if
-; Evaluate a block of code if a given condition is true. IF does not return any value, 
+; Evaluate a block of code if a given condition is true. IF does not return any value,
 ; so cannot be used in an expression.
 if a < 0 [print "a is negative"]
 
 ; either
-; Evaluate a block of code if a given condition is true, else evaluate an alternative 
-; block of code. If the last expressions in both blocks have the same type, EITHER can 
+; Evaluate a block of code if a given condition is true, else evaluate an alternative
+; block of code. If the last expressions in both blocks have the same type, EITHER can
 ; be used inside an expression.
 either a < 0 [
    either a = 0 [
@@ -147,7 +147,7 @@ either a < 0 [
 
 print ["a is " msg lf]
 
-; There is an alternative way to write this 
+; There is an alternative way to write this
 ; (Which is allowed because all code paths return a value of the same type):
 
 msg: either a < 0 [
@@ -162,7 +162,7 @@ msg: either a < 0 [
 print ["a is " msg lf]
 
 ; until
-; Loop over a block of code until the condition at end of block, is met. 
+; Loop over a block of code until the condition at end of block, is met.
 ; UNTIL does not return any value, so it cannot be used in an expression.
 c: 5
 until [
@@ -172,11 +172,11 @@ until [
 ]
 ;   will output:
 ooooo
-; Note that the loop will always be evaluated at least once, even if the condition is 
+; Note that the loop will always be evaluated at least once, even if the condition is
 ; not met from the beginning.
 
 ; while
-; While a given condition is met, evaluate a block of code. 
+; While a given condition is met, evaluate a block of code.
 ; WHILE does not return any value, so it cannot be used in an expression.
 c: 5
 while [c > 0][
@@ -206,7 +206,7 @@ print twice b   ; will output 6.
 
 ## Further Reading
 
-The main source for information about Red is the [Red language homepage](http://www.red-lang.org).  
+The main source for information about Red is the [Red language homepage](http://www.red-lang.org).
 
 The source can be found on [github](https://github.com/red/red).
 
@@ -218,4 +218,4 @@ Browse or ask questions on [Stack Overflow](stackoverflow.com/questions/tagged/r
 
 Maybe you want to try Red right away? That is possible on the [try Rebol and Red site](http://tryrebol.esperconsultancy.nl).
 
-You can also learn Red by learning some [Rebol](http://www.rebol.com/docs.html). 
+You can also learn Red by learning some [Rebol](http://www.rebol.com/docs.html).
diff --git a/ru-ru/css-ru.html.markdown b/ru-ru/css-ru.html.markdown
new file mode 100644
index 00000000..2e2d40b7
--- /dev/null
+++ b/ru-ru/css-ru.html.markdown
@@ -0,0 +1,250 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+filename: learncss-ru.css
+lang: ru-ru
+---
+
+В свои ранние дни веб состоял в основном из чистого текста. С развитием браузеров
+веб-страницы с графическими элементами стали обычным делом.
+CSS - язык, разграничивающий содержимое (HTML) и внешний вид веб-страниц.
+
+Если коротко, то CSS предоставляет синтаксис, позволяющий выбирать различные
+HTML элементы и определять их внешний вид.
+
+Как и у других языков, у CSS много версий. Мы описываем CSS2.0 - не самую новую,
+но самую поддерживаемую и распространенную версию.
+
+**ВАЖНО:** Так как результатом применения CSS является изменение внешнего вида
+элементов, постарайтесь использовать CSS-песочницы при изучении языка.
+Например [dabblet](http://dabblet.com/).
+В данной статье рассматриваются в первую очередь синтаксис и общие рекомендации.
+
+
+```css
+/* Для комментариев используется слеш-астериск, как на этой строчке.
+   В CSS нет однострочных комментариев; все комментарии записываются таким способом */
+
+/* ####################
+   ## СЕЛЕКТОРЫ
+   #################### */
+
+/* Выражения в CSS очень просты */
+селектор { атрибут: значение; /* другие атрибуты...*/ }
+
+/* селекторы используются для выбора элементов на странице
+
+Чтобы выбрать все элементы, используйте астериск: */
+* { color:red; }
+
+/*
+Если на странице присутствует такой элемент:
+
+<div class='some-class class2' id='someId' attr='value' otherAttr='en-us foo bar' />
+*/
+
+/* его можно выбрать по одному классу */
+.some-class { }
+
+/* или по обоим классам */
+.some-class.class2 { }
+
+/* по названию тега */
+div { }
+
+/* по идентификатору */
+#someId { }
+
+/* по имеющемуся атрибуту */
+[attr] { font-size:smaller; }
+
+/* или по атрибуту с определенным значением */
+[attr='value'] { font-size:smaller; }
+
+/* можно выбрать атрибуты, начинающиеся с определенного значения (CSS3) */
+[attr^='val'] { font-size:smaller; }
+
+/* или заканчивающиеся определенным значением (CSS3) */
+[attr$='ue'] { font-size:smaller; }
+
+/* содержащие отделенное пробелами значение в названии атрибута (CSS3)  */
+[otherAttr~='foo'] { font-size:smaller; }
+
+/* можно выбрать атрибут как с точным, так и со стоящим после значения “-” (U+002D) */
+[otherAttr|='en'] { font-size:smaller; }
+
+
+/* Более того, все это можно использовать вместе - между разными частями
+не должно быть пробелов, иначе селектор будет иметь совершенно иное значение  */
+div.some-class[attr$='ue'] { }
+
+/* Вы можете выбрать элемент по его родителю */
+
+/* прямой потомок другого элемента (выбранного с помощью селектора) */
+div.some-parent > .class-name {}
+
+/* потомок любого родителя в дереве элементов
+   следующая строка означает: "любой элемент класса "class-name",
+   являющийся потомком div-элемента класса "some-parent"
+   НЕЗАВИСИМО ОТ УРОВНЯ ВЛОЖЕННОСТИ" */
+div.some-parent .class-name {}
+
+/* важно: этот же селектор без пробелов имеет иное значение
+   можете догадаться, какое? */
+div.some-parent.class-name {}
+
+/* вы можете выбрать элемент по первому предшествующему
+   родственному элементу */
+.i-am-before + .this-element { }
+
+/* или любому предшествующему родственнику перед элементом */
+.i-am-any-before ~ .this-element {}
+
+
+/* Существуют псевдо-классы, позволяющие изменять внешний вид элемента
+   в зависимости от событий, произошедших с элементом */
+
+/* например, когда курсор наведен на элемент */
+element:hover {}
+
+/* когда пользователь проходил по ссылке ранее */
+element:visited {}
+
+/* или еще не проходил по ней */
+element:link {}
+
+/* выбранное поле воода (input) */
+element:focus {}
+
+
+/* ####################
+   ## АТРИБУТЫ
+   #################### */
+
+selector {
+    
+    /* Единицы измерения */
+    width: 50%; /* проценты */
+    font-size: 2em; /* умножается на высоту шрифта (2em - в два раза больше) */
+    width: 200px; /* пиксели */
+    font-size: 20pt; /* пункты */
+    width: 5cm; /* сантиметры */
+    min-width: 50mm; /* милиметры */
+    max-width: 5in; /* дюймы */
+    height: 0.2vh; /* умножается на высоту окна браузера (CSS3) */
+    width: 0.4vw; /* умножается на ширину окна браузера (CSS3) */
+    min-height: 0.1vmin; /* наименьшее из vh и vw (CSS3) */
+    max-width: 0.3vmax; /* наибольшее из vh и vw (CSS3) */
+    
+    /* Цвета */
+    background-color: #F6E;  /* сокращенная запись шестнадцатеричного кода */
+    background-color: #F262E2; /* стандартная запись шестнадцатеричного кода */
+    background-color: tomato; /* название цвета */
+    background-color: rgb(255, 255, 255); /* цветовая модель rgb */
+    background-color: rgb(10%, 20%, 50%); /* цветовая модель rgb в процентах */
+    background-color: rgba(255, 0, 0, 0.3); /* цветовая модель rgb (последний аргумент отвечает за прозрачность цвета) (CSS3) */
+    background-color: transparent; /* прозрачный цвет */
+    background-color: hsl(0, 100%, 50%); /* в формате hsl (CSS3) */
+    background-color: hsla(0, 100%, 50%, 0.3); /* в формате hsl (последний аргумент отвечает за непрозрачность цвета) (CSS3) */
+
+    
+    /* Изображения */
+    background-image: url(/path-to-image/image.jpg); /* кавычки внутри url() опциональны */
+    
+    /* Шрифты */
+    font-family: Arial;
+    font-family: "Courier New"; /* если в названии есть пробелы, заключите его в кавычки */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif; /* если шрифт не найден,
+                             будет использован следующий за ним в списке */
+}
+
+```
+
+## Использование
+
+Сохраните готовый файл с расширением .css
+
+```xml
+<!-- добавьте css файл в тег <head> на странице: -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+
+<!-- Можно использовать встроенные стили. Рекомендуется избегать подобного подхода. -->
+<body>
+  <style>
+     a { color: purple; }
+  </style>
+</body>
+
+<!-- Можно установить стиль элемента напрямую.
+Используйте этот способ только в случае крайней необходимости. -->
+<div style="border: 1px solid red;">
+</div>
+
+```
+
+## Приоритет
+
+Как вы заметили, внешний вид элемента может определяться несколькими селекторами,
+а значение атрибута элемента может быть установлено больше одного раза.
+В подобных случаях одно из значений оказывается приоритетнее остальных.
+
+Если взять следующую таблицу стилей:
+
+```css
+/*A*/
+p.class1[attr='value']
+
+/*B*/
+p.class1 {}
+
+/*C*/
+p.class2 {}
+
+/*D*/
+p {}
+
+/*E*/
+p { property: value !important; }
+
+```
+
+и следующую разметку:
+
+```xml
+<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
+</p>
+```
+
+Приоритет стилей будет таким:
+Помните: приоритет выставляется для **атрибута**, а не для всего блока стилей.
+
+* `E` имеет наивысший приоритет благодаря ключевому слову `!important`.
+    Используйте только в случае крайней необходимости.
+* `F` идет следующим, так как является встроенным стилем.
+* `A` следующий, как самый конкретизированный.  
+    конкретизированный == большее количество определителей.
+    В этом примере 3 определителя: 1 тег `p` +   
+    название класса `class1` + 1 атрибут `attr='value'`
+* `C` следующий. Несмотря на одинаковое с `B` количество определителей,
+    `C` определен позже.
+* Затем `B`
+* И последний `D`.
+
+## Совместимость
+
+Несмотря на то, что большая часть функций CSS2 (а также CSS3) подеррживается всеми
+браузерами и устройствами, не забывайте проверять совместимость CSS-правил
+с современными браузерами.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) замечательно подходит для этого.
+
+To run a quick compatibility check, [CanIUse](http://caniuse.com) is a great resource.
+
+## Ресурсы для самостоятельного изучения
+
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
diff --git a/ru-ru/javascript-ru.html.markdown b/ru-ru/javascript-ru.html.markdown
index 79844565..8655ae4a 100644
--- a/ru-ru/javascript-ru.html.markdown
+++ b/ru-ru/javascript-ru.html.markdown
@@ -470,9 +470,6 @@ myNumber === myNumberObj; // = false
 if (0) {
     // Этот код не выполнится, потому что 0 - это ложь.
 }
-if (Number(0)) {
-    // Этот код *выполнится*, потому что Number(0) истинно.
-}
 
 // Впрочем, объекты-обёртки и встроенные типы имеют общие прототипы,
 // поэтому вы можете расширить функционал строк, например:
diff --git a/ru-ru/objective-c-ru.html.markdown b/ru-ru/objective-c-ru.html.markdown
index ddff2e5c..8eac4ddb 100644
--- a/ru-ru/objective-c-ru.html.markdown
+++ b/ru-ru/objective-c-ru.html.markdown
@@ -17,7 +17,7 @@ Cocoa Touch.
 Он является объектно-ориентированным языком программирования общего назначения,
 который добавляет обмен сообщениями в Smalltalk-стиле к языку программирования C.
 
-```objective_c
+```objective-c
 // Однострочные комментарии начинаются с //
 
 /*
diff --git a/ru-ru/php-ru.html.markdown b/ru-ru/php-ru.html.markdown
index 53b2f916..5672aa90 100644
--- a/ru-ru/php-ru.html.markdown
+++ b/ru-ru/php-ru.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Trismegiste", "https://github.com/Trismegiste"]
 translators:
     - ["SlaF", "https://github.com/SlaF"]
+    - ["Corpsee", "https://github.com/corpsee"]
 lang: ru-ru
 filename: learnphp-ru.php
 ---
@@ -14,8 +15,8 @@ filename: learnphp-ru.php
 ```php
 <?php // PHP код должен быть заключен в теги <?php
 
-// Если ваш файл содержит только PHP код, то можно
-// пропустить закрывающийся ?>
+// Если ваш файл содержит только PHP-код, то можно
+пропустить закрывающий ?>
 
 // А так начинаются комментарии
 
@@ -30,10 +31,10 @@ filename: learnphp-ru.php
 print('Hello '); // Напечатать "Hello " без перевода строки
 
 // () необязательно применять для print и echo
-echo "World\n"; // Печатать "World" и перейти на новую строку.
+echo "World\n"; // Напечатать "World" и перейти на новую строку.
 // (все утверждения должны заканчиваться ;)
 
-// Любые символы за пределами закрывающегося тега выводятся автоматически:
+// Любые символы за пределами закрывающего тега выводятся автоматически:
 ?>
 Hello World Again!
 <?php
@@ -46,7 +47,7 @@ Hello World Again!
 // Переменные начинаются с символа $.
 // Правильное имя переменной начинается с буквы или знака подчеркивания,
 // и может содержать любые цифры, буквы, или знаки подчеркивания.
-// Не рекомендуется использовать кирилические символы в именах (прим. пер.)
+// Не рекомендуется использовать кириллические символы в именах (прим. пер.)
 
 // Логические значения нечувствительны к регистру
 $boolean = true;  // или TRUE или True
@@ -56,7 +57,7 @@ $boolean = false; // или FALSE или False
 $int1 = 12;   // => 12
 $int2 = -12;  // => -12-
 $int3 = 012;  // => 10 (ведущий 0 обозначает восьмеричное число)
-$int4 = 0x0F; // => 15 (ведущие символы 0x означает шестнадцатеричное число)
+$int4 = 0x0F; // => 15 (ведущие символы 0x означают шестнадцатеричное число)
 
 // Дробные числа
 $float = 1.234;
@@ -126,7 +127,7 @@ echo 'This outputs '.FOO;
 
 // Все массивы в PHP - это ассоциативные массивы или хеши,
 
-// Ассоциативные массивы, известные в других языках как хеш-карты.
+// Ассоциативные массивы, известные в других языках как HashMap.
 
 // Работает во всех версиях РHP
 $associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
@@ -199,13 +200,13 @@ assert($c > $b); // больше
 assert($a <= $b); // меньше или равно
 assert($c >= $d); // больше или равно
 
-// Следующие утверждения истинны если переменные имеют одинаковый тип.
+// Следующие утверждения истинны, если переменные имеют одинаковый тип.
 assert($c === $d);
 assert($a !== $d);
 assert(1 == '1');
 assert(1 !== '1');
 
-// Переменные могут изменять тип, в зависимости от их использования.
+// Переменные могут изменять тип в зависимости от их использования.
 $integer = 1;
 echo $integer + $integer; // => 2
 
@@ -235,7 +236,7 @@ $var = null; // Null
 $integer = 10;
 $boolen = settype($integer, "string") // теперь $integer имеет строковый тип
 
-// settype возвращает true - если преобразование удалось и false в противном случае
+// settype возвращает true, если преобразование удалось и false в противном случае
 
 /********************************
  * Управляющие структуры
@@ -311,7 +312,7 @@ echo "\n";
 
 for ($x = 0; $x < 10; $x++) {
     echo $x;
-} // Prints "0123456789"
+} // Напечатает "0123456789"
 
 echo "\n";
 
@@ -320,7 +321,7 @@ $wheels = ['bicycle' => 2, 'car' => 4];
 // Циклы foreach могут обходить массивы
 foreach ($wheels as $wheel_count) {
     echo $wheel_count;
-} // Prints "24"
+} // Напечатает "24"
 
 echo "\n";
 
@@ -337,14 +338,14 @@ while ($i < 5) {
         break; // Exit out of the while loop
     }
     echo $i++;
-} // Prints "012"
+} // Напечатает "012"
 
 for ($i = 0; $i < 5; $i++) {
     if ($i === 3) {
         continue; // Skip this iteration of the loop
     }
     echo $i;
-} // Prints "0124"
+} // Напечатает "0124"
 
 
 /********************************
@@ -369,7 +370,7 @@ function add ($x, $y = 1) { // $y по умолчанию равно 1
 echo add(4); // => 5
 echo add(4, 2); // => 6
 
-// $result недоступна за пределами функции
+// $result недоступен за пределами функции
 // print $result; // Выдает предупреждение
 
 // Начиная с PHP 5.3 вы можете объявлять анонимные функции:
@@ -402,19 +403,19 @@ echo $function_name(1, 2); // => 3
 
 
 /********************************
- * Includes
+ * Включения
  */
 
 <?php
 // PHP код внутри включаемого файла должен начинаться с тега PHP.
 
 include 'my-file.php';
-// Код в файле my-file.php теперь доступен в текущем в текущем пространстве имен.
-// Если файл не удалось включить, будет выдано предупреждение.
+// Код в файле my-file.php теперь доступен в текущем пространстве имен.
+// Если файл не удалось подключить, то будет выдано предупреждение.
 
 include_once 'my-file.php';
-// Если код в файле my-file.php уже был включен, он не будет включен повторно.
-// Это предотвращает ошибку повторного включения файла.
+// Если код в файле my-file.php уже был подключен, он не будет подключен повторно.
+// Это предотвращает ошибку повторного подключения файла.
 
 require 'my-file.php';
 require_once 'my-file.php';
@@ -422,7 +423,7 @@ require_once 'my-file.php';
 // Same as include(), except require() will cause a fatal error if the
 // file cannot be included.
 // Действует также как и include(), но если файл не удалось подключить,
-// функция выдает неисправимую ошибку
+// функция выдает фатальную ошибку
 
 // Содержимое файла my-include.php:
 <?php
@@ -452,19 +453,19 @@ class MyClass
 
     static $staticVar   = 'static';
 
-    // Properties must declare their visibility
+    // Свойства объявляются с указанием их видимости
     public $property    = 'public';
     public $instanceProp;
-    protected $prot = 'protected'; // Accessible from the class and subclasses
-    private $priv   = 'private';   // Accessible within the class only
+    protected $prot = 'protected'; // Свойство доступно только потомкам и самому классу
+    private $priv   = 'private';   // Свойство доступно только самому классу
 
-    // Create a constructor with __construct
+    // Конструктор описывается с помощью __construct
     public function __construct($instanceProp) {
-        // Access instance variables with $this
+        // Доступ к эземпляру класса с помощью $this
         $this->instanceProp = $instanceProp;
     }
 
-    // Methods are declared as functions inside a class
+    // Методы объявляются как функции принадлежащие классу
     public function myMethod()
     {
         print 'MyClass';
@@ -502,7 +503,7 @@ class MyOtherClass extends MyClass
         echo $this->prot;
     }
 
-    // Override a method
+    // Переопределение родительского метода
     function myMethod()
     {
         parent::myMethod();
@@ -595,7 +596,7 @@ class SomeOtherClass implements InterfaceOne, InterfaceTwo
  * Трейты
  */
 
-// Трейты появились в PHP 5.4.0 и объявляются при помощи ключевого слова trait
+// Трейты появились в PHP 5.4 и объявляются при помощи ключевого слова trait
 
 trait MyTrait
 {
@@ -611,7 +612,7 @@ class MyTraitfulClass
 }
 
 $cls = new MyTraitfulClass();
-$cls->myTraitMethod(); // Prints "I have MyTrait"
+$cls->myTraitMethod(); // Напечатает "I have MyTrait"
 
 
 /********************************
diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown
index a0e2b474..3852a550 100644
--- a/ru-ru/python-ru.html.markdown
+++ b/ru-ru/python-ru.html.markdown
@@ -167,6 +167,10 @@ li = []
 # Можно сразу начать с заполненного списка
 other_li = [4, 5, 6]
 
+# строка разделена в список
+a="adambard"
+list(a) #=> ['a','d','a','m','b','a','r','d']
+
 # Объекты добавляются в конец списка методом append
 li.append(1)    # [1]
 li.append(2)    # [1, 2]
@@ -238,7 +242,6 @@ d, e, f = 4, 5, 6
 # Обратите внимание, как легко поменять местами значения двух переменных
 e, d = d, e     # теперь d == 5, а e == 4
 
-
 #  Словари содержат ассоциативные массивы
 empty_dict = {}
 # Вот так описывается предзаполненный словарь
diff --git a/ru-ru/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown
index 318e0e09..69b5fb46 100644
--- a/ru-ru/ruby-ru.html.markdown
+++ b/ru-ru/ruby-ru.html.markdown
@@ -158,6 +158,7 @@ array << 6 #=> [1, 2, 3, 4, 5, 6]
 hash = {'color' => 'green', 'number' => 5}
 
 hash.keys #=> ['color', 'number']
+hash.values #=> ['green', 5]
 
 # Значение в хэше легко может быть найдено по ключу:
 hash['color'] #=> 'green'
diff --git a/ruby-ecosystem.html.markdown b/ruby-ecosystem.html.markdown
index d8a02d36..1fbcc752 100644
--- a/ruby-ecosystem.html.markdown
+++ b/ruby-ecosystem.html.markdown
@@ -42,7 +42,7 @@ The three major version of Ruby in use are:
 * 2.0.0 - Released in February 2013. Most major libraries and frameworks support
   2.0.0.
 * 1.9.3 - Released in October 2011. This is the version most rubyists use
-  currently.
+  currently. Also [retired](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
 * 1.8.7 - Ruby 1.8.7 has been
   [retired](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
 
diff --git a/ruby.html.markdown b/ruby.html.markdown
index 7bd28d86..998b4bf7 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -12,7 +12,8 @@ contributors:
   - ["Dzianis Dashkevich", "https://github.com/dskecse"]
   - ["Levi Bostian", "https://github.com/levibostian"]
   - ["Rahil Momin", "https://github.com/iamrahil"]
-
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
 ---
 
 ```ruby
@@ -39,6 +40,8 @@ You shouldn't either
 10 * 2 #=> 20
 35 / 5 #=> 7
 2**5 #=> 32
+5 % 3 #=> 2
+5 ^ 6 #=> 3
 
 # Arithmetic is just syntactic sugar
 # for calling a method on an object
@@ -106,8 +109,20 @@ placeholder = 'use string interpolation'
 'hello ' + 3 #=> TypeError: can't convert Fixnum into String
 'hello ' + 3.to_s #=> "hello 3"
 
-# print to the output
+# Combine strings and operators
+'hello ' * 3 #=> "hello hello hello "
+
+# Append to string
+'hello' << ' world' #=> "hello world"
+
+# print to the output with a newline at the end
 puts "I'm printing!"
+#=> I'm printing!
+#=> nil
+
+# print to the output without a newline
+print "I'm printing!"
+#=> I'm printing! => nill
 
 # Variables
 x = 25 #=> 25
@@ -154,6 +169,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 # Arrays can be indexed
 # From the front
 array[0] #=> 1
+array.first #=> 1
 array[12] #=> nil
 
 # Like arithmetic, [var] access
@@ -164,10 +180,15 @@ array.[] 12 #=> nil
 
 # From the end
 array[-1] #=> 5
+array.last #=> 5
 
 # With a start index and length
 array[2, 3] #=> [3, 4, 5]
 
+# Reverse an Array
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
 # Or with a range
 array[1..3] #=> [2, 3, 4]
 
@@ -254,6 +275,12 @@ hash.each do |key, value|
   puts "#{key} is #{value}"
 end
 
+# If you still need and index you can use "each_with_index" and define an index
+# variable
+array.each_with_index do |element, index|
+  puts "#{element} is number #{index} in the array"
+end
+
 counter = 1
 while counter <= 5 do
   puts "iteration #{counter}"
@@ -265,6 +292,19 @@ end
 #=> iteration 4
 #=> iteration 5
 
+# There are a bunch of other helpful looping functions in Ruby,
+# for example "map", "reduce", "inject", the list goes on. Map,
+# for instance, takes the array it's looping over, does something
+# to it as defined in your block, and returns an entirely new array.
+array = [1,2,3,4,5]
+doubled = array.map do |element|
+  element * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
 grade = 'B'
 
 case grade
diff --git a/rust.html.markdown b/rust.html.markdown
index 4fbd6144..d0c56b4a 100644
--- a/rust.html.markdown
+++ b/rust.html.markdown
@@ -6,20 +6,20 @@ filename: learnrust.rs
 ---
 
 Rust is a programming language developed by Mozilla Research.
-Rust combines low-level control over performance with high-level convenience and 
-safety guarantees. 
+Rust combines low-level control over performance with high-level convenience and
+safety guarantees.
 
-It achieves these goals without requiring a garbage collector or runtime, making 
+It achieves these goals without requiring a garbage collector or runtime, making
 it possible to use Rust libraries as a "drop-in replacement" for C.
 
-Rust’s first release, 0.1, occurred in January 2012, and for 3 years development 
+Rust’s first release, 0.1, occurred in January 2012, and for 3 years development
 moved so quickly that until recently the use of stable releases was discouraged
-and instead the general advise was to use nightly builds. 
+and instead the general advice was to use nightly builds.
 
-On May 15th 2015, Rust 1.0 was released with a complete guarantee of backward 
+On May 15th 2015, Rust 1.0 was released with a complete guarantee of backward
 compatibility. Improvements to compile times and other aspects of the compiler are
 currently available in the nightly builds. Rust has adopted a train-based release
-model with regular releases every six weeks. Rust 1.1 beta was made available at 
+model with regular releases every six weeks. Rust 1.1 beta was made available at
 the same time of the release of Rust 1.0.
 
 Although Rust is a relatively low-level language, Rust has some functional
@@ -287,9 +287,9 @@ fn main() {
     // While a value is mutably borrowed, it cannot be accessed at all.
     let mut var2 = 4;
     let ref_var2: &mut i32 = &mut var2;
-    *ref_var2 += 2;
+    *ref_var2 += 2;         // '*' is used to point to the mutably borrowed var2
 
-    println!("{}", *ref_var2); // 6
+    println!("{}", *ref_var2); // 6 , //var2 would not compile. //ref_var2 is of type &mut i32, so                                                      //stores a reference to an i32 not the value.
     // var2 = 2; // this would not compile because `var2` is borrowed
 }
 ```
diff --git a/sass.html.markdown b/sass.html.markdown
new file mode 100644
index 00000000..02bec47f
--- /dev/null
+++ b/sass.html.markdown
@@ -0,0 +1,447 @@
+---
+language: sass
+filename: learnsass.scss
+contributors:
+  - ["Laura Kyle", "https://github.com/LauraNK"]
+  - ["Sean Corrales", "https://github.com/droidenator"]
+---
+
+Sass is a CSS extension language that adds features such as variables, nesting, mixins and more. 
+Sass (and other preprocessors, such as [Less](http://lesscss.org/)) help developers to write maintainable and DRY (Don't Repeat Yourself) code.
+
+Sass has two different syntax options to choose from. SCSS, which has the same syntax as CSS but with the added features of Sass. Or Sass (the original syntax), which uses indentation rather than curly braces and semicolons. 
+This tutorial is written using SCSS.
+
+If you're already familiar with CSS3, you'll be able to pick up Sass relatively quickly. It does not provide any new styling options but rather the tools to write your CSS more efficiently and make maintenance much easier.
+
+```scss
+
+	
+//Single line comments are removed when Sass is compiled to CSS.
+
+/*Multi line comments are preserved. */	
+	
+	
+	
+/*Variables
+==============================*/
+	
+	
+
+/* You can store a CSS value (such as a color) in a variable.
+Use the '$' symbol to create a variable. */
+	
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;	
+
+/* You can use the variables throughout your stylesheet. 
+Now if you want to change a color, you only have to make the change once.*/	
+	
+body {
+	background-color: $primary-color;
+	color: $secondary-color;
+	font-family: $body-font;
+}
+
+/* This would compile to: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* This is much more maintainable than having to change the color
+each time it appears throughout your stylesheet. */
+	
+
+
+/*Mixins
+==============================*/
+
+
+
+/* If you find you are writing the same code for more than one
+element, you might want to store that code in a mixin.
+
+Use the '@mixin' directive, plus a name for your mixin.*/
+
+@mixin center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* You can use the mixin with '@include' and the mixin name. */
+
+div {
+	@include center;
+	background-color: $primary-color;
+}
+
+/*Which would compile to: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+
+/* You can use mixins to create a shorthand property. */
+
+@mixin size($width, $height) {
+	width: $width;
+	height: $height;
+}
+	
+/*Which you can invoke by passing width and height arguments. */
+
+.rectangle {
+	@include size(100px, 60px);
+}
+
+.square {
+	@include size(40px, 40px);
+}
+
+/* This compiles to: */
+.rectangle {
+  width: 100px;
+  height: 60px; 
+}
+
+.square {
+  width: 40px;
+  height: 40px; 
+}
+
+
+
+/*Functions
+==============================*/   
+   
+   
+   
+/* Sass provides functions that can be used to accomplish a variety of 
+   tasks. Consider the following */
+
+/* Functions can be invoked by using their name and passing in the 
+   required arguments */
+body {
+  width: round(10.25px);    
+}
+
+.footer {
+  background-color: fade_out(#000000, 0.25)
+}
+
+/* Compiles to: */
+
+body {
+  width: 10px;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}   
+   
+/* You may also define your own functions. Functions are very similar to 
+   mixins. When trying to choose between a function or a mixin, remember
+   that mixins are best for generating CSS while functions are better for 
+   logic that might be used throughout your Sass code. The examples in 
+   the Math Operators' section are ideal candidates for becoming a reusable 
+   function. */
+
+/* This function will take a target size and the parent size and calculate 
+   and return the percentage */
+   
+@function calculate-percentage($target-size, $parent-size) {
+  @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+  width: $main-content;
+}
+
+.sidebar {
+  width: calculate-percentage(300px, 960px);
+}
+
+/* Compiles to: */
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+
+
+/*Extend (Inheritance)
+==============================*/
+
+
+
+/*Extend is a way to share the properties of one selector with another. */
+
+.display {
+	@include size(5em, 5em);
+	border: 5px solid $secondary-color;
+}
+
+.display-success {
+	@extend .display;
+	border-color: #22df56;
+}
+
+/* Compiles to: */
+.display, .display-success {
+  width: 5em;
+  height: 5em;
+  border: 5px solid #51527F; 
+}
+
+.display-success {
+  border-color: #22df56; 
+}
+
+/* Extending a CSS statement is preferable to creating a mixin 
+   because of the way it groups together the classes that all share
+   the same base styling. If this was done with a mixin, the width, 
+   height, and border would be duplicated for each statement that 
+   called the mixin. While it won't affect your workflow, it will
+   add unnecessary bloat to the files created by the Sass compiler. */
+
+	
+
+/*Nesting
+==============================*/
+
+
+
+/*Sass allows you to nest selectors within selectors */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+	
+	li {
+		background-color: #FF0000;		
+	}	
+}
+
+/* '&' will be replaced by the parent selector. */
+/* You can also nest pseudo-classes. */
+/* Keep in mind that over-nesting will make your code less maintainable.
+Best practices recommend going no more than 3 levels deep when nesting.
+For example: */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+	
+	li {
+		background-color: red;
+		
+		&:hover {
+		  background-color: blue;
+		}
+		
+		a {
+		  color: white;
+		}
+	}	
+}
+
+/* Compiles to: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/*Partials and Imports
+==============================*/   
+   
+   
+   
+/* Sass allows you to create partial files. This can help keep your Sass
+   code modularized. Partial files should begin with an '_', e.g. _reset.css.
+   Partials are not generated into CSS. */
+   
+/* Consider the following CSS which we'll put in a file called _reset.css */
+   
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+   
+/* Sass offers @import which can be used to import partials into a file.
+   This differs from the traditional CSS @import statement which makes 
+   another HTTP request to fetch the imported file. Sass takes the 
+   imported file and combines it with the compiled code. */
+   
+@import 'reset';
+   
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compiles to: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}   
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+  
+
+   
+/*Placeholder Selectors
+==============================*/  
+    
+    
+   
+/* Placeholders are useful when creating a CSS statement to extend. If you
+   wanted to create a CSS statement that was exclusively used with @extend,
+   you can do so using a placeholder. Placeholders begin with a '%' instead
+   of '.' or '#'. Placeholders will not appear in the compiled CSS. */
+   
+%content-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  @extend %content-window;
+  background-color: #0000ff;
+}
+
+/* Compiles to: */
+
+.message-window {
+  font-size: 14px;
+  padding: 10px;
+  color: #000;
+  border-radius: 4px;
+}
+
+.message-window {
+  background-color: #0000ff;
+}
+
+      
+  
+/*Math Operations
+==============================*/   
+    
+      
+   
+/* Sass provides the following operators: +, -, *, /, and %. These can
+   be useful for calculating values directly in your Sass files instead
+   of using values that you've already calculated by hand. Below is an example
+   of a setting up a simple two column design. */
+   
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: $main-size;
+}
+
+.sidebar {
+  width: $sidebar-size;
+}
+
+.gutter {
+  width: $gutter;
+}
+
+/* Compiles to: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+	
+```	
+
+
+
+## SASS or Sass?
+Have you ever wondered whether Sass is an acronym or not? You probably haven't, but I'll tell you anyway. The name of the language is a word, "Sass", and not an acronym. 
+Because people were constantly writing it as "SASS", the creator of the language jokingly called it "Syntactically Awesome StyleSheets". 
+
+
+## Practice Sass
+If you want to play with Sass in your browser, check out [SassMeister](http://sassmeister.com/).
+You can use either syntax, just go into the settings and select either Sass or SCSS.
+
+
+## Compatibility
+
+Sass can be used in any project as long as you have a program to compile it
+into CSS. You'll want to verify that the CSS you're using is compatible
+with your target browsers. 
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) and [CanIUse](http://caniuse.com) are great resources for checking compatibility. 
+
+	
+## Further reading
+* [Official Documentation](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) provides tutorials (beginner-advanced) and articles.
diff --git a/scala.html.markdown b/scala.html.markdown
index c482752d..7f545196 100644
--- a/scala.html.markdown
+++ b/scala.html.markdown
@@ -6,7 +6,6 @@ contributors:
     - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
     - ["Geoff Liu", "http://geoffliu.me"]
     - ["Ha-Duong Nguyen", "http://reference-error.org"]
-filename: learn.scala
 ---
 
 Scala - the scalable language
@@ -43,9 +42,13 @@ Scala - the scalable language
 // Printing, and forcing a new line on the next print
 println("Hello world!")
 println(10)
+// Hello world!
+// 10
 
 // Printing, without forcing a new line on next print
 print("Hello world")
+print(10)
+// Hello world!10
 
 // Declaring values is done using either var or val.
 // val declarations are immutable, whereas vars are mutable. Immutability is
@@ -240,10 +243,11 @@ i    // Show the value of i. Note that while is a loop in the classical sense -
      // comprehensions above is easier to understand and parallelize
 
 // A do while loop
+i = 0
 do {
-  println("x is still less than 10")
-  x += 1
-} while (x < 10)
+  println("i is still less than 10")
+  i += 1
+} while (i < 10)
 
 // Tail recursion is an idiomatic way of doing recurring things in Scala.
 // Recursive functions need an explicit return type, the compiler can't infer it.
@@ -562,8 +566,8 @@ sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
 // Implicit function parameters enable us to simulate type classes in other
 // functional languages. It is so often used that it gets its own shorthand. The
 // following two lines mean the same thing:
-def foo[T](implicit c: C[T]) = ...
-def foo[T : C] = ...
+// def foo[T](implicit c: C[T]) = ...
+// def foo[T : C] = ...
 
 
 // Another situation in which the compiler looks for an implicit is if you have
diff --git a/self.html.markdown b/self.html.markdown
index 69524a84..9290a0c9 100644
--- a/self.html.markdown
+++ b/self.html.markdown
@@ -5,13 +5,13 @@ contributors:
 filename: learnself.self
 ---
 
-Self is a fast prototype based OO language which runs in its own JIT vm. Most development is done through interacting with live objects through a visual development environment called *morphic* with integrated browsers and debugger. 
+Self is a fast prototype based OO language which runs in its own JIT vm. Most development is done through interacting with live objects through a visual development environment called *morphic* with integrated browsers and debugger.
 
 Everything in Self is an object. All computation is done by sending messages to objects. Objects in Self can be understood as sets of key-value slots.
 
 # Constructing objects
 
-The inbuild Self parser can construct objects, including method objects. 
+The inbuild Self parser can construct objects, including method objects.
 
 ```
 "This is a comment"
@@ -38,18 +38,18 @@ The inbuild Self parser can construct objects, including method objects.
   x <- 20.
 |)
 
-"An object which understands the method 'doubleX' which 
+"An object which understands the method 'doubleX' which
 doubles the value of x and then returns the object"
 (|
   x <- 20.
   doubleX = (x: x * 2. self)
 |)
 
-"An object which understands all the messages 
-that 'traits point' understands". The parser 
-looks up 'traits point' by sending the messages 
-'traits' then 'point' to a known object called 
-the 'lobby'. It looks up the 'true' object by 
+"An object which understands all the messages
+that 'traits point' understands". The parser
+looks up 'traits point' by sending the messages
+'traits' then 'point' to a known object called
+the 'lobby'. It looks up the 'true' object by
 also sending the message 'true' to the lobby."
 (|     parent* = traits point.
        x = 7.
@@ -63,19 +63,19 @@ also sending the message 'true' to the lobby."
 Messages can either be unary, binary or keyword. Precedence is in that order. Unlike Smalltalk, the precedence of binary messages must be specified, and all keywords after the first must start with a capital letter. Messages are separeated from their destination by whitespace.
 
 ```
-"unary message, sends 'printLine' to the object '23' 
+"unary message, sends 'printLine' to the object '23'
 which prints the string '23' to stdout and returns the receiving object (ie 23)"
 23 printLine
 
 "sends the message '+' with '7' to '23', then the message '*' with '8' to the result"
-(23 + 7) * 8 
+(23 + 7) * 8
 
 "sends 'power:' to '2' with '8' returns 256"
-2 power: 8 
+2 power: 8
 
-"sends 'keyOf:IfAbsent:' to 'hello' with arguments 'e' and '-1'. 
+"sends 'keyOf:IfAbsent:' to 'hello' with arguments 'e' and '-1'.
 Returns 1, the index of 'e' in 'hello'."
-'hello' keyOf: 'e' IfAbsent: -1 
+'hello' keyOf: 'e' IfAbsent: -1
 ```
 
 # Blocks
@@ -90,13 +90,13 @@ Examples of the use of a block:
 
 ```
 "returns 'HELLO'"
-'hello' copyMutable mapBy: [|:c| c capitalize] 
+'hello' copyMutable mapBy: [|:c| c capitalize]
 
 "returns 'Nah'"
-'hello' size > 5 ifTrue: ['Yay'] False: ['Nah'] 
+'hello' size > 5 ifTrue: ['Yay'] False: ['Nah']
 
 "returns 'HaLLO'"
-'hello' copyMutable mapBy: [|:c| 
+'hello' copyMutable mapBy: [|:c|
    c = 'e' ifTrue: [c capitalize]
             False: ['a']]
 ```
@@ -105,7 +105,7 @@ Multiple expressions are separated by a period. ^ returns immediately.
 
 ```
 "returns An 'E'! How icky!"
-'hello' copyMutable mapBy: [|:c. tmp <- ''| 
+'hello' copyMutable mapBy: [|:c. tmp <- ''|
    tmp: c capitalize.
    tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!'].
    c capitalize
@@ -119,7 +119,7 @@ Blocks are performed by sending them the message 'value' and inherit (delegate t
     x: 15.
     "Repeatedly sends 'value' to the first block while the result of sending 'value' to the
      second block is the 'true' object"
-    [x > 0] whileTrue: [x: x - 1]. 
+    [x > 0] whileTrue: [x: x - 1].
     x
 ] value
 ```
@@ -130,12 +130,12 @@ Methods are like blocks but they are not within a context but instead are stored
 
 ```
 "Here is an object with one assignable slot 'x' and a method 'reduceXTo: y'.
-Sending the message 'reduceXTo: 10' to this object will put 
+Sending the message 'reduceXTo: 10' to this object will put
 the object '10' in the 'x' slot and return the original object"
-(| 
+(|
     x <- 50.
     reduceXTo: y = (
-        [x > y] whileTrue: [x: x - 1]. 
+        [x > y] whileTrue: [x: x - 1].
         self)
 |)
 .
diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown
new file mode 100644
index 00000000..3b388505
--- /dev/null
+++ b/smalltalk.html.markdown
@@ -0,0 +1,955 @@
+---
+language: smalltalk
+contributors:
+    - ["Jigyasa Grover", "https://github.com/jig08"]
+---
+
+- Smalltalk is an object-oriented, dynamically typed, reflective programming language.
+- 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`.
+
+
+##Allowable characters:
+- a-z
+- A-Z
+- 0-9
+- .+/\*~<>@%|&?
+- blank, tab, cr, ff, lf
+
+##Variables:
+- variables must be declared before use
+- shared vars must begin with uppercase
+- local vars must begin with lowercase
+- reserved names: `nil`, `true`, `false`, `self`, `super`, and `Smalltalk`
+
+##Variable scope:
+- Global: defined in Dictionary Smalltalk and accessible by all objects in system                                 - Special: (reserved) `Smalltalk`, `super`, `self`, `true`, `false`, & `nil`
+- Method Temporary: local to a method
+- Block Temporary: local to a block
+- Pool: variables in a Dictionary object
+- Method Parameters: automatic local vars created as a result of message call with params
+- Block Parameters: automatic local vars created as a result of value: message call
+- Class: shared with all instances of one class & its subclasses
+- Class Instance: unique to each instance of a class
+- Instance Variables: unique to each instance
+
+`"Comments are enclosed in quotes"`
+
+`"Period (.) is the statement seperator"`
+
+## Transcript:
+```
+Transcript clear.                                           "clear to transcript window"
+Transcript show: 'Hello World'.                             "output string in transcript window"
+Transcript nextPutAll: 'Hello World'.                       "output string in transcript window"
+Transcript nextPut: $A.                                     "output character in transcript window"
+Transcript space.                                           "output space character in transcript window"
+Transcript tab.                                             "output tab character in transcript window"
+Transcript cr.                                              "carriage return / linefeed"
+'Hello' printOn: Transcript.                                "append print string into the window"
+'Hello' storeOn: Transcript.                                "append store string into the window"
+Transcript endEntry.                                        "flush the output buffer"
+```
+
+##Assignment:
+```
+| x y |
+x _ 4.                                                      "assignment (Squeak) <-"
+x := 5.                                                     "assignment"
+x := y := z := 6.                                           "compound assignment"
+x := (y := 6) + 1.
+x := Object new.                                            "bind to allocated instance of a class"
+x := 123 class.                                             "discover the object class"
+x := Integer superclass.                                    "discover the superclass of a class"
+x := Object allInstances.                                   "get an array of all instances of a class"
+x := Integer allSuperclasses.                               "get all superclasses of a class"
+x := 1.2 hash.                                              "hash value for object"
+y := x copy.                                                "copy object"
+y := x shallowCopy.                                         "copy object (not overridden)"
+y := x deepCopy.                                            "copy object and instance vars"
+y := x veryDeepCopy.                                        "complete tree copy using a dictionary"
+```
+
+##Constants:
+```
+| b |
+b := true.                                                  "true constant"
+b := false.                                                 "false constant"
+x := nil.                                                   "nil object constant"
+x := 1.                                                     "integer constants"
+x := 3.14.                                                  "float constants"
+x := 2e-2.                                                  "fractional constants"
+x := 16r0F.                                                 "hex constant".
+x := -1.                                                    "negative constants"
+x := 'Hello'.                                               "string constant"
+x := 'I''m here'.                                           "single quote escape"
+x := $A.                                                    "character constant"
+x := $ .                                                    "character constant (space)"
+x := #aSymbol.                                              "symbol constants"
+x := #(3 2 1).                                              "array constants"
+x := #('abc' 2 $a).                                         "mixing of types allowed"
+
+```
+
+## Booleans:
+```
+| b x y |
+x := 1. y := 2.
+b := (x = y).                                               "equals"
+b := (x ~= y).                                              "not equals"
+b := (x == y).                                              "identical"
+b := (x ~~ y).                                              "not identical"
+b := (x > y).                                               "greater than"
+b := (x < y).                                               "less than"
+b := (x >= y).                                              "greater than or equal"
+b := (x <= y).                                              "less than or equal"
+b := b not.                                                 "boolean not"
+b := (x < 5) & (y > 1).                                     "boolean and"
+b := (x < 5) | (y > 1).                                     "boolean or"
+b := (x < 5) and: [y > 1].                                  "boolean and (short-circuit)"
+b := (x < 5) or: [y > 1].                                   "boolean or (short-circuit)"
+b := (x < 5) eqv: (y > 1).                                  "test if both true or both false"
+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 := x isNil.                                               "test if object is nil"
+b := x isZero.                                              "test if number is zero"
+b := x positive.                                            "test if number is positive"
+b := x strictlyPositive.                                    "test if number is greater than zero"
+b := x negative.                                            "test if number is negative"
+b := x even.                                                "test if number is even"
+b := x odd.                                                 "test if number is odd"
+b := x isLiteral.                                           "test if literal constant"
+b := x isInteger.                                           "test if object is integer"
+b := x isFloat.                                             "test if object is float"
+b := x isNumber.                                            "test if object is number"
+b := $A isUppercase.                                        "test if upper case character"
+b := $A isLowercase.                                        "test if lower case character"
+
+```
+
+## Arithmetic expressions:
+```
+| x |
+x := 6 + 3.                                                 "addition"
+x := 6 - 3.                                                 "subtraction"
+x := 6 * 3.                                                 "multiplication"
+x := 1 + 2 * 3.                                             "evaluation always left to right (1 + 2) * 3"
+x := 5 / 3.                                                 "division with fractional result"
+x := 5.0 / 3.0.                                             "division with float result"
+x := 5.0 // 3.0.                                            "integer divide"
+x := 5.0 \\ 3.0.                                            "integer remainder"
+x := -5.                                                    "unary minus"
+x := 5 sign.                                                "numeric sign (1, -1 or 0)"
+x := 5 negated.                                             "negate receiver"
+x := 1.2 integerPart.                                       "integer part of number (1.0)"
+x := 1.2 fractionPart.                                      "fractional part of number (0.2)"
+x := 5 reciprocal.                                          "reciprocal function"
+x := 6 * 3.1.                                               "auto convert to float"
+x := 5 squared.                                             "square function"
+x := 25 sqrt.                                               "square root"
+x := 5 raisedTo: 2.                                         "power function"
+x := 5 raisedToInteger: 2.                                  "power function with integer"
+x := 5 exp.                                                 "exponential"
+x := -5 abs.                                                "absolute value"
+x := 3.99 rounded.                                          "round"
+x := 3.99 truncated.                                        "truncate"
+x := 3.99 roundTo: 1.                                       "round to specified decimal places"
+x := 3.99 truncateTo: 1.                                    "truncate to specified decimal places"
+x := 3.99 floor.                                            "truncate"
+x := 3.99 ceiling.                                          "round up"
+x := 5 factorial.                                           "factorial"
+x := -5 quo: 3.                                             "integer divide rounded toward zero"
+x := -5 rem: 3.                                             "integer remainder rounded toward zero"
+x := 28 gcd: 12.                                            "greatest common denominator"
+x := 28 lcm: 12.                                            "least common multiple"
+x := 100 ln.                                                "natural logarithm"
+x := 100 log.                                               "base 10 logarithm"
+x := 100 log: 10.                                           "logarithm with specified base"
+x := 100 floorLog: 10.                                      "floor of the log"
+x := 180 degreesToRadians.                                  "convert degrees to radians"
+x := 3.14 radiansToDegrees.                                 "convert radians to degrees"
+x := 0.7 sin.                                               "sine"
+x := 0.7 cos.                                               "cosine"
+x := 0.7 tan.                                               "tangent"
+x := 0.7 arcSin.                                            "arcsine"
+x := 0.7 arcCos.                                            "arccosine"
+x := 0.7 arcTan.                                            "arctangent"
+x := 10 max: 20.                                            "get maximum of two numbers"
+x := 10 min: 20.                                            "get minimum of two numbers"
+x := Float pi.                                              "pi"
+x := Float e.                                               "exp constant"
+x := Float infinity.                                        "infinity"
+x := Float nan.                                             "not-a-number"
+x := Random new next; yourself. x next.                     "random number stream (0.0 to 1.0)
+x := 100 atRandom.                                          "quick random number"
+
+```
+
+##Bitwise Manipulation:
+```
+| b x |
+x := 16rFF bitAnd: 16r0F.                                   "and bits"
+x := 16rF0 bitOr: 16r0F.                                    "or bits"
+x := 16rFF bitXor: 16r0F.                                   "xor bits"
+x := 16rFF bitInvert.                                       "invert bits"
+x := 16r0F bitShift: 4.                                     "left shift"
+x := 16rF0 bitShift: -4.                                    "right shift"
+"x := 16r80 bitAt: 7."                                      "bit at position (0|1) [!Squeak]"
+x := 16r80 highbit.                                         "position of highest bit set"
+b := 16rFF allMask: 16r0F.                                  "test if all bits set in mask set in receiver"
+b := 16rFF anyMask: 16r0F.                                  "test if any bits set in mask set in receiver"
+b := 16rFF noMask: 16r0F.                                   "test if all bits set in mask clear in receiver"
+
+```
+
+## Conversion:
+```
+| x |
+x := 3.99 asInteger.                                        "convert number to integer (truncates in Squeak)"
+x := 3.99 asFraction.                                       "convert number to fraction"
+x := 3 asFloat.                                             "convert number to float"
+x := 65 asCharacter.                                        "convert integer to character"
+x := $A asciiValue.                                         "convert character to integer"
+x := 3.99 printString.                                      "convert object to string via printOn:"
+x := 3.99 storeString.                                      "convert object to string via storeOn:"
+x := 15 radix: 16.                                          "convert to string in given base"
+x := 15 printStringBase: 16.
+x := 15 storeStringBase: 16.
+
+```
+
+## Blocks:
+- blocks are objects and may be assigned to a variable
+- value is last expression evaluated unless explicit return
+- blocks may be nested
+- specification [ arguments | | localvars | expressions ]
+- Squeak does not currently support localvars in blocks
+- max of three arguments allowed
+- `^`expression terminates block & method (exits all nested blocks)
+- blocks intended for long term storage should not contain `^`
+
+```
+| x y z |
+x := [ y := 1. z := 2. ]. x value.                          "simple block usage"
+x := [ :argOne :argTwo |   argOne, ' and ' , argTwo.].      "set up block with argument passing"
+Transcript show: (x value: 'First' value: 'Second'); cr.    "use block with argument passing"
+"x := [ | z | z := 1.]. *** localvars not available in squeak blocks"
+```
+
+## Method calls:
+- unary methods are messages with no arguments
+- binary methods
+- keyword methods are messages with selectors including colons standard categories/protocols:                     - initialize-release    (methods called for new instance)
+- accessing             (get/set methods)
+- testing               (boolean tests - is)
+- comparing             (boolean tests with parameter
+- displaying            (gui related methods)
+- printing              (methods for printing)
+- updating              (receive notification of changes)
+- private               (methods private to class)
+- instance-creation     (class methods for creating instance)
+```
+| x |
+x := 2 sqrt.                                                "unary message"
+x := 2 raisedTo: 10.                                        "keyword message"
+x := 194 * 9.                                               "binary message"
+Transcript show: (194 * 9) printString; cr.                 "combination (chaining)"
+x := 2 perform: #sqrt.                                      "indirect method invocation"
+Transcript                                                  "Cascading - send multiple messages to receiver"
+   show: 'hello ';
+   show: 'world';
+   cr.
+x := 3 + 2; * 100.                                          "result=300. Sends message to same receiver (3)"
+```
+
+##Conditional Statements:
+```
+| x |
+x > 10 ifTrue: [Transcript show: 'ifTrue'; cr].             "if then"
+x > 10 ifFalse: [Transcript show: 'ifFalse'; cr].           "if else"
+x > 10                                                      "if then else"
+   ifTrue: [Transcript show: 'ifTrue'; cr]
+   ifFalse: [Transcript show: 'ifFalse'; cr].
+x > 10                                                      "if else then"
+   ifFalse: [Transcript show: 'ifFalse'; cr]
+   ifTrue: [Transcript show: 'ifTrue'; cr].
+Transcript
+   show:
+      (x > 10
+         ifTrue: ['ifTrue']
+         ifFalse: ['ifFalse']);
+   cr.
+Transcript                                                  "nested if then else"
+   show:
+      (x > 10
+         ifTrue: [x > 5
+            ifTrue: ['A']
+            ifFalse: ['B']]
+         ifFalse: ['C']);
+   cr.
+switch := Dictionary new.                                   "switch functionality"
+switch at: $A put: [Transcript show: 'Case A'; cr].
+switch at: $B put: [Transcript show: 'Case B'; cr].
+switch at: $C put: [Transcript show: 'Case C'; cr].
+result := (switch at: $B) value.
+```
+
+## Iteration statements:
+```
+| x y |
+x := 4. y := 1.
+[x > 0] whileTrue: [x := x - 1. y := y * 2].                "while true loop"
+[x >= 4] whileFalse: [x := x + 1. y := y * 2].              "while false loop"
+x timesRepeat: [y := y * 2].                                "times repear loop (i := 1 to x)"
+1 to: x do: [:a | y := y * 2].                              "for loop"
+1 to: x by: 2 do: [:a | y := y / 2].                        "for loop with specified increment"
+#(5 4 3) do: [:a | x := x + a].                             "iterate over array elements"
+```
+
+## Character:
+```
+| x y |
+x := $A.                                                    "character assignment"
+y := x isLowercase.                                         "test if lower case"
+y := x isUppercase.                                         "test if upper case"
+y := x isLetter.                                            "test if letter"
+y := x isDigit.                                             "test if digit"
+y := x isAlphaNumeric.                                      "test if alphanumeric"
+y := x isSeparator.                                         "test if seperator char"
+y := x isVowel.                                             "test if vowel"
+y := x digitValue.                                          "convert to numeric digit value"
+y := x asLowercase.                                         "convert to lower case"
+y := x asUppercase.                                         "convert to upper case"
+y := x asciiValue.                                          "convert to numeric ascii value"
+y := x asString.                                            "convert to string"
+b := $A <= $B.                                              "comparison"
+y := $A max: $B.
+
+```
+
+## Symbol:
+```
+| b x y |
+x := #Hello.                                                "symbol assignment"
+y := 'String', 'Concatenation'.                             "symbol concatenation (result is string)"
+b := x isEmpty.                                             "test if symbol is empty"
+y := x size.                                                "string size"
+y := x at: 2.                                               "char at location"
+y := x copyFrom: 2 to: 4.                                   "substring"
+y := x indexOf: $e ifAbsent: [0].                           "first position of character within string"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the string"
+b := x conform: [:a | (a >= $a) & (a <= $z)].               "test if all elements meet condition"
+y := x select: [:a | a > $a].                               "return all elements that meet condition"
+y := x asString.                                            "convert symbol to string"
+y := x asText.                                              "convert symbol to text"
+y := x asArray.                                             "convert symbol to array"
+y := x asOrderedCollection.                                 "convert symbol to ordered collection"
+y := x asSortedCollection.                                  "convert symbol to sorted collection"
+y := x asBag.                                               "convert symbol to bag collection"
+y := x asSet.                                               "convert symbol to set collection"
+```
+
+## String:
+```
+| b x y |
+x := 'This is a string'.                                    "string assignment"
+x := 'String', 'Concatenation'.                             "string concatenation"
+b := x isEmpty.                                             "test if string is empty"
+y := x size.                                                "string size"
+y := x at: 2.                                               "char at location"
+y := x copyFrom: 2 to: 4.                                   "substring"
+y := x indexOf: $a ifAbsent: [0].                           "first position of character within string"
+x := String new: 4.                                         "allocate string object"
+x                                                           "set string elements"
+   at: 1 put: $a;
+   at: 2 put: $b;
+   at: 3 put: $c;
+   at: 4 put: $e.
+x := String with: $a with: $b with: $c with: $d.            "set up to 4 elements at a time"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the string"
+b := x conform: [:a | (a >= $a) & (a <= $z)].               "test if all elements meet condition"
+y := x select: [:a | a > $a].                               "return all elements that meet condition"
+y := x asSymbol.                                            "convert string to symbol"
+y := x asArray.                                             "convert string to array"
+x := 'ABCD' asByteArray.                                    "convert string to byte array"
+y := x asOrderedCollection.                                 "convert string to ordered collection"
+y := x asSortedCollection.                                  "convert string to sorted collection"
+y := x asBag.                                               "convert string to bag collection"
+y := x asSet.                                               "convert string to set collection"
+y := x shuffled.                                            "randomly shuffle string"
+```
+
+## Array:         Fixed length collection
+- ByteArray:     Array limited to byte elements (0-255)
+- WordArray:     Array limited to word elements (0-2^32)
+
+```
+| b x y sum max |
+x := #(4 3 2 1).                                            "constant array"
+x := Array with: 5 with: 4 with: 3 with: 2.                 "create array with up to 4 elements"
+x := Array new: 4.                                          "allocate an array with specified size"
+x                                                           "set array elements"
+   at: 1 put: 5;
+   at: 2 put: 4;
+   at: 3 put: 3;
+   at: 4 put: 2.
+b := x isEmpty.                                             "test if array is empty"
+y := x size.                                                "array size"
+y := x at: 4.                                               "get array element at index"
+b := x includes: 3.                                         "test if element is in array"
+y := x copyFrom: 2 to: 4.                                   "subarray"
+y := x indexOf: 3 ifAbsent: [0].                            "first position of element within array"
+y := x occurrencesOf: 3.                                    "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the array"
+b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
+y := x select: [:a | a > 2].                                "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
+y := x collect: [:a | a + a].                               "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum array elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum array elements"
+sum := x inject: 0 into: [:a :c | a + c].                   "sum array elements"
+max := x inject: 0 into: [:a :c | (a > c)                   "find max element in array"
+   ifTrue: [a]
+   ifFalse: [c]].
+y := x shuffled.                                            "randomly shuffle collection"
+y := x asArray.                                             "convert to array"
+"y := x asByteArray."                                       "note: this instruction not available on Squeak"
+y := x asWordArray.                                         "convert to word array"
+y := x asOrderedCollection.                                 "convert to ordered collection"
+y := x asSortedCollection.                                  "convert to sorted collection"
+y := x asBag.                                               "convert to bag collection"
+y := x asSet.                                               "convert to set collection"
+```
+
+##OrderedCollection: acts like an expandable array
+```
+| b x y sum max |
+x := OrderedCollection with: 4 with: 3 with: 2 with: 1.     "create collection with up to 4 elements"
+x := OrderedCollection new.                                 "allocate collection"
+x add: 3; add: 2; add: 1; add: 4; yourself.                 "add element to collection"
+y := x addFirst: 5.                                         "add element at beginning of collection"
+y := x removeFirst.                                         "remove first element in collection"
+y := x addLast: 6.                                          "add element at end of collection"
+y := x removeLast.                                          "remove last element in collection"
+y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
+x at: 2 put: 3.                                             "set element at index"
+y := x remove: 5 ifAbsent: [].                              "remove element from collection"
+b := x isEmpty.                                             "test if empty"
+y := x size.                                                "number of elements"
+y := x at: 2.                                               "retrieve element at index"
+y := x first.                                               "retrieve first element in collection"
+y := x last.                                                "retrieve last element in collection"
+b := x includes: 5.                                         "test if element is in collection"
+y := x copyFrom: 2 to: 3.                                   "subcollection"
+y := x indexOf: 3 ifAbsent: [0].                            "first position of element within collection"
+y := x occurrencesOf: 3.                                    "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
+y := x select: [:a | a > 2].                                "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
+y := x collect: [:a | a + a].                               "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+   ifTrue: [a]
+   ifFalse: [c]].
+y := x shuffled.                                            "randomly shuffle collection"
+y := x asArray.                                             "convert to array"
+y := x asOrderedCollection.                                 "convert to ordered collection"
+y := x asSortedCollection.                                  "convert to sorted collection"
+y := x asBag.                                               "convert to bag collection"
+y := x asSet.                                               "convert to set collection"
+```
+
+## SortedCollection:    like OrderedCollection except order of elements determined by sorting criteria
+```
+| b x y sum max |
+x := SortedCollection with: 4 with: 3 with: 2 with: 1.      "create collection with up to 4 elements"
+x := SortedCollection new.                                  "allocate collection"
+x := SortedCollection sortBlock: [:a :c | a > c].           "set sort criteria"
+x add: 3; add: 2; add: 1; add: 4; yourself.                 "add element to collection"
+y := x addFirst: 5.                                         "add element at beginning of collection"
+y := x removeFirst.                                         "remove first element in collection"
+y := x addLast: 6.                                          "add element at end of collection"
+y := x removeLast.                                          "remove last element in collection"
+y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
+y := x remove: 5 ifAbsent: [].                              "remove element from collection"
+b := x isEmpty.                                             "test if empty"
+y := x size.                                                "number of elements"
+y := x at: 2.                                               "retrieve element at index"
+y := x first.                                               "retrieve first element in collection"
+y := x last.                                                "retrieve last element in collection"
+b := x includes: 4.                                         "test if element is in collection"
+y := x copyFrom: 2 to: 3.                                   "subcollection"
+y := x indexOf: 3 ifAbsent: [0].                            "first position of element within collection"
+y := x occurrencesOf: 3.                                    "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
+y := x select: [:a | a > 2].                                "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
+y := x collect: [:a | a + a].                               "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+   ifTrue: [a]
+   ifFalse: [c]].
+y := x asArray.                                             "convert to array"
+y := x asOrderedCollection.                                 "convert to ordered collection"
+y := x asSortedCollection.                                  "convert to sorted collection"
+y := x asBag.                                               "convert to bag collection"
+y := x asSet.                                               "convert to set collection"
+```
+
+## Bag:        like OrderedCollection except elements are in no particular order
+```
+| b x y sum max |
+x := Bag with: 4 with: 3 with: 2 with: 1.                   "create collection with up to 4 elements"
+x := Bag new.                                               "allocate collection"
+x add: 4; add: 3; add: 1; add: 2; yourself.                 "add element to collection"
+x add: 3 withOccurrences: 2.                                "add multiple copies to collection"
+y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
+y := x remove: 4 ifAbsent: [].                              "remove element from collection"
+b := x isEmpty.                                             "test if empty"
+y := x size.                                                "number of elements"
+b := x includes: 3.                                         "test if element is in collection"
+y := x occurrencesOf: 3.                                    "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
+y := x select: [:a | a > 2].                                "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
+y := x collect: [:a | a + a].                               "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+   ifTrue: [a]
+   ifFalse: [c]].
+y := x asOrderedCollection.                                 "convert to ordered collection"
+y := x asSortedCollection.                                  "convert to sorted collection"
+y := x asBag.                                               "convert to bag collection"
+y := x asSet.                                               "convert to set collection"
+```
+
+## Set:           like Bag except duplicates not allowed
+## IdentitySet:   uses identity test (== rather than =)
+```
+| b x y sum max |
+x := Set with: 4 with: 3 with: 2 with: 1.                   "create collection with up to 4 elements"
+x := Set new.                                               "allocate collection"
+x add: 4; add: 3; add: 1; add: 2; yourself.                 "add element to collection"
+y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
+y := x remove: 4 ifAbsent: [].                              "remove element from collection"
+b := x isEmpty.                                             "test if empty"
+y := x size.                                                "number of elements"
+x includes: 4.                                              "test if element is in collection"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
+y := x select: [:a | a > 2].                                "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
+y := x collect: [:a | a + a].                               "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+   ifTrue: [a]
+   ifFalse: [c]].
+y := x asArray.                                             "convert to array"
+y := x asOrderedCollection.                                 "convert to ordered collection"
+y := x asSortedCollection.                                  "convert to sorted collection"
+y := x asBag.                                               "convert to bag collection"
+y := x asSet.                                               "convert to set collection"
+```
+
+## Interval:
+```
+| b x y sum max |
+x := Interval from: 5 to: 10.                               "create interval object"
+x := 5 to: 10.
+x := Interval from: 5 to: 10 by: 2.                         "create interval object with specified increment"
+x := 5 to: 10 by: 2.
+b := x isEmpty.                                             "test if empty"
+y := x size.                                                "number of elements"
+x includes: 9.                                              "test if element is in collection"
+x do: [:k | Transcript show: k printString; cr].            "iterate over interval"
+b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
+y := x select: [:a | a > 7].                                "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
+y := x collect: [:a | a + a].                               "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
+sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+   ifTrue: [a]
+   ifFalse: [c]].
+y := x asArray.                                             "convert to array"
+y := x asOrderedCollection.                                 "convert to ordered collection"
+y := x asSortedCollection.                                  "convert to sorted collection"
+y := x asBag.                                               "convert to bag collection"
+y := x asSet.                                               "convert to set collection"
+```
+
+##Associations:
+```
+| x y |
+x := #myVar->'hello'.
+y := x key.
+y := x value.
+```
+
+## Dictionary:
+## IdentityDictionary:   uses identity test (== rather than =)
+```
+| b x y |
+x := Dictionary new.                                        "allocate collection"
+x add: #a->4; add: #b->3; add: #c->1; add: #d->2; yourself. "add element to collection"
+x at: #e put: 3.                                            "set element at index"
+b := x isEmpty.                                             "test if empty"
+y := x size.                                                "number of elements"
+y := x at: #a ifAbsent: [].                                 "retrieve element at index"
+y := x keyAtValue: 3 ifAbsent: [].                          "retrieve key for given value with error block"
+y := x removeKey: #e ifAbsent: [].                          "remove element from collection"
+b := x includes: 3.                                         "test if element is in values collection"
+b := x includesKey: #a.                                     "test if element is in keys collection"
+y := x occurrencesOf: 3.                                    "number of times object in collection"
+y := x keys.                                                "set of keys"
+y := x values.                                              "bag of values"
+x do: [:a | Transcript show: a printString; cr].            "iterate over the values collection"
+x keysDo: [:a | Transcript show: a printString; cr].        "iterate over the keys collection"
+x associationsDo: [:a | Transcript show: a printString; cr]."iterate over the associations"
+x keysAndValuesDo: [:aKey :aValue | Transcript              "iterate over keys and values"
+   show: aKey printString; space;
+   show: aValue printString; cr].
+b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
+y := x select: [:a | a > 2].                                "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
+y := x collect: [:a | a + a].                               "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+   ifTrue: [a]
+   ifFalse: [c]].
+y := x asArray.                                             "convert to array"
+y := x asOrderedCollection.                                 "convert to ordered collection"
+y := x asSortedCollection.                                  "convert to sorted collection"
+y := x asBag.                                               "convert to bag collection"
+y := x asSet.                                               "convert to set collection"
+
+Smalltalk at: #CMRGlobal put: 'CMR entry'.                  "put global in Smalltalk Dictionary"
+x := Smalltalk at: #CMRGlobal.                              "read global from Smalltalk Dictionary"
+Transcript show: (CMRGlobal printString).                   "entries are directly accessible by name"
+Smalltalk keys do: [ :k |                                   "print out all classes"
+   ((Smalltalk at: k) isKindOf: Class)
+      ifFalse: [Transcript show: k printString; cr]].
+Smalltalk at: #CMRDictionary put: (Dictionary new).         "set up user defined dictionary"
+CMRDictionary at: #MyVar1 put: 'hello1'.                    "put entry in dictionary"
+CMRDictionary add: #MyVar2->'hello2'.                       "add entry to dictionary use key->value combo"
+CMRDictionary size.                                         "dictionary size"
+CMRDictionary keys do: [ :k |                               "print out keys in dictionary"
+   Transcript show: k printString; cr].
+CMRDictionary values do: [ :k |                             "print out values in dictionary"
+   Transcript show: k printString; cr].
+CMRDictionary keysAndValuesDo: [:aKey :aValue |             "print out keys and values"
+   Transcript
+      show: aKey printString;
+      space;
+      show: aValue printString;
+      cr].
+CMRDictionary associationsDo: [:aKeyValue |                 "another iterator for printing key values"
+   Transcript show: aKeyValue printString; cr].
+Smalltalk removeKey: #CMRGlobal ifAbsent: [].               "remove entry from Smalltalk dictionary"
+Smalltalk removeKey: #CMRDictionary ifAbsent: [].           "remove user dictionary from Smalltalk dictionary"
+```
+
+## Internal Stream:
+```
+| b x ios |
+ios := ReadStream on: 'Hello read stream'.
+ios := ReadStream on: 'Hello read stream' from: 1 to: 5.
+[(x := ios nextLine) notNil]
+   whileTrue: [Transcript show: x; cr].
+ios position: 3.
+ios position.
+x := ios next.
+x := ios peek.
+x := ios contents.
+b := ios atEnd.
+
+ios := ReadWriteStream on: 'Hello read stream'.
+ios := ReadWriteStream on: 'Hello read stream' from: 1 to: 5.
+ios := ReadWriteStream with: 'Hello read stream'.
+ios := ReadWriteStream with: 'Hello read stream' from: 1 to: 10.
+ios position: 0.
+[(x := ios nextLine) notNil]
+   whileTrue: [Transcript show: x; cr].
+ios position: 6.
+ios position.
+ios nextPutAll: 'Chris'.
+x := ios next.
+x := ios peek.
+x := ios contents.
+b := ios atEnd.
+```
+
+## FileStream:
+```
+| b x ios |
+ios := FileStream newFileNamed: 'ios.txt'.
+ios nextPut: $H; cr.
+ios nextPutAll: 'Hello File'; cr.
+'Hello File' printOn: ios.
+'Hello File' storeOn: ios.
+ios close.
+
+ios := FileStream oldFileNamed: 'ios.txt'.
+[(x := ios nextLine) notNil]
+   whileTrue: [Transcript show: x; cr].
+ios position: 3.
+x := ios position.
+x := ios next.
+x := ios peek.
+b := ios atEnd.
+ios close.
+```
+
+## Date:
+```
+| x y |
+x := Date today.                                            "create date for today"
+x := Date dateAndTimeNow.                                   "create date from current time/date"
+x := Date readFromString: '01/02/1999'.                     "create date from formatted string"
+x := Date newDay: 12 month: #July year: 1999                "create date from parts"
+x := Date fromDays: 36000.                                  "create date from elapsed days since 1/1/1901"
+y := Date dayOfWeek: #Monday.                               "day of week as int (1-7)"
+y := Date indexOfMonth: #January.                           "month of year as int (1-12)"
+y := Date daysInMonth: 2 forYear: 1996.                     "day of month as int (1-31)"
+y := Date daysInYear: 1996.                                 "days in year (365|366)"
+y := Date nameOfDay: 1                                      "weekday name (#Monday,...)"
+y := Date nameOfMonth: 1.                                   "month name (#January,...)"
+y := Date leapYear: 1996.                                   "1 if leap year; 0 if not leap year"
+y := x weekday.                                             "day of week (#Monday,...)"
+y := x previous: #Monday.                                   "date for previous day of week"
+y := x dayOfMonth.                                          "day of month (1-31)"
+y := x day.                                                 "day of year (1-366)"
+y := x firstDayOfMonth.                                     "day of year for first day of month"
+y := x monthName.                                           "month of year (#January,...)"
+y := x monthIndex.                                          "month of year (1-12)"
+y := x daysInMonth.                                         "days in month (1-31)"
+y := x year.                                                "year (19xx)"
+y := x daysInYear.                                          "days in year (365|366)"
+y := x daysLeftInYear.                                      "days left in year (364|365)"
+y := x asSeconds.                                           "seconds elapsed since 1/1/1901"
+y := x addDays: 10.                                         "add days to date object"
+y := x subtractDays: 10.                                    "subtract days to date object"
+y := x subtractDate: (Date today).                          "subtract date (result in days)"
+y := x printFormat: #(2 1 3 $/ 1 1).                        "print formatted date"
+b := (x <= Date today).                                     "comparison"
+```
+
+## Time:
+```
+| x y |
+x := Time now.                                              "create time from current time"
+x := Time dateAndTimeNow.                                   "create time from current time/date"
+x := Time readFromString: '3:47:26 pm'.                     "create time from formatted string"
+x := Time fromSeconds: (60 * 60 * 4).                       "create time from elapsed time from midnight"
+y := Time millisecondClockValue.                            "milliseconds since midnight"
+y := Time totalSeconds.                                     "total seconds since 1/1/1901"
+y := x seconds.                                             "seconds past minute (0-59)"
+y := x minutes.                                             "minutes past hour (0-59)"
+y := x hours.                                               "hours past midnight (0-23)"
+y := x addTime: (Time now).                                 "add time to time object"
+y := x subtractTime: (Time now).                            "subtract time to time object"
+y := x asSeconds.                                           "convert time to seconds"
+x := Time millisecondsToRun: [                              "timing facility"
+   1 to: 1000 do: [:index | y := 3.14 * index]].
+b := (x <= Time now).                                       "comparison"
+```
+
+## Point:
+```
+| x y |
+x := 200@100.                                               "obtain a new point"
+y := x x.                                                   "x coordinate"
+y := x y.                                                   "y coordinate"
+x := 200@100 negated.                                       "negates x and y"
+x := (-200@-100) abs.                                       "absolute value of x and y"
+x := (200.5@100.5) rounded.                                 "round x and y"
+x := (200.5@100.5) truncated.                               "truncate x and y"
+x := 200@100 + 100.                                         "add scale to both x and y"
+x := 200@100 - 100.                                         "subtract scale from both x and y"
+x := 200@100 * 2.                                           "multiply x and y by scale"
+x := 200@100 / 2.                                           "divide x and y by scale"
+x := 200@100 // 2.                                          "divide x and y by scale"
+x := 200@100 \\ 3.                                          "remainder of x and y by scale"
+x := 200@100 + 50@25.                                       "add points"
+x := 200@100 - 50@25.                                       "subtract points"
+x := 200@100 * 3@4.                                         "multiply points"
+x := 200@100 // 3@4.                                        "divide points"
+x := 200@100 max: 50@200.                                   "max x and y"
+x := 200@100 min: 50@200.                                   "min x and y"
+x := 20@5 dotProduct: 10@2.                                 "sum of product (x1*x2 + y1*y2)"
+```
+
+## Rectangle:
+```
+Rectangle fromUser.
+```
+
+## Pen:
+```
+| myPen |
+Display restoreAfter: [
+   Display fillWhite.
+
+myPen := Pen new.                                           "get graphic pen"
+myPen squareNib: 1.
+myPen color: (Color blue).                                  "set pen color"
+myPen home.                                                 "position pen at center of display"
+myPen up.                                                   "makes nib unable to draw"
+myPen down.                                                 "enable the nib to draw"
+myPen north.                                                "points direction towards top"
+myPen turn: -180.                                           "add specified degrees to direction"
+myPen direction.                                            "get current angle of pen"
+myPen go: 50.                                               "move pen specified number of pixels"
+myPen location.                                             "get the pen position"
+myPen goto: 200@200.                                        "move to specified point"
+myPen place: 250@250.                                       "move to specified point without drawing"
+myPen print: 'Hello World' withFont: (TextStyle default fontAt: 1).
+Display extent.                                             "get display width@height"
+Display width.                                              "get display width"
+Display height.                                             "get display height"
+
+].
+```
+
+## Dynamic Message Calling/Compiling:
+```
+| receiver message result argument keyword1 keyword2 argument1 argument2 |
+"unary message"
+receiver := 5.
+message := 'factorial' asSymbol.
+result := receiver perform: message.
+result := Compiler evaluate: ((receiver storeString), ' ', message).
+result := (Message new setSelector: message arguments: #()) sentTo: receiver.
+
+"binary message"
+receiver := 1.
+message := '+' asSymbol.
+argument := 2.
+result := receiver perform: message withArguments: (Array with: argument).
+result := Compiler evaluate: ((receiver storeString), ' ', message, ' ', (argument storeString)).
+result := (Message new setSelector: message arguments: (Array with: argument)) sentTo: receiver.
+
+"keyword messages"
+receiver := 12.
+keyword1 := 'between:' asSymbol.
+keyword2 := 'and:' asSymbol.
+argument1 := 10.
+argument2 := 20.
+result := receiver
+   perform: (keyword1, keyword2) asSymbol
+   withArguments: (Array with: argument1 with: argument2).
+result := Compiler evaluate:
+   ((receiver storeString), ' ', keyword1, (argument1 storeString) , ' ', keyword2, (argument2 storeString)).
+result := (Message
+   new
+      setSelector: (keyword1, keyword2) asSymbol
+      arguments: (Array with: argument1 with: argument2))
+   sentTo: receiver.
+```
+
+## Class/Meta-class:
+```
+| b x |
+x := String name.                                           "class name"
+x := String category.                                       "organization category"
+x := String comment.                                        "class comment"
+x := String kindOfSubclass.                                 "subclass type - subclass: variableSubclass, etc"
+x := String definition.                                     "class definition"
+x := String instVarNames.                                   "immediate instance variable names"
+x := String allInstVarNames.                                "accumulated instance variable names"
+x := String classVarNames.                                  "immediate class variable names"
+x := String allClassVarNames.                               "accumulated class variable names"
+x := String sharedPools.                                    "immediate dictionaries used as shared pools"
+x := String allSharedPools.                                 "accumulated dictionaries used as shared pools"
+x := String selectors.                                      "message selectors for class"
+x := String sourceCodeAt: #size.                            "source code for specified method"
+x := String allInstances.                                   "collection of all instances of class"
+x := String superclass.                                     "immediate superclass"
+x := String allSuperclasses.                                "accumulated superclasses"
+x := String withAllSuperclasses.                            "receiver class and accumulated superclasses"
+x := String subclasses.                                     "immediate subclasses"
+x := String allSubclasses.                                  "accumulated subclasses"
+x := String withAllSubclasses.                              "receiver class and accumulated subclasses"
+b := String instSize.                                       "number of named instance variables"
+b := String isFixed.                                        "true if no indexed instance variables"
+b := String isVariable.                                     "true if has indexed instance variables"
+b := String isPointers.                                     "true if index instance vars contain objects"
+b := String isBits.                                         "true if index instance vars contain bytes/words"
+b := String isBytes.                                        "true if index instance vars contain bytes"
+b := String isWords.                                        true if index instance vars contain words"
+Object withAllSubclasses size.                              "get total number of class entries"
+```
+
+## Debuging:
+```
+| a b x |
+x yourself.                                                 "returns receiver"
+String browse.                                              "browse specified class"
+x inspect.                                                  "open object inspector window"
+x confirm: 'Is this correct?'.
+x halt.                                                     "breakpoint to open debugger window"
+x halt: 'Halt message'.
+x notify: 'Notify text'.
+x error: 'Error string'.                                    "open up error window with title"
+x doesNotUnderstand: #cmrMessage.                           "flag message is not handled"
+x shouldNotImplement.                                       "flag message should not be implemented"
+x subclassResponsibility.                                   "flag message as abstract"
+x errorImproperStore.                                       "flag an improper store into indexable object"
+x errorNonIntegerIndex.                                     "flag only integers should be used as index"
+x errorSubscriptBounds.                                     "flag subscript out of bounds"
+x primitiveFailed.                                          "system primitive failed"
+
+a := 'A1'. b := 'B2'. a become: b.                          "switch two objects"
+Transcript show: a, b; cr.
+```
+
+## Misc
+```
+| x |
+"Smalltalk condenseChanges."                                "compress the change file"
+x := FillInTheBlank request: 'Prompt Me'.                   "prompt user for input"
+Utilities openCommandKeyHelp
+```
+
+
+
+
+## Ready For More?
+
+### Free Online
+
+* [GNU Smalltalk User's Guide](https://www.gnu.org/software/smalltalk/manual/html_node/Tutorial.html)
+* [smalltalk dot org](http://www.smalltalk.org/smalltalk/learning.html)
+* [Computer Programming using GNU Smalltalk](http://www.canol.info/books/computer_programming_using_gnu_smalltalk/)
+* [Smalltalk Cheatsheet](http://www.angelfire.com/tx4/cus/notes/smalltalk.html)
+* [Smalltalk-72 Manual](http://www.bitsavers.org/pdf/xerox/parc/techReports/Smalltalk-72_Instruction_Manual_Mar76.pdf)
+* [BYTE: A Special issue on Smalltalk](https://archive.org/details/byte-magazine-1981-08)
+* [Smalltalk, Objects, and Design](https://books.google.co.in/books?id=W8_Une9cbbgC&printsec=frontcover&dq=smalltalk&hl=en&sa=X&ved=0CCIQ6AEwAWoVChMIw63Vo6CpyAIV0HGOCh3S2Alf#v=onepage&q=smalltalk&f=false)
+* [Smalltalk: An Introduction to Application Development Using VisualWorks](https://books.google.co.in/books?id=zalQAAAAMAAJ&q=smalltalk&dq=smalltalk&hl=en&sa=X&ved=0CCgQ6AEwAmoVChMIw63Vo6CpyAIV0HGOCh3S2Alf/)
diff --git a/swift.html.markdown b/swift.html.markdown
index 509c9d2f..f451288d 100644
--- a/swift.html.markdown
+++ b/swift.html.markdown
@@ -3,8 +3,9 @@ language: swift
 contributors:
   - ["Grant Timmerman", "http://github.com/grant"]
   - ["Christopher Bess", "http://github.com/cbess"]
-  - ["Joey Huang", "http://github.com/kamidox"]  
+  - ["Joey Huang", "http://github.com/kamidox"]
   - ["Anthony Nguyen", "http://github.com/anthonyn60"]
+  - ["Clayton Walker", "https://github.com/cwalk"]
 filename: learnswift.swift
 ---
 
@@ -12,7 +13,7 @@ Swift is a programming language for iOS and OS X development created by Apple. D
 
 The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.
 
-See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.
+See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/DevelopiOSAppsSwift/), which has a complete tutorial on Swift.
 
 ```swift
 // import a module
@@ -57,8 +58,9 @@ let piText = "Pi = \(π), Pi 2 = \(π * 2)" // String interpolation
 print("Build value: \(buildValue)") // Build value: 7
 
 /*
-    Optionals are a Swift language feature that allows you to store a `Some` or
-    `None` value.
+    Optionals are a Swift language feature that either contains a value,
+    or contains nil (no value) to indicate that a value is missing.
+    A question mark (?) after the type marks the value as optional.
 
     Because Swift requires every property to have a value, even nil must be
     explicitly stored as an Optional value.
@@ -74,11 +76,17 @@ if someOptionalString != nil {
     if someOptionalString!.hasPrefix("opt") {
         print("has the prefix")
     }
-    
+
     let empty = someOptionalString?.isEmpty
 }
 someOptionalString = nil
 
+/*
+    Trying to use ! to access a non-existent optional value triggers a runtime 
+    error. Always make sure that an optional contains a non-nil value before
+    using ! to force-unwrap its value.
+*/
+
 // implicitly unwrapped optional
 var unwrappedString: String! = "Value is expected."
 // same as above, but ! is a postfix operator (more syntax candy)
@@ -93,13 +101,13 @@ if let someOptionalStringConstant = someOptionalString {
 
 // Swift has support for storing a value of any type.
 // AnyObject == id
-// Unlike Objective-C `id`, AnyObject works with any value (Class, Int, struct, etc)
+// Unlike Objective-C `id`, AnyObject works with any value (Class, Int, struct, etc.)
 var anyObjectVar: AnyObject = 7
 anyObjectVar = "Changed value to a string, not good practice, but possible."
 
 /*
     Comment here
-    
+
     /*
         Nested comments are also supported
     */
@@ -295,10 +303,10 @@ print(numbers) // [3, 6, 18]
 // MARK: Structures
 //
 
-// Structures and classes have very similar capabilites
+// Structures and classes have very similar capabilities
 struct NamesTable {
     let names = [String]()
-    
+
     // Custom subscript
     subscript(index: Int) -> String {
         return names[index]
@@ -329,7 +337,7 @@ public class Shape {
 
 internal class Rect: Shape {
     var sideLength: Int = 1
-    
+
     // Custom getter and setter property
     private var perimeter: Int {
         get {
@@ -340,11 +348,11 @@ internal class Rect: Shape {
             sideLength = newValue / 4
         }
     }
-    
+
     // Lazily load a property
     // subShape remains nil (uninitialized) until getter called
     lazy var subShape = Rect(sideLength: 4)
-    
+
     // If you don't need a custom getter and setter,
     // but still want to run code before and after getting or setting
     // a property, you can use `willSet` and `didSet`
@@ -354,19 +362,19 @@ internal class Rect: Shape {
             print(someIdentifier)
         }
     }
-    
+
     init(sideLength: Int) {
         self.sideLength = sideLength
         // always super.init last when init custom properties
         super.init()
     }
-    
+
     func shrink() {
         if sideLength > 0 {
             --sideLength
         }
     }
-    
+
     override func getArea() -> Int {
         return sideLength * sideLength
     }
@@ -398,13 +406,13 @@ class Circle: Shape {
     override func getArea() -> Int {
         return 3 * radius * radius
     }
-    
+
     // Place a question mark postfix after `init` is an optional init
     // which can return nil
     init?(radius: Int) {
         self.radius = radius
         super.init()
-        
+
         if radius <= 0 {
             return nil
         }
@@ -458,7 +466,7 @@ enum Furniture {
     case Desk(height: Int)
     // Associate with String and Int
     case Chair(String, Int)
-    
+
     func description() -> String {
         switch self {
         case .Desk(let height):
@@ -497,7 +505,7 @@ protocol ShapeGenerator {
 
 class MyShape: Rect {
     var delegate: TransformShape?
-    
+
     func grow() {
         sideLength += 2
 
@@ -532,7 +540,7 @@ extension Int {
     var customProperty: String {
         return "This is \(self)"
     }
-    
+
     func multiplyBy(num: Int) -> Int {
         return num * self
     }
@@ -574,4 +582,18 @@ print(mySquare.sideLength) // 4
 // change side length using custom !!! operator, increases size by 3
 !!!mySquare
 print(mySquare.sideLength) // 12
+
+// Operators can also be generics
+infix operator <-> {}
+func <-><T: Equatable> (inout a: T, inout b: T) {
+    let c = a
+    a = b
+    b = c
+}
+
+var foo: Float = 10
+var bar: Float = 20
+
+foo <-> bar
+print("foo is \(foo), bar is \(bar)") // "foo is 20.0, bar is 10.0"
 ```
diff --git a/ta_in/css.html.markdown b/ta_in/css.html.markdown
new file mode 100644
index 00000000..56f94ed0
--- /dev/null
+++ b/ta_in/css.html.markdown
@@ -0,0 +1,254 @@
+---
+language: css
+contributors:
+    - ["Mohammad Valipour", "https://github.com/mvalipour"]
+    - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+translators:
+	- ["Rasendran Kirushan", "https://github.com/kirushanr"]
+filename: learncss.css
+lang:in-ta
+---
+
+
+இணையத்தின்    ஆரம்ப காலத்தில்  முழுமையாக உரைகளை மட்டுமே கொண்டிருந்தன. 
+ஆனால் உலாவிகளில் கொண்டு வரப்பட்ட மாற்றங்களில் முழுமையான காட்சிபடுத்தல்களுடன்
+கூடிய இணையதளங்கள் உருவாகின.
+
+
+CSS ஆனது HTML மற்றும் அதன் அழகுபடுத்கூடிய காரணிகளையும் வேறுபடுத்த உதவியது.
+
+ஒரு html இல் உள்ள உறுப்புகளை(elements) வெவ்வேறு வகையான காட்சி பண்புகளை வழங்க உதவுகிறது.
+
+இந்த வழிகாட்டி CSS2 உக்கு எழுதப்பட்டுள்ளது, இருப்பினும் தற்போது CSS 3 வேகமாக பிரபல்யமாகி வருகிறது.
+
+**குறிப்பு:**
+CSS ஆனது முற்று முழுதாக visual(காட்சி)  மாற்றங்களை தருவதால் அதை நீங்கள் முயற்சிக்க
+இதை    உபயோகபடுத்தலாம்  [dabblet](http://dabblet.com/).
+இந்த வழிகாட்டியின் பிரதான நோக்கம் CSS இன்  syntax மற்றும் மேலும் சில வழிமுறைகளை
+உங்களுக்கு கற்று தருவதாகும்
+
+```css
+/* css இல் குறிப்புகளை இப்படி இடலாம் */
+
+/* ####################
+   ## SELECTORS
+   #################### */
+
+/* ஒரு HTML பக்கத்தில் இருக்கும் உறுப்பை நாம் selector மூலம் தெரிவு செய்யலாம்
+selector { property: value; /* more properties...*/ }
+
+/*
+கிழே ஒரு உதாரணம் காட்டப்பட்டுள்ளது:
+
+<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
+*/
+
+/* நீங்கள் அந்த உறுப்பை அதன் CSS class மூலம் தெரியலாம் */
+.class1 { }
+
+/* அல்லது இவ்வாறு  இரண்டு  class மூலம் தெரியலாம்! */
+.class1.class2 { }
+
+/* அல்லது  அதன்  பெயரை பாவித்து தெரியலாம் */
+div { }
+
+/* அல்லது  அதன் id ஐ  பயன்படுத்தி  தெரியலாம்*/
+#anID { }
+
+/* அல்லது ஒரு  உறுப்பின்   பண்பு ஒன்றின்  மூலம்! */
+[attr] { font-size:smaller; }
+
+/* அல்லது அந்த  பண்பு ஒரு  குறிப்பிட்ட  பெறுமானத்தை கொண்டு இருப்பின் */
+[attr='value'] { font-size:smaller; }
+
+/* ஒரு  பெறுமதியுடன் ஆரம்பமாகும் போது (CSS 3) */
+[attr^='val'] { font-size:smaller; }
+
+/* அல்லது  ஒரு பெறுமதியுடன் முடிவடையும் போது  (CSS 3) */
+[attr$='ue'] { font-size:smaller; }
+
+/*  அல்லது  காற்புள்ளியால் பிரிக்கப்பட்ட  பெறுமானங்களை கொண்டு இருப்பின் */
+[otherAttr~='foo'] { }
+[otherAttr~='bar'] { }
+
+/* அல்லது  `-` பிரிக்கப்பட்ட  பெறுமானங்களை கொண்டு இருப்பின், உ.ம்:-, "-" (U+002D) */
+[otherAttr|='en'] { font-size:smaller; }
+
+
+/* நாம் இரண்டு selectors ஐ ஒன்றாக உபயோகித்தும் ஒரு உறுப்பை அணுக முடியும்  , 
+அவற்றுக்கு இடயே இடைவெளி காணப்படகூடாது
+ */
+div.some-class[attr$='ue'] { }
+
+/*அல்லது ஒரு உறுப்பினுள் இருக்கும் இன்னொரு உறுப்பை (child element) அணுக */
+div.some-parent > .class-name { }
+
+/* ஒரு  ஒரு  பிரதான உறுப்பில் உள்ள உப உறுப்புகளை அணுக*/
+div.some-parent .class-name { }
+
+/* மேலே  குறிபிட்ட அணுகுமுறையில் இடைவெளி காணப்படாது விடின் 
+	அந்த selector வேலை செய்யாது
+ */
+div.some-parent.class-name { }
+
+/* அல்லது ஒரு உறுப்புக்கு அடுத்துள்ள  */
+.i-am-just-before + .this-element { }
+
+/* or அல்லது அதற்கு முந்தய உறுப்பின்  மூலம் */
+.i-am-any-element-before ~ .this-element { }
+
+/* 
+	சில selectors ஐ pseudo class மூலம் அணுக முடியும் , எப்போது எனில் அவை
+	குறித்த ஒரு நிலையில் இருக்கும் போது ஆகும்
+   */
+
+/* உதாரணமாக நாம் ஒரு  உறுப்பின் மீதாக cursor ஐ நகர்த்தும் போது */
+selector:hover { }
+
+/* அல்லது ஒரு
+பார்வையிட்ட இணைப்பு */
+selector:visited { }
+
+/* அல்லது ஒரு  பார்வையிடபடாத இணைப்பு */   
+selected:link { }
+
+/* அல்லது  ஒரு element ஐ  focus செய்யும் போது */
+selected:focus { }
+
+/* 
+	எல்லா elementகளையும் ஒரே நேரத்தில் அணுக `*`
+*/
+* { } /* all elements */
+.parent * { } /* all descendants */
+.parent > * { } /* all children */
+
+/* ####################
+   ## பண்புகள்
+   #################### */
+
+selector {
+    
+    /*  நீளத்தின் அலகுகள் absolute அல்லது 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 hsla percentages with alpha */
+    
+    /* 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
+
+ஒரு css file ஐ  save செய்ய `.css`.
+
+```xml
+<!-- உங்கள் css file ஐ  <head>. உள் குறிப்பிட வேண்டும் 
+     சரியான முறையை பார்க்க  http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css' />
+
+<!-- நீங்கள் css ஐ html உள்ளும் எழுத முடியும் -->
+<style>
+   a { color: purple; }
+</style>
+
+<!-- அல்லது css ஐ நேரடியாக அந்த element இல் எழுத முடியும் -->
+<div style="border: 1px solid red;">
+</div>
+```
+
+## Precedence அல்லது Cascade
+
+ஒரு element ஆனது ஒன்றுக்கு மேற்பட்ட selectors மூலம் அணுகபடலாம் ,இவ்வாறான சந்தர்பங்களில் 
+ஒரு குறிபிட்ட விதிமுறையை பின்பற்றுகிறது இது cascading என அழைக்கபடுகிறது, அதனால் தன
+இது  Cascading Style Sheets என அழைக்கபடுகிறது.
+
+
+கிழே தரப்பட்டுள்ள css இன் படி:
+
+```css
+/* A */
+p.class1[attr='value']
+
+/* B */
+p.class1 { }
+
+/* C */
+p.class2 { }
+
+/* D */
+p { }
+
+/* E */
+p { property: value !important; }
+```
+
+அத்துடன் கிழே தரப்பட்டுள்ள கட்டமைப்பின்படியும்:
+
+```xml
+<p style='/*F*/ property:value;' class='class1 class2' attr='value' />
+```
+
+
+css முன்னுரிமை பின்வருமாறு 
+* `E` இதுவே அதிக முக்கியத்துவம் வாய்ந்தது காரணம் இது `!important` பயன்படுத்துகிறது. இதை பயன்படுத்துவதை தவிர்க்கவும்
+* `F` இது இரண்டாவது காரணம் இது inline style.
+* `A` இது  மூன்றவதாக வருகிறது, காரணம் இது மூன்று காரணிகளை குறிக்கிறது : element(உறுப்பு) பெயர் `p`, அதன் class `class1`, an அதன் பண்பு(attribute) `attr='value'`.
+* `C` இது அடுத்த நிலையில் உள்ளது கடைசி.
+* `B` இது அடுத்தது.
+* `D` இதுவே கடைசி .
+
+## css அம்சங்களின் பொருந்தகூடிய தன்மை
+
+பெரும்பாலான css 2 வின் அம்சங்கள் எல்லா உலாவிகளிலும் , கருவிகளிலும் உள்ளன. ஆனால் முன்கூட்டியே அந்த அம்சங்களை பரிசோதிப்பது நல்லது.
+
+## வளங்கள்
+
+* To run a quick compatibility check, [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/)
+
+## மேலும் வாசிக்க
+
+* [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/ta_in/javascript.html.markdown b/ta_in/javascript.html.markdown
new file mode 100644
index 00000000..f0b0a36a
--- /dev/null
+++ b/ta_in/javascript.html.markdown
@@ -0,0 +1,594 @@
+---
+language: javascript
+contributors:
+    - ['Adam Brenecki', 'http://adam.brenecki.id.au']
+    - ['Ariel Krakowski', 'http://www.learneroo.com']
+translators:
+  - ["Rasendran Kirushan", "https://github.com/kirushanr"]
+filename: javascript.js
+lang:in-ta
+---
+
+javascript 1995 ஆம்  ஆண்டு Netscape இல் பணிபுரிந்த Brendan Eich
+என்பவரால் உருவாக்கபட்டது.ஆரம்பத்தில் மிகவும் எளிமையான
+ஸ்க்ரிப்டிங் மொழியாக இணையதளங்களில் பயன்படுத்தபட்டது.
+இது ஜாவா (java ) வில் உருவாக்கபட்ட மிகவும் சிக்கலான இணைய செயலிகளுக்கு 
+உதவும் முகமாக உருவாக்கபட்டது. எனினும் இணையதள பக்கங்களில் இதன் முழுதான பயன்பாடு 
+மற்றும் உலாவிகளில்   பயன்படுத்த கூடிய வகையில் இருந்தமையாலும் Java வை விட 
+இணையதளகளின் முகப்பு உருவாக்கத்தில் இன்றளவில் முன்னிலை பெற்றுள்ளது.
+
+உலாவிகளுக்கு மட்டும் மட்டுபடுத்தபடவில்லை , Node.js மூலமாக 
+மிகவும் பிரபல்யமடைந்து வருகின்றது , உதாரணமாக கூகிள்க்ரோம் உலாவியின் 
+V8 JavaScript engine Node .js உதவியுடன் இயங்குகிறது .
+
+உங்கள் கருத்துக்கள் மிகவும் வரவேற்கபடுகின்றன , என்னுடன் தொடர்புகொள்ள 
+[@adambrenecki](https://twitter.com/adambrenecki), or
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// குறிப்புக்கள் C நிரலாக்கத்தை ஒத்தது .ஒரு வரி குறிப்புக்கள்  "//" குறியீடுடன் ஆரம்பமாகும் 
+
+/* பலவரி குறிப்புக்கள் "/*" ஆரம்பமாகி "/*" இல் முடிவடையும்  */
+
+// ஒரு கூற்று முற்றுபெற செய்ய ; இடல் வேண்டும் .
+doStuff();
+
+// ...ஆனால் அரைபுள்ளி இட வேண்டும் என்று அவசியம் இல்லை ஏன்  எனில் 
+// ஒரு வரி புதிதாக இடப்படும் போது அரைபுள்ளிகள் தானாகவே இடப்படும் ஆனால் சில தருணங்களை தவிர .
+doStuff()
+
+// ஆனால் அவ்வாறான தருணங்கள் எதிர்பாராத முடிவுகளை தரலாம் 
+
+// எனவே நாம் தொடர்ந்து ஒரு கூற்று நிறைவடையும் போது அரைபுள்ளி ஒன்றை இடுவோம் .
+
+///////////////////////////////////
+// 1. எண்கள்(Number) ,சரம் (String),செயற்குறிகள்(Operators) 
+
+// JavaScript ஒரே ஒரு எண்வகை காணப்படுகிறது  தசமி  (which is a 64-bit IEEE 754 double).
+// தசமி எண்வகை  (Doubles) 2^ 52 வரை சேமிக்க கூடியது
+// முழு எண்வகையின் 9✕10¹⁵ சேமிக்க போதுமானது .
+3; // = 3
+1.5; // = 1.5
+
+// அடிப்படை கணித பொறிமுறைகள் 
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// வகுத்தல்
+5 / 2; // = 2.5
+
+
+//bitwise பொறிமுறையை உபயோகிக்கும் போது 
+//உங்கள் தசம எண்ணின் பெறுமானமானது ஒரு நேர் அல்லது மறை அல்லது பூசியமாகவுள்ள முழு எண்ணாக 
+//மாற்றம் பெறுகிறது  இது 32 இருமம்(bit) வரை செல்லலாம் 
+
+1 << 2; // = 4
+
+// நிரலாக்கத்தில் செயலியை அமுல்படுத்தும் வரிசைமுறையில் அடைப்பு குறிக்கு முன்னிலை வழங்கபடுகிறது 
+(1 + 3) * 2; // = 8
+
+// மெய் எண்  அல்லாத மூன்றுபெறுமானங்கள் உள்ளன :
+Infinity; // result of e.g. 1/0
+-Infinity; // result of e.g. -1/0
+NaN; // result of e.g. 0/0, இது எண்  அல்ல என்பதை  குறிக்கும் 
+
+// தர்க ரீதியில் ஆன கட்டமைப்பு காணப்படுகிறது .
+true;
+false;
+
+// சரம் (string) ' அல்லது "  குறியீட்டினால்  உருவாக்கபடுகிறது 
+'abc';
+"Hello, world";
+
+// ஒரு boolean பெறுமானத்தின் எதிர்மறை பெறுமானத்தை பெற ! குறியீடு பயன்படுத்தபடுகிறது 
+!true; // = false
+!false; // = true
+
+//  சமமா என பார்க்க  ===
+1 === 1; // = true
+2 === 1; // = false
+
+// சமனற்றவையா  என பார்க்க  !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// மேலும் சில ஒப்பீடுகள் 
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// இரண்டு சரங்களை(Strings) ஒன்றாக இணைப்பதற்கு +
+"Hello " + "world!"; // = "Hello world!"
+
+// இரண்டு மாறிகளை/பெறுமானங்களை  ஒப்பிட  < and >
+"a" < "b"; // = true
+
+// இரண்டு பெறுமானங்கள் / மாறிகள்  ஒரேவகையை சேர்ந்தவையா என பார்க்க 
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...இல்லாவிடின்  ===
+"5" === 5; // = false
+null === undefined; // = false 
+
+// ...கிழே உள்ள கூற்றுகள் எதிர்பாராத 
+வெளியீடுகளை தரலாம் ...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// ஒரு சரத்தில்(string ) உள்ள எழுத்தை பெற  `charAt`
+"This is a string".charAt(0);  // = 'T'
+
+
+//... ஒரு சரத்தை(string )  சொற்களாக பிரிக்க (substring) `substring
+"Hello world".substring(0, 5); // = "Hello"
+
+// `length` ஒரு சரத்தில்(string) உள்ள சொற்களின் எண்ணிக்கை அல்லது நீளத்தை(length)அறிய 
+"Hello".length; // = 5
+
+// `null` மற்றும்  `undefined` இரு பெறுமானங்கள் உள்ளன  .
+null;      // மதிப்பு அற்ற ஒரு பெறுமானத்தை குறிக்கும் 
+undefined; // பெறுமானம் இன்னும் நிர்ணயிக்க படவில்லை என்பதை குறிக்கும்  (
+           // `undefined` இருப்பினும் இதுவும் ஒரு பெறுமானமாக கருதபடுகிறது )
+
+// ஆகியன  தர்க்க ரீதியாக பிழையானவை(false) , மற்றவை யாவும் சரியானவை (true).
+// 0 மானது பிழையை (false) குறிக்கும்  "0" சரியை (true) குறிக்கும் எனினும் 0 == "0".
+
+///////////////////////////////////
+// 2. மாறிகள்  (Variables),அணிகள் (Arrays) மற்றும் பொருட்கள் (Objects)
+
+// மாறிகளை உருவாக்க `var ` என்னும் குறியீட்டு சொல் (keyword ) பயன்படுகிறது .
+//உருவாக்கப்படும் மாறிகள் எந்த வகையை சார்ந்தன என்பதை  JavaScript 
+//தானாகவே நிர்ணயிக்கும் . மாறிக்கு  ஒரு பெறுமானத்தை வழங்க  `=` பாவிக்க 
+var someVar = 5;
+
+// //நீங்கள் மாறிகளை  நிறுவ  'var' குறியீட்டு சொல்லை பயன்படுத்தா விடினும் 
+//அது தவறில்லை ...
+someOtherVar = 10;
+
+// ...ஆனால் நீங்கள் நிறுவிய மாறி(variable) எல்லா உங்கள் ப்ரோக்ராம் இன் சகல இடங்களிலும் 
+//அணுக கூடியதாய் அமையும் , இல்லாவிடின் அது ஒரு குறிபிட்ட இடத்திற்கு மட்டும் 
+//மட்டுபடுத்தபடும் .
+
+//பெறுமானம் வழங்கபடாத மாறிகளுக்கு ,இயல்பாக/தானாக undefined என்ற பெறுமானம் 
+//வழங்கப்படும் 
+var someThirdVar; // = undefined
+
+// மாறிகளில் கணித செயல்பாடுகளை நடத்த சுருக்கெழுத்து முறைகள் காணப்படுகின்றன :
+someVar += 5; // இது  someVar = someVar + 5; ஐ  ஒத்தது someVar இன் பெறுமானம் இப்போது  10
+someVar *= 10; //  someVar இன் பெறுமானம் இப்போது  100
+
+//மிகவும் சுருக்கமான சுருகேழுத்து முறை கூட்டல்  அல்லது  கழித்தல் செயன்முறையை 
+//மேற்கொள்ள    
+someVar++; // someVar இன் பெறுமானம் இப்போது is 101
+someVar--; // someVar இன் பெறுமானம் இப்போது 100
+
+// அணிகள்(Arrays) எல்லாவகையான  பெறுமானங்களையும் உள்ளடக்க கூடியது 
+var myArray = ["Hello", 45, true];
+
+// அணிகள்(Arrays) உறுப்பினர்கள் சதுர அடைப்புக்குறிக்குள் அதன் தான இலக்கத்தை கொண்டு 
+//அணுகமுடியும் .
+// அணிகளில் உள்ள உறுப்புகள் 0 இருந்து  ஆரம்பமாகும் .
+myArray[1]; // = 45
+
+// அணிகள் உள்ள உறுப்புகளை மாற்றமுடியும்  அத்துடன் உறுப்புகளின் எண்ணிக்கையும் மாறலாம் .
+myArray.push("World");
+myArray.length; // = 4
+
+// அணியில்(Array)  ஒரு குறிப்பிட்ட இடத்தில உள்ள பெறுமானத்தை மாற்ற .
+myArray[3] = "Hello";
+
+// JavaScript's பொருள் (objects) அகராதியை ஒத்தன  
+// ஒழுங்கு படுத்த படாத சேகரிப்பு (collection) ஆகும் இதில் ஒரு சாவியும்(key) 
+//அதுக்குரிய பெறுமானமும்(value) காணப்படும் .
+var myObj = {key1: "Hello", key2: "World"};
+
+// விசைகள் சரங்களை, ஆனால் அவர்கள் சரியான என்றால் மேற்கோள் அவசியம் இல்லை
+//சாவிகளை உ.ம் : "key" என நிறுவலாம் ஆனால் , மேற்கோள்  ஆனது சாவி முன்பே நிறுவபட்டிருப்பின்
+//அவசியம் இல்லை   
+// சாவிகளுக்குரிய பெறுமானங்கள் எந்த வகையாகவும் இருக்கலாம் 
+var myObj = {myKey: "myValue", "my other key": 4};
+
+//பொருள் பண்புகளை சதுர அடைப்புக்குறிக்குள் அதன் சாவியின் பெயரை (key) கொண்டு 
+//அணுகமுடியும் ,
+myObj["my other key"]; // = 4
+
+// ... அல்லது புள்ளி குறியீட்டை பயன்படுத்தி ,சாவியின் (key is a valid identifier)
+//பெயர் மூலம் அணுக முடியும் 
+myObj.myKey; // = "myValue"
+
+// பொருட்கள்(ஒப்ஜெக்ட்ஸ்) மாற்றபடகூடியான சாவிகளின் பெறுமதிகளை மாற்ற முடியும் அத்துடன் புதிய 
+//சாவிகளை(keys) இடவும் முடியும் 
+myObj.myThirdKey = true;
+
+//பெறுமதி வரையறுக்கபடாத ஒரு சாவியினை அணுகும் போது 
+//அது வெளியிடும் பெறுமதி `undefined`.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. தர்க்கம் மற்றும் கட்டுப்பாட்டு கட்டமைப்பு
+
+// கீழே காட்டப்பட்டுள்ள தொடரியல் ஜாவா வை ஒத்தது 
+
+// The `if` ஒரு குறித்த தர்க்கம் சரியாயின் 
+//அல்லது என்ற வடிவமைப்பை 
+var count = 1;
+if (count == 3){
+    // count  இன் பெறுமானம் 3 சமமா என பார்க்கபடுகிறது 
+} else if (count == 4){
+    // count  இன் பெறுமானம் 4க்கு  சமமா என பார்க்கபடுகிறது 
+} else {
+    // count ஆனது 3  அல்ல  4 அல்ல  எனின் 
+}
+
+// ஒரு குறிப்பிட்ட  ஒப்பீடு உண்மையாக இருக்கும் வரை  `while`.
+while (true){
+    // இந்த இருக்கும் கூற்றுகள் முடிவிலி தடவை மறுபடி செயற்படுத்தப்படும் !
+}
+
+// while போல் அல்லாது do-while ,அவை ஒரு தடவையேனும் அதனுள் உள்ள கூற்றுகள் செயற்படுத்தபடும் 
+var input;
+do {
+    input = getInput();
+} while (!isValid(input))
+
+// for (loop /சுற்று ) C , ஜாவாவை ஒத்தது 
+//மாறிக்கு பெறுமானத்தை  வழங்கல் , மாறியானது தர்க்கத்தை பூர்த்தி செய்கிறதா என பார்த்தல் ,
+//சுற்றுக்குள் இருக்கும் கூற்றை செயற்படுதல்  
+
+for (var i = 0; i < 5; i++){
+    // இந்த சுற்று 5 தடவைகள் தொடர்ந்து செயற்படுத்தபடும் 
+}
+
+//for /In  சுற்றுகள் prototype சங்கிலியில் உள்ள சகல காரணிகள் ஊடகவும் செல்லும் 
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18}; 
+for (var x in person){
+    description += person[x] + " ";
+}
+
+//ஒரு பொருளில் (Object) இடப்பட்ட பண்புகளை (properties) கருத்தில் கொள்ளும் போது
+//குறிப்பிட்ட பண்புகளை அந்த Object கொண்டுள்ளதா என பார்க்க  
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18}; 
+for (var x in person){
+    if (person.hasOwnProperty(x)){
+        description += person[x] + " ";
+    }
+}
+
+//for /in  ஆனது அணியில் உள்ள பண்புகள் ஒழுங்குபடுத்தப்பட்டவிதம் முக்கியம் 
+//ஆயின் பாவிப்பதை தவிர்க்கவும் ஏனெனில் அது சரியான ஒழுங்கில் 
+//வெளியீட்டை தரும் என்பது ஐயம் ஆகும் 
+
+// && is logical and, || is logical or
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+}
+if (colour == "red" || colour == "blue"){
+    // colour is either red or blue
+}
+
+// && and || "short circuit", which is useful for setting default values.
+var name = otherName || "default";
+
+
+
+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. Functions, Scope and Closures
+
+// JavaScript இல் functions நிறுவ  `function` keyword.பயன்படும் 
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+//ஒரு பெறுமானத்தை return செய்ய வேண்டும் எனின் இரண்டும் ஒரே வரியில் 
+//இருக்க வேண்டும் இல்லாவிடின் return ஆனது `undefined ` return செய்யும் 
+//காற் புள்ளி  தானாகவே இடப்படும் , நீங்கள்  Allman style உபயோகிக்கும் போது 
+//அவதானமாக இருக்கவும் 
+function myFunction()
+{
+    return // <- semicolon automatically inserted here
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// JavaScript functions ஆனது   first class objects ஆகும் ,எனவே அவற்றை மாறிகளுக்கு 
+//assign செய்ய முடியும் அதுமட்டும் அல்லது functions களில் arguments ஆக அனுப்பமுடியும் 
+// உதாரணமாக ஒரு event handler:
+function myFunction(){
+    //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும் 
+}
+setTimeout(myFunction, 5000);
+// Note: setTimeout ஆனது  ஜாவஸ்க்ரிப்ட்  சேர்ந்தது அன்று , ஆனால் அந்த வசதி 
+//உலாவிகளிலும் ,Node .js  காணப்படுகிறது 
+
+// Function objects கட்டாயம் பெயரிடப்பட வீண்டும் என்று அவசியம் இல்லை 
+// அவை  anonymous(பெயரிடப்படாமல்) உருவாக்கபடலாம் 
+setTimeout(function(){
+        //இந்த code 5 செக்கன்களில்  செயற்படுத்தப்படும் 
+}, 5000);
+
+// JavaScript  function ஒரு குறிப்பிட்ட  scope(எல்லை) கொண்டுள்ளது ;
+//functions தமக்கென  ஒரு scope கொண்டுள்ளன .
+
+if (true){
+    var i = 5;
+}
+i; // = 5 - //இது undefined அல்ல 
+
+// இதன் காரணமாக anonymous functions உடனடியாக செயற்படுத்தபடுகின்றன 
+//இதன் மூலம் தற்காலிக மாறிகள்(variable) குளோபல் scope
+//இற்கு மாறுவதை தவிர்க்கலாம் .
+(function(){
+    var temporary = 5;
+	//நாங்கள் ஒரு மாறியை எங்கிருந்தும் அணுக (access) அதை "global object"
+	//ஒன்றுக்கு வழங்க வேண்டும் உலாவியில் அது எப்போதும் `window` ஆகும் .
+	//உலாவி  அல்லாத சூழலில் (Node.js) வேறு பெயருடன் இருக்கும் 
+    window.permanent = 10;
+})();
+temporary; // raises ReferenceError
+permanent; // = 10
+
+//JavaScript's மிகவும் சக்தி வாய்ந்த ஒரு வசதி closures ஆகும் 
+//ஒரு function இன்னொரு function உள் உருவாக்கபடின்
+//அது உருவாகப்பட்ட function  இன் மாறிகளை அணுக முடியும்  
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    // Inner functions ஆனது local scope இல்  காணப்படும் 
+	//அது `var ` என்ற குறியீட்டு சொல்லால் நிறுவப்படும் 
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    //setTimeout  ஆனது background இல் இயங்கும்  , எனவே sayHelloInFiveSeconds function,
+	//செயற்பாடு முடிவடைய ,setTimeout ஆனது inner function call செய்யும்.
+
+}
+sayHelloInFiveSeconds("Adam"); // //இது ஒரு popup  ஐ ஐந்து செக்கன்களில் காட்டும் 
+
+///////////////////////////////////
+// 5.  Objects; Constructors and Prototypes  பற்றி மேலும் 
+
+// Objects  functions ஐ கொண்டிருக்கலாம் 
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+//functions ஆனது objects உடன் இணைக்கப்பட்டுள போது அவை object ஐ அணுக முடியும் 
+//அவை this என்ற  குறியீட்டு  சொல்லை பயன்படுத்தி இணைக்கபடுகின்றன 
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+//எங்கள் function ஆனது தொழிற் படாமல் போகலாம் அது context(அமைப்பு ) of the object call செய்யபடவிடின் 
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+
+//function ஆனது ஒரு object உக்கு assign செய்யலாம் பிறகு அதை நாம் அணுகமுடியும் 
+//`this` மூலம்  
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+//ஒரு function ஒரு அமைப்பை நாம் உருவாக்க முடியும் 
+//அதை நாம் `call` அல்லது  `apply` மூலம் செயல்படுத்த முடியும்
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+//apply செயற்பாட்டளவில் ஒத்தன ,ஆனால் அது array (அணி) argument 
+//ஆக எடுக்கிறது.
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+//இது தொடர்ச்சியான arguments ஐ நாம் function ஒன்றுக்குள் pass பண்ண 
+//வேண்டும் எனில் மிகவும் உபயோகமானது 
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+//ஆனால் `call ` ,`apply ` இரண்டும் தற்காலிகமானவை 
+//அவற்றை நிரந்தரமாக்க bind function ஐ பயன்படுத்தவும் 
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+//`bind ` ஐ உபயோகித்து ஒரு function ஐ பகுதியாக apply செய்ய முடியும் 
+
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+
+//ஒரு function ஐ நாம் new என்ற குறியீட்டு சொல்லை பயன்படுத்தி 
+//அழைக்கும் போது  புதிய object உருவாக்கப்படும் .இவ்வாறான  functions 
+//constructors என அழைக்கப்படும் 
+
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+//ஒவ்வொரு JavaScript object உம் ஒரு `prototype ` கொண்டுள்ளது 
+//நீங்கள் object ஒன்றின் ஒரு property ஐ அணுகும் போது 
+//அந்த property இல்லாவிடின்  interpreter  ஆனது 
+//அதன் prototype உள்ளதா என பார்க்கும் 
+
+//JS இன் சில செயலாக்கங்கள் ஒரு object இன் protoype ஐ 
+//இலகுவாக `__proto__` மூலம் access செய்ய முடியும் .
+//இது prototype பாவணை யை இலகுவாக்கினாலும் 
+//இது சரியான ஒரு முறை அல்ல 
+var myObj = {
+    myString: "Hello world!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// This works for functions, too.
+myObj.myFunc(); // = "hello world!"
+
+//உங்கள் property prototype இல் இல்லது இருப்பின் , protype இன் 
+//prototype search செய்யப்படும் 
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+//ஒவ்வொரு object உம்  அதன் protype க்கும்  reference (மேற்கோள் ) ஒன்றை வைத்திருக்கும்  
+//நாம் ஒரு protype இணை மாற்றினால் அதன் மாற்றங்கள் எல்லா இடத்திலும் (program இல் )
+//பிரதிபலிக்கும் 
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+ 
+//நாம் முன்பு கூறியது போல் `__proto__` பயன்படுத்துவது சரியான முறை அல்ல 
+//எனவே நாம் ஒரு protype ஐ object இல் உருவாக்க  இரண்டு வழிமுறைகள்
+//உள்ளன
+
+// முதல் முறை  Object.create இது அண்மையில் அறிமுகம் செய்ய பட்ட ஒன்று
+//எனவே சில இடங்களில் இந்த முறை இன்னும் அறிமுகம் ஆகவில்லை
+
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+
+// இரண்டாவது முறை , இது சகல இடங்களிலும் வேலைசெய்யும், இது constructors மூலம்.
+//constructors prototype என்னும் ஒரு காரணியை  கொண்டுள்ளது , இது  constructor function
+//இன் prototype அன்று. ,இது நாம் new என்ற குறியீட்டு சொல்லையும்  அந்த constructor உபயோகித்து
+//உருவாக்கபடுகிறது
+
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// Built-in types like strings and numbers also have constructors that create
+// equivalent wrapper objects.
+// JavaScript இல் உள்ள strings மற்றும் numbers வகைகளும் constructors கொண்டுள்ளன
+//இவை wrapper objects ஐ ஒத்தன
+
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+
+//இவை மிக சிறிய அளவில் ஒத்தவை
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // இந்த கூற்றானது செயல்படுத்தபடாது ஏனெனில் ௦ false ஆகும்
+}
+
+// However, the wrapper objects and the regular builtins share a prototype, so
+// you can actually add functionality to a string, for instance.
+
+//இருப்பினும்  wrapper objects மற்றும் regular builtins ஆகியன  prototype ஒன்றை கொண்டுள்ளன
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// This fact is often used in "polyfilling", which is implementing newer
+// features of JavaScript in an older subset of JavaScript, so that they can be
+// used in older environments such as outdated browsers.
+
+//இந்த முறையானது  "polyfilling" இல் உபயோகபடுத்தபடுகிறது.
+//புதிய சில  வசதிகளை JavaScript பழைய JavaScript பிரதிகளில் இல்  உருவாக்குகிறது.
+//இது பழைய சூழல்களில் உபயோகிகப்படும்.
+
+
+//நாங்கள் முன்பு கூறி இருந்தோம்  Object.create சில இடங்களில் இந்த முறை இன்னும் 
+//அறிமுகம் ஆகவில்லை என்று ஆனால் இதை polyfill ஐ  பயன்படுத்தி உருவாக்க
+//முடியும்
+
+if (Object.create === undefined){ // don't overwrite it if it exists
+    Object.create = function(proto){
+        // make a temporary constructor with the right prototype
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // then use it to create a new, appropriately-prototyped object
+        return new Constructor();
+    }
+}
+```
+
+## மேலும் JavaScript பற்றி கற்க
+
+The [Mozilla Developer
+Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) provides
+excellent documentation for JavaScript as it's used in browsers. Plus, it's a
+wiki, so as you learn more you can help others out by sharing your own
+knowledge.
+
+MDN's [A re-introduction to
+JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+covers much of the concepts covered here in more detail. This guide has quite
+deliberately only covered the JavaScript language itself; if you want to learn
+more about how to use JavaScript in web pages, start by learning about the
+[Document Object
+Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) is a variant of this reference with built-in challenges.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) is an in-depth
+guide of all the counter-intuitive parts of the language.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) is a classic guide / reference book.
+
+In addition to direct contributors to this article, some content is adapted
+from Louie Dinh's Python tutorial on this site, and the [JS
+Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+on the Mozilla Developer Network.
diff --git a/ta_in/json.html.markdown b/ta_in/json.html.markdown
new file mode 100644
index 00000000..d85e0d82
--- /dev/null
+++ b/ta_in/json.html.markdown
@@ -0,0 +1,86 @@
+---
+language: json
+filename: learnjson.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+translators:
+  - ["Rasendran Kirushan", "https://github.com/kirushanr"]
+lang: ta-in
+---
+
+ஜேசன் ஒரு ஒரு மிக எளிய தரவு உள்மாற்றீட்டு வடிவம் ஆகும்.
+Learn X in Y Minutes இதுவே மிகவும் இலகுவான பகுதியாக  அமைய போகிறது.
+
+
+ஜேசன்  இன் எளிமையான கட்டமைப்பில்  குறிப்புக்கள் (Comments) இல்லை , எனினும் 
+பெரும்பாலான  பாகுபடுத்திகளில் C - style  முறையிலான (`//`, `/* */`) குறிப்புகளை இட முடியும்.
+சில பாகுபடுத்திகள்(interpreter) குறிப்புகளுக்கு (comments)தொடர்ச்சியாக வரும்
+ காற்புள்ளியை  அனுமதிக்கின்றன (உதாரணமாக ஒரு அணியை (array) அடுத்துவரும் காற்புள்ளி
+ அல்லது ஒரு பொருளில் (object)உள்ள கடைசி உறுப்பை/சொத்தை(  last property) அடுத்து வரும் காற்புள்ளி )
+எனினும் சகல இடங்களிலும் ஜேசன் பயன்படுத்த பட வேண்டும் எனில் மேற்கூறிய குறிப்புகளை தவிர்த்தல் நல்லது .\
+
+
+ஜேசன் 100% மிக சரியாக அமைவது மட்டும் இன்றி 
+இலகுவாக புரியக் கூடிய எளிய தரவு உள்மாற்றீட்டு வடிவம் ஆகும்.
+
+
+ஜேசன் அனுமதிக்கும் தரவு வகைகள் : சரம் (string),முழு (int),பூலியன் (தர்க ரீதியில் ஆன கட்டமைப்பு),
+அணி (array ),கழி (null ),பொருள் (object).
+
+ஜேசன் அனுமதிக்கும் அல்லது பாவனைக்கு உட்படுத்த கூடிய உலாவிகள் (browsers): 
+Firefox(Mozilla) 3.5, Internet Explorer 8, Chrome, Opera 10, Safari 4.
+
+ஜேசனின் கோப்புவகை(filetype)  ".json " ஆகும் .
+
+ஜேசன் உரைக்கான MIME வகை   "application/json" ஆகும். 
+ஜேசன் இல் காணப்படும் பிரதான பின்னடைவு தரவு இனம் இதுவென்று வரையறுக்க 
+படாமை ஆகும் .
+
+ஒரு ஜேசன் இன் எளிய கட்டமைப்பு கீழே காட்டப்பட்டுள்ளது 
+
+```json
+{
+  "key": "ஒரு சாவிக்கு ஒரு பெறுமதி உள்ளது ",
+
+  "keys": "சாவிகள் , மற்றும் பெறுமானங்கள் மேற்கோள் குறிக்குள் இடல் வேண்டும்",
+  "numbers": 0,
+  "strings": "Hellø, wørld. எல்லாவகையான  unicode உம் அனுமதிக்கப்படும், அத்துடன் \"escaping\".",
+  "has bools?": true,
+  "nothingness": null,
+
+  "big number": 1.2e+100,
+
+  "objects": {
+    "comment": "பெரும்பாலான கட்டமைப்புகள் objects இல் இருந்தே வருகின்றன",
+
+    "array": [0, 1, 2, 3, "array யானது எல்லாவகையான பெறுமானங்களையும் கொண்டிருக்கும்", 5],
+
+    "another object": {
+      "comment": "இவை ஒன்றுக்குள் இன்னொன்றை எழுத முடியும்"
+    }
+  },
+
+  "silliness": [
+    {
+      "sources of potassium": ["வாழைபழம்"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "alternative style": {
+    "comment": "இதை பார்க்கவும்"
+  , "comma position": "doesn't matter - as long as it's before the value, then it's valid"
+  , "another comment": "how nice"
+  },
+
+  "that was short": "நீங்கள் ஜேசன் பற்றி யாவற்றையும் கற்றுள்ளீர்கள்"
+}
+```
+
diff --git a/ta_in/xml.html.markdown b/ta_in/xml.html.markdown
new file mode 100644
index 00000000..a9bfa9cd
--- /dev/null
+++ b/ta_in/xml.html.markdown
@@ -0,0 +1,145 @@
+---
+language: xml
+filename: learnxml.xml
+contributors:
+  - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+  - ["Rasendran Kirushan", "https://github.com/kirushanr"]
+lang:in-ta
+---
+
+
+XML ஆனது ஒரு கட்டமைப்பு மொழி ஆகும் இது தகவலை சேமிக்கவும்
+தகவலை பரிமாறவும் உருவாக்கபட்டுள்ளது
+
+
+HTML போல் அன்றி , XML ஆனது தகவலை மட்டும் கொண்டு செல்ல்கிறது 
+* XML வாக்கிய அமைப்பு
+
+
+```xml
+<!-- இது ஒரு XML குறிப்பு -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<bookstore>
+  <book category="COOKING">
+    <title lang="en">Everyday Italian</title>
+    <author>Giada De Laurentiis</author>
+    <year>2005</year>
+    <price>30.00</price>
+  </book>
+  <book category="CHILDREN">
+    <title lang="en">Harry Potter</title>
+    <author>J K. Rowling</author>
+    <year>2005</year>
+    <price>29.99</price>
+  </book>
+  <book category="WEB">
+    <title lang="en">Learning XML</title>
+    <author>Erik T. Ray</author>
+    <year>2003</year>
+    <price>39.95</price>
+  </book>
+</bookstore>
+
+
+  <!--
+  
+	மேல காட்டப்பட்டுள்ளது ஒரு xml file இன் உதாரணம் ஆகும்
+	அது metadata உடன் ஆரம்பமாகிறது
+	XML  ஆனது ஒரு மரத்தை போன்ற கட்டமைப்பை ஒத்தது. 
+	இங்கு root node (கொப்பு)  `bookstore`  இது மூன்று கிளைகள்  (child nodes)
+	கொண்டுள்ளது. இந்த கிளைகள் மேலும் சில கிளைகளை கொண்டு இருக்கலாம்
+	ஒவொரு node கட்டமைப்பும்  ஒரு `<` ஆரம்பாமாகி `>` முடிவடையும்
+	கிளைகள் இந்த கட்டமைப்புக்கு இடையில் நிறுவப்படும்
+  -->
+
+
+<!--
+XML இரண்டு வகையான தகவல்களை கொண்டு செல்லக்கூடியது
+1- Attributes -> ஒரு  கணு(node) பற்றிய metadata 
+பொதுவாக   XML Parser இந்த தகவலை பயன்படுத்தியே தகவலை
+சரியான முறையில் சேமிக்க.
+இது xml கட்டமைப்பின் ஆரம்பத்தில் உள்ள name="value"
+தீர்மானிக்கபடுகிறது.
+
+2-Elements ->இவற்றில் முற்றிலும் தகவல்களே சேமிக்கபட்டு இருக்கும்
+Elements  ஒரு `<` ஆரம்பாமாகி `>` முடிவடையும் காணப்படும்
+
+
+-->
+
+<!-- கிழே உள்ள element இரண்டு பெறுமானங்களை கொண்டுள்ளது  -->
+<file type="gif" id="4293">computer.gif</file>
+
+
+```
+
+* சரியான முறையில் ஒழுகுபடுத்தபட்ட X document
+
+
+ஒரு XML document ஆனது சரியான முறையில் எழுத பட்டிருப்பின் மட்டுமே அது 
+சிறந்த வகையில்  வடிவமைக்கபட்டுள்ளது,எனினும் மேலும் பல கட்டுபாடுகளை
+நாம் ஒரு xml document உக்கு இட முடியும் உ.ம்:-DTD மற்றும்  XML Schema.
+
+
+ஒரு xml document ஆனது ஒரு வரையறுக்கபட்டிருப்பின் மட்டுமே 
+அது சரி என கொள்ளப்படும்
+
+
+With this tool, you can check the XML data outside the application logic.
+இந்த கருவியை உபயோகித்து xml தகவல்களை சோதிக்க முடியும் 
+
+```xml
+
+<!-- கீழே bookstore html document இன் எளிமையான வடிவம் 
+    DTD வரையறைகளுடன்
+-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "Bookstore.dtd">
+<bookstore>
+  <book category="COOKING">
+    <title >Everyday Italian</title>
+    <price>30.00</price>
+  </book>
+</bookstore>
+
+<!-- DTD ஆனது பின்வருமாறு  அமையும் :-->
+
+<!DOCTYPE note
+[
+<!ELEMENT bookstore (book+)>
+<!ELEMENT book (title,price)>
+<!ATTLIST book category CDATA "Literature">
+<!ELEMENT title (#PCDATA)>
+<!ELEMENT price (#PCDATA)>
+]>
+
+
+<!-- DTD ஆனது root node ஐ உருவாக்கிய பின் நிறுவ படுகிறது ,இது ஒன்று அல்லது 
+ஒன்றிக்கு மேற்பட்ட child node களை எதிர்பார்க்கிறது.
+ ஒவ்வொரு 'book' உம் கட்டாயமாக ஒரு 'title' , 'price','category', with "Literature"
+ ஆகிய பெறுமானங்களை கொண்டிருத்தல் அவசியம்.
+--> 
+
+<!-- DTD ஆனது xml file ஒன்றினுள் உருவாக்கபடுகிறது-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT bookstore (book+)>
+<!ELEMENT book (title,price)>
+<!ATTLIST book category CDATA "Literature">
+<!ELEMENT title (#PCDATA)>
+<!ELEMENT price (#PCDATA)>
+]>
+
+<bookstore>
+  <book category="COOKING">
+    <title >Everyday Italian</title>
+    <price>30.00</price>
+  </book>
+</bookstore>
+```
diff --git a/tcl.html.markdown b/tcl.html.markdown
index af2911c9..b90bd690 100644
--- a/tcl.html.markdown
+++ b/tcl.html.markdown
@@ -14,7 +14,7 @@ programming language.  It can also be used as a portable C library, even in
 cases where no scripting capability is needed, as it provides data structures
 such as dynamic strings, lists, and hash tables.  The C library also provides
 portable functionality for loading dynamic libraries, string formatting and
-code conversion, filesystem operations, network operations, and more.  
+code conversion, filesystem operations, network operations, and more.
 Various features of Tcl stand out:
 
 * Convenient cross-platform networking API
@@ -58,14 +58,14 @@ lighter that that of Lisp, just gets out of the way.
 #! /bin/env tclsh
 
 ################################################################################
-## 1. Guidelines 
+## 1. Guidelines
 ################################################################################
 
 # Tcl is not Bash or C!  This needs to be said because standard shell quoting
 # habits almost work in Tcl and it is common for people to pick up Tcl and try
 # to get by with syntax they know from another language.  It works at first,
 # but soon leads to frustration with more complex scripts.
- 
+
 # Braces are just a quoting mechanism, not a code block constructor or a list
 # constructor.  Tcl doesn't have either of those things.  Braces are used,
 # though, to escape special characters in procedure bodies and in strings that
@@ -73,7 +73,7 @@ lighter that that of Lisp, just gets out of the way.
 
 
 ################################################################################
-## 2. Syntax 
+## 2. Syntax
 ################################################################################
 
 # Every line is a command.  The first word is the name of the command, and
@@ -83,13 +83,13 @@ lighter that that of Lisp, just gets out of the way.
 # are used, they are not a string constructor, but just another escaping
 # character.
 
-set greeting1 Sal 
+set greeting1 Sal
 set greeting2 ut
 set greeting3 ations
 
 
 #semicolon also delimits commands
-set greeting1 Sal; set greeting2 ut; set greeting3 ations 
+set greeting1 Sal; set greeting2 ut; set greeting3 ations
 
 
 # Dollar sign introduces variable substitution
@@ -126,11 +126,11 @@ puts lots\nof\n\n\n\n\n\nnewlines
 set somevar {
     This is a literal $ sign, and this \} escaped
     brace remains uninterpreted
-} 
+}
 
 
 # In a word enclosed in double quotes, whitespace characters lose their special
-# meaning 
+# meaning
 set name Neo
 set greeting "Hello, $name"
 
@@ -178,7 +178,7 @@ set greeting "Hello $people::person1::name"
 
 
 ################################################################################
-## 3. A Few Notes 
+## 3. A Few Notes
 ################################################################################
 
 # All other functionality is implemented via commands.  From this point on,
@@ -193,8 +193,8 @@ set greeting "Hello $people::person1::name"
 namespace delete ::
 
 
-# Because of name resolution behaviour, it's safer to use the "variable" command to 
-# declare or to assign a value to a namespace. If a variable called "name" already 
+# Because of name resolution behaviour, it's safer to use the "variable" command to
+# declare or to assign a value to a namespace. If a variable called "name" already
 # exists in the global namespace, using "set" here will assign a value to the global variable
 # instead of creating a new variable in the local namespace.
 namespace eval people {
@@ -210,7 +210,7 @@ set people::person1::name Neo
 
 
 ################################################################################
-## 4. Commands 
+## 4. Commands
 ################################################################################
 
 # Math can be done with the "expr" command.
@@ -295,7 +295,7 @@ while {$i < 10} {
 
 
 # A list is a specially-formatted string.  In the simple case, whitespace is sufficient to delimit values
-set amounts 10\ 33\ 18 
+set amounts 10\ 33\ 18
 set amount [lindex $amounts 1]
 
 
@@ -339,7 +339,7 @@ eval {set name Neo}
 eval [list set greeting "Hello, $name"]
 
 
-# Therefore, when using "eval", use [list] to build up a desired command 
+# Therefore, when using "eval", use [list] to build up a desired command
 set command {set name}
 lappend command {Archibald Sorbisol}
 eval $command
@@ -355,8 +355,8 @@ eval $command ;# There is an error here, because there are too many arguments \
 # This mistake can easily occur with the "subst" command.
 set replacement {Archibald Sorbisol}
 set command {set name $replacement}
-set command [subst $command] 
-eval $command ;# The same error as before:  to many arguments to "set" in \
+set command [subst $command]
+eval $command ;# The same error as before: too many arguments to "set" in \
     {set name Archibald Sorbisol}
 
 
@@ -364,12 +364,12 @@ eval $command ;# The same error as before:  to many arguments to "set" in \
 # command.
 set replacement [list {Archibald Sorbisol}]
 set command {set name $replacement}
-set command [subst $command] 
+set command [subst $command]
 eval $command
 
 
 # It is extremely common to see the "list" command being used to properly
-# format values that are substituted into Tcl script templates.  There are 
+# format values that are substituted into Tcl script templates.  There are
 # several examples of this, below.
 
 
@@ -422,12 +422,12 @@ proc while {condition script} {
 
 # The "coroutine" command creates a separate call stack, along with a command
 # to enter that call stack. The "yield" command suspends execution in that
-# stack. 
+# stack.
 proc countdown {} {
 	#send something back to the initial "coroutine" command
 	yield
 
-	set count 3 
+	set count 3
 	while {$count > 1} {
 		yield [incr count -1]
 	}
@@ -435,12 +435,12 @@ proc countdown {} {
 }
 coroutine countdown1 countdown
 coroutine countdown2 countdown
-puts [countdown 1] ;# -> 2 
-puts [countdown 2] ;# -> 2 
-puts [countdown 1] ;# -> 1 
-puts [countdown 1] ;# -> 0 
+puts [countdown 1] ;# -> 2
+puts [countdown 2] ;# -> 2
+puts [countdown 1] ;# -> 1
+puts [countdown 1] ;# -> 0
 puts [coundown 1] ;# -> invalid command name "countdown1"
-puts [countdown 2] ;# -> 1 
+puts [countdown 2] ;# -> 1
 
 
 ```
diff --git a/tmux.html.markdown b/tmux.html.markdown
index c11da5fc..868302a8 100644
--- a/tmux.html.markdown
+++ b/tmux.html.markdown
@@ -38,7 +38,7 @@ then later reattached.
     lsp              # List panes
      -a              # List all panes
      -s              # List all panes in session
-     -t              # List app panes in target
+     -t              # List all panes in target
 
     kill-window      # Kill current window
      -t "#"          # Kill target window
@@ -249,3 +249,7 @@ set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] |
 [Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
 
 [Display CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
+
+[tmuxinator - Manage complex tmux sessions](https://github.com/tmuxinator/tmuxinator) 
+
+
diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index a68026a5..91c7c269 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -234,7 +234,8 @@ on a new line! ""Wow!"", the masses cried";
             // Üçlü operatörler
             // Basit bir if/else ifadesi şöyle yazılabilir
             // <koşul> ? <true> : <false>
-            string isTrue = (true) ? "True" : "False";
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
 
             // While döngüsü
             int fooWhile = 0;
diff --git a/tr-tr/objective-c-tr.html.markdown b/tr-tr/objective-c-tr.html.markdown
index f27cbf08..727f973e 100644
--- a/tr-tr/objective-c-tr.html.markdown
+++ b/tr-tr/objective-c-tr.html.markdown
@@ -14,7 +14,7 @@ kendi çatıları olan Cocoa ve Cocoa Touch için kullanılan bir programlama di
 Genel açamlı, object-oriented bir yapıya sahip programlama dilidir. C 
 programlama diline Smalltalk stilinde mesajlaşma ekler.  
 
-```objective_c
+```objective-c
 // Tek satır yorum // işaretleri ile başlar
 
 /*
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 90f3fcd5..c13f5ecf 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -7,13 +7,10 @@ lang: tr-tr
 ---
 
 Swift iOS ve OSX platformlarında geliştirme yapmak için Apple tarafından oluşturulan yeni bir programlama dilidir.  Objective - C ile beraber kullanılabilecek ve de hatalı kodlara karşı daha esnek bir yapı sunacak bir şekilde tasarlanmıştır. Swift 2014 yılında Apple'ın geliştirici konferansı WWDC de tanıtıldı. Xcode 6+'a dahil edilen LLVM derleyici ile geliştirildi.
-
-The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.  
+ 
 
 Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
 
-See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.  
-
 Ayrıca Swift ile gelen tüm özellikleri görmek için Apple'ın [başlangıç kılavuzu](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html)na bakmanızda yarar var.
 
 
@@ -244,7 +241,7 @@ print("Benzin fiyatı: \(fiyat)")
 
 // Çeşitli Argümanlar
 func ayarla(sayilar: Int...) {
-    // its an array
+    // bu bir dizidir
     let sayi = sayilar[0]
     let argumanSAyisi = sayilar.count
 }
diff --git a/vi-vn/json-vi.html.markdown b/vi-vn/json-vi.html.markdown
new file mode 100644
index 00000000..257216ff
--- /dev/null
+++ b/vi-vn/json-vi.html.markdown
@@ -0,0 +1,76 @@
+---
+language: json
+filename: learnjson-vi.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+translators:
+  - ["Thanh Phan", "https://github.com/thanhpd"]
+lang: vi-vn
+---
+
+Do JSON là một ngôn ngữ trao đổi dữ liệu hết sức đơn giản, đây có thể sẽ là bài
+đơn giản nhất của Học X trong Y phút (Learn X in Y Minutes) từ trước tới nay.
+
+JSON ở dạng thuần túy nhất không có chú thích cho câu lệnh (comment) nào, nhưng
+hầu hết các trình phân tích cú pháp (parser) đều chấp nhận chú thích theo phong
+cách của ngôn ngữ C (`//`, `/* */`). Một số trình phân tích cú pháp còn chấp
+nhận dấu phẩy cuối cùng (vd: một dấu phẩy sau phần tử cuối cùng của một mảng
+hoặc sau thuộc tính cuối cùng của một object), nhưng những trường hợp này nên
+tránh để có sự tương thích tốt hơn.
+
+Để phục vụ cho mục đích bài học này, tất cả cú pháp JSON ở đây sẽ đều là 100% hợp lệ.
+May mắn thay, chúng cũng tự trình bày cho chính mình mà không cần thêm giải thích.
+
+Các kiểu dữ liệu được JSON hỗ trợ bao gồm: số (*numbers*), chuỗi kí tự
+(*string*), toán tử đúng/sai (*boolean*), mảng (*array*), *object* và *null*.
+Các trình duyệt hỗ trợ bao gồm: Mozilla Firefox phiên bản 3.5 trở lên,
+Internet Explorer 8 trở lên, Google Chrome, Opera 10 trở lên, Safari 4 trở lên.
+Kiểu tệp JSON có dạng ".json". Kiểu MIME (Multipurpose Internet Mail Extensions)
+cho JSON là "application/json". Điểm yếu của JSON đó là thiếu các định dạng cho
+kiểu dữ liệu cũng như quy chuẩn cú pháp chặt chẽ sử dụng DTD.
+
+```json
+{
+  "khóa": "dữ liệu",
+
+  "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ự\"."
+  "có đúng không?": true,
+  "không có gì": null,
+
+  "số rất lớn": 1.2e+100,
+
+  "objects": {
+    "chú thích": "Hầu hết các cấu trúc dữ liệu bạn sẽ dùng sẽ sử dụng object.",
+
+    "mảng": [0, 1, 2, 3, "Mảng có thể chứa bất kì thứ gì bên trong.", 5],
+
+    "một object khác": {
+      "chú thích": "Những thứ này có thể lồng vào nhau, rất tiện."
+    }
+  },
+
+  "ngớ ngẩn": [
+    {
+      "nguồn cung cấp kali": ["chuối"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+
+  "phong cách khác": {
+    "chú thích": "kiểm tra cái này xem!"
+  , "vị trí dấu phẩy": "không quan trọng - chỉ cần nó ở trước khóa tiếp theo là được"
+  , "chú thích khác": "tiện phải không"
+  },
+
+  "nó rất ngắn": "Và bạn đã xong rồi đấy. Bạn đã biết tất cả những thứ mà JSON có thể cung cấp."
+}
+```
diff --git a/vi-vn/objective-c-vi.html.markdown b/vi-vn/objective-c-vi.html.markdown
index c97bb560..38e418e9 100644
--- a/vi-vn/objective-c-vi.html.markdown
+++ b/vi-vn/objective-c-vi.html.markdown
@@ -12,7 +12,7 @@ filename: LearnObjectiveC-vi.m
 Objective-C là ngôn ngữ lập trình chính được sử dụng bởi Apple cho các hệ điều hành OS X, iOS và các framework tương ứng của họ, Cocoa và Cocoa Touch.

 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

+```objective-c

 // Chú thích dòng đơn bắt đầu với //

 

 /*

diff --git a/vi-vn/ruby-vi.html.markdown b/vi-vn/ruby-vi.html.markdown
new file mode 100644
index 00000000..73382100
--- /dev/null
+++ b/vi-vn/ruby-vi.html.markdown
@@ -0,0 +1,549 @@
+---
+language: ruby
+filename: learnruby.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Vinh Nguyen", "http://rubydaily.net"]
+lang: vi-vn
+
+---
+
+```ruby
+# Đây là một comment
+
+=begin
+Đây là một comment nhiều dòng
+Không ai dùng cách này
+Bạn không nên dùng
+=end
+
+# Đầu tiên và quan trọng nhất: Mọi thứ là đối tượng.
+
+# Các con số là các đối tượng.
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Một vài bài toán số học căn bản
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+
+# Số học vừa là các cú pháp  thân thiện cho việc gọi
+# một hàm trên một đối tượng
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Các giá trị đặc biệt là các đối tượng
+nil # Ở đây không có gì để xem
+true # luôn đúng
+false # luôn sai
+
+nil.class #=> Lớp Nil
+true.class #=> Lớp True
+false.class #=> Lớp False
+
+# So sánh bằng
+1 == 1 #=> true
+2 == 1 #=> false
+
+# So sánh không bằng
+1 != 1 #=> false
+2 != 1 #=> true
+
+# Ngoài chính false, thì nil là một giá trị khác của false
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Các loại so sánh khác
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Các toán tử logic
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+
+# Có các cách khác của các toán tử logic với mức thấp hơn
+# Chúng được sử dụng như các cấu trúc điều khiển luồng nối các mệnh đề
+# với nhau cho đến khi một trong số chúng trả về đúng hoặc sai.
+
+# `do_something_else` chỉ được gọi nếu như hàm  `do_something` thành công.
+do_something() and do_something_else()
+# `log_error` chỉ được gọi nếu hàm `do_something` không thành công.
+do_something() or log_error()
+
+
+# Các chuỗi là các đối tượng
+
+'I am a string'.class #=> String
+"I am a string too".class #=> String
+
+placeholder = 'use string interpolation'
+"I can #{placeholder} when using double quoted strings"
+#=> "I can use string interpolation when using double quoted strings"
+
+# Nên đưa các chuỗi vào trong dấu nháy đơn
+# Ngoài ra dấu nháy kép được sử dụng trong tính toán.
+
+# Nối các chuỗi, nhưng không nối với các số.
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+
+# Xuất ra ngoài màn hình
+puts "I'm printing!"
+
+# Các biến
+x = 25 #=> 25
+x #=> 25
+
+# Chú ý về việc gán các giá trị được trả về vào biến.
+# Điều này có nghĩa là bạn có thể gán nhiều biến.
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Theo quy ước, dùng snake_case cho các tên của biến.
+snake_case = true
+
+# Dùng để mô tả tên các biến
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+
+# Ký tự (là các đối tượng)
+# Các ký tự là bất biến, như các biến hằng số chỉ đến các số nguyên.
+# Chúng thường xuyên được sử dụng thay cho các chuỗi để chuyển đổi các giá
+# trị hiệu quả.
+
+:pending.class #=> Symbol
+
+status = :pending
+
+status == :pending #=> true
+
+status == 'pending' #=> false
+
+status == :approved #=> false
+
+# Các mảng
+
+# Đây là một mảng
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Các mảng có thể chứa nhiều phần tử khác nhau
+
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Có thể truy cập các giá trị của mảng thông qua các chỉ mục
+array[0] #=> 1
+array[12] #=> nil
+
+# Giống như số học, sử dụng [biến] là một cú pháp thông dụng
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Lấy phần tử cuối cùng
+array[-1] #=> 5
+
+# Bắt đầu từ chỉ mục và số phần tử cần lấy
+array[2, 3] #=> [3, 4, 5]
+
+# Đảo ngược một mảng
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Lấy một khoảng
+array[1..3] #=> [2, 3, 4]
+
+# Thêm phần tử vào mảng bằng cách này
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# Hoặc cách này
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Kiểm tra phần tử có tồn tại trong mảng
+array.include?(1) #=> true
+
+# Băm là phần chính của Ruby với các cặp khoá/giá trị
+# Băm được biểu thị bằng dấu ngoặc nhọn:
+hash = { 'color' => 'green', 'number' => 5 }
+
+hash.keys #=> ['color', 'number']
+
+# Băm có thể được truy cập nhanh chóng thông qua khoá
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+
+# Khoá không tồn tại sẽ trả về nil
+hash['nothing here'] #=> nil
+
+# Kể từ Ruby bản 1.9, đây là một cú pháp đặc biệt, sử dụng symbol như khoá
+
+new_hash = { defcon: 3, action: true }
+
+new_hash.keys #=> [:defcon, :action]
+
+# Kiểm tra khoá hoặc giá trị có tồn tại hay không
+new_hash.has_key?(:defcon) #=> true
+new_hash.has_value?(3) #=> true
+
+# Mẹo: Cả Mảng và Băm đều là Enumberable
+# Chúng cùng chia sẻ rất nhiều phương thức hữu ích như each, map, count...
+
+# Cấu trúc điều khiển
+
+if true
+  'if statement'
+elsif false
+  'else if, optional'
+else
+  'else, also optional'
+end
+
+for counter in 1..5
+  puts "iteration #{counter}"
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+# TUY NHIÊN, không ai sử dụng vòng lặp  for.
+# Thay vào đó, ban nên dùng phương thức "each" và truyền vào đó một khối.
+# Một khối là một loạt các mã mà bạn có thể truyền
+# cho một phương thức giống như each.
+# Nó tương tự với lambda,  các hàm ẩn danh hoặc closures trong các ngôn ngữ
+# lập trình khác.
+#
+# Phương thức "each" cho một khoản sẽ chạy qua từng phần tử của khoảng đó.
+# Khối được truyền vào là một số đếm như là tham số.
+# Gọi một method "each" với một khối sẽ trông như thế này:
+
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+# Bạn cũng có thể bao khối trong các dấu ngoặc nhọn.
+(1..5).each { |counter| puts "iteration #{counter}" }
+
+# Các nội dung của cấu trúc dữ liệu cũng có thể được lặp bằng each.
+array.each do |element|
+  puts "#{element} is part of the array"
+end
+hash.each do |key, value|
+  puts "#{key} is #{value}"
+end
+
+counter = 1
+while counter <= 5 do
+  puts "iteration #{counter}"
+  counter += 1
+end
+#=> iteration 1
+#=> iteration 2
+#=> iteration 3
+#=> iteration 4
+#=> iteration 5
+
+grade = 'B'
+
+case grade
+when 'A'
+  puts 'Way to go kiddo'
+when 'B'
+  puts 'Better luck next time'
+when 'C'
+  puts 'You can do better'
+when 'D'
+  puts 'Scraping through'
+when 'F'
+  puts 'You failed!'
+else
+  puts 'Alternative grading system, eh?'
+end
+#=> "Better luck next time"
+
+# Cases cũng được dùng cho các dãy
+grade = 82
+case grade
+when 90..100
+  puts 'Hooray!'
+when 80...90
+  puts 'OK job'
+else
+  puts 'You failed!'
+end
+#=> "OK job"
+
+# Xử lý ngoại lệ:
+begin
+  # Code ở đây có thể sẽ đưa ra một ngoại lệ.
+  raise NoMemoryError, 'You ran out of memory.'
+rescue NoMemoryError => exception_variable
+  puts 'NoMemoryError was raised', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'RuntimeError was raised now'
+else
+  puts 'This runs if no exceptions were thrown at all'
+ensure
+  puts 'This code always runs no matter what'
+end
+
+# Hàm
+
+def double(x)
+  x * 2
+end
+
+# Hàm (và tất cả các khối) được mặc định giá trị trả về ở mệnh đề cuối.
+double(2) #=> 4
+
+# Dấu ngoặc là một tuỳ chọn cho một kết quả rõ ràng.
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Các đối số được chia cắt bởi dấu phẩy.
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Tất cả các hàm có thể có một tham số tuỳ chọn.
+# Nó có thể được gọi với từ khóa "yield".
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts 'hello world' }
+
+# {
+# hello world
+# }
+
+
+# Bạn có thể truyền một khối đến một hàm
+# Dấu "&" được đánh dấu đến một khối
+def guests(&block)
+  block.call 'some_argument'
+end
+
+# Bạn có thể truyền một danh sách các tham số, nó sẽ được chuyển thành mảng.
+# Thông qua việc sử dụng dấu *.
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Định nghĩ một lớp thông qua từ khoá class.
+class Human
+
+  # Một biến class. Nó được chia sẽ cho tất cả các instance của lớp này.
+  @@species = 'H. sapiens'
+
+  # Các khởi tạo căn bản
+  def initialize(name, age = 0)
+    # Gán đối số đến biến instance "name"
+    @name = name
+    # Nếu không có age, sẽ lấy giá trị mặc định trong danh sách đối số.
+    @age = age
+  end
+
+  # Hàm nhập giá trị căn bản
+  def name=(name)
+    @name = name
+  end
+
+  # Hàm lấy giá trị căn bản
+  def name
+    @name
+  end
+
+  # Các hàm trên có thể được gọn lại bằng cách dùng hàm attr_accessor
+  attr_accessor :name
+
+  # Các hàm nhận/lấy cũng có thể được tạo riêng như sau:
+  attr_reader :name
+  attr_writer :name
+
+  # Một hàm lớp dùng self để phân biệt với hàm instance.
+  # Nó chỉ có thể được gọi trên lớp.
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# Khởi tạo một lớp
+jim = Human.new('Jim Halpert')
+
+dwight = Human.new('Dwight K. Schrute')
+
+# Hãy gọi một cặp các hàm.
+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"
+
+# Gọi một hàm lớp
+Human.say('Hi') #=> "Hi"
+
+# Phạm vi của biến được định nghĩa bởi cách chúng ta đặt tên cho chúng.
+# Các biến bắt đầu với dấu $ là biến toàn cục.
+$var = "I'm a global var"
+defined? $var #=> "global-variable"
+
+# Các biến bắt đầu với dấu @ là biến phạm vi.
+@var = "I'm an instance var"
+defined? @var #=> "instance-variable"
+
+# Các biến bắt đầu với dấu @@ có pham vi là trong một lớp.
+@@var = "I'm a class var"
+defined? @@var #=> "class variable"
+
+# Các biến bắt đầu với ký tự viết hoa là biến hằng.
+Var = "I'm a constant"
+defined? Var #=> "constant"
+
+# Lớp cũng là một đối tượng trong Ruby. Bởi vậy lớp có các biến instance.
+# Biến lớp được chia sẽ trong lớp và các lớp kế thừa nó.
+
+# Lớp cơ sở
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Lớp kế thừa
+class Worker < Human
+end
+
+Human.foo # 0
+Worker.foo # 0
+
+Human.foo = 2 # 2
+Worker.foo # 2
+
+# Các biến lớp instance không được chia sẽ trong lớp kế thừa.
+
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+Human.bar # 0
+Doctor.bar # nil
+
+module ModuleExample
+  def foo
+    'foo'
+  end
+end
+
+# Include một module sẽ đưa các hàm của module thành instances của lớp.
+# Extend một module sẽ đưa các hàm của module thành các biến của lớp.
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => NoMethodError: undefined method `foo'
+
+# Hàm hồi quy được thực hiện khi include và extend một module.
+
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     # => 'bar'
+Something.qux     # => NoMethodError: undefined method `qux'
+Something.new.bar # => NoMethodError: undefined method `bar'
+Something.new.qux # => 'qux'
+```
+
+## Các nguồn tham khảo thêm.
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
+- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
diff --git a/visualbasic.html.markdown b/visualbasic.html.markdown
index 00d61843..bdfdcc10 100644
--- a/visualbasic.html.markdown
+++ b/visualbasic.html.markdown
@@ -17,7 +17,7 @@ Module Module1
         ' This navigation system is explained however as we go deeper into this
         ' tutorial, you'll understand what it all means.
         Console.Title = ("Learn X in Y Minutes")
-        Console.WriteLine("NAVIGATION") 'Display 
+        Console.WriteLine("NAVIGATION") 'Display
         Console.WriteLine("")
         Console.ForegroundColor = ConsoleColor.Green
         Console.WriteLine("1. Hello World Output")
@@ -39,13 +39,13 @@ Module Module1
             Case "2" 'Hello Input
                 Console.Clear()
                 HelloWorldInput()
-            Case "3" 'Calculating Whole Numbers 
+            Case "3" 'Calculating Whole Numbers
                 Console.Clear()
                 CalculatingWholeNumbers()
-            Case "4" 'Calculting Decimal Numbers 
+            Case "4" 'Calculting Decimal Numbers
                 Console.Clear()
                 CalculatingDecimalNumbers()
-            Case "5" 'Working Calcculator 
+            Case "5" 'Working Calcculator
                 Console.Clear()
                 WorkingCalculator()
             Case "6" 'Using Do While Loops
@@ -74,7 +74,7 @@ Module Module1
     'One - I'm using numbers to help with the above navigation when I come back
     'later to build it.
 
-    'We use private subs to seperate different sections of the program. 
+    'We use private subs to seperate different sections of the program.
     Private Sub HelloWorldOutput()
         'Title of Console Application
         Console.Title = "Hello World Ouput | Learn X in Y Minutes"
@@ -172,7 +172,7 @@ Module Module1
         'program more than once.
         Console.Title = "UsingDoWhileLoops | Learn X in Y Minutes"
         Dim answer As String 'We use the variable "String" as the answer is text
-        Do 'We start the program with 
+        Do 'We start the program with
             Console.Write("First number: ")
             Dim a As Double = Console.ReadLine
             Console.Write("Second number: ")
@@ -192,7 +192,7 @@ Module Module1
             Console.WriteLine(" = " + f.ToString.PadLeft(3))
             Console.ReadLine()
             'Ask the question, does the user wish to continue? Unfortunately it
-            'is case sensitive. 
+            'is case sensitive.
             Console.Write("Would you like to continue? (yes / no)")
             'The program grabs the variable and prints and starts again.
             answer = Console.ReadLine
@@ -208,8 +208,8 @@ Module Module1
 
         Console.Title = "Using For Loops | Learn X in Y Minutes"
         'Declare Variable and what number it should count down in Step -1,
-        'Step -2, Step -3 ect. 
-        For i As Integer = 10 To 0 Step -1 
+        'Step -2, Step -3 ect.
+        For i As Integer = 10 To 0 Step -1
             Console.WriteLine(i.ToString) 'Print the value of the counter
         Next i 'Calculate new value
         Console.WriteLine("Start") 'Lets start the program baby!!
@@ -236,7 +236,7 @@ Module Module1
     'Nine
     Private Sub IfElseStatement()
     Console.Title = "If / Else Statement | Learn X in Y Minutes"
-        'Sometimes its important to consider more than two alternatives.
+        'Sometimes it is important to consider more than two alternatives.
         'Sometimes there are a good few others.
         'When this is the case, more than one if statement would be required.
         'An if statement is great for vending machines. Where the user enters a code.
@@ -274,8 +274,8 @@ End Module
 
 ## References
 
-I learnt Visual Basic in the console application. It allowed me to understand the principles of computer programming to go on to learn other programming languages easily. 
+I learnt Visual Basic in the console application. It allowed me to understand the principles of computer programming to go on to learn other programming languages easily.
 
-I created a more indepth <a href="http://www.vbbootcamp.co.uk/" Title="Visual Basic Tutorial">Visual Basic tutorial</a> for those who would like to learn more. 
+I created a more indepth <a href="http://www.vbbootcamp.co.uk/" Title="Visual Basic Tutorial">Visual Basic tutorial</a> for those who would like to learn more.
 
-The entire syntax is valid. Copy the and paste in to the Visual Basic compiler and run (F5) the program. 
+The entire syntax is valid. Copy the and paste in to the Visual Basic compiler and run (F5) the program.
diff --git a/whip.html.markdown b/whip.html.markdown
index 3faee98a..61c301a5 100644
--- a/whip.html.markdown
+++ b/whip.html.markdown
@@ -2,6 +2,7 @@
 language: whip
 contributors:
   - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
 author: Tenor Biel
 author_url: http://github.com/L8D
 filename: whip.lisp
@@ -93,13 +94,13 @@ null ; used to indicate a deliberate non-value
 undefined ; user to indicate a value that hasn't been set
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; 2. Vairbles, Lists, and Dicts
+; 2. Variables, Lists, and Dicts
 
 ; Variables are declared with the `def` or `let` functions.
 ; Variables that haven't been set will be `undefined`.
 (def some_var 5)
 ; `def` will keep the variable in the global context.
-; `let` will only have the variable inside its context, and has a wierder syntax.
+; `let` will only have the variable inside its context, and has a weirder syntax.
 (let ((a_var 5)) (+ a_var 5)) ; => 10
 (+ a_var 5) ; = undefined + 5 => undefined
 
@@ -163,7 +164,7 @@ undefined ; user to indicate a value that hasn't been set
 
 (my_function 10 10) ; = (+ (+ 10 10) 10) => 30
 
-; Obiously, all lambdas by definition are anonymous and
+; Obviously, all lambdas by definition are anonymous and
 ; technically always used anonymously. Redundancy.
 ((lambda (x) x) 10) ; => 10
 
@@ -191,7 +192,7 @@ undefined ; user to indicate a value that hasn't been set
 (slice (.. 1 5) 2) ; => (3 4 5)
 (\ (.. 0 100) -5) ; => (96 97 98 99 100)
 
-; `append` or `<<` is self expanatory
+; `append` or `<<` is self explanatory
 (append 4 (1 2 3)) ; => (1 2 3 4)
 (<< "bar" ("foo")) ; => ("foo" "bar")
 
diff --git a/xml.html.markdown b/xml.html.markdown
index 059ea132..b95d6088 100644
--- a/xml.html.markdown
+++ b/xml.html.markdown
@@ -3,11 +3,12 @@ language: xml
 filename: learnxml.xml
 contributors:
   - ["João Farias", "https://github.com/JoaoGFarias"]
+  - ["Rachel Stiyer", "https://github.com/rstiyer"]
 ---
 
 XML is a markup language designed to store and transport data.
 
-Unlike HTML, XML does not specify how to display or to format data, just carry it.
+Unlike HTML, XML does not specify how to display or to format data, it just carries it.
 
 * XML Syntax
 
@@ -38,15 +39,16 @@ Unlike HTML, XML does not specify how to display or to format data, just carry i
 
 <!-- Above is a typical XML file.
   It starts with a declaration, informing some metadata (optional).
-  
+
   XML uses a tree structure. Above, the root node is 'bookstore', which has
-  three child nodes, all 'books'. Those nodes has more child nodes, and so on... 
-  
-  Nodes are created using open/close tags, and childs are just nodes between
+  three child nodes, all 'books'. Those nodes have more child nodes (or
+  children), and so on...
+
+  Nodes are created using open/close tags, and children are just nodes between
   the open and close tags.-->
 
 
-<!-- XML carries two kind of data:
+<!-- XML carries two kinds of data:
   1 - Attributes -> That's metadata about a node.
       Usually, the XML parser uses this information to store the data properly.
       It is characterized by appearing with the format name="value" within the opening
@@ -54,8 +56,8 @@ Unlike HTML, XML does not specify how to display or to format data, just carry i
   2 - Elements -> That's pure data.
       That's what the parser will retrieve from the XML file.
       Elements appear between the open and close tags. -->
-      
-  
+
+
 <!-- Below, an element with two attributes -->
 <file type="gif" id="4293">computer.gif</file>
 
@@ -64,25 +66,25 @@ Unlike HTML, XML does not specify how to display or to format data, just carry i
 
 * Well-Formated Document x Validation
 
-A XML document is well-formated if it is syntactically correct.
+An XML document is well-formatted if it is syntactically correct.
 However, it is possible to inject more constraints in the document,
 using document definitions, such as DTD and  XML Schema.
 
-A XML document which follows a document definition is called valid, 
-regarding that document. 
+An XML document which follows a document definition is called valid,
+in regards to that document.
 
 With this tool, you can check the XML data outside the application logic.
 
 ```xml
 
-<!-- Below, you can see an simplified version of bookstore document, 
+<!-- Below, you can see an simplified version of bookstore document,
   with the addition of DTD definition.-->
 
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE note SYSTEM "Bookstore.dtd">
 <bookstore>
   <book category="COOKING">
-    <title >Everyday Italian</title>
+    <title>Everyday Italian</title>
     <price>30.00</price>
   </book>
 </bookstore>
@@ -120,7 +122,7 @@ With this tool, you can check the XML data outside the application logic.
 
 <bookstore>
   <book category="COOKING">
-    <title >Everyday Italian</title>
+    <title>Everyday Italian</title>
     <price>30.00</price>
   </book>
 </bookstore>
diff --git a/zfs.html.markdown b/zfs.html.markdown
new file mode 100644
index 00000000..74487e35
--- /dev/null
+++ b/zfs.html.markdown
@@ -0,0 +1,400 @@
+---
+category: tool
+tool: zfs
+contributors:
+    - ["sarlalian", "http://github.com/sarlalian"]
+filename: LearnZfs.txt
+---
+
+
+[ZFS](http://open-zfs.org/wiki/Main_Page)
+is a rethinking of the storage stack, combining traditional file systems as well as volume
+managers into one cohesive tool.  ZFS has some specific teminology that sets it appart from
+more traditional storage systems, however it has a great set of features with a focus on
+usability for systems administrators.
+
+
+## ZFS Concepts
+
+### Virtual Devices
+
+A VDEV is similar to a raid device presented by a RAID card, there are several different
+types of VDEV's that offer various advantages, including redundancy and speed.  In general
+VDEV's offer better reliability and safety than a RAID card.  It is discouraged to use a
+RAID setup with ZFS, as ZFS expects to directly manage the underlying disks.
+
+Types of VDEV's 
+* stripe (a single disk, no redundancy)
+* mirror (n-way mirrors supported)
+* raidz
+	* raidz1 (1-disk parity, similar to RAID 5)
+	* raidz2 (2-disk parity, similar to RAID 6)
+	* raidz3 (3-disk parity, no RAID analog)
+* disk
+* file (not recommended for production due to another filesystem adding unnecessary layering)
+
+Your data is striped across all the VDEV's present in your Storage Pool, so more VDEV's will
+increase your IOPS.
+
+### Storage Pools
+
+ZFS uses Storage Pools as an abstraction over the lower level storage provider (VDEV), allow
+you to separate the user visable file system from the physcal layout.
+
+### ZFS Dataset
+
+ZFS datasets are analagous to traditional filesystems but with many more features.  They
+provide many of ZFS's advantages.  Datasets support [Copy on Write](https://en.wikipedia.org/wiki/Copy-on-write)
+snapshots, quota's, compression and deduplication.
+
+
+### Limits
+
+One directory may contain up to 2^48 files, up to 16 exabytes each.  A single storage pool
+can contain up to 256 zettabytes (2^78) of space, and can be striped across 2^64 devices.  A
+single host can have 2^64 storage pools.  The limits are huge.
+
+
+## Commands
+
+### Storage Pools
+
+Actions:
+* List
+* Status
+* Destroy
+* Get/Set properties
+
+List zpools
+
+```bash
+# Create a raidz zpool 
+$ zpool create bucket raidz1 gpt/zfs0 gpt/zfs1 gpt/zfs2
+
+# List ZPools
+$ zpool list
+NAME    SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP  HEALTH  ALTROOT
+zroot   141G   106G  35.2G         -    43%    75%  1.00x  ONLINE  -
+
+# List detailed information about a specific zpool
+$ zpool list -v zroot
+NAME                                     SIZE  ALLOC   FREE  EXPANDSZ   FRAG    CAP  DEDUP HEALTH  ALTROOT
+zroot                                    141G   106G  35.2G         -    43%    75%  1.00x ONLINE  -
+  gptid/c92a5ccf-a5bb-11e4-a77d-001b2172c655   141G   106G  35.2G         -    43%    75%
+```
+
+Status of zpools
+
+```bash
+# Get status information about zpools
+$ 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
+
+# Scrubbing a zpool to correct any 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
+```
+
+Properties of zpools
+
+```bash
+
+# Getting properties from the pool properties can be user set or system provided.
+$ zpool get all zroot
+NAME   PROPERTY                       VALUE                          SOURCE
+zroot  size                           141G                           -
+zroot  capacity                       75%                            -
+zroot  altroot                        -                              default
+zroot  health                         ONLINE                         -
+...
+
+# Setting a zpool property
+$ zpool set comment="Storage of mah stuff" zroot
+$ zpool get comment
+NAME   PROPERTY  VALUE                 SOURCE
+tank   comment   -                     default
+zroot  comment   Storage of mah stuff  local
+```
+
+Remove zpool
+
+```bash
+$ zpool destroy test
+```
+
+
+### Datasets
+
+Actions:
+* Create
+* List
+* Rename
+* Delete
+* Get/Set properties
+
+Create datasets
+
+```bash
+# Create dataset
+$ zfs create tank/root/data
+$ mount | grep data
+tank/root/data on /data (zfs, local, nfsv4acls)
+
+# Create child dataset
+$ zfs create tank/root/data/stuff
+$ mount | grep data
+tank/root/data on /data (zfs, local, nfsv4acls)
+tank/root/data/stuff on /data/stuff (zfs, local, nfsv4acls)
+
+
+# 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  -
+```
+
+List datasets
+
+```bash
+# List all datasets
+$ 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
+...
+
+# List a specific dataset
+$ zfs list zroot/home
+NAME         USED  AVAIL  REFER  MOUNTPOINT
+zroot/home   288K  30.8G   144K  none
+
+# List snapshots
+$ zfs list -t snapshot
+zroot@daily-2015-10-15                                                                  0      -   144K  -
+zroot/ROOT@daily-2015-10-15                                                             0      -   144K  -
+zroot/ROOT/default@daily-2015-10-15                                                     0      -  24.2G  -
+zroot/tmp@daily-2015-10-15                                                           124K      -   708M  -
+zroot/usr@daily-2015-10-15                                                              0      -   144K  -
+zroot/home@daily-2015-10-15                                                             0      -  11.9G  -
+zroot/var@daily-2015-10-15                                                           704K      -  1.42G  -
+zroot/var/log@daily-2015-10-15                                                       192K      -   828K  -
+zroot/var/tmp@daily-2015-10-15                                                          0      -   152K  -
+```
+
+Rename datasets
+
+```bash
+$ zfs rename tank/root/home tank/root/old_home
+$ zfs rename tank/root/new_home tank/root/home
+```
+
+Delete dataset
+
+```bash
+# Datasets cannot be deleted if they have any snapshots
+zfs destroy tank/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
+zroot/home      mounted               yes                    -
+...
+
+# Get property from dataset
+$ zfs get compression zroot/usr/home
+NAME            PROPERTY     VALUE     SOURCE
+zroot/home      compression  off       default
+
+# Set property on dataset
+$ zfs set compression=gzip-9 mypool/lamb
+
+# Get a set of properties from all datasets
+$ zfs list -o name,quota,reservation
+NAME                                                               QUOTA  RESERV
+zroot                                                               none    none
+zroot/ROOT                                                          none    none
+zroot/ROOT/default                                                  none    none
+zroot/tmp                                                           none    none
+zroot/usr                                                           none    none
+zroot/home                                                          none    none
+zroot/var                                                           none    none
+...
+```
+
+
+### Snapshots
+
+ZFS snapshots are one of the things about zfs that are a really big deal
+
+* The space they take up is equal to the difference in data between the filesystem and its snapshot
+* Creation time is only seconds
+* Recovery is as fast as you can write data.
+* They are easy to automate.
+
+Actions:
+* Create
+* Delete
+* Rename
+* Access snapshots
+* Send / Receive
+* Clone
+
+
+Create snapshots
+
+```bash
+# Create a snapshot of a single dataset
+zfs snapshot tank/home/sarlalian@now
+
+# Create a snapshot of a dataset and its children
+$ zfs snapshot -r tank/home@now
+$ zfs list -t snapshot
+NAME                       USED  AVAIL  REFER  MOUNTPOINT
+tank/home@now                 0      -    26K  -
+tank/home/sarlalian@now       0      -   259M  -
+tank/home/alice@now           0      -   156M  -
+tank/home/bob@now             0      -   156M  -
+...
+
+Destroy snapshots
+
+```bash
+# How to destroy a snapshot
+$ zfs destroy tank/home/sarlalian@now
+
+# Delete a snapshot on a parent dataset and its children
+$ zfs destroy -r tank/home/sarlalian@now
+
+```
+
+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 -r tank/home@now @yesterday
+```
+
+Accessing snapshots
+
+```bash
+# CD Into a snapshot directory
+$ cd /home/.zfs/snapshot/
+```
+
+Sending and Receiving
+
+```bash
+# Backup a snapshot to a file
+$ zfs send tank/home/sarlalian@now | gzip > backup_file.gz
+
+# Send a snapshot to another dataset
+$ zfs send tank/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'
+
+# Send full dataset with snapshos to new host
+$ zfs send -v -R tank/home@now | ssh root@backup_server 'zfs recv tank/home'
+```
+
+Cloneing Snapshots
+
+```bash
+# Clone a snapshot
+$ zfs clone tank/home/sarlalian@now tank/home/sarlalian_new
+
+# Promoting the clone so it is no longer dependent on the snapshot
+$ zfs promote tank/home/sarlalian_new
+```
+
+### Putting it all together
+
+This following a script utilizing FreeBSD, jails and ZFS to automate 
+provisioning a clean copy of a mysql staging database from a live replication
+slave.
+
+```bash
+#!/bin/sh
+
+echo "==== Stopping the staging database server ===="
+jail -r staging
+
+echo "==== Cleaning up existing staging server and snapshot ===="
+zfs destroy -r zroot/jails/staging
+zfs destroy zroot/jails/slave@staging
+
+echo "==== Quiescing the slave database ===="
+echo "FLUSH TABLES WITH READ LOCK;" | /usr/local/bin/mysql -u root -pmyrootpassword -h slave
+
+echo "==== Snapshotting the slave db filesystem as zroot/jails/slave@staging ===="
+zfs snapshot zroot/jails/slave@staging
+
+echo "==== Starting the slave database server ===="
+jail -c slave
+
+echo "==== Cloning the slave snapshot to the staging server ===="
+zfs clone zroot/jails/slave@staging zroot/jails/staging
+
+echo "==== Installing the staging mysql config ===="
+mv /jails/staging/usr/local/etc/my.cnf /jails/staging/usr/local/etc/my.cnf.slave
+cp /jails/staging/usr/local/etc/my.cnf.staging /jails/staging/usr/local/etc/my.cnf
+
+echo "==== Setting up the staging rc.conf file ===="
+mv /jails/staging/etc/rc.conf.local /jails/staging/etc/rc.conf.slave
+mv /jails/staging/etc/rc.conf.staging /jails/staging/etc/rc.conf.local
+
+echo "==== Starting the staging db server ===="
+jail -c staging
+
+echo "==== Make sthe staging database not pull from the master ===="
+echo "STOP SLAVE;" | /usr/local/bin/mysql -u root -pmyrootpassword -h staging
+echo "RESET SLAVE;" | /usr/local/bin/mysql -u root -pmyrootpassword -h staging
+```
+
+
+### Additional Reading
+
+* [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
+* [FreeBSD Handbook on ZFS](https://wiki.freebsd.org/ZF://wiki.freebsd.org/ZFS)
+* [BSDNow's Crash Course on ZFS](http://www.bsdnow.tv/tutorials/zfs)
+* [Oracle's Tuning Guide](http://www.oracle.com/technetwork/articles/servers-storage-admin/sto-recommended-zfs-settings-1951715.html)
+* [OpenZFS Tuning Guide](http://open-zfs.org/wiki/Performance_tuning)
+* [FreeBSD ZFS Tuning Guide](https://wiki.freebsd.org/ZFSTuningGuide)
diff --git a/zh-cn/csharp-cn.html.markdown b/zh-cn/csharp-cn.html.markdown
index a3cda5b3..971c1be9 100644
--- a/zh-cn/csharp-cn.html.markdown
+++ b/zh-cn/csharp-cn.html.markdown
@@ -232,7 +232,8 @@ on a new line! ""Wow!"", the masses cried";
             // 三元表达式
             // 简单的 if/else 语句可以写成：
             // <条件> ? <真> : <假>
-            string isTrue = (true) ? "True" : "False";
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
 
             // While 循环
             int fooWhile = 0;
diff --git a/zh-cn/javascript-cn.html.markdown b/zh-cn/javascript-cn.html.markdown
index dfeb2012..bdef0099 100644
--- a/zh-cn/javascript-cn.html.markdown
+++ b/zh-cn/javascript-cn.html.markdown
@@ -447,9 +447,6 @@ myNumber === myNumberObj; // = false
 if (0){
     // 这段代码不会执行，因为0代表假
 }
-if (Number(0)){
-    // 这段代码*会*执行，因为Number(0)代表真
-}
 
 // 不过，包装类型和内置类型共享一个原型，
 // 所以你实际可以给内置类型也增加一些功能，例如对string：