ShiningRay的Blog

上海的洪水

ShiningRay — Mon, 25 Aug 2008 22:11:45 +0800

今天是到渡维上班的第一天，结果遇上了百年一遇的暴雨，造成上海多个地方积水严重。我9点出门，等69路等了1个小时，找出租车用了半个小时，上了出租车之后绕绕绕，绕到虹井路延安西路，结果到了快一点，还没走多远，打车就85元了。然后路边随便找了一个饭店草草解决了午饭，长途跋涉，沿延安西路一直走到古北路兴义路。途中历经艰难险阻，过中环的时候都是趟着没过膝盖的污水经过的。到这个69路公交车站的时候已经是下午3点了，然后等69路最后坐到长宁路，到达公司的时候已经是4点多。

所幸，我还是到了。

晚上回来时乘坐69路则一路畅通，但我仍然看到中环靠近吴中路那边非常堵。

东西一流行就容易变味

ShiningRay — Fri, 08 Aug 2008 16:43:00 +0800

以前朋友带我去上海的一些店里吃东西，经常说“店大了，东西没有以前好吃了”。然而，我也和朋友去过另外一些小店，味道和店面都一如既往十几年（除了物价上涨）。

这时候我发现身边很多东西一旦开始流行，就立刻变味——也许这就叫量变到质变。身边的例子很多，记得05年的时候，我还和同学们一起吃一种叫做“掉渣大饼“的东西，那时候这玩意儿突然很流行，但没过多久，突然又消失匿迹了。有人分析原因是这样：“流行风，不适合在一个固定地点开店，适合流动售卖。口味比较重，油也挺大，不是健康食品。所以刚出来时，大家出于好奇，买的人较多，但不适合常吃。”^[1]然而也有人分析是因为“无序加盟”造成的^[2]。

掉渣大饼的例子算是一类典型，但它的“潮流”，也许还不是那么地引人注目。只能说，它的“流行”只是相对于其他接近的东西，在短时间内聚集了大量关注。也许标题改成“公司在快速扩张过程中容易出现问题”更能符合我所想说的。因为公司产品突然地流行起来，意味着公司更加有利可图，那么公司会想办法扩张，而在扩张过程中，由于某些方面做得不到位，或另些方面做得太过分等，而导致产品不能如公司或者受众的期望继续发展，甚至最终导致公司扩张失败、甚至市场萎缩。

我很想探究其中的道理。不过我认为应该首先定义“流行”是什么。百度百科上这样解释[3]：

比如一些事物，刚开始没有太多人去注意，慢慢的引起了很多的注视，后来越来越多的人开始关注它，这就是所谓的“流行＂

不过这似乎与我要阐述的流行有所不同，在这里我所谓的流行是指受众比原有变的多，且增长速度也在提升。当然还有受众的问题，当受众之间个体之间相同点少，那么可以说是大众流行，反之，就是小众流行；如果小众是属于有钱人，似乎就是高档的奢侈品；如果在受众中的接受程度高，那么就是该群体中的“主流”；如果在大众中接受程度高，那就可以算“主流”了。

我把在潮流中的三个类角色划分出来：A. 通过这个事物引领、制造（有意或无意的）潮流的公司或个体，B. 在潮流中模仿A，想分一杯羹的跟风者，C. 潮流的受众们。

C是原动力，A是导火索，B是推波助澜的。没有广泛的C，就不能成就A所需要的市场，没有市场带来的利益，也就不会有B的跟风。当A不能注重品质，东西就变味了。

往往当潮流来临的时候，没有人会意识到它有多大，它能持续多长，普通的公司往往都只想在潮流中能捞多少捞多少，而不管自己是不是真的有实力。我归结这些个公司在潮流中失败的原因往往有：

只注重扩张，而不注重品质：只知道要多捞点，不知道要全面均衡发展。
有各方面条件更好的后来者居上：没想到被巨头盯上了。
市场需求被透支：过分炒作流行的概念，等受众回头醒悟发现被骗了。

所以我想问问，那些准备制造、或刚刚制造了潮流的商家们，你们真的准备好了吗？

关于Apple

其实突然想写本文其实也是因为Apple。随着Apple的一系列优秀产品iPod、iPhone等一下子流行起来。最近Apple的日子不好过：

