M-OSCAR

Moving into Tencent Building

2009-09-03T19:45:00.001+08:00

今日第一次准时落班，因为要搬迁到腾讯大厦，哈哈兴奋~~

不过甘早落班，未有班车接送翻屋企，难得有时间，决定行路返去 :D

南山科技路，汇聚左好多IT公司，远处太阳底下突出来既就系腾讯大厦了~~

中兴应该系腾讯大厦建成之前附近最高既建筑，夜景好正~~

腾讯大厦~~传说中顶楼既风景一流，听日入去上班之后要上去睇睇~~

从飞亚达出发大概行左半个钟头先来到腾讯大厦脚下 -____- |||

屋企就系新大楼隔离，趁时间尚早，摸索条归家路先~~

深圳既天气除左比较热之外都仲唔错，蓝天白云都仲系偶然有的~~

我住的友邻公寓........隔离既西海明珠:P 同公司另一个同事合租左一个30楼既单位，坐北向南，景观唔错，西面可以远远望到一个码头，码头既对岸就系珠海了 :)

东门“便便”游~~

2009-08-09T02:24:00.001+08:00

今日某兴和小冰导游东门，稳到左传说中的“便所主题餐厅”，哇D雪糕真系同XX一样....好彩味道好正常:P 然后去左万象城睇Ice Age III 3D版，哇门票要120蚊（囧囧），哈哈只可怜既松鼠又为左粒松子四处奔波~~

小冰多有后现代非主流的潜质~~

东门步行街，感觉像回到广州的上下九~~

可怜的小冰，走着走着突然被埋伏在路边的卖花女用死亡缠绕攻击，瞬间被秒杀~~

信春哥者得永生，小冰在便便主体餐厅满状态复生~~（连座位都是马桶 -_-）

菜单都好有特色....

用“马桶”装住的“便便”雪糕....

哈哈，间餐厅入面有好多XX公仔 :P

传说中的大学班长某兴~~

便便是用来舔D orz

厕所入面有好多恶搞画报~~

Missing you ....

2009-08-07T00:40:00.001+08:00

今天收到了公司送的一对QQ公仔，本来是入职的时候送的，不过说当时没存货，就拖到现在才到手~~加上这两只已经拿了5只胖企鹅了....哈哈再接再厉~~

明天又是星期五了，感觉上班的时间过的很快，老婆我好想你！

Inside Fiyta

2009-08-04T07:52:00.002+08:00

上班两周，就得了胃痛 -_- 飞亚达里到处都是QQ公仔：

5楼办公室一进门就一只巨型企鹅，肚腩都已经胖得坠下来了~~

导向牌后面也躲着QQ

旁边的导师的桌脚下也有一只加大的QMM

连厕所门上的都是QQ -____- |||

每晚的免费宵夜：面包+汽水，还有免费自助餐，想不胖都不行....

Moved to my new house ....

2009-07-27T13:23:00.002+08:00

昨天搬到酒店隔离的友邻公寓30楼，哈哈风景不错~~

从露台看出去的夜景~~好多“星星”~~

从露台看出去的晨景....刚落完雨好多云....

室内系甘的:P

Linux文件与目录权限

2009-07-22T14:13:00.004+08:00

我们在linux里输入ls -l或者ll后，会输出一个如下的列表，显示当前目录下的文件和子目录详细信息（XXX表示文件名）：

drwxr-xr-x  4 oscartang users 4096 2009-07-22 11:25 xxx
drwxr-xr-x 23 oscartang users 4096 2009-07-22 11:25 xxx
drwxr-xr-x  3 oscartang users 4096 2009-07-22 11:25 xxx
drwxr-xr-x  4 oscartang users 4096 2009-07-22 11:25 xxx
drwxr-xr-x  3 oscartang users 4096 2009-07-22 11:25 xxx
-rwxr-xr-x  1 oscartang users   69 2009-07-22 11:25 xxx
drwxr-xr-x  3 oscartang users 4096 2009-07-22 11:25 xxx

最前面有一堆“drwxr-xr-x”样子的东东是什么来的呢？它是文件/子目录的权限设置，第一个字母通常用于区分类型（是文件、目录、还是其他东东），后面9个字母由左至右每三个为一租分别标识所有者、与所有者同组用户、其他用户的权限。具体如下：

d : 表示是一个目录，事实上在ext2fs中，目录是一个特殊的文件；

- : 表示这是一个普通的文件；
l : 表示这是一个符号链接文件，实际上它指向另一个文件；
b、c : 分别表示区块设备和其他的外围设备，是特殊类型的文件；

s、p : 这些文件关系到系统的数据结构和管道，通常很少见到。

r(Read) : 对文件而言，具有读取文件内容的权限；对目录来说，具有浏览目录的权限；
w(Write) : 对文件而言，具有新增、修改文件内容的权限；对目录来说，具有删除、移动目录内文件的权限；
x(eXecute) : 对文件而言，具有执行文件的权限；对目录了来说该用户具有进入目录的权限；
- : 表示不具有该项权限。

下面举例说明：

-rwx------ : 文件所有者对文件具有读取、写入和执行的权限。
-rwxr—r-- : 文件所有者具有读、写与执行的权限，其他用户则具有读取的权限。
-rw-rw-r-x : 文件所有者与同组用户对文件具有读写的权限，而其他用户仅具有读取和执行的权限。
drwx--x--x : 目录所有者具有读写与进入目录的权限,其他用户近能进入该目录，却无法读取任何数据。

drwx------ : 除了目录所有者具有完整的权限之外，其他用户对该目录完全没有任何权限。

Second day at work ....

2009-07-21T18:26:00.001+08:00

同事们工作都好认真，唯独我仍在看文档看代码，努力跟上各位前辈的步伐....上班两日，最有感触的是....饿:P，看来要带点零食来上班才行了~~公司说5点半下班，但接送班车却到7点至11点才有....明显鼓励各位加班....饿晕了，先去吃饭~~
Tomorrow will be a better day :)

5月35日

2009-06-04T19:44:00.001+08:00

今天终于答辩完了～～哇演示的时候紧张得我手震震～～最后程序本身倒没什么问题，反而又是论文格式要改，郁闷，这些填表教授表填多了心理不平衡，也要让学生感受一下～～毕业了，感触良多，如果问我大学里最大的收获是什么，我会说，不是书本上的知识，不是技术上的进步，而是认识到什么叫做冷漠～～渐渐的，我对很多东西失去了信心，对周围的人，对这个社会，对这个国家，都已经不再像从前那样看待，我想这就叫做成长吧。

今天又有更多网站进入“技术维护”状态，想必是企图完全切断国民讨论的渠道，让今天不了了之的过去，我对20年前的今天没有多少了解，我不对一段我不了解的历史做任何评论，只是觉得能够做出这种卑劣的事情，只能证明某些人心里有鬼～～连“分享网络2.0”这样的一个技术型网站都被自觉维护，还要特意强调自己真的是因为技术问题要进行维护，虚伪！我真的觉得很失望，不禁想起《V for Vendetta》里的一句对白：If you're looking for the guilty, you need only look into a mirror.

全国技术维护日

2009-06-03T17:30:00.001+08:00

全国技术维护日

今天国内的饭否和VeryCD两大网站也顶不住河蟹的重量，纷纷俯首称臣，在“敏感时刻”自觉进行“技术维护”整站关闭，还能说什么呢～～我也自觉技术维护一下吧～～

Use Erlang to handle xml stream

2009-06-03T16:44:00.001+08:00

写了一个模块，使用xmerl_scan:string函数流式的读取和处理XML流（边读边处理），很适合用于处理XMPP协议的XML流数据，每读取到一个完整的节点（message, presence, iq ....）就会做相应处理～～源码在这里～～

豆瓣网：BLOGSPOT网络遊彳亍小组！小组已被解散

2009-06-03T02:10:00.000+08:00

尊敬的用户：

作为一家在中国境内运营的网站，

