Merge remote-tracking branch 'refs/remotes/adambard/master'

Conflicts:
	c.html.markdown

52 files changed, 5048 insertions, 510 deletions

diff --git a/README.markdown b/README.markdown
index 774797d5..28fa5093 100644
--- a/README.markdown
+++ b/README.markdown
@@ -8,7 +8,7 @@ commented code and explained as they go.
 
 ... to write more inline code tutorials. Just grab an existing file from
 this repo and copy the formatting (don't worry, it's all very simple).
-Make a new file, send a pull request, and if it passes muster I'll get it up pronto.
+Make a new file, send a pull request, and if it passes master I'll get it up pronto.
 Remember to fill in the "contributors" fields so you get credited
 properly!
 
diff --git a/bash.html.markdown b/bash.html.markdown
index 191f916a..211d2944 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -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
diff --git a/c++.html.markdown b/c++.html.markdown
index 6f4d0562..2bee51dc 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -404,6 +404,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);
diff --git a/c.html.markdown b/c.html.markdown
index 5e8e13c1..7bb363b3 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -6,7 +6,12 @@ contributors:
     - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
     - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
     - ["Marco Scannadinari", "https://marcoms.github.io"]
+<<<<<<< HEAD
     - ["Zachary Ferguson", "https://github.io/zfergus2"]
+=======
+    - ["himanshu", "https://github.com/himanshu81494"]
+
+>>>>>>> refs/remotes/adambard/master
 ---
 
 Ah, C. Still **the** language of modern high-performance computing.
