dsh0416 (Delton Ding)

[上海][12.3,12.4] RubyConf China 2021 Hotwire 开始售票

dsh0416 — Tue, 06 Jul 2021 14:05:22 +0800

时间：~~2021 年 8 月 14 日 - 15 日~~ 因疫情影响，现决定于 2021 年 12 月 3 日 ~ 4 日（周五周六）

地点：上海市黄浦区南京西路 399 号明天广场 JW 万豪酒店

官网：http://rubyconfchina.org

购票链接：https://wx.duohui.co/event/13050

RubyConf China 2021 Hotwire 售票工作正式开始啦！

多会依旧赞助了本届大会的售票和现场签到支持。

成本原因，票价与前年相比，向上浮动

超级早鸟票（不含发票）368 元、早鸟票（不含发票）398 元，主要用于支付两天的午餐和茶歇。

普通票（带发票）468 元，相比早鸟票多出的 70 元，一部分用来支付税点和快递费用（税点是 1%），剩下的部分用于大会的筹办。

普通票（带发票）总共购买超过三张后，算作团体参加，请把订单号和公司的 Logo 及公司网站地址邮件发送给工作人员（邮箱见本帖最后），工作人员会把您公司放入感谢名单（如果您的公司能够赞助大会，也可以算入赞助金额中）。

团体参加的购票者请填写：https://jinshuju.net/f/cFmz8w

关于退票

在大会召开一周前，允许自由退票，之后会将购票的所得款项支付给酒店，故停止支持退票，请理解！

退票方式为：

如果使用小程序购票，多会小程序中可以看到购票的订单，然后退票即可。
如果使用网页购票，进入购票链接，点击登录，然后可以看到“我的订单”，进入，然后退票即可。

联系方式

有任何疑问请联系：

江俊寅：alexanderjiangjunyin@gmail.com 微信：alexanderjunyin（请备注 RubyConf China 咨询）

丁盛豪 @dsh0416：dsh0416@gmail.com

姜军 @jasl ：jasl9187@hotmail.com 微信：jasl123（请备注 RubyConf China 咨询）

[杭州] Fork AI 招聘 Ruby 工程师 2 名

dsh0416 — Thu, 24 Jun 2021 14:43:51 +0800

Fork AI 是一家目前坐落于杭州的帮助企业进行智能获客的创业公司，旗下产品 Fork AI 是一款帮助企业销售进行规模化获客的商业数据挖掘引擎。

第一阶段产品已经获得字节、声网、七牛的认可，实现了年近百万营收。目前已取得 100 万美元天使轮融资，未来半年内将开展第二轮融资。1-2 年内不存在资金的压力。

开放职位

Ruby 工程师

职位描述

负责产品后端的维护、测试和持续迭代
负责后端代码的重构和优化
与其它团队成员合作，共同完成项目

职位要求

熟悉 Ruby on Rails 框架
掌握常见的设计模式和最佳实践
熟悉基本的开发工具，包括但不限于编辑器、Git、Shell
熟悉 PostgreSQL 和 Redis 数据库
熟悉 Linux 操作系统的使用
具有良好的代码规范意识
基本的英语读写能力

加分项

有 TDD/BDD 经验
有 Ruby on Rails API 开发经验
对于 Ruby 3.0 和 Rails 6.0 的新特性熟悉
有 PostgreSQL 性能优化实践经验
对代码质量、文档质量有追求
有个人大型开源项目优先

职位待遇

月薪 15k - 30k RMB
弹性工作制，不打卡，工作量合理（杜绝 996 制度性加班）
办公室提供零食、饮料、下午茶 ~~（对下午茶不满意，老板天天晚上请你吃烧烤）~~
我们理所当然地提供五险一金、双休、法定节假日、年假等法律规定的待遇。
具体待遇由 HR 确定

其他职位，包括非技术类的，详见我们的招聘页面

联系方式

简历请发送至 contact@fork.ai 工作日 17:00 前发送，当天回复。

如果有任何疑问可以提问，我会尽量回答。

RubyConf China 2021 Hotwire 赞助征集

dsh0416 — Wed, 02 Jun 2021 13:36:53 +0800

Ruby China 社区是中国最大的、水平最高的的 Ruby 交流社区，已经吸收了国内大半部分从事 Ruby 技术开发的人士和爱好者，并且维护了国内最大的 RubyGems 源。此外，Ruby China 社区各地热心的组织者们会定期举办地区级别的小型分享交流会。

RubyConf China 则是由 Ruby China 社区官方以公开、非盈利形式组织的一年一度的技术交流大会，我们会邀请国内的明星开发者、知名项目/团队的负责人、海外技术专家来分享 Ruby 和相关领域的最新成果、经验总结。

RubyConf China 自 2009 年始至 2020 年已成功举办十一届，也是中国大陆唯一的 Ruby 技术交流会议，组织者都是各公司的一线开发者。

往届大会的情况可以通过 Ruby China 社区的 RubyConf 节点（https://ruby-china.org/topics/node51）了解。

本届大会预计参会者规模在 300 人，场地最大可容纳 500 人，根据往届经验，个人参会者约占参会人员比例的 50%，3 - 5 人团体购票约占比 30%，其余为 6 人以上团体购票。

国内 Ruby 的主要使用者也主要以中小型、创业公司的技术团队以及自由职业者为主，可参考 Ruby China 社区的酷站版块和招聘板块，Ruby 社区对于各种前后端技术，如 Go、Elixir、Erlang、Android、iOS、Web 前端等有着相当高的包容度。

第十二届 RubyConf China 预计将于 2021 年 8 月 14 日 - 8 月 15 日在上海明天广场 JW 万豪酒店举办。2021 年，本次会议将采用线上和线下结合的方式，除了线下的讲师，受限于疫情原因无法到达现场的讲师会通过直播的形式参与。

我们提供了以下⼏种赞助方案：

赞助方案

红宝石赞助商（限量）—— 30000 元

在大会官网优先位置放置公司 Logo 并可以跳转到公司网站
在大会官网有约 200 字的文字介绍
在大会召开期间，可以在会场放置 4 个易拉宝
在⼤会召开期间，可以在会场前设置宣传摊位并派发展品和纪念品
在茶歇和午休期间播放不超过 3 分钟的宣传视频
在演讲录像中展示红宝石赞助商 Logo
可提供宣传纸质材料（作为大会资料分发给参会者）
十张⻔票

金牌赞助商（限量）—— 20000 元

在大会官网放置公司 Logo 并可以跳转到公司网站
在大会官网有约 200 字的文字介绍
在大会召开期间，可以在会场放置 2 个易拉宝
在⼤会召开期间，可以在会场前设置宣传摊位并派发展品和纪念品
在茶歇和午休期间播放不超过 1 分钟的宣传视频
可提供宣传纸质材料（作为大会资料分发给参会者）
五张⻔票

银牌赞助商 —— 10000 元

在大会官网放置公司 Logo 并可以跳转到公司网站
在大会官网有约 75 字的文字介绍
在大会召开期间，可以在会场放置 1 个易拉宝
可提供宣传纸质材料（作为大会资料分发给参会者）
两张⻔票

合作伙伴 —— 3500 元

在大会官网放置公司 Logo 并可以跳转到公司网站
可提供宣传纸质材料（作为大会资料分发给参会者）

全价票（带发票）总共购买超过三张后，算作团体参加，请把订单号和公司的 Logo 及公司网站地址发送到大会联系邮箱，我会把您公司放入感谢名单（如果您的公司能够赞助大会，也可以算入赞助金额中）。

联系方式

conf@ruby-china.org

讲师征集

我们同时还在征集讲师中，讲师相关事宜请见此帖。

三点几嚟，饮茶先啦 —— 将大马饮料名编译成汉语

dsh0416 — Sun, 23 May 2021 00:41:39 +0800

大马饮料名

近几日马来西亚网友 Gurdip Singh 在 Facebook 发的这个「三点几嚟，饮茶先啦」非常流行。

Facebook: www.facebook.com/100009201465316/videos/2530411593942198

Bilibili 搬运：https://www.bilibili.com/video/av845257746/

不过马来语的饮料名称非常有意思。某个目前居住在新加坡的朋友 @david92 给我解释了一下，如何在店里点茶喝。基本是一个组合式的语法，非常规律。最基础的茶底是红茶（Teh）或者咖啡（Kopi）。默认饮料是带糖和炼乳的，但你可以重新定制。如果你在后面加上 O 表示不要加炼乳，而 C 表示把炼乳换成鲜奶。类似，Kosong 是无糖，Siu Dai 是少糖，而 Gah Dai 是加更多的糖。

ebnf 语法

我查阅了一些资料进一步完善了一下这个概念，发现这个语法完全是「可编译」的，非常简单。很快，我写了一个 bnf 语法来描述这个概念：

<water>     ::= "Kopi" | "Teh" | "Milo"
<sugar>     ::= "Kosong" | "Siu Dai" | "Gah Dai"
<milk>      ::= "O" | "C"
<thickness> ::= "Po" | "Gau"
<extra>     ::= "Peng" | "Bubble" | "Halia"
<upsize>    ::= "Nga Lat"
<takeout>   ::= "Bungkus" 
<plastic>   ::= "Ikat"
<knot>      ::= "Mati" | "Tepi"

<drink>     ::=
  (<takeout> (" " <plastic> (" " <knot>)?)? " ")?
  (<upsize> " ")?
  <water> (" " <milk>)? (" " <sugar>)?
  (" " <thickness>)?
  (" " <extra>)*

其中，Po 是清淡，Gau 是浓缩，Peng 是加冰块，Bubble 是加珍珠，Halia 是加姜汁。Nga Lat 是大杯。外带的概念比校复杂，Bungkus 是外带，通常是杯状的。像是 Bernard Tee 视频里那种塑料袋装的，叫 Ikat。Ikat 有两种不同的打结方式，一种是打死结 Mati，还有一种是侧面打结，开口的叫 Tepi。

比如 Bungkus Ikat Mati Nga Lat Kopi O Siu Dai Gau Peng Bubble 就是外带塑料袋装打死结大杯少糖浓缩咖啡加冰块和珍珠。

我们可以在 ebnf playground 测试这个语法：

这个网站甚至能生成随机的符合某个语法（比如这里 Drink）的字符串，来让我们人工检查这个语法对不对。

实现到汉语的编译器

Ruby 中有一个 gem 叫 ebnf 可以读取 ebnf 文件然后生成对应的 parser，然后我们写一个输出中文的 generator 即可将马来西亚语翻译成中文。

由于 ebnf 的语法并没有规范，Ruby ebnf 库和我们刚刚 playground 中的语法有细微不同，这里做了一些变更。

require "ebnf"

TEA_GRAMMER = <<-EOF
Water     ::= "Kopi" | "Teh" | "Milo"
Sugar     ::= "Kosong" | "Siu Dai" | "Gah Dai"
Milk      ::= "O" | "C"
Thickness ::= "Po" | "Gau"
Extra     ::= "Peng" | "Bubble" | "Halia"
Upsize    ::= "Nga Lat"
Knot      ::= "Mati" | "Tepi"
Plastic   ::= "Ikat" Knot?
Takeout   ::= "Bungkus" Plastic?

Drink     ::= Takeout? Upsize? Water Milk? Sugar? Thickness? Extra*
EOF

由于这个库执行 parse 需要先转换成解析表达文法（Parsing Expression Grammar）从而生成更多的子规则，我们先打印一下自动生成的子规则便于之后开发 generator。

EBNF.parse(TEA_GRAMMER).make_peg.ast

=begin
(rule Water (alt "Kopi" "Teh" "Milo"))
(rule Sugar (alt "Kosong" "Siu Dai" "Gah Dai"))
(rule Milk (alt "O" "C"))
(rule Thickness (alt "Po" "Gau"))
(rule Extra (alt "Peng" "Bubble" "Halia"))
(rule Upsize (seq "Nga Lat"))
(rule Knot (alt "Mati" "Tepi"))
(rule Plastic (seq "Ikat" _Plastic_1))
(rule _Plastic_1 (opt Knot))
(rule Takeout (seq "Bungkus" _Takeout_1))
(rule _Takeout_1 (opt Plastic))
(rule Drink (seq _Drink_1 _Drink_2 Water _Drink_3 _Drink_4 _Drink_5 _Drink_6))
(rule _Drink_1 (opt Takeout))
(rule _Drink_2 (opt Upsize))
(rule _Drink_3 (opt Milk))
(rule _Drink_4 (opt Sugar))
(rule _Drink_5 (opt Thickness))
(rule _Drink_6 (star Extra))
=end

我们创建一个 generator 类，如下：

class MalayTea
  include EBNF::PEG::Parser
  attr_reader :rules
   def initialize
    @rules = EBNF.parse(TEA_GRAMMER).make_peg.ast
  end

  def evaluate(input)
    parse(input, :Drink, @rules)
  end
end

p MalayTea.new.evaluate(gets.chomp)

这时候输入一个句子，其会如实输出 AST 抽象语法树。而我们要做的就是根据 rule 名称来规约这些语法树直到某个特定输出。

production(:_Drink_1, clear_packrat: true) do |value|
    if value.nil?
        ""
    elsif value.length == 1
        "外带"
    else
        "外带#{value[-1].values.join}"
    end
end

production(:Plastic, clear_packrat: true) do |value|
    if value.nil?
        ""
    elsif value.length == 1
        "塑料袋装"
    else
        "塑料袋装#{value[-1].values.join}"
    end
end

production(:_Plastic_1, clear_packrat: true) do |value|
    value.nil? ? "" : { Mati: "打死结", Tepi: "侧面打结"}[value.to_sym]
end

production(:_Drink_2, clear_packrat: true) do |value|
    value.nil? ? "" : "大杯"
end

production(:Water, clear_packrat: true) do |value|
    { Kopi: "咖啡", Teh: "红茶", Milo: "美禄" }[value.to_sym]
end

production(:_Drink_3, clear_packrat: true) do |value|
    value.nil? ? "炼乳" : { O: "", C: "鲜奶" }[value.to_sym]
end

production(:_Drink_4, clear_packrat: true) do |value|
    value.nil? ? "" : { Kosong: "无糖", "Siu Dai": "少糖", "Gah Dai": "加糖"}[value.to_sym]
end

production(:_Drink_5, clear_packrat: true) do |value|
    value.nil? ? "" : { Gau: "浓缩", Po: "清淡"}[value.to_sym]
end

production(:_Drink_6, clear_packrat: true) do |value|
    extras = value.map do |a|
        { Peng: "冰块", Bubble: "珍珠", Halia: "姜汁" }[a.to_sym]
    end
    extras.empty? ? "" : "加#{extras.join}"
end

我们规约最后一步的时候需要特殊处理鲜奶红茶和鲜奶咖啡这两个词语，因为一般我们直接叫奶茶和咖啡拿铁。

production(:Drink, clear_packrat: true) do |value|
    h = value.inject(&:merge)
    if h[:Water] == "红茶" and h[:_Drink_3] == "鲜奶"
        h[:Water] = "奶茶"
        h[:_Drink_3] = ""
    elsif h[:Water] == "咖啡" and h[:_Drink_3] == "鲜奶"
        h[:Water] = "咖啡拿铁"
        h[:_Drink_3] = ""
    end
    "#{h[:_Drink_1]}#{h[:_Drink_2]}#{h[:_Drink_4]}#{h[:_Drink_3]}#{h[:_Drink_5]}#{h[:Water]}#{h[:_Drink_6]}"
end

成果

最后我们得到了一个将马来西亚语的饮料名编译到汉语的编译（翻译）器。

完整代码如下：

require "ebnf"

TEA_GRAMMER = <<-EOF
Water     ::= "Kopi" | "Teh" | "Milo"
Sugar     ::= "Kosong" | "Siu Dai" | "Gah Dai"
Milk      ::= "O" | "C"
Thickness ::= "Po" | "Gau"
Extra     ::= "Peng" | "Bubble" | "Halia"
Upsize    ::= "Nga Lat"
Knot      ::= "Mati" | "Tepi"
Plastic   ::= "Ikat" Knot?
Takeout   ::= "Bungkus" Plastic?

Drink     ::= Takeout? Upsize? Water Milk? Sugar? Thickness? Extra*
EOF

class MalayTea
  include EBNF::PEG::Parser
  attr_reader :rules

  production(:_Drink_1, clear_packrat: true) do |value|
    if value.nil?
      ""
    elsif value.length == 1
      "外带"
    else
      "外带#{value[-1].values.join}"
    end
  end

  production(:Plastic, clear_packrat: true) do |value|
    if value.nil?
      ""
    elsif value.length == 1
      "塑料袋装"
    else
      "塑料袋装#{value[-1].values.join}"
    end
  end

  production(:_Plastic_1, clear_packrat: true) do |value|
    value.nil? ? "" : { Mati: "打死结", Tepi: "侧面打结"}[value.to_sym]
  end

  production(:_Drink_2, clear_packrat: true) do |value|
    value.nil? ? "" : "大杯"
  end

  production(:Water, clear_packrat: true) do |value|
    { Kopi: "咖啡", Teh: "红茶", Milo: "美禄" }[value.to_sym]
  end

  production(:_Drink_3, clear_packrat: true) do |value|
    value.nil? ? "炼乳" : { O: "", C: "鲜奶" }[value.to_sym]
  end

  production(:_Drink_4, clear_packrat: true) do |value|
    value.nil? ? "" : { Kosong: "无糖", "Siu Dai": "少糖", "Gah Dai": "加糖"}[value.to_sym]
  end

  production(:_Drink_5, clear_packrat: true) do |value|
    value.nil? ? "" : { Gau: "浓缩", Po: "清淡"}[value.to_sym]
  end

  production(:_Drink_6, clear_packrat: true) do |value|
    extras = value.map do |a|
      { Peng: "冰块", Bubble: "珍珠", Halia: "姜汁" }[a.to_sym]
    end
    extras.empty? ? "" : "加#{extras.join}"
  end

  production(:Drink, clear_packrat: true) do |value|
    h = value.inject(&:merge)
    if h[:Water] == "红茶" and h[:_Drink_3] == "鲜奶"
      h[:Water] = "奶茶"
      h[:_Drink_3] = ""
    elsif h[:Water] == "咖啡" and h[:_Drink_3] == "鲜奶"
      h[:Water] = "咖啡拿铁"
      h[:_Drink_3] = ""
    end
    "#{h[:_Drink_1]}#{h[:_Drink_2]}#{h[:_Drink_4]}#{h[:_Drink_3]}#{h[:_Drink_5]}#{h[:Water]}#{h[:_Drink_6]}"
  end

  def initialize
    @rules = EBNF.parse(TEA_GRAMMER).make_peg.ast
  end

  def evaluate(input)
    parse(input, :Drink, @rules)
  end
