rasefon (Raw)

Ruby china 代码里面的一个问题。

rasefon — Fri, 14 Aug 2015 10:33:19 +0800

请教各位一个问题。最近看了下 ruby china 的源代码，有个叫做 Cpanel 的是用在哪里的啊？……

云梯现在是不是挂了？

rasefon — Mon, 27 Jul 2015 21:03:57 +0800

貌似始终连不上。。

uglifier 实在太慢了，建议大家用 closure-compiler

rasefon — Thu, 09 Jul 2015 17:13:59 +0800

同样的 precompile, uglifier 花了 5 小时，closure 只花了一分钟！

淫神好像把他的博客搬家到了简书了。。。

rasefon — Mon, 26 Jan 2015 17:18:34 +0800

http://www.yinwang.org/ 有粉丝跟上么？

好玩的遗传算法。

rasefon — Sat, 10 Jan 2015 00:18:12 +0800

之前有位同学问了个问题，关于随机数生成的，我想了想觉得用遗传算法是很好玩的，具体题目请见： https://ruby-china.org/topics/23514

如何实现，请看：

$pm = 0.01
$cluster_num = 20
$result = nil

def gen_rands(n, lb, rb)
  rands = []
  n.times do
    r = rand(lb..rb)
    rands << r
  end
  rands
end

def gen_rands_arr(arr_num, n, lb, rb)
  rands_arr = []
  arr_num.times do 
    rands_arr << gen_rands(n, lb, rb)
  end
  rands_arr
end

def fit(sum, all_rands)
  total_p = 0.0
  curr_p_arr = []
  all_rands.each do |rands|
    curr_p = 0.0;
    rands.each { |r| curr_p += r }
    delta = sum-curr_p
    if delta == 0
      $result=rands
      return
    end
    curr_p = 1.0/(delta)
    curr_p = curr_p.abs
    curr_p_arr << curr_p
    total_p += curr_p
  end

  fit_arr = []
  fit_arr << curr_p_arr[0]/total_p
  curr_p_arr.each_index do |i|
    next if i == 0
    fit_arr << fit_arr[i-1] + curr_p_arr[i]/total_p
  end

  fit_arr
end

def ga(sum, n, lb, rb)
  rands_arr = gen_rands_arr($cluster_num, n, lb, rb)
  fit_arr = fit(sum, rands_arr)
  while $result.nil?
    fit_arr = fit(sum, rands_arr)
    return unless $result.nil?
    selector_arr = []
    $cluster_num.times do
      selector_arr << rand()
    end

    selected_rands_indexs = Array.new($cluster_num, 0)
    selector_arr.each do |s|
      # binary search
      low = 0
      high = fit_arr.size
      while low <= high
        middle = (low+high)/2
        if fit_arr[middle] >= s
          high = middle-1
        else
          low = middle+1
        end
      end
      selected_rands_indexs[low] += 1
    end

    next_gen_rands_arr = []
    k = 0
    while k < $cluster_num do
      i = 0
      while selected_rands_indexs[i] == 0
        i += 1
      end
      selected_rands_indexs[i] -= 1

      j = i+1
      while selected_rands_indexs[j] == 0
        j += 1
      end
      j = i if j == $cluster_num
      selected_rands_indexs[j] -= 1

      next_gen_rands1 = []
      next_gen_rands2 = []
      # 随机交叉点
      r1 = rand(0..n-1)
      r2 = rand(0..n-1)
      if r1 > r2
        tmp = r1
        r1 = r2
        r2 = tmp
      end 

      for ii in 0..(r1-1) do
        next_gen_rands1[ii] = rands_arr[i][ii]
        next_gen_rands2[ii] = rands_arr[j][ii]
      end
      for jj in (r2+1)..(n-1) do
        next_gen_rands1[jj] = rands_arr[i][jj]
        next_gen_rands2[jj] = rands_arr[j][jj]
      end
      # 交换基因
      for kk in r1..r2 do 
        next_gen_rands1[kk] = rands_arr[j][kk]
        next_gen_rands2[kk] = rands_arr[i][kk]
      end
      # 忽略修复重复基因

      #新种群
      next_gen_rands_arr[k] = next_gen_rands1
      next_gen_rands_arr[k+1] = next_gen_rands2
      k+=2
    end

    next_gen_rands_arr.each do |r|
      #突变
      pm = rand()
      if pm < $pm
        #发生突变
        #突变点
        pi = rand(0..n-1)
        new_rand = rand(lb..rb)
        r[pi] = new_rand
      end
    end
    rands_arr = next_gen_rands_arr

    rands_arr.each do |rands|
      curr_p=0
      rands.each { |r| curr_p += r }
      delta = sum-curr_p
      if delta == 0
        $result=rands
        return
      end
    end
  end
