v2ex 有用Scala做web开发的吗？

有没有Scala的同好呢?

Scala 写 web app 也是扔到 Tomcat/Jetty 里面跑的么？

@iwinux 不一定是的。
play framework 是类似RoR这类的full stack framework 一站式框架，
不依赖任何web服务器或是java web容器。

还有人对Scala 做web应用开发感兴趣的么？

招募Scala爱好者

现在 Scala 大规模应用是不是只有 4SQ？

@skywinger 兴趣是有的，但我连 Scala 都还没开始学呢，最近在玩 Clojure...

@skywinger 你是在组建开发者社区？

@iwinux 我只是对Scala 在并行计算方面的特性特别感兴趣，因为我原先就是从事大并发量的后台服务端程序开发的。
嗯，如果条件合适的话，有可能组建开发者社区。
Scala有一点是ruby、python、Erlang这类的语言所无法比拟的优势：
那就是Scala所运行的VM环境是目前所有VM中最完善，速度最快，效率最高，第三方支持最多工业级的JVM。

相比Scala还是Clojure更吸引人 :)

@Kymair 我说了我关注的是并行计算这块的，更加的关注VM本身的效率和速度。
因此Scala对我的吸引更大。

@Kymair 不好意思，我可能说的有点快，没注意到Clojure也是基于JVM上的。

我更喜欢Scala这种静态类型，带有泛型与OOP的语言。

某个金融机构里有用Scala，主要还是看中了语法简洁和在JVM直接运行。

scala 路过

还不太理解一站式框架....

看到Scala这种和c++一个复杂度的语言就头疼。。。

@iandyh twitter貌似也在用scala?

twitter 目前已经把它们的应用从ruby环境搬迁到Scala JVM环境上了。
并发响应速度快了N倍。

据说知乎也要转向 Scala

@zhuzhuor 有兴趣的话，可以搜索下twitter内部关于ruby 与 Scala的比较大讨论。

@skywinger 我个人比较讨厌ror...
之前踢出mongrel作者的事情（貌似搜不到了？不知道我记得对不对）
还有前两天github的事情

@zhuzhuor 我只是觉得Ruby的动态语言特性我不大适应，毕竟我以前都是用的c、c++、delphi、java、都是静态类型的语言。
个人对Scala更加适应些，可以说是无缝适应，上手快。

@skywinger 哦～～不过我觉得python很不错，可读性很好
现在有pypy解析器，跟c之类的静态语言的速度差距也变小了
觉得以后python要一桶浆糊了！...

@zhuzhuor 虽然目前各个动态语言的VM在不断完善与改进性能与速度，但是跟JVM比还是有着数量级上的差距。目前JVM的执行效率与速度与C++的性能已经很接近了，不存在数量级别的差距，只是还稍微比原生语言差了一点点，甚至在多线程、并发处理及NIO方面差距更小。毕竟JVM能有今天，主要还是之前各大IT巨头（IBM、Sun、Oracle、BEA）等投入了大量的资源进行研发与改进。
另Python我个人也很喜欢，也在某些场合下使用。不过做为一种可以应用于多场合，安全、高效、代码易于阅读的语言来说，Scala是我认为比较符合上述条件的语言。

楼主又要引起口水战了
不过是个工具，什么场合用什么呗

@skywinger 你觉得好你就用呗......

@zhuzhuor 更正一下，pypy现在所谓的差距缩小是指与CPython编译器相比，而非与C语言本身进行效率对比。不过这个与本帖话题无关，飘过~

@hilyjiang 前阵子我看到有几个quora工程师们关注了scala，而且也已经有些项目在使用scala了。
http://www.quora.com/Is-the-Quora-team-considering-adopting-Scala-Why

@reorx 就相当于是提速了嘛...原先我用c重写python同样功能的代码，大致就是1-2个数量级差别
但是有pypy，原来的代码不用改动就能提速1个数量级...个人觉得pypy还是超nb啊...我还小donate了10刀...

@zhuzhuor @alexzhan @reorx @muxi @hilyjiang @insraq @iwinux
看来大家讨论时还是避免各种语言之间的论战吧，选择适合自己的才是最重要的。
那么有同样喜欢Scala的同学么？

@skywinger 我我我！~不过我是scala新手啊。。。也是为了play才学的scala~

@voidmain 你也在用play啊？

@skywinger 是啊~~在别人的推荐下用的~目前毕业设计在用这个做~~

@ play支持java和scala两种JVM语言，挺灵活的，唯一缺点就是doc及help比较少，国内用的人还不多。

@skywinger @muxi

个人认为，因为害怕口水战而不敢讨论编程语言在不同应用场景的优劣，是挺可悲的事情啊。盲目地说“XXX就是最牛的语言”和客观地讨论“XXX在并行计算方面有很大优势”，这两者是有本质区别的吧。

@reorx 现在pypy的速度已经远超CPython了，何谈缩小和CPython的差距