豆瓣遵守中国的法律法规和相关政策的要求。( 相关法律法规，请参考《互联网信息服务管理办法》http://www.cnnic.net.cn/html/Dir/2000/09/25/0652.htm 第十五条。)

你参与的小组 BLOGSPOT网络遊彳亍小组！因讨论主题属于社区指导原则不允许、不欢迎的内容，已被解散。

由此给你带来的不便，我们深表歉意，并感谢你的理解和配合。

附社区指导原则：http://www.douban.com/about?policy=guideline

——豆瓣

今日莫名其妙的收到了这样一封邮件，我都不记得了自己参加了这样一个游行小组，貌似只是声讨政府屏蔽BLOGSPOT的做法，近来说临近六四，国内很多动作，百度贴吧里各大学的贴吧都被禁止了评论功能，以图阻止学生们交流，很多网站都加大力度查封所谓敏感内容，事实上这样做实在不智，须知人的好奇心，越是搞的神秘，越是有人要翻墙去看个到底，现在互联网时代，要屏蔽资讯不像once upon a time那么容易～～再说平生不做亏心事，夜半敲门也不惊，如此之举实乃有些人实在心虚害怕～～

但是再怎么说，要在这样的社会存活下来，还是有不少网站，尤其是大网站很识时务，主动配合，不顾扭曲自己，不顾用户流失，但求留得青山在，对这样的服务商，我又能说什么呢，想起《斯巴达300勇士》里Leinidas的一句台词十分适合：You there, Ephialtes. May you live forever.

erlang 与 linked-in driver 间的通信

2009-05-31T16:35:00.001+08:00

erlang貌似没有直接向port写入整数的方法，通过port传送的全是binary数据，以下代码在erlang中通过port传送一个整数给cpp读取～～

Erlang :
send_integer(Int) ->
    Size = erlang:system_info(wordsize) * 8,
    Data = <<Int:Size/integer-little>>,
    Port ! {self(), {command, Data}},
    ....

CPP :
static void output(ErlDrvData handle, char* buff, int bufflen){
    int *num = (int *)buff
    ....

Google Docs 写博测试

2009-05-30T02:27:00.001+08:00

Google Docs 写博测试

拜GFW所赐，Blogspot从大陆不能直接访问，虽然用代理能够正常访问正常发文，但上传不了图片，无奈，发现原来Google Docs可以当作编辑器将文章发布到Blogspot，实在十分好！马上测试一下～～

Ubuntu下保存mms类型地址的视频

2009-05-26T12:10:00.000+08:00

在ubuntu下用这个mimms软件可以下载mms类型地址的视频，安装很简单，如下：
sudo apt-get install mimms

装好后输入如下命令即可下载，有进度和剩余时间显示～～
mimms mms://....

Google App Engine on Ubuntu 9.04

2009-05-25T14:26:00.002+08:00

Google App Engine官方所支持的python版本为2.5，BUT Ubuntu 9.04默认使用的是python 2.6.2，这样在本地测试时就会遇到点问题了，比如会出现如下的异常：
Throwing : No module named _multiprocessing

不过幸好，我们只要转回2.5版本就平安大吉了，步骤如下：

sudo apt-get install python2.5
修改dev_appserver.py文件，将第一行替换为#!/usr/bin/env python2.5
OK～～

Erlang Linked in driver

2009-05-24T19:08:00.000+08:00

Erlang允许其他语言编写的程序以共享库的方式动态连接到Erlang运行时环境里运行，与Erlang Port的方式相似，这种方式称为linked-in driver（内部连接驱动？？），是Erlang与其他语言程序交互的最高效的方式，但同时也是最危险的，因为一旦驱动内部出现致命异常，Erlang虚拟机也会崩溃，拖累其他Erlang进程一起挂掉，因此如非必要不推荐使用linked-in driver。

下面是C++编写的driver，具体代码结构解析请参见《Programming Erlang》

#include 
#include "erl_driver.h"
using namespace std;

struct data{
    ErlDrvPort port;
};

//PORT打开时执行
static ErlDrvData start(ErlDrvPort port, char *buff){
    data* d = (data*)driver_alloc(sizeof(data));
    d->port = port;
    return (ErlDrvData)d;
}

//PORT关闭时执行
static void stop(ErlDrvData handle){
    driver_free((char*)handle);
}

//ERLANG发送来信息时执行
static void output(ErlDrvData handle, char *buff, int bufflen){
    cout << buff << endl;
    char rs[] = "ok";
    data* d = (data*)handle;
    driver_output(d->port, rs, 2);
}

ErlDrvEntry driver_entry = {
    NULL,    //F_PTR init N/A
    start,   //L_PTR PORT打开时执行此函数
    stop,    //F_PTR PORT关闭时执行此函数
    output,  //F_PTR ERLANG发来信息时执行
    NULL,    //F_PTR ready_input, called when input descriptor ready to read
    NULL,    //F_PTR ready_output
    "test",  //DRIVER名，OPEN_PORT函数的参数
    NULL,    //F_PTR finish, called when unloaded
    NULL,    //F_PTR control, port_command callback
    NULL,    //F_PTR timeout, reserved
    NULL     //F_PTR outputv, reserved
};

extern "C"{
    DRIVER_INIT(test){
        return &driver_entry;
    }
}

然后用如下命令编译成共享库：
g++ test.cpp -I/usr/local/lib/erlang/usr/include/ -fPIC -shared -o test.so

Erlang里调用这个共享库的代码如下：

-module(test).
-compile(export_all).

start() ->
    ok = erl_ddll:load_driver(".", "test"),
    Port = open_port({spawn, "test"}, [{packet, 2}]),
    Port ! {self(), {command, "woo just a test"}},
    receive
        {Port, {data, Data}} ->
            ok = io:format("[~p/~p] ~p\n", [?MODULE, self(), Data])
    end,
    Port ! {self(), close}.

Tail Recursion & ActionScript 3.0

2009-05-19T18:27:00.000+08:00

貌似AS3.0还未支持尾遞歸，如果執行尾遞歸函數的話，可能會得到如下的堆棧溢出異常：
Error #1023: Stack overflow occurred

包括在使用Alchemy時的C/C++函數裡如果有遞歸的話也可能會出現堆棧溢出，鬱悶～～唯有改改算法或者等AS4.0吧，聽說4.0會支持尾遞歸～～

sztrace not declared ?

2009-05-19T17:08:00.000+08:00

今天用Alchemy編譯一個C++文件時，得到如下錯誤：
error: ‘sztrace’ was not declared in this scope

在c裡面sztrace函數都可以直接使用，怎麼到了c++就出錯了呢... 搜索一下在Adobe Forums裡有如下解答：
sztrace is a C, rather than C++, function. Because your are compiling your code as C++, you must wrap your manual declaration with extern "C" { } so that the function is not given c++ decorations.

OK，在代碼裡加入如下定義，編譯成功～～
extern "C"{
void sztrace(char*);
}

Blogger is being GFWed

2009-05-17T10:48:00.000+08:00

Blogger也撞牆了....Google的服務一個接一個的被拒之牆外，讓人怎麼活下去....然而對于這樣堂而皇之的侵犯，除了鬱悶和無奈，又能做什麼呢？這樣只會讓民眾更加討厭這個黨這個社會，更加討厭你們這群烏合之眾，遺為後世唾罵～～

我改變不了世界，我改變不了他人，但至少我還能堅持做好自己～～

Alchemy之二值化圖像

2009-05-15T09:13:00.002+08:00

今天試了一下通過Alchemy用C語言來處理FLASH裡的彩色圖像，圖像由Camera採集並將其像素數據以ByteArray格式傳入C函數，C計算圖像的Otsu最優灰度閥值，並據此將圖像轉換為二值化圖像，效果如下：

因為所有算法相關的計算都用C實現，因此生成的SWF性能明顯比純AS實現的同樣功能要高效很多很多，幀率為24fps，CPU消耗30%，完全不卡，很爽很爽～～

有興趣的話可以下載源碼和演示～～
也可以點這裡直接在瀏覽器上試試，需要Flash Player 10

Alchemy之 Memory to ByteArray

2009-05-14T19:11:00.001+08:00

Q: 我在C函數裡開了一片內存寫入了些數據，怎樣將這些數據作為ByteArray返回給AS呢？？
A: 可將將數據塊的首指針地址返回給AS以讀取其中數據，具體看下面代碼：

比如說我們在C裡創建了一個整型數組，要返回給AS：

static AS3_Val myfun(void *self, AS3_Val args){
    int buffer[4] = {1, 2, 3, 4};
    return AS3_Array("IntType, AS3ValType", AS3_Int(4), AS3_Ptr(buffer));
}

然後在AS裡進行讀取：

var loader:CLibInit = new CLibInit();
var clib:Object = loader.init();

var rs:Array = clib.myfun();
var len:init = rs[0];
var ptr:uinit = rs[1];

var ns:Namespace = new Namespace("cmodule.ModuleName");
var memory:ByteArray = (ns::gstate).ds;
memory.position = ptr;

var i:int;
for(i = 0; i < len; i ++){
    trace(memory.readInt());
}

Alchemy之讀取AS ByteArray數據類型

2009-05-14T14:31:00.008+08:00

Alchemy的C API裡沒有直接讀取ByteArray數據類型的方法，但在圖像處理等很多情況下我們都需要用到ByteArray，那C該如何處理ByteArray類型的數據呢？看下面的演示函數：

//讀取AS傳入的ByteArray類型數據
static AS3_Val readByteArray(void *self, AS3_Val args)
{
    //提取ByteArray
    AS3_Val data = AS3_Undefined();
    AS3_ArrayValue(args, "AS3ValType", &data);

    //獲取ByteArray長度
    AS3_Val prop = AS3_String("length");
    int length = AS3_IntValue(AS3_Get(data, prop));
    
    int i, tmp;
    char buffer[128];
    for (i = 0; i < length; i ++){
        //讀取ByteArray裡的值並輸出到終端顯示
        tmp = AS3_IntValue(AS3_Get(data, AS3_Int(i)));
        sprintf(buffer, "[%d] : %d", i, tmp);
        sztrace(buffer);
    }
    
    return AS3_Null();
}

注意一下AS3_Get這個函數，它用于獲取一個AS Object obj的指定屬性prop，屬性用一個AS String字符串來表示，其函數定義為：
AS3_Val AS3_Get(AS3_Val obj, AS3_Val prop)
如果obj不存在指定屬性，則函數返回NULL

然後在AS裡寫如下代碼來調用C函數並傳入ByteArray參數：

//初始化Alchemy
var loader:CLibInit = new CLibInit();
var lib:Object = loader.init();

//創建一個ByteArray並寫入點數據
var bytes:ByteArray = new ByteArray();
bytes.writeByte(10);
bytes.writeByte(20);
bytes.writeByte(255);

//調用C函數
lib.readByteArray(bytes);

測試結果如下：
[0] : 10
[1] : 20
[2] : 255

PS : 另外在C代碼裡，除了AS3_Get(data, AS3_Int(i))外，還可以用如下方法讀取ByteArray：

unsigned char rs;
AS3_ByteArray_seek(data, 0, SEEK_SET);
AS3_ByteArray_readBytes(&rs, data, 1);
傳說中這樣比較高效～～

AS3_ByteArray_seek
AS3_ByteArray_readBytes
AS3_ByteArray_writeBytes
這三個函數是C用來操作ByteArray的，詳細用法請自行參閱Alchemy API

初試 Adobe Alchemy

2009-05-14T12:38:00.003+08:00

配置好了Alchemy後先去Adobe Labs裡看一看Getting Start Guide和Alchemy API，下面的例子從AS裡傳入兩個整型參數到C函數中，C計算兩者之和並返回給AS：

先看看C的代碼：

#include <stdlib.h>
#include <stdio.h>
#include "AS3.h"

//供AS調用的函數，args即為AS傳入給C函數的參數
static AS3_Val myfun(void *self, AS3_Val args)
{ 
    //提取參數
    int a, b;
    AS3_ArrayValue(args, "IntType, IntType", &a, &b);
    
    //計算a, b之和，轉換為AS裡的Int數據類型並返回之
    return AS3_Int(a+b);
}

int main()
{
    //定義一個公開給AS調用的函數
    AS3_Val myMethod = AS3_Function(NULL, myfun);

    //創建一個持有該函數引用的Object
    AS3_Val result = AS3_Object("myfun:AS3ValType", myMethod);

    //Release
    AS3_Release(myMethod);

    //告知初始化完成，此方法不會返回
    AS3_LibInit(result);

    //永遠不會執行到這裡
    return 0;
}

下面是AS代碼：

package{

    import flash.display.Sprite;
    import flash.utils.ByteArray;
    import cmodule.test.CLibInit;

    public class Test extends Sprite
    {
        public function Test()
        {
            var loader:CLibInit = new CLibInit();
            var lib:Object = loader.init();
            trace(lib.myfun(10, 20));
        }
    }
}

OK，然後編譯一下：
C: gcc test.c -O3 -Wall -swc -o test.swc
AS: mxmlc -library-path+=test.swc Test.as

[轉載] 划时代的 Adobe Alchemy

2009-05-12T18:44:00.003+08:00

此文章转载于天地会的HuangYZ。

      Adobe 自从2007年中推出了AS3支持了面向对象的开发方式之后, 可谓动作不断. 去年又将AVM2的核心虚拟机tamarin 捐赠给了ECMA4 , 又将FlexBuild2直接升级到FlexBuild3, 这不,在08年末,又蹦出一个 Adobe Alchemy, 这在战略上具有极为重要意义. 而FLASH 从一个简单的动画客户端,一跃升级成一个未来富媒体应用程序的平台. 从这一系列战略步骤,不难看出ADOBE想成为WEB乃至桌面开发霸主的野心! 微软你要小心了.

那么你可能要问了, 为什么Alchemy这么重要呢?  作为FLASH实践者, 效率问题是众所周知的. 因为, FLASH中运行的代码是 ACTIONSCRIPT, 它是一个脚本语言.而这个语言是运行在FLASH内部的AVM2虚拟机上的. 所以它的一些功能都需要经过, 语言解释成AVM2虚拟机字节码,然后AVM2运行字节码,最后由本地NATIVE语言,也就是本机2进制程序执行.虽然这解决了平台无关的问题,但是带来一个副作用,就是比较慢,这就是为什么FLASH上一直没有杀手级应用的主要原因.

从本质上来说, 这是一个构架上的问题. 而Alchemy 的出现,从构架上,改进了这个问题,你可以使用C/C++编写核心,快速的算法,让AS3进行调用, 达到加速的目标. 这在过去,你只能使用ADOVE提供给你的内置native 程序. 现在,你可以自己干这件事情了. 既解决了平台无关的问题,又解决了效率的问题,甚至可以利用FLASH本身几十亿现有的客户端的优势,解决了渠道问题.可以这样说, Alchemy 打开了一个前所未有的时代!

让我们看看 Alchemy 到底做什么. 从ADOBE的说明文档上可以看到, Alchemy 是一个运行在低层的虚拟机 (Low Level Virtual Machine) ,他运行在AVM2之下. 那你又要问了.既然有了一个虚拟AVM2了,为什么还要一个LLVM?  其实, LLVM 将C/C++代码进行编译, 并且生成RISC-LIKE指令的字节码, 存储在缓冲区之中, 在FLASH运行开始的时候, 实时翻译成机器相关的本地代码. 需要调用的时候是调用翻译之后的2进制本地代码.以此来提高整体速度.这就是LLVM的关键技术, 而运行时译 (Runtime-Compile) 这种技术有点像 .NET . 而这种LLVM和AVM2的区别是, AVM2实时解释运行脚本代码,LLVM 预编译本地运行.可以这样认为 AVM2 是 JAVA虚拟机, LLVM是 .NET虚拟机.他们在构架上处于不同的层次,满足不同需求对速度的要求.

当生成编译完成后,字节码需要保存在一个缓冲区之内. 由于在框架之内需要和AVM2兼容,所以这个缓冲区,将以 AVM2能识别的BYTEARRAY 形式保存在内存之中. 即使使用反编译工具,反编译这个SWF文件,也看不到任何代码. 并且, alchemy自动生成一个 AS3的接口文件,以方便AS3程序进行调用. 值得注意的是, 所有C/C++编译之后的数据,都以 SWC 函数库的形式生成, 用户可以在自己的工程里 IMPORT.经过使用后发现,由 Alchemy 生成的SWC文件是比较大, 比 C/C++源文件大的多.即使一个只有几十来行的纯C 功能,生成SWC后都会有100多KB. 参考ADOBE的文档上说, 编译C/C++的代码,会将C/C++所需要的所有库,比如C标准库统统放到一个SWC里去,并且严格遵循POSIX标准. (可移植操作系统接口) 由于这种机制的存在, 我们甚至可以在C/C++里嵌入线程的支持, 来运行同步或者异步的功能. 从而弥补了FLASH是单线程这一不足! 这将是一件美妙的事情! 而本人认为,由于C/C++代码是公用一个C标准库的,所以只要SWC中的功能越多,那么从空间效率上就越是划算. 并且在目前的宽带之下,多个100来KB问题不是太大.

当然,安全问题,也是alchemy的重头戏, 我们知道, FLASH 对安全问题是有一套非常严格的措施的,比如访问本地资源后,就不能访问远程资源,访问这个域的资源后,就不能访问其他域的资源.如果你要访问,就要在另外一个域上安装一个沙箱(SecurityBox)文件,才能顺利访问. 而alchemy将C/C++带入FLASH之中,而C/C++ 是否能坏了这个规矩,让应用程序出轨呢? 答案当然是否定的,一旦这个程序被调用之后,其C/C++程序被严格的运行在一LLVM上,LLVM作为一个代理机构,向上,提供了对C/C++的平台支持,比如独立的内存空间,独立的堆栈空间,独立的线程管理机构,等等. 向下将2进制程序输送到本机CPU进行执行. 所以安全问题上是非常到位的, 所以对C/C++来说,只要LLVM环境没有提供的,它将永远访问不到.

Adobe已经对 alchemy 进行了比较深度的优化,并且我相信以后将继续下去.就从用户来说,由于有了alchemy 的出现,一些对速度要求较高的算法,都可以使用C/C++来代替. 由于接口上都是AS3的接口,所以移植现有的程序将会非常轻松.比如目前游戏开发中广泛使用的那个BitmapData.CopyPixel 如果用C纯代码进行改写,那么速度将提高几十倍之多.

总结.  Alchemy 的出现,开启了一个全新的时代, 未来你将会发现网业上不再是简单画面,而是充满动态的不同的效果,给于用户全新的体验.随着LLVM提供的功能加多,比如将显卡硬件的功能作为一个抽象接口提供给C/C++调用,那么将来UNREAL3出现在网页上,你千万不要惊奇.甚至WOW出现在网页上,你也不要惊奇. 因为新时代的门已经打开!

[ Erlang + ActionScript ] System Monitor

2009-05-12T01:05:00.000+08:00

在畢業設計裡加入了一個遠程的服務端負載監測功能，可以遠程查看服務端的當前CPU負載、內存分配等狀況，效果圖如下：

前台用Flex實現，Flex的圖表組件很好用，坐標軸能自動根據數據來調整，不過數據綁定上好像有點問題，數據源更新了圖表卻不會自動刷新～～後台由Erlang提供數據，Erlang的OS_MON模塊可以提供系統CPU負載、內存狀況、硬碟空間使用情況等系統信息～～Erlang通過Socket主動推送JSON格式的數據給客戶端～～有興趣的話可以看看源碼：

客戶端源碼 / 服務端源碼

Erlang處理JSON數據～～

2009-05-09T17:27:00.006+08:00

要用Erlang處理JSON數據，先下載這個東東：
JSON and JSON-RPC for Erlang
下載解壓編譯完之後，輸出的beam文件在ebin目錄下～～

上面下載的包裡有一個rfc4627模塊，提供了JSON數據的encode、decode等方法，還可以將JSON與Erlang Record相互轉換，十分方便快捷，下面看看用法：

首先試試將字符串轉換為Json Object：
1> JsonBin = <<"{ 
1> \"username\":\"Oscar Tong\",
1> \"password\":\"123456\",
1> \"male\":true,
1> \"age\":23
1> }">>.
<<"{\n\"username\":\"Oscar Tong\",\n\"password\":\"123456\",\n\"male\":true,\n\"age\":23\n}">>
2> {ok, {obj, JsonObj}, _Rest} = rfc4627:decode(JsonBin).
{ok,{obj,[{"username",<<"Oscar Tong">>},
          {"password",<<"123456">>},
          {"male",true},
          {"age",23}]},
    []}

再轉換為JSON格式的字符串：
3> rfc4627:encode({obj,JsonObj}).
"{\"username\":\"Oscar Tong\",\"password\":\"123456\",\"male\":true,\"age\":23}"

經測試表明，JSON數據的解析與處理速度比XML要快得多，decode和encode僅耗時約40us，比xmerl模塊處理XML需要超過200us相比實在是快多了～～

ActionScript處理JSON數據～～

2009-05-09T17:09:00.001+08:00

要用ActionScript來處理JSON數據，首先下載這東東：
as3corelib

as3corelib包裡有一個JSON類，可以將一個AS Object轉換為JSON格式的字符串，例如：

var obj:Object = {
    username : "Oscar Tong",
    password : "123456",
    age : 23,
    male: true,
    contacts: {
        mobile: "13800138000",
        phone: "020-39322849",
        addr: "guangdong university of technology"
    }
}
  
var json:String = JSON.encode(obj);
trace(json);

輸出JSON格式的字符串為：
{"username":"Oscar Tong",
 "age":23,
 "password":"123456",
 "male":true,
 "contact":
    {"addr":"guangdong university of technology",
     "phone":"020-39322849",
     "mobile":"13800138000"}
}

貌似輸出結果的順序有點亂了，另外JSON還有一個靜態方法decode，可以將JSON格式的字符串轉換為一個AS Object，具體自己看看包裡附帶的reference吧～～

精簡URL以減輕網站流量壓力？

2009-05-09T13:17:00.001+08:00

這篇文章《Thinking outside the box - Filenames and Web Optimization》講述了長URL如何吃掉高流量網站大量的帶寬，以及提供了一些解決方法，值得看看～～

gen_tcp:controlling_process BADARG error ??

2009-05-07T19:45:00.000+08:00

今晚嘗試了一下在ERLANG裡將SOCKET鏈接的控制進程轉到另一個節點上去，結果得了一個{error,badarg}錯誤，代碼如下：

....
{ok, Sock} = gen_tcp:accept(Listener),
Pid = spawn(SomeOtherNode, Mod, Fun, Arg),
ok = gen_tcp:controlling_process(Sock, Pid),
....

看來想用這種方式來將眾多SOCKET鏈接的壓力分擔到多個節點上是不行的 -____- |||

Erlang的進程信息過濾

2009-05-06T18:06:00.000+08:00

Erlang進程之間可以通過收發信息來通信，有時可能有一堆信息從各處無序的湧來，你只想處理其中部分信息，而將其他的保留在進程的收件箱裡遲點再管，那該怎麼搞呢？其實很簡單的，看下面代碼：

...
wait_for_reply() ->
    receive
        {reply, Reply} -> handle(Reply);
        _Other -> wait_for_reply()
    end.

上述函數僅處理匹配{reply, Reply}格式的信息，其他信息因為唯一的匹配模式是一個被忽略的參數_Other，因此不會被處理而繼續留在收件箱裡～～

Erlang : head mismatch ??

2009-05-02T20:52:00.000+08:00

今天編譯代碼的時候出現了一個奇怪的問題，erlang老提示某個函數有head mismatch錯誤，但我看來看去沒發現什麼不對哇，函數的定義和調用都沒錯～～最後發現原來是因為函數放置了在兩個重名函數之間，即：

出錯前：
myfun(params1) -> .... ;
myfun(params2) -> .... .

這樣就會提示錯誤了：
myfun(params1) -> .... ;
new_fun_here(params) -> .... .
myfun(params2) -> .... .

把新函數放到其他地方就OK了～～粗心之過～～

畢業相～～

2009-04-30T14:06:00.005+08:00

昨天拍了畢業照，感覺....好复雜～～覺得自己已經唔再系學校既一份子，本應系一個喜慶的日子，我卻總覺得自己....似乎未准備好～～Anyway, tomorrow will be a better day, I guess.

Reload Erlang Module

2009-04-27T01:14:00.002+08:00

有时模块代码更新并编译后，需要重新载入才能生效，此时可以在erlang shell里输入如下：

> l(my_module).
{module, my_module)

输入help().还可以查看更多的erlang shell命令～～

Embed Prezi into your website

2009-04-26T16:43:00.007+08:00

Prezi系一個很有特色的在線動態簡報服務，詳細簡介見這里～～
本文講解如何將Prezi嵌入到你的個人blog或其他网站里，首先打開你的Prezi主頁，點擊要嵌入的簡報，選擇Share，然后將右下角的link填入如下代碼的src里，然后在你的网頁上插入下面的代碼就OK了～～

<iframe height="360" src="http://prezi.com/6272/view" width="480"></iframe>

嵌入效果如下：

PS：很喜歡Prezi，可惜啊惡心的网路經常出問題，很多有創意的WebApp就是卡死了在网速上～～

在Erlang啟動時執行一系列操作

2009-04-26T14:27:00.003+08:00

可以將任意的Erlang代碼放入HOME目錄里的.erlang文件中，當Erlang啟動時，它就會自動執行該文件里的命令，例如：

io:format("Erlang is running ....\n").
code:add_patha("."),
code:add_pathz("/home/m/bin").

啟動erlang時，可以看到如下輸出：

$ erl
Erlang (BEAM) emulator version 5.6.5 [source] [smp:2] [async-threads:0] [hipe] [kernel-poll:false]

Erlang is running ....
Eshell V5.6.5  (abort with ^G)
1>

如果當前目錄下也有一個.erlang文件，則會優先于HOME目錄下的那個，這樣就可以在不同啟動位置定制不同的行為：

如果你不知道系統的HOME目錄的位置，可以看看Erlang認為的HOME目錄在哪里：

1> init:get_argument(home).
{ok,[["/home/m"]]}

設置Erlang裝載代碼的路徑

2009-04-26T14:12:00.005+08:00

code:get_path() 查看當前的裝載路徑：

code:get_path().
["ebin",".","/usr/local/lib/erlang/lib/kernel-2.12.5/ebin",
 "/usr/local/lib/erlang/lib/stdlib-1.15.5/ebin",
 "/usr/local/lib/erlang/lib/xmerl-1.1.10/ebin",
 "/usr/local/lib/erlang/lib/webtool-0.8.3.2/ebin",
 "/usr/local/lib/erlang/lib/typer-0.1.5/ebin",
 "/usr/local/lib/erlang/lib/tv-2.1.4.2/ebin",
 "/usr/local/lib/erlang/lib/tools-2.6.2/ebin",
 "/usr/local/lib/erlang/lib/toolbar-1.3.0.1/ebin",
 "/usr/local/lib/erlang/lib/test_server-3.2.4/ebin",
 "/usr/local/lib/erlang/lib/syntax_tools-1.5.6/ebin",
 "/usr/local/lib/erlang/lib/ssl-3.10/ebin",
 "/usr/local/lib/erlang/lib/ssh-1.0.2/ebin",
 [...]|...]

code:add_patha(Dir) -> true | {error, bad_directory}
添加新目錄Dir到裝載路徑列表的開頭

code:add_pathz(Dir) -> true | {error, bad_directory}
添加新目錄Dir到裝載路徑列表的尾部

如果怀疑裝載了錯誤的模塊，可以調用函數code:all_loaded()查看所有己加載的模塊列表，或者調用code:clash()

也可以在啟動Erlang的時候指定代碼載入路徑：
> erl -pa Dir1 -pa Dir2 ... -pz DirK1 -pz DirK2

其中-pa將目錄添加到搜索路徑的開頭，而-pz則把目錄加到路徑的末尾～～

Erlang的Makefile～～

2009-04-26T08:42:00.003+08:00

Erlang有一個類似makefile的Emakefile文件，用于編譯項目，當我們在Erlang虛擬机里執行make:all()或輸入shell命令erl -make時，Erlang會搜索當前目錄下的Emakefile文件，并按其設置編譯一個或多個模塊。Emakefile內容格式如下：

{Modules, Options}

Modules即需要編譯的模塊（atom），可以是模塊的文件名，如：mymod；
也可以是其他目錄中的模塊名，如：/somefolder/mymod；
也可以使用通配符來指定一組模塊名，如：my*；
還可以是上述種種的列表，如：['mymod', '/somefolder/mymod', 'my*']；
Options是編譯參數，詳細可參見compile模塊，下面几個比較常用：

debug_info
在輸出的beam文件里包含debug調試信息，諸如Debugger、Xref、Cover的工具需要使用這些信息，BUT可以從這些調試信息里重构出源代碼，用debuf_info_key選項可以加密debug信息以防止泄露源代碼；

{i, "/path/to/include"}
導入文件所在的目錄；

{outdir, "ebin"}
指定編譯輸出路徑。

［转］Erlang开发建议(杂记版)

2009-04-25T10:32:00.005+08:00

由 Oscar Tang 透過 Google 閱讀器傳送給您：

Erlang开发建议(杂记版)

經由 Erlang Display - erlang:display(All_About_Erlang) litaocheng 著 (日期為 2009/4/24)

以下是在erlang项目开发中的一些记录，即包含很多通俗易懂的原则，也包含一些似是而非的建议，比较混乱，还没有积累到一个可以分门别类的地步，各位就将就看吧..
:)

