33小时，不睡觉啊？

@SErHo 你就不能顺便贴个链接什么的，比如

http://stackoverflow.com/questions/9371238/why-is-reading-lines-from-stdin-much-slower-in-c-than-python

http://stackoverflow.com/questions/9378500/why-is-splitting-a-string-slower-in-c-than-python

@est 同样是做web，用C++的明显档次就高了很多，只有用C++，才可以充分发挥你对语言规范以及编译器实现的所有细节的深入了解。用上模板元，尽可能深度嵌套直到不修改编译器模板递归层数会编译不过，用LLVM来充当一个加速模板编译的JIT，并实现模板编译期的尾递归，......。谁还敢说用C++写Web的浮躁了，光编译就有无数的学问呢。

最后搞出一个巨大的神经网络来算 true and false = false ?

@muxi 扬长避短，你不比也知道哪个长哪个短？

@iwinux 顺便补充一下，之前忘了说了，打算用pypy跑Django的必须特别小心，不然会悲剧的。Django代码写的时候都是为CPython优化的。Django 1.4引入了PBKDF2，默认是用一个纯Python实现的，特别为CPython速度优化的版本。在CPython上的运行速度，快得令人发指。但直接拿到pypy上跑会很慢。但即便是去掉那些特别优化，用最一般的实现在pypy上跑，还是比不过在CPython上跑的那个特别优化版本。

码农也是要吃饭的，哪里钱多往哪里去

@skywinger

其实Scala的Actor和Erlang process几乎是一样快的，但是用起来就不是那么一回事了。

下面的代码是根据这篇博客里的代码改的
http://www.krazykoding.com/2011/07/scala-actor-v-erlang-genserver.html
那里面Erlang代码用的是cast，对Scala太不公平了，所以改成call。
你可以看到，Scala还是要慢一点。

--------------------------------------------------------------
$ cat Client.scala
import scala.actors.Actor._
import scala.compat.Platform
import scala.actors.Scheduler

object Client {
val server = new Server

def main(args: Array[String]) {
runTest(3000000)
Scheduler.shutdown
}

def runTest(msgCount: Int) {
val start = Platform.currentTime
val count = test(msgCount)
val finish = Platform.currentTime
val elapsedTime = (finish - start) / 1000.0

printf("Count is %s%n",count)
printf("Test took %s seconds%n", elapsedTime)
printf("Throughput=%s per sec%n", msgCount / elapsedTime)
}

def test(msgCount: Int) :Any = {
val bytesPerMsg = 100
val updates = (1 to msgCount).foreach((x: Int) => server ! (AddCount, 1))

val count = server !? GetCount
return count
}
}

$ cat Server.scala
import scala.actors.Actor

case object GetCount
case object AddCount

class Server extends Actor {
var count: Int = 0

def act() {
react {
case GetCount =>
reply(count)
act
case (AddCount, c: Int) =>
count=count+c
act
}
}
start()
}

$ cat client.erl
-module(client).

-export([runTest/1, start/0, start/1, main/1]).


start() ->
main([]).

start(Args) ->
main(Args).

main(_Args) ->
runTest(3000000),
halt().

runTest(Size) ->
server:start_link(),
Start=now(),
{ok, Count} =test(Size),
Finish=now(),
server:stop(),
io:format("Count is ~p~n",[Count]),
io:format("Test took ~p seconds~n",[elapsedTime(Start,Finish)]),
io:format("Throughput=~p per sec~n",[throughput(Size,Start,Finish)]).

test(Size) ->
lists:foreach(fun (_X)-> server:add_count(1) end, lists:seq(1,Size)),
server:get_count().

elapsedTime(Start,Finish) ->
(toMicroSeconds(Finish) - toMicroSeconds(Start)) /1000000.

toMicroSeconds({MegaSeconds,Seconds,MicroSeconds}) ->
(MegaSeconds+Seconds) * 1000000 + MicroSeconds.

throughput(Size,Start,Finish) -> Size / elapsedTime(Start,Finish).

$ cat server.erl
-module(server).