@glasslion @reorx 很好奇 PyPy 能在生产环境使用了么……比如跑个 Django 什么的？

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

@bhuztez “最慢”是跟什么 VM 比呢？

@zhuzhuor @glasslion 不好意思是我看错了，把 http://speed.pypy.org/ 的benchmark 图表的Y轴理解反了。

@iwinux 目前只听说Quora有使用，不过根据groups里的讨论来看，pypy是非常"stable and productive"的。

@iwinux quora已经跑在pypy上面了。http://www.quora.com/Alex-Gaynor/Posts/Quora-is-now-running-on-PyPy

@bhuztez
Erlang 是process模型，Scala 是thread Actor模型，孰优孰劣，大家自然清楚。
说ErlangVM比JVM快，全世界人民都笑了。
千万不要迷信，也不要心理上排斥java及jvm
jvm无疑是目前工业级的VM。

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

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

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

@bhuztez 多说无意，还是一切以实验为主，大家可以写个埃拉托色尼质数过滤算法的程序，来比较下。

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

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

@bhuztez @skywinger 照我的理解，在 real-time system 这类应用里，Erlang 比 JVM 有优势？我对这两个 VM 都不了解，但偶尔会看到有人吐槽 JVM 的 GC...

@glasslion 看上去已经脱离玩具阶段了啊。不过我想问那些用了 C extension 的 Python 库怎么办？以及 PyPy 是不是还没有摆脱 GIL？

@bhuztez 连实际写程序来比都不敢比，谈何谈论哪个VM快？？？

@iwinux pypy正准备去掉GIL，pypy将会使用STM.

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

@bhuztez 和你谈论这个一点意思都没有，你偏执的有点。。。。

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

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

@bhuztez JVM是否启动慢，我不知道你是从何得来的观点依据，但是，我觉得你本身就是对java及JVM有很强烈的偏见。

@bhuztez 我的应用偏向大并发量，并行处理速度及复杂业务计算方面的，这方面JVM无疑是非常快的。

不知道在大型机环境下，处理纯数字的数据方面，从处理速度来说Scala能比COBOL要快多少

@bhuztez 不是所有的应用都是做web方面的，并行计算，并发通讯方面的，我不相信ruby或是python会比JVM下运行的NIO程序快。

@skywinger @bhuztez 这楼彻底歪了...

关于 JVM 的 startup time，可以参考 http://en.wikipedia.org/wiki/Java_performance#Startup%5Ftime

虽说不是所有 VM 中最慢的，但也快不到哪里去（这里不讨论运行性能的问题）

@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。

@bhuztez 你好意思写出hello world的例子，这玩意只跟type在堆栈内存中的push及poll 以及io有关，能不能就写个数学计算方面的能够尽量应用cpu的样例再来比较一下？？

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

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

看到楼上有小白在吹PyPy的性能了，想起以前有人说过的。一个Python程序员，能搞清楚PyPy，CPython，Jython这几个在什么场景下能达到性能最优，才可以被认为是一个优秀的Python程序员。连GIL存在的意义都没搞清楚，说JVM启动比执行速度更慢的CPython更慢来抨击JVM的，更是不知道说啥好了。

@ayanamist 明白人。

这帖窜得快啊，试用下play感觉不错，然后发现oschina上在搞play问答:)

@skywinger

playframework2.0正式版才发布没有几天，楼主很迅速。我用play1.2做过私有项目，也在看关注Scala。

Scala的web框架其实还有不少：https://github.com/scalatra/scalatra ，http://liftweb.net/

@szanlin play framework 很优雅，RoR的很彻底，但扩展性又比RoR好太多了，再加上JVM的执行速度与效率，确实是静态语言方面做Web的最好选择了。

@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，你打算都自己去改代码么。
--------------------------------------------------------------

其实一个刚起步的项目，最重要的是，你的团队可以什么语言来写。

咱说 asp 现在落后了，但要是有扎克的脑袋，asp 也能给写出个 fb，然后改成不是 asp，现在fb的php已经hack到不是php了吧？哦，对了，开源很重要。

以后做大了，有什么不能换呢？京东还在转 Java 呢。

喜欢就用，不喜欢就不用。多简单的事，何必如此复杂。

----------------------

玩过一段时间的 Scala，没入门，但挺喜欢的，用 Idea 敲代码还是相当不错的。
目前在做 .Net

@bhuztez 真是个固执的偏执狂，我无话可说

@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
$

没有万金油语言，只有最适合的，github 用erland，因为erland可以满足他们的需求，并且他们喜欢这种语言，java无疑是现在工业标准，jvm的启动速度快慢，并不是最致命，开发效率，协作能力，都是团队要考虑的，虽然现在java相比新兴的动态语言，感觉笨重了很多，但是在当年，的确是小清新啊