end

loop do
  puts "输入饮料名："
  print "> "
  puts  "< #{MalayTea.new.evaluate(gets.chomp)}"
end

我们来运行一下看看：

❯ ruby main.rb
输入饮料名：
> Bungkus Ikat Mati Nga Lat Kopi O Siu Dai Gau Peng Bubble
< 外带塑料袋装打死结大杯少糖浓缩咖啡加冰块珍珠

欢迎大家带着这个程序去马来西亚／新加坡饮茶。

RubyConf China 2021 Hotwire 讲师征集

dsh0416 — Sun, 16 May 2021 21:25:46 +0800

什么是 RubyConf China 2021 Hotwire

第十二届 RubyConf China 预计将于 2021 年 8-9 月在上海举办。RubyConf China 2020 受到疫情影响变为纯线上进行，我们将其称为 RubyConf China 2020 SSR (Server-Side Rendering)。2021 年，本次会议将采用线上和线下结合的方式，除了线下的讲师，受限于疫情原因无法到达现场的讲师会通过直播的形式参与。我们将这种混合线上和线下的模式称为 Hotwire。这是一次在特殊时期下的全新尝试，但我们会尽可能提升各位参会的品质。

~~大家期待的豪华午餐回来啦！~~

Hotwire 版本会议与往年会议的主要差异

	常规会议	SSR 会议	Hotwire 会议
门票	收取线下门票费用	参会者可以自由参与直播	参与者收取门票费用，门票包括两天的午餐和纪念品
语言	建议以中文进行	可以使用中文、英文或日语进行我们会在直播前为演讲内容配上字幕	线上讲者可以自由选择语言，我们会在会议前为演讲内容配上字幕线下讲者建议以中文进行
演讲形式	现场演讲	为确保直播质量需要提前录制	线上讲者为确保会议质量需要提前录制线下讲者现场演讲
其它			参与线下会议必须全程佩戴口罩，遵守防疫规定因应防疫要求，主办方保留随时终止线下会议的权力

讲师征集 CFP

RubyConf China 2021 年的讲师征集已经正式开始，欢迎大家填写表单提出自己的选题。讲师征集会于 6 月 15 日截止，我们会陆续与确认的讲师进行接洽。

讲师征集表单：https://jinshuju.net/f/AtbBBD

讲师权益：

讲师专享纪念品一套（T-shirt 等）
免费 RubyConf China 2021 门票一张

投稿如果没有选中，无论超级早鸟票有无售罄，都可以按超级早鸟票价格购买门票。

参会交流

参会交流 Telegram 群：https://t.me/joinchat/ATOwuHwuMEtmNDFl

结

COVID-19 疫情虽然已有好转，但仍未完全过去。我们希望今年的 RubyConf China 的特殊方式能让各位 Rubyist 减少风险，同时给大家带来更好的参会体验，以及让这个世界变得更好一些。

Be alert, not anxious.

保持警觉，但不要焦虑。

[线上][2021年2月9日] RubyTuesday@Clubhouse

dsh0416 — Mon, 08 Feb 2021 18:12:38 +0800

时间：2020 年 2 月 9 日 (周二) 19:00 - 21:00

地点：https://www.joinclubhouse.com/event/PGEq6Gwv

主题

随便聊聊近期 Rubyist 们的工作、遇到的问题、Ruby 近期进展。

腾讯会议转播

https://voovmeeting.com/s/MHeH0mCe1gNO

用 Ruby 实现飞机自动驾驶仪

dsh0416 — Fri, 08 Jan 2021 12:46:56 +0800

krpc

krpc 是一个砍巴拉太空计划（Kerbel Space Program）中的插件。可以通过 RPC 来控制游戏。同时有第三方的 Ruby 客户端：krpc-rb。和真实飞机不同的是，在砍巴拉游戏中驾驶飞机是非常痛苦的，在没有插件辅助的情况下，你看不到具体的 GPS 坐标，很多时候看到的都是和飞机驾驶无关的轨道参数，而一些关键的控制参数缺很难获取。同时游戏中也没有自动驾驶仪。特别在航天飞机降落的控制非常难，虽然手动降落不会太有问题，游戏对于重着陆的容忍度很高，但是要控制飞机飞往机场的过程漫长而痛苦。于是我们试试看利用 krpc 来实现正常商用飞机都有的自动驾驶仪的功能。

PID 控制

PID 是自动化控制中最基础也是最常用的控制算法。

我们假设我们要控制汽车油门使得汽车的速度达到某个我们预想中的速度。最直接的想法就是基于距离目标速度的大小来调整油门。也就是说越接近目标速度，我们油门踩得越轻。

但这会产生一个问题，由于我们控制的是给油，油门到加速度控制存在一个延迟，使得我们放开油门后的几毫秒内可能速度还会上升；而当我们看到速度超过放开油门的量越来越大，随着车速越来越快，我们受到的空气阻力实际在增加，车速又会很快下降，而无法与加速度达到平衡，这种情况下我们就会在目标速度附近来回震荡。根据我们按比例控制的激进程度，振幅可能有所变化，最坏情况下我们会震动幅度越来越大，使得系统完全失控。

解决这个问题最直接的方法是引入一个积分项，不单单根据目前速度的误差，也要根据当前加速度的积分，也就是速度来判断。速度越大可能我们需要的油门也要更大一些。

最后我们实际控制还会遇到扰动的问题，我们可能还要根据过去一段时间内误差变化幅度来调节油门大小，比如遇到一个晃动速度快速下降，我们就要快速补一下油门来弥补这个误差。这意味着我们还要引入一个微分项。把这三个结合起来，我们可以得到公式： $$ u(t) = K_pe(t) + K_i\int_0^te(\tau)d\tau+K_d\frac{d}{dt}e(t) $$ 形成一个通用的 P（比例）I（积分）D（微分）控制器。不过虽然说是通用，这每一项前面的系数比例要想调好也是不容易的。我们会用这个控制器来分别控制飞机的节流阀、滚转和俯仰。

用 Ruby 实现出来是这样的：

class PIDController
  def initialize(kp, ki, kd, clip_min=0.0, clip_max=1.0)
    @prev_err = 0.0
    @integral = 0.0
    @kp = kp
    @ki = ki
    @kd = kd
    @clip_min = clip_min
    @clip_max = clip_max

    @last_frame = 0.0
  end

  def trigger(goal, measured)
    trigger_err(goal - measured)
  end

  def trigger_err(err)
    current_frame = Time.now.to_f
    dt = current_frame - @last_frame
    if dt > 1.0
      @last_frame = current_frame
      return 0.0
    end

    @integral = @integral + err * dt

    @integral = @clip_min if @integral < @clip_min
    @integral = @clip_max if @integral > @clip_max

    d = (err - @prev_err) / dt
    res = @kp * err + @ki * @integral + @kd * d
    @prev_err = err
    @last_frame = current_frame

    return @clip_min if res < @clip_min
    return @clip_max if res > @clip_max
    res
  end
end

实际实现和公式有一些细微差异。积分项不能比可以控制的最大值更大，也不能比最小值更小。否则当误差和控制不在一个数量级的时候，往往会出现很难控制或者反应迟钝的问题。

起飞控制

起飞控制比较简单，在打开 SAS 保持稳定的情况下，我们只需要控制系统加速到抬轮速度，然后将飞机抬头到俯仰 10 度，收起起落架。最后爬升到给定的高度。

class TakeoffProcess
  def initialize(vessel, vr, velocity, height)
    @vessel = vessel
    @control = vessel.control

    @vr = vr
    @velocity = velocity
    @height = height

    @throttle_controller = PIDController.new(0.1, 0.01, 0.2)
    @pitch_controller = PIDController.new(0.05, 0.05, 0.1, -1.0, 1.0)
  end

  def run
    @control.brakes = false
    @control.sas = true
    loop do
      orbit = @vessel.flight(@vessel.orbit.body.reference_frame)
      surface = @vessel.flight(@vessel.surface_reference_frame)
      break unless orbit.speed < @vr
      throttle = @throttle_controller.trigger(@velocity, orbit.speed)
      @control.throttle = throttle
    end

    # Rotate
    puts "Rotate, Gear Up!"
    @control.gear = false

    loop do
      orbit = @vessel.flight(@vessel.orbit.body.reference_frame)
      surface = @vessel.flight(@vessel.surface_reference_frame)
      break unless orbit.mean_altitude < @height - 100
      throttle = @throttle_controller.trigger(@velocity, orbit.speed)
      @control.throttle = throttle

      pitch = @pitch_controller.trigger(10, surface.pitch)
      @control.pitch = pitch
    end

    puts "Takeoff Process Finished."
  end
end

比较麻烦的地方是 ksp 有一个 reference_frame 的概念，很多参数需要的是相对于 reference_frame 参数的概念。比如当你需要速度的时候，有可能获得轨道速度，也可能得到的是地面速度。再比如俯仰，如果是相对于轨道的俯仰，那么理论上始终应该是在 0 附近，因为轨道会随着俯仰变化而变化。所以计算的时候要小心。

方向角计算

起飞后一般飞机自动驾驶仪一个最重要的功能就是根据预先在飞行电脑上设定好的飞行路线来飞行了。路点一般有几个关键参数：高度、速度、经纬度。高度和速度的写法和我们起飞的时候差不多。但转向就比较复杂。

我们首先需要确定的是，飞机要转几度才能转到目标点，也就是计算方位角。我们先来考虑，如果这个地球是一个平面，经纬度是 x 和 y 轴上的坐标，方向角应当怎么算呢？其实我们可以很容易得到方向向量： $$ (x, y) = (x_b-x_a, y_b-y_a) $$ 那么方向角（自正北作为 0 度的顺时针角度）就是 $$ tan(\theta)=\frac{x_b-x_a}{y_b-y_a} \ \theta = atan(\frac{x_b-x_a}{y_b-y_a}) $$ 然而在球面上计算这个问题要复杂一些，本质上我们需要知道大圆上任意两点的距离，我们需要用到球面三角学中重要的半正矢公式（Harversine Formula）。

根据半正矢定理，我们有： $$ hav(c) = hav(a-b)+sin(a)sin(b)hav(C) $$ 其中： $$ hav(\theta)=sin^2\frac{\theta}{2}=\frac{1-cos\theta}{2} $$

进一步我们可以得到： $$ A = (lat_a, lng_a) \ B = (lat_b, lng_b) \ N = (\frac{\pi}{2}, 0) \ hav(NB) = hav(AB-AN)+sin(AB)sin(AN)hav(\ang NAB) $$ 再往下算基本就吐了，这公式长到打在 Wolfram Alpha 上直接不识别。只好上网找了个算好的结果： $$ tan(\theta)=\frac{|lng_b-lng_a|}{ln(\frac{tan(\frac{lat_B}{2}+\frac{\pi}{4})}{tan(\frac{lat_A}{2}+\frac{\pi}{4})})} $$ 需要特别注意，当 $$ lat_a = lat_b $$ 的时候分母为 0，针对这类情况，大多数编程语言都有 atan2(y, x) 函数，当 x = 0 时返回 90 度。最后我们有程序：

delta_phi = Math.log(Math.tan((@latitude / 180 * Math::PI) / 2 + Math::PI / 4) / Math.tan((orbit.latitude / 180 * Math::PI) / 2 + Math::PI / 4))
delta_lon =  (@longitude - orbit.longitude)  / 180 * Math::PI
theta = Math.atan2(delta_lon, delta_phi)
target_heading = theta * 180 / Math::PI

偏航控制

飞机上有两个可以控制飞机转向的方法，一个是偏航（Yaw），另一个是组合使用滚转（Roll）和俯仰（Pitch）。偏航通常是通过垂直尾翼来产生偏航力矩。而滚转和俯仰由副翼和水平尾翼得到。显然副翼和水平尾翼比垂直尾翼大很多，控制也会更快速、灵敏。事实上我们只需要控制滚转即可，因为当我们控制滚转，飞机的升力面会减少，从而导致升力下降、飞机下降；为了保持飞行高度，我们基于飞行高度控制的俯仰自然会提高俯仰，从而产生偏航方向的力矩。

不过需要注意两个关键点：

控制俯仰来控制升力的原理是，在一定范围内攻角（Angle of Attack）和升力系数成正比。然而当攻角大于某个角度，升力可能会迅速下降（即失速），如果要提高升力应当降低俯仰，而不是继续抬升俯仰。
当滚转角度越来越大后，副翼的升力面会逐渐减小到无论如何提高节流阀大小或调整俯仰都无法维持的情况（即失速），应当将侧倾角度（bank angle）控制在合理范围内。

在控制程序中我直接限制了俯仰的范围是 [-5.0, 10] 度，而滚转限制在正负 25 度以内。整体程序如下：

class WaypointProcess
  def initialize(vessel, velocity, height, latitude, longitude)
    @vessel = vessel
    @control = vessel.control

    @velocity = velocity
    @height = height
    @longitude = longitude
    @latitude = latitude

    @throttle_controller = PIDController.new(0.1, 0.01, 0.2)
    @pitch_controller = PIDController.new(0.05, 0.05, 0.1, -1.0, 1.0)
    @roll_controller = PIDController.new(0.0005, 0.01, 0.7, -1.0, 1.0)
  end

  def run
    @control.sas = false
    loop do
      orbit = @vessel.flight(@vessel.orbit.body.reference_frame)
      surface = @vessel.flight(@vessel.surface_reference_frame)
      break if (orbit.latitude - @latitude).abs < 1e-4 and (orbit.longitude - @longitude).abs < 1e-4

      throttle = @throttle_controller.trigger(@velocity, orbit.speed)
      @control.throttle = throttle

      pitch = @pitch_controller.trigger(@height, orbit.mean_altitude)
      if pitch > 0.0 and surface.pitch > 10
        pitch = -0.1
      elsif pitch < 0.0 and surface.pitch < -5
        pitch = 0.1
      end
      @control.pitch = pitch

      delta_phi = Math.log(Math.tan((@latitude / 180 * Math::PI) / 2 + Math::PI / 4) / Math.tan((orbit.latitude / 180 * Math::PI) / 2 + Math::PI / 4))
      delta_lon =  (@longitude - orbit.longitude)  / 180 * Math::PI
      theta = Math.atan2(delta_lon, delta_phi)
      target_heading = theta * 180 / Math::PI

      target_heading = 360 + target_heading if target_heading < 0
      delta_heading = target_heading - surface.heading

      delta_heading = 360 - delta_heading if delta_heading > 180
      delta_heading = delta_heading + 360 if delta_heading < -180

      bank_angle = delta_heading
      bank_angle = 25 if delta_heading > 25
      bank_angle = -25 if delta_heading < -25

      roll = @roll_controller.trigger(bank_angle, surface.roll)
      @control.roll = roll
      current_roll = surface.roll
    end

    puts "Waypoint lat: #{@latitude}, lng: #{@longitude} Reached."
  end
end

测试

我们使用如下的飞行路径设定：

require 'matrix'
require 'krpc'

require './libs/controller/pid'
require './libs/process/takeoff'
require './libs/process/waypoint'

KRPC.connect do |client|
  vessel = client.space_center.active_vessel

  # VR: 100m/s, Climb at 390 knots to 2000m
  TakeoffProcess.new(vessel, 100, 200, 2000).run
  # Fly to North pole (N90, S0.0) at 330 knots at FL300
  WaypointProcess.new(vessel, 170, 7000, 90.0, 0.0).run
end

在 100m/s 时抬轮，以 390 节速度爬升到 2000 米，然后爬升到 30000 英尺转向飞往北极点。测试完美。

完整测试视频：https://youtu.be/Mlqzk6bTOxQ

完整代码：GitHub dsh0416/ksp-pilot

我用的是自带存档强翼 A300 进行的测试。该飞机被设计成大气层内飞行的重型运输机。由于 Kerbin 星球比起地球大气稀薄，到 FL300 飞机已经难以维持 300 节的时速了。不过如果使用空天飞机进行测试则没有这样的问题。

目前的 PID 曲线的调教比较保守，在高度控制上震荡比较厉害。这可以针对具体飞机进行调整，如果在安装 Ferram Aerospace Research 的情况下，可以获得具体的「升力系数参数」，其实通过控制升力系数来控制高度是最为可靠的方法，现实中的飞机也是这么做的。

之后如果能获取机场 GPS 坐标实现自动进近和降落应该会更有意思。

