面向数据的编程与面向对象的编程 - 未名空间MITBBS历史存档

面向数据的编程与面向对象的编程# Programming - 葵花宝典

h*i2017-05-10 07:05

1 楼

面向数据的编程（data oriented programming）就是把程序的逻辑用数据结构表达。
这其实在分布式计算
已经用得很多了，各种逻辑可以变成数据结构在节点间传来传去。而Clojure社区现在
意识到，其实单机程序也可以这样写。一个逻辑，能用数据机构表达的，就用数据结构
表达，这样更灵活。
这个关于data的地位的问题，Alan Kay（就是因为Smalltalk拿图灵奖那位，面向对象
的编程的祖师爷）与Rich
Hickey（就是发明Clojure的那个民科）还在hackernews上有一个争论https://news.
ycombinator.com/item?id=11945722)。前者认为"Data is a bad idea", 因为data总
是需要一个interpreter。后者认为Data是客观存在的，是第一位的，如何interpret是
第二位的。搞计算机技术，要以第一位的东西为中心。
显然，我是同意Rich Hickey的观点的。因为其实最终的interpreter，是在人的脑子里
面。就算再多的type checking, proof, blah blah, 最后还是要人来决定这个程序的
结果是对还是不对。不要以为程序能搞定这个interpreter的问题。
还有一个支持Hickey观点的arugment，是从信息论的角度，就是“信息永远不会增多”
的定理（https://en.wikipedia.org/wiki/Data_processing_inequality）。加个
interpreter不会增加任何信息。哈哈。
可惜OOP的祖师爷觉得Object应该成为这样的interpreter. 他举出的理想技术居然是一
个人造的用来与外星人通话的语言。所以我觉得图灵奖得主和民科似乎换位了。哈哈。
No wonder OOP is doomed to fail. It's philosophically and mathematically
unsound.

w*m2017-05-10 07:05

2 楼

OOP的目的就是搬砖。
不认为自己是搬砖的人都会比较痛苦。
但是，没有OOP，砖很难搬的动。
很难想象，如果没有继承，封装，多态，抽象这些特性，
如何去改动别人的代码，或者多个人做一个项目。

h*i2017-05-10 07:05

3 楼

其实不用你想象，现在这么多函数式编程的语言和项目，只要睁开眼睛就行。
继承和封装都是不好的主意。继承其实是把世界强迫用树来模拟；如果数据是
immutable的，封装其实不必要。
多态的方式可以很多，OOP多态其实限制太大了，只能despatch by class，其实可以
dispatch by anything.
抽象是计算机科学的核心，没有什么计算机技术不是在玩抽象的游戏。但OOP基于名词
的抽象的限制太过了，一切都必须成为名词（object, class)，搞成了Kingdom of
Nouns （https://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-
nouns.html）.而现实世界名词动词形容词啥都有。
如何改动别人的代码，如何多个人做一个项目？用数据啊。就像Internet一样，只要
知道了数据交换的协议，按协议规格编程就行了。这都是成熟的方法了，现在把它用在
编程上，就行了，其实也不复杂。
计算机各个领域之间的相互借鉴，是很必要的。嗯。

【在 w********m 的大作中提到】

: OOP的目的就是搬砖。
: 不认为自己是搬砖的人都会比较痛苦。
: 但是，没有OOP，砖很难搬的动。
: 很难想象，如果没有继承，封装，多态，抽象这些特性，
: 如何去改动别人的代码，或者多个人做一个项目。

j*w2017-05-10 07:05

4 楼

没有OOP之前，大型项目就很多了。现在kernel这种超大型项目依然用C这种低级语言完
成的。继承，封装，多态，抽象等不需要OOP就能做。
现在各种语言乱飞，个个吹的天花乱坠，其实本质上并没对软件业产生变革性推进。

【在 w********m 的大作中提到】

: OOP的目的就是搬砖。
: 不认为自己是搬砖的人都会比较痛苦。
: 但是，没有OOP，砖很难搬的动。
: 很难想象，如果没有继承，封装，多态，抽象这些特性，
: 如何去改动别人的代码，或者多个人做一个项目。

w*m2017-05-10 07:05

5 楼

你们想多了，OOP的发明者很聪明，知道天才的时代已经过去了，
预测到未来软件界的主力来自于东南亚某国。
天才还有，比如linus，还有王银，那是可遇不可求。
继承是，三哥写了一个上千行的像屎样的class。不要改他的代码，否则他咬死你。继
承一下，override几个method，将就着用吧。
封装是，要三哥把所有的变量放到class，不要毒害环境。
抽象是，三哥好多天偷懒不出货，写个interface要他implement一下。
多态是，三哥可以随便瞎写，但得把我的interface实现。
没有这些手段，软件很难写。

g*t2017-05-10 07:05

6 楼

说的不错。这些东西其实都是用来整人的。

【在 w********m 的大作中提到】

: 你们想多了，OOP的发明者很聪明，知道天才的时代已经过去了，
: 预测到未来软件界的主力来自于东南亚某国。
: 天才还有，比如linus，还有王银，那是可遇不可求。
: 继承是，三哥写了一个上千行的像屎样的class。不要改他的代码，否则他咬死你。继
: 承一下，override几个method，将就着用吧。
: 封装是，要三哥把所有的变量放到class，不要毒害环境。
: 抽象是，三哥好多天偷懒不出货，写个interface要他implement一下。
: 多态是，三哥可以随便瞎写，但得把我的interface实现。
: 没有这些手段，软件很难写。

N*m2017-05-10 07:05

7 楼

整人也谈不上，就是福特流水线的发明一样。
降低熟练工人的门槛。

【在 g****t 的大作中提到】

: 说的不错。这些东西其实都是用来整人的。

d*n2017-05-10 07:05

8 楼

data driven development and validation
没有数据写毛code

c*n2017-05-10 07:05

9 楼

嗯工厂化工业化降低不可替代性
一边是独门绝技一边是每个部件上个螺丝拧紧

【在 N*****m 的大作中提到】

: 整人也谈不上，就是福特流水线的发明一样。
: 降低熟练工人的门槛。

r*z2017-05-10 07:05

10 楼

walkrandom的点评太到位啦……

d*r2017-05-10 07:05

11 楼

继承确实是个很非常蠢笨的idea，但是封装不是啊，
而且对人这种脑内内存有限的生物来说, 封装内部结构是做抽象的基础

【在 h*i 的大作中提到】

: 其实不用你想象，现在这么多函数式编程的语言和项目，只要睁开眼睛就行。
: 继承和封装都是不好的主意。继承其实是把世界强迫用树来模拟；如果数据是
: immutable的，封装其实不必要。
: 多态的方式可以很多，OOP多态其实限制太大了，只能despatch by class，其实可以
: dispatch by anything.
: 抽象是计算机科学的核心，没有什么计算机技术不是在玩抽象的游戏。但OOP基于名词
: 的抽象的限制太过了，一切都必须成为名词（object, class)，搞成了Kingdom of
: Nouns （https://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-
: nouns.html）.而现实世界名词动词形容词啥都有。
: 如何改动别人的代码，如何多个人做一个项目？用数据啊。就像Internet一样，只要

h*i2017-05-10 07:05

12 楼

不封装就不能抽象了么？抽象不需要封装。
所谓抽象，其实无非是在数据上再堆数据（i.e. tag some existing data with type
and other meta information)，那原有数据封起来干嘛啊，还是因为怕别人乱动。数
据如果都是immutable的，那别人也动不了，所以就不必要脱裤子放屁了，因为你早晚
还是要看里面的数据的。
现在OOP不是鼓励用interface了么？其实用interface，就是tag数据而已。

【在 d*******r 的大作中提到】

: 继承确实是个很非常蠢笨的idea，但是封装不是啊，
: 而且对人这种脑内内存有限的生物来说, 封装内部结构是做抽象的基础

d*r2017-05-10 07:05

13 楼

哦, 我的意思是这样的, 对人这种脑力有限的生物来说, 封装后再抽象很重要.
很多东西底层是一大坨messy细节, 封装打包完, 再tag几个high-level接口才能用.

type

【在 h*i 的大作中提到】

: 不封装就不能抽象了么？抽象不需要封装。
: 所谓抽象，其实无非是在数据上再堆数据（i.e. tag some existing data with type
: and other meta information)，那原有数据封起来干嘛啊，还是因为怕别人乱动。数
: 据如果都是immutable的，那别人也动不了，所以就不必要脱裤子放屁了，因为你早晚
: 还是要看里面的数据的。
: 现在OOP不是鼓励用interface了么？其实用interface，就是tag数据而已。

h*i2017-05-10 07:05

14 楼

问题是我们在讨论在计算机里面应该如何组织数据。人在脑子里面怎么封装都可以，搞
在计算机语言里面就不必要了，这些封装凭空造出一些问题本身并没有的限制，人必须
要去想它们，给人本来就有限的脑力增加负担，这就是所谓的incidental complexity。

【在 d*******r 的大作中提到】

: 哦, 我的意思是这样的, 对人这种脑力有限的生物来说, 封装后再抽象很重要.
: 很多东西底层是一大坨messy细节, 封装打包完, 再tag几个high-level接口才能用.
:
: type

r*g2017-05-10 07:05

15 楼

函数算是数据外面的还是数据的一部分？

【在 h*i 的大作中提到】

: 面向数据的编程（data oriented programming）就是把程序的逻辑用数据结构表达。
: 这其实在分布式计算
: 已经用得很多了，各种逻辑可以变成数据结构在节点间传来传去。而Clojure社区现在
: 意识到，其实单机程序也可以这样写。一个逻辑，能用数据机构表达的，就用数据结构
: 表达，这样更灵活。
: 这个关于data的地位的问题，Alan Kay（就是因为Smalltalk拿图灵奖那位，面向对象
: 的编程的祖师爷）与Rich
: Hickey（就是发明Clojure的那个民科）还在hackernews上有一个争论https://news.
: ycombinator.com/item?id=11945722)。前者认为"Data is a bad idea", 因为data总
: 是需要一个interpreter。后者认为Data是客观存在的，是第一位的，如何interpret是

r*g2017-05-10 07:05

16 楼

我觉得作为语言，要有动词，名词，介词副词，才能表达力丰富。这个OOP只有名字，
函数式只有动词，都还是太原始了。

【在 h*i 的大作中提到】

: 面向数据的编程（data oriented programming）就是把程序的逻辑用数据结构表达。
: 这其实在分布式计算
: 已经用得很多了，各种逻辑可以变成数据结构在节点间传来传去。而Clojure社区现在
: 意识到，其实单机程序也可以这样写。一个逻辑，能用数据机构表达的，就用数据结构
: 表达，这样更灵活。
: 这个关于data的地位的问题，Alan Kay（就是因为Smalltalk拿图灵奖那位，面向对象
: 的编程的祖师爷）与Rich
: Hickey（就是发明Clojure的那个民科）还在hackernews上有一个争论https://news.
: ycombinator.com/item?id=11945722)。前者认为"Data is a bad idea", 因为data总
: 是需要一个interpreter。后者认为Data是客观存在的，是第一位的，如何interpret是

g*t2017-05-10 07:05

17 楼

让你读thinking in xxx,
把你洗脑，弄成随时可替代的部分,然后进行重复劳动。
还不是整人吗。

: 整人也谈不上，就是福特流水线的发明一样。

: 降低熟练工人的门槛。

【在 N*****m 的大作中提到】

: 整人也谈不上，就是福特流水线的发明一样。
: 降低熟练工人的门槛。

h*i2017-05-10 07:05

18 楼

函数在数据上操作。
当然了，用Lisp的话，函数其实也是数据。

【在 r*g 的大作中提到】

: 函数算是数据外面的还是数据的一部分？

h*i2017-05-10 07:05

19 楼

函数式是啥词都有啊。函数是动词，数据其实可以是任何词，因为解释器是在人脑子里
面。
OOP以为Object能搞定解释器，Haskell人们以为type checker能搞定解释器，其实都是
大谬，自以为给数据加些条条框框似乎就给数据赋予了意义了，其实唯一的功能是他们
说的“整人”。