种种负面消息传出，我就会说，Apple，你的iPhone还没准备好吧？不可否认，Apple的iPhone的外观设计是出色的、操作系统是优秀的，软件服务也是很棒的，可惜，Apple你本来不是做手机的。iPhone的流行导致这个苹果变味儿了。

过去的定位与未来目标的冲突

Apple的产品定位一直是高端用户群体。以前，我对Apple的Mac是有一些好感的，当然我也不讨厌Windows。我一直认为Apple的东西很酷，很有形，用Apple的是设计师，非常有个性的人，他们很有创造力。然而在国外，iPod已然变成了是一个日用品。而在国内，则是一个时尚的代名词，用iPod，就可以显得很前卫，很潮流。其实当用的人多了，也就没有什么前卫不前卫的。因为直到有一天，我发现送外卖的小弟也揣着一个iPod。同时，模仿iPod的MP3、MP4公司越来越多，功能也会超越iPod，iPod虽然能因为Apple的种种魅力保持他的地位，但它在这个领域的份额也会逐渐减少——就好比现在手机与山寨机；如果iPod的份额不减少，甚至越来越高，那么说明市场正在衰退，因为用的人实在太多了，没有人会觉得这很前卫、很时尚。

其实Apple过去做的东西是有点“奢侈品”的意思在里面，然而，将来它要面对的是自己的产品变得大众化。

盲目扩张，忽视了品质

也许并非Apple不注重品质，而是对于手机的设计制造还缺乏经验，所以才出现了种种“瑕疵”。正因为对iPhone前景过于充满信心而到处签约，却忽视了iPhone的产能问题。这些问题非常容易导致iPhone的品牌被做烂掉。

Apple没有做过手机，难免会出现一些问题，但是因为Apple之前太成功了，所以iPhone理应成功，人们的期望总是很高。这种突然的潮流，搞不好就会淹没Apple自己。

其实iPod，在2001年出现第一代iPod，也是出现了很多问题，我的印象中，到05年，国内才开始流行iPod。这种稳步的渐进式的，也许更加符合发展规律。

这点Google就非常聪明，Google也希望进军手机领域，但它清楚，一方面自己没有做过手机，另一方面蛋糕要一起吃，只有拉拢手机巨头们，才能抢占这个市场，所以它推出了Open Handset Alliance，自己主导做系统，然后推自己服务。当时Gmail的推出，引发了无限/超大容量邮箱的革命时，Google也是用了类似策略，因为 Google清楚自己无法应付过多的用户，所以他在Gmail推出初期，只有被邀请才能加入，并且刺激别的邮件供应商跟进。这样在占据了合理的市场份额的同时，保证了Gmail的品质和发展。

摊子铺太广、独来独往

有人经常拿Apple和Microsoft比，其实我觉得两者除了在操作系统上可以进行比较外，其他方面没有很多交集。

历史上任何一个大浪潮，都不是单单某一个公司能够凭借一己之力完成的，PC机和Windows的流行，并不是一朝一夕的事情，而是顺应历史的必然。在Windows95流行之前，微软就已经做了十几年操作系统，而微软的联盟者，已经做了十几年的PC机。微软从来没有想着自己做硬件去统治整个市场。这就是为何微软抄了苹果的界面，却比苹果更流行的原因。

因为苹果什么都做，同时又几乎完全封闭自己的架构，一个公司的能力是有限的，所以它一直只能走小众路线。苹果从硬件方面的芯片、机箱、显示器，到软件上的操作系统、各种“i”系列的应用软件，从台式机到服务器，到现在的电子产品、手机，Apple可谓无所不包（虽然不是每个零件都自己做）。这也就是为何苹果机没有最终广泛流行的原因，因为微软不是一个人在战斗，微软的背后有Intel，有IBM，有各大中小PC制造商，有无数共享软件开发者，有无数的游戏厂商。苹果的封闭而又追求完美的面面俱到的开发，使他开发出来的只能是曲高和寡的艺术品。

当然，苹果也走了几招妙棋。MacOSX是基于BSD系统开发的操作系统，BSD是开源Unix系统家族中的一员，而且苹果也开放了一些东西让广大开发者一起维护。这就使得MacOSX可以兼容相当多的*nix软件，一下子吸引了很多*nix的开发人员。然后苹果又与Intel结盟，采用Intel芯片。

总结上述一些问题，我认为苹果目前其实处境还是很危险的。希望苹果不要再变味了。

并行的快速排序

