Customers do not give a fucking rats about your documentation. They are not paying for the documentation, they are paying for the shit that does the shit.
Nobody, I say nobody, care about the documentation, comments, types, or whatever your management want you to believe. These are the things that hold you down on your seat on the assembly line.
Think, like a normal fucking human being.
You wonder why women don't like programming? They are smart. They intuitively know what is good for a human being.
【 在 hci (海螺子) 的大作中提到: 】 : Customers do not give a fucking rats about your documentation. They are not : paying for the documentation, they are paying for the shit that does the : shit. : Nobody, I say nobody, care about the documentation, comments, types, or : whatever your management want you to believe. These are the things that hold : you down on your seat on the assembly line. : Think, like a normal fucking human being. : You wonder why women don't like programming? They are smart. They : intuitively know what is good for a human being.
【 在 hci (海螺子) 的大作中提到: 】 : Customers do not give a fucking rats about your documentation. They are not : paying for the documentation, they are paying for the shit that does the : shit. : Nobody, I say nobody, care about the documentation, comments, types, or : whatever your management want you to believe. These are the things that hold : you down on your seat on the assembly line. : Think, like a normal fucking human being. : You wonder why women don't like programming? They are smart. They : intuitively know what is good for a human being.
It depends on what "Customer" means. If it means the end SW user, OK they don't care. But if your customers are other programmers, documentation is useful.
【 在 Caravel (克拉维尔) 的大作中提到: 】 : Customers是不会care documentation，你给一堆shit给他们，只要能work就行。这是 : 关乎马农的健康和效率，如果没有documentation，comments，coding style，前人留 : 给的你的一堆shit，明天客户要你出东西怎么办？ : not : hold
【 在 lexabc (derby) 的大作中提到: 】 : It depends on what "Customer" means. : If it means the end SW user, OK they don't care. : But if your customers are other programmers, documentation is useful.
If you read the history of linux kernel and python carefully, you will get what I meant here. The first version of Linus is only a toy project of an undergraduate student, which is nothing comparable with the current version see say today. Python? Take a look at the long list of PEPs ...
【 在 hci (海螺子) 的大作中提到: 】 : Don't know about tensorflow's early history, but linux kernel and python are : my examples. : My conjecture: a coherent and complex piece of human artifact can only be : born out of at most two minds. : I would love to be shown otherwise, then it will provide a unique specimen : that may greatly advance the understanding of human minds. :
It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000. Without the 1, you got nothing.
My point is the 1 can only be brought about by at most two persons. There's no denying that. At least you have not come up with any counter-example so far.
Try harder.
I am curious too.
【 在 Caravel (克拉维尔) 的大作中提到: 】 : If you read the history of linux kernel and python carefully, you will get : what I meant here. The first version of Linus is only a toy project of an : undergraduate student, which is nothing comparable with the current version : see say today. Python? Take a look at the long list of PEPs ... : are
【 在 hci (海螺子) 的大作中提到: 】 : It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000. : Without the 1, you got nothing. : My point is the 1 can only be brought about by at most two persons. There's : no denying that. At least you have not come up with any counter-example so : far. : Try harder. : I am curious too. : version
Lol, Every building must have a first brick. But it doesn't mean the first brick is the most important one. Think about it: Was Python' initial version so much better than all the other attempts? I think Guido won't agree with you. He attributes the success of python to continuously bringing in improvements and ideas from the entire community.
【 在 hci (海螺子) 的大作中提到: 】 : It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000. : Without the 1, you got nothing. : My point is the 1 can only be brought about by at most two persons. There's : no denying that. At least you have not come up with any counter-example so : far. : Try harder. : I am curious too. : version
I am talking about the concrete act of building a software.
Of course nothing comes out of nowhere.
But the concrete act of initially put an idea (which might be the results of countless interaction with thousands of people) into a single piece of running code, can only be done by at most two people. I have not found any evidence to the contrary. Everything I read, all the work I personally involved with, and all the things have heard, do not provide a single counter-example.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : It took others more than 30 years to figure out that the Poincare : Hypothesis was one of the most important math problems. : The context or the setup of a work is at least as important as the work : itself because the context defined the meaning and the value of the work.
of course most software projects are created by one person or two first if started from scratch, as there was zero lines of code in the begining. nobody will ask 20 hackers to start writing main() for same project at same time.
but I don't think you can discredit others who contributed in later stages, especially complex commercial software.
【 在 hci (海螺子) 的大作中提到: 】 : It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000. : Without the 1, you got nothing. : My point is the 1 can only be brought about by at most two persons. There's : no denying that. At least you have not come up with any counter-example so : far. : Try harder. : I am curious too. : version
But the fact is a fact. Disregard basic facts results in sloppy reasoning and wrong decision making, e.g. prioritizing the less important thing.
Static typing is helpful, nobody is disputing that. Is it helpful enough to worth the crippling effect on an individual's ability to do things? Not so much. Type system is just too weak.
【 在 helpme (名虚胖字满肥) 的大作中提到: 】 : of course most software projects are created by one person or two first if : started from scratch, as there was zero lines of code in the begining. : nobody will ask 20 hackers to start writing main() for same project at same : time. : but I don't think you can discredit others who contributed in later stages, : especially complex commercial software. : s
There are certainly tons of counter examples. For a corporate software. the first runable version is more likely completed by more than 2 people. The open source projects are probably more likely done by 1 or 2 persons because they are hobby projects at the beginning.
【 在 hci (海螺子) 的大作中提到: 】 : I am talking about the concrete act of building a software. : Of course nothing comes out of nowhere. : But the concrete act of initially put an idea (which might be the results of : countless interaction with thousands of people) into a single piece of : running code, can only be done by at most two people. I have not found any : evidence to the contrary. Everything I read, all the work I personally : involved with, and all the things have heard, do not provide a single : counter-example.
I have personally done plenty of corporate software to know that it's the same as in open source. A lead will do it with the help of another guy, then other people join in. When other joins, the core thing is already working. There's no exception.
【 在 Caravel (克拉维尔) 的大作中提到: 】 : There are certainly tons of counter examples. For a corporate software. the : first runable version is more likely completed by more than 2 people. The : open source projects are probably more likely done by 1 or 2 persons because : they are hobby projects at the beginning. : of
Keep using physical analogy gets you nowhere. Already repeated so many times, software is closer to poetry or novel than a building, because they are both virtual.
【 在 Caravel(克拉维尔) 的大作中提到: 】
: Lol, Every building must have a first brick. But it doesn't mean the first
: brick is the most important one. Think about it: Was Python' initial version
: so much better than all the other attempts? I think Guido won't agree with
: you. He attributes the success of python to continuously bringing in
: improvements and ideas from the entire community.
A software is certainly much closer to a building than poetry or novel. The software have strict rules, whatever you wrote must be compilable or at least executable on a machine.
In literature works，you could throw in anything you want. You can even ignore grammar if you want.
【 在 hci (海螺子) 的大作中提到: 】 : Keep using physical analogy gets you nowhere. Already repeated so many times : , software is closer to poetry or novel than a building, because they are : both virtual. : : Lol, Every building must have a first brick. But it doesn't mean the : first : : brick is the most important one. Think about it: Was Python' initial : version : : so much better than all the other attempts? I think Guido won't agree : with : : you. He attributes the success of python to continuously bringing in : ...................
McCarthy had planned to develop an automatic Lisp compiler using M- expressions as the language syntax and S-expressions to describe the compiler's internal processes. Stephen B. Russell read the paper and suggested to him that S-expressions were a more convenient syntax. Although McCarthy disapproved of the idea, Russell and colleague Daniel J. Edwards hand-coded an interpreter program that could execute S-expressions.[2] This program was adopted by McCarthy's research group, establishing S-expressions as the dominant form of Lisp.
MSFT's Excel is another example. 【 在 hci (海螺子) 的大作中提到: 】 : Are these software?
Guido adopted others ideas from his previous paid language project. 【 在 Caravel (克拉维尔) 的大作中提到: 】 : Lol, Every building must have a first brick. But it doesn't mean the first : brick is the most important one. Think about it: Was Python' initial version : so much better than all the other attempts? I think Guido won't agree with : you. He attributes the success of python to continuously bringing in : improvements and ideas from the entire community. : s
Is Intel Math Kernel Library (MKL) from one single person's idea? BLAS? Any physics computation/simulation software?
Golang were from three people, right?
【 在 hci (海螺子) 的大作中提到: 】 : I am talking about the concrete act of building a software. : Of course nothing comes out of nowhere. : But the concrete act of initially put an idea (which might be the results of : countless interaction with thousands of people) into a single piece of : running code, can only be done by at most two people. I have not found any : evidence to the contrary. Everything I read, all the work I personally : involved with, and all the things have heard, do not provide a single : counter-example.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : Lisp is resulted from group efforts. : McCarthy had planned to develop an automatic Lisp compiler using M- : expressions as the language syntax and S-expressions to describe the : compiler's internal processes. Stephen B. Russell read the paper and : suggested to him that S-expressions were a more convenient syntax. Although : McCarthy disapproved of the idea, Russell and colleague Daniel J. Edwards : hand-coded an interpreter program that could execute S-expressions.[2] This : program was adopted by McCarthy's research group, establishing S- expressions : as the dominant form of Lisp. : MSFT's Excel is another example.
I am talking about the concrete act of putting an idea initially in to code.
I am not talking about where the idea come from. I already said, the idea may be the results of hundreds of interaction with thousands of people. When it is first realized in code as a running software, it is realized by one person, or at most two persons.
This is a very specific and concrete description.
No one has been able to come up with a counter example. If you can, I would like to see it. Because it would be interesting.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : You are talking about the hinder most illusion. : Is Intel Math Kernel Library (MKL) from one single person's idea? : BLAS? Any physics computation/simulation software? : Golang were from three people, right? : of
No, you cannot throw in anything you want in literature. It has strict rules too, violating the rules and people will not accept it as literature (i.e. not compile). e.g. you cannot have a novel without a story.
【 在 Caravel (克拉维尔) 的大作中提到: 】 : Your basic reasoning is problematic. : A software is certainly much closer to a building than poetry or novel. : The software have strict rules, whatever you wrote must be compilable or at : least executable on a machine. : In literature works，you could throw in anything you want. You can even : ignore grammar if you want. : times : agree
The code is written by at most two guys. That's my point. You have not come up with anything to the contrary.
In this business, people say "idea is cheap".
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : McCarthy brought us two systems: S-expression and M-expression. : It was not possible to underestimate the importance of the decision of using : the S-expression. That decision came from group engineering efforts.
As I said earlier, ideas could be resulted directly from tons of group engineering efforts. That is called the "population based wisdom" in AI.
Where the "the concrete act of putting an idea initially in to code."of the Golang came from?
Three people, right?
【 在 hci (海螺子) 的大作中提到: 】 : I am talking about the concrete act of putting an idea initially in to code. : I am not talking about where the idea come from. I already said, the idea : may be the results of hundreds of interaction with thousands of people. When : it is first realized in code as a running software, it is realized by one : person, or at most two persons. : This is a very specific and concrete description. : No one has been able to come up with a counter example. If you can, I would : like to see it. Because it would be interesting.
Who wrote the code? How do you know it's three people. It would be very interesting. Show me.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : As I said earlier, ideas could be resulted directly from tons of group : engineering efforts. That is called the "population based wisdom" in AI. : Where the "the concrete act of putting an idea initially in to code."of the : Golang came from? : Three people, right? : code. : When : would
I stand corrected. I actually dug into golang commit log. It does show that three of them made large amount of code contributions initially. They are not even the person who commit first.
But the main point still stands, just change the number 2 to 3.
But if you push harder, I would consider only griesemer and pike as the initial authors. Because ken was just fixing things very early on.
【 在 hci (海螺子) 的大作中提到: 】 : Ideas are cheap. : Who wrote the code? How do you know it's three people. It would be very : interesting. Show me. : the
Golang's initial team outsourced the scheduler to a Russian guy later. Let's change the number into 4. LoL
You intended to name the author of the first single letter of a book as the only author. That is ridiculous.
【 在 hci (海螺子) 的大作中提到: 】 : I stand corrected. I actually dug into golang commit log. It does show that : three of them made similar amount of code contributions initially. They are : not even the person who commit first. : But the main point still stands, just change the number 2 to 3.
BLAs and MKL would not be the kind of software I am talking about. these are collections to begin with.
As I said, if you push it, I would say golang had only two initial authors. ken would not count.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : You can find the answer from github. : Besides Golang, could the BLAS,MKL,...etc from a single author? : Even the most simplest random number lib could be resulted from different : people's work.
" Ken Thompson's main code contribution was writing the Go compiler, so you can thank him for Go code compiling so fast. " --Somebody from the Quora
【 在 hci (海螺子) 的大作中提到: 】 : BLAs and MKL would not be the kind of software I am talking about. these are : collections to begin with. : As I said, if you push it, I would say golang had only two initial authors. : ken would not count.
The main authors are just two. ken was just fixing things. outsource parts doesn't count either.
I am just stating the fact. If you look at the content of the commit. I think my initial estimate of at most two persons is correct.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : Golang's initial team outsourced the scheduler to a Russian guy later. : Let's change the number into 4. LoL : You intended to name the author of the first single letter of a book as the : only author. That is ridiculous. : that : are
Not from the commit log. From the commit log, he's not the language designer, for most of the spec is by the other two guys. His written the compiler is like that Russian guy they outsourced to for the scheduler. As a new language, I would credit the other two guys. It's all in the commit log. There's no point arguing about fact.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : Ken Thompson wrote the initial compiler. : " : Ken Thompson's main code contribution was writing the Go compiler, so you : can thank him for Go code compiling so fast. : " --Somebody from the Quora : are : .
It was quite normal that a group of people kept polishing a software and it turned into a different thing later.
Java initially was an embedded language. Without population based wisdom, there is no Java web app/server.
【 在 hci (海螺子) 的大作中提到: 】 : No. : The main authors are just two. ken was just fixing things. outsource parts : doesn't count either. : I am just stating the fact. If you look at the content of the commit. I : think my initial estimate of at most two persons is correct. : the
It did not matter. The structure of a software could change later and new people could join and redefine the target of the software.
On the other hand, there were many domain specific softwares which was not possible a result a single/2/3/4 people's work because a single people did not have multi-domains knowledge. For example,the embedded code set of F16.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : It was quite normal that a group of people kept polishing a software : and it turned into a different thing later. : Java initially was an embedded language. Without population based wisdom, : there is no Java web app/server.
【 在 hci (海螺子) 的大作中提到: 】 : I stand corrected. I actually dug into golang commit log. It does show that : three of them made large amount of code contributions initially. They are : not even the person who commit first. : But the main point still stands, just change the number 2 to 3. : But if you push harder, I would consider only griesemer and pike as the : initial authors. Because ken was just fixing things very early on.
Instruction sets, math libraries, etc. are not the kind of software I am talking about. They are not a system that runs.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】 : It did not matter. The structure of a software could change later and new : people could join and redefine the target of the software. : On the other hand, there were many domain specific softwares which was not : possible a result a single/2/3/4 people's work because a single people did : not have multi-domains knowledge. For example,the embedded code set of F16.
golang is a new language. Whoever wrote the initial spec of the language are the authors. There were only two: pike and griesmer.
The first commit of ken was already the implementation of the compiler. So it depends on how you want to count it. I wouldn't count him as the language designer.
You could put BLAS under your theory as Goto started/implemented the modern one.
【 在 hci (海螺子) 的大作中提到: 】 : BLAs and MKL would not be the kind of software I am talking about. these are : collections to begin with. : As I said, if you push it, I would say golang had only two initial authors. : ken would not count.
【 在 hci (海螺子) 的大作中提到: 】 : Good to know. : Why are we even arguing about these? : I thought everybody here had done enough programming to know how it is done : in the real world. : Apparently we got some people who have not done any serious software work. : These are the "ideas guys" we often heard about? : There are CTOs who write production code, and CTOs who do not. : Guess who is who? : modern
【 在 hci (海螺子) 的大作中提到: 】 : Good to know. : Why are we even arguing about these? : I thought everybody here had done enough programming to know how it is done : in the real world. : Apparently we got some people who have not done any serious software work. : These are the "ideas guys" we often heard about? : There are CTOs who write production code, and CTOs who do not. : Guess who is who? : modern
程序语言的静态类型的出发点，其实是把程序员看成是一个流水线工人的一种哲学，而动态类型是把程序员看成是一个用手艺吃饭的自由工匠的哲学。
我都说了很多遍了，复杂的商业应用程序，处理人类用户关心的信息，所谓RH的
situated programming, 是我讨论的用例，这其实是99%以上的职业程序员的时常工作
，只是大多数程序员不愿面对和承认而已。这种编程，大多是由PHB （pointy haired boss) 驱动的，也就是由不懂技术的PM决定的，他们今天要这个，明天要那个，这个和那个可能连逻辑都不自洽，但他们就要这样，广大程序员们没有任何办法，日常工作就是搞这些屎一样的东西。大家扪心自问，是不是这样？
Clojure的哲学，是让搞这些东西也可以搞得很开心，让你的编程生涯轻松和愉快。你
不一定非要去搞政治，其实搞技术也可以自己很开心，同时让老板也很开心，给你高工资。根据stackoverflow调查，Clojure是工资最高的编程语言。
Clojure哲学代表的这种追求，其实是一种职业工匠的追求，是程序员们应该追求的方
向。而不是反方向， 把编程搞成流水线工作，个人完全没有任何自主权，如果都要靠
工具好用才能编程，都工业化了，谁都可以被替代，那可不就996什么都来了。对不对
？资本家当然想把编程变成流水线工作，但程序员还跟着吆喝，是不是有点傻？
好了，有人说，但是最后工业化会赢的，以前的那些木匠石匠们不都被工厂替代了么？
我说，编程有特殊性。编程是对付虚拟的东西，人对虚拟东西的需求是无止境的。而木匠石匠都是搞物理东西的，物理是有止境的，所以可以被科学化，工程化，而虚拟的东西不可以被科学化和工程化。所以软件“工程”从来也不是工程，反而和流行服装届更接近，各种风格轮换着流行。这种行业，流水线只能造便宜货，高附加值的东西，还是需要工匠。
你是想做工匠还是流水线工人？
软件需要分工协作，主要的要求是高内聚，低偶联。
一般的解偶，要靠dependency injection。
静态语言有名字加类型，注入要方便一些。
动态语言的话，只有名字一个限定词，搞注入比较麻烦。
分工协作看是哪种，流水线那种还是工匠那种。
你听了上面链接的talk么？
他说的和你说的完全是反的。“静态语言的问题就是没有名字，名字都被compiled
away了，只剩下类型和位置，导致tight coupling. 静态语言需要DI说明还是需要搞动态才行，这其实就是脱裤子放屁。“ 这些几乎就是RH的原话。你们是听不懂英文？
RH的talk被广泛追捧，因为说出了广大想做工匠的程序员的心声。
【 在 walkrandom (walkrandom) 的大作中提到: 】
: 软件需要分工协作，主要的要求是高内聚，低偶联。
: 一般的解偶，要靠dependency injection。
: 静态语言有名字加类型，注入要方便一些。
: 动态语言的话，只有名字一个限定词，搞注入比较麻烦。
自由的工匠为毛要写那么多文档？
铁匠铺做大以后是应该雇1000个人一起抡锤子，还是买机器架流水线。
动态语言做demo很好，这没问题。请乖乖做demo, 别拿来直接产品化。
你这个我原文都回答了。
【 在 insect9 (insect9) 的大作中提到: 】
: 自由的工匠为毛要写那么多文档？
: 铁匠铺做大以后是应该雇1000个人一起抡锤子，还是买机器架流水线。
: 动态语言做demo很好，这没问题。请乖乖做demo, 别拿来直接产品化。
Customers do not give a fucking rats about your documentation. They are not paying for the documentation, they are paying for the shit that does the
shit.
Nobody, I say nobody, care about the documentation, comments, types, or
whatever your management want you to believe. These are the things that hold you down on your seat on the assembly line.
Think, like a normal fucking human being.
You wonder why women don't like programming? They are smart. They
intuitively know what is good for a human being.
【 在 insect9 (insect9) 的大作中提到: 】
: 自由的工匠为毛要写那么多文档？
: 铁匠铺做大以后是应该雇1000个人一起抡锤子，还是买机器架流水线。
: 动态语言做demo很好，这没问题。请乖乖做demo, 别拿来直接产品化。
这个见解非常有道理。
你这还是太理想化了，想成立软件乌托邦，恐怕没啥希望。
另外，绝大部分女人除了吃的穿的戴的，好像就没啥喜欢的了。
【 在 hci (海螺子) 的大作中提到: 】
: Customers do not give a fucking rats about your documentation. They are
not
: paying for the documentation, they are paying for the shit that does the
: shit.
: Nobody, I say nobody, care about the documentation, comments, types, or
: whatever your management want you to believe. These are the things that
hold
: you down on your seat on the assembly line.
: Think, like a normal fucking human being.
: You wonder why women don't like programming? They are smart. They
: intuitively know what is good for a human being.
Customers是不会care documentation，你给一堆shit给他们，只要能work就行。这是
关乎马农的健康和效率，如果没有documentation，comments，coding style，前人留
给的你的一堆shit，明天客户要你出东西怎么办？
【 在 hci (海螺子) 的大作中提到: 】
: Customers do not give a fucking rats about your documentation. They are
not
: paying for the documentation, they are paying for the shit that does the
: shit.
: Nobody, I say nobody, care about the documentation, comments, types, or
: whatever your management want you to believe. These are the things that
hold
: you down on your seat on the assembly line.
: Think, like a normal fucking human being.
: You wonder why women don't like programming? They are smart. They
: intuitively know what is good for a human being.
人家的意思是，documents是给流水线工人看的，工匠不需要。
【 在 Caravel (克拉维尔) 的大作中提到: 】
: Customers是不会care documentation，你给一堆shit给他们，只要能work就行。这是
: 关乎马农的健康和效率，如果没有documentation，comments，coding style，前人留
: 给的你的一堆shit，明天客户要你出东西怎么办？
: not
: hold
rh是什么 ？
海老师这篇文章我老明天要打出来， 一个错字都没有， 除了老邱，全站找不出来。
以前我老是自作聪明， 觉得自己高， 别人什么都不是，凭什么对我指手画脚？ 现在
也想明白了， 你雇我来算命， 我就来算， 你想什么命，我就给你算什么命； 你想要这样的命， 我就给你算这样的命； 明天你想要那样的命， 我就给你算那样的命。 我才懒得纠结为什么你过了一天又改主意了。
这你说反了吧
动态的inject才方便呢
【 在 walkrandom (walkrandom) 的大作中提到: 】
: 软件需要分工协作，主要的要求是高内聚，低偶联。
: 一般的解偶，要靠dependency injection。
: 静态语言有名字加类型，注入要方便一些。
: 动态语言的话，只有名字一个限定词，搞注入比较麻烦。
You got it.
前人留给你的shit, why it's shit at first place...
【 在 helpme (名虚胖字满肥) 的大作中提到: 】
: 人家的意思是，documents是给流水线工人看的，工匠不需要。
那你就是承认toB应该用静态了？
toB加需求没那么好加的
It depends on what "Customer" means.
If it means the end SW user, OK they don't care.
But if your customers are other programmers, documentation is useful.
【 在 Caravel (克拉维尔) 的大作中提到: 】
: Customers是不会care documentation，你给一堆shit给他们，只要能work就行。这是
: 关乎马农的健康和效率，如果没有documentation，comments，coding style，前人留
: 给的你的一堆shit，明天客户要你出东西怎么办？
: not
: hold
clojure 码农工资高其实更可能是因为老司机比例高
【 在 hci (海螺子) 的大作中提到: 】
: 程序语言的静态类型的出发点，其实是把程序员看成是一个流水线工人的一种哲学，而
: 动态类型是把程序员看成是一个用手艺吃饭的自由工匠的哲学。
: 我都说了很多遍了，复杂的商业应用程序，处理人类用户关心的信息，所谓RH的
: situated programming, 是我讨论的用例，这其实是99%以上的职业程序员的时常工作
: ，只是大多数程序员不愿面对和承认而已。这种编程，大多是由PHB （pointy
haired
: boss) 驱动的，也就是由不懂技术的PM决定的，他们今天要这个，明天要那个，这个和
: 那个可能连逻辑都不自洽，但他们就要这样，广大程序员们没有任何办法，日常工作就
: 是搞这些屎一样的东西。大家扪心自问，是不是这样？
: Clojure的哲学，是让搞这些东西也可以搞得很开心，让你的编程生涯轻松和愉快。你
: 不一定非要去搞政治，其实搞技术也可以自己很开心，同时让老板也很开心，给你高工
: ...................
YY一下也没什么不好，毕竟人是喜欢echo chamber的。
这问题其实随便看一下levels.fyi之类的网站就知道答案了，业界相同级别工资给的最高的公司里，能找到一
家主要用clojure的么？
【 在 ironcool (syscall center) 的大作中提到: 】
: clojure 码农工资高其实更可能是因为老司机比例高
: haired
"clojure 码农工资高其实更可能是因为老司机比例高" 这个猜想有道理！
【 在 ironcool(syscall center) 的大作中提到: 】
: clojure 码农工资高其实更可能是因为老司机比例高
: haired
Isn't it the point?
老工匠值钱，流水线只要年轻人，不是么？
【 在 ironcool (syscall center) 的大作中提到: 】
: clojure 码农工资高其实更可能是因为老司机比例高
: haired
Of course.
Isn't it what we want?
【 在 sui (黑圈圈) 的大作中提到: 】
: "clojure 码农工资高其实更可能是因为老司机比例高" 这个猜想有道理！
:
: clojure 码农工资高其实更可能是因为老司机比例高
:
: haired
:
资本家当然想把编程搞成流水线。
我的观点是，他们不会成功。
因为软件的特殊性。
【 在 fantasist (一) 的大作中提到: 】
: YY一下也没什么不好，毕竟人是喜欢echo chamber的。
: 这问题其实随便看一下levels.fyi之类的网站就知道答案了，业界相同级别工资给的最
: 高的公司里，能找到一
: 家主要用clojure的么？
你来来回回无非是打算证明手工打造的限量版Lamborghini比量产版Toyota更高大上。
这没问题。
问题是量产版Toyota可以依靠数量轻轻松松淹死你呀。手工打造最终在专精一项上可能有优势，问题是比堆feature数量，功能的全面程度，那是输定了呀。
【在 hci(海螺子)的大作中提到：】
：资本家当然想把编程搞成流水线。
：
是对老板cut cost useful
【 在 lexabc (derby) 的大作中提到: 】
: It depends on what "Customer" means.
: If it means the end SW user, OK they don't care.
: But if your customers are other programmers, documentation is useful.
为什么你会觉得clojure高大上？lisp是最简单的语言
【 在 insect9 (insect9) 的大作中提到: 】
: 你来来回回无非是打算证明手工打造的限量版Lamborghini比量产版Toyota更高大上。
: 这没问题。
: 问题是量产版Toyota可以依靠数量轻轻松松淹死你呀。手工打造最终在专精一项上可能
: 有优势，问题是比堆feature数量，功能的全面程度，那是输定了呀。
: ：资本家当然想把编程搞成流水线。
: ：
都重复了很多遍了，软件的特殊性。
世界上几乎所有的重要软件都是由一两个核心人员开发的，项目里其余可能上百的人都是在搞点边角料，知道为什么不？很简单，因为软件是虚拟的，最好的载体是人脑。一旦变成代码，就没人知道到底咋回事了。
你为流水线而优化的静态类型工具根本就不能在“堆feature数量，功能的全面程度上
“与为工匠而优化的动态类型工具比，人家一两个人分分钟钟就加了的功能，你一个团队要搞一年最后系统太复杂什么都动不了项目失败收场，这些是在各个公司每天都在发生的事情。
【 在 insect9 (insect9) 的大作中提到: 】
: 你来来回回无非是打算证明手工打造的限量版Lamborghini比量产版Toyota更高大上。
: 这没问题。
: 问题是量产版Toyota可以依靠数量轻轻松松淹死你呀。手工打造最终在专精一项上可能
: 有优势，问题是比堆feature数量，功能的全面程度，那是输定了呀。
: ：资本家当然想把编程搞成流水线。
: ：
Rich Hickey
https://github.com/tallesl/Rich-Hickey-fanclub
【 在 magliner (magliner) 的大作中提到: 】
: rh是什么 ？
: 海老师这篇文章我老明天要打出来， 一个错字都没有， 除了老邱，全站找不出来。: 以前我老是自作聪明， 觉得自己高， 别人什么都不是，凭什么对我指手画脚？ 现在
: 也想明白了， 你雇我来算命， 我就来算， 你想什么命，我就给你算什么命； 你想要
: 这样的命， 我就给你算这样的命； 明天你想要那样的命， 我就给你算那样的命。 我
: 才懒得纠结为什么你过了一天又改主意了。
你这个前提就是错的，
“世界上几乎所有的重要软件都是由一两个核心人员开发的“， 你能举两个例子么？
【 在 hci (海螺子) 的大作中提到: 】
: 都重复了很多遍了，软件的特殊性。
: 世界上几乎所有的重要软件都是由一两个核心人员开发的，项目里其余可能上百的人都
: 是在搞点边角料，知道为什么不？很简单，因为软件是虚拟的，最好的载体是人脑。一
: 旦变成代码，就没人知道到底咋回事了。
: 你为流水线而优化的静态类型工具根本就不能在“堆feature数量，功能的全面程度上
: “与为工匠而优化的动态类型工具比，人家一两个人分分钟钟就加了的功能，你一个团
: 队要搞一年最后系统太复杂什么都动不了项目失败收场，这些是在各个公司每天都在发
: 生的事情。
你堆边角料堆不过人家呀。。。一个人精力是有限的，用静态语言上在核心功能上可能比你动态语言多花一倍时间，so?
在边角料上大量的工作可以交给码畜去做，而不需要担心那些傻逼把你的核心code弄坏呀。
这是一个最简单的80/20问题。20%的核心代码解决了80%的问题，问题是还有80%的
monkey code在解决20%的问题。问题是能把核心功能做好的团队不止一个，最后拼的反倒变成那20% copy paste的部分谁质量控制好，谁占领80%市场。
核心程序猿考虑的不该是怎么为自己的那20%核心代码制造壁垒，而是应该考虑怎么把
老板扔给你的傻逼丢出去去做那80%的周边代码。雪球滚到足够大你就不是打工仔了，
而是CTO了。这不比你钻研工匠精神强？
【在 hci(海螺子)的大作中提到：】
：都重复了很多遍了，软件的特殊性。
：
好的东西都是少数人搞出来的、这个没啥错
git
【 在 Caravel (克拉维尔) 的大作中提到: 】
: 你这个前提就是错的，
: “世界上几乎所有的重要软件都是由一两个核心人员开发的“， 你能举两个例子么？
你能举出一个反例么。我是一个也想不出来。
【 在 Caravel (克拉维尔) 的大作中提到: 】
: 你这个前提就是错的，
: “世界上几乎所有的重要软件都是由一两个核心人员开发的“， 你能举两个例子么？
软件咱不懂， 但可不可以这么说， 世界上几乎所有的重要著作都是由一两个核心人员开发的 。 我还得加一句， 99.999%是一个人写的 。
两个人写的，有， 但很少， 比如马克思恩格斯选集。
三个人写的，就更少了， 马克思，恩格斯，列宁选集。
四个人写的， 我还真没听说过。
所以啊， 我看写软件， 跟写书， 写诗一样，是个工匠型的活。
git何止一个人开放，你去github上面开发，linus顶多算开发了一个原型。
【 在 nchip (脑残芯) 的大作中提到: 】
: git
多的是，linux kernel，python，tensflow, 目前的版本，即使算核心的开发者也有几十个。基本任何in production的大型项目都不可能是一辆人开发。
【 在 hci (海螺子) 的大作中提到: 】
: 你能举出一个反例么。我是一个也想不出来。
没有原型哪里来这么多搞边角料的
【 在 Caravel (克拉维尔) 的大作中提到: 】
: git何止一个人开放，你去github上面开发，linus顶多算开发了一个原型。
是吗？
我倒是看.Net程序员晒.Net搜索频率，一到节假日就显著下降
他们用此证明.Net程序的成熟稳健，一旦开发完毕，不用担心bug找后账
不用火急火燎的赶工救故障
.Net和C#不就是静态类型的典型代表？
我是说，你推崇 clojure 的一些特点，很多确实是不错的。只是这个工资高，是因为 clojure 带来的高效率造成的，还是因为这伙老司机本身的经验素质，就不确定了。我相信这伙人用他们拿手的静态语言可能也不会少挣。
【在 hci(海螺子)的大作中提到：】
：Isn't it the point?
：
资治通鉴就是好多人一起写的。毛泽东选集应该也是的。
诗，书，礼，易，春秋。圣经。...
都是多人写的。
【 在 magliner(magliner) 的大作中提到: 】
<br>: 软件咱不懂， 但可不可以这么说， 世界上几乎所有的重要著作都是由一两个核
心人员
<br>: 开发的 。 我还得加一句， 99.999%是一个人写的 。
<br>: 两个人写的，有， 但很少， 比如马克思恩格斯选集。
<br>: 三个人写的，就更少了， 马克思，恩格斯，列宁选集。
<br>: 四个人写的， 我还真没听说过。
<br>: 所以啊， 我看写软件， 跟写书， 写诗一样，是个工匠型的活。
<br>
why old guys prefer Clojure?
【 在 ironcool(syscall center) 的大作中提到: 】
: 我是说，你推崇 clojure 的一些特点，很多确实是不错的。只是这个工资高，
是因为
: clojure 带来的高效率造成的，还是因为这伙老司机本身的经验素质，就不确定了。我
: 相信这伙人用他们拿手的静态语言可能也不会少挣。
: ：Isn't it the point?
: ：
这些都是文集。没有必要抬杠了，大家都明白的意思。
软件写作的这种个人特性，是被学界和工业界刻意掩盖了的。
但任何真正搞过系统的人都知道。软件就是一个人，最多两个人写的，其余的人都是打酱油的。其实就是学校的学生group course project，都是这样，无一列外。大家都做过学生的，扪心自问，是不是这样。
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: 资治通鉴就是好多人一起写的。毛泽东选集应该也是的。
: 诗，书，礼，易，春秋。圣经。...
: 都是多人写的。
:
: 软件咱不懂， 但可不可以这么说， 世界上几乎所有的重要著作都是由一
: 两个核
: 心人员
:
: 开发的 。 我还得加一句， 99.999%是一个人写的 。
:
: 两个人写的，有， 但很少， 比如马克思恩格斯选集。
:
: 三个人写的，就更少了， 马克思，恩格斯，列宁选集。
:
: 四个人写的， 我还真没听说过。
: ...................
Don't know about tensorflow's early history, but linux kernel and python are my examples.
My conjecture: a coherent and complex piece of human artifact can only be
born out of at most two minds.
I would love to be shown otherwise, then it will provide a unique specimen
that may greatly advance the understanding of human minds.
【 在 Caravel (克拉维尔) 的大作中提到: 】
: 多的是，linux kernel，python，tensflow, 目前的版本，即使算核心的开发者也有几
: 十个。基本任何in production的大型项目都不可能是一辆人开发。
If you read the history of linux kernel and python carefully, you will get
what I meant here. The first version of Linus is only a toy project of an
undergraduate student, which is nothing comparable with the current version see say today. Python? Take a look at the long list of PEPs ...
【 在 hci (海螺子) 的大作中提到: 】
: Don't know about tensorflow's early history, but linux kernel and python
are
: my examples.
: My conjecture: a coherent and complex piece of human artifact can only be : born out of at most two minds.
: I would love to be shown otherwise, then it will provide a unique specimen
: that may greatly advance the understanding of human minds.
:
It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000.
Without the 1, you got nothing.
My point is the 1 can only be brought about by at most two persons. There's no denying that. At least you have not come up with any counter-example so
far.
Try harder.
I am curious too.
【 在 Caravel (克拉维尔) 的大作中提到: 】
: If you read the history of linux kernel and python carefully, you will get
: what I meant here. The first version of Linus is only a toy project of an : undergraduate student, which is nothing comparable with the current
version
: see say today. Python? Take a look at the long list of PEPs ...
: are
It took others more than 30 years to figure out that the Poincare
Hypothesis was one of the most important math problems.
The context or the setup of a work is at least as important as the work
itself because the context defined the meaning and the value of the work.
【 在 hci (海螺子) 的大作中提到: 】
: 这些都是文集。没有必要抬杠了，大家都明白的意思。
: 软件写作的这种个人特性，是被学界和工业界刻意掩盖了的。
: 但任何真正搞过系统的人都知道。软件就是一个人，最多两个人写的，其余的人都是打
: 酱油的。其实就是学校的学生group course project，都是这样，无一列外。大家都做
: 过学生的，扪心自问，是不是这样。
counter-examples: Quantum Mechanics, thermodynamics , ....
【 在 hci (海螺子) 的大作中提到: 】
: It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000.
: Without the 1, you got nothing.
: My point is the 1 can only be brought about by at most two persons. There's
: no denying that. At least you have not come up with any counter-example so
: far.
: Try harder.
: I am curious too.
: version
Lol, Every building must have a first brick. But it doesn't mean the first
brick is the most important one. Think about it: Was Python' initial version so much better than all the other attempts? I think Guido won't agree with you. He attributes the success of python to continuously bringing in
improvements and ideas from the entire community.
【 在 hci (海螺子) 的大作中提到: 】
: It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000.
: Without the 1, you got nothing.
: My point is the 1 can only be brought about by at most two persons. There's
: no denying that. At least you have not come up with any counter-example so
: far.
: Try harder.
: I am curious too.
: version
Are these software?
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: counter-examples: Quantum Mechanics, thermodynamics , ....
: s
I am talking about the concrete act of building a software.
Of course nothing comes out of nowhere.
But the concrete act of initially put an idea (which might be the results of countless interaction with thousands of people) into a single piece of
running code, can only be done by at most two people. I have not found any
evidence to the contrary. Everything I read, all the work I personally
involved with, and all the things have heard, do not provide a single
counter-example.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: It took others more than 30 years to figure out that the Poincare
: Hypothesis was one of the most important math problems.
: The context or the setup of a work is at least as important as the work
: itself because the context defined the meaning and the value of the work.
of course most software projects are created by one person or two first if
started from scratch, as there was zero lines of code in the begining.
nobody will ask 20 hackers to start writing main() for same project at same time.
but I don't think you can discredit others who contributed in later stages, especially complex commercial software.
【 在 hci (海螺子) 的大作中提到: 】
: It's a matter of 0 or 1. Once you have 1, you can have 2, 3, to 1000.
: Without the 1, you got nothing.
: My point is the 1 can only be brought about by at most two persons. There's
: no denying that. At least you have not come up with any counter-example so
: far.
: Try harder.
: I am curious too.
: version
Nobody is discrediting anybody.
But the fact is a fact. Disregard basic facts results in sloppy reasoning
and wrong decision making, e.g. prioritizing the less important thing.
Static typing is helpful, nobody is disputing that. Is it helpful enough to worth the crippling effect on an individual's ability to do things? Not so
much. Type system is just too weak.
【 在 helpme (名虚胖字满肥) 的大作中提到: 】
: of course most software projects are created by one person or two first if
: started from scratch, as there was zero lines of code in the begining.
: nobody will ask 20 hackers to start writing main() for same project at
same
: time.
: but I don't think you can discredit others who contributed in later stages,
: especially complex commercial software.
: s
There are certainly tons of counter examples. For a corporate software. the first runable version is more likely completed by more than 2 people. The
open source projects are probably more likely done by 1 or 2 persons because they are hobby projects at the beginning.
【 在 hci (海螺子) 的大作中提到: 】
: I am talking about the concrete act of building a software.
: Of course nothing comes out of nowhere.
: But the concrete act of initially put an idea (which might be the results of
: countless interaction with thousands of people) into a single piece of
: running code, can only be done by at most two people. I have not found any
: evidence to the contrary. Everything I read, all the work I personally
: involved with, and all the things have heard, do not provide a single
: counter-example.
I have personally done plenty of corporate software to know that it's the
same as in open source. A lead will do it with the help of another guy, then other people join in. When other joins, the core thing is already working. There's no exception.
【 在 Caravel (克拉维尔) 的大作中提到: 】
: There are certainly tons of counter examples. For a corporate software.
the
: first runable version is more likely completed by more than 2 people. The : open source projects are probably more likely done by 1 or 2 persons
because
: they are hobby projects at the beginning.
: of
Keep using physical analogy gets you nowhere. Already repeated so many times, software is closer to poetry or novel than a building, because they are
both virtual.
【 在 Caravel(克拉维尔) 的大作中提到: 】
: Lol, Every building must have a first brick. But it doesn't mean the
first
: brick is the most important one. Think about it: Was Python' initial
version
: so much better than all the other attempts? I think Guido won't agree with
: you. He attributes the success of python to continuously bringing in
: improvements and ideas from the entire community.
: s
Your basic reasoning is problematic.
A software is certainly much closer to a building than poetry or novel.
The software have strict rules, whatever you wrote must be compilable or at least executable on a machine.
In literature works，you could throw in anything you want. You can even
ignore grammar if you want.
【 在 hci (海螺子) 的大作中提到: 】
: Keep using physical analogy gets you nowhere. Already repeated so many
times
: , software is closer to poetry or novel than a building, because they are : both virtual.
:
: Lol, Every building must have a first brick. But it doesn't mean the
: first
:
: brick is the most important one. Think about it: Was Python' initial
: version
:
: so much better than all the other attempts? I think Guido won't
agree
: with
:
: you. He attributes the success of python to continuously bringing in
: ...................
Lisp is resulted from group efforts.
McCarthy had planned to develop an automatic Lisp compiler using M-
expressions as the language syntax and S-expressions to describe the
compiler's internal processes. Stephen B. Russell read the paper and
suggested to him that S-expressions were a more convenient syntax. Although McCarthy disapproved of the idea, Russell and colleague Daniel J. Edwards
hand-coded an interpreter program that could execute S-expressions.[2] This program was adopted by McCarthy's research group, establishing S-expressions as the dominant form of Lisp.
MSFT's Excel is another example.
【 在 hci (海螺子) 的大作中提到: 】
: Are these software?
Guido adopted others ideas from his previous paid language project.
【 在 Caravel (克拉维尔) 的大作中提到: 】
: Lol, Every building must have a first brick. But it doesn't mean the first
: brick is the most important one. Think about it: Was Python' initial
version
: so much better than all the other attempts? I think Guido won't agree
with
: you. He attributes the success of python to continuously bringing in
: improvements and ideas from the entire community.
: s
You are talking about the hinder most illusion.
Is Intel Math Kernel Library (MKL) from one single person's idea?
BLAS? Any physics computation/simulation software?
Golang were from three people, right?
【 在 hci (海螺子) 的大作中提到: 】
: I am talking about the concrete act of building a software.
: Of course nothing comes out of nowhere.
: But the concrete act of initially put an idea (which might be the results of
: countless interaction with thousands of people) into a single piece of
: running code, can only be done by at most two people. I have not found any
: evidence to the contrary. Everything I read, all the work I personally
: involved with, and all the things have heard, do not provide a single
: counter-example.
So McCarthy invented lisp - 1 person
Daniel and Stephen implement it - 2 people
没毛病
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: Lisp is resulted from group efforts.
: McCarthy had planned to develop an automatic Lisp compiler using M-
: expressions as the language syntax and S-expressions to describe the
: compiler's internal processes. Stephen B. Russell read the paper and
: suggested to him that S-expressions were a more convenient syntax.
Although
: McCarthy disapproved of the idea, Russell and colleague Daniel J. Edwards : hand-coded an interpreter program that could execute S-expressions.[2]
This
: program was adopted by McCarthy's research group, establishing S-
expressions
: as the dominant form of Lisp.
: MSFT's Excel is another example.
I am talking about the concrete act of putting an idea initially in to code.
I am not talking about where the idea come from. I already said, the idea
may be the results of hundreds of interaction with thousands of people. When it is first realized in code as a running software, it is realized by one
person, or at most two persons.
This is a very specific and concrete description.
No one has been able to come up with a counter example. If you can, I would like to see it. Because it would be interesting.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: You are talking about the hinder most illusion.
: Is Intel Math Kernel Library (MKL) from one single person's idea?
: BLAS? Any physics computation/simulation software?
: Golang were from three people, right?
: of
No, you cannot throw in anything you want in literature. It has strict rules too, violating the rules and people will not accept it as literature (i.e. not compile). e.g. you cannot have a novel without a story.
【 在 Caravel (克拉维尔) 的大作中提到: 】
: Your basic reasoning is problematic.
: A software is certainly much closer to a building than poetry or novel.
: The software have strict rules, whatever you wrote must be compilable or
at
: least executable on a machine.
: In literature works，you could throw in anything you want. You can even
: ignore grammar if you want.
: times
: agree
McCarthy brought us two systems: S-expression and M-expression.
It was not possible to underestimate the importance of the decision of using the S-expression. That decision came from group engineering efforts.
【 在 nchip (脑残芯) 的大作中提到: 】
: So McCarthy invented lisp - 1 person
: Daniel and Stephen implement it - 2 people
: 没毛病
: Although
: This
: expressions
Does not matter. Irrelevant.
The code is written by at most two guys. That's my point. You have not come up with anything to the contrary.
In this business, people say "idea is cheap".
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: McCarthy brought us two systems: S-expression and M-expression.
: It was not possible to underestimate the importance of the decision of
using
: the S-expression. That decision came from group engineering efforts.
As I said earlier, ideas could be resulted directly from tons of group
engineering efforts. That is called the "population based wisdom" in AI.
Where the "the concrete act of putting an idea initially in to code."of the Golang came from?
Three people, right?
【 在 hci (海螺子) 的大作中提到: 】
: I am talking about the concrete act of putting an idea initially in to
code.
: I am not talking about where the idea come from. I already said, the idea : may be the results of hundreds of interaction with thousands of people.
When
: it is first realized in code as a running software, it is realized by one
: person, or at most two persons.
: This is a very specific and concrete description.
: No one has been able to come up with a counter example. If you can, I
would
: like to see it. Because it would be interesting.
Ideas are cheap.
Who wrote the code? How do you know it's three people. It would be very
interesting. Show me.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: As I said earlier, ideas could be resulted directly from tons of group
: engineering efforts. That is called the "population based wisdom" in AI.
: Where the "the concrete act of putting an idea initially in to code."of
the
: Golang came from?
: Three people, right?
: code.
: When
: would
I stand corrected. I actually dug into golang commit log. It does show that three of them made large amount of code contributions initially. They are
not even the person who commit first.
But the main point still stands, just change the number 2 to 3.
But if you push harder, I would consider only griesemer and pike as the
initial authors. Because ken was just fixing things very early on.
【 在 hci (海螺子) 的大作中提到: 】
: Ideas are cheap.
: Who wrote the code? How do you know it's three people. It would be very
: interesting. Show me.
: the
You can find the answer from github.
Besides Golang, could the BLAS,MKL,...etc from a single author?
Even the most simplest random number lib could be resulted from different
people's work.
【 在 hci (海螺子) 的大作中提到: 】
: Ideas are cheap.
: Who wrote the code? How do you know it's three people. It would be very
: interesting. Show me.
: the
Golang's initial team outsourced the scheduler to a Russian guy later.
Let's change the number into 4. LoL
You intended to name the author of the first single letter of a book as the only author. That is ridiculous.
【 在 hci (海螺子) 的大作中提到: 】
: I stand corrected. I actually dug into golang commit log. It does show
that
: three of them made similar amount of code contributions initially. They
are
: not even the person who commit first.
: But the main point still stands, just change the number 2 to 3.
BLAs and MKL would not be the kind of software I am talking about. these are collections to begin with.
As I said, if you push it, I would say golang had only two initial authors. ken would not count.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: You can find the answer from github.
: Besides Golang, could the BLAS,MKL,...etc from a single author?
: Even the most simplest random number lib could be resulted from different : people's work.
Ken Thompson wrote the initial compiler.
"
Ken Thompson's main code contribution was writing the Go compiler, so you
can thank him for Go code compiling so fast.
" --Somebody from the Quora
【 在 hci (海螺子) 的大作中提到: 】
: BLAs and MKL would not be the kind of software I am talking about. these
are
: collections to begin with.
: As I said, if you push it, I would say golang had only two initial authors.
: ken would not count.
No.
The main authors are just two. ken was just fixing things. outsource parts
doesn't count either.
I am just stating the fact. If you look at the content of the commit. I
think my initial estimate of at most two persons is correct.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: Golang's initial team outsourced the scheduler to a Russian guy later.
: Let's change the number into 4. LoL
: You intended to name the author of the first single letter of a book as
the
: only author. That is ridiculous.
: that
: are
Not from the commit log. From the commit log, he's not the language designer, for most of the spec is by the other two guys. His written the compiler is like that Russian guy they outsourced to for the scheduler. As a new
language, I would credit the other two guys. It's all in the commit log.
There's no point arguing about fact.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: Ken Thompson wrote the initial compiler.
: "
: Ken Thompson's main code contribution was writing the Go compiler, so you : can thank him for Go code compiling so fast.
: " --Somebody from the Quora
: are
: .
It was quite normal that a group of people kept polishing a software
and it turned into a different thing later.
Java initially was an embedded language. Without population based wisdom,
there is no Java web app/server.
【 在 hci (海螺子) 的大作中提到: 】
: No.
: The main authors are just two. ken was just fixing things. outsource parts
: doesn't count either.
: I am just stating the fact. If you look at the content of the commit. I
: think my initial estimate of at most two persons is correct.
: the
It did not matter. The structure of a software could change later and new
people could join and redefine the target of the software.
On the other hand, there were many domain specific softwares which was not
possible a result a single/2/3/4 people's work because a single people did not have multi-domains knowledge. For example,the embedded code set of F16.
【 在 hci (海螺子) 的大作中提到: 】
: Not from the commit log
Irrelevant.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: It was quite normal that a group of people kept polishing a software
: and it turned into a different thing later.
: Java initially was an embedded language. Without population based wisdom,
: there is no Java web app/server.
robpike 257 commits
griesemer 183 commits
ken 175 commits
rsc 22 commits
【 在 hci (海螺子) 的大作中提到: 】
: I stand corrected. I actually dug into golang commit log. It does show
that
: three of them made large amount of code contributions initially. They are : not even the person who commit first.
: But the main point still stands, just change the number 2 to 3.
: But if you push harder, I would consider only griesemer and pike as the
: initial authors. Because ken was just fixing things very early on.
Irrelevant.
Instruction sets, math libraries, etc. are not the kind of software I am
talking about. They are not a system that runs.
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: It did not matter. The structure of a software could change later and new : people could join and redefine the target of the software.
: On the other hand, there were many domain specific softwares which was not
: possible a result a single/2/3/4 people's work because a single people
did
: not have multi-domains knowledge. For example,the embedded code set of F16.
Number doesn't mean anything.
golang is a new language. Whoever wrote the initial spec of the language are the authors. There were only two: pike and griesmer.
The first commit of ken was already the implementation of the compiler. So
it depends on how you want to count it. I wouldn't count him as the language designer.
【 在 Caravel (克拉维尔) 的大作中提到: 】
: https://github.com/golang/go/graphs/contributors?from=2007-03-19&to=2008-
09-
: 09&type=c
: robpike 257 commits
: griesemer 183 commits
: ken 175 commits
: rsc 22 commits
: that
You could put BLAS under your theory as Goto started/implemented the modern one.
【 在 hci (海螺子) 的大作中提到: 】
: BLAs and MKL would not be the kind of software I am talking about. these
are
: collections to begin with.
: As I said, if you push it, I would say golang had only two initial authors.
: ken would not count.
Good to know.
Why are we even arguing about these?
I thought everybody here had done enough programming to know how it is done in the real world.
Apparently we got some people who have not done any serious software work.
These are the "ideas guys" we often heard about?
There are CTOs who write production code, and CTOs who do not.
Guess who is who?
【 在 pptwo (pp) 的大作中提到: 】
: You could put BLAS under your theory as Goto started/implemented the
modern
: one.
: are
: .
【 在 hci (海螺子) 的大作中提到: 】
: Good to know.
: Why are we even arguing about these?
: I thought everybody here had done enough programming to know how it is
done
: in the real world.
: Apparently we got some people who have not done any serious software work.
: These are the "ideas guys" we often heard about?
: There are CTOs who write production code, and CTOs who do not.
: Guess who is who?
: modern
反例来了
【 在 hci (海螺子) 的大作中提到: 】
: Good to know.
: Why are we even arguing about these?
: I thought everybody here had done enough programming to know how it is
done
: in the real world.
: Apparently we got some people who have not done any serious software work.
: These are the "ideas guys" we often heard about?
: There are CTOs who write production code, and CTOs who do not.
: Guess who is who?
: modern
How so? Explain
【 在 helpme(名虚胖字满肥) 的大作中提到: 】
: https://yq.aliyun.com/articles/653511
: 反例来了
: done
你这个发言已经毫无理性了。
很多软件是包含几十个领域的具体知识的。两个人怎么写？你找两个人写个飞机控制系统
我看看。传感器都写不出来。
这种例子数不胜数。
电视上前几天刚放的MSFT AI选啤酒口味的系统。三个人写的出吗？
【 在 hci(海螺子) 的大作中提到: 】
<br>: How so? Explain
<br>
你这立场摇摆不定怎么辩论啊，一下子是1，2人，一下有可以放宽到3，4人。一下子要求design，一下子又是写code。到底是哪个？别人给你证据你又各种做鸵鸟各种抵赖
你说的例子，和二人律不矛盾。
1. domain knowledge需要很多人，和我说的写软件就两人，没有任何矛盾。
2. 大型项目，分块往往是明显的，必然是分组分头做自己的软件。每个组的软件的写
作，也是符合二人律的。
【 在 guvest (我爱你老婆Anna) 的大作中提到: 】
: 你这个发言已经毫无理性了。
: 很多软件是包含几十个领域的具体知识的。两个人怎么写？你找两个人写个飞机控制系统
: 我看看。传感器都写不出来。
: 这种例子数不胜数。
: 电视上前几天刚放的MSFT AI选啤酒口味的系统。三个人写的出吗？
:
: How so? Explain
:
目前来看，还是二人律不变，没放宽。
一个语言的设计，可以算是写一个软件的工作。而这个语言的实现，是另一个写软件的工作。所以这是两个软件。
设计一个语言是写spec，我自己搞过，我认为这也算是写软件，也要写test，结果也可以执行，要debug，无非是执行环境是脑子和纸笔而已。
而实现这个语言，那是完全不同的另一个软件，两者用的语言不同，输入输出不同，需求不同，不能算是同一个软件。而且，同一个语言，可以有完全不同的实现，说明这两者不是一个工作。
证据要阐述清楚的，给个阿里巴巴软文的链接算啥证据？我要求解释，这算鸵鸟抵赖？
【 在 Caravel (克拉维尔) 的大作中提到: 】
: 你这立场摇摆不定怎么辩论啊，一下子是1，2人，一下有可以放宽到3，4人。一下子要
: 求design，一下子又是写code。到底是哪个？别人给你证据你又各种做鸵鸟各种抵赖
继续扯就是，一个函数不需要超过两人，一行不需要超过两人。。。
你一会说即使像Linux这样大的软件系统也是二人律，一会又说大系统要细分成小
components来满足二人律，到底谁鸵鸟抵赖？？
【 在 hci (海螺子) 的大作中提到: 】
: 目前来看，还是二人律不变，没放宽。
: 一个语言的设计，可以算是写一个软件的工作。而这个语言的实现，是另一个写软件的
: 工作。所以这是两个软件。
: 设计一个语言是写spec，我自己搞过，我认为这也算是写软件，也要写test，结果也可
: 以执行，要debug，无非是执行环境是脑子和纸笔而已。
: 而实现这个语言，那是完全不同的另一个软件，两者用的语言不同，输入输出不同，需
: 求不同，不能算是同一个软件。而且，同一个语言，可以有完全不同的实现，说明这两
: 者不是一个工作。
: 证据要阐述清楚的，给个阿里巴巴软文的链接算啥证据？我要求解释，这算鸵鸟抵赖？
不要瞎扯淡，上面一直在说linux kernel. 这当然是二人律。没人提Linux系统。
大系统的分块在现实中甚至都不是个技术问题，往往是PHB政治斗争的结果，与软件屁
关系都没有，当然不是二人律讨论的范畴。二人律是具体落实到编程的时候的假说。
【 在 helpme (名虚胖字满肥) 的大作中提到: 】
: 你一会说即使像Linux这样大的软件系统也是二人律，一会又说大系统要细分成小
: components来满足二人律，到底谁鸵鸟抵赖？？
我说的这些都是大实话，也就你们这些没干过软件实践的还这这里抬杠，有意思么？
还什么”基本前提就错了“，这哪是什么前提，分明是实践中人人都知道的现象，我来总结一下，当成一个假说。
现在把这个假说的提法逐步完善，不是很自然么？
【 在 Caravel (克拉维尔) 的大作中提到: 】
: 继续扯就是，一个函数不需要超过两人，一行不需要超过两人。。。
我看你们扯来扯去， 很有意思。 是不是可以这么说， 盖一个楼， 当然是很牛逼的楼， 巴黎圣母院，或者人民大会堂级别的楼， hci的意思说， 绝大部分牛逼的楼，
master piece, 大师级别的， 其实都是一个人盖的，最多两个人。 另外一方说，不对，那施工方怎么算？ 大楼是广大民工盖得，还有室内装修啊什么的，怎么能算一两个
人的成果？
那厮一开始说所有软件都是二人律，没有反例。我举了阿里云的例子，里面重要组成部分例如分布式存储，任务调度以及网络通信等等就有七八项，初始团队就三十来个程序员。结果丫立刻改口说要把项目细分，每个下属项目仍然满足二人律。真没见过这么不要脸的。
【 在 magliner (magliner) 的大作中提到: 】
: 我看你们扯来扯去， 很有意思。 是不是可以这么说， 盖一个楼， 当然是很牛逼的楼
: ， 巴黎圣母院，或者人民大会堂级别的楼， hci的意思说， 绝大部分牛逼的楼，
: master piece, 大师级别的， 其实都是一个人盖的，最多两个人。 另外一方说，不对
: ，那施工方怎么算？ 大楼是广大民工盖得，还有室内装修啊什么的，怎么能算一两个
: 人的成果？
你也太自我中心了，你那个鸟文我看都没看，让你explains你不回我就没鸟你。
我一直在与另一个人说话，你不要自作多情。
【 在 helpme(名虚胖字满肥) 的大作中提到: 】
: 那厮一开始说所有软件都是二人律，没有反例。我举了阿里云的例子，里面重要组成部
: 分例如分布式存储，任务调度以及网络通信等等就有七八项，初始团队就三十来个程序
: 员。结果丫立刻改口说要把项目细分，每个下属项目仍然满足二人律。真没见过这么不
: 要脸的。
你太不要脸了。
【 在 hci (海螺子) 的大作中提到: 】
: 你也太自我中心了，你那个鸟文我看都没看，让你explains你不回我就没鸟你。
: 我一直在与另一个人说话，你不要自作多情。
:
: 那厮一开始说所有软件都是二人律，没有反例。我举了阿里云的例子，里面重要
: 组成部
:
: 分例如分布式存储，任务调度以及网络通信等等就有七八项，初始团队就三十来
: 个程序
:
: 员。结果丫立刻改口说要把项目细分，每个下属项目仍然满足二人律。真没见过
: 这么不
:
: 要脸的。
:
哈哈。
【 在 helpme (名虚胖字满肥) 的大作中提到: 】
: 你太不要脸了。
我来结合我在研究所干过的经历给你说说。 我老很多年前再个国内小研究所干， 基本是干活的一批人， 当官的批人， 政工干部一批人 。 宣传科在政工干部里面， 每天
干什么呢？ 写材料。 不听话的，写你的材料， 干出成绩的， 也写材料，往部里汇报 。 写材料就很讲究了， 得写的有文采， 英雄人物要突出，几天不睡觉了，加班加点了，抛弃国外的优厚待遇了 等等等， 就是向党表忠心呗。 团队其他人，也得写，
生孩子顾不上了，怎么有团队精神了。 当官的，写得往里写， 在‘所党委的集体领导下 干出了什么什么’。
其实呢， 干了几年你就知道， 每个课题最牛逼的往往就一个人。 这个工程总体设计
，如何实施，大概会碰到什么困难，人家早就想好了 。 所以研究所才把人家请来。
就是盖大楼的例子，你说是设计师盖的还是民工盖的 ？
是个别英雄写的历史，还是人民群众写的历史？
是资本家养活了工人，还是工人养活了资本家？
中美贸易是美国赚了还是中国赚了？
是民主好还是集权好？
人性本善还是人性本恶？
其实这些都是工作过的人都心知肚明的，也就是一些大眼睛的学生或者学校里面呆久了的人在反对这个说法。
这些纯洁的小盆友，你把外面的世界的真相告诉他们，他们也不愿意相信，说你太不要脸了，和哈。
【 在 magliner (magliner) 的大作中提到: 】
: 我来结合我在研究所干过的经历给你说说。 我老很多年前再个国内小研究所干， 基本
: 是干活的一批人， 当官的批人， 政工干部一批人 。 宣传科在政工干部里面， 每天
: 干什么呢？ 写材料。 不听话的，写你的材料， 干出成绩的， 也写材料，往部里汇报
: 。 写材料就很讲究了， 得写的有文采， 英雄人物要突出，几天不睡觉了，加班加点
: 了，抛弃国外的优厚待遇了 等等等， 就是向党表忠心呗。 团队其他人，也得写，
: 生孩子顾不上了，怎么有团队精神了。 当官的，写得往里写， 在‘所党委的集体领导
: 下 干出了什么什么’。
: 其实呢， 干了几年你就知道， 每个课题最牛逼的往往就一个人。 这个工程总体设计
: ，如何实施，大概会碰到什么困难，人家早就想好了 。 所以研究所才把人家请来。: 就是盖大楼的例子，你说是设计师盖的还是民工盖的 ？
: ...................
我说的核心意思就是宣传材料呢，真真假假，假假真真。 古人说了么， 尽信书不如不看书。
另外， 我说的项目，当时都是国家级的项目，做完了以后，都是部里一等奖的。 阿里云肯定是够档次了。
所领导也乐意这么写。 个人牛逼了， 可以申报院士。 集体牛逼了， 可以申报先进集体。 我说的那个小研究组， 最后到人民大会堂领的奖。
不光是宣传材料，其实是教育也是如此。
我老也当过教授的，随大流也要求学生做group project，培养团队精神啥的，等等，
现在想想，其实是让小盆友事先适应社会真相，就是一个software group project，代码是一两个人写的，但大家都得一样的credit。在学校里就适应了，以后工作了就不觉得奇怪了。
公司其实也知道，面试人的时候，问resume上的project的情形，都会问，What's your role in this group project? 因为其实大家都知道group project是咋回事，人和人的贡献不是一样的。
【 在 magliner (magliner) 的大作中提到: 】
: 我说的核心意思就是宣传材料呢，真真假假，假假真真。 古人说了么， 尽信书不如不
: 看书。
: 另外， 我说的项目，当时都是国家级的项目，做完了以后，都是部里一等奖的。 阿里
: 云肯定是够档次了。
: 所领导也乐意这么写。 个人牛逼了， 可以申报院士。 集体牛逼了， 可以申报先进集
: 体。 我说的那个小研究组， 最后到人民大会堂领的奖。
我们当时还流行（ 也许现在依然流行）大学生建模竞赛，三个人一组。 我们学校一直玩这个，老师都知道怎么玩，肯定会得奖。 就把领导的孩子塞进一个实力最强的组里
。 其实真正做的就一个人。 最后果然这个组拿了奖。 到了年底评先进， 只有一个名额， 三个人选谁？ 是干活的，还是领导的孩子 ？
当然是领导的孩子， 因为校长也要晋升。后来干活的那个特别不服气， 事闹大了，
研究生都不让他报名。 对了， 根本就不让你报名考。 分配的时候直接到小山沟。
你们知道当年大学生工作是国家分配的么？ 其实说穿了就是几个领导大笔一挥。 让你到哪儿去就得到哪去。