【在 r*g 的大作中提到】

: 我觉得作为语言，要有动词，名词，介词副词，才能表达力丰富。这个OOP只有名字，
: 函数式只有动词，都还是太原始了。

N*n2017-05-10 07:05

20 楼

反对封装的程序员大概没写过C语言的大项目。C的指针可以不受限制满天乱指，
用过C的人最怕指针出错。张三的指针出错指到李四的数据上。李四那边发现异
常还莫名其妙不知道咋回事，自己的代码查了半天也没找出原因。最后才明白
原来是张三的指针撒野搞乱了自己的数据，责任根本不在李四。HOHOHO
加封装就是要引入一种安全责任机制，专职代码掌控专项数据。出问题可以快
速锁定病源模块，这样做项目才有效率。甩C语言"李四纠张三的错"那种风格
几条街。反对封装的八成没吃过C语言的苦。

h*i2017-05-10 07:05

21 楼

C语言就是个打扮光鲜的汇编语言，现在都啥时代了，扯那些老黄历干嘛。我老写C为中
国人民解放军做贡献的时候，很多小孩可能还在穿开裆裤，可能不少都还没生出来。还
指针，Java啥的早就把指针都取消了，哪有指针给你玩。封装是数据随便乱动时代的解
决问题的一个办法，但是，现在人家都在搞immutable数据了，再扯封装就是迂腐了。
时代在变化，要跟上时代才能吃香喝辣。当然你现在还可以去写C，但就不要抱怨不能
吃香喝辣了。

【在 N********n 的大作中提到】

: 反对封装的程序员大概没写过C语言的大项目。C的指针可以不受限制满天乱指，
: 用过C的人最怕指针出错。张三的指针出错指到李四的数据上。李四那边发现异
: 常还莫名其妙不知道咋回事，自己的代码查了半天也没找出原因。最后才明白
: 原来是张三的指针撒野搞乱了自己的数据，责任根本不在李四。HOHOHO
: 加封装就是要引入一种安全责任机制，专职代码掌控专项数据。出问题可以快
: 速锁定病源模块，这样做项目才有效率。甩C语言"李四纠张三的错"那种风格
: 几条街。反对封装的八成没吃过C语言的苦。

N*n2017-05-10 07:05

22 楼

封装保证了专职模块负责专项数据，即安全还有清楚OWNERSHIP。带来的开发效
率远比没有封装强。
Hate to break it to you but "immutable data" is simply myth. You
can put some value type data in immutable state but not for real
world complex data like a big server database as the real world
is inherently mutable.

【在 h*i 的大作中提到】

: C语言就是个打扮光鲜的汇编语言，现在都啥时代了，扯那些老黄历干嘛。我老写C为中
: 国人民解放军做贡献的时候，很多小孩可能还在穿开裆裤，可能不少都还没生出来。还
: 指针，Java啥的早就把指针都取消了，哪有指针给你玩。封装是数据随便乱动时代的解
: 决问题的一个办法，但是，现在人家都在搞immutable数据了，再扯封装就是迂腐了。
: 时代在变化，要跟上时代才能吃香喝辣。当然你现在还可以去写C，但就不要抱怨不能
: 吃香喝辣了。

h*i2017-05-10 07:05

23 楼

“保证专职模块负责专项数据，安全还有清楚OWNERSHIP”，这些都不需要在程序语言
层面搞封装。封装是实现这些的一个手段，如果其弊大于利，那么就不必要。
哪有啥是“inherently mutable”的东西。你孤落寡闻了不是，append-only数据库都
有不少了，rethinkdb, datomic，这些都是用户很多的。Kafka这种系统，也是append
-only.
mutable是为了省硬件省钱，但增加了编程复杂性。现在硬件越来越不值钱，immutable
的系统会越来越多。

【在 N********n 的大作中提到】

:
: 封装保证了专职模块负责专项数据，即安全还有清楚OWNERSHIP。带来的开发效
: 率远比没有封装强。
: Hate to break it to you but "immutable data" is simply myth. You
: can put some value type data in immutable state but not for real
: world complex data like a big server database as the real world
: is inherently mutable.

d*r2017-05-10 07:05

24 楼

我感觉你俩说的“封装”不是一个概念...
NeverLearn说的广义上的，hci说的OOP上那种什么都要强制封入object的思想

h*i2017-05-10 07:05

25 楼

哦，是么？他不是在说OOP的封装么？什么解决C的指针乱指啥的，不就是C++么？

【在 d*******r 的大作中提到】

: 我感觉你俩说的“封装”不是一个概念...
: NeverLearn说的广义上的，hci说的OOP上那种什么都要强制封入object的思想

d*c2017-05-10 07:05

26 楼

概念上我部分同意你说的，但是其他人说的封装，抽象，要么和你说的不完全是一回事
，要么还是有其意义，至少在他们的语境下有意义，比如在C，在Java里。你不能说你
Clojure不需要这些，别人就也不需要这些吧。
从程序角度，关键是减少不必要的耦合，把该相关的相关，不该相关的隔离。封装和抽
象是实现的一种方式，复杂性是增加了，但是从人脑的角度看不见一些东西，不需要了
解一些东西就可以放心使用，这是进步。的确这不一定在程序里做，但在C和java的条
件下有这个是实用的。
另外硬件不值钱这个说法也不完全，能够不在意硬件限制的应用越来越多，但同样有些
需求增长速度永远大于你硬件进步的速度。
从内存到不限于内存
从单机到多机
这两个变化都需要计算模式的根本变化。单机，内存以内简单，那随时都有问题超过你
单机和内存的限制。你用其它存储，用多机，总得用个不同的计算模式，总得限制你自
己，多机始终不可能做到像个虚拟的单机一样。

append
immutable

【在 h*i 的大作中提到】

: “保证专职模块负责专项数据，安全还有清楚OWNERSHIP”，这些都不需要在程序语言
: 层面搞封装。封装是实现这些的一个手段，如果其弊大于利，那么就不必要。
: 哪有啥是“inherently mutable”的东西。你孤落寡闻了不是，append-only数据库都
: 有不少了，rethinkdb, datomic，这些都是用户很多的。Kafka这种系统，也是append
: -only.
: mutable是为了省硬件省钱，但增加了编程复杂性。现在硬件越来越不值钱，immutable
: 的系统会越来越多。

d*c2017-05-10 07:05

27 楼

OO偏颇了，一切都必须是名词
函数又全是动词
有些概念是形容词副词，比如一些decorator
还有aspect
肯定是每个都有其用途
关键是必要的内聚，不必要的减少耦合，我觉得这两个概念比较精确。
能不耦合的不耦合，减少复杂度，减少相互影响。抽象是层次上减少可见信息，封装是
加东西来减少可见信息。东西都更复杂了，但人可见的简单了。如果底下的没有做错，
人只在上面操作是更好了。
但是必要的内聚实际避免不了。
函数式编程强调无副作用，但是现实生活中没有副作用你程序什么也干不了，打印显示
都做不到，影响不了外界你就不存在。
MVC架构是个典型，实际上用户界面这里你无法避免一些耦合，硬分开最后还是要关联
起来。
许多耦合最后只能定义好接口把规矩定好，只考虑子集让问题简化一些。
再回头一看，OO的好处在于数据和代码内聚在一起，然后封装了，一切都是消息传递，
不关心内部实现细节。数据代码的内聚就是合理的，互相局限在相关的范围内，问题都
简单一些。
当然现实生活中往往没有那么理想的模型，需求再一变化，又是麻烦。那么对于某些问
题，动词和数据的概念就可能更合适。
也就是说，有的问题适合用名词描述，可以用类的概念，有的适合用不同动词和数据，
这不是很正常吗？

【在 h*i 的大作中提到】

: 其实不用你想象，现在这么多函数式编程的语言和项目，只要睁开眼睛就行。
: 继承和封装都是不好的主意。继承其实是把世界强迫用树来模拟；如果数据是
: immutable的，封装其实不必要。
: 多态的方式可以很多，OOP多态其实限制太大了，只能despatch by class，其实可以
: dispatch by anything.
: 抽象是计算机科学的核心，没有什么计算机技术不是在玩抽象的游戏。但OOP基于名词
: 的抽象的限制太过了，一切都必须成为名词（object, class)，搞成了Kingdom of
: Nouns （https://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-
: nouns.html）.而现实世界名词动词形容词啥都有。
: 如何改动别人的代码，如何多个人做一个项目？用数据啊。就像Internet一样，只要

d*c2017-05-10 07:05

28 楼

读了一段alan kay的争论，感觉他过于偏执了。基本上说光发数据给别人不可信，比喻
说重要事情不能靠发电报，要派个外交官代表。也就是要把数据和负责解释，执行的代
码一起发，也就是代码和数据捆绑，简直到了别人不能解释，必须我自己解释的程度。
如果真的数据必须要自己解释，这样可以，不过有太多情况不是这种需求了。
是屁股决定脑袋，还是盛名之下，其实难副，还是只是时代造就了成就，不是全靠本人
？

h*i2017-05-10 07:05

29 楼

哈哈。我觉得两者都有吧。属于同时是屁股决定脑袋和名不副实。
有时候，死得早也不是坏事。

【在 d******c 的大作中提到】

: 读了一段alan kay的争论，感觉他过于偏执了。基本上说光发数据给别人不可信，比喻
: 说重要事情不能靠发电报，要派个外交官代表。也就是要把数据和负责解释，执行的代
: 码一起发，也就是代码和数据捆绑，简直到了别人不能解释，必须我自己解释的程度。
: 如果真的数据必须要自己解释，这样可以，不过有太多情况不是这种需求了。
: 是屁股决定脑袋，还是盛名之下，其实难副，还是只是时代造就了成就，不是全靠本人
: ？

y*w2017-05-10 07:05

30 楼

精辟

【在 w********m 的大作中提到】

: 你们想多了，OOP的发明者很聪明，知道天才的时代已经过去了，
: 预测到未来软件界的主力来自于东南亚某国。
: 天才还有，比如linus，还有王银，那是可遇不可求。
: 继承是，三哥写了一个上千行的像屎样的class。不要改他的代码，否则他咬死你。继
: 承一下，override几个method，将就着用吧。
: 封装是，要三哥把所有的变量放到class，不要毒害环境。
: 抽象是，三哥好多天偷懒不出货，写个interface要他implement一下。
: 多态是，三哥可以随便瞎写，但得把我的interface实现。
: 没有这些手段，软件很难写。

y*w2017-05-10 07:05

31 楼

c代码写多了, 慢慢就又去自己实现模块封装去了。

【在 N********n 的大作中提到】

: 反对封装的程序员大概没写过C语言的大项目。C的指针可以不受限制满天乱指，
: 用过C的人最怕指针出错。张三的指针出错指到李四的数据上。李四那边发现异
: 常还莫名其妙不知道咋回事，自己的代码查了半天也没找出原因。最后才明白
: 原来是张三的指针撒野搞乱了自己的数据，责任根本不在李四。HOHOHO
: 加封装就是要引入一种安全责任机制，专职代码掌控专项数据。出问题可以快
: 速锁定病源模块，这样做项目才有效率。甩C语言"李四纠张三的错"那种风格
: 几条街。反对封装的八成没吃过C语言的苦。

x*42017-05-10 07:05

32 楼

完全同意。OOP和java就是外包三哥的基础。

【在 w********m 的大作中提到】

: 你们想多了，OOP的发明者很聪明，知道天才的时代已经过去了，
: 预测到未来软件界的主力来自于东南亚某国。
: 天才还有，比如linus，还有王银，那是可遇不可求。
: 继承是，三哥写了一个上千行的像屎样的class。不要改他的代码，否则他咬死你。继
: 承一下，override几个method，将就着用吧。
: 封装是，要三哥把所有的变量放到class，不要毒害环境。
: 抽象是，三哥好多天偷懒不出货，写个interface要他implement一下。
: 多态是，三哥可以随便瞎写，但得把我的interface实现。
: 没有这些手段，软件很难写。