ShiningRay — Wed, 06 Aug 2008 09:44:04 +0800

快速排序是一种应用了“分治法”的算法，所谓分治法(divid & conquer)，就是把大的问题分割为结构相同的小问题，然后进行解决的方法。因为都是相同的小问题，所以我们可以利用并行计算来并行处理这些问题，使用Erlang可以非常方便非常清晰地利用这种方法解决问题。
由于Erlang是一种声明式、函数式编程语言，所以要表述基本的快速排序算法非常方便：

qsort(_, []) -> [];
qsort(F, [H|T]) ->
    qsort(F, [X || X <- T, F(X, H)])
    ++ [H] ++
    qsort(F, [X || X <- T, not F(X, H)]).

qsort(L) -> qsort(fun(X, Y) -> X < Y end, L).

其中F是一个用于比较的函数。这种描述方式非常精炼，不过效率不高，原因在于1. 不是尾递归, 2. 该代码中应用了两个列表领悟（ list comprehension ），其结果是对同一个列表进行了两次遍历。不过这些问题我们稍后考虑。
在erlang中，创建和维护进程是非常方便的，可以很容易地将以上的顺序算法变成创建单独的进程解决对每个子问题：

psort(Pid, _Fun, []) -> Pid ! {self(), []};
psort(Pid, Fun, [H|T]) ->
    Lid = spawn_link(?MODULE, psort, [self(), Fun, [X||X <- T, Fun(X, H)]]),
    Rid = spawn_link(?MODULE, psort, [self(), Fun, [X||X <- T, not Fun(X, H)]]),
    receive
        {Lid, L} -> Left = L
    end,
    receive
        {Rid, R} -> Right = R
    end,
    Pid ! {self(), Left ++ [H] ++ Right}.
%% @spec psort(fun(X, Y) -> bool(), list(any())) -> list(any()).
psort(Fun, L) ->
    Pid = spawn_link(?MODULE, psort, [self(), Fun, L]),
    receive
        {Pid, R} -> R
    end.
psort(L) -> psort(fun(X, Y) -> X < Y end, L).

解决父任务的进程通过接受子进程发来的消息来获得结果。然而，这个代码除了前面的问题之外，也有两个问题：1. 粒度太小，如果小到连一个空列表都要生成一个新的进程来解决问题，那么创建进程的开销就会大过计算本身。2. Programming Erlang中讲到，并发编程要注意“小消息，大计算”，这里在消息中频繁传递列表是开销较大的操作。

我通过生成1000个0-1000之间的随机数的列表来测试这两个算法的性能，在我的迅驰1.8G的本上，结果表示：

lists:sort 1.45ms
qsort 9.44ms
psort 30.75ms

看来我的这两个实现还是比较低效的。首先关于qsort的两个问题，1. 遍历了两次列表，可以通过单独使用一个分区函数来遍历一次完成对列表的划分；2. 不是尾递归，可以使用一个累加器来收集结果，此法可以将其中一个递归变成尾递归（我还无法做到两个都消除）。

qsort3(_F, []) -> [];
qsort3(F, L) -> qsort3_acc(F, L, []).

qsort3(L) -> qsort3(fun(X, Y) -> if X < Y -> -1; X =:= Y -> 0; true -> 1 end end, L).

qsort3_acc(_F, [], Acc) -> Acc;
qsort3_acc(F, [H | T], Acc) ->
    part_acc(F, H, T, {[], [H], []}, Acc).

part_acc(F,_, [], {L,E,G}, Acc) ->
    qsort3_acc(F, L, (E ++ qsort3_acc(F, G, Acc)));
part_acc(F, X, [H | T], {L, E, G}, Acc) ->
    C = F(H, X),
    if
        C < 0 ->
            part_acc(F, X, T, {[H | L], E, G}, Acc);
        C =:= 0 ->
            part_acc(F, X, T, {L, [H | E], G}, Acc);
        true ->
            part_acc(F, X, T, {L, E, [H | G]}, Acc)
    end.

此为改进版的快速排序。在此基础上，再解决并行快速排序的两个问题：1. 粒度太小：可以设置一个阈值，当列表长度小于多少时，调用快速排序解决问题；2. 消息太大——我还没想到解决方案。

psort3(Pid, _F, _Granularity, []) ->
    Pid ! {self(), []};