end

ga 80000, 100, 4, 1300
p $result.sort

Rails 集成 ActiveX

rasefon — Sun, 04 Jan 2015 10:51:25 +0800

各位有没有试过用 rails 做带 ActiveX 控件的 server？不知道可不可行。

变态版五子棋。

rasefon — Sun, 07 Dec 2014 11:01:07 +0800

最近写了个变态版五子棋。规则如下：每人走 2 步，两步不能走在相邻的位置，即第二步不能走在第一步周围 8 个格子。

前端用 html5 canvas 后端 ror ai 用 cpp，socket 和 ror 通信。

代码： https://github.com/rasefon/gobang_server https://github.com/rasefon/gobang

The unix-haters handbook

rasefon — Fri, 25 Jul 2014 12:46:58 +0800

http://web.mit.edu/~simsong/www/ugh.pdf 挺有意的。

一个简易的读取文件字符的系统，可用于词法分析。

rasefon — Tue, 03 Jun 2014 13:47:12 +0800

这里没有 C 语言节点，所以就放在 Go 下面了。（能加一个么？）这个输入系统，主要是用于词法分析的读取，自己写一个是基于效率方面的考量，通常用流实现的的文件读取库，到了应用层，都会额外多一次字符拷贝的动作，比如 fopen 就会要求提供一个 char[] buf 作为输入参数，自己写的就可以避免这种浪费。具体代码在这里：https://github.com/rasefon/RWInputSys 另外程序还没仔细测试过，之后应该会把测试加上。

如何自制正则表达式引擎 (一)

rasefon — Thu, 22 May 2014 23:02:24 +0800

昨天发了个贴，讲 LL 预测分析表的自动生成（http://ruby-china.org/topics/19459），正好借机说一说如何自己做一个正则表达式的引擎。打算分以下几个篇章，理论结合实践，我会一步步用 ruby 来实现一个引擎：

LL 预测分析表的生成
NFA 构造
NFA 转 DFA
DFA 最小化

今天把 LL 预测分析表完成了，代码放在：https://github.com/rasefon/LLTableGenerator 由于时间太晚要睡觉了，我会争取这两天把第一篇完成。

分割线，今天先更新一部分，具体算法的详细解析放在下回。

def next_token
   # Get next token from lexema buffer.
end

def T
   F()
   T1()
   #do something
end

def F
   if "(" == next_token()
      T()
      if ")" == next_token()
         # do something
      else
         # Error!
      end
   elsif id() == next_token()
      # do something
   else
      # Error!
   end
end

def T1
   if "*" == next_token()
      F()
      T1()
      # do something
   else
      # Error!
   end
end

# Start parsing...
T()

在"do something'处可以插入用于构造 NFA 模型的代码。注意此处文法都是右递归的，左递归的文法无法用于自顶向下的文法解析算法，所以要先把文法从左递归转成右递归。递归下降算法优点是简单，缺点是有回溯，效率低，且不容易扩展变更。所以我们可以先做一个 LL 语法解析器的自动生成器，就像 yacc 那样（基于 LALR 算法）。这样生成一个 LL 预测分析表以后，我们就可以进行无回溯的文法解析。下面说下如何构造 LL 预测分析表. 构造预测表，首先我们需要读取语法描述文件，语法描述文件是我自定义的，这里给出一个例子：

``
token: tPlus, tMul, tLp, tRp, tEnd
token: tId
# nil is predefined keyword.
``
$Start: E
E:    T,E1
E1:   tPlus,T,E1
E1:   nil
T:    F,T1
T1:   tMul,F,T1
T1:   nil
F:    F1
F1:   tLp,E,tRp
F1:   tId

''如同 yacc 里的%% 第一部分是定义 token 集，第二部分是定义文法。在此给出解析此文件，并生成临时文法规则数据结构的简单算法：