N*n2017-05-10 07:05

33 楼

append
immutable
"IMMUTABLE"概念在C++/C#/JAVA早有了，那些const/readonly/final关键字
就是干这个用的。"IMMUTABLE"不是万能药，因为RACE CONDITION往往是逻辑
上的错误，不是用几个"IMMUTABLE"变量就能避免的。
如果两个操作同时在一个账户上存钱且彼此之间没有任何同步，那这个账户的
数目最终有可能是错的。账目数字就是个“inherently mutable”的东西，解
决的方式就是要写同步机制代码，强制这两个操作在串行状态下执行。逻辑上
问题，不是弄个IMMUTABLE,append-only之类的小trick就能避免的。

【在 h*i 的大作中提到】

: “保证专职模块负责专项数据，安全还有清楚OWNERSHIP”，这些都不需要在程序语言
: 层面搞封装。封装是实现这些的一个手段，如果其弊大于利，那么就不必要。
: 哪有啥是“inherently mutable”的东西。你孤落寡闻了不是，append-only数据库都
: 有不少了，rethinkdb, datomic，这些都是用户很多的。Kafka这种系统，也是append
: -only.
: mutable是为了省硬件省钱，但增加了编程复杂性。现在硬件越来越不值钱，immutable
: 的系统会越来越多。

w*m2017-05-10 07:05

34 楼

这就是data scientist不是一个好职业的原因。
这个行业好像不喜欢OOP。
改别人代码成为一个非常难受的擦屁股的事情。
非常之苦逼。

g*t2017-05-10 07:05

35 楼

F(x)--->Y
在F作用的过程中，输入X不能改。
这就是输入输出分离。
这是电工的活...

: 这就是data scientist不是一个好职业的原因。

: 这个行业好像不喜欢OOP。

: 改别人代码成为一个非常难受的擦屁股的事情。

: 非常之苦逼。

【在 w********m 的大作中提到】

: 这就是data scientist不是一个好职业的原因。
: 这个行业好像不喜欢OOP。
: 改别人代码成为一个非常难受的擦屁股的事情。
: 非常之苦逼。

n*t2017-05-10 07:05

36 楼

這個事情用oop解決不了的啊。

【在 N********n 的大作中提到】

: 反对封装的程序员大概没写过C语言的大项目。C的指针可以不受限制满天乱指，
: 用过C的人最怕指针出错。张三的指针出错指到李四的数据上。李四那边发现异
: 常还莫名其妙不知道咋回事，自己的代码查了半天也没找出原因。最后才明白
: 原来是张三的指针撒野搞乱了自己的数据，责任根本不在李四。HOHOHO
: 加封装就是要引入一种安全责任机制，专职代码掌控专项数据。出问题可以快
: 速锁定病源模块，这样做项目才有效率。甩C语言"李四纠张三的错"那种风格
: 几条街。反对封装的八成没吃过C语言的苦。

h*i2017-05-10 07:05

37 楼

这个immutable数据结构可不是const， readonly这么简单的概念，也不是小trick，可
见你并不理解immutable是啥意思。
immutable不是说不能改东西，而是说，不在*原地*改东西。所谓改东西，其实是产生
一个新东西。在数据库上用，就是append only，在kafka这种东西上用，就叫
persistent queue.
真正在概念上类似的东西，是copy on write，就是不管改什么，都先copy一个，原来
的不变，在copy上面改。当然如果真copy的话，性能是会很差的。所以immutable数据
结构的技术难点就是如何让人在概念上觉得是copy了，但其实没有copy，至少没有全
copy。实现的办法就是所谓的structure sharing，就是用一个树来track改动，只是
copy改动的树的路径。上述的的算法，最早是Bagwell在2000年的一篇文章《Ideal
Hash Tree》提出的： https://infoscience.epfl.ch/record/64398/files/
idealhashtrees.pdf
Clojure和其他FP语言实现这类算法把它实用化，要在几年之后。所以immutable数据结
构，不可能在C++/C#/Java早就有了。
你居然用银行账号做“inherently mutable”的例子，显然不知道这是immutable数据
的一个示范例子，算是immutable数据的killer app.
为什么？因为账目每一次改动，必须都记录在案，改动前的数字，改动后的数字，都必
须记下来，因为要被audit。银行为了在传统数据库上实现这个功能，需要花废很大的
功夫，多花很多的钱。而immutable数据库可以免费提供这个功能，因为它们是append-
only，改动不会把原来的数字给盖了。

【在 N********n 的大作中提到】

:
: append
: immutable
: "IMMUTABLE"概念在C++/C#/JAVA早有了，那些const/readonly/final关键字
: 就是干这个用的。"IMMUTABLE"不是万能药，因为RACE CONDITION往往是逻辑
: 上的错误，不是用几个"IMMUTABLE"变量就能避免的。
: 如果两个操作同时在一个账户上存钱且彼此之间没有任何同步，那这个账户的
: 数目最终有可能是错的。账目数字就是个“inherently mutable”的东西，解
: 决的方式就是要写同步机制代码，强制这两个操作在串行状态下执行。逻辑上
: 问题，不是弄个IMMUTABLE,append-only之类的小trick就能避免的。

N*n2017-05-10 07:05

38 楼

如果有两个存钱操作A和B同时进行。A先读，当A没结束写时B就开始读那么最
终A或者B写进去的数目是错的。数据端存取到底是原地还是APPEND或COPY都
是无用功。
银行账号这种变量在逻辑上是“inherently mutable”，A、B在逻辑上就是
要操作同一个变量。若硬塞给A、B各一个immutable变量让他们互不冲突那逻
辑上就错了。所以我说race condition是逻辑上的问题，不是靠immutable
数据结构拿出来用一下就可以简化编程了。immutable有用但没那么神。

【在 h*i 的大作中提到】

: 这个immutable数据结构可不是const， readonly这么简单的概念，也不是小trick，可
: 见你并不理解immutable是啥意思。
: immutable不是说不能改东西，而是说，不在*原地*改东西。所谓改东西，其实是产生
: 一个新东西。在数据库上用，就是append only，在kafka这种东西上用，就叫
: persistent queue.
: 真正在概念上类似的东西，是copy on write，就是不管改什么，都先copy一个，原来
: 的不变，在copy上面改。当然如果真copy的话，性能是会很差的。所以immutable数据
: 结构的技术难点就是如何让人在概念上觉得是copy了，但其实没有copy，至少没有全
: copy。实现的办法就是所谓的structure sharing，就是用一个树来track改动，只是
: copy改动的树的路径。上述的的算法，最早是Bagwell在2000年的一篇文章《Ideal

h*i2017-05-10 07:05

39 楼

你还是概念不清楚。
你把变量和identity搞混淆了。identity是逻辑上的一个东西。实现一个逻辑上的东西
及其变化，有两种实现办法，1.用一个变量。2.用一个指针来指向immutable的量。
这两种办法，在逻辑上是一样的。变量你懂，我就不讲了。
用immutable的数据如何实现一个identity的变化？具体来说，如何实现一个帐户数目
的变化？简单，用指针啊。变化前，指向immutable数A，变化后，指向imutable数B，
就这么简单。所谓immutable数据结构，其实是在玩指针的游戏。明白了么？
至于同时操作一个帐户怎么做，简单，数据库Transaction怎么做的，这儿也同样的办
法。比如两个操作，同时来，其中一个可能要被roll back的，或者retry。这些与
mutable, immutable是没有关系的，两者做法一样，无非是一个是改数，一个是改指针
指向。

【在 N********n 的大作中提到】

:
: 如果有两个存钱操作A和B同时进行。A先读，当A没结束写时B就开始读那么最
: 终A或者B写进去的数目是错的。数据端存取到底是原地还是APPEND或COPY都
: 是无用功。
: 银行账号这种变量在逻辑上是“inherently mutable”，A、B在逻辑上就是
: 要操作同一个变量。若硬塞给A、B各一个immutable变量让他们互不冲突那逻
: 辑上就错了。所以我说race condition是逻辑上的问题，不是靠immutable
: 数据结构拿出来用一下就可以简化编程了。immutable有用但没那么神。

N*n2017-05-10 07:05

40 楼

A没有完成写之前B就开始。因此A/B都指向原始数据。结果就是A/B之间必然
有一个写错。典型RACE CONDITION。

【在 h*i 的大作中提到】

: 你还是概念不清楚。
: 你把变量和identity搞混淆了。identity是逻辑上的一个东西。实现一个逻辑上的东西
: 及其变化，有两种实现办法，1.用一个变量。2.用一个指针来指向immutable的量。
: 这两种办法，在逻辑上是一样的。变量你懂，我就不讲了。
: 用immutable的数据如何实现一个identity的变化？具体来说，如何实现一个帐户数目
: 的变化？简单，用指针啊。变化前，指向immutable数A，变化后，指向imutable数B，
: 就这么简单。所谓immutable数据结构，其实是在玩指针的游戏。明白了么？
: 至于同时操作一个帐户怎么做，简单，数据库Transaction怎么做的，这儿也同样的办
: 法。比如两个操作，同时来，其中一个可能要被roll back的，或者retry。这些与
: mutable, immutable是没有关系的，两者做法一样，无非是一个是改数，一个是改指针

h*i2017-05-10 07:05

41 楼

race condition和我们讨论的问题没有什么关系。没有人说immutable数据结构是用来
solve race condition的。
我来回顾一下，尝试诊断一下你的思维过程。我在说OOP的封装在数据是immutable的情
况下，会成为不必要的限制。你说没有封装就不能抽象了，我说没有封装也能抽象。
然后你说immutable是const，readonly啥的小trick，不能解决race
condition.。这个跳跃就很奇怪了，如果你的论证试图是说mutable OOP能解决race
condition, immutable不能，那还情有可原，但你又不是在说这个。总之，你随意从一
个问题跳跃到另一个完全无关的问题，说明你的思维方式很不严谨，不适合做技术工作。
稍微发挥一下。很多老中在技术工作中被认为表达能力不强，表面上说是英文不好。我
个人观察，其实不是英文不好，而是思维方式不符合逻辑，其中文表达的能力也不强。
我说的留美学生大多没文化的现象，可能与语言表达能力和思维方式都有关系。所以我
说教育小孩，特别在早期，要重文轻理，否则问题很大。

【在 N********n 的大作中提到】

:
: A没有完成写之前B就开始。因此A/B都指向原始数据。结果就是A/B之间必然
: 有一个写错。典型RACE CONDITION。

b*i2017-05-10 07:05

42 楼

你说得有一定道理。
我感觉像git。还有比特币，存变化。当然如果比特币既存变化又存当前结果就好了。
或者至少每月存一次结果。至少可以把几个月前的信息扔掉。比特币现在几百G，才那
么点人参与。

作。

【在 h*i 的大作中提到】

: race condition和我们讨论的问题没有什么关系。没有人说immutable数据结构是用来
: solve race condition的。
: 我来回顾一下，尝试诊断一下你的思维过程。我在说OOP的封装在数据是immutable的情
: 况下，会成为不必要的限制。你说没有封装就不能抽象了，我说没有封装也能抽象。
: 然后你说immutable是const，readonly啥的小trick，不能解决race
: condition.。这个跳跃就很奇怪了，如果你的论证试图是说mutable OOP能解决race
: condition, immutable不能，那还情有可原，但你又不是在说这个。总之，你随意从一
: 个问题跳跃到另一个完全无关的问题，说明你的思维方式很不严谨，不适合做技术工作。
: 稍微发挥一下。很多老中在技术工作中被认为表达能力不强，表面上说是英文不好。我
: 个人观察，其实不是英文不好，而是思维方式不符合逻辑，其中文表达的能力也不强。

N*n2017-05-10 07:05

43 楼

你先说要搞immutable，我指出很多现实问题的本质是"inherently mutable"
你又说没有所谓的"inherently mutable"，我就拿银行账户做反例，指出存取
账户是典型的"inherently mutable"操作。copy/append/"指针"等immutable
数据结构的小trick在这里没用。