psort3(Pid, F, Granularity, [H|T]=Ls) ->
    if length(Ls) < Granularity ->
        Pid ! {self(), qsort3(F, Ls)};
    true ->
        {Lesser, Eq, Greater} = part(F, H, T, {[], [H], []}),
        Lid = spawn_link(?MODULE, psort3, [self(), F, Granularity, Lesser]),
        Rid = spawn_link(?MODULE, psort3, [self(), F, Granularity, Greater]),
        receive
            {Lid, L} -> Left = L
        end,
        receive
            {Rid, R} -> Right = R
        end,
        Pid ! { self(), Left ++ Eq ++ Right }
    end.

psort3(F, Granularity, L) ->
    Pid = spawn_link(sort, psort3, [self(), F, Granularity, L]),
    receive
        {Pid, R} -> R
    end.
psort3(L) ->
    psort3(fun(X, Y) -> if X < Y -> -1; X =:= Y -> 0; true -> 1 end end, 100, L).

测试结果为：

qsort3: 5.31ms
psort3: 7.76ms

另外，我发现，如果从命令行中传递比较函数，则性能下降非常大，不知何故。

电信的宽带迁移更人性化了

ShiningRay — Mon, 04 Aug 2008 21:28:53 +0800

在上海搬了好几次家，每次都要把自己的宽带迁移，前几次电信的方法是这样的：交迁移手续费，并且将过去的欠帐结清，迁移到新的地址之后，帐号和密码都会重新更换，最奇怪的是当月到办理迁移当天剩下的钱却会重新有一个帐单寄到原来的地址，然而我肯定是不会回去拿那个帐单了。
而这一次非常方便，迁移手续费会直接算入下一个月的帐单中，并且也不需要更改帐号和密码了，很好。

Programming in Erlang

ShiningRay — Mon, 04 Aug 2008 13:11:34 +0800

上上周搬了家，把宽带迁了，借着青黄不接的几天不能上网的光景，看完了”Programming in Erlang“。

Erlang是一门面向并发和分布式的编程语言。Programming in Erlang以非常浅显的语言，介绍了Erlang的各个方面的基础，是一本合适的入门教材。作为入门教材，能够提到OTP的一些常用内容和常用的分布式设计的思想，已经非常不错了，加上书后的参考。我更感兴趣的是如何使用erlang来构建高并发、分布式系统，包括它的设计模式、部署模式等等，并没有在本书中涉及，非常关键的OTP、Mnesia也仅仅只涉及了一些基础。当然它还是给出了深入学习的途径。

看完了本书，加上翻阅了一些资料，我对Erlang有了更深入的了解，也纠正了一些错误概念：

过去曾认为Erlang就代表高并发，高并发就代表高性能，同时认为Erlang就只是高并发的代名词。其实，Erlang的并发性能也并非最强。首先Erlang的虚拟机是C写的，其次诸如Haskell、OCaml + JoCaml，以及Python的PyPy，其实都能提供不弱于Erlang的并发能力。

同时Erlang在顺序计算上的性能也不佳，甚至不能超过Python、Lua这类脚本语言（也许是和其本身的特殊性质有关）。所以就更落后于Haskell和OCaml这类可编译的语言。然而即使并发和并行也需要顺序计算，所以单从并发性能上来说，Erlang还不是最强的。

Erlang写的Yaws这个Web服务器，虽然能承受高并发，但性能，尤其是IO性能依然无法与lighttpd、nginx这种C写的Web服务相比——Erlang的虚拟机本身也是C写的。

同时，Erlang本身设计为一个结构化编程语言而非面向对象编程语言。这就令其较难应用更有开发效率的面向对象的项目开发流程和方法。

那么为何Erlang在并发、分布式编程中如此受推崇？我认为因为它本身是并发和并行在语义、处理上的一致，所以它编写此类程序更加方便。同时，它提供的是一个关于并发、并行以及分布式的统一的解决方案，而不仅仅是高并发。它的目的是构建有容错能力、有伸缩性的可靠系统，同时又能最简化编程工作。这就是它的真正的优势。

Shanghai on rails 7月26日活动小记

ShiningRay — Tue, 29 Jul 2008 13:01:36 +0800

第一次参加Shanghai on rails，不过因为搬家事宜，听完了三个演讲之后就立刻闪人了。

高举旗帜

伙食很重要

领导的指示也很重要

PPT分享：

PPT of Role based Permission
给你点新思路