$start_lside_rule = ""
$token_list = Set.new
$gram_list = Hash.new
$first_set = Hash.new
$follow_set = Hash.new
# For ll table construction
$nonterm_token_list = [] # [E, F, T, ...]
$single_gram_list = [] # [{T->[E,tRp]}, ...]
$input_tokens = ["$"]
$ll_table = nil

def construct_table_model(rule_file_name)
   lines = IO.readlines(rule_file_name) 
   lines = lines.map { |l| l.chomp }
   token_def_phase = false
   rule_def_phase = false
   # temporarily record left side tokens and right tokens as string.
   lines.each do |line|
      # skip comment
      next if "#" == line[0]
      # Start token define phase.
      if "``" == line
         if !token_def_phase
            token_def_phase = true
         else
            token_def_phase = false
            rule_def_phase = true
         end
         next
      end

      if token_def_phase
         line.split(':')[1].split(',').each { |t| $token_list.add(t.strip) }
      elsif rule_def_phase
         rule = line.split(':').map { |item| item.strip }
         if "$Start" == rule[0]
            $start_lside_rule = rule[1]
         else
            rhs = rule[1].split(',').map { |r| r.strip }
            if $gram_list.has_key?(rule[0])
               # merge right side rule
               $gram_list[rule[0]] = $gram_list[rule[0]] << rhs
            else
               $gram_list[rule[0]] = [] << rhs
            end
         end
      end
   end
   $input_tokens.concat($token_list.to_a)
end

这个方法会生成一个全局的$token_list 集合，一个$input_tokens 的所有可能的输入 tokens 数组（即 token_list 加上终结符"$"），一个表示语法的$gram_list.

LL 预测分析表需要两个集合，一个是 First 集合，一个是 Follow 集合，首先给出构造这两者的算法，然后再说明这两个集合的用处，以及具体的构造步骤： First 集合：

def construct_first_set()
   #first to add all the terminal and 'nil' into the FIRST set.
   $gram_list.each do |lhs, rhs_arr|
      unless $first_set.has_key?(lhs)
         $first_set[lhs] = Set.new
      end

      rhs_arr.each do |rhs|
         if $token_list.include?(rhs.first) or "nil" == rhs.first
            $first_set[lhs].add(rhs.first)
         end
      end
   end
   # loop computing first set until no new item is added.
   changed = true
   while (changed)
      changed = false
      $gram_list.each do |lhs, rhs_arr|
         rhs_arr.each do |rhs|
            # If the first item of the rhs token is terminal or 'nil', just skip it because the token had already been
            # added in previous loop.
            next if $token_list.include?(rhs.first) or "nil" == rhs.first

            count = 0
            rhs.each do |rhs_term|
               # If 'nil' is contained in FIRST set of rhs_term, skip to the next term.
               if $first_set[rhs_term].include?("nil")
                  count += 1
                  next
               else
                  # merge the FIRST SET of rhs token with the lhs if necessary.
                  $first_set[rhs_term].each do |token|
                     unless $first_set[lhs].include?(token)
                        $first_set[lhs].add(token)
                        changed = true
                     end
                  end
                  break
               end
            end
            # check if all the rhs tokens produce nil, if so add nil to the lhs FIRST set.
            if rhs.size == count
               $first_set[lhs].add("nil")
            end
         end
      end
   end
end

First 集合的结果会放在全局变量$first_set 中，同样的对于 follow set，构造算法如下：

