

>潘多拉（Pandora）“具有一切天赋的女人”

# ChatGPT
ChatGPT 实在是当红炸子鸡，其火爆程度，甚至我的 `older sister in law` (实在不知道怎么说，我对称谓那一套没什么兴趣，觉得一切简化成叔叔阿姨多方便) 都在好奇是什么东西，也想去体验一下对话。

我对其兴趣并不是很高。
其实在现在的生活中不难想象，网络兴起之后，无法见面的陌生交流甚至可能占据了我们的绝大多数对话。
* 你在在线电子游戏中和另一个人的对话是什么体验？
* 现在将对面的人换成一个高度聪明的AI是什么感觉？
* 对话的过程中核心点是什么？

# 交流
## 对话的意义
### 信息类
此时我们有更加明确的目的性，对于对话过程的信息更加关注，希望交谈中的双方交换尽可能多的信息。以及对于信息的有效性能够尽量做到足够的精确。 交换精确的信息并达成一致时交流的目的。

对于现有的AI产品，我对该能力不存在任何怀疑，计算机对于资料的存储和检索能力远超于任何人类。IBM的深蓝在很多年前就对医疗行业进行了尝试，灌入大量医学论文和数据之后，对于疾病的诊断成功率非常之高，甚至是非常小众的病例。

其阻碍核心我认为在于，在于大量的非结构化数据中，能否自助发现与区分`知识`或者说`信息`。而如今的引导式对话，依然是否看成一种辅助数据标注手段？

### 心理需求类
在此类对话中，往往对于信息要求更低，前一段时间网络热词 `摸鱼搭子` 便是属于此类。人生的目的并不是每分每秒都在创造大众正向价值，如果如此人类便是机器而不是人类了，同时文化娱乐行业也便不复存在。正由于存在心理需求，有时候进行的对话，并不十分看重信息，更看重的交流过程的愉悦感。取悦于交流双方才是交流的目的。

在此场景中，尚没有可靠的体验，不过如何定义 `Shell` 中是否运行的是`Programe` 还是 `Ghost`？

# 遥远的潘多拉
如今的AI已经在生产力只是小试牛刀，在信息产生和处理，尤其是自然语言知识处理方面的未来，个人认为几乎已成定论。

对于普通人，AI过于遥远。并非我们无法体验AI产品，得益于工业化，我们甚至可以以非常低廉的价格体验AI带来的功能，然而，普通大众将离AI的核心越来越远，无论是认知理解，还是控制。

同时AI的兴起一定是带来大量工种的消失。如果认为AI兴起会去除部分工种然后带来新的工种未免过于乐观。可能去除了10W个信息类岗位，却只增加了几个技术研发岗位。无论是工种能力级别还是岗位数量差上，可能存在着天量的鸿沟。

而这，就引出了最根本的问题。AI将会带来最严重的劳动关系危机。现行的劳动关系中认为， `人是需要劳动的，劳动使人幸福` 而当AI上岗之后，人类的劳动任务，消失了。而当有任何新的想法，发现AI都已经处理了，将如何面对茫然？在新的劳动关系建立之前，可能对于我们内心的自身价值与存在的定义将会引发更多的思考。

同时，由于劳动关系的改善，另一个直接的物理现实问题就是，AI上岗将会将生产资料高度集中。甚至无产阶级也将不会再被需要，或只需要少量的低端劳动力（随着技术发展，机器人一定将会更加的先进）。多年以前就有过一起争论，是否应该征收 `机器人税` ， 这个问题放到现在来看，确实是AI风暴来临之前的小小风雨。那么，在分配关系上我们是否做好了准备？

<blockquote>
潘多拉（Pandora）“具有一切天赋的女人”
</blockquote>
<h1>ChatGPT</h1>
ChatGPT 实在是当红炸子鸡，其火爆程度，甚至我的 <code class="language-text">older sister in law</code> (实在不知道怎么说，我对称谓那一套没什么兴趣，觉得一切简化成叔叔阿姨多方便) 都在好奇是什么东西，也想去体验一下对话。
我对其兴趣并不是很高。
其实在现在的生活中不难想象，网络兴起之后，无法见面的陌生交流甚至可能占据了我们的绝大多数对话。
<ul>
<li>你在在线电子游戏中和另一个人的对话是什么体验？</li>
<li>现在将对面的人换成一个高度聪明的AI是什么感觉？</li>
<li>对话的过程中核心点是什么？</li>
</ul>
<h1>交流</h1>
<h2>对话的意义</h2>
<h3>信息类</h3>
此时我们有更加明确的目的性，对于对话过程的信息更加关注，希望交谈中的双方交换尽可能多的信息。以及对于信息的有效性能够尽量做到足够的精确。 交换精确的信息并达成一致时交流的目的。
对于现有的AI产品，我对该能力不存在任何怀疑，计算机对于资料的存储和检索能力远超于任何人类。IBM的深蓝在很多年前就对医疗行业进行了尝试，灌入大量医学论文和数据之后，对于疾病的诊断成功率非常之高，甚至是非常小众的病例。
其阻碍核心我认为在于，在于大量的非结构化数据中，能否自助发现与区分<code class="language-text">知识</code>或者说<code class="language-text">信息</code>。而如今的引导式对话，依然是否看成一种辅助数据标注手段？
<h3>心理需求类</h3>
在此类对话中，往往对于信息要求更低，前一段时间网络热词 <code class="language-text">摸鱼搭子</code> 便是属于此类。人生的目的并不是每分每秒都在创造大众正向价值，如果如此人类便是机器而不是人类了，同时文化娱乐行业也便不复存在。正由于存在心理需求，有时候进行的对话，并不十分看重信息，更看重的交流过程的愉悦感。取悦于交流双方才是交流的目的。
在此场景中，尚没有可靠的体验，不过如何定义 <code class="language-text">Shell</code> 中是否运行的是<code class="language-text">Programe</code> 还是 <code class="language-text">Ghost</code>？
<h1>遥远的潘多拉</h1>
如今的AI已经在生产力只是小试牛刀，在信息产生和处理，尤其是自然语言知识处理方面的未来，个人认为几乎已成定论。
对于普通人，AI过于遥远。并非我们无法体验AI产品，得益于工业化，我们甚至可以以非常低廉的价格体验AI带来的功能，然而，普通大众将离AI的核心越来越远，无论是认知理解，还是控制。
同时AI的兴起一定是带来大量工种的消失。如果认为AI兴起会去除部分工种然后带来新的工种未免过于乐观。可能去除了10W个信息类岗位，却只增加了几个技术研发岗位。无论是工种能力级别还是岗位数量差上，可能存在着天量的鸿沟。
而这，就引出了最根本的问题。AI将会带来最严重的劳动关系危机。现行的劳动关系中认为， <code class="language-text">人是需要劳动的，劳动使人幸福</code> 而当AI上岗之后，人类的劳动任务，消失了。而当有任何新的想法，发现AI都已经处理了，将如何面对茫然？在新的劳动关系建立之前，可能对于我们内心的自身价值与存在的定义将会引发更多的思考。
同时，由于劳动关系的改善，另一个直接的物理现实问题就是，AI上岗将会将生产资料高度集中。甚至无产阶级也将不会再被需要，或只需要少量的低端劳动力（随着技术发展，机器人一定将会更加的先进）。多年以前就有过一起争论，是否应该征收 <code class="language-text">机器人税</code> ， 这个问题放到现在来看，确实是AI风暴来临之前的小小风雨。那么，在分配关系上我们是否做好了准备？

遥远的潘多拉


> 短期看政策，中期看土地，长期看人口。

但是这句话对于个人的指导价值约等于放屁。普通人没有足够的资金进行添油战术一样的长线投资。而指望人口的调整而对某些绑定了锚定人口的刚需资源会极端降价，更是白日做梦。人生短短几十年，用几十年后的可能存在胡萝卜拉不动背后的磨。就像我不喜欢演化论，species 演化代表了无数个体的死亡或者说失去繁衍价值。长期看人口，同样意味着，本世代的大多数都将会是牺牲品。

有个说法是"作为资金水池，偏偏锚定了最让大众需求的XX"。我认为这地方至少有两个错误。 
1. XX是否是水池，水池/水库的作用是削峰填谷，洪峰来临之时，将水存入库容，干旱之时放出库容供给使用。那么，这个当资金涌入了这个行业，资金是否存储起来？还是像吃饭一样，肠道一日游。
2. 偏偏锚定了大众刚需。到底是为了饺子买瓶醋，还是为了这瓶儿醋，包了这顿饺子？这件事大家各有看法。但是我认为，就算不是XX行业，也必然是每个人必须的行业，几千年来的盐铁行业换成了另一个行业而已。

