23 files changed, 2864 insertions, 166 deletions

diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown
index 6a6df968..a1dfe9e1 100644
--- a/asymptotic-notation.html.markdown
+++ b/asymptotic-notation.html.markdown
@@ -155,7 +155,7 @@ Small-o, commonly written as **o**, is an Asymptotic Notation to denote the
 upper bound (that is not asymptotically tight) on the growth rate of runtime 
 of an algorithm.
 
-`f(n)` is o(g(n)), if for some real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is < `c g(n)` 
+`f(n)` is o(g(n)), if for all real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is < `c g(n)` 
 for every input size n (n > n<sub>0</sub>).
 
 The definitions of O-notation and o-notation are similar. The main difference 
@@ -168,7 +168,7 @@ Small-omega, commonly written as **ω**, is an Asymptotic Notation to denote
 the lower bound (that is not asymptotically tight) on the growth rate of 
 runtime of an algorithm.
 
-`f(n)` is ω(g(n)), if for some real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is > `c g(n)` 
+`f(n)` is ω(g(n)), if for all real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is > `c g(n)` 
 for every input size n (n > n<sub>0</sub>).
 
 The definitions of Ω-notation and ω-notation are similar. The main difference 
diff --git a/awk.html.markdown b/awk.html.markdown
index e3ea6318..de26c0a1 100644
--- a/awk.html.markdown
+++ b/awk.html.markdown
@@ -161,7 +161,7 @@ function arithmetic_functions(a, b, c,     d) {
     # Most AWK implementations have some standard trig functions
     localvar = sin(a)
     localvar = cos(a)
-    localvar = atan2(a, b) # arc tangent of b / a
+    localvar = atan2(b, a) # arc tangent of b / a
 
     # And logarithmic stuff
     localvar = exp(a)
diff --git a/bash.html.markdown b/bash.html.markdown
index 3f3e49eb..d1e6bf25 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -74,7 +74,7 @@ echo ${Variable/Some/A} # => A string
 
 # Substring from a variable
 Length=7
-echo ${Variable:0:Length} # => Some st
+echo ${Variable:0:$Length} # => Some st
 # This will return only the first 7 characters of the value
 
 # Default value for variable
diff --git a/c.html.markdown b/c.html.markdown
index 0c6df413..684d330a 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -101,7 +101,7 @@ int main (int argc, char** argv)
   char y_char = 'y'; // Char literals are quoted with ''
 
   // longs are often 4 to 8 bytes; long longs are guaranteed to be at least
-  // 64 bits
+  // 8 bytes
   long x_long = 0;
   long long x_long_long = 0;
 
diff --git a/chapel.html.markdown b/chapel.html.markdown
index 9190f462..354cd832 100644
--- a/chapel.html.markdown
+++ b/chapel.html.markdown
@@ -100,7 +100,7 @@ writeln(varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg);
 // be made to alias a variable other than the variable it is initialized with.
 // Here, refToActual refers to actual.
 var actual = 10;
-ref refToActual = actual; 
+ref refToActual = actual;
 writeln(actual, " == ", refToActual); // prints the same value
 actual = -123; // modify actual (which refToActual refers to)
 writeln(actual, " == ", refToActual); // prints the same value
@@ -444,7 +444,7 @@ arrayFromLoop = [value in arrayFromLoop] value + 1;
 
 // Procedures
 
-// Chapel procedures have similar syntax functions in other languages. 
+// Chapel procedures have similar syntax functions in other languages.
 proc fibonacci(n : int) : int {
   if n <= 1 then return n;
   return fibonacci(n-1) + fibonacci(n-2);
@@ -893,7 +893,6 @@ foo();
 // We can declare a main procedure, but all the code above main still gets
 // executed.
 proc main() {
-  writeln("PARALLELISM START");
 
 // A begin statement will spin the body of that statement off
 // into one new task.
@@ -1141,11 +1140,13 @@ to see if more topics have been added or more tutorials created.
 Your input, questions, and discoveries are important to the developers!
 -----------------------------------------------------------------------
 
-The Chapel language is still in-development (version 1.16.0), so there are
+The Chapel language is still in active development, so there are
 occasional hiccups with performance and language features. The more information
 you give the Chapel development team about issues you encounter or features you
-would like to see, the better the language becomes. Feel free to email the team
-and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman).
+would like to see, the better the language becomes.
+There are several ways to interact with the developers:
++ [Gitter chat](https://gitter.im/chapel-lang/chapel)
++ [sourceforge email lists](https://sourceforge.net/p/chapel/mailman)
 
 If you're really interested in the development of the compiler or contributing
 to the project, [check out the master GitHub repository](https://github.com/chapel-lang/chapel).
@@ -1154,12 +1155,14 @@ It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0)
 Installing the Compiler
 -----------------------
 
+[The Official Chapel documentation details how to download and compile the Chapel compiler.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
+
 Chapel can be built and installed on your average 'nix machine (and cygwin).
 [Download the latest release version](https://github.com/chapel-lang/chapel/releases/)
 and it's as easy as
 
- 1. `tar -xvf chapel-1.16.0.tar.gz`
- 2. `cd chapel-1.16.0`
+ 1. `tar -xvf chapel-<VERSION>.tar.gz`
+ 2. `cd chapel-<VERSION>`
  3. `source util/setchplenv.bash # or .sh or .csh or .fish`
  4. `make`
  5. `make check # optional`
diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown
index 33897225..b313727c 100644
--- a/de-de/python3-de.html.markdown
+++ b/de-de/python3-de.html.markdown
@@ -152,7 +152,7 @@ print("Ich bin Python. Schön, dich kennenzulernen!")
 some_var = 5    # kleinschreibung_mit_unterstrichen entspricht der Norm
 some_var #=> 5
 
-# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus.
+# Das Ansprechen einer noch nicht deklarierten Variable löst eine Exception aus.
 # Unter "Kontrollstruktur" kann noch mehr über
 # Ausnahmebehandlung erfahren werden.
 some_unknown_var  # Löst einen NameError aus
@@ -225,7 +225,7 @@ a, b, c = (1, 2, 3)     # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3
 # Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen
 d, e, f = 4, 5, 6
 # Es ist kinderleicht zwei Werte zu tauschen
-e, d = d, e     # d is now 5 and e is now 4
+e, d = d, e     # d ist nun 5 und e ist nun 4
 
 
 # Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare
@@ -379,8 +379,8 @@ with open("meineDatei.txt") as f:
         print(line)
 
 # Python bietet ein fundamentales Konzept der Iteration.
-# Das Objekt, auf das die Interation, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
-# Die range Method gibt ein solches Objekt aus.
+# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
+# Die range Methode gibt ein solches Objekt aus.
 
 filled_dict = {"one": 1, "two": 2, "three": 3}
 our_iterable = filled_dict.keys()
@@ -396,8 +396,8 @@ our_iterable[1]  # TypeError
 # Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft.
 our_iterator = iter(our_iterable)
 
-# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es geraden hat während wir durch es gehen.
-# Das jeweeils nächste Objekt bekommen wir mit "next()"
+# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat während wir durch es gehen.
+# Das jeweils nächste Objekt bekommen wir mit "next()"
 next(our_iterator)  #=> "one"
 
 # Es hält den vorherigen Status
@@ -442,7 +442,7 @@ def keyword_args(**kwargs):
 # Rufen wir es mal auf, um zu sehen, was passiert
 keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
 
-# Wir können beides gleichzeitig machem, wenn wir wollen
+# Wir können beides gleichzeitig machen, wenn wir wollen
 def all_the_args(*args, **kwargs):
     print(args)
     print(kwargs)
diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index 307ba817..0516ea92 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -166,7 +166,7 @@ function arithmetic_functions(a, b, c,     localvar) {
     # trigonométricas estándar
     localvar = sin(a)
     localvar = cos(a)
-    localvar = atan2(a, b) # arcotangente de b / a
+    localvar = atan2(b, a) # arcotangente de b / a
 
     # Y cosas logarítmicas
     localvar = exp(a)
diff --git a/fsharp.html.markdown b/fsharp.html.markdown
index bbf477ba..dd85552d 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -306,7 +306,7 @@ module DataTypeExamples =
 
     // ------------------------------------
     // Union types (aka variants) have a set of choices
-    // Only case can be valid at a time.
+    // Only one case can be valid at a time.
     // ------------------------------------
 
     // Use "type" with bar/pipe to define a union type
diff --git a/it-it/python3-it.html.markdown b/it-it/python3-it.html.markdown
index 06ef9a5e..04f78cff 100644
--- a/it-it/python3-it.html.markdown
+++ b/it-it/python3-it.html.markdown
@@ -400,8 +400,8 @@ else:                  # Anche else è opzionale
     print("some_var è  10.")
 
 """
-I cicli for iterano sulle liste, cioé ripetono un codice per ogni elemento 
-# di una lista.
+I cicli for iterano sulle liste, cioè ripetono un codice per ogni elemento 
+di una lista.
 Il seguente codice scriverà:
     cane è un mammifero
     gatto è un mammifero
@@ -409,7 +409,7 @@ Il seguente codice scriverà:
 """
 for animale in ["cane", "gatto", "topo"]:
     # Puoi usare format() per interpolare le stringhe formattate.
-    print("{} is a mammal".format(animal))
+    print("{} è un mammifero".format(animale))
 
 """
 "range(numero)" restituisce una lista di numeri da zero al numero dato
diff --git a/julia.html.markdown b/julia.html.markdown
index 9e28452f..047bb538 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -3,13 +3,14 @@ language: Julia
 contributors:
     - ["Leah Hanson", "http://leahhanson.us"]
     - ["Pranit Bauva", "http://github.com/pranitbauva1997"]
+    - ["Daniel YC Lin", "http://github.com/dlintw"]
 filename: learnjulia.jl
 ---
 
 Julia is a new homoiconic functional language focused on technical computing.
 While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
 
-This is based on Julia 0.4.
+This is based on Julia 0.6.4
 
 ```ruby
 
@@ -49,7 +50,7 @@ div(5, 2) # => 2 # for a truncated result, use div
 ~2 # => -3   # bitwise not
 3 & 5 # => 1 # bitwise and
 2 | 4 # => 6 # bitwise or
-2 $ 4 # => 6 # bitwise xor
+xor(2, 4) # => 6 # bitwise xor
 2 >>> 1 # => 1 # logical shift right
 2 >> 1  # => 1 # arithmetic shift right
 2 << 1  # => 4 # logical/arithmetic shift left
@@ -80,25 +81,33 @@ false
 2 < 3 < 2 # => false
 
 # Strings are created with "
+try
 "This is a string."
+catch ; end
 
 # Julia has several types of strings, including ASCIIString and UTF8String.
 # More on this in the Types section.
 
 # Character literals are written with '
+try
 'a'
+catch ; end
 
 # Some strings can be indexed like an array of characters
+try
 "This is a string"[1] # => 'T' # Julia indexes from 1
+catch ; end
 # However, this is will not work well for UTF8 strings,
 # so iterating over strings is recommended (map, for loops, etc).
 
 # $ can be used for string interpolation:
+try
 "2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
+catch ; end
 # You can put any Julia expression inside the parentheses.
 
 # Another way to format strings is the printf macro.
-@printf "%d is less than %f" 4.5 5.3 # 4.5 is less than 5.300000
+@printf "%d is less than %f" 4.5 5.3 # 4 is less than 5.300000
 
 # Printing is easy
 println("I'm Julia. Nice to meet you!")
@@ -405,8 +414,8 @@ f_add(x, y) = x + y # => "f (generic function with 1 method)"
 f_add(3, 4) # => 7
 
 # Function can also return multiple values as tuple
-f(x, y) = x + y, x - y
-f(3, 4) # => (7, -1)
+fn(x, y) = x + y, x - y
+fn(3, 4) # => (7, -1)
 
 # You can define functions that take a variable number of
 # positional arguments
@@ -497,9 +506,10 @@ add_10(3) # => 13
 map(add_10, [1,2,3]) # => [11, 12, 13]
 filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
 
-# We can use list comprehensions for nicer maps
+# We can use list comprehensions
 [add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
 [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. Types
@@ -543,7 +553,7 @@ sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
 # The other kind of types is abstract types.
 
 # abstract Name
-abstract Cat # just a name and point in the type hierarchy
+abstract type Cat end # just a name and point in the type hierarchy
 
 # Abstract types cannot be instantiated, but can have subtypes.
 # For example, Number is an abstract type
@@ -553,30 +563,28 @@ subtypes(Number) # => 2-element Array{Any,1}:
 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.
+subtypes(AbstractString)        # 6-element Array{Union{DataType, UnionAll},1}:
+				# Base.SubstitutionString
+				# Base.Test.GenericString
+				# DirectIndexString      
+				# RevString              
+				# String                 
+				# SubString
+
+# Every type has a super type; use the `supertype` function to get it.
 typeof(5) # => Int64
-super(Int64) # => Signed
-super(Signed) # => Integer
-super(Integer) # => Real
-super(Real) # => Number
-super(Number) # => Any
-super(super(Signed)) # => Real
-super(Any) # => Any
+supertype(Int64) # => Signed
+supertype(Signed) # => Integer
+supertype(Integer) # => Real
+supertype(Real) # => Number
+supertype(Number) # => Any
+supertype(supertype(Signed)) # => Real
+supertype(Any) # => Any
 # All of these type, except for Int64, are abstract.
-typeof("fire") # => ASCIIString
-super(ASCIIString) # => DirectIndexString
-super(DirectIndexString) # => AbstractString
-# Likewise here with ASCIIString
+typeof("fire") # => String
+supertype(String) # => AbstractString
+# Likewise here with String
+supertype(DirectIndexString) # => AbstractString
 
 # <: is the subtyping operator
 type Lion <: Cat # Lion is a subtype of Cat
@@ -670,23 +678,22 @@ fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
 
 fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr
 try
-  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
-catch
+  fight(Panther(),Lion("RAWR"))
+catch e
+  println(e) 
+  # => MethodError(fight, (Panther("green"), Lion("green", "RAWR")), 0x000000000000557b)
 end
 
 # Also let the cat go first
 fight(c::Cat,l::Lion) = println("The cat beats the Lion")
-# => Warning: New definition
-#    fight(Cat,Lion) at none:1
-# is ambiguous with
-#    fight(Lion,Cat) at none:2.
-# Make sure
-#    fight(Lion,Lion)
-# is defined first.
-#fight (generic function with 4 methods)
 
 # This warning is because it's unclear which fight will be called in:
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
+try
+  fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
+catch e
+  println(e)
+  # => MethodError(fight, (Lion("green", "RAR"), Lion("brown", "rarrr")), 0x000000000000557c)
+end
 # The result may be different in other versions of Julia
 
 fight(l::Lion,l2::Lion) = println("The lions come to a tie")
diff --git a/lambda-calculus.html.markdown b/lambda-calculus.html.markdown
index 6103c015..72ed78ba 100644
--- a/lambda-calculus.html.markdown
+++ b/lambda-calculus.html.markdown
@@ -3,6 +3,7 @@ category: Algorithms & Data Structures
 name: Lambda Calculus
 contributors:
     - ["Max Sun", "http://github.com/maxsun"]
+    - ["Yan Hui Hang", "http://github.com/yanhh0"]
 ---
 
 # Lambda Calculus
@@ -114,8 +115,100 @@ Using successor, we can define add:
 
 **Challenge:** try defining your own multiplication function!
 
+## Get even smaller: SKI, SK and Iota
+
+### SKI Combinator Calculus
+
+Let S, K, I be the following functions:
+
+`I x = x`
+
+`K x y =  x`
+
+`S x y z = x z (y z)`
+
+We can convert an expression in the lambda calculus to an expression
+in the SKI combinator calculus:
+
+1. `λx.x = I`
+2. `λx.c = Kc`
+3. `λx.(y z) = S (λx.y) (λx.z)`
+
+Take the church number 2 for example:
+
+`2 = λf.λx.f(f x)`
+
+For the inner part `λx.f(f x)`:
+```
+  λx.f(f x)
+= S (λx.f) (λx.(f x))          (case 3)
+= S (K f)  (S (λx.f) (λx.x))   (case 2, 3)
+= S (K f)  (S (K f) I)         (case 2, 1)
+```
+
+So:
+```
+  2
+= λf.λx.f(f x)
+= λf.(S (K f) (S (K f) I))
+= λf.((S (K f)) (S (K f) I))
+= S (λf.(S (K f))) (λf.(S (K f) I)) (case 3)
+```
+
+For the first argument `λf.(S (K f))`:
+```
+  λf.(S (K f))
+= S (λf.S) (λf.(K f))       (case 3)
+= S (K S) (S (λf.K) (λf.f)) (case 2, 3)
+= S (K S) (S (K K) I)       (case 2, 3)
+```
+
+For the second argument `λf.(S (K f) I)`:
+```
+  λf.(S (K f) I)
+= λf.((S (K f)) I)
+= S (λf.(S (K f))) (λf.I)             (case 3)
+= S (S (λf.S) (λf.(K f))) (K I)       (case 2, 3)
+= S (S (K S) (S (λf.K) (λf.f))) (K I) (case 1, 3)
+= S (S (K S) (S (K K) I)) (K I)       (case 1, 2)
+```
+
+Merging them up:
+```
+  2
+= S (λf.(S (K f))) (λf.(S (K f) I))
+= S (S (K S) (S (K K) I)) (S (S (K S) (S (K K) I)) (K I))
+```
+
+Expanding this, we would end up with the same expression for the
+church number 2 again.
+
+### SK Combinator Calculus
+
+The SKI combinator calculus can still be reduced further. We can
+remove the I combinator by noting that `I = SKK`. We can substitute
+all `I`'s with `SKK`.
+
+### Iota Combinator
+
+The SK combinator calculus is still not minimal. Defining:
+
+```
+ι = λf.((f S) K)
+```
+
+We have:
+
+```
+I = ιι
+K = ι(ιI) = ι(ι(ιι))
+S = ι(K) = ι(ι(ι(ιι)))
+```
+
 ## For more advanced reading:
 
 1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
 2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
-3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
\ No newline at end of file
+3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
+4. [Wikipedia - SKI combinator calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus)
+5. [Wikipedia - Iota and Jot](https://en.wikipedia.org/wiki/Iota_and_Jot)
diff --git a/objective-c.html.markdown b/objective-c.html.markdown
index 04c4e529..de3884af 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -731,7 +731,10 @@ if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
 ///////////////////////////////////////
 // Blocks are statements of code, just like a function, that are able to be used as data.
 // Below is a simple block with an integer argument that returns the argument plus 4.
-int (^addUp)(int n); // Declare a variable to store the block.
+^(int n) {
+    return n + 4;
+}
+int (^addUp)(int n); // Declare a variable to store a block.
 void (^noParameterBlockVar)(void); // Example variable declaration of block with no arguments.
 // Blocks have access to variables in the same scope. But the variables are readonly and the
 // value passed to the block is the value of the variable when the block is created.
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 75b73abe..761f5294 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -171,7 +171,7 @@ function arithmetic_functions(a, b, c,    d) {
     # Muitas implementações AWK possuem algumas funções trigonométricas padrão
     localvar = sin(a)
     localvar = cos(a)
-    localvar = atan2(a, b) # arco-tangente de b / a
+    localvar = atan2(b, a) # arco-tangente de b / a
 
     # E conteúdo logarítmico
     localvar = exp(a)
diff --git a/python3.html.markdown b/python3.html.markdown
index 019934cb..d6cfbf59 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -138,6 +138,10 @@ len("This is a string")  # => 16
 # still use the old style of formatting:
 "%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
 
+# You can also format using f-strings or formatted string literals
+name = "Reiko"
+f"She said her name is {name}." # => "She said her name is Reiko"
+
 
 # None is an object
 None  # => None
diff --git a/ro-ro/elixir-ro.html.markdown b/ro-ro/elixir-ro.html.markdown
new file mode 100644
index 00000000..d8b261af
--- /dev/null
+++ b/ro-ro/elixir-ro.html.markdown
@@ -0,0 +1,459 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+    - ["Ev Bogdanov", "https://github.com/evbogdanov"]
+translators:
+    - ["Vitalie Lazu", "https://github.com/vitaliel"]
+
+filename: learnelixir-ro.ex
+---
+
+Elixir este un limbaj funcțional modern construit pe baza mașinii virtuale Erlang.
+E total compatibil cu Erlang, dar are o sintaxă mai prietenoasă și propune mai multe
+posibilități.
+
+```elixir
+
+# Comentariile de o linie încep cu simbolul diez.
+
+# Pentru comentarii pe mai multe linii nu există sintaxă separată,
+# de aceea folosiți mai multe linii cu comentarii.
+
+# Pentru a folosi shell-ul elixir utilizați comanda `iex`.
+# Compilați modulele cu comanda `elixirc`.
+
+# Ambele comenzi vor lucra în terminal, dacă ați instalat Elixir corect.
+
+## ---------------------------
+## -- Tipuri de bază
+## ---------------------------
+
+# Numere
+3    # număr întreg
+0x1F # număr întreg
+3.0  # număr cu virgulă mobilă
+
+# Atomii, sunt constante nenumerice. Ei încep cu `:`.
+:salut # atom
+
+# Tuplele sunt păstrate în memorie consecutiv.
+{1,2,3} # tuple
+
+# Putem accesa elementul tuplelui folosind funcția `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Listele sunt implementate ca liste înlănțuite.
+[1,2,3] # listă
+
+# Fiecare listă ne vidă are cap (primul element al listei)
+# și coadă (restul elementelor).
+# Putem accesa capul și coada listei cum urmează:
+[cap | coadă] = [1,2,3]
+cap   #=> 1
+coadă #=> [2, 3]
+
+# În Elixir, ca și în Erlang, simbolul `=` denotă potrivirea șabloanelor și
+# nu atribuire.
+#
+# Aceasta înseamnă că expresia din stînga (șablonul) se potrivește cu
+# expresia din dreaptă.
+#
+# În modul acesta exemplul de mai sus lucrează accesînd capul și coada unei liste.
+
+# Potrivirea șablonului va da eroare cînd expresiile din stînga și dreapta nu se
+# potrivesc, în exemplu acesta tuplele au lungime diferită.
+{a, b, c} = {1, 2} #=> ** (MatchError)
+
+# Există și date binare
+<<1,2,3>>
+
+# Sunt două tipuri de șiruri de caractere
+"salut" # șir de caractere Elixir
+'salut' # listă de caractere Erlang
+
+# Șir de caractere pe mai multe linii
+"""
+Sunt un șir de caractere
+pe mai multe linii.
+"""
+#=> "Sunt un șir de caractere\npe mai multe linii..\n"
+
+# Șirurile de caractere sunt codificate în UTF-8:
+"Bună dimineața" #=> "Bună dimineața"
+
+# Șirurile de caractere sunt date binare, listele de caractere doar liste.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` în Elixir întoarce codul ASCII pentru litera `a`
+?a #=> 97
+
+# Pentru a concatena listele folosiți `++`, pentru date binare - `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'Salut ' ++ 'lume'  #=> 'Salut lume'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"Salut " <> "lume"  #=> "Salut lume"
+
+# Diapazoanele sunt reprezentate ca `început..sfîrșit` (inclusiv)
+1..10 #=> 1..10
+început..sfîrșit = 1..10 # Putem folosi potrivirea șabloanelor cu diapazoane de asemenea
+[început, sfîrșit] #=> [1, 10]
+
+# Dicţionarele stochează chei şi o valoare pentru fiecare cheie
+genuri = %{"Ion" => "bărbat", "Maria" => "femeie"}
+genuri["Ion"] #=> "bărbat"
+
+# Dicționare cu chei de tip atom au sintaxă specială
+genuri = %{ion: "bărbat", maria: "femeie"}
+genuri.ion #=> "bărbat"
+
+## ---------------------------
+## -- Operatori
+## ---------------------------
+
+# Operații matematice
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# În Elixir operatorul `/` întotdeauna întoarce un număr cu virgulă mobilă.
+
+# Folosiți `div` pentru împărțirea numerelor întregi
+div(10, 2) #=> 5
+
+# Pentru a obține restul de la împărțire utilizați `rem`
+rem(10, 3) #=> 1
+
+# Există și operatori booleni: `or`, `and` and `not`.
+# Acești operatori așteaptă ca primul argument o expresie booleană.
+true and true #=> true
+false or true #=> true
+1 and true    #=> ** (BadBooleanError)
+
+# Elixir de asemenea  oferă `||`, `&&` și `!` care acceptă argumente de orice tip.
+# Toate valorile în afară de `false` și `nil` se vor evalua ca `true`.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Operatori de comparație: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` și `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` și `!==` au strictețe mai mare cînd comparăm numere întregi și reale:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Putem compara de asemenea și date de diferite tipuri:
+1 < :salut #=> true
+
+# La compararea diferitor tipuri folosiți următoare prioritate:
+# număr < atom < referință < funcție < port < proces < tuple < listă < șir de caractere
+
+# Cităm pe Joe Armstrong în acest caz: "Ordinea actuală nu e importantă,
+dar că ordinea totală este bine definită este important."
+
+## ---------------------------
+## -- Ordinea execuției
+## ---------------------------
+
+# expresia `if`
+if false do
+  "Aceasta nu veți vedea niciodată"
+else
+  "Aceasta veți vedea"
+end
+
+# expresia opusă `unless`
+unless true do
+  "Aceasta nu veți vedea niciodată"
+else
+  "Aceasta veți vedea"
+end
+
+# Țineți minte potrivirea șabloanelor? Multe structuri în Elixir se bazează pe ea.
+
+# `case` ne permite să comparăm o valoare cu multe șabloane:
+case {:unu, :doi} do
+  {:patru, :cinci} ->
+    "Aceasta nu se potrivește"
+  {:unu, x} ->
+    "Aceasta se potrivește și atribuie lui `x` `:doi` în acest bloc"
+  _ ->
+    "Aceasta se va potrivi cu orice valoare"
+end
+
+# Simbolul `_` se numește variabila anonimă.
+# Folosiți-l pentru valori ce nu vă interesează.
+# De exemplu, dacă doar capul listei ne intereseaza:
+[cap | _] = [1,2,3]
+cap #=> 1
+
+# Pentru o citire mai bună putem scri:
+[cap | _coadă] = [:a, :b, :c]
+cap #=> :a
+
+# `cond` ne permite să verificăm multe condiții de odată.
+# Folosiți `cond` în schimbul la multe expresii `if`.
+cond do
+  1 + 1 == 3 ->
+    "Aceasta nu veți vedea niciodată"
+  2 * 5 == 12 ->
+    "Pe mine la fel"
+  1 + 2 == 3 ->
+    "Aceasta veți vedea"
+end
+
+# Este obușnuit de setat ultima condiție cu `true`, care se va potrivi întotdeauna.
+cond do
+  1 + 1 == 3 ->
+    "Aceasta nu veți vedea niciodată"
+  2 * 5 == 12 ->
+    "Pe mine la fel"
+  true ->
+    "Aceasta veți vedea (este else în esență)"
+end
+
+# Blocul `try/catch` se foloște pentru prelucrarea excepțiilor.
+# Elixir suportă blocul `after` care se execută în orice caz.
+try do
+  throw(:salut)
+catch
+  mesaj -> "Am primit #{mesaj}."
+after
+  IO.puts("Sunt în blocul after.")
+end
+#=> Sunt în blocul after.
+# "Am primit salut"
+
+## ---------------------------
+## -- Module și Funcții
+## ---------------------------
+
+# Funcții anonime (atenție la punct la apelarea funcției)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Ele de asemenea aceptă multe clauze și expresii de gardă.
+# Expresiile de gardă vă permit să acordați potrivirea șabloanelor,
+# ele sunt indicate după cuvîntul cheie `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir de asemenea oferă multe funcții incorporate.
+# Ele sunt accesibile în scopul curent.
+is_number(10)    #=> true
+is_list("salut") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Puteți grupa cîteva funcții într-un modul. În interiorul modulului folosiți `def`
+# pentru a defini funcțiile necesare.
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3)  #=> 9
+
+# Pentru a compila modulul nostru simplu Math îl salvăm ca `math.ex` și utilizăm `elixirc`.
+# în terminal: elixirc math.ex
+
+# În interiorul modulului putem defini funcții cu `def` și funcții private cu `defp`.
+defmodule PrivateMath do
+  # O funcție definită cu `def` este accesibilă pentru apelare din alte module,
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  # O funcție privată poate fi apelată doar local.
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Declarația funcției de asemenea suportă expresii de gardă și multe clauze:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+Geometry.area({:circle, "not_a_number"}) #=> ** (FunctionClauseError)
+
+# Din cauza variabilelor imutabile, un rol important îl ocupă funcțiile recursive
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Modulele în Elixir suportă atribute, există atribute incorporate și
+# puteți adăuga altele.
+defmodule MyMod do
+  @moduledoc """
+  Este un atribut incorporat
+  """
+
+  @my_data 100 # Acesta e atributul nostru
+  IO.inspect(@my_data) #=> 100
+end
+
+# Operatorul |> permite transferarea rezultatului unei expresii din stînga
+# ca primul argument al unei funcții din dreapta.
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Structuri și Excepții
+## ---------------------------
+
+# Structurile sunt extensii a dicționarelor ce au valori implicite,
+# verificări în timpul compilării și polimorfism
+defmodule Person do
+  defstruct name: nil, age: 0, height: 0
+end
+
+joe_info = %Person{ name: "Joe", age: 30, height: 180 }
+#=> %Person{age: 30, height: 180, name: "Joe"}
+
+# Acesarea cîmpului din structură
+joe_info.name #=> "Joe"
+
+# Actualizarea valorii cîmpului
+older_joe_info = %{ joe_info | age: 31 }
+#=> %Person{age: 31, height: 180, name: "Joe"}
+
+# Blocul `try` cu cuvîntul cheie `rescue` e folosit pentru a prinde excepții
+try do
+  raise "o eroare"
+rescue
+  RuntimeError -> "a fost prinsă o eroare runtime"
+  _error -> "aici vor fi prinse toate erorile"
+end
+#=> "a fost prinsă o eroare runtime"
+
+# Toate excepțiile au un mesaj
+try do
+  raise "o eroare"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "o eroare"
+
+## ---------------------------
+## -- Concurența
+## ---------------------------
+
+# Concurența în Elixir se bazează pe modelul actor. Pentru a scrie programe
+# concurente avem nevoie de trei lucruri:
+# 1. Crearea proceselor
+# 2. Trimiterea mesajelor
+# 3. Primirea mesajelor
+
+# Un nou proces se crează folosind funcția `spawn`, care primește o funcție
+# ca argument.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` întoarce identificatorul procesului pid, îl puteți folosi pentru
+# a trimite mesaje procesului. Mesajele se transmit folosind operatorul `send`.  
+# Pentru primirea mesajelor se folosește mecanismul `receive`:
+
+# Blocul `receive do` este folosit pentru așteptarea mesajelor și prelucrarea lor
+# cînd au fost primite. Blocul `receive do` va procesa doar un singur mesaj primit.
+# Pentru a procesa mai multe mesaje, funcția cu blocul `receive do` trebuie
+# recursiv să se auto apeleze.
+
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Aria = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Aria = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Compilați modulul și creați un proces
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# Un alt mod
+pid = spawn(Geometry, :area_loop, [])
+
+# Trimiteți un mesaj către `pid` care se va potrivi cu un șablon din blocul `receive`
+send pid, {:rectangle, 2, 3}
+#=> Aria = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Aria = 12.56000000000000049738
+#   {:circle,2}
+
+# Interpretatorul este de asemenea un proces, puteți folosi `self` 
+# pentru a primi identificatorul de proces: 
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agenții
+## ---------------------------
+
+# Un agent este un proces care urmărește careva valori ce se schimbă.
+
+# Creați un agent cu `Agent.start_link`, transmițînd o funcție.
+# Stare inițială a agentului va fi rezultatul funcției.
+{ok, my_agent} = Agent.start_link(fn -> ["roșu", "verde"] end)
+
+# `Agent.get` primește numele agentului și o `fn` care primește starea curentă
+# Orice va întoarce `fn` este ceea ce veți primi înapoi: 
+Agent.get(my_agent, fn colors -> colors end) #=> ["roșu", "verde"]
+
+# Actualizați starea agentului în acelaș mod:
+Agent.update(my_agent, fn colors -> ["albastru" | colors] end)
+```
+
+## Link-uri utile
+
+* [Primii pași](http://elixir-lang.org/getting-started/introduction.html) de pe [situl Elixir](http://elixir-lang.org)
+* [Documentația oficială Elixir](http://elixir-lang.org/docs/master/)
+* [Un mic conspect pe Elixir](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* [Cartea "Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
+* [Cartea "Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert
+* [Cartea "Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) de Joe Armstrong
diff --git a/ruby.html.markdown b/ruby.html.markdown
index e0a6bb6e..51f220e3 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -15,32 +15,28 @@ contributors:
   - ["Gabriel Halley", "https://github.com/ghalley"]
   - ["Persa Zula", "http://persazula.com"]
   - ["Jake Faris", "https://github.com/farisj"]
+  - ["Corey Ward", "https://github.com/coreyward"]
 ---
 
 ```ruby
 # This is a comment
 
-=begin
-This is a multiline comment
-No-one uses them
-You shouldn't either
-=end
+# In Ruby, (almost) everything is an object.
+# This includes numbers…
+3.class #=> Integer
 
-# First and foremost: Everything is an object.
-
-# Numbers are objects
-
-3.class #=> Fixnum
-
-3.to_s #=> "3"
+# …strings…
+"Hello".class #=> String
 
+# …even methods!
+"Hello".method(:class).class #=> Method
 
 # Some basic arithmetic
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
-2**5 #=> 32
+2 ** 5 #=> 32
 5 % 3 #=> 2
 
 # Bitwise operators
@@ -52,6 +48,7 @@ You shouldn't either
 # for calling a method on an object
 1.+(3) #=> 4
 10.* 5 #=> 50
+100.methods.include?(:/) #=> true
 
 # Special values are objects
 nil # equivalent to null in other languages
@@ -72,9 +69,10 @@ false.class #=> FalseClass
 
 # apart from false itself, nil is the only other 'falsey' value
 
-!nil   #=> true
-!false #=> true
-!0     #=> false
+!!nil   #=> false
+!!false #=> false
+!!0     #=> true
+!!""    #=> true
 
 # More comparisons
 1 < 10 #=> true
@@ -82,7 +80,8 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
-# Combined comparison operator
+# Combined comparison operator (returns `1` when the first argument is greater, 
+# `-1` when the second argument is greater, and `0` otherwise)
 1 <=> 10 #=> -1
 10 <=> 1 #=> 1
 1 <=> 1 #=> 0
@@ -90,7 +89,6 @@ false.class #=> FalseClass
 # Logical operators
 true && false #=> false
 true || false #=> true
-!true #=> false
 
 # There are alternate versions of the logical operators with much lower
 # precedence. These are meant to be used as flow-control constructs to chain
@@ -101,23 +99,17 @@ do_something() and do_something_else()
 # `log_error` only called if `do_something` fails.
 do_something() or log_error()
 
-
-# Strings are objects
-
-'I am a string'.class #=> String
-"I am a string too".class #=> String
+# String interpolation
 
 placeholder = 'use string interpolation'
 "I can #{placeholder} when using double quoted strings"
 #=> "I can use string interpolation when using double quoted strings"
 
-# Prefer single quoted strings to double quoted ones where possible
-# Double quoted strings perform additional inner calculations
-
-# Combine strings, but not with numbers
+# You can combine strings using `+`, but not with other types
 'hello ' + 'world'  #=> "hello world"
 'hello ' + 3 #=> TypeError: can't convert Fixnum into String
 'hello ' + 3.to_s #=> "hello 3"
+"hello #{3}" #=> "hello 3"
 
 # Combine strings and operators
 'hello ' * 3 #=> "hello hello hello "
@@ -150,9 +142,8 @@ snake_case = true
 
 # Use descriptive variable names
 path_to_project_root = '/good/name/'
-path = '/bad/name/'
+m = '/bad/name/'
 
-# Symbols (are objects)
 # Symbols are immutable, reusable constants represented internally by an
 # integer value. They're often used instead of strings to efficiently convey
 # specific, meaningful values
@@ -167,6 +158,11 @@ status == 'pending' #=> false
 
 status == :approved #=> false
 
+# Strings can be converted into symbols and vice versa:
+
+status.to_s #=> "pending"
+"argon".to_sym #=> :argon
+
 # Arrays
 
 # This is an array
@@ -196,7 +192,7 @@ array.last #=> 5
 array[2, 3] #=> [3, 4, 5]
 
 # Reverse an Array
-a=[1,2,3]
+a = [1,2,3]
 a.reverse! #=> [3,2,1]
 
 # Or with a range
@@ -223,7 +219,7 @@ hash['number'] #=> 5
 # Asking a hash for a key that doesn't exist returns nil:
 hash['nothing here'] #=> nil
 
-# Since Ruby 1.9, there's a special syntax when using symbols as keys:
+# When using symbols for keys in a hash, you can use this alternate syntax:
 
 new_hash = { defcon: 3, action: true }
 
@@ -246,33 +242,26 @@ else
   'else, also optional'
 end
 
+
+# In Ruby, traditional `for` loops aren't very common. Instead, these 
+# basic loops are implemented using enumerable, which hinges on `each`:
+
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+
+# Which is roughly equivalent to this, which is unusual to see in Ruby:
+
 for counter in 1..5
   puts "iteration #{counter}"
 end
-#=> iteration 1
-#=> iteration 2
-#=> iteration 3
-#=> iteration 4
-#=> iteration 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 `do |variable| ... end` construct above is called a “block”. Blocks are similar
+# to lambdas, anonymous functions or closures in other programming languages. They can
+# be passed around as objects, called, or attached as methods. 
 #
 # 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}" }
@@ -365,10 +354,10 @@ def double(x)
   x * 2
 end
 
-# Methods (and all blocks) implicitly return the value of the last statement
+# Methods (and blocks) implicitly return the value of the last statement
 double(2) #=> 4
 
-# Parentheses are optional where the result is unambiguous
+# Parentheses are optional where the interpretation is unambiguous
 double 3 #=> 6
 
 double double 3 #=> 12
@@ -399,25 +388,57 @@ surround { puts 'hello world' }
 # }
 
 
-# You can pass a block to a method
-# "&" marks a reference to a passed block
+# Blocks can be converted into a `proc` object, which wraps the block 
+# and allows it to be passed to another method, bound to a different scope,
+# or manipulated otherwise. This is most common in method parameter lists,
+# where you frequently see a trailing `&block` parameter that will accept 
+# the block, if one is given, and convert it to a `Proc`. The naming here is
+# convention; it would work just as well with `&pineapple`:
 def guests(&block)
-  block.call 'some_argument'
+  block.class #=> Proc
+  block.call(4)
 end
 
+# The `call` method on the Proc is similar to calling `yield` when a block is 
+# present. The arguments passed to `call` will be forwarded to the block as arugments:
+
+guests { |n| "You have #{n} guests." }
+# => "You have 4 guests."
+
 # You can pass a list of arguments, which will be converted into an array
 # That's what splat operator ("*") is for
 def guests(*array)
   array.each { |guest| puts guest }
 end
 
-# If a method returns an array, you can use destructuring assignment
-def foods
-    ['pancake', 'sandwich', 'quesadilla']
+# Destructuring
+
+# Ruby will automatically destructure arrays on assignment to multiple variables:
+a, b, c = [1, 2, 3]
+a #=> 1
+b #=> 2
+c #=> 3
+
+# In some cases, you will want to use the splat operator: `*` to prompt destructuring
+# of an array into a list:
+
+ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"]
+
+def best(first, second, third)
+  puts "Winners are #{first}, #{second}, and #{third}."
 end
-breakfast, lunch, dinner = foods
-breakfast #=> 'pancake'
-dinner #=> 'quesadilla'
+
+best *ranked_competitors.first(3) #=> Winners are John, Sally, and Dingus.
+
+# The splat operator can also be used in parameters:
+def best(first, second, third, *others)
+  puts "Winners are #{first}, #{second}, and #{third}."
+  puts "There were #{others.count} other participants."
+end
+
+best *ranked_competitors 
+#=> Winners are John, Sally, and Dingus.
+#=> There were 2 other participants.
 
 # By convention, all methods that return booleans end with a question mark
 5.even? # false
diff --git a/tcl.html.markdown b/tcl.html.markdown
index 40d9111a..f48d5271 100644
--- a/tcl.html.markdown
+++ b/tcl.html.markdown
@@ -328,6 +328,7 @@ proc greet {greeting name} {
 # the third argument to "proc", is a string.  The previous command
 # can be rewritten using no braces:
 proc greet greeting\ name return\ \"\$greeting,\ \$name!\"
+# "
 
 
 
diff --git a/toml.html.markdown b/toml.html.markdown
index 980563f9..39caaa23 100755
--- a/toml.html.markdown
+++ b/toml.html.markdown
@@ -102,9 +102,10 @@ boolMustBeLowercase = true
 # Datetime #
 ############
 
-date1 = 1979-05-27T07:32:00Z # follows the RFC 3339 spec
-date2 = 1979-05-27T07:32:00 # without offset
-date3 = 1979-05-27 # without offset nor time
+date1 = 1979-05-27T07:32:00Z # UTC time, following RFC 3339/ISO 8601 spec
+date2 = 1979-05-26T15:32:00+08:00 # with RFC 3339/ISO 8601 offset
+date3 = 1979-05-27T07:32:00 # without offset
+date4 = 1979-05-27 # without offset or time
 
 ####################
 # COLLECTION TYPES #
diff --git a/tr-tr/c++-tr.html.markdown b/tr-tr/c++-tr.html.markdown
new file mode 100644
index 00000000..f9f22a1d
--- /dev/null
+++ b/tr-tr/c++-tr.html.markdown
@@ -0,0 +1,1076 @@
+---
+language: c++
+filename: learncpp.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+    - ["Ankush Goyal", "http://github.com/ankushg07"]
+    - ["Jatin Dhankhar", "https://github.com/jatindhankhar"]
+    - ["Adem Budak", "https://github.com/p1v0t"]
+---
+
+C++ 
+[yaratıcısı Bjarne Stroustrup'a göre](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+
+- "daha iyi bir C" yapmak
+- veri soyutlamayı desteklemek 
+- nesneye yönelik programlamayı deskteklemek
+- tipten bağımsız programlamayı desteklemek 
+
+için tasarlanmış bir sistem programlama dilir.
+
+Sözdizimi daha yeni dillerden daha zor veya karmaşık olsa da işlemcinin doğrudan çalıştırabileceği
+native komutlara derlenerek, donanım üzerinde (C gibi) sıkı bir kontrol sağlar, bunu yaparken
+tipten bağımsızlık, exception'lar ve sınıflar gibi yüksek-seviyeli özellikleri destekler.
+Bu hız ve kullanışlılık C++'ı en çok kullanılan dillerden biri yapar.
+
+```c++
+//////////////////////
+// C ile karşılaştırma
+//////////////////////
+
+// C++ _neredeyse_ C'nin bir üstkümesidir, değişken tanımı, basit tipleri
+// ve fonksiyonları için temelde aynı sözdizimini paylaşır.
+
+// Aynı C gibi, programın başlangıç noktası bir integer döndüren 
+// main fonksiyonudur.
+// Bu değer programın bitiş statüsünü belli eder.
+// Daha fazla bilgi için bknz http://en.wikipedia.org/wiki/Exit_status .
+
+int main(int argc, char** argv)
+{
+    // Komut satırı argümanları C'de olduğu gibi argv ve argc ile geçilir
+    // argc, argüman sayısını belli eder,
+    // argv, argümanları belli eden, C-stili string'lerin (char*) dizisidir.
+    // İlk argüman çağrılan programın adıdır.
+    // Eğer argümanları umursamıyorsan, argv ve argc kullanılmayabilir 
+    // int main() gibi
+
+    // 0 çıkış durumu başarıyı belirtir.
+    return 0;
+}
+
+// Bunlara rağmen C++ aşağıdaki noktalarda farklılaşır:
+
+// C++'ta, karakterler char türündendir
+sizeof('c') == sizeof(char) == 1
+
+// C'de, karakterler int türündendir
+sizeof('c') == sizeof(int)
+
+
+// C++ katı bir prototip kuralına sahiptir
+void func(); // fonksiyon argüman kabul etmez
+
+// C'de
+void func(); // fonksiyon herhangi bir sayıda argüman kabul edebilir
+
+// C++'da NULL yerine nullptr kullanılır
+int* ip = nullptr;
+
+// C standard başlıkları başına "c" eklenip, sondaki .h
+// kullanılmadan C++'ta kullanılabilir
+#include <cstdio>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+//////////////////////////////////
+// Fonksiyonun fazladan yüklenmesi
+//////////////////////////////////
+
+// C++ herbir fonksiyonun farklı parametereler
+// aldığı fonksiyon fazladan yüklenmesini desktekler 
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("My int is %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // void print(const char*) fonksiyonunu çağırır.
+    print(15); // void print(int) fonksiyonunu çağırır.
+}
+
+////////////////////////////////
+// Default fonksiyon argümanları
+////////////////////////////////
+
+// Eğer çağırıcı tarafından fonksiyona argüman sağlanmamışsa,
+// fonksiyona default argüman verebilirsin
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Burada int'lerle birşeyler yap
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Default argümanlar, argüman listesinin sonunda yer almalı.
+
+void invalidDeclaration(int a = 1, int b) // Hata!
+{
+}
+
+
+/////////////////////////
+// Namespace(İsim uzayı)
+/////////////////////////
+
+// Namespace'ler değişken, fonksiyon ve diğer bildirimlerin 
+// kapsama alanını ayırır. 
+// Namespace'ler içiçe geçebilir.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("This is First::Nested::foo\n");
+        }
+    } // Nested namespace'inin sonu
+} // First namespace'inin sonu
+
+namespace Second {
+    void foo()
+    {
+        printf("This is Second::foo\n");
+    }
+}
+
+void foo()
+{
+    printf("This is global foo\n");
+}
+
+int main()
+{
+    // Second namespace'i içinideki tüm sembolleri mevcut kapsama alanına dahil eder.
+    // Dikkat edersen artık yalnızca foo() çağrısı çalışmayacaktır çünkü hangi
+    // namespace'ten çağrıldığı açık değildir.
+    using namespace Second;
+
+    Second::foo(); // "This is Second::foo" yazdırıır
+    First::Nested::foo(); // "This is First::Nested::foo" yazdırır
+    ::foo(); // "This is global foo" yazdırır.
+}
+
+///////////////
+// Input/Output
+///////////////
+
+// C++'ta input ve output stream'leri kullanır.
+// cin, cout ve cerr,sırasıyla, stdin, stdout, ve stderr'i temsil eder.
+// << araya ekleme ve >> aradan çıkarma operatörüdür.
+
+#include <iostream> // I/O stream'lerini dahil etmek için
+
+using namespace std; // Streamler std namespace'i içindedir(standard kütüphane)
+
+int main()
+{
+   int myInt;
+
+   // stdout (veya terminal/screen)'ta çıktı verir
+   cout << "Enter your favorite number:\n";
+   // Girdiyi alır 
+   cin >> myInt;
+
+   // cout ayrıca formatlanabilir
+   cout << "Your favorite number is " << myInt << "\n";
+   // prints "Your favorite number is <myInt>"
+
+    cerr << "Used for error messages";
+}
+
+//////////////
+// String'ler
+/////////////
+
+// String'ler C++'ta nesnedir ve pek çok üye fonksiyonu vardır
+#include <string>
+
+using namespace std; // String'ler de std namespace'i içindedir. (standard kütüphane)
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + eklemek için kullanıldır 
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// C++'ta  stringler are mutable'dır (değişebilir).
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+///////////////////////
+// Reference (Referans)
+///////////////////////
+
+// C'deki pointer'lara ek olarak 
+// C++ _reference_'lara sahiptir.
+// Bunlar bir kere atandınğında tekrardan atanamayan pointer'dır
+// ve null olamaz.
+// Değişkenin kendisiyle aynı sözdizimine sahiptir:
+// Değerine ulaşmak için * ihtiyaç yoktur ve
+// atama için & (address of) kullanılmaz.
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // Bu foo'nun reference'ını oluşturur.
+fooRef += ". Hi!"; // foo'yu reference'ı üzerinden değiştirir.
+cout << fooRef; // "I am foo. Hi!" yazdırır.
+
+// "fooRef"e yeniden atama yapmaz. Bu "foo = bar" denktir ve bu satırdan sonra
+//  foo == "I am bar" olur
+cout << &fooRef << endl; // foo'un adresini yazdırır
+fooRef = bar;
+cout << &fooRef << endl; //Hala foo'nun adresini yazdırır
+cout << fooRef;  //"I am bar" yazdırır
+
+// fooRef'in adresi aynı kalır yani hala foo'nun adresidir.
+
+const string& barRef = bar; // bar'a const reference oluşturur
+// C'de olduğu gibi, const değerler (pointer'lar ve reference'ler) değiştirilemez.
+barRef += ". Hi!"; // Hata, const reference'ler değiştirilemez.
+
+// Kısa bir ekleme: reference'lere devam etmeden önce, geçici nesne konseptinden
+// bahsetmeliyiz. Mesela aşadaki gibi bir kod var:
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Bu iki satırda aslında ne oluyor:
+//   - tempObjectFun fonksiyonundan bir string nesnesi dönüyor
+//   - dönmüş olan nesneyle yeni bir string oluşturuyor
+//   - dönmüş olan nesne yok ediliyor
+// İşte bu dönen nesneye geçici nesne denir. Geçici nesneler fonksiyon nesne
+// döndürdüğünde oluşturulur ve ifade işini bitirdiğinde yok edilir (Aslında,
+// standard'ın söylediği şey bu ama derleyiciler bu davranışı değiştirmemize 
+// izin veriyor. Daha fazla detay için "return value optimization" diye
+// aratabilirsin. Sonuç olarak aşağıdaki kodda:
+foo(bar(tempObjectFun()))
+
+// foo ve bar'ın varolduğunu kabul ediyoruz, tempObjectFun'dan dönen nesne
+// bar'a geçti ve foo çağrılmadan önce yokedildir.
+
+// Şimdi reference'lara dönelim. "ifadenin sonunda" kuralının bir istisnası
+// eğer geçici nesne const reference'a geçildiyse oratya çıkar, bu durumda
+// nesnenin ömrü mevcut kapsama alanına kadar uzar:
+
+void constReferenceTempObjectFun() {
+  // constRef geçici nesneyi alır ve bu durum fonksiyonun sonuna kadar geçerlidir.
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// C++11 ile gelen diğer bir reference geçici nesnelere özeldir. Bu türden birden 
+// bir tip tanımlayamazsın ama aşırı yüklenme sırasında bu tipler öncelik alır:
+void someFun(string& s) { ... }  // Regular reference
+void someFun(string&& s) { ... }  // Geçici nesneye reference 
+
+string foo;
+someFun(foo);  // regular reference'ı çağırır
+someFun(tempObjectFun());  // geçici reference'ı çağırır
+
+/////////////////////
+// Enum
+/////////////////////
+
+// Enum'lar sabit değerler yapmak için kullanılır ve çoğunlukla kodun daha okunaklı
+// olması için kullanılır
+
+enum ECarTypes
+{
+  Sedan,
+  Hatchback,
+  SUV,
+  Wagon
+};
+
+ECarTypes GetPreferredCarType()
+{
+	return ECarTypes::Hatchback;
+}
+
+// C++11 ile beraber bir tipi enum'a atamanın kolay bir yolu var, bu enum'un istenen
+// tipe dönüştürmek için kullanışlı bir yöntem
+enum ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// enum uint8_t tipine dönüştürüldü
+	WriteByteToFile(InputCarType);
+}
+
+// Diğer yandan enum'ların yanlışlıkla integer tipini veya diğer enumlara dönüşmesini
+// istemiyorsan enum class olarak tanımlayabilirsin
+enum class ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// ECarTypes, uint8_t tipinde olmasına rağmen, "enum class" olarak 
+	// tanımlandığından derlenmeyecektir!
+	WriteByteToFile(InputCarType);
+}
+
+///////////////////////////////////////////
+// Sınıflar ve nesneye yönelik proglamalama
+///////////////////////////////////////////
+
+// Sınıflara(class) ilk örnek
+#include <iostream>
+
+// Sınıfı tanımla.
+// Sınıflar genelde header (.h veya .hpp) dosyalarında tanımlanır.
+class Dog {
+    // Üye değişkenler ve fonksiyonlar default olarak private'dir.
+    std::string name;
+    int weight;
+
+// Aşağıda, "private:" veya "protected:" bulunana kadar
+// bütün üyeler public'tir.
+public:
+
+    // Default constructor
+    Dog();
+
+    // Üye fonksiyon bildirimi (gerçeklenimi aşağıda)
+    // Dikkat ederseniz using namespace std; yerine
+    // std::string kullandık.
+    // Hiçbir zaman header dosyasında "using namespace std;" kullanma.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // Nesnenin durumunu değiştirmeyen fonksiyonlar const ile işaretlenmelidir
+
+    // Türetilen sınıflarda fonksiyonu override edebilmek için başına 
+    // _virtual_ eklenmelidir.
+    // Fonksiyonlar, performanslar ilgili nedenlerden ötürü default olarak virtual değildir
+    virtual void print() const;
+
+    // Fonksiyonlar class içinde de tanımlanabilir.
+    // Bu şekille tanımlanan fonksiyonlar otomatik olarak inline olur.
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // C++ constructor'ların yanında destructor'da sağlar.
+    // Bunlar nesne silindiğinde veya scope'un dışına çıktığında çağrılır.
+    // Bu RAII gibi güçlü paradigmaları etkin kılar.
+    // (aşağıda açıklandı)
+    // Eğer sınıf kendisinden türetiliyorsa, destructor virtual olmalıdır,
+    // eğer virtual değilse, türetilmiş sınıfın destructor'ı nesne, ana sınıf
+    // referans'ı veya pointer'ı üzerinden yok edildiğinde, çağrılmayacaktır.
+    virtual ~Dog();
+
+}; // class tanımının sonuda noktalı virgül(;) olmalıdır.
+
+// Sınıfın üye fonksiyonları genelde .cpp dosyaları içinde gerçeklenir.
+Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// Objects (such as strings) should be passed by reference
+// Nesneler (string gibi) reference ile fonksiyonlara geçilmelidir
+// Eğer nesneleri değiştirilecekse reference ile fonksiyonlara geçilmelidir,
+// değiştirilmeyecekse const reference ile geçilmelidir.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Dikkat edersen "virtual" yalnızca bildirimde gerekli, tanımlamada değil.
+void Dog::print() const
+{
+    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    std::cout << "Goodbye " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // "A dog has been constructed" yazdırır
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // "Dog is Barkley and weighs 10 kg" yazdırır.
+    return 0;
+} // "Goodbye Barkley" yazdırır.
+
+// Inheritance(Miras)
+
+// Bu sınıf, Dog sınıfında public ve protected olan herşeyi miras alır, 
+// private olanları da miras alır ama, public ve protected sınıflar aracılıyla
+// yapılmıyorsa, doğrudan erişemez.
+class OwnedDog : public Dog {
+
+public:
+    void setOwner(const std::string& dogsOwner);
+
+    // print fonksiyonunun davranışını bütün OwnedDogs sınıfı için override eder
+    // (üstünden geçer, kendine uyarlar).
+    // bknz http://en.wikipedia.org/wiki/Polymorphism_(computer_science)
+    // override anahtar sözcüpü kullanılma da olur ama kullanılması aslında bir temel
+    // temel sınıf fonksiyonunun üzerinden geçtiğimizi gösterir.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Bu arada takip eden .cpp dosyasında:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Ana dog sınıfındaki print fonksiyonunu çağırır 
+    std::cout << "Dog is owned by " << owner << "\n";
+    // 	      "Dog is <name> and weights <weight>"
+    //        "Dog is owned by <owner>"
+    // 	       yazdırır
+}
+
+/////////////////////////////////////////////////////
+// ilk değer atama ve Operatörün fazladan yüklenmesi
+/////////////////////////////////////////////////////
+
+// C++ dilinde +, -, *, /, gibi operatörlerin davranışını fazladan yükleyebilirsiniz.
+// Bu, operator her kullandınıldığında çağrılan bir fonksiyon tanımlamasıyla yapılır.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Üye değişkenkenlere default değer atanabilir.
+    double x = 0;
+    double y = 0;
+    
+    // Default constructor
+    Point() { };
+
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* İlk değer atama dışında birşey yapma */ }
+
+    // + operatorünün fazladan yükle.
+    Point operator+(const Point& rhs) const;
+
+    // += operatorünü fazladan yükle
+    Point& operator+=(const Point& rhs);
+
+    // - ve -= operatorleri fazladan yüklemek de mantıklı olurdu
+    // ama kısa tutmak için burda değinmedik.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // yeni bir nokta oluştur ve bunu rhs ile topla
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // Bu Point + operatorünü çağırır
+    Point result = up + right;
+    // "Result is upright (1,1)" yazdırır.
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+////////////////////////
+// Şablonlar (Templates)
+////////////////////////
+
+// Şablonlar C++ dilinde tipten bağımsız programlama için kullanılır.
+
+// Zaten aşina olduğun tipten bağımsız programlamayla başladık. Bir tip parametresi
+// alan fonksiyon veya sınıf tanımlamaık için:
+template<class T>
+class Box {
+public:
+    // Bu sınıfta T, herhangi bir tip için kullanılabilir.
+    void insert(const T&) { ... }
+};
+
+// Derleme esnasında derleyici aslında, parametreleri yerine konmuş şekilde herbir şablonu üretir,
+// bu yüzden sınıfın tam tanımı her çağrılma sırasında var olmak zorundadır. Bu nedenle şablon sınıflarını
+// tamamen header dosyalarında görürsün.
+
+// Stack'ta şablon sınıfın bir örneğini oluşturmak için:
+Box<int> intBox;
+
+// ve, anladığın gibi, kullanabilirsin:
+intBox.insert(123);
+
+// Tabi, şablonları içiçe geçirebilirsin:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// C++11'den önce iki '>' arasına boşluk koymak zorundaydık yoksa sağa kaydırma 
+// operatörü olarak algılanabilirdi.
+
+// Bazen şunu da görebilirsin
+//   template<typename T>
+// 'class' ve 'typename' anahtar sözcükleri çoğunlukla 
+// birbirlerinin yerine kullanılabilir. Tam açıklama için, bknz.
+//   http://en.wikipedia.org/wiki/Typename
+// (evet, bu anahtar sözcüğün kendi Wikipedia sayfası var).
+
+// Benzer şekilde, bir şablon fonksiyon:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Dikkat edersen tip parametresi hakkında birşey belirtilmedi. Derleyici bunları üretecek
+// ve her parametre geçişinde tip-kontrolü yapacaktır, bu nedenle de fonksiyon herhangi bir T
+// tipi için çalışacaktır!
+
+Dog fluffy;
+fluffy.setName("Fluffy")
+barkThreeTimes(fluffy); // Üç kere "Fluffy barks" yazdırır.
+
+// Şablonun parametresi sınıf olmak zorunda değildir:
+template<int Y>
+void printMessage() {
+  cout << "Learn C++ in " << Y << " minutes!" << endl;
+}
+
+// Ve template'i daha etkili kod için dışarıdan özelleştirebilirsin. 
+// Tabiki gerçek-dünya kullanımlarında özelleştirme bunun kadar kolay değildir.
+// Dikkat edersen, bütün parametreleri dıştan özelleştirmiş olsak bile
+// hala fonksiyonu (veya sınıfı( template olarak tanımlamamız gerekli.
+template<>
+void printMessage<10>() {
+  cout << "Learn C++ faster in only 10 minutes!" << endl;
+}
+
+printMessage<20>();  // "Learn C++ in 20 minutes!" yazdırır
+printMessage<10>();  // "Learn C++ faster in only 10 minutes!" yazdırır
+
+
+///////////////////////////////////////////////
+// İstisnai Durum Yönetimi (Exception Handling)
+///////////////////////////////////////////////
+
+// Standard kütüphane bazı istisnai tipler sağlar
+// (bknz http://en.cppreference.com/w/cpp/error/exception)
+// ama herhangi bir tip de istisnai durum fırlatabilir 
+
+#include <exception>
+#include <stdexcept>
+
+// _try_ bloğu içinde fırlatılan bütün istisnai durumlar, takip eden, _catch_ ile 
+// yakalanabilir.
+try {
+    // _new_ kullanarak heap'ten istisnai durumlar için yer ayırma
+    throw std::runtime_error("A problem occurred");
+}
+
+// istisnai durumlar nesne ise  const reference ile yakala
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Bir önceki _catch_ bloğundan kaçan istisnai durum burda yakala
+catch (...)
+{
+    std::cout << "Unknown exception caught";
+    throw; // Tekrardan istisnai durum fırlatır
+}
+
+///////
+// RAII
+///////
+
+// RAII, "Resource Acquisition Is Initialization" kelimelerinin kısaltmasıdır.
+// Bu Türkçe, "Kaynak alımı aynı zamanda ilk değer atamasıdır." olarak çevrilebilir.
+// Bunu basitçe constructor ile ayrılan hafızanın destructor ile iade edilmesi olarak 
+// düşünebiliriz.
+
+// Bunun ne şekilde kullanışlı olduğunu görmek için
+// bir C dosyasının, dosya işleme biçimine bakabiliriz:
+void doSomethingWithAFile(const char* filename)
+{
+    // Başlangıçta herşeyin yolunda gittiğini düşünelim
+
+    FILE* fh = fopen(filename, "r"); // Dosyayı okuma modunda aç
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Dosyayı kapat
+}
+
+// Malesef hatalarla başa çıkmaya çalışırken işler hızlıca karmaşıklaşır.
+// Mesela fopen'ın başarısız olduğunu varsayalım, ve doSoomethingWithTheFile ve 
+// doSomethingWithIt hata kodları gönderdi.
+//  (İstisnai durumlar yonetimi, hata koduna tercih ediler bir yöntemdir, ama bazı
+//   programcılar, özellikle C arkaplanı olanlar, aynı fikirde değildir.
+// Bu durumda her bir fonksiyon çağrısını kontrol etmeli ve bir problem oluştuysa
+// dosyayı kapatmalıyız.
+
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");  // Dosyayı okuma modunda aç
+    if (fh == nullptr) // Başarısız olma durumunda dönen değer null olur
+        return false; // Başarısız olma durumunu çağırıcıya bildir
+
+    // Başarısız olma durumunda her iki fonksiyonun da false döndürdüğünü kabul edelim
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Dosyayı kapatalım, akıntı olmasın.
+        return false; // Hatayı bildir
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Dosyayı kapatalım, akıntı olmasın.
+        return false; // Hatayı bildir
+    }
+
+    fclose(fh); // Dosyayı kapat
+    return true; // Başarı durumunu ifade eder
+}
+
+// C programcıları biraz goto kullanarak bu durumu temizler
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // Dosyayı kapat 
+    return true; // Başarı durumunu ifade eder
+
+failure:
+    fclose(fh);
+    return false; // Hatayı bildir
+}
+
+// Eğer fonksiyon istisnai durum yönetimi araçlarını kullanırsa
+// işler daha temiz olur ama hala en iyi durumun altında kalır.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); 
+    if (fh == nullptr)
+        throw std::runtime_error("Could not open the file.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Hata durumunda dosyayı kapattığından emin ol
+        throw; // Sonra, tekrardan istisnai durum fırlat
+    }
+
+    fclose(fh); // Dosyayı kapat
+    // Herşey başarılı
+}
+
+// Şimdi aynı şeyi C++'ın dosya stream sınıfıyla (fstream) karşılaştıralım
+// fstream, dosyayı kapatmak için kendi destructor'ını kullanır.
+// Destructor'ın, nesne scope dışına çıktığında otomatik olarak çağrıldığını 
+// hatırlayın.
+void doSomethingWithAFile(const std::string& filename)
+{
+    std::ifstream fh(filename); // Dosyayı aç
+
+    // Dosyayla birşeyler yap
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // Dosya, destructor tarafından otomatik olarak kapatıldı
+
+// Bunun _çok büyük_ avantajları var:
+// 1. Ne olursa olursun,
+//    kaynak (bu örnekte dosya tutucusu) temizlenecektir.
+//    Destructor doğru yazıldığında,
+//    Tutucuyu kapatmayı unutma ve kaynak akıntısı _imkansız_dır.
+// 2. Kodun çok daha temiz olduğuna dikkat edin.
+//    Destructor, dosyayı kapatma işini, endilenmemize gerek kalmadan
+//    arka planda halleder.
+// 3. Kod, istisnai durumlara karşı korunaklıdır.
+//    İstisnai durum fonksiyonun herhangi bir yerinde fırlatılabilir ve
+//    temizleme işi gene de yapılır.
+
+// Bütün C++ kodu deyimleri RAII prensibini tüm kaynakları için kullanır.
+// Ek örnekler şunlardır:
+// - unique_ptr ve shared_ptr ile hafıza kullanımı
+// - Tutucular - standard kütüphane linked list,
+//   vector (yani kendiliğinden boyu ayarlanan dizi), hash map vs.
+//   scope'un dışına çıktığında içerini otomatik olarak yok eden tüm yapılar.
+// - lock_guard ve unique_lock kullanan mutex'ler
+
+///////////////////////////////////////
+// Lambda İfadeleri (C++11 ve yukarısı)
+///////////////////////////////////////
+
+// lambda'lar, tam olarak çağrıldığı yerde bir anonim fonksiyon tanımlamak
+// veya fonksiyona argüman geçmek için uygun bir yoldur.
+
+// Mesela, pair'lardan oluşan bir vector'u, pair'ın ikinci değerine 
+// göre sıralamak isteyelim
+
+vector<pair<int, int> > tester;
+tester.push_back(make_pair(3, 6));
+tester.push_back(make_pair(1, 9));
+tester.push_back(make_pair(5, 0));
+
+// sort fonksiyonuna üçüncü argüman olarak lambda ifadesini geç
+// sort, <algorithm> başlığında tanımlı
+
+sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
+        return lhs.second < rhs.second;
+    });
+
+// Lambda ifadesinin söz dizimine dikkat edin, 
+// lambda'daki [], değişkenleri "tutmak" için kullanılır
+// "Tutma listesi", fonksiyon gövdesinde nelerin, ne şekilde erişilebilir olduğunu tanımlar
+// Şunlardan biri olabilir:
+// 	1. bir değer : [x]
+//	2. bir referans : [&x]
+//	3. mevcut scope içindeki herhangi bir değişkene referans ile [&]
+//	4. 3 ile aynı, ama değer ile [=]
+// Mesela:
+vector<int> dog_ids;
+// number_of_dogs = 3;
+for(int i = 0; i < 3; i++) {
+	dog_ids.push_back(i);
+}
+
+int weight[3] = {30, 50, 10};
+
+// Mesela dog_ids vector'unu dog'ların ağırlıklarına göre sıralamak isteyelim
+// Yani en sonunda şöyle olmalı: [2, 0, 1]
+
+// Burada lambda ifadesi oldukça kullanışlıdır
+
+sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs) {
+        return weight[lhs] < weight[rhs];
+    });
+// Dikkat edersen "weight" dizisini referans ile aldık.
+// C++'da lambdalar hakkında daha fazla bilgi için : http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11
+
+//////////////////////////////////
+// Akıllı For (C++11 ve yukarısı)
+//////////////////////////////////
+
+// Akıllı for döngüsünü bir tutucuyu dolaşmak için kullanabilirsin
+int arr[] = {1, 10, 3};
+
+for(int elem: arr){
+	cout << elem << endl;
+}
+
+// Tutucunun elemanlarının tipi için endişe etmeden "auto" kullanabilirsin
+// Mesela:
+
+for(auto elem: arr) {
+	// arr dizisinin elemanlarıyla ilgili bir şeyler yap
+}
+
+////////////////
+// Güzel Şeyler
+////////////////
+
+// C++ dilinin bakış açısı yeni başlayanlar için (hatta dili iyi bilenler için bile)
+// şaşırtıcı olabilir. 
+// Bu bölüm, ne yazık ki, büyük ölçüde tam değil; C++ kendi ayağına ateş edilebilecek kolay
+// dillerden biridir.
+
+// private metodları override edebilirsin!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Foo::bar fonksiyonu override edilir!
+};
+
+
+// 0 == false == NULL (çoğu zaman)!
+bool* pt = new bool;
+*pt = 0; // 'pt'nin gösterdiği değere false atar.
+pt = 0;  // 'pt'ye null pointer atar. Her iki satır uyarısız derlenir.
+
+// nullptr'ın bu meselenin bazılarını çözmesi beklenmiştir:
+int* pt2 = new int;
+*pt2 = nullptr; // Derlenmez.
+pt2 = nullptr;  // pt2'ye null atar.
+
+// bool tipleri için bir istisna vardır.
+// Bu null pointer'ları if(!ptr) ile test etmek içindir.
+// ama sonuç olarak bir bool değerine nullptr atayabilirsin!
+*pt = nullptr;  // '*pt' değeri bir boll olmasına rağmen, hala derlenir!
+
+
+// '=' != '=' != '='!
+// Calls Foo::Foo(const Foo&) or some variant (see move semantics) copy
+// Foo::Foo(const Foo&) çağrısını veya kopyalama constructor'ının bir çeşidinin çağrısınıyapar(taşıma semantiklerine bknz.)
+Foo f2;
+Foo f1 = f2;
+
+// Foo::operator=(Foo&) çağrısını yapar.
+Foo f1;
+f1 = f2;
+
+
+///////////////////////////////////////
+// Tuple (C++11 ve yukarısı)
+///////////////////////////////////////
+
+#include<tuple>
+
+// Ana fikir olarak, Tuple, eski veri yapılarına (C'deki struct'lar) benzer ama isimli veri üyeleri yerine 
+// elemanlarına tuple içindeki sırasına göre erişilir.
+
+// Tuple'ı inşa ederek başlayalım
+// değişkenleri tuple içinde paketliyoruz
+auto first = make_tuple(10, 'A');
+const int maxN = 1e9;
+const int maxL = 15;
+auto second = make_tuple(maxN, maxL);
+
+// 'first' tuple'ının değerlerini yazdırma
+cout << get<0>(first) << " " << get<1>(first) << "\n"; // 10 A yazdırır
+
+// 'second' tuple'ının değerlerini yazdırma
+cout << get<0>(second) << " " << get<1>(second) << "\n"; // 1000000000 15 yazdırır
+
+// Değişkenleri tuple'dan çıkarma
+
+int first_int;
+char first_char;
+tie(first_int, first_char) = first;
+cout << first_int << " " << first_char << "\n";  // 10 A yazdırır
+
+// Ayrıca şu şekide de tuple oluşturabiliriz.
+
+tuple<int, char, double> third(11, 'A', 3.14141);
+// tuple_size, tuple'daki eleman sayısını (constexpr olarak) döndürür
+
+cout << tuple_size<decltype(third)>::value << "\n"; // 3 yazdırır
+
+// tuple_cat, tuple'daki tüm elemanları aynı sırada birleştirir.
+
+auto concatenated_tuple = tuple_cat(first, second, third);
+// concatenated_tuple = (10, 'A', 1e9, 15, 11, 'A', 3.14141) olur
+
+cout << get<0>(concatenated_tuple) << "\n"; // 10 yazdırır
+cout << get<3>(concatenated_tuple) << "\n"; // 15 yazdırır
+cout << get<5>(concatenated_tuple) << "\n"; // 'A' yazdırır
+
+
+/////////////////////
+// Tutucular
+/////////////////////
+
+// Tutucular veya Standard Şablon Kütüphanesi(STL) önceden tanımlanmış şablonlar sunar.
+// Bunlar elemanları için ayrılan hafıza alanını yönetir
+// ve onlara erişim ve değiştirmek için üye fonksiyonlar sağlar
+
+// Bazı tutucular şunlardır:
+
+// Vector (Dinamik Dizi)
+// koşma anında nesne dizisi veya list oluşturmamızı sağlar
+#include <vector>
+string val;
+vector<string> my_vector; // vector'ü tanımla
+cin >> val;
+my_vector.push_back(val); // val değerini my_vector vectörüne push edecektir
+my_vector.push_back(val); // val değerini yeniden push edecektir (şu an iki elemanı var)
+
+// vector içinde dolaşmak için iki seçenek var:
+// ya klasik döngüyle (0. index'ten son index'e kadar iterasyon yaparak)
+for (int i = 0; i < my_vector.size(); i++) {
+	cout << my_vector[i] << endl; // vector'ün elemanlarına uşamak için [] operatörünü kullanabiliriz
+}
+
+// ya da iteratör kulllanarak:
+vector<string>::iterator it; // vector için iterator tanımla
+for (it = my_vector.begin(); it != my_vector.end(); ++it) {
+	cout << *it  << endl;
+}
+
+// Set(Küme)
+// Set'ler benzersiz(unique) elemanları belirli bir sırada saklayan tutuculardır.
+// Set, benzersiz değerleri, herhangi bir fonksiyon veya kod gerektirmeksizin, sıralı olarak
+
+#include<set>
+set<int> ST;    // int tipi için set tanımlar
+ST.insert(30);  // ST kümesini 30 değerini dahil eder
+ST.insert(10);  // ST kümesini 10 değerini dahil eder
+ST.insert(20);  // ST kümesini 20 değerini dahil eder
+ST.insert(30);  // ST kümesini 30 değerini dahil eder
+// Şimdi kümedeki elemanlar aşağıdaki gibidir
+//  10 20 30
+
+// Bir eleman silmek için:
+ST.erase(20);  // 20 değerine sahip elemanı siler
+// Set ST: 10 30
+// Iterator kullanarak Set içinde iterasyon yapmak için:
+set<int>::iterator it;
+for(it=ST.begin();it<ST.end();it++) {
+	cout << *it << endl;
+}
+// Output:
+// 10
+// 30
+
+// Tutucuyu tamamen silmek için Tutucu_Adi.clear() kullanırız
+ST.clear();
+cout << ST.size();  // ST kümesinin eleman sayısı(size)nı yazdırır.
+// Output: 0
+
+// NOTE: Aynı elemanlari içerebilen kümle için multiset kullanırız
+
+// Map(Harita)
+// Map, elemanları anahtar değer, haritalanmış değer şeklinde özel bir sırada saklar.
+// anahtar_değer -> haritalanmış_değer
+
+#include<map>
+map<char, int> mymap;  // Anahtar char ve değer int olacak şekilde map tanımlar
+
+mymap.insert(pair<char,int>('A',1));
+// 1 değeri için A anahtar değerini ekler
+mymap.insert(pair<char,int>('Z',26));
+// 26 değeri için Z anahtar değerini ekler
+
+// Map'te dolaşma
+map<char,int>::iterator it;
+for (it=mymap.begin(); it!=mymap.end(); ++it)
+    std::cout << it->first << "->" << it->second << '\n';
+// Output:
+// A->1
+// Z->26
+
+// Anahtar'a atanmış değeri bulmak için
+it = mymap.find('Z');
+cout << it->second;
+
+// Output: 26
+
+
+/////////////////////////////////////////////
+// Mantıksal ve Bit seviyesindeki operatörler
+/////////////////////////////////////////////
+
+// Pek çok C++ operatörleri diğer dillerdekiyle aynıdır
+
+// Mantıksal operatörler
+
+// C++, bool ifadelerinde Kısa-devre değerlendirmesini kullanır yani ikinci argüman yalnızca ilk argüman
+// ifadenin değerine karar vermek için yeterli değilse çalıştırılır
+
+true && false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir
+true || false // **mantıksal veya** işlemi yapılır ve true  sonucu üretilir 
+! true        // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir
+
+// Sembolleri kullanmak yerine onlara karşılık gelen anahtar kelimeler kullanılabilir
+true and false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir
+true or false  // **mantıksal veya** işlemi yapılır ve true  sonucu üretilir 
+not true       // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir
+
+// Bit seviyesindeki operatörler
+
+// **<<** Sola kaydırma operatörü
+// << bitleri sola kaydırır
+4 << 1 // 4'ün bitlerini 1 sola kaydırır ve 8 sonucunu verir
+// x << n, x * 2^n olarak düşünülebilir
+
+
+// **>>** Sağa kaydırma operatörü
+// >> bitleri sağa kaydırır
+4 >> 1 // 4'ün bitlerini 1 sağa kaydırır ve 2 sonucunu verir
+// x >> n, x / 2^n olarak düşünülebilir
+
+~4    // Bit seviyesinde değil işlemini gerçekleştirir
+4 | 3 // Bit seviyesinde veya işlemini gerçekleştirir
+4 & 3 // Bit seviyesinde ve işlemini gerçekleştirir
+4 ^ 3 // Bit seviyesinde xor işlemini gerçekleştirir
+
+// Eşdeğer anahtar kelimeler
+compl 4    // Bit seviyesinde değil işlemini gerçekleştirir
+4 bitor 3  // Bit seviyesinde veya işlemini gerçekleştiri
+4 bitand 3 // Bit seviyesinde ve işlemini gerçekleştirir
+4 xor 3    // Bit seviyesinde xor işlemini gerçekleştirir
+
+
+```
+İleri okuma:
+
+Güncel bir referans 
+<http://cppreference.com/w/cpp> adresinde bulunabilir
+
+Ek kaynaklar <http://cplusplus.com> adresinde bulunabilir
diff --git a/tr-tr/git-tr.html.markdown b/tr-tr/git-tr.html.markdown
new file mode 100644
index 00000000..533bb21a
--- /dev/null
+++ b/tr-tr/git-tr.html.markdown
@@ -0,0 +1,595 @@
+---
+category: tool
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
+    - ["Andrew Taylor", "http://github.com/andrewjt71"]
+    - ["Jason Stathopulos", "http://github.com/SpiritBreaker226"]
+    - ["Milo Gilad", "http://github.com/Myl0g"]
+    - ["Adem Budak", "https://github.com/p1v0t"]
+    
+filename: LearnGit.txt
+---
+
+Git dağınık versiyon kontrol ve kaynak kod yönetim sistemidir.
+
+Bunu projenin bir seri anlık durumunu kaydederek yapar ve bu anlık durumları 
+kullanarak versiyon ve kaynak kodu yönetmeni sağlar.
+
+## Versiyonlama Konseptleri
+
+### Versiyon kontrol nedir?
+
+Versiyon kontrol, zaman içerisinde dosya(lar)daki değişikliği kaydeden sistemdir.
+
+### Merkezi Versiyonlama vs. Dağınık Versiyonlama
+
+* Merkezi versiyon kontrolü dosyaların eşitlenmesine, takibine ve yedeklenmesine odaklanır. 
+* Dağınık versiyon kontrolü değişimin paylaşılmasına odaklanır. Her değişiminin benzersiz bir adı vardır.
+* Dağınık sistemlerin belirlenmiş bir yapısı yoktur. Git ile kolayca SVN'deki gibi merkezi bir sistem elde edebilirsin. 
+
+[Daha fazla bilgi](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Neden Git?
+
+* Çevrimdışı çalışabilir
+* Diğerleriyle beraber çalışmak kolaydır!
+* Dallanma kolaydır!
+* Dallanma hızlıdır!
+* Git hızlıdır
+* Git esnektir
+
+## Git Mimarisi
+
+### Repository
+
+Bir grup dosya, dizin, geriye dönük kayıt, commit, head. Bunları kaynak kodun veri
+yapısı gibi düşünebilirsin, herbir kaynak kod "elemanı" seni kendi revizyon geçmişine 
+eriştirir. 
+
+Bir git repo'su .git dizini ve çalışma ağacından oluşur. 
+
+### .git Dizini (repository bileşeni)
+
+.git dizini bütün konfigrasyon, log, dallanma, HEAD ve daha fazlasını tutar.
+[detaylı liste](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Çalışma Ağacı (repository bileşeni)
+
+Temelde repo'daki dizinlerin ve dosyalarındır. Sıkça çalışma ağacın olarak anılır.
+
+### Index (.git dizininin birleşeni)
+
+Index git'in evreleme alanıdır (staging area). Temelde çalışma ağacını Git repo'sundan 
+ayıran bir katmandır. Bu geliştiricilere neyin Git repo'suna gönderileceği hakkında daha 
+fazla güç verir. 
+
+### Commit
+
+Bir git commit'i Çalışma Ağacındaki bir takım değişiklerdir. Mesela 5 tane dosya
+eklemişsindir ve diğer 2 tanesini silmişindir, bu değişikler commit'te (anlık kayıtta) 
+tutulacaktır. Bu commit daha sonra diğer repo'lara bastırılabilir (pushed) ve bastırılmaz!
+
+### Branch
+
+Bir branch esasen yaptığın son commit'e göstericidir(pointer). Commit'lemeye devam ettiğinde,
+bu gösterici otomatik olarak son commit'e güncellenir.
+
+### Tag
+
+Bir tag, tarihteki belirli bir noktanın işaretidir. İnsanlar bunu genelde 
+sürüm notları için kullanır (v1.0 vs.)
+
+### HEAD ve head (.git dizininin birleşenleri)
+
+HEAD mevcut branch'a bir göstericidir. Bir repository yalnızca 1 *aktif*
+HEAD'e sahiptir.
+head, commit'e bir göstericidir. Bir repository herhangi bir sayıda head'e sahip olabilir.
+
+### Git'in Stage'leri
+* Modified - Dosyada değişikler yapıldı ama henüz Git Veritabanına commit yapılmadı.
+* Staged - Modified edilmiş bir dosyayı, sonraki commit'e gitmek üzere işaretler.
+* Committed - Dosyalar Git Veritabanına commit'lendi.  
+
+### Kavramsal Kaynaklar 
+
+* [Bilgisayar Bilimciler için Git](http://eagain.net/articles/git-for-computer-scientists/)
+* [Tasarımcılar için Git](http://hoth.entp.com/output/git_for_designers.html)
+
+## Komutlar
+
+### init
+
+Boş bir Git repository'si oluştur. Git repository'sinin ayarları, depolanmış
+bilgileri ve daha fazlası ".git" adlı dizinde (bir klasör) tutulur.
+
+```bash
+$ git init
+```
+
+### config
+
+Ayarları yapılandırmak için. Repository, sistemin kendisi veya global yapılandırmalar
+için olarabilir. (global yapılandırma dosyası `~/.gitconfig`).
+
+```bash
+# Print & Set Some Basic Config Variables (Global)
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[git config hakkında daha fazla bilgi için.](http://git-scm.com/docs/git-config)
+
+### help
+
+Her bir komutun detaylı kılavuzuna hızlı bir erişim için. Ya da sadece bazı şeylerin
+anlamı için hızlı bir hatırlatıcı için.
+
+```bash
+# Quickly check available commands
+$ git help
+
+# Check all available commands
+$ git help -a
+
+# Command specific help - user manual
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+# or git <command_here> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### dosyaları ignore etme 
+
+git'in bazı dosya(ları) ve klasör(leri) kasıtlı olarak takip etmemesi için. Genel
+olarak,repository'de ne de olsa paylaşılacak, private ve temp dosyaları için.
+
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "private_key" >> .gitignore
+```
+
+### status
+
+index dosyası(temelde çalıştığın repo) ve mevcut HEAD commit arasındaki farkı göstermek için.
+
+```bash
+# Will display the branch, untracked files, changes and other differences
+$ git status
+
+# To learn other "tid bits" about git status
+$ git help status
+```
+
+### add
+
+Dosyaları staging area'ya eklemek için. Eğer yeni dosyaları staging area'ya `git add` 
+yapmazsanız, commit'lere eklenmez!
+
+```bash
+# add a file in your current working directory
+$ git add HelloWorld.java
+
+# add a file in a nested dir
+$ git add /path/to/file/HelloWorld.c
+
+# Regular Expression support!
+$ git add ./*.java
+
+# You can also add everything in your working directory to the staging area.
+$ git add -A
+```
+Bu yalnızca dosyayı staging area'a/index'e ekler, çalışılan dizine/repo'ya commit etmez.
+
+### branch
+
+Branch'ları yönetir. Bu komutu kullanarak, branch'ları görebilir, düzenleyebilir, oluşturabilir, silebilirsin.
+
+```bash
+# list existing branches & remotes
+$ git branch -a
+
+# create a new branch
+$ git branch myNewBranch
+
+# delete a branch
+$ git branch -d myBranch
+
+# rename a branch
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# edit a branch's description
+$ git branch myBranchName --edit-description
+```
+
+### tag
+
+tag'leri yönetir
+
+```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
+
+index'in versiyonun eşlemek için çalışma ağacındaki,veya belirtilen ağactaki, tüm dosyaları günceller.
+
+```bash
+# Checkout a repo - defaults to master branch
+$ git checkout
+
+# Checkout a specified branch
+$ git checkout branchName
+
+# Create a new branch & switch to it
+# equivalent to "git branch <name>; git checkout <name>"
+
+$ git checkout -b newBranch
+```
+
+### clone
+
+Varolan bir repository'i yeni bir dizine clone'lar veya kopyalar. 
+Ayrıca clone'lanmış repodaki her bir branch için, uzak branch'a bastırmana izin veren,
+uzak takip branch'ları ekler.
+
+```bash
+# Clone learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+
+# shallow clone - faster cloning that pulls only latest snapshot
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+
+# clone only a specific branch
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
+```
+
+### commit
+
+index'in mevcut içeriğini yeni bir "commit"te saklar. Bu commit, kullanıcının oluşturduğu
+bir mesajı ve yapılan değişiklikleri saklar. 
+
+```bash
+# commit with a message
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+
+# signed commit with a message (user.signingkey must have been set
+# with your GPG key e.g. git config --global user.signingkey 5173AAD5)
+$ git commit -S -m "signed commit message"
+
+# automatically stage modified or deleted files, except new files, and then commit
+$ git commit -a -m "Modified foo.php and removed bar.php"
+
+# change last commit (this deletes previous commit with a fresh commit)
+$ git commit --amend -m "Correct message"
+```
+
+### diff
+
+Shows differences between a file in the working directory, index and commits.
+Bir dosyanın, çalışma ağacı, index ve commit'ler arasındaki farklarını göster.
+
+```bash
+# Show difference between your working dir and the index
+$ git diff
+
+# Show differences between the index and the most recent commit.
+$ git diff --cached
+
+# Show differences between your working dir and the most recent commit
+$ git diff HEAD
+```
+
+### grep
+
+Bir repository'de hızlıca arama yapmana izin verir.
+
+İsteğe Bağlı Yapılandırmalar:
+
+```bash
+# Thanks to Travis Jeffery for these
+# Set line numbers to be shown in grep search results
+$ git config --global grep.lineNumber true
+
+# Make search results more readable, including grouping
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Search for "variableName" in all java files
+$ git grep 'variableName' -- '*.java'
+
+# Search for a line that contains "arrayListName" and, "add" or "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Daha fazla örnek için
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Repository'deki commitleri gösterir.
+
+```bash
+# Show all commits
+$ git log
+
+# Show only commit message & ref
+$ git log --oneline
+
+# Show merge commits only
+$ git log --merges
+
+# Show all commits represented by an ASCII graph
+$ git log --graph
+```
+
+### merge
+
+Dış commit'lerdeki değişiklikleri mevcut branch'a "merge" et (birleştir).
+
+```bash
+# Merge the specified branch into the current.
+$ git merge branchName
+
+# Always generate a merge commit when merging
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Bir dosyayı yeniden taşı veya yeniden adlandır
+
+```bash
+# Renaming a file
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Moving a file
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Force rename or move
+# "existingFile" already exists in the directory, will be overwritten
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Bir repository'den çeker ve diğer branch'a merge eder.
+
+```bash
+# Update your local repo, by merging in new changes
+# from the remote "origin" and "master" branch.
+# git pull <remote> <branch>
+$ git pull origin master
+
+# By default, git pull will update your current branch
+# by merging in new changes from its remote-tracking branch 
+$ git pull
+
+# Merge in changes from remote branch and rebase
+# branch commits onto your local repo, like: "git fetch <remote> <branch>, git 
+# rebase <remote>/<branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Bir branch'taki değişikleri, uzak branch'a bastır ve birleştir.
+
+```bash
+# Push and merge changes from a local repo to a
+# remote named "origin" and "master" branch.
+# git push <remote> <branch>
+$ git push origin master
+
+# By default, git push will push and merge changes from
+# the current branch to its remote-tracking branch 
+$ git push
+
+# To link up current local branch with a remote branch, add -u flag:
+$ git push -u origin master
+# Now, anytime you want to push from that same local branch, use shortcut:
+$ git push
+```
+
+### stash
+
+Stash'leme çalışma dizinindeki kirli durumu alır ve bitmemiş değişiklikler 
+yığınına kaydeder. Bu değişikleri istediğin zaman tekrar uygulayabilirsin.
+
+Mesela git repo'nda bazı işler yaptın ama remote'dan pull yapmak istiyorsun.
+Bazı dosyalarında kirli (commit'lenmemiş) değişiklikler olduğundan `git pull`
+yapamazsın. Onun yerine önce `git stash` ile değişikliklerini yığına kaydet!
+
+(stash, sözlük anlamı: bir şeyi, özel bir yere güvenli biçimde saklamak)
+
+```bash
+$ git stash
+Saved working directory and index state \
+  "WIP on master: 049d078 added the index file"
+  HEAD is now at 049d078 added the index file
+  (To restore them type "git stash apply")
+```
+
+Şimdi pull yapabilirsin!
+
+```bash
+git pull
+```
+`...changes apply...`
+
+Herşeyin tamam olduğunu kontrol et
+
+```bash
+$ git status
+# On branch master
+nothing to commit, working directory clean
+```
+Şu ana kadar neleri stash'lediğini `git stash list` kullanarak görebilirsin.
+Stash'lenen şeyler Son-Giren-İlk-Çıkar şeklinde tutulduğundan en son değişim
+en üste olacaktır.
+
+```bash
+$ git stash list
+stash@{0}: WIP on master: 049d078 added the index file
+stash@{1}: WIP on master: c264051 Revert "added file_size"
+stash@{2}: WIP on master: 21d80a5 added number to log
+```
+Şimdi de kirli değişiklileri yığından çıkarıp uygulayalım.
+
+```bash
+$ git stash pop
+# On branch master
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   index.html
+#      modified:   lib/simplegit.rb
+#
+```
+
+`git stash apply` da aynı şeyi yapar
+
+Şimdi kendi işine dönmeye hazırsın!
+
+[Ek Okuma.](http://git-scm.com/book/en/v1/Git-Tools-Stashing)
+
+### rebase (dikkat)
+
+Branch'ta commit'lenen tüm değişimleri al ve onları başka bir branch'ta tekrar oynat
+*Public repo'ya push edilmiş commit'leri rebase etme*
+
+```bash
+# Rebase experimentBranch onto master
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Ek Okuma.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (dikkat)
+
+Reset the current HEAD to the specified state. This allows you to undo merges,
+pulls, commits, adds, and more. It's a great command but also dangerous if you 
+don't know what you are doing.
+
+HEAD'i belirtilen duruma resetle. Bu merge'leri, pull'ları, commit'leri, add'leri
+ve daha fazlasını geriye almanı sağlar. Muhteşem bir komuttur ama aynı zamanda, ne
+yaptığını bilmiyorsan, tehlikelidir.
+
+```bash
+# Reset the staging area, to match the latest commit (leaves dir unchanged)
+$ git reset
+
+# Reset the staging area, to match the latest commit, and overwrite working dir
+$ git reset --hard
+
+# Moves the current branch tip to the specified commit (leaves dir unchanged)
+# all changes still exist in the directory.
+$ git reset 31f2bb1
+
+# Moves the current branch tip backward to the specified commit
+# and makes the working dir match (deletes uncommitted changes and all commits
+# after the specified commit).
+$ git reset --hard 31f2bb1
+```
+
+### reflog (dikkat)
+
+Reflog, verilen zaman içinde,default olarak 90 gündür, yaptığın git komutlarını listeler.
+
+Bu sana beklemediğin şekilde yanlış giden komutları geriye çevirme şansı verir. 
+(mesela, eğer bir rebase uygulamanı kırdıysa)
+
+Şu şekilde yapıbilirsin:
+
+1. `git reflog` rebase için tüm git komutlarını listele
+
+```
+38b323f HEAD@{0}: rebase -i (finish): returning to refs/heads/feature/add_git_reflog
+38b323f HEAD@{1}: rebase -i (pick): Clarify inc/dec operators
+4fff859 HEAD@{2}: rebase -i (pick): Update java.html.markdown
+34ed963 HEAD@{3}: rebase -i (pick): [yaml/en] Add more resources (#1666)
+ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748)
+2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d
+```
+2. Nereye reset'leyeceğini seç, şu durumda `2e6c386` veya `HEAD@{5}`
+3. 'git reset --hard HEAD@{5}' bu repo'nu seçilen head'e eşitler 
+4. Rebase'e yeniden başlayabilir veya onu yalnız bırakabilirsin.
+
+[Ek Okuma.](https://git-scm.com/docs/git-reflog)
+
+### revert
+
+Revert commit'leri geri almada kullanılır. Projenin durumunu önceki bir noktaya 
+alan reset ile karıştırılmamalıdır. Revert, belirtilen commit'in tersine yeni bir
+commit ekleyecektir.
+
+```bash
+# Revert a specified commit
+$ git revert <commit>
+```
+
+### rm
+
+git add'in tersine, git rm çalışma ağacından dosyaları kaldırır.
+
+```bash
+# remove HelloWorld.c
+$ git rm HelloWorld.c
+
+# Remove a file from a nested dir
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+## Daha Fazla Bilgi
+
+* [tryGit - Git'i öğrenmek için eğlenceli interaktif bir yol](http://try.github.io/levels/1/challenges/1)
+
+* [Git Dallanmayı Öğren -  Git'i web üzerinde öğrenmek için en görsel ve interaktif yol](http://learngitbranching.js.org/)
+
+* [Udemy Git Tutorial: Kapsayıcı bir kılavuz](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
+
+* [Git Immersion - Git'in temelinden başlayan bir tur](http://gitimmersion.com/)
+
+* [git-scm - Video Tutorial](http://git-scm.com/videos)
+
+* [git-scm - Dökümantasyon](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorial & Workflow](https://www.atlassian.com/git/)
+
+* [SalesForce Kopya Kağıdı](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
+
+* [Git - Basit bir kılavuz](http://rogerdudler.github.io/git-guide/index.html)
+
+* [Pro Git](http://www.git-scm.com/book/en/v2)
+
+* [Yeni başlayanlar için Git ve Github](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 1d600400..df642f73 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -30,7 +30,7 @@ JavaDoc-коментар виглядає так. Використовуєтьс
 
 // Імпорт класу ArrayList з пакета java.util
 import java.util.ArrayList;
-// Імпорт усіх класів з пакета java.security 
+// Імпорт усіх класів з пакета java.security
 import java.security.*;
 
 // Кожний .java файл містить один зовнішній публічний клас, ім’я якого співпадає
@@ -99,13 +99,13 @@ public class LearnJava {
 
         // Примітка: Java не має беззнакових типів.
 
-        // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754 
+        // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754
         // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
         // f або F використовується для позначення того, що змінна має тип float;
         // інакше трактується як double.
 
-        // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754 
+        // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754
         // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
@@ -130,13 +130,13 @@ public class LearnJava {
         // байтів, операції над ними виконуються функціями, які мають клас BigInteger
         //
         // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок.
-        
+
         BigInteger fooBigInteger = new BigInteger(fooByteArray);
 
 
         // BigDecimal — Незмінні знакові дробові числа довільної точності
         //
-        // BigDecimal складається з двох частин: цілого числа довільної точності 
+        // BigDecimal складається з двох частин: цілого числа довільної точності
         // з немасштабованим значенням та 32-бітного масштабованого цілого числа
         //
         // BigDecimal дозволяє розробникам контролювати десяткове округлення.
@@ -147,10 +147,10 @@ public class LearnJava {
         // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int).
 
         BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
-        
+
         // Для дотримання заданої точності рекомендується використовувати
-        // конструктор, який приймає String 
-        
+        // конструктор, який приймає String
+
         BigDecimal tenCents = new BigDecimal("0.1");
 
 
@@ -295,7 +295,7 @@ public class LearnJava {
             // Виконається 10 разів, fooFor 0->9
         }
         System.out.println("Значення fooFor: " + fooFor);
-        
+
         // Вихід із вкладеного циклу через мітку
         outer:
         for (int i = 0; i < 10; i++) {
@@ -306,7 +306,7 @@ public class LearnJava {
             }
           }
         }
-        
+
         // Цикл For Each
         // Призначений для перебору масивів та колекцій       
         int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};       
@@ -318,7 +318,7 @@ public class LearnJava {
 
         // Оператор вибору Switch Case
         // Оператор вибору працює з типами даних byte, short, char, int.
-        // Також працює з переліками Enum, 
+        // Також працює з переліками Enum,
         // класом String та класами-обгортками примітивних типів:
         // Character, Byte, Short та Integer.
         int month = 3;
@@ -334,7 +334,7 @@ public class LearnJava {
                      break;
         }
         System.out.println("Результат Switch Case: " + monthString);
-        
+
         // Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так:
         String myAnswer = "можливо";
         switch(myAnswer) {
@@ -398,7 +398,7 @@ public class LearnJava {
 
         // toString повертає рядкове представлення об’єкту.
         System.out.println("Інформація про об’єкт trek: " + trek.toString());
-        
+
         // У Java немає синтаксису для явного створення статичних колекцій.
         // Це можна зробити так:
 
@@ -554,7 +554,7 @@ public interface Digestible {
 
 // Можна створити клас, що реалізує обидва інтерфейси.
 public class Fruit implements Edible, Digestible {
-  
+
     @Override
     public void eat() {
         // ...
@@ -694,41 +694,41 @@ public abstract class Mammal()
 
 public enum Day {
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
-    THURSDAY, FRIDAY, SATURDAY 
+    THURSDAY, FRIDAY, SATURDAY
 }
 
 // Перелік Day можна використовувати так:
 
 public class EnumTest {
-    
+
     // Змінна того же типу, що й перелік
     Day day;
-    
+
     public EnumTest(Day day) {
         this.day = day;
     }
-    
+
     public void tellItLikeItIs() {
         switch (day) {
             case MONDAY:
-                System.out.println("Понеділкі важкі.");
+                System.out.println("Понеділки важкі.");
                 break;
-                    
+
             case FRIDAY:
                 System.out.println("П’ятниці краще.");
                 break;
-                         
-            case SATURDAY: 
+
+            case SATURDAY:
             case SUNDAY:
                 System.out.println("Вихідні найліпші.");
                 break;
-                        
+
             default:
                 System.out.println("Середина тижня так собі.");
                 break;
         }
     }
-    
+
     public static void main(String[] args) {
         EnumTest firstDay = new EnumTest(Day.MONDAY);
         firstDay.tellItLikeItIs(); // => Понеділки важкі.
@@ -737,7 +737,7 @@ public class EnumTest {
     }
 }
 
-// Переліки набагато потужніші, ніж тут показано. 
+// Переліки набагато потужніші, ніж тут показано.
 // Тіло переліків може містити методи та інші змінні.
 // Дивіться більше тут: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
 
diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 397b1c5e..6a64a623 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -45,7 +45,7 @@ doStuff()
 3; // = 3
 1.5; // = 1.5
 
-// Деякі прості арифметичні операції працють так, як ми очікуємо.
+// Деякі прості арифметичні операції працюють так, як ми очікуємо.
 1 + 1; // = 2
 0.1 + 0.2; // = 0.30000000000000004 (а деякі - ні)
 8 - 1; // = 7
@@ -106,7 +106,7 @@ null == undefined; // = true
 
 // ... але приведення не виконується при ===
 "5" === 5; // = false
-null === undefined; // = false 
+null === undefined; // = false
 
 // ... приведення типів може призвести до дивних результатів
 13 + !0; // 14
@@ -171,7 +171,7 @@ myArray[3] = "світ";
 // Об’єкти в JavaScript схожі на словники або асоціативні масиви в інших мовах
 var myObj = {key1: "Hello", key2: "World"};
 
-// Ключі - це рядки, але лапки не обов’язкі, якщо ключ задовольняє
+// Ключі - це рядки, але лапки не обов’язкові, якщо ключ задовольняє
 // правилам формування назв змінних. Значення можуть бути будь-яких типів.
 var myObj = {myKey: "myValue", "my other key": 4};
 
@@ -258,7 +258,7 @@ function myFunction(thing) {
     return thing.toUpperCase();
 }
 myFunction("foo"); // = "FOO"
- 
+
 // Зверніть увагу, що значення яке буде повернено, повинно починатися на тому ж
 // рядку, що і ключове слово return, інакше завжди буде повертатися значення undefined
 // через автоматичну вставку крапки з комою
@@ -332,7 +332,7 @@ var myObj = {
 };
 myObj.myFunc(); // = "Hello, world!"
 
-// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за 
+// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за
 // допомогою ключового слова this.
 myObj = {
     myString: "Hello, world!",
@@ -348,7 +348,7 @@ myObj.myFunc(); // = "Hello, world!"
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
-// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до 
+// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до
 // цього об’єкта через this
 var myOtherFunc = function() {
     return this.myString.toUpperCase();
@@ -371,7 +371,7 @@ Math.min(42, 6, 27); // = 6
 Math.min([42, 6, 27]); // = NaN (Ой-ой!)
 Math.min.apply(Math, [42, 6, 27]); // = 6
 
-// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт 
+// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт
 // використовують bind
 var boundFunc = anotherFunc.bind(myObj);
 boundFunc(" Hello!"); // = "Hello world, Hello!"
@@ -475,7 +475,7 @@ if (Object.create === undefined) { // не перезаписуємо метод
         // Створюємо правильний конструктор з правильним прототипом
         var Constructor = function(){};
         Constructor.prototype = proto;
-    
+
         return new Constructor();
     }
 }
diff --git a/zh-cn/fortran95-cn.html.markdown b/zh-cn/fortran95-cn.html.markdown
new file mode 100644
index 00000000..e28d309f
--- /dev/null
+++ b/zh-cn/fortran95-cn.html.markdown
@@ -0,0 +1,435 @@
+---
+language: Fortran
+filename: learnfortran-cn.f95
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+translators:
+    - ["Corvusnest", "https://github.com/Corvusnest"]
+lang: zh-cn
+---
+
+Fortran 是最古老的计算机语言之一。它由IBM开发于1950年用于数值运算（Fortran 为 "Formula
+Translation" 的缩写）。虽然该语言已年代久远，但目前仍用于高性能计算，如天气预报。
+该语言仍在持续发展，并且基本保持向下兼容。知名的版本为 Fortran 77, Fortran 90,
+Fortran 95, Fortran 2003, Fortran 2008 与 Fortran 2015。
+
+这篇概要将讨论 Fortran 95 的一些特征。因为它是目前所广泛采用的标准版本，并且与最新版本的内容
+也基本相同（而 Fortran 77 则是一个非常不同的版本）。
+
+```fortran
+
+! 这是一行注释
+
+
+program example   !声明一个叫做 example 的程序
+
+    ! 代码只能放在程序、函数、子程序或者模块内部
+    ! 推荐使用缩进，但不是必须的。
+
+    ! 声明变量
+    ! ===================
+
+    ! 所有的声明必须放在语句与表达式之前
+
+    implicit none    !阻止变量的隐式声明 (推荐!)
+    ! Implicit none 必须在每一个 函数/程序/模块 中进行声明
+
+    ! 重要  - Fortran 对大小写不敏感
+    real z
+    REAL Z2
+
+    real :: v,x    ! 警告: 默认值取决于编译器!    
+    real :: a = 3, b=2E12, c = 0.01
+    integer :: i, j, k=1, m
+    real, parameter :: PI = 3.1415926535897931    !声明一个常量
+    logical :: y = .TRUE. , n = .FALSE.    !布尔值
+    complex :: w = (0,1)    !sqrt(-1) (译注: 定义复数，此为-1的平方根)
+    character (len=3) :: month    !长度为3的字符串
+
+    real :: array(6)     !声明长度为6的浮点数数组
+    real, dimension(4) :: arrayb    !声明数组的另一种方法
+    integer :: arrayc(-10:10)   !有着自定义索引的数组
+    real :: array2d(3,2)    !多维数组
+
+    ! 分隔符 '::' 并不总是必要的，但推荐使用
+
+    ! 还存在很多其他的变量特征:
+    real, pointer :: p    !声明一个指针
+
+    integer, parameter :: LP = selected_real_kind(20)
+    real (kind = LP) :: d    !长精度变量
+
+    ! 警告：在声明期间初始化变量将导致在函数内发生问题，因为这将自动具备了 “save” 属性，
+    ! 因此变量的值在函数的多次调用期间将被存储。一般来说，除了常量，应分开声明与初始化！
+
+    ! 字符串
+    ! =======
+
+    character :: a_char = 'i'
+    character (len = 6) :: a_str = "qwerty"
+    character (len = 30) :: str_b
+    character (len = *), parameter :: a_long_str = "This is a long string."
+    !可以通过使用 (len=*) 来自动判断长度，但只对常量有效
+
+    str_b = a_str // " keyboard"    !通过 // 操作符来连接字符串
+
+
+    ! 任务与计算
+    ! =======================
+
+    Z = 1    !向之前声明的变量 z 赋值 (大小写不敏感).
+    j = 10 + 2 - 3
+    a = 11.54  /  (2.3 * 3.1)
+    b = 2**3    !幂
+
+
+    ! 控制流程语句 与 操作符
+    ! ===================================
+
+    !单行 if 语句
+    if (z == a) b = 4  !判别句永远需要放在圆括号内
+
+    if (z /= a) then !z 不等于 a
+    ! 其他的比较运算符： < > <= >= == /=
+      b = 4
+    else if (z .GT. a) then !z 大于(Greater) a
+    ! 文本形式的比较运算符: .LT. .GT. .LE. .GE. .EQ. .NE.  
+      b = 6
+    else if (z < a) then !'then' 必须放在该行
+      b = 5 !执行部分必须放在新的一行里
+    else
+      b = 10
+    end if !结束语句需要 'if' (也可以用 'endif').
+
+
+    if (.NOT. (x < c .AND. v >= a .OR. z == z)) then   !布尔操作符
+      inner: if (.TRUE.) then    !可以为 if 结构命名
+        b = 1
+      endif inner    !接下来必须命名 endif 语句.
+    endif
+
+
+    i = 20
+    select case (i)
+      case (0)    !当 i == 0
+        j=0
+      case (1:10)    !当 i 为 1 到 10 之内 ( 1 <= i <= 10 )
+        j=1
+      case (11:)    !当 i>=11
+        j=2
+      case default
+        j=3
+    end select
+
+
+    month = 'jan'
+    ! 状态值可以为整数、布尔值或者字符类型
+    ! Select 结构同样可以被命名
+    monthly: select case (month)
+      case ("jan")
+         j = 0
+      case default
+         j = -1
+    end select monthly
+
+    do i=2,10,2    !从2到10(包含2和10)以2为步进值循环
+      innerloop: do j=1,3    !循环同样可以被命名
+        exit    !跳出循环
+      end do innerloop
+    cycle    !重复跳入下一次循环
+    enddo
+
+
+    ! Goto 语句是存在的，但强烈不建议使用
+    goto 10    
+    stop 1    !立即停止程序 (返回一个设定的状态码).
+10  j = 201    !这一行被标注为 10 行 （line 10）
+
+
+    ! 数组
+    ! ======
+    array = (/1,2,3,4,5,6/)
+    array = [1,2,3,4,5,6]    !当使用 Fortran 2003 版本.
+    arrayb = [10.2,3e3,0.41,4e-5]
+    array2d =  reshape([1.0,2.0,3.0,4.0,5.0,6.0], [3,2])
+
+    ! Fortran 数组索引起始于 1
+    ! (默认下如此，也可以为数组定义不同的索引起始)
+    v = array(1)    !获取数组的第一个元素
+    v = array2d(2,2)
+
+    print *, array(3:5)    !打印从第3到第五5之内的所有元素
+    print *, array2d(1,:)    !打印2维数组的第一列
+
+    array = array*3 + 2    !可为数组设置数学表达式
+    array = array*array    !数组操作支持元素级(操作) (element-wise)
+    !array = array*array2d    !这两类数组并不是同一个维度的
+
+    ! 有很多内置的数组操作函数
+    c = dot_product(array,array)    !点乘 (点积)
+    ! 用 matmul() 来进行矩阵运算.
+    c = sum(array)
+    c = maxval(array)
+    print *, minloc(array)
+    c = size(array)
+    print *, shape(array)
+    m = count(array > 0)
+
+    ! 遍历一个数组 (一般使用 Product() 函数).
+    v = 1
+    do i = 1, size(array)
+        v = v*array(i)
+    end do
+
+    ! 有条件地执行元素级操作
+    array = [1,2,3,4,5,6]
+    where (array > 3)
+        array = array + 1
+    elsewhere (array == 2)
+        array = 1
+    elsewhere
+        array = 0
+    end where
+
+    ! 隐式DO循环可以很方便地创建数组
+    array = [ (i, i = 1,6) ]    !创建数组 [1,2,3,4,5,6]
+    array = [ (i, i = 1,12,2) ]    !创建数组 [1,3,5,7,9,11]
+    array = [ (i**2, i = 1,6) ]    !创建数组  [1,4,9,16,25,36]
+    array = [ (4,5, i = 1,3) ]    !创建数组 [4,5,4,5,4,5]
+
+
+    ! 输入/输出
+    ! ============
+
+    print *, b    !向命令行打印变量 'b'
+
+    ! 我们可以格式化输出
+    print "(I6)", 320    !打印 '   320'
+    print "(I6.4)", 3    !打印 '  0003'
+    print "(F6.3)", 4.32    !打印 ' 4.320'
+
+
+    ! 该字母与数值规定了给定的数值与字符所用于打印输出的类型与格式
+    ! 字母可为 I (整数), F (浮点数), E (工程格式),
+    ! L (逻辑/布尔值), A (字符) ...
+    print "(I3)", 3200    !如果数值无法符合格式将打印 '***'
+
+    ! 可以同时设定多种格式
+    print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
+    print "(3I5)", 10, 20, 30    !连续打印3个整数 (字段宽度 = 5).
+    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3   !连续分组格式
+
+    ! 我们也可以从终端读取输入
+    read *, v
+    read "(2F6.2)", v, x    !读取2个数值
+
+    ! 读取文件
+    open(unit=11, file="records.txt", status="old")
+    ! 文件被引用带有一个单位数 'unit', 为一个取值范围在9-99的整数
+    ! 'status' 可以为 {'old','replace','new'} 其中之一
+    read(unit=11, fmt="(3F10.2)") a, b, c
+    close(11)
+
+    ! 写入一个文件
+    open(unit=12, file="records.txt", status="replace")
+    write(12, "(F10.2,F10.2,F10.2)") c, b, a
+    close(12)
+    ! 在讨论范围之外的还有更多的细节与可用功能，并于老版本的 Fortran 保持兼容
+
+
+    ! 内置函数
+    ! ==================
+
+    ! Fortran 拥有大约 200 个内置函数/子程序
+    ! 例子
+    call cpu_time(v)    !以秒为单位设置时间
+    k = ior(i,j)    !2个整数的位或运算
+    v = log10(x)    !以10为底的log运算
+    i = floor(b)    !返回一个最接近的整数小于或等于x (地板数)
+    v = aimag(w)    !复数的虚数部分
+
+
+    ! 函数与子程序
+    ! =======================
+
+    ! 一个子程序会根据输入值运行一些代码并会导致副作用 (side-effects) 或修改输入值
+    ! (译者注: 副作用是指对子程序/函数外的环境产生影响，如修改变量)
+
+    call routine(a,c,v)    !调用子程序
+
+    ! 一个函数会根据输入的一系列数值来返回一个单独的值
+    ! 但输入值仍然可能被修改以及产生副作用
+
+    m = func(3,2,k)  !调用函数
+
+    ! 函数可以在表达式内被调用
+    Print *, func2(3,2,k)
+
+    ! 一个纯函数不会去修改输入值或产生副作用
+    m = func3(3,2,k)
+
+
+contains ! 用于定义程序内部的副程序(sub-programs)的区域
+
+    ! Fortran 拥有一些不同的方法去定义函数
+
+    integer function func(a,b,c)    !一个返回一个整数的函数
+        implicit none   !最好也在函数内将含蓄模式关闭 (implicit none)
+        integer :: a,b,c !输入值类型定义在函数内部
+        if (a >= 2) then
+            func = a + b + c !返回值默认为函数名
+            return !可以在函数内任意时间返回当前值
+        endif
+        func = a + c
+        ! 在函数的结尾不需要返回语句
+    end function func
+
+
+    function func2(a,b,c) result(f)    !将返回值声明为 'f'
+        implicit none
+        integer, intent(in) :: a,b    !可以声明让变量无法被函数修改
+        integer, intent(inout) :: c
+        integer :: f     !函数的返回值类型在函数内声明
+        integer :: cnt = 0    !注意 - 隐式的初始化变量将在函数的多次调用间被存储
+        f = a + b - c
+        c = 4    !变动一个输入变量的值
+        cnt  = cnt + 1    !记录函数的被调用次数
+    end function func2
+
+
+    pure function func3(a,b,c)  !一个没有副作用的纯函数
+        implicit none
+        integer, intent(in) :: a,b,c
+        integer :: func3
+        func3 = a*b*c
+    end function func3
+
+
+    subroutine routine(d,e,f)
+        implicit none
+        real, intent(inout) :: f
+        real, intent(in) :: d,e
+        f = 2*d + 3*e + f
+    end subroutine routine
+
+
+end program example   ! 函数定义完毕 -----------------------
+
+! 函数与子程序的外部声明对于生成程序清单来说，需要一个接口声明（即使它们在同一个源文件内）(见下)
+! 使用 'contains' 可以很容易地在模块或程序内定义它们
+
+elemental real function func4(a) result(res)
+! 一个元函数(elemental function) 为一个纯函数使用一个标量输入值
+! 但同时也可以用在一个数组并对其中的元素分别处理，之后返回一个新的数组
+    real, intent(in) :: a
+    res = a**2 + 1.0
+end function func4
+
+
+! 模块
+! =======
+
+! 模块十分适合于存放与复用相关联的一组声明、函数与子程序
+
+module fruit
+    real :: apple
+    real :: pear
+    real :: orange
+end module fruit
+
+
+module fruity
+
+    ! 声明必须按照顺序: 模块、接口、变量
+    ! (同样可在程序内声明模块和接口)
+
+    use fruit, only: apple, pear    ! 使用来自于 fruit 模块的 apple 和 pear
+    implicit none    !在模块导入后声明
+
+    private    !使得模块内容为私有(private)(默认为公共 public)
+    ! 显式声明一些变量/函数为公共
+    public :: apple,mycar,create_mycar
+    ! 声明一些变量/函数为私有(在当前情况下没必要)(译注: 因为前面声明了模块全局 private)
+    private :: func4
+
+    ! 接口
+    ! ==========
+    ! 在模块内显式声明一个外部函数/程序
+    ! 一般最好将函数/程序放进 'contains' 部分内
+    interface
+        elemental real function func4(a) result(res)
+            real, intent(in) :: a
+        end function func4
+    end interface
+
+    ! 重载函数可以通过已命名的接口来定义
+    interface myabs
+        ! 可以通过使用 'module procedure' 关键词来包含一个已在模块内定义的函数
+        module procedure real_abs, complex_abs
+    end interface
+
+    ! 派生数据类型
+    ! ==================
+    ! 可创建自定义数据结构
+    type car
+        character (len=100) :: model
+        real :: weight    !(公斤 kg)
+        real :: dimensions(3)    !例: 长宽高(米)
+        character :: colour
+    end type car
+
+    type(car) :: mycar    !声明一个自定义类型的变量
+    ! 用法具体查看 create_mycar()
+
+    ! 注: 模块内没有可执行的语句
+
+contains
+
+    subroutine create_mycar(mycar)
+        ! 展示派生数据类型的使用
+        implicit none
+        type(car),intent(out) :: mycar
+
+        ! 通过 '%' 操作符来访问(派生数据)类型的元素
+        mycar%model = "Ford Prefect"
+        mycar%colour = 'r'
+        mycar%weight = 1400
+        mycar%dimensions(1) = 5.0    !索引默认起始值为 1 !
+        mycar%dimensions(2) = 3.0
+        mycar%dimensions(3) = 1.5
+
+    end subroutine
+
+    real function real_abs(x)
+        real :: x
+        if (x<0) then
+            real_abs = -x
+        else
+            real_abs = x
+        end if
+    end function real_abs
+
+    real function complex_abs(z)
+        complex :: z
+        ! 过长的一行代码可通过延续符 '&' 来换行
+        complex_abs = sqrt(real(z)**2 + &
+                                         aimag(z)**2)
+    end function complex_abs
+
+
+end module fruity
+
+```
+
+### 更多资源
+
+了解更多的 Fortran 信息:
+
++ [wikipedia](https://en.wikipedia.org/wiki/Fortran)
++ [Fortran_95_language_features](https://en.wikipedia.org/wiki/Fortran_95_language_features)
++ [fortranwiki.org](http://fortranwiki.org)
++ [www.fortran90.org/](http://www.fortran90.org)
++ [list of Fortran 95 tutorials](http://www.dmoz.org/Computers/Programming/Languages/Fortran/FAQs%2C_Help%2C_and_Tutorials/Fortran_90_and_95/)
++ [Fortran wikibook](https://en.wikibooks.org/wiki/Fortran)
++ [Fortran resources](http://www.fortranplus.co.uk/resources/fortran_resources.pdf)
++ [Mistakes in Fortran 90 Programs That Might Surprise You](http://www.cs.rpi.edu/~szymansk/OOF90/bugs.html)