def construct_follow_set
   # Initialize FOLLOW set and add '$' into the FOLLOW set of start tokens.
   $gram_list.each_key do |lhs|
      $follow_set[lhs] = Set.new
      $follow_set[lhs].add("$") if lhs == $start_lside_rule
   end

   changed = true
   while (changed)
      changed = false
      $gram_list.each do |lhs, rhs_arr|
         rhs_arr.each do |rhs|
            rhs.each_index do |i|
               # skip the nil and terminal token.
               next if 'nil' == rhs[i] or $token_list.include?(rhs[i])

               # case 1, the current rhs term is the last one. 
               if (i+1) == rhs.size 
                  # Union the FOLLOW set of the rhs into the current rhs term.
                  $follow_set[lhs].each do |token|
                     unless $follow_set[rhs[i]].include?(token)
                        changed = true
                        $follow_set[rhs[i]].add(token)
                     end
                  end
               else
                  # First union the FIRST set of the follow rhs token into the current rhs token.
                  if "nil" != rhs[i+1]
                     if $token_list.include?(rhs[i+1])
                        unless $follow_set[rhs[i]].include?(rhs[i+1])
                           changed = true
                           $follow_set[rhs[i]].add(rhs[i+1])
                        end
                     else
                        $first_set[rhs[i+1]].each do |token|
                           if !$follow_set[rhs[i]].include?(token) and "nil" != token
                              changed = true
                              $follow_set[rhs[i]].add(token)
                           end
                        end
                     end
                  end
                  # If the follow rhs tokens produces a 'nil' chain, union the FOLLOW set of lhs into the current rhs token.
                  all_nil = true
                  j = i + 1
                  while (j < rhs.size)
                     # If there is any terminal, break.
                     if "nil" == rhs[j] or $token_list.include?(rhs[j])
                        all_nil = false
                        break
                     end

                     unless $first_set[rhs[j]].include?("nil")
                        all_nil = false
                        break
                     end
                     j += 1
                  end
                  if all_nil
                     $follow_set[lhs].each do |token|
                        unless $follow_set[rhs[i]].include?(token)
                           changed = true
                           $follow_set[rhs[i]].add(token)
                        end
                     end
                  end
               end
            end
         end
      end
   end
end

结果放在$follow_set.

LL (1) 预测分析表生成器。

rasefon — Wed, 21 May 2014 21:42:17 +0800

最近在看编译器的前段，大部分人都是用现有工具去实现，例如经典的 Lex/yacc。很少有人会从头自己去手写 parser，或者做个 parser 解析器。看理论不实践，总觉得不踏实，所以我找了些现有的词法分析生成器源码看了看，里面对正则表达式解析器本身的处理，多数都是用了最直观的右递归递归下降算法，也就是说是有回溯的算法。故此我便想用脚本，读取一些简单的自定义语法文本，来自动生成 LL 预测分析表，现在已经把 First 集合和 Follow 集合计算完毕，过两天把分析表输出成 c 语言的头文件就算大功告成。

Repo 地址：https://github.com/rasefon/LLTableGenerator

简单的文法文本如下：

``
token: tPlus, tMul, tLp, tRp, tEnd
token: tId
# nil is predefined keyword.
``
$Start: E
E:    T,E1
E1:   tPlus,T,E1
E1:   nil
T:    F,T1
T1:   tMul,F,T1
T1:   nil
F:    F1
F1:   tLp,E,tRp
F1:   tId

脚本用的是 ruby，代码如下：

require 'set'

# 'nil' and '$' are predefined terminal token, 'nil' means empty action and '$' is the end flag of parsing.

$start_lside_rule = ""
$token_list = Set.new
$gram_list = Hash.new
$first_set = Hash.new
$follow_set = Hash.new

def construct_table_model(rule_file_name)
   lines = IO.readlines(rule_file_name) 
   lines = lines.map { |l| l.chomp }
   token_def_phase = false
   rule_def_phase = false
   # temporarily record left side tokens and right tokens as string.
   lines.each do |line|
      # skip comment
      next if "#" == line[0]
      # Start token define phase.
      if "``" == line
         if !token_def_phase
            token_def_phase = true
         else
            token_def_phase = false
            rule_def_phase = true
         end
         next
      end

      if token_def_phase
         line.split(':')[1].split(',').each { |t| $token_list.add(t.strip) }
      elsif rule_def_phase
         rule = line.split(':').map { |item| item.strip }
         if "$Start" == rule[0]
            $start_lside_rule = rule[1]
         else
            rhs = rule[1].split(',').map { |r| r.strip }
            if $gram_list.has_key?(rule[0])
               # merge right side rule
               $gram_list[rule[0]] = $gram_list[rule[0]] << rhs
            else
               $gram_list[rule[0]] = [] << rhs
            end
         end
      end
   end
end