另外，play我一直在用，从1.0开始，现在升级到2.0感觉快速开发的优势减弱了，scala的Anorm，感觉数据层的访问回到了jdbc时代，不过终于可以多数据源了。

@iwinux 此言差矣，这年头谁怕谁，
为什要跟捍卫Python的人说Scala多么优秀？
为什么要跟喜欢Rails的人说PHP也能做到？

这对于我们的进步和工作没有任何的帮助
任何语言在我眼里就是一个实现想法和创意的工具，什么能快速、稳定、高效的实现就去用什么，我自问不是一个编程语言的研究者，我是一个工程师，不是一个研究员。我也没打算成为一个研究员。

人生苦短，何不把有限的时间做点自己想做的事情

@muxi

讨论的目的不是为了说服别人，不是为了传道，而是为了跟别人交换*有用的*信息。比如我说 Vim 好用，你说 Emacs 更强大，我看到之后可能会问“Emacs 哪里好用了？它都不能XXXX”我这样回复，并不是为了贬低 Emacs，更不是为了捍卫 Vim，而是真的想知道它有什么优点，并且如果有可能的话会去试用。

人生苦短，所以更要见识多一点自己的框框之外的东西。显然楼上的很多人都没有理解这一点。

@iwinux 赞同，为了避免不必要的麻烦现在我每次觉得有歧义都加一句“真心请教了”

@iwinux

“Emacs 哪里好用了？它都不能XXXX”

======

这样的话在我看来似乎用处不大，理由很简单，如果Emacs 真的不能XXXX，而且又没有解决方案，那么这个XXXX功能就是在别人看来就是没用的，或者大部分Emacs用户几乎用不到，如果Emacs 本身没有XXXX功能，但是这个功能又是必须的，或许有其他的实现方式，只是非Emacs 不了解而已。如果都没有，那大不了就混合方案么，又没人说Emacs就不能用vim，这跟我当年写HTML 用dreamwave，写PHP用vim一样，这就跟现在很多团队PHP + Python， PHP+JAVA , php+C++一样，什么场合用什么东西，都只是工具，了解即可，未必需要拿出来说一句：它都不能XXXX，而引发没必要的口水。

真正值得拿来说的，是扬长避短的混合架构实施方案

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

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

@muxi

1. 问题就在于，如果没有这样的讨论，你怎么去*了解*这些工具的优劣？何来扬长避短，何来混合架构？

2. 什么场合用什么工具，这句话没错，但你怎么保证自己手上的工具就是最适合的？多跟别人交换一些信息，知道解决这个问题的其他方案，难道不可以么？举例来说，你可能很长一段时间都在用 Dreamweaver，后来听说 Vim 写 PHP 比较爽，这时候你问一句“Vim 貌似不能自动补全哦”（假设你不知道它可以），也是很自然的事情吧？

3. 口水战并不是必然的结果，只是大家习惯把自己手头的工具当成了自己的立场而已。JVM 又不是你家的，说两句坏话干嘛那么激动呢～

===================

大家有兴趣可以参考 Stack Overflow 上的这个讨论：
http://stackoverflow.com/questions/1257021/suitable-functional-language-for-scientific-statistical-computing

同样是在讨论“哪一种语言适合XXXX”，回答者就在答案里列举出有价值的参考信息你能看到口水战的痕迹吗？

@bhuztez @iwinux @muxi
大家真心来讨论，其实我是非常欢迎的。
更多的交流可以了解更多自己所不清楚的知识。
但是客观来讲，其实大家自身心理都有一些偏见或是喜欢。
能够不固执与自己的偏见并且能够接受一些正确的观点来弥补自己的欠缺，
这样大家才能够不断的进步。
Scala、Erlang、Java、C、C++、Python、Lisp、PHP、Ruby都是不错的语言。
但是也许跟自己的经历有关，我最早是从C、C++开始接触计算机编程语言，
使用c多年（目前都还在从事linux c开发），并有Java web开发多年经验，
因此对静态类型语言更有好感，所以在挑选一些新的语言时，也带上了某些方面的喜好。
我觉得大家肯定也是有着类似的相同经历的，所以对某些语言也带有偏见。

至于为什么说JVM是一个很强大的VM，主要是因为许多大公司原先在这方面投入了大量的资源进行研究和开发。
我相信这么多的资源投入肯定是比一些小语种的VM要成熟及稳定的。
不然的话，那么多的企业级应用原先都是架构在c及c++的基础上的，也没可能后来大多数都转移到了java平台上。
哈哈，以上是我的愚见。

也是为了学 play2 才学 的 scala

@skywinger 真心不觉得投入大，产出就一定好。


@skywinger
@bhuztez 你们都在说工业级这个词，这个词怎么定义？达到怎么样标准才算工业级，你们各自列一下呗。学习学习。

@kingwkb 我现在在看 play2

只是公司用的 play1,升级不上去了

推荐一个 algocasts.io play akka slick