> 大基建是为未来计

我在ALIBABA的时候感叹，"这家公司真low，内控审查披露没几次数量商10w，居然还有十几块被查的"。但是华为在我就职期间给每个员工可是结结实实发了将近2000元。被内控查处的贪腐资金，平分给每个员工。当时华为的员工至少10W+。这是何等巨量的资金。诚然，不同公司的内控水平存在差异，职业侵占手段不一样都会影响这些。但是，我觉得，之所以有如此巨量的差异。因为当时的业务线是制造线，制造线天然存在海量的资金流水，尤其是涉及供应链等。而藏住一片树叶，放在树林就可以。ALIBABA很少有这样的不容易被发现的海量资金流。
同时由于地理区位优势，以及内部消费疲软（我个人认为，互联网在放贷化之前的过去15年，就是吃的消费的面包渣，而这一切，几乎都是外资主导），东南沿海优势将持续扩大。大基建能否顺应以后的发展？第一次把一条狗送到月球，是工程技术的结晶。但是第二次如果依然只是送一条狗上月球。可以说是缺心眼了。大众的脚也说明了这种趋势。"江西处在全国前十的省环绕，去哪儿打工都方便" 这样的调侃更加说明了，人口向经济活力更强的地区流动已经是事实，而滚雪球的游戏中， winner takes all。 用户的需求是用上电，那么长途假设高压线路能达到，但是安装一套太阳能也能做到。为什么偏偏要选择更昂贵且没有后续价值的方案？


<blockquote>
短期看政策，中期看土地，长期看人口。
</blockquote>
但是这句话对于个人的指导价值约等于放屁。普通人没有足够的资金进行添油战术一样的长线投资。而指望人口的调整而对某些绑定了锚定人口的刚需资源会极端降价，更是白日做梦。人生短短几十年，用几十年后的可能存在胡萝卜拉不动背后的磨。就像我不喜欢演化论，species 演化代表了无数个体的死亡或者说失去繁衍价值。长期看人口，同样意味着，本世代的大多数都将会是牺牲品。
有个说法是”作为资金水池，偏偏锚定了最让大众需求的XX”。我认为这地方至少有两个错误。
<ol>
<li>XX是否是水池，水池/水库的作用是削峰填谷，洪峰来临之时，将水存入库容，干旱之时放出库容供给使用。那么，这个当资金涌入了这个行业，资金是否存储起来？还是像吃饭一样，肠道一日游。</li>
<li>偏偏锚定了大众刚需。到底是为了饺子买瓶醋，还是为了这瓶儿醋，包了这顿饺子？这件事大家各有看法。但是我认为，就算不是XX行业，也必然是每个人必须的行业，几千年来的盐铁行业换成了另一个行业而已。</li>
</ol>
<blockquote>
大基建是为未来计
</blockquote>
我在ALIBABA的时候感叹，“这家公司真low，内控审查披露没几次数量商10w，居然还有十几块被查的”。但是华为在我就职期间给每个员工可是结结实实发了将近2000元。被内控查处的贪腐资金，平分给每个员工。当时华为的员工至少10W+。这是何等巨量的资金。诚然，不同公司的内控水平存在差异，职业侵占手段不一样都会影响这些。但是，我觉得，之所以有如此巨量的差异。因为当时的业务线是制造线，制造线天然存在海量的资金流水，尤其是涉及供应链等。而藏住一片树叶，放在树林就可以。ALIBABA很少有这样的不容易被发现的海量资金流。
同时由于地理区位优势，以及内部消费疲软（我个人认为，互联网在放贷化之前的过去15年，就是吃的消费的面包渣，而这一切，几乎都是外资主导），东南沿海优势将持续扩大。大基建能否顺应以后的发展？第一次把一条狗送到月球，是工程技术的结晶。但是第二次如果依然只是送一条狗上月球。可以说是缺心眼了。大众的脚也说明了这种趋势。“江西处在全国前十的省环绕，去哪儿打工都方便” 这样的调侃更加说明了，人口向经济活力更强的地区流动已经是事实，而滚雪球的游戏中， winner takes all。 用户的需求是用上电，那么长途假设高压线路能达到，但是安装一套太阳能也能做到。为什么偏偏要选择更昂贵且没有后续价值的方案？

我怎么看未来和现在


Q：如何提升系统的稳定性？
* 靠人的主观能动性值班？
* 靠BUG与开发人员KPI绑定的压力？

实际上系统稳定性是一个更加追求科学与现代化的过程，我们需要不断的做出改进，包含但不限于
* 研发和测试和回顾流程不断进行调优
* 良性的错误评估与修正计划
* 长期架构优化演进计划
* 良好的灰度与监控
* 良好的快速反应方案SOP
* 其他

看，面向现代化的第一个问题就是：接受人的能力限界。
也许有少部分人真的能够能像段子中的 `Jeff Dean` 一样厉害，但是当成为一个团队的时候，我们并不会按照 `Jeff Dean` 的能力作为团队基准，而是以团队平均能力制作整体方案。

`为什么会有那么多流程，流程貌似除了制造麻烦，根本没有创造任何价值` 这是我在华为工作的时候最深的疑惑，而在许多年后我才想明白这个问题，流程就是承认人存在能力限界，
于是在现代化的过程中，提出了无数的管理模型与开发模型以及流程，其目的就是积攒前任的工作经验，后续的人们就不再需要一次又一次的把以前踩过的坑再踩一遍，良好的流程是快速提升团队
管理合作能力的工具。同时这需要我们对流程有足够多的认识，包含但不限于流程产生是为了规避哪些问题，结合我们的团队与工作能够有多少调整。

我在网络论坛看到一个case
```
国内私企只知道减少成本及造假，某某地铁的事故就是例子，所以xx年之后，都是国企承建一切。
```

这位网友明显不太了解现在土建行业的分包等等其他问题。也不是了解我们的合格的产品是如何出厂的。现在工业之所以伟大，主要原因是QA。因为有了各个环节的QA标准，才能保准最终的SLA。供应链QA
管理更加是重中之重，如果他觉得国企更可靠，那谁对QA审查负责呢。当然此处并不讨论 国企私企的优越性，能够提供合格产品的企业就是好的企业。合格的产品并不是意味着怎么都好，而是达到SLA，或者
达到产品QA标准。毕竟“把煤炭洗的白白的，并不产生更多的价值。”

现代化的问题，终究还是要用现代化的方法来解决。


Q：如何提升系统的稳定性？
<ul>
<li>靠人的主观能动性值班？</li>
<li>靠BUG与开发人员KPI绑定的压力？</li>
</ul>
实际上系统稳定性是一个更加追求科学与现代化的过程，我们需要不断的做出改进，包含但不限于
<ul>
<li>研发和测试和回顾流程不断进行调优</li>
<li>良性的错误评估与修正计划</li>
<li>长期架构优化演进计划</li>
<li>良好的灰度与监控</li>
<li>良好的快速反应方案SOP</li>
<li>其他</li>
</ul>
看，面向现代化的第一个问题就是：接受人的能力限界。
也许有少部分人真的能够能像段子中的 <code class="language-text">Jeff Dean</code> 一样厉害，但是当成为一个团队的时候，我们并不会按照 <code class="language-text">Jeff Dean</code> 的能力作为团队基准，而是以团队平均能力制作整体方案。
<code class="language-text">为什么会有那么多流程，流程貌似除了制造麻烦，根本没有创造任何价值</code> 这是我在华为工作的时候最深的疑惑，而在许多年后我才想明白这个问题，流程就是承认人存在能力限界，
于是在现代化的过程中，提出了无数的管理模型与开发模型以及流程，其目的就是积攒前任的工作经验，后续的人们就不再需要一次又一次的把以前踩过的坑再踩一遍，良好的流程是快速提升团队
管理合作能力的工具。同时这需要我们对流程有足够多的认识，包含但不限于流程产生是为了规避哪些问题，结合我们的团队与工作能够有多少调整。
我在网络论坛看到一个case
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">国内私企只知道减少成本及造假，某某地铁的事故就是例子，所以xx年之后，都是国企承建一切。</code></pre></div>
这位网友明显不太了解现在土建行业的分包等等其他问题。也不是了解我们的合格的产品是如何出厂的。现在工业之所以伟大，主要原因是QA。因为有了各个环节的QA标准，才能保准最终的SLA。供应链QA
管理更加是重中之重，如果他觉得国企更可靠，那谁对QA审查负责呢。当然此处并不讨论 国企私企的优越性，能够提供合格产品的企业就是好的企业。合格的产品并不是意味着怎么都好，而是达到SLA，或者
达到产品QA标准。毕竟“把煤炭洗的白白的，并不产生更多的价值。”
现代化的问题，终究还是要用现代化的方法来解决。