@@ -27,6 +32,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 +58,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 +80,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;
@@ -221,7 +241,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;
@@ -291,6 +311,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) {
@@ -306,7 +328,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
   ///////////////////////////////////////
@@ -472,7 +516,24 @@ 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
+*/
 // if referring to external variables outside function, must use extern keyword.
 int i = 0;
 void testFunc() {
diff --git a/chapel.html.markdown b/chapel.html.markdown
index e20be998..7252a3e4 100644
--- a/chapel.html.markdown
+++ b/chapel.html.markdown
@@ -633,7 +633,7 @@ writeln( toThisArray );
 // 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.
+// 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.
 
diff --git a/coffeescript.html.markdown b/coffeescript.html.markdown
index 85a5f81f..89a29677 100644
--- a/coffeescript.html.markdown
+++ b/coffeescript.html.markdown
@@ -7,7 +7,7 @@ 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.
+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,19 +54,19 @@ 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?
@@ -75,14 +75,14 @@ alert "I knew it!" if elvis?
 # Array comprehensions:
 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..e2f0737d
--- /dev/null
+++ b/coldfusion.html.markdown
@@ -0,0 +1,321 @@
+---
+language: ColdFusion
+contributors:
+    - ["Wayne Boka", "http://wboka.github.io"]
+filename: LearnColdFusion.cfm
+---
+
+ColdFusion is a scripting language for web development.
+[Read more here.](http://www.adobe.com/products/coldfusion-family.html)
+
+```ColdFusion
+
+<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/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 02650038..7aca2c6f 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -6,6 +6,7 @@ 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"]
 filename: LearnCSharp.cs
 ---
 
@@ -159,7 +160,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;
@@ -418,12 +419,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
@@ -443,6 +480,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";
@@ -610,7 +650,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
             }
@@ -750,7 +790,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" };
 
@@ -761,7 +801,7 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             set {
-                return passengers[i] = value;
+                passengers[i] = value;
             }
         }
 
@@ -837,7 +877,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;
@@ -876,7 +917,7 @@ on a new line! ""Wow!"", the masses cried";
 ## 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)
diff --git a/css.html.markdown b/css.html.markdown
index 811767e6..d8f30ca3 100644
--- a/css.html.markdown
+++ b/css.html.markdown
@@ -5,25 +5,20 @@ contributors:
     - ["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!
@@ -33,219 +28,226 @@ 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 { }
 
-/* an element which is direct child of an element (selected the same way) */
-div.some-parent > .class-name {}
+/* You may also select an element based on its adjacent sibling */
+.i-am-just-before + .this-element { }
 
-/* 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 {}
+/* or any sibling preceding it */
+.i-am-any-element-before ~ .this-element { }
 
-/* warning: the same selector without space has another meaning.
-   can you say what? */
-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 */
 
-/* you also might choose to select an element based on its direct
-   previous sibling */
-.i-am-before + .this-element { }
+/* for example, when the cursor hovers over an element */
+selector:hover { }
 
-/* or any sibling before this */
-.i-am-any-before ~ .this-element {}
+/* or a link has been visited */
+selector:visited { }
 
-/* There are some pseudo classes that allows you to select an element
-   based on its page behaviour (rather than page structure) */
+/* or hasn't been visited */
+selected:link { }
 
-/* for example for when an element is hovered */
-selector:hover {}
+/* or an element in focus */
+selected:focus { }
 
-/* or a visited link */
-selected:visited {}
+/* any element that is the first child of its parent */
+selector:first-child {}
 
-/* or not visited link */
-selected:link {}
+/* any element that is the last child of its parent */
+selector:last-child {}
 
-/* or an input element which is focused */
-selected:focus {}
+/* Just like pseudo classes, pseudo elements allow you to style certain parts of a document  */
 
+/* matches a virtual first child of the selected element */
+selector::before {}
+
+/* matches a virtual last child of the selected element */
+selector::after {}
+
+/* At appropriate places, an asterisk may be used as a wildcard to select every
+   element */
+* { } /* all elements */
+.parent * { } /* all descendants */
+.parent > * { } /* all children */
 
 /* ####################
    ## PROPERTIES
    #################### */
 
 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) */
-
-
-    /* Images */
-    background-image: url(/path-to-image/image.jpg); /* quotes inside url() optional */
-
+    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;
-    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, [Can I Use...](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
 
-* [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)
-* [SCSS](http://sass-lang.com/) and [LESS](http://lesscss.org/) for CSS pre-processing
+* [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 ba24b60f..80c1dc65 100644
--- a/d.html.markdown
+++ b/d.html.markdown
@@ -23,8 +23,10 @@ about [D](http://dlang.org/). The D programming language is a modern, general-pu
 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
+    // 'auto' can be used for inferring types.
+    auto n = 1;
 
-    // Numeric literals can use _ as a digit seperator for clarity
+    // 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
+    // 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,13 +100,11 @@ 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)
         return b;
@@ -107,9 +112,8 @@ T max(T)(T a, T 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;
 
@@ -117,13 +121,13 @@ void swap(T)(ref T a, ref T b) {
     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,21 +137,20 @@ 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;
     }
@@ -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;
+
+    // Call the getters to fetch the values.
+    writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
 
-    mc.data = 7;
-    mc.other = "seven";
+    // Call the setters to assign new values.
+    mc.data = 8;
+    mc.other = "eight";
 
-    writeln(mc.data);
-    writeln(mc.other);
+    // Call the getters again to fetch the new values.
+    writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
 
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index 036d7082..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.
 
 ///////////////////////////////////
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/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/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/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/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 62118006..76318d7d 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -119,7 +119,7 @@ printfn "A string %s, and something generic %A" "hello" [1;2;3;4]
 // ================================================
 
 // 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
diff --git a/git.html.markdown b/git.html.markdown
index b1347309..971d53e4 100644
--- a/git.html.markdown
+++ b/git.html.markdown
@@ -5,6 +5,7 @@ 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
 ---
 
@@ -76,6 +77,11 @@ other repositories, or not!
 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.
@@ -206,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.
@@ -484,6 +512,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)
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/haml.html.markdown b/haml.html.markdown
index 847714e6..0948e9ef 100644
--- a/haml.html.markdown
+++ b/haml.html.markdown
@@ -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
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/java.html.markdown b/java.html.markdown
index ba602d2e..35ec57d8 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Simon Morgan", "http://sjm.io/"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
 filename: LearnJava.java
 ---
 
@@ -95,11 +96,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 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
@@ -114,7 +117,35 @@ public class LearnJava {
         // 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 percision 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!";
 
@@ -286,6 +317,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.
@@ -348,7 +396,7 @@ public class LearnJava {
            validCodes.add("FINLAND");
         }
 
-        // But there's a nifty way to achive the same thing in an
+        // But there's a nifty way to achieve the same thing in an
         // easier way, by using something that is called Double Brace
         // Initialization.
 
@@ -358,9 +406,9 @@ public class LearnJava {
             add("FINLAND");
         }}
 
-        // The first brace is creating an new AnonymousInnerClass and the
-        // second one declares and instance initializer block. This block
-        // is called with the anonymous inner class is created.
+        // 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.
 
@@ -368,7 +416,7 @@ public class LearnJava {
 } // 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.
 
 
@@ -389,7 +437,7 @@ class Bicycle {
     // Constructors are a way of creating classes
     // This is a constructor
     public Bicycle() {
-        // You can also call another constructor: 
+        // You can also call another constructor:
         // this(1, 50, 5, "Bontrager");
         gear = 1;
         cadence = 50;
@@ -489,6 +537,7 @@ public interface Digestible {
 
 // We can now create a class that implements both of these interfaces.
 public class Fruit implements Edible, Digestible {
+  
     @Override
     public void eat() {
         // ...
@@ -504,6 +553,7 @@ public class Fruit implements Edible, Digestible {
 // interfaces. For example:
 public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     InterfaceTwo {
+
     @Override
     public void InterfaceOneMethod() {
     }
@@ -511,6 +561,7 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     @Override
     public void InterfaceTwoMethod() {
     }
+
 }
 
 // Abstract Classes
@@ -522,10 +573,10 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 // }
 
 // 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 
+// 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, 
+// 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.
 
@@ -541,7 +592,7 @@ public abstract class Animal
         age = 30;
     }
 
-    // No need to initialize, however in an interface 
+    // No need to initialize, however in an interface
     // a variable is implicitly final and hence has
     // to be initialized.
     protected int age;
@@ -569,7 +620,7 @@ class Dog extends Animal
         // age = 30;	==> ERROR!	age is private to Animal
     }
 
-    // NOTE: You will get an error if you used the 
+    // 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.
@@ -583,7 +634,7 @@ class Dog extends Animal
     }
 }
 
-// Final Classes 
+// Final Classes
 
 // Final Class declaration syntax
 // <access-level> final <final-class-name> {
@@ -592,8 +643,8 @@ class Dog extends Animal
 // }
 
 // 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 
+// 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
 {
diff --git a/javascript.html.markdown b/javascript.html.markdown
index 754832f1..6ea0b0bb 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -218,6 +218,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";
diff --git a/json.html.markdown b/json.html.markdown
index 6aff2ce2..060e9c3d 100644
--- a/json.html.markdown
+++ b/json.html.markdown
@@ -4,14 +4,23 @@ filename: learnjson.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
 ---
 
 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.
+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.
+
+Data types supported by JSON includes: numbers, string, boolean, array, object and null.
+Supporting browsers are: Firefox(Mozilla) 3.5, Internet Explorer 8, Chrome, Opera 10, Safari 4.
+JSON file type for JSON files is ".json". The MIME type for JSON text is "application/json"
+Drawbacks of JSON include lack of type definition and some sort of DTD.
 
 ```json
 {
@@ -49,7 +58,7 @@ going to be 100% valid JSON. Luckily, it kind of speaks for itself.
 
   "alternative style": {
     "comment": "check this out!"
-  , "comma position": "doesn't matter - as long as it's before the value, then it's valid"
+  , "comma position": "doesn't matter - as long as it's before the next key, then it's valid"
   , "another comment": "how nice"
   },
 
diff --git a/julia.html.markdown b/julia.html.markdown
index 66329feb..c5089dc3 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -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).
@@ -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
diff --git a/latex.html.markdown b/latex.html.markdown
new file mode 100644
index 00000000..e180e622
--- /dev/null
+++ b/latex.html.markdown
@@ -0,0 +1,231 @@
+---
+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
+---
+% 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/matlab.html.markdown b/matlab.html.markdown
index 02fe5962..0cbc6f57 100644
--- a/matlab.html.markdown
+++ b/matlab.html.markdown
@@ -3,6 +3,7 @@ language: Matlab
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
     - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
 
 ---
 
@@ -464,6 +465,59 @@ 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/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/objective-c.html.markdown b/objective-c.html.markdown
index 89901308..cf6bf780 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -13,7 +13,7 @@ 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.
 
-```objective_c
+```objective-c
 // Single-line comments start with //
 
 /*
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 63c0830a..0f015b45 100644
--- a/perl6.html.markdown
+++ b/perl6.html.markdown
@@ -75,7 +75,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 +96,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 +106,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 +124,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);
 
@@ -162,7 +161,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 +172,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 +196,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 +233,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,
@@ -380,7 +379,9 @@ 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
+
+# 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 +526,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,27 +609,26 @@ 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 {
@@ -656,7 +656,6 @@ $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;
@@ -751,7 +750,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 +762,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 +772,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 +796,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 {
@@ -829,7 +826,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 +859,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 +867,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 +891,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 +1020,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 +1052,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
@@ -1089,7 +1089,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 +1109,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 +1221,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 +1243,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 +1286,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,7 +1329,7 @@ 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 !" }
@@ -1346,7 +1347,7 @@ 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 remove <key>
@@ -1429,7 +1430,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 +1462,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 2b1fe1dc..39ec5aef 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -693,8 +693,43 @@ use My\Namespace as SomeOtherNamespace;
 
 $cls = new SomeOtherNamespace\MyClass();
 
+/**********************
+*  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
@@ -709,4 +744,4 @@ If you're coming from a language with good package management, check out
 [Composer](http://getcomposer.org/).
 
 For common standards, visit the PHP Framework Interoperability Group's
-[PSR standards](https://github.com/php-fig/fig-standards).
\ No newline at end of file
+[PSR standards](https://github.com/php-fig/fig-standards).
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-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/python.html.markdown b/python.html.markdown
index 5572e38e..b939ebbe 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -14,7 +14,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
 
@@ -142,7 +148,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
@@ -473,9 +485,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
diff --git a/python3.html.markdown b/python3.html.markdown
index acd6187c..a1125c73 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -33,27 +33,27 @@ 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, 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**y, x to the yth power)
-2**4 # => 16
+2**4  # => 16
 
 # Enforce precedence with parentheses
 (1 + 3) * 2  # => 8
@@ -63,20 +63,20 @@ 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
@@ -98,13 +98,13 @@ False or True #=> True
 
 # (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
+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."
@@ -113,24 +113,24 @@ b == a # => True, a's and b's objects are equal
 # Strings can be added too! But try not to do this.
 "Hello " + "world!"  # => "Hello world!"
 # Strings can be added without using '+'
-"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
@@ -139,14 +139,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
 
 
 ####################################################
@@ -154,11 +154,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!
+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
@@ -185,7 +189,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
 
@@ -194,61 +198,61 @@ 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.
+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]
 
 # 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'>
+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
 # 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
@@ -259,45 +263,45 @@ 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.
+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
@@ -306,31 +310,31 @@ del filled_dict["one"]  # Removes the key "one" from filled dict
 # Sets store ... well sets
 empty_set = set()
 # Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
-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'
+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}
 
 # Check for existence in a set with in
 2 in filled_set   # => True
-10 in filled_set   # => False
+10 in filled_set  # => False
 
 
 
@@ -416,12 +420,12 @@ try:
     # Use "raise" to raise an error
     raise IndexError("This is an index error")
 except IndexError as e:
-    pass    # Pass is just a no-op. Usually you would do recovery here.
+    pass                 # Pass is just a no-op. Usually you would do recovery here.
 except (TypeError, NameError):
-    pass    # Multiple exceptions can be handled together, if required.
-else:   # Optional clause to the try/except block. Must follow all except blocks
+    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
@@ -435,11 +439,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)  # => range(1,10). 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
@@ -449,17 +453,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"]
 
 
 ####################################################
@@ -469,20 +473,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
@@ -490,7 +494,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
@@ -507,33 +511,33 @@ 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)
+    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.
+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):
     # 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):
     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)
@@ -549,25 +553,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"
@@ -606,15 +613,15 @@ 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*"
 
 
 ####################################################
@@ -627,8 +634,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
@@ -636,7 +643,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
@@ -661,8 +668,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)
@@ -697,7 +702,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 :(
 ```
 
@@ -714,6 +719,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/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/ruby.html.markdown b/ruby.html.markdown
index 8f23b2e6..0e798706 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -12,7 +12,7 @@ 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"]
 ---
 
 ```ruby
@@ -39,6 +39,7 @@ You shouldn't either
 10 * 2 #=> 20
 35 / 5 #=> 7
 2**5 #=> 32
+5 % 3 #=> 2
 
 # Arithmetic is just syntactic sugar
 # for calling a method on an object
@@ -106,8 +107,14 @@ placeholder = 'use string interpolation'
 'hello ' + 3 #=> TypeError: can't convert Fixnum into String
 'hello ' + 3.to_s #=> "hello 3"
 
-# print to the output
+# 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 +161,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,6 +172,7 @@ array.[] 12 #=> nil
 
 # From the end
 array[-1] #=> 5
+array.last #=> 5
 
 # With a start index and length
 array[2, 3] #=> [3, 4, 5]
@@ -258,6 +267,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}"
@@ -269,6 +284,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 b2854b0c..d0c56b4a 100644
--- a/rust.html.markdown
+++ b/rust.html.markdown
@@ -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/swift.html.markdown b/swift.html.markdown
index a40e86c8..f451288d 100644
--- a/swift.html.markdown
+++ b/swift.html.markdown
@@ -5,6 +5,7 @@ contributors:
   - ["Christopher Bess", "http://github.com/cbess"]
   - ["Joey Huang", "http://github.com/kamidox"]
   - ["Anthony Nguyen", "http://github.com/anthonyn60"]
+  - ["Clayton Walker", "https://github.com/cwalk"]
 filename: learnswift.swift
 ---
 
@@ -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.
@@ -79,6 +81,12 @@ if someOptionalString != nil {
 }
 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,7 +101,7 @@ 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."
 
@@ -295,7 +303,7 @@ 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]()
 
@@ -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/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/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/xml.html.markdown b/xml.html.markdown
index d407512d..efc2340f 100644
--- a/xml.html.markdown
+++ b/xml.html.markdown
@@ -7,7 +7,7 @@ contributors:
 
 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
 
@@ -40,13 +40,14 @@ Unlike HTML, XML does not specify how to display or to format data, just carry i
   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...
+  three child nodes, all 'books'. Those nodes have more child nodes (or
+  children), and so on...
 
-  Nodes are created using open/close tags, and childs are just nodes between
+  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
@@ -82,7 +83,7 @@ With this tool, you can check the XML data outside the application logic.
 <!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 +121,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>