20 files changed, 1529 insertions, 52 deletions

diff --git a/zh-cn/bf-cn.html.markdown b/zh-cn/bf-cn.html.markdown
index 6cea3012..2d2a114a 100644
--- a/zh-cn/bf-cn.html.markdown
+++ b/zh-cn/bf-cn.html.markdown
@@ -1,11 +1,13 @@
 ---
 language: bf
-lang: zh-cn
+filename: brainfuck-cn.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["lyuehh", "https://github.com/lyuehh"]
+lang: zh-cn
+
 ---
 
 Brainfuck 是一个极小的只有8个指令的图灵完全的编程语言。
diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown
index 1e10416e..02ec7f7b 100644
--- a/zh-cn/c-cn.html.markdown
+++ b/zh-cn/c-cn.html.markdown
@@ -41,7 +41,7 @@ enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
 void function_1(char c);
 void function_2(void);
 
-// 如果函数出现在main()之后，那么必须在main()之前
+// 如果函数调用在main()之后，那么必须在main()之前
 // 先声明一个函数原型
 int add_two_ints(int x1, int x2); // 函数原型
 
diff --git a/zh-cn/crystal-cn.html.markdown b/zh-cn/crystal-cn.html.markdown
new file mode 100644
index 00000000..14805114
--- /dev/null
+++ b/zh-cn/crystal-cn.html.markdown
@@ -0,0 +1,567 @@
+---
+language: crystal
+filename: learncrystal-cn.cr
+contributors:
+    - ["Vitalii Elenhaupt", "http://veelenga.com"]
+    - ["Arnaud Fernandés", "https://github.com/TechMagister/"]
+translators:
+    - ["Xuty", "https://github.com/xtyxtyx"]
+lang: zh-cn
+---
+
+```crystal
+
+# 这是一行注释
+
+# 一切都是对象(object)
+nil.class  #=> Nil
+100.class  #=> Int32
+true.class #=> Bool
+
+# nil, false 以及空指针是假值(falsey values)
+!nil   #=> true  : Bool
+!false #=> true  : Bool
+!0     #=> false : Bool
+
+# 整数类型
+
+1.class #=> Int32
+
+# 四种有符号整数
+1_i8.class  #=> Int8
+1_i16.class #=> Int16
+1_i32.class #=> Int32
+1_i64.class #=> Int64
+
+# 四种无符号整数
+1_u8.class  #=> UInt8
+1_u16.class #=> UInt16
+1_u32.class #=> UInt32
+1_u64.class #=> UInt64
+
+2147483648.class          #=> Int64
+9223372036854775808.class #=> UInt64
+
+# 二进制数
+0b1101 #=> 13 : Int32
+
+# 八进制数
+0o123 #=> 83 : Int32
+
+# 十六进制数
+0xFE012D #=> 16646445 : Int32
+0xfe012d #=> 16646445 : Int32
+
+# 浮点数类型
+
+1.0.class #=> Float64
+
+# Crystal中有两种浮点数
+1.0_f32.class #=> Float32
+1_f32.class   #=> Float32
+
+1e10.class    #=> Float64
+1.5e10.class  #=> Float64
+1.5e-7.class  #=> Float64
+
+# 字符类型
+
+'a'.class #=> Char
+
+# 八进制字符
+'\101' #=> 'A' : Char
+
+# Unicode字符
+'\u0041' #=> 'A' : Char
+
+# 字符串
+
+"s".class #=> String
+
+# 字符串不可变(immutable)
+s = "hello, "  #=> "hello, "        : String
+s.object_id    #=> 134667712        : UInt64
+s += "Crystal" #=> "hello, Crystal" : String
+s.object_id    #=> 142528472        : UInt64
+
+# 支持字符串插值(interpolation)
+"sum = #{1 + 2}" #=> "sum = 3" : String
+
+# 多行字符串
+"这是一个
+   多行字符串"
+
+# 书写带有引号的字符串
+%(hello "world") #=> "hello \"world\""
+
+# 符号类型
+# 符号是不可变的常量，本质上是Int32类型
+# 符号通常被用来代替字符串，来高效地传递特定的值
+
+:symbol.class #=> Symbol
+
+sentence = :question?     # :"question?" : Symbol
+
+sentence == :question?    #=> true  : Bool
+sentence == :exclamation! #=> false : Bool
+sentence == "question?"   #=> false : Bool
+
+# 数组类型(Array)
+
+[1, 2, 3].class         #=> Array(Int32)
+[1, "hello", 'x'].class #=> Array(Int32 | String | Char)
+
+# 必须为空数组指定类型
+[]               # Syntax error: for empty arrays use '[] of ElementType'
+[] of Int32      #=> [] : Array(Int32)
+Array(Int32).new #=> [] : Array(Int32)
+
+# 数组可以通过下标访问
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] : Array(Int32)
+array[0]                #=> 1               : Int32
+array[10]               # raises IndexError
+array[-6]               # raises IndexError
+array[10]?              #=> nil             : (Int32 | Nil)
+array[-6]?              #=> nil             : (Int32 | Nil)
+
+# 使用负位置编号，从后往前访问数组
+array[-1] #=> 5
+
+# With a start index and size
+# 使用起始位置编号+大小
+array[2, 3] #=> [3, 4, 5]
+
+# 使用范围(range)访问数组
+array[1..3] #=> [2, 3, 4]
+
+# 向尾部添加元素
+array << 6  #=> [1, 2, 3, 4, 5, 6]
+
+# 删除尾部元素
+array.pop #=> 6
+array     #=> [1, 2, 3, 4, 5]
+
+# 删除首部元素
+array.shift #=> 1
+array       #=> [2, 3, 4, 5]
+
+# 检查元素是否存在与数组之中
+array.includes? 3 #=> true
+
+# 一种特殊语法，用来创建字符串数组或符号数组
+%w(one two three) #=> ["one", "two", "three"] : Array(String)
+%i(one two three) #=> [:one, :two, :three]    : Array(Symbol)
+
+# 对于定义了`new`和`#<<`方法的类，可以用以下语法创建新对象
+set = Set{1, 2, 3} #=> [1, 2, 3]
+set.class          #=> Set(Int32)
+
+# 以下代码与上方等同
+set = Set(typeof(1, 2, 3)).new
+set << 1
+set << 2
+set << 3
+
+# 哈希表类型(Hash)
+
+{1 => 2, 3 => 4}.class   #=> Hash(Int32, Int32)
+{1 => 2, 'a' => 3}.class #=> Hash(Int32 | Char, Int32)
+
+# 必须为空哈希表指定类型
+{}                     # Syntax error
+{} of Int32 => Int32   # {}
+Hash(Int32, Int32).new # {}
+
+# 可以使用键(key)快速查询哈希表
+hash = {"color" => "green", "number" => 5}
+hash["color"]        #=> "green"
+hash["no_such_key"]  #=> Missing hash key: "no_such_key" (KeyError)
+hash["no_such_key"]? #=> nil
+
+# 检查某一键哈希表中是否存在
+hash.has_key? "color" #=> true
+
+# 对于定义了`#[]=`方法的类，可以使用以下语法创建对象
+class MyType
+  def []=(key, value)
+    puts "do stuff"
+  end
+end
+
+MyType{"foo" => "bar"}
+
+# 以上与下列代码等同
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+# 范围类型(Range)
+
+1..10                  #=> Range(Int32, Int32)
+Range.new(1, 10).class #=> Range(Int32, Int32)
+
+# 包含或不包含端点
+(3..5).to_a  #=> [3, 4, 5]
+(3...5).to_a #=> [3, 4]
+
+# 检查某一值是否在范围内
+(1..8).includes? 2 #=> true
+
+# 元组类型(Tuple)
+
+# 元组类型尺寸固定，不可变，储存在栈中
+# 元组可以有不同类型的对象组成
+{1, "hello", 'x'}.class #=> Tuple(Int32, String, Char)
+
+# 使用下标访问元组
+tuple = {:key1, :key2}
+tuple[1] #=> :key2
+tuple[2] #=> syntax error : Index out of bound
+
+# 将元组中的元素赋值给变量
+a, b, c = {:a, 'b', "c"}
+a #=> :a
+b #=> 'b'
+c #=> "c"
+
+# 命名元组类型(NamedTuple)
+
+tuple = {name: "Crystal", year: 2011} # NamedTuple(name: String, year: Int32)
+tuple[:name] # => "Crystal" (String)
+tuple[:year] # => 2011      (Int32)
+
+# 命名元组的键可以是字符串常量
+{"this is a key": 1} # => NamedTuple("this is a key": Int32)
+
+# 过程类型(Proc)
+# 过程代表一个函数指针，以及可选的上下文(闭包)
+# 过程通常使用字面值创建
+proc = ->(x : Int32) { x.to_s }
+proc.class # Proc(Int32, String)
+
+# 或者使用`new`方法创建
+Proc(Int32, String).new { |x| x.to_s }
+
+# 使用`call`方法调用过程
+proc.call 10 #=> "10"
+
+# 控制语句(Control statements)
+
+if true
+  "if 语句"
+elsif false
+  "else-if, 可选"
+else
+  "else, 同样可选"
+end
+
+puts "可以将if后置" if true
+
+# 将if作为表达式
+a = if 2 > 1
+      3
+    else
+      4
+    end
+
+a #=> 3
+
+# 条件表达式
+a = 1 > 2 ? 3 : 4 #=> 4
+
+# `case`语句
+cmd = "move"
+
+action = case cmd
+  when "create"
+    "Creating..."
+  when "copy"
+    "Copying..."
+  when "move"
+    "Moving..."
+  when "delete"
+    "Deleting..."
+end
+
+action #=> "Moving..."
+
+# 循环
+index = 0
+while index <= 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+index = 0
+until index > 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# 更好的做法是使用`each`
+(0..3).each do |index|
+  puts "Index: #{index}"
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# 变量的类型取决于控制语句中表达式的类型
+if a < 3
+  a = "hello"
+else
+  a = true
+end
+typeof a #=> (Bool | String)
+
+if a && b
+  # 此处`a`与`b`均为Nil
+end
+
+if a.is_a? String
+  a.class #=> String
+end
+
+# 函数(Functions)
+
+def double(x)
+  x * 2
+end
+
+# 函数(以及所有代码块)均将最末尾表达式的值作为返回值
+double(2) #=> 4
+
+# 在没有歧义的情况下，括号可以省略
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# 使用逗号分隔参数
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# 所有函数都有一个默认生成、可选的代码块(block)参数
+# 在函数中可以使用yield调用此代码块
+
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts "hello world" }
+
+# {
+# hello world
+# }
+
+
+# 可将代码块作为参数传给函数
+# "&" 表示对代码块参数的引用
+def guests(&block)
+  block.call "some_argument"
+end
+
+# 使用星号"*"将参数转换成元组
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# 如果函数返回数组，可以将其解构
+def foods
+    ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast #=> "pancake"
+dinner    #=> "quesadilla"
+
+# 按照约定，所有返回布尔值的方法都以问号结尾
+5.even? # false
+5.odd?  # true
+
+# 以感叹号结尾的方法，都有一些破坏性(destructive)行为，比如改变调用接收者(receiver)
+# 对于某些方法，带有感叹号的版本将改变调用接收者，而不带有感叹号的版本返回新值
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald"  #=> "Donald Mifflin"
+company_name  #=> "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name  #=> "Donald Mifflin"
+
+
+# 使用`class`关键字来定义类(class)
+class Human
+
+  # 类变量，由类的所有实例所共享
+  @@species = "H. sapiens"
+
+  # `name`的类型为`String`
+  @name : String
+
+  # 构造器方法(initializer)
+  # 其中@name、@age为简写，相当于
+  #
+  # def initialize(name, age = 0)
+  #   @name = name
+  #   @age = age
+  # end
+  #
+  # `age`为可选参数，如果未指定，则使用默认值0
+  def initialize(@name, @age = 0)
+  end
+
+  # @name的setter方法
+  def name=(name)
+    @name = name
+  end
+
+  # @name的getter方法
+  def name
+    @name
+  end
+
+  # 上述getter与setter的定义可以用property宏简化
+  property :name
+
+  # 也可用getter与setter宏独立创建getter与setter
+  getter :name
+  setter :name
+
+  # 此处的`self.`使`say`成为类方法
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# 将类实例化
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# 调用一些实例方法
+jim.species #=> "H. sapiens"
+jim.name #=> "Jim Halpert"
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.name #=> "Jim Halpert II"
+dwight.species #=> "H. sapiens"
+dwight.name #=> "Dwight K. Schrute"
+
+# 调用类方法
+Human.say("Hi") #=> 输出 Hi ，返回 nil
+
+# 带有`@`前缀的变量为实例变量
+class TestClass
+  @var = "I'm an instance var"
+end
+
+# 带有`@@`前缀的变量为类变量
+class TestClass
+  @@var = "I'm a class var"
+end
+# 首字母大写的变量为常量
+Var = "这是一个常量"
+Var = "无法再次被赋值" # 常量`Var`已经被初始化
+
+# 在crystal中类也是对象(object)，因此类也有实例变量(instance variable)
+# 类变量的定义由类以及类的派生类所共有，但类变量的值是独立的
+
+# 基类
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# 派生类
+class Worker < Human
+end
+
+Human.foo   #=> 0
+Worker.foo  #=> 0
+
+Human.foo = 2 #=> 2
+Worker.foo    #=> 0
+
+Worker.foo = 3 #=> 3
+Human.foo   #=> 2
+Worker.foo  #=> 3
+
+module ModuleExample
+  def foo
+    "foo"
+  end
+end
+
+# include <Module> 将模块(module)中的方法添加为实例方法
+# extend <Module>  将模块中的方法添加为类方法
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => undefined method 'foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => undefined method 'foo' for Book
+
+
+# 异常处理
+
+# 定义新的异常类(exception)
+class MyException < Exception
+end
+
+# 再定义一个异常类
+class MyAnotherException < Exception; end
+
+ex = begin
+   raise MyException.new
+rescue ex1 : IndexError
+  "ex1"
+rescue ex2 : MyException | MyAnotherException
+  "ex2"
+rescue ex3 : Exception
+  "ex3"
+rescue ex4 # 捕捉任何类型的异常
+  "ex4"
+end
+
+ex #=> "ex2"
+
+```
+
+## 参考资料
+
+- [官方网站](https://crystal-lang.org/)
+- [官方文档](https://crystal-lang.org/docs/overview/)
+- [在线运行代码](https://play.crystal-lang.org/#/cr)
+- [Github仓库](https://github.com/crystal-lang/crystal)
diff --git a/zh-cn/dart-cn.html.markdown b/zh-cn/dart-cn.html.markdown
index 6a6562bc..b0287f0c 100644
--- a/zh-cn/dart-cn.html.markdown
+++ b/zh-cn/dart-cn.html.markdown
@@ -492,8 +492,8 @@ main() {
 
 Dart 有一个综合性网站。它涵盖了 API 参考、入门向导、文章以及更多，
 还包括一个有用的在线试用 Dart 页面。
-http://www.dartlang.org/
-http://try.dartlang.org/
+* [https://www.dartlang.org](https://www.dartlang.org)
+* [https://try.dartlang.org](https://try.dartlang.org)
 
 
 
diff --git a/zh-cn/elisp-cn.html.markdown b/zh-cn/elisp-cn.html.markdown
index 06f38d77..3f6ccbcf 100644
--- a/zh-cn/elisp-cn.html.markdown
+++ b/zh-cn/elisp-cn.html.markdown
@@ -293,7 +293,7 @@ lang: zh-cn
  

 (hello-to-bonjour)

  

-;; 给这些名字上个色:

+;; 给这些名字加粗:

  

 (defun boldify-names ()

     (switch-to-buffer-other-window "*test*")

@@ -340,5 +340,6 @@ lang: zh-cn
 ;; - Kevin Montuori

 ;; - Arne Babenhauserheide

 ;; - Alan Schmitt

+;; - spacegoing

 ```

 

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)
diff --git a/zh-cn/go-cn.html.markdown b/zh-cn/go-cn.html.markdown
index 75498367..37b4b137 100644
--- a/zh-cn/go-cn.html.markdown
+++ b/zh-cn/go-cn.html.markdown
@@ -142,6 +142,7 @@ func learnTypes() {
 func learnNamedReturns(x, y int) (z int) {
     z = x * y
     return // z is implicit here, because we named it earlier.
+}
 
 // Go全面支持垃圾回收。Go有指针，但是不支持指针运算。
 // 你会因为空指针而犯错，但是不会因为增加指针而犯错。
diff --git a/zh-cn/groovy-cn.html.markdown b/zh-cn/groovy-cn.html.markdown
index 562a0284..0e7a020c 100644
--- a/zh-cn/groovy-cn.html.markdown
+++ b/zh-cn/groovy-cn.html.markdown
@@ -219,10 +219,12 @@ for (i in array) {
 
 //遍历映射
 def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
-x = 0
+x = ""
 for ( e in map ) {
     x += e.value
+    x += " "
 }
+assert x.equals("Roberto Grails Groovy ")
 
 /*
   运算符
diff --git a/zh-cn/java-cn.html.markdown b/zh-cn/java-cn.html.markdown
index 1e9c38f6..27003f3e 100644
--- a/zh-cn/java-cn.html.markdown
+++ b/zh-cn/java-cn.html.markdown
@@ -108,7 +108,7 @@ public class LearnJava {
         boolean [] booleanArray = new boolean[100];
 
         // 声明并初始化数组也可以这样:
-        int [] y = {9000, 1000, 1337};
+        int [] intArray = {9000, 1000, 1337};
 
         // 随机访问数组中的元素
         System.out.println("intArray @ 0: " + intArray[0]);
@@ -309,7 +309,7 @@ class Bicycle {
         name = "Bontrager";
     }
 
-    // 一下是一个含有参数的构造函数
+    // 以下是一个含有参数的构造函数
     public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
         this.gear = startGear;
         this.cadence = startCadence;
diff --git a/zh-cn/javascript-cn.html.markdown b/zh-cn/javascript-cn.html.markdown
index bdef0099..360f7c65 100644
--- a/zh-cn/javascript-cn.html.markdown
+++ b/zh-cn/javascript-cn.html.markdown
@@ -12,12 +12,9 @@ translators:
 lang: zh-cn
 ---
 
-Javascript于1995年由网景公司的Brendan Eich发明。
-最初发明的目的是作为一个简单的网站脚本语言，来作为
-复杂网站应用java的补充。但由于它与网页结合度很高并且由浏览器内置支持，
-所以javascript变得比java在前端更为流行了。
+Javascript 于 1995 年由网景公司的 Brendan Eich 发明。最初它作为一种简单的，用于开发网站的脚本语言而被发明出来，是用于开发复杂网站的 Java 的补充。但由于它与网页结合度很高并且在浏览器中得到内置的支持，所以在网页前端领域 Javascript 变得比 Java 更流行了。
 
-不过 JavaScript 可不仅仅只用于浏览器： Node.js，一个基于Google Chrome V8引擎的独立运行时环境，也越来越流行。
+不过，Javascript 不仅用于网页浏览器，一个名为 Node.js 的项目提供了面向 Google Chrome V8 引擎的独立运行时环境，它正在变得越来越流行。
 
 很欢迎来自您的反馈，您可以通过下列方式联系到我：
 [@adambrenecki](https://twitter.com/adambrenecki), 或者
diff --git a/zh-cn/kotlin-cn.html.markdown b/zh-cn/kotlin-cn.html.markdown
index 5d655029..f6dcd847 100644
--- a/zh-cn/kotlin-cn.html.markdown
+++ b/zh-cn/kotlin-cn.html.markdown
@@ -22,7 +22,7 @@ package com.learnxinyminutes.kotlin
 
 /*
 Kotlin程序的入口点是一个"main"函数
-该函数传递一个包含任何命令行参数的数组。
+该函数传递一个包含所有命令行参数的数组。
 */
 fun main(args: Array<String>) {
     /*
@@ -67,10 +67,10 @@ fun helloWorld(val name : String) {
     模板表达式从一个美元符号($)开始。
     */
     val fooTemplateString = "$fooString has ${fooString.length} characters"
-    println(fooTemplateString)
+    println(fooTemplateString) // => 输出 My String Is Here! has 18 characters
 
     /*
-    当某个变量的值可以为 null 的时候，我们必须被明确指定它是可为空的。
+    当某个变量的值可以为 null 的时候，我们必须明确指定它是可为空的。
     在变量声明处的类型后面加上?来标识它是可为空的。
     我们可以用?.操作符来访问可为空的变量。
     我们可以用?:操作符来指定一个在变量为空时使用的替代值。
@@ -96,24 +96,24 @@ fun helloWorld(val name : String) {
     println(hello()) // => Hello, world!
 
     /*
-    用"vararg"关键字来修饰一个函数的参数来允许可变参数传递给该函数
+    函数的可变参数可使用 "vararg" 关键字来修饰
     */
     fun varargExample(vararg names: Int) {
         println("Argument has ${names.size} elements")
     }
-    varargExample() // => Argument has 0 elements
-    varargExample(1) // => Argument has 1 elements
-    varargExample(1, 2, 3) // => Argument has 3 elements
+    varargExample() // => 传入 0 个参数
+    varargExample(1) // => 传入 1 个参数
+    varargExample(1, 2, 3) // => 传入 3 个参数
 
     /*
-    当函数只包含一个单独的表达式时，大括号可以被省略。
-    函数体可以被指定在一个=符号后面。
+    当函数只包含一个单独的表达式时，大括号可以省略。
+    函数体可以写在一个=符号后面。
     */
     fun odd(x: Int): Boolean = x % 2 == 1
     println(odd(6)) // => false
     println(odd(7)) // => true
 
-    // 如果返回值类型可以被推断，那么我们不需要指定它。
+    // 如果返回值类型可以推断，那么我们不需要指定它。
     fun even(x: Int) = x % 2 == 0
     println(even(6)) // => true
     println(even(7)) // => false
@@ -122,15 +122,14 @@ fun helloWorld(val name : String) {
     fun not(f: (Int) -> Boolean) : (Int) -> Boolean {
         return {n -> !f.invoke(n)}
     }
-    // 命名函数可以用::运算符被指定为参数。
+    // 普通函数可以用::运算符传入引用作为函数参数。
     val notOdd = not(::odd)
     val notEven = not(::even)
-    // 匿名函数可以被指定为参数。
+    // lambda 表达式可以直接作为参数传递。
     val notZero = not {n -> n == 0}
     /*
-    如果一个匿名函数只有一个参数
-    那么它的声明可以被省略（连同->）。
-    这个参数的名字是"it"。
+    如果一个 lambda 表达式只有一个参数
+    那么它的声明可以省略（连同->），内部以 "it" 引用。
     */
     val notPositive = not {it > 0}
     for (i in 0..4) {
@@ -152,7 +151,7 @@ fun helloWorld(val name : String) {
     注意，Kotlin没有"new"关键字。
     */
     val fooExampleClass = ExampleClass(7)
-    // 可以使用一个点号来调用成员函数。
+    // 可以使用一个点号来调用成员方法。
     println(fooExampleClass.memberFunction(4)) // => 11
     /*
     如果使用"infix"关键字来标记一个函数
@@ -162,7 +161,7 @@ fun helloWorld(val name : String) {
 
     /*
     数据类是创建只包含数据的类的一个简洁的方法。
-    "hashCode"、"equals"和"toString"方法将被自动生成。
+    "hashCode"、"equals"和"toString"方法将自动生成。
     */
     data class DataClassExample (val x: Int, val y: Int, val z: Int)
     val fooData = DataClassExample(1, 2, 4)
diff --git a/zh-cn/livescript-cn.html.markdown b/zh-cn/livescript-cn.html.markdown
index fea00bc1..cc7daab1 100644
--- a/zh-cn/livescript-cn.html.markdown
+++ b/zh-cn/livescript-cn.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: LiveScript
-filename: learnLivescript.ls
+filename: learnLivescript-cn.ls
 contributors:
     - ["Christina Whyte", "http://github.com/kurisuwhyte/"]
 translators:
diff --git a/zh-cn/make-cn.html.markdown b/zh-cn/make-cn.html.markdown
new file mode 100644
index 00000000..4cdf1e63
--- /dev/null
+++ b/zh-cn/make-cn.html.markdown
@@ -0,0 +1,262 @@
+---
+language: make
+contributors:
+- ["Robert Steed", "https://github.com/robochat"]
+- ["Jichao Ouyang", "https://github.com/jcouyang"]
+translators:
+- ["Jichao Ouyang", "https://github.com/jcouyang"]
+filename: Makefile-cn
+lang: zh-cn
+---
+
+Makefile 用于定义如何创建目标文件, 比如如何从源码到可执行文件. 创建这一工具的目标是
+减少不必要的编译或者任务.是传说中的 Stuart Feldman 在 1976 年花了一个周末写出来的, 
+而今仍然使用广泛, 特别是在 Unix 和 Linux 系统上.
+
+虽然每个语言可能都有相应的或多或少提供 make 的功能, 比如 ruby 的 rake, node 的 gulp, broccoli
+, scala 的 sbt 等等. 但是 make 的简洁与高效, 和只做一件事并做到极致的风格, 使其至今仍是无可替代的,
+甚至与其他构建工具一起使用也并无冲突.
+
+尽管有许多的分支和变体, 这篇文章针对是标准的 GNU make.
+
+```make
+# 这行表示注释
+
+# 文件名一定要交 Makefile, 大小写区分, 使用 `make <target>` 生成 target
+# 如果想要取别的名字, 可以用 `make -f "filename" <target>`.
+
+# 重要的事情 - 只认识 TAB, 空格是不认的, 但是在 GNU Make 3.82 之后, 可以通过
+# 设置参数 .RECIPEPREFIX 进行修改
+
+#-----------------------------------------------------------------------
+# 初级
+#-----------------------------------------------------------------------
+
+# 创建一个 target 的规则非常简单
+# targets : prerequisites
+# 	recipe
+# 	 …
+# prerequisites(依赖) 是可选的, recipe(做法) 也可以多个或者不给.
+
+# 下面这个任务没有给 prerequisites, 只会在目标文件 file0.txt 文件不存在是跑
+file0.txt:
+	echo "foo" > file0.txt
+	# 试试 `make file0.txt`
+	# 或者直接 `make`, 因为第一个任务是默认任务.
+	# 注意: 即使是这些注释, 如果前面有 TAB, 也会发送给 shell, 注意看 `make file0.txt` 输出
+
+# 如果提供 prerequisites, 则只有 prerequisites 比 target 新时会执行
+# 比如下面这个任务只有当 file1.txt 比 file0.txt 新时才会执行.
+file1.txt: file0.txt
+	cat file0.txt > file1.txt
+	# 这里跟shell里的命令式一毛一样的.
+	@cat file0.txt >> file1.txt
+	# @ 不会把命令往 stdout 打印.
+	-@echo 'hello'
+	# - 意思是发生错误了也没关系.
+	# 试试 `make file1.txt` 吧.
+
+# targets 和 prerequisites 都可以是多个, 以空格分割
+file2.txt file3.txt: file0.txt file1.txt
+	touch file2.txt
+	touch file3.txt
+
+# 如果声明重复的 target, make 会给一个 warning, 后面会覆盖前面的
+# 比如重复定义 file2.txt 会得到这样的 warning
+# Makefile:46: warning: overriding commands for target `file2.txt'
+# Makefile:40: warning: ignoring old commands for target `file2.txt'
+file2.txt: file0.txt
+	touch file2.txt
+
+# 但是如果不定义任何 recipe, 就不会冲突, 只是多了依赖关系
+file2.txt: file0.txt file3.txt
+
+#-----------------------------------------------------------------------
+# Phony(假的) Targets
+#-----------------------------------------------------------------------
+
+# phony targets 意思是 tagets 并不是文件, 可以想象成一个任务的名字而已.
+# 因为不是文件, 无法比对是否有更新, 所以每次make都会执行.
+all: maker process
+
+# 依赖于 phony target 的 target 也会每次 make 都执行, 即使 target 是文件
+ex0.txt ex1.txt: maker
+
+# target 的声明顺序并不重要, 比如上面的 all 的依赖 maker 现在才声明
+maker:
+	touch ex0.txt ex1.txt
+
+# 如果定义的 phony target 与文件名重名, 可以用 .PHONY 显示的指明哪些 targets 是 phony
+.PHONY: all maker process
+# This is a special target. There are several others.
+
+# 常用的 phony target 有: all clean install ...
+
+#-----------------------------------------------------------------------
+# 变量与通配符
+#-----------------------------------------------------------------------
+
+process: file*.txt | dir/a.foo.b	# 可以用通配符匹配多个文件作为prerequisites
+	@echo $^	# $^ 是 prerequisites
+	@echo $@	# $@ 代表 target, 如果 target 为多个, $@ 代表当前执行的那个
+	@echo $<	# $< prerequisite 中的第一个
+	@echo $?	# $? 需要更新的 prerequisite 文件列表
+	@echo $+	# $+ 所有依赖, 包括重复的
+	@echo $|	# $| 竖线后面的 order-only prerequisites
+
+a.%.b:
+	@echo $*  # $* match 的target % 那部分, 包括路径, 比如 `make dir/a.foo.b` 会打出 `dir/foo`
+
+# 即便分开定义依赖, $^ 依然能拿到
+process: ex1.txt file0.txt
+# 非常智能的, ex1.txt 会被找到, file0.txt 会被去重.
+
+#-----------------------------------------------------------------------
+# 模式匹配
+#-----------------------------------------------------------------------
+
+# 可以让 make 知道如何转换某些文件到别格式
+# 比如 从 svg 到 png
+%.png: %.svg
+	inkscape --export-png $^
+
+# 一旦有需要 foo.png 这个任务就会运行
+
+# 路径会被忽略, 所以上面的 target 能匹配所有 png
+# 但是如果加了路径, make 会找到最接近的匹配, 如果
+# make small/foo.png (在这之前要先有 small/foo.svg 这个文件)
+# 则会匹配下面这个规则
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+%.png: %.svg
+	@echo 重复定义会覆盖前面的, 现在 inkscape 没用了
+
+# make 已经有一些内置的规则, 比如从 *.c 到 *.o
+
+#-----------------------------------------------------------------------
+# 变量
+#-----------------------------------------------------------------------
+# 其实是宏 macro
+
+# 变量都是字符串类型, 下面这俩是一样一样的
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # 这个会被蠢蠢的解析成 $(n)ame.
+	@echo \"$(name3)\" # 为声明的变量或扩展成空字符串.
+	@echo $(name4)
+	@echo $(name5)
+# 你可以通过4种方式设置变量.
+# 按以下顺序由高到低:
+# 1: 命令行参数. 比如试试 `make echo name3=JICHAO`
+# 2: Makefile 里面的
+# 3: shell 中的环境变量
+# 4: make 预设的一些变量
+
+name4 ?= Jean
+# 问号意思是如果 name4 被设置过了, 就不设置了.
+
+override name5 = David
+# 用 override 可以防止命令行参数设置的覆盖
+
+name4 +=grey
+# 用加号可以连接 (中间用空格分割).
+
+# 在依赖的地方设置变量
+echo: name2 = Sara2
+
+# 还有一些内置的变量
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX)}
+	echo $(FC)
+	echo ${CFLAGS)}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# 变量 2
+#-----------------------------------------------------------------------
+
+# 加个冒号可以声明 Simply expanded variables 即时扩展变量, 即只在声明时扩展一次
+# 之前的等号声明时 recursively expanded 递归扩展
+
+var := hello
+var2 :=  $(var) hello
+
+# 这些变量会在其引用的顺序求值
+# 比如 var3 声明时找不到 var4, var3 会扩展成 `and good luck`
+var3 := $(var4) and good luck
+# 但是一般的变量会在调用时递归扩展, 先扩展 var5, 再扩展 var4, 所以是正常的
+var5 = $(var4) and good luck
+var4 := good night
+
+echoSEV:
+	@echo $(var)
+	@echo $(var2)
+	@echo $(var3)
+	@echo $(var4)
+	@echo $(var5)
+
+#-----------------------------------------------------------------------
+# 函数
+#-----------------------------------------------------------------------
+
+# make 自带了一些函数.
+# wildcard 会将后面的通配符变成一串文件路径
+all_markdown:
+	@echo $(wildcard *.markdown)
+# patsubst 可以做替换, 比如下面会把所有 markdown
+# 后缀的文件重命名为 md 后缀
+substitue: *
+	@echo $(patsubst %.markdown,%.md,$* $^)
+
+# 函数调用格式是 $(func arg0,arg1,arg2...)
+
+# 试试
+ls:	*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Directives
+#-----------------------------------------------------------------------
+
+# 可以用 include 引入别的 Makefile 文件
+# include foo.mk
+
+sport = tennis
+# 一些逻辑语句 if else 什么的, 顶个写
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# 还有 ifneq, ifdef, ifndef
+
+foo = true
+
+# 不只是 recipe, 还可以写在外面哟
+ifdef $(foo)
+bar = 'bar'
+endif
+
+hellobar:
+	@echo bar
+```
+
+### 资源
+
++ GNU Make 官方文档 [HTML](https://www.gnu.org/software/make/manual/) [PDF](https://www.gnu.org/software/make/manual/make.pdf)
++ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/)
++ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
diff --git a/zh-cn/markdown-cn.html.markdown b/zh-cn/markdown-cn.html.markdown
index 87ed46ad..e9a8aeb2 100644
--- a/zh-cn/markdown-cn.html.markdown
+++ b/zh-cn/markdown-cn.html.markdown
@@ -13,7 +13,7 @@ Markdown 由 John Gruber 于 2004年创立. 它旨在成为一门容易读写的
 欢迎您多多反馈以及分支和请求合并。
 
 
-```markdown
+```md
 <!-- Markdown 是 HTML 的父集，所以任何 HTML 文件都是有效的 Markdown。
 这意味着我们可以在 Markdown 里使用任何 HTML 元素，比如注释元素，
 且不会被 Markdown 解析器所影响。不过如果你在 Markdown 文件内创建了 HTML 元素，
diff --git a/zh-cn/matlab-cn.html.markdown b/zh-cn/matlab-cn.html.markdown
index 77ba765a..2fbccfc4 100644
--- a/zh-cn/matlab-cn.html.markdown
+++ b/zh-cn/matlab-cn.html.markdown
@@ -1,11 +1,13 @@
 ---

 language: Matlab

+filename: matlab-cn.m

 contributors:

     - ["mendozao", "http://github.com/mendozao"]

     - ["jamesscottbrown", "http://jamesscottbrown.com"]

 translators:

     - ["sunxb10", "https://github.com/sunxb10"]

 lang: zh-cn

+

 ---

 

 MATLAB 是 MATrix LABoratory （矩阵实验室）的缩写，它是一种功能强大的数值计算语言，在工程和数学领域中应用广泛。

diff --git a/zh-cn/python3-cn.html.markdown b/zh-cn/python3-cn.html.markdown
index 76455a46..211ce0c5 100644
--- a/zh-cn/python3-cn.html.markdown
+++ b/zh-cn/python3-cn.html.markdown
@@ -568,13 +568,14 @@ def double_numbers(iterable):
         yield i + i
 
 # 生成器只有在需要时才计算下一个值。它们每一次循环只生成一个值，而不是把所有的
-# 值全部算好。这意味着double_numbers不会生成大于15的数字。
+# 值全部算好。
 #
 # range的返回值也是一个生成器，不然一个1到900000000的列表会花很多时间和内存。
 #
 # 如果你想用一个Python的关键字当作变量名，可以加一个下划线来区分。
 range_ = range(1, 900000000)
 # 当找到一个 >=30 的结果就会停
+# 这意味着 `double_numbers` 不会生成大于30的数。
 for i in double_numbers(range_):
     print(i)
     if i >= 30:
diff --git a/zh-cn/red-cn.html.markdown b/zh-cn/red-cn.html.markdown
new file mode 100644
index 00000000..85812990
--- /dev/null
+++ b/zh-cn/red-cn.html.markdown
@@ -0,0 +1,208 @@
+---
+name: Red
+category: language
+language: Red
+filename: LearnRed-zh.red
+contributors:
+    - ["Arnold van Hofwegen", "https://github.com/iArnold"]
+translators:
+    - ["Limo Saplf", "https://github.com/saplf"]
+lang: zh-cn
+---
+
+Red 的编写是出于工作需要，该语言的作者想要使用 REBOL，但它有许多缺陷。
+当时 REBOL 还没有开源，由于它是一门解释型语言，这就意味着它比编译型语言效率低。
+
+Red 使用 C 语言级别的 Red/System，是一门涉及所有编程领域的语言。
+Red 基于 REBOL 编写，它继承了 REBOL 的灵活性，同时也包含了许多 C 语言能做的底层实现。
+
+Red 将会成为世界上第一门全栈式编程语言，这意味着它可以完成几乎所有的编程任务，从底层到抽象，无需其他工具的参与。
+而且，Red 支持交叉编译，任意两个平台之间，不需要任何 GCC 之类的工具链的支持。
+所有的工作，仅仅需要一个不到 1 MB 的二进制可执行文件。
+
+准备好你的 Red 第一课了吗？
+
+```red
+所有 header 之前的文字都是注释，只要你不使用 "red" 关键字，其中的 "r" 大写。
+这是词法分析器的一个缺陷，所以大多数时候，你都应该直接以 header 开始程序或者脚本的编写。
+
+red 脚本的 header 由关键字，首字母大写的 "red" 开始，后跟一个空格，再跟一对方括号 []。
+方括号里可以写上一些关于这段脚本或者程序的相关信息：
+作者，文件名，版本号，license，程序功能的简介，它依赖的其他文件。
+red/System 的 header 和 red header 类似，仅仅是说明 "red/System" 而非 "red"。
+
+
+Red []
+
+; 这是一条行注释
+
+print "Hello Red World"    ; 另一条注释
+
+comment {
+    这是多行注释。
+    你刚刚看到的就是 Red 版的 Hello World。
+}
+
+; 程序的入口就是第一句可执行的代码
+; 不需要把它放在 'main' 函数里
+
+; 变量名以一个字母开始，可以包含数字，
+; 只包含 A ~ F 字符和数字的变量名不能以 'h' 结尾，
+; 因为这是 Red 和 Red/System 中十六进制数字的表达方式。
+
+; 给变量赋值使用冒号 ":"
+my-name: "Red"
+reason-for-using-the-colon: {使用冒号作为赋值符号
+ 是为了能够让 "=" 能够用来作为比较符号，这本来就是 "="
+ 存在的意义！还记得上学时学的，y = x + 1 、 x = 1，
+ 以及推导出的 y = 2 吗？
+}
+is-this-name-valid?: true
+
+; 用 print 打印输出，prin 打印不带换行的输出
+
+prin "我的名字是 " print my-name
+; 我的名字是 Red
+
+print ["我的名字是 " my-name lf]
+; 我的名字是 Red
+
+; 注意到了吗：语句没有以分号结尾 ;-)
+
+;
+; 数据类型
+;
+; 如果你了解 Rebol，你可能就会注意到它有许多数据类型。
+; Red 并没有囊括它所有的类型，但由于 Red 想要尽可能的
+; 接近 Rebol，所以它也会有很多数据类型。
+; 类型以叹号结尾，但要注意，变量名也是可以以叹号结尾的。
+; 一些内置类型有 integer! string! block!
+
+; 使用变量前需要声明吗？
+; Red 能够分辨什么时候使用什么变量，变量声明并非必要的。
+; 一般认为，声明变量是较好的编码实践，但 Red 并不会强制这点。
+; 你可以声明一个变量然后指定它的类型，而一个变量的类型就
+; 指定了它的字节大小。
+
+; integer! 类型的变量通常是 4 字节，32位
+my-integer: 0
+; Red 的整型包含符号，暂时不支持无符号类型，但以后会支持的。
+
+; 怎样判断一个变量的类型？
+type? my-integer
+; integer!
+
+; 一个变量的初始化可以使用另一个同样刚刚初始化的变量：
+i2: 1 + i1: 1
+
+; 算数运算符
+i1 + i2 ; 3
+i2 - i1 ; 1
+i2 * i1 ; 2
+i1 / i2 ; 0 (0.5，但截取为 0)
+
+; 比较运算符都差不多，但和其他语言不一样的是相等的比较，
+; Red 使用单个的 '='。
+; Red 有一个类似 boolean 的类型，它的值是 true 和 false，
+; 但也可以使用 on/off 或者 yes/on
+
+3 = 2  ; false
+3 != 2 ; true
+3 > 2  ; true
+3 < 2  ; false
+2 <= 2 ; true
+2 >= 2 ; true
+
+;
+; 控制流
+;
+; if
+; 如果给定的条件为 true 则执行一段代码块。
+; if 没有返回值，所以不能用作表达式。
+if a < 0 [print "a 是负值"]
+
+; either
+; 如果给定的条件为 true 则执行一段代码块，否则就
+; 执行另一段可选的代码块。如果两个代码块中最后一个表达式
+; 的类型相同， either 就可以用作表达式。
+either a > 0 [
+    msg: "正值"
+][
+    either a = 0 [
+        msg: "零"
+    ][
+        msg: "负值"
+    ]
+]
+print ["a 是 " msg lf]
+
+; 还可以有另一种写法
+; （因为两条路径的返回值相同，所以可以这么写）：
+
+msg: either a > 0 [
+    "正值"
+][
+    either a = 0 [
+        "零"
+    ][
+        "负值"
+    ]
+]
+print ["a 是 " msg lf]
+
+; util
+; 循环执行一段代码块，直到满足给定的条件为止。
+; util 没有返回值，所以它不能用在表示式中。
+c: 5
+util [
+    prin "o"
+    c: c - 1
+    c = 0    ; 终止循环的条件
+]
+; 输出：ooooo
+; 需要注意的是，即使条件从一开始就不满足，
+; 这个循环也至少会执行一次。
+
+; while
+; 当满足给定的条件，就执行一段代码。
+; while 没有返回值，不能用在表达式中。
+c: 5
+while [c > 0][
+    prin "o"
+    c: c - 1
+]
+; 输出：ooooo
+
+;
+; 函数
+;
+; 函数示例
+twice: function [a [integer!] /one return: [integer!]][
+        c: 2
+        a: a * c
+        either one [a + 1][a]
+]
+b: 3
+print twice b      ; 输出 6
+
+; 使用 #include 和 %文件名 来导入外部文件
+#include %includefile.red
+; 现在就可以使用 includefile.red 中的函数了。
+
+```
+
+## 更进一步
+
+Red 相关的源码信息在 [Red 语言主页](http://www.red-lang.org)。
+
+源代码的 [github 库](https://github.com/red/red)。
+
+Red/System 特性在 [这里](http://static.red-lang.org/red-system-specs-light.html)。
+
+想要了解更多关于 Rebol 和 Red 的信息，加入 [Gitter 聊天室](https://gitter.im/red/red)。如果你无法加入，也可以给我们发[邮件](mailto:red-langNO_SPAM@googlegroups.com)。
+
+也可以在 [Stack Overflow](stackoverflow.com/questions/tagged/red) 上查阅、提交问题。
+
+也许你现在就要试一试 Red ？可以在线尝试 [try Rebol and Red site](http://tryrebol.esperconsultancy.nl)。
+
+你也可以通过学习一些 [Rebol](http://www.rebol.com/docs.html) 来学习 Red。
diff --git a/zh-cn/swift-cn.html.markdown b/zh-cn/swift-cn.html.markdown
index cba9252d..c25b2918 100644
--- a/zh-cn/swift-cn.html.markdown
+++ b/zh-cn/swift-cn.html.markdown
@@ -445,47 +445,47 @@ if let circle = myEmptyCircle {
 // 枚举可以像类一样，拥有方法
 
 enum Suit {
-    case Spades, Hearts, Diamonds, Clubs
+    case spades, hearts, diamonds, clubs
     func getIcon() -> String {
         switch self {
-        case .Spades: return "♤"
-        case .Hearts: return "♡"
-        case .Diamonds: return "♢"
-        case .Clubs: return "♧"
+        case .spades: return "♤"
+        case .hearts: return "♡"
+        case .diamonds: return "♢"
+        case .clubs: return "♧"
         }
     }
 }
 
 // 当变量类型明确指定为某个枚举类型时，赋值时可以省略枚举类型
-var suitValue: Suit = .Hearts
+var suitValue: Suit = .hearts
 
 // 非整型的枚举类型需要在定义时赋值
 enum BookName: String {
-    case John = "John"
-    case Luke = "Luke"
+    case john = "John"
+    case luke = "Luke"
 }
-print("Name: \(BookName.John.rawValue)")
+print("Name: \(BookName.john.rawValue)")
 
 // 与特定数据类型关联的枚举
 enum Furniture {
     // 和 Int 型数据关联的枚举记录
-    case Desk(height: Int)
+    case desk(height: Int)
     // 和 String, Int 关联的枚举记录
-    case Chair(brand: String, height: Int)
+    case chair(brand: String, height: Int)
 
     func description() -> String {
         switch self {
-        case .Desk(let height):
+        case .desk(let height):
             return "Desk with \(height) cm"
-        case .Chair(let brand, let height):
+        case .chair(let brand, let height):
             return "Chair of \(brand) with \(height) cm"
         }
     }
 }
 
-var desk: Furniture = .Desk(height: 80)
+var desk: Furniture = .desk(height: 80)
 print(desk.description())     // "Desk with 80 cm"
-var chair = Furniture.Chair(brand: "Foo", height: 40)
+var chair = Furniture.chair(brand: "Foo", height: 40)
 print(chair.description())    // "Chair of Foo with 40 cm"
 
 
diff --git a/zh-cn/typescript-cn.html.markdown b/zh-cn/typescript-cn.html.markdown
index 2651b1cb..032f89e4 100644
--- a/zh-cn/typescript-cn.html.markdown
+++ b/zh-cn/typescript-cn.html.markdown
@@ -153,7 +153,7 @@ var pairToTuple = function<T>(p: Pair<T>) {
 var tuple = pairToTuple({ item1:"hello", item2:"world"});
 
 // 引用定义文件
-// <reference path="jquery.d.ts" />
+/// <reference path="jquery.d.ts" />
 
 // 模板字符串(使用反引号的字符串)
 // 嵌入变量的模板字符串
diff --git a/zh-cn/visualbasic-cn.html.markdown b/zh-cn/visualbasic-cn.html.markdown
index 59f18fe2..e30041b3 100644
--- a/zh-cn/visualbasic-cn.html.markdown
+++ b/zh-cn/visualbasic-cn.html.markdown
@@ -5,10 +5,10 @@ contributors:
 translators:
     - ["Abner Chou", "http://cn.abnerchou.me"]
 lang: zh-cn
-filename: learnvisualbasic.vb-cn
+filename: learnvisualbasic-cn.vb
 ---
 
-```vb
+```
 Module Module1
 
     Sub Main()
@@ -77,7 +77,7 @@ Module Module1
     ' 使用 private subs 声明函数。 
     Private Sub HelloWorldOutput()
         ' 程序名
-        Console.Title = "Hello World Ouput | Learn X in Y Minutes"
+        Console.Title = "Hello World Output | Learn X in Y Minutes"
         ' 使用 Console.Write("") 或者 Console.WriteLine("") 来输出文本到屏幕上
         ' 对应的 Console.Read() 或 Console.Readline() 用来读取键盘输入
         Console.WriteLine("Hello World")