justin (陆晓勇)

Reddot RubyConf 2016 总结

justin — Mon, 27 Jun 2016 23:55:41 +0800

今年代表公司（Beansmile）前往新加坡参加Reddot RubyConf, 收获满满，趁现在有时间，简单总结一下，供自己接下来的学习方向和目标，查漏补缺，也给未到场的朋友分享一下。以下内容，仅供参考，如若有误，请指正。

首先，我们来看下日程表

满满的都是干货，满满的都是大神，看得我那个鸡冻~~

Day 1

Yukihiro (Matz) Matsumoto – Keynote: Ruby Typing

Don't care about small things

第一个讲的是 Ruby 之父Matz，以 O 型血的人不在意细节，分析动态语言和静态语言的区别入题，借此引入 Ruby 3 新 FeatureSoft Typing

Types(part of ruby 3)
- Duck typing in ruby(runtime)
- Don't check type on Programming
- Just care about behavior
- example for String.IO
- Don't care small things
- Soft Typing
- Don't challenge 100% coverage

Jason Yeo – Slaying the Dragon

先调侃了 Matz，设计了Matzlisp的Logo，注册了matzLisp.org等等。

简单介绍mal的用法，了解 Lisp 的基本概念

Kristine Joy Paas – Let's Play Ruby Golf

各种 Ruby 黑魔法，请自我对比一下

正常情况

黑魔法情况下

这是正常人看不懂的代码，所以通常情况下，这些写法在团队都是不推荐的，权当学习哈~

Prathamesh Sonpatki – Secrets of testing Rails 5 apps

来自bigbinary的博主，分享关于 Rails5 的一些内容
Rails 5 integration test are default
Rails 5 controller test are deprecated
Active Job Async adapter

需要了解更多细节，请前往Rails-5，里面满满的都是干货。

Godfrey Chan – Keynote (coming soon)

授人以鱼不如授人以渔
Probelm Solving
Disruption
The Traditional Path
All abstractions leak
Debugging

Grzegorz Witek – Your API is too slow!

Web app optimization

Web API optimization

gem 'ruby-prof'
gem 'rack-mini-profiler'
gem 'newrelic'
gem 'skylight'

Ligtning talks

Jo Cranford – Where Did Everybody Go?

主要是问卷调查，详情请看视频

SHIBATA Hiroshi – How to Begin Developing Ruby Core

介绍如何为 ruby 贡献源码

Ankita Gupta – Speeding Up Your Test Suite

Giovanni Sakti – Flexible Authorization

Tim Riley – Next-generation Ruby web apps with dry-rb, rom-rb, and Roda

简单介绍下一代 Web 框架dry-rb，及各种主件
dry-rb 源码
rom-rb
roda
dry-web - Lightweight web application stack with pluggable routing front-ends

Sau Sheong Chang – Programming Complexity

Day 2

Aaron Patterson – Keynote: Taking Out The Trash

https://github.com/tenderlove/widen
We don't care about small things, so we are removing downcase in Ruby 2.5
Glossary
Something About GC
Find Unlink Node
Remembered Set
Incremental GC
Algorithm
Compacting
heap layout
https://engineering.heroku.com/blogs/2015-02-04-incremental-gc/
Ruby menmory Page && OS menmory page
GC::Profiler.report
http://ruby-doc.org/core-2.2.0/GC/Profiler.html

Sameer Deshmukh – Scientific Computing in Ruby

Konstantin Hasse – How We Replaced Salary Negotiations with a Sinatra App

Vipul Amler – Rails Frontend: 2016 edition

https://www.bigbinary.com/building-modern-web-applications-with-reactjs
https://engineering.heroku.com/blogs/2016-02-18-speeding-up-sprockets/
Sprockets Feature
Headers(ETag,http_cache_forever)
Caching(Action/View/ActionMailer,SQL)
Layouts and Tags(async-defer)

Sayanee Basu – Sense and Sensibility

Yasuko Ohba – Our Fight Against Super Bad Patterns in Legacy Rails Apps

Lightning talks

Kenji Mori – Learning Through Blogging: Ruby Blogging Benefits

Jack Chen Songyong – Grow from Small Simple Steps

Yuki Nishijima – 20 Tools and Techniques that Make You More Creative

gem "did you mean/experimental"
budnle config --global jobs 16
app.get "/"
minitest-power_assert
mv /path/{old, new}.rb/
ctrl + R
tree
ag/ lick ack
curl xxxxx | jq .dependecies.development
pagmentize alise 'more'=pagmentize -g

Steven Yap – Building Real-Time App with React/Redux/Rails/RethinkDB