def construct_first_set()
   #first to add all the terminal and 'nil' into the FIRST set.
   $gram_list.each do |lhs, rhs_arr|
      unless $first_set.has_key?(lhs)
         $first_set[lhs] = Set.new
      end

      rhs_arr.each do |rhs|
         if $token_list.include?(rhs.first) or "nil" == rhs.first
            $first_set[lhs].add(rhs.first)
         end
      end
   end
   # loop computing first set until no new item is added.
   changed = true
   while (changed)
      changed = false
      $gram_list.each do |lhs, rhs_arr|
         rhs_arr.each do |rhs|
            # If the first item of the rhs token is terminal or 'nil', just skip it because the token had already been
            # added in previous loop.
            next if $token_list.include?(rhs.first) or "nil" == rhs.first

            count = 0
            rhs.each do |rhs_term|
               # If 'nil' is contained in FIRST set of rhs_term, skip to the next term.
               if $first_set[rhs_term].include?("nil")
                  count += 1
                  next
               else
                  # merge the FIRST SET of rhs token with the lhs if necessary.
                  $first_set[rhs_term].each do |token|
                     unless $first_set[lhs].include?(token)
                        $first_set[lhs].add(token)
                        changed = true
                     end
                  end
                  break
               end
            end
            # check if all the rhs tokens produce nil, if so add nil to the lhs FIRST set.
            if rhs.size == count
               $first_set[lhs].add("nil")
            end
         end
      end
   end
end

def construct_follow_set
   # Initialize FOLLOW set and add '$' into the FOLLOW set of start tokens.
   $gram_list.each_key do |lhs|
      $follow_set[lhs] = Set.new
      $follow_set[lhs].add("$") if lhs == $start_lside_rule
   end

   changed = true
   while (changed)
      changed = false
      $gram_list.each do |lhs, rhs_arr|
         rhs_arr.each do |rhs|
            rhs.each_index do |i|
               # skip the nil and terminal token.
               next if 'nil' == rhs[i] or $token_list.include?(rhs[i])

               # case 1, the current rhs term is the last one. 
               if (i+1) == rhs.size 
                  # Union the FOLLOW set of the rhs into the current rhs term.
                  $follow_set[lhs].each do |token|
                     unless $follow_set[rhs[i]].include?(token)
                        changed = true
                        $follow_set[rhs[i]].add(token)
                     end
                  end
               else
                  # First union the FIRST set of the follow rhs token into the current rhs token.
                  if "nil" != rhs[i+1]
                     if $token_list.include?(rhs[i+1])
                        unless $follow_set[rhs[i]].include?(rhs[i+1])
                           changed = true
                           $follow_set[rhs[i]].add(rhs[i+1])
                        end
                     else
                        $first_set[rhs[i+1]].each do |token|
                           if !$follow_set[rhs[i]].include?(token) and "nil" != token
                              changed = true
                              $follow_set[rhs[i]].add(token)
                           end
                        end
                     end
                  end
                  # If the follow rhs tokens produces a 'nil' chain, union the FOLLOW set of lhs into the current rhs token.
                  all_nil = true
                  j = i + 1
                  while (j < rhs.size)
                     # If there is any terminal, break.
                     if "nil" == rhs[j] or $token_list.include?(rhs[j])
                        all_nil = false
                        break
                     end

                     unless $first_set[rhs[j]].include?("nil")
                        all_nil = false
                        break
                     end
                     j += 1
                  end
                  if all_nil
                     $follow_set[lhs].each do |token|
                        unless $follow_set[rhs[i]].include?(token)
                           changed = true
                           $follow_set[rhs[i]].add(token)
                        end
                     end
                  end
               end
            end
         end
      end
   end
end

construct_table_model(ARGV[0])
construct_first_set
construct_follow_set

#puts $start_lside_rule
#puts "" 
#puts $gram_list 
#puts ""
puts "FIRST SET: #{$first_set}"
puts ""
puts "FOLLOW SET: #{$follow_set}"
puts ""

恒大威武！！！

rasefon — Sat, 09 Nov 2013 21:59:17 +0800

！！！

傅立叶变化的完美解释。

rasefon — Thu, 31 Oct 2013 16:42:48 +0800

相似图比较算法。

rasefon — Wed, 30 Oct 2013 14:31:41 +0800

最近要人肉比较图片，太痛苦，不能逐像素点比较，这样容错率太低，看了篇网上的文章，照着实现了一下，感觉还不错，代码放在这里： https://gist.github.com/rasefon/7227972

算法介绍： http://www.labbookpages.co.uk/software/imgProc/otsuThreshold.html

关于 C++，关于 gc 的一些东西

rasefon — Mon, 28 Oct 2013 09:50:17 +0800

昨天没事又翻出了 Coders at Work 这本书看看，看到 Ken Thompson 对 C++ 和 GC 的评论，觉得很有意思，也很赞同，关于 C++ 的原文： Seibel: You were at AT&T with Bjarne Stroustrup. Were you involved at all in the development of C++?