不过这个项目还是很有意义的，不但练习了 Ruby 编程，还学习了立体几何、物理、飞行原理和自动化控制的相关知识。

为 Ruby 3 Fiber 调度器设计事件库 Evt

dsh0416 — Tue, 22 Dec 2020 16:22:10 +0800

Ruby 3 Fiber 调度器

我在 2020 年 7 月写过一篇文章《Ruby 3 Fiber 变化前瞻》，以及后来 8 月又写过一篇文章《尝试使用 Ruby 3 调度器》，简单介绍了 Fiber 调度器。Ruby 3 在这几个月中更新了数个版本，包括 ruby-3.0.0-preview1 ruby-3.0.0-preview2 和 ruby-3.0.0-rc1，其对于 Fiber 调度器的 API 做了更多的改进。

不过正如我之前所说，Ruby 3 调度器实现的只有接口，如果没有配套的接口实现，默认是不会启动的。最近四个月工作实在很忙，抽出了点时间来跟上 API 更新的脚步。这个项目得以进一步更新。

项目地址：Evt

Fiber 调度器的使用

我们假设我们现在有一对 IO.pipe，我们往一个里写入 Hello World，然后从另一个里读出来。我们可能会写这样一份代码：

rd, wr = IO.pipe

wr.write("Hello World")
wr.close

message = rd.read(20)
puts message
rd.close

不过这个程序有很多限制，比如写入不能超过 buffer，否则另一端由于没有异步读取，会卡死。以及必须要先写再读，否则也会卡死。当然我们可以使用多线程来解决这个问题：

require 'thread'

rd, wr = IO.pipe

t1 = Thread.new do
  message = rd.read(20)
  puts message
  rd.close
end

t2 = Thread.new do
  wr.write("Hello World")
  wr.close
end

t1.join
t2.join

但我们知道，使用线程来实现 I/O 的多路复用是效率极低的。操作系统的线程切换代价非常大，甚至对于线程之间调度的公平性，至今都是操作系统研究领域的噩梦。然而对于一个 I/O 问题，并不是 CPU-bound 的，只是需要调度器提供合适的睡眠和回调。这时，你只需要调用 Ruby 3 的调度器接口来替代线程就可以了。

require 'evt'

rd, wr = IO.pipe
scheduler = Evt::Scheduler.new

Fiber.set_scheduler scheduler

Fiber.schedule do
  message = rd.read(20)
  puts message
  rd.close
end

Fiber.schedule do
  wr.write("Hello World")
  wr.close
end

scheduler.run

一般来说异步代码需要写 callback 或者引入 async await 的关键字。但是在 Ruby 3 中这是不必要的。Ruby 3 列举了所有常见的需要进行上下文切换调度的场景：I/O 多路复用、等待进程退出、内核睡眠、自旋锁。把这些接口暴露出来，让开发者可以通过自行开发调度器来进行处理，从而无需引入任何额外的关键字。而我这几个月写的 Evt 就是这样一个调度器。

比起上面这个简单的例子，下面这个例子是一个 HTTP/1.1 的服务器

require 'evt'

@scheduler = Evt::Scheduler.new
Fiber.set_scheduler @scheduler

@server = Socket.new Socket::AF_INET, Socket::SOCK_STREAM
@server.bind Addrinfo.tcp '127.0.0.1', 3002
@server.listen Socket::SOMAXCONN

def handle_socket(socket)
  until socket.closed?
    line = socket.gets
    until line == "\r\n" || line.nil?
      line = socket.gets
    end
    socket.write("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
  end
end

Fiber.schedule do
  loop do
    socket, addr = @server.accept
    Fiber.schedule do
      handle_socket(socket)
    end
  end
end

@scheduler.run

可以看出来，开发的过程基本上和同步阻塞的线程开发没有任何区别，只需要 Fiber.set_scheduler 来设置你的调度器，然后在每个原先需要多线程来处理的 I/O 阻塞场景用 Fiber.scheduler 来替代。最后触发 scheduler.run 来启动调度器即可。

后端支持情况

`io_uring` 支持

这几个月不止 Ruby API 进行了很多优化，我的调度器也做了很多优化，比如做了许多 I/O 多路复用后端的优化。一个是 Linux 5.4 开始引入的 io_uring 多路复用的支持。由于 io_uring 可以减少 syscall 调用次数以及直接的 iov 调用理论上能比 epoll 达到更好的性能。直接的 iov 调用需要 Ruby Fiber 调度器接口上的额外支持。在和 ioquatix 讨论后，Ruby 3.0.0-preview2 开始引入了相关的接口。于是整个 io_uring 的实现需要两个部分，一个是和 epoll 模式兼容的 one-shot polling 相关的代码：

#include <liburing.h>

#define URING_ENTRIES 64
#define URING_MAX_EVENTS 64

struct uring_data {
  bool is_poll;
  short poll_mask;
  VALUE io;
};

void uring_payload_free(void* data);
size_t uring_payload_size(const void* data);

static const rb_data_type_t type_uring_payload = {
  .wrap_struct_name = "uring_payload",
  .function = {
    .dmark = NULL,
    .dfree = uring_payload_free,
    .dsize = uring_payload_size,
  },
  .data = NULL,
  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
};

void uring_payload_free(void* data) {
    io_uring_queue_exit((struct io_uring*) data);
    xfree(data);
}

size_t uring_payload_size(const void* data) {
    return sizeof(struct io_uring);
}

VALUE method_scheduler_init(VALUE self) {
    int ret;
    struct io_uring* ring;
    ring = xmalloc(sizeof(struct io_uring));
    ret = io_uring_queue_init(URING_ENTRIES, ring, 0);
    if (ret < 0) {
        rb_raise(rb_eIOError, "unable to initalize io_uring");
    }
    rb_iv_set(self, "@ring", TypedData_Wrap_Struct(Payload, &type_uring_payload, ring));
    return Qnil;
}

VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
    VALUE ring_obj;
    struct io_uring* ring;
    struct io_uring_sqe *sqe;
    struct uring_data *data;
    short poll_mask = 0;
    ID id_fileno = rb_intern("fileno");

    ring_obj = rb_iv_get(self, "@ring");
    TypedData_Get_Struct(ring_obj, struct io_uring, &type_uring_payload, ring);
    sqe = io_uring_get_sqe(ring);
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));

    int ruby_interest = NUM2INT(interest);
    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));

    if (ruby_interest & readable) {
        poll_mask |= POLL_IN;
    }

    if (ruby_interest & writable) {
        poll_mask |= POLL_OUT;
    }

    data = (struct uring_data*) xmalloc(sizeof(struct uring_data));
    data->is_poll = true;
    data->io = io;
    data->poll_mask = poll_mask;

    io_uring_prep_poll_add(sqe, fd, poll_mask);
    io_uring_sqe_set_data(sqe, data);
    io_uring_submit(ring);
    return Qnil;
}

VALUE method_scheduler_deregister(VALUE self, VALUE io) {
    // io_uring runs under oneshot mode. No need to deregister.
    return Qnil;
}

另一部分则是直接的 iov 支持：

VALUE method_scheduler_io_read(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
    struct io_uring* ring;
    struct uring_data *data;
    char* read_buffer;
    ID id_fileno = rb_intern("fileno");
    // @iov[io] = Fiber.current
    VALUE iovs = rb_iv_get(self, "@iovs");
    rb_hash_aset(iovs, io, rb_funcall(Fiber, rb_intern("current"), 0));
    // register
    VALUE ring_obj = rb_iv_get(self, "@ring");
    TypedData_Get_Struct(ring_obj, struct io_uring, &type_uring_payload, ring);
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));

    read_buffer = (char*) xmalloc(NUM2SIZET(length));
    struct iovec iov = {
        .iov_base = read_buffer,
        .iov_len = NUM2SIZET(length),
    };

    data = (struct uring_data*) xmalloc(sizeof(struct uring_data));
    data->is_poll = false;
    data->io = io;
    data->poll_mask = 0;

    io_uring_prep_readv(sqe, fd, &iov, 1, NUM2SIZET(offset));
    io_uring_sqe_set_data(sqe, data);
    io_uring_submit(ring);

    VALUE result = rb_str_new(read_buffer, strlen(read_buffer));
    if (buffer != Qnil) {
        rb_str_append(buffer, result);
    }

    rb_funcall(Fiber, rb_intern("yield"), 0); // Fiber.yield
    return result;
}

VALUE method_scheduler_io_write(VALUE self, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
    struct io_uring* ring;
    struct uring_data *data;
    char* write_buffer;
    ID id_fileno = rb_intern("fileno");
    // @iov[io] = Fiber.current
    VALUE iovs = rb_iv_get(self, "@iovs");
    rb_hash_aset(iovs, io, rb_funcall(Fiber, rb_intern("current"), 0));
    // register
    VALUE ring_obj = rb_iv_get(self, "@ring");
    TypedData_Get_Struct(ring_obj, struct io_uring, &type_uring_payload, ring);
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));

    write_buffer = StringValueCStr(buffer);
    struct iovec iov = {
        .iov_base = write_buffer,
        .iov_len = NUM2SIZET(length),
    };

    data = (struct uring_data*) xmalloc(sizeof(struct uring_data));
    data->is_poll = false;
    data->io = io;
    data->poll_mask = 0;

    io_uring_prep_writev(sqe, fd, &iov, 1, NUM2SIZET(offset));
    io_uring_sqe_set_data(sqe, data);
    io_uring_submit(ring);
    rb_funcall(Fiber, rb_intern("yield"), 0); // Fiber.yield
    return length;
}

不过目前不知道为什么 iov 调用没有被 Ruby Scheduler 识别到，目前还在修复相关的问题。不过好消息是至少达到了接近 epoll 的性能了。

IOCP 支持

另一个麻烦的地方是 Windows IOCP 支持。我试图写了一个 IOCP 的调度器：

VALUE method_scheduler_init(VALUE self) {
    HANDLE iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
    rb_iv_set(self, "@iocp", TypedData_Wrap_Struct(Payload, &type_iocp_payload, iocp));
    return Qnil;
}

VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
    HANDLE iocp;
    VALUE iocp_obj = rb_iv_get(self, "@iocp");
    struct iocp_data* data;
    TypedData_Get_Struct(iocp_obj, HANDLE, &type_iocp_payload, iocp);
    int fd = NUM2INT(rb_funcallv(io, rb_intern("fileno"), 0, 0));
    HANDLE io_handler = (HANDLE)rb_w32_get_osfhandle(fd);

    int ruby_interest = NUM2INT(interest);
    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));
    data = (struct iocp_data*) xmalloc(sizeof(struct iocp_data));
    data->io = io;
    data->is_poll = true;
    data->interest = 0;

    if (ruby_interest & readable) {
        interest |= readable;
    }

    if (ruby_interest & writable) {
        interest |= writable;
    }

    HANDLE res = CreateIoCompletionPort(io_handler, iocp, (ULONG_PTR) data, 0);
    printf("IO at address: 0x%08x\n", (void *)data);

    return Qnil;
}

VALUE method_scheduler_wait(VALUE self) {
    ID id_next_timeout = rb_intern("next_timeout");
    ID id_push = rb_intern("push");
    VALUE iocp_obj = rb_iv_get(self, "@iocp");
    VALUE next_timeout = rb_funcall(self, id_next_timeout, 0);

    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));

    HANDLE iocp;
    OVERLAPPED_ENTRY lpCompletionPortEntries[IOCP_MAX_EVENTS];
    ULONG ulNumEntriesRemoved;
    TypedData_Get_Struct(iocp_obj, HANDLE, &type_iocp_payload, iocp);

    DWORD timeout;
    if (next_timeout == Qnil) {
        timeout = 0x5000;
    } else {
        timeout = NUM2INT(next_timeout) * 1000; // seconds to milliseconds
    }

    DWORD NumberOfBytesTransferred;
    LPOVERLAPPED pOverlapped;
    ULONG_PTR CompletionKey;

    BOOL res = GetQueuedCompletionStatus(iocp, &NumberOfBytesTransferred, &CompletionKey, &pOverlapped, timeout);
    // BOOL res = GetQueuedCompletionStatusEx(
    //    iocp, lpCompletionPortEntries, IOCP_MAX_EVENTS, &ulNumEntriesRemoved, timeout, TRUE);

    VALUE result = rb_ary_new2(2);

    VALUE readables = rb_ary_new();
    VALUE writables = rb_ary_new();

    rb_ary_store(result, 0, readables);
    rb_ary_store(result, 1, writables);

    if (!result) {
        return result;
    }

    printf("--------- Received! ---------\n");
    printf("Received IO at address: 0x%08x\n", (void *)CompletionKey);
    printf("dwNumberOfBytesTransferred: %lld\n", NumberOfBytesTransferred);

    // if (ulNumEntriesRemoved > 0) {
    //     printf("Entries: %ld\n", ulNumEntriesRemoved);
    // }

    // for (ULONG i = 0; i < ulNumEntriesRemoved; i++) {
    //     OVERLAPPED_ENTRY entry = lpCompletionPortEntries[i];

    //     struct iocp_data *data = (struct iocp_data*) entry.lpCompletionKey;

    //     int interest = data->interest;
    //     VALUE obj_io = data->io;
    //     if (interest & readable) {
    //         rb_funcall(readables, id_push, 1, obj_io);
    //     } else if (interest & writable) {
    //         rb_funcall(writables, id_push, 1, obj_io);
    //     }

    //     xfree(data);
    // }

    return result;
}

但实际发现收到的 I/O 全部都是错误的指针。一番研究后发现，如果要让 IOCP 调度对应的 I/O，该 I/O 在初始化时就要有 FILE_FLAG_OVERLAPPED Flag 的支持。这意味着还需要 Ruby 的 win32/win32.c 中做出一些改进，才能在调度器中正确调度 IOCP。不过 Windows 上的 fallback IO.select 调度器还是能正常使用的，这问题就不大，毕竟谁在乎 Windows 的生产性能呢...

`kqueue` 支持改进

另一个做出的改进是在 macOS 的 kqueue 上。kqueue 在 FreeBSD 上的性能相当好，但是在 macOS 上就比较拉跨。只能通过减少 syscall 来提高性能。这几个月的一个改进是使用了 kqueue 的 one-shot 模式，来减少一次 deregister 需要的 syscall。

VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
    struct kevent event;
    u_short event_flags = 0;
    ID id_fileno = rb_intern("fileno");
    int kq = NUM2INT(rb_iv_get(self, "@kq"));
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
    int ruby_interest = NUM2INT(interest);
    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));

    if (ruby_interest & readable) {
        event_flags |= EVFILT_READ;
    }

    if (ruby_interest & writable) {
        event_flags |= EVFILT_WRITE;
    }

    EV_SET(&event, fd, event_flags, EV_ADD|EV_ENABLE|EV_ONESHOT, 0, 0, (void*) io);
    kevent(kq, &event, 1, NULL, 0, NULL); // TODO: Check the return value
    return Qnil;
}

概览

最后我们把主流的操作系统 I/O 多路复用都写了一遍集成到了我们的事件处理库中，整体情况如下：

	Linux	Windows	macOS	FreeBSD
io_uring	✅ (见 1)	❌	❌	❌
epoll	✅ (见 2)	❌	❌	❌
kqueue	❌	❌	✅ (⚠️见 5)	✅
IOCP	❌	❌ (⚠️见 3)	❌	❌
Ruby (`IO.select`)	✅ Fallback	✅ (⚠️见 4)	✅ Fallback	✅ Fallback

当编译时检测到 liburing-dev 已被安装
当 Linux 内核版本 >= 2.6.8
在 I/O 初始化过程中 FILE_FLAG_OVERLAPPED flag 被引入前 无法工作。
一些 I/O 在 Windows 下无法变成非阻塞 I/O，详见调度器文档.
kqueue 在 Darwin 下的一些特殊情况性能很烂，可能会在未来被禁用。

基准测试

那么总体性能如何呢？

下面的测试是在 evt v0.2.2 和 Ruby 3.0.0-rc1 上运行的，详细的测试代码见 evt-server-benchmark。测试仅使用单线程服务器。

测试命令是 wrk -t4 -c8192 -d30s http://localhost:3001.

操作系统	CPU	内存	后端	请求/秒
Linux	Ryzen 2700x	64GB	epoll	54680.08
Linux	Ryzen 2700x	64GB	io_uring	50245.53
Linux	Ryzen 2700x	64GB	Ruby (使用 poll)	44159.23
macOS	i7-6820HQ	16GB	kqueue	37855.53
macOS	i7-6820HQ	16GB	Ruby (使用 poll)	28293.36

相当惊人。这个结果有几方面因素。现在的 Falcon 等异步框架使用的都是基于 nio4r 来实现的，其背后是 libev。libev 在各个异步事件库中的性能本来就是比较一般的，再加上其为了更好的兼容性做了大量的妥协。另一方面，以前的调度库需要大量 Ruby 元编程帮助，而现在几乎都是在 C extension 间完成的，性能也有了很大的提升。

另外比起我们之前在 preview1 上做的测试，这个版本的 Fiber 调度器修复了大量的错误，而 wrk 的测试结果是非常错误敏感的，这使得我们最终的请求速度比起之前又提升了 10 倍。

与 Ractor 结合

我在 2020 年 11 月 17 日写过一篇关于 Ractor 的扫盲贴《Ractor 下多线程 Ruby 程序指南》，Ractor 和 Fiber 的结合始终是一个有意思的话题。目前情况下 Fiber 与 Ractor 结合来实现 Web 服务器有两个可能的路径：