Xin Tian – Journey to becoming a techlady

Kir Shatrov – Building a ChatOps framework

https://github.com/litaio/lita

Terence Lee - Closing Keynote: After a Decade, Still a Rubyist - RedDotRubyConf 2016

图片

中国参会 Rubyist 合照

新加坡美景

夜景

标志性建筑

各种资源

官网

http://www.reddotrubyconf.com/

直播视频

Day 1
Day 2
完整视频播放列表 📺https://www.youtube.com/playlist?list=PLECEw2eFfW7iiJpXtb_cYeKv5_A6Pd1tl

RedDotRubyConf 2016 links & resources

现场 3D 图

[广州][2015年07月22日 19:00] GZRUBY 第 26 次聚会 [微信开发专场]

justin — Mon, 06 Jul 2015 20:48:48 +0800

Hello Rubyist! 距离上一次GZRUBY 聚会已经两个月了，现在我们已经迎来了燥热的夏天。我们发现最近使用 ruby 开发微信应用的团队越来越多了。大家在开发微信应用的时候有踩过什么坑吗？大家对微信的接口有什么想吐槽了的吗？大家有什么用微信开发的有趣的小应用想分享出来的吗？大家对微信上开发 app 前景是怎么看的呢？大家对微信运营方面有什么心得吗？

欢迎大家带上自己的主题，让我们聚在一起分享吧！

已报名主题

这次我们的主题是基于微信的。欢迎任何与微信相关的话题或者演讲。我们还在此持续更新我们收集到的演讲主题名称，请大家踊跃报名。

@ruby_sky（weixin_rails_middleware gem 作者）《ruby 与微信开发那些事》
@rainchen 《友约 v0.4 开发经验分享—微信与 react 中踩过的那些坑》
duxiaolong《关于微信上适合开发什么样的应用的一些思考？》

活动时间

时间/When: 星期三－7 月 22 号 19:00 / July 22, 19:00 PM
聚会安排:
- 19:00-19:45 主题演讲
- 19:45-20:00 茶歇休息
- 20:00-20:45 主题演讲
- 20:45-21:30 茶歇休息 & 自由交流

活动报名

这次我们的报名采用由Beansmile团队内部开发的一款基于微信的活动报名签到的应用。前端采用 reactjs 实现。大家扫一扫二维码就可以报名参加了。

活动场地

地点/Where: 广东省广州市海珠区新港中路 397 号 T.I.T 创意园创意大道 06 号 CCIC 联合文创（因为百度地图没有此处地址数据，需要导航的建议用腾讯地图）
地铁/Metro: 客村 A 出口/Line 3 - Ke Cun, Exit A

联系方式

Email: justin at beansmile.com wechat: justin_lu_xiao_yong

Rails Scopes 预加载

justin — Fri, 03 Jul 2015 21:59:33 +0800

前几天在rubyweekly里面看到一篇文章，感觉写得不错。拿出来分享一下。原文更精彩

scope 会造成 N+1 查询

作为一个 Rails 开发者，我们经常使用scope来做查询，以简化你的代码，如：

class Review < ActiveRecord::Base
  belongs_to :restaurant

  scope :positive, -> { where("rating > 3.0") }
end

irb(main):001:0> Restaurant.first.reviews.positive.count
  Restaurant Load (0.4ms)  SELECT  `restaurants`.* FROM `restaurants`  ORDER BY `restaurants`.`id` ASC LIMIT 1
   (0.6ms)  SELECT COUNT(*) FROM `reviews` WHERE `reviews`.`restaurant_id` = 1 AND (rating > 3.0)
=> 5

但是，当你一不小心，这将严重的影响你应用的性能。为什么呢？因为使用scope进行定义的查询并不会被预加载。假设你要查询一些restaurants所有positive reviews：

irb(main):001:0> restauraunts = Restaurant.first(5)
irb(main):002:0> restauraunts.map do |restaurant|
irb(main):003:1*   "#{restaurant.name}: #{restaurant.reviews.positive.length} positive reviews."
irb(main):004:1> end
  Review Load (0.6ms)  SELECT `reviews`.* FROM `reviews` WHERE `reviews`.`restaurant_id` = 1 AND (rating > 3.0)
  Review Load (0.5ms)  SELECT `reviews`.* FROM `reviews` WHERE `reviews`.`restaurant_id` = 2 AND (rating > 3.0)
  Review Load (0.7ms)  SELECT `reviews`.* FROM `reviews` WHERE `reviews`.`restaurant_id` = 3 AND (rating > 3.0)
  Review Load (0.7ms)  SELECT `reviews`.* FROM `reviews` WHERE `reviews`.`restaurant_id` = 4 AND (rating > 3.0)
  Review Load (0.7ms)  SELECT `reviews`.* FROM `reviews` WHERE `reviews`.`restaurant_id` = 5 AND (rating > 3.0)
