m*4
2 楼
RT。 这样断断续续的快一个月了。最初是发烧，然后一天后烧自己退了，但是喉咙开
始无比的疼，喝水都不敢咽，喉咙也全哑了，看了医生，测试NEGATIVE，但是还是给开
了抗生素AZITHROMYCIN 250mg （青霉素过敏）的六颗，吃完一个疗程，全好了，可是
过了两天，又开始了，但是没烧也没鼻涕和其他任何症状，就是喉咙疼，还一边一边的
疼，打电话给医生，又续了同样的抗生素，又是一个疗程，吃了3颗就全好了，但是我
还是全吃完了，结果又过了3天，又开始疼了，没前几次厉害，只有右边疼，不想去看
医生了，也不想吃抗生素了。主要我还在母乳，实在怕一来依赖上抗生素，二来对娃不
好。有没有什么好的意见？多谢了。
始无比的疼，喝水都不敢咽，喉咙也全哑了，看了医生，测试NEGATIVE，但是还是给开
了抗生素AZITHROMYCIN 250mg （青霉素过敏）的六颗，吃完一个疗程，全好了，可是
过了两天，又开始了，但是没烧也没鼻涕和其他任何症状，就是喉咙疼，还一边一边的
疼，打电话给医生，又续了同样的抗生素，又是一个疗程，吃了3颗就全好了，但是我
还是全吃完了，结果又过了3天，又开始疼了，没前几次厉害，只有右边疼，不想去看
医生了，也不想吃抗生素了。主要我还在母乳，实在怕一来依赖上抗生素，二来对娃不
好。有没有什么好的意见？多谢了。
x*s
3 楼
前半年有1042-S收入，withhold了钱，后半年w-2收入，没有扣税 （J1免税期）。
现在在用h&r block，没找到怎么添加1042-S表，请问遇到这种情况，是把1042-s的收
入手动添加到w-2里面？还是不能用软件报税，只能自己填1040？
包子求助。
现在在用h&r block，没找到怎么添加1042-S表，请问遇到这种情况，是把1042-s的收
入手动添加到w-2里面？还是不能用软件报税，只能自己填1040？
包子求助。
s*y
4 楼
经过持续不懈的努力，也终于在今天约到了8月9号渥太华的签证。
希望找mm一起订宾馆分摊费用~~~
这个账号是gg的，所以请联系我的邮箱：c*********[email protected]
希望找mm一起订宾馆分摊费用~~~
这个账号是gg的，所以请联系我的邮箱：c*********[email protected]
p*e
5 楼
check
这种情况很可能发生，结果中国连自己的2800都没有用完，给老印so了，因为老印的排
期so后还比中国
完。。。。。。。。。。
我觉得NIU应该提醒一下O了
m*a
6 楼
【 以下文字转载自 Prose 讨论区 】
发信人: moha (moha), 信区: Prose
标 题: 浮城之恋 19
发信站: BBS 未名空间站 (Thu Mar 21 03:17:02 2013, 美东)
由乔治推着，我很快到达图书馆。正如乔治所说，图书馆外的留言板上，帖着一份《寻
狗启事》，它下半部的联系方法被人撕去了。啊，已经有人去告发我了！
“这就是你的老皮吧!” 乔治指着上面的照片说。
“不是成茹蜜妮莎公主的了么？” 我也不置可否。
“我总觉得她和你之间有什么事。” 乔治说。
“什么事也没有，我根本不认识她！”
“你这叫欲盖弥彰。”
“真的吗？” 我顺手扯下《寻狗启事》，揉成一团，投进远处垃圾筒，说：“看！《
寻狗启事》没了，茹蜜妮莎公主也不在世了，一切都象没发生的样子……”
“你怎么这么冷血？她这么敏感的身份，不该到处贴署名的《寻狗启事》，引来杀身之
祸，这不是都为帮你找狗吗？你不知道，她死的时候，门外墙上贴满了《寻狗启事》，
生怕知情人不认路，找不到她住的地方。”
嗯？我心中格登两下，门外贴满了《寻狗启事》的地方是她的隔壁！“等等，你能肯定
她死了？”
“大家都这么说。那个贴满了《寻狗启事》的客舱难道还会是别人的吗？有人看到尸体
从那抬出来。”
“你肯定那尸体就是她？”
“还能是别人吗？”他反问道。
走廊的另一头有人走来，我心虚，催乔治快点进图书馆。这个茹蜜妮莎公主多半没死成
，我得快点查出她的来历，不然不知惹上什么事呢。我让乔治把我推到最里的一个单间
，里面有一个数据云终端。乔治看我忙着，自己点了一本科幻小说《卜算子的仄韵》看
。我搜索了一会儿，才找到个三流小报《星云午餐伴读》，上有一文《茹蜜妮莎公主—
—罗姆人最后的贵族》。我正想读个究竟，一小群人踏进图书馆。其中一个保安大声宣
布：“闭馆了！” 图书馆里没几人，都合作地出去了。我急着想看那篇文章，而数据
云终端的东西带不出去，转头看乔治还看得入迷，就没当回事，继续读着：
“罗姆人，星际中的文明鼻祖。他们拥有五大发明，星际导航，四维建筑，通灵音乐，
物品复制，和反物质存储。如今，这五大发明在各大星系发扬光大，而罗姆人却没落了
。他们的故土罗姆星球，由归顺帝国的加达人占据，是帝国的反物质废料堆放场，指不
定那天就爆发成迷你白矮星。他们的人民四处流浪，从罗姆星球所在的史密斯云，一路
向外，经英仙座旋臂进入银河系后，渗透到猎户座旋臂，再经人马座旋臂向银核进发。
他们多以拾荒，卖艺，小工品生产为生。他们居无定所，飞船是他们的家。何曾想到，
他们从前尊贵的皇族，罗姆星球的统治者，仍有血脉散落于人间呢？十几年前，罗姆皇
族后裔试图夺回罗姆星球，以失败而告终，通通被捕，一批一批上绞架。茹蜜妮莎公主
的母亲，在绞索悬空她的身体之后，生下一女婴。刽子手没能接住溜滑的婴儿，让她飘
入太空，成为罗姆人皇族最后的血脉，人称茹蜜妮莎公主。”
新生的婴儿在太空中能存活多久呢？不过是一个悲惨的传说罢了。我叹口气，这个命运
多舛的茹蜜妮莎公主，还会有人冒充？这时，我听见图书馆的大门重重地关上，还人被
反锁上。
“辛扎，把我的披风拿来！今天晚上我们就得睡这了。”茹蜜妮莎公主的声音传来。
发信人: moha (moha), 信区: Prose
标 题: 浮城之恋 19
发信站: BBS 未名空间站 (Thu Mar 21 03:17:02 2013, 美东)
由乔治推着，我很快到达图书馆。正如乔治所说，图书馆外的留言板上，帖着一份《寻
狗启事》，它下半部的联系方法被人撕去了。啊，已经有人去告发我了！
“这就是你的老皮吧!” 乔治指着上面的照片说。
“不是成茹蜜妮莎公主的了么？” 我也不置可否。
“我总觉得她和你之间有什么事。” 乔治说。
“什么事也没有，我根本不认识她！”
“你这叫欲盖弥彰。”
“真的吗？” 我顺手扯下《寻狗启事》，揉成一团，投进远处垃圾筒，说：“看！《
寻狗启事》没了，茹蜜妮莎公主也不在世了，一切都象没发生的样子……”
“你怎么这么冷血？她这么敏感的身份，不该到处贴署名的《寻狗启事》，引来杀身之
祸，这不是都为帮你找狗吗？你不知道，她死的时候，门外墙上贴满了《寻狗启事》，
生怕知情人不认路，找不到她住的地方。”
嗯？我心中格登两下，门外贴满了《寻狗启事》的地方是她的隔壁！“等等，你能肯定
她死了？”
“大家都这么说。那个贴满了《寻狗启事》的客舱难道还会是别人的吗？有人看到尸体
从那抬出来。”
“你肯定那尸体就是她？”
“还能是别人吗？”他反问道。
走廊的另一头有人走来，我心虚，催乔治快点进图书馆。这个茹蜜妮莎公主多半没死成
，我得快点查出她的来历，不然不知惹上什么事呢。我让乔治把我推到最里的一个单间
，里面有一个数据云终端。乔治看我忙着，自己点了一本科幻小说《卜算子的仄韵》看
。我搜索了一会儿，才找到个三流小报《星云午餐伴读》，上有一文《茹蜜妮莎公主—
—罗姆人最后的贵族》。我正想读个究竟，一小群人踏进图书馆。其中一个保安大声宣
布：“闭馆了！” 图书馆里没几人，都合作地出去了。我急着想看那篇文章，而数据
云终端的东西带不出去，转头看乔治还看得入迷，就没当回事，继续读着：
“罗姆人，星际中的文明鼻祖。他们拥有五大发明，星际导航，四维建筑，通灵音乐，
物品复制，和反物质存储。如今，这五大发明在各大星系发扬光大，而罗姆人却没落了
。他们的故土罗姆星球，由归顺帝国的加达人占据，是帝国的反物质废料堆放场，指不
定那天就爆发成迷你白矮星。他们的人民四处流浪，从罗姆星球所在的史密斯云，一路
向外，经英仙座旋臂进入银河系后，渗透到猎户座旋臂，再经人马座旋臂向银核进发。
他们多以拾荒，卖艺，小工品生产为生。他们居无定所，飞船是他们的家。何曾想到，
他们从前尊贵的皇族，罗姆星球的统治者，仍有血脉散落于人间呢？十几年前，罗姆皇
族后裔试图夺回罗姆星球，以失败而告终，通通被捕，一批一批上绞架。茹蜜妮莎公主
的母亲，在绞索悬空她的身体之后，生下一女婴。刽子手没能接住溜滑的婴儿，让她飘
入太空，成为罗姆人皇族最后的血脉，人称茹蜜妮莎公主。”
新生的婴儿在太空中能存活多久呢？不过是一个悲惨的传说罢了。我叹口气，这个命运
多舛的茹蜜妮莎公主，还会有人冒充？这时，我听见图书馆的大门重重地关上，还人被
反锁上。
“辛扎，把我的披风拿来！今天晚上我们就得睡这了。”茹蜜妮莎公主的声音传来。
n*1
7 楼
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也完全没有意义。
譬如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也完全没有意义。
d*n
8 楼
下次进赌场前先看看须知，拜拜山头...
股市有风险，入市须谨慎！
【在 c*********t 的大作中提到】
: 有没有响应的？！
: 证监会是个垃圾单位。
股市有风险，入市须谨慎！
【在 c*********t 的大作中提到】
: 有没有响应的？！
: 证监会是个垃圾单位。
A*a
9 楼
测了什么negative
【在 m********4 的大作中提到】
: RT。 这样断断续续的快一个月了。最初是发烧，然后一天后烧自己退了，但是喉咙开
: 始无比的疼，喝水都不敢咽，喉咙也全哑了，看了医生，测试NEGATIVE，但是还是给开
: 了抗生素AZITHROMYCIN 250mg （青霉素过敏）的六颗，吃完一个疗程，全好了，可是
: 过了两天，又开始了，但是没烧也没鼻涕和其他任何症状，就是喉咙疼，还一边一边的
: 疼，打电话给医生，又续了同样的抗生素，又是一个疗程，吃了3颗就全好了，但是我
: 还是全吃完了，结果又过了3天，又开始疼了，没前几次厉害，只有右边疼，不想去看
: 医生了，也不想吃抗生素了。主要我还在母乳，实在怕一来依赖上抗生素，二来对娃不
: 好。有没有什么好的意见？多谢了。
【在 m********4 的大作中提到】
: RT。 这样断断续续的快一个月了。最初是发烧，然后一天后烧自己退了，但是喉咙开
: 始无比的疼，喝水都不敢咽，喉咙也全哑了，看了医生，测试NEGATIVE，但是还是给开
: 了抗生素AZITHROMYCIN 250mg （青霉素过敏）的六颗，吃完一个疗程，全好了，可是
: 过了两天，又开始了，但是没烧也没鼻涕和其他任何症状，就是喉咙疼，还一边一边的
: 疼，打电话给医生，又续了同样的抗生素，又是一个疗程，吃了3颗就全好了，但是我
: 还是全吃完了，结果又过了3天，又开始疼了，没前几次厉害，只有右边疼，不想去看
: 医生了，也不想吃抗生素了。主要我还在母乳，实在怕一来依赖上抗生素，二来对娃不
: 好。有没有什么好的意见？多谢了。
z*8
10 楼
自己填表。第7项填1042s加W2的收入之和。然后在21项填上-1042s的收入。在横线上写
上Tax treaty P.R.CHINA article #.最后附上你的w2和1042s就可以了。
上Tax treaty P.R.CHINA article #.最后附上你的w2和1042s就可以了。
t*r
11 楼
有见解
B*J
12 楼
同问，测啥了？很多时候嗓子疼是病毒，喝水+时间，你的医生连啥问题都没搞清楚就
给你开这么强的抗生素，而且你还在给孩子喂奶，你的医生很不负责任。
给你开这么强的抗生素，而且你还在给孩子喂奶，你的医生很不负责任。
x*s
13 楼
谢谢，不过我自己研究了一个晚上，觉得这么做貌似也可以。
7就是w2的收入，21填1042S的收入，之所以这样做是因为和版上大部分案例不同，我的
1042-S是withhold了税的。W2除了社会安全税和医疗税，倒是没有扣税。
包子答谢了~
【在 z********8 的大作中提到】
: 自己填表。第7项填1042s加W2的收入之和。然后在21项填上-1042s的收入。在横线上写
: 上Tax treaty P.R.CHINA article #.最后附上你的w2和1042s就可以了。
7就是w2的收入，21填1042S的收入，之所以这样做是因为和版上大部分案例不同，我的
1042-S是withhold了税的。W2除了社会安全税和医疗税，倒是没有扣税。
包子答谢了~
【在 z********8 的大作中提到】
: 自己填表。第7项填1042s加W2的收入之和。然后在21项填上-1042s的收入。在横线上写
: 上Tax treaty P.R.CHINA article #.最后附上你的w2和1042s就可以了。
l*n
14 楼
nod
m*4
15 楼
测了strapped throat, 结果negative
【在 A*****a 的大作中提到】
: 测了什么negative
【在 A*****a 的大作中提到】
: 测了什么negative
z*8
16 楼
包子收到，谢谢。
你的意思是说在你的w2收入里已经包括了1042s的收入了吗，那样的话应该在第7项填w2
收入
然后在21项填-1042s收入。无论如何填，个人觉得你需要保证一点正确，就是在第22项
得到的数值应该是你应该交税的收入，供参考。
【在 x*********s 的大作中提到】
: 谢谢，不过我自己研究了一个晚上，觉得这么做貌似也可以。
: 7就是w2的收入，21填1042S的收入，之所以这样做是因为和版上大部分案例不同，我的
: 1042-S是withhold了税的。W2除了社会安全税和医疗税，倒是没有扣税。
: 包子答谢了~
你的意思是说在你的w2收入里已经包括了1042s的收入了吗，那样的话应该在第7项填w2
收入
然后在21项填-1042s收入。无论如何填，个人觉得你需要保证一点正确，就是在第22项
得到的数值应该是你应该交税的收入，供参考。
【在 x*********s 的大作中提到】
: 谢谢，不过我自己研究了一个晚上，觉得这么做貌似也可以。
: 7就是w2的收入，21填1042S的收入，之所以这样做是因为和版上大部分案例不同，我的
: 1042-S是withhold了税的。W2除了社会安全税和医疗税，倒是没有扣税。
: 包子答谢了~
b*s
17 楼
虽然滥用oo不好，但是这样简单化视之显然也是浅薄的
m*4
18 楼
他还一再跟我说计量小不会影响。
【在 B****J 的大作中提到】
: 同问，测啥了？很多时候嗓子疼是病毒，喝水+时间，你的医生连啥问题都没搞清楚就
: 给你开这么强的抗生素，而且你还在给孩子喂奶，你的医生很不负责任。
【在 B****J 的大作中提到】
: 同问，测啥了？很多时候嗓子疼是病毒，喝水+时间，你的医生连啥问题都没搞清楚就
: 给你开这么强的抗生素，而且你还在给孩子喂奶，你的医生很不负责任。
S*s
19 楼
错了
【在 x*********s 的大作中提到】
: 谢谢，不过我自己研究了一个晚上，觉得这么做貌似也可以。
: 7就是w2的收入，21填1042S的收入，之所以这样做是因为和版上大部分案例不同，我的
: 1042-S是withhold了税的。W2除了社会安全税和医疗税，倒是没有扣税。
: 包子答谢了~
【在 x*********s 的大作中提到】
: 谢谢，不过我自己研究了一个晚上，觉得这么做貌似也可以。
: 7就是w2的收入，21填1042S的收入，之所以这样做是因为和版上大部分案例不同，我的
: 1042-S是withhold了税的。W2除了社会安全税和医疗税，倒是没有扣税。
: 包子答谢了~
p*2
20 楼
都是机器世界和现实世界之间的折衷吧？就看折衷在什么地方了。不能说Java不对，只
能说actor更上层。Functional本来就比Imperative上层。
能说actor更上层。Functional本来就比Imperative上层。
A*a
21 楼
多喝水，注意休息，用温盐水漱喉咙
【在 m********4 的大作中提到】
: 测了strapped throat, 结果negative
【在 m********4 的大作中提到】
: 测了strapped throat, 结果negative
p*2
22 楼
Scala里面的actor也是object吧？也是OOP的东西。Erlang不熟悉，不过感觉actor本来
也是个object，封装性很强。但是不share state，性能有影响。
也是个object，封装性很强。但是不share state，性能有影响。
m*a
23 楼
那有可能不是细菌感染是其他情况，再回去看下医生吧。医生不会给你开可能对娃不好
的药的
【在 m********4 的大作中提到】
: RT。 这样断断续续的快一个月了。最初是发烧，然后一天后烧自己退了，但是喉咙开
: 始无比的疼，喝水都不敢咽，喉咙也全哑了，看了医生，测试NEGATIVE，但是还是给开
: 了抗生素AZITHROMYCIN 250mg （青霉素过敏）的六颗，吃完一个疗程，全好了，可是
: 过了两天，又开始了，但是没烧也没鼻涕和其他任何症状，就是喉咙疼，还一边一边的
: 疼，打电话给医生，又续了同样的抗生素，又是一个疗程，吃了3颗就全好了，但是我
: 还是全吃完了，结果又过了3天，又开始疼了，没前几次厉害，只有右边疼，不想去看
: 医生了，也不想吃抗生素了。主要我还在母乳，实在怕一来依赖上抗生素，二来对娃不
: 好。有没有什么好的意见？多谢了。
的药的
【在 m********4 的大作中提到】
: RT。 这样断断续续的快一个月了。最初是发烧，然后一天后烧自己退了，但是喉咙开
: 始无比的疼，喝水都不敢咽，喉咙也全哑了，看了医生，测试NEGATIVE，但是还是给开
: 了抗生素AZITHROMYCIN 250mg （青霉素过敏）的六颗，吃完一个疗程，全好了，可是
: 过了两天，又开始了，但是没烧也没鼻涕和其他任何症状，就是喉咙疼，还一边一边的
: 疼，打电话给医生，又续了同样的抗生素，又是一个疗程，吃了3颗就全好了，但是我
: 还是全吃完了，结果又过了3天，又开始疼了，没前几次厉害，只有右边疼，不想去看
: 医生了，也不想吃抗生素了。主要我还在母乳，实在怕一来依赖上抗生素，二来对娃不
: 好。有没有什么好的意见？多谢了。
N*K
24 楼
编程序 和 系统仿真 完全不一样
所谓的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
所谓的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
25 楼
每个活对象独占一线程 在量子计算机出来前 就是好莱坞意淫
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
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
26 楼
我说的线程是抽象概念， 并非OS kernel thread。人家
erlang上面几十万个userspace thread照样跑得好好的。
建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
啥yy
>>打印机 安装多个打印鼓 相当于多线程
打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
动， 难道一个线程够了？
>>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
个电子当成一个活对象。
但我们真正需要的活对象少之又少.
【在 N******K 的大作中提到】
: 每个活对象独占一线程 在量子计算机出来前 就是好莱坞意淫
:
: Erlang
erlang上面几十万个userspace thread照样跑得好好的。
建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
啥yy
>>打印机 安装多个打印鼓 相当于多线程
打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
动， 难道一个线程够了？
>>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
个电子当成一个活对象。
但我们真正需要的活对象少之又少.
【在 N******K 的大作中提到】
: 每个活对象独占一线程 在量子计算机出来前 就是好莱坞意淫
:
: Erlang
n*1
27 楼
没错， 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，性能有影响。
但我的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
28 楼
凭记忆回想一下why OO
记得当年磨c++ 编程思想的时候，颇有篇幅在比较c 和 c++
一个主要的问题就是c++成员有更好的access control
时间顺序上，多线程远晚于oo，这一点不太确定。
打算学学fp，不过，除非最低层系统，middleware都不用oo，oo还是无法替代的，比如
硬件抽象，大量第三方驱动，fp是怎么处理的。
记得当年磨c++ 编程思想的时候，颇有篇幅在比较c 和 c++
一个主要的问题就是c++成员有更好的access control
时间顺序上，多线程远晚于oo，这一点不太确定。
打算学学fp，不过，除非最低层系统，middleware都不用oo，oo还是无法替代的，比如
硬件抽象，大量第三方驱动，fp是怎么处理的。
d*i
29 楼
典型的新新派上层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
西要是没有多线程，你的电脑早死菜菜了。
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
30 楼
多线程远早于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是怎么处理的。
即使这样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
31 楼
我提的这个与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是怎么处理的。
, 没有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
32 楼
用8086也可以 有啥意思？ cpu就那么几个可怜的核
【在 n****1 的大作中提到】
: 我说的线程是抽象概念， 并非OS kernel thread。人家
: erlang上面几十万个userspace thread照样跑得好好的。
: 建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
: 啥yy
: >>打印机 安装多个打印鼓 相当于多线程
: 打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
: 动， 难道一个线程够了？
: >>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
: 你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
: 的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
【在 n****1 的大作中提到】
: 我说的线程是抽象概念， 并非OS kernel thread。人家
: erlang上面几十万个userspace thread照样跑得好好的。
: 建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
: 啥yy
: >>打印机 安装多个打印鼓 相当于多线程
: 打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
: 动， 难道一个线程够了？
: >>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
: 你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
: 的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
N*K
33 楼
为啥要去掉成员函数？
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也能
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
34 楼
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猴子们会把每一
实是好的概念，而且是非常实用的概念。我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
35 楼
对于非cpu bound的web backend app，erlang其实经常是很好的选择
N*K
36 楼
这种thread和 通常意义的thread有何区别？
+
【在 d*******r 的大作中提到】
: userspace virtual thread 这种类似的高级执行单元 (我也不知道严格定义是啥)，确
: 实是好的概念，而且是非常实用的概念。我hack过 OpenFlow 的 user space OS, C++
: 写的，就有自己的 virtual cooperative thread.
: Erlang 就是同时开无数个 OTP process 的。
: 原生的 thread+sync 那一坨东西，直接用起来，实在太麻烦了，必然是要被取代的。
+
【在 d*******r 的大作中提到】
: userspace virtual thread 这种类似的高级执行单元 (我也不知道严格定义是啥)，确
: 实是好的概念，而且是非常实用的概念。我hack过 OpenFlow 的 user space OS, C++
: 写的，就有自己的 virtual cooperative thread.
: Erlang 就是同时开无数个 OTP process 的。
: 原生的 thread+sync 那一坨东西，直接用起来，实在太麻烦了，必然是要被取代的。
g*g
37 楼
你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (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
立人格吗？
一个桌子没有任何思想，就不能有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
38 楼
你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
old data来表示？它有啥method?
;这个世界万物皆物体 (object)
到底是谁走火入魔？
读完帖子再喷是交流的基本前提
【在 g*****g 的大作中提到】
: 你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (object)，物体需要独
: 立人格吗？
: 一个桌子没有任何思想，就不能有4条腿，一个面吗？你连最基本的常识都弄错了，还
: 推理了一大堆，I服了U。
: 事实上，OO里所谓对象，无非是一堆的相关的数据状态，用对象方法来确保数据的变化
: 保持一致性罢了。
: 另外，你对多线程的理解也很狭隘。actor model在复杂多线程的系统里很好用，可以
: 简化线程同步。
: 但反过来，如果系统并没有那么多的同步需要。比如绝大部分web应用，无非是某种形
: 式的CRUD，
old data来表示？它有啥method?
;这个世界万物皆物体 (object)
到底是谁走火入魔？
读完帖子再喷是交流的基本前提
【在 g*****g 的大作中提到】
: 你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (object)，物体需要独
: 立人格吗？
: 一个桌子没有任何思想，就不能有4条腿，一个面吗？你连最基本的常识都弄错了，还
: 推理了一大堆，I服了U。
: 事实上，OO里所谓对象，无非是一堆的相关的数据状态，用对象方法来确保数据的变化
: 保持一致性罢了。
: 另外，你对多线程的理解也很狭隘。actor model在复杂多线程的系统里很好用，可以
: 简化线程同步。
: 但反过来，如果系统并没有那么多的同步需要。比如绝大部分web应用，无非是某种形
: 式的CRUD，
g*g
39 楼
这不过是举个例子，桌子是死的也罢。为啥银行帐户不能用object来表示，莫非你想说
balance也是死的？
你大谈物体必须有人格，根本就是违反常识的事情。
【在 n****1 的大作中提到】
: 你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
: old data来表示？它有啥method?
: ;这个世界万物皆物体 (object)
: 到底是谁走火入魔？
: 读完帖子再喷是交流的基本前提
balance也是死的？
你大谈物体必须有人格，根本就是违反常识的事情。
【在 n****1 的大作中提到】
: 你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
: old data来表示？它有啥method?
: ;这个世界万物皆物体 (object)
: 到底是谁走火入魔？
: 读完帖子再喷是交流的基本前提
n*1
40 楼
哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
以有method. Banker是很好的object例子， 但account不是。
【在 g*****g 的大作中提到】
: 这不过是举个例子，桌子是死的也罢。为啥银行帐户不能用object来表示，莫非你想说
: balance也是死的？
: 你大谈物体必须有人格，根本就是违反常识的事情。
我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
以有method. Banker是很好的object例子， 但account不是。
【在 g*****g 的大作中提到】
: 这不过是举个例子，桌子是死的也罢。为啥银行帐户不能用object来表示，莫非你想说
: balance也是死的？
: 你大谈物体必须有人格，根本就是违反常识的事情。
N*K
41 楼
BankAccount 可以设置一些method 控制数据安全性 比如低权限的不能看不能写
【在 n****1 的大作中提到】
: 哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
: 我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
: 以有method. Banker是很好的object例子， 但account不是。
【在 n****1 的大作中提到】
: 哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
: 我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
: 以有method. Banker是很好的object例子， 但account不是。
N*K
42 楼
it喜欢把技术讨论 演变为人身攻击
【在 n****1 的大作中提到】
: 你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
: old data来表示？它有啥method?
: ;这个世界万物皆物体 (object)
: 到底是谁走火入魔？
: 读完帖子再喷是交流的基本前提
【在 n****1 的大作中提到】
: 你不过在重复和强化我的观点罢了。 就拿桌子为例， 桌子是死的 为啥不能用plain
: old data来表示？它有啥method?
: ;这个世界万物皆物体 (object)
: 到底是谁走火入魔？
: 读完帖子再喷是交流的基本前提
g*g
43 楼
这个世界大多数物体都是死的，没人操作不会改变，难道就不叫物体了？谁规定了物体
得活的，
你学了那么多年物理，齿轮，绳子哪个是活的？
车没人开就不会走，也是死的，不叫物体？你懂什么叫物体吗？没见过这么没常识还振
振有词的。
【在 n****1 的大作中提到】
: 哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
: 我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
: 以有method. Banker是很好的object例子， 但account不是。
得活的，
你学了那么多年物理，齿轮，绳子哪个是活的？
车没人开就不会走，也是死的，不叫物体？你懂什么叫物体吗？没见过这么没常识还振
振有词的。
【在 n****1 的大作中提到】
: 哦， 莫非balance是活的？ 其他人如果不去操作它， 它的值会变化么？
: 我顶楼已经举了例子，BankAccount不适合拥有method,而Banker是改变账户的actor,可
: 以有method. Banker是很好的object例子， 但account不是。
n*1
44 楼
有么？ 我原话是啥？
我想说的是“物体”不应该和OOP里面"object"划等号， 因为很多物体没有method, 但
"object"都有method, 至少有几个java自带的notify/wait之类的。
而OO猴子中毒太深， 直接把"物体"和"object"划等号。
【在 g*****g 的大作中提到】
: 这不过是举个例子，桌子是死的也罢。为啥银行帐户不能用object来表示，莫非你想说
: balance也是死的？
: 你大谈物体必须有人格，根本就是违反常识的事情。
n*1
45 楼
这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
【在 N******K 的大作中提到】
: BankAccount 可以设置一些method 控制数据安全性 比如低权限的不能看不能写
【在 N******K 的大作中提到】
: BankAccount 可以设置一些method 控制数据安全性 比如低权限的不能看不能写
g*g
46 楼
物体和object本来就是中英翻译罢了。物体和对象本来就是一个东西，对象抽象一点可
以包括虚拟的物体。具体到语言，无
非是个建模的工具，
各种feature都是取舍，有好处同样也有坏处。跟世界完全一致本来就不是设计语言的
要求，也做不到。
语言是工具，用来建模的，啥时候语言跟物理必须等价了。你一脑残理论，还来劲了。
【在 n****1 的大作中提到】
: 这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
以包括虚拟的物体。具体到语言，无
非是个建模的工具，
各种feature都是取舍，有好处同样也有坏处。跟世界完全一致本来就不是设计语言的
要求，也做不到。
语言是工具，用来建模的，啥时候语言跟物理必须等价了。你一脑残理论，还来劲了。
【在 n****1 的大作中提到】
: 这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
n*1
47 楼
Tell me about it! How can I understand "wait/notify" method of an Account
object?
怀疑版上70%以上的人身攻击是你挑起的。 对骂脑残我没兴趣。
【在 g*****g 的大作中提到】
: 物体和object本来就是中英翻译罢了。物体和对象本来就是一个东西，对象抽象一点可
: 以包括虚拟的物体。具体到语言，无
: 非是个建模的工具，
: 各种feature都是取舍，有好处同样也有坏处。跟世界完全一致本来就不是设计语言的
: 要求，也做不到。
: 语言是工具，用来建模的，啥时候语言跟物理必须等价了。你一脑残理论，还来劲了。
object?
怀疑版上70%以上的人身攻击是你挑起的。 对骂脑残我没兴趣。
【在 g*****g 的大作中提到】
: 物体和object本来就是中英翻译罢了。物体和对象本来就是一个东西，对象抽象一点可
: 以包括虚拟的物体。具体到语言，无
: 非是个建模的工具，
: 各种feature都是取舍，有好处同样也有坏处。跟世界完全一致本来就不是设计语言的
: 要求，也做不到。
: 语言是工具，用来建模的，啥时候语言跟物理必须等价了。你一脑残理论，还来劲了。
g*g
48 楼
你无知又逼我来打脸了是吧？为啥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%以上的人身攻击是你挑起的。 对骂脑残我没兴趣。
都有一个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
49 楼
把安全控制函数 想象为金库围墙和大门
banker控制的是金库钥匙 而不是去建一个安全的金库
【在 n****1 的大作中提到】
: 这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
banker控制的是金库钥匙 而不是去建一个安全的金库
【在 n****1 的大作中提到】
: 这个也不是Account的责任吧， 数据安全也应该由Banker的逻辑来控制。
n*1
50 楼
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
51 楼
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.
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
52 楼
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
53 楼
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".
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
54 楼
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控制的是金库钥匙 而不是去建一个安全的金库
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
55 楼
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.
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
56 楼
oo是比较僵化的，4条腿是桌子，3条，2条，1条就不是了？2个面就一定不是桌子了？
这种跟据属性确定object只适合比较静态常规情况，不适合高动态应用。
【在 g*****g 的大作中提到】
: 你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (object)，物体需要独
: 立人格吗？
: 一个桌子没有任何思想，就不能有4条腿，一个面吗？你连最基本的常识都弄错了，还
: 推理了一大堆，I服了U。
: 事实上，OO里所谓对象，无非是一堆的相关的数据状态，用对象方法来确保数据的变化
: 保持一致性罢了。
: 另外，你对多线程的理解也很狭隘。actor model在复杂多线程的系统里很好用，可以
: 简化线程同步。
: 但反过来，如果系统并没有那么多的同步需要。比如绝大部分web应用，无非是某种形
: 式的CRUD，
这种跟据属性确定object只适合比较静态常规情况，不适合高动态应用。
【在 g*****g 的大作中提到】
: 你走火入魔了，谁说对象需要独立人格？这个世界万物皆物体 (object)，物体需要独
: 立人格吗？
: 一个桌子没有任何思想，就不能有4条腿，一个面吗？你连最基本的常识都弄错了，还
: 推理了一大堆，I服了U。
: 事实上，OO里所谓对象，无非是一堆的相关的数据状态，用对象方法来确保数据的变化
: 保持一致性罢了。
: 另外，你对多线程的理解也很狭隘。actor model在复杂多线程的系统里很好用，可以
: 简化线程同步。
: 但反过来，如果系统并没有那么多的同步需要。比如绝大部分web应用，无非是某种形
: 式的CRUD，
g*g
57 楼
OO的建模相当灵活，如果腿和面是可变的，你大可以设两个属性，腿数，面数。
所以你说的这个完全没有道理。相比之下，FP强调数据不可变，只能做成状态机，建模
才不方便。
【在 c*******9 的大作中提到】
: oo是比较僵化的，4条腿是桌子，3条，2条，1条就不是了？2个面就一定不是桌子了？
: 这种跟据属性确定object只适合比较静态常规情况，不适合高动态应用。
所以你说的这个完全没有道理。相比之下，FP强调数据不可变，只能做成状态机，建模
才不方便。
【在 c*******9 的大作中提到】
: oo是比较僵化的，4条腿是桌子，3条，2条，1条就不是了？2个面就一定不是桌子了？
: 这种跟据属性确定object只适合比较静态常规情况，不适合高动态应用。
c*9
58 楼
这样你自己做具体应用也许问题不大，如果做库，应用中总有你考虑不到情况，为了灵
活增加属性，给用库的人增加负担，不是所以用库的人都有同样的需求。
FP要么是不强制类型，要么像haskell那样通过类型间的关系定义类型。比如桌子建模
可以不关心桌子有几个腿，几个面，
只要面上可以摆放东西。
【在 g*****g 的大作中提到】
: OO的建模相当灵活，如果腿和面是可变的，你大可以设两个属性，腿数，面数。
: 所以你说的这个完全没有道理。相比之下，FP强调数据不可变，只能做成状态机，建模
: 才不方便。
活增加属性，给用库的人增加负担，不是所以用库的人都有同样的需求。
FP要么是不强制类型，要么像haskell那样通过类型间的关系定义类型。比如桌子建模
可以不关心桌子有几个腿，几个面，
只要面上可以摆放东西。
【在 g*****g 的大作中提到】
: OO的建模相当灵活，如果腿和面是可变的，你大可以设两个属性，腿数，面数。
: 所以你说的这个完全没有道理。相比之下，FP强调数据不可变，只能做成状态机，建模
: 才不方便。
g*g
59 楼
不合适的库显然可以不用。没有比OO库更丰富的了。FP expressive是真的，flexible
差远了。
为了immutable，绕着一堆monad的弯子。
【在 c*******9 的大作中提到】
: 这样你自己做具体应用也许问题不大，如果做库，应用中总有你考虑不到情况，为了灵
: 活增加属性，给用库的人增加负担，不是所以用库的人都有同样的需求。
: FP要么是不强制类型，要么像haskell那样通过类型间的关系定义类型。比如桌子建模
: 可以不关心桌子有几个腿，几个面，
: 只要面上可以摆放东西。
差远了。
为了immutable，绕着一堆monad的弯子。
【在 c*******9 的大作中提到】
: 这样你自己做具体应用也许问题不大，如果做库，应用中总有你考虑不到情况，为了灵
: 活增加属性，给用库的人增加负担，不是所以用库的人都有同样的需求。
: FP要么是不强制类型，要么像haskell那样通过类型间的关系定义类型。比如桌子建模
: 可以不关心桌子有几个腿，几个面，
: 只要面上可以摆放东西。
c*9
60 楼
估计你主要做网站。很多应用是难找合适库的。程序员找库不浪费时间。
说flexible难有比像Lisp这样有的eval的了。动态改程序，数据还不够flexible。
monad不是为了仅仅为了immutable，也容易实现AOP。不熟悉的人觉得别扭，一旦熟悉
，没有比这更好用的了。
flexible
【在 g*****g 的大作中提到】
: 不合适的库显然可以不用。没有比OO库更丰富的了。FP expressive是真的，flexible
: 差远了。
: 为了immutable，绕着一堆monad的弯子。
说flexible难有比像Lisp这样有的eval的了。动态改程序，数据还不够flexible。
monad不是为了仅仅为了immutable，也容易实现AOP。不熟悉的人觉得别扭，一旦熟悉
，没有比这更好用的了。
flexible
【在 g*****g 的大作中提到】
: 不合适的库显然可以不用。没有比OO库更丰富的了。FP expressive是真的，flexible
: 差远了。
: 为了immutable，绕着一堆monad的弯子。
g*g
61 楼
client端的东西我不懂，但凡是server端的，有通用价值的，基本上没有啥库不存在的。
lisp, LOL, lisp有像样的库吗。你说的这些lisp的特性还是expressive, fp光不强调
封装，
轮子就永远赶不上oo。
【在 c*******9 的大作中提到】
: 估计你主要做网站。很多应用是难找合适库的。程序员找库不浪费时间。
: 说flexible难有比像Lisp这样有的eval的了。动态改程序，数据还不够flexible。
: monad不是为了仅仅为了immutable，也容易实现AOP。不熟悉的人觉得别扭，一旦熟悉
: ，没有比这更好用的了。
:
: flexible
lisp, LOL, lisp有像样的库吗。你说的这些lisp的特性还是expressive, fp光不强调
封装，
轮子就永远赶不上oo。
【在 c*******9 的大作中提到】
: 估计你主要做网站。很多应用是难找合适库的。程序员找库不浪费时间。
: 说flexible难有比像Lisp这样有的eval的了。动态改程序，数据还不够flexible。
: monad不是为了仅仅为了immutable，也容易实现AOP。不熟悉的人觉得别扭，一旦熟悉
: ，没有比这更好用的了。
:
: flexible
n*1
62 楼
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.
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
63 楼
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.
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
64 楼
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.
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
65 楼
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.
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
66 楼
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
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
67 楼
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.
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
68 楼
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
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
69 楼
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.
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
70 楼
这种仿真的唯一下场就是 out of memory...
【在 N******K 的大作中提到】
: 编程序 和 系统仿真 完全不一样
: 所谓的object 可以对应物理世界的一个实物 有状态 有动作 比如打印机
: thread和object不一样
: 比如一台打印机 安装多个打印鼓 相当于多线程
: 在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
:
: Erlang
【在 N******K 的大作中提到】
: 编程序 和 系统仿真 完全不一样
: 所谓的object 可以对应物理世界的一个实物 有状态 有动作 比如打印机
: thread和object不一样
: 比如一台打印机 安装多个打印鼓 相当于多线程
: 在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
:
: Erlang
c*9
71 楼
"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
这可不一定，你能改一下某个电子，质子的静止质量吗。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
72 楼
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.
过段时间会写个更详细的介绍。
那个index其实就是function closure. 每一个函数里面都可以有一个名字一样的不变
量， 但它们的值不一定要一样。
FP里面用closure+recursion来对mutable environment建模， 利用recursion的层数达
到x_t!=x_(t+1)的效果。
如果资源有限， 某些情况下不需要保存所有的X_t, 那就可以把一些function closure
丢掉。 这就是传说中的tail call optimization.
过段时间会写个更详细的介绍。
c*9
73 楼
你说的server端估计还是局限于网站。 lisp在人工智能方面还是有些库，尽管现在
java c++库也不少。
fp的问题不是封装（封装往往也不比OO差），fp不普及，是因为多数初学者，喜欢和具
体事物直接联系的语言和库，抽象些就无从下手。就像佛教很少人能懂，李大师把它具
体化庸俗化，立刻招来上亿信徒。
的。
【在 g*****g 的大作中提到】
: client端的东西我不懂，但凡是server端的，有通用价值的，基本上没有啥库不存在的。
: lisp, LOL, lisp有像样的库吗。你说的这些lisp的特性还是expressive, fp光不强调
: 封装，
: 轮子就永远赶不上oo。
java c++库也不少。
fp的问题不是封装（封装往往也不比OO差），fp不普及，是因为多数初学者，喜欢和具
体事物直接联系的语言和库，抽象些就无从下手。就像佛教很少人能懂，李大师把它具
体化庸俗化，立刻招来上亿信徒。
的。
【在 g*****g 的大作中提到】
: client端的东西我不懂，但凡是server端的，有通用价值的，基本上没有啥库不存在的。
: lisp, LOL, lisp有像样的库吗。你说的这些lisp的特性还是expressive, fp光不强调
: 封装，
: 轮子就永远赶不上oo。
g*g
74 楼
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
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
75 楼
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不普及，是因为多数初学者，喜欢和具
: 体事物直接联系的语言和库，抽象些就无从下手。就像佛教很少人能懂，李大师把它具
: 体化庸俗化，立刻招来上亿信徒。
:
: 的。
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
76 楼
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看法
: ，没有什么绝对标准来判断那个更真。
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
77 楼
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
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
78 楼
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.
:
'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
79 楼
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.
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
80 楼
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
81 楼
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
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
82 楼
IMO, it's the best of all, it's pure OOP, full blown FP, extensible, concise
,
scalable, plus it can use all Java libraries.
,
scalable, plus it can use all Java libraries.
g*g
83 楼
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.
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
84 楼
嗯。这个用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.
: 过段时间会写个更详细的介绍。
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
85 楼
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
【在 g*****g 的大作中提到】
: Everything comes with a price, it's powerful, flexible and expressive, but
: it's also complicate.
:
: concise
t*t
86 楼
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.
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
87 楼
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.
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
88 楼
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
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
89 楼
finished reading traits. it's pretty interesting. the stackable modification
is pretty powerful.
is pretty powerful.
c*o
90 楼
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.
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
91 楼
我觉得你好好花时间看看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废掉了.
点，我这样的彩笔看了受益，高手看了有共鸣；现在的结果，我这个彩笔看了不懂，高
手看了误解。。。
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
92 楼
看了, 可惜俺做不到那境界. 你就当俺胡说八道好了.
【在 j********x 的大作中提到】
: 我觉得你好好花时间看看TAOCP，学学Knuth老爷爷的逻辑与写作；然后再来阐述这些观
: 点，我这样的彩笔看了受益，高手看了有共鸣；现在的结果，我这个彩笔看了不懂，高
: 手看了误解。。。
:
: encapsulated
【在 j********x 的大作中提到】
: 我觉得你好好花时间看看TAOCP，学学Knuth老爷爷的逻辑与写作；然后再来阐述这些观
: 点，我这样的彩笔看了受益，高手看了有共鸣；现在的结果，我这个彩笔看了不懂，高
: 手看了误解。。。
:
: encapsulated
z*e
93 楼
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
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
94 楼
在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
我喜欢在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
95 楼
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
而且表达完全不一样
你还不如说是抄袭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
96 楼
嘿嘿
jee里面每一个对象和thread都是死的
你的概念早就被人搞定了
问题在于大多数程序员不懂而已
【在 n****1 的大作中提到】
: 我说的线程是抽象概念， 并非OS kernel thread。人家
: erlang上面几十万个userspace thread照样跑得好好的。
: 建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
: 啥yy
: >>打印机 安装多个打印鼓 相当于多线程
: 打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
: 动， 难道一个线程够了？
: >>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
: 你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
: 的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
jee里面每一个对象和thread都是死的
你的概念早就被人搞定了
问题在于大多数程序员不懂而已
【在 n****1 的大作中提到】
: 我说的线程是抽象概念， 并非OS kernel thread。人家
: erlang上面几十万个userspace thread照样跑得好好的。
: 建议你看看erlang, 看了你就知道独占一个userspace thread是已经实现了的， 不是
: 啥yy
: >>打印机 安装多个打印鼓 相当于多线程
: 打印机/鼓里面本来就有电子芯片， 高度智能， 当然是活的。 如果你要写个打印机驱
: 动， 难道一个线程够了？
: >>在量子计算机出来之前 搞和物理世界一对一的仿真 是不可能的
: 你要是陷入了java/python思维模式不能自拔，就会觉得java里几乎每一个对象都是活
: 的，连true/false都是。 那样连量子计算机也不可能达到， 因为OOP猴子们会把每一
z*e
97 楼
web发展已经到瓶颈了，再没有突破的话
这一波就会重演十几年前的泡沫
【在 s***o 的大作中提到】
: 对于非cpu bound的web backend app，erlang其实经常是很好的选择
这一波就会重演十几年前的泡沫
【在 s***o 的大作中提到】
: 对于非cpu bound的web backend app，erlang其实经常是很好的选择
t*t
98 楼
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的呢
the way scala doing lambda.
【在 z****e 的大作中提到】
: lambda怎么都算是scala的了？
: 而且表达完全不一样
: 你还不如说是抄袭dart的呢
t*t
99 楼
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.
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.
相关阅读
便宜的VPS (转载)求zhaoce大牛内推Netflix王垠为什么悲愤？ (转载)问一下：怎么算复杂度？写code都推一起很牛逼吗js里不允许任何html markup王垠是个难得的计算机语言天才 (转载)问一个关于网络的问题，大家不要笑话请问搬瓦工现在国内还能用来翻墙吗？王垠： 编程的宗派有啥好轮子可以抓取网页里的不规则信息？30天自制操作系统网页数据，生成word文档，生成PDF文件问个node.js的问题python: 可以用map计算数列之间的差额吗？java里一般一个函数在多少行问一个mapreduce题目王垠相当于反对global warming theory的气候学家 (转载)天方夜谭 节选前端码农想转后端的困惑，望大牛解答