【在 h*i 的大作中提到】

: race condition和我们讨论的问题没有什么关系。没有人说immutable数据结构是用来
: solve race condition的。
: 我来回顾一下，尝试诊断一下你的思维过程。我在说OOP的封装在数据是immutable的情
: 况下，会成为不必要的限制。你说没有封装就不能抽象了，我说没有封装也能抽象。
: 然后你说immutable是const，readonly啥的小trick，不能解决race
: condition.。这个跳跃就很奇怪了，如果你的论证试图是说mutable OOP能解决race
: condition, immutable不能，那还情有可原，但你又不是在说这个。总之，你随意从一
: 个问题跳跃到另一个完全无关的问题，说明你的思维方式很不严谨，不适合做技术工作。
: 稍微发挥一下。很多老中在技术工作中被认为表达能力不强，表面上说是英文不好。我
: 个人观察，其实不是英文不好，而是思维方式不符合逻辑，其中文表达的能力也不强。

h*i2017-05-10 07:05

44 楼

你还是概念不清，混淆了两个我前面已经指出的不同概念：mutable变量，一个客观对
象（identity）的属性的变化，这是两个不同的东西。前者是一个具体的计算机实现，
而后者是一个功能需求。
如果你的“inherently mutable”是指一个对象的属性会发生变化，也就是指一个功能
需求，那么，你提这个“inherently mutable”的东西是不能用来作为immutable数据
的反例的，因为immutable数据也是用来实现这种功能需求的一种方法。
如果你的“inherently mutable”是指mutable变量这个具体实现，那么你是可以提这
个来做反例。但是，你没有提出任何问题是mutable变量能解决，而immutable数据不能
解决的。你提到的银行账号问题，这两个实现都有一样的问题，因此你的论证失败了。
我也是基于你的“inherently mutable”是指mutable变量的假设来说这句“没有什么
是inherently mutable的东西“的。我的意思是说，mutable的变量是现实世界中不存
在的东西，是人想出来的概念，然后用一种计算机实现来模拟的。如果你追根到底，会
发现，就连计算机的mutable的变量，也是用一个地址存不同的东西（i.e. immutable
value）来实现的，这与数学（人脑产物）上的变量不是一回事。
值本身都是immutable的，比如1，就是1， 1不会自己变成其他2. 银行账号A，今天的
value是1，明天是2，其本质，就是A其实是个地址，今天存1这个值，明天存2这个值。
如果世界的本质就是这样，immutable数据就是把这个本质明显化，这样解决实际问题
编程更简单，很多问题，比如如何支持audit等，都不是问题；而mutable变量，想要模
拟一个人为产生的假象，所以解决实际问题编程就更复杂，比如想要audit，那就得搞
一套复杂的机制。

【在 N********n 的大作中提到】

: 你先说要搞immutable，我指出很多现实问题的本质是"inherently mutable"
: 你又说没有所谓的"inherently mutable"，我就拿银行账户做反例，指出存取
: 账户是典型的"inherently mutable"操作。copy/append/"指针"等immutable
: 数据结构的小trick在这里没用。

h*i2017-05-10 07:05

45 楼

immutable数据结构其实不存变化，只存结果，无非是后面的结果并不盖掉以前的结果
而已。新的结果就意味着一个新的reference。
一个东西A，变化之后会产生一个新东西A'。如果有别的部分的代码指向A，就还是指
向A，所谓immutable就是这个意思。不用担心一个东西在本部分代码不知情的情况下被
另一部分代码给改了。如果你想要这个新东西A'，需要外显直接说要A'。
总之目的是把变化搞得很外显，而不像传统编程的变量，变化是隐含的。

【在 b***i 的大作中提到】

: 你说得有一定道理。
: 我感觉像git。还有比特币，存变化。当然如果比特币既存变化又存当前结果就好了。
: 或者至少每月存一次结果。至少可以把几个月前的信息扔掉。比特币现在几百G，才那
: 么点人参与。
:
: 作。

g*t2017-05-10 07:05

46 楼

Immutable的风格要把变化的东西单独拉出来，
作为独立的输入或者信号源吧？这个和simulink一摸一样

: immutable数据结构其实不存变化，只存结果，无非是后面的结果并不盖掉以前
的结果

: 而已。新的结果就意味着一个新的reference。

: 一个东西A，变化之后会产生一个新东西A'。如果有别的部分的代码指向A，就
还是指

: 向A，所谓immutable就是这个意思。不用担心一个东西在本部分代码不知情的情
况下被

: 另一部分代码给改了。如果你想要这个新东西A'，需要外显直接说要A'。

: 总之目的是把变化搞得很外显，而不像传统编程的变量，变化是隐含的。

【在 h*i 的大作中提到】

: immutable数据结构其实不存变化，只存结果，无非是后面的结果并不盖掉以前的结果
: 而已。新的结果就意味着一个新的reference。
: 一个东西A，变化之后会产生一个新东西A'。如果有别的部分的代码指向A，就还是指
: 向A，所谓immutable就是这个意思。不用担心一个东西在本部分代码不知情的情况下被
: 另一部分代码给改了。如果你想要这个新东西A'，需要外显直接说要A'。
: 总之目的是把变化搞得很外显，而不像传统编程的变量，变化是隐含的。

h*i2017-05-10 07:05

47 楼

这也从一个侧面反映了，immutable的风格，其实是和客观物理世界一致的：一个东西
的物理属性如果变化了，它其实就是另一个东西了。至于人还是要把这个新东西要赋予
一个跟以前一样的identity，那是人的主观认知上发生的事情，与客观物理世界无关。
很多情况下，如果物理属性变化太大了，可能人主观上把两个东西赋予同一个identity
都很困难，比如一个人如果作了变性手术，肯定会改名。
归根到底，identity是个主观概念。而编程序，说来说去还是在物理世界里操作，按物
理世界的规则办，事情就要简单一些。

【在 g****t 的大作中提到】

: Immutable的风格要把变化的东西单独拉出来，
: 作为独立的输入或者信号源吧？这个和simulink一摸一样
:
:
: immutable数据结构其实不存变化，只存结果，无非是后面的结果并不盖掉以前
: 的结果
:
: 而已。新的结果就意味着一个新的reference。
:
: 一个东西A，变化之后会产生一个新东西A'。如果有别的部分的代码指向A，就
: 还是指
:
: 向A，所谓immutable就是这个意思。不用担心一个东西在本部分代码不知情的情
: 况下被

g*y2017-05-10 07:05

48 楼

javascript代码千千万，框架天天变，不也越发展越壮大。就是没有oop也有办法

【在 w********m 的大作中提到】

: OOP的目的就是搬砖。
: 不认为自己是搬砖的人都会比较痛苦。
: 但是，没有OOP，砖很难搬的动。
: 很难想象，如果没有继承，封装，多态，抽象这些特性，
: 如何去改动别人的代码，或者多个人做一个项目。

g*y2017-05-10 07:05

49 楼

指针和封装是两个问题。封装了也可以有指针指向任意内存空间，c++不就是这样吗。

【在 N********n 的大作中提到】

: 反对封装的程序员大概没写过C语言的大项目。C的指针可以不受限制满天乱指，
: 用过C的人最怕指针出错。张三的指针出错指到李四的数据上。李四那边发现异
: 常还莫名其妙不知道咋回事，自己的代码查了半天也没找出原因。最后才明白
: 原来是张三的指针撒野搞乱了自己的数据，责任根本不在李四。HOHOHO
: 加封装就是要引入一种安全责任机制，专职代码掌控专项数据。出问题可以快
: 速锁定病源模块，这样做项目才有效率。甩C语言"李四纠张三的错"那种风格
: 几条街。反对封装的八成没吃过C语言的苦。

a*o2017-05-10 07:05

50 楼

这个我不同意。你今天老了一天就不是你了？这只是哲学家的一种思路，不能拿来当真
理。

identity

【在 h*i 的大作中提到】

: 这也从一个侧面反映了，immutable的风格，其实是和客观物理世界一致的：一个东西
: 的物理属性如果变化了，它其实就是另一个东西了。至于人还是要把这个新东西要赋予
: 一个跟以前一样的identity，那是人的主观认知上发生的事情，与客观物理世界无关。
: 很多情况下，如果物理属性变化太大了，可能人主观上把两个东西赋予同一个identity
: 都很困难，比如一个人如果作了变性手术，肯定会改名。
: 归根到底，identity是个主观概念。而编程序，说来说去还是在物理世界里操作，按物
: 理世界的规则办，事情就要简单一些。

d*c2017-05-10 07:05

51 楼

我对你变量和指针的讨论没有不同意见，但如果说“没有mutable”，有点矫枉过正。
对比一下芝诺悖论，你这样实际是把变化全部静态化，说没有变化，只有前后不同的东
西。
要说呢，变化也的确是一个人造出来的概念，需要时间，更需要认定一个事物在不同时
间是同一个东西但又不同，才有变化概念。你可以采用不同的实现方式，不使用这种概
念，但把mutable概念就否定，也有点过头。
作为编程语言要宣传新的计算模式，要强调它的优点，能解决的问题是很自然的，但不
代表这是唯一正确的方式。

【在 h*i 的大作中提到】

: 你还是概念不清，混淆了两个我前面已经指出的不同概念：mutable变量，一个客观对
: 象（identity）的属性的变化，这是两个不同的东西。前者是一个具体的计算机实现，
: 而后者是一个功能需求。
: 如果你的“inherently mutable”是指一个对象的属性会发生变化，也就是指一个功能
: 需求，那么，你提这个“inherently mutable”的东西是不能用来作为immutable数据
: 的反例的，因为immutable数据也是用来实现这种功能需求的一种方法。
: 如果你的“inherently mutable”是指mutable变量这个具体实现，那么你是可以提这
: 个来做反例。但是，你没有提出任何问题是mutable变量能解决，而immutable数据不能
: 解决的。你提到的银行账号问题，这两个实现都有一样的问题，因此你的论证失败了。
: 我也是基于你的“inherently mutable”是指mutable变量的假设来说这句“没有什么

d*c2017-05-10 07:05

52 楼

有太多东西是人想出来的，但也需要去实现。
值也同样是人想出来的，最多有客观事实，但只有人去加工才变成值。
计算机执行程序时根据时钟去执行下一条指令，时钟跟你说的一个地址存不同东西不太
一样吧。

在的东西，是人想出来的概念，然后用一种计算机实现来模拟的。如果你追根到底，会
发现，就连计算机的mutable的变量，也是用一个地址存不同的东西（i.e. immutable
value）来实现的

【在 h*i 的大作中提到】

: 这也从一个侧面反映了，immutable的风格，其实是和客观物理世界一致的：一个东西
: 的物理属性如果变化了，它其实就是另一个东西了。至于人还是要把这个新东西要赋予
: 一个跟以前一样的identity，那是人的主观认知上发生的事情，与客观物理世界无关。
: 很多情况下，如果物理属性变化太大了，可能人主观上把两个东西赋予同一个identity
: 都很困难，比如一个人如果作了变性手术，肯定会改名。
: 归根到底，identity是个主观概念。而编程序，说来说去还是在物理世界里操作，按物
: 理世界的规则办，事情就要简单一些。

d*c2017-05-10 07:05

53 楼

另外R是copy on write，并且尽量避免不必要的copy让这一点不明显。
它的实现有可能比你说的论文要早，不过我不清楚细节，只是乱猜。可能用的不同的实
现方式。

【在 h*i 的大作中提到】

: immutable数据结构其实不存变化，只存结果，无非是后面的结果并不盖掉以前的结果
: 而已。新的结果就意味着一个新的reference。
: 一个东西A，变化之后会产生一个新东西A'。如果有别的部分的代码指向A，就还是指
: 向A，所谓immutable就是这个意思。不用担心一个东西在本部分代码不知情的情况下被
: 另一部分代码给改了。如果你想要这个新东西A'，需要外显直接说要A'。
: 总之目的是把变化搞得很外显，而不像传统编程的变量，变化是隐含的。