Thompson: I’m gonna get in trouble.

Seibel: That’s fine.

Thompson: I would try out the language as it was being developed and make comments on it. It was part of the work atmosphere there. And you’d write something and then the next day it wouldn’t work because the language changed. It was very unstable for a very long period of time. At some point I said, no, no more. In an interview I said exactly that, that I didn’t use it just because it wouldn’t stay still for two days in a row. When Stroustrup read the interview he came screaming into my room about how I was undermining him and what I said mattered and I said it was a bad language. I never said it was a bad language. On and on and on. Since then I kind of avoid that kind of stuff.

Seibel: Can you say now whether you think it’s a good or bad language? Thompson: It certainly has its good points. But by and large I think it’s a bad language. It does a lot of things half well and it’s just a garbage heap of ideas that are mutually exclusive. Everybody I know, whether it’s personal or corporate, selects a subset and these subsets are different. So it’s not a good language to transport an algorithm—to say, “I wrote it; here, take it.” It’s way too big, way too complex. And it’s obviously built by a committee. Stroustrup campaigned for years and years and years, way beyond any sort of technical contributions he made to the language, to get it adopted and used. And he sort of ran all the standards committees with a whip and a chair. And he said “no” to no one. He put every feature in that language that ever existed. It wasn’t cleanly designed—it was just the union of everything that came along. And I think it suffered drastically from that.

Seibel: Do you think that was just because he likes all ideas or was it a way to get the language adopted, by giving everyone what they wanted?

Thompson: I think it’s more the latter than the former. 关于 GC 的原文： Seibel: On a somewhat related note, what about garbage collection? With Java, GC has finally made it into the mainstream. As Dennis Ritchie once said, C is actively hostile to garbage collection. Is it good that folks are moving toward garbage-collected languages—is it a technology that deserves to finally be in mainstream use?

Thompson: I don’t know. I’m schizophrenic on the subject. If you’re writing an operating system or a C compiler or something that’s used by lots and lots of people, I think garbage collection is a mistake, almost. It’s a cheat for you where you can do it by hand and do it better—much better. What you’re doing is your sloughing your task, your job, making it slower for your users. So I think it’s a mistake in an operating system. It almost just doesn’t fit in an operating system. But if you are writing a hack program to do a job, get an answer and then throw the program away, it’s beautiful. It takes a layer of stuff you don’t want to think about, at a cost you can afford, because computers are so fast, and it’s nothing but a win-win-win position. So I’m really schizophrenic on this subject. Part of the problem is there are different garbage-collection algorithms and they have different properties—massively different properties. So you’re writing some really general-purpose thing like an operating system—if you’re going to write it in a language that garbage-collects underneath, you don’t even have the choice of the algorithm for the operating systems. Suppose that you just can’t stand big real-time gaps and you have a garbage collector that runs up to some threshold and then does mark and sweep. You’re screwed before you start. So if you’re doing some general-purpose task that you don’t know who your real users are, you just can’t do that. Plus, garbage collection fights cache coherency massively. And there’s no garbage-collection algorithm that is right for all machines. There are machines where you can speed it up by a factor of five or more by messing around with the cache. They should be tied to the machine much more than they are. Usually they treat them as separate algorithms that have nothing to do with machines, but the cache coherency is very important for garbage-collection algorithms.

分享一首非常赞的歌和歌词。

rasefon — Wed, 16 Oct 2013 22:20:51 +0800

Stevie Wonder 的 Black man，歌词太赞了！ First man to die For the flag we now hold high [Crispus Attucks] Was a black man

The ground were we stand With the flag held in our hand Was first the red man's

Guide of a ship On the first Columbus trip [Pedro Alonzo Nino] Was a brown man

The railroads for trains Came on tracking that was laid By the yellow man

We pledge allegiance All our lives To the magic colors Red, blue and white But we all must be given The liberty that we defend For with justice not for all men History will repeat again It's time we learned This World Was Made For All Men

Heart surgery Was first done successfully By a black man [Dr Daniel Hale Williams]

Friendly man who died But helped the pilgrims to survive [Squanto] Was a red man

Farm workers rights Were lifted to new heights [Caesar Chavez] By a brown man

Incandescent light Was invented to give sight [Thomas Edison] By the white man

Hear me out...

Now I know the birthday of a nation Is a time when a country celebrates But as your hand touches your heart Remember we all played a part in America To help that banner wave

