n****1
发帖数: 1136 | 1 OOP的粉丝们喜欢吹鼓一切皆对象， 对象都有自己的method, 就像有自己的独立人格。
譬如BankAccount是对象， 它有deposit/withdraw/query这些method， 甚至连True/
False这俩也是对象。 但其实这些都是死物， 它们自己不会动的， 而是被一些特殊的
对象： 活对象来使用， 像Banker这种。
这些活对象的却应该有自己的动作(method), 而且除此之外， 每个活对象还都需要有
独立运作空间。 换句话说， 每个对象都应该有自己独立的thread。 而传统的c++/
java/python这些oop都是把object和thread两个概念完全正交分离的， 结果就是在
multithread中很难搞懂object与thread之间错综复杂的关系， 所以程序员讨厌多线程
， 写出来的最robust的架构都是单线程的。
而每个活对象独占一线程， 同时把线程这玩意完全abstract out的思想， 正是Erlang
/Scala所提倡的actor model. 而Erlang/Scala的风靡正说明了object和thread两个概
念其实是应该统一起来的, thread这种东西根本不该在java这类OOP语言中存在。
不是每个java里面的对象都适合做actor的， BankAccount/True/False就不适合， 你
给它一个独立的thread也完全没有意义。 |
t**r
发帖数: 3428 | |
l**********n
发帖数: 8443 | |
b*******s
发帖数: 5216 | 4 虽然滥用oo不好，但是这样简单化视之显然也是浅薄的 |
p*****2
发帖数: 21240 | 5 都是机器世界和现实世界之间的折衷吧？就看折衷在什么地方了。不能说Java不对，只
能说actor更上层。Functional本来就比Imperative上层。 |
p*****2
发帖数: 21240 | 6 Scala里面的actor也是object吧？也是OOP的东西。Erlang不熟悉，不过感觉actor本来
也是个object，封装性很强。但是不share state，性能有影响。 |
N******K
发帖数: 10202 | 7 编程序 和 系统仿真 完全不一样
所谓的object 可以对应物理世界的一个实物 有状态 有动作 比如打印机
thread和object不一样
比如一台打印机 安装多个打印鼓 相当于多线程
在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
Erlang
【在 n****1 的大作中提到】
: OOP的粉丝们喜欢吹鼓一切皆对象， 对象都有自己的method, 就像有自己的独立人格。
: 譬如BankAccount是对象， 它有deposit/withdraw/query这些method， 甚至连True/
: False这俩也是对象。 但其实这些都是死物， 它们自己不会动的， 而是被一些特殊的
: 对象： 活对象来使用， 像Banker这种。
: 这些活对象的却应该有自己的动作(method), 而且除此之外， 每个活对象还都需要有
: 独立运作空间。 换句话说， 每个对象都应该有自己独立的thread。 而传统的c++/
: java/python这些oop都是把object和thread两个概念完全正交分离的， 结果就是在
: multithread中很难搞懂object与thread之间错综复杂的关系， 所以程序员讨厌多线程
: ， 写出来的最robust的架构都是单线程的。
: 而每个活对象独占一线程， 同时把线程这玩意完全abstract out的思想， 正是Erlang
|
N******K
发帖数: 10202 | 8 每个活对象独占一线程 在量子计算机出来前 就是好莱坞意淫
Erlang
【在 n****1 的大作中提到】
: OOP的粉丝们喜欢吹鼓一切皆对象， 对象都有自己的method, 就像有自己的独立人格。
: 譬如BankAccount是对象， 它有deposit/withdraw/query这些method， 甚至连True/
: False这俩也是对象。 但其实这些都是死物， 它们自己不会动的， 而是被一些特殊的
: 对象： 活对象来使用， 像Banker这种。
: 这些活对象的却应该有自己的动作(method), 而且除此之外， 每个活对象还都需要有
: 独立运作空间。 换句话说， 每个对象都应该有自己独立的thread。 而传统的c++/
: java/python这些oop都是把object和thread两个概念完全正交分离的， 结果就是在
: multithread中很难搞懂object与thread之间错综复杂的关系， 所以程序员讨厌多线程
: ， 写出来的最robust的架构都是单线程的。
: 而每个活对象独占一线程， 同时把线程这玩意完全abstract out的思想， 正是Erlang
|
n****1
发帖数: 1136 | 9 我说的线程是抽象概念， 并非OS kernel thread。人家
erlang上面几十万个userspace thread照样跑得好好的。
建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
啥yy
>>打印机 安装多个打印鼓 相当于多线程
打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
动， 难道一个线程够了？
>>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
个电子当成一个活对象。
但我们真正需要的活对象少之又少.
【在 N******K 的大作中提到】
: 每个活对象独占一线程 在量子计算机出来前 就是好莱坞意淫
:
: Erlang
|
n****1
发帖数: 1136 | 10 没错， actor是object
但我的point是：
只有actor才值得用object的概念来建模. 其他的"object"不过是普通的encapsulated
data struct罢了。
拥有"独立人格"的东西最难建模与分析了，因为数学上是non deterministic, 甚至某
些actor可能等价于一个turing machine. 所以从程序复杂度的角度， 也应该尽量减少
actor的数量。 AKA, 不要抱着万物皆活物的思想写程序。
还有，这个actor和FP一毛钱关系也没有. 你也提醒过我， golang也用类似于actor的
goroutine, 而把thread api废掉了.
【在 p*****2 的大作中提到】
: Scala里面的actor也是object吧？也是OOP的东西。Erlang不熟悉，不过感觉actor本来
: 也是个object，封装性很强。但是不share state，性能有影响。
|
|
|
h**********c
发帖数: 4120 | 11 凭记忆回想一下why OO
记得当年磨c++ 编程思想的时候，颇有篇幅在比较c 和 c++
一个主要的问题就是c++成员有更好的access control
时间顺序上，多线程远晚于oo，这一点不太确定。
打算学学fp，不过，除非最低层系统，middleware都不用oo，oo还是无法替代的，比如
硬件抽象，大量第三方驱动，fp是怎么处理的。 |
d****i
发帖数: 4809 | 12 典型的新新派上层FP教徒的一面之词，没有多线程，你怎么能用电脑来发帖？底层的东
西要是没有多线程，你的电脑早死菜菜了。
Erlang
【在 n****1 的大作中提到】
: OOP的粉丝们喜欢吹鼓一切皆对象， 对象都有自己的method, 就像有自己的独立人格。
: 譬如BankAccount是对象， 它有deposit/withdraw/query这些method， 甚至连True/
: False这俩也是对象。 但其实这些都是死物， 它们自己不会动的， 而是被一些特殊的
: 对象： 活对象来使用， 像Banker这种。
: 这些活对象的却应该有自己的动作(method), 而且除此之外， 每个活对象还都需要有
: 独立运作空间。 换句话说， 每个对象都应该有自己独立的thread。 而传统的c++/
: java/python这些oop都是把object和thread两个概念完全正交分离的， 结果就是在
: multithread中很难搞懂object与thread之间错综复杂的关系， 所以程序员讨厌多线程
: ， 写出来的最robust的架构都是单线程的。
: 而每个活对象独占一线程， 同时把线程这玩意完全abstract out的思想， 正是Erlang
|
d****i
发帖数: 4809 | 13 多线程远早于OO, UNIX下的pthread早就有了。FP就是用来意淫写写上层的东西，但是
即使这样FP也不是必须的，淘宝那么大的流量用Java没问题。底层的东西还得C来写，
以前80年代有过一阵子lisp machine研究，后来被证明是个joke, 全部死菜菜了。
【在 h**********c 的大作中提到】
: 凭记忆回想一下why OO
: 记得当年磨c++ 编程思想的时候，颇有篇幅在比较c 和 c++
: 一个主要的问题就是c++成员有更好的access control
: 时间顺序上，多线程远晚于oo，这一点不太确定。
: 打算学学fp，不过，除非最低层系统，middleware都不用oo，oo还是无法替代的，比如
: 硬件抽象，大量第三方驱动，fp是怎么处理的。
|
n****1
发帖数: 1136 | 14 我提的这个与FP完全无关， 就拿c++做例子， 我希望C++里面的class只有data member
, 没有method member. 这样就可以完全从线程的角度, imperative style来看问题(其
实等价于用了opaque struct的C).
或者像golang这样， 完全隐藏多线程， 只有goroutine, 这样就可以完全从actor的角
度看问题。 同时考虑actor和线程是非常痛苦的。
＠domini
你就这点理解能力么？ 凡是反OO的就是FP么？ 我这帖子啥时候提FP了？
我是说OOP语言里的多线程应该由runtime来实现， 而不该直接把kernel thread api暴
露给程序员， 我啥时候说不用多线程了？
话说我还真认为imperative常常比OO的逻辑更清晰， 没有OO概念，PHP照样流行,c也能
写出整个linux 内核， 而java代码往往是滥用模式，又臭又长。
【在 h**********c 的大作中提到】
: 凭记忆回想一下why OO
: 记得当年磨c++ 编程思想的时候，颇有篇幅在比较c 和 c++
: 一个主要的问题就是c++成员有更好的access control
: 时间顺序上，多线程远晚于oo，这一点不太确定。
: 打算学学fp，不过，除非最低层系统，middleware都不用oo，oo还是无法替代的，比如
: 硬件抽象，大量第三方驱动，fp是怎么处理的。
|
N******K
发帖数: 10202 | 15 用8086也可以 有啥意思？ cpu就那么几个可怜的核
【在 n****1 的大作中提到】
: 我说的线程是抽象概念， 并非OS kernel thread。人家
: erlang上面几十万个userspace thread照样跑得好好的。
: 建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
: 啥yy
: >>打印机 安装多个打印鼓 相当于多线程
: 打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
: 动， 难道一个线程够了？
: >>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
: 你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
: 的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
|
N******K
发帖数: 10202 | 16 为啥要去掉成员函数？
actor之间的交互 很复杂 怎么搞？
member
【在 n****1 的大作中提到】
: 我提的这个与FP完全无关， 就拿c++做例子， 我希望C++里面的class只有data member
: , 没有method member. 这样就可以完全从线程的角度, imperative style来看问题(其
: 实等价于用了opaque struct的C).
: 或者像golang这样， 完全隐藏多线程， 只有goroutine, 这样就可以完全从actor的角
: 度看问题。 同时考虑actor和线程是非常痛苦的。
: ＠domini
: 你就这点理解能力么？ 凡是反OO的就是FP么？ 我这帖子啥时候提FP了？
: 我是说OOP语言里的多线程应该由runtime来实现， 而不该直接把kernel thread api暴
: 露给程序员， 我啥时候说不用多线程了？
: 话说我还真认为imperative常常比OO的逻辑更清晰， 没有OO概念，PHP照样流行,c也能
|
d*******r
发帖数: 3299 | 17 userspace virtual thread 这种类似的高级执行单元 (我也不知道严格定义是啥)，确
实是好的概念，而且是非常实用的概念。我hack过 OpenFlow 的 user space OS, C++
写的，就有自己的 virtual cooperative thread.
Erlang 就是同时开无数个 OTP process 的。
原生的 thread+sync 那一坨东西，直接用起来，实在太麻烦了，必然是要被取代的。
【在 n****1 的大作中提到】
: 我说的线程是抽象概念， 并非OS kernel thread。人家
: erlang上面几十万个userspace thread照样跑得好好的。
: 建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
: 啥yy
: >>打印机 安装多个打印鼓 相当于多线程
: 打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
: 动， 难道一个线程够了？
: >>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
: 你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
: 的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
|
s***o
发帖数: 6934 | 18 对于非cpu bound的web backend app，erlang其实经常是很好的选择 |
N******K
发帖数: 10202 | 19 这种thread和 通常意义的thread有何区别？
+
【在 d*******r 的大作中提到】
: userspace virtual thread 这种类似的高级执行单元 (我也不知道严格定义是啥)，确
: 实是好的概念，而且是非常实用的概念。我hack过 OpenFlow 的 user space OS, C++
: 写的，就有自己的 virtual cooperative thread.
: Erlang 就是同时开无数个 OTP process 的。
: 原生的 thread+sync 那一坨东西，直接用起来，实在太麻烦了，必然是要被取代的。
|
g*****g
发帖数: 34805 | 20 你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (object)，物体需要独
立人格吗？
一个桌子没有任何思想，就不能有4条腿，一个面吗？你连最基本的常识都弄错了，还
推理了一大堆，I服了U。
事实上，OO里所谓对象，无非是一堆的相关的数据状态，用对象方法来确保数据的变化
保持一致性罢了。
另外，你对多线程的理解也很狭隘。actor model在复杂多线程的系统里很好用，可以
简化线程同步。
但反过来，如果系统并没有那么多的同步需要。比如绝大部分web应用，无非是某种形
式的CRUD，
有同步需要的部分都在数据库里处理了。这时候actor就如同spring bean里用
prototype，明明一个singleton够用了，却产生了大量的copy，导致GC开销提高很
多，造成性能下降。我个人用scala的时候为了最大化系统throughput，在调GC仍然有
问题之后，不得已用了object pool来重用actor，这已经违背了actor model的本意。
Erlang
【在 n****1 的大作中提到】
: OOP的粉丝们喜欢吹鼓一切皆对象， 对象都有自己的method, 就像有自己的独立人格。
: 譬如BankAccount是对象， 它有deposit/withdraw/query这些method， 甚至连True/
: False这俩也是对象。 但其实这些都是死物， 它们自己不会动的， 而是被一些特殊的
: 对象： 活对象来使用， 像Banker这种。
: 这些活对象的却应该有自己的动作(method), 而且除此之外， 每个活对象还都需要有
: 独立运作空间。 换句话说， 每个对象都应该有自己独立的thread。 而传统的c++/
: java/python这些oop都是把object和thread两个概念完全正交分离的， 结果就是在
: multithread中很难搞懂object与thread之间错综复杂的关系， 所以程序员讨厌多线程
: ， 写出来的最robust的架构都是单线程的。
: 而每个活对象独占一线程， 同时把线程这玩意完全abstract out的思想， 正是Erlang
|
|
|
n****1
发帖数: 1136 | 21 你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
old data来表示？它有啥method?
;这个世界万物皆物体 (object)
到底是谁走火入魔？
读完帖子再喷是交流的基本前提
【在 g*****g 的大作中提到】
: 你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (object)，物体需要独
: 立人格吗？
: 一个桌子没有任何思想，就不能有4条腿，一个面吗？你连最基本的常识都弄错了，还
: 推理了一大堆，I服了U。
: 事实上，OO里所谓对象，无非是一堆的相关的数据状态，用对象方法来确保数据的变化
: 保持一致性罢了。
: 另外，你对多线程的理解也很狭隘。actor model在复杂多线程的系统里很好用，可以
: 简化线程同步。
: 但反过来，如果系统并没有那么多的同步需要。比如绝大部分web应用，无非是某种形
: 式的CRUD，
|
g*****g
发帖数: 34805 | 22 这不过是举个例子，桌子是死的也罢。为啥银行帐户不能用object来表示，莫非你想说
balance也是死的？
你大谈物体必须有人格，根本就是违反常识的事情。
【在 n****1 的大作中提到】
: 你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
: old data来表示？它有啥method?
: ;这个世界万物皆物体 (object)
: 到底是谁走火入魔？
: 读完帖子再喷是交流的基本前提
|
n****1
发帖数: 1136 | 23 哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
以有method. Banker是很好的object例子， 但account不是。
【在 g*****g 的大作中提到】
: 这不过是举个例子，桌子是死的也罢。为啥银行帐户不能用object来表示，莫非你想说
: balance也是死的？
: 你大谈物体必须有人格，根本就是违反常识的事情。
|
N******K
发帖数: 10202 | 24 BankAccount 可以设置一些method 控制数据安全性 比如低权限的不能看不能写
【在 n****1 的大作中提到】
: 哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
: 我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
: 以有method. Banker是很好的object例子， 但account不是。
|
N******K
发帖数: 10202 | 25 it喜欢把技术讨论 演变为人身攻击
【在 n****1 的大作中提到】
: 你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
: old data来表示？它有啥method?
: ;这个世界万物皆物体 (object)
: 到底是谁走火入魔？
: 读完帖子再喷是交流的基本前提
|
g*****g
发帖数: 34805 | 26 这个世界大多数物体都是死的，没人操作不会改变，难道就不叫物体了？谁规定了物体
得活的，
你学了那么多年物理，齿轮，绳子哪个是活的？
车没人开就不会走，也是死的，不叫物体？你懂什么叫物体吗？没见过这么没常识还振
振有词的。
【在 n****1 的大作中提到】
: 哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
: 我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
: 以有method. Banker是很好的object例子， 但account不是。
|
n****1
发帖数: 1136 | 27
有么？ 我原话是啥？
我想说的是“物体”不应该和OOP里面"object"划等号， 因为很多物体没有method, 但
"object"都有method, 至少有几个java自带的notify/wait之类的。
而OO猴子中毒太深， 直接把"物体"和"object"划等号。
【在 g*****g 的大作中提到】
: 这不过是举个例子，桌子是死的也罢。为啥银行帐户不能用object来表示，莫非你想说
: balance也是死的？
: 你大谈物体必须有人格，根本就是违反常识的事情。
|
n****1
发帖数: 1136 | 28 这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
【在 N******K 的大作中提到】
: BankAccount 可以设置一些method 控制数据安全性 比如低权限的不能看不能写
|
g*****g
发帖数: 34805 | 29 物体和object本来就是中英翻译罢了。物体和对象本来就是一个东西，对象抽象一点可
以包括虚拟的物体。具体到语言，无
非是个建模的工具，
各种feature都是取舍，有好处同样也有坏处。跟世界完全一致本来就不是设计语言的
要求，也做不到。
语言是工具，用来建模的，啥时候语言跟物理必须等价了。你一脑残理论，还来劲了。
【在 n****1 的大作中提到】
: 这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
|
n****1
发帖数: 1136 | 30 Tell me about it! How can I understand "wait/notify" method of an Account
object?
怀疑版上70%以上的人身攻击是你挑起的。 对骂脑残我没兴趣。
【在 g*****g 的大作中提到】
: 物体和object本来就是中英翻译罢了。物体和对象本来就是一个东西，对象抽象一点可
: 以包括虚拟的物体。具体到语言，无
: 非是个建模的工具，
: 各种feature都是取舍，有好处同样也有坏处。跟世界完全一致本来就不是设计语言的
: 要求，也做不到。
: 语言是工具，用来建模的，啥时候语言跟物理必须等价了。你一脑残理论，还来劲了。
|
|
|
g*****g
发帖数: 34805 | 31 你无知又逼我来打脸了是吧？为啥java的所有对象都有wait/notify，因为所有的对象
都有一个monitor，wait/notify就是为了这个monitor服务的。没有这个monitor的存在
，java就实现不了built-in的synchronization。这就是一个语言的feature，还有问为
什么的？
任何建模都有局限性，就比如actor model，大多数语言的实现是保证actor本身单线程
。我老人
家边吃饭边灌水，你拿actor model就建模不了。
班上70%的人身攻击，都是因为你这样的脑残不懂还非要装逼引起的。诸如魏公公坚信
自己的单机可以秒掉nasdaq，除了傻逼没有更合适的词了。
【在 n****1 的大作中提到】
: Tell me about it! How can I understand "wait/notify" method of an Account
: object?
: 怀疑版上70%以上的人身攻击是你挑起的。 对骂脑残我没兴趣。
|
N******K
发帖数: 10202 | 32 把安全控制函数 想象为金库围墙和大门
banker控制的是金库钥匙 而不是去建一个安全的金库
【在 n****1 的大作中提到】
: 这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
|
n****1
发帖数: 1136 | 33
My point is that thread/sync in Java is the wrong approach at the first
place, that is why Golang removes it.
Actor in most OO language is single-threaded because most OO languages suck,
that's why scala/clojure/golang have a shot despite of the existing
popularity of Java.
>>班上70%的人身攻击，都是因为你这样的脑残不懂还非要装逼引起的。
I noticed the dirty words usually start from your posts. I guest you are the
only genius good enough to teach them a lesson.
【在 g*****g 的大作中提到】
: 你无知又逼我来打脸了是吧？为啥java的所有对象都有wait/notify，因为所有的对象
: 都有一个monitor，wait/notify就是为了这个monitor服务的。没有这个monitor的存在
: ，java就实现不了built-in的synchronization。这就是一个语言的feature，还有问为
: 什么的？
: 任何建模都有局限性，就比如actor model，大多数语言的实现是保证actor本身单线程
: 。我老人
: 家边吃饭边灌水，你拿actor model就建模不了。
: 班上70%的人身攻击，都是因为你这样的脑残不懂还非要装逼引起的。诸如魏公公坚信
: 自己的单机可以秒掉nasdaq，除了傻逼没有更合适的词了。
|
g*****g
发帖数: 34805 | 34 LOL，last time I checked, Scala implemented actor in single thread too. So
maybe it's time for you to relearn 101.
At the end of the day, a language doesn't need to be the best at everything.
All features are double-edge swords. For a given job, a language may be
easier than another, that's about it.
However, I wouldn't say Java took the wrong approach in the first place. A
popular language is never a wrong approach. It's only not best for
everything, and it doesn't have to. I always compliment FP and actor model
in complicate concurrency systems. But I don't see it shining elsewhere and
definitely not a replacer for OOP in general. Now, that's a reality check.
suck,
【在 n****1 的大作中提到】
:
: My point is that thread/sync in Java is the wrong approach at the first
: place, that is why Golang removes it.
: Actor in most OO language is single-threaded because most OO languages suck,
: that's why scala/clojure/golang have a shot despite of the existing
: popularity of Java.
: >>班上70%的人身攻击，都是因为你这样的脑残不懂还非要装逼引起的。
: I noticed the dirty words usually start from your posts. I guest you are the
: only genius good enough to teach them a lesson.
|
n****1
发帖数: 1136 | 35
everything.
I think you can make this paragraph as your signature. It applies to all the
posts on this board, with zero substance.
I'm Ok to be labeled as "lack of common sense", but I do know that scala has
"Dispatcher/PinnedDispatcher/BalancingDispatcher/CallingThreadDispatcher".
【在 g*****g 的大作中提到】
: LOL，last time I checked, Scala implemented actor in single thread too. So
: maybe it's time for you to relearn 101.
: At the end of the day, a language doesn't need to be the best at everything.
: All features are double-edge swords. For a given job, a language may be
: easier than another, that's about it.
: However, I wouldn't say Java took the wrong approach in the first place. A
: popular language is never a wrong approach. It's only not best for
: everything, and it doesn't have to. I always compliment FP and actor model
: in complicate concurrency systems. But I don't see it shining elsewhere and
: definitely not a replacer for OOP in general. Now, that's a reality check.
|
g*****g
发帖数: 34805 | 36 LOL, so this is the best defense you can come up with after being exposed of
lacking basic
common sense? Cry me a river but none of FP language today is mainstream,
actor model or not.
the
【在 n****1 的大作中提到】
:
: everything.
: I think you can make this paragraph as your signature. It applies to all the
: posts on this board, with zero substance.
: I'm Ok to be labeled as "lack of common sense", but I do know that scala has
: "Dispatcher/PinnedDispatcher/BalancingDispatcher/CallingThreadDispatcher".
|
n****1
发帖数: 1136 | 37 I guess you get confused between Account and cash. Account is just a group
of numbers, and does not need to be guarded by a vault.
Cash do need a vault, but the guarding logic should be put in somewhere else
, like a security robot, not in cash or Account.
【在 N******K 的大作中提到】
: 把安全控制函数 想象为金库围墙和大门
: banker控制的是金库钥匙 而不是去建一个安全的金库
|
N******K
发帖数: 10202 | 38 Account 这个我理解就是 账户名 账户余额什么的 当然包括钱在内
else
【在 n****1 的大作中提到】
: I guess you get confused between Account and cash. Account is just a group
: of numbers, and does not need to be guarded by a vault.
: Cash do need a vault, but the guarding logic should be put in somewhere else
: , like a security robot, not in cash or Account.
|
c*******9
发帖数: 9032 | 39 oo是比较僵化的，4条腿是桌子，3条，2条，1条就不是了？2个面就一定不是桌子了？
这种跟据属性确定object只适合比较静态常规情况，不适合高动态应用。
【在 g*****g 的大作中提到】
: 你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (object)，物体需要独
: 立人格吗？
: 一个桌子没有任何思想，就不能有4条腿，一个面吗？你连最基本的常识都弄错了，还
: 推理了一大堆，I服了U。
: 事实上，OO里所谓对象，无非是一堆的相关的数据状态，用对象方法来确保数据的变化
: 保持一致性罢了。
: 另外，你对多线程的理解也很狭隘。actor model在复杂多线程的系统里很好用，可以
: 简化线程同步。
: 但反过来，如果系统并没有那么多的同步需要。比如绝大部分web应用，无非是某种形
: 式的CRUD，
|
g*****g
发帖数: 34805 | 40 OO的建模相当灵活，如果腿和面是可变的，你大可以设两个属性，腿数，面数。
所以你说的这个完全没有道理。相比之下，FP强调数据不可变，只能做成状态机，建模
才不方便。
【在 c*******9 的大作中提到】
: oo是比较僵化的，4条腿是桌子，3条，2条，1条就不是了？2个面就一定不是桌子了？
: 这种跟据属性确定object只适合比较静态常规情况，不适合高动态应用。
|
|
|
c*******9
发帖数: 9032 | 41 这样你自己做具体应用也许问题不大，如果做库，应用中总有你考虑不到情况，为了灵
活增加属性，给用库的人增加负担，不是所以用库的人都有同样的需求。
FP要么是不强制类型，要么像haskell那样通过类型间的关系定义类型。比如桌子建模
可以不关心桌子有几个腿，几个面，
只要面上可以摆放东西。
【在 g*****g 的大作中提到】
: OO的建模相当灵活，如果腿和面是可变的，你大可以设两个属性，腿数，面数。
: 所以你说的这个完全没有道理。相比之下，FP强调数据不可变，只能做成状态机，建模
: 才不方便。
|
g*****g
发帖数: 34805 | 42 不合适的库显然可以不用。没有比OO库更丰富的了。FP expressive是真的，flexible
差远了。
为了immutable，绕着一堆monad的弯子。
【在 c*******9 的大作中提到】
: 这样你自己做具体应用也许问题不大，如果做库，应用中总有你考虑不到情况，为了灵
: 活增加属性，给用库的人增加负担，不是所以用库的人都有同样的需求。
: FP要么是不强制类型，要么像haskell那样通过类型间的关系定义类型。比如桌子建模
: 可以不关心桌子有几个腿，几个面，
: 只要面上可以摆放东西。
|
c*******9
发帖数: 9032 | 43 估计你主要做网站。很多应用是难找合适库的。程序员找库不浪费时间。
说flexible难有比像Lisp这样有的eval的了。动态改程序，数据还不够flexible。
monad不是为了仅仅为了immutable，也容易实现AOP。不熟悉的人觉得别扭，一旦熟悉
，没有比这更好用的了。
flexible
【在 g*****g 的大作中提到】
: 不合适的库显然可以不用。没有比OO库更丰富的了。FP expressive是真的，flexible
: 差远了。
: 为了immutable，绕着一堆monad的弯子。
|
g*****g
发帖数: 34805 | 44 client端的东西我不懂，但凡是server端的，有通用价值的，基本上没有啥库不存在的。
lisp, LOL, lisp有像样的库吗。你说的这些lisp的特性还是expressive, fp光不强调
封装，
轮子就永远赶不上oo。
【在 c*******9 的大作中提到】
: 估计你主要做网站。很多应用是难找合适库的。程序员找库不浪费时间。
: 说flexible难有比像Lisp这样有的eval的了。动态改程序，数据还不够flexible。
: monad不是为了仅仅为了immutable，也容易实现AOP。不熟悉的人觉得别扭，一旦熟悉
: ，没有比这更好用的了。
:
: flexible
|
n****1
发帖数: 1136 | 45 Monad is not invented to solve immutability problem.
Monad is real, and people use it everyday without noticing it. For example,
list is the most illustrative monad, and list comprehension/LINQ in python/C
# can reduce a lot of boilerplate code and make code more readable.
Haskell just grouped the conceptually similar structures together and gives
this group a ridiculous name called "Monad". I would prefer to call them "
mappable and flatable".
Mappable means you can map ordinal functions on monads, just like lists.
Flatable means you can reduce a two-level structure into one-level, just
like you can join lists of lists into a single list. It is easy to see that
stack is not a monad because it is mappable but not flatable.
Java need "绕着一堆design pattern的弯子". Many of these patterns are only
necessary in java due to the lack of 1st class function. |
n****1
发帖数: 1136 | 46 Encapsulation is not a privilege but a basic requirement of all good
architecture, even in imperative/FP.
However private member of objects is not the only way to do encapsulation.
Even in smalltalk/javascript, which advocates themselvs as OOP more than FP,
there is no private member. Encapsulation is achieved in modular/file level.
I don't see any reason that FP is anti-encapsulation. |
n****1
发帖数: 1136 | 47 Mutable-value is a quick&easy hack to get many things done, without build a
formal math model.
Things get bad when mutable-values are everywhere in a complex system. You
lost the ability to build a formal model even you wish to. |
g*****g
发帖数: 34805 | 48 Mutable value is the way this world works. I grow another year old, the old
me didn't transform to the new me with an older age. My age just increases,
it's the same me,
plain and simple. There's a good reason FP never got popular, because it's
not intuitive for human beings.
a
【在 n****1 的大作中提到】
: Mutable-value is a quick&easy hack to get many things done, without build a
: formal math model.
: Things get bad when mutable-values are everywhere in a complex system. You
: lost the ability to build a formal model even you wish to.
|
g*****g
发帖数: 34805 | 49 Monad works for some and awful for others, like IO. And IO is real.
At the end of the day, mutable is how this world is being described.
Immutable is a special case for mutable objects, not vice versa, making
everything immutable is an ugly hack.
,
/C
gives
that
【在 n****1 的大作中提到】
: Monad is not invented to solve immutability problem.
: Monad is real, and people use it everyday without noticing it. For example,
: list is the most illustrative monad, and list comprehension/LINQ in python/C
: # can reduce a lot of boilerplate code and make code more readable.
: Haskell just grouped the conceptually similar structures together and gives
: this group a ridiculous name called "Monad". I would prefer to call them "
: mappable and flatable".
: Mappable means you can map ordinal functions on monads, just like lists.
: Flatable means you can reduce a two-level structure into one-level, just
: like you can join lists of lists into a single list. It is easy to see that
|
g*****g
发帖数: 34805 | 50 And encapsulation in modular/file level cannot enforce proper encapsulation.
The grouping is just too subjective and arbitrary.
FP,
level.
【在 n****1 的大作中提到】
: Encapsulation is not a privilege but a basic requirement of all good
: architecture, even in imperative/FP.
: However private member of objects is not the only way to do encapsulation.
: Even in smalltalk/javascript, which advocates themselvs as OOP more than FP,
: there is no private member. Encapsulation is achieved in modular/file level.
: I don't see any reason that FP is anti-encapsulation.
|
|
|
n****1
发帖数: 1136 | 51 Go back to school and take some math course, and you can learn there is
something called time-series, where values are represented as X_t.
X_t != X_(t+1), but X_t itself is a immutable constant for every t.
This is the only formal way to model time-variant values. This is why people
invent calendar.
git is exactly using the lower index idea: the head keeps updating but each
snapshot is immutable. Git can even give a sense of multi-demensional time(
in the form of multiple branches). A naive mutable storage system could
never archive the same power as git.
Data structure in FP share the same idea as git, they are called persistent
data structure. Software transactional memory in haskell, the key of
lockless concurrency in haskell, also depends on this idea.
Ancient people will think real number is ridiculous, because from their
perspective, fractions and negatives are already tough to understand, real
number is just not how it works.
The true is, no one knows how our world works, we can only model it(and math
is the best friend here), but not assert it.
old
,
【在 g*****g 的大作中提到】
: Mutable value is the way this world works. I grow another year old, the old
: me didn't transform to the new me with an older age. My age just increases,
: it's the same me,
: plain and simple. There's a good reason FP never got popular, because it's
: not intuitive for human beings.
:
: a
|
n****1
发帖数: 1136 | 52 As if grouping in class is not subjective/arbitrary...
You forget java's policy is one class per file?
encapsulation.
【在 g*****g 的大作中提到】
: And encapsulation in modular/file level cannot enforce proper encapsulation.
: The grouping is just too subjective and arbitrary.
:
: FP,
: level.
|
q*c
发帖数: 9453 | 53 这种仿真的唯一下场就是 out of memory...
【在 N******K 的大作中提到】
: 编程序 和 系统仿真 完全不一样
: 所谓的object 可以对应物理世界的一个实物 有状态 有动作 比如打印机
: thread和object不一样
: 比如一台打印机 安装多个打印鼓 相当于多线程
: 在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
:
: Erlang
|
c*******9
发帖数: 9032 | 54 "mutable is how this world is being described."
这可不一定，你能改一下某个电子，质子的静止质量吗。mutable是日常具体食物的一
种观察，有一定实用性，但不一定具有普遍意义。很多抽象些的事物都有Immutable特
性，对具体的事物看法也有多种，就像“人不能重复过一条河”是一种Immutable看法
，没有什么绝对标准来判断那个更真。
【在 g*****g 的大作中提到】
: Monad works for some and awful for others, like IO. And IO is real.
: At the end of the day, mutable is how this world is being described.
: Immutable is a special case for mutable objects, not vice versa, making
: everything immutable is an ugly hack.
:
: ,
: /C
: gives
: that
|
n****1
发帖数: 1136 | 55 FP里面的data和git是很像的， 只不过那个index/snapshot id不大容易看出来罢了。
那个index其实就是function closure. 每一个函数里面都可以有一个名字一样的不变
量， 但它们的值不一定要一样。
FP里面用closure+recursion来对mutable environment建模， 利用recursion的层数达
到x_t!=x_(t+1)的效果。
如果资源有限， 某些情况下不需要保存所有的X_t, 那就可以把一些function closure
丢掉。 这就是传说中的tail call optimization.
过段时间会写个更详细的介绍。 |
c*******9
发帖数: 9032 | 56 你说的server端估计还是局限于网站。 lisp在人工智能方面还是有些库，尽管现在
java c++库也不少。
fp的问题不是封装（封装往往也不比OO差），fp不普及，是因为多数初学者，喜欢和具
体事物直接联系的语言和库，抽象些就无从下手。就像佛教很少人能懂，李大师把它具
体化庸俗化，立刻招来上亿信徒。
的。
【在 g*****g 的大作中提到】
: client端的东西我不懂，但凡是server端的，有通用价值的，基本上没有啥库不存在的。
: lisp, LOL, lisp有像样的库吗。你说的这些lisp的特性还是expressive, fp光不强调
: 封装，
: 轮子就永远赶不上oo。
|
g*****g
发帖数: 34805 | 57 Except you don't exactly model FP with time series. Now I admit my knowledge
with FP is limited and I only worked with Scala for 2 years. But I didn't
see anyone attached timestamp to every piece of data. Cassandra DB does but
not the Scala language. Now you can be full of crap but FP doesn't do it
that way. So cut some crap.
So called FP people feel they are superior, but at the end of the day, look
at what they've achieved with their precious languages. A hammer is to
create great things, not for bragging right. Stop showing off your hammer.
people
each
persistent
【在 n****1 的大作中提到】
: Go back to school and take some math course, and you can learn there is
: something called time-series, where values are represented as X_t.
: X_t != X_(t+1), but X_t itself is a immutable constant for every t.
: This is the only formal way to model time-variant values. This is why people
: invent calendar.
: git is exactly using the lower index idea: the head keeps updating but each
: snapshot is immutable. Git can even give a sense of multi-demensional time(
: in the form of multiple branches). A naive mutable storage system could
: never archive the same power as git.
: Data structure in FP share the same idea as git, they are called persistent
|
g*****g
发帖数: 34805 | 58 It's not about religion, it's about getting the job done. We are not talking
about math proof where you only need one people. We are talking about
practical systems that you need millions of programmers to create, and OOP
have got there. If FP fails in that department, it's its own problem and no
one else to blame.
【在 c*******9 的大作中提到】
: 你说的server端估计还是局限于网站。 lisp在人工智能方面还是有些库，尽管现在
: java c++库也不少。
: fp的问题不是封装（封装往往也不比OO差），fp不普及，是因为多数初学者，喜欢和具
: 体事物直接联系的语言和库，抽象些就无从下手。就像佛教很少人能懂，李大师把它具
: 体化庸俗化，立刻招来上亿信徒。
:
: 的。
|
g*****g
发帖数: 34805 | 59 Where does OOP say the property of objects must be mutable? If they are
constants, so be it.
The one more easily understandable by the mass is the better approach in
most cases, that's why FP is complimentary these days, not primary. Let's
get some reality check.
【在 c*******9 的大作中提到】
: "mutable is how this world is being described."
: 这可不一定，你能改一下某个电子，质子的静止质量吗。mutable是日常具体食物的一
: 种观察，有一定实用性，但不一定具有普遍意义。很多抽象些的事物都有Immutable特
: 性，对具体的事物看法也有多种，就像“人不能重复过一条河”是一种Immutable看法
: ，没有什么绝对标准来判断那个更真。
|
n****1
发帖数: 1136 | 60 It's ok to be ignorant, but not ok to be arrogant. Your failure in
recognizing FP working in that way doesn't mean I'm wrong. Again, Read all
the damn posts before posting!
I already said that function closure + recursion serve the purpose of
versioning. That is why FP love recursion. The "t" in X_t can be anything
instead of time stamp, like commit ID in git, or like the function closure
in FP.
And yet, you still did not respond about file level encapsulation and one
class per file in java.
knowledge
but
look
【在 g*****g 的大作中提到】
: Except you don't exactly model FP with time series. Now I admit my knowledge
: with FP is limited and I only worked with Scala for 2 years. But I didn't
: see anyone attached timestamp to every piece of data. Cassandra DB does but
: not the Scala language. Now you can be full of crap but FP doesn't do it
: that way. So cut some crap.
: So called FP people feel they are superior, but at the end of the day, look
: at what they've achieved with their precious languages. A hammer is to
: create great things, not for bragging right. Stop showing off your hammer.
:
: people
|
|
|
g*****g
发帖数: 34805 | 61 No, you are the one being ignorant. You talk the crap of time series and can
't link it to the language.
You don't get created and destroyed with a new copy every second past, like
how you'll do when modeled in FP,
so that's just an ugly hack. Admit it.
And Java doesn't intend to encapsulate with file, it's just a way to
organize the structure. Access is mostly restricted by keywords. If you
change java to allow multiple public classes in a file, it hardly makes any
difference in encapsulation aspect. Your 101 is so lacking is not even funny.
【在 n****1 的大作中提到】
: It's ok to be ignorant, but not ok to be arrogant. Your failure in
: recognizing FP working in that way doesn't mean I'm wrong. Again, Read all
: the damn posts before posting!
: I already said that function closure + recursion serve the purpose of
: versioning. That is why FP love recursion. The "t" in X_t can be anything
: instead of time stamp, like commit ID in git, or like the function closure
: in FP.
: And yet, you still did not respond about file level encapsulation and one
: class per file in java.
:
|
n****1
发帖数: 1136 | 62 Firstly, about file level encapsulation. Java's policy make file-level the
same as keyword mechanism, at least for java itself. Yet you said file level
encapsulation is not good enough. You are arguing with yourself instead of
me, dude.
I didn't link FP with "generalized index" because I thought you are able, or
is willing to, catch that. Since you don't, let me give a example.
factorial 1 = 1
factorial n = n * factorial m
where m = n-1
When we compute (factorial 3), there are two copies of the same function on
the stack. In the first copy m has value 2, in the succeeding copy m has
value 1. These copies serve the purpose of index for m.
Pls stop saying "crap", especially after you admitting that you don't have
enough experience in FP. FP is abstract enough, so your inability to
think abstractly does not imply others are nuts.
can
like
any
funny.
【在 g*****g 的大作中提到】
: No, you are the one being ignorant. You talk the crap of time series and can
: 't link it to the language.
: You don't get created and destroyed with a new copy every second past, like
: how you'll do when modeled in FP,
: so that's just an ugly hack. Admit it.
: And Java doesn't intend to encapsulate with file, it's just a way to
: organize the structure. Access is mostly restricted by keywords. If you
: change java to allow multiple public classes in a file, it hardly makes any
: difference in encapsulation aspect. Your 101 is so lacking is not even funny.
|
p*****2
发帖数: 21240 | 63
level
of
or
on
I'd like to see more discussion on file-level encapsulation. I think it can
achieve the same as OOP, but just not as easy as OO.
【在 n****1 的大作中提到】
: Firstly, about file level encapsulation. Java's policy make file-level the
: same as keyword mechanism, at least for java itself. Yet you said file level
: encapsulation is not good enough. You are arguing with yourself instead of
: me, dude.
: I didn't link FP with "generalized index" because I thought you are able, or
: is willing to, catch that. Since you don't, let me give a example.
: factorial 1 = 1
: factorial n = n * factorial m
: where m = n-1
: When we compute (factorial 3), there are two copies of the same function on
|
g*****g
发帖数: 34805 | 64 I didn't know your english comprehension is so poor. I didn't say file level
encapsulation is not good enough, I said it's not required. Scala is a
perfect example how multiple classes can be kept in a single file, the
access is controlled by keywords. Java could have done the same but it didn'
t.
level
of
or
on
【在 n****1 的大作中提到】
: Firstly, about file level encapsulation. Java's policy make file-level the
: same as keyword mechanism, at least for java itself. Yet you said file level
: encapsulation is not good enough. You are arguing with yourself instead of
: me, dude.
: I didn't link FP with "generalized index" because I thought you are able, or
: is willing to, catch that. Since you don't, let me give a example.
: factorial 1 = 1
: factorial n = n * factorial m
: where m = n-1
: When we compute (factorial 3), there are two copies of the same function on
|
t***t
发帖数: 6066 | 65 IMO, it's the best of all, it's pure OOP, full blown FP, extensible, concise
,
scalable, plus it can use all Java libraries. |
g*****g
发帖数: 34805 | 66 Everything comes with a price, it's powerful, flexible and expressive, but
it's also complicate.
concise
【在 t***t 的大作中提到】
: IMO, it's the best of all, it's pure OOP, full blown FP, extensible, concise
: ,
: scalable, plus it can use all Java libraries.
|
T*******x
发帖数: 8565 | 67 嗯。这个用immutable来实现mutable的方法不错。
closure
【在 n****1 的大作中提到】
: FP里面的data和git是很像的， 只不过那个index/snapshot id不大容易看出来罢了。
: 那个index其实就是function closure. 每一个函数里面都可以有一个名字一样的不变
: 量， 但它们的值不一定要一样。
: FP里面用closure+recursion来对mutable environment建模， 利用recursion的层数达
: 到x_t!=x_(t+1)的效果。
: 如果资源有限， 某些情况下不需要保存所有的X_t, 那就可以把一些function closure
: 丢掉。 这就是传说中的tail call optimization.
: 过段时间会写个更详细的介绍。
|
t***t
发帖数: 6066 | 68 you can choose to not use complicate stuff. it can be very simple too.
【在 g*****g 的大作中提到】
: Everything comes with a price, it's powerful, flexible and expressive, but
: it's also complicate.
:
: concise
|
t***t
发帖数: 6066 | 69 finished 1/4 of the book "Programming in Scala".
Scala is really powerful and pretty from what I read so far.
【在 t***t 的大作中提到】
: you can choose to not use complicate stuff. it can be very simple too.
|
c******o
发帖数: 1277 | 70 highly recommend
the book:
Functional Programming in Scala
http://www.manning.com/bjarnason/
Will be classic books, it is basically turn scala into a pure FP env as in
Haskell.
Of course you can then choose how much FP you want to use and switch between
FP/OO
【在 t***t 的大作中提到】
: finished 1/4 of the book "Programming in Scala".
: Scala is really powerful and pretty from what I read so far.
|
|
|
t***t
发帖数: 6066 | 71 thanks
Just checked Java 8, it looks like a converging trend.
Java 8 copied lots of stuff from Scala, such as lambda, traits etc, also
Oracle gets its own Node.js implementation called Node.jar
between
【在 c******o 的大作中提到】
: highly recommend
: the book:
: Functional Programming in Scala
: http://www.manning.com/bjarnason/
: Will be classic books, it is basically turn scala into a pure FP env as in
: Haskell.
: Of course you can then choose how much FP you want to use and switch between
: FP/OO
|
t***t
发帖数: 6066 | 72 finished reading traits. it's pretty interesting. the stackable modification
is pretty powerful. |
c******o
发帖数: 1277 | 73 isn't node.js filer level encapsulation?
I use it that way.
can
【在 p*****2 的大作中提到】
:
: level
: of
: or
: on
: I'd like to see more discussion on file-level encapsulation. I think it can
: achieve the same as OOP, but just not as easy as OO.
|
j********x
发帖数: 2330 | 74 我觉得你好好花时间看看TAOCP，学学Knuth老爷爷的逻辑与写作；然后再来阐述这些观
点，我这样的彩笔看了受益，高手看了有共鸣；现在的结果，我这个彩笔看了不懂，高
手看了误解。。。
encapsulated
【在 n****1 的大作中提到】
: 没错， actor是object
: 但我的point是：
: 只有actor才值得用object的概念来建模. 其他的"object"不过是普通的encapsulated
: data struct罢了。
: 拥有"独立人格"的东西最难建模与分析了，因为数学上是non deterministic, 甚至某
: 些actor可能等价于一个turing machine. 所以从程序复杂度的角度， 也应该尽量减少
: actor的数量。 AKA, 不要抱着万物皆活物的思想写程序。
: 还有，这个actor和FP一毛钱关系也没有. 你也提醒过我， golang也用类似于actor的
: goroutine, 而把thread api废掉了.
|
n****1
发帖数: 1136 | 75 看了, 可惜俺做不到那境界. 你就当俺胡说八道好了.
【在 j********x 的大作中提到】
: 我觉得你好好花时间看看TAOCP，学学Knuth老爷爷的逻辑与写作；然后再来阐述这些观
: 点，我这样的彩笔看了受益，高手看了有共鸣；现在的结果，我这个彩笔看了不懂，高
: 手看了误解。。。
:
: encapsulated
|
z****e
发帖数: 54598 | 76 nonono
erlang没有人用
主要是搞通信还有从ee通信转行的人喜欢用
主流编程界并不推崇erlang
Erlang
【在 n****1 的大作中提到】
: OOP的粉丝们喜欢吹鼓一切皆对象， 对象都有自己的method, 就像有自己的独立人格。
: 譬如BankAccount是对象， 它有deposit/withdraw/query这些method， 甚至连True/
: False这俩也是对象。 但其实这些都是死物， 它们自己不会动的， 而是被一些特殊的
: 对象： 活对象来使用， 像Banker这种。
: 这些活对象的却应该有自己的动作(method), 而且除此之外， 每个活对象还都需要有
: 独立运作空间。 换句话说， 每个对象都应该有自己独立的thread。 而传统的c++/
: java/python这些oop都是把object和thread两个概念完全正交分离的， 结果就是在
: multithread中很难搞懂object与thread之间错综复杂的关系， 所以程序员讨厌多线程
: ， 写出来的最robust的架构都是单线程的。
: 而每个活对象独占一线程， 同时把线程这玩意完全abstract out的思想， 正是Erlang
|
z****e
发帖数: 54598 | 77 在server side你搞单线程说明你的并发不够大，没有大到让你崩溃的地步
我喜欢在gui时候搞单线程，做游戏就应该单线程，我说的是游戏app
Erlang
【在 n****1 的大作中提到】
: OOP的粉丝们喜欢吹鼓一切皆对象， 对象都有自己的method, 就像有自己的独立人格。
: 譬如BankAccount是对象， 它有deposit/withdraw/query这些method， 甚至连True/
: False这俩也是对象。 但其实这些都是死物， 它们自己不会动的， 而是被一些特殊的
: 对象： 活对象来使用， 像Banker这种。
: 这些活对象的却应该有自己的动作(method), 而且除此之外， 每个活对象还都需要有
: 独立运作空间。 换句话说， 每个对象都应该有自己独立的thread。 而传统的c++/
: java/python这些oop都是把object和thread两个概念完全正交分离的， 结果就是在
: multithread中很难搞懂object与thread之间错综复杂的关系， 所以程序员讨厌多线程
: ， 写出来的最robust的架构都是单线程的。
: 而每个活对象独占一线程， 同时把线程这玩意完全abstract out的思想， 正是Erlang
|
z****e
发帖数: 54598 | 78 lambda怎么都算是scala的了？
而且表达完全不一样
你还不如说是抄袭dart的呢
【在 t***t 的大作中提到】
: thanks
: Just checked Java 8, it looks like a converging trend.
: Java 8 copied lots of stuff from Scala, such as lambda, traits etc, also
: Oracle gets its own Node.js implementation called Node.jar
:
: between
|
z****e
发帖数: 54598 | 79 嘿嘿
jee里面每一个对象和thread都是死的
你的概念早就被人搞定了
问题在于大多数程序员不懂而已
【在 n****1 的大作中提到】
: 我说的线程是抽象概念， 并非OS kernel thread。人家
: erlang上面几十万个userspace thread照样跑得好好的。
: 建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
: 啥yy
: >>打印机 安装多个打印鼓 相当于多线程
: 打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
: 动， 难道一个线程够了？
: >>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
: 你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
: 的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
|
z****e
发帖数: 54598 | 80 web发展已经到瓶颈了，再没有突破的话
这一波就会重演十几年前的泡沫
【在 s***o 的大作中提到】
: 对于非cpu bound的web backend app，erlang其实经常是很好的选择
|
|
|
t***t
发帖数: 6066 | 81 I'm not talking about lambda belong to scala, I'm talking that java 8 copied
the way scala doing lambda.
【在 z****e 的大作中提到】
: lambda怎么都算是scala的了？
: 而且表达完全不一样
: 你还不如说是抄袭dart的呢
|
t***t
发帖数: 6066 | 82 it seems google gradually abandon ship on javascript and move to dart,
another java-like static typed language for its UI. google almost abandon
its gwt totally.
this is the trend. dynamic language though is esier to start and small
projects, it cost much more to maintain and for large project.
UI, frontend, backend are all battlefields for different languages and
frameworks.
js is trying to invade into backend, and java is trying to invade into UI.
but java is tedious that's why java-like lang come out, in frontend, backend
even in UI. |