d*c2017-05-10 07:05

54 楼

物理世界只是程序应用领域的一部分。
举个例子，我做shiny界面的时候，发现很多时候你要实现对人来说比较自然，比较直
觉的操作在逻辑上是不清晰，复杂的。
用户直觉是历史发展出来的，或者纯粹就是为了用起来比较省事，逻辑上未必是清晰合
理的。
需要你做一些看起来比较丑陋的东西然后让用户用起来比较简单。如果你坚持逻辑上简
单清晰，用户用起来可能要麻烦。
当你的需求就要服从主观概念的时候，你当然就得按主观世界的规则办，你不能去跟用
户说你的直觉逻辑不清晰，那不对。

identity

【在 h*i 的大作中提到】

: 这也从一个侧面反映了，immutable的风格，其实是和客观物理世界一致的：一个东西
: 的物理属性如果变化了，它其实就是另一个东西了。至于人还是要把这个新东西要赋予
: 一个跟以前一样的identity，那是人的主观认知上发生的事情，与客观物理世界无关。
: 很多情况下，如果物理属性变化太大了，可能人主观上把两个东西赋予同一个identity
: 都很困难，比如一个人如果作了变性手术，肯定会改名。
: 归根到底，identity是个主观概念。而编程序，说来说去还是在物理世界里操作，按物
: 理世界的规则办，事情就要简单一些。

h*i2017-05-10 07:05

55 楼

计算机应该是模拟物理世界的，老了的你，在物理上的确不是你了。这两个你在计算机
中的表示，应该是不一样的。
在你的主观上，你还觉得是你，但那是另外一个需要模拟的问题。需要做的，应该是在
上面的两个不同的你的表示的基础上，在用更多的数据来表示这两个东西在你的主观上
，有相同的identity。
把主观和客观两者混淆，貌似简单了，其实给编程增加不必要的复杂性，因为没有反应
出真实情况。
这不是哲学，而是计算机科学，因为我们在试图用计算机准确的模拟现实。

【在 a*******o 的大作中提到】

: 这个我不同意。你今天老了一天就不是你了？这只是哲学家的一种思路，不能拿来当真
: 理。
:
: identity

a*o2017-05-10 07:05

56 楼

我不认为物理学有这种说法。如果你认为有，请拿出证据。一个人或者一个东西，某些
属性是可以改变的。这并不违反任何规律。

【在 h*i 的大作中提到】

: 计算机应该是模拟物理世界的，老了的你，在物理上的确不是你了。这两个你在计算机
: 中的表示，应该是不一样的。
: 在你的主观上，你还觉得是你，但那是另外一个需要模拟的问题。需要做的，应该是在
: 上面的两个不同的你的表示的基础上，在用更多的数据来表示这两个东西在你的主观上
: ，有相同的identity。
: 把主观和客观两者混淆，貌似简单了，其实给编程增加不必要的复杂性，因为没有反应
: 出真实情况。
: 这不是哲学，而是计算机科学，因为我们在试图用计算机准确的模拟现实。

h*i2017-05-10 07:05

57 楼

我的意思很明确，mutable变量是一个shortcut，因为他把客观变化和主观identity混
在一起来实现。
这个shortcut，在很多情况下，是够用的。但是，使用者必须要知道它是个shortcut，
所以有其适用范围。
现在的问题是，绝大部分人不承认它是shortcut，而是认为mutable变量就是真实存在
的。这就没有什么合稀泥的说法能解决这个问题了，只能说，“你是错的”。

【在 d******c 的大作中提到】

: 我对你变量和指针的讨论没有不同意见，但如果说“没有mutable”，有点矫枉过正。
: 对比一下芝诺悖论，你这样实际是把变化全部静态化，说没有变化，只有前后不同的东
: 西。
: 要说呢，变化也的确是一个人造出来的概念，需要时间，更需要认定一个事物在不同时
: 间是同一个东西但又不同，才有变化概念。你可以采用不同的实现方式，不使用这种概
: 念，但把mutable概念就否定，也有点过头。
: 作为编程语言要宣传新的计算模式，要强调它的优点，能解决的问题是很自然的，但不
: 代表这是唯一正确的方式。

a*o2017-05-10 07:05

58 楼

比萨斜塔落下来的石头，它每一秒都变成了一个新的石头？

【在 a*******o 的大作中提到】

: 我不认为物理学有这种说法。如果你认为有，请拿出证据。一个人或者一个东西，某些
: 属性是可以改变的。这并不违反任何规律。

h*i2017-05-10 07:05

59 楼

人主观想出的东西当然也需要去实现。但它需要靠增加新的数据来实现。
这其实是计算机科学解决问题的本质思路，就是，任何问题都靠增加更多的数据来解决
，即所谓抽象。

immutable

【在 d******c 的大作中提到】

: 有太多东西是人想出来的，但也需要去实现。
: 值也同样是人想出来的，最多有客观事实，但只有人去加工才变成值。
: 计算机执行程序时根据时钟去执行下一条指令，时钟跟你说的一个地址存不同东西不太
: 一样吧。
:
: 在的东西，是人想出来的概念，然后用一种计算机实现来模拟的。如果你追根到底，会
: 发现，就连计算机的mutable的变量，也是用一个地址存不同的东西（i.e. immutable
: value）来实现的

h*i2017-05-10 07:05

60 楼

我们在讨论计算机如何实现的问题。主观世界当然也需要模拟，但那需要更多的数据去
模拟，而不是靠混淆主观和客观。混淆了，貌似简单了，其实计算机实现起来更难，
这就是我的主要论点。
这就是为什么很多人一但用了FP，就再不愿意回去了，这种难易对比的体会是非常深切
的。

【在 d******c 的大作中提到】

: 物理世界只是程序应用领域的一部分。
: 举个例子，我做shiny界面的时候，发现很多时候你要实现对人来说比较自然，比较直
: 觉的操作在逻辑上是不清晰，复杂的。
: 用户直觉是历史发展出来的，或者纯粹就是为了用起来比较省事，逻辑上未必是清晰合
: 理的。
: 需要你做一些看起来比较丑陋的东西然后让用户用起来比较简单。如果你坚持逻辑上简
: 单清晰，用户用起来可能要麻烦。
: 当你的需求就要服从主观概念的时候，你当然就得按主观世界的规则办，你不能去跟用
: 户说你的直觉逻辑不清晰，那不对。
:

a*o2017-05-10 07:05

61 楼

我不反对FP，但是不同意 immutable 反映客观世界的本质。没必要扯那么远。就事论
事比较好。

【在 h*i 的大作中提到】

: 我们在讨论计算机如何实现的问题。主观世界当然也需要模拟，但那需要更多的数据去
: 模拟，而不是靠混淆主观和客观。混淆了，貌似简单了，其实计算机实现起来更难，
: 这就是我的主要论点。
: 这就是为什么很多人一但用了FP，就再不愿意回去了，这种难易对比的体会是非常深切
: 的。

h*i2017-05-10 07:05

62 楼

物理学有什么说法不是我讨论的问题，我在讨论计算机问题，计算机科学不是物理学的
实现。
物理学是对物理世界的一种模拟，是人的对世界的主观认识的一种。
计算机科学是对物理世界和主观世界的模拟，是另一种对世界的主观认识。
上面两种模拟可以相互借鉴，但是相互独立的。
我讨论的问题是，“东西有属性，属性会变”，这种观点，在计算机上如何实现的问题
。我推荐的实现办法，是更符合计算机科学的对世界的主观认识的。至于物理学如何认
识，不在讨论范围之内。
计算机科学的主要方法就是抽象，就是在数据上加更多数据，一切可以有表征的东西，
都用数据来表征: “Solve any problem with an extra level of indirection"

【在 a*******o 的大作中提到】

: 我不认为物理学有这种说法。如果你认为有，请拿出证据。一个人或者一个东西，某些
: 属性是可以改变的。这并不违反任何规律。

h*i2017-05-10 07:05

63 楼

不同的学科，对客观世界的本质有不同的认识，因为侧重不同，这没有什么奇怪的。
不要以为物理学就是客观世界的本质，它只是人对客观世界的本质的某一方面的一种主
观认识而已。
计算机科学可以对客观世界的本质有自己的不同的认识，我这是就事论事，因为我论的
是计算机科学的事。扯到物理学才是扯得太远了。

【在 a*******o 的大作中提到】

: 我不反对FP，但是不同意 immutable 反映客观世界的本质。没必要扯那么远。就事论
: 事比较好。

h*i2017-05-10 07:05

64 楼

如果要用计算机来模拟，那是的，每次变化在计算机里面都应该有新的表征。

【在 a*******o 的大作中提到】

: 比萨斜塔落下来的石头，它每一秒都变成了一个新的石头？

h*i2017-05-10 07:05

65 楼

R的数据不是immutable的，还是change in place。
你说的可能是R的object system的实现用copy on write吧？
immutable重要的是在*概念*上要copy on write，而且前后两个copy都是accessible的
，相互独立，是两个不同的东西。实现上，实用的算法和数据结构是2000以后才开始出
现的，现在也不时有新东西出来。
R并没有这样的概念吧。

【在 d******c 的大作中提到】

: 另外R是copy on write，并且尽量避免不必要的copy让这一点不明显。
: 它的实现有可能比你说的论文要早，不过我不清楚细节，只是乱猜。可能用的不同的实
: 现方式。

g*t2017-05-10 07:05

66 楼

理论上讲， immutable是没问题的。任何一个数学家物理学家定义Map f:x-->y,都不可
能允许f去改x的。所以functional 的思路做任何软件在理论上都没问题。
但是现实上一个很大的困难一是操作系统call back之类的
东西。
二是自然语言描述的和现实世界的需求分析。
这些东西的命名和api定义什么的，不是stateless的。
最简单的一个例子。例如一个button的颜色。
这个颜色在白天是white,晚上是black.
Functional的想法的话，这个颜色是一个函数的return value.
后续因这个颜色引起的变化用函数的组合解决。
非functional的想法，这是个可变的变量。后续查这个变量
的值就好。这两种办法，我想不少人第一时间会
倾向于后者。
当然这些困难都可以通过中间层解析成functional 的
，然后加一层软件。但这个risk/reward只能是case by case
的看了。

: 如果要用计算机来模拟，那是的，每次变化在计算机里面都应该有新的表征。

【在 h*i 的大作中提到】

: R的数据不是immutable的，还是change in place。
: 你说的可能是R的object system的实现用copy on write吧？
: immutable重要的是在*概念*上要copy on write，而且前后两个copy都是accessible的
: ，相互独立，是两个不同的东西。实现上，实用的算法和数据结构是2000以后才开始出
: 现的，现在也不时有新东西出来。
: R并没有这样的概念吧。

g*t2017-05-10 07:05

67 楼

另外还一个问题。
Fp做数学物理模型，以及信号处理模型是天生一致的。
但是现实世界的很多问题，不像数学物理的方法那样，
追求的是回答。我们可以追求解决和克服。
换句话说，数学物理模型本质上，
问题和答案是分开的。
西方现代这个哲学的好处是容易scale up.西方科学的扩散和病毒是类似的。
但是我们东方或者西方后现代有别的哲学。问题和答案，不是可分的。
对问题，可以不追求解答，而是追求解决。回答并不是解决问题的单一路径，也不可能
是单一路径。因为你一旦选定了
回答这个办法，约束就上来了。
问题和答案是一个时间内演进的共同体。问题解决后，
形成另一种逻辑。就好比历史的逻辑，战争的逻辑，
界面设计的逻辑等等。这些不是数学物理覆盖的。

: 理论上讲， immutable是没问题的。任何一个数学家物理学家定义Map f:
x--

【在 g****t 的大作中提到】

