victor (Victor)

TestProf

victor — Fri, 06 Jul 2018 09:58:30 +0800

TestProf 收集了一堆测试分析和性能优化相关的工具。

https://test-prof.evilmartians.io/#/?id=testprof

139 个关于 Rails 的小技巧

victor — Tue, 29 May 2018 09:44:33 +0800

https://til.hashrocket.com/rails

每条仅需 30 秒，走过路过不要错过

PS: 站点也有其他关于小技巧，比如：React, VIM 请自行去首页按需服用

Exploding Rails

victor — Thu, 03 May 2018 10:33:42 +0800

Have you felt the pain of using Active Record on a large codebase? How about messy controllers? Read this short guide on how to improve a Rails application's structure by exploding its responsibilities into small classes with their own unique responsibilities. Starring rom-rb and dry-rb.

https://leanpub.com/explodingrails

Ruby 位运算符详解

victor — Fri, 16 Mar 2018 00:54:19 +0800

字符编码

进化历史

计算机只能处理数字，如果要处理文本等，那么必须要把文本转化为二进制的数字才可以处理。
最开始只有 ASCII 编码，它包含大小写字母，符号，数字。1 个字符占用 1 个字节 (byte)，一个字节 8 位 (bits)。
因为需要用其它语言，中间过渡了一下 GB2312 之类的编码，一个中文占用 2 个字节 (bytes)。
后来开始使用 Unicode 编码，它包含所有国家语言，所以不会出乱码。ASCII 占用 1 个字节 (byte)，Unicode 通常 2 个字节 (bytes)，因为一些生僻字可能需要 3 或 4 个字节 (bytes)。

关于 bit(位) 和 byte(字节) 的解释可以读一下 Working with Bits and Bytes in Ruby

字符集和编码方式的区别

UTF-8

在 Unicode 编码下，使用中文的时候占用 2 个字节。但使用字母的时候，其实只是用了一个字节，就是后面的一个字节。比如 00000000 01000000，大家会注意这里就造成了浪费，就是在原来的字节前面加 0 就可以了，这样就相当于多了一倍的储存空间，在存储和运输上不太划算。

UTF-8 编码是基于 Unicode 编码的可变长度编码方式。它把 Unicode 编码根据不同的数字大小编码成 1-6 个字节，常用的字母就是 1 个字节，汉字等通常 2-3 个字节。

'hello world'.each_byte.to_a #=> [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
"s".bytes #=> [115]
"中".bytes #=> [228, 184, 173]

当你在看 bytes 文档的时候，可能还会发现一些冷门知识，比如：代码点 codepoints，有兴趣自己去找资料学习吧。

'hello world'.codepoints.to_a #=> [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
"中".codepoints.to_a #=> [20013]

计算机通用的字符编码工作模式

刚才我们知道在计算机内存中，用的是 Unicode 编码，当要存储在硬盘或者传输时，就转换为 UTF-8 模式，当我们在编辑一个文本文件时，还没保存的时候，我们用的就是 Unicode 编码，当我们点击保存时，这时候就转换为 UTF-8 编码了，当我们读取的时候，就又变成了 Unicode 编码，就是这样转换的。

Ruby 默认是 UTF-8。

"some string".encoding #=> #<Encoding:UTF-8>
Encoding.default_external #=> #<Encoding:UTF-8>

什么是位运算

在计算机中所有数据都是以二进制的形式储存的，位运算其实就是直接对在内存中的二进制数据进行操作，因此处理数据的速度非常快。

位运算符作用于位，并逐位执行操作。

Ruby 位运算符

假设如果 a = 60，且 b = 13，现在以二进制格式，它们如下所示：

a = 0011 1100
b = 0000 1101

a&b #=> 0000 1100
a|b #=> 0011 1101
a^b #=> 0011 0001
~a  #=> 1100 0011

下表列出了 Ruby 支持的位运算符 ( '或' 符号我用英文 I 代替的，尴尬)：

运算符	描述	运算规则
`&`	与	两个位都为 1 时，结果才为 1
I	或	两个位都为 0 时，结果才为 0
`^`	异或	两个位相同为 0，相异为 1
`~`	取反	0 变 1，1 变 0
`<<`	左移	各二进位全部左移若干位，高位丢弃，低位补 0
`>>`	右移	各二进位全部右移若干位

运算符	实例
`&`	`(a & b)` 将得到 12，即为 0000 1100
I	`(a I b)` 将得到 61，即为 0011 1101
`^`	`(a ^ b)` 将得到 49，即为 0011 0001
`~`	`(~a )` 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
`<<`	`a << 2` 将得到 240，即为 1111 0000
`>>`	`a >> 2` 将得到 15，即为 0000 1111

注意以下几点：

只有 ~ 取反是单目操作符，其它 5 种都是双目操作符。
位操作只能用于整形数据，对 float 和 double 类型进行位操作会被编译器报错。
位操作符的运算优先级比较低，因为尽量使用括号来确保运算顺序。
>> 操作。对无符号数，高位补 0；有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补 0（逻辑右移），见后面的代码示例。

a, b = 15, -15
a >> 2 #=> 3
b >> 2 #=> -4

因为 15 的二进制是 0000 1111，右移二位成为 __00 1111，最高位由符号位填充将得到 0000 0011 即十进制的 3。-15 的二进制是 1111 0001，右移二位成为 __11 1100，最高位由符号位填充将得到 1111 1100 即十进制的 -4。

pack 和 unpack

上面的例子这里涉及到两个知识点：

怎么把 15 变成 2 进制，另外字母怎么转换成 2 进制，中文怎么转换成 2 进制？
符号位是怎么回事？

不同编码之间的处理

第一个问题很简单，以字符串为例，先转换成 ascii 码再转换成 2 进制。

'A'.bytes.first.to_s(2) #=> "1000001"

闹呢，当然不可能这么傻。C 语言允许开发人员直接访问存储变量的内存，而 Ruby 不行。当我们需要在 Ruby 中访问字节 (byte) 和位 (bits) 的时候，可以使用 pack 和 unpack 方法。

一般来说，对于 unpack 方法你只要记住两个参数 b* 转换成 2 进制，和 C* 转换成 ascii 码。

'A'.unpack('b*') #=> ["10000010"]
"hello world".unpack('C*') #=> [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
"中".unpack('C*') #=> [228, 184, 173]

真的足够用了，再去研究 B* 和 b* 有什么不同，又会牵扯到 MSB/LSB 的问题，'H' 转换成 16 进制什么的，完全不用在意。

懂了 unpack 那 pack 也就懂了，无非是逆向操作。

[1000001].pack('C') #=> "A"
[104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100].pack('C*') #=> "hello world"

符号位

首先要弄懂原码，反码和补码，而我不打算摘抄一大段东西，所以可以直接看

关于第 2 个问题你目前只需要了解到：

符号位是第一个字节 8 位 (bits) 的第 1 位，1 为负，0 为正。
ruby 的 >> 操作是算术右移。低位溢出，符号位不变，并用符号位数补溢出的高位。

实际应用

缘由出来了，今天遇到了这个函数。问这个函数有什么用。

