luikore (Zete)

torch.rb 看起来不错，用 Ruby 搞深度学习也能走上正统了

luikore — Wed, 12 Aug 2020 18:00:00 +0800

感谢 PyTorch 做了 libTorch，它是个建构在 Eigen / ATen 之上的 C++ 库，然后 Ruby 只要做个绑定包装就可以使用了。

缺点也有，就是 Ruby namespace 四个点，不如 Python 的一个点好看。用前 include 好了。

brew install libtorch automake
# rice 需要 --enabled-shared
RUBY_CONFIGURE_OPTS="--enable-shared" rbenv install -k -v 2.8.0-dev
# 感觉 rice 没搞对 clang 的一些默认 flag
CXX='clang++ -std=c++11 -fdeclspec' gem ins rice
gem ins torch-rb

一道题解

luikore — Mon, 24 Feb 2020 10:55:42 +0800

问题是这样的 (1977 年第 19 届 IMO)

在一个有限项的实数序列中，任意的相连 7 项之和 < 0，任意的相连 11 项之和 > 0。求这种序列最多有几项。

竞赛题解网上有，就不表了…… 这里用程序蛮力解决。

显然这些约束都可以写成线性规划约束，用单纯形法求解。

我们考虑小一个层级的问题：任意相连 2 项之和 < 0，任意相连 4 项 > 0，那这个问题写成 GMPL 程序会是这样：

var x0;
var x1;
var x2;
var x3;
s.t. c1: 1*x0 + 1*x1 + 0*x2 + 0*x3 <= -0.1;
s.t. c2: 0*x0 + 1*x1 + 1*x2 + 0*x3 <= -0.1;
s.t. c3: 0*x0 + 0*x1 + 1*x2 + 1*x3 <= -0.1;
s.t. c4: 1*x0 + 1*x1 + 1*x2 + 1*x3 >= 0.1;
solve;
display x0,x1,x2,x3;
end;

如果有解，那执行 glpsol --math problem.mod 输出里会显示一行 "OPTIMAL LP SOLUTION FOUND".

于是我们从长度为 11 的序列开始生成 GMPL 程序，解解看到多长以后没有解，就能得出答案了。

def feasible? vars, args
  problem = []
  vars.each do |v|
    problem << "var #{v};"
  end
  n = 0
  args.each do |(coe, rgt)|
    n += 1
    lft = coe.zip(vars).map{|(c, v)| "#{c}*#{v}" }.join " + "
    problem << "s.t. c#{n}: #{lft} #{rgt};"
  end
  problem << "solve;"
  problem << "display #{vars.join ','};"
  problem << "end;"

  File.open 'problem.mod', 'w' do |f|
    f.puts problem
  end
  res = `glpsol --math problem.mod`
  if $?.exitstatus != 0
    puts res
    raise "problem failed"
  end
  !!res['OPTIMAL LP SOLUTION FOUND']
end

long = 11
short = 7
last_feasible = nil

(long..).each do |i|
  vars = (0...i).to_a
  args = []

  # short consecutives: <= -0.1
  vars.each_cons short do |vs|
    row = Array.new i, 0
    vs.each do |j|
      row[j] = 1
    end
    args << [row,  '<= -0.1']
  end

  # positive long consecutives: >= 0.1
  vars.each_cons long do |vs|
    row = Array.new i, 0
    vs.each do |j|
      row[j] = 1
    end
    args << [row, '>= 0.1']
  end

  var_names = vars.map{|j| "x#{j}"}
  if feasible?(var_names, args)
    puts "Feasible: #{i}"
    last_feasible = i
  else
    break
  end
end
puts "Longest sequence: #{last_feasible}"

程序输出（秒解）：

Feasible: 11
Feasible: 12
Feasible: 13
Feasible: 14
Feasible: 15
Feasible: 16
Longest sequence: 16

所以满足题目条件的序列最多有 16 项。

Ruby 2.6 无限 Range

luikore — Fri, 20 Apr 2018 09:43:53 +0800

array[1..]
(1..).each {|i| puts i }

https://bugs.ruby-lang.org/issues/12912

TimescaleDB 做了个新主页

luikore — Fri, 11 Aug 2017 19:03:45 +0800

这下应该会火吧？

http://www.timescale.com/

Startcom 证书已经不靠谱

luikore — Tue, 06 Sep 2016 10:10:12 +0800