: 理论上讲， immutable是没问题的。任何一个数学家物理学家定义Map f:x-->y,都不可
: 能允许f去改x的。所以functional 的思路做任何软件在理论上都没问题。
: 但是现实上一个很大的困难一是操作系统call back之类的
: 东西。
: 二是自然语言描述的和现实世界的需求分析。
: 这些东西的命名和api定义什么的，不是stateless的。
: 最简单的一个例子。例如一个button的颜色。
: 这个颜色在白天是white,晚上是black.
: Functional的想法的话，这个颜色是一个函数的return value.
: 后续因这个颜色引起的变化用函数的组合解决。

h*i2017-05-10 07:05

68 楼

"imperative programming is more intuitive"这没有任何证据，是个经常被重复的
myth.
这个话题我以前跟大家争论过多次了，就不重复了。两个观点：
1. 这是因人而异的。比如我自己，比如wdong的小孩，都觉得变量不容易理解。我不排
除可能有人会觉得变量很好理解的。我假设这是两种不同的人。
2. 这是acquired taste. 大部分程序员都是学imperative programming出生的，学出
了bias。所以其实不是它更简单直观，而是更熟悉。

【在 g****t 的大作中提到】

: 理论上讲， immutable是没问题的。任何一个数学家物理学家定义Map f:x-->y,都不可
: 能允许f去改x的。所以functional 的思路做任何软件在理论上都没问题。
: 但是现实上一个很大的困难一是操作系统call back之类的
: 东西。
: 二是自然语言描述的和现实世界的需求分析。
: 这些东西的命名和api定义什么的，不是stateless的。
: 最简单的一个例子。例如一个button的颜色。
: 这个颜色在白天是white,晚上是black.
: Functional的想法的话，这个颜色是一个函数的return value.
: 后续因这个颜色引起的变化用函数的组合解决。

g*t2017-05-10 07:05

69 楼

我的意思是，操作系统本身就包装成非fp的。
另外一个困难，需求分析的自然语言很多地方是非fp的。
人们很多时候想的是自动化一下重复操作，想到的是procedure,不是函数。
Acquired taste这个肯定有。我们电工普遍都是懂
输入输出隔离的。电路图是一块一块分开的。后面的
尽可能不影响前面。
我自己写程序都是尽可能输入输出隔离。

: "imperative programming is more intuitive"这没有任何证
据，是个经常被重
复的

: myth.

: 这个话题我以前跟大家争论过多次了，就不重复了。两个观点：

: 1. 这是因人而异的。比如我自己，比如wdong的小孩，都觉得变量不容易
理解。
我不排

: 除可能有人会觉得变量很好理解的。我假设这是两种不同的人。

: 2. 这是acquired taste. 大部分程序员都是学imperative programming
出生的
，学出

: 了bias。所以其实不是它更简单直观，而是更熟悉。

【在 h*i 的大作中提到】

: "imperative programming is more intuitive"这没有任何证据，是个经常被重复的
: myth.
: 这个话题我以前跟大家争论过多次了，就不重复了。两个观点：
: 1. 这是因人而异的。比如我自己，比如wdong的小孩，都觉得变量不容易理解。我不排
: 除可能有人会觉得变量很好理解的。我假设这是两种不同的人。
: 2. 这是acquired taste. 大部分程序员都是学imperative programming出生的，学出
: 了bias。所以其实不是它更简单直观，而是更熟悉。

m*u2017-05-10 07:05

70 楼

无论那种搞法，编程无非就是把一个解决某个问题的数学方法翻译成计算机的某种/某
几种“语言”而已，不管是FP也好，还是狗P也好，都是个“特色”而已，把它们放那
么高，眼界啊。。。

a*o2017-05-10 07:05

71 楼

我提物理学是想搞清楚你的参照是什么。计算机怎么表现客观世界就没有一个统一的理
论。用一个否定另一个很难说服别人。从科学的角度，我从来没有看到明确的理论说同
一个人不同年纪就是两个不同人。

【在 h*i 的大作中提到】

: 不同的学科，对客观世界的本质有不同的认识，因为侧重不同，这没有什么奇怪的。
: 不要以为物理学就是客观世界的本质，它只是人对客观世界的本质的某一方面的一种主
: 观认识而已。
: 计算机科学可以对客观世界的本质有自己的不同的认识，我这是就事论事，因为我论的
: 是计算机科学的事。扯到物理学才是扯得太远了。

g*t2017-05-10 07:05

72 楼

你迟早也会碰到类似问题的。
要还是不要reference transpancy
这不是个小问题

: 无论那种搞法，编程无非就是把一个解决某个问题的数学方法翻译成计算机的某
种/某

: 几种“语言”而已，不管是FP也好，还是狗P也好，都是个“特色”而已，把它
们放那

: 么高，眼界啊。。。

【在 m**u 的大作中提到】

: 无论那种搞法，编程无非就是把一个解决某个问题的数学方法翻译成计算机的某种/某
: 几种“语言”而已，不管是FP也好，还是狗P也好，都是个“特色”而已，把它们放那
: 么高，眼界啊。。。

h*i2017-05-10 07:05

73 楼

需求分析的自然语言是非FP的。举个例子？
procedure怎么不是函数了？函数不就是动词么，用来描述procedure不是很直接么。

【在 g****t 的大作中提到】

: 我的意思是，操作系统本身就包装成非fp的。
: 另外一个困难，需求分析的自然语言很多地方是非fp的。
: 人们很多时候想的是自动化一下重复操作，想到的是procedure,不是函数。
: Acquired taste这个肯定有。我们电工普遍都是懂
: 输入输出隔离的。电路图是一块一块分开的。后面的
: 尽可能不影响前面。
: 我自己写程序都是尽可能输入输出隔离。
:
:
: "imperative programming is more intuitive"这没有任何证
: 据，是个经常被重

g*t2017-05-10 07:05

74 楼

你可以认为同一个人不同年龄是同一个人。
那把人当作函数就可以了。不要当变量。
人就是一个输出嘛

: 我提物理学是想搞清楚你的参照是什么。计算机怎么表现客观世界就没有一个统
一的理

: 论。用一个否定另一个很难说服别人。从科学的角度，我从来没有看到明确的理
论说同

: 一个人不同年纪就是两个不同人。

【在 a*******o 的大作中提到】

: 我提物理学是想搞清楚你的参照是什么。计算机怎么表现客观世界就没有一个统一的理
: 论。用一个否定另一个很难说服别人。从科学的角度，我从来没有看到明确的理论说同
: 一个人不同年纪就是两个不同人。

h*i2017-05-10 07:05

75 楼

参照就是计算机科学。
正因为没有统一的理论，才可以争论嘛。都统一了，大家就只需要讨论学习心得了。
你以前没看到这个明确的理论，现在看到了吧？

【在 a*******o 的大作中提到】

: 我提物理学是想搞清楚你的参照是什么。计算机怎么表现客观世界就没有一个统一的理
: 论。用一个否定另一个很难说服别人。从科学的角度，我从来没有看到明确的理论说同
: 一个人不同年纪就是两个不同人。

g*t2017-05-10 07:05

76 楼

例如股市价格的颜色。有红有绿。
这个颜色定义成变量，还是定义成一个函数的
按涨跌的输出呢？
定义成变量的好处是，
万一将来这个颜色将来不按数学规律变了。
也可以容纳。简单说，变量就是假设成可以不讲理随便变的
一个函数。混乱是肯定的。但是表达能力强。

: 需求分析的自然语言是非FP的。举个例子？

: procedure怎么不是函数了？函数不就是动词么，用来描述procedure不是
很直接
么。

【在 h*i 的大作中提到】

: 参照就是计算机科学。
: 正因为没有统一的理论，才可以争论嘛。都统一了，大家就只需要讨论学习心得了。
: 你以前没看到这个明确的理论，现在看到了吧？

h*i2017-05-10 07:05

77 楼

guvest悟性刚刚的。
说“一个人长了一岁，其实还是同一个人”，应该表达为：
(=（person-identity X) (person-identity (grow X)))
这样就没有任何信息丧失，完美用计算机表达了一切需要表达的东西。

【在 g****t 的大作中提到】

: 你可以认为同一个人不同年龄是同一个人。
: 那把人当作函数就可以了。不要当变量。
: 人就是一个输出嘛
:
:
: 我提物理学是想搞清楚你的参照是什么。计算机怎么表现客观世界就没有一个统
: 一的理
:
: 论。用一个否定另一个很难说服别人。从科学的角度，我从来没有看到明确的理
: 论说同
:
: 一个人不同年纪就是两个不同人。
:

h*i2017-05-10 07:05

78 楼

问题是变量不是函数。
如果一个函数是“不讲理随便变的”，其表达能力为零
【在 g****t 的大作中提到】

: 例如股市价格的颜色。有红有绿。
: 这个颜色定义成变量，还是定义成一个函数的
: 按涨跌的输出呢？
: 定义成变量的好处是，
: 万一将来这个颜色将来不按数学规律变了。
: 也可以容纳。简单说，变量就是假设成可以不讲理随便变的
: 一个函数。混乱是肯定的。但是表达能力强。
:
:
: 需求分析的自然语言是非FP的。举个例子？
:
: procedure怎么不是函数了？函数不就是动词么，用来描述procedure不是

g*t2017-05-10 07:05

79 楼

按immutable 的想法，计算机科学可以打到底，这个是没问题的。

: guvest悟性刚刚的。

: 说“一个人长了一岁，其实还是同一个人”，应该表达为：

: (=（person-identity X) (person-identity (grow X)))

: 这样就没有任何信息丧失，完美用计算机表达了一切需要表达的东西。

【在 h*i 的大作中提到】

: 问题是变量不是函数。
: 如果一个函数是“不讲理随便变的”，其表达能力为零

g*t2017-05-10 07:05

80 楼

对。我说的就是这一点。变量就是可以不讲理随便改的。
也好也不好。

: 问题是变量不是函数。

: 如果一个函数是“不讲理随便变的”，其表达能力为零

【在 h*i 的大作中提到】

: 问题是变量不是函数。
: 如果一个函数是“不讲理随便变的”，其表达能力为零

N*n2017-05-10 07:05

81 楼

identity啥的都是说辞。其实就是FP/immutable没那么神。race condition
导致处理mutable问题很复杂。immutable号称可以简化编程。那好，OOP靠边
站，请FP露一手吧。用immutable方式操作银行账户，把原地操作换成FP指定
的copy/append，楼上折腾半天结果连基本的存储操作都搞错。mutable环境下
头疼的RC问题换immutable照样没招，那些copy/append都是无用功。
至于保存immutable数据做audit，那不就是版本控制么。那是软件系统需求，
跟程序语言有啥关系？常用的github / svm / tfs / cvs / perforce 就是
典型的immutable存储。需要的话OOP照样写一个，又不是FP独有的概念。
世界上不是一切都是mutable，但也不是一切都immutable。你开车去加油站，
你的油箱是变成新油箱了，还是就在原箱加满油？你的车轮每转一圈就被复制
成新轮子了，还是原来的老轮子？凡事量身而做，把immutable当成真理然后去
生搬硬套，那是书呆子本末倒置闹笑话。

【在 h*i 的大作中提到】

: 你还是概念不清，混淆了两个我前面已经指出的不同概念：mutable变量，一个客观对
: 象（identity）的属性的变化，这是两个不同的东西。前者是一个具体的计算机实现，
: 而后者是一个功能需求。
: 如果你的“inherently mutable”是指一个对象的属性会发生变化，也就是指一个功能
: 需求，那么，你提这个“inherently mutable”的东西是不能用来作为immutable数据
: 的反例的，因为immutable数据也是用来实现这种功能需求的一种方法。
: 如果你的“inherently mutable”是指mutable变量这个具体实现，那么你是可以提这
: 个来做反例。但是，你没有提出任何问题是mutable变量能解决，而immutable数据不能
: 解决的。你提到的银行账号问题，这两个实现都有一样的问题，因此你的论证失败了。
: 我也是基于你的“inherently mutable”是指mutable变量的假设来说这句“没有什么

h*i2017-05-10 07:05

82 楼