First clock to be made In America was created By a black man [Benjamin Banneker]

Scout who used no chart Helped lead Lewis and Clark Was a red man [Sacagawea]

Use of martial arts In our country got its start By a yellow man

And the leader with a pen Signed his name to free all men Was a white man [Abraham Lincoln]

This world was made for all men This world was made for all men This world was made for all men God saved His world for all men All people All babies All children All colors All races This world's for you and me This world My world Your world Everybody's world This world Their world Our world This world was made for all men

Hear me out...

Who was the first man to set foot on the North Pole? Matthew Henson - a black man

Who was the first american to show the Pilgrims at Plymouth the secrets of survival in the new world? Squanto - a red man

Who was the soldier of Company G who won high honors for his courage and heroism in World War 1? Sing Kee - a yellow man

Who was the leader of united farm workers and helped farm workers maintain dignity and respect? Caesar Chavez - a brown man

Who was the founder of blood plasma and the director of the Red Cross blood bank? Dr. Charles Drew - a black man

Who was the first American heroine who aided the Lewis and Clark expedition? Sacajewa - a red woman

Who was the famous educator and semanticist who made outstanding contributions to education in America? Hayakawa - a yellow man

Who invented the world's first stop light and the gas mask? Garrett Morgan - a black man

Who was the American surgeon who was one of the founders of neurosurgery? Harvey Williams Cushing - a white man

Who was the man who helped design the nation's capitol, made the first clock to give time in America and wrote the first almanac? Benjamin Banneker - a black man

Who was the legendary hero who helped establish the League of Iroquois? Hiawatha - a red man

Who was the leader of the first microbiotic center in America? Micho Kushi - a yellow man

Who was the founder of the city of Chicago in 1772? Jean Baptiste - a black man

Who was one of the organizers of the American Indian Movement? Denis Banks - a red man

Who was the Jewish financier who raised founds to sponsor Cristopher Columbus' voyage to America? Lewis D. Santangel - a white man

Who was the woman who led countless slaves to freedom on the underground rairoad? Harriet Tubman - a black woman

发个很好的 Ruby VM 的学习资料

rasefon — Thu, 29 Aug 2013 13:22:09 +0800

英文版： http://edwinmeyer.com/Integrated_RHG.html

日文版： http://i.loveruby.net/ja/rhg/book/

无意中找了 ruby 语法的伪 BNF 范式，发出来给大家参考一下。

rasefon — Thu, 29 Aug 2013 11:04:47 +0800

Pseudo BNF Syntax of Ruby

Here is the syntax of Ruby in pseudo BNF. For more detail, see parse.y in Ruby distribution.

PROGRAM : COMPSTMT

COMPSTMT : STMT (TERM EXPR)* [TERM]