在主 Ractor 部署一个调度器，用来处理请求的 accept。将请求派发到子 Ractor 中，由子线程进行处理后将返回值传回主 Ractor 中进行请求返回。
利用 Linux 内核 SO_REUSEPORT 特性让多个 Ractor 同时监听请求，即可直接将单线程服务器扩展成多线程服务器。

比较可惜的是，目前这两者都是无法实现的。因为目前 Fiber 的一些特性无法在 Ractor 中使用。我个人倾向认为这是误报，目前已提交了一个 patch GitHub #3971。根据我之前的测试，Ractor 的加入在实际上应该还能再提升 4 倍左右的吞吐量。不过由于 API 服务器通常是无状态的，主要矛盾也不是 CPU-bound，所以这些吞吐量也是可以由多进程来实现的，Ractor 的引入更多是比起多进程实现的内存消耗降低。

等 Ruby 3.0 更新后我们可以进一步测试。

总结

这比起 preview1 10 倍的性能提升，和比起以前阻塞 I/O 近 36 倍的性能提升足以证明 Ruby 目前服务器的性能问题的本质是 I/O 阻塞问题，而不是 Ruby CPU 执行慢的问题。而随着 I/O 调度器的引入，Ruby 3 的 I/O 性能能更上一个台阶。接下来我们要等待的就是一些使用 C 原生组件的，比如数据库驱动和 Redis 驱动的更新。然后使用一个基于 Fiber 的 Web 服务器，例如 Falcon。无需任何业务上代码的变化，就能得到数倍甚至数十倍的性能提升。

让我们继续享受 Ruby 的快乐编程。

更新

wrk 对于错误非常敏感，这个 benchmark 中的 parser 有问题，无法准确关闭 socket。把我的 Midori 重新捡起来改成了 Ruby 3 Scheduler 项目。性能在 kqueue 达到了 247k req/s 单线程！达到了上百倍的性能提升。epoll 上能达到 627k req/s！

Ractor 下多线程 Ruby 程序指南

dsh0416 — Tue, 17 Nov 2020 15:23:23 +0800

什么是 Ractor?

Ractor 是 Ruby 3 新引入的特性。Ractor 顾名思义是 Ruby 和 Actor 的组合词。Actor 模型是一个基于通讯的、非锁同步的并发模型。基于 Actor 的并发模型在 Ruby 中有很多应用，比如 concurrent-ruby 中的 Concurrent::Actor。Concurrent Ruby 虽然引入了大量的抽象模型，允许开发高并发的应用，但是它并不能摆脱 Ruby 的 GIL (Global Interpreter Lock)，这使得同一时间，只有一个线程是活跃的。所以通常 concurrent-ruby 需要搭配无锁的 JRuby 解释器使用。然而，直接解除 GIL 锁会导致大量默认 GIL 可用的依赖出现问题，在多线程开发中会产生难以预料的线程竞争问题。

去年在 RubyConf China 的时候，我问 matz 说 90 年代多核的小型机以及超级计算机已经变得非常普遍了，为什么会把 Ruby 的多线程设计成这样呢？matz 表示，他当时还在用装着 Windows 95 的 PC，如果他知道以后多核会那么普遍，他也不会把 Ruby 设计成这样。

什么数据可以在 Ractor 间共享？

但是，历史遗留问题依然需要解决。随着 Fiber Scheduler 在 Ruby 3 引用来提高 I/O 密集场景下单一线程利用率极低的问题；我们需要进一步解决，计算密集场景下，多线程的利用率。

为了解决这一问题，Ruby 3 引入了 Ractor 模型。Ractor 本质来说还是 Thread 线程，但是 Ractor 做了一系列的限制。首先，锁是不会在 Ractor 之间共享的；也就是说，不可能有两个线程争抢同一个锁。Ractor 和 Ractor 之间可以传递消息。Ractor 内部具有全局锁，确保 Ractor 内的行为和原先 Thread 是一致的。传递消息必须是值类型的，这意味着不会有指针跨 Ractor 生存，也会避免数据竞争问题。简而言之，Ractor 把每个 Thread 当作一个 Actor。

但 Ruby 没有真正的值类型。但值类型的本质就是用拷贝来替代引用。我们要做的就是确保 Ruby 对象的可拷贝性。我们查看 Ractor 的文档，我们可以看到这个的严格描述：

Ractors don't share everything, unlike threads.

* Most objects are *Unshareable objects*, so you don't need to care about thread-safety problem which is caused by sharing.
* Some objects are *Shareable objects*.
  * Immutable objects: frozen objects which don't refer to unshareable-objects.
    * `i = 123`: `i` is an immutable object.
    * `s = "str".freeze`: `s` is an immutable object.
    * `a = [1, [2], 3].freeze`: `a` is not an immutable object because `a` refer unshareable-object `[2]` (which is not frozen).
  * Class/Module objects
  * Special shareable objects
    * Ractor object itself.
    * And more...

Ractor 性能提升测试

为了测试出 Ractor 的效果，我们需要一个计算密集的场景。最计算密集的场景，当然就是做数学计算本身。比如我们有下面一个程序：

DAT = (0...72072000).to_a
p DAT.map { |a| a**2 }.reduce(:+)

这个程序计算 0 到 72072000 的平方和。我们运行一下这个程序，得到运行时间是 8.17s。

如果我们用传统的多线程来写，我们可以把程序写成这样：

THREADS = 8
LCM = 72072000
t = []

res = []
(0...THREADS).each do |i|
  r = Thread.new do
    dat = (((LCM/THREADS)*i)...((LCM/THREADS)*(i+1))).to_a
    res << dat.map{ |a| a ** 2 }.reduce(:+)
  end
  t << r
end

t.each { |t| t.join }
p res.reduce(:+)

运行后，我们发现，虽然确实创建了 8 个系统线程，但是总运行时间变成了 8.21s。没有显著的性能提升。

使用 Ractor 重写程序，主要需要改变我们子线程内需要访问外面的 i 变量，我们用消息的方法传递进去，改进后的代码会变成这样：

THREADS = 8
LCM = 72072000
t = []

(0...THREADS).each do |i|
  r = Ractor.new i do |j|
    dat = (((LCM/THREADS)*j)...((LCM/THREADS)*(j+1))).to_a
    dat.map{ |a| a ** 2 }.reduce(:+)
  end
  t << r
end

p t.map { |t| t.take }.reduce(:+)

其结果如何呢？我们根据不同的线程数量进行了测试。

Threads	AMD Ryzen 7 2700x	Intel i7-6820HQ
1	8.171	12.027
2	4.483	6.913
3	4.874	6.755
4	2.353	6.188
5	2.429	5.154
6	2.259	5.320
7	1.908	5.368
8	2.156	5.754
9	2.136
10	3.159
11	2.577
12	2.679
13	2.787
14	2.615
15	2.197
16	2.303

Ractor 确实改善了多线程全局解释锁的问题。

显微镜下的 Ractor

我使用了 AMD uProf（对于 Intel CPU，可以使用 Intel VTune）进行 CPU 运算情况的统计。为了降低睿频对单线程性能的影响，我将 AMD Ryzen 7 2700x 全核心锁死 4.2GHz。

对于 AMD Ryzen 7 2700x，4 线程比单一线程快了 3 倍多。到 4 线程，比单一线程快了约 4 倍。AMD Ryzen 7 2700x 是一款 8 核心 16 线程的 CPU。同时，每 4 个核心组成一个 CCX，跨 CCX 的内存访问有额外的代价。这使得 4 线程内性能提升很显著，超过 4 线程后受限于 CCX 和 SMT，性能提升变得比较有限。其表现是随着线程数的增加，IPC（每时钟周期指令数）开始下降。在单线程运算时，每时钟周期 CPU 可以执行 2.42 个指令；但到了 16 线程运算时，每时钟周期 CPU 只能执行 1.40 个指令。同时，更多的线程意味着更复杂的操作系统的线程调度，使得多核的利用率越来越低。

同样，对于 Intel i7-6820HQ，我们得到了类似的结论。这是一款 4 核 8 线程的 CPU，由于第 5 个线程开始需要使用 HT，从而提升变得很有限。

Ractor 如何改善现有 Ruby 程序的性能？

Ractor 的引入除了可以改善计算密集场景下的运算效率，对于现有大型 Ruby Web 程序的内存占用也是有积极意义的。现有 Web 服务器，比如 puma，由于 I/O 多路复用性能极其低下，通常会使用多线程 + 多进程的形式来提升性能。由于 Web 服务器可以自由水平扩展，使用多进程的形式来管理，可以完全解开 GIL 锁的问题。

但是 fork 指令效率低下。微软在 2019 年 HOTOS 上给出了一篇论文：A fork() in the road，和 spawn 相比，fork 模式会导致启动速度变得非常慢。为了缓解这一问题，在 Ruby 2.7 引入 GC.compact 后，通常需要执行多次 compact 来降低 fork 启动的消耗。进一步地，使用 Ractor 来替代多进程管理，可以更容易地传递消息，复用可冻结的常量，从而降低内存占用。

总结

Ruby 3 打开了多线程的潘多拉盒子。我们可以更好利用多线程来改善性能。但是看着 CPU Profiler 下不同线程调用会导致 CPU IPC 下降和缓存命中下降，对程序调优也提出了更高的要求。

我们边走边看吧。

尝试使用 Ruby 3 调度器

dsh0416 — Tue, 18 Aug 2020 21:10:19 +0800

一次失败的提案

在准备 RubyConf China 2020 的时候，我仔细检查了 Fiber 调度器提出的补丁。当我看调度器的样例代码的时候，我发现其调用的是 Ruby 中的 IO.select API。IO.select API 在 Ruby 内部有多种实现，它可能调用 poll、大尺寸 select、POSIX 兼容的 select 取决于不同的操作系统。于是我想用一些更快的 syscall 来实现，比如 epoll kqueue 和 IOCP。

我做了一个相关的提案但是被拒绝了。主要问题是 Ruby 的 IO.select API 是无状态的。如果没有含状态的注册，这些新 API 的性能甚至会不如 poll。在 Koichi Sasada 跑了 banchmark 证明了这一点后，提案被正式拒绝。在和 Samuel Williams 在 Twitter 上讨论后，它建议我从 Scheduler 的实现上来进行注入，因为 Scheduler 本身是有状态的。于是我开始写一个 gem 作为 Ruby 3 调度器接口的概念证明。

实现调度器

本文中的 Ruby 版本是：

ruby 2.8.0dev (2020-08-18T10:10:09Z master 172d44e809) [x86_64-linux]

基本的 Scheduler 例子来自于 Ruby 的单元测试。这是 Ruby 3 调度器的测试，而不是真正用于生产的，因此是使用 IO.select 进行 I/O 多路复用。因此我们可以基于此，开发一个性能更好的 Ruby 调度器。

我们需要做一些 C 开发来支持其它 syscall，因此第一件事是兼容原始的实现。

Fallback 到 Ruby `IO.select`

对于 select/poll API, 不需要预先创建文件描述符，也不需要在运行时注册文件描述符。所以唯一要做的就是处理调度器触发时的行为。

VALUE method_scheduler_wait(VALUE self) {
    // return IO.select(@readable.keys, @writable.keys, [], next_timeout)
    VALUE readable, writable, readable_keys, writable_keys, next_timeout;
    ID id_select = rb_intern("select");
    ID id_keys = rb_intern("keys");
    ID id_next_timeout = rb_intern("next_timeout");

    readable = rb_iv_get(self, "@readable");
    writable = rb_iv_get(self, "@writable");

    readable_keys = rb_funcall(readable, id_keys, 0);
    writable_keys = rb_funcall(writable, id_keys, 0);
    next_timeout = rb_funcall(self, id_next_timeout, 0);

    return rb_funcall(rb_cIO, id_select, 4, readable_keys, writable_keys, rb_ary_new(), next_timeout);
}

我们花了 10 行 C 干了原来 1 行 Ruby 就干好了的事。主要是这允许我们用 C 的宏定义来控制，从而使用其它 I/O 多路复用方法，例如 epoll and kqueue。我们需要实现 4 个 C 方法：

Scheduler.backend
scheduler = Scheduler.new

scheduler.register(io, interest)
scheduler.deregister(io)
scheduler.wait

#include <ruby.h>

VALUE Evt = Qnil;
VALUE Scheduler = Qnil;

void Init_evt_ext();
VALUE method_scheduler_init(VALUE self);
VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest);
VALUE method_scheduler_deregister(VALUE self, VALUE io);
VALUE method_scheduler_wait(VALUE self);
VALUE method_scheduler_backend();

void Init_evt_ext()
{
    Evt = rb_define_module("Evt");
    Scheduler = rb_define_class_under(Evt, "Scheduler", rb_cObject);
    rb_define_singleton_method(Scheduler, "backend", method_scheduler_backend, 0);
    rb_define_method(Scheduler, "init_selector", method_scheduler_init, 0);
    rb_define_method(Scheduler, "register", method_scheduler_register, 2);
    rb_define_method(Scheduler, "deregister", method_scheduler_deregister, 1);
    rb_define_method(Scheduler, "wait", method_scheduler_wait, 0);
}

Scheduler.backend 是专门给调试用的，剩下 4 个 API 会注入到调度器的 Scheduelr#run, Scheduelr#wait_readable, Scheduelr#wait_writable, Scheduelr#wait_any 中。

使用 `epoll` 和 `kqueue`

epoll 的三个核心 API 是 epoll_create epoll_ctl epoll_wait。很好理解，我们只要在调度器初始化的时候初始化 epoll fd，然后在注册 I/O 事件的时候调用 epoll_ctl，最后用 epoll_wait 替换掉 IO.select。

#if defined(__linux__) // TODO: Do more checks for using epoll
#include <sys/epoll.h>
#define EPOLL_MAX_EVENTS 64

VALUE method_scheduler_init(VALUE self) {
    rb_iv_set(self, "@epfd", INT2NUM(epoll_create(1))); // Size of epoll is ignored after Linux 2.6.8.
    return Qnil;
}

VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
    struct epoll_event event;
    ID id_fileno = rb_intern("fileno");
    int epfd = NUM2INT(rb_iv_get(self, "@epfd"));
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
    int ruby_interest = NUM2INT(interest);
    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WAIT_READABLE")));
    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WAIT_WRITABLE")));

    if (ruby_interest & readable) {
        event.events |= EPOLLIN;
    } else if (ruby_interest & writable) {
        event.events |= EPOLLOUT;
    }
    event.data.ptr = (void*) io;

    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);
    return Qnil;
}

VALUE method_scheduler_deregister(VALUE self, VALUE io) {
    ID id_fileno = rb_intern("fileno");
    int epfd = NUM2INT(rb_iv_get(self, "@epfd"));
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL); // Require Linux 2.6.9 for NULL event.
    return Qnil;
}

VALUE method_scheduler_wait(VALUE self) {
    int n, epfd, i, event_flag, timeout;
    VALUE next_timeout, obj_io, readables, writables, result;
    ID id_next_timeout = rb_intern("next_timeout");
    ID id_push = rb_intern("push");

    epfd = NUM2INT(rb_iv_get(self, "@epfd"));
    next_timeout = rb_funcall(self, id_next_timeout, 0);
    readables = rb_ary_new();
    writables = rb_ary_new();

    if (next_timeout == Qnil) {
        timeout = -1;
    } else {
        timeout = NUM2INT(next_timeout);
    }

    struct epoll_event* events = (struct epoll_event*) xmalloc(sizeof(struct epoll_event) * EPOLL_MAX_EVENTS);

    n = epoll_wait(epfd, events, EPOLL_MAX_EVENTS, timeout);
    // TODO: Check if n >= 0

    for (i = 0; i < n; i++) {
        event_flag = events[i].events;
        if (event_flag & EPOLLIN) {
            obj_io = (VALUE) events[i].data.ptr;
            rb_funcall(readables, id_push, 1, obj_io);
        } else if (event_flag & EPOLLOUT) {
            obj_io = (VALUE) events[i].data.ptr;
            rb_funcall(writables, id_push, 1, obj_io);
        }
    }

    result = rb_ary_new2(2);
    rb_ary_store(result, 0, readables);
    rb_ary_store(result, 1, writables);

    xfree(events);
    return result;
}

VALUE method_scheduler_backend() {
    return rb_str_new_cstr("epoll");
}
#endif

kqueue 是类似的。唯一不同的是，BSD 的注册和等待用的是同一个 API，只是参数不同，所以有点难懂。

#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__)
#include <sys/event.h>
#define KQUEUE_MAX_EVENTS 64

VALUE method_scheduler_init(VALUE self) {
    rb_iv_set(self, "@kq", INT2NUM(kqueue()));
    return Qnil;
}

VALUE method_scheduler_register(VALUE self, VALUE io, VALUE interest) {
    struct kevent event;
    u_short event_flags = 0;
    ID id_fileno = rb_intern("fileno");
    int kq = NUM2INT(rb_iv_get(self, "@kq"));
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
    int ruby_interest = NUM2INT(interest);
    int readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WAIT_READABLE")));
    int writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WAIT_WRITABLE")));

    if (ruby_interest & readable) {
        event_flags |= EVFILT_READ;
    } else if (ruby_interest & writable) {
        event_flags |= EVFILT_WRITE;
    }

    EV_SET(&event, fd, event_flags, EV_ADD|EV_ENABLE, 0, 0, (void*) io);
    kevent(kq, &event, 1, NULL, 0, NULL); // TODO: Check the return value
    return Qnil;
}