我说immutable让很多编程问题更简单。然后你提出一个编程问题，是immutable与
mutable都有同样的毛病的，这能说明什么呢？如果你认为这就成了immutable不行的“
反例”（你的用词），说明你逻辑思维能力不行。
在计算机上表示加满油的油箱，与空的油箱，必须要用两个不同的数据表征，这没有任
何问题。你提这个来说明immutable是不对的，再次证明你思维有点乱。因为你主观上
觉得这是同一个油箱，与在计算机上需要把他们表示为两个不同的油箱，是没有关系的
。我们在讨论计算机上如何表示更好。

【在 N********n 的大作中提到】

:
: identity啥的都是说辞。其实就是FP/immutable没那么神。race condition
: 导致处理mutable问题很复杂。immutable号称可以简化编程。那好，OOP靠边
: 站，请FP露一手吧。用immutable方式操作银行账户，把原地操作换成FP指定
: 的copy/append，楼上折腾半天结果连基本的存储操作都搞错。mutable环境下
: 头疼的RC问题换immutable照样没招，那些copy/append都是无用功。
: 至于保存immutable数据做audit，那不就是版本控制么。那是软件系统需求，
: 跟程序语言有啥关系？常用的github / svm / tfs / cvs / perforce 就是
: 典型的immutable存储。需要的话OOP照样写一个，又不是FP独有的概念。
: 世界上不是一切都是mutable，但也不是一切都immutable。你开车去加油站，

g*t2017-05-10 07:05

83 楼

所有的数学书，物理书里面的map 都是不改
变量的，函数内也没有状态一说，immutable的思路不能轻视。
从实践来讲。我多年前写的有的code因为是reference transpancy,避免过一次编译器
重大事故。我并不知道什么是fp.
所以我个人看法，凡是明确描述数学物理模型的
代码，尽量和数学定义的函数一致。这样避免自造轮子。
如果需要算法
变种，用别的办法lift up到高一层，不要两种函数混一起。

: identity啥的都是说辞。其实就是FP/immutable没那么神。race
condition

: 导致处理mutable问题很复杂。immutable号称可以简化编程。那好，OOP
靠边

: 站，请FP露一手吧。用immutable方式操作银行账户，把原地操作换成FP
指定

: 的copy/append，楼上折腾半天结果连基本的存储操作都搞错。mutable环
境下

: 头疼的RC问题换immutable照样没招，那些copy/append都是无用功。

: 至于保存immutable数据做audit，那不就是版本控制么。那是软件系统需
求，

: 跟程序语言有啥关系？常用的github / svm / tfs / cvs / perforce 就是

: 典型的immutable存储。需要的话OOP照样写一个，又不是FP独有的概念。

: 世界上不是一切都是mutable，但也不是一切都immutable。你开车去加油
站，

: 你的油箱是变成新油箱了，还是就在原箱加满油？你的车轮每转一圈就被
复制

【在 N********n 的大作中提到】

:
: identity啥的都是说辞。其实就是FP/immutable没那么神。race condition
: 导致处理mutable问题很复杂。immutable号称可以简化编程。那好，OOP靠边
: 站，请FP露一手吧。用immutable方式操作银行账户，把原地操作换成FP指定
: 的copy/append，楼上折腾半天结果连基本的存储操作都搞错。mutable环境下
: 头疼的RC问题换immutable照样没招，那些copy/append都是无用功。
: 至于保存immutable数据做audit，那不就是版本控制么。那是软件系统需求，
: 跟程序语言有啥关系？常用的github / svm / tfs / cvs / perforce 就是
: 典型的immutable存储。需要的话OOP照样写一个，又不是FP独有的概念。
: 世界上不是一切都是mutable，但也不是一切都immutable。你开车去加油站，

a*o2017-05-10 07:05

84 楼

看到了:-D 只是你的看法而已。把这个当成大家一致同意的公理出发去讨论，难免让人
怀疑你整个的理论，因为你的根基别人就不一定认同。

【在 h*i 的大作中提到】

: 参照就是计算机科学。
: 正因为没有统一的理论，才可以争论嘛。都统一了，大家就只需要讨论学习心得了。
: 你以前没看到这个明确的理论，现在看到了吧？

c*e2017-05-10 07:05

85 楼

Rich Hickey拿过什么奖？

【在 h*i 的大作中提到】

: 面向数据的编程（data oriented programming）就是把程序的逻辑用数据结构表达。
: 这其实在分布式计算
: 已经用得很多了，各种逻辑可以变成数据结构在节点间传来传去。而Clojure社区现在
: 意识到，其实单机程序也可以这样写。一个逻辑，能用数据机构表达的，就用数据结构
: 表达，这样更灵活。
: 这个关于data的地位的问题，Alan Kay（就是因为Smalltalk拿图灵奖那位，面向对象
: 的编程的祖师爷）与Rich
: Hickey（就是发明Clojure的那个民科）还在hackernews上有一个争论https://news.
: ycombinator.com/item?id=11945722)。前者认为"Data is a bad idea", 因为data总
: 是需要一个interpreter。后者认为Data是客观存在的，是第一位的，如何interpret是

h*i2017-05-10 07:05

86 楼

哪有啥奖。学音乐出生的，在SUNY的一个社区大学学过点CS，有没有CS本科文凭都不知
道。一直做程序员，喜欢自己看书看文献琢磨而已。所以我说是民科嘛。不过计算机这
个行当，其实是个实践性很强的学科。象牙塔里的东西，往往不如第一手实践中出来的
东西好用。Rich Hickey的很多讲座，在程序员社区是深得群众认同的，觉得点到了痛
处。
Alan Kay这种在研究院的，其实没啥实践经验，做的工作，往往是为求新而求新，不是
出于真实需要。往往是先有个观点，然后做系统来验证，力图往下走，看能走多远。当
然作研究这样无可厚非。

【在 c*********e 的大作中提到】

: Rich Hickey拿过什么奖？

c*e2017-05-10 07:05

87 楼

你还别说，我朋友一公司，找的几个程序员，都是bootcamp出身。和和

【在 h*i 的大作中提到】

: 哪有啥奖。学音乐出生的，在SUNY的一个社区大学学过点CS，有没有CS本科文凭都不知
: 道。一直做程序员，喜欢自己看书看文献琢磨而已。所以我说是民科嘛。不过计算机这
: 个行当，其实是个实践性很强的学科。象牙塔里的东西，往往不如第一手实践中出来的
: 东西好用。Rich Hickey的很多讲座，在程序员社区是深得群众认同的，觉得点到了痛
: 处。
: Alan Kay这种在研究院的，其实没啥实践经验，做的工作，往往是为求新而求新，不是
: 出于真实需要。往往是先有个观点，然后做系统来验证，力图往下走，看能走多远。当
: 然作研究这样无可厚非。

a*o2017-05-10 07:05

88 楼

Alan Kay 的经历非常丰富，发明了图形用户界面，OOP, SmallTalk。似乎也是笔记本
电脑发明者之一，在Atari, Apple都干过。怎么在你这儿变成学院派了。
下面是从维基节选
为了发展Dynabook, 艾伦甚至发明了Smalltalk编程语言，Smalltalk吸取了Simula的
class的概念，并发展出图形使用者界面（GUI）[2]，即是苹果麦金塔电脑的原型。
1970年，鲍勃·泰勒成立PARC研究中心，阿伦·凯成为第一个雇员，他建立学习研究工
作组（LRC），并参与Alto计算机的开发。1972年，PARC发布了Smalltalk的第一个版本
。1979年，凯邀请乔布斯、Teff Raskin 来到PARC参观，乔布斯对视窗图形用户界面印
象深刻。
1983年，凯离开全录，担任Atari公司首席科学家兼副总裁。1984年，阿伦·凯加盟苹
果的ATG ( Advanced Technology Group )。1996年，阿伦·凯加入了迪斯尼公司，任
Imagineering公司的副总裁，开发Squeak软件。

【在 h*i 的大作中提到】

: 哪有啥奖。学音乐出生的，在SUNY的一个社区大学学过点CS，有没有CS本科文凭都不知
: 道。一直做程序员，喜欢自己看书看文献琢磨而已。所以我说是民科嘛。不过计算机这
: 个行当，其实是个实践性很强的学科。象牙塔里的东西，往往不如第一手实践中出来的
: 东西好用。Rich Hickey的很多讲座，在程序员社区是深得群众认同的，觉得点到了痛
: 处。
: Alan Kay这种在研究院的，其实没啥实践经验，做的工作，往往是为求新而求新，不是
: 出于真实需要。往往是先有个观点，然后做系统来验证，力图往下走，看能走多远。当
: 然作研究这样无可厚非。

d*c2017-05-10 07:05

89 楼

不太清楚你说的“数据”是指什么。
R算function programming language
john chambers 有几句话
Everything that exists in R is an object.
Everything that happens in R is a function call.
你说的object sytem是指OO实现吗？R应该几乎所有东西都是copy on modify/write的
，看这个讨论
http://stackoverflow.com/questions/15759117/what-exactly-is-copy-on-modify-semantics-in-r-and-where-is-the-canonical-source
data.table不是，因为它专门避免copy来节省内存和提高性能。

【在 h*i 的大作中提到】

: R的数据不是immutable的，还是change in place。
: 你说的可能是R的object system的实现用copy on write吧？
: immutable重要的是在*概念*上要copy on write，而且前后两个copy都是accessible的
: ，相互独立，是两个不同的东西。实现上，实用的算法和数据结构是2000以后才开始出
: 现的，现在也不时有新东西出来。
: R并没有这样的概念吧。

h*i2017-05-10 07:05

90 楼

PARC不是学院派是啥。PARC当然作了很多东西，他们想做啥就做啥，作的东西Xerox从
来也没用过啊，这还不是学院派还要怎么才算学院派？我觉得他们比大学教授还要学院
派，起码大学教授还要看NSF，DARPA的需求，PARC是谁的需求都不需要看。不要太爽。
可惜PARC这种学院派现在是再也不存在了，时代不同了。
Apple，哈哈，Jobs回来可是把整个研究院给cut了。当年我在研究院混的时候，可有不
少同事是apple研究院逃来的，这些人都是Alan的手下。这些人的风格，与上面我对他
的描述是完全一致的。我可没说这是啥坏事，我自己在研究院混的时候的风格，也是这
样的。哈哈。

【在 a*******o 的大作中提到】

: Alan Kay 的经历非常丰富，发明了图形用户界面，OOP, SmallTalk。似乎也是笔记本
: 电脑发明者之一，在Atari, Apple都干过。怎么在你这儿变成学院派了。
: 下面是从维基节选
: 为了发展Dynabook, 艾伦甚至发明了Smalltalk编程语言，Smalltalk吸取了Simula的
: class的概念，并发展出图形使用者界面（GUI）[2]，即是苹果麦金塔电脑的原型。
: 1970年，鲍勃·泰勒成立PARC研究中心，阿伦·凯成为第一个雇员，他建立学习研究工
: 作组（LRC），并参与Alto计算机的开发。1972年，PARC发布了Smalltalk的第一个版本
: 。1979年，凯邀请乔布斯、Teff Raskin 来到PARC参观，乔布斯对视窗图形用户界面印
: 象深刻。
: 1983年，凯离开全录，担任Atari公司首席科学家兼副总裁。1984年，阿伦·凯加盟苹

h*i2017-05-10 07:05

91 楼

R programming还是基于赋值的，results 在纯FP里面，一般编程不赋值。immutable数据，不能赋值。如果你没用过，可能想象
不出不能赋值怎么编程。哈哈。
R的作者后悔没干脆把R搞成Lisp来着，所以他有FP的倾向，但R不是FP的语言。
Lisp不一定是纯FP的，common lisp, scheme, 这些Lisp，大都还是基于赋值的编程，
不是FP为主的。数据还是mutable的。
Clojure是FP为主的，因为是immutable by default

【在 d******c 的大作中提到】