STMT : CALL do [|' [BLOCK_VAR]|'] COMPSTMT end | undef FNAME | alias FNAME FNAME | STMT if EXPR | STMT while EXPR | STMT unless EXPR | STMT until EXPR | BEGIN'{' COMPSTMT }' |END' {' COMPSTMT}' | LHS =' COMMAND [do [|' [BLOCK_VAR] `|'] COMPSTMT end] | EXPR

CALL : FUNCTION | COMMAND

COMMAND : OPERATION CALL_ARGS | PRIMARY .' OPERATION CALL_ARGS | PRIMARY::' OPERATION CALL_ARGS | super CALL_ARGS

ARG : LHS =' ARG | LHS OP_ASGN ARG | ARG..' ARG | ARG ...' ARG | ARG+' ARG | ARG -' ARG | ARG' ARG | ARG /' ARG | ARG%' ARG | ARG `*' ARG | +' ARG |-' ARG | ARG |' ARG | ARG^' ARG | ARG &' ARG | ARG<=>' ARG | ARG >' ARG | ARG>=' ARG | ARG <' ARG | ARG<=' ARG | ARG ==' ARG | ARG===' ARG | ARG !=' ARG | ARG=~' ARG | ARG !~' ARG |!' ARG | ~' ARG | ARG<<' ARG | ARG >>' ARG | ARG&&' ARG | ARG `||' ARG | defined? ARG | PRIMARY

PRIMARY : (' COMPSTMT)' | LITERAL | VARIABLE | PRIMARY ::' IDENTIFIER |::' IDENTIFIER | PRIMARY [' [ARGS]]' | [' [ARGS [,']] ]' |{' [(ARGS|ASSOCS) [,']]}' | return [(' [CALL_ARGS])'] | yield [(' [CALL_ARGS])'] | defined? (' ARG)' | FUNCTION | FUNCTION {' [|' [BLOCK_VAR] |'] COMPSTMT}' | if EXPR THEN COMPSTMT (elsif EXPR THEN COMPSTMT)* [else COMPSTMT] end | unless EXPR THEN COMPSTMT [else COMPSTMT] end | while EXPR DO COMPSTMT end | until EXPR DO COMPSTMT end | case COMPSTMT (when WHEN_ARGS THEN COMPSTMT)+ [else COMPSTMT] end | for BLOCK_VAR in EXPR DO COMPSTMT end | begin COMPSTMT [rescue [ARGS] DO COMPSTMT]+ [else COMPSTMT] [ensure COMPSTMT] end | class IDENTIFIER [<' IDENTIFIER] COMPSTMT end | module IDENTIFIER COMPSTMT end | def FNAME ARGDECL COMPSTMT end | def SINGLETON (.'|`::') FNAME ARGDECL COMPSTMT end

WHEN_ARGS : ARGS [,'' ARG] | `' ARG

THEN : TERM | then | TERM then

DO : TERM | do | TERM do

BLOCK_VAR : LHS | MLHS

MLHS : MLHS_ITEM ,' [MLHS_ITEM (,' MLHS_ITEM)] [`' [LHS]] | `*' LHS

MLHS_ITEM : LHS | '(' MLHS ')'

LHS : VARIABLE | PRIMARY [' [ARGS]]' | PRIMARY `.' IDENTIFIER

MRHS : ARGS [,'' ARG] | `' ARG

ARGS : ARG (`,' ARG)*

ARGDECL : (' ARGLIST)' | ARGLIST TERM

ARGLIST : IDENTIFIER(,'IDENTIFIER)*[,'*'[IDENTIFIER]][,'&'IDENTIFIER] |*'IDENTIFIER[,'&'IDENTIFIER] | [`&'IDENTIFIER]

SINGLETON : VARIABLE | (' EXPR)'

ASSOCS : ASSOC (`,' ASSOC)*

ASSOC : ARG `=>' ARG

VARIABLE : VARNAME | nil | self

TERM : ;' |\n'

The followings are recognized by lexical analizer.

OP_ASGN : +=' |-=' | *=' |/=' | %=' |**=' | &=' ||=' | ^=' |<<=' | >>=' |&&=' | `||='

SYMBOL : :'FNAME |:'VARNAME

FNAME : IDENTIFIER | ..' ||' | ^' |&' | <=>' |==' | ===' |=~' | >' |>=' | <' |<=' | +' |-' | *' |/' | %' |**' | <<' |>>' | ~' |+@' | -@' |[]' | `[]='

OPERATION : IDENTIFIER | IDENTIFIER'!' | IDENTIFIER'?'

VARNAME : GLOBAL | `@'IDENTIFIER | IDENTIFIER

GLOBAL : $'IDENTIFIER |$'any_char | `$''-'any_char

STRING : "' any_char*"' | '' any_char*'' | ' any_char*'

STRING2 : %'(Q'|q'|x')char any_char* char

HERE_DOC : `<<'(IDENTIFIER|STRING) any_char* IDENTIFIER

REGEXP : /' any_char*/'[i'|o'|p'] |%'`r' char any_char* char

IDENTIFIER is the sqeunce of characters in the pattern of /[a-zA-Z_][a-zA-Z0-9_]*/.

2.0 respond_to?(x,x) 坑死人！

rasefon — Wed, 10 Jul 2013 14:55:56 +0800

原来正常的代码，升级到 2.0 就不正常了，查了半天发觉这个 method 语义变了！非 public 方法默认返回假！

最近想到一个关于上传图片的问题。

rasefon — Sun, 12 Aug 2012 00:56:38 +0800

我发现当发一个带图片的帖子的时候，或者说带上传文件的帖子的时候。如果你已经把附件上传到服务器了，但是最后并没有发表帖子，会导致这些附件成为类似于内存泄露一样的野指针。没有任何对象会引用它们，不能被编辑，也不能删除，一直存在与服务器上面。

目前发现很多论坛都有这类问题。不知道有没有好的解决方法？