2008年混杂着奥运的狂喜与自然灾害及金融危机呼啸而过，时间真的是过的越来越快，果然是：”我觉察他去的匆匆了，伸出手遮挽时，他又从遮挽着的手边过去“。
此去经年是我最爱在元旦时留下的标题，而今又是“流光容易把人抛，红了樱桃，绿了芭蕉“了、、、然掩而叹息亦不能改变我又老去了一岁，在过去的一年中我又一事无成的事实。
看来历史总是重复的基本上也是对的吧，不过人总会不满足于现状，在回首看看逝去的一年，心中不由的生出的恐惧与懊恼，追悔不及自然是有的，但是后悔是不能解决问题的，真的问题是需要解决问题，让自己成长，能在自己曾经的时光废墟中立起来，也算是新年新气象吧。
特此立酸文志之，只需要在明年的元旦再看时不再心中有悔，此愿足矣！
虽然Textmate一直是俺的最爱，但是出了ruby及os x之外，使用Textmate有时成了一种奢望，就说rubinius吧，这个*nix only的项目，现在也没有办法在cgywin上编译通过，在我打过多处补丁之后，发现这几乎对我来说是一项不可能完成的任务。不太懂*nix下的线程与信号的说，这个以后俺再补补，争取出个windows上原生线程的port。
为了在*nix（ubuntu与mac os x)下读读它，并跟踪一下它的运行，我只好祭出emacs了，好在它可以整合emacs code browser及cscope，而且还能同时使用图形化的gdb界面。看来Ｃ++还是用emacs好了。
其实我也一直很叶公好龙滴，虽然早就耳闻emacs的好，但是在ubuntu下俺就用gedit来偷懒，dreamhost上用不太熟的vi来混混，windows上还是主要依赖于VS、notepad++，有时也拿intype来找一下textmate的感觉。
最近又因为公司里不许安装Ｄ版，而且VS公司又不肯买，在这点的Jole测试上公司应该是零分的:( 还说是因为印度那边用VC++ Express一直都很好，而且因为金融危机的问题，公司不肯再在软件上投入更多的预算，真是服了公司的目光短浅及印度人的忍耐力、、、、
不过我是被Visual Assist X给宠坏了，不让我使用alt+o, alt+shift+s, alt+shift+o我是没有办法习惯了,而且我曾经花美金买到绝版的ref++及现在refactor!等等的插件都再也办法用了:( 不能装插件的vc express是一个让我无法适应的IDE。
好在emacs还有一个windows的版本，在配完cedet之后，与VAX相同的功能也都回来了，只是emacs下的重构功能我还没有试过，而且那个是要收费滴
经过了几天与emacs的搏斗之后，才发现emacs的难学只是听起来吓人的，慢慢的，还不等你记住，你的手指也开始记住了它的习惯了。而且使用它与*nix下的工具合作起来真的是很爽的，而且这样你在三个平台之下都有了一个统一的IDE感觉真的很爽，不过不知为什么，我居然没有想过用eclipse与netbean呢？我也不知道，可能我天生爱受虐，或者喜欢虐键盘，总对用quicksilver与launchy调出一个emacs疯狂打上一些古怪组合键感觉良好。不知你是否有同好？呵呵
一直对Rubinius所宣称的“Ruby In Ruby”很以为然，而且龙书中之也提到一个语言成熟的标志之一就是能“自举”--即使用自已来实现自己。以此为标准，Fortran、Basic、Javascript、Perl、PHP之类应该都算是不举，而LISP、C/C++、Smalltalk早就是很举的，Python、Java与Ruby现在是半举，并在让自己摆脱ED的印象之中，而Rubinius自然是Rubyist的春药罗
这两天读到Simple VM JIT with LLVM 觉得很是有趣，不过奇怪的是居然这个网站也被盾了，如果你从来没有tor过，或者gladder过，建议你赶紧找一个翻过墙去看看。不过顺便也谈谈我的读后感吧，算是学习笔记了。
Rubinius与YARV一样是一个虚拟机(VM)，它如同Python一样，先将源代码编译成Bytecode文件，在执行时优先执行Bytecode。这样能提高ruby的执行效率。说到VM自然不能不说它的bc了，一个VM无非就是拿一些bc来执行了事而已，其实PC也是这样的，只是一个实一个虚而已。
Evan为了举例说明，首先杜撰了一个足够tiny的VM：
因此下面这字节
[ 0, 0, 3,
1, 0, 0, 4,
2, 0 ]
就表明将3与4相加并打印出来这样一个简单的功能，结果嘛如果不出意思自然是7
用C实现这个VM最平铺直叙的方法就是直接写就好了，如下
void add(int* ops, int* registers) { registers[ops[1]] = registers[ops[2]] + ops[3]; } void set(int* ops, int* registers) { registers[ops[1]] = ops[2]; } void show(int* ops, int* registers) { printf("=> %d\n", registers[ops[1]]); } void run(int* ops, int* registers) { switch(*ops) { case 0: set(ops, registers); ops += 3; break; case 1: add(ops, registers); ops += 4; break; case 2: show(ops, registers); return; } }
随后Evan还另给出一个去除switch的直接的不能再直接的版本：
void my_program() { int registers[2] = {0, 0}; int program[10] = [ 0, 0, 3, 1, 0, 0, 4, 2, 0 ] int* ops = (int*)program; set(ops, registers); ops += 3; add(ops, registers); ops += 4; show(ops, registers); ops += 2; }
其实两者的功能是一样的，唯一的区别是前者更通用一点，可以在运行时执行，而后者比较象使用Bytecode直接翻译过来的样子。
而且的确是这样，处理这样将Bytecode执行的一种最最静态的方法，就是写一个bc的C代码生成器(C code emitter)，将bc一次解析并产生一个类似第二段代码后几句的c代码文件，然后编译执行即可。
不过这种方法最大的缺点就是太静态了，所以的东西已经在编译时就定了，这当然不是Rubinius可以使用的方式，至于如第一段代码那样，一个更动态一点的方法，就是写一个解释器，在运行时解析代码并动态执行。其实这就有点类似YARV的方式。
除此之外有没有别的什么方法还执行bc呢？自然是有的，而且早就有很多人使用过了，那就是JIT(Just-in-time compilation)嘛: JIT是一个不那么纯编译也不那么纯解释的方法，bc在被执行前，先被转成目标机器上的原生指令，然后再执行，因为这一过程是即时的生成的，因此可以在其中增加一个优化的环节。而且因为代码是即时生成的，因此它可以对生成的代码做一些caching，所以它要比一句一句“忠实”执行的解释器快，而且因为JIT能获得更多的运行时信息，如CPU的架构及代码执行统计信息，因此能够生成一些CPU“特化”的代码及运行时的优化工作，所以JIT也是很有可能比静态编译要快的。
其实说了这么多也不过是为了引入今天所要谈的主角-----LLVM: LLVM并不是一个编译器，而仅仅只是一个编译器的基础设施(infrastructure)，这个比较绕，其实它最有趣是提供了一套语言无关的中间层的优化与分析工具集。晕，其实这样说依然很绕:( 不过如果看一看Evan的例子之后可能会明白一些
首先就算是JIT也是需要将Bytecode的语义，即set/add/show指令提供给LLVM滴，先将这三个函数放入一个ops.c文件中，再用到llvm-gcc工具了，它利用gcc的前端，将C代码转换成LLVM的bc文件
命令如下
llvm-gcc -emit-llvm -O3 -c ops.c
这会生成一个ops.o的bc文件
使用llvm-dis < ops.o 命令查看，会看到与bc文件相对应的LLVM汇编指令
@.str = internal constant [7 x i8] c"=> %dA0" ; [#uses=1] define void @add(i32* %ops, i32* %registers) nounwind { entry: %tmp1 = getelementptr i32* %ops, i32 1 ; [#uses=1] %tmp2 = load i32* %tmp1, align 4 ; [#uses=1] %tmp4 = getelementptr i32* %ops, i32 2 ; [#uses=1] %tmp5 = load i32* %tmp4, align 4 ; [#uses=1] %tmp7 = getelementptr i32* %registers, i32 %tmp5 ; [#uses=1] %tmp8 = load i32* %tmp7, align 4 ; [#uses=1] %tmp10 = getelementptr i32* %ops, i32 3 ; [#uses=1] %tmp11 = load i32* %tmp10, align 4 ; [#uses=1] %tmp12 = add i32 %tmp11, %tmp8 ; [#uses=1] %tmp14 = getelementptr i32* %registers, i32 %tmp2 ; [#uses=1] store i32 %tmp12, i32* %tmp14, align 4 ret void } define void @set(i32* %ops, i32* %registers) nounwind { entry: %tmp1 = getelementptr i32* %ops, i32 1 ; [#uses=1] %tmp2 = load i32* %tmp1, align 4 ; [#uses=1] %tmp4 = getelementptr i32* %ops, i32 2 ; [#uses=1] %tmp5 = load i32* %tmp4, align 4 ; [#uses=1] %tmp7 = getelementptr i32* %registers, i32 %tmp2 ; [#uses=1] store i32 %tmp5, i32* %tmp7, align 4 ret void } declare i32 @printf(i8*, ...) nounwind define void @show(i32* %ops, i32* %registers) nounwind { entry: %tmp1 = getelementptr i32* %ops, i32 1 ; [#uses=1] %tmp2 = load i32* %tmp1, align 4 ; [#uses=1] %tmp4 = getelementptr i32* %registers, i32 %tmp2 ; [#uses=1] %tmp5 = load i32* %tmp4, align 4 ; [#uses=1] %tmp7 = tail call i32 (i8*, ...)* @printf( i8* getelementptr ([7 x i8]* @.str, i32 0, i32 0), i32 %tmp5 ) nounwind ; [#uses=0] ret void }
无它，这个ops.o主要是拿来给LLVM使用的，在运行时生成相应的语义调用
然后使用LLVM的C++ API来生成一段与第二段代码相应的LLVM代码
Function* create(Module** out) { std::string error; Module* jit; // Load in the bitcode file containing the functions for each // bytecode operation. if(MemoryBuffer* buffer = MemoryBuffer::getFile("ops.o", &error)) { jit = ParseBitcodeFile(buffer, &error); delete buffer; } // Pull out references to them. Function* set = jit->getFunction(std::string("set")); Function* add = jit->getFunction(std::string("add")); Function* show = jit->getFunction(std::string("show")); // Now, begin building our new function, which calls the // above functions. Function* body = cast<Function>(jit->getOrInsertFunction("body", Type::VoidTy, PointerType::getUnqual(Type::Int32Ty), PointerType::getUnqual(Type::Int32Ty), (Type*)0)); // Our function will be passed the ops pointer and the // registers pointer, just like before. Function::arg_iterator args = body->arg_begin(); Value* ops = args++; ops->setName("ops"); Value* registers = args++; registers->setName("registers"); BasicBlock *bb = BasicBlock::Create("entry", body); // Set up our arguments to be passed to set. std::vector<Value*> params; params.push_back(ops); params.push_back(registers); // Call out to set, passing ops and registers down CallInst* call = CallInst::Create(set, params.begin(), params.end(), "", bb); ConstantInt* const_3 = ConstantInt::get(APInt(32, "3", 10)); ConstantInt* const_4 = ConstantInt::get(APInt(32, "4", 10)); // add 3 to the ops pointer. GetElementPtrInst* ptr1 = GetElementPtrInst::Create(ops, const_3, "tmp3", bb); // Setup and call add, notice we pass down the updated ops pointer // rather than the original, so that we've moved down. std::vector<Value*> params2; params2.push_back(ptr1); params2.push_back(registers); CallInst* call2 = CallInst::Create(add, params2.begin(), params2.end(), "", bb); // Push the ops pointer down another 4. GetElementPtrInst* ptr2 = GetElementPtrInst::Create(ops, const_4, "tmp3", bb); // Setup and call show. std::vector<Value*> params3; params3.push_back(ptr2); params3.push_back(registers); CallInst* call3 = CallInst::Create(show, params3.begin(), params3.end(), "", bb); // And we're done! ReturnInst::Create(bb); *out = jit; return body; }
然后调用之
int main() { // The registers. int registers[2] = {0, 0}; // Our program. int program[20] = {0, 0, 3, 1, 0, 0, 4, 2, 0}; int* ops = (int*)program; // Create our function and give us the Module and Function back. Module* jit; Function* func = create(&jit); // Add in optimizations. These were taken from a list that 'opt', LLVMs optimization tool, uses. PassManager p; /* Comment out optimize p.add(new TargetData(jit)); p.add(createVerifierPass()); p.add(createLowerSetJmpPass()); p.add(createRaiseAllocationsPass()); p.add(createCFGSimplificationPass()); p.add(createPromoteMemoryToRegisterPass()); p.add(createGlobalOptimizerPass()); p.add(createGlobalDCEPass()); p.add(createFunctionInliningPass()); */ // Run these optimizations on our Module p.run(*jit); // Setup for JIT ExistingModuleProvider* mp = new ExistingModuleProvider(jit); ExecutionEngine* engine = ExecutionEngine::create(mp); // Show us what we've created! std::cout << "Created " << *jit; // Have our function JIT'd into machine code and return. We cast it to a particular C function pointer signature so we can call in nicely. void (*fp)(int*, int*) = (void (*)(int*, int*))engine->getPointerToFunction(func); // Call what we've created! fp(ops, registers); }
最后的结果会是这样
<snip same LLVM as before> define void @body(i32* %ops, i32* %registers) { entry: call void @set( i32* %ops, i32* %registers ) %tmp3 = getelementptr i32* %ops, i32 3 ; [#uses=1] call void @add( i32* %tmp3, i32* %registers ) %tmp31 = getelementptr i32* %ops, i32 4 ; [#uses=1] call void @show( i32* %tmp31, i32* %registers ) ret void } => 7
bc被执行了，不是吗？而且上面的那个boby就如同是my_program最后几行代码最直白的翻译，不同这处只是它是用API来产生的而已。
不过等等，最有趣的在后面，如果将LLVM的优化功能全部打开了之后，我们能得到什么？
define void @body(i32* %ops, i32* %registers) { entry: %tmp1.i = getelementptr i32* %ops, i32 1 ; [#uses=1] %tmp2.i = load i32* %tmp1.i, align 4 ; [#uses=1] %tmp4.i = getelementptr i32* %ops, i32 2 ; [#uses=1] %tmp5.i = load i32* %tmp4.i, align 4 ; [#uses=1] %tmp7.i = getelementptr i32* %registers, i32 %tmp2.i ; [#uses=1] store i32 %tmp5.i, i32* %tmp7.i, align 4 %tmp3 = getelementptr i32* %ops, i32 3 ; [#uses=3] %tmp1.i7 = getelementptr i32* %tmp3, i32 1 ; [#uses=1] %tmp2.i8 = load i32* %tmp1.i7, align 4 ; [#uses=1] %tmp4.i9 = getelementptr i32* %tmp3, i32 2 ; [#uses=1] %tmp5.i10 = load i32* %tmp4.i9, align 4 ; [#uses=1] %tmp7.i11 = getelementptr i32* %registers, i32 %tmp5.i10 ; [#uses=1] %tmp8.i = load i32* %tmp7.i11, align 4 ; [#uses=1] %tmp10.i = getelementptr i32* %tmp3, i32 3 ; [#uses=1] %tmp11.i = load i32* %tmp10.i, align 4 ; [#uses=1] %tmp12.i = add i32 %tmp11.i, %tmp8.i ; [#uses=1] %tmp14.i = getelementptr i32* %registers, i32 %tmp2.i8 ; [#uses=1] store i32 %tmp12.i, i32* %tmp14.i, align 4 %tmp31 = getelementptr i32* %ops, i32 4 ; [#uses=1] %tmp1.i2 = getelementptr i32* %tmp31, i32 1 ; [#uses=1] %tmp2.i3 = load i32* %tmp1.i2, align 4 ; [#uses=1] %tmp4.i4 = getelementptr i32* %registers, i32 %tmp2.i3 ; [#uses=1] %tmp5.i5 = load i32* %tmp4.i4, align 4 ; [#uses=1] %tmp7.i6 = call i32 (i8*, ...)* @printf( i8* getelementptr ([7 x i8]* @.str, i32 0, i32 0), i32 %tmp5.i5 ) nounwind ; [#uses=0] ret void } => 7
对，函数被LLVM给Inline化了，强吧！Evan称之为使用核能做饭，呵呵。
嗯，的确是很趣，那么我们从中又能学到什么呢？使用LLVM强大的中间层基础设施，可以为rubinius的bc执行带来强大的JIT功能。至于rubinius真的是怎样做到，让我读读rubinius的代码之后再接着谈吧:)
无意间发现DreamHost 最近在搞优惠活动，凡是在9月10号之前注册的用户，都能享受无限的(之前是500G)磁盘空间与无限的带宽(之前是5T)。呵呵，其实这当然是有一点噱头的成份在里面，毕竟500G与5T(每周都会涨的)我是根本没有用完过，不过如果你认为你一定能用完，或者你梦想远大，或者只为了YY，那你可以赶紧注册一个噢!
当然当然最重要的就是，呵呵，使用我的PROMO CODE：LEESEON 噢，这个是能打折滴，以前是$97，现在也就只有$50了，看来老外滑头起来也是不差的
自然自然无利不起早嘛，听说使用我的Promo Code我是能赚钱滴—俺从来没有拿到过:(,不过还是要佩服一下这种有点象传销一般的病毒式商业运作方式
好久没有写blog了，最近才发现游戏公司忙起来还真的不是一般的忙，现在对那著名的“对EA的血泪控诉”也开始是感同身受了啊，唉!
好在最近闲下来了一点，而且发现自己的gmail里面堆满了从dreamhost发过来的Cron Daemon的错误提示，提示我mephisto的/admin出错了。
本来没有当回事，估计是因为dreamhost的rails升级到2.1.0引起的，当时我使用mephisto0.8，因为正好系统中有rails 2.0.2一时偷懒没有将rails freeze起来，心想应该freeze一下就没有问题了。二话不说，开工，运行
rake rails:freeze:gems VERSION=2.0.2
本以为重启一下服务就能好了，谁知出了一堆错，提示我 “undefined method ‘install_gem_spec_stubs’”
查了一下文档，不对啊，install_gem_spec_stubs可是rails2.1.0中的函数啊，怎么会出现在mephisto 0.8之中，怪啊，不过即然如此，拿2.0.2试试便知，运行
rails _2.0.2_ testrails
打开config/boot.rb看了看，根本不用比较工具就能发现mephisto0.8的文件中的确是多出一行，注掉即可
class VendorBoot < Boot def load_initializer require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer" #Rails::Initializer.run(:install_gem_spec_stubs) end end
想想，可能是因为使用edge rails来生成的mephisto 0.8的原始文件的吧
以前一直都将Capistrano 的deploy.rb的文件放在SVN中，最近需要将代码共享给别人一同开发，这才发现了有一个问题，就是我的空间帐号与数据库的密码是不希望让人知道，毕竟知道的人越少越好嘛。
而且最近做了一件傻事，就是以前我都是将
ENV["GEM_HOME"]="/home/yourusername/.gems"
ENV["GEM_PATH"]="/home/yourusername/.gems:/usr/lib/ruby/gems/1.8"
这样的配置放在dispatch.fcgi中，现在因为使用了Phusion Passenger (mod_rails)之后，这一段的内容放在了config/enviroment.rb之中，所以在windows上运行rake test时，出现了找不到gems的错误，一时没有想到了这样的问题，还费了半天的功夫:(
于是鉴于这些问题，deploy.rb原则上不需要放在版本控制中的，而且database.yml与enviroment.rb也不需要放在版本控制之中，这些文件可以另外保存，与rails代码分开，放在另一个版本控制之中，并且放在share_dir中，在部署时拷贝到相应的目录之中。
想做到这样，只需要在deploy.rb中增加一个任务
before "deploy:restart", 'deploy:copy_config'
desc "Copy the configuration file "
task :copy_config, :roles => :app, :except => { :no_release => true } do
run "cp -f #{shared_dir}/environment.rb #{current_path}/config/environment.rb"
run "cp -f #{shared_dir}/database.yml #{current_path}/config/database.yml"
end即可
自从上回 之后，ruby、rails与gems也都开始更新了，于是也更新了一下安装脚本，如下：
关于脚本的解释可以看以前 的说明，这次仅仅只是版本上的更新而已，不再多做说明
文件依然放在http://leeseon.com/private/allinstall.sh 处
也同样可以使用
curl http://leeseon.com/private/allinstall.sh | sh
来执行，无它、、、
Rails在6.1号就已经发布2.1了，这个号称参与人数最多，代码更改行数最多的版本，就这么漫不经心地来了。最近gems也发布1.2了，而且中文版本的《what’s new in rails 2.1》也基本上在网络上翻译好了，rails的社区参与度与活跃度也最来最高了，这样的rails/ruby社区怎能不越来越快？
最近依然在忙碌中度过，上来写写博文只能算是应个景儿，有点对不起自己了:(
最近一直忙于工作，居然有两周没有写blog了，不过也不是完全没有时间写，只是因为实在是没有什么时间来实践rails上的一些新东东，觉得言之无物:(
不过ruby/rails社区最近却是如大事连连：先是rails 2.1的发布，还有就是ironruby在rubinius之后也宣布可以运行rails了，这个所有ruby实现都视之为重要目标的里程碑。
一旦运行上了轨道，后面自然是一发而不可收拾噢，虽然我对ironruby的兴趣缺缺的说
只是偶然发现ruby on rails的这个名字真的很有趣，以至于我自己能生造出Running On Rails这样古怪的半通不通的双关来，算是玩笑吧:P
不是我不明白，只是这个世界变得快!
最近因为地震的原因，在网上看新闻的时侯比较多，对于ruby的新进展的了解要慢了几拍：
昨天才知道dreamhost已经开始支持mod_rails了，还写下了一篇酸溜溜的blog
今天也是通过从InfoQ订阅的新闻中得知Rubinius开始支持rails了，好消息啊，这是续它支持gems与merb之后又一重大的里程碑啊，贺之！看来以后新的rails的基于rubinius的host主机很可能会出现了，最有可能的自然是engineyard 了，只是不希望太贵噢，这样我还能试试，不过想来可能性不大:(
虽然以前Capistrno 在windows下不能使用，但是自从2.0以后，其实就是可以使用的了。而且现在的2.3还加入了对git的支持。
而且从InfoQ 上得知Tom Copeland 已经使用Capistrano来更新mod_rails了,的确如它所说，只是给这个应用程序建立了一个“restart.txt”文件，就会导致Passenger Phusion/mod_rails重启这个应用程序。的确很简单明了不是吗？
最终的deploy.rb文件看起来会象下面这样
呵呵，这个当然是好事，只可惜我一语成谶 ， 正好在DreamHost 支持mod_rails的两天之前写了两篇关于怎样在dreamhost上安装ruby、rails与gems的blog, 当然现在这些东东已经过期了，不再有用了，看来以后有什么心得就需要立刻记下来，第一为了免得稍纵即逝错过了最想记录下来的冲动时刻，第二也许我早点写出来，可能会对大家更有用，起码能让后来者少起点弯路（有点自以为的是地想）。当然做我们这么行，知识的过期是再正常不过的了，不过当年在那儿探索的苦恼与成功之后的喜悦是不可能忘却的，而且从中学到的一些东西也并不是全无用处，比如虽然有了mod_rails但是当你需要自己的gems时，还是可以自己装一份来用的嘛，只是不会再遇到我所遇到的那些莫名的 FastCGI: comm with (dynamic) server ”/home/u/domain/public/dispatch.fcgi” aborted: (first read) idle timeout (60 sec) 的挫折了，这自然是好事噢，有点不甘心地说:P
嗯，如dreamhost所说一般以domain的控制面板上多了一个Ruby on Rails Passenger的选项，勾上就好了，简单得不行了吧，不过有一点要注意，dispatch.fcgi中的代码将会永远用不到了，所以如果如我一般自己安装了gems的并有dispatch.fcgi中配置了gems的路径的话，就需要将
ENV["GEM_HOME"]="/home/yourusername/.gems"
ENV["GEM_PATH"]="/home/yourusername/.gems:/usr/lib/ruby/gems/1.8"
移到config/enviroment.rb中的ENV[‘RAILS_ENV’] ||= ‘production’之后就好了，否则可能会看到一个mod_rails提示的出错页面，无它，很简单的，不错
昨天只是泛泛谈了一下在DreamHost上安装Ruby、Gems与Rails的最简单方法 似乎有点 意犹未尽，决定写个续集，呵呵:)
好吧从哪儿说起呢？嗯，看我注释过的脚本吧，注释应该已经算是说得比较明白了，无它!
![[Valid Atom 1.0]](/images/valid-atom.png "my Atom 1.0 feed")