: 不太清楚你说的“数据”是指什么。
: R算function programming language
: john chambers 有几句话
: Everything that exists in R is an object.
: Everything that happens in R is a function call.
: 你说的object sytem是指OO实现吗？R应该几乎所有东西都是copy on modify/write的
: ，看这个讨论
: http://stackoverflow.com/questions/15759117/what-exactly-is-copy-on-modify-semantics-in-r-and-where-is-the-canonical-source
: data.table不是，因为它专门避免copy来节省内存和提高性能。

a*o2017-05-10 07:05

92 楼

反正你说啥就是啥。也不需要证明。大伙就闭上脑子听着就是了。

h*i2017-05-10 07:05

93 楼

其实不难，只说自己知道的事情，不知道的事情不参与，不评论，这样就没人能说得过
你。
大家都这样的话，是不是世界会更美好？

【在 a*******o 的大作中提到】

: 反正你说啥就是啥。也不需要证明。大伙就闭上脑子听着就是了。

T*x2017-05-10 07:05

94 楼

请展开说一下抽象就是数据上累加数据？这和我理解的抽象不一样。

【在 h*i 的大作中提到】

: 其实不难，只说自己知道的事情，不知道的事情不参与，不评论，这样就没人能说得过
: 你。
: 大家都这样的话，是不是世界会更美好？

h*i2017-05-10 07:05

95 楼

说说你理解的抽象。

【在 T*******x 的大作中提到】

: 请展开说一下抽象就是数据上累加数据？这和我理解的抽象不一样。

j*w2017-05-10 07:05

96 楼

现在有什么大型软件系统是用面向数据的编程模式编写的吗？所有的东西都要实践检验
来决定到底好不好。历史上有很多吹的天花乱坠的模式，最后都被实践抛弃了。最基本
的C语言，没有OO，没有FP，没有bullshit，却好好的活了四十多年，而且还没有要完
蛋的迹象。

【在 h*i 的大作中提到】

: 我说immutable让很多编程问题更简单。然后你提出一个编程问题，是immutable与
: mutable都有同样的毛病的，这能说明什么呢？如果你认为这就成了immutable不行的“
: 反例”（你的用词），说明你逻辑思维能力不行。
: 在计算机上表示加满油的油箱，与空的油箱，必须要用两个不同的数据表征，这没有任
: 何问题。你提这个来说明immutable是不对的，再次证明你思维有点乱。因为你主观上
: 觉得这是同一个油箱，与在计算机上需要把他们表示为两个不同的油箱，是没有关系的
: 。我们在讨论计算机上如何表示更好。

g*t2017-05-10 07:05

97 楼

c有fp.
For example, 古代拆行拆列重用内存。
在现代谁家的c矩阵求逆，改送进来的矩阵？
这不就是immutable嘛

【在 j***w 的大作中提到】

: 现在有什么大型软件系统是用面向数据的编程模式编写的吗？所有的东西都要实践检验
: 来决定到底好不好。历史上有很多吹的天花乱坠的模式，最后都被实践抛弃了。最基本
: 的C语言，没有OO，没有FP，没有bullshit，却好好的活了四十多年，而且还没有要完
: 蛋的迹象。

w*g2017-05-10 07:05

98 楼

其实C++的boost里早该有纯functional的数据结构库了。
这事情就是没人去做。

【在 g****t 的大作中提到】

: c有fp.
: For example, 古代拆行拆列重用内存。
: 在现代谁家的c矩阵求逆，改送进来的矩阵？
: 这不就是immutable嘛

d*c2017-05-10 07:05

99 楼

对，R不算pure FP，但比一般过程语言更加FP一些。
看过一点FP的东西，对于追求纯FP觉得有点偏离现实，没有副作用，打印都打印不了吧
？好像也可以找些办法来实现，但是各种绕
有的领域纯FP的优点比较明显，所以用的也多一些。但这不是纯FP一定比非FP更优越，
而是更适合问题。
我觉得纯FP还是有点限制太多。

【在 h*i 的大作中提到】

: R programming还是基于赋值的，results : 在纯FP里面，一般编程不赋值。immutable数据，不能赋值。如果你没用过，可能想象
: 不出不能赋值怎么编程。哈哈。
: R的作者后悔没干脆把R搞成Lisp来着，所以他有FP的倾向，但R不是FP的语言。
: Lisp不一定是纯FP的，common lisp, scheme, 这些Lisp，大都还是基于赋值的编程，
: 不是FP为主的。数据还是mutable的。
: Clojure是FP为主的，因为是immutable by default

j*w2017-05-10 07:05

100 楼

我指的是语言上的native support，当然所有功能最后都得机器语言来实现，C肯定捣
腾一下也能做，至少差不多。

【在 g****t 的大作中提到】

: c有fp.
: For example, 古代拆行拆列重用内存。
: 在现代谁家的c矩阵求逆，改送进来的矩阵？
: 这不就是immutable嘛

g*t2017-05-10 07:05

101 楼

这个事情要反着看。如果你在公司混饭，不妨拆行拆列，
共用内存，复用变量，搞搞乱。反正语言一般都没有native fp支持。
指针什么的，按定义就是可以乱指的。所以其实还行。变量，如果复用。。。

【在 j***w 的大作中提到】

: 我指的是语言上的native support，当然所有功能最后都得机器语言来实现，C肯定捣
: 腾一下也能做，至少差不多。

T*x2017-05-10 07:05

102 楼

一般情况下的抽象是提出概念，或者说给结构命名。计算机编程领域的抽象我理解是
给结构命名。所以OOP中的定义Class，以及封装，更符合我理解的抽象。

【在 T*******x 的大作中提到】

: 请展开说一下抽象就是数据上累加数据？这和我理解的抽象不一样。

g*t2017-05-10 07:05

103 楼

My two percent:
Abstract = lift up to superset
fruit is the abstraction of apple,orange,...

一般情况下的抽象是提出概念，或者说给结构命名。计算机编程领域的抽象我理解是

【在 T*******x 的大作中提到】

: 一般情况下的抽象是提出概念，或者说给结构命名。计算机编程领域的抽象我理解是
: 给结构命名。所以OOP中的定义Class，以及封装，更符合我理解的抽象。

T*x2017-05-10 07:05

104 楼

和我说的差不多。

【在 g****t 的大作中提到】

: My two percent:
: Abstract = lift up to superset
: fruit is the abstraction of apple,orange,...
:
: 一般情况下的抽象是提出概念，或者说给结构命名。计算机编程领域的抽象我理解是

a*a2017-05-10 07:05

105 楼

看了一遍，这帖子大概是SICP第三章没学过的水平

g*t2017-05-10 07:05

106 楼

You can lift up to higher order functions too

【在 T*******x 的大作中提到】

: 和我说的差不多。

T*x2017-05-10 07:05

107 楼

举个例子？

【在 g****t 的大作中提到】

: You can lift up to higher order functions too

w*x2017-05-10 07:05

108 楼

c++的oo设计是把简单事情复杂化了，然后为了一些所谓的方便引进了一系列的坑，但
是还是有很多人无畏的跳进去学习，感觉就是浪费生命。。。
c++现在就是个垃圾语言，c++委员会就是群二货

g*t2017-05-10 07:05

109 楼

加减乘除是二元计算的一些实现。
二元函数就是抽象。

【在 T*******x 的大作中提到】

: 举个例子？

T*x2017-05-10 07:05

110 楼

这也在范围内。
这是你所说的higher order function？

【在 g****t 的大作中提到】

: 加减乘除是二元计算的一些实现。
: 二元函数就是抽象。

h*i2017-05-10 07:05

111 楼

用代码来描述比较清楚。
本来的数据，是两个字符串，“Apple", "Orange"
老板说，这两串其实有共性，他们都可以抽象成"Fruit"。
OOP马公说，我知道该咋办：
class Fruit {
String name = "";
}
class Apple extends Fruit {
String name = "Apple";
}
class Orange extends Fruit {
String name = "Orange";
}
FP马公说，其实加个函数就够了:
(defn fruit? [s] (#{"Apple" "Orange"} s))
DOP (data oriented programming)马公说，这些都是脱裤子放屁，不就是数据么：
{:fruit "Apple"}
{:fruit "Orange"}
你说所谓抽象是不是就是“数据上加数据”？

【在 g****t 的大作中提到】

: My two percent:
: Abstract = lift up to superset
: fruit is the abstraction of apple,orange,...
:
: 一般情况下的抽象是提出概念，或者说给结构命名。计算机编程领域的抽象我理解是

g*t2017-05-10 07:05

112 楼

yes. I meant a function that returns other functions.

【在 T*******x 的大作中提到】

: 这也在范围内。
: 这是你所说的higher order function？

g*t2017-05-10 07:05

113 楼

我自己的代码里大量用你写的fp那种格式.
等于就是函数列表.
你最后那种语法是什么意思？in python就是：
fruit=['apple','orange']?
给list或者字典一个名字叫fruit？
这样也对。就是superset.

【在 h*i 的大作中提到】

: 用代码来描述比较清楚。
: 本来的数据，是两个字符串，“Apple", "Orange"
: 老板说，这两串其实有共性，他们都可以抽象成"Fruit"。
: OOP马公说，我知道该咋办：
: class Fruit {
: String name = "";
: }
: class Apple extends Fruit {
: String name = "Apple";
: }

h*i2017-05-10 07:05

114 楼

{:fruit "Apple"}是一个immutable hashmap，键是:fruit, 值是“Apple".
这是很FP的。这个hashmap本身也可以作函数:
(def a {:fruit "Apple"})
(a :fruit)会返回"Apple"
当然:fruit也可以作函数
(:fruit a)同样返回“Apple"
:fruit是Lisp里面的keyword。keyword always evaluates to itself.
(:fruit "Car")返回nil
从OOP角度，这个hashmap其实就是一个轻量级的对象。不过不是封装的，你可以随便给
一个hashmap添加新键来产生一个新的hashmap。因为hashmap是immutable的，你可以把
它随便传来传去，不怕被人改了。

【在 g****t 的大作中提到】

: 我自己的代码里大量用你写的fp那种格式.
: 等于就是函数列表.
: 你最后那种语法是什么意思？in python就是：
: fruit=['apple','orange']?
: 给list或者字典一个名字叫fruit？
: 这样也对。就是superset.

g*t2017-05-10 07:05

115 楼

哦。就是查表。不过我一般不喜欢用hash table
能用look up table我尽量用look up table

【在 h*i 的大作中提到】

: {:fruit "Apple"}是一个immutable hashmap，键是:fruit, 值是“Apple".
: 这是很FP的。这个hashmap本身也可以作函数:
: (def a {:fruit "Apple"})
: (a :fruit)会返回"Apple"
: 当然:fruit也可以作函数
: (:fruit a)同样返回“Apple"
: :fruit是Lisp里面的keyword。keyword always evaluates to itself.
: (:fruit "Car")返回nil
: 从OOP角度，这个hashmap其实就是一个轻量级的对象。不过不是封装的，你可以随便给
: 一个hashmap添加新键来产生一个新的hashmap。因为hashmap是immutable的，你可以把

c*e2017-05-10 07:05

116 楼

immutable 只是让multi-threading变得简单点。

【在 a*******o 的大作中提到】

: 我不反对FP，但是不同意 immutable 反映客观世界的本质。没必要扯那么远。就事论
: 事比较好。

h*r2017-05-10 07:05

117 楼

剑宗气宗的淡看来是扯不完了。

w*m2017-05-10 07:05

118 楼

大概是OOP里面的factory pattern。
class Fruit {
Map createOrange() {};
Map createApple() {};
}

【在 h*i 的大作中提到】

: 用代码来描述比较清楚。
: 本来的数据，是两个字符串，“Apple", "Orange"
: 老板说，这两串其实有共性，他们都可以抽象成"Fruit"。
: OOP马公说，我知道该咋办：
: class Fruit {
: String name = "";
: }
: class Apple extends Fruit {
: String name = "Apple";
: }

k*i2017-05-10 07:05

119 楼

data is coarse abstraction, while interpretation tends to opinionated

：
：面向数据的编程（data oriented programming）就是把程序的逻辑用数据结构表达。