# File activesupport/lib/active_support/security_utils.rb, line 11
def secure_compare(a, b)
  return false unless a.bytesize == b.bytesize
  l = a.unpack "C#{a.bytesize}"
  res = 0
  b.each_byte { |byte| res |= byte ^ l.shift }
  res == 0
end

看完了上面的文章，这函数应该能看懂了吧。当然，除了 a.unpack "C#{a.bytesize}" 这句有点迷糊，刚才明明说好只要记住 C* 和 b* 两个参数足够了啊。

没办法去看文档吧，然后，我懵了！

"aaa".unpack('h2H2c') #=> ["16", "61", 97]
"whole".unpack('xax2aX2aX1aX2a') #=> ["h", "e", "l", "l", "o"]

这什么鬼参数，好歹找到了一篇中文解释 pack 模板字符串。

翻译过来，这一句就跟 a.unpack 'C*' 没区别。

其它没什么好解释的了，按位异或比较传入的两个参数是否相等。

我想了半天也没想到这么比较有什么好处，又不想靠 gg 搜答案，晚上跟老伙伴讨论了一波，他也没什么头绪，没办法只好 gg 了。

转了一圈又回来了，原来论坛上有相关帖子，这函数主要是搞定 计时攻击 的，具体可看计时攻击原理以及 Rails 对应的防范。

后记

延展开去还有关于 IO 打开文件时候的外部编码和内部编码的问题，可以直接看相关阅读中 Ruby 对多语言的支持 一文，虽然文章有点老，还是针对 Ruby 1.9 版本阐述的问题，但是不影响你理解。

再扯其它的就离主题太远了，初衷只是因为今天做笔试题时候发现自己对这块知识基本忘光了，赶快奶自己一波。

如果你知道自己在某一领域上有所欠缺，就应该立刻开始学习相关知识。

补充

上文中应该把 ASCII 和 Unicode 称为字符集，UTF-8 称为编码规则更准确。
广义的 Unicode 指一个标准，定义字符集及编码规则，即 Unicode 字符集和 UTF-8、UTF-16 编码等。

[北京][三元桥] W�E+ 诚聘 Ruby 初级后端工程师

victor — Tue, 28 Jun 2016 12:28:44 +0800

公司介绍

WE+（上海帷迦科技有限公司）是由上实发展与美国柯罗尼资本（Colony Capital）在中国的新扬子基金于 2015 年 5 月共同创立。WE+ 充分整合各方股东的优势资源，建立了互联网思维下的新型办公模式，采取创新与创业、线上与线下、孵化与投资相结合的方式，为中小微和初创企业提供全方位服务。以联合办公众创空间为载体，以人为本，共享经济为核心，定制服务和互联互信互助的社区文化相结合，打造办公生活一体化的生态圈。创始团队和技术团队分别有海外留学经历及百度，腾讯，阿里巴巴等一流互联网公司工作经历，团队氛围活跃，扁平化管理方式。

截止至 2016 年 6 月，WE+ 已有 10 个空间，20000 平米以上投入运营。位于北京、上海、杭州、广州、苏州等地。共有工位 3000 个，出租率 85%，已入驻团队上百个。

技术团队目前的项目

凭借对联合办公行业和互联网的深刻理解，技术团队将联合办公行业需求与互联网应用相融合，为办公空间提供系统、全面、高效、实用的智慧管理解决方案，帮助空间实现低成本、高效率的信息化管理。

职位职责

服务端产品的开发与维护（Ruby on Rails/Web为主）；
参与、协助产品的需求分析、设计、实现、测试、集成以及维护；

职位要求

精通 Ruby，2 年以上 Ruby On Rails 经验；3 年以上互联网应用开发经验；
熟练掌握 SQL、HTML、CSS、JavaScript，能够独立完成完整的 Web 应用；
了解大型 Web 应用程序系统架构，对 Memcached、Redis、MySQL 负载均衡、服务器运维有实际经验；

加分

有扎实的英语功底，并且能够轻松的阅读英文文档；
对互联网行业与技术充满热忱，理解一个创业公司所面对的高速，多变，与未知；

福利待遇

上面的官话说完了，下面说点实在的。

薪水 13K 起，根据能力可酌情上调（我们会合理避税，5 险 1 金均有，但你到手后的银子并不会差太多）；
上班时间 10:00-19:00，双休（工作日肯定会偶尔加班，但周末肯定是双休）；
带狗上班，中午有太空舱可以午睡，目前有 VR 可以玩，天天小团建，周周大团建，月月大保健；
你可以选择 LOL 郊区钻石带你飞/Dota2 鱼塘队伍纯娱乐；
资深老司机带你上车（懂的人自然懂）；

联系我

办公地址：北京朝阳区三元桥远洋新干线 D 座 1 层 WE+ Coffee 邮箱：victorwang@weplus.com

下面是你将来的办公地点，和你的狗同事

How Ruby Uses Memory

victor — Thu, 28 May 2015 17:37:13 +0800

每个开发者都想让自己编写的代码占用更少的内存并且运行的更快。在 Ruby 中内存是非常重要的，但是很少有开发者清楚地了解为啥在自己代码运行期间内存占用率会忽高忽低。本文会让你对 Ruby 中内存和对象的关系有一个初步的了解，介绍一些常见的技巧让你的代码减少内存占用并因此运行的更快。

Object Retention

在 Ruby 中最常见的引起内存飙高的方法是保留对象。Ruby 中的常量是永远不会被垃圾回收的，所以如果常量引用了一个对象，那么这个对象也永远不会被垃圾回收。

RETAINED = []
100_000.times do
  RETAINED << "a string"
end

执行这段代码，并用 GC.stat(:total_freed_objects) 观察有多少个对象被释放。对比一下：

# Ruby 2.2.0

GC.start
before = GC.stat(:total_freed_objects)

RETAINED = []
100_000.times do
  RETAINED << "a string"
end

GC.start
after = GC.stat(:total_freed_objects)
puts "Objects Freed: #{after - before}"

# => "Objects Freed: 44

这里创建了 100000 个 a string 的副本，但是由于咱将来可能会使用它们，所以它们不会被垃圾回收。在 Ruby 中一个对象一旦被全局对象引用，它就不会被垃圾回收。 这一原则也适用于常量，全局变量，模块 (modules) 和类 (class)。因此，在全局可访问的任何地方引用对象都要注意这一点。

但是假如能在这个过程中不保留任何对象：

100_000.times do
  foo = "a string"
end

被释放的对象会立刻增加到：Objects Freed: 100038，内存占用率下降了。当保留对象引用的时候，内存占用从 6mb 增加到 12mb。你也可以使用 get_process_mem gem 来监测内存变化。

对象保留也可以使用 GC.stat(:total_allocated_objects) 观测，被保留的对象等于 total_allocated_objects - total_freed_objects。

Retention for Speed

Ruby 程序员都很熟悉 DRY。这一原则也适用于代码中进行对象分配。有时我们期望保留对象以便重用，而不是一次又一次重新创建。Ruby 的字符串对象内置了这个方法。冻结一个字符串，解释器会认为你不会修改该字符串，并保留它以便重复使用。下面是一个例子：

RETAINED = []
100_000.times do
  RETAINED << "a string".freeze
end

执行这个代码，你发现被释放的对象是 Objects Freed: 50，看起来没啥变化，但是我们的内存使用率确实降低了。你可以使用 GC.stat(:total_allocated_objects) 来验证，我们为 a string 分配了很少的对象，因为我们保留并重用了它。