VALUE method_scheduler_deregister(VALUE self, VALUE io) {
    struct kevent event;
    ID id_fileno = rb_intern("fileno");
    int kq = NUM2INT(rb_iv_get(self, "@kq"));
    int fd = NUM2INT(rb_funcall(io, id_fileno, 0));
    EV_SET(&event, fd, 0, EV_DELETE, 0, 0, NULL);
    kevent(kq, &event, 1, NULL, 0, NULL); // TODO: Check the return value
    return Qnil;
}

VALUE method_scheduler_wait(VALUE self) {
    int n, kq, i;
    u_short event_flags = 0;

    struct kevent* events; // Event Triggered
    struct timespec timeout;
    VALUE next_timeout, obj_io, readables, writables, result;
    ID id_next_timeout = rb_intern("next_timeout");
    ID id_push = rb_intern("push");

    kq = NUM2INT(rb_iv_get(self, "@kq"));
    next_timeout = rb_funcall(self, id_next_timeout, 0);
    readables = rb_ary_new();
    writables = rb_ary_new();

   events = (struct kevent*) xmalloc(sizeof(struct kevent) * KQUEUE_MAX_EVENTS);

    if (next_timeout == Qnil || NUM2INT(next_timeout) == -1) {
        n = kevent(kq, NULL, 0, events, KQUEUE_MAX_EVENTS, NULL);
    } else {
        timeout.tv_sec = next_timeout / 1000;
        timeout.tv_nsec = next_timeout % 1000 * 1000 * 1000;
        n = kevent(kq, NULL, 0, events, KQUEUE_MAX_EVENTS, &timeout);
    }

    // TODO: Check if n >= 0
    for (i = 0; i < n; i++) {
        event_flags = events[i].filter;
        if (event_flags & EVFILT_READ) {
            obj_io = (VALUE) events[i].udata;
            rb_funcall(readables, id_push, 1, obj_io);
        } else if (event_flags & EVFILT_WRITE) {
            obj_io = (VALUE) events[i].udata;
            rb_funcall(writables, id_push, 1, obj_io);
        }
    }

    result = rb_ary_new2(2);
    rb_ary_store(result, 0, readables);
    rb_ary_store(result, 1, writables);

    xfree(events);
    return result;
}

VALUE method_scheduler_backend() {
    return rb_str_new_cstr("kqueue");
}
#endif

使用调度器的 HTTP 服务器例子

在实现好调度器后，我们要测试调度器的性能。因此我写了一个简单的 HTTP 服务器 benchmark。

require 'evt'

puts "Using Backend: #{Evt::Scheduler.backend}"
Thread.current.scheduler = Evt::Scheduler.new

@server = Socket.new Socket::AF_INET, Socket::SOCK_STREAM
@server.bind Addrinfo.tcp '127.0.0.1', 3002
@server.listen Socket::SOMAXCONN
@scheduler = Thread.current.scheduler