* 确保没有任何编译警告

* Erlang中String采用list实现，32位系统中，其1个字符用8个字节的空间（4个保存value, 4个保存指针)。因此string速度较慢，空间占用较大

* 在Server中，总是尽力书写尾递归(tail-recursive)的函数

* 使用'++'时，left list会被拷贝，然后添加到right list的头部，因此最好把length较短的list放在左侧

* 避免使用regexp，如果需要正则表达式，请使用re

* timer模块的大部分函数实现，依赖于一个process，如果过多使用timer，会导致这个process负载过大，影响效率。推荐使用erlang:send_after/3及erlang:start_timer/3

* 避免使用list_to_atom/1，因为erlang中atom数量最大为1048576, 且不进行GC控制。因此如果持续性的调用list_to_atom/1，可能很容易达到系统上限，从而导致emulator terminate。请使用list_to_existing_atom/1。

* list内部实现为一个列表，因此length(List), 需要遍历整个list比较耗时

* 对于不同的数据类型，使用不同的size函数：tuple_size/1, byte_size/1, bit_size/1

* 使用binary match来进行binary的分割，而不使用split_binary/2

* 如果两个list都拥有很多数据，那么请不要使用'--'，而是将数据转化到ordsets，然后调用ordsets:substract/2.

* 对于binary相关操作可以进行binary优化（bin_opt_info编译选项）代码框架：

* f(<<Pattern1,...,Rest/bits>>,...) ->
... % Rest is not used here
f(Rest,...);
f(<<Pattern2,...,Rest/bits>>,...) ->
... % Rest is not used here
f(Rest,...);
...
f(<<>>, ...) ->
ReturnValue.

* 调用lists:flatten/1可以将list扁平化，这个操作代价很大，比'++'还要昂贵。下面这些时候我们可以避免：
将数据发送给port时
调用list_bo_binary/1和iolist_to_binary前

* 小的函数可以让您方便的找出错误的函数和代码