Ruby 只存储一个字符串并引用了 100000 次该对象，而不是创建 100000 个不同的对象。除了降低内存使用，我们还因此减少了运行时间，因为 Ruby 不会浪费时间去创建对象和分配内存。你可以使用 benchmark-ips 来检查。

这个去除重复对象的小技巧虽然常被用来处理字符串，但是当你要把其他对象分配给常量的时候也可以使用。事实上，储存外部连接（例如 Redis）的时候，这个技巧已经成了一种通用模式了。例如：

RETAINED_REDIS_CONNECTION = Redis.new

因为常量引用了 Redis 的连接，所以它不会被垃圾回收。

很有趣吧，有时我们很小心地保留住对象是可以降低内存占用的。

Short Lived Objects

大多数对象的生命周期都很短。短的意思是创建对象之后并没有引用它。例如下面的代码：

User.where(name: "schneems").first

表面上看起来，这个语句仅需要很少的对象（一个 hash {name: "schneems"}）。事实上，当你调用它的时候，会创建非常非常多的中间对象以便生成正确的 SQL 语句。这些对象中绝大部分的生命周期仅在这段代码的执行过程中。那么，我们为啥要关心这些不会被保留的对象被创建多少个呢？

产生大量生命周期适中和较长的对象会引起内存在一段时间内持续增长。一旦在 GC 释放的瞬间这些对象仍在引用，可能引起 Ruby GC 需要更多的内存。

Ruby Memory Goes Up

当你有很多对象需要被使用，并且它们超过了 Ruby 当前内存中可放入对象的数量时，Ruby 需要分配更多的内存。从操作系统中请求内存分配的操作是很昂贵的，所以 Ruby 尽量减少这种操作的机会。Ruby 不会每次请求几 KB 的内存，而是请求一大块远超过当前需要的内存。你可以通过设置 RUBY_GC_HEAP_GROWTH_FACTOR 环境变量来更改这个值。

例如：Ruby 消耗了 100mb 内存，我们设置 RUBY_GC_HEAP_GROWTH_FACTOR=1.1。Ruby 再次请求内存分配的时候，它会得到 110mb 内存。当 Ruby 应用程序启动的时候，它会按照同样的百分比增加内存，直到整个程序可以在这些已分配的内存中执行。这个环境变量值设置越低，意味着我们越要频繁的运行 GC 和请求分配内存。该数值越大，意味着更少的 GC，以及超过我们程序运行所需要的内存。

基于优化网站性能的缘故，很多开发者以为 Ruby 永远不进行内存释放。这不完全正确，事实上 Ruby 是会释放内存的，稍后我们会讨论这一点。

如果把这些行为考虑在内，那么你会对于非保留的对象 (临时对象) 如何影响内存的使用有更清晰的认识。例如：

def make_an_array
  array = []
  10_000_000.times do
    array <<  "a string"
  end
  return nil
end

当我们调用这个方法，会创建 10000000 个字符串对象。当方法执行完毕退出后，这些字符串没有被引用，所以会垃圾回收。然后，当程序执行期间 Ruby 需要为这 10000000 个字符串分配足够的空间。这大概需要 500mb 的内存。

也许你的应用仅需要 10mb 的空间，但是这个数组的创建却需要分配 500mb 的内存。一个简单的例子，假设这个过程是在一个大型 Rails 项目的页面请求中发生，它会耗尽你的内存。因为如果服务器没有足够的内存，GC 就需要不停地释放和分配内存。

因为分配内存的操作开销很大，Ruby 会把这些分配的内存保持住一段时间。一旦进程将这些内存用尽，那么就再次申请内存。内存会逐渐释放，这一过程很慢。如果你在乎程序的效率，那就尽可能少的创建对象。

In-Place Modification for Speed

有一个小技巧可以加快程序执行速度和减少对象分配：利用修改状态来替代创建新对象。例如，这里有一些代码来自于 mime-types gem:

