joyfire: 0和1

C++0x标准确定在09年发布

Sat, 05 Jul 2008 19:14:16 GMT

　　搞定了pFind里程碑，放松下来踅摸踅摸天下大势。有段时间没跟进C++0x的进展，今天上网搜索了一下，整理出来。

　　C++委员会6月份刚刚在法国的Sophia Antipolis举行了会议（WG21）。会议的最大成果是确定了C++0x发布时间，漫长的投票表决过程总算接近结束。今年9月委员会将提交一份草案，以便公众审阅和反馈，进入ISO程序，预计12个月后正式发布。希望C++0x的这个“x”是9，而不会升到A。居然没有中文技术站点报道这么重要的新闻。

　　技术细节上，这次会议有两个最主要的features通过投票：

　　首先是传说中的Initializer lists提案（N2672 N2679），以后可以用更直观的方式初始化STL容器了：

     vector<string> v = {"xyzzy”, "plugh”, "abracadabra” };
     map<string,string> phonebook =
          { { “Bjarne Stroustrup (cell)”, "+1 (212) 555-1212″ },
             { “Tom Petty (home)”, "+1 (858) 555-9734″ },
             { “Amy Winehouse (agent)”, "+44 99 74855424″ } };

　　第二项是thread_local关键字( N2659 )。经过近一年来的几次投票，并行机制的内存模型、原子操作和线程包装的多项提案都已经通过投票，这大概是C++0x最重要的变化。

　　其实每次都会投票通过几十个features，只不过大多数没引起注意，比如我无意瞅到了一项07年获得通过的提案，是Herb Sutter代表微软提交的空指针关键字nullptr (N2431) ，这就可以用nullptr替换VC++下的NULL宏，免得每次往gcc下移植都得手工加入。

　　这次会议留下的一个遗憾是大名鼎鼎的concepts（N2081）依然在等待“check in”。

　　以上信息都依据网上来源：Bjarne Stroustrup的C++0x概述报告slices，Google的Lawrence Crowl对线程模型的报告slices, MS的Herb Sutter的BLOG、CodeGear的Alisdair Meredith的BLOG。他们都是委员会成员。另外我还找到一个旁听会议的Java程序员的BLOG，由于视角不同，难免有不少比较，比如C++委员会与JCP的异同。当然，你也可以参考正式、客观、全面但枯燥的会议记录。

J.K. Rowling在哈佛大学的讲演

Thu, 19 Jun 2008 03:44:38 GMT

　　昨晚睡前花了2小时追杀3只可恶的蚊子。在等待“嗡嗡”声出现的空隙，我重温了《哈利·波特》前两本。

　　J.K. Rowling于6月5日参加了哈佛大学2008年的毕业典礼，被授予荣誉学位，并作为特邀嘉宾做了标题为《The Fringe Benefits of Failure, and the Importance of Imagination》的演讲。老实说，我觉得她的讲演比去年BG的更有趣。当然，更公平来说，每年的哈佛毕业典礼的讲演都很精彩。

　　看来《哈利·波特》里的很多描述和感悟，例如对失败的恐惧、贫困（罗恩一家）、种族歧视、狐假虎威的官僚以及专制压迫，都源于作者的实际体验。保守的宗教团体因邓波利多校长被描写为同性恋而抵制《哈利·波特》，Rowling就此幽默了一把。

FF3下载日

Wed, 18 Jun 2008 08:18:48 GMT

　　今天Firefox 3.0正式发布。mozilla基金会号召所有开源支持者们集体行动，创造软件单日下载次数的吉尼斯世界纪录。令人惊诧的是，到现在为止，来自伊朗的下载量已经超过了16万，超过了中国和加拿大，目前排在前三位的是德国、日本和美国。

　　Firefox的最大竞争对手，微软IE团队送了个恶搞的蛋糕。说起来这两个团队的关系还算不错，总是礼尚往来。上一次，是FF团队同意IE 7使用自己的RSS图标，以利于用户体验的统一。

　　后续：最终的记录是八百三十多万次，下载量排名前10的国家分别为：美国，德国，日本，西班牙，英国，法国，伊朗，意大利，加拿大及波兰。

生物信息和创业

Sun, 15 Jun 2008 17:57:36 GMT

　　都知道我患有轻度创业妄想症，痴迷收集各种白手起家的离奇故事，狂热鼓动周围所有合适不合适的朋友下海。可俺手头的工作叫生物信息，传说中最阳春白雪，让热血青年丧失注意力的一种罕见菌类，哦不，我是说一种罕见学科。

　　所以俺总在饭碗和理想之间寻找联系。

　　以前就写过BLOG，猜测生物信息领域未来最可能的杀手应用。里面提到的23andMe其实是Google创始人的新婚妻子创建的。（Google两个创始人几乎同时结婚，娶的都是搞生物信息的博士）。今天在科学松鼠会看到一篇以玩笑口吻撰写的创业计划。笑过以后提醒你，并没有看起来那么荒谬，目前硅谷VC资助的生物信息创业公司，基本也就是这些路数。

　　关于扫描基因取得个人倾向，05年想到时还很兴奋。其实已是老生常谈。电影GATTACA里性感美女谈恋爱的标准模式，就是拔根头，然后留下联系方式，“如果对我感兴趣，打电话”。你可以拿着头发去医院里算命：如果有孩子，得心脏病的概率是多少。

　　BTW：伦理问题不是工程师的范畴，让哲学、社会学和法律专业的兄弟姐妹去头疼吧。最坏情况下，出现基因专利和昂贵的定制基因服务，就像刘慈欣《赡养人类》里的一号文明一样，富人和穷人逐渐演变成不同物种。

新闻批注

Tue, 10 Jun 2008 08:34:29 GMT

　　中星9号直播卫星终于赶在奥运会之前发射成功。卫星采用我国自主的ABS—S和AVS技术标准。

　　抛却名利虚荣，研发成果实际用起来，才是我们工程师最大的价值体现。

　　发表论文，申请专利，建立标准……最终在国计民生重要环节（例如：中国首颗电视直播卫星上的视频信源编码标准）发挥关键作用（例如：直接为奥运转播服务，卫星有47个频道，那么每年节省上千万美元的MPEG4专利费）。有机会把整个链条走完是种幸福。向曾经和正在参与AVS标准研发的弟兄们致敬。

　　攀亲戚：好歹俺也曾借调到AVS课题组做过一星期的手机播放器界面呀，嘿嘿。

　　借机抒情一把：pFind任重而道远，俺将上下而求索。

web2py和uliweb

Thu, 05 Jun 2008 06:25:52 GMT

　　先来一幅hurryto的四格漫画，再说正事。

　　Google发布GAE后，Python社区热闹起来。很多框架和开发界面在第一时间实现了对GAE的兼容。下面视频是web2py的演示。

　　appspot.com上已经冒出了很多有趣的项目。特别推荐一下uliweb。国内最出色的Python开发者limodou在试用期就得到了GAE帐号。uliweb是他推出的又一个开源项目。小建议：像web2py一样制作更多视频，最好有中英文两个版本。教学video逐渐代替用户手册和帮助文档，这是潮流。（BTW：我们的pFind Studio套件各个工具都制作了演示视频，将在新版网站上公开）

Google App Engine开放了

Thu, 29 May 2008 03:38:48 GMT

　　好消息是，登录Google App Engine后，终于不再显示请等待审批的提示。开通帐号需要手机短信确认。

　　坏消息是，兴冲冲建立第一个应用时，发现joyfire、我自己的姓名、pBuild和pLabel这些标识都已被抢了，我只抢回了pFind。哇啦哇啦。

　　说到这个，感觉第二次网络创业热潮开始降温了。之前一两年，总有域名中介联系我，希望购买lehuo.com、lehuo.net系列，单域名价格最高谈到三万。但是从今年春节以后，我就没有再接到这种电话了。看样子机会真来了，追求财务自由的虫子们，准备逢低吸纳。

Google App Engine视频

Mon, 05 May 2008 15:58:04 GMT

　　Google App Engine不顾俺三番五次申请，就是不给试用帐号。郁闷呀。

　　这里有一段视频，演示了简单的Google App Engine开发步骤。尤其是用GQL调用传说中的MapReduce海量分布式存储，看得俺直掉口水。趋势不可逆转，很快多数软件都会以ASP（Application Service Provider）方式提供服务。我很想知道微软首席架构师Ray Ozzie看到这东西是什么感觉。

　　按一般观点，类似俺们pFind这种计算密集型应用，核心模块必须使用C/C++ API，否则慢得难以忍受。然而，一旦基础架构的分布式规模达到Google所谓的“云计算”这种级别，就算有几十万张谱，也可以充分地分而治之，被分解到巨大的PC Farm里，让集群节点一对一PK，甚至进一步按蛋白数据库再细分任务。这种情况下，即使单个节点的线性效率稍差，也可以接受，可能用Python就够了（对比：按我们现在的经验，没经过精心优化的Matlab代码鉴定一张质谱大约5分钟，当然可以进一步采用各种优化加速手段，例如psyco）。到时候，最主要的速度限制也许就来自网络带宽，上传多少即时鉴定多少。

　　未来某天的软件创业故事：逃课的小孩在大学宿舍里编写了一款网路游戏（比如，也许是跑在iPhone或Android上的多人联机MMORPG），上传到Google App Engine，再到常去的论坛发个帖子，邀请大家来试玩，结果这个游戏一炮而红，Google和中国电信作为基础服务提供商，对利润进行分成。这个故事不会很快变成现实，但是也不会很慢，技术演化总是被低估。

两件大事

Wed, 09 Apr 2008 05:32:54 GMT

　　刚刚发生了两件大事：

　　第一件，俺们的pFind 2.1版的开发完成了第一个milestone，万事开头难，比计划晚了2天。

　　第二件，Google发布了App Engine，看起来很牛很得力。俺希望Guido van Rossum开发的那个传说中的Mondrian也可以加进去。

pFind新版开发启动

Sun, 06 Apr 2008 06:12:16 GMT

　　三月份大部分时间在写材料和开会。甚至出现了一个meeting week，周一到周五全都用来赶场参加各种会，最夸张的一天开了三个会，一直弄到将近23:00才散，差点没赶上5号轻轨末班。

　　上周终于着手2.1新版设计。鉴于大伙儿元气大伤，取消了setup会议，单独找每个人面对面交流再汇总Todo List。

　　周三下午，把电脑和投影仪搬到会议室里，直接对着代码展开第一个模块的设计。双人编程，正确说，应该是四人编程，推敲所有细节，甚至明确参数命名。一开始当然有点痛苦，各人都没有特别细致的思路，更别提大家的一致。不过几个回合重构下来，最终一版的空模块（只定义了接口和架构）编译通过，每个人都很开心，团队的信心和士气提高了不少。这不仅因为完成了第一个里程碑，还因为统一明确了设计原则和质量底线，后续设计工作照方抓药就可以了。磨刀不误砍柴工，设计阶段精耕细作从来都不会白费。

　　上周的另一件事是继续调试2.0老版本。多谢chh支援，困扰两个多月的BUG总算有些眉目：第一组实验中，碰到一个变态的蛋白，修饰位点组合爆炸，出现九千多万种可能性，把递归程序撑爆了；第二组实验中，为压力测试调大了参数，有个地方的vector容器装不下。把两个地方剪枝条件加强就解决了。折腾这么久，真算职业生涯的奇耻大辱。搞到最后老板都不好意思问了；反而是老妈每晚的餐桌上都关心进展；去参加文献club，生物学家也问“你的BUG怎么样了”。

　　另一方面，由此看来，老版pFind的潜力也就仅限于此了，稍微上点数据量就开始这里那里到处漏水。这也正是彻底重新设计架构，开发2.1版的主要原因。

　　我预计新版的C++代码可以从18万行降到10万行左右，速度提高一倍以上，而海量数据的处理上限，可以有不止一个数量级的提升。当然新版的一个重要变化是实现跨平台，为将接下来的分布式集群打基础。

关于C++的ABI

Sun, 23 Mar 2008 10:39:11 GMT

　　如果要给最头疼的C++特性投票，我会选ABI兼容：C++标准没有明确跨编译器的二进制兼容，于是各个编译器的实现都不同。用VC在Extension Dll里实现一个类，到了gcc代码里就不能直接调用。这带来了很多麻烦，尤其在有移植和平台兼容需求的大项目里。最近我的项目进行下一步规划，就为培训新手挠头。

　　更糟的是，这还导致其他编程语言不能简明地“胶合”C++：大多数编程语言的编译器或解析器都是以C/C++实现的。按理说来，在这些语言中调用C++的类应该是很容易实现的天然属性。但是正由于ABI不兼容，这些语言要支持C++二进制调用就必须先选择编译器：到底是支持VC还是gcc？因此很多语言避开C++，以纯C形式的动态链接库（Windows下就是Regular Dll）作为对外胶合的二进制接口。这进一步影响到不少混合语言项目选用C而非C++与动态语言进行高低搭配。

　　作为实现“底层硬核”的系统级语言，C++的调用接口这种基础机制不理想，负面影响有些大。

　　当然也有不少对应的解决方案。最有名的是COM，它利用类似虚函数表的方法，建立语言无关的接口兼容模型，微软把Windows系统的几乎所有的模块接口都变成了COM，比如ActiveX和DirectX。还有其他一些常用方案，像SWIG。普通一点的方法是用C语言接口做桥接。

　　前几天刘未鹏征求中国程序员给B.S.的问题，俺问ABI标准啥时候有指望。据说问题的关键不是技术，而是C++标准委员会各大厂商间的政治原因。

　　BTW：最近玩D语言，本来就是一帮C++高手另立山头搞出来的，自然是针对后者的软肋作改进，目前看起来的确很美好。不过二十年前C++刚从C里面蜕变出来时，看起来也很美。路漫漫其修远兮。

Mondrian视频

Mon, 25 Feb 2008 14:21:59 GMT

　　Google Tech Talks上的好东西很多。

　　TopLanguage上有人推荐B.S.的C++0x Initialization Lists视频，本打算上来写点观后感的。可又被Python的东西吸引过去，最终还是强烈推荐Guido Van Rossum的这个讲座，这是他被Google挖去后负责的项目。

　　此外还要推荐这段BayPIGgies: Developing A Product In Python。

　　BTW：一个冷笑话，“UC Berkeley的工程师管Stanford的工程师叫什么？”，正确的答案是：“老板”

返璞归真

Mon, 18 Feb 2008 18:34:12 GMT

　　过去一年左右，听过的最有收获的技术讲座，就是阿北的和云风的。

　　两人都是骨灰级程序员，阿北写过将近20年的程序，云风C++经验也超过15年；都是一线架构师，在相对自由的环境下，按照自己的思路，架构一个完整的大系统。所以尽管他们开发的是不同产品，用的是不同技术，讲座内容听起来居然有某些相似：把握技术的方向感，设计上的返璞归真。

　　其中不少一带而过的设计细节都会引发我的兴奋和一点遗憾：兴奋缘于共鸣，而遗憾则因为“如果早两年前能明白……”。不过反过来说，很多事只有躬身入局试过才能真正明白，否则就是听到了也会放过去。

　　春节闲翻书，又读了一遍Conversation with I.M.PEI。贝聿铭从名校毕业后，有十一年都专做贫民区改造项目。这阶段的工作在师友看来有些低档，但是他自己认为非常重要：因为他借此熟悉了社会是如何运作（这一类项目，大多和政府法令和补贴有关，所以必须学会跟着老板去和政府官员和媒体打交道），学会了在受限的条件下作出最合适的设计方案（书里举例说明当时如何想方设法，既能设计出完美的建筑，又能满足严格的成本限制）。通过这些磨练积累，才有了后来的卢浮宫金字塔、香港中银大厦、香山饭店和伊斯坦布尔博物馆。

　　国内软件业正在发生变化。一大批工程师已经积累了“贫民区改造项目”的经验。一旦这些人得到环境的支持，拥有了独当一面自由发挥的机会，就能做出真正有趣有影响力的设计。接下来几年俺们等着瞧吧。

混合编程的前世今生

Sat, 16 Feb 2008 13:21:56 GMT

　　老妈在玩Python语言，她说Python简洁严谨的风格很像Fortune，“不像C++那么乱哄哄”。从穿孔纸带开始，老太太算是各种技术都经历过一遍了。虽然比不上她老人家，俺用来赚过银子的编程语言，从本科大一兼职开始算，也有十种以上了。

　　说起不同的编程语言，就掺乎到Language Wars，历来是吃力不讨好的大坑（Joel on software有一篇很经典）。最近几年的趋势是混合语言编程，用静态语言实现关键模块，用动态语言做胶水，必要的时进一步用DSL归纳特定领域的高效开发模式。

　　Google一下，原来很早就有牛人预计到了这种趋势，看看John K. Ousterhout在10年前于IEEE Computer发表的这篇论文，不得不佩服他眼光很毒。其中关于gluing language和component frameworks的提法，如今已经成为业界的标准术语。

　　最初的潮流推动者是微软，早期VB正是一种经典的胶水语言：从Web到Office，从ActiveX到DirctX，Win32系统中几乎所有功能模块和技术特性，用VB都可以轻松整合。即使用今天的观点来衡量，VB6.0 / VC++6.0这一对仍然堪称黄金搭档，整套架构以COM技术为核心基础。只可惜.net技术推出后，VB突然莫名其妙地失去了定位，有一阵似乎希望变成“另一种C#”，不断向系统级语言演化，反而让老用户无所适从。等明白过味儿来，.net 3.0不得不从头引入新的IronPython。

程序员日快乐，哈哈

Thu, 14 Feb 2008 05:32:23 GMT

　　云风在BLOG上说了一个冷笑话，好寒啊，果然deepcold。

　　说点严肃的。云风提到的ENIAC，《程序员》杂志上专门澄清过，它不是第一台电子计算机：美国法院对于计算机发明权的归属展开了多年法庭调查，在1973年作出最终宣判：第一台电子计算机是由依阿华州立大学的物理学家约翰·文森特·阿坦那索夫于1939年发明的ABC，而不是ENIAC，后者对ABC有明显的抄袭。ENIAC的发明人虽然因抢注专利获得了暴利，但此前由所谓“计算机之父”而得来的各种荣誉大多被陆续取消。

Tango Tina文档翻译完了

Mon, 11 Feb 2008 17:26:38 GMT

　　Tina文档的翻译完成了初稿，Tango的网站管理员刚刚在文档类表和wiki上添加了这篇BLOG的链接。当然这还只是粗坯，不少地方需要进一步修饰甚至推倒重来。

　　尽量保证每晚都抽出一小段时间，先校对前一天的内容，再翻译下一段，蚂蚁搬家。不算太长的文档，总共用了两个月，比原计划久一些。到底是第一次，年底这段时间工作压力也比较大，又碰到骨折受伤、出差和私事影响情绪，效率和质量都不算完美。不管怎样，能坚持下来挺有成就感。

　　人家问我是否继续翻译手册的其他各章。我打算先休息一段，至少等到骨折完全恢复再说。还会继续踅摸D语言，希望与有兴趣的朋友互相交流，大家也可以分工合作进行翻译。

　　BTW1：石膏已经拆了，经过这几天，机能基本恢复了，不用担心变成周总理那样，偶尔还会疼，腰椎扭伤也需要休养。谢谢大家的关心

　　BTW2：好吧俺承认，胳膊的确是滑单板摔断的：南山今年开了一条很长很好玩的新雪道，也许是傍晚周围的景色比较容易分散精力，呵呵。估计老板也猜出来了，没点破。话说回来了，我也没误事，吊着石膏就去出差了，差点让大雪留在上海过年。

2007年图灵奖颁发给Edmund M. Clarke，Allen Emerson和Joseph Sifakis

Sun, 10 Feb 2008 15:18:15 GMT

　　ACM官方网站上刚刚发布了如下消息：

　　ACM, the Association for Computing Machinery, has named Edmund M. Clarke, E. Allen Emerson, and Joseph Sifakis the winners of the 2007 A.M. Turing Award, widely considered the most prestigious award in computing, for their original and continuing research in a quality assurance process known as Model Checking

　　关于Model Checking的背景知识可以参考wikipedia。另外CSDN有牛人推荐这篇介绍。还有g9老大的博客。

　　记得本科上《程序设计方法学》课，彻底晕菜，对于“程序正确性证明”、“程序的形式推导”和“程序变换”什么的基本没听懂。不过成绩居然挺好，也不知是怎么考出来的。

Google Tech上关于Python 3000的讲座

Sat, 09 Feb 2008 13:24:12 GMT

　　D语言新闻组里刚刚转载了Google Tech Talk中关于多线程的讲座，跑去搜索，又发现了不少其他内容。

　　下面这是Guido van Rossum于06年初介绍传说中的Python 3000。过了一年半，前几天刚发布了alpha 2，估计final版发布得等到奥运会之后。

　　就像上次说的，站队很重要，我的技术储备大多押宝到Google。看看Ubuntu、Firefox、Python、AJAX这些年的成长轨迹，就能知道Google在引领技术趋势方面的能量。这种对软件工程师的绝对影响力曾经只属于微软；而现在的微软，越来越像OS/2年代的IBM了（多久没关心软件业从XP向vista的迁移了？）。这并不意味着微软不行了，它仍然是最赚钱的蓝筹股，只不过，它不再是那个让人闻风丧胆所向披靡的怪物了。

最常用的软件

Sat, 26 Jan 2008 03:10:38 GMT

　　先列出自己常用的软件或网络服务：

MS Windows XP操作系统
Firefox浏览器
Google & Baidu搜索引擎
Google Reader种子订阅器
Gmail邮件
Sina & Sohu新闻
Safe360系统安全
Windows Live Massenger & Spaces即时通讯和博客
金山词霸
Google Doc文档编写

　　大部分是MS和Google两强推出的。Windows的地位仍然不可替代，但Google的网络服务动摇了MS其他Killer Applications。我并不是反微软的意识形态分子，替代大多是被迫完成的：

　　逼我改用Firefox的，是漏洞攻击、病毒、木马、强制安装和弹出广告。前两天微软无条件允许XP用户安装IE7，试了试感觉不错，但已经用惯Firefox插件了。

　　没列MS Office自己也很惊诧。半年前如果要打赌，我绝不会押这个。合作伙伴生物学家经常这样用Google Doc：一个人去韩国参加人类蛋白质组大会，另一个留在家里做实验，两人一起上Google Doc合作修改论文，通过页面里的AJAX聊天功能交流，必要时回滚到之前某个历史版本，开会机器坏了，换一台上网继续演示幻灯片，甚至在手机上……俺就逐渐被忽悠过去了，有一天Windows提示：“桌面上有长期不使用的图标……”

Google研发经理的职位要求

Sat, 19 Jan 2008 16:35:22 GMT

　　胳膊断了以后写的代码就明显少了，情绪也显得焦躁。这周唯一一次放松，是老娘学JAVA，写一个SWT小界面，跑不通，从MSN上喊我过去帮忙调程序（就隔一道门，喊一嗓子呗，俺也觉得很变态）。反过来，现在老板不好意思严厉要求俺，肆无忌惮迟到早退，有更多机会思考、上网和交流，为下一版的pFind开发做准备。

　　搜索有关python的东西，Google在页面顶端明显地放置了招聘广告，点进去瞅瞅自己能卖多少钱一斤肉。

　　看得出来Google是懂行的，知道什么人是真正的高手（废话，人家不懂谁懂）。有趣的现象是MS和Google都投资于Python，而ThoughtWorks倾向于Ruby，（可怜的PHP跟错了Yahoo!）。下面是Google北京公司的Tech Leads/Managers职位要求：

CS degree strongly preferred.

Strong programming capabilities in at least two of the following: Java, C++, and Python.

Very technical and technologically savvy.

Strong distributed systems and architecture knowledge, and experience with multi-tiered mission-critical systems preferred.

Substantial knowledge of UNIX/Linux or Windows environments.

Capable of working closely with product management to ensure we're building the best products.

Excellent communication abilities in both Chinese and English.

Strong leader capable of motivating and energizing the very best software engineers, as well as gaining their respect.

Ability to manage a team of 6-12 software engineers, including task planning and code reviews.

Demonstrated expertise in problem solving and technical innovation.

Proven ability to share knowledge with more junior team members via a formal mentoring relationship, reviewing code, reviewing design docs, giving technical talks, teaching classes, or as a consultant on projects.

5-10 years experience (including time working towards advanced degrees and/or experience).

Google Trends上的编程语言

Thu, 10 Jan 2008 09:12:24 GMT

　　看看Google Trends上C++,Java和C#三种语言的查询统计。你能挖掘出什么结论？

c++ java c#

Java仍然拥有绝对优势，C#在上升，C++在缓慢下降；
印度的软件工业的确很强大；跟在后面的是俄罗斯、波兰、台湾地区、罗马尼亚……世界是平的

　　再看看国内的情况：

c++ java c#

西安软件园不声不响，但实力不容小视，深圳的软件工业也很强大，传说中的大连其实还需时日；
三个黄金周假期，有意思。

gmail广告

Tue, 01 Jan 2008 17:02:43 GMT

　　刚注意到gmail右边自动显示的个性化广告。google的文字分析和聚类算法还真有效果。

　　我这封邮件内容都用汉语，唯一可利用的信息就是提到了IPI:Human库。如果不是关键词购买，那么这种关联应该是从互联网内容上自动挖掘出来的。海量存储和计算是未来真正AI的基础。

　　点进去看，几个公司站点上从DNA、RNA到Protein软件都挺全。生物信息领域小公司不少，竞争很激烈。大家都还没找到合适的Killer Application和商业模式。

Tango Clusters中文翻译

Thu, 13 Dec 2007 17:20:53 GMT

　　这是占位贴。最近在玩D语言，我手头马上面临的工作又和集群运算有关，所以自然对Tina格外关注。因此准备把Tango库文档的Clusters这一节翻成中文，每天逐步翻译一点。这是件需要毅力的事，所以预先昭告天下，断自己的后路。

　　向不太熟悉的朋友简单介绍一下：D语言的官方标准运行时库是phobos，而Tango是目前比较完善的第三方类库，Tina是后者集群部分中QOS的一个参考实现（你也可以继承有关interface，自己实现QOS组件，见下文）。你还可以到dsource.org上查找更多D语言的类库、代码实例、开发工具和开源项目。除了phobos和Tango两个类库，dsource.org上另一个常用项目是dsss工具包，它用于配置、编译、安装D语言的整套开发环境，自动处理phobos和Tango并存的兼容性问题。刚结束的D Conference 2007上有Tina（ppt和pdf）、dsource.org（ppt)和dsss（pdf）的专题讲座可供参考。

Tango Clusters

　　（原文地址：http://www.dsource.org/projects/tango/wiki/ChapterClustering，版权属于原作者）

　　（中文译文转载，请保留http://joyfire.spaces.live.com地址）

　　Clusters就是电脑集群，我们认为，所谓“集群”是指，同处局域网内，分布执行关联任务的一组电脑。很多种应用都能从分布式获得好处；具体来说，相比于单机架构，分布式的设计将给应用程序带来更好的可拓展性。

　　例如，集群常常用于高性能计算：通过把大块的计算量分解到网络上的多个从机，一个计算密集性的应用能相当有效地提高计算量，或减少计算时间。按需求情况可以把更多从机加入集群。如果原有硬件脱离了集群，其他从机可以分担它的任务。

　　另一个例子是分布式保存某些需要频繁读取的数据，通过集群向一组客户端提供快速读取服务。这种设计的典型意图是缓解对关键单点（例如数据库）的抢占，以提高系统整体的计算能力。

　　再进一步的例子，是设计能力不可能应付请求的极端峰值的应用系统。这些系统需要一种机制来缓冲请求，而不是即时响应处理。在某些特定情况下，应用系统会把请求持久化存储起来，等到更合适的时机再去真正处理。虽然这可以通过数据库或类似方式实现，但更轻量分散的方式也许更适当。尤其是当吞吐量很敏感的情况下，数据库本身就可能会成为瓶颈。工作流系统就倾向于这种风格的缓冲方式。

　　以上所有场景，集群都有用武之地。Tango库支持很有吸引力和灵活性的集群模型，以帮助你不费太多事就可以构建这种应用，

　　作为使用体验，这里有一段在集群上执行expression任务的D语言代码示例：

real add (real x, real y) {return x + y;}

void main (char[][] args)
{
scope add = new NetCall!(add);
Stdout.formatln ("cluster expression of 3.0 + 4.0 = {}", add(3, 4));
}

可适用性

　　Tango工具包把集群的常用行为归纳成4种类型加以支持：消息队列，消息缓存，消息执行和消息广播。对应这4种行为的实现机制分别是queue, cache, task和bulletin。

　　基本概念为，你在一台或更多联网的计算机上启动一个或更多cache、queue、task服务器端实例，通过一个或多个集群客户端来调用它们。这些客户端链接入（link）你的应用程序，使其可以使用各种集群功能——它帮你的应用管理集群通讯，提供各种失败情况下的强大容错能力。总之，若干客户端会与潜在的若干cache、queue、task服务器端通话。

　　衡量集群应用是否成功的一个关键因素，就是看它对以下情况的鲁棒性：瞬时的传输拥塞，变化的反应延时，集群成员节点的增减（包括潜在的硬件错误）。评价因素还包括效率，既有选择的通讯中介的效率，也有应用实体在集群中转移的传输效率。

模型和QOS

　　Tango集群用由D语言的interface和工具class组成的模型来描述。这种设计的目的是，使不同的集群实现方式都拥有一个相同的模型，稍做微小改动就能切换到另一种不同的实现方式。为什么要有多种不同的实现方式？因为不同的应用有不同的需要——有的认为吞吐量是绝对重要的，有的认为数据的复制更需要重视，还有的可能需要某种特殊行为。

　　也就是说，该模型打算跨越各种不同需要和实现。不同的需要和实现要用到不同的服务质量或QOS。若一个集群应用程序同时使用多种QOS实现，以满足不同的目标，也是完全可行的。

　　为了加入集群，应用程序需要一个QOS客户端实例。通过这一点，所有活动都能被模型的工具class纳入管理。也就是说，QOS是一个单独的、公平的、简洁的、几乎透明的组件。模型的工具class在此之上提供附加行为。

　　该模型本身受到了一些现存系统的影响，包括hints的发布和订阅、Linda、JavaSpaces等，还有其它一些你可能已经熟悉的系统。

接触Tina

　　类库提供的一组服务就是一个内置QOS实现，以便快速开发集群应用。它主要由三个服务器端构成，这三个服务器端分别支持cache、queue、task三种集群服务方式。另外它还包括与服务器端相关的集群客户端的实现。前者（服务器端）是独立的、有自己权限的应用程序。而后者(客户端)要链接到你的应用程序里，以使集群对它可见。Bulletins是彻底由客户端实例操作的，在对等（P2P）方式下不存在bulletin服务器。

　　Tango用D语言源码module来描述服务器端，同时提供完整而简洁的代码作为构造相应服务器的例子。客户端通过一个class暴露给用户调用，应用程序实例化这个class就可以了。两者结合，让你快速简单地构建出应用系统的专用集群。

　　这个内置的QOS是面向高效连接的，其重点是避免任何堆积行为（除在cache hosting这种必要情况下）。它既平衡了传输中的TCP/IP和多播，也平衡了序列存储中的磁盘文件。它有个爱称叫Tina，应用程序使用Tina，需要import tango.net.cluster.tina.Cluster

关键概念

　　无论任何工具包，为了发挥它最大的功效，都需要熟悉一些关键概念。这些概念不多，我们会在这一节里专门解释。首先从频道（channel）开始。

频道（Channel）

　　如果使用过发布/订阅系统，对频道的概念应该比较熟悉。频道是消息传输和交付所通过的实体的名字。集群应用订阅（或监听）频道，发布（或写入）频道。没有它就无法与集群进行通讯。你向QOS提出要求，由它代表你创建一个频道，此后就开始使用。实际上，模型里有很多躲在后台的工具class为你实现频道的创建。然而，你可以在需要时自由使用频道。

　　有了频道，应用就可以发送或请求集群消息，监听异步行为，在网络里执行任务。模型里的很多工具class在此基础上提供出一个结构化的框架，在适当的地方添加进一步价值。

　　当一个消息(message)被一个命名频道送出，只有监听同一个频道的候选者才接收到这个消息。频道的名字必须在所有通讯地点保持一致：这样就提供了隔离不同目的的不同类型消息的基础。实践中我们发现，使用点分隔符号的频道名字（例如employee.contact.information）非常方便，易于对消息类型区分和聚合。实际上频道是描述D语言class的好方法——每个频道对应一个独立的class——它非常精细地隔离了彼此不一致的内容，显著简化了集群自身相互间聚合数据的传输。刚好，接下来要提到的概念就是消息。

消息(Message)

　　消息是所有集群上下文的基础。你向queue存入东西，是以消息形式发送的；从cache恢复内容，其实也是接收一个消息；当在集群中执行task，它表达为消息；当异步多播的bulletin在集群中分布式交互时，它们就是消息的实例。总之集群里的一切都是消息。

　　当用D编程语言，每个集群消息都被实现为一个class。进一步的，所有消息或继承于NetworkMessage工具class，或实现了IMessage接口（interface）。消息实例被转换成网络协议包，在集群之间传输。

　　有一个模板能用来为你很方便地生成一小段代码，负责消息和网络协议包之间的相互转换；另一种办法是通过实现两个简单的消息方法来明确控制转换行为。如果你使用模板，所有本地数据都被加入用于发送和恢复的消息；如果只处理消息的一部分，就要通过两个预订（译者注：回调或委托）方法对如何转换进行干预。

　　所有消息变量默认都要注册。也就是说，为了让集群客户端能正确重建输入消息，每种消息类型都必须在应用启动时提交给NetworkRegistry。有一种特殊情况不需要注册——task不要求客户端注册，如果你明确提供了输入消息的主机，就不用注册了。然而，注册你应用中用到的所有消息类型是种好习惯。消息的静态构造函数是个适于注册的位置。例如：

import tango.net.cluster.NetworkMessage,
tango.net.cluster.NetworkRegistry;

class MyMessage : Message
{
        static this()
        {
                NetworkRegistry.shared.enroll (new MyMessage);
        }
}

　　除要求注册以外，每个消息就是一个标准的D语言class，可以以一般形式进行操作。它仅仅是拥有了一种附加能力：可以在集群上的其他机器出现并随意行动。

队列（Queue）

　　queue是消息的贮藏。每个queue都有自己的频道，即被队列化的频道会有单独的queue实例。消息通过频道行为存入queue，再以相同方式从queue恢复。这些操作是同步方式。与此不同，消息的消费者（频道的订阅者）能以异步方式监听消息行为，当queue存在变动，就把消息提供给它们。两种方法都有自己的优势，由你自己选择。

　　queue内的消息不单独设定地址；当你查找一个消息，不能指定与请求有关的特殊值。queue把单独的频道名字隔离起来的，没有任何其他元数据。

　　queue消息既可以在无进一步动作的情况下被消费，也可以有返回。典型的返回通过另一个频道发送（对原始频道的名字做修改），在始发者接收前，返回消息经常被队列化。始发者要监听返回，监听方式与订阅其他队列化消息一样。

　　queue是持久化的，可以经受电力故障和重启。

缓存（Cache）

　　Cache主机以非常类似联合数组或哈希表的方式存储消息。消息用频道名隔开，以键值进行检索。在Tango里，这个键值是char类型的数组。

　　放在集群cache里的消息会被同一频道中拥有相同key的实体替代。进一步，用有条件的时间戳来控制对＂新＂的检验。后者在分布式环境下是重要有用的。这种环境下，也许会出现cache更新冲突。cache实例会自动清除旧的实体，以便为新的内容释放必要空间。

　　通过使用模型工具，集群的cache可以进行部分本地复制。这个机制模拟了经典的level1/level2 combination，这会对很多应用程序都有用。模型工具还使保持一组cache实例的一致变得容易。

　　Cache实例仅仅打算临时驻留在内存里，即Tina的实现不对它们进行持久化保存。

任务（Task）

　　task是可执行的消息，在调用进程以外执行。通常，task会发送到集群中的某个能执行该任务的服务器端上去，执行后把运行结果返回给调用者。这是一个同步方式的执行模型。对于去耦(decoupled)执行模型（译者注：异步方式），任务可以先发送到一个queue上挂起，直到有订阅者恢复并执行它。这种模型下的返回一般通过另外一个queue发送，和一般的queue消息返回方式一样（参考前文的queue）。

　　相比其它消息类型task有些独特性，因为它是主动消息，不是被动的。和queue或cache里面躺在那里等待相比，task消息是打算要在集群里面干点什么。这意味着，task消息为了这个目的必须实现execute()方法。有一种被称为expression的task，仅由一个简单的函数构成。这种任务可以被NetCall模板转化成一个真正的task实例，这个模板吧函数当作参数，返回一个task实例。这篇文章的开头演示了这种用法。

　　task消息另一个独特之处在于，它应该在集群上被注册。这就意味着task消息是每个task服务器端的主要组成部分，以便可以在服务器端被执行。实际上，有两种主要的可选方式：把task消息静态链接到每个task服务器端，或动态发布并链接到每个task服务器端。请注意，现在D语言并没有在所有平台上都实现动态链接，所以默认Tina实现task是采用前者——注册task服务器，注册的内容是端口和方法调用。

公告（Bulletin）

　　这是一种发送给对所有集群成员的通知消息类型，它调用能用到的最有效的底层机制。这种消息的大小尺寸受到限制（一般小于1K），它本质上就打算简单和轻量级。Tina QOS使用bulletins来进行cluster发现，queue活动通知，cache同步，用广播作为分布式机制。当一个bulletin被发送，所有同一频道的监听者都会接收到。

　　bulletins的应用层潜在用途是通知所有监听者关机。这种方法用来确保所有服务器端实例在相同版本下运行——新版本被写入中心位置，然后批处理任务通知服务器端重启，无论它是否已经被停止过（以改用新版）。

推 Vs. 拉（Push versus Pull）

　　Tango集群支持两种访问内容的形式。cache或queue内容的请求是同步调用，也就是常说的拉（pull）模型；另一方面，创建queue活动或bulletin的监听者使用异步通知，就是所谓推（push）模型，若没有明确订阅某种特殊消息，内容就不会被推给的该接收者。

　　类似同步要求，异步的push通知在特定的频道上进行传输：你得到你想要的，没有其他多余的。push和pull的主要区别在于，前者可能出现在一个独立的执行线程中，所以你必须了解一般多线程情况下可能碰到的潜在问题（例如对共享资源的同时访问）。

　　当通知出现时，到达的内容和输入的消息通过变量形式传送给监听者。大多数情况下，到达的消息是描述一个通知内容的单独实体。然而，queue通知会集中传输一个或多个序列消息。

客户端使用

　　在这一节我们通过代码例子看看如何使用集群功能。首先需要import适当的集群。在以下这些例子里我们会一直使用Tina QOS，但对其他实现要import对应的包取而代之。注意这里主要关注客户端，服务器端在后一节介绍。

Cache客户端

　　这个例子演示如何把cluster作为分布式cache使用。这里仅仅演示了主要概念，还有其他很多可用的操作。注意我们把命令行参数传输给join()方法：为cache设置一组有效可用的cache实例。和其他设施不同，cache实例不是自发现的（self-discovering）。

import tango.net.cluster.NetworkCache;
import tango.net.cluster.tina.Cluster;

void main (char[][] args)
{
        if (args.length > 1)
        {
                // hook into the cluster
                auto cluster = (new Cluster).join (args[1..$]);

// hook into the Cache layer
auto cache = new NetworkCache (cluster, "my.cache.channel");

// add a cache entry to the cluster
cache.put ("key", cache.EmptyMessage);

                // retrieve it from the cluster
                auto msg = cache.get ("key");
        }
        else
                Stdout.formatln ("usage: cache cachehost:port ...");
}

Bulletin客户端

　　怎样通过集群发送和接受通知。这些通知被发送给某个特殊广播频道的每个监听者。注意我们创建了一个回调函数，传给集群作为bulletin的消费者。

private import tango.net.cluster.NetworkAlert;
private import tango.net.cluster.tina.Cluster;

void main (char[][] args)
{
// hook into the cluster
auto cluster = (new Cluster).join;

// hook into the Alert layer
auto alert = new NetworkAlert (cluster, "my.kind.of.alert");

        // declare a listener
        void listen (IEvent event)
        {
                event.log.info ("Received alert on channel " ~ event.channel.name);
        }

// listen for the broadcast (on this channel)
alert.createConsumer (&listen);

// and send everyone an empty alert (on this channel)
alert.broadcast;

// wait for it to arrive ...
Thread.sleep(1);

}

Queue拉客户端

　　下文演示怎样在同步模型下安装和使用queue。我们把一些东西放入queue，然后再恢复出来。

private import tango.net.cluster.NetworkQueue;
private import tango.net.cluster.tina.Cluster;

void main (char[][] args)
{

// join the cluster
auto cluster = (new Cluster).join;

// access a queue of the specified name
auto queue = new NetworkQueue (cluster, "my.queue.channel");

// stuff something into the queue
queue.put (queue.EmptyMessage);

// retrieve it synchronously
auto msg = queue.get;
}

Queue推客户端

　　这里演示如何在异步模式下安装和使用queue。我们把监听者委托（delegate）给集群，当订阅的内容从集群任何地方到达queue，监听者就会被调用。

private import tango.net.cluster.NetworkQueue;
private import tango.net.cluster.tina.Cluster;

void main (char[][] args)
{

// join the cluster
auto cluster = (new Cluster).join;

// access a queue of the specified name
auto queue = new NetworkQueue (cluster, "my.queue.channel");

        // declare a listener
        void listen (IEvent event)
        {
                while (event.get)
                       event.log.info ("received msg on channel " ~ event.channel.name);
        }

// listen for messages placed in my queue, via a delegate
queue.createConsumer (&listen);

        // stuff something into the queue
        queue.log.info ("sending three messages to the queue");
        queue.put (queue.EmptyMessage);
        queue.put (queue.EmptyMessage);
        queue.put (queue.EmptyMessage);

// wait for asynchronous msgs to arrive ...
Thread.sleep (1);

}

Queue返回客户端

　　在这个不同的版本中，我们把消息存入集群中的queue，通过监听者接收到它，再从另一个不同的频道发送对该消息的返回，最后接收返回值。这个例子用到了两个监听者。

private import tango.net.cluster.NetworkQueue;
private import tango.net.cluster.tina.Cluster;

void main (char[][] args)
{

        // open the cluster and a queue channel. Note that the queue has
        // been configured with a reply listener ...
        auto cluster = (new Cluster).join;
        auto queue = new NetworkQueue (cluster, "message.channel",
                                      (IEvent event){event.log.info ("Received reply");}
                                      );

        void recipient (IEvent event)
        {
                auto msg = event.get;

                event.log.info ("Replying to message on channel "~msg.reply);
                event.reply (event.replyChannel(msg), queue.EmptyMessage);
        }

// setup a listener to receive and reply
queue.createConsumer (&recipient);

// toss a message out to the cluster
queue.put (queue.EmptyMessage);

// wait for completion ...
Thread.sleep (1);

}

Task客户端

　　集群task的执行一般由三个参与者组成。首先，我们需要创建task自己，它一般在一个单独的模块里。在下面案例中，我们示范前面提到的expression task。

module Add;

real add (real x, real y)
{
return x + y;
}

　　第二步，我们需要在客户端应用程序里import这个task并使用它。我们用NetCall()模板来外覆自己的expression task，把它转化成一个集群消息。

import Add,
tango.net.cluster.tina.ClusterTask;

void main (char[][] args)
{

scope add = new NetCall!(add);
Stdout.formatln ("cluster expression of 3.0 + 4.0 = {}", add(3, 4));

}

　　第三步，我们需要把同样的task加入task服务器端，以便其可以在集群中被执行。这里演示怎么创建并配置可执行的task服务器端。

import Add,
tango.net.cluster.tina.TaskServer;

void main (char[][] args)
{

// handle command-line
auto arg = new CmdParser ("task.server");

// create ourselves a task server
auto server = new TaskServer (new InternetAddress(arg.port), arg.log);

// and configure it with our task(s)
server.enroll (new NetCall!(add));

// start the server
server.start;

}

Tina

　　Tina 是默认的QOS实现，为处理queue、cache和task请求提供了三种不同的服务器端。它的源代码以工具包的形式提供，用户针对具体需要对每种服务器端进行配置。当然也有示例程序的支持，通过这些例子，可以单独编译构造各种工作服务器端。这些示例代码都是服务器端功能性的一些琐碎的前端处理，所以上手有些困难。例如这是qserver.d全文：

import tango.io.Console;
import tango.net.InternetAddress;
import tango.net.cluster.tina.CmdParser,
　tango.net.cluster.tina.QueueServer;

void main (char[][] args)
{
        auto arg = new CmdParser ("queue.server");
        if (args.length > 1)
            arg.parse (args[1..$]);

        if (arg.help)
            Cout ("usage: qserver -port=number -log[=trace, info, warn, error, fatal, none]").newline;
        else
           (new QueueServer(new InternetAddress(arg.port), arg.log)).start;
}

　　每种服务器端都有一套命令行参数，以配置所有日志数据和服务器端口数目。如果不指定这两个参数，就按照默认进行设定。所有集群的示例都放在tango/example/cluster文件夹，其中引用的module会在接下来讨论。

Queue服务器端

　　queue的配置简洁明了：编译示例qserver.d模块然后启动它。每个queue被写入服务启动的目录中的独立文件里。这意味着两个独立的queue服务器端不能存放在同一个目录下，因为queue文件不能被共享。想在同一台机器上实例化多个queue服务器端，必须在不同的目录启动它们。

Cache服务器端

　　cache的配置也很简单：编译示例cserver.d模块然后启动它。当使用Tina时，cache客户端需要一组“服务器地址：端口号”对，作为一组有效cache服务器端的唯一标识。这种标识是必须的，这是由分布式算法的基本属性决定的。例如，若客户端启动时，所有cache实例并未全部运行，那么在整个集群范围内就有可能存在这种潜在问题：各个客户端看到的cache不一样。这意味着，当每个cache服务器启动后，必须记录它选择的端口号，或者直接给它配置指定的端口号。记录的标识列表应该在cache的客户端启动时提供给它们。

Task服务器端

　　Task服务器端采用一种不同的机制。由于目前D语言对编译后模块的动态链接的支持还很有限，还不能通过集群实现task代码的动态发布。

　　目前，我们必须在每个server上都import各自的task代码，以便调用。这意味着，每个task应该位于单独的pachage或module里，与客户端和服务器端都分开，以便后两者都能import。在Tina QOS中，使用task类的全名作为关键字来匹配集群里的执行请求。这里说的“全名”包括module名，也就是说客户端和服务器端必须import完全相同的task modules以便名字完全匹配。

　　一般情况下，若没有特殊原因，在独立的module里实现每个（组）task是一种易于代码维护的好习惯。

日志

　　Tina里的服务器端都用到了Tango的日志系统以报告行动。默认情况下，日志内容仅在控制台输出，但通过调整服务器设置，可以把日志导向文件等各种其他目标。主机应用会为每个服务器端提供一个logger实例用于存放配置信息。更多细节请查看有关日志的文档。

技术注释

　　下面这些编程关键点可以帮你发挥集群工具包的最大功效。

线程

　　集群的监听器天然就是异步的，是与主程序分离的一个独立线程。当一个bulletin通知到达(推)，监听器唤醒委托的客户端，传入必要的信息，以便客户端读取输入消息。

　　当消息到达时，由客户端采取必要措施以确保后续动作的正确性，这本质上就是一个多线程应用。若要连接一个事件子系统，我们也可以加入一个模块，把异步的通知转化为事件。后一种情况下，所有异步通知都被有效转化为同步通知。

消息分割

　　Tina的输入输出是多线程的，各个频道实例不共享缓冲区，而是拥有各自独立的输入输出。这种方式避免了线程抢占和同步问题，也让Tina完全避免了所有网络活动的堆分配。这明显地节省了你应用程序的内存空间，避免线程的争夺共享资源，消除了集群中潜在的垃圾回收工作，一般情况下会减轻电脑主机的负载。

IO within Tina is multi-threaded. Rather than share a single set of IO buffers, each channel instance has its own set. This sidesteps any issues regarding thread-contention & synchronization, and enables Tina to avoid heap-allocation entirely for all network activity. This significantly reduces the memory footprint of your applications, avoids a common point of thread contention, removes clustering as a potential instigator of garbage collection, and generally limits the load placed upon the host computer.

　　然而当集群信息到达客户端时，传入的消息是引用别名，而不是拷贝。也就是说到达客户端的消息都是临时的。

However, when a cluster message arrives at a client, array-attributes of the message are aliased rather than being copied into the heap. In short, messages arriving at a client are transient.

　　如果客户端打算在一段时间内储存消息，而不是立刻处理，这就可能成为一个问题。目前设计的选择是尽量减少消息复制带来的垃圾回收压力；需要时，也可以复制输入消息，使这个消息不再被当作临时对象。消息类针对这种目的有个专门的clone()方法，可以在这种情况下使用。

This may becomes an issue where a client intends to store the message locally for a period of time, rather than process it immediately. The design trades-off a large savings in GC pressure for the potential of some message cloning as and when necessary – the act of copying an incoming message such that it is no longer considered transient. The message class has a clone() method specifically for this purpose, and it should be used accordingly.

对消息的约束

　　要成功发送某个消息，它应该有一定的自我约束。也就是说，无论何时，消息被重新初始化，都不需要任何第三方施加影响——它应该支持默认构造函数。

In order to successfully send a message it should generally be self-contained. That is – wherever a message is re-instantiated, the representation of it should not require the influence of any third party - it should support what's known as a default-constructor.

　　举个例子，如果我们发送的消息内嵌有一个数据库连接，这意味着在消息被重建的任何地方，该连接必须都是可用的。实际情况中这类行为相当罕见，大多数消息本质上都是很简单的。进一步讲，cache和queue的实现很少考虑对消息进行重新初始化，因为它们更倾向于存储原始的网络报文格式。然而task实例需要在集群内远程执行，就必须考虑这种情况。

For example, if we send a message which embeds a database connection, an equivalent connection must be made available (and assigned) wherever that message is brought back into existence. In practice, this type of behavior is only rarely needed since large subsets of message types are usually quite simplistic in nature. In addition, implementations of cache and queue would rarely need (if ever) to instantiate a message since they would tend to store the message in raw network format instead. However, task instances are executed remotely within the cluster, and this is where consideration must be applied.

　　Tina QOS使用消息克隆(message-cloning)以满足这种需求。首先，task消息应该在每台task服务器端注册；第二步，注册的消息要实现read()方法，以便通过必要的环境参数建立集群实例。换句话说，每个注册实例都有个可选项，利用自己的参数，通过构造函数复制出相同对象。在实践下很少需要第二步，但必要时仍然要支持它。绝大多数task只需注册，因为实际处理代码本身就在场，可以直接执行。

In order to satisfy these requirements, the Tina QOS uses a form of directed message-cloning to achieve it. First, task messages should be enrolled with each task server and second, the registered message should implement the read() method in order to establish the cluster instance with the environment it needs. In other words, the registered instance of each message has the option of establishing the equivalent of ctor arguments for each incoming message, potentially based upon it's own ctor arguments. In practice, the need for this second step is rare but the support is there when necessary. The vast majority of tasks require registration only, since the actual executable code itself must be present and available for execution.

　　如果试图发送执行集群中没注册过的task，会引发一个远程异常返回给调用者。不过，我们打算添加一个动态安装和注册的机制，以解决潜在的安全问题。

Shipping and executing unregistered tasks on the cluster will result in a remote exception, returned to the caller. However we expect to add a facility to install and register tasks dynamically, subject to potential security concerns.

注册和收容

　　接收消息后，集群的客户端需要一个类的实例来收容(host)这些内容。大多数情况下，收容类通过消息的注册挑选，前面提过，应用程序中所有的消息类型都要预先注册。但是task消息不需要预先注册，因为输出的消息实例本省同时也就是收容类。对其他类型的消息都需要专门的收容类，除了依赖注册表以外，应用程序也可以手工支持定制的收容类，作为调用集群的参数的一部分。这就能对某些高级用途提供方便，尤其是在频道名直接映射专门的消息类型的情况下（频道和消息类一一映射）。

Upon receipt of each incoming message, a cluster client requires a class instance to host the content. In most cases, the host is selected from the message registry where all your application message types were previously enrolled. This is not required for task messages, since the outgoing message instance is used to host the result also. For other message types though, the host is required. Instead of depending upon the registry, an application may manually supply an appropriate host as part of a cluster request. This can be convenient in some advanced uses, especially where the channel name maps directly to a specific message type (a one-to-one mapping between the channel and a message class).

需求分析VS惯用法

Wed, 12 Dec 2007 17:15:40 GMT

　　让出Web开发和企业级开发领域后，C++集中于系统级开发，也就是一般应用软件的“硬核”部分。所以一个有趣的现象是，尽管C++的市场份额在下降，C++程序员的平均工资却在提高。

　　但C++的复杂性一直让人头疼。最近关于C，C++，D语言的大争论，国内外都引起强烈反响。和以往“编程语言口水仗”不同，不少经验丰富的程序员和架构师发表了自己的意见。

　　刘未鹏刚发布的这篇《学习C++：实践者的方法》值得推荐。学习C++容易钻到语言细节的牛角尖里出不来，相信很多人都有共鸣，而且身边的新人还在不断重复这种弯路。其实，对系统功能需求本身的理解和分析，比你用了几种惯用法和设计模式，重要得多。BLOG后半部分还给出了学习要点的列表，比较中肯。文中提到的Bjarne Stroustrup的回信，Andrei Alexandrescu的专访，云风的BLOG，都值得看一看。

　　BTW1：下班时fy大侠评价：“系统跑得很流畅”。这一阶段的优化工作干得很苦，结果也令人欣慰：内存占用降到了老版本的1/5，从而避免了进程空间2G上溢崩溃的问题，速度也有所提高。改进效果在越大的数据上越明显。human库同时指定5、6种可变修饰，pFind不再那么吃力了。

　　BTW2：近几个月的重构，“水面以下”的进展是以exception throw替代掉原有C风格的return false和GetLastError()。十几万代码，三十几个模块，逐步利用各种机会顺手重构，到今天算基本改完了。目前的异常和日志机制让我满意。如果要列出用C++而不用C的最主要原因，我大概会选STL和异常处理。

　　BTW3：闲暇时玩玩D语言，编程的感觉很好。变化的正是C++那些让人别扭的历史包袱。

Andrei Alexandrescu专访

Sun, 02 Dec 2007 08:59:58 GMT

　　很多朋友都问参加SD2China（软件开发2.0大会）的感觉，还在“反刍”中，也想等等看别人的BLOG有什么整理。回过来审视自己手头的pFind 2.0工作，有了不少新的视点和思路。

　　参加SD2China原因之一是冲着Andrei Alexandrescu去的，他的课程都听了，得到亲笔签名的C++ Coding Standards：101 Rules, Guidelines, and Best Practices。这里有段专访，里面提到C++0x标准提案里，他最喜欢的三个features是：variadic templates、auto和concept，说到俺心里去了。

Google里的牛人

Sun, 25 Nov 2007 17:27:45 GMT

　　很早以前看Joel on software讨论程序员招聘，里面提到宁缺勿滥，绝对不要招笨蛋，因为高手喜欢扎堆。对技术人员来说，和牛人混在一起是让自己变牛的捷径。

　　Google之所以成为很多程序员梦想的地方，大概不仅仅是由于免费美食，看看它都收集了哪些大牛：

　　Vinton Cerf（TCIP/IP协议合作设计者）、 Joshua Bloch（《Effective Java》作者，JSR175标准的leader,J2SE 1.5的主要开发者）、Guido Van Rossum（Python之父）、Andrew Morton（linux的二号人物，维护kernel 2.6）、Mark Lucovsky（Windows内核设计师）、Bram Moolenaar（Vim作者）、 Darin Fisher（Mozilla项目主力开发者）、Sean Egan（Gaim开发团队Leader）、Greg Stein（Apache项目主要开发者，Apache基金会主席）、Udi Manber（原Amazon的A9搜索团队总监）、Rob Pike（Plan 9主力开发者）、Adam Bosworth（原BEA首席架构师）、Andy Hertzfeld（Macintosh研发团队核心成员）、Louis Monier（Internet搜索引擎发明者，原eBay开发总监）、Ben Goodger（Firefox的主要设计者，但已由Google 加入微软)、Danny Thorpe（Delphi开发者，原Borland首席科学家）、Alexander Limi（plone创始人）、David Presotto（plan 9创始人）

Google Android SDK发布了

Tue, 13 Nov 2007 02:52:16 GMT

　　Android Linux SDK发布了，技术文档和源代码在Google Code。Google的知名服务都集成进去了，例如Google Earth(+GPS)和Google Talk，当然少不了还有搜索引擎，可以想到未来能集成的还有更多，例如Gmail、Google Reader、Google Doc、Google Notepad等等。

　　Google把软件Web服务化的技术路线，太适合手持设备了。当然，这架空了操作系统，动摇了MS Office这个Killer Application的根基，正触动了微软的大忌。

　　谷歌中国只有研发出这种东西，而不仅限于汉化，质疑声才能减少。tj说过他的目标是做出全世界人都用的application，加油。

等待Android SDK

Tue, 06 Nov 2007 10:40:58 GMT

　　传说中的Android SDK还没发布，Google说：“请再等一周。”

　　这回拉起来的盟友很唬人：有Qualcomm、Intel、Motorola这种技术强援，也有NTT DoCoMo和中国移动这样的运营寡头。

　　接下来要看看Google如何对付WinCE、iPhone和Symbian。