=> ["Judd's Pub: 5 positive reviews.", "Felix's Nightclub: 6 positive reviews.", "Mabel's Burrito Shack: 7 positive reviews.", "Kendall's Burrito Shack: 2 positive reviews.", "Elisabeth's Deli: 15 positive reviews."]

我们可以看到，scope:positive并没有被缓存起来，这明显的是一个N+1查询。

用 associations 代替 scopes

我们可以通过用 associations 代替 scopes，来避免这个问题。请看下面例子：

class Restaurant < ActiveRecord::Base
  has_many :reviews
end

当我们查看这个文档时，我们可以看到，has_many允许我们添加自定义查询

class Restaurant < ActiveRecord::Base
  has_many :reviews
  has_many :positive_reviews, -> { where("rating > 3.0") }, class_name: "Review"
end

但我们可以这样子获取一个restaurant的所有positive_reviews

irb(main):001:0> Restaurant.first.positive_reviews.count
  Restaurant Load (0.2ms)  SELECT  `restaurants`.* FROM `restaurants`  ORDER BY `restaurants`.`id` ASC LIMIT 1
   (0.4ms)  SELECT COUNT(*) FROM `reviews` WHERE `reviews`.`restaurant_id` = 1 AND (rating > 3.0)
=> 5

然后我们就可以通过include来预加载这个关联关系了

irb(main):001:0> restauraunts = Restaurant.includes(:positive_reviews).first(5)
  Restaurant Load (0.3ms)  SELECT  `restaurants`.* FROM `restaurants`  ORDER BY `restaurants`.`id` ASC LIMIT 5
  Review Load (1.2ms)  SELECT `reviews`.* FROM `reviews` WHERE (rating > 3.0) AND `reviews`.`restaurant_id` IN (1, 2, 3, 4, 5)
irb(main):002:0> restauraunts.map do |restaurant|
irb(main):003:1*   "#{restaurant.name}: #{restaurant.positive_reviews.length} positive reviews."
irb(main):004:1> end
=> ["Judd's Pub: 5 positive reviews.", "Felix's Nightclub: 6 positive reviews.", "Mabel's Burrito Shack: 7 positive reviews.", "Kendall's Burrito Shack: 2 positive reviews.", "Elisabeth's Deli: 15 positive reviews."]

至此，6 个 Sql 查询变成 2 个

消除重复

现在我们定义了一个scope:positive和一个关系has_many :positive_reviews，我们可以看到，它们是重复的。我们可以简单的消除这个 DRY.

class Review < ActiveRecord::Base
  belongs_to :restaurant

  scope :positive, -> { where("rating > 3.0") }
end

class Restaurant < ActiveRecord::Base
  has_many :reviews
  has_many :positive_reviews, -> { positive }, class_name: "Review"
end

至此，我们可以知道scope虽然好用，但是当你发现的代码出现以上问题时，简单的修改，能减少许多sql查询

文章没有逐字翻译，如有问题，麻烦指出。

理解 ActiveSupport::Concern

justin — Sat, 27 Jun 2015 14:50:16 +0800

分享一下自己阅读 ActiveSupport::Concern 源码的过程，希望和大家一起学习，错误之处，还请指出

在查看 ActiveSupport::Concern 源码之前，我们先理解几个概念

class_eval and instance_eval

instance_eval

首先从名字可以得到的信息是，instance_eval的调用者receiver必须是一个实例instance，而在instance_eval block 的内部，self 即为 receiver 实例本身。

# 例子一
obj_instance.instance_eval do
  self  # => obj_instance
  # current class => obj_instance's singleton class
end

根据这个定义，如果在一个实例上调用了instance_eval，就可以在其中定义该实例的单态函数singleton_method

# 例子二
class A
end

a = A.new
a.instance_eval do
  puts self  # => a
  # current class => a's singleton class
  def method1
    puts "this is a singleton method of instance a"
  end
end

a.method1
#=> this is a singleton method of instance a