code_refactoring_javaeye_rails1.x_2.x
都是干货

open social
其实题目是‘shaking-the-money-tree’

感谢Vibram，我们有了视频
http://www.tudou.com/playlist/id/4072842/

特别感谢：
演讲嘉宾，包括Javaeye,chinaonrails在内的所有rails社区. 还有，最重要的
我们的赞助商
易空海 http://www.ekohe.com/
ShellShadow http://www.shellshadow.com
结构数据公司 http://www.structuredcommons.com/
ELC Technologies http://elctech.com

重叠、指针转换和gcc3.3

ShiningRay — Wed, 23 Jul 2008 15:12:20 +0800

http://mail-index.netbsd.org/tech-kern/2003/08/11/0001.html

Subject: Aliasing, pointer casts and gcc 3.3.

To: None <tech-kern@netbsd.org>

From: Krister Walfridsson <cato@df.lth.se>

List: tech-kern

Date: 08/11/2003 23:16:48

我见过一些用来“修复”gcc 3.3 别名警告的提交，这些并没有给我貌似温存的感觉，同时我总是在不同的邮件列表看到很多关于别名（一般来说是ISO C）概念的混淆，所以我尝试解释一些已经/将要困扰我们的一些问题。

如果本文太浅显，请包涵。

重叠（ALIASING）

什么是重叠？

从硬件的角度来看指针的话，指针可以指向任何内存地址，所以通过指针写入可以更改程序中的任何变量：

int i = 23;

*f = 5;

/* 这时候我们不能确定i是什么值。 */

我们无法得知i的值，因为指针&i和f可能指向同一个地址（这就是当ISO C说&i与f可能重叠时所表达的意思）。

这样就使很多类型的优化无法进行，同时它也确实造成了实实在在的区别，因为现实情况中多数指针是不会指向同一个位置的。ISO C通过（大致）说“不同类型的指针不能指向同一个地址”来（针对编译器）改进了这个情况。

int

foo(float *f) {

        int i = 23;

        *f = 5.0;

        /* float* 不能和 int* 指向同一个地址。 */

        return i * 2;

}

这样，编译起可以将其优化为：

int

foo(float *f) {

*f = 5.0;

return 46;

}

The ISO标准并不完全阻止指针指向同一个地址——它指定了当你提领指向一个不同（不兼容）类型的对象的指针时，结果是不确定的。所以以下例子也是可行的：

int i = 23, *tmp;

tmp = (int*)f;

*tmp = 5;

/* 我们无法确定i现在的值。 */

不过注意，我们实际上在内存中按照“int”写入而非按照“float”。

然而以上规则有一个非常重要的例外： char* 可以重叠任何类型（如果ISO阻止这点，那么太多的代码就会坏掉……）

很多情况下你还是想以不同的类型来访问同一个地址：

float *f = 2.718;

printf(”The memory word has value 0x%08x\n”, *((int*)f));

在ISO C中，你不能这么做，但是gcc在这里会进行一个扩展，认为内存中存在一个有多个类型的联合体，所以以下代码可以在gcc中运行（但不能保证在其他编译器中也可以运行！）

union {

int i;

float f;

} u;

u.f = 2.718;

printf(”The memory word has value 0x%08x\n”, u.i);

有个副作用是当你使用很多联合体构造时，gcc可能会损失很多优化。

标准是如何说的[*]

第6.5条（表达式）陈述了重叠规则：

7 一个对象只允许通过有以下类型之一的左值表达式来访问对象存储的值：{脚注73}

      一种与该对象的有效类型相兼容的类型，

     一种与该对象的有效类型相兼容的类型的正规版本，

     一种与该对象的有效类型相对应的有符号或无符号类型，

     一种与该对象的有效类型相兼容的类型的正规版本相对应的有符号或无符号类型，

     一种聚合或联合类型包含了上述类型之一成员（包括递归的子聚合或被包含的联合体），或者

     一种字符类型。



{脚注73} 该列表的意图是指定哪些情况下，对象可能或可能不被重叠。

7 An object shall have its stored value accessed only by an lvalue

   expression that has one of the following types: {footnote 73}

     a type compatible with the effective type of the object,

     a qualified version of a type compatible with the effective type of

     the object,

     a type that is the signed or unsigned type corresponding to the

     effective type of the object,

     a type that is the signed or unsigned type corresponding to a

     qualified version of the effective type of the object,

     an aggregate or union type that includes one of the aforementioned

     types among its members (including, recursively, a member of a

     subaggregate or contained union), or

     a character type.