def handle_socket(socket)
  line = socket.gets
  until line == "\r\n" || line.nil?
    line = socket.gets
  end
  socket.write("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
  socket.close
end

Fiber.new(blocking: false) do
  while true
    socket, addr = @server.accept
    Fiber.new(blocking: false) do
      handle_socket(socket)
    end.resume
  end
end.resume

@scheduler.run

比起原先阻塞的 I/O，使用 Ruby 3 非阻塞 I/O 后可以达到 3.33x 的性能，而使用 epoll 后可以达到 4.21x。服务器的例子很简单，所以当 JIT 启动时，不容易造成 ICache 不命中，因此性能进一步提升到了 4.54x。

测试是基于 Intel(R) Xeon(R) CPU E3-1220L V2 @ 2.30GHz CPU 的，而且程序是单线程的。如果有更好的 CPU，epoll 和 poll 的差距会更大。欢迎尝试，相关 gem 代码已开源。

未来工作

未来工作主要是两部分。一个是提升现有 API 的稳定性，还有就是加入 io_uring 和 IOCP 的支持。io_uring 倒是还好，但我是一点都不懂 Windows 开发。所以欢迎大家来提供意见和贡献。

源码

dsh0416/evt

拯救老婆 —— MacBook Pro 维修计划

dsh0416 — Wed, 12 Aug 2020 17:49:04 +0800

我的老婆不行了

我的 MacBook Pro 15 (late-2016) 真的不行了。

作为一款 16 GB 内存，i7-7820HQ CPU 的电脑，实在是卡得不行。特别是在我搬家后，机器已经卡到一个完全不能忍受的地步。kernel_task 进程自己能吃掉 6 GB 的内存，还能吃掉 250% 的 CPU，一丁点道理都没有。我打开 Activity Monitor 仔仔细细研究着这个 kernel_task 到底在干什么。慢慢地我发现了几个问题。

软件着手研究问题

首先是内存，我的各种后台程序即使在刚刚开机的情况下也能吃掉 > 20 GB 的内存。而物理内存只有 16 GB，这意味着 swap 介入了。这直接体现就是我的硬盘吞吐量惊人。运行一天 kernel_task 硬盘吞吐量高达 2TB。如果这么下去，先不说机器卡不卡，我对我 SSD 的寿命感到怀疑。特别是这一代的 SSD 并不是可更换的，一旦健康状况出问题，会变得非常麻烦。

说到硬盘我就发现了另一个问题，一旦我从 NAS 上大量拉数据到硬盘，CPU 占用也会狂飙。这时候我就想到 Mac 的一个芯片问题 —— Apple T1 Chip。在后续机型中，苹果使用的 T2 芯片是能够负责硬盘加解密的，而 T1 芯片其实主要就是 SMC (EC) 芯片的替代，只是加入了 TouchID 指纹芯片的一些特性。这意味着我的电脑的硬盘加解密是跑在 CPU 上的。在我 CPU 如此卡顿的情况下，我必须要从软件上先处理这一问题。

于是我把系统备份，然后重装成了 macOS Big Sur，同时关闭了 FileVault，暂停了全盘加解密。

是什么在导致 CPU 疯狂降频？

然而重装后虽然 swap 的问题减轻了，但是机器并不能算快。一旦运行一些负载稍微大一点的应用，比如 Chrome 或者 Firefox，机器还是会变卡。这意味着还有别的问题在困扰我的老婆。

既然主要问题来自 CPU，于是我去下载了一个 Intel Power Gadget 来查看 CPU 的具体情况。结果发现，当 CPU 降频发生时，CPU 温度只有 60 多摄氏度，而风扇却已经满载了。严重时，频率降到了 1.0GHz，远远低于 CPU 的基础频率。这意味着，有别的东西在引发降频。正当我一筹莫展的时候，我把充电线一拔，突然 CPU 频率就回去了（？？？）

于是我尝试搜索了充电和降频的问题，果然很快就找到了一些文章。在左侧的 Type-C 接口充电，会导致 MacBook Pro 过热降频。所以，你必须 Charge Your MacBook Pro“Right”。当我把充电线移动到右边后，至少 MacBook Pro 可以不那么卡了。

风扇转速为什么还是那么高？

然而在移动了充电线后，CPU 的温度倒是上去了，风扇一直在高负载转动，这也太奇怪了。如果我们在软件或者外设上找不到原因，可能硬件上确实出了问题。于是我先简单把外壳先拆了，发现整个壳子内的灰已经满到结成毛团了。在我用刷子先把壳子里的灰尘和风扇上的灰尘清理后，机器的降频现象得到了改善。

CPU 满载时为什么还会降频？

于是我开始对机器进行压力测试。可惜压力测试 5 分钟后，CPU 还是达到 100 摄氏度触发过热降频，虽然频率只会降到 2.2GHz，但我觉得鳍片上没有处理到的灰尘可能是原因。于是我决定给机器来个大扫除，清理灰尘，更换硅脂。

我打开 ifixit 开始看这台机器的拆解。结果发现这款机器要想更换硅脂，几乎要把所有东西都拆了，要拆掉 114514 个螺丝。我想不行我还是找个店铺来帮我弄吧。于是开始找日本的 Mac 修理的店铺。结果发现光拆机器的手工费就要 15000 日元。看着这个价格，我想我一万上的劳动也能省这 15000 日元吧。

于是我照着教程一个个把螺丝拆下来。果然鳍片上全是灰尘，而且苹果的这个便宜硅脂也已经发干了。最后我给 CPU 和 GPU 重新上了 MX-4 的硅脂，小心安装回去，一个螺丝也没有多。开机，轻松点亮。

我的老婆救回来了

更换完散热的结果如何呢？

以默认风扇 profile，烤机 2 分钟风扇甚至都不会满载。而强制风扇满载后，CPU 烤机温度也只有 86 摄氏度，不但不降频，甚至还能睿频！至此，我的老婆终于被我抢救了回来，再也不用过着靠插管度日的生活，可以开开心心地安享她的下半生了。

Ruby 3 Fiber 变化前瞻

dsh0416 — Sun, 26 Jul 2020 13:31:46 +0800

引

随着 GitHub #3032 的合并，从 Feature #13618 开始的，关于 Ruby Fiber 调度器的讨论取得了实质性的进展。但相关的变化还没有结束。目前正在被讨论与还没有合并的 Issue 还包括 Feature #16786、Feature #16792。这些 Issue 正在围绕 Ruby Fiber 调度器剩余的一些实现进行讨论，这些围绕着 Fiber 技术展开的对并发的实现，将作为 Ruby 3 并发提升的重要来源之一。

Ruby 3 Fiber 调度器会给我们带来什么？如何理解 Ruby 3 Fiber 调度器的引入？如何面对 Ruby 3 Fiber 的新变化？本文就此些问题进行一些讨论。

为什么要有 Fiber？

现代操作系统一个基本的特性就是允许多任务的执行。这个「多任务」可能是多线程或者多进程系统。对于一个 CPU，一个典型的情况是拥有 8 个左右的核心数，所以理论上只能同时执行 8 个任务。但操作系统同时执行的进程数往往有数千个，并不能「真正」同时运行。而操作系统需要在不同进程中快速切换从而实现多任务的同时运行。

现代操作系统使用的调度系统称为抢占式调度系统。简单理解，就是任务运行过程中，如果其它任务急需运行，操作系统会强制停止当前任务来执行其它任务。更传统的操作系统会使用协作式多任务（cooperative multitasking）系统来实现。也就是一个正在执行的任务必须主动宣布自己可以暂停运行，系统才会把执行权交给其它任务。Windows 3.1x、Mac OS 9 就是使用该方法进行的任务调度。

协作式多任务有着显著的优点和缺点。优点是切换的频率减少，执行效率提高了。而缺点是如果有程序发生了死循环或者长时间占用，系统就会陷入卡死，用户体验极差。

然而不同于操作系统，对于单一程序内，协作式多任务有时会带来更大的好处。由于线程是由操作系统实现和管理的，调度必须依赖操作系统，而一次操作系统的切换会带来很大的耗时。相比操作系统无法确定程序会不会发生死循环，自己的程序内部代码完全是自己控制的，如果发生死循环那必然是自己的代码问题。在自己的程序内实现一个简单的协作式多任务系统来提高并发显然是个好办法。

而 Ruby 标准库就实现了一个简单的协作式多任务系统，其中的最小的执行单元称为 Fiber 纤程。提供了 resume yield 和 transfer 方法，实现了纤程之间的切换。

Fiber 的实现很简单，早年 Ruby Fiber 是基于 caller、 callee 来实现的。熟悉 Lisp 语言的，对这两个函数可能是再熟悉不过了。但是对于现在的 Ruby Fiber 实现，主要可以参考 Feature #14739 的实现。由于这个代码是多个机器平台的汇编实现（出于性能上的考虑），我们这里以 amd64 平台为例。

##
##  This file is part of the "Coroutine" project and released under the MIT License.
##
##  Created by Samuel Williams on 10/5/2018.
##  Copyright, 2018, by Samuel Williams. All rights reserved.
##

.text

# For older linkers
.globl _coroutine_transfer
_coroutine_transfer:

.globl coroutine_transfer
coroutine_transfer:
    # Save caller state
    pushq %rbp
    pushq %rbx
    pushq %r12
    pushq %r13
    pushq %r14
    pushq %r15

    # Save caller stack pointer
    movq %rsp, (%rdi)

    # Restore callee stack pointer
    movq (%rsi), %rsp

    # Restore callee stack
    popq %r15
    popq %r14
    popq %r13
    popq %r12
    popq %rbx
    popq %rbp

    # Put the first argument into the return value
    movq %rdi, %rax

    # We pop the return address and jump to it
    ret

简简单单，非常好理解。amd64 的 callee-saved register 是 %rbx (base pointer), %rbp (frame prointer) 以及 %r12 %r13 %r14 %r15。把这 6 个指针塞入栈，然后把栈指针 %rsp 返回。而还原一个上下文则是把这个栈顶指针找出来，然后依次取出这 6 个指针，就还原了上下文。

Fiber 与 I/O

但是要想让 Fiber 来提升 Web 系统的并发问题，还需要解决一个问题，那就是基于 I/O 的调度。我们清楚地知道，如果我们收到一个连接，在 Web 请求传输完之前，我们的 Ruby 程序什么都不能做，只能干等。而当我们处理完返回结果后，我们还是要干等到数据传输完后才能关闭连接。虽然现代的 rack 服务器例如 puma 能够异步解决这一问题。但是一旦涉及到 Redis、数据库和文件读写，我们依然逃不开这个问题。这是包括 Rails 在内的 Ruby 几乎所有 Web 框架性能问题的主要原因。

如果我们能围绕 I/O 设计一个 Fiber 调度器，那么我们就能极大提高 Ruby Web 框架的性能，但是这个问题并不是没有人做过。从早年的 EventMachine 到基于 nio4r 的 async，包括我自己写的 midori 内单独实现的调度器 murasaki，都是相同的原理。虽然这些框架的细节、性能和功能略有不同。

Ruby 今天 Fiber 自动异步调度仍然没有称为主流的核心原因是社区的分裂。

这几个开源的调度器都有一些小问题，然而大家的解决方法就是「一言不合，再写一个」。这使得像是 ActiveRecord 之类的常用框架都很难跟进这些快速迭代的调度器。根本方法就是大家合力来维护同一个调度器，让这个调度器进入标准库。这就是 GitHub #3032 的核心思路。

Scheduler 主要实现了三个核心的调度形式 scheduler.wait_writable scheduler.wait_readable 和 scheduler.wait_sleep。也就是当 Fiber 需要等待 I/O 完成写入、读取或者需要休眠时，就会主动将工作权让渡出来，交给其它 Fiber。从而实现基于多个 Fiber 的单线程内的并发性能提升。

目前 Fiber 调度器剩余的问题

目前 Scheduler 使用 poll 和 select 方法实现 I/O 的多路复用，而未来显然会支持 Linux 上的 epoll 、BSD 上的 kqueue、Windows 上的 iocp 来实现更好的多路复用性能，而无需调整 API。因为以目前 Ruby Scheduler 的 API 定义，是可以兼容这些多路复用方法的。而至于会不会去支持 macOS 的 kqueue 可能就要打个问号了，毕竟 macOS 的多路复用实现太 buggy 了。

另一个 Ruby 3 Fiber 亟待解决的问题是目前的 Mutex 锁是基于线程的。而对于同一个 Thread 下多个 Fiber 出现的锁竞争，Mutex 会遇到不小的问题。而目前各个已有的框架都是通过元编程在业务上解决的，比如我 midori-contrib 中对 MySQL 的封装就使用了一系列奇技淫巧来避免问题。不过好在 Feature #16792 正在针对这一问题提出方案，希望在 Ruby 3 之前能够有比较好的解决。

如何迎接 Ruby 3 Fiber 的新变化？

如何你是单纯的 Ruby 高级框架的使用者，那么你几乎什么都不用做。你只需要等着你常用的框架例如 Rails、Sinatra、ActiveRecord、Sequel 更新来支持这一特性，你的 Web 性能就理应会得到质的飞跃。根据我个人的实测，Ruby 的 Web 服务受到 I/O 调度问题而损失的性能高达 80% 到 90%，这意味着随着你使用的库全面支持 Fiber 的自动调度后，性能有望提升 5-10 倍。

如果你是 Ruby 框架的维护者和贡献者，那么你要做的事情就相对比较多。本来我想在这篇文章中进一步讨论 Fiber 调度器的使用，不过由于 API 还有很大的变化的可能，并且你需要使用 ruby-head 版本才能进行体验，我决定把该内容放在之后的文章里讲。核心的就是要尽快让你的 gem 中涉及底层 I/O 调用、锁实现和计时实现兼容新 Fiber。因为对于一个任务的 I/O 阻塞来说，一处阻塞处处阻塞，良好的性能必须要由完全不阻塞的 I/O 实现才能做到，否则都会受到显著的影响。

如果你是 Ruby 的贡献者，并且于 Ruby 不需要额外引入类似 async await 的原语而实现 I/O 无痛的性能提升很感兴趣的话，Ruby 3 Fiber 调度器需要做的事情还很多。比如对 epoll kqueue iocp 的支持；比如对 Ruby 2.x 的 backports。请不要害羞，请尽情贡献你的代码吧。

结

Ruby 今天 27 岁了，慢慢步入中年。但是我们依然能看到这门步入中年的语言里闪烁着令人激动的新特性的光辉。也许中年危机不单单是中年危机，更是中年转机。而这份转机靠的是我们每一个 Ruby 的使用者、贡献者和宣传者，让更多的程序员开心起来。

83 行 Ruby 的蓝调即兴生成器

dsh0416 — Thu, 23 Apr 2020 12:09:19 +0800

刻板印象的蓝调

如果让我用代码来生成音乐，我可能优先的类型就是爵士。像是流行音乐，要是来几颗不和谐音，这听起来可就一点都不流行了。但爵士不一样，弹错一次是弹错，如果能连续弹错两次，那就是真正的爵士艺术家了（逃）。但爵士对乐理的要求太高，要想完全靠代码把逻辑理清楚那也不是一件容易的事。一个好的爵士即兴实在是太难了，不过我们可以根据一些刻板印象来做一做。我就想到了十二小节蓝调和声进行以及蓝调音阶，单靠这两个就一下子把需要的伴奏和旋律的模式给提供了一个大概，也许可以试试用代码来自动生成看看。

合成器方面我用的是 Sonic Pi，一款基于 Ruby 的实时编码音乐合成器。其实我之前用过一两次，也不算太会用这个库，也是突发奇想然后现学的。

节奏生成

首先还是要有一个节奏生成器，由于是蓝调音乐，节奏其实可以比较随性。我的基本想法很简单，在给定一个小节里随机填充四分、八分音符。

FOURTH = 0.5
EIGHTH = FOURTH / 2
SIXTEENTH = EIGHTH / 2

def generate_rhythms(candidates=[EIGHTH, FOURTH], remaining_time=FOURTH*4)
  rhythms = []

  while remaining_time > candidates.min
    rhythm = choose(candidates)
    rhythms << rhythm
    remaining_time -= rhythm
  end

  rhythms << remaining_time if remaining_time > 0

  rhythms
end

节奏上想要比较 swing 一点。一个刻板印象的 swing 就是两个八分音符前一拍长一点，后一拍短一点。所以我就在随机填充后在做了一些手动上的修改：

def generate_rhythms(candidates=[EIGHTH, FOURTH], remaining_time=FOURTH*4)
  rhythms = []

  while remaining_time > candidates.min
    rhythm = choose(candidates)
    rhythms << rhythm
    remaining_time -= rhythm
  end

  rhythms << remaining_time if remaining_time > 0

  # Generate Swing Pattern
  (rhythms.length - 1).times do |i|
    if rhythms[i] == EIGHTH and rhythms[i + 1] == EIGHTH
      rhythms[i] = EIGHTH + SIXTEENTH
      rhythms[i + 1] = EIGHTH - SIXTEENTH
    end
  end

  rhythms
end

写完节奏，我们写一个测试来听一下。

live_loop :rhythm_test do
  use_synth :pulse
  rhythms = generate_rhythms
  rhythms.each do |t|
    play :C3, release: t
    sleep t
  end
end

感觉还行。

试听

贝斯

有了节奏我们接下来就可以写贝斯。~~贝斯反正很多人听不见，也不用花很大力气写。~~

十二小节蓝调的和弦基本上就是四个一级，两个四级两个一级，一个五级一个四级再两个一级如此重复。贝斯我的想法就是写一个 walking bass（走路贝斯）。基本上就是第一个音是和弦根音（否则听起来就不像这个和弦了），后面的音就是在九和弦的三度、七度、九度音上随便爬就行。

CHORDS_BASE = [:C2, :C2, :C2, :C2, :F2, :F2, :C2, :C2, :G2, :F2, :C2, :C2]

live_loop :bass_line do
  use_synth :fm

  CHORDS_BASE.each do |c|
    notes = chord(c, '9').to_a

    rhythms = generate_rhythms

    play notes[0], release: rhythms[0]
    sleep rhythms[0]

    rhythms[1..-1].each do |t|
      play choose([notes[1], notes[3], notes[4]]), release: t
      sleep t
    end
  end
end

感觉差不多。

试听

左手伴奏

写完了贝斯，最好在高一个八度再写一个左手伴奏，节奏可以和贝斯错开。因为已经有贝斯了，这个伴奏我不想要有和弦根音。然后节奏上希望有一些错落感，不要像 bass 一样从头弹到尾。于是我加了一个随机变量，当到达当前节奏时 50% 演奏和弦，50% 概率直接跳过。

CHORDS_HARMONY = [:C3, :C3, :C3, :C3, :F3, :F3, :C3, :C3, :G3, :F3, :C3, :C3]

live_loop :chord do
  use_synth :fm

  CHORDS_HARMONY.each do |c|
    notes = chord(c, '9').to_a
    rhythms = generate_rhythms

    rhythms.each do |t|
      play [notes[1], notes[3], notes[4]], release: t if choose([true, false])
      sleep t
    end
  end
end

听起来是这样的。这蓝调的味道一下子就来了。

试听

即兴

布鲁斯的即兴旋律其实和写中国五声音阶的即兴旋律差不多。是一个上上下下的循环，然后在里面再做一些变化。我这里选用的音阶是 C Eb F Gb G Bb 和 C1，然后两个小节一生成。默认根据其在小节中的大概位置生成一个上升或下降的旋律，然后提供一个 offset 从 -2 到 2 之间随机。在原先旋律上加上一个 offset，如果超出了我们的音程就 clip 掉。这样应该就能产生一个整体上有上下，但是实际上又有很多变化的旋律了。

和贝斯以及和弦不太一样的是，为了有更多的变化感，节奏要从二分、四分、八分、十六分里任意随机。然后被跳过的概率不用 50% 那么大，10% 应该就可以。

BLUES_SCALE = [:C4, :Eb4, :F4, :Gb4, :G, :Bb4, :C5]

melody_reverse = false
live_loop :melody do
  use_synth :beep

  rhythm = generate_rhythms([FOURTH*2, FOURTH, EIGHTH, SIXTEENTH], remaining_time=FOURTH*8)
  scale_notes = BLUES_SCALE
  scale_notes = scale_notes.reverse if melody_reverse
  melody_reverse = !melody_reverse

  rhythm.each_with_index do |t, i|
    offset = choose([-2, -1, 1, 2])

    new_index = (i.to_f / rhythm.length * scale_notes.length).to_i + offset
    new_index = 0 if new_index < 0
    new_index = scale_notes.length - 1 if new_index >= scale_notes.length

    note = scale_notes[new_index]
    play note, release: t if rrand(0, 1) < 0.9
    sleep t
  end
end

最后我们得到了这样的成品：

试听

总结

完整代码如下：

CHORDS_BASE =    [:C2, :C2, :C2, :C2, :F2, :F2, :C2, :C2, :G2, :F2, :C2, :C2]
CHORDS_HARMONY = [:C3, :C3, :C3, :C3, :F3, :F3, :C3, :C3, :G3, :F3, :C3, :C3]
BLUES_SCALE = [:C4, :Eb4, :F4, :Gb4, :G, :Bb4, :C5]

FOURTH = 0.5
EIGHTH = FOURTH / 2
SIXTEENTH = EIGHTH / 2

def generate_rhythms(candidates=[EIGHTH, FOURTH], remaining_time=FOURTH*4)
  rhythms = []

  while remaining_time > candidates.min
    rhythm = choose(candidates)
    rhythms << rhythm
    remaining_time -= rhythm
  end

  rhythms << remaining_time if remaining_time > 0

  # Generate Swing Pattern
  (rhythms.length - 1).times do |i|
    if rhythms[i] == EIGHTH and rhythms[i + 1] == EIGHTH
      rhythms[i] = EIGHTH + SIXTEENTH
      rhythms[i + 1] = EIGHTH - SIXTEENTH
    end
  end

  rhythms
end

live_loop :bass_line do
  use_synth :fm

  CHORDS_BASE.each do |c|
    notes = chord(c, '9').to_a

    rhythms = generate_rhythms

    play notes[0], release: rhythms[0]
    sleep rhythms[0]

    rhythms[1..-1].each do |t|
      play choose([notes[1], notes[3], notes[4]]), release: t
      sleep t
    end
  end
end

live_loop :chord do
  use_synth :fm

  CHORDS_HARMONY.each do |c|
    notes = chord(c, '9').to_a
    rhythms = generate_rhythms

    rhythms.each do |t|
      play [notes[1], notes[3], notes[4]], release: t if choose([true, false])
      sleep t
    end
  end
end

melody_reverse = false
live_loop :melody do
  use_synth :beep

  rhythm = generate_rhythms([FOURTH * 2, FOURTH, EIGHTH, SIXTEENTH], remaining_time=FOURTH*8)
  scale_notes = BLUES_SCALE
  scale_notes = scale_notes.reverse if melody_reverse
  melody_reverse = !melody_reverse

  rhythm.each_with_index do |t, i|
    offset = choose([-2, -1, 1, 2])

    new_index = (i.to_f / rhythm.length * scale_notes.length).to_i + offset
    new_index = 0 if new_index < 0
    new_index = scale_notes.length - 1 if new_index >= scale_notes.length

    note = scale_notes[new_index]
    play note, release: t if rrand(0, 1) < 0.9
    sleep t
  end
end

一共 83 行，好像还挺像那么回事的。而且由于是一个 Loop，放着程序可以无穷无尽地生成下去，作为什么免费无版权的背景音乐素材好像还是个挺不错的来源。

用 Ruby 学习基本乐理（二）：音程

dsh0416 — Sat, 11 Apr 2020 18:15:53 +0800

什么是音程？

在上一篇文章里，我们认识了音高。这相当于学会了怎么数数。学完数数的小朋友就要学习加减法了，而音高之间的加减法就叫音程。说到「音程」，最类似的日常词语是「路程」。路程是两点间的距离，音程也是两个音高之间的距离。描述音程有两种方法，一种简单的，一种常用的。

音数

简单的方法就是我们执行数学上的减法运算，也就是所谓「半音数差」。比如 C 和 D 之间隔了 2 个半音。

我们把上次的代码稍稍改一下就可以计算音数差了。既然是音数就是个减法运算，我们就可以通过在 Ruby 中实现一个减法方法，从而可以实现 Tone 类之间的减法运算。

class Tone
  STANDARD_TUNING = 440.0
  attr_reader :frequency, :name, :offset

  def initialize(name)
    @name = name
    @offset = parse_name(name)
    @frequency = frequency_by_offset(@offset)
  end

  def parse_name(name)
    raise AugumentError unless name.match?(/^[CDEFGAB][#,b]*\d$/)
    tone = name[0]
    sharps = name[1...-1]
    range = name[-1].to_i

    # Calculate offset
    major_scale = [-9, -7, -5, -4, -2, 0, 2]
    offset = major_scale['CDEFGAB'.index(tone)] + (range - 4) * 12 # Offset without sharps or flats

    sharps.chars.each do |c|
      c == '#' ? offset += 1 : offset -= 1
    end

    offset
  end

  def frequency_by_offset(offset)
    STANDARD_TUNING * (2.0 ** (1.0 / 12)) ** offset
  end

  def harmonic_series(max=Tone.new('B9').frequency)
    tones = []
    (2..).each do |n|
      break if @frequency * n > max
      tones << Tone.by_frequency(@frequency * n)
    end
    tones.uniq { |t| t.name }
  end

  def -(tone)
    raise TypeError unless tone.is_a?(Tone)
    @offset - tone.offset
  end

  class << self
    ALL_TONES = (0..9).map {|range| ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'].map {|name| "#{name}#{range}"}}.flatten.map { |name| Tone.new(name) }

    def by_frequency(freq)
      errs = ALL_TONES.map {|x| (x.frequency - freq).abs }
      ALL_TONES[errs.rindex(errs.min)]
    end
  end
end

p Tone.new('C3') - Tone.new('D3') # => -2

我们 C3 比 D3 低了 2 个半音，完美。

音级

另一种对音程的描述是基于音级的。在上篇文章我们说到过

音高到音名的关系是一对多的，D、C## 可以表示同一个音高（取决于作曲家的具体需求）。

这是因为在乐理中，音高是在某一个音阶（音高的集合）上的概念。当要在具体音符上使用升降记号时，说明是要使用音阶外音。而音阶外音就需要标注是从音阶中哪个音变化过去的。这就是为什么像是 C# 和 Db 在乐理中是两个不同的音。这一点在五线谱上实际上是特别清晰的，但是很多流行音乐或者电子音乐的制作流程已经完全是基于 midi 乐器的。而 midi 乐器只关心实际的频率，通常都是在钢琴卷帘上进行创作的，是完全不区分 C# 与 Db 的，这也是很多流行音乐创作者容易犯的乐理错误。

（这下理解流行乐坛乐理小王子怎么在节目里讲乐理被真音乐学院副教授给骂了吧。）

但是我们刚刚的基于音数的音程计算方法，完全不能体现出这样的特性。于是我们应该在描述音的距离的时候，要基于音阶上的音，同时也要能给出不少于音数的信息量。描述音阶上的音我们就要引入音级的概念。

音级	C	D	E	F	G	A	B
C	1	2	3	4	5	6	7
D	2	1	2	3	4	5	6
E	3	2	1	2	3	4	5
F	4	3	2	1	2	3	4
G	5	4	3	2	1	2	3
A	6	5	4	3	2	1	2
B	7	6	5	4	3	2	1

音级是描述音名与音名之间的距离关系，单位是度，这一关系完全忽略升降号。然而比较奇怪的是，相同音是 1 度音，而不是 0 度。换句话说，纯一度是这个音级加法群的单位元，而不是大家熟悉的 0。

def interval_number(tone)
  raise TypeError unless tone.is_a?(Tone)
  if self - tone > 0
    'CDEFGAB'.index(@name[0]) - 'CDEFGAB'.index(tone.name[0]) + (@name[-1].to_i - tone.name[-1].to_i) * 7 + 1
  else
    'CDEFGAB'.index(tone.name[0]) - 'CDEFGAB'.index(@name[0]) + (tone.name[-1].to_i - @name[-1].to_i) * 7 + 1
  end
end

p Tone.new('C3').interval_number(Tone.new('D3')) # => 2
p Tone.new('C3').interval_number(Tone.new('G2')) # => 4
p Tone.new('C3').interval_number(Tone.new('C1')) # => 15

形态

对于音级的修饰叫「型态」，乐理上有 5 种基本型态：大、小、纯（完全）、增、减。分别用 M, m, P, A, d。其中 1 4 5 8 度用的是增、纯、减这三个词，而 2 3 6 7 度用的是大、小、增、减。在 C 大调上 C D E F G A B C1 与 C 的关系分别是纯一度大二度大三度纯四度纯五度大六度大七度纯八度。比大音程小一个半音的叫小音程。比小音程或纯音程小一个半音的叫减音程，而比大音程或纯音程大一个半音的叫增音程。然后更大更小的再前面用倍字修饰。

所以理论上 C 和 D#### 之间的音程是「倍倍倍增二度」，而频率完全相同的 C 和 F# 则是「增四度」。

def interval_type(tone)
  raise TypeError unless tone.is_a?(Tone)
  semitones = (self - tone).abs % 12
  number = (interval_number(tone) - 1) % 7 # Eighth's type is equal to union's.
  default_type_semitones = [0, 2, 4, 5, 7, 9, 11]
  default_types = %w(P M M P P M M)
  delta = semitones - default_type_semitones[number]
  current_type = default_types[number]

  until delta == 0
    if delta > 0 and (current_type == 'P' or current_type == 'M')
      delta -= 1
      current_type = 'A'
    elsif delta > 0
      delta -= 1
      current_type = "A#{current_type}"
    elsif delta < 0 and (current_type == 'P' or current_type == 'm')
      delta += 1
      current_type = "d"
    else
      delta += 1
      current_type = "d#{current_type}"
    end
  end

  current_type
end

p Tone.new('C3').interval_type(Tone.new('D3')) # => "M"
p Tone.new('C3').interval_type(Tone.new('G2')) # => "P"
p Tone.new('C3').interval_type(Tone.new('C1')) # => "P"

总结

最后我们结合一下这两者：

def interval(tone)
  "#{interval_type(tone)}#{interval_number(tone)}"
end

p Tone.new('C3').interval(Tone.new('D3')) # => "M2"
p Tone.new('C3').interval(Tone.new('G2')) # => "P4"
p Tone.new('C3').interval(Tone.new('C1')) # => "P15"
p Tone.new('C3').interval(Tone.new('D####3')) # => "AAAA2"

至此，我们用 Ruby 处理了乐理中与音程有关的常见问题。让我们对 Ruby 和乐理的熟练程度都进一步提升了。接下来，我会介绍如何进一步用 Ruby 来处理和弦。

用 Ruby 学习基本乐理（一）：音高

dsh0416 — Sat, 11 Apr 2020 13:30:33 +0800

序

音乐很有趣，理解音乐很难。但音乐背后的物理、数学原理并没有那么复杂，此所谓乐理。Ruby 是一门编程语言。编程编的是程序，所谓程序，是计算机执行的指令，是阐明计算过程的方式。我们在此使用 Ruby 语言描述乐理，以简单的例子提高自己对乐理的理解，也可以精进自己的 Ruby 编程技能。

从基本音高定义开始

关于音高的基本定义如下：

标准音高 A4 = 440Hz
一个八度有 12 个半音：C, C#, D, D#, E, F, F#, G, G#, A, A#, B
两个八度之间的频率关系差 2 倍
以十二平均律调音，两个相邻音的频率关系差 $$ 2^\frac{1}{12} $$ 倍。

我们先设计一个根据到 A4 半音数量计算音高频率的 Ruby 程序：

STANDARD_TUNING = 440.0
def frequency_by_offset(offset)
  STANDARD_TUNING * (2.0 ** (1.0 / 12)) ** offset
end

然后我们要解析音名，从而处理到音高的关系。音乐中的音名主要有七个：C、D、E、F、G、A、B，之间关系是大调音阶关系，即全音、全音、半音、全音、全音、全音、半音。但一个八度内半音数量有 12，所以后面可以接升降记号 # 或 b，记号可以叠加。音高到音名的关系是一对多的，D、C## 可以表示同一个音高（取决于作曲家的具体需求）。最后加上一个八度的标记来表示超过一个八度的音，我们可以用一个正则表达式 ^[CDEFGAB][#,b]*\d$ 来匹配。

class Tone
  STANDARD_TUNING = 440.0
  attr_reader :frequency
  attr_reader :name

  def initialize(name)
    @name = name
    offset = parse_name(name)
    @frequency = frequency_by_offset(offset)
  end

  def parse_name(name)
    raise AugumentError unless name.match?(/^[CDEFGAB][#,b]*\d$/)
    tone = name[0]
    sharps = name[1...-1]
    range = name[-1].to_i

    # Calculate offset
    major_scale = [-9, -7, -5, -4, -2, 0, 2]
    offset = major_scale['CDEFGAB'.index(tone)] + (range - 4) * 12 # Offset without sharps or flats
    sharps.chars.each do |c|
      c == '#' ? offset += 1 : offset -= 1
    end
    offset
  end

  def frequency_by_offset(offset)
    STANDARD_TUNING * (2.0 ** (1.0 / 12)) ** offset
  end
end

我们来验证一下这个程序：

2.7.0 :070 > Tone.new('A4')
 => #<Tone:0x00007f828c865b58 @name="A4", @frequency=440.0>
2.7.0 :071 > Tone.new('A#5')
 => #<Tone:0x00007f828c8653b0 @name="A#5", @frequency=932.3275230361803> 
2.7.0 :072 > Tone.new('C3')
 => #<Tone:0x00007f828c864d48 @name="C3", @frequency=130.8127826502992>

我们和调音网站比对一下结果：

音名	计算结果	调音网站标准值
A4	440.00	440.00
A#5	932.328	932.33
C3	130.813	130.81

结果基本准确。

频率反查

我们根据音名计算除了频率，下一步是要根据频率计算出接近的音名。但是频率是一个浮点数，浮点数不适合直接用等于号比较。在许多计算中，我们会设置一个阈值 $$\epsilon$$，即计算两个值的差是否小于这个阈值来判断是否相等。但是这个在音乐中是不适合的，因为八度是一个在频率上呈指数增长的东西，于是当音越高，其对阈值越宽容；当音越低，其对阈值越严格。这在和弦上还发展出了「低音程限制」的问题，我们会在之后具体提到。

在此我们采用一个粗暴搜索的算法来处理，即二分查找算法 (binary search algorithm)。在 Ruby 中，Array 有自带的二分查找实现，我们不妨使用它。

ALL_TONES = (0..9).map {|range| ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'].map {|name| "#{name}#{range}"}}.flatten.map { |name| Tone.new(name) }

def by_frequency(freq)
  ALL_TONES.bsearch { |x| x.frequency >= freq }
end

p by_frequency(440) # => #<Tone:0x00007f9b62815498 @name="A4", @frequency=440.0>

我们把这套系统合并到我们的类中，我们可以得到：

class Tone
  STANDARD_TUNING = 440.0
  attr_reader :frequency
  attr_reader :name

  def initialize(name)
    @name = name
    offset = parse_name(name)
    @frequency = frequency_by_offset(offset)
  end

  def parse_name(name)
    raise AugumentError unless name.match?(/^[CDEFGAB][#,b]*\d$/)
    tone = name[0]
    sharps = name[1...-1]
    range = name[-1].to_i

    # Calculate offset
    major_scale = [-9, -7, -5, -4, -2, 0, 2]
    offset = major_scale['CDEFGAB'.index(tone)] + (range - 4) * 12 # Offset without sharps or flats

    sharps.chars.each do |c|
      c == '#' ? offset += 1 : offset -= 1
    end

    offset
  end

  def frequency_by_offset(offset)
    STANDARD_TUNING * (2.0 ** (1.0 / 12)) ** offset
  end

  class << self
    ALL_TONES = (0..9).map {|range| ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'].map {|name| "#{name}#{range}"}}.flatten.map { |name| Tone.new(name) }

    def by_frequency(freq)
      ALL_TONES.bsearch { |x| x.frequency >= freq }
    end
  end
end

p Tone.by_frequency(440) # => #<Tone:0x00007fb0cd8164a8 @name="A4", @frequency=440.0>

泛音列

发声体除了整体振动（基音）以外，还会分段振动。因此除了基础的频率，通常还会产生两倍、三倍、四倍...频率的泛音。站在频率上非常好理解，但是要想记住泛音列的组成音的音名还是挺难记忆的。我们来看看能不能利用我们的音高定义和频率反查系统来自动计算泛音列吧。

由于理论上泛音列是无穷的，只要是整数倍都可以。所以我们可以利用 Ruby 2.6.0 开始引入的 endless range 特性让代码变得好看一些。由于我们反查的上限是 B9 所以当搜索超过 B9 我们就忽略之后的泛音列。另外在特高频率上，可能多个频率对应的是某同一个音名，所以在计算完，我们可以 uniq 一下。

def harmonic_series(max=Tone.new('B9').frequency)
  tones = []
  (2..).each do |n|
    break if @frequency * n > max
    tones << Tone.by_frequency(@frequency * n)
  end
  tones.uniq { |t| t.name }
end

p Tone.new('C7').harmonic_series # => [#<Tone:0x00007f859703d8c8 @name="C8", @frequency=4186.009044809585>, #<Tone:0x00007f859700ec80 @name="G#8", @frequency=6644.875161279136>, #<Tone:0x00007f859700c868 @name="C9", @frequency=8372.018089619174>, #<Tone:0x00007f85980424a8 @name="E9", @frequency=10548.081821211863>, #<Tone:0x00007f8598040130 @name="G#9", @frequency=13289.750322558277>, #<Tone:0x00007f8597063438 @name="A#9", @frequency=14917.240368578916>]

根据 C 的泛音列表，其前 6 个泛音是 C G C1 E1 G1 Bb1。我们的计算器把其中两个 G 都计算成了 G#。这是因为我们的频率反查器可以接受一定程度的偏高，但不能接受偏低。考虑到我们的搜索范围只有 120 个音，我们其实没有必要将时间复杂度优化到 $$O(logn)$$，我们大可以使用 $$O(n)$$ 的复杂度。于是我把频率反查改成了下面的代码：

def by_frequency(freq)
  errs = ALL_TONES.map {|x| (x.frequency - freq).abs }
  ALL_TONES[errs.rindex(errs.min)]
end

于是我们的泛音列结果变成了：

p Tone.new('C7').harmonic_series # => [#<Tone:0x00007fc27787a2d0 @name="C8", @frequency=4186.009044809585>, #<Tone:0x00007fc277878c78 @name="G8", @frequency=6271.926975708001>, #<Tone:0x00007fc277877850 @name="C9", @frequency=8372.018089619174>, #<Tone:0x00007fc277876f40 @name="E9", @frequency=10548.081821211863>, #<Tone:0x00007fc277875960 @name="G9", @frequency=12543.853951416007>, #<Tone:0x00007fc277874330 @name="A#9", @frequency=14917.240368578916>]

与泛音表完全一致。

小结

至此，我们用 Ruby 处理了乐理中与音高有关的常见问题。让我们对 Ruby 和乐理的熟练程度都进一步提升了。接下来，我会介绍如何进一步用 Ruby 来处理音程与和弦。

RubyConf China 2020 SSR 讲师征集

dsh0416 — Wed, 08 Apr 2020 08:58:16 +0800

什么是 RubyConf China 2020 SSR？

第十一届 RubyConf China 将于 8 月 15 日 - 16 日在线上举办。SSR 指 Server-Side Rendering，本次会议中讲师的内容将在服务器端进行渲染、处理后再通过线上形式传达给各位。简单来说，本次大会将以直播录播视频（首播）和直播问答的形式交叉进行。这是一次在特殊时期下的全新尝试，我们很难估计本次会议的质量，但我们会尽可能提升各位线上参会的品质。

我们为什么取消了线下的 RubyConf China 2020？

RubyConf China 2020 的准备工作事实上从 RubyConf China 2019 结束不久后就开始了。我们原定于 2019 年末确定会场并开始征集讲稿，但突如其来的 COVID-19 疫情极大打乱了我们的工作进度。虽然我们对于原定的举办时间下流行能被妥善控制感到乐观，但被极大压缩的准备时间、讲师可能因延期到 9 月的 RubyKaigi 冲突以及可能与到来的婚礼高峰的撞车导致的场租上涨，使得我们对能顺利举办线下 RubyConf China 2020 存在一定的疑虑。

随着 RailsConf 2020 决定以线上形式 (RailsConf 2020.2 Couch Edition) 举办，我们也决定尝试一下类似手段。我们将于 8 月 15 日 - 16 日在线上进行直播，直播由预先录制的 Keynote 演讲、直播问答互动和直播 Workshop 三个部分组成。本届大会预计演讲数量为 12-14 场（每场 45 分钟）。我们会帮助指导讲师搭建录像与直播平台，并且通过有限的后期编辑进一步确保每场演讲的时间、节奏和品质。

SSR 版本会议与往年会议的主要差异

本届会议采取线上举办。
本届会议不收取门票费用，参会者可以自由参与直播。
Keynote 演讲需要提前录制以确保直播质量。
Keynote 可以使用中文、英文或日本語进行，我们会在直播前为演讲内容配上字幕。
本届会议将引入 Workshop 的尝试。

讲师征集 CFP

RubyConf China 2020 年的讲师征集已经正式开始，欢迎大家填写表单提出自己的选题。讲师征集会于 6 月 15 日截止，我们会陆续与确认的讲师进行接洽。

讲师征集表单： https://jinshuju.net/f/Wz7Vyj

参会交流

参会交流微信群：由于已超过 200 人，请填写此表单，管理员会稍后手动拉你入群。 https://jinshuju.net/f/sKTs9P

参会交流 Telegram 群： https://t.me/joinchat/BZajARkli04bfnaV9Ior6Q

结

COVID-19 的疫情虽然已有好转，但仍未完全过去。我们希望今年的 RubyConf China 的特殊方式能让各位 Rubyist 减少风险，以及让这个世界变得更好一些。

Be alert, not anxious.

保持警觉，但不要焦虑。

RubyConf China 2020 先行调查表

dsh0416 — Tue, 10 Dec 2019 12:11:32 +0800

为了更好的举办 RubyConf China 2020，我们希望通过一系列改革进一步提升诸位的参会体验。因此，我们分发这份先行调查，希望收集大家更多的建议。

非常感谢各位愿意抽出时间，来填写本调查表。

本调查表使用 Google Form 收集，可能需要一定特殊方法访问。

点此跳转至调查表

Ant Design 错了吗？

dsh0416 — Tue, 25 Dec 2018 22:37:34 +0800

引

Ant Design 今天的圣诞门闹得沸沸扬扬，Ant Design 内建的圣诞彩蛋在各个使用 antd 的产品中被「强制」弹出，令许多人措手不及，造成了很大的社会影响。但事实上，Ant Design 使用的是 MIT LICENSE，完全是一个使用者「后果自负」的协议。然而，Issue 里哭天喊地要开发者「负责」的舆论却又一面倒。

在此，我要问一个问题：「Ant Design 错了吗？」

就我来看，毋庸置疑，错了。

但这篇文章讨论的是以下几点：

Ant Design 犯了什么错？
开源的权利与责任的界限在哪里？
我们应当怎么从这个事件中获取教训？

Ant Design 犯了什么错？

从产品的角度来看，这个彩蛋，连彩蛋的定义都不符合。彩蛋（Easter Eggs）是一个隐藏在程序中的信息，而不是突然糊在你脸上的定时炸弹。所以从想出这个问题的那个人就已经不太对劲了。但我们抛开这个产品的问题，从实现上，这个 Santa.jsx 文件也同样是非常糟糕。作为一个组件级项目，很多人会对组件样式做二次开发，这一坨硬编码（Hardcoded）并没有起到它彩蛋的作用，相反还把很多网站弄得一团糟。如果你试图阅读过 Ruby 的代码，你往往会发现 Ruby 有那么多错误命名的 C API 为什么一直不把它改对呢？因为这种语言级别的东西，你无法确定用户是怎么使用的时候，就必须保持最低限度的兼容。Ant Design 也是如此。

然而「人主之患在莫之应，故曰：一手独拍，虽疾无声。」导致 Ant Design 问题的，不单单是彩蛋本身的错，更大的是 Ant Design 开源社区开发流程的问题。或者换一句话说：是软件工程的问题。

如果我们现在要往一个开源项目中加入一个不合适的东西，其实并不那么容易。Ant Design 有基于 GitHub Pull Request 系统的 Code Review 机制。一个并非紧急的代码，为什么可以直接跳过 Code Review 直接推上去？Ant Design 作为一个组件级的基础项目，到底应该怎么设计测试？

这个 2017 年 12 月 25 日写下的代码，写入到发作的这一年中，暴露的并不是谁的错，而是这个项目本身就是一个错误。

如何运行一个开源项目？

Ant Design 错了，需要检讨，需要反省，需要道歉。但另一方面，在 Issue 下大骂「要阿里负责，要阿里赔偿」的则是走向了另一个极端。今天的开源项目，在使用常见的 Copyleft 许可证的情况下，大多数（包含且不止包含 MIT、BSD、GPLv2、GPLv3、AGPLv3、LGPLv3、MPL 2.0、Apache License 2.0、The Unlicensed）都在许可证中明确写了，不包括任何保修的条款，使用者自行负责。这让很多人听起来匪夷所思，觉得 Ant Design 一个阿里的产品，怎么也是阿里在背书。然而事实上，可能除了信誉，没有规定任何东西是实质的背书。前几天有人在 Ruby China 上开了个帖子问：

到某某网站上浏览时，发现上面说，以上版本均需获取商业授权，方可做商业运营使用，既然是开源的，咋还涉及到商业授权啊，不理解，请指教。谢谢！

然而版权的实际情况却恰恰相反。源代码放出来只是让你看，并不能让你用。就像别人放在那里的芒果，你不能寻思是别人不要了吧。代码是不是开源，需要取决于使用什么授权协议。哪怕是 GPL 的 RedHat 也有卖商业服务的。如果人家没有设定任何授权协议的话，那就只能默认是 Copyright 私有了。而只有签了具体包含保修责任的条款的协议后，对方才有保修的义务。不然，我自己写着玩开源出来，你用的时候也已经同意免责了。你用出问题了为什么要来找我呢？有问题你自己 fork 了改不就好了？

这就牵扯到了另一个问题：开源的社会价值。当一个开源产品，比如 Ant Design，有大量的用户在使用的时候，对于这个开源社区的期待是完全不同的。这也是为什么世界上大多数的大型开源项目，都有一个庞大的组织在维护着。其目的很大程度上，就是要维护代码的可靠性，担负起其社会价值。~~你觉得阿里价值观能担负起社会价值吗？~~

有人在我微博下呛：

照右边这个逻辑的话，广大 MIT 框架作者应该纷纷往自己代码加挖矿，这世界不需要开源，人与人也不需要信任。别人写好的高级语言也别用啊，一起汇编起来。

然而事实上，如果你愿意找一下，GitHub 上许多 MIT 项目是有暗藏挖矿的，甚至还有暗藏后门的。至于「别人写好的高级语言也别用啊」也是如此，UNIX 创始人 Ken Thompson 在 30 年前获得图灵奖的获奖演说中，就有提到这种类似的暗藏在 C 语言编译器中的手段实现攻击。这也是为什么一方面 C 语言编译器也有一套复杂的自举发布流程，像 gcc 还会有严格的代码审查机制来避免这种问题的发生。然而甚至硬件本身，也不是 100% 可信的。这不是「人与人的信任」问题，相反，就算 100% 相信别人不去做坏事，但是由于人都会犯错，总会做出错误的东西，我们需要的是通过机制来避免它发生。

在以前一个非常有名的 NVIDIA 开源驱动的维护项目 bumblebee 中就有出现过开发者疏失，导致更新的用户直接把所有的 /usr 用户文件不小心删了个精光。甚至有人曾试图通过给 Linux 项目提交 patch 的形式，将后门埋入操作系统中。并且这些看起来不经意的错误，甚至会使得一些人为的 Code Review 失效，所以 Linux 还有复杂的安全性和回归测试来保证其可靠性。

如果这不是无意的行为，而是有意的。那么对于开源世界，我们有个更简单的方法：fork。我们只要分叉一个自己的版本，自己维护自己负责就可以了。MySQL 被 Oracle 收购后，虽然 Oracle 暂时还没有做什么坏事，大家为了谨防这种情况发生，就有一些开发者 fork 出了 MariaDB。

但是，我也反过来问一句：你 fork 后的项目，你真的能维护得更好吗？

软件工程是一个复杂而庞大的东西，把七个积木搭在一起，和把七千万块积木堆在一起是完全不同的系统工程问题。开源软件的管理看起来松散，于是更需要设计合理的制度防范于未然。在挑选开源项目的时候，并不只是挑一个能用的就行了，对于其质量、维护能力、开源协议都必须是评估的内容。我不是在说「用开源的东西不审查代码，出了问题活该」，但是什么都不看，不出问题才奇怪吧？

教训

为什么包括谷歌微软在内的大公司，在使用别人的开源项目时，都要经过内部审查。虽然不至于精确到每行代码，但也要大致确认一下这个项目的状况。这也是为什么，Facebook 之前内部许可证事件沸沸扬扬，因为这真的很重要。就好像，警察在努力阻止盗窃案的发生，但我们自身平时就要做好防范，而不能大门敞开，出了事去骂警察吧。

然而现实的情况却是，用 Ant Design 的本来就是一群想用个组件库草草了事的人，根本没有可能去参与到开源项目的审查中。而 Ant Design 目前草率的开发流程，确实也无法承担如此大的社会责任。如果今天不是「偏右」的圣诞节代码出了问题，明天后天一样会出别的问题。如果今天是「偏右」辞退就来平息风波，那么明天后天 Ant Design 还是会继续出问题（~~毕竟是阿里嘛~~）。

今天 Ant Design 的问题是一个典型的软件工程问题，让任何一个个人来负责，都只是息事宁人的策略，并不能从根本上解决问题。对于一个「开发公司 HR 工具的离职谈话功能推到开发者头上；匿名表达对老员工，特别是对彭姓员工不满，大老板可能含沙射影地让你滚；用脚本在公司网站抢月饼，可能违反价值观」的公司，你指望它在软件工程上有秩序吗？

我觉得你在做梦。

总结一下：

开源项目本身并没有所谓的「责任」的概念，你要有自己评估其可靠性的能力，并承担风险。
评估可靠性不在于其背后是多大的公司，更在于其是否有健全的开发流程，因为人为疏失不可避免。
越是底层、组件级的项目对于可靠性的要求越高。
只要不是主观上故意犯错误，我们更应该检讨我们的系统工程，而不单单是检讨个人。

Ruby 2.6.0 已发布

dsh0416 — Tue, 25 Dec 2018 17:20:19 +0800

本文翻译自 Ruby 2.6.0 发布新闻

我们高兴地宣布 Ruby 2.6.0 已发布。

Ruby 2.6.0 引入了许多新特性以及性能提升，其中最值得瞩目的是：

全新的 JIT 编译器
RubyVM::AbstractSyntaxTree 模块

JIT [实验性]

Ruby 2.6 引入了 JIT (Just-in-time) 编译器的初始实现。

JIT 编译器旨在提升任何 Ruby 程序的执行速度。不同于其他语言中常见的 JIT 编译器，Ruby 的 JIT 编译器进行 JIT 编译的过程非常独特。其将生成的 C 代码打印至磁盘并 spawn 常见的 C 编译器进行代码的生成工作。详见：Vladimir Makarov 的 MJIT 组织。

如何使用：在命令行或 $RUBYOPT 环境变量中指定 --jit 参数。指定 --jit-verbose=1 将允许打印 JIT 编译过程中的调试信息。详见 ruby --help 查看更多其他选项。

JIT 编译器需要在 Ruby 由 GCC、Clang 或 Microsoft VC++ 编译后，编译器仍可被运行时发现时才可用。

Ruby 2.6.0-rc1 在使用 CPU 密集型场景下的复杂 Benchmark Optcarrot https://gist.github.com/k0kubun/d7f54d96f8e501bbbc78b927640f4208 进行测试后，比起 Ruby 2.5 取得了 1.7 倍的性能提升。然而，许多内存密集型场景（例如 Rails）可能暂时无法从中获益。你可以查看 Ruby 2.6 JIT - 进展与未来（英文）来了解更多详情。

请保持对 Ruby 新时代性能的关注。

RubyVM::AbstractSyntaxTree [试验性]

Ruby 2.6 引入了 RubyVM::AbstractSyntaxTree 模块。但对于 AST 节点的向后兼容性不做保证。

此模块提供 parse 方法，传入 Ruby 代码字符串，返回 AST（抽象语法树）节点。而 parse_file 方法则接受一个 Ruby 代码文件作为参数，返回 AST 节点。

同时引入了 RubyVM::AbstractSyntaxTree::Node 类，你可以从 Node 对象中获取位置信息和子节点。此功能尚处于实验性质。

其它新特性

为 Kernel#yield_self 添加了新别名 then。[功能 #14594]
常量名现在可以以非 ASCII 大写字母开头。[功能 #13770]
无限范围 [功能 #12912]

引入了无限范围 (1..)。这个范围没有终点，以下是使用场景的举例。

ary[1..]                          # 等价于 ary[1..-1] 而不需要魔法的 -1
(1..).each {|index| ... }         # 从 1 开始的无限循环
ary.zip(1..) {|elem, index| ... } # ary.each.with_index(1) { ... }

新增 Enumerable#chain 与 Enumerator#+ [功能 #15144]
为 Proc 和 Method 新增了函数构造操作符 << 与 >>。 [功能 #6284]

f = proc{|x| x + 2}
g = proc{|x| x * 3}
(f << g).call(3) # -> 11; identical to f(g(3))
(f >> g).call(3) # -> 15; identical to g(f(3))

新增 Binding#source_location。[功能 #14230]

此方法以一个二元组数组 __FILE__ 和 __LINE__ 的形式返回 binding 的源代码路径。传统上，这可以通过执行 eval("[__FILE__, __LINE__]", binding) 来获得相同的数据。但我们计划改变这一行为让 Kernel#eval 忽略 binding 的源代码路径 [漏洞 #4352]。所以，用户需要通过新加入的方法来替代之前的 Kernel#eval。

增加 :exception 选项，以让 Kernel.#system 抛出错误而不是返回 false。[功能 #14386]
新增 oneshot 模式 [功能 #15022]
- 此模式检查「每一行代码是否都至少被执行一次」，而不是「每行代码被执行了几次」。每行代码的 hook 至多被调用一次，并会在调用后将 hook 标识移除。换句话说，移除后的代码运行将没有额外的性能开销。
- 为 Coverage.start 方法新增 :oneshot_lines 关键字参数。
- 为 Coverage.result 方法新增 :stop 和 :clear 关键字参数。如果 clear 被设置为 true，它会清空计数器。如果 stop 被设置为 true，它会禁用覆盖测量。
- 新增 Coverage.line_stub，其为从源代码新建代码覆盖存根（stub）提供了一个简单的帮助函数。
FileUtils#cp_lr。[功能 #4189]

性能提升

由于移除了对 $SAFE 临时赋值的支持，提升 Proc#call 的速度。[功能 #14318]

通过 lc_fizzbuzz 多次使用 Proc#call 的 benchmark 我们测量到了 1.4 倍性能提升 [漏洞 #10212]。

提升了当 block 是代码块参数时 block.call 的性能。[功能 #14330]

通过与 Ruby 2.5 中引入的提升代码块传递的性能的方法结合，Ruby 2.6 进一步提升了传递代码块调用时的性能。通过 micro-benchmark 我们观察到了 2.6 倍性能提升。[功能 #14045]

引入了瞬态堆 (theap)。 [漏洞 #14858] [功能 #14989]

瞬态堆是用于管理指向特定类（Array、Hash、Object 和 Struct）短生命周期内存对象的堆。例如，创建小而短生命周期的哈希对象的速度提升到了 2 倍快。根据 rdoc benchmark，我们观察到了 6% 到 7% 的性能提升。

协程采用了原生实现（arm32、arm64、ppc64le、win32、win64、x86、amd64）显著提升了 Fiber 的性能。 [功能 #14739]

Fiber.yield 与 Fiber#resume 方法在 64 位 Linux 上提升了 5 倍性能。对于使用 Fiber 密集的程序，约有最高 5% 的性能提升。

其它自 2.5 以来值得注意的新特性

$SAFE 成为了进程全局状态，我们可以再次将其设为 0。[功能 #14250]
不再建议将 safe_level 参数传递给 ERB.new 的行为。trim_mode 和 eoutvar 参数被转换成了关键词参数。[功能 #14256]
升级支持的 Unicode 版本至 11。我们计划在未来 Ruby 2.6 的小更新中升级至 12 和 12.1。其将引入新的日本年号。
合并 RubyGems 3.0.1，--ri 和 --rdoc 选项已被移除。请使用 --document 和 --no-document 选项来替代他们。
合并 Bundler 作为默认 gem。
不含 rescue 的 else 现在会引起语法错误。[实验性][功能 #14606]

见 NEWS 或提交日志以查看详情。

这些合并后，自 Ruby 2.5.0 已发生了 6437 个文件变更，231471 行新增 (+)，98498 行删除 (-)！

圣诞快乐！享受你 Ruby 2.6 的编程之旅吧！

下载

https://cache.ruby-lang.org/pub/ruby/2.6/ruby-2.6.0.tar.gz

SIZE: 16687800 bytes SHA1: c95f4e86e21390270dad3ebb94491fd42ee2ce69 SHA256: f3c35b924a11c88ff111f0956ded3cdc12c90c04b72b266ac61076d3697fc072 SHA512: 01f886b0c0782a06315c4a46414e9f2b66ee634ba4349c8e0697f511793ae3c56d2ad3cad6563f2b0fdcedf0ff3eba51b9afab907e7e1ac243475772f8688382
https://cache.ruby-lang.org/pub/ruby/2.6/ruby-2.6.0.zip

SIZE: 20582054 bytes SHA1: a804e63d18da12107e1d101918a3d8f4c5462a27 SHA256: 8a4fb6ca58202495c9682cb88effd804398bd0ef023e3e36f001ca88d8b5855a SHA512: 16d66ec4a2c6a2e928d5b50e094a5efa481ac6e4d5ed77459d351ef19fe692aa59b68307e3e25229eec5f30ae2f9adae2663bafe9c9d44bfb45d3833d77839d4
https://cache.ruby-lang.org/pub/ruby/2.6/ruby-2.6.0.tar.bz2

SIZE: 14585856 bytes SHA1: b8638eb806efbf7b6af87b24ccc6ad915f262318 SHA256: c89ca663ad9a6238f4b1ec4d04c7dff630560c6e6eca6d30857c4d394f01a599 SHA512: ca3daf9acf11d3db2900af21b66231bd1f025427a9d2212b35f6137ca03f77f57171ddfdb99022c8c8bcd730ff92a7a4af54e8a2a770a67d8e16c5807aa391f1
https://cache.ruby-lang.org/pub/ruby/2.6/ruby-2.6.0.tar.xz

SIZE: 11918536 bytes SHA1: 9ddaeba3505d2855460c8c653159fc0ac8928c0f SHA256: acb00f04374899ba8ee74bbbcb9b35c5c6b1fd229f1876554ee76f0f1710ff5f SHA512: c56eaf85ef7b79deb34ee4590b143c07f4fc83eb79775290761aee5a7c63374659613538a41f25706ed6e19e49d5c67a1014c24d17f29948294c7abd0b0fcea8

[Ruby Quiz] Base32 字母表 —— 加密猫基因解码

dsh0416 — Sat, 08 Dec 2018 01:13:15 +0800

刚刚在 ruby-talk 的邮件列表读到一个很有意思的 Ruby Quiz，题目可以见此。想到好久没有看到 Ruby Quiz 了，就做了并翻译了一下。

题目翻译

庆祝 CryptoKitties 一周年 —— 区块链上诞生了超过 100 万只可爱的小猫！

我们来尝试转换 "sekretoooo" 加密猫的基因，一个 240 位的整数，以每 5 位进行分割，再通过 base32 (2^5=32) 进行转换，转至 kai 标注。

Q: 什么是 kai 标注？

Kai 标注（因为 Kai Turner 解码了加密猫的基因而命名）是一种针对 240 位整数分割成 5 位块的 base58 的变种（子集）。每个 5 位块含有 32 种可能性，240 位基因可以给分割成 12 组，每组 4 (x 5 位）基因。

举例：

Kai	Binary	Num	Kai	Binary	Num	Kai	Binary	Num	Kai	Binary	Num
1	00000	00	9	01000	08	h	10000	16	q	11000	24
2	00001	01	a	01001	09	i	10001	17	r	11001	25
3	00010	02	b	01010	10	j	10010	18	s	11010	26
4	00011	03	c	01011	11	k	10011	19	t	11011	27
5	00100	04	d	01100	12	m	10100	20	u	11100	28
6	00101	05	e	01101	13	n	10101	21	v	11101	29
7	00110	06	f	01110	14	o	10110	22	w	11110	30
8	00111	07	g	01111	15	p	10111	23	x	11111	31

注意：数字 0 和字母 l 不会在 kai 中被使用。

我们开始编程吧！举例来说：


# A 240-bit super "sekretoooo" integer genome

# hexadecimal (base 16)
genome = 0x4a52931ce4085c14bdce014a0318846a0c808c60294a6314a34a1295b9ce
# decimal (base 10)
genome = 512955438081049600613224346938352058409509756310147795204209859701881294
# binary (base 2)
genome = 0b010010100101001010010011000111001110010000001000010111000001010010111101110011100000000101001010000000110001100010000100\
           011010100000110010000000100011000110000000101001010010100110001100010100101000110100101000010010100101011011100111001110

我们可以把 10 进制数转换成 16 进制或 2 进制数：

p genome    # printed as decimal (base 10) by default
# => 512955438081049600613224346938352058409509756310147795204209859701881294

p genome.to_s(16)
# => "4a52931ce4085c14bdce014a0318846a0c808c60294a6314a34a1295b9ce"

p genome.to_s(2)
# => "10010100101001010010011000111001110010000001000010111000001010010111101110011100000000101001010000000110001100010000100\
#     011010100000110010000000100011000110000000101001010010100110001100010100101000110100101000010010100101011011100111001110"

bin = '%0240b' % genome     # note: adds leading zeros - to_s(2) does not
p bin.size
# => 240
p bin
# => "010010100101001010010011000111001110010000001000010111000001010010111101110011100000000101001010000000110001100010000100\
#     011010100000110010000000100011000110000000101001010010100110001100010100101000110100101000010010100101011011100111001110"

hex = '%060x' % genome     # note: adds leading zeros - to_s(16) does not
p hex.size
# => 60
p hex
# => 60
# => "4a52931ce4085c14bdce014a0318846a0c808c60294a6314a34a1295b9ce"

最终要得到的效果是：

kai = kai_encode( genome )   ## number to base32 kai notation
p kai
# => "aaaa788522f2agff16617755e979244166677664a9aacfff"

挑战：创建 kai_encode 方法并通过 RubyQuizTest :-).

def kai_encode( num )
  # ...
end

对于 Level 1 挑战，你需要把 240 位整数转换成 Base 32 的 Kai 标注。对于 Level 2 挑战，你要把结果 4 个 4 个进行分组，将

"aaaa788522f2agff16617755e979244166677664a9aacfff"

转换成

"aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"

def kai_fmt( kai )
  # ...
end

你可以从头开始编码，也可以使用任何你想用的库 / gem。你需要通过如下的测试：

require 'minitest/autorun'

class RubyQuizTest < MiniTest::Test

  ################################
  # test data
  def genomes
     [
       [0x00004a52931ce4085c14bdce014a0318846a0c808c60294a6314a34a1295b9ce,
        "aaaa 7885 22f2 agff 1661 7755 e979 2441 6667 7664 a9aa cfff"]
     ]  
  end

  #############
  # tests
  def test_kai_encode
    genomes.each do |pair|
      num       = pair[0]
      exp_value = pair[1].gsub(' ','')   # note: remove spaces

      assert_equal exp_value, kai_encode( num )
    end
  end # method test_kai_encode

  def test_kai_fmt
    genomes.each do |pair|
      kai       = pair[1].gsub(' ','') # remove spaces
      exp_value = pair[1]

      assert_equal exp_value, kai_fmt( kai )
    end
  end # method test_kai_fmt

end # class RubyQuizTest

注：对于解码后与基因的对应关系表实在太长了，而且和题目无关。如果想看可以查原文。

dsh0416 (Delton Ding)

[上海][12.3,12.4] RubyConf China 2021 Hotwire 开始售票

关于退票

联系方式

[杭州] Fork AI 招聘 Ruby 工程师 2 名

开放职位

Ruby 工程师

职位描述

职位要求

加分项

职位待遇

联系方式

RubyConf China 2021 Hotwire 赞助征集

赞助方案

红宝石赞助商（限量）—— 30000 元

金牌赞助商（限量）—— 20000 元

银牌赞助商 —— 10000 元

合作伙伴 —— 3500 元

联系方式

讲师征集

三点几嚟，饮茶先啦 —— 将大马饮料名编译成汉语

大马饮料名

ebnf 语法

实现到汉语的编译器

成果

RubyConf China 2021 Hotwire 讲师征集

什么是 RubyConf China 2021 Hotwire

Hotwire 版本会议与往年会议的主要差异

讲师征集 CFP

参会交流

结

[线上][2021年2月9日] RubyTuesday@Clubhouse

主题

腾讯会议转播

用 Ruby 实现飞机自动驾驶仪

krpc

PID 控制

起飞控制

方向角计算

偏航控制

测试

为 Ruby 3 Fiber 调度器设计事件库 Evt

Ruby 3 Fiber 调度器

Fiber 调度器的使用

后端支持情况

io_uring 支持

IOCP 支持

kqueue 支持改进

概览

基准测试

与 Ractor 结合

总结

更新

Ractor 下多线程 Ruby 程序指南

什么是 Ractor?

什么数据可以在 Ractor 间共享？

Ractor 性能提升测试

显微镜下的 Ractor

Ractor 如何改善现有 Ruby 程序的性能？

总结

尝试使用 Ruby 3 调度器

一次失败的提案

实现调度器

Fallback 到 Ruby IO.select

使用 epoll 和 kqueue

使用调度器的 HTTP 服务器例子

未来工作

源码

拯救老婆 —— MacBook Pro 维修计划

我的老婆不行了

软件着手研究问题

是什么在导致 CPU 疯狂降频？

风扇转速为什么还是那么高？

CPU 满载时为什么还会降频？

我的老婆救回来了

Ruby 3 Fiber 变化前瞻

引

为什么要有 Fiber？

Fiber 与 I/O

目前 Fiber 调度器剩余的问题

`io_uring` 支持

`kqueue` 支持改进

Fallback 到 Ruby `IO.select`

使用 `epoll` 和 `kqueue`