* 不要在同一行出现相同的符号
20 some_fun() ->
21 L = [{key1, v1}, {key2, [some_record#v21, v22]}],
22 ...
编译时，会提示line 21 '[' 语法错误，因为21行有多个 '[' ，所以这个bug不能准确定位，你需要花时间去排查代码。
好的做法是：
20 some_fun() ->
21 L = [{key1, v1},
22 {key2, [some_record#v21, v22]}
23 ],
...
这样，编译其会提示你 line 22 '[' 语法错误，你很开就知道是那个地方错了。

* 使用 CTRL ＋ \ 或 init:stop()，可以退出Erlang，使用CTRL ＋ G 及 CTRL + C 弹出菜单选项，可以选择是否退出Erlang。
其中CTRL ＋ G可以用来连接其他的shell， CTRL ＋ C可以查看其他一些系统信息
Ctrl + C abort 是野蛮的退出方式

* use "open_port({fd,0,2}, [out])" make erlang program write standard error to unix system

* If you don't run experiments before you start designing a new system, your entire system will be an experiment!

* standard data structure desc:

Module Description
sets sets, i.e. a collection of unique elements.
gb_sets sets, but based on a general balanced data structure
gb_tree a general balanced tree
dict maps, also called associative arrays
ets hash tables and ordered sets (trees)
dets on-disk hash tables

Suggestion：
elments count: 0 － 100 | 100 - 10000 | 10000 -
our select : list | ets | gb_tree

* 通过code:clash/0 检测代码中是否有module冲突现象（sticky)

* epmd -d -d 启动 epmd 可以查看erlang node之间的通讯

* 将正常的逻辑代码和错误处理代码分离，发生错误时，尽管错误。由另一个错误处理模块进行处理

* 类似于操作系统，我们的程序也可以分为kernel 和 user 两层，对于kernel绝对不能出现错误，对于user可以出现错误，进行恢复

* process顶层loop涉及的代码及函数，最好在一个module中实现

* process 的register name和module名称一致，便于寻找代码

* 每个process具有一个单一的角色，比如：supervisor 用来进行错误恢复， work 工作者，可以出现错误， trusted worker 不会出现错误

* 通过函数调用可以实现的功能，就不要使用sever实现（如gen_server, 及类似的loop 实现）

* 给消息加一个tag，在发生错误的时候，可以定位到消息，同时也有利于程序的稳健

* 在消息循环中，对于unknown的消息，请调用lib:flush_receive/0 将其清除，减轻process msg queue的长度

* server中总是书写尾递归的循环

* 尽量使用record，而不是原始的tuple来表现数据结构，在使用record时，使用select match：
#person{name = Name, age = Age} = Person

* 对于返回值，最好也添加一个tag，用来说明返回值类型，或者执行成功与否

* 尽可能少的使用catch和try，在erlang程序中，不推荐主动捕获异常。只有当我们的逻辑特别复杂，我们可以使用throw来返回数据，使用catch来获取返回值。

* 当然程序与外界交互，外界数据不可靠时，需要使用catch和try

* 慎重使用process dictory，当你使用get/1, put/1时，你的应用会具有很大的slide effect。可以通过加入一个新的参数来保存原本需要存储到process dictory中数据

* 如果不想使自己糊涂，请不要使用import

* 使用export时，将功能类似的接口组合在一起，并添加合理的注视，这样你的接口更清晰，别人使用起来更方便

* 不要书写嵌套太深的代码

* 不要书写太长的module

* 不要书写太长的函数

* 每行代码不能太长

* 避免使用 "_" 匿名变量，请为每个变量选择有意义的名称，如够某个变量暂时不使用，请以下划线 "_" 开始

* {error, enfile} enfile error in socket 是以为内linux系统中 ulimit 限制，在root下修改：ulimit -n 25000

* {error, enotconn} 表示socket已经关闭

* 在erlang开发时，慎重使用macro，因为erlang的single assign的缘故，同时调用某个marco，而macro又定义了某个变量，可能导致badmatch错误。
比如：
-define(ADDLINEINFO1(F),
(
begin
Str1 = lists:concat(["[Mod:", ?MODULE, " Line:", ?LINE, "]"]),
Str1 ++ F
end
)).
-define(WARN(Log, F, D), log4erl:warn(Log, ?ADDLINEINFO(F), D)).
如果连续使用 WARN, 会出现此错误

* erlang中可以定义很多环境变量：
ERL_MAX_ETS_TABLES 设置最大的ets数目默认1400
ERL_MAX_PORTS erlang最大的port数目默认1024

* .app文件中的start_phases，选项既可以用来作为include applications之间的同步启动，也可以用来对单个application进行分布启动。
顺序如下
包含included app:

application:start(prim_app)
=> prim_app_cb:start(normal, [])
=> prim_app_cb:start_phase(init, normal, [])
=> prim_app_cb:start_phase(go, normal, [])
=> incl_app_cb:start_phase(go, normal, [])
ok

无included app:
application:start(prim_app)
=> prim_app_cb:start(normal, [])
=> prim_app_cb:start_phase(init, normal, [])
=> prim_app_cb:start_phase(go, normal, [])
ok

* 任何时候，都要重视函数的返回值，通过match确保您的预期，如果发生错误，那么就大胆的表达出来。

您可以在這裡操作的事項：

使用 Google 閱讀器訂閱 Erlang Display - erlang:display(All_About_Erlang)
開始使用 Google 閱讀器，輕鬆掌握所有您最愛網站的最新資訊

Embedding Resource with AS 3.0

2009-04-23T00:38:00.003+08:00

哇，用了ActionScript那么久，现在才发现原来Embed那么有用～～可以直接嵌入外部图片，或是外部SWF内的元件，直接用嵌入的资源作为类来创建实例，例如：

[Embed(source="....jpg")]
private var MyImage:Class;
....
var img:Bitmap = new MyImage();

[Embed(source="....swf", symbol="SomeSymbolId")]
private var MySymbol:Class;
....
var sym:Sprite = new MySymbol()

What's my purpose ?

2009-04-22T01:47:00.002+08:00

越來越近畢業，覺得每一天都有那麼多想做的事情，那麼多想學的東東，卻只剩下這麼少的時間～～最近一直听某人說A公司薪水多高B部門福利多好C城市生活多悠閒....感覺像是讀完大學就能過無憂的生活，不同的家庭環境養出來的人想法果然不同，難道讀20年書，學一身技術，就只為了高薪厚祿？為什么我們要重复又重复他人走過的路？

考到間不錯的大學，找到份体面的工作，朋友都覺得我前程無憂，家人都對我寄予厚望，但我卻感受不到畢業生應有的興奮，反而系有點后悔，后悔大學這四年學得太少太少了....

What's my purpose ? Where should I go ?

Prezi 在线动态简报

2009-04-22T01:23:00.003+08:00

Prezi系一個可縮放旋轉的在線動態簡報，比傳統的PowerPoint效果好好多，由于系基于FLASH的，所有文本和圖案內容都可以無限量伸縮，過渡效果十分有動感，可以將內容更好的關聯和展示～～可惜Prezi貌似比較多限制，雖然簡報可以下載，但免費用戶卻只能下載3次....分享協作功能也不如Google Docs～～不過總体來說還是創意十足的，有點衝動山寨一個～～

Firefox翻墙记之Youtube篇～～

2009-04-17T16:03:00.004+08:00

Youtube貌似被封好久了，十分郁悶，无奈只好翻墙了，Firefox有一个插件Gladder可以自动用代理访问被GFW墙了的网站，不过进得了Youtube却还是看不到视频，欺人太甚了！不能在线播，我下载来看！一搜发现一个Youtube视频下载服务KeepHD，哈哈下载速度还不错～～

这个主仆颠倒的国家，什么时候连我们判断是非利害的权力都让给那些狗奴才了？凭什么你们说封就封说禁就禁？
This country needs a little change.

How to use Erlang SSL Socket

2009-04-15T16:29:00.003+08:00

首先要用OpenSSL生成私鑰和證書：

openssl genrsa -des3 -out privkey.pem 2048
生成一個長2048 bit的私鑰，并用密碼以DES算法加密該私鑰，最后輸出為名為privkey.pem的文件。
如果加密了該私鑰，則每次使用的時候都需要提供密碼，如果不需要密碼保謢，去掉-des3參數就可以了～～

openssl req -new -x509 -key privkey.pem -out cert.pem -days 1020
生成一個自簽的測試用證書，輸出為文件cert.pem，有效期為1020天。

然后用Erlang的SSL模塊實現一個ssl socket server和client：


-module(test).
-export([start/0, connect/0]).


%啟動SSL服務
start() ->
    application:start(ssl),
    ssl:seed("seed-every-time"),
    {ok, spawn(fun() -> start_server() end)}.


%運行SSL SOCKET SERVER
start_server() ->
    
    %創建socket server
    {ok, ListenSocket} = ssl:listen(51020, [
        binary, {active, true},
        {keyfile, "privkey.pem"},
        {certfile, "cert.pem"}]),
    io:format("SSL socket server is ready\n", []),

    %接受客戶端連接
    {ok, Sock} = ssl:transport_accept(ListenSocket),
    ok = ssl:ssl_accept(Sock),
    io:format("New ssl client is connected\n", []),
    loop_client(Sock).


%處理來自客戶端的信息
loop_client(Sock) ->
    receive
        {ssl, Sock, Data} ->
            io:format("Receive : ~p\n", [Data]),
            ssl:send(Sock, Data),
            loop_client(Sock);
        {ssl_closed, Sock} -> io:format("Client ~p is discionnected\n", [Sock]);
        {ssl_errlr, Sock, Reason} -> io:format("ERROR : ~p\n", [Reason])
    end.


%客戶端進行連接
connect() ->
    {ok, Sock} = ssl:connect("localhost", 51020, [bianry]),
    io:format("connected\n", []),
    ssl:send(Sock, "this is just a test"),
    receive
        Any ->
            io:format("client receive : ~p\n", [Any])
    end,
    ssl:close(Sock),
    io:format("client closed\n", []).

測試一下能否正常運行：
1> c(test).
{ok,test}

2> test:start().
{ok,<0.46.0>}
SSL server socket is ready

3> test:connect().
New ssl client connected
connected
Receive : <<"this is just a test">>
client receive : {ssl,{sslsocket,6,<0.50.0>},<<"this is just a test">>}
client closed
ok
Client {sslsocket,7,<0.49.0>} is disconnected

哈哈，一切正常～～

Erlang Term Comparisons

2009-04-13T20:57:00.001+08:00

Erlang的比较运算符如下：

== 等于
/= 不等于
=< 小于或等于
<  小于
>= 大于或等于
>  大于
=:= 完全等于
=/= 完全不等于

Erlang list item searching

2009-04-12T15:04:00.002+08:00

使用lists:keysearch函数可以方便的对一个[{key, value}, ....]列表里的指定key进行搜索，函数定义如下：

keysearch(Key, N, TupleList) -> {value, Tuple} | false
    Key = term()
    N = 1..tuple_size(Tuple)
    TupleList = [Tuple]
        Tuple = tuple()

比如说我们有这样的一个列表：

> Attributes = [{to, "jojo@verse.com"},
                {from, "oscar@verse.com/school"},
                {type, "chat"},
                {'xml:lang', "en"}].

> lists:keysearch(from, 1, Attributes).
{value, {from, "oscar@verse.com/school"}}

若指定Key不存在则返回false
> lists:keysearch(not_exist, 2, Attributes).
false

-____- |||

2009-04-11T21:57:00.002+08:00

又一次要用这无语的表情做标题，楼下那恶心的工行ATM机，逢一三五故障二四六吞卡周末必坏.... 西区上万人就放两台ATM，让大家经常大排长龙，远在教学区边缘鸟都不飞去的野地里就放一堆，还有人工服务台，实在是让人郁闷～～

Mnesia 事件处理

2009-04-11T14:31:00.002+08:00

Mnesia会产生两类事件：系统事件（system events）和表事件（table events），用户可创建一个进程来订阅Mnesia所产生的事件，有如下两个相关的函数：

mnesia:subscribe(EventCategory)
当有事件发生时发送一个事件的copy给调用此函数的进程。

mnesia:unsubscribe(EventCategory)
取消事件订阅，不再接收Mnesia产生的事件。

EventCategory可以是system、{table, Tab, simple}或{table, Tab, detailed}。事件会以进程间消息的形式发送给订阅了Mnesia事件的进程，系统事件的格式为{mnesia_system_event, Event}，表事件的格式则为{mnesia_table_event, Event}。

System Events
系统事件有如下几种：

{mnesia_up, Node}
Mnesia在节点Node上被启动；

{mnesia_down, Node}
Mnesia在节点Node上停止了运行；

{mnesia_checkpoint_activated, Checkpoint}
一个与本节点相关的checkpoint被激活了；

{mnesia_checkpoint_deactivated, Checkpoint}
一个与本节点相关的checkpoint被激死（:P）了～～

{mnesia_overload, Details}
本节点上的Mnesia负载过重，可能因为对硬碟的读写请求超过了Mnesia的处理能力，如果不做任何处理可能会导致硬碟空间不足；也可能是Mnesia处理事务的速度跟不上事务的请求速度，事务堆栈可能会越来越大，直至耗尽内存或请求速度减缓。对存在异地备份或位于远程节点上的表发起大量的脏操作（dirty updates）时也可能会引发此事件；

{inconsistent|_database, Context, Node}
Mnesia发现数据库可能存在不一致的情况；

{mnesia_fatal, Format, Args, BinaryCore}
Mnesia发生了致命错误，即将在短时间内终止；

{mnesia_info, Format, Args}
调试系统时，Mnesia发现了一些应用程序可能感兴趣的东东；

{mnesia_error, Format, Args}
Mnesia发生了错误；

{mnesia_user, Event}
某应用程序触发了函数mnesia:report_event(Event)，可用于调试Mnesia。

Table Events
表事件在数据表被更新时发生，分为simple和detailed两种，simple事件包括：

{write, NewRecord, ActivityId}
有新记录被写入；

{delete_object, OldRecord, ActivityId}
记录OldRecord可能被删除了（可能？），如果表类型为bag，则可能还存在其他与OldRecord主键相同的记录；

{delete, {Tab, Key}, ActivityId}
一个或多个记录可能被删除了（可能？？），表里所有主键为Key的记录都已被删除；

detailed事件包括：

{write, Table, NewRecord, [OldRecords], ActivityId}
有新记录被写入；

{delete, Table, What, [OldRecords], ActivityId}
可能有记录被删除（又是可能....），What可能是{Table, Key}或{RecordName, Key, ....}

用qlc进行数据排序与筛选

2009-04-11T13:51:00.002+08:00

Erlang有一个类似SQL的数据检索机制，叫做QLC（Query Interface to Mnesia, ETS, Dets, etc），可用于对Mnesia、ETS/DETS的数据表进行数据检索，包括常见的按指定域排序（ORDER BY）、按条件筛选（WHERE...）以及限制返回的结果长度（COUNT）。看个简单的例子：

-module(test).
-export([start/0]).
-include_lib("stdlib/include/qlc.hrl").

start() ->
    QH1 = qlc:q([{X, Y} || X <- [8,3,6,2], Y <- [b,a,c]]),
    %以第一个值作为key进行排序
    QH2 = qlc:keysort(1, QH1, [{order, ascending}]),
    QC = qlc:cursor(QH2),
    %获取前两条记录
    qlc:next_answers(QC, 2),
    %获取剩余的其他记录
    qlc:next_answers(QC, all_remainning).

Supervisor也崩溃了？？

2009-04-11T01:56:00.002+08:00

今天测试程序的时候出现了一个怪问题：我用一个supervisor（sup）去监督一个gen_server（test）的工作，test崩溃后被重启了，但随即sup也跟着崩溃了，导致整棵监督树倒了...郁闷，检查错误报告（见下）发现test仅仅被重启了一次，不是因为重启次数过多而使得sup崩溃～～

=ERROR REPORT==== 11-Apr-2009::01:51:47 ===
** Generic server test terminating 
** Last message in was error
** When Server state == []
** Reason for termination == 
** error
gen_server test is started （test重启时所输出的信息）
** exception exit: {error,{gen_server,call,[test,error]}}
    in function  gen_server:call/2
13> 
=ERROR REPORT==== 11-Apr-2009::01:51:47 ===
** Generic server sup terminating 
** Last message in was {'EXIT',<0.54.0>,
    {{error,{gen_server,call,[test,error]}},

可见sup系因为收到‘EXIT’信息才崩溃的，大白天谁无缘无故发个‘EXIT’信息出来？Google一番后在Google Groups里找到解答如下：

在erlshell里测试，需要unlink supervisor，这是因为在shell里运行时，进程层次状况如下：

shell
    eval_loop
        sup

这几个进程是link起来的，如不unlink，在出错时eval_loop会退出重启，导致sup收到{'EXIT', Pid, _}而发生退出。

OK，据此稍为修改监督者的启动函数即可：

{ok, Pid} = supervisor:start_link({local, sup}, sup, []),
unlink(Pid).

动态增删Mnesia数据库节点

2009-04-10T22:36:00.002+08:00

Mnesia支持动态的增删节点以进行数据转移或备份：

首先启动新节点上面的mnesia
> rpc:call(Node, mnesia, start, []).
添加新节点
> {ok, _} = mnesia:change_config(extra_db_nodes, [Node]).
修改新节点上的schema表的类型
> {atomic, ok} = mnesia:change_table_copy_type(schema, Node, disc_copies).

OK，现在可以在新节点上添加表备份、分块等等了，如果不再需要某个节点，可以这样删除节点：

首先关闭该节点上的mnesia
> rpc:call(Node, mnesia, stop, []).
删掉该节点上的schema表
> {atomic, ok} = mnesia:del_table_copy(schema, Node).
> ok = mnesia:delete_schema([Node]).

record_info不能接受參數？

2009-04-10T20:39:00.002+08:00

Q：有如下函數：

1> rd(test, {key, value}).
2> Arg = test.
3> record_info(fields, test).
[key, value]
4> record_info(fields, Arg).
* 1: illegal record info

Arg跟記錄名test系一樣的，為什么传入record_info里會提示错误呢？？

A：转Google Goups - [erlang-questions]上的一段解答：
record_info is not a proper function. It only exists during compilation, which means that it cannot take variable arguments:

record_info(fields, address) %% works
Rec = address,
record_info(fields, Rec) %% doesn't work!

Of course it only works if the address record is defined in that module. If you do want a function that uses record_info, try to use a macro instead.

定義成Macro就可以？馬上試試先：

-record(test, {key, value}).
-define(FIELDS(Record), record_info(fields, Record)).
....
?FIELDS(test).
> [key, value]

哇哇，果然OK哦～～

Local Content Tables

2009-04-10T17:03:00.002+08:00

分布於多個節點上的同一個表，在各節點的備份上都保持有相同的數据，不過呢有時可能需要同一個表在不同節點備份上有不同的內容，這時就需要用到Local Content Tables了～～

如果我們創建表的時候將其屬性設置為{local_content, true}，表同樣會分布多個備份到我們所指定的節點上，但寫操作僅會影響本地節點，不會同步到其他節點的備份上。另外當mnesia啟動時，這樣的表也僅會從本地讀取初始化數据，不會等待其他節點上的備份～～

感覺有點像表的分塊哦～～

Mnesia Table Fragmentation

2009-04-10T13:45:00.013+08:00

The Concept
Mnesia支持將一個龐大的數据表分割為多個分塊，每個分塊跟一個普通的表一樣，可以備份可以創建索引等。讀寫數据的時候，Mnesia通過mnesia_frag模塊（一個mnesia_access callback behaviour）來定位實際數据位于哪個分塊里：首先mnesia_frag根据記錄的key記算一個hash值，然后根据該hash值決定表分塊的名稱，最后用普通的數据庫讀寫函數來堆該表分塊進行讀寫。若事前不知道記錄的key，則mnesia會搜索所有的分塊來尋找匹配的記錄。

下面的代碼描述如何將一個已存在的mnesia數据表轉化為一個分塊的表，以及如何動態的添加新分塊：

(a@oscar) 1> mnesia:start().
ok

當前有a、b、c三個節點正在運行
(a@oscar) 2> mnesia:system_info(running_db_nodes).
[b@oscar, c@oscar, a@oscar]

創建一個表dictionary
(a@oscar) 3> Tab = dictionary.
(a@oscar) 4> mnesia:create_table(Tab, [{ram_copies, [a@oscar, b@oscar]}]).
{atomic, ok}
(a@oscar) 5> Write = fun(Keys) -> [mnesia:write({Tab, K, -K}) || K <- Keys], ok end.
#Fun<....>
(a@oscar) 6> mnesia:activity(sync_dirty, Write, [lists:seq(1, 256)], mnesia_frag).
ok

啟動表分塊
(a@oscar) 7> mnesia:change_table_frag(Tab, {activate, []}).
{atomic, ok}

查看一下与分塊相關屬性
(a@oscar) 8> mnesia:table_info(Tab, frag_properties).
[{base_table, dictionary},
 {foreign_key, undefined},
 {n_doubles, 0},
 {n_fragments, 1},
 {next_n_to_split, 1},
 {node_pool, [a@oscar, b@oscar, c@oscar]}]

添加分塊
(a@oscar) 9> Info = fun(Item) -> mnesia:table_info(Tab, Item) end.
#Fun<....>
(a@oscar) 10> Dist = mnesia:activity(sync_dirty, Info, [frag_dist], mnesia_frag).
[{c@oscar,0}, {a@oscar,1}, {b@oscar, 1}]
(a@oscar) 11> mnesia:change_table_frag(Tab, {add_frag, Dist}).
{atomic, ok}

再添加兩個分塊
(a@oscar) 12> Dist2 = mnesia:activity(sync_dirty, Info, [frag_dist], mnesia_frag).
[{b@oscar, 1}, {c@oscar, 1}, {a@oscar, 2}]
(a@oscar) 13> mnesia:change_table_frag(Tab, {add_frag, Dist2}).
{atomic, ok}
(a@oscar) 14> Dist3 = mnesia:activity(sync_dirty, Info, [frag_dist], mnesia_frag).
[{a@oscar, 2}, {b@oscar, 2}, {c@oscar, 2}]
(a@oscar) 15> mnesia:change_table_frag(Tab, {add_frag, Dist3}).
{atomic, ok}

從分塊里讀取數据
(a@oscar) 16> Read = fun(Key) -> mnesia:read({Tab, Key}) end.
#Fun<....>
(a@oscar) 17> mnesia:activity(transaction, Read, [12], mnesia_frag).
[{dictionary, 12, -12}]

查看各分塊所包含的數据量
(a@oscar) 18> mnesia:activity(sync_dirty, Info, [frag_size], mnesia_frag).
[{dictionary, 64},
 {dictionary_frag2, 64},
 {dictionary_frag3, 64},
 {dictionary_frag3, 64}]
（哇，這么均衡～～）

Fragmentation Properties
可調用mnesia:table_info(Tab, frag_properties)函數來查看指定表的分塊清況，包含如下屬性（不全）：

{n_fragments, Int}：當前表包含有多少個分塊，此屬性可在創建表時設定，或由{add_frag, NodesOrDist}、del_frag等操作所修改，默認值為1。

{node_pool, List}：分塊節點池，可在表創建時指定，或由{add_node, Node}、{del_node, Node}等操作所修改，在創建數据表的時候，mnesia會將表的分塊平均的分布到節點池里的各個節點上，默認為mnesia:system_info(db_nodes)的返回值。

{n_ram_copies, Int}：設定每個分塊應該有多少個ram_copies型備份，默認為0，但若n_disc_copies和n_disc_only_copies都為0，則此屬性會默認為1。

{n_disc_copies, Int}：設定每個分塊應有多少個disc_copies型備份，默認為0。

{n_disc_only_copies, Int}：設定每個分塊應有多少個disc_only_copies型備份，默認為0。

{hash_module, Atom}：此屬性允許用戶指定一個散列模式（hashing schema），此模塊必須實現mnesia_frag_hash回調行為（callback behaviour），默認為mnesia_frag_hash。

Management of Fragmented Tables
函數mnesia:change_table_frag(Tab, Change)用于修改分塊表的配置，其中Change可能為如下值：

{activate, FragProps}：激活已存在表的分塊机制，FragProps應為{node_pool, Nodes}或[]。

deactivate：關閉表的分塊机制，其分塊數必須為1。

{add_frag, NodesOrDist}：向分塊表添加一個新的分塊，其中一個舊分塊里的數据會被重新散列，它們中的約一半會被搬到新的分塊上去。所有其他含有指向該表的外鍵的分塊表都會自動得到一個新分塊，并按同樣的方式重新分布數据。
NodesOrDist可以是一列節點，或函數mnesia:table_info(Tab, frag_dist)的返回值，NodesOrDist應該是一個有序的數組，其中最适合放置新分塊的節點放在最前面的位置，新的分塊會得到与第一個分塊同樣數量的備份。

del_frag：從分塊表里刪除一個分塊，最后一個分塊的所有數据都會被搬到另一個分塊里。

{add_node, Node}：向node_pool里添加一個新節點，新的節點池會改變函數mnesia:table_info(Tab, frag_dist)的返回值。

{del_node, Node}：從node_pool里刪除一個節點，同樣也會改變函數mnesia:table_info(Tab, frag_dist)的返回值。

Erlang OTP - Supervisor

2009-04-09T15:46:00.006+08:00

supervisor behaviour用于实现层状监督树机制，包含一套标准的接口函数和追踪错误等的功能，监督者负责启动、停止和监督其子进程的工作，子进程可以是一个工作进程，也可以是一个子监督者，监督者机制的基本理念是通过自动重启子进程而保证其能正常持续的对外提供服务。

监督者的子进程由child specifications列表定义，当监督者启动时，其子进程将按该列表顺序从左到右启动，监督者终止运行时，其子进程将按相反方向关闭，最后终止监督者自己。子进程列表定义如下：

child_spec() = {Id, StartFunc, Restart, Shutdown, Type, Modules}
    Id = term()
    StartFunc = {M, F, A}
        M = F = atom()
        A = [term()]
    Restart = permanent | transient | temporary
    Shutdown = brutal_kill | int()>=0 | infinity
    Type = worker | supervisor
    Modules = [Module] | dynamic
        Module = atom()

其中Id是监督者内部标识该子进程的名称，StartFunc定义了启动该子进程所需调用的函数，这个启动函数必须创建并连接到一个子进程，然后返回{ok, Child}或{ok, Child, Info}，Child是子进程的pid，Info会被监督者所忽略；如果子进程因某些原因未能启动可返回ignore；如果发生了错误也可以返回一个{error, Error}。

Restart定义了子进程何时将会被重启：
permanent：无论子进程因何终止都应被重启；
temporary：无须重启子进程；
transient：仅在子进程因非正常原因终止时才重启子进程。

Shutdown定义了子进程应被如何终止：
brutal_kill：使用exit(Child, kill)强制终止；
int()>=0：监督者调用exit(Child, shutdown)告知子进程终止并等待其终止信号，若超过指定时间尚未收到再调用exit(Child, kill)来强制终止；
infinity：如果子进程为一个子监督者，则应将超时时间设定为infinity，以让其有充足时间来终止其子监督树。

Type定义了子进程是一个监督者还是一个工作进程。

监督者对子进程的重启方式（Restart Strategy）有如下几种：
one_for_one：如果一个子进程终止了，则只需重启该子进程；
one_for_all：如果一个子进程终止了，所有其他子进程都将被终止，然后重启所有子进程；
rest_for_one：如果一个子进程终止了，则按启动顺序比其晚启动的其他子进程都将被终止，然后该子进程和被终止掉的其他子进程都会被重启；
simple_one_for_one：是one_for_one的简化版，该监督者的所有子进程都是动态加入的，并且每个子进程类型都相同，都运行一样的代码。

为了避免监督者陷入子进程被不停的终止－重启的死循环，每个监督者都有一个最大重启频度（maximum restart frequency），由参数MaxR和MaxT所决定，如果在MaxT秒内发生多于MaxR次子进程重启，则监督者会终止其所有子进程和它本身。

Callback Module
supervisor behaviour的回调模块僅包含一个回调函数init/1：

init(_Args) ->
    {ok, {{RestartStrategy, MaxR, MaxT}, [ChildSpec]}}

Starting a Supervisor
监督者通过调用函数supervisor:start_link/2来启动，如下：

supervisor:start_link(MODULE, []).

MODULE为该监督者的回调模块，第二个参数为传入到回调函数init/1里的参数。如果想为该监督者注册个名字，也可以用下面这个函数来启动：

supervisor:start_link({local, Name}, Module, Args) 或
supervisor:start_link({global, Name}, Module, Args)

启动后，监督者会调用回调模块里的init/1函数，并根据该函数的返回值启动其子进程，注意supervisor:start_link这函数不是异步的，要直到所有子进程都启动后才会返回。

Adding a Child Process
监督树可以是静态的，也可以是动态的，我们可以随时加入新的子进程到监督树中：

supervisor:start_child(Sup, ChildSpec)

其中Sup是监督者的pid或注册名，ChildSpec是一个子进程声明。动态增添的子进程和其他子进程一样，但若监督者死掉然后被重新启动后，所有动态添加的子进程都会丢失。

Stopping a Child Process
所有子进程无论动态静态，都可以按照关闭设置被停止运行：

supervisor:terminate_child(Sup, Id)

可用如下函数删除被停止运行的子进程的进程声明：

supervisor:delete_child(Sup, Id)

同样，监督者本身重启后，删除静态子进程的操作将失效。

Mnesia写入数据错误？

2009-04-08T11:21:00.005+08:00

Q:我创建了如下一个Mnesia表，为何写入数据时会出现bad type错误呢？？

> rd(message, {to, from, content}).
> mnesia:create_table(msg, [{attributes, record_info(fields, message)}]).

> mnesia:dirty_write({message, jojo, oscar, <<"missing you">>}).
** exception exit: {aborted,{no_exists,message}}
    in function  mnesia:abort/1

> mnesia:dirty_write(msg, {message, jojo, oscar, <<"test">>}).
** exception exit: {aborted,{bad_type,
    #message{to = jojo, from = oscar, content = <<"test">>}}}
        in function  mnesia:abort/1

A:第一次执行dirty_write时提示没有找到message表，当表名和表所存储的record名相同时，写入数据时可以忽略表名，但现在表名并非message而是msg，好吧我们指定一个表名再写入试试，这次却出现了第二个错误提示类型错误，郁闷，原来当表名和record名不同时，创建表的时候应另外添加一个参数{record_name, ...}，即：

> mnesia:create_table(msg, [
    {attributes, record_info(fields, message)},
    {record_name, message}]).

这样就可以正常插入数据了~~

I am back ~~

2009-04-07T22:05:00.002+08:00

祭祖归来~~学校校园网验证更新后，Ubuntu依然没有可用的客户端连接网络，无耻的网管！Youtube依然未能访问，无耻的GFW！go2居然说暂停对国内提供代理服务，要“增加过滤技术”，唉，还有什么话好说的呢~~

This country needs a little change ....

我不高兴～～

2009-04-04T12:35:00.004+08:00

今天报纸上看到几句言论比较精彩，特意记下来：

“在一个法治上轨道的国家里，人是有权生气的。....不要以为你是大学教授，所以做研究比较重要；不要以为你是杀猪的，所以没有人会听你的话；也不要以为你是个大学生，不够资格管社会的事。你今天不生气，不站出来的话，明天－－还有我、还有你我的下一代，就要成为沉默的牺牲者、受害人！如果你有种、有良心，你现在就去告诉你的公仆‘立法委员’、告诉卫生署、告诉环保局：你受够了，你很生气！你一定要很大声地说。”－－龙应台

“在一个代议制国家，我的利益被人堂而皇之地代表。然而，代表我利益的人姓甚名谁我竟不知晓－－即使是那隐姓埋名的佐罗，我也知道他的刀剑与相貌。他们从来没有向我询问过我需要什么利益。为此，我不高兴。”

“17世纪英国中央政府给社会带来的经济负担不到5%，想到2007年中国财政收入占GDP比例占到了20.80%，而且财政收入的1/3被用于‘三公消费’，大学生不去创业，而是争考公务员。国富民穷，权利诱人。为此，我不高兴。”

回想一下，我见识过两次人大代表的选举方式：一次是在我家乡珠海，村委们拿出一张所谓选票，上面有几个人名，老实说我是一个也不认识，也从来没见过他们出来宣传自己，告诉大家他会为大家争取些什么做些什么，随便打一个勾把票投了，就可以换来10块钱，实在是神奇，至于投完票后结果如何、点票是否公正、甚至说到底有没点票，实在是无人知晓；另一次是在广州读大学时，学校贴出个公告，说我们学校某某老师要参选人大，要求同学“踊跃支持”，但我为什么要支持一个我素未谋面毫无了解的人做自己的代表呢？学校的公告里貌似只给出了因为他是我们学校的老师这一条原因 -____- ||| 所以，我两次都没有参与～～

郁闷～～

2009-04-03T22:05:00.002+08:00

鬱悶啊！今天校園網要強製換用新的客戶端，卻只提供了Windows版，平時上網慢的難以忍受也就忍過去了，現在Linux是完全上不了网～～我還要在Ubuntu下搞畢業設計的啊！該死的牙又痛了整天....

設置Erlang最大總進程數

2009-04-03T16:37:00.009+08:00

Erlang默認的最大進程總數隻有32768個，有時不怎么夠用，此時可以在啓動Erlang時加上參數“+P”來設置最大進程總數，如下：

erl +P 100000

看看是否設置成功：

1> erlang:system_info(process_limit).
100000

不過雖說在Erlang里進程不用錢，但也不應該想開多少就開多少，不然內存資源會被迅速耗盡死機的～～比如說我們創建1百萬個進程，看看繫統資源佔用情況：

黑色框部分就是創建1百萬個進程時的內存消耗情況，我那1.5GB的內存被迅速用光，交換區也被猛吃了一截....

Toothache ....

2009-04-03T13:00:00.002+08:00

嗚嗚～～牙好痛好痛～～

利用List Comprehension過慮列表里的項目

2009-04-02T19:57:00.003+08:00

Erlang的數据結構十分容易進行匹配和過慮，下面演示個例子：

首先定義一個結構體
1> rd(person, {name, gender}).

創建一個person列表
2> List=[
2>     {person, oscar, male},
2>     {person, jojo, female},
2>     {person, god, male},
2>     {person, jessica, female}].

我們現在過慮出所有gender為male的人的名字
3> [P#person.name || P <- List, P#person.gender==male].
[oscar, god]

再將名為jojo的項目過慮出來
4> [P || P <- List, P#person.name==jojo].
[#person{name = jojo, gender = female}]

很簡便吧～～有興趣的可詳細參見這里。

Google Docs的繪圖功能

2009-03-30T14:38:00.001+08:00

哇，今天發現原來Google Docs支持繪圖功能的，如下圖所示：

SCIM輸入選框無法自動跟隨光標？

2009-03-29T17:57:00.004+08:00

Ubuntu下的中文輸入法真係多災多難，之前出現詞頻無法調整的問題，貌似換用繁体中文後就沒事了，今天又發現輸入選框沒有自動跟隨光標的位置，而係傻傻的呆在屏幕上....Google一番得出如下解決方法：
打開/etc/X11/xinit/xinput.d/scim文件，找到如下內容：
GTK_IM_MODULE=xim
QT_IM_MODULE=xim

將它們該成：
GTK_IM_MODULE=scim
QT_IM_MODULE=scim

注銷或重啟X即可～～

Erlang 查看文件屬性

2009-03-29T14:06:00.003+08:00

要查看某文件F的屬性，我們可以調用file:read_file_info(F)，如果F係一個有效的文件或目錄名，則函數返回{ok, Info}，Info係一個#file_info類型的record，包含如下項：
size：文件的大小（字節）；
type：類型，可能為：device, directory, regular, other；
access：讀寫模式，可能為：read, write, read_write, none；
atime：文件最后一次被讀的本地時間：{{Year, Mon, Day}, {Hour, Min, Sec}}；
mtime：文件最后一次被寫入的本地時間；
ctime：此項對不同的操作系統有不同的意義，在Unix下為文件或inode最后一次更改的時間，在Windows下為文件的創建時間；
mode：（整數）文件權限；
links：連接到該文件的鏈接個數（如果文件系統不支持連接則為1）；
major_device：（整數）用于標識文件系統（Unix）或設備號（A:=0, B:=1）（Windows）。

mode和access的功能其實係一樣的，不過你可以用mode來一次過設置多個文件的屬性。下例演示如何查看文件的大小和類型（注意需要包含file.hrl文件，其包含了#file_info的定義）：

-include_lib("kernel/include/file.hrl").
file_size_and_type(File) ->
    case file:read_file_info(File) of
        {ok, Facts} ->
            {Facts#file_info.type, Facts#file_info.size};
        _ ->
            error
    end.

還有一种更為方便的方式，filelib模塊里包含了一些諸如file_size(File)和is_dir(X)的函數，如果你僅需得到文件的大小信息，直接調用file_size(File)就可以了，不用使用file:read_file_info那么囉嗦～～

譯自《Programming Erlang》- Chapter 13 - Programming with Files

Erlang Directory Operations

2009-03-29T13:51:00.002+08:00

file模塊里有三個函數用于目錄操作：list_dir(Dir)用于列舉目錄Dir里的所有文件；make_dir(Dir)用于創建一個新目錄；del_dir(Dir)用于刪除目錄，例如：

1> cd("/home/joe/book/erlang/Book/code").
/home/joe/book/erlang/Book/code
ok
2> file:list_dir(".").
{ok, ["id3_v1.erl~",
    "update_binary_file.beam",
    "benchmark_assoc.beam",
    ....
]}

大家可以發現，輸出的文件列表貌似沒有什么順序，也沒有信息說明某項是文件還是子目錄，更沒有文件大小等信息....想要查看上述這些信息，我們可以使用函數file:read_file_info，詳細介紹見下一篇文章～～

譯自《Programming Erlang》- Chapter 13 - Programming with Files

Erlang文件讀寫

2009-03-29T10:22:00.007+08:00

Organization of the Libraries
操作文件的函數被組織成如下4個模塊：
file：打開、關閉、讀寫文件、列取目錄等；
filename：跨平台的文件名操作模塊；
filelib：係file的擴展模塊，包含一系列用于列取文件、檢查文件類型等的函數；
io：用于操作已經打開的文件，例如格式化輸出數据到文件等。

The Different Ways of Reading a File
例如我們要操作包含如下內容的一個文件data1.dat：

{person, "oscar", "tang",
    [{occupation, programmer}, {favoriteLanguage, erlang}]}.
{cat, {name, "ml"},{owner, "oscar"}}.

下面我們用几种方式來讀取上述文件：

Reading All the Terms in the File
函數file:consult可讀取文件里包含的所有Erlang terms：

1> file:consult("data1.dat").
{ok, [{person, "oscar", "tang",
    [{occupation, programmer}, {favoriteLanguage, erlang}]},
    {cat, {name, "ml"}, {owner, "oscar"}}]}

file:consult(File)假設文件由一堆Erlang terms組成，如成功讀取文件里的所有terms則返回{ok, [Term]}，否則返回{error, Reason}。

Reading the Terms in the File One at a Time
如果想逐個讀取文件里的erlang term，可首先用file:open來打開文件，然后用io:read讀取一個erlang term，直到去到文件尾，最后用file:close關閉文件：

1> {ok, S} = file:open("data1.dat", read).
{ok, <0.36.0>}
2> io:read(S, '').
{ok, {person, "oscar", "tang",
    [{occupation, programmer}, {favoriteLanguage, erlang}]}}
3> io:read(S, '').
{ok, {cat, {name, "ml"}, {owner, "oscar"}}}
4> io:read(S, '').
eof
5> file:close(S)

上例用到的函數用法如下：
@spec file:open(File, read) -> {ok, IoDevice} | {error, Why}
嘗試以讀取方式打開文件，如果成功打開則返回{ok, IoDevice}，否則返回{error, Reason}，IoDevice係一個用于操作文件的標識符。

@spec io:read(IoDevice, Prompt) -> {ok, Term} | {error, Why} | eof
從IoDevice處讀取一個erlang term，如果係讀取文件，參數Prompt會被省略，當我們用io:read從標准輸入處獲取用戶輸入時，Prompt負責輸出一句提示輸入的信息。

@spec file:close(IoDevice) -> ok | {error, Why}
關閉文件。

使用上述的几個函數我們就可以自己實現file:consult了：

consult(File) ->
    case file:open(File, read) of
        {ok, S} ->
            Val = consult1(S),
            file:close(S),
            {ok, Val};
        {error, Why} ->
            {error, Why}
    end.

consult1(S) ->
    case io:read(S, '') of
        {ok, Term} -> [Term | consult1(S)];
        eof -> [];
        Error -> Error
    end.

BUT file:consult其實并非這樣定義的，它有更好的錯誤報告功能，如果你明白上面的代碼的話，可以去看看真正的file:consult係怎樣的。不過還有一個小問題，我們去哪里找file.erl的源文件？Well，我們可以使用函數code:which，該函數可以定位任何已加載模塊的源文件所在路徑：

1> code:which(file).
"/usr/local/lib/erlang/lib/kernel-2.11.2/ebin/file.beam"

在標准發布（standard release）里，每個庫都包含有兩個子目錄，一個叫做src，包含源文件，另一個叫ebin，包含已編譯的Erlang代碼，所以根据上面的返回結果，我們可以知道file.erl的源文件應該在：
/usr/local/lib/erlang/lib/kernel-2.11.2/src/file.erl

Reading the Lines in a File One at a Time
如果我們將io:read換成io:get_line，我們就可以每次讀取文件的一行數据，例如：

1> {ok, S} = file:open("data1.dat", read).
{ok, <0.43.0>}
2> io:get_line(S, '').
"{person, \"oscar\", \"tang\", \n"
3> io:get_line(S, '').
"\t[{occupation, programmer}, {favoriteLanguage, erlang}]}.\n"
....
6> io:get_line(S, '').
eof
7> file:close(S).
ok

Reading the Entire File into a Binary
你可以用函數file:read_file(File)將整個文件當作一個二進製數据來讀取：

1> file:read_file("data1.dat").
{ok, <<"{person, \"oscar\", \"tang\"" ....>>}

如果讀取成功的話，file:read_file(File)返回{ok, Bin}，否則返回{error, Why}。這種方式係至今讀取文件最高效的方式。

Reading a File with Random Access
如果我們想要讀取的文件非常大不能一次過進行讀取，那么我們可以打開raw模式用file:pread來讀取文件的任何部分，例如：

1> file:open("data1.dat",[read, binary, raw]).
{ok, {file_descriptor, prim_file, {#Port<0.106>, 5}}}
2> file:pread(S, 22, 46).
{ok, <<"ng\", \n\t[{occupation, progr ....>>}
3> file:pread(S, 1, 10).
{ok, <<"person, \"o">>}
4> file:pread(S, 2, 10).
{ok, <<"erson, \"os">>}
5> file:close(S).

file:pread(IoDevice, Start, Len)從IoDevice處讀取以Start為開頭讀取Len個字節的數据（第一個字節的位置為1，不是0），返回{ok, Bin}或{error, Why}。

The Different Ways of Writing to a File
寫文件的過程跟讀文件差不多～～

Write a List of Terms to a File
假設我們想要創建一個能用file:consult來讀取的文件，標准庫里并沒有提供這樣的一個函數，所以我們要自己實現，看下面的例子：

unconsult(File, L) ->
    {ok, S} = file:open(File, write),
    lists:foreach(fun(X) -> io:format(S, "~p.\n", [X] end, L),
    file:close(S).

然后在shell里運行上述代碼：

1> lib_misc:unconsult("test1.dat",
    [{cats, ["zorrow", "daisy"]},
    {weather, snowing}]).
ok

看看是否寫入成功并且可以正常打開：

2> file:consult("test1.dat").
{ok, [{cats, ["zorrow", "daisy"]}, {weather, snowing}]}

unconsult首先以write模式來打開文件，然后用io:format(S, "~p\n", [X])來將erlang terms輸出到文件里。

Writing Lines to a File

1> {ok, S} = file:open("test2.dat", write).
{ok, <0.62.0>}
2> io:format(S, "~s\n", ["Hello readers"]).
ok
3> io:format(S, "~w\n", [123]).
ok
4> io:format(S, "~s\n", ["that's it"]).
ok
5> file:close(S).

上述代碼會生成一個名為test2.dat的文件，并寫入如下內容到文件里：

Hello readers
123
that's it

Writing an Entire File in One Operation
用函數file:write_file(Filename, Bytes)一次過寫入整個文件，係最有效率的寫文件操作，如果指定的文件不存在則自動創建一個。

Writing to a Random-Access File
首先我們要先把文件以write模式打開，然后用函數file:pwrite(Position, Bin)來寫入文件，例如：

1> {ok, S} = file:open("....", [raw, write, binary]).
{ok, ....}
2> file:pwrite(S, 10, <<"new">>).
ok
3> file:close(S).
ok

上述代碼在文件的第10個字節位置處寫入字符串"new"，如果原先已經有舊的內容，則舊內容會被覆蓋掉～～

譯自《Programming Erlang》- Chapter 13 - Programming with Files

Erlang Gen_Event Behaviour

2009-03-29T00:12:00.003+08:00

Event Handling Principles
在Erlang OTP里，事件管理器（event manager）係一個用于處理事件的模塊，這些事件可能係錯誤、警報、或其他需要被記錄的信息。

在事件管理器里可能會有0個、1個或多個事件處理器（event handlers），當事件管理器接收到事件時，所有這些事件處理器都會對事件進行處理。比如有一個處理錯誤的事件管理器，它有一個默認的事件處理器將錯誤信息輸出到終端顯示；你可以為其添加另一個事件處理器，在特定情況下將錯誤信息寫入文件；當不再需要將信息寫入文件時，可以將這個事件處理器移除。

事件管理器實質上係一個接收事件的進程，而事件處理器則為一個回調模塊（callback module）。

Example
下例演示如何實現一個將錯誤信息輸出到終端的事件處理器：

-module(terminal_logger).
-behaviour(gen_event).
-export([init/1, handle_event/2, terminate/2]).

init(_Args) ->
    {ok, []}.

handle_event(ErrorMsg, State) ->
    io:format("***ERROR*** ~p\n", [ErrorMsg]),
    {ok, State}.

terminate(_Args, _State) ->
    ok.

而將錯誤信息寫入文件的事件處理器可以這樣寫：

-module(file_logger).
-behaviour(gen_event).
-export([init/1, handle_event/2, terminate/2]).

init(File) ->
    {ok, Fd} = file:open(File, read),
    %原文的打開方式係read，但我覺得應該是write或append吧
    {ok, Fd}.

handle_event(ErrorMsg, Fd) ->
    io:format(Fd, "***ERROR*** ~p\n", [ErrorMsg]),
    {ok, Fd}.

terminate(_Args, Fd) ->
    file:close(Fd).

下面會詳細講解上述代碼。

Starting an Event Manager
要啟動事件管理器來處理錯誤，可使用如下函數：

gen_event:start_link({local, error_man}).

這函數會新生并連接一個新進程，即事件管理器進程。參數{local, error_man}指定了該事件管理器的注冊名，此例中其注冊名為error_man，僅在本節點有效。如果不注冊一個名字，則必需通過事件管理器進程的進程標識PID來向其發送信息，注冊名也可以設置為{global, Name}。

如果事件管理器係屬於監督樹的一部分，則必需通過gen_event:start_link來啟動。另外有一個gen_event:start函數來啟動一個獨立的事件管理器～～

Adding an Event Handler
下例在shell里演示如何啟動一個事件處理器并為其添加一個事件處理器：

1> gen_event:start({local, error_man}).
{ok, <0.31.0>}
2> gen_event:add_handler(error_man, terminal_logger, []).
ok

上述函數向名為error_man的事件管理器發送一個事件，告訴它添加一個事件處理器terminal_logger，事件管理器會調用terminal_logger模塊的初始化函數terminal_logger:init([])，其中[]即add_handler函數里的第三個參數。init應該返回{ok, State}，State即事件處理器的內部狀態。

Notifying About Events

3> gen_event:notify(error_man, no_reply).
***Error*** no_reply
ok

error_man係事件管理器的名字，no_reply係事件。事件會作為信息發送給事件管理器進程，接收到事件後，事件管理器會按照添加順序調用它每個事件處理器的handle_event(Event, State)函數來處理事件，這些函數都應返回{ok, State1}，State1即事件處理器的新內部狀態。

Deleting an Event Handler

4> gen_event:delete_handler(error_man, terminal_logger, []).
ok

上述函數向名為error_man的事件管理器發送一個信息，告知它刪除事件處理器terminal_logger，事件管理器會調用terminal_logger模塊的terminate([], State)函數來終止該處理器。terminate函數應進行一些必要的清理工作等，其返回值會被忽略～～

Stopping
當事件管理器停止時，它會給机會給它的每一個事件處理器進行清理工作。如果該事件處理器係監督樹的一部分，事件管理器在必要的時候會被其監督者關閉；如果是一個獨立的事件管理器，則可調用如下函數去停止它：

>gen_event:stop(error_man).
ok

Erlang Generic Event Handling

2009-03-28T13:32:00.010+08:00

當我們編程去處理事件的時候，只需將事件作為一個信息發送給負責處理事件的進程：

RegProcName ! {event, E}

E就係一個事件（可以係任何Erlang數据類型），RegProcName即處理進程的注冊名。事件發送出去後，發送方就毋需關心該事件會被如何處理了～～

現在我們看看處理事件的進程（事件處理器 - event handler），看個例子：

-module(event_handler).
-export([make/1, add_handler/2, event/2]).

%創建一個名為Name的新事件處理器
%其接收到事件後，會執行函數no_op/1
make(Name) ->
    register(Name, spawn(fun() -> my_handler(fun no_op/1) end)).

add_handler(Name, Fun) -> Name ! {add, Fun}.

%產生一個事件
event(Name, X) -> Name ! {event, X}.

my_handler(Fun) ->
    receive
        {add, Fun1} ->
            my_handler(Fun1);
        {event, Any} ->
            (catch Fun(Any)),
            my_handler(Fun)
    end.

no_op(_) -> void.

上例的事件處理器有如下功能：
event_handler:make(Name)：創建一個名為Name的事件處理器；
event_handler:event(Name, X)：向名為Name的事件處理器發送事件X；
event_handler:add_handler(Name, Fun)：將事件處理器的處理函數（最初係一個什么都不幹的函數no_op/1）替換為Fun，替換後當接收到事件時，就會調用新的處理函數Fun來處理該事件。

運行試試效果如何：

1> event_handler:make(errors).
true
2> event_handler:event(errors, hi).
{event, hi}

Well，沒咩特別事發生，因為現在的處理函數什么都不幹～～我們接著寫個回調模塊（callback module）來設立一個會做實際工作的事件處理函數：

-module(motor_controller).
-export([add_event_handler/0]).

add_event_handler() ->
    event_handler:add_handler(errors, fun controller/1).

controller(too_hot) -> io:format("Turn off the motor!n");
controller(X) -> io:format("~w ignored event: ~p~n", [?MODULE, X]).

上述代碼編譯之後就會添加一個事件處理函數了：

3> c(motor_controller).
{ok, motor_controller}
4> motor_controller:add_event_handler().
{add, #Fun}

現在向事件處理器發送信息，將由函數motor_controller:controller/1來處理：

5> event_handler:event(errors, cool).
motor_controller ignored event: cool
{event, cool}
6> event_handler:event(errors, too_hot).
Turn off the motor
{event, too_hot}

好了，上面寫了一大堆，到底都做了些什么呢？首先我們提供了一個接收事件的事件處理器（這里係一個注冊名為errors的進程），然后定義了如何發送事件給該處理器（發送方毋需知道處理器會對事件作什么處理），最后我們看到怎么在運行過程中動態的更新事件處理函數。

譯自《Programming Erlang》

Erlang Exception Handling

2009-03-27T00:15:00.019+08:00

Raising an Exception
当系统检测到有错误发生时会自动丢出一个异常，这些异常通常都是由模式匹配错误（没有符合的匹配结果）或传入不当类型的参数到BIFs函数里而引起的。

我们也可以用如下BIFs手动的抛出异常：
exit(Why)：当你想终止当前进程的运行时可调用此BIF，如果不捕捉住这个异常，当前进程就会广播{'EXIT, Pid, Why}到所有与其相连的进程。

throw(Why)：此BIF用于抛出异常。写程序注释时应注明调用此BIF的函数可能会抛出些什么异常。

erlang:error(Why)：此BIF用于抛出一个“崩溃性错误（crashing errors）”，即一些比较奇异的我们没有意料到的错误。

try .... catch
如果你熟悉Java的话，一定知道try...catch系干什么的，Java可以用如下方式来捉住一个异常：

try{
    block
} catch(exception type identifier){
    block
} catch(exception type identifier){
    block
} ....
finally{
    block
}

Erlang处理异常的方式也十分相近，就像这样：

try FuncOrExpressionSequence of
    Pattern1 [when Guard1] -> Expressions1;
    Pattern2 [when Guard2] -> Expressions2;
    ....
catch
    ExceptionType: ExPattern1 [when ExGuard1] -> ExExpressions1;
    ExceptionType: ExPattern2 [when ExGuard2] -> ExExpressions2
after
    AfterExpressions
end

try...catch的工作方式是这样的：首先执行FuncOrExpressionSeq，如果这部分代码没有引发任何异常，函数就会根据Pattern1、Pattern2....来匹配一个函数返回值，然后返回数据结束运行；BUT如果在执行FuncOrExpressionSeq中跑出了个异常，函数就会跳去匹配ExPattern1、ExPattern2....看看到底是出了什么异常，然后执行相应的ExExpression来处理异常。ExceptionType（throw、exit、error）指明异常的类型，如果忽略的话则默认为throw。注意：由Erlang runtime system检测出的内部错误其异常类型总是error。

跟在after后面的代码一般是用来做清理工作的，即使有异常发生，这部分代码也一定会被执行。

Shortcuts
try...catch表達式的某些部分是可以被忽略的，例如：

try F
catch
    ....
end

跟下面這段代碼系一樣的：

try F of
    Val -> Val
catch
    ....
end

同樣的，after部分也可以省略掉～～

Programming Idioms with try...catch
我們設計應用程式時，通常都需要保証代碼產生的所有錯誤和异常都會被捕捉到，下面來個例子，首先我們要產生一些异常出來先：

generate_exception(1) -> a;
generate_exception(2) -> throw(a);
generate_exception(3) -> exit(a);
generate_exception(4) -> {'EXIT',a};
generate_exception(5) -> erlang:error(a).

然后我們用try...catch來處理這些异常：

demo1() ->
    [catcher(I) || I <- [1,2,3,4,5]].

catcher(N) ->
    try generate_exception(N) of
        Val -> {N, normal, Val}
    catch
        throw:X -> {N, caught, thrown, X};
        exit:X -> {N, caught, exited, X};
        error:X -> {N, caught, error, X}
    end.

運行上述代碼可得如下結果：

1> try_test:demo1().
[{1, normal, 1},
 {2, caught, thrown, a},
 {3, caught, exited, a},
 {4, normal, {'EXIT', a}},
 {5, caught, error, a}]

catch
另外也可以直接使用catch來捕捉异常，如下：

demo2() ->
    [{I, (catch generate_exception(I))} || I <- [1,2,3,4,5]].

運行上述代碼可得如下結果：

2> try_test:demo2().
[{1, a},
 {2, a},
 {3, {'EXIT', a}},
 {4, {'EXIT', a}},
 {5, {'EXIT', {a, [
    {try_test, generate_exception, 1},
    {try_test, '-demo2/0-fun-0-', 1},
    {lists, map, 2},
    {lists, map, 2},
    {erl_eval,do_apply,5},
    {shell,exprs,6},
    {shell,eval_loop,3}
]}}}]

與try...catch的例子對比，你會發現上例丟失了很多錯誤原因信息～～

Improving Error Messages
erlang:error的一個用途就是改善錯誤信息的提示方式，比如說如果我們在調用函數math:sqrt(X)時傳入一個負數作為參數，會看到如下錯誤提示：

1> math:sqrt(-1).
** exited: {badarith, [
    {math, sqrt, [-1]},
    {erl_eval, do_apply, 5},
    {shell, exprs, 6},
    {shell, eval_loop, 3}]} **

羅羅唆唆一大堆又不直觀，我們可以寫如下這樣的代碼來改善一下輸出的信息：

sqrt(X) when X<0 ->
    erlang:error({squareRootNegativeArgument, X});
sqrt(X) ->
    math:sqrt(X).

2> lib_misc:sqrt(-1).
** exited: {
    {squareRootNegativeArgument, -1},
    [{lib_misc, sqrt, 1},
     {erl_eval, do_apply, 5},
     {shell, exprs, 6},
     {shell, eval_loop, 3}]} **

Catching Every Possible Exception
如果我們想捕捉晒所有可能出現的錯誤，可以使用如下形式的代碼：

try Expr
catch
    _:_ -> ...處理異常...
end

Stack Traces
當捉到異常時，可以通過調用erlang:get_stacktrace()獲取最新的堆棧追蹤信息（stack trace），下面看個例子：

demo3() ->
    try generate_exception(5)
    catch
        error:X ->
            {X, erlang:get_stacktrace()}
    end.

1> try_test:demo3().
{a, [{try_test, generate_exception, 1},
     {try_test, demo3, 0},
     {erl_eval, do_apply, 5},
     {shell, exprs, 6},
     {shell, eval_loop, 3}]}

“堆棧追蹤（stack trace）”包含了一繫列在堆棧上的函數，如果不是因為出了異常，當前函數能順利執行的話，就會返囬到這些函數里去，這些函數的排列順序基本上等于我們進入到當前函數（發生了異常的函數）的函數調用順序（除了尾遞歸函數）。在調試程序的角度來講，stack trace隻有前幾行輸出比較有意義，比如上例的第一行輸出告訴我們繫統崩潰時正在執行函數generate_exception，其參數來自糢塊try_test，try_test:generate_exception/1可能是由try_test:demo3()調用的。

譯自《Programming Erlang》- Chapter 4 - Exceptions

突然没有了eth0？？

2009-03-25T14:44:00.002+08:00

郁闷，今天校园网老是出现IP冲突，想在Ubuntu下装个防火墙看有没效，谁知糊弄一番发现没有了网络连接....只剩下了lo本地回环～～郁闷～～Google一下用如下方法问题解决：

输入命令sudo gedit /etc/network/interfaces，貌似是个网络设备配置文件，应该能看到如下内容：
auto lo
iface lo inet loopback

在下面增加这两句：
auto eth0
iface eth0 inet dhcp

保存并重启Ubuntu，一切恢复正常～～

Mnesia Fragmenting

2009-03-24T16:37:00.003+08:00

本文参考自Nick Gerakines的Dynamically sizing a fragmented mnesia store，原文请看这里～～

Mnesia在32位系统下单个表最大只能存储4G的数据，很多情况下这显然系不够的，不过不要紧，Mnesia可以将单个表分拆成多个分块（Fragment），这些块可以分布到不同节点节点不同主机上，被分块的表和其他表一样可以备份复制等等～～

创建和初始化数据库表
首先我们运行三个节点node1@m、node2@m和node3@m并将它们连接起来（详细可以参看Interconnecting Erlang Nodes），然后在node1上初始化一个表，将该表分成三块，分布在上述的三个节点上：
（以下代码省略了部分返回结果）

初始化schema
node1 > Nodes=[node() | nodes()].
node1 > mnesia:create_schema(Nodes).

启动所有节点上的Mnesia
node1 > mnesia:start().
node2 > mnesia:start().
node3 > mnesia:start().

在Node1上创建和初始化数据表
node1 > rd(test,{key,value}).
node1 > FragProps=[
            {node_pool,Nodes},
            {n_fragments,3},
            {n_disc_only_copies,1}].
node1 > mnesia:create_table(test,[
            {frag_properties,FragProps},
            {attributes,record_info(fields,test)}]).
node1 > Write=fun() ->
                  [mnesia:write({test,K,K}) || K<-lists:seq(1,1000)]
              end.
node1 > mnesia:activity(sync_dirty,Write,[],mnesia_frag).

检查一下数据都写到哪里去了
node1 > Info=fun(Item) -> mnesia:info(test,Item) end.
node1 > mnesia:activity(sync_dirty,Info,[frag_size],mnesia_frag).
[{test,230},{test_frag2,524},{test_frag3,246}]

添加新分块到新节点上

启动新节点node4
$ erl -sname node4
node4 > mnesia:start().

连接并添加新节点
node1 > net_adm:ping('node4@m').
node1 > mnesia:change_config(extra_db_nodes,['node4@m']).

通过mnesia:info()我们发现新节点的类新为ram_copies，这与其他几个节点不兼容
所以要先对node4上的表进行类型转换
node4 > change_table_copy_type(schema,node(),disc_copies).

添加新分块到新节点上，可以向同一节点添加多个分块
node1 > mnesia:change_table_frag(test,{add_frag,['node4@m']}).
node1 > mnesia:change_table_frag(test,{add_frag,['node4@m']}).
node1 > mnesia:change_table_frag(test,{add_frag,['node4@m']}).
node1 > mnesia:activity(sync_dirty,Info,[frag_dist],mnesia_frag).
[{'node1@m',1},
 {'node2@m',1},
 {'node3@m',1},
 {'node4@m',3}]
node1 > mnesia:activity(sync_dirty,Info,[frag_size],mnesia_frag).
[{test,121},
 {test_frag2,115},
 {test_frag3,246},
 {test_frag4,291},
 {test_frag5,109},
 {test_frag6,118}]

OK，可以看到数据已经自动的分布到各个节点上的分块里了～～

List Comprehensions

2009-03-24T00:02:00.002+08:00

1 Simple Examples
We start with a simple example:
> [X || X <- [1,2,a,3,4,b,5,6], X > 3].
[a,4,b,5,6]

This should be read as follows: The list of X such that X is taken from the list [1,2,a,...] and X is greater than 3. The notation X <- [1,2,a,...] is a generator and the expression X > 3 is a filter. An additional filter can be added in order to restrict the result to integers:
> [X || X <- [1,2,a,3,4,b,5,6], integer(X), X > 3].
[4,5,6]

Generators can be combined. For example, the Cartesian product of two lists can be written as follows:
> [{X, Y} || X <- [1,2,3], Y <- [a,b]].
[{1,a},{1,b},{2,a},{2,b},{3,a},{3,b}]

2 Quick Sort
The well known quick sort routine can be written as follows:
sort([Pivot|T]) -> sort([ X || X <- T, X <>= Pivot]);
sort([]) -> [].

The expression [X || X <- T, X <> is the list of all elements in T, which are less than Pivot.
[X || X <- T, X >= Pivot] is the list of all elements in T, which are greater or equal to Pivot.
To sort a list, we isolate the first element in the list and split the list into two sub-lists. The first sub-list contains all elements which are smaller than the first element in the list, the second contains all elements which are greater than or equal to the first element in the list. We then sort the sub-lists and combine the results.

3 Permutations
The following example generates all permutations of the elements in a list:
perms([]) -> [[]];
perms(L) -> [[H|T] || H <- L, T <- perms(L--[H])].

We take take H from L in all possible ways. The result is the set of all lists [H|T], where T is the set of all possible permutations of L with H removed.
> perms([b,u,g]).
[[b,u,g],[b,g,u],[u,b,g],[u,g,b],[g,b,u],[g,u,b]]

4 Pythagorean
Triplets Pythagorean triplets are sets of integers {A,B,C} such that A**2 + B**2 = C**2.
The function pyth(N) generates a list of all integers {A,B,C} such that A**2 + B**2 = C**2 and where the sum of the sides is equal to or less than N.
pyth(N) ->
[ {A,B,C} ||
A <- lists:seq(1,N),
B <- lists:seq(1,N),
C <- lists:seq(1,N),
A+B+C =< N,
A*A+B*B == C*C ].

> pyth(3).
[].
> pyth(11).
[].
> pyth(12).
[{3,4,5},{4,3,5}]
> pyth(50).
[{3,4,5},
{4,3,5},
{5,12,13},
{6,8,10},
{8,6,10},
{8,15,17},
{9,12,15},
{12,5,13},
{12,9,15},
{12,16,20},
{15,8,17},
{16,12,20}]

The following code reduces the search space and is more efficient:
pyth1(N) ->
[{A,B,C} ||
A <- lists:seq(1,N-2),
B <- lists:seq(A+1,N-1),
C <- lists:seq(B+1,N),
A+B+C =< N, A*A+B*B == C*C ].

5 Simplifications with List Comprehensions
As an example, list comprehensions can be used to simplify some of the functions in lists.erl:
append(L) -> [X || L1 <- L, X <- L1].
map(Fun, L) -> [Fun(X) || X <- L].
filter(Pred, L) -> [X || X <- L, Pred(X)].

6 Variable Bindings in List Comprehensions
The scope rules for variables which occur in list comprehensions are as follows:

all variables which occur in a generator pattern are assumed to be "fresh" variables
any variables which are defined before the list comprehension and which are used in filters have the values they had before the list comprehension
no variables may be exported from a list comprehension.

As an example of these rules, suppose we want to write the function select, which selects certain elements from a list of tuples. We might write select(X, L) -> [Y || {X, Y} <- L]. with the intention of extracting all tuples from L where the first item is X.
Compiling this yields the following diagnostic:
./FileName.erl:Line: Warning: variable 'X' shadowed in generate

This diagnostic warns us that the variable X in the pattern is not the same variable as the variable X which occurs in the function head.
Evaluating select yields the following result:
> select(b,[{a,1},{b,2},{c,3},{b,7}]).
[1,2,3,7]

This result is not what we wanted. To achieve the desired effect we must write select as follows:
select(X, L) -> [Y || {X1, Y} <- L, X == X1].

The generator now contains unbound variables and the test has been moved into the filter. This now works as expected:
> select(b,[{a,1},{b,2},{c,3},{b,7}]).
[2,7]

One consequence of the rules for importing variables into a list comprehensions is that certain pattern matching operations have to be moved into the filters and cannot be written directly in the generators. To illustrate this, do not write as follows:
f(...) -> Y = ...
[ Expression || PatternInvolving Y <- Expr, ...]
...

Instead, write as follows:
f(...) -> Y = ...
[ Expression || PatternInvolving Y1 <- Expr, Y == Y1, ...] ...

Mnesia Indexing

2009-03-23T23:46:00.003+08:00

Data retrieval and matching can be performed very efficiently if we know the key for the record. Conversely, if the key is not known, all records in a table must be searched. The larger the table the more time consuming it will become. To remedy this problem Mnesia’s indexing capabilities are used to improve data retrieval and matching of records.

The following two functions manipulate indexes on existing tables:

mnesia:add table index(Tab, AttributeName) -> {aborted, R} |fatomic, ok}
mnesia:del table index(Tab, AttributeName) -> {aborted, R} |fatomic, ok}

These functions create or delete a table index on field defined by AttributeName. To illustrate this, add an index to the table definition (employee, {emp_no, name, salary, sex, phone, room_no}). The function which adds an index on the element salary can be expressed in the following way:

1 > mnesia:add_table_index(employee, salary).
The indexing capabilities of Mnesia are utilized with the following three functions, which retrieve and match records on the basis of index entries in the database.

mnesia:index read(Tab, SecondaryKey, AttributeName) -> transaction abort | RecordList. Avoids an exhaustive search of the entire table, by looking up the SecondaryKey in the index to find the primary keys.
mnesia:index match object(Pattern, AttributeName) -> transaction abort | RecordList. Avoids an exhaustive search of the entire table, by looking up the secondary key in the index to find the primary keys. The secondary key is found in the AttributeName field of the Pattern. The secondary key must be bound.
mnesia:match object(Pattern) -> transaction abort | RecordList. Uses indices to avoid exhaustive search of the entire table. Unlike the other functions above, this function may utilize any index as long as the secondary key is bound.

转自《Mnesia Database Management System》

Mnesia Database Management System

2009-03-23T19:27:00.004+08:00

详细讲解Mnesia数据库，由简介入门到诸如分布式、容错、数据表分块等各种特性都涵盖到了，好文档，值得分享～～点这里下载～～

另附一个Google搜出的文档《Mnesia table fragmentation 过程及算法分析》（中文），通过案例详细讲解了Mnesia的分片机制和原理～～

在Ubuntu下排放多个终端窗口

2009-03-23T08:57:00.002+08:00

在Ubuntu下，有时需要同时打开多个终端窗口来工作，一大堆窗口堆在桌面上，手动拖放排列很麻烦，此时Terminator就帮到你了，Terminator可以让你将一个终端水平或垂直的分割为两个，安装方法也很简单，直接sudo apt-get install terminator就可以了～～效果如下：

V4L2 for ARToolKit

2009-03-19T19:32:00.005+08:00

之前运行ARToolKit的例子一直不成功，总是到了获取摄像头channel的地方出错，后来检查发现原来系我的摄像头只支持V4L2，但ARToolKit只提供了V4L1的驱动，怎么办呢～～唔洗惊，下载这个文件，将其放到ARToolKit根目录，然后输入如下命令：
patch -p1 < path_file_name.patch
重新编译一次ARToolKit，这次Configure的时候就会多出一个Video4Linux 2的选项了，编译完后摄像头设备就应该能够正常使用了～～

体检日～～

2009-03-18T11:44:00.003+08:00

今日学校要搞毕业体检，哇一早去到医院门前又系人山人海～～排左成个半钟先抽左个血....

睇我地D大学生几有素质，平时灭火器箱上面放满的都系空汽水罐、宣传单张.... 依家居然连抽血之后用的绵签都甘样随处乱丢，完全唔顾及他人的感受同自己的形象～～某工业大学哇，睇你都教出什么学生了～～

Augmented Reality 虚拟与现实的结合

2009-03-13T23:48:00.002+08:00

Augmented Reality系一种将电脑虚拟图像实时融合到现实世界的技术，可以广泛应用于导航、游戏、制造业、医学等各个领域～～下面两段视频演示的系其中一种实现手段：在真实世界中放置一些印有特殊编码的标记，当摄像头拍摄到包含这些标记的图像时，会实时识别标记的位置、角度、距离等信息，从而利用这些信息将虚拟物体添加到原始图像上，在屏幕上看起来就像虚拟物体真实存在一样～～

ARToolkit系一个实现Augmented Reailty技术的开源软件包，在Windows、Linux、MacOS三大主流系统上都能使用～～还有人开发了ActionScript版的，不过效率实在比较差～～等佩戴式显示设备流行起来之后，这样的技术应该会有很大的应用空间～～

C++运算符重载

2009-03-11T23:22:00.004+08:00

运算符重载可以赋予已有的运算符多重含义，重新定义运算符的功能～～定义一个运算符重载函数跟定义普通函数相似，只是函数名必须以operator开头，如下：

<返回类型> operator <运算符>(<形参表>){....}
<返回类型><类名>::operator <运算符>(<形参表>){....}

重载的运算符必须是C++的合法运算符，如+、-、*、/、++等，下面来个例子：

#include <stdio.h>
#include <string.h>


class Person{
private:
char name[20];
unsigned int age;

public:
//构造函数
Person(const char *pname,unsigned int page){
strcpy(name,pname);
age=page;
}

//重载运算符+，返回两个Person实例的age相加
int operator +(Person &p){
return age+p.age;
}
};


int main(){
//创建两个Person
Person *p1=new Person("Oscar Tang",23);
Person *p2=new Person("JoJo Zhou",22);

//测试一下重载后的+号～～
printf("%d\n",*p1+*p2);
}

OK～～编译后运行就可以看到结果了～～

SnippetShare

2009-03-09T21:14:00.004+08:00

SnippetShare系我写的一个在线代码编辑器，有自动缩进、代码着色、行号标示、TAB输入等功能，主要用于在线编辑、管理自己的代码片段，或通过博客widget等方式共享代码～～现在只写好了核心部分，先发个图出来～～

有兴趣的可以到这里试试效果，或者下载源代码～～

扩展gedit的突出显示模式以支持MXML

2009-03-09T12:05:00.000+08:00

gedit支持代码高亮（突出显示模式），十分方便编程，不过gedit也非万能，它不支持一些不太流行的代码的高亮显示，不过幸好可以自己手工扩展，只需到这里下载几个文件，将他们放到/usr/share/gtksourceview-2.0/language-specs/目录下，重启gedit即可，效果如下：

一点感想：一个应用程序不可能一发布就什么都支持，但应该做到容易扩展和指引清晰，将用户变成自己开发团队的一员，不仅事半功倍，还利于软件的发展～～因此底层架构和事前规划十分十分重要～～

Interconnecting Erlang Nodes

2009-03-09T12:02:00.000+08:00

警告：Erlang节点一旦相互连接就可以对对方进行完全的控制，包括在对方上运行任何命令，甚至可以完全关闭对方节点～～

Cookie

首先应将各个节点上的Cookie设置成一样，设置Cookie有如下方式：

在Erlang节点启动时添加如下参数：
erl -setcookie THISISJUSTATEST -name node1

或者可以将cookie存储在$HOME/.erlang.cookie文件里：
THISISJUSTATEST

又或者当你用参数-name或-sname启动Erlang节点之后，可以执行如下函数：
erlang:set_cookie(node(), ‘ THISISJUSTATEST ‘).

要检查各个节点上的Cookie是否都一样，可调用如下函数：
erlang:get_cookie().

Nodes names

当启动Erlang节点的时候，务必要设置一个唯一的节点名：
erl -name nodename

节点启动后，可用如下函数来检视当前节点名：
node().
‘ nodename@machine1.example.org ‘

Hosts file

在$HOME目录（或者code:root_dir()目录）创建文件.hosts.erlang，其内容为其他节点所在的主机名，例如在machine1里其内容如下：
‘ machine2.example.com ‘.

执行如下函数检查其是否被正确的加载：
net_adm:host_file().

Interconnect the Erlang nodes

首先当然系启动所有节点啦，然后在node1上执行如下函数：
net_adm:world().
[' node2@machine2.example.com ',' node1@machine1.example.com']
可以看到node1已经发现了在machine2上的令一个节点node2～～

执行如下函数看看自己都连接到什么节点上了：
nodes().
[' node2@machine2.example.com ']
已经连接到node2上了～～

当然啦你也可以手动尝试连接到其他节点，如果连接成功会返回pong，失败则返回pang：
net_adm:ping(’ node2@machine2.example.com ‘).
pong
net_adm:ping(’ node3@notexist.com ‘).
pang

最后搞个比较有趣的东东，调用如下函数可以收集所有其他节点上的时间：
rpc:multical(nodes(), erlang, localtime, []).

上面的这个函数定义如下：
rpc:multical(Nodes, Module, Function, Args) -> {ResL, BadNodes}

Nodes = [node()]
Module = Function = atom()
Args = [term()]
ResL = [term()]
BadNodes = [node()]

Start an erlang shell on a remote node

连接到其他节点上之后，你还可以在远程节点上运行Erlang shell，例如在node1的shell上按Ctrl+G可以进入到任务控制模式（jobs control mode）：
User switch command
–>

输入h可以获得帮助：
User switch command
–> h
c [nn] - connect to job
i [nn] - interrupt job
….

输入j以查看当前任务：
–> j
1* {shell, start, []}
–>

我们可以在node2上创建一个远程任务：
–> r ‘ node2@machine2.example.com ‘
–> j
1 {shell, start, []}
2* {node2@machine2.example.com, shell, start, []}
–>

连接到新的任务：
–> c 2
Eshell V5.4 (abort with ^G)
(node2@machine2.example.com) 1>

Play with your remote Erlang shell

提醒一下：连接到远程节点上之后，你可以对其进行任何操作，就像你操作本地节点一样～～

例如我可以获取远程节点的内存状况：
memory().
[{total, 3010399}, ....]

或者可以获取远程节点当前有多少进程在运行：
erlang:system_info(process_count).

….

Close the remote Erlang shell safely

搞掂之后记得要关闭远程Erlang shell，再次按Ctrl+G，然后输入j查看远程shell的ID：
User switch command
–> j
1 {shell, start, []}
2* {node2@machine2.example.com, shell, start, []}
–>

远程shell的ID系2，然后输入如下命令来关掉它：
–> k 2
–>

不过没有任何关闭成功或失败的信息，所以再查看一下所有任务确认远程shell已经关闭：
–> j
1 {shell, start, []}
–>

最后还有一个更加便捷的方式来连接到远程节点并启动一个远程shell：
erl -sname node1 -remsh node2@machine2.example.com
Erlang (BEAM) emulator version 5.4.8 [source] [hipe]
Eshell V5.4.8 (abort with ^G)
(node2@machine2.example.com)1>

（译自Ejabber Tutorials）

3D Street Art

2009-03-09T12:01:00.000+08:00

鬼佬D创意真系一流～～

面瘫

2009-03-09T12:00:00.003+08:00

哈哈～～很搞笑～～

在项目中使用Gravatar头像

2009-03-09T12:00:00.000+08:00

Gravatar即Globally Recognized Avatars（个人全球统一标识），简单来说就系一种通用的头像服务，用户只需在Gravatar上注册，绑定一个头像到自己的邮箱地址，那么在所有使用Gravatar服务的网站（例如WordPress）上使用这个邮箱地址发帖发评论时，头像就会自动贴上，开发者无须自己维护用户的头像数据～～Gravator服务通过URL调用，提供PHP、JSP、.NET、Python等多种语言的帮助，例如用Python可以这样写：

#import code for encoding urls and generating md5 hashes
import urllib, hashlib

#Set your variables here
email = "someone@somewhere.com"
default = "http://www.somewhere.com/homsar.jpg"
size = 40

#construct the url
gravatar_url = "http://www.gravatar.com/avatar.php?" 
gravatar_url += urllib.urlencode({'gravatar_id':hashlib.md5(email).hexdigest(),
    'default':default,'size':str(size)})

gravatar_url即为用户someone@somewhere.com的头像路径～～

Python中字符串与时间的转换

2009-03-09T11:39:00.000+08:00

使用datetime.strptime函数可将时间字符串转换为datetime类型数据，见下例：

>>> from datetime import datetime
>>> datetime.strptime(”2009-02-20 15:49:21″,“%Y-%m-%d %H:%M:%S”)
datetime.datetime(2009, 2, 20, 15, 49, 21)

%Y代表年份，%m代表月份…. 详细请参看Python Library Reference

inet_ntoa使用要注意….

2009-03-09T02:11:00.001+08:00

在GNU C Library Reference里函数inet_ntoa有如下描述：

char * inet_ntoa (struct in_addr addr)

This function converts the IPv4 Internet host address addr to a string in the standard numbers-and-dots notation. The return value is a pointer into a statically-allocated buffer. Subsequent calls will overwrite the same buffer, so you should copy the string if you need to save it. In multi-threaded programs each thread has an own statically-allocated buffer. But still subsequent calls of inet_ntoa in the same thread will overwrite the result of the last call.

注意粗体部分，inet_ntoa函数返回的指针系指向一个固定分配的缓存区的，因此每次调用inet_ntoa都会覆盖上次执行的结果，用来直接输出就没什么问题，但如果要保存的话，就需要自己另外开辟空间将结果复制过去了～～另外对于多线程程序，由于每个线程都有其独立的固定分配缓存区，因此各个线程之间不会互相覆盖对方的执行结果。

解析Sniffer数据包中的地址与端口

2009-03-09T02:09:00.002+08:00

继续昨天的FTP Sniffer的开发，现在要在嗅探到感兴趣的数据后，显示数据的来源和去向（源/目标地址及端口），地址以整数形式保存了在sniff_ip结构体里，而端口则在sniff_tcp结构体里，这些数据都以网络字节顺序（network byte order）保存，需要在使用前转换成本地字节顺序（host byte order），相关转换函数包含在arpa/inet.h和netinet/in.h两个头文件里，转换方法如下：

//输出源地址与端口
cout << "Src Addr : " << inet_ntoa ( ip->ip_src ) << endl;
cout << "Src Port : " << ntohs ( tcp->th_sport ) << endl;

//输出目标地址与端口
cout << "Dst Addr : " << inet_ntoa ( ip->ip_dst ) << endl;
cout << "Dst Port : " << ntohs ( tcp->th_dport ) << endl;

inet_ntoa函数将struct in_addr类型数据转换为点分式IP地址字符串，ntohs将一个16位无符号整数从网络字节顺序转换为本地字节顺序。具体函数定义可参见GNU C Library相关章节。

Linux卸载源码包

2009-03-09T02:09:00.001+08:00

Q：一般安装源码包都系./configure、make、make install，那怎么卸载呢？？
A：卸载命令为 make uninstall

gen_server中handle_call、cast、info的用法

2009-03-09T02:08:00.000+08:00

Erlang中的gen_server有handle_call、handle_cast和handle_info这三个接口函数，其函数定义十分相近，但使用上有一些细微的差别：

handle_call用于处理远程调用（remote procedure calls），一般应返回一个Reply（{reply, Reply, State}）作为调用结果；

handle_cast一般不返回Reply（{noreply, NewState}），而只改变服务器的状态，一般用于对服务器进行某些操作，比如关闭服务器；

handle_info用于处理其他一些“自发性”的信息（Spontaneous Message），即诸如相关连接进程崩溃所发出的{’EXIT’, Pid, Why}信息，同样一般没有Reply而只改变服务器状态。

译自《Programming Erlang》

在Erlang中处理XML数据

2009-03-09T02:06:00.001+08:00

xmerl_lib有一个方便处理XML的函数simplify_element（但该函数没有公开在文档里），可以用来解析和处理XML数据，如下例：

xml_example() ->
    Options=[{space,normalize},{encoding,"utf-8"}],
    Str=”<root title=’test’><person id=’oscar’ gender=’m'>Oscar Tang</person>
        <person id=’jojo’ gender=’f'>JoJo Zhou</person></root>”,
    {Xml,_}=xmerl_scan:string(Str,Options),
    xmerl_lib:simplify_element(Xml).

上述函数运行在我机上大约耗时230微秒（绝大部分耗在xmerl_scan:string函数上），即每秒可以将超过4000个XML数据从字符串转换成如下数据结构：

{root,[{title,"test"}],[
    {person,[{id,"oscar"},{gender,"m"}],["Oscar Tang"]},
    {person,[{id,"jojo"},{gender,"f"}],["JoJo Zhou"]}
]}

返回数据的一般结构为：
{node_name,[attributes],[children]}

Erlang性能评测

2009-03-09T02:05:00.000+08:00

JavaEye上的chaoslawful分别对Erlang的ETS/DETS、Port、I/O进行了性能评测，附有详细的测试环境、方法、结果以及测试用的代码下载～～见原文：

Erlang文件IO性能评测

Erlang Port性能评测

Erlang ETS/DETS性能评测

提高Gedit的代码输入速度

2009-03-09T02:04:00.000+08:00

在Ubuntu里比较喜欢用Gedit编写代码，有时面对又长又枯燥重复又重复的代码，会很有把键盘扔掉的冲动～～这个时候，gedit的“片段”插件就可以帮到你了，该插件用于帮助用户快速的插入一些常用的字符片段，还可以设置片段中变量的位置和默认值，看个例子：

首先选择编辑>首选项>插件，激活“片段”，如下图左：

然后我们添加一个Python分类下的片段handler，如上图右，其中的$1为第一个变量，${2:get}为另一个变量，其默认值为get，$0为最后光标停留的位置，Tab触发器一项设置为handler，则输入时只需键入handler然后按Tab键，gedit就会自动按片段设置补齐，光标停留在$1所在位置等待用户输入，然后再按Tab光标会跑到$2处，如此类跑，最后到$0处～～

Erlang连接操作MySQL

2009-03-09T02:03:00.002+08:00

需要用到一個名為Erlang-MySQL-Driver的開源項目，點這裏去項目主頁~~

創建並打開第一個MySQL連接（pl為連接池標識）：

mysql:start_link(pl,”localhost”,”user”,”password”,”database”).

可繼續添加連接到連接池：

mysql:connect(pl,”localhost”,undefined,”user”,”password”,”database”,true).

執行SQL語句：

mysql:fetch(pl,<<”insert into table ….”>>),

Result=mysql:fetch(pl,<<”select * from table ….”>>),

io:format(”Result : ~p\n”,[Result]).

處理返回結果：

執行語句後的返回結果有如下三種類型：

{data,MySQLRes}, {update,MySQLRes}, {error,MySQLRes}

MySQLRes為mysql_result類型的record數據（mysql_result定義與mysql.hrl文件中），其具體結構如下：

{mysql_result, [fieldinfo], [rows], affectedrows, [error]}

fieldinfo：域信息，包括域所屬表、域名、數據長度、數據類型；

rows：實際數據；

affectedrows：執行SQL語句影響的行數；

error：錯誤信息。

Erlang-mysql-driver還包括事務等其他功能，具體可以查看下載包裏的例子。

WebQQ限量封测中

2009-03-09T02:03:00.001+08:00

“从今天起，能看网页既能上QQ。无需下载、安装、等待、升级”~~

WebQQ开始了限量封测，用户可到WebQQ主页登记申请，腾讯将通过QQ消息发送试用通知~~WebQQ提供如下功能：

直接在页面上与QQ好友以及群保持联系
查收未读的QQ邮件
跟踪好友的最新动态
便捷查看和处理未读消息

继腾讯在QQ-Mail里插入QQ聊天模块后，终于推出WebQQ了，哈哈爽，日后只要能用浏览器上网就可以方便快捷的上Q了~~有人觉得老是要开着浏览器很麻烦，但是试想一下，若将来的电脑只需安装浏览器，浏览器替代了今天桌面的作用，那还会麻烦么？

初试Google App Engine

2009-03-09T02:02:00.002+08:00

Google App Engine可以让你上传自己的应用到Google服务器上运行，基本上可让开发者完全摆脱服务器配置等繁琐的工作，将注意力集中到应用的开发上，目前仅支持用Python开发，相信将来应该会集成更多开发环境，如果再加一个在线编译器就更好了～～

要使用Google App Engine可先到其主页注册，并下载Google App Engine的SDK，支持Windows / Linux / Mac OS X等多种主流操作系统，SDK里包含一个本地测使用服务端及上传组件等东东，安装完开发环境后可以到这里查看相关帮助文档，很容易上手～～

为什么要使用Google App Engine呢？感觉上其实跟传统的虚拟主机服务差不多，不也是提供点空间让你上传点东东么～～其实好处还是很多的，比如说Google服务器在国外而且速度很快，这就允许我们能避开国内万恶的审查机制做很多“坏事”了，嘿嘿～～另外Google的服务器也相当稳定，服务质量有保证，加之Google App Engine允许开发者调用Google众多的其他服务（比如用户验证等），降低开发难度～～

在Erlang中计算指定函数的执行耗时

2009-03-09T02:02:00.001+08:00

timer模块内包含一个tc函数，可用于计算指定函数的执行时间：
timer:tc ( Module, Func, Args ) -> {Time,ReturnValue}
Time : 运行耗时
ReturnValue : 函数的返回值

M-OSCAR

Moving into Tencent Building

东门“便便”游~~

Missing you ....

Inside Fiyta

Moved to my new house ....

Linux文件与目录权限

Second day at work ....

5月35日

全国技术维护日

Use Erlang to handle xml stream

豆瓣网：BLOGSPOT网络遊彳亍小组！小组已被解散

erlang 与 linked-in driver 间的通信

Google Docs 写博测试

Ubuntu下保存mms类型地址的视频

Google App Engine on Ubuntu 9.04

Erlang Linked in driver

最近～～

Tail Recursion & ActionScript 3.0

sztrace not declared ?

Blogger is being GFWed

Alchemy之二值化圖像

Alchemy之 Memory to ByteArray

Alchemy之讀取AS ByteArray數據類型

初試 Adobe Alchemy

[轉載] 划时代的 Adobe Alchemy

[ Erlang + ActionScript ] System Monitor

Erlang處理JSON數據～～

ActionScript處理JSON數據～～

精簡URL以減輕網站流量壓力？

gen_tcp:controlling_process BADARG error ??

Erlang的進程信息過濾

Erlang : head mismatch ??

畢業相～～

Reload Erlang Module

Embed Prezi into your website

在Erlang啟動時執行一系列操作

設置Erlang裝載代碼的路徑

Erlang的Makefile～～

［转］Erlang开发建议(杂记版)

由 Oscar Tang 透過 Google 閱讀器傳送給您：

Erlang开发建议(杂记版)

您可以在這裡操作的事項：

Embedding Resource with AS 3.0

What's my purpose ?

Prezi 在线动态简报

Firefox翻墙记之Youtube篇～～

How to use Erlang SSL Socket

Erlang Term Comparisons

Erlang list item searching

-____- |||

最近～～

Mnesia 事件处理

用qlc进行数据排序与筛选

Supervisor也崩溃了？？

动态增删Mnesia数据库节点

record_info不能接受參數？

Local Content Tables

Mnesia Table Fragmentation

Erlang OTP - Supervisor

Mnesia写入数据错误？

I am back ~~

我不高兴～～

郁闷～～

設置Erlang最大總進程數

Toothache ....

利用List Comprehension過慮列表里的項目

Google Docs的繪圖功能

SCIM輸入選框無法自動跟隨光標？

Erlang 查看文件屬性

Erlang Directory Operations

Erlang文件讀寫

Erlang Gen_Event Behaviour

Erlang Generic Event Handling

Erlang Exception Handling

突然没有了eth0？？

Mnesia Fragmenting

List Comprehensions

Mnesia Indexing

Mnesia Database Management System