{footnote 73} The intent of this list is to specify those circumstances

in which an object may or may not be aliased.

gcc的警告

gcc会警告某些可能会破坏重叠规则的构造，但不是所有（甚至大部分都没有警告），所以没有出现警告的源代码并不能给你任何担保。

最常见的警告可能是“提领类型双关的指针将破坏强重叠规则”（dereferencing type-punned pointer will break strict-aliasing rules）。它给出警告的位置一般来说是不会错的——gcc想告诉你的是当你提领了指针后，你可能会破坏重叠规则（除非你首先将它转换为原始类型）。该警告应该解释为，你的接口可能设计得很差，同时正确避免该警告的方式是重新以一种无须在相冲突的类型之间转换的方式重新设计他们。（即使你可以通过将void**改成void*来绕过这个警告）

指针转换和对齐

问题

很多架构都要求指针在访问大于一个字节的对象时能够正确对齐。然而系统代码中很多地方你只能接受到未对齐的数据（如，网络栈），所以你需要更正它：

    char* data;

    struct foo_header *tmp, header;

    tmp = data + offset;

    memcpy(&header, tmp, sizeof(header));

    if (header.len < FOO)

    [...]

然而这是无效的……原因是当你将一个未对齐的值赋给指向需要进行对齐的类型的指针的时候，行为是不确定的。在以上例子中所发生的是，gcc注意到tmp和header必须被对齐，所以它可能会使用了一个内联的memcpy，它用到了假设数据已对齐的指令。

正确的修正方式是不使用foo_header指针。

    char* data;

    struct foo_header header;

    memcpy(&header, data + offset, sizeof(header));

    if (header.len < FOO)

    [...]

上面的例子可能看上去比较傻，但确实是让我们好几次头疼……

标准是如何说的[*]

在第6.3.2.3条（指针）中陈述了指针对齐要求：

7 [...]指向某个对象或者不完全类型的指针可以被转换成指向另一个不同对象或者不完全类型的指针。如果得到的指针没有针对所指向的对象被正确地对齐{脚注57}，行为是无法确定的。否则，当转换回去时，结果应该与原始指针相同。[...]

{footnote 57} 一般来说，“被正确对齐”的概念是传递的：如果一个指向A类型的指针被正确为指向B类型的指针进行对齐，同时指向B类型的指针又是正确为一个指向C类型的指针对齐的，那么指向A类型的指针则是针对指向C类型的指针正确对齐的。

7 A pointer to an object or incomplete type may be converted to a pointer

   to a different object or incomplete type. If the resulting pointer is

   not correctly aligned {footnote 57} for the pointed-to type, the

   behavior is undefined. Otherwise, when converted back again, the result

   shall compare equal to the original pointer. [...]

{footnote 57} In general, the concept “correctly aligned” is transitive:

if a pointer to type A is correctly aligned for a pointer to type B,

which in turn is correctly aligned for a pointer to type C, then a

pointer to type A is correctly aligned for a pointer to type C.

总结

ISO C已经不是爷爷用的C了，同时把它认为是一种高级机器语言的想法也是错的……

指针转换非常不和谐（无论是显式还是隐式转换），同时你必须在给代码加入指针转换前三思。

[*] 标准引用来自ISO/IEC 9899:1999，不过老的ANSI/ISO标准基本上说的一样。

作者：Krister，翻译：ShiningRay

提领类型双关的指针将破坏强重叠规则

ShiningRay — Fri, 18 Jul 2008 11:54:13 +0800

最近复习C/C++，今日用APR编写了一个生产/消费模型的小程序。结果出现了这样一个奇怪的警告：“提领类型双关的指针将破坏强重叠规则”，让我大惑不解，特此和大家讨论一下。

我用的是gcc 版本 4.2.3 (Ubuntu 4.2.3-2ubuntu7) 线程模型：posix。出现警告的这段是这样的：

    apr_queue_t *queue = (apr_queue_t *) data;
    int *d = NULL;
    while(1){
        apr_queue_pop(queue, (void **)(&d)); // －－ 此处为出现警告的地方。
        printf("Consumed: %d\n", *d);
    }