现代化的问题

>当你老了
>
>眼眉低垂
>
>灯火昏黄不定
>
>当我老了
>
>我真希望
>
>这首歌是唱给你的
>
> &mdash; <cite>[赵照][1]</cite>
[1]: https://baike.baidu.com/item/当你老了/13871014

人是很难改变的，`江山易改，本性难移`，有的习惯一辈子都无法改变，尤其是等待他人变化的过程，往往使人沮丧而失望。人是会变的，人会顿悟，也会缓慢而又无声的的变化，往往在不经意间发现不一样的自己与别人。而我，变得更加的慵懒，不那么极端化。

有人评价过我，过于极端化，那是很久之前了，我不久之前才想明白。其实想想，过于极端化的，不止是我，现在的网络舆论环境中，舆论更显得极端。

每个人的经历，认知不同，造成每个人对不同事务的不同看法，这是一件非常正常的事情。但是如果持有了看法与观点，便如入高塔，只顾对其他观点进行攻讦，以捍卫观点更“正确”来捍卫自身影响力及心理激励。便是落入了下乘。在某件事情上持有相同看法并不代表是朋友，持有相反观点也并不见得是敌人。同时敌人的敌人也不见得是朋友。

世界上，没有那么多的正确。更多的不过是取舍以及无奈。我们渴望能够改变一切，让我们的生活更美好，让世界按照我们的设想运转，让世界听到我的声音。然而最终，我们的渴望却让我们走向了更极端的境地。不过，幸好我们都会面对真实的世界，我们会有沮丧，会有无力，却会一直跪着走下去。

<blockquote>
当你老了
眼眉低垂
灯火昏黄不定
当我老了
我真希望
这首歌是唱给你的
— <cite>[赵照][1]</cite>
[1]: <a href="https://baike.baidu.com/item/%E5%BD%93%E4%BD%A0%E8%80%81%E4%BA%86/13871014">https://baike.baidu.com/item/当你老了/13871014</a>
</blockquote>
人是很难改变的，<code class="language-text">江山易改，本性难移</code>，有的习惯一辈子都无法改变，尤其是等待他人变化的过程，往往使人沮丧而失望。人是会变的，人会顿悟，也会缓慢而又无声的的变化，往往在不经意间发现不一样的自己与别人。而我，变得更加的慵懒，不那么极端化。
有人评价过我，过于极端化，那是很久之前了，我不久之前才想明白。其实想想，过于极端化的，不止是我，现在的网络舆论环境中，舆论更显得极端。
每个人的经历，认知不同，造成每个人对不同事务的不同看法，这是一件非常正常的事情。但是如果持有了看法与观点，便如入高塔，只顾对其他观点进行攻讦，以捍卫观点更“正确”来捍卫自身影响力及心理激励。便是落入了下乘。在某件事情上持有相同看法并不代表是朋友，持有相反观点也并不见得是敌人。同时敌人的敌人也不见得是朋友。
世界上，没有那么多的正确。更多的不过是取舍以及无奈。我们渴望能够改变一切，让我们的生活更美好，让世界按照我们的设想运转，让世界听到我的声音。然而最终，我们的渴望却让我们走向了更极端的境地。不过，幸好我们都会面对真实的世界，我们会有沮丧，会有无力，却会一直跪着走下去。

当我老了