b = A.new
b.method1
#=> NoMethodError: undefined method `method1' for #<A:0x007fbc2ced9550>
from (pry):13:in `<main>'

如我们所知，因为类本身也是 Class 类的一个实例，instance_eval 也可以用在类上，这个时候就可以在其中定义该类的 singleton_method，即为该类的类方法。

# 例子三
class A
end

A.instance_eval do
  puts self  # => A
  # current class => A's singleton class
  def method1
    puts 'this is a singleton method of class A'
  end
end

A.method1
# this is a singleton method of class A
#=>  nil

#=> NoMethodError: undefined method `method1' for #<A:0x007fbc3009e180>
from (pry):11:in `<main>'

class_eval

再来看class_eval，首先从名字可以得到的信息是，class_eval 的调用者 receiver 必须是一个类，而在class_eval block的内部，self即为 receiver 类本身。

# 例子四
class A
end

A.class_eval do
  puts self  
end
# => A

根据这个定义，如果在一个类上调用了 class_eval，就可以在其中定义该类的实例方法 (instance_method)，例如

# 例子五
class A
end

a = A.new
a.method1
#=> NoMethodError: undefined method `method1' for <A:0x007fbc29a826f8> from (pry):21:in `<main>'

A.class_eval do
  def method1
    puts 'this is a instance method of class A'
  end
end

a.method1
#=> this is a instance method of class A

综合上面例子，我们可得出

1. instance_eval必须由 instance 来调用，可以用来定义单例函数（singleton_methods) 2. class_eval必须是由 class 来调用，可以用来定义类的实例方法 (instance_methods)

include and extend

废话不多说，先看代码：

# 例子六
module Foo
  def foo
    puts 'foo method with include...'
  end
end

class Bar
  include Foo
end

Bar.new.foo 
# foo method with include...
# => nil
Bar.foo 
# NoMethodError: undefined method `foo' for Bar:Class
# from (pry):75:in `<main>'

class Baz
  extend Foo
end

Baz.foo
# foo method with include...
# => nil

Baz.new.foo
# NoMethodError: undefined method `foo' for #<Baz:0x007f8061dec068>
# from (pry):80:in `<main>'

由例子我们可以看出，include会把module的方法变成实例方法，extend 会把方法变成类方法。但是，大多时候我们也可以用include来实现类方法和实例方法，请看以下例子：

# 例子七
module Foo
  def self.included(base)
    base.extend(ClassMethods)
  end

  module ClassMethods
    def bar
      puts 'class method'
    end
  end

  def foo
    puts 'instance method'
  end
end

class Baz
  include Foo
end

Baz.bar
# class method
# => nil
Baz.new.foo
# instance method
# => nil
Baz.foo
# NoMethodError: undefined method `foo' for Baz:Class
Baz.new.bar
# NoMethodError: undefined method `bar' for #<Baz:0x007fbc30274ab8>

从例子我们可以看出，include有一个叫included的钩子，正是通过这个钩子，我们可以用include实现添加类方法和实例方法我们来看看included这个钩子到底做了什么？

module A
  def self.included(mod)
    puts "#{self} included in #{mod}"
  end
end
module Enumerable
  include A
end
# A included in Enumerable
# => Enumerable

从代码我们的输出我们可以知道，included类方法作用域self为Module A，并传入include A的receiver Enumerable。然后我们再看看例子七，结合extend与include的理解，就能明白其中的原理所在。

再来看看 ActiveSupport::Concern 的实现：

在没有引入ActiveSupport::Concern之前，我们可以这样进行模块分离

module M
  def self.included(base)
    base.extend ClassMethods
    base.class_eval do
      scope :disabled, -> { where(disabled: true) }
    end

    include InstanceMethods
  end

  module ClassMethods
    def say_hello
      puts "say hello"
    end
  end

  module InstanceMethods
    def say_no
      puts "say no"
    end
  end
end

从代码可知，通过extend和class_eval为base定义了ClassMethods里面的类方法，通过include 为base定义了InstanceMethods里面的实力方法。

当我们引入ActiveSupport::Concern之后，以上例子我们可以这样写：

require 'active_support/concern'

module M
  extend ActiveSupport::Concern

  included do
    scope :disabled, -> { where(disabled: true) }

    include InstanceMethods
  end

  module ClassMethods
    def say_hello
      puts "say hello"
    end
  end

  module InstanceMethods
    def say_no
      puts "say no"
    end
  end
end

最后，我们再来看看ActiveSupport::Concern,是不是就很好理解了？

module Concern
    class MultipleIncludedBlocks < StandardError #:nodoc:
      def initialize
        super "Cannot define multiple 'included' blocks for a Concern"
      end
    end

    def self.extended(base) #:nodoc:
      base.instance_variable_set(:@_dependencies, [])
    end

    def append_features(base)
      if base.instance_variable_defined?(:@_dependencies)
        base.instance_variable_get(:@_dependencies) << self
        return false
      else
        return false if base < self
        @_dependencies.each { |dep| base.include(dep) }
        super
        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
      end
    end

    def included(base = nil, &block)
      if base.nil?
        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)

        @_included_block = block
      else
        super
      end
    end

    def class_methods(&class_methods_module_definition)
      mod = const_defined?(:ClassMethods, false) ?
        const_get(:ClassMethods) :
        const_set(:ClassMethods, Module.new)

      mod.module_eval(&class_methods_module_definition)
    end
  end