matchdata.captures.map { |e|
  e.downcase.gsub(%r{[Xx]-}o, '')
end

这段代码通过正则的 match 方法返回了 matchdata object。然后，它将正则表达式捕获的元素组成了一个数组，并将其传递给代码块。代码块对字符串进行一些处理。这段代码看起来很合理。但是当它在 mime-types gem 中被上千次的调用时，每次调用 downcase 和 gsub 都会创建一个新字符串对象，及其耗时和浪费内存。为了避免这样，我们可以做一些修改：

matchdata.captures.map { |e|
  e.downcase!
  e.gsub!(%r{[Xx]-}o, ''.freeze)
  e
}

虽然代码变得冗余一些，但是它运行起来更快。这招可以提高我们的效率，因为我们没有在代码块中引用原字符串对象，所以我们可以放心的修改已经存在的字符串而不是创建一个新的。

注意：你不需要用一个常量来储存正则表达式，所有的正则表达式文本由 Ruby 解释器自动冻结（frozen）。

In-Place Modification 也会给你带来麻烦。你很容易修改一个在其它地方会用到的变量，而你并没意识到这一点，因此造成的 bug 很难被找到。在使用这招进行性能优化之前，确保你已经有足够的测试。另外，仅对你仔细斟酌过并确认存在大量创建对象操作的代码进行优化。

有一种错误的观点，认为 对象是很慢的。事实上对象可以让程序容易理解和容易优化。即便是最快的工具和技术，当用法不对的时候一样会变得很慢。

在应用级别捕捉不必要的分配可以使用 derailed_benchmarks。在更底层的级别，可以使用 allocation_tracer 或 memory_profiler。

另外：本文的作者写了 derailed_benchmarks，可以利用 rake perf:mem 来查看内存统计。

Good to be Free

正如前文所说，Ruby 会释放内存，虽然很慢。执行 make_an_array 方法会引起内存飙高，你可以监控 Ruby 是如何释放内存的：

while true
  GC.start
end

应用程序占用的内存减小的过程非常缓慢。当分配太多内存的时候，Ruby 释放少量空页（一组内存颗粒）。操作系统调用 malloc 来进行内存分配，取决于操作系统对于 malloc 库的不同实现，这些内存可能会被交还给系统。

对于大多数应用，比如 web 应用来说，这一分配内存的动作都由客户端触发。当客户端频频触发这一动作时，我们无法依靠 Ruby 自身的能力去释放内存来保证我们的应用程序占用的空间足够小。另外，释放内存很耗时，最好还是避免创建对象。

You’re Up

现在你已经对 Ruby 中对象和内存的关系有了基本的了解。当你想要对自己的程序进行内存方面的性能优化时，可以使用下面的工具：

遵循下面的模式：找到热点中容易引发问题的地方，优化性能，进行性能测试。

广告时间

[远程办公] Tower 团队招募小伙伴，详情 http://v2ex.com/t/192966 。

Ruby / 10k-20k / 1-3 年 / 本科及以上

入职后，贫道带你一起飞。如果有幸可以在北京共事，我可以请吃西红柿刀削面，大家没事还能出来散散步，划划船。别犹豫了，快到碗里来吧！

版主手下留情啊，@zchar 让我发的。

利用 ActiveSupport::Notifications 在 Rails 中实现 PUB/SUB 模式

victor — Mon, 30 Mar 2015 19:34:10 +0800

利用 ActiveSupport::Notifications 在 Rails 中实现 PUB/SUB 模式

前言

自从 Rails 4 从核心中移除了 Observers 之后，对于复杂的业务逻辑和依赖关系该放在哪，大家就开始各显神通了。

有人建议利用 Concerns 和 callback 来搞定。

module MyConcernModule
  extend ActiveSupport::Concern

  included do
    after_save :do_something
  end

  def do_something
     ...
  end
end

class MyModel < ActiveRecord::Base
  include MyConcernModule
end

更多的人认为，依据单一职责原则抽出一个 Service Object 才是王道。

在此基础上，Wisper确实是一个很好的解决方案。

你可以这么玩：

class PostsController < ApplicationController
  def create
    @post = Post.new(params[:post])

    @post.subscribe(PusherListener.new)
    @post.subscribe(ActivityListener.new)
    @post.subscribe(StatisticsListener.new)

    @post.on(:create_post_successful) { |post| redirect_to post }
    @post.on(:create_post_failed)     { |post| render :action => :new }

    @post.create
  end
end

也可以这么玩：

class ApplicationController < ActionController::Base
  around_filter :register_event_listeners

  def register_event_listeners(&around_listener_block)
    Wisper.with_listeners(UserListener.new) do
      around_listener_block.call
    end
  end
end

class User
  include Wisper::Publisher
  after_create{ |user| publish(:user_registered, user) }
end

class UserListener
  def user_registered(user)
    Analytics.track("user:registered", user.analytics)
  end
end

但是 @Rei 一句 Rails 有 ActiveSupport::Notifications 竟让我无言以对。

ActiveSupport::Notifications

在阅读了相关阅读中给出的链接，以及 Notifications in Rails 3 和官方文档之后，感觉这东西设计出来完全是为了进行统计、日志、性能分析之类的事情啊。

那么用它能不能实现一个 PUB/SUB 模式呢？先来回顾一下 PUB/SUB 模式核心的两个要点。

Publishers 在对象状态改变且需要触发事件的时候发布事件。
Subscribers 仅接收它们能响应的事件，并且在每个事件中可以接收到被监控的对象。

The Basics of AS::Notifications

ActiveSupport::Notifications 主要核心就是两个方法：instrument 和 subscribe。

你可以把 instrument 理解为发布事件。instrument 会在代码块执行完毕并返回结果之后，发布事件 my.custom.event，同时会自动把相关的一组参数：开始时间、结束时间、每个事件的唯一 ID 等，放入 payload 对象。

ActiveSupport::Notifications.instrument "my.custom.event", this: :data do
  # do your custom stuff here
end

现在你可以监听这个事件：

ActiveSupport::Notifications.subscribe "my.custom.event" do |name, started, finished, unique_id, data|
  puts data.inspect # {:this=>:data}
end

理解了这两个方法，我们可以试着实现一个 PUB/SUB 模式。

Publisher

# app/pub_sub/publisher.rb
module Publisher
  extend self

  # delegate to ActiveSupport::Notifications.instrument
  def broadcast_event(event_name, payload={})
    if block_given?
      ActiveSupport::Notifications.instrument(event_name, payload) do
        yield
      end
    else
      ActiveSupport::Notifications.instrument(event_name, payload)
    end
  end
end

首先我们定了 Publisher。它把 payload 夹在事件中广播出去，代码块也可以当做一个可选参数传递进来。

我们可以在 model 或 controller 中发布具体事件。

if user.save
  # publish event 'user.created', with payload {user: user}
  Publisher.broadcast_event('user.created', user: user)
end

def create_user(params)
  user = User.new(params)
  # publish event 'user.created', with payload {user: user}, using block syntax
  # now the event will have additional data about duration and exceptions
  Publisher.broadcast_event('user.created', user: user) do
    User.save!
    # do some more important stuff here
  end
end

Subscriber

Subscriber 可以订阅事件，并将代码块当做参数，传递给 ActiveSupport::Notifications::Event 的实例。

# app/pub_sub/subscriber.rb
module Subscriber
  # delegate to ActiveSupport::Notifications.subscribe
  def self.subscribe(event_name)
    if block_given?
      ActiveSupport::Notifications.subscribe(event_name) do |*args|
        event = ActiveSupport::Notifications::Event.new(*args)
        yield(event)
      end
    end
  end
end

# subscriber example usage
Subscriber.subscribe('user.created') do |event|
  error = "Error: #{event.payload[:exception].first}" if event.payload[:exception]
  puts "#{event.transaction_id} | #{event.name} | #{event.time} | #{event.duration} | #{event.payload[:user].id} | #{error}"
end

经典场景

用户注册后，为该用户发送欢迎邮件。

# app/pub_sub/publisher.rb
module Publisher
  extend ::ActiveSupport::Concern
  extend self

  included do
    # add support for namespace, one class - one namespace
    class_attribute :pub_sub_namespace

    self.pub_sub_namespace = nil
  end

  # delegate to class method
  def broadcast_event(event_name, payload={})
    if block_given?
      self.class.broadcast_event(event_name, payload) do
        yield
      end
    else
      self.class.broadcast_event(event_name, payload)
    end
  end

  module ClassMethods
    # delegate to ASN
    def broadcast_event(event_name, payload={})
      event_name = [pub_sub_namespace, event_name].compact.join('.')
      if block_given?
        ActiveSupport::Notifications.instrument(event_name, payload) do
          yield
        end
      else
        ActiveSupport::Notifications.instrument(event_name, payload)
      end
    end
  end
end

# app/pub_sub/publishers/registration.rb
module Publishers
  class Registration
    include Publisher

    self.pub_sub_namespace = 'registration'
  end
end

# broadcast event
if user.save
  Publishers::Registration.broadcast_event('user_signed_up', user: user)
end

# app/pub_sub/subscribers/base.rb
module Subscribers
  class Base
    class_attribute :subscriptions_enabled
    attr_reader :namespace

    def initialize(namespace)
      @namespace = namespace
    end

    # attach public methods of subscriber with events in the namespace
    def self.attach_to(namespace)
      log_subscriber = new(namespace)
      log_subscriber.public_methods(false).each do |event|
        ActiveSupport::Notifications.subscribe("#{namespace}.#{event}", log_subscriber)
      end
    end

    # trigger methods when an even is captured
    def call(message, *args)
      method  = message.gsub("#{namespace}.", '')
      handler = self.class.new(namespace)
      handler.send(method, ActiveSupport::Notifications::Event.new(message, *args))
    end
  end
end

# app/pub_sub/subscribers/registration_mailer.rb
module Subscribers
  class RegistrationMailer < ::Subscribers::Base
    def user_signed_up(event)
      # lets delay the delivery using delayed_job
      RegistrationMailer.delay(priority: 1).welcome_email(event.payload[:user])
    end
  end
end

# config/initializers/subscribers.rb
Subscribers::RegistrationMailer.attach_to('registration')

醉了吗？详细的解释可以看相关阅读中的文章。如果你的队友没有把 ASN 吃透，肯定会掀桌子。

所以是引入一个 gem 还是自己根据 ASN 来实现同样的功能，还是由你自己想吧。

4.22 补充

22 楼的 @satzcoal 提了如下几个问题，我也答应 @billy 在踩坑之后过来补充一下此文。@satzcoal 面对的问题有下面这些：

ActiveSupport::Notifications 在 sub 的管理上非常困难

ASN 对于 sub 的管理和 Wisper 其实并无太大差异。仍然可以进行全局订阅和临时订阅。如果你觉得难以管理，那我建议你跟我一样，在 initializes 文件夹下面建立一个 subscribers.rb 用来统一进行订阅。

subsribers = {
  todos: [ 'started', 'paused', 'completed', 'deleted' ],
  topics: ['created', 'deleted', 'sticked', 'unsticked', 'commented'],
  documents: ['created', 'deleted', 'updated', 'commented', 'recovered'],
}

subsribers.each do |key, value|
  value.each do |action|
    ActiveSupport::Notifications.subscribe("#{key}.#{action}") do |*args|
      event = ActiveSupport::Notifications::Event.new(*args)
      WebhookService.call(event.name, event.transaction_id, event.payload)
    end
  end
end

很难验证 sub 的重复性

如果你使用了上面那种集中式管理 sub 的方法，这个问题就略过吧。

很难进行 unsub

可以利用 unsubscribe 来取消订阅，但是我在使用中，没有遇到这个场景。

很难管理 sub 的顺序

我猜你问得是很难定义 instrument 的顺序吧。从别人那里摘抄一个代码，你看看是不是你需要的？

ActiveSupport::Notifications.instrument 'user.signup' do
  # create user record
  ActiveSupport::Notifications.instrument 'twitter.location' do
    user.last_location = Twitter.user(user.twitter_username).location
  end
  # do more work
end

很难对 sub 中的异常进行处理

同上直接上代码了

ActiveSupport::Notifications.instrument 'twitter.location', :user => user.id do
  user.last_location = Twitter.user(user.twitter_username).location
end

# instrument message data - name, start, end, id, payload
=> ['twitter.location', 2015-04-22 17:15:44, 2015-04-22 17:15:44, 'LAiKEjiMCy8XYY9Y'， { :user => 1023, :exception => ["Twitter::Error:NotFound", "not found"]}]

ASN 会在 payload 中返回 Exception Type 和 Exception Message 的。

小结

向 @billy 的报告。过去几周我使用 ASN 为我司的项目添加了 Webhook 功能。还是原来的答案，核心逻辑不该用 ASN。

ASN 可以使用在下列场景：

Custom Logging
New Relic Tracking
Google Analytics events
Gampfire / HipChat alerts
Schedule background jobs
Fire web hooks

发布 / 订阅模式

victor — Mon, 30 Mar 2015 13:48:47 +0800

使用场景

很多项目中都有消息分发或者事件通知机制，尤其是模块化程度高的项目。

比如：在你的系统中，很多模块都对 新建用户 感兴趣。权限模块希望给新用户设置默认权限，报表模块希望重新生成当月的报表，邮件系统希望给用户发送激活邮件...诸如此类的代码都写到新建用户的业务逻辑后面，会加大耦合度，降低可维护性，并且对于每个模块都是一个独立系统的情况，这种方式更是不可取。

对于简单的情形，观察者模式 The Observer Pattern 就足够了。如果系统中有很多地方都需要收发消息，那么它就不适用了。否则会造成类数量的膨胀，增加类的复杂性，这时候就需要一种更集中的机制来处理这些业务逻辑。

什么是发布/订阅模式 (PUB-SUB)

现实中，并不是所有请求都期待答复，而不期待答复，自然就没有了状态。广播听过吧？收音机用过吧？就这个意思。

发布/订阅模式定义了一种一对多的依赖关系，让多个订阅者对象同时监听某一个主题对象。这个主题对象在自身状态变化时，会通知所有订阅者对象，使它们能够自动更新自己的状态。

特点

一个订阅者可以订阅多个发布者
消息是会到达所有订阅者处，订阅者根据 filter 丢掉自己不需要的消息 (filter 是在订阅端起作用的)
每个订阅者都会接收到每条消息的一个副本
基于推送 push，其中消息自动地向订阅者广播，它们无须请求或轮询主题来获得新消息

发布/订阅模式内部，有多种不同类型的订阅者。

非持久订阅者是临时订阅类型，它们只是在主动侦听主题时才接收消息。
持久订阅者将接收到发布的每条消息的一个副本，即便在发布消息，它们处于"离线"状态时也是如此。
另外还有动态持久订阅者和受管的持久订阅者等类型。

优势

降低了模块间的耦合度：发布者与订阅者松散地耦合，并且不需要知道对方的存在。相关操作都集中在 Publisher 中。
可扩展性强：系统复杂后，可以把消息订阅和分发机制单独作为一个模块来实现，增加新特性以满足需求

缺陷

与其说缺陷，不如说它设计本身就有如下特点。但不管怎么说，这种模式在逻辑上不可靠的。主要体现在：

发布者不知道订阅者是否收到发布的消息
订阅者不知道自己是否收到了发布者发出的所有消息
发送者不能获知订阅者的执行情况
没人知道订阅者何时开始收到消息

Wisper

你可能早就看过 RailsCasts 上的 #260 Messaging with Faye 和 #316 Private Pub。但今天要来介绍的是另外一个 gem。

首先看看传统的利用 `callback` 的实现

Post 模型通过回调，与 Feed 模型和 User::NotifyFollowers 服务紧密的耦合在一起。

# app/models/post.rb
class Post
  after_create :create_feed, :notify_followers

  def create_feed
    Feed.create!(self)
  end

  def notify_followers
    User::NotifyFollowers.call(self)
  end
end

# app/controllers/api/v1/posts_controller.rb
class Api::V1::PostsController < Api::V1::ApiController
  def create
    @post = current_user.posts.build(post_params)
    if @post.save
      render_created(@post)
    else
      render_unprocessable_entity(@post.errors)
    end
  end
end

利用 `Wisper` 的 PUB-SUB 模式

# app/models/post.rb
class Post
  # no callbacks in the models!
end

Publishers 在对象状态改变且需要触发事件的时候发布事件。

# app/controllers/api/v1/posts_controller.rb
# corresponds to the publisher in the previous figure
class Api::V1::PostsController < Api::V1::ApiController

  include Wisper::Publisher
  def create
    @post = current_user.posts.build(post_params)
    if @post.save
      # Publish event about post creation for any interested listeners
      publish(:post_create, @post)
      render_created(@post)
    else
      # Publish event about post error for any interested listeners
      publish(:post_errors, @post)
      render_unprocessable_entity(@post.errors)
    end
  end
end

Subscribers 仅接收它们能响应的事件。

# app/listener/feed_listener.rb
class FeedListener
  def post_create(post)
    Feed.create!(post)
  end
end
# app/listener/user_listener.rb
class UserListener
  def post_create(post)
    User::NotifyFollowers.call(self)
  end
end

Event Bus 用来管理系统中订阅者都订阅哪些频道。

# config/initializers/wisper.rb

Wisper.subscribe(FeedListener.new)
Wisper.subscribe(UserListener.new)

进一步，根据单一职责原则把 PUB-SUB 模式和 Service Objects 联合起来

Publisher

# app/service/financial/order_review.rb
class Financial::OrderReview
  include Wisper::Publisher
  def self.call(order)
    if order.approved?
      publish(:order_create, order)
    else
      publish(:order_decline, order)
    end
  end
end

Subscribers

# app/listener/client_listener.rb
class ClientListener
  def order_create(order)
    # can implement transaction using different service objects
    Client::Charge.call(order)
    Inventory::UpdateStock.call(order)
  end

  def order_decline(order)
    Client::NotifyDeclinedOrder(order)
  end
end

更多用法，请参考 Wisper wiki。

后记

本文的唯一作用可能就是，能让大家在设计 Service Objects 时候再多思考一点。虽然到底要不要抽出 Service Objects 也是一个见仁见智的问题。在相关连接中我有贴出 Gourmet Service Objects 一文，另外本站的 Service Object: What? Why? and How? 也请抽空读一下。

这里没有交代如何在发布/订阅模式中引入队列系统的方法，所以上面的代码你是绝对没办法直接拿去用的。

Gulp on Rails: Replacing the Asset Pipeline

victor — Thu, 19 Feb 2015 22:31:35 +0800

http://viget.com/extend/gulp-rails-asset-pipeline

Learn the Ruby Programming Language

victor — Wed, 31 Dec 2014 12:13:18 +0800

http://ruby.about.com/

This site will teach you the Ruby programming language. We'll teach you with simple, step-by-step tutorials so you can follow along.

个推服务端 Ruby SDK

victor — Fri, 08 Aug 2014 18:04:44 +0800

百度推送实在太坑，在小米手机上也经常出现丢失或者无法唤醒程序的 bug。所以老大决定换个推。

如果也有用个推进行推送的兄弟们，可以省点时间了。

https://github.com/wjp2013/igetui-ruby

不谢，请叫我雷锋侠。

railstips 的 alfred workflow

victor — Mon, 05 May 2014 15:04:25 +0800

起因，不知道 reorder 这个 rails build-in 的方法。想了半天怎么把 default_scope 的结果重新排序，因为不能用 unscoped 粗暴的搞定，会打破关联。google 了一下，结果发现了 reorder

干脆做个 workflow 每天早上先读 1，2 个方法在开工吧

功能：学习 rails 的小花招
用法：唤醒 alfred 输入 railstips 回车，看到内容之后再按一下回车跳转到 http://api.rubyonrails.org/ 查看详情
数据地址：https://github.com/wjp2013/railstips 欢迎帮忙添加内容

RubyChina Workflow For Alfred 2.0 by ruby

victor — Wed, 26 Mar 2014 12:18:15 +0800

https://github.com/wjp2013/alfred2-workflows

没啥新鲜的，和 http://ruby-china.org/topics/9730 的功能完全一样，只不过用 ruby 实现了一次而已。

Hybrid 技术调研

victor — Tue, 18 Mar 2014 12:49:06 +0800

此文是我们团队内部选型时候我的一点笔记，主要是给同事看的，也许对大家有点帮助，没什么新东西，主要是整理人家的文章和内容为主。

移动 App 开发技术分类

Web App

介绍

成本低，快速开发
响应式设计
浏览器运行很多手机特性无法访问。例如联系人，推送等
single page app
销售渠道限制于浏览器

Native App

介绍

学习成本高，开发成本高，开发效率低
不同平台一道坎

Hybrid App

介绍

Hybrid App 优点

兼具 Native App 良好用户体验的优势和 Web App 跨平台开发的优势
开发成本和难度比 Native App 小
使得开发和日常维护过程变得集中式、更简短、更经济高效
既可以通过 Native 分发渠道推广产品，也可同时在微信，百度轻，UC 等移动平台推广

现状

国外的 Facebook，App Store
国内的百度搜索，淘宝客户端 Android 版。其中百度封装的不是 WebView 而是自己的浏览内核，体验更像原生客户端，更高效。

Hybrid 含义

mobile application: 就是一个移动应用
both browser-supported language and computer language: 同时使用网页语言和程序语言编写
avaiable through application distribution platforms: 通过应用商店进行分发
a target device: 区分目标平台
install to run: 用户需要安装使用

Hybrid 类型

多 View 混合型
单 View 混合型
Web 主体型

多 View 混合型 (中)

即 Native View 和 Web View 独立展示，交替出现。例如我们第一版本的安卓 App。

单 View 混合型 (好)

即在同一个 View 内，同时包括 Native View 和 Web View。互相之间是覆盖（层叠）的关系。

这种 Hybrid App 的开发成本较高，开发难度较大，但是体验较好。

例如百度搜索为代表的单 View 混合型移动应用，既可以实现充分的灵活性，又能实现较好的用户体验。

Web 主体型 (差)

即移动应用的主体是 Web View，主要以网页语言编写，穿插 Native 功能的 Hybrid App 开发类型。

这种类型开发的移动应用体验相对而言存在缺陷，但整体开发难度大幅降低，并且基本可以实现跨平台。

Web 主体型的移动应用用户体验的好坏，主要取决于底层中间件的交互与跨平台的能力。

国外的 appMobi、PhoneGap 国内的 AppCan 和 Rexsee 都属于 Web 主体型移动应用中间件。其中 Rexsee 不支持跨平台开发。appMobi 和 PhoneGap 除基础的底层能力更多是通过插件（Plugins）扩展的机制实现 Hybrid。而 AppCan 除了插件机制，还提供了大量的单 View 混合型的接口来完善和弥补 Web 主体型 Hybrid App 体验差的问题，接近 Native App 的体验。

中间件

App 的 Native 代码部分使用操作系统的 API 来创建嵌入式 HTML 渲染引擎，该引擎在浏览器和设备的 API 之间充当了桥梁。这座桥梁让 Hybrid App 得以充分利用现代设备所提供的全部特性。

App 开发者可以选择编写自己的桥梁，或者充分利用现成的解决方案，比如 PhoneGap。

App 的 Web 部分可能是驻留在服务器上的网页，也可能是一组 HTML、JavaScript、CSS 和媒体文件，封装到 App 代码中，存储在设备本地。

放置在服务器上的 HTML 代码让开发者不必经历提交和批准过程——有些 App 商店要求这个过程，就可以对 App 进行小幅更新。遗憾的是，这个方法摈弃了任何离线可用性，因为设备与网络没有连接时，无法访问设备。
把 Web 代码封装到 App 里面可以提高性能和可访问性，但是不允许远程更新。
推荐的方案是：结合使用两者。这种系统采用的架构可以把 HTML 资源放置在 Web 服务器上，以获得灵活性，但是又把它们本地缓存在移动设备上，以获得高性能。

根据我们目前的技术实力和业务需求，内部时间人力资源预算，不建议使用中间件，以下是市面主流中间件的对比。

最后选择的架构

Ember 用于双向绑定，网络请求，视图管理等工作
Require.js JavaScript 模块化工具，能够帮助你把整体的代码管理的井井有条（这块还没决定好）
开发阶段使用 Haml + Sass + Coffee
API server 使用 Ruby Rack + Grape + Puma

题外话

为毛不用 Angular，为毛不用 jade，为毛不用 BackBone，不用 jQuery Mobile，不用 PhoneGap。。。。

我也不知道为啥不用。可能都是命吧。另外朋友们提到的一些技术，例如 jade，我是确实不了解。可能在具体的开发中，如果发现特别合适的话，就会果断使用的。另外一些，比如 jQuery Mobile，PhoneGap 和 BackBone 确实是各有缺点，不适合我们目前的需求。并不是它们不好，我相信它们都有自己适用的地方。

后记

在用 Ember 开发了 2 周之后，发现确实可以满足我们目前阶段的需求。还在疑虑的同学，可以小范围的开始上了。

参考资源

[北京][电商] 招 Ruby 开发初级工程师 [结贴]

victor — Mon, 17 Feb 2014 14:30:15 +0800

公司介绍：

团队主营项目是垂直电商，盈利稳定，发展迅速。同时和阿里系的公司有深度合作。

我们不需要业内的见证，不想当明星团队，只需要一个踏实，勤奋的你来补充我们的队伍。

公司地址

13 号线望京西站附近南湖西园，步行道望京西站大概 8 分钟

职位描述

参与设计、开发、调试 Ruby and Rails 编写的程序

任职要求

基本要求

2 本以上计算机相关专业毕业
1 年工作经验，对学校里面学习的知识没有忘光
能看懂 Ruby 代码
使用 Rails 开发过项目
使用 Mac

加分

有自己的 github
使用 vim 或者 sublime text
写技术 blog
善于学习技术，有持续学习技术的激情
能阅读英文技术文档
会科学上网，遇到问题会 google，知道 stackoverflow

薪资

6 - 8K 如果觉得过低，先别忙着关闭本页，可以抬头看看题目，然后再看看最我们的基本要求。

我在发帖之前，充分参考了其他家的薪资水平，对于这个看起来低于市场价的薪水，我们相应的放低了对应聘者的要求。

我们更注重你的人品和学习能力，而不是现阶段的工作能力。

我们不能提供

我们目前还在民宅中办公，所以没有那种奢华高调的办公室，但也不会是格子间。
我们是一帮笨人，信奉勤能补拙，偶尔会加班几小时。我们没有加班费，但能提供一份晚餐。

我们能提供

5 险，定期体检
不打卡，工作时间 9 点半 - 6 点半，周末双休
奖金妥妥的，工作满 1 年配发期权
零食饮料，不定期组织聚会
没节操的同事和妹子

友情提示：我们的期权不是某些拿投资的公司那种，上市之后才能兑现的。我们直接按照期权年底分红，给现金。

我们还能提供什么

我们没有什么办公室政治，没有经理，老板。只有哥哥，姐姐。我们这里永远称呼 X 哥，X 姐。如果有一天你发现我们有 X 经理、X 总、X 董，那意味着我们要完蛋了，你可以收拾东西准备跑路了。

你想买任何计算机技术相关的书籍都报销，我们也提供 tutsplus.com 的付费账号。买美金付费的电子书，也没问题。

我们目前在民宅也要马上搬家到更大的民宅，搬家后你可以根据个人喜欢，布置自己期望的工作环境。公司提供 Mac Mini 并且公司内部有 2T 的时间胶囊供大家备份资料。

对于你个人技术上的成长。老道虽然是老菜鸟，但也是从 07 年开始接触 Rails 开发的。6 年来，多多少少累积了一点点心得和开发经验。

你可以学习到：

如何进行产品的开发，测试，调研，需求分析
常见的 gem 使用技巧，rvm、bunlder、brew 等的基本使用
Ruby and Rails 的编程规范
MVC 的设计思想
RESTful API 设计，如何开发一套供移动应用使用的 API 服务
Ruby/Rails 项目部署
Git 的使用，如何利用 git flow 帮我们进行团队开发
日访问量百万级别项目的缓存和优化
如果你有兴趣，对于 HTML5，CSS3，jQuery，响应式布局，移动 Web 开发，我都可以提供一点心得和经验

将来我们可以一起：

学习 rspec 进行 BDD 或者 TDD
学习 Mysql 的优化
学习 Memcache，Redis 为将来的项目的优化提供技术选型
学习 BDD，OOD，Refactoring Patterns 等等

因为我也是一枚老菜鸟，所以在这些方面上我能提供的经验和心得有限，只能我们一起学习，共同进步了。

联系方式

QQ: 22674812 先简单聊聊，聊的好就来公司见见。不会让你先投简历，之后石沉大海。或者完全不了解你，就让你往公司跑耽误你的宝贵时间。

写在最后

我们期望寻找到一枚靠谱，稳重的小伙。和我们一起成长，咱俩一起撑起整个公司的后台项目。我会尽力帮你迅速成长为熟练开发者。

PS：

老道的熏香会一直在工作时间滋养你的身体，绝对让你生龙活虎，晚上撸再多也不累。
贫道在打坐，念经，驱鬼，风水，国学，茶，香，剑道方面也可提供一定指导。

71 篇 Practicing Ruby 系列文章

victor — Mon, 10 Feb 2014 10:21:41 +0800

免费开放，篇篇精彩。

地址：https://practicingruby.com/#public-archives

发现自最新一期的《码农周刊》

Issuepost 限免

victor — Tue, 28 Jan 2014 14:30:31 +0800

Issuepost lets you submit GitHub issues from your desktop quickly—much faster than what you're doing now.

https://itunes.apple.com/cn/app/issuepost/id673907630?l=en&mt=12

有人了解 ruby 2.0 的 collect! 和 map! 的区别么？

victor — Sun, 19 Jan 2014 17:57:47 +0800

从 Ruby 2 的文档看两个方法是一样的。但是实际使用中不是这样

class OptionValue < ActiveRecord::Base
  belongs_to :option_type, touch: true, inverse_of: :option_values
  has_and_belongs_to_many :variants
end

class Variant < ActiveRecord::Base
  has_and_belongs_to_many :option_values

  def options_text
    values = option_values.joins(:option_type)
    values.collect! do |ov|
      "#{ov.option_type.presentation}: #{ov.presentation}"
    end
    values.to_sentence({ words_connector: ", ", two_words_connector: ", " })
  end
end

这里如果把 values.collect! 替换成 values.map! 就报错

undefined method `map!' for #<OptionValue::ActiveRecord_AssociationRelation:0x007fd5175ba650>

我也查看了 Rails4 的 API。并没有扩展 map! 或者 collect! 方法。

环境：Ruby 2.0.0, Rails 4.1.0.beta1

PS: 我的 Dash 安装的是 Ruby 2.1 的文档，所以看的是 Ruby2.1 的文档对 map! 和 collect! 的解释。

Ruby Code Smells

victor — Tue, 14 Jan 2014 20:08:11 +0800

写在前面，因为是摘抄和自己混写。所以出现简体繁体参杂的情况，请大家体谅，勿喷。

1. Duplicate code 重复的代码

如果你在一个以上的地点看到相同的程序结构，那么当可肯定：设法将它们合而为一，程序会变得更好。

同一个 class 内的两个函数中含有重复的代码段
两个兄弟 class 的成员函数中含有重复的代码段
两个毫不相关的 class 内出现重复的代码段

注意：重复的代码是多数潜在 BUG 的温床！

2. Long method 过长的方法

拥有短函数的对象会活的比较好、比较长。

程序愈长就愈难理解
函数过长阅读起来也不方便
小函数的价值：解释能力、共享能力、选择能力

原则：每当感觉需要以注释来说明点什么的时候，我们就把需要说明的东西写进一个独立的函数中。记着，起个好名字！

3. Feature envy 依恋情节

函数对某个类的兴趣高过对自己所处类的兴趣，就会产生对这个类的依恋情节，造成紧耦合。

原则：判断哪个类拥有最多被此函数使用的数据，然后将这个函数和那些数据摆在一起。 原则：将总是变化的东西放在一块。

# BAD
class A
  attr_reader :x, :y, :z

  def initialize x, y, z
    @x = x
    @y = y
    @z = z
  end

  def some_function
    y / z
  end
end

class B
  attr_reader :a

  def initialize a
    @a = a
  end

  def my_method
    a.x + a.y * a.z ** a.some_function
  end
end

# GOOD
class A
  attr_reader :x, :y, :z

  def initialize x, y, z
    @x = x
    @y = y
    @z = z
  end

  def some_function
    y / z
  end

  def special_method
    x + y * z ** some_function
  end
end

class B
  attr_reader :a

  def initialize a
    @a = a
  end

  def my_method
    a.special_method
  end
end

4. Data clumps 数据泥团

有些数据项，喜欢成群结队地待在一块。那就把它们绑起来放在一个新的类里面。这样就可以：

缩短参数列表
简化函数调用

class Point
  attr_reader :x, :y, :z

  def initialize x, y, z
    @x = x
    @y = y
    @z = z
  end

  #BAD
  def some_function _x, _y, _z
    # Do something with it
  end

  #GOOD
  def some_function point
    # Do something with it
  end  
end

5. Comments 过多的注释

过多注释的代码段，往往都是因为那段代码比较糟糕，散发着一股恶臭。

原则：当你感觉需要写注释时，请尝试重构，试着让所有注释都变得多余。

6. Divergent Change 发散式变化

我们希望软件能够更容易被修改。一旦需要修改，我们希望能够跳到系统的某一点，只在该处做修改。如果不能做到这点，你就踩入了 发散式变化 或 霰弹式修改 的坑。

发散式变化：一个类受多种变化的影响

数据库新加一个字段，同时修改三个函数：Load、Insert、Update
新加一个角色二进制，同时修改四处
...

原则：针对某一外界变化的所有相应修改，都只应该发生在单一类中

7. Primitive Obsession 基本类型偏执

代码中有很多基本数据类型的数据。

原则：如果看到一些基本类型数据，尝试定义一种新的数据类型，符合它当前所代表的对象类型。

class Product
  attr_reader :name, :color, :price
  def initialize name, color, price
    @name = name
    @color = color
    @price = price
  end
end

# BAD
[ "Shirt", "Pink", 10 ]

# GOOD
Product.new "Shirt", "Pink", 10

我所参考的视频，仅总结了如上 7 点，我自己又从其它文章中补了下面几个

8. Large Class 过大类

如果想利用单一类做太多事情，其内往往就会出现太多的成员变量。

提取完成同一任务的相关变量到一个新的类
干太多事情的类，可以考虑把责任委托给其他类

注意：一个类如果拥有太多的代码，也是代码重复、混乱、死亡的绝佳滋生地点。

9. Long Parameters List 过长的参数列表

太长的参数列表难以理解，太多参数会造成前后不一致、不易使用，而且你需要更多数据时，就不得不修改它。

原则：参数不超过 3 个！

10. Shotgun Surgery 霰弹式修改

如果每遇到某种变化，你都必须在许多不同的类内做出许多小修改以响应之。如果需要修改的代码散布四处，你不但难以找到它们，也很容易忘记某个重要的修改。

霰弹式修改：一种变化引起多个类相应的修改

11. Switch Statement Switch 语句

面向对象程序的一个最明显特征就是：少用 switch 语句。从本质上说 switch 语句的问题在于重复。

原则：看到 switch 你就应该考虑使用多态来替换它。

12. Temporary Field 暂时成员变量

有时你会看到这样的对象：其内某个成员变量仅为某种特定的情形而设。这样的代码容易让人不解，因为你通常认为对象在所有时候都需要它的所有变量。

在变量未被使用的情况下猜测当初设置目的，会让你发疯。

一个对象的属性可能只在某些情况下才有意义。这样的代码将难以理解。专门建立一个对象来持有这样的孤儿属性，把只和他相关的行为移到该类。最常见的是一个特定的算法需要某些只有该算法才有用的变量。

最后

尚有如下情况未列入，欢迎大家补充。

Parallel Inheritance Hierarchies
Speculative Generality
Message Chain
Middle Man
Inappropriate Intimacy
Alternative Classes with Different Interfaces
Incomplete Library Class
Data Class

为 Grape 和 Jbuilder 的非 Rails 应用增加缓存的 Gem

victor — Thu, 19 Dec 2013 17:33:26 +0800

使用 Grape 做 API 的兄弟们如果使用 Jbuilder 来构建模板。想用 HTTP caching 的话可以考虑一下这个 Gem

https://github.com/wjp2013/grape-shaman_cache

仅在非 Rails 应用上，测试通过。

victor (Victor)

TestProf

139 个关于 Rails 的小技巧

Exploding Rails

Ruby 位运算符详解

字符编码

进化历史

UTF-8

计算机通用的字符编码工作模式

什么是位运算

Ruby 位运算符

pack 和 unpack

不同编码之间的处理

符号位

实际应用

后记

相关阅读

补充

[北京][三元桥] W�E+ 诚聘 Ruby 初级后端工程师

公司介绍

技术团队目前的项目

职位职责

职位要求

加分

福利待遇

联系我

How Ruby Uses Memory

Object Retention

Retention for Speed

Short Lived Objects

Ruby Memory Goes Up

In-Place Modification for Speed

Good to be Free

You’re Up

相关链接

广告时间

利用 ActiveSupport::Notifications 在 Rails 中实现 PUB/SUB 模式

利用 ActiveSupport::Notifications 在 Rails 中实现 PUB/SUB 模式

前言

ActiveSupport::Notifications

The Basics of AS::Notifications

Publisher

Subscriber

经典场景

相关阅读

4.22 补充

ActiveSupport::Notifications 在 sub 的管理上非常困难

很难验证 sub 的重复性

很难进行 unsub

很难管理 sub 的顺序

很难对 sub 中的异常进行处理

小结

发布 / 订阅模式

使用场景

什么是发布/订阅模式 (PUB-SUB)

特点

优势

缺陷

Wisper

首先看看传统的利用 callback 的实现

利用 Wisper 的 PUB-SUB 模式

进一步，根据单一职责原则把 PUB-SUB 模式和 Service Objects 联合起来

后记

相关链接

Gulp on Rails: Replacing the Asset Pipeline

Learn the Ruby Programming Language

个推服务端 Ruby SDK

railstips 的 alfred workflow

RubyChina Workflow For Alfred 2.0 by ruby

Hybrid 技术调研

移动 App 开发技术分类

Web App

Native App

Hybrid App

Hybrid App 优点

现状

Hybrid 含义

Hybrid 类型

多 View 混合型 (中)

单 View 混合型 (好)

首先看看传统的利用 `callback` 的实现

利用 `Wisper` 的 PUB-SUB 模式