虽然可以运行无误，但该警告还是让我比较无奈，最后我改成了如下：

    apr_queue_t *queue = (apr_queue_t *) data;
    int *d = NULL;
    void *c = NULL;
    while(1){
        apr_queue_pop(queue, &c);
        d = (int *)c;
        printf("Consumed: %d\n", *d);
    }

因为很久没有写C，在这里，我的问题是：

什么叫做“提领类型双关的指针”？
什么是“强重叠规则”？
为什么会破坏？
破坏之后会引发什么问题？

希望有C/C++达人能解决我这些疑问，谢谢。

附源代码：main.c

关于《浅析Rails部署》

ShiningRay — Fri, 11 Jul 2008 14:18:08 +0800

我之前写的文章《浅析Ruby on Rails部署方案》受到不少同学的关注，在此首先感谢大家。

但是也有同学对此提出了一些疑问，我经过检查，发现文章确实存在很多漏洞和不足：

Lighttpd作为负载均衡反向代理时，无论是链接FastCGI还是HTTP后端，KeepAlive链接默认都是关闭的
Nginx的FastCGI模式，默认也是关闭持久链接的
缺少了一些重要的前后端搭配的方式
对于Rails应用的内存占用也应该考虑在内

我会针对这一些问题，重新设计测试案例，并重写该文章。再次感谢大家的关注。

php shell

ShiningRay — Fri, 04 Jul 2008 18:15:54 +0800

本文要讲的php shell并非是使用php来写shell脚本，而是讲一个php的REPL的交互式shell。所谓REPL，也就是read-eval-print-loop，也就是说，shell读入一个指令，计算，然后输出结果，常见的有Python、Ruby的IRB等。

对于PHP，我们常常会写一个test.php，然后放入一些自己的代码，再打开浏览器检验一下，如果不对，又要重新修改代码，非常麻烦。交互式shell的好处就可以体现出来了，输入指令之后可以立刻看到执行代码的结果，所以非常适合用来检验代码片段（snippets）的正确性以及进行一些试验。

PHP本身自带一个交互式的shell，在命令行中输入php -i，便可以交互式运行，但要先输入一个php脚本的起始标签，但是该shell遇到异常的时候会直接退出，非常不方便。那么我找到一个非常接近于REPL的交互式shell便是php-shell

1. 安装

php-shell要求php 5.0以上版本

下载PHP_Shell-0.3.1.tgz

运行pear install PHP_Shell-0.3.1.tgz

如果确保pear已经安装，并在你的PATH路径中

2. 使用方法

在命令行下输入php-shell（Linux为php-shell.sh）进入交互式命令行：


PHP-Shell - Version 0.3.1, with readline() support
(c) 2006, Jan Kneschke <jan@kneschke.de>

>> use '?' to open the inline help 

>>

这时候我们可以输入我们所需的表达式了，在php-shell中直接输入变量名，它也可以将内容直接打印出来：

>> $a = new ArrayObject( )
ArrayObject::__set_state(array(
))
>> $a->
__construct(
append(
count(
exchangeArray(
getArrayCopy(
getFlags(
getIterator(
getIteratorClass(
offsetExists(
offsetGet(
offsetSet(
offsetUnset(
setFlags(
setIteratorClass(
>> $a->append( 'a' )

>> $a->count( )
1
>> $a->offsetGet( 0 )
'a'

当出现异常时，php-shell也会打印出异常的内容。
你可以使用exit退出。

3. Tab补全

php-shell一个强大的功能是支持补全，以下内容可以被补全：

new 类名()
类名::方法名()
类名::常量名
$变量名
函数名()
$object->方法名()

请先输入第一个字符然后按TAB按钮。如果只有一种匹配，它便会直接补全名称，否则，再按一次TAB会列出所有的可能性。

如果你想查看所有已声明的类，你可以使用 getdeclaredclasses()：

>> get_<TAB>
>> get_<TAB><TAB>
get_browser(
...
get_declared_classes(
...
get_resource_type(
>> get_dec<TAB>
>> get_declared_<TAB><TAB>
get_declared_classes(
get_declared_interfaces(
get_defined_constants(
get_defined_functions(
get_defined_vars(
>> get_declared_classes( )

4. 总结

如果是php新手，希望php-shell能帮你快速掌握php。老手也可以用其来检验代码段。

除此之外，也可以尝试一下基于Web页面的php shell，如http://phpshell.sf.net/