* 在知乎上看到一个类似的非常有意思的问题[《英雄本色》里小马哥仅仅因为跛了，江湖地位就一落千丈，算是剧情 bug 吗？](https://www.zhihu.com/question/367109543)。
* 《剧变：人类社会与国家危机的转折点》是一本相当不错的书，个人危机到更大的国家危机的行为处置都有不错的分析。类似的，在电视剧《大明王朝1556》中也提到过。三思，即思危，思退，思变。

> 学生习气：太看不起别人，太看得起别人，太看不起自己，太看得起自己。

这句话非常矛盾吗，非常矛盾。但是也不矛盾，其核心是”无法判断和确认自身价值和周围环境及团队价值“。

我经历过或者现在还在经历巨大的危机，在危机中反视自身，方才终于明白什么是眼界太小。 非常有趣的是我得每一份工作变动都让我有了不同的认识，当然，这并不能说危机帮助我们成长，就像不能说萨拉热窝那一枪导致了奥斯曼帝国的解体。但是危机确实往往是一个很不错的触发原因。

我的第一次工作剧烈变动后，我花了很长时间思考一个问题 *“我为什么要换工作?”* 一方面是对未知的巨大恐慌，另一方面也是对自己的一个提问。 价值是什么？是否对状况有改变？我开始怀念之前的生活了，因为回头想想，之前的老板对我简直是无法形容的包容了（当然，老板和我都没有龙阳之好，本人也没那个姿色）。

当然现在回头来看，如果刨去认识更多世界这个看法，其实与价值而言并没有太多，对于无论是心理状况还是其他状况并无其他改善。人生就是如此，怎么经过都是一年，所谓的追求更高，生活的精彩缤纷与难受，没准儿下个月就忘记了。就算现在因为某个事情如丧考妣，过一段时间回头看，其实也就是一段时间的经历。牢记和回味更像是某种情绪价值。

近期的工作变动则让我看到了一个更有意思的地方。我们时常追求卓越，是少口头上如此。但是有两点非常可疑
* 如何判定卓越
* 局部卓越是否有效
* 是否都能做到卓越

如何判定卓越其实非常麻烦，毕竟*横看成岭侧成峰，远近高低各不同*，在不同的观察者眼中就有不同的结果。况且我们大多数时候并不能选择观察者，以前在工作中，我们就讨论过，在互联网公司内 RD的结果到底怎么评判？ 如果以传统软件工程的思维来看，RD无非是*交付效率*，*SLA保障*作为评价基本盘。然而在互联网公司，甚至产品公司内部，RD往往要背负业务指标，这就产生了一个很奇怪的现象：RD在产品决策时无权投票（甚至不允许质疑需求合理性，防止打击团队士气），却要为产品结果负责（无论是薪酬还是晋升）。回过头来，我们往往无法选择评价者，我们却又必须要承受评价者的评价（作为需要回馈与互动的机构）。当然如果能够无视评价，那当然毋需理会。或者另一还有一条路，无欲则刚。

局部卓越是否有效，也是RD人员最容易显陷入的问题。RD往往标榜好学。他们确实很好学，各种奇怪的方案都能学习并简单应用，但是RD普遍缺少一个能力“评估”。IT行业有一个金句*No Silver Bullet*。很少有方案能从小到大各种情况都适合。于是我们往往需要在各种因素中选择合适的方案。无论是从*符合程度*，*可靠程度*，*团队匹配程度* 等等。学习的最终目的一定是有所作用，而作用并不一定体现在应用上，能够将学习经验应用在正确的评估与应用上，是一种非常难得的能力。

是否能做到卓越？人与自然的演进关系上有一个 “人定胜天”的阶段，认为主观能动性能解决所有问题。这当然与一贯的成长思维定势有关系，如果工作与评价体系相对固定，每天的工作内容和反馈都非常情绪。就会自然地认为，所有的事情只要去做就是可以实现的。我们能够选择事情走向某一面。然而非常不幸的是，事实并非如此。人生有多少事情是由不得自己，6个9甚至可能更多，自己能做主的事情少之又少。那能做到卓越的事情又有多少？少之又少。但这并不意味着我们直接沉沦于无法控制的失落中。我们能做的无非是做好每一个选择，剩下的，May God Bless America.

<ul>
<li>在知乎上看到一个类似的非常有意思的问题<a href="https://www.zhihu.com/question/367109543">《英雄本色》里小马哥仅仅因为跛了，江湖地位就一落千丈，算是剧情 bug 吗？</a>。</li>
<li>《剧变：人类社会与国家危机的转折点》是一本相当不错的书，个人危机到更大的国家危机的行为处置都有不错的分析。类似的，在电视剧《大明王朝1556》中也提到过。三思，即思危，思退，思变。</li>
</ul>
<blockquote>
学生习气：太看不起别人，太看得起别人，太看不起自己，太看得起自己。
</blockquote>
这句话非常矛盾吗，非常矛盾。但是也不矛盾，其核心是”无法判断和确认自身价值和周围环境及团队价值“。
我经历过或者现在还在经历巨大的危机，在危机中反视自身，方才终于明白什么是眼界太小。 非常有趣的是我得每一份工作变动都让我有了不同的认识，当然，这并不能说危机帮助我们成长，就像不能说萨拉热窝那一枪导致了奥斯曼帝国的解体。但是危机确实往往是一个很不错的触发原因。
我的第一次工作剧烈变动后，我花了很长时间思考一个问题 “我为什么要换工作?” 一方面是对未知的巨大恐慌，另一方面也是对自己的一个提问。 价值是什么？是否对状况有改变？我开始怀念之前的生活了，因为回头想想，之前的老板对我简直是无法形容的包容了（当然，老板和我都没有龙阳之好，本人也没那个姿色）。
当然现在回头来看，如果刨去认识更多世界这个看法，其实与价值而言并没有太多，对于无论是心理状况还是其他状况并无其他改善。人生就是如此，怎么经过都是一年，所谓的追求更高，生活的精彩缤纷与难受，没准儿下个月就忘记了。就算现在因为某个事情如丧考妣，过一段时间回头看，其实也就是一段时间的经历。牢记和回味更像是某种情绪价值。
近期的工作变动则让我看到了一个更有意思的地方。我们时常追求卓越，是少口头上如此。但是有两点非常可疑
<ul>
<li>如何判定卓越</li>
<li>局部卓越是否有效</li>
<li>是否都能做到卓越</li>
</ul>
如何判定卓越其实非常麻烦，毕竟横看成岭侧成峰，远近高低各不同，在不同的观察者眼中就有不同的结果。况且我们大多数时候并不能选择观察者，以前在工作中，我们就讨论过，在互联网公司内 RD的结果到底怎么评判？ 如果以传统软件工程的思维来看，RD无非是交付效率，SLA保障作为评价基本盘。然而在互联网公司，甚至产品公司内部，RD往往要背负业务指标，这就产生了一个很奇怪的现象：RD在产品决策时无权投票（甚至不允许质疑需求合理性，防止打击团队士气），却要为产品结果负责（无论是薪酬还是晋升）。回过头来，我们往往无法选择评价者，我们却又必须要承受评价者的评价（作为需要回馈与互动的机构）。当然如果能够无视评价，那当然毋需理会。或者另一还有一条路，无欲则刚。
局部卓越是否有效，也是RD人员最容易显陷入的问题。RD往往标榜好学。他们确实很好学，各种奇怪的方案都能学习并简单应用，但是RD普遍缺少一个能力“评估”。IT行业有一个金句No Silver Bullet。很少有方案能从小到大各种情况都适合。于是我们往往需要在各种因素中选择合适的方案。无论是从符合程度，可靠程度，团队匹配程度 等等。学习的最终目的一定是有所作用，而作用并不一定体现在应用上，能够将学习经验应用在正确的评估与应用上，是一种非常难得的能力。
是否能做到卓越？人与自然的演进关系上有一个 “人定胜天”的阶段，认为主观能动性能解决所有问题。这当然与一贯的成长思维定势有关系，如果工作与评价体系相对固定，每天的工作内容和反馈都非常情绪。就会自然地认为，所有的事情只要去做就是可以实现的。我们能够选择事情走向某一面。然而非常不幸的是，事实并非如此。人生有多少事情是由不得自己，6个9甚至可能更多，自己能做主的事情少之又少。那能做到卓越的事情又有多少？少之又少。但这并不意味着我们直接沉沦于无法控制的失落中。我们能做的无非是做好每一个选择，剩下的，May God Bless America.

我是主人公

### 是什么影响了个体之间对同一个事物/事件的情绪表现？

> 读《金瓶梅》而生怜悯心者，菩萨也；生畏惧心者，君子也；生欢喜心者，小人也；生效法心者，乃禽兽耳”

到目前为止，我一直持有的观点是：每个人都是独立个体，由于独立个体之间的长期积累事物观察与体验的不一致，形成了对同一客观事务的不同体验与感受。

> 　　老师让这几个同学回到自己的座位上，然后和颜悦色地说：“大家发现了吗？看的角度不同，杨桃的样子也就不一样。当我们看见别人把杨桃画成五角星的时候，不要忙着发笑，要看看人家是从什么角度看的。”
> 
>　　老师的教诲让我终生难忘。
> 
> &mdash; <cite>《画杨桃》岑桑</cite>

## 我们的观察与推论是否可靠？

此处的观察并不局限于用眼注视，更倾向于**探测(Detective)**。 
我们可以通过眼睛看到和煦的阳光，通过耳朵听到清脆的鸟鸣，通过鼻子嗅到迷人的芳香，通过舌头尝到鲜甜的汤汁，通过指尖感受到细腻的服饰，这一类可以说是最直接的身体体验，经由化学与电信号直接抵达大脑的原始体验。

除此之外，我们也可以通过社会性的方法方法进行观察。通过阅读书本获得知识，阅读报纸获得新闻实时，听取讲座，报告获取当前前沿的理论等对客观世界进行观察与学习。

但是，我们需要回想一个问题：我们的观察是否可靠？

通过身体本身电化学的反应来进行观察世界的结果是否是可靠的？不尽然，在生物遗传学上有一个著名的病症：红绿色盲(当年生物考试计算概率估计令不少人吃了苦头 ^_^ )。红绿色盲患者由于遗传因素导致患者无法正确的区分颜色。如果一个正常人和一个红绿色盲看同一双袜子，估计对于客观事务的观察认知会出现争论不休。另一个证明就是 对于香菜（芫荽）的适应性，部分人（比如我）特别讨厌香菜的怪味，另一部分人却觉得香菜美味无比。个体物理身体的原因导致对同一个事物观察的差距是如此之大，让人不得不怀疑，我们是否为***缸中之脑***，进而怀疑真实世界是否客观存在，我们是否为***Matrix***中的一个运行实例。扯远了。

而社会性方法的观察已经无数次证明，并非非常可靠。以讲座为例，前沿的理论可能在不久后的将来会被另一个理论所否定，抑或是由于演讲者本人的表述歧义导致受众的感受与想法南辕北辙。而炮制的假新闻也是层出不穷。

此外，对于大部分的偶然性事件，我们几乎不可能实现对于该类事物的直接观察与体验。于是往往需要我们引入推论，即结合现有的*主观观察证据*（如上两段，推断人不一样，可能观察结果发生极大差异）以及*主观经验*进行推论，对历史已经发生的事情进行*主观*的想象发挥。找寻证据与定罪的过程是找寻支撑**想象过程**的证据，以获得大众的*普适认知经验*的主观支持

这样的推论可靠吗？不知道，但是我们必须相信与依赖这样的结果，因为我们没有其他的方法来解决这样的场景遇到的这样的问题，客观真相已经无法观测。如果我们有时间机器也许可以回溯进行播放了解细节。

关于本部分，建议可以看一下*芥川龙之介*的《树林中》，一篇非常精炼而又有趣的短篇小说。

## 社会性观察的欺骗性
上一段中提到，如果需要做出令大众都支持的推论。则需要获得大众的*普适认知经验*的支持。

大众如何获取*普适认知经验*？ 我一般认为有两种，一种为亲身体验，如靠近火会烫伤。 另外一种为社会性观察习得，无论基础教育，还是广告，宣传，其实都是一种社会性观察的习得。

社会性观察会有欺骗性吗？这是当然的，所有传播行为一定存在主体，人/组织 所有行为均是利己行为。

如何实施？
1. 炮制假消息。 最简单的欺骗方法，但是容易被发现，也容易被驳斥。
2. 片段录取。经典图为美军喂水图，如果裁开图片只报道左边，则容易传播“美军对战俘进行暴力压制”，而如果裁开图片只报道又边，则容易传播“美军对战俘进行救治”。无论本张图拍摄于何种场景，图中到底为何种交互。本段描述只是为了说明该类方法可以进行社会性观察的欺骗。![喝水](irak005.jpg)
3. 场景忽略。一般认为的可接受行为往往具有场景约束，诡辩论者往往先描述成立场景下的合理性，然后引诱带入所有场景下的合理性，以获得不恰当的认同与传播效果。

4. 潜意识影响。通过前后描述形成潜意识，使受众无意识中接受夹杂其中的其他影响。典型案例: *芥川龙之介*《地狱变》，通过谄媚者的视角不停的谄媚描述，便容易忽略大公的暴戾与乖张。

## 如何观察与推论

<h3>是什么影响了个体之间对同一个事物/事件的情绪表现？</h3>
<blockquote>
读《金瓶梅》而生怜悯心者，菩萨也；生畏惧心者，君子也；生欢喜心者，小人也；生效法心者，乃禽兽耳”
</blockquote>
到目前为止，我一直持有的观点是：每个人都是独立个体，由于独立个体之间的长期积累事物观察与体验的不一致，形成了对同一客观事务的不同体验与感受。
<blockquote>
　　老师让这几个同学回到自己的座位上，然后和颜悦色地说：“大家发现了吗？看的角度不同，杨桃的样子也就不一样。当我们看见别人把杨桃画成五角星的时候，不要忙着发笑，要看看人家是从什么角度看的。”
 
　　老师的教诲让我终生难忘。
 
— <cite>《画杨桃》岑桑</cite>
</blockquote>
<h2>我们的观察与推论是否可靠？</h2>
此处的观察并不局限于用眼注视，更倾向于探测(Detective)。
我们可以通过眼睛看到和煦的阳光，通过耳朵听到清脆的鸟鸣，通过鼻子嗅到迷人的芳香，通过舌头尝到鲜甜的汤汁，通过指尖感受到细腻的服饰，这一类可以说是最直接的身体体验，经由化学与电信号直接抵达大脑的原始体验。
除此之外，我们也可以通过社会性的方法方法进行观察。通过阅读书本获得知识，阅读报纸获得新闻实时，听取讲座，报告获取当前前沿的理论等对客观世界进行观察与学习。
但是，我们需要回想一个问题：我们的观察是否可靠？
通过身体本身电化学的反应来进行观察世界的结果是否是可靠的？不尽然，在生物遗传学上有一个著名的病症：红绿色盲(当年生物考试计算概率估计令不少人吃了苦头 ^_^ )。红绿色盲患者由于遗传因素导致患者无法正确的区分颜色。如果一个正常人和一个红绿色盲看同一双袜子，估计对于客观事务的观察认知会出现争论不休。另一个证明就是 对于香菜（芫荽）的适应性，部分人（比如我）特别讨厌香菜的怪味，另一部分人却觉得香菜美味无比。个体物理身体的原因导致对同一个事物观察的差距是如此之大，让人不得不怀疑，我们是否为缸中之脑，进而怀疑真实世界是否客观存在，我们是否为Matrix中的一个运行实例。扯远了。
而社会性方法的观察已经无数次证明，并非非常可靠。以讲座为例，前沿的理论可能在不久后的将来会被另一个理论所否定，抑或是由于演讲者本人的表述歧义导致受众的感受与想法南辕北辙。而炮制的假新闻也是层出不穷。
此外，对于大部分的偶然性事件，我们几乎不可能实现对于该类事物的直接观察与体验。于是往往需要我们引入推论，即结合现有的主观观察证据（如上两段，推断人不一样，可能观察结果发生极大差异）以及主观经验进行推论，对历史已经发生的事情进行主观的想象发挥。找寻证据与定罪的过程是找寻支撑想象过程的证据，以获得大众的普适认知经验的主观支持
这样的推论可靠吗？不知道，但是我们必须相信与依赖这样的结果，因为我们没有其他的方法来解决这样的场景遇到的这样的问题，客观真相已经无法观测。如果我们有时间机器也许可以回溯进行播放了解细节。
关于本部分，建议可以看一下芥川龙之介的《树林中》，一篇非常精炼而又有趣的短篇小说。
<h2>社会性观察的欺骗性</h2>
上一段中提到，如果需要做出令大众都支持的推论。则需要获得大众的普适认知经验的支持。
大众如何获取普适认知经验？ 我一般认为有两种，一种为亲身体验，如靠近火会烫伤。 另外一种为社会性观察习得，无论基础教育，还是广告，宣传，其实都是一种社会性观察的习得。
社会性观察会有欺骗性吗？这是当然的，所有传播行为一定存在主体，人/组织 所有行为均是利己行为。
如何实施？
<ol>
<li>炮制假消息。 最简单的欺骗方法，但是容易被发现，也容易被驳斥。</li>
<li>片段录取。经典图为美军喂水图，如果裁开图片只报道左边，则容易传播“美军对战俘进行暴力压制”，而如果裁开图片只报道又边，则容易传播“美军对战俘进行救治”。无论本张图拍摄于何种场景，图中到底为何种交互。本段描述只是为了说明该类方法可以进行社会性观察的欺骗。<img src="/_next/static/content/posts/%E8%A7%82%E5%AF%9F%E4%B8%8E%E6%8E%A8%E8%AE%BA/irak005.jpg" alt="喝水"></li>
<li>场景忽略。一般认为的可接受行为往往具有场景约束，诡辩论者往往先描述成立场景下的合理性，然后引诱带入所有场景下的合理性，以获得不恰当的认同与传播效果。</li>
</ol>

<ol start="4">
<li>潜意识影响。通过前后描述形成潜意识，使受众无意识中接受夹杂其中的其他影响。典型案例: 芥川龙之介《地狱变》，通过谄媚者的视角不停的谄媚描述，便容易忽略大公的暴戾与乖张。</li>
</ol>
<h2>如何观察与推论</h2>

观察与推论

很纠结，想做点东西，却又不知道做啥好 
不过最近再看kotlin，于是就用kotlin+SpringBoot写了个Echo 然后配置了一下完整的部署流程 
BTW.缺少EC依然很蛋疼

## 接入

#### NGINX安装
由于偏向后端服务，而且也并没有准备写页面，所以就没有放cloudflare了，直接用nginx作为http server了.本来可以直接用NGINX官方repo直接用软件包安装的，但是我一直想试一下[LibreSSL](https://www.libressl.org/)(LibreSSL是OpenSSL心脏出血漏洞后由OpenBSD开发者从1.0.1 fork的一个版本，[官方的宣传](https://www.openbsd.org/papers/bsdcan14-libressl/))是否可以替代OpenSSL，于是手动编译了，编译参数可以根据./configure --help自行调整，我主要的参数调整就是关闭了不需要的邮件proxy，以及其他的语言网关，然后手动打开了HTTP/2和SSL
```
--with-http_ssl_module
--with-http_v2_module
```
还需要手动指定LibreSSL目录
```
--with-openssl=../libressl-2.6.3
```
目前看来替换完全OK，我以前在MAC上构建使用LibreSSL构建GIT时不知道为什么失败了，估计是以前的BUG吧。唯一的遗憾就是LibreSSL目前仍然不支持草案状态的TLSv1.3，，有人提了这个[issue](https://github.com/libressl-portable/portable/issues/228)，开发者的意思是:"这东西还在草案，别急(你急也没用)。" (BTW. OpenSSL 1.1+版本已经实现，TLSv1.3是个非常重要的版本，握手方式优化，简化了握手流程，据说减少1/3的连接建立时间)

 #### NGINX的配置
主要做了几点
1. HTTP强制301到HTTPS(仔细想想，貌似没啥卵用。毕竟没有页面。)
```
if ($scheme = http){
 rewrite ^/(.*) https://$host$request_uri permanent;
}
```
2. 开启HSTS(没有页面就不做CSP了，但是HSTS还是要做滴，最新版的wget都支持HSTS了)
```
add_header Strict-Transport-Security "max-age=15768000; includeSubDomains" always;
```
3. mirror，不直接将服务暴露额外搞个NGINX主要原因也是因为要用NGINX的mirror流量复制功能，方便需要本地写的时候直接接入，而又不侵入环境（不知道为什么mirror时proxy\_pass一定要强制附加$request_uri）当然还有一个考虑就是以后在这儿做接入控制。

## 代码以及代码仓库
代码托管于BitBucket，为什么不是Gayhub，因为Gayhub的私有repo要钱。同时BitBucket Pipeline还免费一个月提供50分钟的CI构建时间，勉强够用了。Pipeline构建出Docker包上传到hub.docker.com的私有repo

## 部署
在部署机器上编写docker-compose.yml文件使用docker-compose进行部署，当提交了新的代码后，Pipeline自动构建出包，然后在部署机器上只需要执行
```
docker pull <PACKAGE_NAME>
docker-compose up -d
```
就会自动更新部署，由于Docker打包的特性，每次升级实际上只升级了小部分layer，无论是上传docker还是从docker下载，实际上传输的大小都只有20+M，但导出镜像估计就得有500+M，毕竟JDK 9 的块头实在是太大，我试图自己封装也只是减少了40+M的样子，还不如直接套用现有的[azul/zulu-openjdk-debia](https://hub.docker.com/r/azul/zulu-openjdk-debian/)镜像.

## 下一步
1. 想出到底要做啥吧
2. 自动部署，不用自己去pull以及up，以及试试consul
3. 用这个学习K8S暂不考虑，这EC太破了，跑不动那么大的集群。

PS. Stream貌似鸽了很久，玩心太大，收不住啊~~~

PSS. 关于nginx mirror的用法，我一般是这样配置
```
 location /mirror {
 internal;
 proxy_pass http://127.0.0.1:8080$request_uri;
}
```
本地启动开发服务，监听本地8080，最重要的一步
使用SSH进行流量转派
```
ssh -R [remote_addr]:[remote_port]:[local_addr]:[local_port] <HOST_NAME>
```
我一般使用情况 i.e
```
ssh -R localhost:8080:localhost8080 <HOST_NAME>
```
SSHD将会监听` [remote_addr]:[remote_port]`地址上的流量，转发到` [local_addr]:[local_port] `，为什么一定要注明` remote_addr` 和` local_addr` 为localhost，主要是我个人习惯一般控只能制在本机能够访问。

很纠结，想做点东西，却又不知道做啥好 
不过最近再看kotlin，于是就用kotlin+SpringBoot写了个Echo 然后配置了一下完整的部署流程 
BTW.缺少EC依然很蛋疼
<h2>接入</h2>
<h4>NGINX安装</h4>
由于偏向后端服务，而且也并没有准备写页面，所以就没有放cloudflare了，直接用nginx作为http server了.本来可以直接用NGINX官方repo直接用软件包安装的，但是我一直想试一下<a href="https://www.libressl.org/">LibreSSL</a>(LibreSSL是OpenSSL心脏出血漏洞后由OpenBSD开发者从1.0.1 fork的一个版本，<a href="https://www.openbsd.org/papers/bsdcan14-libressl/">官方的宣传</a>)是否可以替代OpenSSL，于是手动编译了，编译参数可以根据./configure —help自行调整，我主要的参数调整就是关闭了不需要的邮件proxy，以及其他的语言网关，然后手动打开了HTTP/2和SSL
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">--with-http_ssl_module
--with-http_v2_module</code></pre></div>
还需要手动指定LibreSSL目录
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">--with-openssl=../libressl-2.6.3</code></pre></div>
目前看来替换完全OK，我以前在MAC上构建使用LibreSSL构建GIT时不知道为什么失败了，估计是以前的BUG吧。唯一的遗憾就是LibreSSL目前仍然不支持草案状态的TLSv1.3，，有人提了这个<a href="https://github.com/libressl-portable/portable/issues/228">issue</a>，开发者的意思是:“这东西还在草案，别急(你急也没用)。” (BTW. OpenSSL 1.1+版本已经实现，TLSv1.3是个非常重要的版本，握手方式优化，简化了握手流程，据说减少1/3的连接建立时间)
<h4>NGINX的配置</h4>
主要做了几点
<ol>
<li>HTTP强制301到HTTPS(仔细想想，貌似没啥卵用。毕竟没有页面。)</li>
</ol>
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">if ($scheme = http){
 rewrite ^/(.*) https://$host$request_uri permanent;
}</code></pre></div>
<ol start="2">
<li>开启HSTS(没有页面就不做CSP了，但是HSTS还是要做滴，最新版的wget都支持HSTS了)</li>
</ol>
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">add_header Strict-Transport-Security "max-age=15768000; includeSubDomains" always;</code></pre></div>
<ol start="3">
<li>mirror，不直接将服务暴露额外搞个NGINX主要原因也是因为要用NGINX的mirror流量复制功能，方便需要本地写的时候直接接入，而又不侵入环境（不知道为什么mirror时proxy_pass一定要强制附加$request_uri）当然还有一个考虑就是以后在这儿做接入控制。</li>
</ol>
<h2>代码以及代码仓库</h2>
代码托管于BitBucket，为什么不是Gayhub，因为Gayhub的私有repo要钱。同时BitBucket Pipeline还免费一个月提供50分钟的CI构建时间，勉强够用了。Pipeline构建出Docker包上传到hub.docker.com的私有repo
<h2>部署</h2>
在部署机器上编写docker-compose.yml文件使用docker-compose进行部署，当提交了新的代码后，Pipeline自动构建出包，然后在部署机器上只需要执行
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">docker pull &lt;PACKAGE_NAME>
docker-compose up -d</code></pre></div>
就会自动更新部署，由于Docker打包的特性，每次升级实际上只升级了小部分layer，无论是上传docker还是从docker下载，实际上传输的大小都只有20+M，但导出镜像估计就得有500+M，毕竟JDK 9 的块头实在是太大，我试图自己封装也只是减少了40+M的样子，还不如直接套用现有的<a href="https://hub.docker.com/r/azul/zulu-openjdk-debian/">azul/zulu-openjdk-debia</a>镜像.
<h2>下一步</h2>
<ol>
<li>想出到底要做啥吧</li>
<li>自动部署，不用自己去pull以及up，以及试试consul</li>
<li>用这个学习K8S暂不考虑，这EC太破了，跑不动那么大的集群。</li>
</ol>
PS. Stream貌似鸽了很久，玩心太大，收不住啊~~~
PSS. 关于nginx mirror的用法，我一般是这样配置
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text"> location /mirror {
 internal;
 proxy_pass http://127.0.0.1:8080$request_uri;
}</code></pre></div>
本地启动开发服务，监听本地8080，最重要的一步
使用SSH进行流量转派
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">ssh -R [remote_addr]:[remote_port]:[local_addr]:[local_port] &lt;HOST_NAME></code></pre></div>
我一般使用情况 i.e
<div class="gatsby-highlight" data-language="text"><pre style="counter-reset: linenumber NaN" class="language-text line-numbers"><code class="language-text">ssh -R localhost:8080:localhost8080 &lt;HOST_NAME></code></pre></div>
SSHD将会监听<code class="language-text"> [remote_addr]:[remote_port]</code>地址上的流量，转发到<code class="language-text">[local_addr]:[local_port]</code>，为什么一定要注明<code class="language-text"> remote_addr</code> 和<code class="language-text"> local_addr</code> 为localhost，主要是我个人习惯一般控只能制在本机能够访问。

自己实验环境的配置

# 写在正文之前
在[Java-8-Optional Optional](../Java-8-Optional/index.md)的文章中，我发现我大量的文本都在描述Optional到底怎么使用，这个确实有点偏离我的初衷，但其实是正常的，这个工具没有复杂的设计，带上注释也只有300+行代码，确实谈不上到源代码解析的程度。


# 问题:如何操作集合进行聚合操作？
假设存在一个Array，有一个典型任务要求计算所有内容的总长度(聚合操作)。
### 代码1
```java
 String[] param = new String[]{"this",
 "is",
 "a",
 "test"};
```
在传统代码上怎么写
```java
 int len = 0;
 for (int i = 0; i < param.length; i++) {
 len += param[i].length();
 }
```
如果只是输出每个内容物的长度，那么，其实还可以用
```java
Arrays.asList(param).forEach
```
但是聚合操作不行，直至Java 9 ，匿名类和lambda里面对于捕获的变量的访问一定是final的，不允许修改的，所以实际上对于Array的聚合操作只有两种方法，基于偏移的直接访问操作和迭代器访问操作。
如果是在Java 8中使用Stream API可以很简单的完成这一任务。
### 代码2
```java
Arrays.stream(param)
 .mapToInt(String::length)
 .sum();
```

对于Stream API的使用和基本概念可以看一下这篇参考文档[IBM Developer Works: Java 8 中的 Streams API 详解](https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html)，我觉得重新写一套没有意义，集中于重点，RT.JAR实现与类结构。

# 实现
我们从[代码2](#代码2)开始往下探查，对于[代码2](#代码2)中的Array的Stream创建最终都会委托到
代码3
```java
public static <T> Stream<T> stream(T[] array) {
 return stream(array, 0, array.length);
 }

/* 对输入进行Slice */
public static <T> Stream<T> stream(T[] array,
 int startInclusive,
 int endExclusive) {
 return StreamSupport.stream(spliterator(array,
 startInclusive,
 endExclusive), 
 false);
 } 
```
其中
### 代码4
```java
spliterator(array,startInclusive, endExclusive)
//内部实现如下:
public static <T> Spliterator<T> spliterator(T[] array,
 int startInclusive,
 int endExclusive) {
 return Spliterators.spliterator(array,
 startInclusive, 
 endExclusive, 
 Spliterator.ORDERED |Spliterator.IMMUTABLE);
 }

 public static final int ORDERED = 0x00000010;
 public static final int IMMUTABLE = 0x00000400;
```
这行代码的作用就是创建一个Spliterator，根据原代码的注释，Spliterator的作用就是对数据源的分割，数据源可以是Array，集合(collection)，或者<abbr title="Java 里面还没有这个鬼东西，但是文档是这么说的 _(:з)∠)_">Generator Function</abbr>。
上面的代码中在进行委托调用` Spliterators.spliterator `的时候非常有意思，第三个参数是一个逻辑或运算得出的` Spliterator.ORDERED |Spliterator.IMMUTABLE ` 得出的结果为` 0x00000410 ` (BTW:这种操作一般是用来做属性标记位，比如` chmod`指令里面的RWX一样的做法，有过win32 窗口API经验或者在OC里面看过枚举的都应该很熟悉这种做法。)

上面的代码是委托到下面的方法执行
### 代码5
```java
public static <T> Spliterator<T> spliterator(Object[] array, 
 int fromIndex, 
 int toIndex,
 int additionalCharacteristics) {
 checkFromToBounds(Objects.requireNonNull(array).length,
 fromIndex, 
 toIndex);
 return new ArraySpliterator<>(array, 
 fromIndex, 
 toIndex, 
 additionalCharacteristics);
 }
```
` checkFromToBounds `的作用是为了防止访问的时候出现OOB(OutOfBounds)异常，下面的直接创建了一个` ArraySpliterator `对象` ArraySpliterator `类实现了` Spliterator `接口，对于` ArraySpliterator `对象的构造
### 代码6
```java
public ArraySpliterator(Object[] array, 
 int origin, 
 int fence, 
 int additionalCharacteristics) {
 this.array = array;//原始Array
 this.index = origin;//从0开始访问
 this.fence = fence;//访问结尾
 this.characteristics = additionalCharacteristics | Spliterator.SIZED | Spliterator.SUBSIZED;
 }
```
```java
public static final int SIZED = 0x00000040;
public static final int SUBSIZED = 0x00004000;

```
参数` characteristics `再次发生了变化计算后的值为` Ox00004450 ` ,至此` ArraySpliterator`对象创建完成。

## 我们再看一下` Spliterator`的接口组成
![Spliterator](spliterator.png)

- ` tryAdvance(Consumer<? super T> action):boolean` 如果存在元素，使用给定的` action`lambda(或者匿名类实现)对元素进行操作，同时如果这个` Spliterator`是有顺序(有顺序，看一下上面的[代码4](#代码4)中就是用入参` additionalCharacteristics`标记了` ArraySpliterator`是有序的` Spliterator`)的，则将记录消费位置的游标移至下一个元素处。
 可以看一下` ArraySpliterator`中` tryAdvance`的实现
 ```java
@Override
 public boolean tryAdvance(Consumer<? super T> action) {
 if (action == null)
 throw new NullPointerException();
 if (index >= 0 && index < fence) {
 /* 由于是有序的Spliterator，则必须将游标指向下一个等待操作的元素*/
 @SuppressWarnings("unchecked")
 T e = (T) array[index++];
 action.accept(e);/* 使用action对元素进行操作*/
 return true;
 }
 return false;
 }
 ```
- ` forEachRemaining(Consumer<? super T> action):void` 在当前的线程里面，对所有的元素都操作一遍，如果这个` Spliterator`是有序的，则按照顺序进行遍历，直到所有的元素均处理完或者抛出异常。可以看一看` Spliterator`中` forEachRemaining`的默认实现
```java
default void forEachRemaining(Consumer<? super T> action) {
 do { } while (tryAdvance(action));
}
 ```
 同时再看一看` ArraySpliterator`中` forEachRemaining`的实现
```java
public void forEachRemaining(Consumer<? super T> action) {
 Object[] a; int i, hi; // hoist accesses and checks from loop
 if (action == null)
 throw new NullPointerException();
 /* 注意。此处与默认实现不同的是
 * 默认实现在Spliterator是有序的情况下会移动游标
 * 这个实现并不会，只是单纯的遍历
 */
 if ((a = array).length >= (hi = fence) &&
 (i = index) >= 0 && i < (index = hi)) {
 do { action.accept((T)a[i]); } while (++i < hi);
 }
 }
 ```
- ` trySplit():Spliterator<T>`如果当前` Spliterator`可以被分割(无限长度的` Spliterator`就是无法分割的)，则进行分割，直接这样说其实很莫名其妙，这个方法的存在其实是为了对一个比较大的` Spliterator`进行并行处理，将一个大的` Spliterator`分割成若干小的分别进行操作，然后对结果再次进行合并，就像快排，快排被第一个值分割成为两边后，两边可以交由不同的线程并行处理，大大提高并行效率。如果还是无法直接理解，我们可以看一下` ArraySpliterator`中该方法的实现
```java
public Spliterator<T> trySplit() {
 /* 可能写JavaSE Lib的大佬都喜欢写移位二分不喜欢/操作*/
 int lo = index, mid = (lo + fence) >>> 1;
 return (lo >= mid)
 ? null
 /* 从中间对当前Spliterator进行二分，
 * this Spliterator只包含后半截，
 * 前半截的操作交给另一个并行操作处理
 */
 : new ArraySpliterator<>(array, lo, index = mid, characteristics);
 }
```
- ` estimateSize():long` 能够被forEachRemaining操作到的所有的元素的个数，如果大小是无限，未知，或者计算代价高昂则直接返回Long#MAX_VALUE
- ` getExactSizeIfKnown():long` 更加严谨的计算大小的方法，只有当前` Spliterator`是可以被计算大小的才会计算调用` estimateSize():long`大小并返回否则直接返回-1。是否可以计算大小其实也是由` Spliterator`中的一个属性进行标记，比如[代码6](#代码6)中构造` ArraySpliterator`对象时` additionalCharacteristics | Spliterator.SIZED`就标记了该` Spliterator`是可以被统计大小的。
- ` characteristics():int`获取记录了` Spliterator`基础属性标记位置的数值，属性开关标记是按位查找的。在类图中那些类常量就是用来标记位的，对基础数据0或操作一个静态常量就会将该标记位置激活，如果想取消掉该标记，将标记位重新异或标记为常量就好了(逻辑操作)。比如ORDERED常数为` 0x00000010`，那么它的标记位就在第28位(从1开始计数)。
- ` hasCharacteristics(int characteristics):boolean`校验标记位或者多个标记为的组合是否打开，看默认实现就是一个简单的与运算
```java
boolean hasCharacteristics(int characteristics) {
 return (characteristics() & characteristics) == characteristics;
 }
```
- ` Comparator<? super T> getComparator()`如果` Spliterator`是有序的(ORDERED标记位打开)，且有序是由一个排序lambda或者` Comparator`对象进行排序的就返回该` Comparator`对象，如果本身就是有序的比如` ArraySpliterator`就直接返回null,否则抛出异常，可以看一下` ArraySpliterator`的实现
```java
 public Comparator<? super T> getComparator() {
 if (hasCharacteristics(Spliterator.SORTED))
 return null;
 throw new IllegalStateException();
 }
```

` Spliterator`对象创建完成后就会进行Pipeline对象的构造将在下一篇说明，当所有的对象流程都清晰后，我将会重新再次梳理并将每一种对象的描述文章的结尾重写。

Java 8 Stream API (1):Spliterator

# 问题
Java世界中臭名昭著的的异常一定是NPE，很容易在被遗忘的地方触发，为了解决NPE，一般有很多理论方法，比如:
- 参数提前判断异常退出
 在JDK 7 中引入了
 ```java
 Objects.requireNonNull
 ```
 Google 开发的基础库Guava中也有
 ```java
 checkArguments
 ```
- 代码书写习惯比如

 使用 
 ```java
 "string".equal(str)
 ```
 代替
 ```java
 str.equal("string")
 ```
- 慎重使用null，使用空对象代替null，比如在guava库中就有一个工具API
 ```java
 nullToEmpty(String str)
 ```
 用来在字符串处理之前使用""代替处理
 ```java
 String param=null;
 //some code
 nullToEmpty(param).trim();
 ```
 这就是个典型的非常安全的操作
- 在某些特殊场景(比如树的深度遍历，序列化结构获取)使用特殊继承对象，使用一个类继承原有值类型，重写所有处理方法，当遇到null场景时直接返回继承类的实例，该实例最好单一，这样只需要一连串处理之后判断一下是否是空对象实例就OK。比如
 ### 代码1
 ```java
 class ValueObject{
 String value = null;
 // some code
 public ValueObject getSub(String name){
 ValueObject sub = null;
 // some code 
 return sub;
 }

 public boolean isNull(){
 return false;
 }

 public String getValue(){
 return value;
 }
 }

 class NullValueObject extends ValueObject{
 private static NullValueObject empty = new NullValueObject();

 public static ValueObject empty(){
 return empty;
 }

 private NullValueObject(){
 //do nothing
 }

 // some code
 @Override
 public ValueObject getSub(String name){
 return empty;
 }

 @Override
 public boolean isNull(){
 return true;
 }
 }

 // call
 String fin_value=null;
 ValueObject obj = /// generate
 ValueObject child = obj.getSub("this")
 .getSub("is")
 .getSub("atest");
 fin_value = obj.isNull()?"",obj.getValue()
 ```
 想象一下这段代码如果不用这么写会怎么样
 ### 代码2
 ```java
 class ValueObject{
 String value = null;
 // some code
 public ValueObject getSub(String name){
 ValueObject sub = null;
 // some code 
 if(null == sub){
 sub = NullValueObject.empty()；
 }
 return sub;
 }

 public boolean isNull(){
 return false;
 }

 public String getValue(){
 return value;
 }
 }

 // call
 String fin_value=null;
 ValueObject obj = /// generate
 ValueObject child = obj.getSub("this");
 if(null != child){
 child = obj.getSub("is");
 if(null != child){
 child = obj.getSub("atest");
 }
 }
 fin_value = null == child?"",obj.getValue()
 ```
- 新的语言如kotlin或者swift都引入了新的操作符?上面的第二个实例就可以写成
 ```java
 ValueObject child = obj.getSub("this")?
 .getSub("is")?
 .getSub("atest");
 ```
 但是Java开发组貌似比较讨厌语法糖这种东西,比如对于Tuple这种数据结构，开发者的意见就是"Java is not perl"，几年内几乎不要有这种想法。

扯远了，回到主题。

Java 8 中引入个人认为最重要的特性就是lambda,Stream API,和Optional，这一个语法两个工具引入了函数式的思想，如果想要在JVM上体验更多的函数式效果可以看一下Scala以及Clojure。

# Optional
## Optional是干嘛的呢？
Optional的出现就是为了解决NPE问题！Optional的作用就是将一个值包裹起来，所以这个类唯一的实例变量就是value，需要被包裹的值，还有一个类变量EMPTY就是表示唯一的空实例，空实例就是指包裹的值为null引用，注意，任何时候使用Optional，Optional都不允许是null，不然使用Optional就失去了意义。

## Optional类的结构
![Optional类结构](class_view.png)

## Optional主要的API组成部分

1. Optional的生成方法为三个静态方法
 - ` empty():Optional ` 生成一个空Optional实例(实际上是Optional类变量EMPTY的引用的复制，所以Optional空实例永远只有一个)。
 - ` of(T value):Optional<T> `生成一个包裹value的实例，注意value不能为null，否则会有异常抛出
 - ` ofNullable(T value):Optional<T> `最实用的静态方法，根据value确认，value为null则返回empty否则返回包裹的对象
2. 获取被包裹值得方法
 - ` get():T ` 不推荐，当该Optional是空包裹时会抛出异常
 - ` orElse(T Value):T ` 取值，当是空包裹值时不对value进行判断就直接返回value，所以如果执意要取出null也可以直接orElse(null)
 - ` orElseGet(Supplier<? extends T> other):T ` 和上面的一样，只不过value不是直接传入参数，而是通过lambda表达式计算，lambda表达式暂不细讲
 - ` orElseThrow(Supplier<? extends X> exceptionSupplier):T `去除包裹的值，如果是空包裹，则抛出根据lambda计算得出的异常对象。
3. 包裹内容感知
 - ` isPresent():boolean `当包裹是空包裹则返回false
4. 函数式操作（重头戏）
 - ` ifPresent(Consumer<? super T> consumer):void `单次消费lambda，如果不是空包裹则使用lambda消费包裹值，否则不消费,不可以链式调用
 
 - ` filter(Predicate<? super T> predicate):Optional<T> `:过滤器，空包裹则不进行lambda调用，否则使用传入的lambda表达式，对包裹值进行判断，当满足时返回this包裹，否则直接返回空包裹，可以链式调用，链式调用的含义就是当前Optional包裹的值既满足所有的lambda判断再继续后面的逻辑。
 示例用法
 ```java
 Optional.ofNullable("123456")
 .filter(value->value.length()>2)
 .filter(value->value.length()<10)
 .ifPresent(value->System.out.println(value));
 ```
 因为字符串"123456"满足长度大于2，且长度小于10，所以就会输出
 ```
 123456
 ```
 在计算过程中完全不需要考虑包裹值是否是null，进入了lambda的值绝对是非null
 - ` map(Function<? super T, ? extends U> mapper):Optional `:老实说我觉得真不该叫这个名字，但我确实想不出更好的方法名，map在我的映像里一般代表对一个集合里面的所有元素都做一个操作并回收返回值的动作，但是Optional明显不是一个集合，虽然也可以强行理解为对一个只有一个元素的集合做的操作并回收返回值进行下一步处理,他有一个相邻近的方法flatMap等会儿再说，map运算对于lambda取得的值会使用Optional包裹返回。意味着当你在Lambda里面返回了一个Optional<Integer>则map操作返回的就是` Optional<Optional<Integer>> `。可以链式调用，使用场景一般是下一步依赖上一步结算结果的链式调用场景。
 以[代码2](#代码2)为蓝本示例
 ```java
 ValueObject obj = null;
 //some code
 Optional.ofNullable(obj)
 .map(obj->obj.getSub("this"))
 .map(obj->obj.getSub("is"))
 .map(obj->obj.getSub("atest"))
 .ifPresent(obj->System.out.println(obj.getValue()));
 ```
 这样在不改动原始class的情况下也能更安全与便捷的进行操作。由于getSub不是返回的Optional对象，所以map之后返回的是Optional包裹的ValueObject实例。
 - ` flatMap(Function<? super T, Optional> mapper):Optional `:这个操作和上面的map操作几乎一样，除了一点，它不会将lambda返回的值重新使用Optional包装，强制要求lambda返回Optional对象
 
 如果上面的代码2需要使用这个API那就就需要对class进行改动
 ```java
 class ValueObject{
 // some code
 public ValueObject getSub(String name){
 ValueObject sub = null;
 // some code 
 return Optional.ofNullable(sub);
 }
 //some code
 }
 //call
 ValueObject root = null;
 //some code;
 Optional.ofNullable(root)
 .flatMap(obj->obj.getSub("this"))
 .flatMap(obj->obj.getSub("is"))
 .flatMap(obj->obj.getSub("atest"))
 .ifPresent(obj->System.out.println(obj.getValue()))
 ```
 这个API和map到底那个优劣，无法直接说，如果改造旧代码map明显是万能灵药，但如果新写代码还是建议直接适配flatMap，虽然多打几个字。

# 个人对Optional的看法
Optional可以显著的减少NPE的发生，同时可以显著的减少圈复杂度，但是我觉得Optional并非完美，至少个人觉得如果还有两个API就更好了

```java
//新添加或者修改的API
 public Optional map(Function<? super T, Object> mapper) {
 Objects.requireNonNull(mapper);
 //空包裹则直接不操作返回空包裹保证调用链的正确执行
 if (!isPresent())
 return empty();
 else {
 Object ret = mapper.apply(value);
 //运算的出的是null则返回空包裹
 if(null == ret){
 return empty();
 //运算返回了Optional则直接返回返回对象
 }else if (obj instanceof Optional){
 return obj;
 //运算返回了非null且非Optional的实例则包裹后丢出去
 }else{
 return Optional.of(obj);
 }
 }
 }

 public T orElseOptional(Optional<T> other) {
 return value != null ? value : other.orElse(null);
 }


```