Startcom 被 wosign 悄悄收购

https://news.ycombinator.com/item?id=12411870

还发了假的 github 证书

现在我已经把 Startcom / StartSSL 根证书全 revoke 了 (还得重新生成但 Ruby China 貌似在 Startcom 注册的...

Cjsx 还是挺好使的...

luikore — Sat, 07 Nov 2015 09:34:52 +0800

webpack.config.js 加入 cjsx-loader

var production = (process.env.RACK_ENV == 'production')

module.exports = {
  ...
  plugins: (production ? [
    new webpack.DefinePlugin({
      "process.env": { NODE_ENV: '"production"' } // reduce react size
    }),
    new webpack.optimize.UglifyJsPlugin(),
  ] : [
    new webpack.HotModuleReplacementPlugin()
  ]),
  module: {
    loaders: [
      ...
      { test: /\.cjsx$/,   loader: (production ? 'coffee!cjsx' : 'react-hot!coffee!cjsx') },

匿名 class

React = require 'react'
module.exports = class extends React.Component
  render: ->
    <div></div>

Comprehension 渲染数组，比 Array.map 更有效率，比 for 循环 push 更简洁

<div>
  { <div key={item.id} onClick={ @props.onDelete.bind null, i }>
      Delete {item.name}
    </div> for item, i in items }
</div>

利用 pattern matching + for ... by 实现 ruby 中的 each_slice 或者 lodash 的 chunk 的效果

<div>
  { <tr key={a.id + b.id}>
      <td>{ a }</td>
      <td>{ b }</td>
    </tr> for [a, b] in rows by 2 }
</div>

如果 child component 要和 parent 共享 state, 那么应该由 parent 控制 state, 而 child 只需要接受 props, 控制 state 的方法可以由 props 传入

假设有 Page, 有内部状态 items

class Page extends React.Component
  getInitialState: ->
    items: [{id: 1, name: 'foo'}, {id: 2, name: 'bar'}]

  deleteItem: (i) ->
    @state.items[i..i] = []
    @setState @state

  render: ->
    <div>
      <h1><span>{@state.items.length}</span> items</h1>
      <Items key={item.id} items={@state.items} onDelete={@deleteItem} />
    </div>

用 Coffee 可以这样实现 Items (func.bind(null, ...) 不改变 this ):

class Items extends React.Component
  render: ->
    <div>
      { <div key={item.key}>
          <a onClick={@props.onDelete.bind null, i}>{item.name}</a>
        </div> for item, i in @props.items
      }
    </div>

或者用 Array.map

class Items extends React.Component
  render: ->
    <div>
      { @props.items.map (item, i) =>
          <div key={item.key}>
            <a onClick={=> @props.onDelete i}>{item.name}</a>
          </div>
      }
    </div>

或者用 do 语法...

class Items extends React.Component
  render: ->
    <div>
      { <div key={item.key}>
          <a onClick={do (i) => => @props.onDelete i}>{item.name}</a>
        </div> for item, i in @props.items
      }
    </div>

纯 C 的 http web server

luikore — Sun, 17 May 2015 13:42:49 +0800

今天看到的 https://kore.io/ , 基本满足所有需要：

HTTPS 支持
SPDY 支持
pgsql 支持
websocket 支持

架构类似 nginx: fork 多个进程，每进程用系统的 event

自建高效率消息推送的又一个选择

Egison: 非线性模式匹配的 Lisp 方言

luikore — Thu, 05 Feb 2015 10:20:09 +0800

感谢 @clongbupt 介绍，认识了 Egison (号称新编程范式，东大还开了一门 Egison 的课...)

关于 egison 里的一些符号：

{} 是 list
[] 是 tuple
<> 是 pattern macro
$x 是声明 match variable x
,x 是引用 match variable x 的值

说明下首页那个列举孪生素数的例子：

(match-all primes (list integer)
    [<join _ <cons $p <cons ,(+ p 2) _>>>
     [p (+ p 2)]])

primes 是个所有素数的无穷列表，由于 Egison 偷懒用 Haskell 实现，支持无穷列表没什么障碍... 看看它的前 10 项

(take 10 primes)
;=> {2 3 5 7 11 13 17 19 23 29}

这段 match-all 代码把素数列表转换成 List Integer 作为匹配的输入，穷举所有符合 <join _ <cons $p <cons ,(+ p 2) _>>> 的 p

cons 和 join (我觉得叫 concat 好一点...) 是构造 list 的基本函数 (ruby 的 each_cons 的 cons 也是来源于 lisp):

(cons 1 (cons 2 (cons 3 {})))
;=> {1 2 3}

用在 pattern 中是解析构 list 的作用。另外

_ 是个哑元，匹配任何东西
$p 将任意匹配结果赋值给 match variable p
,(+ p 2) 求值 p + 2 然后匹配 (注意前面那个逗号... 写模式语言的语法不容易...)

最后对每个匹配 p 输出 [p (+ p 2)]

翻译成 ruby 就是

Prime.each_cons(2).lazy.select{|p, q| q == p + 2}.take(10).to_a

match-all 是这个模式匹配的核心，基本语法是：

match-all-expr ::= '(' match-all tgt-expr matcher-expr match-clause ')'
match-clause ::= '[' pattern expr ']'

基本 matcher 有：list, set, multiset (现在 set matcher 还有 bug 的样子，不能去重), array (未实现) 模式构造器有：cons, join, snoc (逆序的 cons...), nioj (逆序的 join) 模式运算：| (或), & (与), ^ (非)

matcher + pattern 就决定了它是如何生成序列来搜索的，有多少个 match variable 就套多少层，一个 1000 大小的 list 用 20 个 match variable 说不定就爆炸了...

我觉得像极了个 prolog... 不过写法更像代码执行的顺序，而且不是 prolog 那样显式指定 sequence, 可以自定义 matcher, match variable 遵循 lexical scoping. 对比代码：

Prolog 版 https://gist.github.com/GRGSIBERIA/c61e05f3fbb4332bf81e

Egison 版 (并列出所有武斗魔法少女霹雳 Q 娃系列的主角) https://gist.github.com/egisatoshi/97453be10d37287bec9c

现在还有了一个 ruby gem, https://github.com/egison/egison-ruby 写法和 egison 略有不同

静态语言元编程哪家强: Nim

luikore — Sat, 24 Jan 2015 00:11:17 +0800

Nim (原来叫 Nimrod) 是一个缩进语法，编译到 C++/ObjC/JS 的静态语言，而且：

有卫生宏，可以让用户添加新语法例如 list comprehension

https://github.com/def-/nim-unsorted/blob/master/listcomprehensions.nim

可以自己插入编译规则

http://nim-lang.org/trmacros.html

模式语言改写 AST 超简单！比 Java 的 annotation processing tool 好一万倍

const 支持编译期计算，不需要难用得一 B 的 C++ 模板了

早就该这么做了...

特别的标识符等价规则：首字符大小写敏感，其余字符不管下划线和大小写

例如 fooBar_BAZ 等价于 foo_barbaz, 但不等价于 FooBar_BAZ

作用：不管你用的库是驼峰党还是蛇党写的，自己的代码依然可以维持统一的风格...

call unification: `foo.bar()` 相当于 `bar(foo)`

C++ 也要加这个 feature 啦

directive guided syntax

语法可以微调，例如 #! strongSpaces 可以启用 strong spaces 特性，提高无空格的操作符的结合度

pragma 调整程序的行为

例如加入 NaN 和 Infinity 检查

{.NanChecks: on, InfChecks: on.}

GC 可以控制步进时间

(还没看实现，难道是 G1GC?)

...

现在尝鲜很简单，到 http://nim-lang.org/download.html 下载一个 zip 包，./build.sh 就好了

hello world:

"hello".echo
echo("nim~~")

bin/nim -r c hello.nim

参考这两篇博客

http://hookrace.net/blog/what-is-special-about-nim/ http://hookrace.net/blog/what-makes-nim-practical/

Ruby 2.2 Tips: max (n), max_by (n), min (n), min_by (n)

luikore — Sat, 27 Dec 2014 16:54:39 +0800

经常有这样的代码

array.sort_by(&:date).take 3

现在可以这么写：

array.min_by 3, &:date

其实现不需要全排序和额外分配一个中间数组，速度往往更快

为什么 React 这么牛

luikore — Tue, 21 Oct 2014 11:28:47 +0800

React 没有很多其他前端框架的问题：手动指定计算属性的数据依赖以确保更新，批量数据变动导致重绘卡顿，无限滚动越滚越卡，到处都是 $scope.$apply() 或者 $q.defer()... Atom 用了 React 以后速度快了一大截。

http://jlongster.com/Removing-User-Interface-Complexity,-or-Why-React-is-Awesome

这篇长文解释了为何，还扯到 immutable data structure 和 FRP, 还有让手机网页速度可以媲美原生应用的 RequestAnimationFrame, functional lenses, immediate mode vs retained mode, 各种杂七杂八 Om, Mori, Cortext, 看完绝对会转投 React 阵营...

小贴士: 面条头发惊讶脸运算符

luikore — Mon, 08 Sep 2014 14:31:52 +0800

(1..10).sort_by &:-@

中秋快乐

杭州滨江转租

luikore — Fri, 05 Sep 2014 15:07:00 +0800

最近为了各种原因以及 rubyconfchina 参会便利，要去北京住了，现在杭州住的地方想转租出去...

http://www.douban.com/group/topic/61779504/

Swift 和 Ruby 差别还是挺大的...

luikore — Wed, 04 Jun 2014 18:07:17 +0800

这里讲的不是语法层面，而是运行时层面

区别一：Swift 是支持泛型的静态类型

类型系统上应该说不支持泛型的 OC 和 Ruby 还比较接近，Swift 区别就有点大了。

比方说数组类型，Swift 中 [1, 2, 3] 的类型是 Int[], ["foo", "bar"] 的类型是 String[], Ruby 的数组在 Swift 中大概相当于 Any[] 或者 var x = [] // 数组类型变成了 NSArray .

由于泛型数组的类型在编译时已经确定，所以可以比多态类型的数组更能发掘性能潜力，RC4 的 Swift 实现比 OC 实现速度快的原因就在于此。

泛型约束可以极度增加函数签名的长度...

区别二：nil 对象

Swift 默认禁止 nil Object, 只有在类型上加问号 (Optional type) 才可以成为 nil.

var s: String = nil // 错误
var b: String? = nil
b?.isEmpty // nil 值链传递
b!               // 取出了 nil 值
b.isEmpty  // 错误, 你必须用 ! 拆箱或者用 ?. 去做链式调用

区别三：对象系统

Swift 是面向类的语言，对象成员表是编译时决定的。

Swift 和 Ruby 同样是单继承，和 Ruby 可以 include 任意多个 module 相比，Swift 可以添加任意多个 protocol 和 extension.

构造方法 init 的规则有点复杂。Swift 里可以定义两种构造方法：designated (写法是：init(...) { ... }) 和 convenient (写法是 convenient init(...) { ... })

convenient 构造方法的常见作用是提供某些默认值，在 convenient 构造方法中，是必须调用 designated 构造方法的。还有个限制是子类中不能调用超类的 convenient 构造方法。

初始化方法的继承有两个规则：

如果子类没有定义 designated 构造方法，那子类可以调用所有超类的 designated 构造方法。
如果子类提供了与超类的所有 designated 构造方法签名相同的方法 (可以是 designated 或者 convenience 的，也可以是规则 1 继承的), 那子类可以调用所有超类的 convenience 构造方法。

对象成员的初始化分为 2 阶段，第一阶段是放默认值 (成员声明中的 var v = 默认值), 第二阶段是执行 init 方法的赋值。初始化代码中有 4 个编译时的 safety check, 如果访问顺序不满足 4 个条件，就会报错。和 Java 完全相反：Swift 是子类成员先赋值，超类成员后赋值 -- 估计这个顺序规则有利于提高性能。(从实现角度看，我猜想 Swift 对象的内存布局可能会类似下面这样，既方便实现 extension method, 又方便 init 方法的优化，没看过内存里什么样子，扯远了...)

struct Object {
  pointer klass;
  pointer super_klass_object;
  ... // members defined in child object
}

成员的默认值其实可以用比较复杂的代码设置，例如

class A {
  var x = {
    ...
  }()
}

有些成员可以用 @lazy 修饰，到用的时候才初始化 ( lazy 成员才能在初始化块中引用 self)... 所以太滥用成员的初始化机制还是挺容易产生坑的... Swift 对象系统还挺复杂难掌握的... 还好报错信息都非常人性化，很容易发现问题在哪里。

区别四：传值类型和 `inout`

区别于 class, 用 struct 定义的类型都是传值类型，不用担心这类对象内存管理的问题 (下面会提到).

Swift 还有一种参数属性是 inout, 使得函数中可以改变参数的值。不过可以返回 tuple 了我觉得挺多余的，这到底是为了提高性能还是吸引 C# 程序员？

区别五：内存管理

Swift 的运行时和 OC 的运行时有很大的重合，它也是基于自动引用计数而不是 GC 的，所以还是要和 OC 一样，用 weak var 来避免循环引用内存不能释放的问题。如果要把 closure 中的强引用改成弱引用，就要用和 C++1x 相似的方括号语法和 unowned 关键字指定 capture list, 例如

someClosure = {
  [unowned foo] (foo: Foo) -> Bar in
  ...
}

区别六：Immutable 对象

let 声明的变量往往会让人想起 Ruby 中的常量，但用 let 对象不但不可以改变值，还不可以改变它的内部状态

let x: Int[] = []
x.append(3)  // can not modify immutable

var x: Int[] = []
x.append(3) // ok

容易坑的地方

下面代码可以看到 a 和 b 指向的是同一个数组：

a = [1]
b = a
a[0] = 3
b[0] // 3

但是当数组长度发生变化时，就坑爹了...

a = [1]
b = a
a.append(2)
a[0] = 3
b[0] // 1

所以数组是个 copy on extension 的东西，用的时候要多加注意... 用意为何没弄明白，难道是并发环境下数组内存重分配的考虑？还在在学 golang 的 slice?? 预测将来要么这个行为会改掉，要么向用户解释十几年...

反射除了 object is Klass 和 reflect(object) 以外，都用的 objc 的反射机制，所以还得回想 objc 的 selector ...

如果想获得 class 对象，需要自己包装一个调用 [object class] 的函数暴露给 swift

"".respondsToSelector("respondsToSelector:") // true

少数函数如 CGColorGetRandomColor 返回对象是没有被 ARC managed 的，需要手动 retain 和 release, 参见 Unmanaged 的文档 ...

和 OC / C 交互

Swift 比引入 Ruby Framework 的优点之一是语言内建了方便交互的桥梁。

在 Swift 项目中加个 .m 文件或者在 OC 项目中加个 .swift 文件，XCode 就会问你要不要加个 项目名-Bridging-Header.h, 然后你把相应的头文件加进去就可以在 Swift 中使用了。

例如 OC 用 NS_ENUM 定义的枚举类型在 Swift 中就可以直接用：

typedef NS_ENUM(NSInteger, MyEnum) { FOO = 1, BAR };

swift:

var e: MyEnum = MyEnum.BAR

如果没用 NE_ENUM 定义，也能用，只是相当于整数类型了。不过好处是范围依然有检查：

typedef enum {FOO = 1, BAR} MyEnum;

swift:

var e: MyEnum = 2
e = 3 // 错误, 超出范围了

简化的 CF API

Swift 数组有定型 native 形式和 NSArray 形式，当用 native 形式时，可以直接赋值给 CFArrayRef 而不用像 OC 那样 __bridge
create ... release 的内容，在 swift 里都可以省掉 release 了
CFMake* 都映射成了短很多的结构体构造函数，并且是带命名参数的
有很多很长前缀的枚举类型，在 Swift 中都直接可以 . + 后缀使用

例如 Swift Interoperability In Depth 中提到的：

func drawGradientRect(context: CGContext, startColor: CGColor, endColor: CGColor, width: CGFloat, height: CGFloat) {
    let colorSpace = CGColorSpaceCreateDeviceRGB() // 不用手动 CGColorSpaceRelease 了
    let gradient = CGGradientCreateWithColors(colorSpace, [startColor, endColor], [0.0, 1.0]) // 不用 __bridge
    let startPoint = CGPoint(x: width / 2, y: 0) // 代替 Make 系列函数
    let endPoint = CGPoint(x: width / 2, y: height)
    CGContextDrawLinearGradient(context, gradient, startPoint, endPoint, 0)
}

特色 feature

整数类型 Int 在 64 位系统相当于 Int64, 在 32 位系统相当 Int32.

为了解决溢出问题，Swift 的运算符默认检查溢出，但是前面加了 & 的话就不检查 (例如 &+, &*, &% ...).

Swift 还可以声明 +=, ||= 等赋值操作符，估计将来可以写原子性的检查 - 赋值语句，但是貌似还不支持 objc 中的 @synchronized, @atomic 等 attributes.

playground 只能用系统已经提供的库，暂时还不能引入项目中内容或者第三方库

[你还不用 pg?] 坑爹的 MySQL 事务

luikore — Fri, 23 May 2014 17:49:41 +0800

mysql 的事务隔离级别 repeatable read 并不能阻止常见的并发更新。

下面代码中 c 和 c2 就是两个并发的 session, c2 在事务中给字段 accounts.money 做了 +1 操作，但 c 在 c2 的事务进行了一半时修改了 accounts.money 的值，结果就是没发生任何事务错误，把 c 的更新给丢了，用户神秘损失 1 块钱。

require "mysql2"

c = Mysql2::Client.new(:host => "localhost", :username => "root")
c.query 'use dummy'
c.query 'set autocommit=1'
c.query 'delete from accounts'
c.query 'insert into accounts (money) values (1)'
puts "at first money = 1"

id = c.query('select * from accounts').first['id']

t = Thread.new do
  c2 = Mysql2::Client.new(:host => "localhost", :username => "root")
  c2.query 'use dummy'
  c2.query 'set autocommit=1'
  c2.query 'set transaction isolation level repeatable read'

  c2.query 'start transaction'
  puts "c2 starts transaction"

  money = c2.query("select * from accounts where id = #{id}").first['money']
  puts "c2 selected money = #{money}"

  sleep 2 # to let c change money

  c2.query "update accounts set money = #{money + 1} where id=#{id}"
  puts "c2 set money = #{money + 1}"
  c2.query 'commit'
end

sleep 1 # to let c2 select money
puts "c set money = 2"
c.query "update accounts set money = 2 where id = #{id}"

t.join

注意这个是 mysql 的问题，上面的代码写成 sql 存储过程也一样存在。解决的方法只有读数据时改成 select ... for lock in share mode, 或者直接改用 pg:

require "pg"

c = PGconn.open dbname: 'dummy'
c.exec "set autocommit to on" # NOTE, if off, it will require transaction wrapping single statement updates

c.exec 'delete from accounts'
puts "at first money = 1"
c.exec 'insert into accounts (money) values (1)'
id = c.exec('select * from accounts').to_a.first['id']

t = Thread.new do
  c2 = PGconn.open dbname: 'dummy'
  c2.exec "set autocommit to on"

  c2.exec 'start transaction isolation level repeatable read'
  money = c2.exec("select * from accounts where id = #{id}").to_a.first['money'].to_i
  puts "c2 selected money = #{money}"
  sleep 2
  c2.exec "update accounts set money = #{money + 1} where id = #{id}"
  puts "c2 set money = #{money + 1}"
  c2.exec 'commit'
end

sleep 1
puts "c set money = 2"
c.exec "update accounts set money = 2 where id = #{id}"

t.join

5-24 更正：一开始我的理解不对，确切的说是 mysql repeatable read 隔离等级的问题而与 phantom read 无关，为免误解已经把幻读部分去掉。

mysql 的 repeatable read 真的会禁止 phantom read, 也就是事务内两次查询得到的 id 集合是一致并且正确的，但是记录的内容不保证正确。

mysql 的解决办法是对读到的记录加锁，或者用 read committed + 乐观锁也可以。

@Tony612 @saiga @bhuztez 晚上做了实验，发现 mysql 用 repeatable read + 乐观锁依然可以防止错误的并发更新。原因是 rails 的乐观锁使用了这样的更新语句：where id = ? and lock_version = ?, 如果别的事务更新 lock_version, 这个查询得到的记录集合就是空的，就 phantom read 了，而 mysql 对 phantom read 的处理是正确的，然后就会产生事务错误，防止了并发更新的数据丢失。

以下代码，mysql 可以在默认的隔离等级中识别乐观锁

require "active_record"
require "mysql2"
require "logger"

ActiveRecord::Base.logger = Logger.new($stdout)
ActiveRecord::Base.logger.level = Logger::DEBUG

def connect
  ActiveRecord::Base.establish_connection \
    adapter: 'mysql2',
    database: 'dummy',
    username: 'root',
    host: 'localhost',
    pool: 5
end

def init
  Article.delete_all
  ar = Article.new
  ar.n = 1
  ar.save!
end

# columns: id serial, n integer, lock_version integer
class Article < ActiveRecord::Base
end

fork do
  connect
  init
  Article.transaction do
    a = Article.first
    puts "t1: #{a.n}"
    sleep 2
    a.n += 1
    a.save!
    puts "t1 updated"
  end
end

fork do
  connect
  sleep 0.3
  Article.transaction do
    a = Article.first
    puts "t2: #{a.n}"
    sleep 1
    a.n += 1
    a.save!
    puts "t2 updated"
  end
end

sleep 3
puts '-' * 50
connect
puts Article.first.n

关于算法, 我们该学什么?

luikore — Sun, 12 Jan 2014 22:57:12 +0800

如果给你一个改进算法的任务，你是盲头苍蝇的 google 又 google 试了又试，还是利用算法知识一下找到问题所在？以我浅薄的经验，觉得应该学的是这些：

寄存器，内存，硬盘，IO 操作速度的不同之处
时间/空间复杂度，大 O 记法，多项式复杂度的基本概念
单/多递归函数的时间/空间复杂度
工作语言中的常用操作的复杂度 (例如 array.index? 的最佳和最差情况)
二分和排序等常见的 log(n) 或者 n log(n) 的算法 (进阶：大 L 记法, 其他复杂度类别).
给一个简单问题知道该用/搜什么算法或者 API 去解决 (这是经验), 不知道算法名称但能直接写代码搞定其实更好 (这是能力)...

如果要求底层算法：

文件 IO 和 mmap
几种基本内存管理的实现 (malloc, memory pool, arena, reference counting, trace GC 等)
CPU 架构：高级缓存，page fault, cache miss, cache line, cache oblivion 等概念和应用
CPU 架构：流水线，分支预测，超向量指令等概念和应用

如果关心计算并行化：

task parallel 和 data parallel 的基本概念
差分方程和母函数法的应用
把简单的算术运算转换成矩阵运算
认出可以优化成 c 倍快或者 log(c) 倍快的代码模式 (其中 c 是核的数目)

如果是数据分析，暂时只想到这些：

用 PAC learning 评价选择适合业务的算法 (关于这个数学框架 Tom Mitchell 的 Machine Learning 有详述)
反向传播算法 (在神经网络，SGD, 各种数值系统都有广泛应用) 和 viterbi 算法 (在 RCG 语法解析，隐马尔可夫模型，条件随机场，和电子方面都有广泛应用)

Postgres 的 CTE 好像很不错

luikore — Thu, 09 Jan 2014 02:17:51 +0800

CTE = common table expressions 类似于 AR 的 scope

http://www.craigkerstiens.com/2013/11/18/best-postgres-feature-youre-not-using/ http://ruby-china.org/topics/9333?page=1#reply14

设想：在这个基础上做个偷懒的 ORM 的话，大概可以比 ActiveRecord 快不少...

[姨妈] 终于把 rvm 换成 rbenv 了

luikore — Sun, 08 Dec 2013 21:25:26 +0800

后知后觉...

主要是 rvm 几点不太爽：

gemset 和 bundler 功能重复
autolib 太傻瓜
rubygems-bundler 自作聪明

rbenv 就没这些问题。brew install rbenv ruby-build rbenv-gem-rehash 改改启动脚本就好了，弄起来还挺简单的，重新安装 ruby 速度也飞快

CONFIGURE_OPTS="--with-readline-dir=$(brew --prefix readline)" rbenv install -k -v 2.1.0-dev

ctags 替代物: ripper-tags

luikore — Sun, 08 Dec 2013 13:48:47 +0800

https://github.com/tmm1/ripper-tags

gem ins ripper-tags
ripper-tags -R my/project/folder

CSS 解决 field error 的重复代码

luikore — Sat, 23 Nov 2013 15:25:58 +0800

表单验证 error 字段写起来是挺麻烦的事情，最后生成的 html 会像是：

<label>
  <input>
  <!-- 下面这个还是条件出现的 -->
  <div class="field-error">...</div>
  ...

前人发明了各种各样的 form builder 和 helper 去简化这种页面结构的创建... 搞得页面很复杂而且前端不友好

但这种小问题用 css 就能简单搞定... 假设页面这么写

label data-error=@errors[field]
  input

样式这么写

label[data-error]:after
  content: attr(data-error)
  color: red

data-error 属性的内容就会自动附加到后面。效果见 http://codepen.io/anon/pen/LCzGA

混合前端验证的话，直接改 data-error 属性就好了。

data-hint 等同理

你还用 simple_form?