Rails4.1 之后，Module 还加入了Concerning方法

Concerning

我们先来看看细化 concern 的几种方法

通过注释

class Todo
  # Other todo implementation
  # ...

  ## Event tracking
  has_many :events

  before_create :track_creation
  after_destroy :track_deletion

  private
    def track_creation
      # ...
    end
end

通过ActiveSupport::Concern

class Todo
  # Other todo implementation
  # ...

  module EventTracking
    extend ActiveSupport::Concern

    included do
      has_many :events
      before_create :track_creation
      after_destroy :track_deletion
    end

    private
      def track_creation
        # ...
      end
  end
  include EventTracking
end

通过concerning

class Todo < ActiveRecord::Base
  # Other todo implementation
  # ...

  concerning :EventTracking do
    included do
      has_many :events
      before_create :track_creation
      after_destroy :track_deletion
    end

    private
      def track_creation
        # ...
      end
  end
end

Todo.ancestors
# [Todo,Todo::EventTracking,...]

总得来说，concerning主要用于切分比较小的 model 另外，还有还提供了类似的concern等方法

concern :EventTracking do
end

is equivalent to

module EventTracking
  extend ActiveSupport::Concern
end

最后贴上自用 sublime snippet,但是我是 Vim 党。

Reference: http://www.railstips.org/blog/archives/2009/05/15/include-vs-extend-in-ruby/ https://github.com/rails/rails/blob/master/activesupport/lib/active_support/concern.rb https://github.com/rails/rails/blob/master/activesupport/lib/active_support/concern.rb

补充：

ActiveSupport::Concern#append_features

def append_features(base)
  if base.instance_variable_defined?(:@_dependencies)
    base.instance_variable_get(:@_dependencies) << self
    return false
  else
    return false if base < self
    @_dependencies.each { |dep| base.include(dep) }
    super
    base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
    base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
  end
end

append_features也是 module 的一个 callback，会在 include 之后，为当前 class 添加 module 的变量，常量，方法等。append_features 会先与 included 被调用，详见：append_features 上面的代码中，如@neverlandxy_naix所说的一样，正是通过递归的方法处理多重嵌套

首先看到一个if判断，这里判断当前类 (base) 是否定义了@_dependencies，如果被定义，则把当前 module 加入@_dependencies。怎么说呢？我们再来看看

def self.extended(base) #:nodoc:
  base.instance_variable_set(:@_dependencies, [])
end

extended类似于included,具体用法见extended 看完extended的用法，我们知道，如果当前类extend了ActiveSupport::Concern,则@_dependencies会被定义。

第二个 if 判断，判断当前类是否继承于当前模块，如果是，则不需要做其他操作，如果不是，则说明当前类既不是当前模块的子类，也没有extend ActiveSupport::Concern。也就是我们最终要include当前模块的类，此时，当前类include当前模块所有依赖@_dependencies,并定义ClassMethods和includedblock 里面的方法。

Rails Activerecod callback 问题

justin — Mon, 30 Sep 2013 16:45:13 +0800

请问，什么回调函数，能实现我每次做 where 查询之前都先执行一次特定函数。（类似after_find）或者，能够实现每天执行一次。

希望各位大牛帮帮忙，google 找不到感激不尽！

如何合并两个 ActiveRecord::Relation 的结果集

justin — Sun, 12 May 2013 22:27:28 +0800

请教下大家一个问题，现在因为使用 ransack 这个 Gem，使用 search 查询功能时，要求对象必须是 ActiveRecord::Relation 如

first = SampleOrder.where(:id => 1)  
second = SampleOrder.where(:id => 2)

想要的结果是 result ＝ first + second 且 result.class => ActiveRecord::Relation

望各位大神指点迷津！

请教关于 Git 工作流的问题

justin — Sat, 23 Mar 2013 21:14:52 +0800

请教各位使用 git 版本管理的程序猿：多人开发不同模块下，有什么比较好的工作流程。目前使用的是（6 个人开发），不同模块在不同分支开发，master 分支上修改共用代码，模块分支不断更新 master 分支代码，直到模块分支开发完成，在合并到 master 分支。现在遇到这样的问题：就是在合并模块分支到 master 分支时，会出现比较多的冲突，而且有些是之前就改过的。

不知道我是否描述清楚。