-behaviour(gen_server).

-export([
start_link/0,
stop/0]).

-export([
init/1,
handle_call/3,
handle_cast/2,
handle_info/2,
terminate/2,
code_change/3]).

-export([
add_count/1,
get_count/0]).

-define(SERVER, ?MODULE).

-record(state,{count}).

start_link() ->
gen_server:start_link({local,?SERVER}, ?MODULE, [], []).

get_count() ->
gen_server:call(?SERVER, get_count).

add_count(Count) ->
gen_server:call(?SERVER, {add_count, Count}).

stop() ->
gen_server:call(?SERVER, stop).

init(_Args) ->
{ok,#state{count=0}}.

handle_call(get_count, _From, State) ->
{reply, {ok, State#state.count}, State};

handle_call({add_count, Count}, _From, State) ->
{reply, ok, State#state{count=State#state.count+Count}};

handle_call(stop, _From, State) ->
{stop, normal, ok, State}.

handle_cast(_Msg, State) ->
{noreply, State}.

handle_info(_Msg, State) ->
{noreply, State}.

terminate(_Reason, _State) ->
ok.

code_change(_OLdVersion, State, _Extra) ->
{ok,State}.

$ time scalac Client.scala Server.scala

real 0m7.553s
user 0m12.683s
sys 0m0.372s
$ time erlc client.erl server.erl

real 0m0.223s
user 0m0.169s
sys 0m0.050s
$ scala Client
Count is 3000000
Test took 10.67 seconds
Throughput=281162.1368322399 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.154026 seconds
Throughput=367916.4133153365 per sec
$ scala Client
Count is 3000000
Test took 8.98 seconds
Throughput=334075.72383073496 per sec
$ scala Client
Count is 3000000
Test took 9.076 seconds
Throughput=330542.0890260026 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.083946 seconds
Throughput=371105.89308736107 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.09488 seconds
Throughput=370604.6290988872 per sec
$ scala Client
Count is 3000000
Test took 9.326 seconds
Throughput=321681.3210379584 per sec
$ scala Client
Count is 3000000
Test took 10.705 seconds
Throughput=280242.8771602055 per sec
$ scala Client
Count is 3000000
Test took 9.165 seconds
Throughput=327332.24222585926 per sec
$ scala Client
Count is 3000000
Test took 9.992 seconds
Throughput=300240.192153723 per sec
$ scala Client
Count is 3000000
Test took 9.043 seconds
Throughput=331748.31361273915 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.100325 seconds
Throughput=370355.51042705076 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.127942 seconds
Throughput=369097.1220021009 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.092804 seconds
Throughput=370699.6981515925 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.117081 seconds
Throughput=369590.98966734466 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.104893 seconds
Throughput=370146.7743004133 per sec
$ scala Client
Count is 3000000
Test took 10.224 seconds
Throughput=293427.23004694836 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.11626 seconds
Throughput=369628.3756311404 per sec
$ erl -noshell -s client
Count is 3000000
Test took 8.120545 seconds
Throughput=369433.3323687019 per sec
$ scala Client
Count is 3000000
Test took 10.094 seconds
Throughput=297206.2611452348 per sec
$

@skywinger 还是总结下，一条条写

--------------------------------------------------------------
> 多说无意，还是一切以实验为主。
> JVM是否启动慢，我不知道你是从何得来的观点依据，但是，我觉得你本身就是对java及JVM有很强烈的偏见。

(我给出了实验代码)

> 我不讨论启动速度不讨论启动速度，我关注的是vm的并行计算能力，高性能的内存模型。

--------------------------------------------------------------
> 目前所有VM中最完善，速度最快，效率最高，第三方支持最多工业级的JVM

肯定不是最完善，肯定有很多方面是不如别的VM，毕竟有历史包袱在那儿。
速度最快，这个只能说是JIT做得最好，有不少情况JVM并非最快。
效率最高？效率的定义是啥？
工业级，在Erlang VM面前只能算个玩具。
--------------------------------------------------------------
> 我不相信ruby或是python会比JVM下运行的NIO程序快。

NIO就是封装了select/poll/epoll/kqueue/IOCP这样的API而已。Python/Ruby都有这些API的封装。用不用这个API，和快不快，一点关系都没有。这个只是让你能比较容易地保持更多的连接而已。运行速度还是看解释器效率的。
--------------------------------------------------------------
> 能不能就写个数学计算方面的能够尽量应用cpu的样例再来比较一下
有几个很基本浮点数运算，用gcj编译，加或者不加常用于浮点数运算的编译参数，竟然都跑不过JVM。

但是光比快，C/C++/Haskell/Fortran之类的直接编译到机器码的语言，各有擅长的领域，基于VM的，几乎可以肯定的是，无论在哪个领域，肯定比不过这其中的最适合那个领域的一种。
--------------------------------------------------------------
> 我关注的是vm的...，高性能的内存模型。
高性能内存模型，和语言/库的关系更大一点。

如果真如你所说，LMAX项目干嘛还要发明disruptor呢。
http://code.google.com/p/disruptor/
--------------------------------------------------------------
> Erlang 是process模型，Scala 是thread Actor模型，孰优孰劣，大家自然清楚。
最好看清楚点

http://en.wikipedia.org/wiki/Erlang_%28programming_language%29
> For concurrency it follows the Actor model.

Erlang在VM级别就真正实现了消息机制，而不是在这之上用别的方法去模拟。模拟会导致一个问题，一个Actor只要不主动交出控制权就可以一直占掉一个线程。

Erlang的优势还是很明显的：
每个Erlang process是独立GC的。GC延时对整个系统的运行影响很小。JVM也可以做到这样，但是，一旦你碰到GC把你卡太久的时候，你得完全理解JVM的GC是怎么工作的，理解CPU的缓存机制，再根据需要打造你需要的库。比如disruptor。用Erlang，你仅仅是损失一点点运行速度。

按照OTP风格写的代码，新版本代码替换掉旧版本代码的时候不需要停掉进程。JVM也可以做到，可是有多少库是兼容OSGi的。你用到的库不兼容OSGi，你打算都自己去改代码么。
--------------------------------------------------------------

@skywinger 我说的是启动速度，启动速度，启动速度，你看清楚点行不。

@skywinger

--------------------------------------------------------------
class Hello {
public static void main(String argv[]) {
System.out.println("Hello, world!");
}
}
--------------------------------------------------------------

--------------------------------------------------------------
#!/usr/bin/env python2

class Hello(object):

@staticmethod
def main(argv):
print "Hello, world!"


if __name__ == "__main__":
import sys
Hello.main(sys.argv[1:])
--------------------------------------------------------------

$ javac Hello.java
$ time java -cp . Hello
Hello, world!

real 0m0.075s
user 0m0.050s
sys 0m0.021s

$ time python hello.py
Hello, world!

real 0m0.039s
user 0m0.029s
sys 0m0.009s

$ time pypy hello.py
Hello, world!

real 0m0.047s
user 0m0.031s
sys 0m0.014s

要注意为了尽可能体现JVM的优势，已经把Python代码扭曲成Java那样了，而且没有预先生成bytecode。

@skywinger 难道工业级就是光比谁速度快？写个埃拉托色尼质数过滤算法的程序就是实际程序了？你先搞清楚要比啥，怎么比，好不好。

@iwinux C extension，很多有问题都是因为pypy和CPython GC机制不一样。上次看见哪里有个兼容列表的。

@skywinger 我说的是启动速度，启动速度，启动速度，你看清楚点行不。

@skywinger 所谓工业级就是比这个？你开玩笑啊

@iwinux 启动速度慢啊，连CPython这种巨慢无比的解释器启动速度都比JVM快了啊

@iwinux pypy的问题是特别能吃内存

@skywinger 说的是启动速度，不是运行速度。

JVM怎么可能是工业级的，连GC延时都要费很大的力气才能控制在1ms之内。

@skywinger 和Erlang VM相比，JVM就一玩具而已。另外也别忘了，JVM同时也是启动速度最慢的。