我花三天时间断断续续看完了《数学觉醒：学会更清晰的思考》这本书，阅读期间，和我老婆一直在高强度的讨论。在中小学数学的掌握上，按照历史成绩以及当前还保留的数学能力来看，我是一个学霸，而我老婆是一个学渣，但我们俩能很热烈的讨论这本书，因为它不是一本一般意义上的数学书，而是试图揭示数学家研究数学时的心理图景，更像是一本心理学或者哲学的书。

看完这本书的时候，我放下手机，对我老婆说：我有点想哭。但我也看到了微信读书上为数不少的差评，我想，要看懂一本书，或者说要和作者产生强烈的共鸣，需要一定的机缘。如果我的前四十年的人生要用一些关键词来描述的话，那一定不能漏掉“数学”这个词，它建立了我早期学习的强大自信，但后来也曾让我陷入深深的疑惑和自我怀疑。

我对我的学习尤其是数学学习有明确的记忆是从小学中年级开始的，在那个农村还非常贫穷匮乏的年代，教辅不是一个常见的东西，但是我的父母花钱给我在城里的新华书店买了一本叫《每日一刻钟》的教辅，其中数学科目的部分题目特别难，按现在的标准，大概是把那种比较简单的奥数题放在里面了，我的父母也不知道怎么用所谓小学生能理解的方式来解答这种题目，但是他们好歹认真学过一点方程，然后就在那个暑假，花了几个消暑的下午，教会了我用方程来解答这些问题，当年的小学数学其实是不学方程的（现在的小学课本更早的引入了方程，事实证明小学生学会简单的方程并不会太困难）。

我突然感觉自己掌握了一个非常趁手的兵器，除了搞定这本教辅外，对我爷爷给我出的很多民间数学难题，用方程解决简直切瓜砍菜一般简单，做对了有红包可以拿，又能得到表扬。数学课也是如此，人们一般会认为善于学习数学，数学成绩好的人是聪明的人，然后聪明的人可以学会任何东西，不管是物理化学，还是语文英语。然后，这成为了一种自我预期实现，我总是觉得自己是领先于同学和老师的进度的，因此上课基本上不听讲，尤其是数学和理科的课程，基本上都在自己看书琢磨和提前做练习题，结果也有点一路开挂的感觉，从拿到小学数学奥赛的全国二等奖，到毫不费力的初中第一次统考总分超出年级第二名一百多分，再到高中特招进入市一中。

在高中的数学学习中，我开始感受到自己能力的天花板，应对日常的学习考试问题不大，数学考试还是经常拿满分，但是当题目难度加大的时候，开始没有小学时解方程那种切瓜砍菜的轻松感了，尤其是高中的奥数，更是力所不逮。不过这个事情刚开始没有让我太焦虑，我在高三模拟考的时候，数学基本上还是145分以上接近满分的状态。我的班主任是数学老师，甚至还跟我说，按照当前高考的情况，没有必要再去花过多的时间深研数学，而应该花更多的时间到语文和英语上，那样收益会更高。

然后就是高考历史上都小有名气的2003年高考，数学卷的难度远超往年，我的一个平时数学成绩尚可的男同学，是哭着从考场出来的，我也没好到哪里去，从选择题填空题开始就感觉到强烈的不适，一直到第一个立体几何的大题，甚至没有彻底解答出来，而传统来说，这个题一般被称为送分题。我千方百计试图稳住自己的心态，甚至还花了时间去攻克最后的附加题，但是最后结果差强人意，只有110多分，好在后来的理综考试中，虽然题目也很难，我心态稳住了，最后的总分离清华北大的分数线差了5分左右。那时的我，其实对大学一无所知，只是在社会舆论中，接受了清华北大是好学校的说法，按照我平时学习的情况，理应是能够考上的，最后没考上，我很自然的把这解读为一种失败。虽然我后来进了中科大计算机系，但是这种失败的阴影笼罩了我很多年，以至于我的大学生活和最初的职业选择现在看来都是一团糟。

在过了三十岁，成家立业之后，我才慢慢对这些事情释怀，首先让自己释怀的是，我想到这是一个关乎眼界的问题，进入中科大对那时的我来说是一个失去了正确选项之后的无奈选择，我的眼界导致我不知道如何开始我的大学生活，虽然，从更加宽广的意义上看，进入中科大无疑是一种成功，而当时的我感受不到那种成功感，然后也没有人能让我真正理解，大学的学习本来就比中学要难得多。我记得我刚进中科大校园，就看到很多学长学姐在食堂门口摆摊卖书，很多都是托福GRE的单词书，当时的我看到这些是懵懂而反感的，浑然不知的是，那些立志要出国的人，不管选择是否正确，至少他们有了规划，有了选择。

然后，我也想到，眼界似乎不能解释一切，也有那些从农村出来的孩子，上了大学后，如鱼得水，很快达到了比我更高的高度。那么，这一切是否又是关乎智商呢？是否因为我的智商不足以支撑我的大学学习，以至于我的大学数学学到似懂非懂，虽然考试分数还不错，但是没有彻底理解，以至于在多年以后研究人工神经网络的时候，总觉得数学上缺课太多。但是先不说智商这个概念本来就很虚妄，它甚至也不能解释：如果我是发挥失常进入了中科大，那为什么我的大学同学类似的分数考入中科大，很多人在大学过得都要比我充实，毕业后的发展也更好呢？总不能说，他们本来就比我更聪明，只是发挥失常得比我更多一些吧。

最后，我怀疑到信心和勇气上来，是因为高考打击了我的信心和勇气，产生了一些微妙的失败情绪，才造就了大学生活的浑浑噩噩。但是这是一种不足以为外人道的隐秘心理体验，我以前只和家人聊过。把自己剖析到这里，我可以回到《数学觉醒：学会更清晰的思考》这本书上来，讲讲为什么它让我很感动。这本书出自一个法国数学家之手，分析研究了自己以及爱因斯坦、笛卡尔等一众超一流数学家科学家研究数学的心理图景，让我彻底释怀和自我和解了。

作者，一个成名的数学家，勇敢的承认了，他几乎很难读懂任何一本数学家写的专业数学书，也听不懂一个数学博士生的毕业论文讲解，爱因斯坦和一个中学生说，他面临的数学上的困难比中学生只多不少，这些不是谦虚和客套，而是诚恳的说法。数学家和普通人一样，在数学面前会面临巨大的困难，那为什么人和人之前的数学能力差距又是如此之大呢？苏炳添百米成绩是9秒83，一个普通的四肢健全的人跑不赢苏炳添，但是最多不过20秒30秒总是可以跑完的。可是数学上人和人之前的差距似乎是某些人需要一个小时才能跑完100米。

数学关乎的是对抽象对象的想象和操控，这是每个人与生俱来的能力。但是这些抽象对象在头脑中的想象和操控，不像语言和运动，是难以通过模仿学习的，因此过早的被很多人放弃，定义为自己没有天赋。逻辑推理只是数学的一种表达语言，是指月之手，不是数学的全部真相。数学，首先关乎的是好奇心和想象力，而最终是直觉，这些迟早都会撞到“天花板”，一次次穿过这个“天花板”的人，被人称之为数学家，这里不关乎智商，关乎的是勇气与自信。在抽象的概念面前，巨大的无知感很容易把人击倒，但是当你知道最伟大的数学家面临的无知是同样令人生畏的，然后再看看他们达到的高度，至少会油然而生一些勇气。取法其上，得乎其中，当然很少人能成为笛卡尔那样伟大的数学家，但是可以肯定的是，在数学上，绝大部分人大大低估了自己，包括我。

只有相信，才能存在和实现，数学，从某种意义上来看，是一种自我预期实现，人生又何尝不是如此。

手机是多模式设备，能够频繁切换状态和场景，一会儿它变成购物广场让你购物，一会儿又变成咖啡厅让你聊天看明星八卦。手机这一类计算机设备的核心技术之一是多进程多线程，但人类习惯的时间分配不是分片轮询的。

我们想象一个在互联网出现之前的场景：我想看一本书，那我就得安排一段特定的时间，找一个安静的地方，拿一本纸质书去看，甚至还要特意去图书馆找书，如果在看书的时候，发现一段特别有意思的内容，想要分享给我的朋友，那我只能先把它用脑子或者笔记下来。然后等到我安排时间去跟朋友见面的时候，再把这个事情说给他听。在这里，阅读和社交是分离的、独立的。

但是现在非常方便。我看书，手机放在旁边，看见一段有意思的内容，立马把它拍下来，发给朋友。这样很方便，对吧？在这里，你主动把阅读和社交混在一起了。更糟糕的是，你甚至不知不觉会切换到看短视频或者逛淘宝拼多多。只要你拿起手机，可能你就被手机上更加短平快的信息给吸引，你需要消耗很多意志力，才能把看书这件事情做完。人的注意力机制决定了其实并不适合这样频繁切换状态。

最早的智能手机叫PDA，也就是个人助理。智能手机发展了几十年，完全没有达到最初预期的效果。智能手机没有很好的成为我们的个人助理，反而成了各大厂商在我们的注意力上跑马的场地，我们随时随地要响应他人，或者随时随地寻找手机上的多巴胺。

现在人工智能发展一日千里，我觉得这一次也许我们有希望把手机真的变成个人助理，它能够根据我们的需求。在不同的场景下，呈现不同的状态来帮助我们而不是干扰我们。但是谁知道事情会不会越变越糟呢。至少在这个理想的状态到来之前，我们自己还需要做很多事情来管好自己的注意力。

回归单模式设备

回归纸笔，当前的AI在这一点上是大有帮助的。比如说，看书做笔记，完全可以远离手机和笔记本电脑，回归纸笔。看完书之后，你再拿出手机，把笔记拍下来，现在的AI可以很准确地识别出你写的东西。这样我们既避免了随时使用手机。也不会完全放弃电子化的便利。

又比如，卧室是睡觉的地方，你可能需要一个更加传统的闹钟，而不是用手机来看时间定闹钟。然后手机就可以滚出卧室了。

善用手机屏幕时间管理类软件

当前的手机和电脑有很丰富的时间管理类软件。比如说iOS的Cape。这类软件一般可以将你的APP分组，然后在不同的时间段禁用。这样我们能初步实现一个使用场景上的切换。比如说把娱乐类软件分组，只在特定时间段开启。不过说实话，以现在的手机操作系统来说，这方面做得还非常粗糙。远远不能真的达到场景切换的程度。第三方的屏幕时间管理软件也只能是略作裱糊。但至少可以做一个初步的尝试。我觉得这应该是未来智能时代的手机跟手机软件进化的一个方向，软件和功能应该只在我需要的时候出现。

配置关闭软件的功能模块

这方面有些软件做得稍微好一些，比如微信，它的发现页面里面的视频号、朋友圈这些都是可以按照你的需求关闭的，比如支付宝也是可以把短视频模块关闭的。但微信和支付宝也还是有茫茫多关不掉的功能。大部分软件，尤其是国内的软件，在可以让用户按需定制方面，做得其实都非常糟糕，这或许是由它们的商业模式决定的。每一个软件都能刷短视频，每一个软件都能借高利贷。我们理应在脑子清醒时，能够决定自己需要软件的什么功能，但是现实很糟糕，我们只能戴着镣铐跳舞。

探索用“龙虾”来重构信息流

目前所有的所谓的个性化推荐系统，其实都不是完全按照你的意愿来给你推荐的。而是去放大你人性中脆弱、懒惰的那一部分，以点击率等指标为目标去优化的。那在“龙虾”等智能体快速发展的时代，其实是有一个重构信息流的机会的。我们可以在头脑清醒的时候，告诉自己的智能体，自己需要看什么样的东西，然后让它去做一个初步的过滤，起到一个真正的助手的作用。这样，理论上应该能大大缓解信息过载。这个方向其实已经有公司在探索了，比如 Bluesky 推出的 Attie。

短期拖延指的是事情能推进下去，但是比预期的要慢。比如论文比最后期限晚了一个星期。很多人从学生时代开始，就喜欢制定计划。但是最后大家也都知道，计划肯定是执行不下去的。但是我觉得计划还是有用的，它不是让你百分百去执行，而是说给了你一个可以观察的标杆，看看你进度到哪里了。轻微的拖延是人生常态，总有各种各样主观客观的理由，让我们没有办法按计划来做事情。

而长期拖延，则是无法开始，比如想写一本书，但三年过去了，第一页都没开始。如果你是一个有完美主义倾向的人，那么短期拖延很容易导向长期拖延。因为你会说：“既然我都还没开始做，既然我都还没有做好，那我又很担心这样下去会失败。那我干脆就完全不要开始好了。”

要适当放过自己的短期拖延，摒弃完美主义，只要事情在往下推进，就继续下去，不消耗意志力的继续下去。三天打鱼，两天晒网，其实不是最可怕的。最可怕的是，当你发现发现自己有两天晒网的时候，你觉得你的记录不完美了，然后你就再也不想去打鱼了。我也用过很多所谓的To-Do软件，发现一旦没有及时的完成自己自视过高时定下的任务，软件上面就会有一片过期的红色，然后导致你根本都不想再打开这个软件。所以，如果我来开发一款To-Do软件，我觉得应该让它能很好的放过自己。

如果不能接纳自己的短期拖延，很容易变成破罐子破摔：反正已经拖延了，我觉得自己应该是不能按时完成了，干脆就一直不要开始好了。可能我们每一个人都得接受，自己天生就是很善于偷懒和拖延的人。在接纳自己人性如此的基础上，才能慢慢地把一件一件的事情做好。

如果我们走在通往目标的一条正确的路上，慢一点，有时候停下来休息一下，都不是太大的问题。最大的问题是我们害怕自己不能从头到尾快速地奔向目标，而根本没有开始。

曾经，茅台是国宴上的“政治正确”；如今，它悄悄走进千家万户的家宴、婚礼和朋友小聚。一瓶酒，三段人生：从政务酒到商务酒，再到家庭酒。茅台的30年转型，不是简单换渠道，而是主动适应宏观周期的自我进化——从“B端稀缺资源”到“C端真实消费”，从“卖酒”到“卖生活方式”。

据贵州茅台官方历史资料和财报复盘，早期政务采购占比一度接近50%。2012年底“八项规定”后，公司提出“三个转型、五个转变”，商务场景迅速崛起。2021年起地产周期低谷叠加消费疲软，茅台加速C端突围。2022年i茅台上线，直销渠道占比从2018年的低位快速提升；公司明确“以消费者为中心、推进市场化转型”，聚焦客群、场景、服务三大转型，推出“自售+经销+代售+寄售”协同模式，进一步推动渠道向家庭/私人消费场景下沉。

一、政务酒时代：国酒的“政治背书”（1950s–2012年）

1951年，地方政府合并三家私营酒厂成立茅台酒厂，周恩来将其定为国宴酒。1972年尼克松访华，茅台成为外交礼品；国庆、阅兵等重大活动，更是空运专供。早期销售主要通过国营糖酒公司和团购渠道，政务及国企采购占比近50%，批价随经济高增长一路飙升，2012年前曾超2000元。

那时的茅台，喝的不仅是酒，更是身份象征。品牌溢价源于“政治光环”：稀缺+背书，终端供不应求。公司财报和历史报道均显示，这一阶段销售增速高达44%，完全依赖B端政务场景。

二、反腐危机与商务酒的被迫崛起（2013–2021年）

2012年底“八项规定”如同一场风暴。三公消费骤减，茅台直接“中招”。2013–2014年，股价从高点腰斩（约50%跌幅），批价从1200元+跌至最低830元左右，销售增速从44%骤降至2%。公司财报首次承认“史无前例的压力”。

危机倒逼转型。2013年起，茅台提出“三个转型、五个转变”：从政务转向高端商务（企业宴请、礼赠）。经销商快速扩张，餐饮终端成为主力；2015年后停止大规模新增经销商，转向电商和系列酒下沉。商务场景取代政务，成为主要增量。

2018年后，股价重回“股王”宝座。数据显示，商务酒让茅台学会市场化生存：从“铁饭碗”到“市场饭”，渠道利润虽压缩，却打开了更广阔的B端空间。

三、家庭酒的蝶变：地产低谷下的C端突围（2022年至今）

2021年起，中国地产进入下行周期，高端消费疲软，茅台批价承压。2025年前三季度营收增速仅6.32%，全年目标首次下调至个位数。2026年3月，飞天批价一度跌破1600元，创近年新低。

公司果断加速“一步到C”。2022年3月i茅台上线，当年直销收入暴增105.4%。2024年直销渠道收入748.43亿元，占比43.87%，毛利率95.33%（远高于批发代理的89.42%）；i茅台全年收入200.24亿元。2025年上半年，直销占比进一步稳定在44.8%左右。

茅台战略全面升级，发布市场化运营方案，对个性化产品（陈年茅台、精品茅台、生肖酒、鼓乐飞天、小容量飞天等）实施“代售”模式，正式形成“自售+经销+代售+寄售”协同新格局。代售模式下，物权不转移，经销商无需预付全额货款，只需缴纳保证金，通过线上零售、线下门店、餐饮、私域等资源触达消费者，赚取约5%的服务费（佣金）。例如，一瓶53度500ml精品茅台零售价2299元，经销商可赚约115元。所有代售产品必须通过i茅台平台完成销售，原团购客户可扫专卖店专属二维码采购，实现“线上下单、线下提货”，主要服务散户客户。

茅台负责人明确表示：“大家要主动求变，要服务好渠道商，推动实现角色转型，从传统‘卖货’角色转向承担茅台线下展示与服务的功能，形成厂商协同服务消费者的合力。”这一举措直接收回定价权、稳定非标产品价盘，减少渠道炒作，同时让经销商从“坐商”变为“行商”，轻资产、强服务，真正深耕终端。

场景落地最明显：从商务宴请转向家宴、婚庆、寿宴、朋友小聚等私人庆祝。门店设“家宴专区”，i茅台用户占比持续提升，消费者反馈“家庭聚会用茅台比例上升”。90后、85后成为主力，即买即饮、小规格自用成为趋势。茅台从“政务酒的荣耀、商务酒的生存”，走向“家庭酒的归宿”——一杯酒，陪伴真实生活。

四、背后的逻辑与未来启示

茅台的“三变”，本质是宏观周期倒逼微观转型：反腐“断奶”政务依赖，地产低谷催化C端觉醒。公司从政策红利转向消费者主权，完成商业逻辑回归。代售模式，正是这一转型的最新注脚——它把渠道利润从“投机性”变为“稳定性”，倒逼经销商深耕C端服务，而非囤货炒价。分析师指出，这将让有C端运营能力和圈层资源的经销商获得更多配额，纯粹“倒货”的旧模式自然出清。

对行业而言，这是样本。白酒企业必须提前拥抱数字化、场景化，争夺年轻客群和私人消费。茅台“家庭酒”战略成败，关键看开瓶率与年轻化渗透。目前看，公司执行坚定：i茅台成为C端核心抓手，批价与股价在转型中逐步企稳。

五、结语

政务酒是荣耀，商务酒是生存，家庭酒才是归宿。茅台的转型，不仅是企业故事，更是时代镜像——从象征权力到陪伴生活，折射中国消费从B端到C端的微观升级。未来，期待更多创新，让国酒真正香飘寻常百姓家。

你的餐桌上，茅台是哪种酒？欢迎留言讨论。

如果我们感兴趣，会看到无数的自媒体和KOL在介绍这些所谓的生产力工具，但是奇怪的是，这些天天介绍工具、钻研工具的人，往往他们最大的成就可能就是你看到的自媒体，而那些真正在各个领域做出很大成就的人，他们不会去强调自己用的什么工具，即使偶尔我们看到相关的信息，往往也发现他们用的工具平平无奇，甚至也有些无聊。

比如之前有人问深度学习的大佬李沐用什么东西做笔记，他说用Typora，这甚至不是一个笔记软件，而只是一个markdown编辑器。

也有大佬只用一个txt文档，管理自己一切的事务和信息，当然由此也衍生出他的一套方法论。

对除了把研究工具当成自己事业的人，其他人应该先去做手头的事情，如果发现真的有一些痛点需要优化解决，再去寻找相应的工具，其实一般挑市场占有率最高的就对了。

你在职场和商业世界里，有些书是被贴错标签的。

《世界上最伟大的推销员》往往会被扔进“机场成功学”或“廉价鸡汤”的废纸篓。但如果我们剥开它那层略显浮夸的寓言外壳，去观察作者奥格·曼狄诺构建的内核，你会发现这其实是一套关于“认知系统重塑”的底层逻辑。

这本书是我妈在以前在刚学卖保险的时候，我送给她的，我只是照着畅销书榜单买的，其实我也没看过。去年偶然重读这本书，我发现了一些更有意思的视角：关于自我洗脑的科学、原则与经验的博弈，以及现代企业制度下的永生观。

1. 寓言、经文与“心理暗示”的安装包

很多人吐槽这本书的文学风格——大量的类圣经、类佛经排比句，甚至带点“忽悠”的味道。你可能会问：“这不就是传销早会上最爱喊的口号么？”

但从系统论的角度看，这种风格并非无意义的煽情。人类的潜意识其实是不讲逻辑的，它更像是一个只接受“强信号”的操作系统。这种带有宗教色彩、近乎偏执的语言，本质上是一个“心理暗示的安装包”。它通过高度重复的节奏，绕过你理性防御的防火墙，直接修改你的底层执行逻辑。

2. “笨办法”才是最高效的系统重塑

书中提到了一个极其反直觉的要求：每一卷羊皮卷要连续读三十天。

在追求即时反馈的今天，这种“三十天读一卷”的做法简直是反人类的。但这种“笨办法”背后，蕴含着习惯内化的真谛：所有的原则，如果不能进入潜意识并与自我融为一体，就永远只是“外部信息”，而非“能力”。

与其说这是在阅读，不如说这是一种“自我洗脑”的工程学过程。通过海量的、高频的重复，将某种特定的处世哲学（比如“活在当下”、“爱”和“行动力”）固化为一种条件反射。当行为不再需要耗费意志力去驱动时，习惯就成了开启成功的钥匙 。

3. 经验会贬值，但原则是第一性原理

书中海菲与老人的对话中，有一个观点深得我心：经验的价值往往被高估了。

经验往往带有强烈的时代局限性和场景依赖。人老的时候，开口讲的多是糊涂话，因为他们还在用旧时代的地图寻找新世界的出口。而书中强调的“羊皮卷原则”，则是更接近商业和人生“第一性原理”的东西。

• 关于行动： “我现在就付诸行动”。这不是口号，而是对拖延症的系统级截断。

• 关于情绪： 传统的说教是“控制情绪”，但更高阶的见解是“察觉情绪”。你无法控制潮汐，但你可以为自己创造天气。

• 关于门槛： 每个人都要去“敲门”，但真正的核心在于，你是否已经“想明白自己该去敲开哪扇门”。

4. 从“商业王国”到“现代企业制度”

书中的故事背景是古代的商业王国，但如果我们用现代视角去解读海菲王国的消亡，会有一个有趣的发现：

在寓言里，王国随着主人的退休而空空如也。但在现代企业制度中，股东可以变，但企业是永生的。这意味着，我们追求的不应只是个人的成功，而是建立一套可以持续运转、不依赖于特定个体的“系统”。

这种跨越时空的对比，反映了商业文明的演进。海菲最后寻找传人的过程，其实也是在寻找那颗能将“原则种子”传播下去的灵魂 。

5. 入戏与出戏

读这类书，最怕的是“全盘接受”后的盲目狂热，或者“全盘否定”后的傲慢偏见。

最好的状态应该是 “入戏又出戏”。一方面，积极汲取其中关于习惯养成和行动力的精髓，把它当成灌溉心灵的“种子”；另一方面，保持现代商业逻辑的冷静，用批判性思维去“修剪”那些过时的逻辑 。

毕竟，真正的富有是精神上的，而非仅仅是钱包的厚度。在这个浮躁的时代，做一个“好的理念的推销员”，或许才是我们每个人都该上的第一课。

思考题： 如果你要为自己的认知系统写一个“羊皮卷”，你的第一条原则会是什么？欢迎在评论区分享。

什么是代码大全？

代码大全是一本书，讲的是如何写代码，与具体的编程语言无关，而是以方法论为主，很厚，九百多页的砖头。

2008年的时候，我在成都某新华书店第一次看到一本叫《代码大全》的书，我还以为是一本摘抄了各种代码的类似《食谱大全》的书，因此都懒得去翻开看一下，因为觉得抄代码有互联网就足够了，这件事可能说明了两个问题：

• “代码大全”这个书名翻译得太烂；
• 我当年很无知。

《Code Complete》实在是应该翻译为《代码完成》比较合适，据第二版的译者说，因为第一版翻译为《代码大全》，他们也只好将错就错。市面上的计算机类书籍汗牛充栋，大多是针对具体编程语言的，要不就是讲需求分析、软件设计、软件测试，直接讲软件构建的书反而很少，很多人也学了一些软件工程的皮毛，但是代码写出来还是不忍卒读，用本书的观点来说，只有软件构建——直白一点说叫写代码，才是一个程序员才会确实去做的事，至于其他部分，往往都伴随着谎言。

俗话说“走都不会走，还想学跑？”，一个程序员，先老老实实把自己写代码的水平提高，实在是最基本也最重要的，在学校教育经历中，一般人写的都是“一次运行，用完就扔”的学生代码，与做软件产品的要求相距甚远，而这本书，在教你怎么把代码写好这方面，真是事无巨细，处处闪耀着真知灼见，从这个角度来看，叫它大全，也不为错。比如我的编程入门教材是谭浩强的《C程序设计》，里面的变量命名风格是单字母风格，而本书则花了一章来讲变量名的问题，对于单字母门派出来的人，实在是一剂良药。

我从大概2015年买了本英文版读，读了5章后停下来，直到今年（2019）把中文版读完，而这本书的英文版出版于2003年。十几年过去了，书中很多方法论已经是业界公论。但方法论说得溜是当代程序员的特点，而实践水平倒是不见得有什么提升，热衷于谈框架、谈机器学习，但好的代码依然少见。

这份笔记会补充一些我自己近年的思考与近年的技术方法。

第1部分 打好基础

所谓磨刀不误砍柴功，要做什么是一个看似简单，实则复杂的问题。

第1章 欢迎进入软件构建的世界

一般软件工程的书会把过程划分的很清楚，软件开发的活动包括：

• 问题定义
• 需求开发
• 构建计划
• 软件架构
• 详细设计
• 编码和调试
• 单元测试
• 集成测试
• 集成
• 系统测试
• 修正维护

代码构建的核心是编码和调试，为了编码和调试，会或多或少牵涉到其他活动，非正式开发的时候，我们可能直接坐下来敲代码，上面的所有活动都打包了。而软件构建，讲的大概是敲代码的时候干的那些事情，你如果真的敲过代码，就知道大部分时间其实你是对着屏幕发呆状而不是在敲键盘（只有电影里的黑客才不听的噼里啪啦敲键盘），要做的事情包括：

• 检查准备工作是否已经做好，可以安心敲代码了
• 想好如何测试代码
• 设计和实现类和函数
• 创建变量和命名常量
• 选择控制结构，组织语句
• 单元测试，集成测试，调试代码
• 相互Review代码
• 通过格式化和好的注释来打磨代码
• 集成分别开发的组件
• 修改代码使其运行更快占用资源更少

为什么软件构建很重要？

• 软件构建是软件开发的主要活动——大部分时间都在码代码
• 软件构建是软件开发的中心活动——没有代码，再多的文档都是扯淡
• 关注软件构建可以极大提高每个程序员的生产力——大部分的程序员基本功不过关
• 软构建的产品——代码，经常是软件唯一精确的描述——文档都是骗人的
• 软件构建是唯一保证会做的工作——再懒也不能用PPT开发

第2章 用隐喻来更充分地理解软件开发

2.1 隐喻(Metaphors)的重要性

人类理解事物是从已知到未知的，作者举了科学史上很多例子说明metaphor的重要性，我觉得，能打好一个比方其实是很难的，善于打比方的人是最聪明的一类人，这可能需要大脑回路比较丰富才行。对一个事物理解越深刻，想出来的比喻就会越贴切，或者说模型就会越精确。

2.2 如何使用软件的隐喻

比喻不是算法，不会给出明确的指引，而是具有启发性的，会引导你思考的方向。

• 帮你洞察问题和处理
• 帮你找到更好的做事情的方式

2.3 一般的软件隐喻

软件书写：写代码

写代码这个说法很常见，是借喻写文章而来的，这种借喻有很多不恰当的地方，比如代码更易于修改，基本上很难有“完成”的一天，代码不强调原创而强调复用。

基本上，这是一个糟糕的借喻，只对写很小的软件适用。

软件农场：种植系统

软件系统确实有不断增长的一面，但却不是播了种子施肥浇水等收获的概念。

软件牡蛎农场：系统增生

这个隐喻说的是渐进增强，像牡蛎一样，在沙粒上一层层裹碳酸钙，最后长成珍珠。这个概念近年来越来越火了，不单软件工程提，关于创业的理论也提。我个人的体会是：对需求不明的项目，一个基本的初步实现是讨论的基础，也是信心的来源。

软件构建：建造软件

这是最重要的一个隐喻了，它源自建筑行业，开发软件和修建筑有很多相似点

• 复杂度和尺寸的影响很大
• 复用，而不是从头实现
• 个性化定制
• 好的规划能让后续细节的调整更容易
• 不同的项目使用不同的方法
• 越晚修改代价越大
• 对超大型项目，动手构建前的准备极为重要

应用软件技术：智力工具箱

工具箱是一个很好的比喻，以免我们迷失在某个方法论或技术中，“拿个锤子，看什么都像钉子”，好的匠人，必然是有一个好的工具箱的，面对具体的情况，使用不同的工具。一个程序员应当不断扩充自己的工具箱。

合成隐喻

隐喻是启发式的，只要有利于说明我们的问题，都没有必要拒绝。

第3章 三思而后行：前期准备

不同规模的构建，需要不同程度的准备工作，项目的成败，早已埋下伏笔。构建一般占项目时间的65%，而糟糕的准备工作会让构建时间增加两三倍。

3.1 前期准备的重要性

高质量的软件来自高质量的实践，如何保证质量？

• 前期：关注需求、设计。
• 中期：关注构建。
• 后期：关注测试。

本书重点关注中期，但是在开始构建之前，需要弄清前期准备做到了什么程度，贸然开场容易悲剧。

现代软件开发是否需要前期准备？

需要。前期准备可以降低风险，不同的项目可能需要不同的前期准备实践，但不能没有。

不完整的前期准备的理由

• 开发者没有经验——那就去学啊。
• 按捺不住写代码的心——多碰几次壁。
• 上级让你赶紧写代码！——拒绝上级；假装在编程；教育上级；跳槽。

构建之前做好前期准备的理由

你可以拿它来教育别人。

诉诸逻辑

• 需要弄清楚到底想构建个啥。
• 需要弄清楚怎么去构建系统。

诉诸类比

• 造房子
• 软件开发食物链：程序员在食物链尽头。

诉诸数据

• 最后阶段更改的代价是10~100倍。

老板敏捷测试

自我实现预言：

• 我们必须立即开始编码因为还有很多调试工作要做。
• 我们没有计划多少时间去测试因为不会找到太多的缺陷。
• 我们充分研究了需求和设计，在编码和调试的时候不会遇到大的问题。

3.2 确定你开发的软件类型

针对不同的软件类型，需要不同的生命周期模型:

• 商业系统
• 关键任务系统
• 嵌入式性命攸关系统

迭代方法在前期准备中的作用

• 先做80%的需求分析，则类似串行
• 先做20%的需求分析，则类似迭代

在迭代方法与串行方法间的选择

• 需求是否明确？
• 设计是否复杂？
• 团队对领域是否熟悉？
• 项目风险大不大？
• 更改需求、设计的代价如何？

3.3 问题定义

• 好的问题定义弄清楚问题是什么，而不要考虑实现。
• 问题定义在需求分析之前，使用用户语言描述。
• 最好的解决方案可能不需要写软件。
• 除非是为了解决计算机系统问题，否则不使用计算机语言。
• 问题定义出错的代价：浪费了时间，没有解决真正的问题。

3.4 需求分析

需求分析讨论软件怎么解决问题，是解决方案的第一步。

为什么需要正式的需求？

• 确保用户而非程序员决定系统功能，程序员明确知道用户需要什么。
• 避免争吵，以需求为准。
• 好的需求会减少开始构建后的变更。

稳定需求的神话

稳定的需求是软件开发的圣杯。

• 用户往往不能准备描述需求。
• 只有充分使用系统，才能深入理解系统。
• 开发过程会使用户更好的理解系统，这也是需求变更的主要来源。
• 典型的系统会有25%的需求变更，花费70%~85时间重做。

在构建时应对需求变化

• 检查需求分析的质量，如有问题，尽早返工。
• 确保每个人明白需求变更的代价，正确应对“特性中毒者”。
• 建立变更控制过程，做到程序员顾客都满意。
• 使用能适应需求变更的开发方法：原型进化、渐进交付、小开发周期。
• 放弃项目。
• 始终关注项目的商业价值。

3.5 架构设计

架构设计，一般对应“概要设计文档”，架构决定了系统的“概念完整”。架构设计进行工作分解，直至程序员可以上手工作。

第4章 关键构建决策

4.1 选择编程语言

语言选择事关效率，语言熟悉——效率高30%，熟练工——3倍效率。一定程度上，思想表达能力取决于词汇量。 表达能力：C,1;C++,2.5;Python,6. 不要使用了一门新的语言，却不使用它好的机制，还是完全用旧语言的模式编程。 语言描述：

• Ada 数据抽象，信息隐藏，用于军队、航空航天。
• 汇编 处理器相关，代码体积或速度有严格限制时应用。
• C 普适，中等语言，可移植的汇编（指针、地址、位运算、弱类型），高级特性：结构体，控制流，机器独立，丰富的运算符。
• C++ C基础上的面向对象语言，类、多态、异常处理、模板、类型控制、标准库
• C# 类似C、C++、Java（个人认为C#语言本身是很优秀的，融合了部分函数式编程的思想，但是社区支持比Java略差）
• Cobol 通用商业语言（银行还在用）。
• Fortran 最早的高级语言之一，过去科学计算和教学比较多使用（现在Python用得更多吧）。
• Java （最早的虚拟机语言，社区庞大。）
• JavaScript （无处不在了）
• Perl 擅长字符处理（跟Python不同的哲学）
• PHP （世界上最好的语言😀）
• Python （万能胶水，随着机器学习而变成了显学）
• SQL 结构化查询语言，主要用于数据库。
• Visual Basic （拉控件编程的经典）

最近几年的新语言：

• go C++替代之一，代表作品docker
• rust C++替代之二
• dart JavaScript 替代之一，用于框架flutter

4.2 编程约定

高层的架构与底层实现要保持一致，统一的规范不但利于团队合作，还可以解放脑力。

4.3 你在技术浪潮中的位置

处在一个技术的早期，风险与额外的收益并存，技术成熟期则风险小，中规中矩。 注意Program in a language 和 Program into a language的区别，语言提供了工具箱，但是不要局限于语言的工具箱。

如果能多学一些语言，再融汇贯通，就能理解语言的精髓，而不局限于语言。可参考：

• Programming Languages 公开课
• 七周七语言
• 代码之髓

4.4 选择你主要的构建实践

当前针对各种编程语言，一般都会有最佳实践一类的东西，或者有优秀的开源项目作为参考，总之刚开始不要自己摸索，用前人的最佳实践做几个项目之后再考虑根据自己的需要做优化。

做好最佳实践，能够把自己的精力集中到代码的逻辑中去，减轻代码管理、调试等工作的复杂性。

第2部分 创建高质量的代码

第5章 构建中的设计

设计不太可能在构建之前完成。

5.1 设计挑战

• 设计是一个邪恶的(wicked)问题：只能通过解决这个问题或部分解决问题才能清楚的定义这个问题。这是 真正的程序和学生作业的区别。
• 设计是一个草率的过程：会犯错；好的方案很精妙；“足够好”很难定义。
• 设计关乎权衡和优先级
• 设计牵涉约束
• 设计是非决定性的：有很多途径
• 设计是一个启发式的过程：没有银弹
• 设计是自然发生的

5.2 关键设计概念

软件的首要技术法则：管理复杂性

• 偶然的和本质的困难: 此划分来自亚里士多德的哲学。 偶然的：笨拙的语法、非交互式的计算机、难以一起工作的工具； 本质的：与真实世界复杂、无序的接口，异常情况，精确性，准确定义真实世界如何运行。

• 管理复杂性的重要性失败的原因：糟糕的需求/计划/管理，失控的复杂性管理。 程序太大，人类无法一次性理解。问题分级后易于理解（如包管理），保持从程序短小，写代码时考虑人类的极限。

• 如何消灭复杂性：减少每个人脑中需要一次性处理的固有复杂性；防止不必要复杂性的增殖。

理想的设计特征

• 最小复杂度：聪明的 vs 简单易维护的。
• 易维护：为代码维护者编程，自解释的设计。
• 松耦合：不同部分之间的联系尽量少。
• 可扩展性：更改时减少创伤。
• 可复用性
• 高扇入：充分复用底层模块
• 低扇出：不过度依赖其他部分
• 可移植性
• 精简：没有多余部分
• 分层化：隔离变化
• 标准技术：不要用古怪的技术

设计的层次

1. 软件系统
2. 子系统或包：子系统间的通信必须加以限制，否则会不断熵增，一片混乱，可以先紧后松。常见的子系统：商业规则、用户接口、数据存取、系统依赖。
3. 类：包括接口。大项目由子系统划分，定义一些外部函数；小项目由系统直接划分。
4. 例程：可能会引起第3层的修改。
5. 例程内设计

5.3 设计建造的砖块：启发式

一个不断试错的过程。

找到现实世界的对象

• 标识对象和其属性
• 决定改对象能干啥
• 决定每个对象能对其他对象干啥
• 决定对象各部分的可见性
• 决定对象的公开接口

一个迭代过程：重新组织，类的细节修改。

组织一致的抽象

在不同的层次忽略细节。集合=>抽象。基类、接口。

• 函数层次
• 类层次
• 包或子系统层次

封装实现细节

继承——当继承简化设计时使用

信息隐藏

• 结构化设计：黑盒
• 面向对象设计：封装、模块化、抽象

秘密和隐私权

两种策略

• 隐藏复杂性使你的大脑不需要考虑它，除非特别关注时
• 隐藏更改源，隔离变化

信息隐藏的障碍

• 分布过广的信息
• 环形依赖
• 不当的全局数据
• 担心性能损失

信息隐藏的价值

启发性的力量，设计好的公共接口。问正确的问题：这个类需要隐藏什么？

标示易变区域

标示=>分割=>隔离

• 商业规则
• 硬件依赖
• 输入输出
• 非标准语言特性
• 设计和构建困难的区域
• 状态变量：使用枚举代替bool值；使用存取函数代替直接访问。
• 数据大小限制

预期不同程度的变化

先找出最小子集，再做功能性、质量性改进。

保持松耦合

耦合标准

• 大小：模块间联系的数量，如函数的参数个数，类的公开方法数量；
• 可见性：明确引用，胜过更改全局变量。
• 可变性：容易改变连接，被不同的模块调用。

耦合的种类

• 简单数据参数耦合：模块间传递了简单数据类型。常见、可接受。
• 简单对象耦合： 一个对象初始化了另一个对象。合理。
• 对象参数耦合：对象1需要对象2向其传递对象3。耦合较紧密。
• 语义耦合
  • 模块1传递了一个标志给模块2，告诉模块2应该去干啥。如果模块2定义了一个数据类型来表示该标志，则合理。
  • 模块2使用模块1更改过的全局变量。有时序假设，不好。
  • 模块1在调用某函数前必须先调用初始化函数。
  • 模块1传递对象给模块2，知道模块2将使用对象的部分方法，只对对象进行部分初始化。
  • 模块1传递基类给模块2，模块2知道模块1实际传递的是派生类，强制转化后使用。

危险:使用了编译器无法检测的方法使用别的类。 一旦使用了，你就得自己负责正确性。

寻找一般的设计模式

• 模式通过已经准备好的抽象来降低复杂性
• 模式使一般解决方案制度化以减少错误
• 模式通过建议设计选择提供启发性价值
• 模式通过提升设计语言测层次使沟通更流畅

其他的启发式方法

• 高内聚
• 构建继承体系
• 正式化类协议
• 职责分配
• 为测试设计
• 避免失败
• 有意识的选择绑定时间
• 使控制点集中
• 使用暴力方法
• 画图示
• 保持设计模块化

启发性方法指导

 Polya's How to Solve It 

不要卡在一个小问题上，你不需要一次性解决所有的设计问题。

5.4 设计实践

迭代

发现不顶用的设计。

分治

自顶向下与自底向上

两种方法论应当结合使用。自顶向下容易入手，但是有时底层的复杂性会影响到上层；自底向下难入手，但是能及早的管理复杂性，使得上层设计更容易。

试验原型

协作设计

• 起身去问协作者
• 和协作者坐在一起用白板讨论草图
• 结对编程
• 开会向其他协作者讲解设计
• 正式的审查
• 冷处理自己的设计，再回头看
• 求助公司外的人，在论坛上提问

多少设计才足够？

一般来说，越细越好；设计文档不是越多越好。

记录你的设计工作

• 在代码中插入设计文档
• 在Wiki中记录设计的讨论和决定
• 写e-mail总结
• 拍照
• 保存设计海报
• 使用“类-职责-协作”卡片
• 在适当的细节层次使用UML图

5.5 对流行方法学的评论

不要过多关注设计方法学，关注设计本身，不设计或事无巨细的设计都不可取，还是要具体情况具体分析。

第6章 可以工作的类

6.1 类的基础：抽象数据类型(ADTs)

一些数据以及对这些数据操作的集合。ADT是类的基础，但不一定以类的形态存在。

使用ADT的益处：

• 可以隐藏实现细节
• 改动不会影响到整个程序
• 让接口能提供更多信息
• 更容易提高性能
• 让程序的正确性显而易见
• 程序更具自我说明性
• 无须在程序内到处传递数据
• 你可以像在现实世界中那样操作实体

ADT示例：

• 把常见的底层数据类型创建为ADT并使用这些ADT，而不再使用底层数据类型
• 把像文件这样的常用对象当成ADT
• 简单的事物也可以当作ADT
• 不要让ADT依赖于其存储介质

在非面向对象环境中用ADT处理多分数据实例（比如C语言）：

1. 每次使用ADT服务子程序时都明确指定实例（使用id）
2. 明确地向ADT服务子程序提供所要用地数据
3. 使用隐含实例（需要跟踪当前实例，容易出错）

类=ADT+继承+多态

6.2 良好的类接口

• 展现一致的抽象层次
• 理解类所实现的抽象是什么
• 提供成对的服务
• 把不相关的信息转移到其他类中
• 尽可能让接口可编程，而不是表达语义（编译器可检查）
• 谨防在修改时破坏接口的抽象
• 不要添加与接口抽象不一致的公用成员
• 同时考虑抽象性和内聚性

良好的封装

• 尽可能地限制类和成员的可访问性
• 不要公开暴露成员数据
• 避免把私用的实现细节放入类的接口中
• 不要对类的使用者做出任何假设
• 避免使用友元类
• 不要因为一个子程序仅使用公用子程序，就把它归入公开接口
• 让阅读代码比编写代码更方便
• 要格外警惕从语义上破坏封装性
• 留意过于紧密的耦合关系

6.3 有关设计和实现的问题

包含：有一个的关系 has a

• 通过包含来实现有一个的关系
• 在万不得已时通过private继承来实现有个的关系
• 警惕有超过7个数据成员的类

继承：是一个的关系 is a

• 用public继承来实现是一个的关系
• 要么使用继承并进行详细说明，要么就不要用它
• 遵循Liskov替换原则
• 确保只继承需要继承的部分
• 不要覆盖一个不可覆盖的成员函数
• 把共用的接口、数据以操作放到继承树中尽可能高的位置
• 只有一个实例的类是值得怀疑的
• 只有一个派生类的基类也值得怀疑
• 派生类覆盖了某个子程序，但在其中没做任何操作，这种情况也值得怀疑
• 避免让继承体系过深
• 尽量使用多态，避免大量的类型检查
• 让所有的数据都是private

多重继承

• 太复杂，一般不建议使用
• mixins语义可以使用f

总的来说，继承要慎用，因为它一定程度上有悖于控制复杂性的基本理念。

成员函数和数据成员

• 让类中子程序的数量尽可能少
• 禁止隐式地产生你不需要地成员函数和运算符（可以更改默认行为，比如让其private）
• 减少类所调用的不同子程序的数量
• 对其他类的子程序的间接调用要尽可能少（A可以调用A创建的对象B的子程序）
• 一般来说，应尽量减少类和类之间相互合作的范围

构造函数：

• 如果可能，应该在所有的构造函数中初始化所有的数据成员（类似pycharm的IDE往往会有警告）
• 用私用构造函数来强制实现单件属性
• 优先采用深层复本，除非论证可行，才采用浅层复本

6.4 创建类的原因

• 为现实世界中的对象建模
• 为抽象的对象建模
• 降低复杂度
• 隔离复杂度
• 隐藏实现细节
• 限制变动的影响范围
• 隐藏全局数据
• 让参数传递更顺畅
• 建立中心控制点
• 让代码更易于重用
• 为程序族作计划
• 把相关操作包装到一起
• 实现某种特定的重构

应该避免的类

• 避免创建万能类
• 消除无关紧要的类
• 避免用动词命名的类

6.5 与具体编程语言相关的问题

不同语言在实现类的方法上有很多差别。比如类的覆盖。

6.6 超越类：包

如果语言不支持包，可以自己预定实现，几个关键点：

• 用于区分“共用的类”和“某个包私用的类”的命名规则
• 为了区分每个类所属的包而定制的命名规则和/或代码组织规则（即项目结构）
• 固定什么包可以用其它什么包的规则，包框是否可以用继承和/或包含等

第7章 高质量的子程序

7.1 创建子程序的正当理由

• 降低复杂度
• 引入中间的、易懂的抽象
• 避免代码重复
• 支持子类化
• 隐藏顺序
• 隐藏指针操作
• 提高可移植性
• 简化复杂的逻辑判断
• 改善性能（只需要在一个地方优化）

即使很简单的逻辑，如果能提高可读性，也要考虑写出子程序。

7.2 在子程序层上设计

内聚性

• 功能的内聚性：一个程序仅执行一项操作

不太理想的内聚性

• 顺序上的内聚性：子程序内包含有需要按特定顺序执行的操作，这些步骤需要共享数据，而且只有在全部执行完毕后才完成了一项完整的功能。
• 通信上的内聚性：一个子程序中的不同操作使用了同样的数据，但不存在其它任何联系。
• 临时的内聚性：含有一些因为需要同时执行才放到一起的操作的子程序。（可做作为组织者）

不可取的内聚性：

• 过程上的内聚性：一个子程序中的操作是按特定的顺序进行的。
• 逻辑上的内聚性：若干操作被放入同一个子程序中，通过传入的控制标志选择执行其中的一项操作。
• 巧合的内聚性：子程序中的各个操作之间没有任何可以看到的关联。

7.3 好的子程序的名字

• 描述子程序所做的所有事情
• 避免使用无意义的、模糊或表述不清的动词
• 不要仅通过数字来形成不同的子程序名字
• 根据需要确定子程序的长度
• 给函数命名时要对返回值有所描述
• 给过程起名时使用语气强烈的动词加宾语的形式
• 准确使用对仗词
• 为常用操作确立命名规则

7.4 子程序可以写多长

总的来说，没有必要刻意去限制子程序的长度，而应该去考虑的是内聚性等复杂度事项，不过一般这样考虑了，子程序的长度不太可能超过200行。

7.5 如何使用子程序参数

减少接口错误的指导原则：

• 按照输入-修改-输出的顺序排列参数
• 考虑自己创建in和out关键字
• 如果几个子程序都用了类似的一些参数，应该让这些参数的排列顺序保持一致
• 使用所有的参数
• 把状态或出错变量放在最后
• 不要把子程序的参数用作工作变量
• 在接口中对参数的假定加以说明（注释、断言）
• 把子程序的个数限制在大约7个以内
• 考虑对参数采用某种表示输入、修改、输出的命名规则
• 为子程序传递用以维持其接口抽象的变量或对象
• 使用具名参数
• 确保实际参数与形式参数相匹配（类型要匹配）

7.6 使用函数时要特别考虑的问题

如果一个子程序的主要用途就是返回由其名字所指明的返回值，那么就应该使用函数，否则应该使用过程。对于返回值：

• 检查所有可能的返回路径
• 不要返回指向局部数据的引用或指针

7.7 宏子程序和内联子程序

• 把表达式整个包含在括号内
• 把含有多条语句的宏用大括号括起来
• 用给子程序命名的方法来给展开后代码形同子程序的宏命名，以便在需要时可以用子程序来替换宏

可以用来替代宏的方案：

• const
• inline（也需要节制使用）
• enum
• typedef

第8章 防御式编程

防御式编程概念来自于防御式驾驶：子程序应该不因传入错误数据而被破坏，哪怕是由其它子程序产生的错误数据。

8.1 保护程序免遭非法输入数据的破坏

• 检查所有来源于外部的数据的值
• 检查子程序所有输入参数的值
• 决定如何处理错误的输入数据

8.2 断言

• 用错误处理来处理预期会发生的状况，用断言来处理绝不应该发生的状况
• 避免把需要执行的代码放到断言中
• 用断言来注解并验证前条件和后条件
• 对于高健壮性的代码，应该先使用断言再处理错误

8.3 错误处理技术

• 返回中立值
• 换用下一个正确的数据
• 返回与前次相同的数据
• 换用最接近的合法值
• 把警告信息记录到日志文件中
• 返回一个错误码
• 调用错误处理子程序或对象
• 当错误发生时显示出错消息
• 用最妥当的方式在局部处理错误
• 关闭程序

注意正确性与健壮性的选择

• 人身安全攸关的软件倾向于正确性
• 消费类应用软件倾向于健壮性

高层次设计对错误处理方式的影响：应该在整个程序中采用一致的方式处理非法的参数

8.4 异常

• 用异常通知程序的其他部分，发生了不可忽略的错误
• 只有真正例外的情况下才抛出异常
• 不能用异常来推卸责任
• 避免在构造函数和析构函数中抛出异常，除非你在同一地方把它们捕获
• 在恰当的抽象层次抛出异常：抛出的异常也是程序接口的一部分
• 在异常消息中加入关于导致异常发生的全部信息
• 避免使用空的catch语句
• 了解所用函数库可能抛出的异常
• 考虑创建一个集中的异常报告机制
• 把项目中对异常的使用标准化
• 考虑异常的替换方案

8.5 隔离程序，使之包容由错误造成的损害

把某些接口选定为“安全”区域的边界。对穿越安全区域边界的数据进行合法性校验，并当数据非法时做出敏锐的反应。

• 隔栏外部的程序使用错误处理技术
• 隔栏内部的程序使用断言技术

8.6 辅助调试的代码

• 不要自动地把产品版地限制强加于开发版之上

• 尽早引入辅助调试的代码

• 采用进攻式编程：在开发时惨痛的失败

• 计划移除辅助调试的代码

  • 使用类似ant和make这样的版本控制工具和make工具
  • 使用内置的预处理器
  • 编写自己的预处理器
  • 使用调试存根（代码桩）

8.7 确定在产品代码中该保留多少防御式编程

• 保留那些检查重要错误的代码
• 去掉检查细微错误的代码（开关/记录）
• 去掉可以导致程序硬件崩溃的代码
• 保留可以让程序稳妥地崩溃地代码
• 让你的技术支持人员记录错误信息
• 确认留在代码中的错误信息是友好的

8.8 对防御式编程采取防御的姿态

防御式编程同样会增加软件的复杂度

第9章 伪代码编程过程

9.1 创建类和子程序的步骤概述

创建一个类的步骤：

• 创建类的总体设计
• 创建类中的子程序
• 复审并测试整个类

创建子程序的步骤

• 设计子程序
• 检查设计
• 编写子程序的代码
• 复审并测试代码

9.2 伪代码

指导原则：

• 用类似英语的语句来精确描述特定的操作
• 避免使用目标编程语言中的语法元素
• 在本意的层次上编写伪代码
• 在一个足够低的层次上编写伪代码，以便可以近乎自动地从它生成代码

优点：

• 伪代码使得评审更容易
• 伪代码支持反复迭代精化地思想
• 伪代码使变更更加容易
• 伪代码能使给代码做注释地工作量减到最少
• 伪代码比其他形式的设计文档更容易维护

9.3 通过伪代码编程过程创建子程序

设计子程序

• 检查先决条件
• 定义子程序要解决的问题
• 为子程序命名
• 决定如何测试子程序
• 在标准库中搜寻可用的功能
• 考虑错误处理
• 考虑效率问题
• 研究算法和数据结构
• 编写伪代码
• 考虑数据
• 检查伪代码
• 在伪代码中试验一些想法，留下最好的想法（迭代）

编写子程序的代码

• 写出子程序的声明
• 把伪代码转变为高层的注释
• 在每条注释下面填充代码
• 检查代码是否需要进一步分解

检查代码

• 在脑海中检查程序中的错误
• 编译子程序
• 在调试器中逐行执行代码
• 测试代码
• 消除程序中的错误

收尾工作

• 检查子程序的接口
• 检查整体的设计质量
• 检查子程序的变量
• 检查子程序的语句和逻辑
• 检查子程序的布局
• 检查子程序的文档
• 除去冗余的注释

根据需要重复上述步骤

9.4 伪代码编程过程的替代方案

• 测试先行开发
• 重构
• 契约式设计
• 东拼西凑

第3部分 变量

第10章 使用变量的一般事项

10.1 数据认知

10.2 轻松掌握变量定义

• 关闭隐式声明
• 声明全部的变量
• 遵循某种命名规则
• 检查变量名

10.3 变量初始化原则

• 在声明变量的时候初始化
• 在靠近变量第一次使用的位置初始化它
• 理想情况下，在靠近第一次使用变量的位置声明和定义该变量
• 在可能的情况下使用final或者const
• 特别注意计数器和累加器
• 在类的构造函数里初始化该类的数据成员
• 检查是否需要重新初始化
• 一次性初始化具名常量，用可执行代码来初始化变量
• 使用编译器来设置自动初始化所有变量
• 利用编译器的警告信息
• 检查输入参数的合法性
• 使用内存访问检查工具来检查错误的指针
• 在程序开始时初始化工作内存

10.4 作用域

作用域指的是变量在程序内的可见和可引用的范围

使变量引用局部化

尽可能缩短变量的存活时间

减少作用域的一般原则

• 在循环开始之前再去初始化该循环里使用的变量，而不是在该循环所属的子程序的开始处初始化这些变量
• 直到变量即将被使用时再为其赋值
• 把相关语句放在一起
• 把相关语句组提取成单独的子程序
• 开始时采用最严格的可见性，然后根据需要扩展变量的作用域

有关缩小变量作用域的说明

“方便性”与“智力上的可管理性”的权衡

10.5 持续性

持续性的多种形态

• 特定代码段或子程序的生命期
• 只要你允许，他就会持续下去
• 程序的生命期
• 永远持续

10.6 绑定时间

把变量和它的值绑定在一起的时间

• 编码时
• 编译时
• 加载时
• 对象实例化时
• 即时

10.7 数据类型和控制结构之间的关系

• 序列型数据翻译为程序中的顺序数据
• 选择型数据翻译为程序中的if和case语句
• 迭代型数据翻译成程序中的for、repeat、while等循环结构

10.8 为变量指定单一用途

• 每个变量只用于单一用途
• 避免让代码具有隐含含义
• 确保使用了所有已声明的变量

第11章 变量名的力量

11.1 选择好的变量名的注意事项

最重要的命名注意事项

要完全、准确地描述出该变量所代表的事物。

以问题为导向

一个好记的名字反映的通常都是问题，而不是解决方案。

最适当的名字长度

1016个字符，820个字符，注意不要教条

作用域对变量名的影响

• 作用域越大，倾向于用越长的变量名
• 对于全局命名空间中的名字加以限定词

变量名中的计算值限定词

Total、Sum等限定词放到名字的最后

变量名中的常用对仗词

建议成对使用

11.2 为特定类型的数据命名

为循环下标命名

i, j, k

为状态变量命名

不要用一般性的flag，不要猜测变量名的含义

为临时变量命名

警惕临时变量，使用比temp更有含义的命名

为布尔变量命名

• 谨记典型的布尔变量命：done， error，found，success或ok
• 给布尔变量赋予隐含真/假含义的名字
• 使用肯定的布尔变量名

为枚举类型命名

• 如语言不支持类似类的处理，自己加上前缀

为常量命名

使用常量的含义而不是数值命名

11.3 命名规则的力量

为什么要有规则

• 要求你更多地按规矩行事
• 有助于在项目之间传递知识
• 有助于你在新项目中更快速的学习代码
• 有助于减少名字增生
• 弥补编程语言的不足之处
• 强调变量之间的关系

何时采用命名规则

合作/正式/长期的项目

正式程度

取决于项目规模/生命周期

11.4 非正式命名规则

与语言无关的命名规则指导原则

• 区分变量名和子程序名字
• 区分类和对象
• 标识全局变量
• 标识成员变量
• 标识类型声明
• 标识具名常量
• 标识枚举类型的元素
• 在不能保证输入参数只读的语言标识只读参数
• 格式化命名以提高可读性

11.5 标准前缀

• 用户自定义类型缩写
• 语义前缀

11.6 创建具备可读性的短名字

• 不要用从每个单词删除一个字符的方式来缩写
• 缩写要一致
• 创建你能读出来的名字
• 避免使用容易看错或者读错的字符组合
• 使用辞典来解决命名冲突
• 在代码里用缩写对照表来解释极短的名字的含义
• 在一份项目级的标准缩写文档中说明所有的缩写
• 名字对于代码读者的意义比作者更重要

11. 7 应当避免的名字

• 避免使用令人误解的名字或缩写

• 避免使用具有相似含义的名字

• 避免使用具有不同含义但却有相似名字的变量

• 避免使用发音相近的名字

• 避免在名字中使用数字

• 避免在名字中拼错单词

• 避免似乎用英语中常常拼错的单词

• 不要仅靠大小写来区分变量命

• 避免使用多种自然语言

• 避免使用标准类型、变量和子程序的名字

• 不要使用与变量含义完全无关的名字

• 避免在名字中包含易混淆的字符

第12章 基本数据类型

12.1 数值概论

• 避免使用硬编码的“神秘数字”
• 如果需要，可以使用硬编码的0和1
• 预防除零错误
• 使类型转换变得明显
• 避免混合类型的比较
• 注意编译器的警告

12.2 整数

• 检查整数除法
• 检查整数溢出
• 检查中间结果溢出

12.3 浮点数

• 避免数量级相差巨大的数之间的加减运算
• 避免等量判断
• 处理舍入误差问题
• 检查语言和函数库对特定数据类型的支持

12.4 字符和字符串

• 避免使用神秘字符和神秘字符串
• 避免off-by-one错误
• 了解你的语言和开发环境是如何支持Unicode的
• 在程序生命期中尽早决定国际化/本地化策略
• 如果你知道只需要支持一种文字的语言，请考虑使用ISO 8859字符集
• 如果你需要支持多种语言，请使用Unicode
• 采用某种一致的字符串类型转换策略

C语言中的字符串

• 注意字符串指针和字符数组之间的差异
• 把C-style字符串的长度声明为CONSTANT + 1
• 用null初始化字符串以避免无结束符的字符串
• 用字符数组取代C中的指针
• 用字符串子程序的安全版本， strlcpy()或strcpy_s()

12.5 布尔变量

• 用布尔变量对程序加以文档说明
• 用布尔变量来简化复杂的判断
• 如果需要的话，创建自己的布尔类型

12.6 枚举类型

• 用枚举类型来提高可读性
• 用枚举类型来提高可靠性
• 用枚举类型来简化修改
• 用枚举类型作为布尔变量的替换方案
• 检查非法值
• 定义处枚举的第一项和最后一项，以便于循环边界
• 把枚举类型的第一个元素留做非法值
• 明确定义项目代码编写标准中第一个和最后一个元素的使用规则，并且在使用时保持一致
• 警惕给枚举元素明确赋值而带来的失误

如果你的语言里没有枚举类型

可以自己设法用全局变量的规范或者类来模拟。

12.7 具名常量

• 在数据声明中使用具名常量
• 避免使用文字量，即使是安全的
• 用具有适当作用域的变量或类来模拟具名常量
• 统一地使用具名常量

12.8 数组

• 确认所有的数组下标都没有超出数组地边界
• 考虑用容器来取代数组，或者将数组作为顺序化结构来处理
• 检查数组地边界点
• 如果数组是多维的，确认下标的使用顺序是正确的
• 提防下标串话
• 在C中结合ARRAY_LENGTH()宏来使用数组

12.9 创建你自己的类型（类型别名）

• 易于修改
• 避免过多的信息分发
• 增加可靠性
• 弥补语言的不足

指导原则：

• 给所创建的类型取功能导向的名字
• 避免使用预定义类型
• 不要重定义一个预定义的类型
• 定义替代类型以便于移植
• 考虑创建一个类而不是typedef

第13章 不常见的数据类型

13.1 结构体

• 用结构体来明确数据关系
• 用结构体简化对数据块的操作
• 用结构体来简化参数列表
• 用结构体来减少维护

13.2 指针

理解指针的关键：

• 内存中的位置
• 如何解释指针所指的内容

使用指针的一般技巧：

• 把指针操作限制在子程序或者类里面
• 同时声明和定义指针
• 在指针分配相同的作用域中删除指针
• 在使用指针之前检查指针
• 先检查指针所引用的变量再使用它
• 用狗牌字段来检查损毁的内存
• 增加明显的冗余
• 用额外的指针变量来提高代码清晰度
• 简化复杂的指针表达式
• 按照正确的顺序删除链表中的指针
• 分配一片保留的内存后备区域
• 粉碎垃圾数据
• 再删除或者释放指针后把它们设为空值
• 在删除变量之前检查非法指针
• 跟踪指针分配情况
• 编写覆盖子程序，集中实现避免指针问题的策略
• 采用非指针的技术

C++指针

• 理解指针和引用之间的区别
• 把指针用于“按引用传递”参数，把const引用用于“按值传递”参数
• 使用 shared_ptr
• 灵活运用智能指针

C指针

• 使用显式指针类型而不是默认类型
• 避免强制类型转换
• 遵循参数传递的星号规则
• 在内存分配中使用sizeof()确定变量的大小

13.3 全局数据

常见问题：

• 无意间修改了全局数据
• 与全局数据有关的别名问题
• 与全局数据有关的代码重入问题
• 全局数据阻碍代码重用
• 与全局数据有关的非确定的初始化顺序事宜
• 全局数据破坏了模块化和质量上的可管理性

使用全局数据的理由：

• 保存全局数据
• 模拟具名常量
• 模拟枚举类型
• 简化对及其常用的数据使用
• 消除流浪数据

只有万不得已时才使用全局数据

• 首先把每一个变量设置为局部的，仅当需要时才把变量设置为全局的
• 区分全局变量和类变量
• 使用访问器子程序
  • 要求所有的代码通过访问器子程序来存取数据
  • 不要把你所有的全局数据扔在一处
  • 用锁定来控制对全局变量的访问
  • 在你的访问器子程序里构建一个抽象层
  • 使得对一项数据的所有访问都发生在同一个抽象层

如何降低使用全局数据的风险：

• 创建一种命名规则来突出全局变量
• 为全部的全局变量创建一份注释良好的清单
• 不要用全局变量来存放中间结果
• 不要把所有的数据都放在一个大对象中并到处传递，以说明你没有使用全局变量

第4部分 语句

第14章 组织直线型代码

14.1 必须有明确顺序的语句

• 设法组织代码，使依赖关系变得非常明显
• 使子程序名能凸显依赖关系
• 利用子程序参数明确显示依赖关系
• 用注释对不清晰的依赖关系进行说明
• 用断言或者错误处理代码来检查依赖关系

14.2 顺序无关的语句

• 使代码易于自上而下地阅读
• 把相关的语句组织在一起

第15章 使用条件语句

15.1 if 语句

简单 if-then语句

• 首先写正常代码路径，再处理不常见情况
• 确保对于等量的分支是正确的
• 把正常情况的处理放在if后面而不要放在else后面
• 让if子句后面跟随一个有意义的句子
• 考虑else子句

if-then-else语句串

• 利用布尔函数简化复杂的检测
• 把最常用的情况放在最前面
• 确保所有的情况都考虑到了
• 如果你的语言支持，请把if-then-else语句串替换成其它结构

15.2 case语句

为case语句选择最有效的排列顺序：

• 按字母顺序或按数字顺序排列各种情况
• 把正常的情况放在前面
• 按执行频率排列case子句

使用case语句的诀窍：

• 简化每种情况对应的操作：可以使用子程序
• 不要为了使用case语句而刻意制造一个变量
• 把default子句只用于检查真正的默认情况
• 利用default子句来检测错误
• 在C++和Java里，避免代码执行越过一条case子句的末尾（显式的break）
• 在C++里，在case末尾明确无误地标明需要穿越执行的程序流程

第16章 控制循环

16.1 选择循环的种类

• 计数循环
• 连续求值的循环
• 无限循环
• 迭代器循环

什么时候使用while循环

• 检测位于循环的开始
• 检测位于循环的结尾

什么时候用带退出的循环？

正常的带退出的循环：如果把循环条件检测放在循环开始或结束处，那就需要写一个半循环的代码（在循环开始前或结束后需要循环体的重复代码）

何时使用for循环：执行次数固定的循环

合适使用foreach循环：数组或容器的迭代操作

16.2 循环控制

应该把循环看做是一个黑盒子

进入循环

• 只从一个位置进入循环
• 把初始化代码紧放在循环前面
• 用while(true)表示无限循环
• 在适当情况下多使用for循环
• 在while循环更适用的时候，不要使用for循环

处理好循环体

• 用 {} 把循环体中的语句括起来
• 避免空循环
• 把循环内务操作要么凡在循环的开始，要么放在循环的末尾
• 一个循环只做一件事

退出循环

• 设法确认循环能够终止
• 使循环终止条件看起来很明显
• 不要为了终止循环而胡乱改动for循环的下标
• 避免出现依赖于循环下标最终取值的代码
• 考虑使用安全计数器

提前退出循环

• 考虑在while循环中使用break语句而不用布尔标记
• 小心那些有很多break散布其中的循环
• 在循环开始处用continue进行判断
• 如果语言支持，请使用带标号break结构
• 使用break和continue时要小心谨慎

检查端点

• 开始的情况
• 任意选择的中间情况
• 最终的情况

使用循环变量

• 用整数或者枚举类型表示数组和循环的边界
• 在嵌套循环终宏使用有意义的变量命来提高其可读性
• 用有意义的名字来避免循环下标串话
• 把循环下标变量的作用域限制在本循环内

循环应该有多长

• 循环要尽可能地短，以便能够一目了然
• 把嵌套限制在3层以内
• 把长循环的内容移到子程序里
• 要让长循环格外清晰

16.3 轻松创建循环——由内而外

从一种情况开始，用字面量来编写代码，然后缩进它，在外面加一个循环，然后用循环下标或计算表达式替换那些字面量。如果需要，在它的外面再套上一个循环，然后再替换掉一些字面量。

16.4 循环和数组的关系

有些语言是支持直接的数组运算的，从而可以减少循环

第17章 不常见的控制结构

17.1 子程序中的多处返回

• 如果能增强可读性，那么就使用return
• 用防卫子句（早返回或早退出）来简化复杂的错误处理
• 减少每个子程序中return的数量

17.2 递归

• 确认递归能够停止
• 使用安全计数器防止出现无穷递归
• 把递归限制在一个子程序内
• 留心栈空间
• 不要用递归去计算阶乘或者斐波拉契数列

17.3 goto

• 在那些不直接支持结构化控制语句的语言里，用goto模拟那些控制结构
• 如果语言内置了等价的控制结构，那么就不要用goto
• 如果是为了提高代码效率而是用goto，请衡量此举实际带来的性能提升
• 除非你要模拟结构化语句，否则尽量在每个子程序只使用一个goto标号
• 除非你要模拟结构化语句，否则尽量让goto向前跳转而不要向后跳转
• 确认所有goto标号都被用到了
• 确认goto不会产生某些执行不到的代码

第18章 表驱动法

18.1 表驱动法使用总则

从表里面查找信息而不使用逻辑语句，使用表驱动法的两个问题：

• 怎样从表中查询条目：直接访问，索引访问，阶梯方位
• 应该在表里存些什么：数据，动作（代码/函数指针）

18.2 直接访问表

如何构造查询键值：

• 复制信息从而能够直接使用键值
• 转换键值以使其能够直接使用
• 把键值转换提取成独立的子程序

18.3 索引访问表

先用一个基本类型的数据从一张索引表中查出一个键值，然后用这一键值查出你感兴趣的主数据，优点：

• 节省内存空间
• 操作位于索引中的记录更廉价
• 可维护性

18.4 阶梯访问表

表中的记录对于不同的数据范围有效，而不是对于不同的数据点有效。把每一个区间的上限写入一个表里，然后循环按照各区间的上限来检查分数。

• 留心端点
• 考虑用二分查找取代顺序查找
• 考虑用索引访问来取代阶梯技术
• 把阶梯表查询操作提取成单独的子程序

第19章 一般控制问题

19.1 布尔表达式

• 用true和false做布尔判断，隐式地比较布尔值与true和false
• 简化复杂地表达式
  • 拆分复杂的判断并引入新的布尔变量
  • 把复杂的表达式做成布尔函数
  • 用决策表代替复杂的条件
• 编写肯定形式的布尔表达式
• 用括号使布尔表达式更清晰
• 理解布尔表达式时如何求值的，注意短路
• 按照数轴的顺序编写数值表达式
• 与0比较的指导原则
  • 隐式地比较逻辑变量
  • 把数与0相比较
  • 在C中显式地比较字符和零终止符(\0)
  • 把指针与NULL相比较
• 布尔表达式地常见问题
  • 在C家族语言中，应该把常量放在比较地左端
  • 在C++中，刻意考虑创建预处理宏来替换&&， ||和==
  • 在Java中，应理解a==b和a.equals(b)之间的差异

19.2 复合语句（语句块）

• 把括号一起写出
• 用括号来把条件表达清楚

19.3 空语句

• 小心使用空语句
• 为空语句创建一个DoNothing()预处理宏或者内联函数
• 考虑如果换用一个非空的循环，是否会让代码更清晰

19.4 驯服危险的深层嵌套

• 通过重复检测条件中的某一部分来简化嵌套的if语句
• 用break块来简化嵌套if
• 把嵌套if转换成一组if-then-else语句
• 把嵌套if转换成case语句
• 把深层嵌套的代码抽取出来放进单独的子程序
• 使用一种更加面向对象的方法
• 重新设计深层嵌套的代码

19.5 编程基础：结构化编程

一个应用程序应该只采用一些单入单出的控制结构

• 顺序
• 选择
• 迭代

19.6 控制结构与复杂度

降低程序的复杂度，以及为了理解它所需要的专心程度。

第5部分 代码改善

第20章 软件质量概述

20.1 软件质量的特性

• 外在的质量特性
  • 正确性
  • 可用性
  • 效率
  • 可靠性
  • 完整性
  • 适应性
  • 精确性
  • 健壮性
• 内在的质量特性
  • 可维护性
  • 灵活性
  • 可移植性
  • 可重用性
  • 可读性
  • 可测试性
  • 可理解性
• 这些特性是相互制约的

20.2 改善软件质量的技术

• 软件质量目标
• 明确定义质量保证工作
• 测试策略
• 软件工程指南
• 非正式技术复查
• 正式技术复查
• 外部审查

开发过程

• 对变更控制的过程
• 结果的量化
• 制作原型

20.3 不同质量保证技术的相对效能

代码复查的成本效益要高于测试，推荐阵容：

• 对所有的需求、架构以及系统关键部分的设计进行正式检查
• 建模或者创建原型
• 代码阅读或者检查
• 执行测试

20.4 什么时候进行质量保证工作

在早期阶段就开始强调质量保证工作，并贯彻到项目的余下部分中。

20.5 软件质量的普遍原理

改善质量以降低开发成本：减少代码返工上的时间。

第21章 协同构建

21.1协同开发实践概要

• 协同构建是其它质量保证技术的补充
• 协同构建有利于传授公司文化以及编程专业知识
• 集体所有权适用于所有形式的协同构建
• 在构建前后都应保持协作

21.2 结对编程

成功运用结对编程的关键

• 用编码规范类支持结对编程
• 不要让结对编程变成旁观
• 不要强迫在简单的问题上使用结对编程
• 有规律地对人员和分配地工作任务进行轮换
• 鼓励双方跟上对方的步伐
• 确认两个人都能够看到显示器
• 不要强迫程序员与自己关系紧张的人组队
• 避免新手组合
• 指定一个组长

21.3 正式检查

• 你期待相差能够带来什么结果：捕捉到60%的缺陷，评估进度。

• 详查中的人员角色：主持人，作者，评论员、记录员、经理（最好不出席）

• 详查的一般步骤：计划，概述，准备，详查回忆，详查报告，返工，跟进，第三个小时的会议

• 对详查进行细调：切忌胡乱的引入变化

• 注意详查中的自尊心

21.4 其它类型的协同开发实践

• 走查：能找到20%到40%的缺陷，尽量使用更加正式的详查
• 代码阅读：90%的缺陷是在准备复查会议时发现的
• 公开演示：这只是管理层的复查

第22章 开发者测试

22.1 开发者测试在软件质量中的角色

• 一个成功的测试应该弄垮软件
• 测试永远不可能彻底证明程序中没有错误
• 测试本身并不能改善软件的质量
• 测试时要求你假设会在代码里面找到错误

在构建中测试，能更彻底的测试。

22.2 开发者测试的推荐方法

• 对每一项相关的需求进行测试
• 对每一个相关的设计关注点进行测试
• 用基础测试来扩充针对需求和设计的详细测试用例
• 使用一个检查表记录历史错误

可能的情况下，不妨测试先行。

开发者测试的局限性：

• 开发者测试倾向于干净测试
• 开发者测试对覆盖率有过于乐观的估计
• 开发者测试往往会忽略一些更复杂的测试覆盖率类型

22.3 测试技巧锦囊

• 进行完整的测试是不可能的，窍门在于选择那些最有可能找出错误的测试用例
• 结构化的基础测试：需要去测试程序中每一条语句至少一次，尽量覆盖所有的已定义—-已使用数据流形式
• 等价类划分：相同等价类只需要测试一个用例
• 猜测程序会在哪里出错：边界值分析/复合边界值
• 几类坏数据：数据太少/太多的数据/错误的数据/查高度错误的数据/为初始化的数据
• 几类好数据：正常的情况/最小的正常局面/最大的正常局面/与旧数据的兼容性
• 采用容易手工检查的测试用例

22.4 典型错误

绝大多数错误往往与少数几个具有严重缺陷的子程序有关。（二八定律）

• 大多数的错误的影响范围是相当有限的
• 许多错误发生在构建的范畴之外
• 大多数的构建期错误是编程人员的失误造成的
• 笔误是一个常见的问题根源
• 错误理解设计师是犯错的常见原因
• 大多数错误很容易修正
• 总结所在组织中对付错误的经验

小型项目中，构建中的缺陷占了所有错误的大多数，大型项目占比有所下降。

测试本身也可能有错误：

• 检查你的工作
• 开发软件的时候就要计划好测试用例
• 保留你的测试用例
• 将单元测试纳入测试框架

22.5 测试支持工具

• 为测试各个类构建脚手架
• Diff工具
• 测试数据生成器
• 覆盖率监视器
• 数据记录器/日志记录器
• 符号调试器
• 系统干扰器
• 错误数据库

22.6 改善测试过程

• 有计划的测试
• 重新测试（回归测试）
• 自动化测试

22.7 保留测试记录

第23章 调试

23.1 调试概述

错误中学习：

• 理解你正在编写的程序
• 明确你犯了那种类型的错误
• 从代码阅读者的角度分析代码质量
• 审视自己解决问题的方法
• 审视自己修正缺陷的方法

错误的调试方法：

• 凭猜测找出缺陷
• 不要把时间浪费在理解问题上
• 用最唾手可得的方式修正错误
• 迷信式调试

23.2 寻找缺陷

科学的调试方法

1. 将错误状态稳定下来
2. 确定错误的来源
3. 修补缺陷
4. 对所修补的地方进行测试
5. 查找是否还有类似的错误

寻找缺陷的一些小建议：

• 在构造假设时考虑所有的可用数据
• 提炼产生错误的测试用例
• 在自己的单元cesium族中测试代码
• 利用可用的工具
• 采用多种不同的方法重现错误
• 用更多的数据生成更多的假设
• 利用否定性测试用例的结果
• 对可能测假设尝试头脑风暴
• 在桌上放一个记事本，把需要尝试的事情逐条列出
• 缩小嫌疑代码的范围
• 对之前出现共的缺陷的类和子程序保持警惕
• 检查最近修改过的代码
• 扩展嫌疑代码的范围
• 增量式集成
• 检查常见的缺陷
• 同其他人讨论问题
• 抛开问题，休息一下

蛮力调试有可能说有效的方法，要为“快速肮脏调试法”的时候设置用给时间上限，做出一张蛮力调试方法列表

语法错误：

• 不要过分信任编译器信息中的行号
• 不要迷信编译器信息不要相信编译器的第二条信息
• 分而治之
• 找出没有配对的注释或者引号

23.3 修正缺陷

• 在动手之前先要理解问题
• 理解程序本身，而不仅仅是问题
• 验证对错误的分析
• 放松一下
• 保存最初的源代码
• 治本，而不是治标
• 修改代码时一定要有恰当的理由
• 一次只做一个改动
• 检查自己的改动
• 增加能暴露问题的单元测试
• 搜索类似的缺陷

23.4 调试中的心理因素

人总期望一个新的现象类似于它们见过的某种现象

• 证明了养成良好的编程习惯的重要性
• 程序员会对某些部分的代码视而不见，有时候能提高效率，有时候会陷入盲区

23.5 调试工具

• 源代码比较工具
• 编译器的警告信息
• 增强的语法检查和逻辑检查
• 执行性能剖析器
• 测试框架/脚手架
• 调试器

第24章 重构

24.1 软件演化的类型

演化应当提升程序的内在质量

24.2 重构简介

重构的理由：

• 代码重复
• 冗长的子程序
• 循环过长或嵌套过深
• 内聚性太差的类
• 类的接口未能提供层次一致的抽象
• 拥有太多参数的参数列表
• 类的内部修改往往被局限于某个部分
• 变化导致对多个类的相同修改
• 对继承体系的同样修改
• case语句需要做相同的修改
• 同时使用的相关数据并未以类的方式进行组织
• 成员函数使用其他类的特征比使用自身类的特征还要多
• 过多使用基本数据类型
• 某个类无所事事
• 一系列传递流浪数据的子程序
• 中间人对象无事可做
• 某个类同其他类关系过于亲密
• 子程序命名不恰当
• 数据成员被设置为公用
• 某个派生类仅使用了基类的很少一部分成员函数
• 注释被用于解释难懂的代码
• 使用了全局变量
• 在子程序调用请前使用了设置代码，或在调用后使用了收尾代码
• 程序中的一些代码似乎是在将来的某个时候才会用到的

24.3 特定的重构

数据级的重构

• 用具名常量替代神秘数字
• 使变量的名字更为清晰且传递更多信息
• 将表达式内联化
• 用函数来代替表达式
• 引入中间变量
• 用多个单一用途变量代替某个多用途变量
• 在局部用途中使用局部变量而不是参数
• 将基础数据类型转化为类
• 将一组类型码转化为类或枚举类型
• 将一组类型码转化为一个基类及其相应派生类
• 将数组转换为对象
• 把群集封装起来
• 用数据类来代替传统记录

语句级的重构

• 分解布尔表达式
• 将复杂布尔表达式转换成命名准确的布尔函数
• 合并条件语句中不同部分的重复代码片段
• 使用break或return而不是循环控制变量
• 在嵌套的if-then-else语句中一旦知道答案就立即返回，而不是去赋一个返回值
• 用多态来替代条件语句（尤其是重复的case语句）
• 创建和使用null对象而不是去检测空值

子程序级重构

• 提取子程序或者方法
• 将子程序的代码内联化
• 将冗长的子程序转换为类
• 用简单算法替代复杂算法
• 增加参数
• 删除参数
• 将查询从修改操作中独立出来
• 合并相似的子程序，通过参数区分它们的功能
• 将行为取决于参数的子程序拆分开来
• 传递整个对象而非特定成员
• 传递特定成员而非整个对象
• 包装向下转型的操作

类实现的重构

• 将值对象转化为引用对象
• 将引用对象转化为值对象
• 用数据初始化替代虚函数
• 改变成员函数或成员数据的位置
• 将特殊代码提取为派生类
• 将相似代码结合起来放置到基类中

类接口的重构

• 将成员函数放到另一个类中
• 将一个类变成两个
• 删除类
• 去除委托关系
• 去掉中间人
• 用委托代替继承
• 用继承代替委托
• 引入外部的成员函数
• 引入扩展类
• 对暴露在外的成员变量进行封装
• 对于不能修改的类成员，删除相关的set() 成员函数
• 隐藏那些不会在类之外被用到的成员函数
• 封装不使用的成员函数
• 合并那些实现非常相似的基类和派生类

系统级重构：

• 为无法控制的数据创建明确的索引源
• 将单向的类联系改为双向的类联系
• 将双向的类联系改为单向的类联系
• 用Factory Method模式而不是简单地构造函数
• 用异常取代错误处理代码，或者做相反方向的变换

24.4 安全的重构

• 保存初始代码
• 重构的步伐请小些
• 同一时间只做一项重构
• 把要做的事情一条条列出来
• 设置一个停车场
• 多使用检查点
• 利用编译器警告信息
• 重新测试
• 增加测试用例
• 检查对代码的修改
• 根据重构风险级别来调整重构方法

不宜重构的情况

• 不要把重构当做先写后改的代名词
• 避免用重构代替重写

24.5 重构策略

• 在增加子程序时进行重构
• 在添加类的时候进行重构
• 在修补缺陷的时候进行重构
• 关于易于出错的模块
• 关注高度复杂的模块
• 在维护环境下，改善你手中正在处理的代码
• 定义清楚感干净代码和拙劣代码之间的边界，然后尝试把代码移过这条边界

第25章 代码调整策略

25.1 性能概述

• 相对与代码质量，用户更关心的是程序的外在特性
• 从以下角度来思考效率问题
  • 程序需求
  • 程序的设计
  • 类和子程序的设计
  • 程序同操作系统的交互
  • 代码编译
  • 硬件
  • 代码调整

25.2 代码调整简介

• 应当衡量代码的各个部分，找出最需要关注的地方，然后集中火力来对付占用了绝大部分资源的少量代码
• 一些无稽之谈
  • 在高级语言中，减少代码的行数就可以提升所生成的 机器代码的运行速度
  • 特定运算可能比其他的快，代码规模也较小
  • 应当随时随地进行优化
  • 程序的运行速度同其正确性同等重要
• 平铺直叙的代码有利于编译器的优化

25.3 常见的低效率之源

• 输入/输出操作
• 分页
• 系统调用
• 解释型语言
• 错误

25.4 性能测量

如果没有策略性能变化，想当然的优化结果往往只是使得代码更加晦涩难懂。

25.5 反复调整

结合多种方法，不断突破瓶颈。

第26章 代码调整技术

以牺牲程序内部结构的某些特性来换取更高的性能

26.1 逻辑

• 在知道答案之后停止判断
• 按照出现的频率来调整判断顺序
• 相似逻辑结构之间的性能比较
• 用查询表替代复杂表达式
• 使用惰性求值

26.2 循环

• 将判断外提
• 合并
• 展开
• 尽可能减少在循环内部做的工作
• 哨兵值
• 把最忙的循环放在最内层
• 削减强度

26.3 数据变换

• 使用整型数而不是浮点数
• 数组维度尽可能少
• 尽可能减少数组引用
• 使用辅助索引
• 使用缓存机制

26.4 表达式

• 利用代数恒等式
• 削弱运算强度
• 编译期初始化
• 小心系统函数
• 使用正确的常量类型
• 预先算出结果
• 删除公共子表达式

26.5 子程序

• 将子程序重写为内联

26.6 用低级语言重写代码

• 用高级语言编写整个应用程序
• 对程序进行完整的测试，验证其正确性
• 如果测试后发现需要改进程序性能，就对程序进行分析，确定出热点。
• 把几小段代码在低级语言中重写，以此提高这个题性能

26.7 变得越多，事情反而越没变

• 对每一次的改进进行量化

第6部分 系统考虑

第27章 程序规模对构建的影响

27.1 交流的规模

交流路径的数量与项目成员数量的平方大致成正比

27.2 项目规模的范围

27.3 项目规模对错误的影响

随着项目规模的增大，通常更大一部分错误要归咎于需求和设计。

27.4 项目规模对生产率的影响

小项目的生产率回避大项目高出2~3倍。

27.5 项目规模对开发活动的影响

• 随着项目的增大，构建活动的主导地位下降
• 程序、产品、系统和系统产品的区别
• 项目越大，复杂度也越大，也就要求有意识地去关注方法论

第28章 管理构建

28.1 鼓励良好地编码实践

• 设定标准的考虑事项

• 鼓励良好的编码实践的技术

  • 给项目的每一部分分派两个人
  • 进行复查代码
  • 要求代码签名
  • 安排一些好的代码示例供人参考
  • 强调代码是公有财产
  • 奖励好代码
  • 一份简单的标准

28.2 配置管理

系统化地定义项目工件和处理变化，以使项目一直保持完整性。

一些控制设计变更的指导原则：

• 遵循某种系统变化的变更控制手续
• 成组地处理变更请求
• 评估每项变更的成本
• 提防大量的变更请求
• 成立变更控制委员会或者类似机构
• 警惕官僚主义，但也不要因为害怕官僚主义而排斥有效的变更控制

软件代码变更，使用版本控制软件。

工具版本也要纳入版本控制之中。

机器配置也尽量标准化。

做好备份。

28.3 评估构建进度表

• 建立目标
• 为评估留出时间，并且做出计划
• 清楚地说明软件需求
• 在底层细节层面进行评估
• 使用若干不同地评估方法，并且比较其结果
• 定期做重新评估

如果你落后了怎么办？

• 希望自己能赶上
• 扩充团队
• 缩减项目范围

28.4 度量

• 任何一种项目特性都是刻意用某种方法来度量地，而且总会比根本不度量好得多
• 留心度量地副作用
• 反对度量就是认为最好不要去了解项目中到底在发生什么

28.5 把程序员当人看

28.6 管理你的管理者

你要表现得使你的管理者认为他仍然在管理你。

第29章 集成

29.1 集成方法的重要性

29.2 集成频率——阶段式集成还是增量集成

阶段式集成

• 单元开发：设计、编码、测试、调试各个类

• 系统集成：将这些类组成一个庞大的系统

• 系统瓦解：测试并调试整个系统

  增量集成

• 开发一个小的系统功能部件

• 设计、编码、测试、调试某个类

• 将这个新的类集成到系统骨架上

增量集成的益处：

• 易于定位错误
• 及早在项目里取得系统级的成果
• 改善对进度的监控
• 改善客户关系
• 更加充分地测试系统中地各个单元
• 能在更短地开发进度计划内建造出整个系统

29.3 增量集成的策略

• 自顶向下集成：首先加入顶部的类，最后加入底部的类
• 自底向上集成：先集成底部的类，后集成顶部的类
• 三明治集成
• 风险导向的集成：困难部件优先集成法
• 功能导向的集成
• T型集成

29.4 Daliy Build与冒烟测试

• 每日构建
• 检查失败的build
• 每天进行冒烟测试：能够暴露主要的问题
• 让冒烟测试与时俱进
• 将daliy build和冒烟测试自动化
• 成立build小组
• 仅当有意义时，才将修订（revsions）加入build中
• 但是别等太久才将修订加入进来
• 要求开发人员把他的代码添加到系统之前，进行冒烟测试
• 为即将build的代码准备一块暂存区
• 惩罚破坏build的人
• 在早上发布build
• 即使有压力，也要进行daily build和冒烟测试

第30章 编程工具

30.1 设计工具

计算机辅助设计工具(CASE)

30.2 源代码工具

编辑

• IDE
• 查找与替换
• diff工具
• merge工具
• 源代码美化器
• 生成接口文档的工具
• 模板
• 交叉引用工具
• 类的继承体系生成器

分析代码质量

• 吹毛求疵的语法/语义检查器
• 尺度报告器

重构源代码

• 重构器
• 结构改组工具
• 代码翻译器

版本控制

数据字典

30.3 可执行代码工具

产生目标码

• 编译器与链接器
• Build工具
• 程序库
• 代码生成向导
• 安装
• 预处理器

调试

测试

代码调整

• 执行剖析器
• 汇编代码清单和反汇编

30.4 工具导向的环境

UNIX工具箱

30.5 打造你自己的编程工具

• 项目特有的工具
• 脚本

30.6 工具幻境

第7部分 软件工艺

第31章 布局与风格

31.1 基本原则

好的布局凸现程序的逻辑结构

良好布局的目标：

• 准确表现代码的逻辑结构
• 始终如一地表现代码的逻辑结构
• 改善可读性
• 经得起修改

31.2 布局技术

• 空白
  • 分组
  • 空行
  • 缩进
• 括号

31.3 布局风格

• 纯块结构
• 模仿纯块结构
• 使用begin-end对（花括号）指定块边界
• 行尾布局

31.4 控制结构的布局

格式化控制结构块的要点

• 不要用未缩进的begin-end对
• 别让begin和end两次缩进

其他考虑

• 段落之间要使用空行
• 单语句代码块的格式要前后统一
• 对于复杂的表达式，将条件分隔放在几行上
• 不用goto
• case语句不要有行尾布局的例外

31.5 单条语句的布局

• 语句长度需要有所限制
• 用空格使语句显得清楚
  • 使用空格会让逻辑表达式更易读
  • 使用空格会让数组引用更容易读
  • 受用空格让子程序参数更容易读
• 格式化后续行
  • 使续行明显
  • 把紧密关联的元素放在一起
  • 将子程序调用的后续行按标准量缩进
  • 使后续行的结尾易于发现
  • 将控制语句后续行缩进以标准的空格数
  • 不要将赋值语句按等号对齐
  • 对赋值语句后续行按标准量对齐
• 每行仅写一条语句
• 数据声明的布局
  • 每行只声明一个数据
  • 变量声明应尽量接近其首次使用的位置
  • 合理组织声明顺序
  • C++中，声明指针变量是请把星号靠近变量名，或者是去声明指针类型

31.6 注释的布局

• 注释的缩进要与相应代码一致
• 每行注释用至少一个空行分开

31.7 子程序的布局

• 用空行分隔子程序的各部分
• 将子程序参数按标准缩进

31.8 类的布局

• 类接口的布局
  • 说明类及其完整用法的头部注释
  • 构造函数和析构函数
  • public子程序
  • protected子程序
  • private子程序和数据成员
• 类实现的布局
  • 描述类所在文件之内容的头部注释
  • 类数据
  • public子程序
  • protected子程序
  • private子程序
• 如果文件包含多个类，要清楚地标出每一个类
• 文件和程序布局
  • 一个文件应只有一个类
  • 文件的命名应与类名相关
  • 在文件中清晰地风格子程序
  • 按字母顺序排列子程序

第32章 自说明代码

32.1 外部文档

• 单元开发文件夹
• 详细设计文档

32.2 编程风格作文档

在代码层文档中其主要作用地因素并非注释，而是好的编程风格

32.3 注释或不注释

32.4 高效注释之关键

注释种类

• 重复代码：不要写这种注释
• 解释代码：考虑是不是代码写得不清楚
• 代码标记：如TODO标记
• 概述代码
• 代码意图说明
• 传达代码无法表达的信息

高效注释

• 采用不会打断或抑制修改的注释风格
• 用伪代码编程法减少注释时间
• 将注释集成到你的开发风格中
• 性能不是逃避注释的好借口

最佳注释量：约每十条语句有一个注释？

32.5 注释技术

• 注释单行
  • 不要随意添加无关注释
  • 不要对单行代码做行尾注释
  • 不要对多样代码做行尾注释
  • 行尾注释用于数据声明
  • 避免用行尾注释存放维护注记
  • 用行尾注释编辑块尾
• 注释代码段
  • 注释应表达代码的意图
  • 代码本身应尽力做好说明
  • 注释代码时应注重why而不是how
  • 用注释未后面的内容做铺垫
  • 让每个注释都有用
  • 说明非常规做法
  • 别用缩略语
  • 将主次注释区分开
  • 错误或语言环境独特点都要加注释
  • 给出违背良好编程风格的理由
  • 不要注释投机取巧的代码，应重写之
• 注释数据声明
  • 注释数值单位
  • 对数值的允许范围给出注释
  • 注释编码含义
  • 注释对输入数据的限制
  • 注释“位标志”
  • 将于变量相关的注释通过变量名关联起来
  • 注释全局数据
• 注释控制解构
  • 应在if，case、循环或者代码段前加上注释
  • 应在每个控制结构后加上注释
  • 将循环结束处的注释看成是代码太复杂的征兆
• 注释子程序
  • 注释应靠近其说明的代码
  • 在子程序上部用一两句话说明之
  • 在声明参数处注释这些参数
  • 利用诸如javadoc之类的代码说明工具
  • 分清输入和输出参数
  • 注释接口假设
  • 对子程序的局限性作注释
  • 说明子程序的全局效果
  • 记录所用算法的来源
  • 用注释标记程序的各部分
• 注释类、文件和程序
  • 说明该类的设计方法
  • 说明局限性、用法假设等
  • 注释类接口
  • 不要在类接口处说明实现细节
  • 说明各文件的意图和内容
  • 将文件命名为与其内容相关的名字
• 程序注释以书本为范例

32.6 IEEE标准

第33章 个人性格

33.1 个人是否和本书话题无关

33.2 聪明和谦虚

33.3 求知欲

• 在开发过程中建立自我意识
• 试验
• 阅读解决问题的有关方法
• 在行动之前作分析和计划
• 学习成功项目的开发经验
• 阅读文档
• 阅读其他书本期刊
• 同专业人士交往
• 向专业开发看齐

33.4 诚实

33.5 交流与合作

33.6 创造力和纪律

33.7 懒惰

33.8 不如你想象中那样起作用的性格因素

• 坚持
• 经验
• 编程狂人

33.9 习惯

第34章 软件工艺的话题

34.1 征服复杂性

34.2 精选开发过程

34.3 首先为人写程序，其次才是为机器

34.4 Program into Your Language， Not in it

34.5 借助规范集中注意力

34.6 基于问题域编程

34.7 当心落石

34.8 迭代，反反复复，一次又一次

34.9 汝当分离软件于信仰

第35章 何处有更多信息

一、投资理念与原则

1. 资金策略决定投资策略

• 一级市场与二级市场在原则上相通，但资金策略决定投资策略。
• 公募与一级市场的区别在于资金诉求不同。
• 资产管理机构应选择风险收益期望合理、且不是急用的钱。
• 通过锁定期，可帮助投资者避免追涨杀跌。

2. 收益期望与长期回报

• 长期来看，股权类资产的风险收益比最高。
• 美国市场长期合理回报约 10% 年化；他认为中国可能更高。

3. 竞争优势与能力圈

• 核心理念：没有竞争优势的领域绝不进入。
• 竞争优势来源：
  • 对市场的理解与经验。
  • 自知之明，只在能力圈内行动。
  • 把自己当普通人，不假设自己有超凡博弈能力。

4. 盈利来源与价值兑现

• 主要靠长期视角赚钱。
• 收益主要来自企业现金流增长，而非 PE 扩张。
• 赚“逆着来”的钱（逆向），而非追逐趋势的钱（顺势）。
• 投资必须与概率相连接，因无法预测大涨（“天上掉馅饼”）的时刻。

5. 应对不确定性

• 核心是在不确定性中寻找确定性。
• 将价格与企业长期股权联系，更容易找到确定性。
• 催化剂是价值实现的关键。公司便宜但缺乏催化剂，投资者会“熬不住”。

二、市场认知与洞察力

1. 市场行为与噪音

• 中国投资者交易行为受两因素驱动：噪音、叙事。
• 噪音与叙事并非坏事，市场没有绝对正确性。

2. 对中国市场的结构性认知

• 上证指数不涨的原因：
  • 指数采样不完整，未纳入中概股与港股。
  • 上市公司整体市值扩容速度太快，稀释指数表现。
• 市场整体是有效的，代表最关键的因素。
• 他赚的是微观层面的结构性错误，而非宏观层面的钱。

3. 洞察力的培养

• 广泛阅读、持续学习扩展能力圈。
• 多学习、多实践是关键。
• 善用工具（尤其是量化）。
• 理解人性永恒不变。
• 在科技加速的领域，用指数增长思维分析。

三、企业研究与评估

1. 尽调与走访

• 高度重视走访调研。
• 即使疫情时期，也平均每周飞两次（不含高铁）。

2. 企业增长驱动力

• 中国多数公司增长来自市场扩张与融资，而非内生增长。
• 持续融资往往稀释股东利益。
• 美国公司更多通过回购、分红回馈股东。

3. 企业家特质

• 优秀企业家越来越多。
• 优秀者具备：野心 + 脚踏实地。
• 有些企业家只处于生存状态。

4. “幸运与能干”框架

• 优先选“幸运”，其次才是“能干”。
• 幸运：是否踩对长期趋势（如环保、绿色发展）。
• 能干：管理能力，如组织、效率、执行力。
• 勤奋可提升运气；能干者整体上更“带运气”。

四、行业分析与选择

1. 长期产品周期

• 不需要持续创新的行业通常是好行业。
• 技术频繁革新往往让收益归消费者，而非股东。
• 偏好产品生命周期长的行业。

2. 医药行业：零与一

• 医药研发具有 “0 或 1” 属性，没有中间状态。
• 只有大公司能承担组合式研发风险。
• 生物医药兴起后，小公司也能通过长尾效应参与研发。

3. 互联网行业

• 真正的核心壁垒是：站在用户角度思考问题。

4. 新能源行业

• 技术更新快，最终回报多归消费者。
• 长周期（3–5 年以上）投资价值有限。
• 但短周期（数年）仍可能有机会。

五、心性修养与个人特质

情绪与心性管理

• 投资成功的一半在于心性管理。
• 追求“不以物喜，不以己悲”。
• 经历越多，越不情绪化。
• 即使重仓连续跌停，也能保持情绪稳定，因为“见多了”。
• 喜欢“旅游式探索”——走访、学习、调研，而非度假式休闲。

在今年的年报中，我说可口可乐和吉列是不可战胜的公司，并描述了它们有多伟大，它们是由杰出经理人经营的伟大公司。

但我觉得大家最好不要把我的看法，当作是这些公司无条件的买入的建议。

不然你可能会为这些的公司支付过高的价格，至少在短期是这样的。

永远存在一种风险：企业的业绩需要好几年时间才能追上你所支付的价格，再伟大的企业，股价都可能会领先于企业的业绩。

似乎巴菲特持有这些企业但又不建议买入。

所以究竟要怎么理解呢？我觉得大家争论不休的原因可能是因为忽略了两个关键要素：交易的摩擦成本和仓位管理。

持有等于买入是一个事实要基于一个基本假设：假设我们买入卖出股票没有摩擦成本。在这个假设下，我们可以做一个简单的思想实验，得到一个关乎摒弃沉没成本对投资影响的及其重要的视角。假设买入卖出股票没有摩擦成本，每天收盘后，你的股票会被系统以收盘价自动卖出，然后你在第二天开盘前先想好买入哪些股票，请问你要买什么呢？如果你本来的决策就是持仓不变，那么你应该买入和卖出之前同样的股票，而且每个股票的数量也是不变的。这就是持有等于买入的全部含义。

关于交易摩擦成本的影响，芒格在2023年每日期刊股东会上的讲话中，有一个很好的例证：股东问芒格为何伯克希尔不看好银行股，但是每日期刊还要继续持有银行股，芒格说每日期刊持有的银行股买入成本很低，浮盈很高，如果卖出，卖出收入的40%都要以资本利得税的形式交给政府，因此不愿意卖出。

即使没有资本利得税，仅仅是交易佣金，也会导向长期持股的倾向。如果没有任何交易摩擦成本，只要我们持仓以及观察中的任何公司有新的微小的变化，包括基本面的变化和价格的变化，我们的胜率和赔率发生改变，那么从理论上讲，都可以进行微小的调仓。但是考虑到交易摩擦成本之后，只有在公司基本面或者价格发生重大变化时，才会调仓。

持有等于买入的买入，其实指的应该是理想情况下进行持仓的重建，而不是在持有的情况下的加仓。如果是持有某投资标的情况下的加仓买入，或者操作其他持仓导致该投资标的的相对仓位变化，其实都代表了我们对现有投资组合有了新的看法。

所以，归根结底，要从本质上辨析持有是否等于买入，就要厘清究竟什么是持有，什么是买入，这在不同的语境下，不同的人提及时，可能会有不同的含义。

然而，比辨析这句话更重要的是，价值投资者应该学会抛弃买入成本对思考的影响，时刻检视自己的持仓，尽管他们不会经常买入卖出，但是在思维层面，对资产的比较是不会停息的，因为金钱永不眠，所谓的投资，本质上就是就是比较机会成本。

同样的股票，在不同的人眼中是不同的东西，有的人眼中是获取企业分红的凭据，而在有的人眼中则是赌博的筹码。

分红逻辑

股票的最底层逻辑是分享红利，从历史上看，公司赚到了钱，而且乐于通过分红或回购的方式和股东分享。比如贵州茅台、腾讯控股都是这样的公司。这类公司的风险在于：

1. 公司没有真正赚到钱，只是报表上看赚到了钱
   1. 只有利润没有现金流；
   2. 风险后置，比如银行保险之类的公司，现在看赚到了钱，可能隐藏了坏账、赔付的巨大风险；
   3. 财务造假
2. 公司赚到了钱，但不和小股东分享
   1. 不分红或低价回购，而是胡乱去投资（包括高价回购）
   2. 管理层侵占公司利益，各种关联交易挖墙脚
3. 公司以前能赚到钱，未来走下坡路，赚不到钱了
   1. 公司腐化，不再具有竞争力
   2. 被降维打击，变成了夕阳产业

在这个层面，我们要给利润和分红定价，并判断可持续性。

故事逻辑

基于最终会分享红利的逻辑，市场产生共识，认为一家企业未来能赚很多钱。这往往会讲出来一个逻辑通畅的故事来，比如电动车取代燃油车，小米会成为电动车巨头，比如人工智能崛起，百度会重新伟大，又比如拼多多利用中国的巨大产能，为产品找到市场，占据省钱心智。对于这样的公司，第一个层面的风险都存在，但还存在更多的风险：

1. 这个故事讲对了，但该公司不是主角，比如人工智能确实崛起了，但是可能和百度无关；
2. 这个故事根本就是错的，比如电动车取代燃油车可能并不是一个真正的趋势。

在这个层面，我们要给故事定价，难度可能上升了一个量级。这里面带有一些风投的逻辑。

赌博逻辑

在故事逻辑之上，我们有时不需要真的相信这个故事，只需要相信它目前是所谓炒作的热点，这就是赌博逻辑，赌场需要赌博的标的。以赌博逻辑而言，前述两层逻辑的风险反而都不是风险了，它只有一个风险：

1. 热点随时切换，赌博标的的变化难以预测。 在这个层面，根本没法定价，或许只有高频量化会有一些机会。

作为投资者，我只对前两层逻辑有兴趣，并且希望把大部分的仓位放在第一层逻辑上，小部分仓位放到第二层逻辑上。远离第三层逻辑。

今年在雪球上面逛的时候，明显发现讨论牛市是否真的来了，或者处在牛市什么阶段的帖子越来越多。甚至和父母视频聊天的时候，也会被问及，听说现在是牛市？我的基本看法是：从市场情绪来看，A股和港股现在确实是牛市了，但是这种市场情绪能支撑指数涨到多高，是否真的会有基本面的支撑，又是否会有过热后的崩溃，如果有崩溃什么时候来，几乎没法判断。

实际上，我认为作为一个严肃的投资者，尤其是偏向价值投资风格的投资者，对牛市不应该有任何期待，虽然有时候也可以利用一下牛市的市场情绪，在投资品种过分高估时卖出切换到低估的品种。

牛市给价值投资者的，往往是一种歪打正着。价值投资者在市场交易萧条时，按照自己内心的估值，低价格买入好公司好股票，在最萧条的时候，市场的交易者，除了坚定的价值投资者，可能就只有公司的回购。一个股票的价值被发现的过程，在熊市中是很缓慢的，其市值完全是被其真实盈利能力推高的，而市盈率不起任何作用。而当牛市来临时，所有的股票，不管是垃圾股还是绩优股，都可能因为一些莫名其妙的原因引来一堆的买入者，对于价值投资者来说，他们买入股票，一般期待的盈利都至少是翻倍，不会因为一二十个点的收益而“落袋为安”，所以从熊市中走过来的价值股，其卖盘是很少的，卖少买多，这样就可能导致牛市来临时，价值股的股价有时候会暴涨，这种情况，你很难讲这是一个真实的价值发现过程，对价值投资者而言，缓慢的价值发现过程，每年10～20个点的收益也是可以接受的，暴涨反而打乱节奏，逼迫人做出新的决策。

牛市中，会出现数不清的造富神话，人人都是股神，会有人说，巴菲特的年化收益，我一天就拿到了。我觉得熊市的时候，股市更像股市，剔除了流动性溢价之后，能看到真实情况，而牛市来临的时候，尤其是A股这种不成熟的市场，更像是一个赌场。一个理性的人，不会羡慕昨天在澳门赌场赢钱的人，因为他知道，一旦参与这个游戏，赢的钱迟早也会还回去。但是在股市里人的心态又有点不一样，它会加上很多技术分析，基本面分析，让人误以为自己不是在赌博，无论是谁，投资的还是投机的，都在同一个市场交易，让人误以为大家玩的是同一个游戏。只要记住，同一个市场，不同的游戏，你就会对别人的发财故事敬而远之。

这个世界上也许有成功的赌徒，但是如果你没有做好一个当赌徒的心理准备，那么牛市来临时，千万不要兴奋，去参与那些猜大小的赌博游戏，比如是“川大智胜”还是“哈尔斯”，是买带牛字的股票还是带马字的股票。如果熊市时没有买基金股票，牛市时就更加不要买了，赚点货币基金的无风险收益，不做那个发财梦，也挺好的。不过我也知道，没有人会愿意听这种扫兴的话，毕竟，投机像山岳一般古老，太阳底下没有新鲜事，从前的发生的事，将来必定还会发生。

可能最需要学习一点会计和财务知识，能在复杂的财报数据中剔除危险，发掘机会。但只有这些是不够的，要不然会计就会是最好的投资者，但现实不是如此。为了会计计算，需要懂一点数学，但是就像巴菲特说的，小学数学就够了，像牛顿那样的大数学家，投资也会亏到血本无归。

可能需要懂一些企业经营的知识，有企业经营的经验就更好，但是我们也会发现很多好的投资者并没有经营过企业，还有很多企业家在股票市场表现不佳，甚至公司高管对自己企业的股价也难以建立正确的认知。更何况如果要先学会企业经营再去投资，对大多数人来说这个要求不太现实。

可能需要懂一些经济学的知识，对宏观经济数据有一定的敏感性，但实际上看来，这些知识似乎也作用不大，一个明显的例证就是很多经济学家去搞投资，并不比韭菜散户好多少。

可能需要懂一些心理学的知识，知道市场先生是如何疯狂出价的，知道人类的不理性可能带来的危害和机会，知道恐惧和贪婪，知道逆向思考，但这些也远远不够，实际上逆市场而行大部分时候都是错误的。

说到底，投资尤其是二级市场投资，有两重的不确定性和复杂性，首先企业的经营有不确定性和复杂性，其次市场对企业的认知有不确定性和复杂性。企业经营涉及人类的生产和消费，而市场观点本身就是由不同的人组成的，投资最终是一门关于人的学问。人类行为有理性的成分，也有非理性的成分，所以一切学问在投资面前，都力有不逮。

最终，一个好的投资人，只能把自己变成一个行走的书架，思考的永动机，像查理·芒格说的那样，去建立各种各样的思维模型，成为一个杂学家，从不同的角度去思考去决策，持续追求更高的胜率和更高的赔率，让时间和好运越来越站在自己这边。

所以说，专才教育不太可能培养出好的投资人，而只有通才教育才行。但什么都去学一点，又有变成一个夸夸其谈的人的风险，要减少这种风险，只有持续学习，穿透知识的本质去学习，慢慢形成一种质的直觉，最后才能巴菲特一样，对一个企业五分钟就能做出是否值得投资的结论。

不超过一个小时的内容，无论是文字，音频还是视频，都不值得在这上面花时间。 虽是暴论，但矫枉必须过正。

短的内容，比如微博、微信公众号短文、短视频、短剧、一首流行的歌曲、十分钟解读一本书、半小时学完中国历史等等，通通不值得花时间。

长的内容，比如一篇深度长文、一部电影、一集电视剧、一集综艺、一张专辑、一本书、一集长度超过一小时的播客，这些需要一个小时以上去听、去读或者去看，去理解、去思考去感受的，才值得花时间。

碎片时间的迷思

可能你会和我说你没时间看长的东西，但我知道抖音人均日使用时间将近2小时，这是一部电影的时长。

然后你又会说，因为我的时间都是碎片化的，所以才去看碎片化的内容。

首先，碎片化时间可能是个假象，很多时候，我们是因为碎片化的阅读，而自己主动把时间碎片化的，比如我们经常会打开抖音，不知不觉一个小时都在做手指上滑的动作，而这个时间本来够看半部电影或者一集电视剧了。我们常常会把自己低精力的垃圾时间切成碎片，而本来这些时间更适合优质的休息和娱乐。

其次，碎片化时间不一定和碎片化内容匹配，碎片时间可以对一个整体内容做持续阅读和思考，比如一直在看一本讲自我提升的书，或者深入一个故事，比如看一部小说或一个电视剧。

干货的迷思

当代人都喜欢干货，无论是娱乐内容还是严肃内容，比如十分钟解读一本书，三分钟解读一部电影，半小时带你看完红楼梦。

光吃干货也会营养不良，水分是有必要的。论语讲一个仁的概念，多角度反复阐述；一部好的电影，有无数的细节镜头语言；一部好的小说，让你或感动或愉悦的时刻都藏在细节里。

大脑接受一个观念，体会一种情感，都需要反复多角度刺激，走马观花留不下任何有用或有趣的回忆。别人总结的干货和你自己的大脑难以匹配，不会受到大脑的重视。

一个长的内容，除了主干，还有细枝末节，有时候细枝末节对你的启发可能超过主干。

反过来说，一个长的内容如果水分太多，它需要去水总结才值得去看，那么相当于它的实际长度还是不超过一个小时，按照“不超过一个小时的内容不值得花时间”的原则，它就不值得花时间。

花时间挑选内容

只有一种情况，我们可以花较短的时间在长内容上。

比如试听一首歌，然后目的是去听一整张专辑。

花五分钟读一下书的目录，看看是否值得全本阅读。

花一个小时挑选20部电影，平均每部3分钟，放在自己的片单里面，一部一部来看。

花时间去挑选精神食粮，而不是把挑选精神食粮的过程当成了全部，不能沿着小吃一条街试吃，最后就算是吃过了。

对自己好一点

本文也是短内容，其实不值得看。所以如果你看到这里，应该停止刷微信公众号，花一些时间，去找长内容，然后投入进去。

对自己好一点，吃饭的时候，少吃一些快餐。精神食粮也是如此，远离那些短平快的东西，去追求深度、全面、细节，去追求鸡皮疙瘩、头脑风暴、醍醐灌顶、恍然大悟。

直觉投资者，顾名思义，就是凭感觉投资，不经过分析，或者说只经过一些伪分析，可能A股大部分投资者都属于这个行列。一些典型的行为包括但不限于：听某某老师说，最近什么板块比较火，可以炒作一把；看股票名字买入一只股票，但完全不知道这家公司是干什么的；觉得新能源是未来的趋势，所以买入新能源基金，但对基金实际的持仓一无所知（这个基金可能没有持有新能源的股票）。

被动投资者，是一类大智若愚的人，他们知道自己很难打败市场，无法预测市场的涨跌，更无法预测单只股票的股价，转而通过分散投资分散风险，通过定投放弃择时，典型的就是定投宽指数基金，比如沪深300，标普500，纳斯达克，红利指数等等，如果只买入一个国家的指数，那么还存在赌国运的成分，而如果全球化的买入各个国家的指数，则只存在一个“赌球运”的成分，就是你是否相信这个地球上的人类社会会越来越好，只要相信这一点，宽指数基金代表了人类的优秀企业，必然有高出平均社会生产增速的成长。

主动投资者，则是一个积极的投资者的最终形态，他们需要成为一个研究者，在自己的能力范围内彻底研究投资标的，并不断扩大自己的能力范围，相比被动投资者，他们更具进取心的地方在于，他们要去寻找市场定价错误，因此赚取更多的超额收益。然而主动投资可能是一厢情愿和自以为是，最后依然靠直觉。一般来说，多研究总比不研究好，但是，如果过于相信自己的研究，可能比被动投资者陷入更大的危险。这时候，他们依然要借助于分散投资，可是如果投资过于分散，其实和买指数基金区别不大。

总之，投资是一件需要谦虚谨慎的事情，需要多多验证思考自己的成功和失败是因为运气，还是真的掌握了一定的规律。从承认自己无知，获取市场平均收益出发，小心翼翼的去获取更多的收益，几乎所有自负的投资者，在长时间的市场起落中，都会付出代价。

股神巴菲特的长期年化收益也就是20%左右，如果你的预期比这还高，那么得仔细想想你比股神强在哪儿了。

如果是正常的激励和努力，就谈不上是打鸡血，如果是非理性的狂热，将家长的梦想与理念强加于孩子，那这种打鸡血的行为必然不可取。语言反过来会塑造思维，所以我们最好不要用“鸡娃”这种黑话，而要多去想想如何理性的和孩子一起努力。

在这个“鸡娃”黑话遍地走的当下，松弛感这个词放在孩子教育上，听起来就像一剂奢侈的解毒剂。我们可以长篇大论分析一下，东亚的家庭教育是为何会内卷的，从文化回溯到历史，再追溯到地理决定论，但毕竟，现在是二十一世纪了，我们应该担起自己的责任，像一个现代人一样思考问题，不要去苛责前人。无论历史如何，大环境如何，如果你爱自己的孩子，就必须把历史的饥饿感，“吃得苦中苦，方为人上人”的有毒精英思维，那些担心孩子会去扫大街的焦虑感阻断在自己这一代。

近年来人工智能发展非常快，大家除了自己焦虑，还进一步焦虑到孩子头上了。孩子要学点什么才能不被人工智能取代？其实大可不必焦虑，反而这个事情应该成为松弛感的来源。现代人真正满意自己工作的人应该是极少数，如果我们对现在的工作有诸多不满，那么如果被人工智能取代了，只要能有基本生活保障和福利发到手，生活水平不下降，没有工作还有什么好抱怨的呢？或许我们和孩子应该一起提前思考的是，如果不如人工智能，如果不能出人头地，如果不需要再靠自认为无意义的劳动换钱花，要如何过好自己的一生，而想明白了这个问题，那么是否被人工智能取代，也就关系不大了。

消费决策就是说我要花多少钱，买什么档次的东西，这个决策第一当然还是要从实际需求出发，从自己真正的需求出发，所谓真正的需求，自己明确知道自己买的是什么？自己是在为功能付费，还是为炫耀性价值付费，还是在交智商税；第二就是要量入为出，你的资产水平在哪里，收入水平在哪里，能够不费力气用什么档次的产品和服务。

投资决策讲的是风险和回报率，我的资产以哪个形态存在比较安全，能获得比较高的回报率，是货币基金？是股票？还是比特币？

很多人会把这两者混淆到一起，股票账户大涨了，觉得这是白赚来的，去买台车。买车可以，关键是要在股票账户大跌的情况下，还能不吃力的去买，才是真的量入为出。股票账户的涨跌，长期来看当然会影响自己的资产量，但显然不是一个短期的事情，不太可能一轮股票大涨，自己就从买不起这个车到买得起这个车了。

有一个说法，叫做投资要解决问题，其实说的就是投资要提升自己的资产等级才有意义，从只有10万，提升到100万，1000万，这是提升等级，消费也可以相应有所提升，否则，只是从10万到20万，就拿10万出来大肆消费，这不是投资，这是赌博。

我有个长辈，年轻的时候喜欢打牌，假期的时候就每天去茶馆打牌，日出而作，日落而息。每天晚上他回家，只要看他是不是手头拎了两斤猪肉，就知道他是不是赢了，赢了就买肉吃，输了就不买。结果是什么呢？长期而言，一定是输的，因为赢的钱都买肉了。在这个场景中，其实他输钱了也买得起肉吃，所以问题不大。但如果用赌博赢来的钱买自己本来消费不起的东西，就麻烦了。

我在澳门酒店逛的时候，发现那个地方金碧辉煌，比广州气派多了，我老婆感慨这是真正的资本主义。其实就是赌徒的钱堆出来的嘛。输了钱留下，赢了，去买奢侈品，钱照样留下。

投资决策和消费决策不分开，其实就是当赌徒。

股票涨了，人心都是肉长的，谁都高兴，巴菲特说看到股票涨，中午吃面是要加个鸡蛋的。但仅此而已，加个鸡蛋就行了，吃鱼翅燕窝不行。

没有投资后一劳永逸的资产，投资者需要一直评估自己能看懂的各类资产，适时切换，买入相对低估而安全的，卖出相对高估而危险的。

所谓“落袋为安”一般指的是把其他资产变成现金，但现金只有在特定的情况下才是最佳资产，它最大的问题是贬值。有时候收集优质企业的股票是更好的“落袋为安”。

所有的资产都有寿命，无论是代表企业的股票，还是类似黄金和比特币的投机品，说一种资产终究会归零没有意义，有意义的是多久会归零，在有归零的迹象之前跳槽。

沉没成本不是成本

资产的历史只看它的内在表现（如ROE），用来预测它未来的内在表现，所有关于出价的历史，比如自己的买入价，资产的历史价格波动，都需要刻意忽略。

历史最高价和最低价都是用来突破的，下跌了50%需要上涨100%回到原价并不能说明上涨比下跌更困难，跌了90%还能再跌90%，涨了10倍还能再涨10倍。

如果不考虑买卖的摩擦成本，持有即买入，考虑到摩擦成本，品种切换要保守。一个完美的股票软件应该看不到成本价。不看成本价是反人性的，但投资就是反人性的。

基于认知分配仓位

仓位高低和认知深度成正比，认知越深刻，仓位越重。不可能有完美的认知，所以仓位永远应该有上限。

懂得多一点，仓位可以重一点，买入价可以高一点，懂得少一点，仓位就要轻一点，买入价就要低一点。

不要全仓一个品种，不要做空，不要加杠杆，要做时间的朋友，不要做时间的敌人。

火车上，我的心感觉空洞洞的，脑子里老是回闪二十多年前的一个画面，我还是一个小学生的时候，我的同学指着远处路上走来的一个少年，悄悄的对我说：你知道那个初中生吗？那是”斧头帮“的帮主。再走近点我一看：哈，那不是我小哥吗？那是一个香港古惑仔电影以录像带形式流行的年代，这段对话是小哥在我心中潇洒形象的高光时刻。后来，他年纪轻轻去广东打工，虽然没有大富大贵，但也顺顺利利结婚生女，熬过一段和孩子两地分居的时间，后来回到老家工作，新修了房子，孩子也考上了市里最好的重点高中，一切似乎都朝着美好的方向在走。

葬礼上，所有的人在悲痛之余，都不禁在问为什么？我们交流和他交往的种种记忆，开始慢慢有点理解一个精神压力巨大，疑似重度抑郁症的患者。面对一个巨大的悲剧，在生的人总要找到自己的理解，才能在这人间继续前行。两年多了，我除了自责自己在这个悲剧中没有发挥自己的丝毫作用，也一直在找一个让自己信服的理由。

当时小哥的经济状况其实有点糟糕，刚刚在农村修了一栋两层小楼，积蓄已经花光，孩子在读高中，又新买了一台十几万的车，车是分期付款的，而且连首付也是找亲戚凑起来的，本来两口子月月拿工资慢慢还也没有问题，但是又赶上嫂子身体不好动手术，当年不但没拿几天工资还花费不少。我不忍在此再去分析他透支买车的种种动因，只是在众多我能归咎的原因中，我想那个车贷或许是压死骆驼的最后一根稻草。

两年多来，我无数次听见那个广告：“某某新车网，首付三千元，新车开回家”，都会有一种无力的愤怒感。凡所得必有付出，当年轻人三千元把新车开回家的时候，他们清楚所付出的代价是什么吗?

是对未来的选择权，甚至可能是生命。

前几天，广州有个年轻人一把火把租住的房子烧了，然后跳楼自杀了。他所租住的房子由蛋壳公寓管理，这家公司做的是二房东的生意，帮房东把房子装修好，按月给房东租金，然后再去找房客，提供一种租金贷的服务，租客在自己可能不太清楚的情况下，一次性付出了一年的租金，只是形式变成了向银行分期付款，银行从中赚取利息，蛋壳公寓则一次性套现，拿着钱去玩其他的花样，直到玩到没钱，然后房东开始收不到租金，要赶房客走，而房客如果走掉，欠着银行的钱还要继续还，同为受害者，房东和房客却只能自相残杀。

最需要为此付出代价的显然是蛋壳公寓的实控人，但我无意去探讨这个死局中的责任问题，只是觉得能被一年的房租逼到绝境的人，他其实是没有给自己的财务状况留有足够的缓冲，消费了自己无法负担的东西。这类长租公寓普遍在租金上要高出一大截，但在装修与管理上贴合年轻人的喜好，提倡的是”对自己好一点“ 。在这个崇尚“早买早享受”的年代，我的想法实在是太过保守了。

储蓄和投资是放弃当前享受的权力，保留未来的选择权，而透支消费则是放弃未来的选择权，在当前立即享受。不知从何时起，手机上每一个软件都开始提供现金贷服务，无数的广告时刻在给你洗脑：去消费吧，你消费的东西定义了你的人生，剩下的钱慢慢还就好。寅吃卯粮，有三个钱花四个钱这种被传统鄙视的行为反倒成了一种时尚。

月光乃至透支的财务状况，就像一张拉得过满的弓，当然它有慢慢松弛下来的机会，但是断掉的风险也是最高的。

二十多年前，我和小哥还都是小学生的时候，像一个武林大侠，从学校附近一个不高不低的小山崖上纵身跳下，是我们小学男生的时尚，直到有一天，最勇敢的他摔到了自己的胳膊打了石膏，这种行为被学校严查禁止。那时的我们还不知道，这个世间的时尚不仅仅是学武林大侠，这个世间的风险也不仅仅是一个小山崖。

本文为《园丁与木匠》 的书摘和简评，推荐阅读纸质书或微信读书上的电子版。

《园丁与木匠》一书的作者，是儿童学习和发展方向的优秀研究者，心理学家、哲学家。本书的学术素养很高，一本育儿书，从进化论、哲学的高度来谈，还是比较少见的。

你是园丁，还是木匠

作者彻底否定了当前中产阶级主流的、焦虑的育儿模式——所谓“教养”模式。“教养”，英文词汇parenting，是一个上世纪五六十年代才成形的词汇。是中产阶级兴起后，传统育儿模式无以为继后的一种潮流。也许这种模式在工业化生产中起到了正面作用，但是面对更加复杂的未来，必须反思。园丁和木匠在中文中未必是最佳的隐喻，木匠固然是打磨成型，但中国式园丁的杰作“盆景”也是有过之而不无不及。这里的园丁应该是允许植物野蛮生长的。没有一个“理想中的”孩子，对很多中国家长而言是要命的事情吧。养育中有两组悖论：依赖与独立，玩耍与学习，这并不是往哪个方向直接走那么简单的问题。

“教养”是一种糟糕的现代发明

“混乱是阶梯”，儿童的混乱是人类发展的阶梯，探索是儿童的天性，甚至可以说是儿童的使命，如果给孩子画好蓝图，定好条条框框，可以说是相当自负的行为，在原始社会不稳定的生活环境是如此，在当代和未来发展迅速的现实中也是如此。中国传统教育理念中的“玉不琢不成器”，与工业文明下的“教养”似乎一拍即合，变本加厉，这种“教养”模式是一切按类似学校的条条框框来设计孩子，在传统教育中，还有基于亲子关系的直觉，而当下这种直觉甚至都让位于教条，比如孩子哭了要不要抱，父母都没有直觉的判断，而要遵从育儿书的指示，更不用说在“牛娃”攀比中的焦虑了。

童年，人类进化的关键策略

作者把童年的重要性放到了人类进化策略的高度。而现实中，很多家长只是把童年当作仅仅是不得不经历的成人预备期，他们盼望的是孩子快快懂事，成绩优异，不用自己操心。作者从进化论的角度分析人类童年的意义，我觉得是抓住了问题的关键，这种为童年的正名，不仅仅只是人文关怀，而是认知高度的碾压了。从“不能输在起跑线上”开始，要么一辈子竞争下去没有在生活中幸福的能力，要么在某一时间点开始堕落，报复性追求快乐。

爱，持续进化的保障

作者讨论了三个层次的对孩子的爱：父母、祖父母、异亲，从进化论的角度阐释了人类以爱的形式突破囚徒困境，在基因与文化的层面都深植了照顾儿童的密码。不是因为爱而照顾，而是因为照顾而爱。我的体会是，当前的社会文化一定程度上是异化了这种传统。漫天的对“熊孩子”的过敏式的指责，对儿童这种不完全行为能力人，缺乏可预料性的恐惧，比如在飞机上指责哭闹的两岁儿童的母亲。整个社会的“教养”神话是：只要父母好好教育，再小的孩子也能像个大人一样乖乖的遵守公共秩序，而这恰恰是反人性的。

边看边学

这一章讨论孩子通过观察和模仿的学习。现存的教育体系不过几百年，只不过现代的中产阶级家庭父母适应了学校教育，又想把这一套尽早地用在自己的孩子身上，而对更加古老、天然地模仿学习则注意不够。有一种常见的解释是镜像神经元，但这只是一种偷懒地过于简化的解释。孩子的模仿非常复杂而精细，超出成人的感知（不知道他们什么时候就学会了）。首先孩子的模仿不仅仅是模仿过程，而是试图理解成人的意图，从中发掘因果关系，融入自己的思考，最终模仿一个自己感兴趣的结果。如果成人表现得不像专家，孩子会更多的去芜存菁。而当成人表现得更像专家时，孩子会更多的模仿细节，有时候这不是一件好事。孩子的模仿还有社交属性，他们更倾向于模仿和自己更相似的人，模仿那些有仪式感没有实际作用的动作，来使自己融入一个群体。对当代父母的启示在于，中国古语“身教重于言传”永远都不过时，与其整天嘴挂在孩子身上，不如做好自己，和孩子形成良性的互动，给孩子参与家庭乃至社会的的活动充分创造条件。

边听边学

这一章讨论孩子如何通过语言学习，这是人类远远超越其它动物的地方。孩子会听成人说，但也不是全盘接受，他们会判断成人是否值得信任，这种判断基于很多因素：比如说话的人是否自信，说话的人是否是领域内的专家，和说话的人的关系如何，总的来说，需要建立信任。孩子爱问为什么，在绝大多数时候是他们真的想去探究世界的原理，在很多时候，直接问是比观察更加高效的学习方法，比如要知道为什么会下雨。我们不能糊弄小孩，也不用担心偶尔答不出来，因为他们探究的热情是很高的。孩子会从成人的用词中总结出偏见来，比如“日本人都很坏”和“有些日本人很坏”是完全不同的效果。父母要做的不是试图去教什么，而是保持良好的互动，在谈话中构建良好的亲子关系，多回答为什么，也可以多问孩子为什么，多让孩子和更多的人交谈。这种问答构成的是真实的生活，而不是刻意的，由于孩子的敏感性，父母不可能一直假装博学，假装公正客观，一切只能是真情流露。

边玩边学

玩耍的作用很难测量，因为一旦去测量，可能就不是玩了。不仅人类，凡是智能发达的动物都喜欢玩耍。有一种常见的玩耍方式是打闹式玩耍，小狗的相互撕咬，孩子间的身体碰撞，这类游戏可以提高孩子的社交能力。据我观察，当前中国的大部分家长对这类游戏是禁绝的，看见孩子之间有点身体冲突，大人都要开始打架了。玩耍受好奇心驱使，孩子玩耍有点类似科学家做实验，有假设求证、随机探索。人类比其它动物更善于假装类玩耍，这是一种反事实的推理能力，构建一个虚拟的、有一定逻辑的世界，文学作品也有这样的力量。善于假装的孩子更能理解他人的想法，甚至有很多小孩会有一个假想的朋友，这常常会吓到成人。在孩子的玩耍中，家长应当做支持而不是做引导，引导往往会断绝孩子自己的探索想法，变成对成人按部就班的无聊模仿。家长能够积极主动去做的是创造一个有更多东西可以玩的的环境，但是，这不一定取决于花多少钱，比如一根棍子可能就是很好的玩具。其实成人只要放下架子，不见得就不喜欢参与孩子的游戏。

边练边学

这一章主要讨论学龄儿童和学校教育。学龄这个概念是基于学校教育的，但是儿童的心理发展确实有这样一层变化，从探索式学习为主过渡到掌握式学习为主，为成人生活奠定基础，掌握式学习需要练习，是一种对脑神经的重构，这个过程是把技能变成下意识状态的，从另一个角度看也是一种退化。当前的学校教育，是伴随工业化生产产生的，并不是什么人的常态，在此之前，更早的教育都是学徒式教育，这种模式在当前依然在某些领域发挥着主导作用，比如体育和音乐的学习。学校教育培养的是善于上学的人，集中课堂授课的形式需要儿童有很高的集中注意力的能力，而这种能力在从古到今的现实中，不见得是一种优势能力。但是美国的现代教育体系越来越把那些无法长时间集中注意力的儿童定义为多动症，中国也是这个趋势。在集中注意力这个特征谱线上，每个儿童所处的位置都不一样，这不过是一种进化的多样性，作者倡导学校应该适应各种不一样的儿童，而不是给孩子喂药吃。从进化上看，青春期是人类迈向成年人的一个过程，关乎人的动力机制与控制机制，青春期的儿童更容易受同龄人评价影响，更加看重那些冷静的成年人觉得匪夷所思的奖励，当代的儿童青春期到来提前了，但他们却远不如学徒模式中成长的儿童有真正的工作经验，能够控制自己的行为做出真正有意的成就，一个孩子想把科学家作为职业，却只能在二十多岁后才能真正的接触科学家一起工作。学校教育和家庭教育一样，也应当是园丁模式，但现实却更多是木匠模式。

科技与孩子的未来

你的孩子是信息时代的原住民，而你自己则只是个移民，看到我孩子话都说不好却能熟练的操作iPad，我对作者的判断深表赞同。当代父母对科技的恐惧并不是新的恐惧，苏格拉底就对文字书写这个当时的新科技表达过深深的担忧，而且他的担忧成为了现实，我们更加依赖文字传承，而不是口头传承，但是人类的文化没有毁灭，反而更加发扬光大。科技会把下一代人带向何处，我们唯一确定的答案只能是不知道，试图控制孩子的一切，安排好他未来的人生，是多么可笑的事情。青少年在新的文化下成长，他们面临和过去一样的人际交往的各种难题，甚至更甚，需要面对网络陌生人的恶意，这一切无可避免的滑向的未来是这一代人的命运。身为家长，我们能做的不是控制，但也不是所谓的顺其自然，而是做好连接过去和未来的桥梁，孩子在传统中长大，汲取营养，又会有自己的创新，我们可以继续和孩子一起读书，但也绝不可能与电子设备隔绝，因为这个世界的真实面目就是这样。其实写到这里，会有一些伤感，说到底还是长江后浪推前浪，前浪死在沙滩上，一代人有一代人的责任，有一代人的哀与愁。

养育孩子的意义

从哲学上讲，无法界定养育孩子的意义，因为生孩子之前和之后的你根本不是同一个人，多元化的价值观会尊重丁克的想法，但是永远不要假装那些你不曾拥有的是不值得的。从社会发展来看，当前的社会运作方式对亲子关系是有伤害的，父母的工作与孩子基本上没有什么关系，社会不奖励对孩子的养育，孩子成为成人竞争的负累。在过去的熟人社会，社群的成员都会善待儿童，而在冷漠独立的城市生活中，这些都不存在了，有的只是对儿童要表现得过早成熟的压力，网络上对熊孩子毫不留情的打杀，起因固然是某些家长的巨婴行为，但也折射整个社会对儿童的某种歧视。在熟人社会无可避免的解体后，政府、社会必须承担起养育孩子的责任。无论是养育孩子还是赡养老人，整个社会都需要重新思考，在赤裸的经济利益衡量之外，还有没有其它需要考虑的问题？

为人父母是在一系列矛盾中寻找平衡的艺术

我觉得好的育儿书都给不出笃定的答案，这本书的结论也是如此，因为这才是真相。每天，我都会对我的孩子提或软或硬的各种要求，有可能是他干扰了其他人，有可能是单纯觉得怎样做对他更好，然而我每天都在怀疑自己对他的要求是否合理，是否必须，是否是自己自作多情。以如何、怎样开头的育儿书数以千计，数以万计，它们往往都笃定的给你方法，然而，只要你会反思自己，面对孩子时，你永远都不会那么笃定。再专制的家长也会承认自己希望孩子有朝一日能独当一面，但幼小的孩子也确实需要父母的帮助，这种依赖与成长独立的矛盾是永恒的，是没有万能解决方案的。我的体会是，孩子不是瓷器，不会因为一两次父母的错误就粉身碎骨，但可怕的是父母的笃定：这样一定是为你好，没有反思将是一切悲剧的起源，好的育儿书比如这一本为你的反思提供思考的起点，但读完它一切才刚刚开始。

最近集中读了很多关于学习科学的书和资料，想初步整理一下自己的一些感受与想法，但是写成架构式的文章可能需要一本书的容量，自己还远远不够，对这个领域的研究初步计划是五年时间，这篇文章就算是一个良好的开端吧。

1 为什么要关心学习这个话题？

私人的原因有两点：一是自己学习人工智能等复杂的技术时遇到了很多困难，二是想给自己孩子带来身体力行的经验。从更大的视角看，人类的学习机制远比目前的机器学习复杂，基于脑科学、认知科学、心理学等的发展，学习科学虽然有了一些成果，但更多的还是未知，而且这些有限的成果也远没有得到有效的推广。和医学一样，学习中的个人体验很重要，因此习俗、偏方，比起科学的结论往往更有生命力。程序员是最能感受到学习重要性的职业之一，新的技术层出不穷，而每一行代码背后，可能都是取代一个做着重复性工作的人。在互联网越来越抹平信息鸿沟后，我们看到富豪榜中越来越多出现的是学霸，这是认知优势取代信息优势的一个写照。无论是出于考高分、赚大钱的功利目的，或者是追求真理的喜悦，学习都是必须的修炼。

2 学习仅仅是学生的事情么？

把读书学习等同于在学校接受教育，考高分拿文凭，是对学习最大的误解。如果你去实现过“愚蠢”的人工智能，就知道每个孩子都是学习方面的天才。然而，体制化教育的失败者极可能熄灭学习的初心和热情，而体制化教育的成功者，也可能在社会上遭遇失败，被当作读书无用论的典型。很多人的进步停留在工作的头几年，最后一次的大规模学习只在适应工作时被逼的。当他们为人父母，虽然自己的知识水平已经停滞，却又期望自己的子女成绩出众，在教育培训机构“月薪五万养不起一个娃”的软文中焦虑。然而学习本质上不过是生而为人的一种本能，而一般意义上的所谓读书，不过是学习途径中的一种。孔子说：三人行，必有我师，孔子又说：学而时习之，不亦说乎。我不可能说得比他更好了。

3 在所有关于学习的观念中，最最重要的一点是什么？

我觉得最重要的一点，是要抛弃对智商和能力的“整体理论”，拥抱“渐进理论”。简单点说，就是不要相信智商和能力是与生俱来的，不可改变的，而要相信智商和能力是可以通过学习提高的。用天才和普通、高智商和低智商、聪明和愚钝来做二分法，是对人进步的最大伤害。不可否认人有天生的差异，但以常人努力之程度，往往还谈不上比天赋。如果所有人的能力形成一条谱线，那么每个人都会有自己的位置，它不是二分的，也不是固定不变的。每个人都会碰到自己能力的天花板，即使是天才的科学家也不例外，他们也可能终其一生弄不明白一个问题。如果一个人能力天生差一点，又相信这是不可改变的，显然能力是不可能提高的。而一个人如果能力天生比较好，但相信这是不可改变的，当他遇到天花板，遭遇困难和挫折时，就会怀疑自己的智商和能力，不可避免地失败或逃避，这就是所谓的只有小聪明，没有大智慧。不同的信念坚持一生，会是天差地别的结果。而且，这不单单是信念，脑科学早就证明了人的神经细胞是可以一直新生的。

4 是努力重要，还是方法重要？

这自然是一个伪问题，答案当然是都重要。但更深层次的问题是，什么样的努力是正确的努力。在传统观念中，学习被视为一件严肃的事情，正襟危坐，头悬梁锥刺股才是正道。对那些学习成绩好但看上去不是很努力的，我们称赞他天资好，还鼓励他们不要浪费了自己的天资，应该更加努力，而那些看上去很努力但成绩一般的，我们也会不吝夸赞他们的努力，比起那些成绩差又不努力的学渣，总是要好很多。反复阅读学习材料，在书上划重点，做漂亮的课堂笔记，是常见的被科学研究证明无效的学习方法，这类方法的共同特点是会花费学习者不少时间，做一些停留于资料的努力，再清晰漂亮的笔记，不能转化到自己脑子里也是无用的。一切有用的方法，都要基于主动性的原则，想要努力真正弄懂所学的东西，这里面不能有丝毫的自我欺骗，被无知击中的感觉很难受，躲在自以为是的努力中很舒服，但从来就没有轻松学习的方法。

5 为什么考试很重要？

一个最常见、最有效的学习方法就是考试。考试仅仅被当作检验学习成果的工具，分数成为唯一的追求目标，要么唯分数论，要么大谈素质教育避谈考试，是我们对考试这个工具最大的误解和浪费。首先，考试是消除“我已经学会了”这种幻觉的终极武器，反复看教材或笔记，总是会产生这种幻觉；其次，考试会强制你回忆学习的内容，是巩固记忆和理解的绝佳方式。 一个好的老师总是会用各种手段来考学生，课前测验、课堂测验、课后测验，目的不是给学生排名，而是促使学生去提取自己的记忆，加深印象，找到差距。即使不是正式的学习，比如看一本非专业相关的书，也可以充分利用考试的手段，最简单的，在看完一个章节后，合上书本，问一问自己几个问题：刚才看的材料主要讲了什么内容？是否认同这些观点？和自己已有的知识或经验能有什么联系？如果认同，在实际生活和工作中该如何运用？

6 如果读书学习很重要，为什么又会有书呆子？

为什么懂得了很多道理，却依然过不好这一生？不是道理的问题，而是自己的问题。如果把读书学习当作一种像打麻将一样的娱乐，做一个书呆子也未尝不可。但如果是求进步，那么读书学习只是一个开端，而不是结束。书呆子会热衷于书架上有多少本书，读书的速度，每年读书的本数，热衷于掉书袋，热衷于看到了多少干货，却不会去关注有多少知识和观念扎根到了自己的脑子，这些知识和观念有没有形成一个完整的、自洽的、不断进化的体系，有多少观念付诸了实践。曾国藩是能带兵打仗的书生，每天写日记自我反省，反省的是实践活动该如何贯彻自己的理念。 纸上得来终觉浅，绝知此事要躬行，我说得不可能比古人好了。孔子和曾国藩需要每天自我反省，为什么我们就不需要呢？

7 是不是练习得越多，就学习得越好？

一万小时天才理论是流传很广的一个观念，它背后“刻意练习”的理论也是误解很多的一个理论。付出总有回报是让人心生安慰的，然而有效的练习却不是简单的重复就行的。无论是科学研究还是天才的个体经验都表明，有效的练习必须是主动性极高的练习，首先需要以退为进，划分足够细的模块，分模块、针对短板练习，其次，这些练习也不能是简单的重复，要富于变化、相互穿插，这些研究成果是反直觉的，人们总是觉得反复重复练习掌握得更好，而变化穿插的练习效果更差，这是一种难以克服的幻觉。真正有效的练习是高度消耗脑力的，不可能坚持过长的时间。

8 为什么看书总是记不住，理解不了？

最新的记忆理论认为，记忆的提取比记忆的初次生成更重要。每个人都能够过目不忘，问题是那些记忆的碎片散落在大脑中无法重新组织提取出来。唯一的办法是让它们彼此之间建立更多的联系，就像一个本来落后的村落，修了四通八达的水泥路，它就不会再是落后的村落。对不成体系的知识有很多小技巧，比如编顺口溜：“要记大月自有方，七前逢单七后双”，对成体系的知识最重要的是建立自己的知识体系，所有的新知识都要尽量多的跟已有的知识和经验建立联系，显然，这不是一个简单轻松的过程。很多人都有考前突击复习的经验，有时候还能取得不错的成绩，然而，这也是一种幻觉。没有经过艰苦的努力纳入自己体系的知识，依然会还给书本。

9 可不可以少睡一点来多学点东西？

成功人士的神话之一是他们只睡三四个小时，但是他们可以在飞机上补觉，可以在办公室弄一张床，他们作为决策层脑力活动是低烈度的，他们也可能只是在说谎。如果你是高烈度脑力活动者，比如研究生，写代码的程序员，那么牺牲睡眠除了让你可能早点死外，还会严重的降低学习效率。脑科学表明，神经突触的建立必须经过充足的睡眠过程。一切无法建立新的神经突触的学习都是在浪费时间。现代人的生活习惯越来越偏向晚睡，即使是孩子也会受这种文化变迁的影响。而孩子被作业负担压迫到睡眠不足，则是对脑科学的一种嘲讽。

10 学渣是如何诞生的？

在日本励志电影《垫底辣妹》中，女主准备高考但数学基础太差，补习老师的方法是从小学数学学起，这不是夸张，而是有真实原型的。体制化教育的缺陷在于，它不得不制定一个面向大多数人的标准，8岁时应该掌握怎样的语言，9岁时应该懂多少数学，这样总会有人掉队，这些掉队的人则很可能被打上各种负面的标签，也许到12岁时他才心智成熟适合学数学，但是已经没有这样的机会了，往往这些孩子自己已经对学习活动不再有任何参与感。欧美也会有那种根据小孩具体情况的混龄学习课堂，但如果一个12岁的孩子去学小学三年级的数学，家长和孩子的面子都会挂不住，或许这种情况下，补习班才是最好的出路。学习任何领域的知识，都得先慢再快，打好基础，学习就像修房子，万丈高楼平地起，勿在浮沙筑高台，我说得不可能比古人更好了。

11 为什么念念不忘，必有回响？

当准妈妈怀着宝宝的时候，准爸爸会在逛街时发现更多的孕妇，当你苦苦思索苯环的结构时，晚上可能梦见咬自己尾巴的蛇。当你在全力以赴思考一个问题时，即使你停下来，脑子里依然会有像后台进程一样的东西存在，你的感官会不由自主地去搜集相关地信息，你的梦境会去尝试各种方案。突破、灵感是自然产生的，却不是凭空而来的，它们只属于那些全力以赴后松弛的大脑。研究表明，天才也往往只是在自己的专业领域表现突出，他们的灵机一动、神来之笔，不过也就是无数刻苦的努力之后的自然馈赠。如果你想发财，但每天为此花的思考时间连十分钟都不到，又怎么可能天上掉馅饼呢。念念不忘之后的回响，是一个概率事件，但是我们可以提高这个概率。

主要参考书目：

• 有效学习
• 如何学习
• 所谓学习好，就是方法好
• 认知天性 : 让学习轻而易举的心理学规律
• 好好学习 : 个人知识管理精进指南
• 科学学习 : 斯坦福黄金学习法则
• 学习的艺术
• 学习之道
• 如何高效学习 : 1年完成麻省理工4年33门课程的整体性学习法

在这个教程中，我们会展示一些简单但有效的方法，使你可以用很少的训练样本——每个待识别的类别只有几百张到几千张图片——来构建强大的图片分类模型。

我们会使用如下的方法：

• 从头训练一个小的网络作为比较基准
• 使用预训练网络的bottleneck 特征
• 微调预训练网络的最后几层

这会让我们涉及以下的Keras 特性：

• fit_generator 使用Python数据生成器来训练Keras模型
• ImageDataGenerator 实时的图像增强
• 层冻结和模型微调
• …其它

注意：所有的示例都在2017年3月14日更新到了 Keras 2.0 API。运行这些代码需要Keras版本号大于等于2.0.0。

我们的设定：只有2000个样本（每类1000个）

我们从如下设定开始：

• 机器安装了Keras, SciPy, PIL。如果你有NVIDIA 显卡也可以用（需要安装cuDNN），不过由于我们处理的图片很少所以这不是必需的。
• 一个训练集目录和验证集目录，都包含以分类组织的子目录，这些子目录包含 .png或.jpg图片：

data/
    train/
        dogs/
            dog001.jpg
            dog002.jpg
            ...
        cats/
            cat001.jpg
            cat002.jpg
            ...
    validation/
        dogs/
            dog001.jpg
            dog002.jpg
            ...
        cats/
            cat001.jpg
            cat002.jpg
            ...

为了获取几百到几千张你感兴趣的分类的照片，你可以通过 Flickr API 下载特定标签的图片，它的协议比较友好。

在我们的例子中，使用两类图片，它们来自 Kaggle ：1000只猫和1000条狗（尽管原数据集有12,500只猫和12,500条狗，我们只使用每类最靠前的1000张）。再每个类别取400张图片作为验证集来评估模型。

这就只有很少的图片可供学习了，对一个图片分类问题而言这很不容易。这是一个有挑战的机器学习问题，但也很符合现实情况：在现实世界中，只获取小规模的数据集也是很昂贵的甚至是几乎不可能的（比如医疗学习）。从有限的数据获得最大的产出是一个合格的数据科学家的关键技能。

这个问题有多难呢？在Kaggle 开始猫狗分类竞赛（一共25,000张图片）两年多后，出现了如下的评论：

在一个多年前的非正式调查中，计算机图像专家认为当前技术如果没有的的巨大进步，一个准确率高于60%的分类器都几乎是不可能的。作为参考，60%准确率的分类器将12-image HIP的猜测概率从1/4096提高到1/459。而现在的材料认为在这个任务上机器分类的正确率可以高达80%。

在竞赛结果中，顶级选手使用现代的深度学习技术，准确率可以高达98%。在我们的例子中，我们限制只用8%的数据集，问题会更难。

深度学习在小数据问题中的作用

我经常听见这种说法“深度学习只有在你有庞大的数据时才有用”。虽然不是全错，但这种说法一定程度上是有误导作用的。当然，深度学习有从数据中自动学习特征的能力，通常只有在可用的数据量很大时才有可能——特别是当输入样本的维度很高时，比如图片。然而，卷积神经网络网络——深度学习的重要算法之一——是针对大多数感知问题（比如图片分类）的最佳模型，即使只有很少的数据可供学习也是如此。在一个小的图片数据集上从头训练一个卷积神经网络仍然可以获得不错的结果，而且不需要手动设计特征。卷积神经网络足够好了，它们是解决这类问题的正确工具。

但是更进一步，深度学习模型天然地适合更改应用场景：正如你将在本文中看到的，你可以将一个在大型数据集上训练的图片分类或语音识别模型，稍做修改后应用到完全不同的问题上。尤其是在计算机图形领域，很多预训练的模型（通常在ImageNet 数据集上）是公开可下载的，你可以使用它们在很少的数据上构建强大的图像模型。

数据预处理和数据增强

为了更好的利用有限的样本，你需要使用一系列的随机变换来增强图片，这样模型就不会再重复使用完全相同的图片。这可以防止过拟合，模型能更好的泛化。

在Keras 中这可以通过keras.preprocessing.image.ImageDataGenerator类来实现。这个类提供如下功能：

• 设定训练时图片的随机变换和标准化操作
• 通过 .flow(data, labels)或flow_from_directory(directory)来实例化批量增强图片的生成器。这些生成器随即可以作为fit_generator，``evaluate_generator 和predict_generator`等Keras 模型方法的输入。

示例如下：

from keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
        rotation_range=40,
        width_shift_range=0.2,
        height_shift_range=0.2,
        rescale=1./255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True,
        fill_mode='nearest')

这里只是一部分可配置项（更多的请参考文档 。我们看一下上述可配置项的含义：

• rotation_range 是0~180的度数值，表示图片旋转的范围
• width_shift 和height_shift 是宽度、长度的百分比，代表图片平移的范围
• rescale 表示在其它处理之前对图片的乘数。我们的原始图片是由0255之间的RGB值构成的，这种值模型处理起来太大了（在典型的学习率下），所以需要通过缩放因子1/255把值缩放到01之间
• shear_range 表示随机应用错切
• zoom_range 表示图片内的随机缩放
• horizontal_flip 表示随机地水平翻转图片——当没有水平不对称的假设时(例如，真实世界的图片)。
• fill_mode 表示在旋转或水平/垂直平移后，对新像素的填充策略

现在我们使用这个工具在临时文件夹中生成一些图片，直观感受一下这些增强策略的效果，为了图片可显示，这里不使用数值缩放因子。

from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img

datagen = ImageDataGenerator(
        rotation_range=40,
        width_shift_range=0.2,
        height_shift_range=0.2,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True,
        fill_mode='nearest')

img = load_img('data/train/cats/cat.0.jpg')  #这是一个 PIL 图片
x = img_to_array(img)  # 这是一个 Numpy 数组，形状是 (3, 150, 150)
x = x.reshape((1,) + x.shape)  # 这是一个 Numpy 数组，形状是 (1, 3, 150, 150)

# 下面的 .flow() 命令生成一批随机变换的图片
# 然后保存到 `preview/` 目录
i = 0
for batch in datagen.flow(x, batch_size=1,
                          save_to_dir='preview', save_prefix='cat', save_format='jpeg'):
    i += 1
    if i > 20:
        break  # 否则生成器会一直循环下去

下面就是数据增强策略得到的图片。

从头训练一个小卷积网络：40行代码达到80%准确率

卷积网络是解决图片分类问题的合适工具，我们先尝试训练一个作为基准线。由于样本很少，所以首先关注的问题是过拟合。过拟合发生于模型见过的样本太少，而不能泛化到新的数据，也就是说，模型开始使用一些不相关的特征来做预测。比如一个人只见过3张伐木工人的图片，和3张水手的图片，这些图片中只有一个伐木工人是戴帽子的，你可能会想戴帽子是伐木工人的特征而不是水手的，这样就会是一个糟糕的伐木工人/水手分类器。

数据增强是克服过拟合的方法之一，但是仅仅数据增强还不够，因为增强的样本之间是高度相关的。克服过拟合的关键是模型的熵容量——模型可以存储多少信息。模型能存储的信息越多，就有更大的潜力做到精确，它能利用更多的特征，但是有存储不相关特征的风险。而模型只能存储很少的信息时，则能聚焦到数据中找到的显著特征，这些特征更可能是真正问题相关的，能更好的泛化。

在这个例子中，我们使用一个只有少数几层、少数几个过滤器的小卷积网络，同时使用数据增强和dropout。Dropout 也能减轻过拟合，它可以防止一个层两次看到同样的模式，因此扮演了类似数据增强的角色（可以理解为数据增强和dropout都能破环数据中的随机相关性）。

下面的代码是我们的第一个模型，简单的3层卷积网络，卷积使用ReLU激活器，每层卷积紧接一个最大池化层。这和LeCun 在1990年代发表的图像分类模型结构很相似，除了当时没有使用ReLU激活器。

本实验的完整代码可以在这里 找到。

from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense

model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(3, 150, 150)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

#目前为止模型的输出维度 (height, width, features)

在此之上，使用两个全连接层。最后一层是单个单元，使用sigmoid 激活器，它非常适合二分类问题，相应的使用binary_crossentropy 来训练模型。

model.add(Flatten())  # 3维数据特征转化为1维
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

现在开始准备数据，使用.flow_from_directory()根据jpgs图片和相应的目录，生成批量的图片数据和相应的标签。

batch_size = 16

# 用于训练的图片增强配置
train_datagen = ImageDataGenerator(
        rescale=1./255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True)

# 用于测试的图片增强配置:只设定rescale
test_datagen = ImageDataGenerator(rescale=1./255)

# 生成器从'data/train' 文件夹中读取数据, 可以无限生成增强的图片数据
train_generator = train_datagen.flow_from_directory(
        'data/train',  # 目标文件夹
        target_size=(150, 150),  # 所有图片尺寸重设为 150x150
        batch_size=batch_size,
        class_mode='binary')  # binary_crossentropy 损失函数需要二值标签

# 一个类似的生成器，用于验证集数据
validation_generator = test_datagen.flow_from_directory(
        'data/validation',
        target_size=(150, 150),
        batch_size=batch_size,
        class_mode='binary')

现在可以使用生成器来训练模型了。每个轮次训练在GPU上需要2030s，在CPU上需要300400s。所以如果不是很着急，在CPU上运行是可行的。

model.fit_generator(
        train_generator,
        steps_per_epoch=2000 // batch_size,
        epochs=50,
        validation_data=validation_generator,
        validation_steps=800 // batch_size)
model.save_weights('first_try.h5')  # 记得在训练后和训练中适时保存模型

这种方法在50轮次训练后，验证集准确率约为0.79~0.81（50次是随意设定的——因为模型很小，又用了比较强的dropout，不太容易会过拟合）。如果在Kaggle 刚发布这个竞赛的时候，我们的结果已经是最好的——而且只用了8%的数据，也没有优化网络结构和超参数。实际上在Kaggle 的竞赛中这个模型能排进前100（一共215个竞赛者）。所以估计至少有115个竞赛者没有用深度学习。

使用预训练网络的bottleneck 特征：一分钟内达到90%准确率

更优雅的方法是利用在大数据集上的预训练网络。这些网络已经学到了在很多计算机图像问题上都有用的特征，相比那些只依赖问题本身可获得的数据的模型，利用这些特征可以达到更高的准确率。

我们使用VGG16 模型，它是在ImageNet 数据集上预训练的——本博客之前讨论过。由于ImageNet 的1000个分类中包括几个“猫”分类（波斯猫、暹罗猫等）和很多“狗”分类，这个模型已经学到很多和我们的分类问题相关的特征。实际上，仅仅需要记录数据经过模型后的softmax 预测值就可以很好的解决猫狗分类问题，都不需要使用bottleneck 特征。不过为了让方法能有更广泛的适应性，包括那些在ImageNet 中没有出现的分类，我们还是使用bottleneck 特征。

下面是VGG16 的结构：

我们的策略如下：只使用这个模型的卷积部分，即全连接之前的所有层。然后在我们的数据上运行这个模型，使用两个numpy 数组记录所有的输出（即VGG16的bottleneck 特征：全连接层之前的最后一个激活层）。然后在这些记录的基础上，训练一个小的全连接网络。

我们之所以离线记录这些特征，而不是直接在冻结的卷积层之上增加全连接层训练，是因为这样计算更高效。运行VGG16 模型很费时，尤其是使用CPU时，而且我们只希望计算一次。不过注意这样就不能用数据增强了。

可以在这里 找到完整的代码，从Github 获取预训练权重。这里不再讨论模型怎样构造和加载——在很多Keras 的示例中已经讨论过了。不过需要看看如何使用图片生成器记录bottleneck 特征:

batch_size = 16

generator = datagen.flow_from_directory(
        'data/train',
        target_size=(150, 150),
        batch_size=batch_size,
        class_mode=None,  # 这个生成器不产生标签
        shuffle=False)  # 保持数据顺序，先是1000只猫，然后是1000条狗
# 给定一个生成器yields批量的numpy数据，predict_generator会返回模型的输出
bottleneck_features_train = model.predict_generator(generator, 2000)
# 保存这些输出到 numpy数组
np.save(open('bottleneck_features_train.npy', 'w'), bottleneck_features_train)

generator = datagen.flow_from_directory(
        'data/validation',
        target_size=(150, 150),
        batch_size=batch_size,
        class_mode=None,
        shuffle=False)
bottleneck_features_validation = model.predict_generator(generator, 800)
np.save(open('bottleneck_features_validation.npy', 'w'), bottleneck_features_validation)

然后使用保存的数据训练一个小的全连接网络：

train_data = np.load(open('bottleneck_features_train.npy'))
# 由于特征是按猫狗的顺序产生的，所有构造标签很简单
train_labels = np.array([0] * 1000 + [1] * 1000)

validation_data = np.load(open('bottleneck_features_validation.npy'))
validation_labels = np.array([0] * 400 + [1] * 400)

model = Sequential()
model.add(Flatten(input_shape=train_data.shape[1:]))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(train_data, train_labels,
          epochs=50,
          batch_size=batch_size,
          validation_data=(validation_data, validation_labels))
model.save_weights('bottleneck_fc_model.h5')

由于网络很小，所以在CPU上训练也很快（每秒1个轮次）：

Train on 2000 samples, validate on 800 samples
Epoch 1/50
2000/2000 [==============================] - 1s - loss: 0.8932 - acc: 0.7345 - val_loss: 0.2664 - val_acc: 0.8862
Epoch 2/50
2000/2000 [==============================] - 1s - loss: 0.3556 - acc: 0.8460 - val_loss: 0.4704 - val_acc: 0.7725
...
Epoch 47/50
2000/2000 [==============================] - 1s - loss: 0.0063 - acc: 0.9990 - val_loss: 0.8230 - val_acc: 0.9125
Epoch 48/50
2000/2000 [==============================] - 1s - loss: 0.0144 - acc: 0.9960 - val_loss: 0.8204 - val_acc: 0.9075
Epoch 49/50
2000/2000 [==============================] - 1s - loss: 0.0102 - acc: 0.9960 - val_loss: 0.8334 - val_acc: 0.9038
Epoch 50/50
2000/2000 [==============================] - 1s - loss: 0.0040 - acc: 0.9985 - val_loss: 0.8556 - val_acc: 0.9075

准确率达到0.90~0.91，相当不错了。这是因为基础模型已经在标记过猫狗的样本数据上训练过了。

微调预训练网络的最后几层

为了继续改进前面的结果，我们可以微调VGG16模型最后的卷积模块以及分类器。微调意味着从训练过的网络开始，在新的数据集上使用很小的权重更新来重新训练，本例可以分为3步：

• 初始化VGG16 网络的卷积部分加载权重
• 在此基础上增加我们前面训练的全连接网络并加载权重
• 冻结最后的卷积模块之前的层

注意：

• 为了微调模型，所有层都要从训练过的权重开始：比如你不能在预训练的卷积层上增加一个使用随机值初始化的全连接层。因为随机初始化的权重带来的大的更新会伤害卷积层的权重。所以在本例中我们先训练了一个全连接层的分类器，然后才将它和卷积层放在一起工作。
• 为了防止过拟合我们只微调最后的卷积层而不是整个网络，因为整个网络有非常大的熵容量因此很容易过拟合。底层的卷积网络学到的特征是更基础的特征，没有高层特征那么抽象，所以固定最开始几层的特征（更加基础的特征）只训练最后一层是合理的。
• 微调应该用很小的学习率，而且一般用SGD 优化器而不是那些自适应的优化器比如RMSProp。这是为了保持很小量级的权重更新，不伤害网络已经学到的特征。

可以在这里 获得完整的试验代码。

初始化VGG16 网络加载权重后，增加我们前面训练的全连接层：

# 在卷积层上增加分类器
top_model = Sequential()
top_model.add(Flatten(input_shape=model.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(1, activation='sigmoid'))

# 注意为了微调训练，全连接分类器也应该训练过
# classifier, including the top classifier,
# in order to successfully do fine-tuning
top_model.load_weights(top_model_weights_path)

# 添加到卷积层之上
model.add(top_model)

最后开始使用很小的学习率，微调模型：

batch_size = 16

# 准备数据增强
train_datagen = ImageDataGenerator(
        rescale=1./255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True)

test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
        train_data_dir,
        target_size=(img_height, img_width),
        batch_size=batch_size,
        class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
        validation_data_dir,
        target_size=(img_height, img_width),
        batch_size=batch_size,
        class_mode='binary')

# 微调模型
model.fit_generator(
        train_generator,
        steps_per_epoch=nb_train_samples // batch_size,
        epochs=epochs,
        validation_data=validation_generator,
        validation_steps=nb_validation_samples // batch_size)

50轮次训练后，本方法可以到达0.94的准确率。很大的进步！

用下面的方法可以尝试争取准确率达到0.95：

• 更激进的数据增强
• 更激进的dropout
• 使用L1 和L2 正则化（又称“权重衰减”）
• 多微调一层（同时用更大的正则化）

本文到此结束！回顾一下，各部分试验的代码如下：

• 从头训练的卷积网络
• Bottleneck 特征
• 微调

如果关于这篇文章讨论的话题你有任何评论或建议可以到Twitter 。

当前版本：Manjaro KDE 20.0.1

0x00 准备工作

• 系统镜像下载地址
• 使用rufus软件将系统镜像刻录到U盘，建议选择DD写入模式
• 关闭小米笔记本Pro BIOS的安全启动 可参考

0x01 安装

使用U盘启动系统后，使用Live镜像的安装指引程序安装系统。

启动时选择第二项boot（non-free),Manjaro自带的驱动精灵会帮你安装好所需驱动，笔记本双显卡则会帮你安装bumblebee。

注意为了和Windows10和平共处，需要使用自定义分区方案：

• win10系统的硬盘内有个efi的分区（格式为FAT32，一般大小为100M），需要指定为/boot/efi分区，注意选择保留不要格式化
• 新划出的128G系统挂载 / 分区，如果需要休眠到硬盘，最好建立swap分区，一般大小和内存大小一致即可。

0x02 安装后基本配置

1 笔记本双显卡设置

查看显卡NVIDIA状态

lspci| grep -i vga

测试 Bumblebee 是否工作：

optirun glxgears -info

如果需要不依赖Bumblebee来使用CUDA, 为开启NVIDIA显卡，运行:

sudo tee /proc/acpi/bbswitch <<< ON

2.时间和日期

如果安装的是双系统，注意Manjaro Setting Manager > Time and Date勾选以下选项 –set time and date automatically –hardware clock in local time zone

3 源镜像与系统更新

• 排列源

sudo  pacman-mirrors -i -c China -m rank  

#增加archlinuxcn库和antergos库

echo -e "\n[archlinuxcn]\nSigLevel = TrustAll\nServer = https://mirrors.tuna.tsinghua.edu.cn/archlinuxcn/\$arch\n\n[antergos]\nSigLevel = TrustAll\nServer = https://mirrors.tuna.tsinghua.edu.cn/antergos/\$repo/\$arch\n"|sudo tee -a /etc/pacman.conf

• 升级系统：

sudo pacman -Syyu

• 安装archlinuxcn签名钥匙&antergos签名钥匙

sudo pacman -S --noconfirm archlinuxcn-keyring antergos-keyring

• 软件管理界面开启AUR支持。
• 安装增强的命令行软件管理工具yay

sudo pacman -S yay

4 安装中文字体和输入法

• 安装中文字体

sudo pacman -S --noconfirm wqy-microhei wqy-microhei-lite wqy-bitmapfont wqy-zenhei adobe-source-han-sans-cn-fonts adobe-source-han-serif-cn-fonts noto-fonts-cjk && fc-cache -fv

• 安装谷歌输入法

sudo pacman -S --noconfirm fcitx-im fcitx-configtool fcitx-googlepinyin 

• 配置fcitx， 配置完需要重启

sudo echo -e "export GTK_IM_MODULE=fcitx\nexport QT_IM_MODULE=fcitx\nexport XMODIFIERS=@im=fcitx">>~/.xprofile

5 Windows硬盘挂载

/etc/fatab 新增

/dev/nvme0n1p3 /mnt/c ntfs defaults 0 2
/dev/sda1 /mnt/d ntfs defaults 0 2

6 VPN 和 SSH

• 导入OpenVPN配置

sudo nmcli connection import type openvpn file xxx.ovpn

• 恢复备份的ssh配置

cp -r path/to/bak/.ssh ~/.ssh
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_rsa 

0x03 软件备忘

使用pacman或yay安装

• chrome

• intellij-idea-ultimate-edition

• deepin-wine, deepin-wxwork

• easystroke

• nextcloud

• git-cola

• postman-bin

• xmind （removed “–add-modules=java.se.ee” in /usr/share/xmind/XMind/XMind.ini ）

• python-tensorflow-opt-cuda python-pytorch-cuda

• nvidia-docker

• ipython jupyter

• youdao-dict deepin-wine-thunderspeed

• netease-cloud-music

• tusk

• typora

• visual-studio-code-bin

• wps-office

• foxitreader

0x04 日常维护

如果因为windows更新等原因导致双系统grub菜单丢失，一般可通过在windows系统内运行以下命令修复(以管理员运行)

bcdedit /set '{bootmgr}' path \EFI\Manjaro\grubx64.efi

话说有一只青蛙，想要跳下n级台阶下水塘，它每次可以跳1个台阶或者2个台阶，那么请问它一共有多少种跳法下水塘(比如，n=30时)？

用数学的语言来看，我们需要求一个青蛙跳的函数f(n)，对这种自变量取值为非负整数的函数，我们可以从比较小的情况开始考虑，不难得到f(1)=1, f(2)=2，问题是以后的穷举越来越麻烦。

想象你就是那只青蛙，面对n级台阶，第一次你可以先跳1级，那么剩下n-1级，有f(n-1)种跳法，第一次也可以跳两级，那么剩下n-2级，有f(n-2)种跳法，所以这个问题的答案并不陌生，是神奇的斐波拉契数列：

$$ \begin{aligned} F_{0} &=0 \ F_{1} &=1 \ F_{n} &=F_{n-1}+F_{n-2} \quad(\mathrm{n} \geq 2) \end{aligned} $$

解决这类求函数值问题的第一步，是找到一个递推式。我们把递推式翻译成python代码：

def fib(n):
    if n==0:
        return 1
    if n==1:
        return 1
    return fib(n-1)+fib(n-2)

%%time
fib(30)

Wall time: 269 ms
832040

运行时间284ms，有够慢的，为什么慢？因为重复计算实在太多，以计算f(5)为例，调用关系如下：

f(5)==>f(4), f(3)
f(4)==>f(3), f(2), f(3)==>f(2), f(1)
f(3)==>f(2), f(1), f(2)==>f(1), f(0), f(2)==>f(1), f(0), f(1)
f(2)==>f(1), f(0), f(1), f(1), f(0), f(1), f(0), f(1)
f(1), f(0), f(1), f(1), f(0), f(1), f(0), f(1)

那么一个很自然的想法是我们把中间计算结果都缓存下来，幸运的是，python中自带了这个“电池”。

from functools import lru_cache
@lru_cache()
def fib(n):
    if n==0:
        return 1
    if n==1:
        return 1
    return fib(n-1)+fib(n-2)

%%time
fib(30)
Wall time: 0 ns
832040

快到没计量出时间来。python中lru_cache的基本原理是构建一个字典，字典的key为调用参数，value就是该参数的计算结果。大致等价于如下代码：

def fib(n):
    if n in fib.cache:
        return fib.cache[n]
    if n==0:
        ans = 1
    elif n==1:
        ans = 1
    elif:
        ans = fib(n-1)+fib(n-2)
    fib.cache[n] = ans
    return ans
fib.cache = {}

当然，针对这个问题，我们可以使用更加细致的缓存方法， 乃至去掉递归改用循环（相当于只保留两个缓存，大大减少了空间占用，但是如果我们要反复计算各个n值，那么或许前一个方法才更合适）：

def fib(n):
    a, b = 0, 1
    for i in range(n):
        a, b = b, a+b
    return a

本题等同于 leetcode 70 , 在leetcode上的python3解答如下：

from functools import lru_cache
class Solution:
    @lru_cache()
    def climbStairs(self, n: int) -> int:
        if n==0:
            return 1
        if n==1:
            return 1
        return self.climbStairs(n-1)+self.climbStairs(n-2)

执行用时52 ms，内存消耗13.2MB。

2. 简化实用版动态规划

我们从这只青蛙中取得比较通用的启示，解决类似的可构造递推函数的问题：

1. 寻找一个递推关系，建立递归函数，问题变成多个子问题的求解；
2. 为了防止反复计算同样的子问题，使用缓存，用空间换时间。

在一般的算法教材或面试题解中，会花不少时间来设计这个缓存结构，在实际的工程问题中，我们可能对多使用一些缓存空间没有那么敏感，因此只需要开发递归函数，再加上通用的缓存方案就基本解决问题了。只有在缓存空间成为问题时，我们才需要进一步去考虑适应问题的更小的缓存。

为了检验这套方案，我们再看几道题，直接在leetcode上再找几个来刷。

2.1 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

我们考虑数组中每一个位置结尾能得到的最大和的递推关系。 $$ \begin{aligned} f(0)&=nums(0) \ f(k)&=max(f(k-1), 0)+nums(k) \quad(k>0) \end{aligned} $$ 基于此不难得到最终结果为 $$ ans = max_{i=0}^n(f(i)) $$ 在leetcode中翻译成python3代码如下：

from functools import lru_cache
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        self.nums = nums
        return max(self.f(i) for i in range(len(nums)))
    
    @lru_cache()
    def f(self, k):
        if k == 0:
            return self.nums[0]
        else:
            return max(self.f(k-1), 0) + self.nums[k]

执行耗时76 ms，内存消耗13.7 MB。

2.2 最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

示例:

输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 7 解释: 因为路径 1→3→1→1→1 的总和最小。

将矩阵中每个位置作为右下角，求最小路径和，不难得到如下递推公式：

$$ \begin{align} f(0, 0) &= grid(0, 0) \\ f(x, 0) &= f(x-1, 0) + grid(x, 0) \quad(x>0) \\ f(0, y) &= f(0, y-1) + grid(0, y) \quad(y>0) \\ f(x, y) &= \min(f(x-1, y), f(x, y-1)) + grid(x, y) \quad(x>0, y>0) \end{align} $$

在leetcode中翻译成python3代码如下：

from functools import lru_cache
class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        self.grid = grid
        return self.f(len(grid)-1, len(grid[0])-1)
    @lru_cache()
    def f(self, x, y):
        if x == 0 and y == 0:
            return self.grid[0][0]
        elif y == 0:
            return self.f(x-1, 0) + self.grid[x][0]
        elif x == 0:
            return self.f(0, y-1) + self.grid[0][y]
        else:
            return min(self.f(x-1,y), self.f(x,y-1)) + self.grid[x][y]

执行耗时1052ms，内存消耗13.9M。

如何驱动起来？一种是政府驱动，通过税收与公共事业建设运作；另一种是利益驱动，私人的债权投资和股权投资。对个人而言，买理财产品、买股票的本质应该是什么？是我付出了劳动，挣到了相应的钱作为衡量，但是我不完全消费掉，而是让渡出部分回报，用于投资再生产，将来在适当的时候，我可以兑现我的回报。

以上是从社会生产的方面说。个人和家庭，一样有消费和投资的矛盾，拿到工资，钱是是用于享受，还是用于自我提升，还是为将来的人生目标攒钱，需要我们仔细衡量。

很多人和我讨论股票，我都建议他们不要炒股，闲钱买点余额宝一类的货币基金就好，基本上没有风险和波动。因为投资是一件很严肃的事情，需要纳入个人的生活方式，家庭的运作方式去考虑。可能你不懂比较深入的理财知识，如果能努力挣钱，合理消费，适当储蓄，至少也能有个安稳的日子；即使你是个月光族，只要不遇上大的灾祸，也能活得不错。最可怕的反而是，焦虑着想要发大财，去搞所谓的“投资”，最后血本无归倾家荡产。

太多的人，投资买基金买股票往往是对金钱焦虑的一种应激反应，老想着靠股市挣到一笔钱买辆车甚至买套房，这其实和去澳门赌一把没有本质区别。

我这里没有讨论任何知识层面的东西，而是想说，如果炒股的出发点是错的，那么它必然只会导向一个错误的结果。老话说：吃不穷，穿不穷，不会盘算一世穷。对绝大部分人而言，投资不能成为一种职业，不是一种挣钱的方式，而只能是构建家庭理财计划的一部分，用于资产保值。没有站在十年二十年的尺度去规划，而是想着赚快钱，还是不要买基金买股票为好。

投资，是一种生活方式；赌博是另一种。

在鸡汤与焦虑当道的自媒体时代，我有点喜欢的是丧文化，但更喜欢得知生活的种种无望与残酷后，依然像一个小朋友一样，不带太多压力，傻傻地认真努力。有三和大神的人生，也有过劳死的人生，我越来越倾向于认为人生本没有任何意义，或者只是作为基因的载体，意义只关乎选择。所以19年，继续不后悔不抱怨，仔细的选择，为所有的选择负责。

2018年的头衔变成了算法工程师，2019年大概率会继续这个头衔，人工智能的浪潮或许会变冷，整个IT行业喊叫冬天来了。冬天来了，继续当一个能解决问题的人，物质生活的要求简单一点，还是能心安的努力下去的吧，喧嚣与焦虑都与我无关。

2018年读了不到30本书，2019年希望读书能做到旧书新书三七开，多一点时间看看值得反复读的书。

2018年跑步记录有据可查的只有20次不到，更多的被散步取代了，身体的活力其实有点在危险边缘。

2018年投资收益-23%，满仓跨年，但是内心很平静。

所有的年度总结与计划过后拿出来比对，容易变成大型的打脸现场，因为我们总是高估自己的热血，低估人性的怠惰，瞧不起每天一点一滴的努力，想要一口气吃成胖子。只有认清人性，先接纳自己的普通，才能跳出目标定得太高与一点点努力都不做的恶性循环。

人总是低估长期的变化，而高估短期的变化，无论是投资、锻炼身体、孩子的教育，还是自我的提高。最好的努力是不悲不喜的习惯性努力。所以我秉承微习惯的理念，不再制定那些注定难以完成的大计划，只为自己定几个注定难以失败的计划：

1. 每天做一个俯卧撑或者仰卧起坐；
2. 每天看1页纸的上市公司年报或研报；
3. 做一个业余项目，不设完成时限，早期用户只有自己，具体到每天必作的工作是打开项目文件夹，随便做点什么，1行代码或者1行文案都行。

新年快乐。

好吧，这个题目只是标题党。其实，我想说的是，身为穷人，我们更应该去努力学习如何花钱，才能活得相对幸福一点，而真正的富人，自然是不需要看我这篇文章的。

在我老家湖南常德的农村，最近几年开始流行“送货下乡”，比如去年，某某品牌就“惠及农民兄弟”，在乡里推销净水器，疑似三无产品的净水器卖到一千多，至于效果如何，只能在推销时表演的浑水变清水节目上可以感受一下，很多老实巴交的老人平时一分钱舍不得多花，竟然就鬼使神差的装了净水器，这些产品既无品牌背书，更无售后服务，收到钱后谁还管你滤芯要不要换这种事，很多人用了没多久也就闲置了。

你要说这是彻底的诈骗，倒也谈不上，只是明明有无数的正规品牌可以买，为什么非要买一些三无产品呢？首先这自然是大品牌们发掘市场不利，其次，据我妈反映，这些装净水器的人，在村里也是相对比较穷的，身为穷人的可怕就在这里了，本来就没几个钱了，还要被各类骗子和疑似骗子的商家反复收割一番。

挣钱和花钱哪个更需要学习，鸡汤一点的话，我当然会说挣钱更值得学习，毕竟，只要我们钱够多，花钱的时候就不必畏畏缩缩，也不怕吃亏上当，所谓“财务自由”嘛。可是现实一点说，其实花钱更值得学习，因为我不得不很遗憾很颓废的指出，写本文和看本文的人，可能终其一生，也不过是挣扎过了温饱线，一辈子能挣到的钱不用计算器就能估算出来，要达到想怎么花就怎么花的状态，不过是痴心妄想罢了。

所以问题就变成了我们要把有限的钱花到什么地方，才能尽可能的活得相对幸福一些。最颓废的做法，自然是破罐子破摔，反正都是穷鬼，随随便便花，凑活过一辈子也就是了。不过我想的是，既然挣钱这回事太难，不如花钱的时候认真一点，就当我们在解一道限定条件的方程题，或者限定了韵脚去作一首五言绝句，用有限的金钱获得最大的幸福感，少被富人们收割几刀，也不失为失败者的另类成功。

不要误会，这不是“什么值得买“一类的公众号，我们不推荐具体的产品，只探讨一些理念性的问题。

关于花钱，我觉得需要弄清楚的只有一件事，就是我们付出了什么，又得到了什么，像一个炼金术士一样，我希望这两者基本是平衡的。

在消费中，我们付出的首先是显性成本，也就是钱，这似乎很好算，但是你看看”首付三千元，新车开回家“这种广告就容易犯迷糊，发现这笔帐也不是那么好算的。除了钱，我们还要付出时间成本，这是最容易忽略的，因为穷，会更加不珍视自己的时间，干一些花半天时间省五毛钱的事情。

在消费中，我们得到的是商品，每件商品的价格大致由三部分构成，产品的功能、品牌附加值、智商税。产品的功能自然是我们消费的首要目的，比如一件衣服的遮羞御寒、舒适美观的功用，为了减轻产品甄别的负担，品牌附加值往往是我们自愿付出的代价，比如有人认准了苹果手机，他在买手机时就不需要再费心的去比对参数和价格。而智商税，则是我们被有意无意的欺骗而付出的代价，比如小到买了一张彩票、一件防辐射的孕妇装，大到相信自己的孩子能统治世界，给大师打个几千万的培训费这种。

所以，我们穷人的目标很明确：权衡金钱和时间的花费，购买自己真正需要的产品功能，尽量少为品牌溢价付费，坚决不交智商税。

那么要如何才能做到呢？可惜这毕竟不是解方程，没有什么万能公式、标准答案，没有必要也没有可能做到完美。但是，这是一个值得不断学习，不但反思而去接近的目标。在移动支付无比发达的当下，不妨每个月打开自己的支付宝和微信支付账单，去反思一番，自己究竟买到的是什么？

另外很重要的就是，要想不去为防辐射孕妇装这种东西支付智商税，那么对于科学知识，就像一个长者说过的，我们还是要学习一个。

一个现代人拥有的财富，越来越呈现出虚拟的形态，它往往只是一个数字，这个数字可能印刷在纸币上，可能存储在银行系统、股权登记系统中，甚至可能是区块链中的一串比特。这些数字本身不具备价值，而只是价值的代表。相信这些数字代表着财富，无论我们是相信银行系统背后的国家信用，还是比特币背后的密码学，都是人类想象力的伟大胜利。

人类的生物基因，并不会教会人如何看待、获取、利用财富，毕竟财富相关的概念产生在人类社会逐渐成熟时，最多不过几千年，相比漫长的进化史，它来得太迟，又变化得太快。不仅如此，人类基因中那些适应远古生活、来不及变化的部分，有时候反而是我们正确对待财富的障碍，即所谓人性的弱点。

只有借助文化基因的传承，我们才有可能学会正确的财富观。我只是一个刚解决了温饱问题的人，有什么资格大言不惭的谈论高大上的财富问题呢？可是一个突如其来的悲剧让我改变了想法。

前不久，我的一个堂兄因重度抑郁症不幸去世了，在震惊悲痛之余，我也在反思，在这个悲剧中，不太健康的消费观带来的经济压力可能是一个诱因。如何消费、如何理财，和每个人的生活息息相关，或许并不是那么高大上。我自责在这个悲剧酝酿的过程中什么都没做。

我想在正确的财富观的传播上，做一点微小的工作。主要内容是我对当代社会消费、理财、投资的一系列思考。有无数堪比日月的思想家，而我能做的，最多不过一个萤火虫，当一个观念的二道贩子，如果能给任何人带来思考上的一丝光明，那么这些写作也就存留了一丝意义。

给定一个数据集$D={(\mathbf x_1, y_1), (\mathbf x_2, y_2), …, (\mathbf x_m, y_m)}$ ，其中$y_i\in {-1, 1} $，$\mathbf x_i=(x_{i1}, x_{i2}, …x_{id})$为d维向量 。注意有些资料中二分类比较喜欢用${0, 1}$表示，使用什么数字表示二分类从原理上讲没有区别，但在数学表达上会有一些细微差异。

评分值不是一个机器学习算法中的一个正式名词，但是我们不妨建立这样一个认识角度。我们希望建立关于样本$\mathbf x$的一个评分函数$s(\mathbf x)$，它的基本性质很简单，就是要求和目标值$y$同号，即正样本评分为正数，负样本评分为负数，这样最终的二分类函数为$sign(s(\mathbf x))$。

那么我们要如何建立评分函数呢？直观的想法是，对样本的$d$个属性进行加权求和，这样能体现每个属性在评分中的重要性，如此建立的评分不一定在0值处有区分作用，因此再加上一个偏置项，所以评分函数为$s(\mathbf x)=w^T\mathbf x+b$，这个基本的评分函数可以衍生出很多算法。

评价二分类问题的基本标准是分类错误率，针对每一个样本，如果去计算它的损失函数，就是分类正确损失为0，分类错误损失为1，这种损失函数一般叫做0-1损失函数，可记为$l_{0-1}=\mathbb{I}[sign(s(\mathbf x))\neq y]$。

如果我们统一考虑正、负样本，令$z=s(\mathbf x)*y$ ，那么分类正确时，$z$必然始终为正值，不妨称其为绝对评分值,$z$是对分类是否正确的一个度量。则$l_{0-1}=\mathbb{I}[sign(z)= -1]$，故$l_{0-1}$是关于$z$的分段函数。从最优化理论的角度来看，这个函数无法求梯度或次梯度 ，因此需要找它的近似来优化。这个近似$\widetilde l$的基本标准是：始终为非负值；当它很小时，$l_{0-1}$很小。

评分值是属性$X$的线性组合，从另一个角度看，评分值也是关于权值$w$的线性组合。一般的，我们将$X$变换到新的特征空间得到$\phi (\mathbf x)$。则评分值为$z=(w^T\mathbf \phi (\mathbf x)+b)y$。上述分析基本不变，只是模型的复杂度更高了。以下分析如无特别说明仍在原空间进行。

1 线性回归

要求评分值与目标值同号，如果目标定得更加狭隘一些，可以令评分值直接为${-1, 1}$,这是线性回归问题，损失函数使用误差平方（可以做直观的理解，也可以认为样本的误差符合正态分布，从极大似然的角度推导出，这不是本文的重点。）。注意到$l_{sqr}=(s(\mathbf x)-y)^2=(s(\mathbf x) * y-y^2)^2=(z-1)^2$，故误差函数是关于绝对评分值$z$的二次函数。从图中可以看出$l_{sqr}$是始终大于$l_{0-1}$的，而且当$l_{sqr}$比较小时，$l_{0-1}$也比较小，所以可以作为$l_{0-1}$的近似。

线性回归有封闭解$w=(X^TX)^{-1}X^Ty$，所以使用线性回归做二分类非常简单，但是效果一般不太好，为什么呢？从$l_{sqr}$的曲线可以看出，当绝对评分值很大时，$l_{0-1}$应该为0，直观来说，绝对评分值很大应该是区分度高的一件好事情，但是$l_{sqr}$却给与了更高的惩罚，这是不合理的。线性回归可以给出一个还不错的$w$值，可以用作其他算法的初始值。

2 感知机学习

感知机学习可以用如下的直观想法来理解：针对绝对评分值，当它为正数时，分类正确，我们认为误差为0，当它为负数时，我们认为离0值越远，误差越大，即$l_p=max(0, -z)$，从$l_p$的曲线来看，也是$l_{0-1}$的一个近似，虽然它也是一个分段函数，但是是可以求次梯度的,$z\geqslant 0$时，认为梯度为0，当$z<0$时，$\frac{dl_p}{dw}=\frac {dl_p}{dz}\frac{dz}{dw}=-1*y\mathbf x=-y\mathbf x$，使用随机梯度下降法，$w\leftarrow w+\eta y\mathbf x$也就是说，只在出现评分错误时进行优化，这恰好就是感知机学习算法所做的工作。

3 支持向量机

对感知机学习的误差函数，我们可以进一步优化，我们希望绝对评分值要充分大，这样认为样本是正样本我们才更加放心，考虑到$z$是关于$w,b$可缩放的，不妨定义充分大为大于1。于是有$l_{hinge}=max(0, 1-z)$,这个损失函数被称为hinge损失函数。考虑结构风险，我们的优化目标为

$$ \underset{w,b}{min}=\frac{1}{2}\left |w \right |^2+C\sum_{i=1}^{m}max(0, 1-z) $$

通过松弛变量法，就可以变为软间隔支持向量机，通过二次规划来求出模型。

从评分值的角度来理解，评分值充分大使得模型针对新的样本有较好的鲁棒性，这正是支持向量机比较优秀的地方。如果引入特征空间，则在支持向量机的求解过程中要大量计算内积，将特征空间的内积简化为原空间的核函数可以引入核方法。

4 Logistic回归

在$z$值的基础上，我们希望它能算出一个概率，衡量分类正确的概率或者说程度。即将$z$的值域从$(-\infty , +\infty )$映射到$(0,1)$ ,那么sigmoid函数是个好的选择，它可求梯度而且在0处概率恰好为0.5。即

$$ sigmoid(z)=\frac {1}{1+exp(-z)} $$

然后，我们再根据这个sigmoid函数，再来模拟损失函数$l_{0-1}(z)$，我们要求损失函数关于$z$递减，而且始终为正数，考虑概率求对数后再取负号，故

$$ l_{log}(z)=-log(sigmoid(z))=log(1+exp(-z)) $$

由图可以看出，它也是$l_{0-1}(z)$的一种近似。以对数损失函数为优化目标。

$$ \underset{w,b}{min}=\sum_{i=1}^{m}log(1+exp(-z))+ \lambda\left |w \right |^2 $$

这是带正则化的Logistic回归，由于$l_{log}(z)$处处可微，因此可以使用梯度下降法等最优化方法求解。

5 AdaBoost

指数函数同样可以满足近似$l_{0-1}$的基本条件，即损失函数定义为$l_{exp}(z)=exp(-z)$。

指数损失函数结合加性模型，可以推导出AdaBoost算法。

所谓加性模型，可以这样来理解：假设我们得到的特征空间中的d维向量$\phi(\mathbf x)$对应的就是d个弱分类器，就是说比随机猜测50%的正确率高一点的分类器。所谓的Boost方法就是有效的组合这些弱分类器来构建强分类器。加性模型本质上依然是一个线性模型。依然有评分函数为$s(\mathbf x)=w^T\mathbf \phi (\mathbf x)$。（考虑到弱分类器本身可以有偏置，因此取$b=0$。）只不过这里的$\phi(\mathbf x)$代表一个弱分类器，而不是一个简单的属性变换（本质上看，也是一种属性变换）。

AdaBoost是一个逐步迭代的过程，假设经过$m-1$轮迭代已经得到评分函数$s_{m-1}(\mathbf x)=\sum_{i=1}^{m-1}w_i\phi_i(\mathbf x)$,在第$m$轮迭代后得到$w_m, \phi_m(\mathbf x), s_m(\mathbf X)$,则$s_m(\mathbf X)=s_{m-1}(\mathbf X)+w_m\phi_m(\mathbf x)$，AdaBoost的优化目标是使得每一步得到的评分函数关于指数损失函数最小，即

$$ w_m, \phi_m = arg\underset{w,\phi}{min}\sum_{i=1}^Nexp(-z_{mi}) \quad z_{mi}=y_is_m(\mathbf X_i) $$

该式的进一步推导此处不再详述。

小结

以上介绍了6种损失函数，他们都是关于评分值的单调非增函数，其中后面5种是关于0-1损失函数的近似替代，通过求解替代函数能否得到原问题的解，有深入的研究，称为替代损失的“一致性”问题³。

此外，如果我们要找出所有样本种的正例并排序，那么评分值应该在参与优化的时候就具备排序的特性，对数损失和指数损失是单调递减的，以它们为优化目标的模型计算出的评分值可以参与排序，其他几种损失函数不是单调递减的，因此相应的评分值不适合排序。

题图是中国当代艺术家宋冬推出的“物尽其用”装置艺术展的一角，宋冬的母亲一辈子舍不得扔东西，将所有物品囤积起来，包括这些牙膏皮。

1 匮乏与囤积

一个衣食无忧的人如果想要快速了解什么叫做匮乏，可以看看阿城的小说《棋王》，开篇主人公王一生在火车上吃饭，阿城用的成语是“惨无人道”。梁家辉在电影《棋王》中将这一幕淋漓尽致的再现了。

匮乏是人类历史中的常态，它甚至书写到了我们的基因中，比如我们对甜食和脂肪无节制地热爱，是因为原始人食物匮乏，饱餐一顿算一顿。松鼠等动物都知道通过囤积来应对匮乏，而人类在这一点上就更加优秀了。我见过疑似囤积症患者的房间，虽然叹为观止，但我想他们其实只是行为模式更倾向于复古，不适应当代生活而已，毕竟，囤积癖好可能也写在我们基因中，比如很多女性怀孕期间就会激发这种囤积物品筑巢的本性。

所以，囤积物品是符合深植于我们基因中的人性的，然而这种古老的人性是否符合当代生活的特点，是否可能妨碍我们的幸福，却是很值得思考的一件事情。

2 消费主义陷阱

消费主义是当今世界滚滚向前的重要动力之一，消费、创造、然后进步。以消费来定义自己和他人几乎成为一种定式，人人都被挟裹，焦虑着去挣钱，然后去买各式各样必要不必要的商品。而在互联网时代，这一切通过无处不在的广告和社交网络而变本加厉，广告告诉我们：如果想贴上某一种标签，我们应该拥有什么，比如成功人士应该买什么车，文艺青年应该喝什么咖啡，乃至技术宅应该用什么手机。通过社交网络，人们对外展示自己的个性。很多人甚至会觉得自己买得东西与众不同，高人一等，连手机品牌的粉丝之间也会发生口水仗。然而这些个性，并没有逃脱广告所定义的标签。

从物质丰富的消费主义时代再回到匮乏的时代是倒退，但彻底投入消费主义的怀抱，则有可能丧失自由意志，变成物欲的奴隶。环顾我们家中的物品，真正得到使用的可能不到一半，还有一多半的东西买来就不喜欢，甚至可能只是商家的赠品，我们想着总有一天会派上用场，然后堆积在家里，让自己被杂物包围，一不小心就变成垃圾堆一样。

物品本来是实现我们目标的工具，比如可能买车是为了周末带孩子出去玩方便，买衣服是为了美观，然而我们却试图通过购物去证明一些什么，或是去排解自己的空虚寂寞，追求的是下单和收快递时的那一点多巴胺。消费主义是我们的东西越来越多的罪魁祸首。

3 极简主义与安全感

东西太多怎么办？最先想到的自然是整理，在方鸿渐时代，报刊杂志的角落就有如何整理物品的“主妇小技巧”。日本人煞有其事的做事风格之下，称之为“整理术”。然而，整理过房间的人都知道，物品就像杂草一样会生长，整理物品并不能根治东西太多的顽疾。基于对消费主义的反思，很多人开始从更加根本的角度来考虑问题，产生了被称为极简主义的思潮。

中国古话说，生不带来死不带去云云，有很多安贫乐道的道理，但是极简主义生活理念跟这些其实有本质的区别。极简主义是适应当代无比丰富的物质生活的，甚至可以说，推行极简主义的安全感就来自丰富易获取的物质。科技进步也可能简化我们的生活，比如智能手机就替代了一堆的物品。

推行极简主义生活的第一步是扔东西，扔东西是一种伤害安全感的行为，万一要用的时候没有怎么办？其实在市场极度发达的今天，大城市不用说，即使是偏远一点的地方，只要通快递，也几乎没有买不到的东西，办法很简单，先扔了再说，万一要用再买（然而绝大多数情况是不需要再买了）。扔东西当然看起来也是个败家的行为，但只要你扔得下手，下次买买买的时候自然就会三思，是不是买了又会用不上被扔掉，这样折腾几次，你的不必要的消费冲动就断了。

日本甚至产生了很多“扔东西”的专家，比如山下英子，提出了“断舍离”的概念，强调首先就不要买入不必要的东西，近藤麻理惠的“令人砰然心动的整理魔法”，强调只保留那些能让你心动的物品。这些理念，都是适应物资丰富的时代的。通过摆正我们和物品的关系，只留下那些真正实用的，能让我们的生活更幸福的物品，从而给我们留下更多的生活空间。

4 “断舍离”的技术

道与术是相辅相成的，我觉得极简主义的思潮很有意义，因为它是伴随着一系列的“扔东西的技术”的，无需拔高它的哲理层面的意义，人们在极简主义的标志下提倡的一些方法就是很值得学习的（是的，怎么扔东西也是可以学习的）。这里我结合自己的思考列举一些：

• 同一样东西不会超过两件；
• 舍弃一年没用过的物品；
• 将难以舍弃的物品拍成照片，纸质文件可以扫描变成电子版；
• 丢掉收纳的东西，就像清除杂物的巢穴，死角不要放东西；
• 珍惜房子的空间，把超市等当自己的仓库，把咖啡厅当自己的客厅；
• 买一件新物，减一个旧物；
• 购物失败时，及时止损；
• 不参与商家的凑单优惠活动，那样只会浪费时间买回来一堆不需要的东西；
• 降低数量，提高质量，买贵的东西，尤其是那些用旧了还很好用的东西。
• 通过电子书，图书馆借阅等方法，减少家中藏书量，把书墙建到心里，将书融汇贯通在心里；
• 尽量不要用各种软件的收藏功能，要read it now，不用read it later，那样只会read it never；

5 本来无一物

是不是把东西扔了，房间变得空间大了，我们就会幸福？

显然不是。

我们对于物品的执念，不过也是思想的一部分。对物品喜新厌旧而带来的幸福感非常短暂，相比层出不穷的物质生活，什么更重要？这是值得毕生寻找答案的问题。人生道理往往没有什么新鲜的，无论是儒家思想，还是佛教乃至共产主义，都会强调相比物质生活，要更加重视精神生活。极简主义不过是像无数的哲思一样，再一次指出一个道理：人生的意义不是由物质生活来决定的，或者至少不仅仅是由物质生活来决定的，在消费主义主导一切的当今社会，很多人很多时候会忘了这一点。

而所谓的扔东西，只不过是给陷入物质生活枷锁的人的一次解放自己的机会。那些断舍离的技巧是极简主义的术，而极简主义的道则在于寻找有意义的生活，这就不是看几篇文章或者几本书能解决的问题了。

但是话又说回来，相比大段的鸡汤道理，我建议你立即大动干戈的扔一次自己的东西，你对物质生活的理解就能提高很多，当然前提是，你得在这个过程中审视与反思自己的生活。

深度学习能够学会加法吗？

撇开所谓的哲学意义不谈，已经证明了通过RNN可以模拟实现图灵机，这篇神奇的论文看这里 。我的大致理解是，图灵机也是一种模式匹配，而只要有足够多的学习样本，RNN总是可以学会这种模式匹配的。

假设我们要让神经网络学会3位数的加法，比如111+222=333，123+987=110，注意为了简单期间，我们不考虑最高位的进位。

加法可视为两个加数构造的序列来预测作为和的序列，因此可以用RNN来实现。示意图如下：输入序列、输出序列长度均为3，使用一层RNN存储进位信息。输入输出均使用one-hot编码后，输入特征数为20，输出特征数为10，中间层使用RNN，其隐藏节点数设为32。

使用keras搭了一下模型，图示如下：

代码如下：

注意为了画上述示意图，需要安装Graphviz

# -*- coding: utf-8 -*-

from keras.models import Sequential
from keras.utils import plot_model
from keras import layers
import numpy as np

import os
os.environ["PATH"] += os.pathsep + 'C:/Program Files (x86)/Graphviz2.38/bin/'

class CharacterTable(object):
    """
    one-hot encode/decode
    """
    def __init__(self, chars):
        self.chars = sorted(set(chars))
        self.char_indices = dict((c, i) for i, c in enumerate(self.chars))
        self.indices_char = dict((i, c) for i, c in enumerate(self.chars))

    def encode(self, C, num_rows):
        x = np.zeros((num_rows, len(self.chars)))
        for i, c in enumerate(C):
            x[i, self.char_indices[c]] = 1
        return x

    def decode(self, x, calc_argmax=True):
        if calc_argmax:
            x = x.argmax(axis=-1)
        return ''.join(self.indices_char[x] for x in x)

TRAINING_SIZE = 50000
DIGITS = 3

chars = '0123456789'
ctable = CharacterTable(chars)

questions = []
expected = []
seen = set()
print('Generating data...')
while len(questions) < TRAINING_SIZE:
    a = ''.join(np.random.choice(list('0123456789')) for i in range(DIGITS))
    b = ''.join(np.random.choice(list('0123456789')) for i in range(DIGITS))
    key = tuple(sorted((a, b)))
    if key in seen:
        continue
    seen.add(key)

    ans = str((int(a[::-1]) + int(b[::-1]))%1000).zfill(DIGITS)[::-1]
    
    questions.append((a,b))
    expected.append(ans)
print('Total addition questions:', len(questions))

print('Vectorization...')
x = np.zeros((len(questions), DIGITS, len(chars)*2), dtype=np.bool)
y = np.zeros((len(questions), DIGITS, len(chars)), dtype=np.bool)
for i, (a, b) in enumerate(questions):
    x[i] = np.column_stack((ctable.encode(a, DIGITS), ctable.encode(b, DIGITS)))
for i, ans in enumerate(expected):
    y[i] = ctable.encode(ans, DIGITS)
    
print('Split data...')
indices = np.arange(len(y))
np.random.shuffle(indices)
x = x[indices]
y = y[indices]

split_at = len(x) - len(x) // 10
(x_train, x_val) = x[:split_at], x[split_at:]
(y_train, y_val) = y[:split_at], y[split_at:]

print('Training Data:')
print(x_train.shape)
print(y_train.shape)

print('Validation Data:')
print(x_val.shape)
print(y_val.shape)

HIDDEN_SIZE = 32
BATCH_SIZE = 128

print('Build model...')
model = Sequential()

model.add(layers.SimpleRNN(HIDDEN_SIZE, input_shape=(DIGITS, len(chars)*2), return_sequences=True))
model.add(layers.TimeDistributed(layers.Dense(len(chars))))
model.add(layers.Activation('softmax'))
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

print('Plot model...')
model.summary()
plot_model(model, to_file='model.png')

print('Training...')
ITER = 20
for iteration in range(ITER):
    print()
    print('-' * 50)
    print('Iteration', iteration)
    model.fit(x_train, y_train,
              batch_size=BATCH_SIZE,
              epochs=1,
              validation_data=(x_val, y_val))
    print("10 validate examples:")
    for i in range(10):
        ind = np.random.randint(0, len(x_val))
        rowx, rowy = x_val[np.array([ind])], y_val[np.array([ind])]
        preds = model.predict_classes(rowx, verbose=0)
        question = ctable.decode(rowx[0][:,:10]) + '+' + ctable.decode(rowx[0][:,10:])
        correct = ctable.decode(rowy[0])
        guess = ctable.decode(preds[0], calc_argmax=False)
        print('Q', question[::-1], end=' ')
        print('A', correct[::-1], end=' ')
        print('√' if correct == guess else '×', end=' ')
        print(guess[::-1])

能在较短时间内训练到100%的准确率。毕竟，这个模式识别起来不太复杂。

至于如何让机器理解什么是加法，这就是另外一个问题了，毕竟我们也难以理解人类是如何学会理解加法的，甚至人类是否理解加法都不知道。

1. 由日更变为周更，每周1~2篇质量较高的，有一定创造性的文章；
2. 将过去的博客中原创性较低的读书笔记以gitbook的形式重新整理发布到learn子域名；
3. 整理过去的博客，修正错别字，有一些内容不完善的补充完善；
4. 对有价值的内容在主页上做好导航。

对大部分人来说，让他们学新东西是很要命的东西，但也有一部分人，很喜欢学习新的东西，把学习当成一件有乐趣的事情，终身学习，“活到老学到老”是他们的信条，所以我之前一直把“活到老学到老”这句话作为博客的口号。但是今天我认真思考了一下，察觉到这是不够的。

学习这一行为，基于学习者不同的主动程度，会体现出不同的创造性，随便看看公开课视频、朋友圈文章，看看罗辑思维，也可以算是学习，而在教程的指引下写出自己的一个小程序，也是一种学习。学习和创造的界限不是那么分明的，但是总归学习还是偏向于自我修炼，产生变化的主要是自己的脑子，而创造则需要将自己的想法作用于现实世界，所以创造不是空想。

在物质文明越来越发达的今天，精神文明产品创造的意义日益凸显，如果你有好的想法，做成了好的产品，借助于信息时代的传播工具，其复制成本会接近于零，今天游戏产业和电影产业都非常挣钱，其实它们都是精神层面的需求。所以在信息时代，分享是非常简单的，重要的是你的创造。

我没有谈到钱或者价值的问题，因为显而易见，如果创造物是有价值的，那么借助网络效应，很容易获得相应的价值回报。

仔细分辨的话，我的学习中似乎是有一些躲在舒适区的懒惰，但是这都不重要，重要的是更加注重创造，这是三者中最重要的一环。

1. 修改程序的几个维度：正确、效率、特性、优雅，需要在几个维度间平衡，更优雅的代码对软件改进没有直接作用，但可以为未来可能的修改打下更好的基础，而重构就是修改代码使其更优雅。
2. 程序员应当善用别人的代码，提现在两个层次，一个是编程语言的库，应当熟悉常用的并善于查文档，二是一些大的功能模块，比如网页服务器、Email通信组件等。
3. 学习一些高级的复杂的语言特性，应当去理解这个语言特性解决的痛点是什么，这是它出现在这个语言中的原因；
4. 好的代码要长还是短，取决于是否清晰的进行了沟通，即别人能否容易读懂你的代码，太长或太短都可能影响沟通；
5. 自顶向下设计还是自底向上设计，取决于对问题的清晰理解在哪个层次，如果对问题的大尺度理解很清晰，就适合自顶向下设计，不要害怕写一些代码桩。反之，如果大尺度都不清楚，则可以写一些已经分析清楚的小模块，然后进行组合试验。
6. 现在学习编程的条件很好，但是要注意多和他人沟通，多向他人学习。
7. 针对问题，可以先找到快速，dirty的解法，并估算算法的复杂度，看是否有必要进一步优化，优化应当建立在分析焦点操作的基础上。
8. 在必要的时候，要认真读文档。
9. 读代码要主动，最好在IDE环境下读，改一改看结果会怎样。要有整体读代码，获取架构的能力，也要有读片段，迅速找到所需的能力。
10. 智力游戏问题定义清晰，而又足够复杂，很适合进行编程训练。
11. 在三种情况下考虑递归：
    1. 数据结构本身时递归定义的，比如二叉树
    2. 有数学递推式
    3. 能够进行尾递归优化

1 硬件准备

首先，买点3M的无痕魔力扣，像这样的，用起来像魔术贴一样。

用这个挂iPad绰绰有余，而且不用在墙上打洞，具体方法请参看3M产品的说明书。

还要在适当的位置准备一个电源接口，怎么隐藏一下这就是个人发挥的艺术了，一般来说iPad充一次电还是能用蛮久的。所以可以不必一直插着电用。

2 软件准备

iPad删除所有能删除的程序，连上WiFi，到App Sotre装一个QQ，新版的QQ自然装不上，但是App Store会提示你安装历史版本，这样就行了。

在Windows或Mac系统上挑选自己喜欢的照片，统一存放到一个文件夹中。

iPad连上Windows或Mac系统，点开iPad管理界面，使用iTunes的照片同步功能，选择你挑好的文件夹将其同步到iPad。具体的操作可以参考这里 。

把iPad电源关掉，然后打开，看到锁屏界面，点一下滑动解锁旁边的电子相框按钮即可进入电子相框模式。此外，在iPad的设置中也有电子相框设置可以调节效果。

将iPad挂上墙

3 后续维护

如果有大量的照片需要更新，可以将iPad取下来（这也是3M无痕魔力扣的方便之处），重新进行照片同步，注意同步会把之前同步的照片先删除。

如果只是零星的照片想上墙，直接在其他设备如电脑、手机登陆QQ，iPad也登陆QQ，通过QQ传送文件到“我的平板电脑”即可。

1. github因为某事件屏蔽了百度的爬虫，博客在百度上搜不到，通过在个人主机或coding pages建立镜像，然后用dnspod分流的方法可以解决；
2. github pages支持强制https，支持自定义域名，但还不支持自定义域名的强制https。可以用cloudfare的cdn服务解决。

但是上述两个问题很难同时解决，虽然我有个人主机，但是懒得用来托管博客。今天发现netlify服务解决了两个问题。基本步骤如下：

1. netlify在注册后，可以申请权限接通你的github pages的repo；
2. 然后简单配置一下部署命令，对jekyll来说，命令为jekyll build，生成的文件目录配置为_site
3. netlify可以修改子域名为yoursite.netlify.com，然后也可以配置自定义域名，将dns的CNAME记录指向yoursite.netlify.com即可。
4. 开启https服务（可以用自己的证书，也可以用netlify自带的Let’s Encrypt证书），以及强制的https转换。
5. 以后，只要你向github提交更新，netlify就会通过钩子自动重新执行jekyll build命令部署站点。

测试了一下，国内访问会被cdn到日本节点，速度还算可以。

在大荧幕看这部电影，观影感受可以用一个字来形容：爽。

多重叙述是一种非常有意思的电影语言，角色通过语言回忆过去，不同的角色甚至同一个角色不同的时间对同一件事情都会有不同的叙述，而电影可以借助视觉语言多次的迷惑观众，观众则需要在多重叙述中寻找真相，在这个过程中，需要的是不断的体察人性，好的电影会让一切合乎情理。

多重叙述即使在现实生活中，也是一种常态，首先不同的人看事情的视角与重点都不一样，更重要的是，叙事的人可能会说谎，这种对现实的扭曲使得要知道真相很难，即使在历史研究中，也会有类似电影的反转出现。

谎言代表的人性是很微妙的一种东西，一般来说人们都会声称不喜欢说谎，但是又人人都会说谎，以至于《三体》中，说谎倒成了人类的少有的优势之一。

说了这么多，都没有说到电影的具体细节，因为剧透可耻。

1. 大部分无线路由器默认是路由器模式，但是一般可以配置成AP模式，中继器模式、桥接模式、Client模式等，具体的配置方法有些路由器可能有明显的指导，有些需要到网上搜索教程，但基本原理和模式的区别大致如下：
   1. 无线路由器通过LAN有线口接到能上网的路由器，那么就成了AP模式。
   2. 如果通过WIFI接到能上网的路由器，就成了中继模式（配置自己的SSID和上级路由器一致）或桥接模式（配置自己的SSID和上级路由器不一致）
   3. 如果WIFI接到能上网的路由器但是不再发射无线信号，而只在有线口接入设备，则成了Client模式（相当于一个网卡）。
2. 中继模式和桥接模式没什么用，因为正因为信号不好，才需要中继或桥接，那么中继或桥接的这一段始终是瓶颈，导致卧室上网很慢很卡。
3. 强烈推荐使用AP模式，在信号不好的地方（如卧室）放一个路由器，将它的IP改为和上级路由器同网段但是不同的IP，然后通过自己的LAN口接入上级路由器的LAN口，为了使用时无缝切换，将这个路由器的SSID和密码设置为和上级路由器一致。
4. 现在的问题是，找一根线连接两个路由器，如果事先没有布过线，就需要走明线，会很难受，这时候电猫就出场了，电猫可以理解为一根网线，但是中间一段是用电线接通的。高档的电猫可以一拖多（一个主机多个从机），甚至从机自己可以是一个AP。我比较穷而且闲置设备多，所以用了一对普通电猫和一个闲置路由器设置为AP模式搞定了。
5. 如果从头装修房子，还是一间房一个AP比较好，可能的话可以放到吊顶里面。

近两年国内出现了一些现象级的新媒体软件，主要卖点是不设编辑，没有记者，通过人工智能为每个人定制筛选感兴趣的新闻，其实我是相信算法的，如果调教得好，确实能给人追踪新闻带来很大的便利，然而我也观察过不少人使用这些软件的情况，大多并没有意愿去调教软件，而是软件推送什么就看什么，我不知道这些新闻软件在用户不做选择时推送新闻时如何选择的，从内容来看，大多数很无聊，甚至不少是带点颜色的擦边球。我的一个猜测是系统推送了最热门的新闻，毕竟大众其实就是那么低级趣味的，甚至我都不否认我也是低级趣味的，如果一个媒体软件放下身段，卖力的提升自己的点击率，那么必然会去利用人性的弱点，最后劈头盖脸的，无非是些看的时候有点爽，看完毫无价值的东西。

当前所谓的人工智能还是很低级的，但是它已经会朝着人设定的目标不断努力，一个新闻软件的满意度如何衡量？如果以用软件的人是否看了更多新闻来衡量，很容易会陷入人性弱点的陷阱，你不能说人工智能做错了，人工编辑也会这么干，只是人工智能做起来更极致，更没有底线。

我们假设每个用软件的人都有成熟的价值观，那么他可以自己去调教人工智能，使得人工智能知道要去推送什么样的新闻给用户。然而一个无法忽视的事实是，有很多人并没有成熟的价值观，而是会很容易被影响，这个问题自然不是人工智能带来的，但在人工智能时代会更加变本加厉，软件和人工智能的设计者，可能无法摆脱这样的社会责任：软件的用户可能是需要教化与引导的，技术没有道德可言，可是设计技术的人却无法逃脱。

如果还是想尽量用技术手段解决问题，那么问题就是，如何设计一个有社会责任感的新闻推荐系统，而不是任由用户的人性弱点去选择？

我实在不知道这位捡我卡的人有啥目的，或许他以为他能猜出我的密码来？对我来说，首先网银还能继续使用，很快就能把钱都卷走，也可以选择挂失，只是正式挂失还要去开户地，非常麻烦，再说，这种二代芯片卡还没听说能破解，我相信我的密码他也不可能猜出来，如果去ATM机试，密码输错三次卡就会被吞掉。

总的来说，我觉得拿走我的卡是一种损人不利己的行为。我觉得这个人是行家，试图去破解这张卡的几率微乎其微，更大可能是顺手牵羊，想着万一知道密码了呢？万一里面还有钱呢？为了一个极小极小的可能性，轻易的出卖了自己的良心。勿以善小而不为，勿以恶小而为之，当出卖良心甚至违法犯罪的代价极小时，不知道还有几人能做到。

很容易说出它们在语法上的区别：

1. 一个类可以实现多个接口，但是只能继承自一个抽象类；
2. 接口只有定义没有实现，抽象类中可以有具体实现（只要有一个抽象函数即为抽象类）。

那么语义上看，要怎么区分二者呢？接口主要是表示能力，这个能力是用几个方法来表示的（很多时候只要有一个方法就行），比如这个类可以做相等关系的比较，这个类可以被克隆等等。而抽象类往往表达的是更复杂的概念，抽象类代表了一类事物，它们有很多种类，这些种类间有很多的共性，形成了抽象类，就像没有具体的马，只有白马黑马，抽象类中往往有一些功能的实现，它们有点类似函数式语言中的high-order function，主要是调度其他的抽象的函数来完成功能，在设计模式的术语中，叫做模板方法，反过来看，抽象类大部分的应用场景其实都是模板方法。

其实像C++语言支持多继承，那么一个全是抽象函数的类的作用就跟接口是一样的，因此在C++语言中，就没有类似C#或Java中的接口的语法结构。一般来说，如果一门语言不支持多继承，又要表达类似接口的概念，才会出现接口的语法结构，反过来说，当一门语言支持多继承时，我们可以自己规定某些类必须全部是抽象函数（纯虚函数），从而实现接口的功能。

总的启示是，要根据问题的需要寻找语言特性来编程，而语言特性不一定在你使用的语言中不一定会有直接的语法结构支持，但是往往都能有变通的办法。

这可能是我看过最克制的战争片了，三个交织在一起的线索，甚至都称不上是故事，人物形象都还没树立起来，故事就已经结束了，不喜欢的人确实喜欢不起来。

然而坐在巨幕下，被影院的音响狂轰乱炸，似乎亲历了一遍战场，感情丰富一点的人都会自然产生非常多的情绪，这种观影体验是很奇特的。

人们为什么喜欢灾难片，因为会衬托出自己安全观影的幸福，《敦刻尔克》从这个角度来看无异于一部灾难片甚至恐怖片，德军作为敌人的形象是模糊的，仿佛是命运之轮把剧中人物驱赶到一个能望见祖国却又似乎遥不可及的海滩，承受着炮火和飞机的狂轰乱炸。

船只的渺小和大海的深邃，相较之下，我体会到的是一种惶恐，虽然可能不及真正上战场的人之万一，但这种惶恐也是真实的，当历史的打车轮碾过去的时候，每个人都是在赌命，我想现在网络上那些轻浮的扬言支持要发动战争的人不知道是否做好了赌命的准备。

细小的命运在大事件面前微不足道，但是细小的命运又构筑了历史，正如敦刻尔克的军队是靠很多小船撤走一样，在命运之轮面前惶恐过后，也只能是选择去做点什么，否则人生剩下的也只有面对死亡的惶恐了。

一个函数中有很多变量，有一些是函数中定义的（这包含在函数体中），有一些是作为参数传入的，因此一个普通的函数调用，需要知道函数体，也需要知道传入的参数，我们可以称这些参数是不自由的，已经由传入决定了。

如果一个函数中有些变量不是由传入参数决定的呢？那么这些参数是自由的，它们由定义函数的环境所决定。可以简单的认为，函数与定义函数的环境就称为一个闭包，在racket等语言中，实际上所有的函数在底层都会用闭包形式表达，这个闭包包含一个环境，环境提供变量与值的映射，还包括函数体代码，在一些实现中，可以把传入参数的映射也放大环境中，说到这里，发现闭包没什么神奇的，只不过是一个函数体，加上一个变量和值的映射表而已。

在函数式编程语言中，闭包往往很重要，闭包作为值，可以像整数、浮点数一样传递，这个传递的值，如果被另一个函数调用，就像你租了一个餐馆自己做菜，原料（函数调用方待处理的数据）由餐馆提供，但是你自己带了佐料（环境中的变量与值的映射），也带了处理原料的方法（函数体），这里的佐料和处理方法可以千变万化，调用的函数都不关心，因此有了极大的灵活性，比如经典的map函数需要一个处理函数作为参数，只规定了这个函数必须处理列表中的元素，至于怎么处理，是否带上其他复杂的参数，都由这个处理函数蕴含的闭包决定。

闭包还和匿名函数的概念联系起来，匿名函数都是在某个函数中定义并就地调用，匿名函数如果能使用相关环境中的变量，那么就是一个闭包。比如C#中的匿名函数，可以使用定义它的函数所在的对象的所有字段。实际上C#的匿名函数是用一个类实现的，这个类就包含了这个匿名函数（会生成一个名字），还有它所引用的调用方的字段作为私有字段。可以说，C#是用类实现了闭包。

闭包这个词，可以拆开来理解。

1. “闭”代表封闭，闭包对修改是封闭的，闭包中的函数一般来说无从修改，不像对象中的函数，一般是可以通过子类来重载修改的，这不便于扩展，但更稳定。
2. “包”正如前面描述的，代表是函数及定义该函数的环境的包裹。

我对方法的迷恋一直持续到成年，做事情的时候总会想有没有捷径可走，如果找不到捷径，我会感到难受。这几年我在研究治学的方法论，看过古今中外很多高人的经验，然而发现要建立自己的治学方法依然非常困难。

对方法尤其是捷径的迷恋，似乎是当代人的常态，所以所谓的知识付费时代来临后，卖得最火的课程貌似还是成功学，尽管包装得更加精美，然而事实是学习这些东西的人，往往并没有什么变化，倒是卖课的人赚得盆满钵满，比如李笑来的《通往财富自由之路》课程，我也凑热闹交了一把智商税，也学到一些东西，但是倒是和菜头客串的一篇文章印象也很深刻，大概是委婉的说出了这种人生经验很难在经历之前真正学懂。

我的体会是，方法论是从自己的实践中生长出来的一棵树，你可以四处获取养分，然而不能把别人的木头拿过来当成自己的一部分。如果要形成自己的体系，必然需要很多实践方法，如果这些方法有用凑效，最终能不能总结出一套理论来，其实是无所谓的。

那么什么样的方法是好方法呢？对我来说，能够真正坚持下来的方法才是好方法，如果要极大的毅力去坚持，最终往往免不了三分钟热度的悲剧命运。那么什么样的方法才是能坚持下来的方法呢？对我来说，答案很简单，那就是简单易行的方法，比如每天晚上写一下成功日记，用流水账简单几个字就行，忘写了第二天也还能补，这种简单的方法就能让你回顾总结一天的活动，提振自己的士气。又比如看完一篇文章，用一到两句话总结一下文章的观点，不用长篇大论，不费很多精力，但是却能慢慢的形成吸收知识纳为己有而不是泛泛而都，甚至我在写的时候，常常不自觉的就和作者讨论甚至争论起来，所谓的批判性思维，这也算是一个好的开端吧。

人们往往忽视了短时间内取得进步的困难，也低估了长时间取得进步的可能，用简单的方法开始治学，只需要很低程度的持之以恒，长期来看取得的收益是性价比超高的。

人是一种动物，或许是因为生命在于运动，体育电影总是让人能够热血沸腾，相比战争电影，它的“燃”没有什么负面意义，《摔跤吧！爸爸》也是一部典型的正能量电影。

有部分人批评电影中的父亲独裁地为女儿们挑选了摔跤这么一个职业，要反驳很容易，因为导演在片中安排了一个新娘规劝了不服气地两个女儿，如果不去摔跤，只能早早嫁人，没有资格选择职业也没有资格选择老公。片中的父亲没有太多其他的本事，培养有天分的女儿们成为摔跤手是最优选择了。世上少不了何不食肉糜的感叹，然而也不能只是这么简单的批判一番，仔细衡量的话，父母该怎么为子女铺路是一个极其复杂的话题，其实这部电影谈到了很多因素：

1. 父母的个人情结，无数的作品都描述过类似的故事，有悲剧有喜剧。片中的父亲想让子女圆自己的梦，这在很多情况下不见得是好的选择；
2. 子女的天分，片中的父亲是发现女儿们有摔跤的天分后才着手培养的，这一点和前一点结合，才能变成喜剧。然而，怎样才算有天分，实在也是一个复杂的问题。片中的父亲也正是有情结才能发现女儿的天分。如果他是一个程序员，说不定还发现女儿们有写代码的天分；
3. 家庭的眼界，片中的家庭应该算是比较穷，父亲似乎也不懂除了摔跤之外的太多东西，于是摔跤就成了他们能抓住的唯一稻草，如果家庭的眼界更开阔，自然可以有更多的选择，然而在没有选择的情况下，可能更有毅力，因为那是救命稻草。

给子女发现更多的道路是眼界，知道什么样的道路适合子女是智慧，能够坚持培养是韧性，而最终能不能成才还需要一点运气。最后，还有古话聊以自慰：儿孙自有儿孙福。

传销是一种心灵污染

为什么传销无法禁绝，因为人心的贪娈无法禁绝。一个传销头目就是一个污染源，传销作为一种诈骗模式，会迅速的在传销组织中传播，打击传销组织不可能对庞大组织中的人都用重刑，因此哪些处罚很轻或者免于处罚，但是心灵已经被污染的人，会成为新的污染源。因此我们很容易看到相似的传销手段，不断的死灰复燃，政府要想彻底打击基本上不可能，只有像除杂草一样，等长到足够高的时候，用打草机割掉一批。要想彻底除掉杂草，要斩草除根，改变土壤，即使这样，我们也很难看到彻底禁绝杂草的地方。传销也一样，不过总可以尽量减少它的危害，这需要社会人心的改变与国民智商的提高，如果浮躁拜金的社会风气没有改变，人们对投资理财的基本概念没有建立，那么传销的气焰也会始终嚣张。

金字塔模式是一种经典模式

传销的核心模式是金字塔模式。传销的金字塔模式的问题在于，金字塔的底层是不稳固的。如果能形成稳固的底层，金字塔模式就能一层层累积出塔尖来。金字塔模式本没有善恶之分，就看如何运用了。

虽然人们都喜欢平等的概念，但是金字塔模式一定程度上也是文明进步产生的助力，农耕文明的直接战斗力可能比不过游牧民族，但是最终高端一点的东西，无论是科技层面的还是文化层面的，基本上都来自农耕文明，最简单的一个解释就是，只有通过农名供养贵族的金字塔模式，才能造就一帮闲人研究一些温饱之余的问题。红楼梦里面林黛玉的诗写得好，但前提是她不需要下田干活，而是四体不勤五谷不分。

不过我想随着人工智能时代的来临，这个金字塔底可能会由机器人来承担。

跳出圈子的重要性

传销组织的一个特点是试图切断你和家人的联系，将你的社交关系逐渐局限到传销组织的人，然后再开启洗脑模式。无论多么荒谬可笑的东西，只要周围的人都是这么去做，人们就会觉得正常，这是人的社会属性本质决定的。因此，要想防止各式各样的洗脑，最重要的办法就是跳出圈子思考问题，不要把自己归到任何圈子，与各式各样的人建立联系，这里说的人，可能是生活中接触的人，互联网上交往的人，甚至可能是古人，也可以通过他们留下来的书之类的接近他们的思想。

1 信息源

1. inoreader RSS阅读工具
2. 微信订阅号
3. 微博、Twitter
4. 雪球
5. 知乎
6. 即刻
7. Courera
8. TED
9. Pocket 稍后阅读工具

2 信息采集

1. Evernote 备忘录的长期存储，其他内容的临时存储
2. Onenote 主要使用手写笔记功能
3. Pocket 长文章的临时存储

3 笔记整理与生成

1. Evernote 简单笔记的写作
2. Workflowy 结构化笔记的写作

4 写作与成果展示

1. Github pages + Jekyll
2. Typora

尽管这里讨论的编程语言主要指的是图灵完备的通用编程语言，然而每个语言设计的时候都会有自己的场景想象，于是语言设计者会选择一系列认为很有用的语言特性，静态类型还是动态类型？要不要垃圾回收？是否支持闭包？

有一些语言特性会作为语言的核心功能设计，然后在此基础上设计好用的语法糖，要理解一门语言的运作，必须对此有一定的区分，比如C#语言中，一个类中的核心概念是字段和方法，衍生的语法糖包括属性、事件、访问器等，不知道这些区分与运行机制也能写代码，但是可能会遭遇一些无法理解的问题。我知道C#有一本书《C# via CLR》对这些问题讲得比较透彻，其他语言相信也有类似的。

《代码大全》中说，程序员应当根据自己的需要选择语言特性，不要语言提供了的一股脑都去用，比如javascipt语言就有很多奇奇怪怪的特性，甚至还有一本书专门介绍它哪些特性好哪些特性最好不要用，这时候我们用的是语言的子集。还有一些情况，出于其他原因，我们必须使用某种语言，但是却缺乏我们需要的特性，这时候可以考虑自己实现，比如用C语言实现一个简单的对象系统，在Java 7中自己实现一个简单的的map reduce。

从这个角度来说，语言特性高于语言，要充分熟悉各种语言特性，可能要多学几门语言，它们各自有自己的侧重点，从而更容易理解，比如要学闭包，函数式语言就比C#更合适，虽然C#也算是有闭包。

《百鸟朝凤》这部电影虽然没卖座，但也曾站上风口浪尖，大师绝唱这个词，甚至在吴天明导演身上不幸印证了。然而，我还是不得不说，这不是一部很好的电影。

如果以《百鸟朝凤》命题作文，那么我不得不对这部电影的音乐性充满期待，然而，让人遗憾的是，唢呐的演奏甚至都不是电影的重点，唯一有意思的一段是焦三爷喝醉后的唢呐，然而正当我要入戏时，唢呐演奏变成了混响，作为一部和音乐有关的电影，整部电影的配乐可以说比较失败。

看了一半才知道音乐不是电影的重点，重点似乎是要表现民间艺术的失落，然而电影并没有很认真的去介绍唢呐，似乎百鸟朝凤也只是为了导演心目中想要表现的某些命题的应景，这样即使要表达主题，观众看起来的遗憾度也不会太高。

创作者对民间艺术的失落的理解并没有什么新鲜的，只是像一个老人一样感慨过去的好日子，而当下的乐手，在电影中不是断了手指就是得了尘肺病，唯一对生活充满热情的人似乎是哪个师父瞧不上的蓝玉，然而他基本上放弃了唢呐。

好的东西会有人欣赏，然而苦情并不是好的出路。

我希望看到的是用热情浇灌的展现出唢呐演奏的美感的电影，可惜了。

programming-languages这门课用到了ML、Racket、Ruby等三种语言，从语言的选择就可见不走寻常路了，我初步了解了一下，应该是一门偏向函数式编程的介绍编程语言范式的课程。用这个老师Dan Grossman的话说，这是像练武术的人搞一些挑水扫地蹲马步的活动。恰好函数式编程我也不是太熟，不妨一刷。第一次作业一次性拿了满分，看来我还是有写函数式编程代码的天赋么？

类似的试图一次性学习所有编程语言的还有之前见过的一本书《代码之髓》，日本人写的，大概翻过一下，把编程语言中一些主要的概念拿出来对比着讲。愤怒的大牛王垠也写过一篇如何掌握所有的程序语言 ，值得一读。

Dan Grossman也总结了语言学习中的五个要素：

1. 语法，代码怎么写的，这部分肯定是要学会的，但也没什么难度，没什么意思；
2. 语义，这些语法代表什么含义，代码是怎么运行的，理解到这部分，代码才能在脑子里跑起来；
3. 惯用法，如何使用语言特性表达计算，很多语言都有cook book，比如C#，你不用Linq而老是用for循环，那是很暴殄天物的；
4. 库，一般来说，只是学“语言”跟库关系不大，但是要做实际项目，库可能就很重要了；
5. 工具，每种语言可能都有一系列的衍生工具，帮助你更好的完成工程。

这其中第1项是基础，2、3两项，是理解一门语言的关键与难点，而4、5两项，则是衍生品。

我的目标也是掌握所有的程序语言，如果借这次机会学透了函数式语言，我觉得问题不大，因为所有的语言几乎都是C和Lisp之间的光谱分布。核心语法一般1~2天能学会，而语义、惯用法或者说语言特性无非就是一些核心概念里面打转，而库和工具可以在使用中熟悉。

一个人注册的网站越多，那么某个网站泄露他的个人资料的可能性就越大，那些大大小小的网站真的有能力有操守保护我们的隐私吗？匿名化其实是给了注册的人一定的自我保护能力，而在实名制前面，这种保护能力将化为乌有，原本就很严重的个人资料泄露有了实名制后将会如虎添翼，可能不久的将来，更多的人会接到诈骗电话，轻松的报出你的家人的身份证号码和住址，每个人防骗的神经必须绷得更紧才行，你要时刻记住，在这个时代，你和你家人的资料对于骗子来说，基本上已经等同于完全透明了，想明白这一点，或许在接到诈骗电话的时候，反应能机敏一点。

从理论上来说，实名制也对打击各种诈骗、拿钱发帖的水军等有很大的益处。但事实是道高一尺魔高一丈，电话号码的实名制丝毫没有降低诈骗的嚣张程度，估计网络账号的全面实名制也不会有什么区别。实名制的约束只会约束到普通良民，而坏人们总是会想到各种钻空子的办法。

我感觉近几年来黑色产业有一次明显的产业升级，诈骗这种有一定技术含量，风险低收益高的犯罪方式，已经在全面替代盗窃和抢劫。而诈骗的受害者，甚至都得不到大众的同情而是会被嘲笑，因为似乎被骗等同于傻或者自己太贪婪，包括我在内的很多人可能自负的觉得自己一定不会被骗，然而当个人资料越来越多的被泄露后，说实话我的信心也没有那么足了，只能提醒自己提高警惕。

比如说，商场的导购员和餐馆的服务员，往往素质都不会太高，如果遇到了素质高的，是一件值得庆幸的事情，原因很简单，素质高的人不回去做这些工作，即使做了这些工作，也是临时性的，或者很快升迁了。一个人素质很高，又做了大半辈子的服务生，那简直不可想象。又比如说驾校的教练，其实文化素质很高的就不多，原因跟上面一样。所以大部分人学车的体验很难好得起来，且不论教练是否和颜悦色，见钱眼开，就说很多教练其实都讲不清楚基本原理，只能是教学员一些死板的方法搞好应试教育。又比如说月嫂，你说素质很好高的怎么可能去给人当月嫂呢？稀有。所以很多人花了高价请高级月嫂，也不见得有多高级。

当然我们很容易看到，这些服务行业的消费升级，可能是一个想象力无限的市场，首先是经济水平上升后的必然要求，其次也将是人工智能时代的特点，如今看起来有些技术含量的工作，比如开车，以后可能都会被人工智能取代，而一些需要人的亲和力的职业比如销售却可能依然存在。

不过我想到更多的是，一个社会公平的意义，如果不注重社会的整体进步，富人们赚再多的钱也可能享受不了太好的生活，因为谁都避免不了跟服务行业的人打交道，如果始终认为这个阶层的人不值得拿高工资，那么永远也享受不了好的服务。更恐怖的是，如果贫富差距过大，各种悲惨的结局都写在历史书上了。所以说，为富不仁，即使从功利的角度来看，也是不对的。

1. 量化投资并不神秘，简单的指数基金定投其实也可以归到量化投资的范畴；
2. 宽泛一点理解，凡是可以定量计算的，都可以用于量化投资，可以做所谓的动量投资（基本上就是自动化的追涨杀跌或者高抛低吸），也可以做基本面分析，所以量化投资不一定是高频交易，也可能时低频交易，一个量化策略可以吸收各种要素；
3. 散户搞量化交易，相比机构能获得的资源比较有限，自然是有很多劣势，但是也有自己的优势，其中最大的一个优势就是资金量上基本上不会对价格造成冲击，所以交易成本很低。
4. 量化是利用数据分析与程式化的交易（中低频交易不需要自动化程序）来反人性，用数据说话，而不要过于相信感觉或直觉；
5. 量化交易要看全局看全时，总的目的是自己的投资组合赚钱，而不纠结于个别的品种，应当做较长时间的历史分析，而不能只看最近的效果；
6. 量化交易一般需要建立模型，在历史数据上回测再调整，然而历史是螺旋发展的，回测可能会有过拟合的现象，也就是说，会出现一些特别的参数效果特别好，但是用来做策略未来不一定会好。我觉得最好还是要有对模型为什么效果会好的解释，并考察这种解释在未来是否会失效，比如最小市值策略，解释是A股特有的壳价值带来的，但如果新股发行持续改革，这个策略就会失效。
7. 散户资金量小，可能无法建立足够的股票池构建组合，这时候可以考虑基金，类似华泰证券的券商基金交易费率极低，且没有最小消费的限制，非常适合量化交易。此外，如果场外购买基金，交易费率也是要仔细比较的。
8. 学好Python，对量化交易好处多多。看来我去年开始用Python是个明智的决定。
9. 在A股量化策略容易有效的原因是韭菜多，不过这种好日子估计最多5~10年，挣超额收益会越来越难。
10. 演讲中提到的相关的资源：
    1. tushare ：一个开源的金融数据库，可以用Python非常方便的使用；
    2. 优矿 ：一个量化策略平台，提供了丰富的API，支持Python语言。
    3. SSRN ：获取免费的金融方面的英文论文。

【2017-08-10初稿 / 2020-05-01小幅更新】

1.什么是比特币？

比特币是一种数字货币，它不依赖于某一个中心机构发行，而是依赖于互联网，基于密码学与分布式计算理论发行，人人都可以参与，它的总量有限，你可以把它想象成数字世界的一种黄金。

2.比特币有什么用？

比特币目前来说可以买到的最重要的东西是各国的货币。比特币作为一种数字货币，设计的初衷是想让其部分取代法币的，因此理论上它可以做任何钱可以做的事情，然而目前比特币直接购物仍然处在很早期的试验阶段，只有少量商家支持，其中最著名的是微软 。个人认为，阻碍比特币广泛应用的原因有三点，一是比特币支付目前的手续费偏高，对这个问题解决方案的争议甚至导致了比特币的分叉，即支持大区块的BCH和支持闪电网络的BCC；二是比特币的价格波动依然过于剧烈，更多的人把它当成了投资品或投机品；三是由于货币竞争的关系，大部分政府不太支持。

比特币现在被比喻为数字黄金，强调其储值的价值，然而比特币的支付价值才是其价值的基底，比特币如果最终无法用于普遍交易，其价值是值得怀疑的。

3.货币应当有国家信用背书，比特币没有，那么它的信用来自于哪里？

货币不一定要有国家信用背书，比如目前黄金还是可以用作国际通行的货币，货币的信用来自于有多少人相信它是货币，基于国家发行的纸币讲的是一个故事，基于密码学共识发行的比特币讲的是另一个故事，人类正是因为有了相信故事的能力，才能组织起更大规模的合作。（推荐阅读《人类简史》 ）

比特币的信用来源确实不好理解，它通过一种分布式的方式，对谁有多少钱这个问题达成了共识，只要参与这个系统的人都不可否认。你仍然需要理解的是，任何现代货币都是一个故事，货币的特点就是承认它有货币价值的人越多，它就越有货币价值，所以不可否认这里面有信仰成分。

4.这么说比特币就是一种传销或者说庞氏骗局嘛？

比特币和传销或庞氏骗局有一点相同，就是都需要一点点信仰。但是区别主要在于，对比特币的信仰会使得这种货币真正具有价值，它的价值就是作为一种货币存在，而不是其他的。而传销或者庞氏骗局带来的是更多的上当受骗的人。

比特币社区最早聚集的是一帮极客、电子朋克，他们希望的是建立一种新的货币体系，出发点绝不是骗钱。当然现在随着炒作比特币及区块链带来的巨大投机机会，所谓的币圈可能是骗子密度最高的地方，我给所有人的建议是不懂不投。

5.比特币究竟是怎么发行的？

除了创世区块的50个比特币，其它比特币都是对记账权的奖励，是在比特币网络运行中逐渐产生的。比特币需要定期对所有未确认的交易进行确认记账，而获得这个记账权的人将获得一定的比特币奖励，这些奖励是比特币原始的来源。每完成一批交易的记账，会打包成一个所谓的区块，每个区块都有一个指针指向前一个区块，因此被称为区块链。

6.谁有多少比特币是怎么记录的，有一个类似银行的账户么？

并没有类似银行账户的概念，比特币区块链只是记录了比特币的产生，以及它产生后所有的转账记录，当转账到某个地址而暂时没有转出时，则这个地址对这个比特币有所有权。

7.地址是什么？

地址可以理解为一种身份的证明，它是公开的，就像人人都能看见你家大门上的门牌号码一样。但是只有你自己有一把钥匙可以打开这扇门，这里用到了密码学中的签名算法，总的来说，你可以通过私钥来证明这个地址（公钥）归你管理。

8.比特币真的有一个一个的币吗？

上面我们说了，比特币区块链就是一个大帐本，所以并没有像人民币那样一个一个的币存在，而只是人人都能看到某个地址上有多少数量的比特币还没有花掉，而这个地址上的比特币只有持有私钥的人才能签名确认后花掉。因此，比特币实际上就是私钥，因为知道了私钥的人就能花掉比特币。

9.怎么保存比特币？

首先，如前所述，保存比特币首要的就是要保存私钥，这是所谓比特币钱包的主要功能，私钥泄露，则比特币丢失。此外，某个地址上有多少币是由公共的区块链来确定的，人人都可以连上比特币网络验证。

10.那么究竟谁来记账呢？我为什么要信任这个记账的人？

这是比特币的最精妙的设计。谁来记账是一个不确定的事情，每个节点都要去花很长的时间的计算（这需要消耗电力）来竞争这个记账的权力，获得记账权力后，如果随便乱记，那么会得不到其他节点的承认，这个生成的区块也将作废，虽然它也指向前一个区块形成了区块链，但是其他的人可以创建一个得到更多人承认的区块，产生一条更长的区块链，使得你这条短的区块链作废，浪费了电力而得不到打包的比特币奖励。这种精妙的设计通过人性是逐利的来达到了可信。

11. 挖矿与矿机是怎么一回事？

如上一点所述，争夺记账权的工作，也就是争夺对记账权的产生的比特币的奖励，就叫做挖矿。挖矿需要做一种哈希运算，让产生的哈希值包含一定数量的0，这个数量随着整个比特币网络哈希计算能力的提升而变大，使得区块打包的速度，也就是比特币生成的速度基本保持匀速。因此对计算速度的竞赛几乎是一种军备竞赛，从最早的CPU，GPU，一直到现在专门用来计算哈希值的矿机。

挖矿获得的奖励每隔一段时间会减半，慢慢的挖矿的人也就是矿工获得的奖励会越来越少，但比特币网络还有另一种机制：每个转账的人都要给一点点的转账费，作为矿工打包成功的奖励。

12.要怎么获得比特币呢？

由于目前通过竞争记账权也就是挖矿来获得比特币已经很专业很困难了，你必须买专业的矿机，加入所谓的矿池共同分担算力与比特币奖励才行。

最简单的办法还是找持有比特币的人用人民币来买，而买卖的方式，由于目前各国监管日益严格，交易平台大多已经不支持类似股票那种法币和比特币的直接交易，而只支持所谓的场外交易平台，也就是平台只做类似淘宝的担保，甚至连担保都没有只是发布信息，买卖比特币是C2C的。建议还是找一些有知名的有担保交易的大平台来购买，这里就不具体推荐了。

13.每个区块都会产生比特币，那么比特币会不会越来越多？

不会，每个区块的奖励每隔一段时间会减半，因此这是一个比例为1/2的等比数列，其总量为2100万个。因此比特币是设计为通缩的。

14.通缩的货币会越来越能换到更多的商品，那么理论上人人都会囤积比特币而不会花费比特币，那么它还有货币价值吗？

这确实是个好问题，我的理解是到一定的时候（比特币获得了它应有的地位，价格趋于稳定），比特币的拥有者自然会花比特币，就像现在拥有黄金的人一样。而且比特币可以和其他支持通胀的货币一起构成货币体系，就如同现在的黄金和法币一样。

15.我听说比特币是匿名的，所以都被用来买毒品？

比特币是一个公开的大帐本，但是它的地址是一串字符串，确实不能直接和人联系起来，因此有一定的匿名性。但是同时，它的账本是公开的，历史是不可更改可以随时查看的，从这个角度来说，它的匿名性还不如现金，只要把比特币地址和人取得了联系，就会追溯到所有的历史。实际上，用比特币贩毒的丝绸之路就被FBI抓了，所以比特币只是一种工具，并不天然的利于犯罪。

16.我听说比特币被用来洗钱？

就像上一问一样，我不认为比特币天然的利于洗钱，像中国政府已经开始监管交易所里用比特币进行洗钱的风险了，我觉得比特币还是应当更多的用于合规合法的应用。

17.既然比特币只是一种技术，而不由任何组织发行，那么岂不是随随便便都会产生类似的各种数字货币？那么比特币还有什么特别的价值吗？

确实是可以产生任意多种类似的数字货币，甚至它们的技术可以更优秀，但是有两点需要注意，比特币有先发优势，数字货币的价值需要越多参与者越好，在比特币已经占领高地的情况下其他数字货币很难从头开始取得优势地位，其次比特币自身也是可以进行技术革新而进化的。

18.比特币分裂是怎么回事？

比特币的相关规则和软件都是开源的，因此当有人不认同现有理念的时候，可以从某个区块开始，按照一个新的规则来打包交易（挖矿），而不接受原来的规则挖出来的区块，反之原来的规则也不再兼容这个新规则挖出来的区块，因此从这个区块开始，有两条区块链各自为政。在这个分类区块之前的未使用的比特币，可以同时转账到两个区块链分支，因此先当于1个原来的比特币变成了新的两个区块链上的各1个比特币。

19.这种分裂不是相当于比特币翻倍了么？

不完全是这样，分裂后的比特币由于参与者用脚投票，会出现价值上的差异，从既定事实的角度来说，只有价值高的那种才算是正宗的比特币。目前比特币的转账手续费较高，如何解决这个问题，产生了两个方案，一个是对区块的大小进行扩容，支持这个观点的人分叉出了被称为BCH的数字货币，而另外更复杂的协议仍暂时保留了BTC的称号。

20.比特币和区块链的关系？

区块链技术产生于比特币的研发，目前衍生出更多的技术，但是区块链技术的应用场景还需要进一步着实，目前的热潮泡沫很大，个人认为以比特币为代表的数字货币才是区块链真正落实了的应用场景。很多应用场景根本没必要使用区块链技术，但是数字货币却很可能是很有必要的，这一点在此不能详述，可以参见哈耶克的《货币的非国家化》。

21.如何投资比特币？

对大部分人来说，投资比特币唯一可行的方式就是用少量的完全不影响生活的钱购买比特币，长期持有5~10年。由于比特币价格仍在剧烈波动中，任何试图追涨杀跌的行为都将陷入赌徒的境地。任何投资永远记得不懂不投。

雪球上当然也有韭菜和小白，有一些感觉水平比我还低的人，但是大部分情况下我觉得讨论质量还是比较高的。不过最让我觉得讨论水平低下的是对比特币的讨论，无论是大V，还是小白，大部分人的看法都是“传销”，“庞氏骗局”，“没有国家背书的货币毫无意义”，“本世纪最大骗局”之类的。说实话，我也看不清比特币的未来，可能还要至少翻一百倍，也可能一文不值，只能当作一个时代的纪念。但是我能够清楚明白的是，这是一个有着深厚数学基础和经济学基础的伟大发明，而绝不是什么传销和旁氏骗局能解释的。比特币作为一种金融工具，但是由于它的数学基础与程序运行的特点，吸引的早期用户大多是程序员，很多传统的投资界人士可能并没有用心去了解过，或者实际上看也没看懂。

我一直觉得投资中的两大心理障碍是贪婪与恐惧，但是现在发现傲慢与偏见也是，比如很多人都倾向于投资计算机、互联网这些高大上的新兴行业，而对白酒、水电之类的没有太多技术含量的股票不屑一顾。我觉得如果抛开道德因素看的化，任何钱都是平等的，卖白酒的也是挣钱，卖软件的也是挣钱，没有高低之分，对投资人而言，更是应该哪里挣钱哪里去。

其实我看到雪球上的投资人对于比特币的无知言论是觉得很高兴的，因为这说明还有很多人没有发现数字货币和区块链的价值，比特币其实还是再比较小的圈子的一个玩具，对它的推广固然任重道远，但也蕴含了无穷的潜力。这也启示我，对于自己不懂不了解的东西千万不要妄下结论，否则失去了真理也失去了真金。

（写此文时，比特币价格突破3000美金。）

战狼2票房已经突破20亿，豆瓣评分也高达7.5分（好于79%的动作片），我觉得算是叫好又叫座了。我也凑热闹去看了，电影本身我觉得人们已经讨论得够多，我没什么要补充的，总的来说，达到了好莱坞大片的水准，要是把主角换成美国人，解放军换成美军，照样是一部好的爆米花电影。

我想说说它的成功。人们调侃说，估计现在找吴京投资《战狼3》的投资人都把钱堆到他家门口了，毫无疑问，《战狼2》获得了极大的商业成功，电影背后的故事也被逐渐挖了出来。看完这些故事，再联系电影本身的品质，我想有几点值得思考：

1. 成功需要各种因素，《战狼2》赶上了这个月没有外国大片，主要对手《建军大业》太过于作业化，夹带的爱国主义情怀赶上了中国民族主义的上升期，当然最主要的还是电影的品质过硬；
2. 吴京我最早知道他是电视剧《太极宗师》，算是男一号，但是后来一直坎坷，在香港电影里面演反角，比如《杀破狼》，动作很凌厉，但毕竟是反派，还只是大反派的小打手，台词都没几句。《战狼2》片头鸣谢了刘伟强和陈木胜，可以想象，吴京在这些动作片导演下没有白呆，从一个动作片演员到大片导演，虽然我不是行内人，也可以想象有多少东西需要学习；
3. 吴京的老婆谢楠挑人的眼光真不错，所以才有抵押房产投资电影的故事，我老婆说，仔细看看，吴京也还蛮帅的，认真的男人最帅吧。

1 交换

请编写一个函数，函数内不使用任何临时变量，直接交换两个数的值。

public int[] exchangeAB(int[] AB) {
        AB[0] = AB[0]^AB[1];
        AB[1] = AB[0]^AB[1];
        AB[0] = AB[0]^AB[1];
        return AB;
    }

2. 加法

请编写一个函数，将两个数字相加。不得使用+或其他算数运算符。

public int addAB(int A, int B) {
        while(B != 0) {
            A = A ^ B; //异或，相当于无进位加法
            B = ((A^B) & B) << 1; // 所有的进位
        }
        return A;
    }

这个二分查找要写准确，其实比较困难。而且关键是虽然查找的时间复杂度是$$O(logN)$$，但是插入时插入点后的数组需要复制，依然是$$O(N)$$时间复杂度。

3 比较大小

请编写一个方法，找出两个数字中最大的那个。条件是不得使用if-else等比较和判断运算符。

    public int getMax(int a, int b) {//a, b符号不同，取正值，a,b符号相同，考察a-b符号
        int sa = sign(a);
        int sb = sign(b);
        int sc = sign(a - b);
        
        int use_sa = sa^sb; //a, b符号不同，使用a的符号
        int use_sc = flip(use_sa); //a, b符号相同，使用a-b的符号
        int k = sa * use_sa + sc * use_sc; //结合use_sa、use_sc的 0/1取值，相当于 if-else 
        int q = flip(k);
        return a * k + b * q; //结合k、q的0/1取值，相当于 if-else 
    }
    
    public int sign(int x) {//该函数的返回值为 0/1 
        return (x>>>31)^1;
    }
    
    public int flip(int bit) {
        return 1^bit;
    }

1. 算法设计出现根本性错误，一般是对题意有误解，或重要的分支情况未考虑到；
2. 算法设计基本正确，但是有一些边界情况未考虑到；
3. 时间复杂度太高；
4. 低级错误。

以上的1、2、3属于算法的基本功，无论你是在线刷题，还是用IDE刷题，都避免不了，但是对于低级错误，IDE的编辑器静态分析就能发现一批，编译时又能发现一批，似乎也不是什么问题。

问题在于，技能的反面就是解决问题，解决一些低级错误是会浪费时间的，而且，有一些低级错误会躲过编译器，造成更大的危害，因此很有必要尽量减少这些低级错误。在线刷题时，我自己常见的低级错误（主要是java语言的）：

1. 没有写分号，或者写了中文分号；
2. 括号未匹配；
3. 未记住一些API的名称，比如HashMap中的containsKey而不是contains；
4. 拼写错误，导致API调用错误，甚至标识符前后不一致；
5. 更改了某个标识符，但是没有更改完全；
6. 忘记写返回语句，或者某些支路忘记写返回语句，甚至返回了错误的变量或变量类型；
7. 重复声明变量，比如循环内外各申明一次；
8. 想要在循环外使用循环变量，但没有在外面声明；

暂时这些，以后不断补充。

如何改善？我发现我这么多年来都犯了一个错误，因为自己粗心，又觉得不可能不犯错误，就放弃了改善的机会，有些放任自流，从认识上就需要提高。以下是一些观点和方法，希望慢慢能标本兼治：

1. 人都会犯错误，甚至犯低级错误，即所谓的粗心，粗心不能根除，但是可以改善；
2. 意识到自己的低级错误并改善，而不要视而不见，放任自流；
3. 适当放慢速度，萝卜快了不洗泥；
4. 第一遍写的时候随时自我复查，要习惯脑子里有一个角色在复查，争取一次写对；
5. 写完复查一遍。
6. 及时总结自己犯了哪些低级错误。

这里谈的都是低级错误，还每涉及到如果提高程序的正确性，这一点以后再总结。

1 暴力搜索

显然可以把每一对数字都检查一遍，$$n$$个数供需检查$$n(n-1)/2$$组，时间复杂度为$$O(n^2)$$。Java代码如下：

public int count(int[] A) {
        int count = 0;
        for(int i = 1; i < A.length; i++) {
            for(int j = 0; j < i; j++) {
                if(A[j] > A[i]) count++;
            }
        }
        return count;
    }

2. 二分查找

考察1中的代码，我们一次检查了以A[1]到A[n-1]结尾的数字对，即数组每增加一个元素，计算一次之前的元素有多少比自己大。如果之前的元素是有序的，那么通过二分查找，可以很快的找到新元素的位置（注意该位置要越过所有相等的元素），该位置后面的元素就是所求的逆序对个数，然后将新元素插入该位置。Java代码如下：

    public int count(int[] A) {
        int count = 0;
        for(int i = 1; i < A.length; i++) {
            int num = A[i];
            int p = find(A, 0, i, num);
            count += (i - p);
            for(int j = i; j > p; j--) {
                A[j] = A[j-1];
            }
            A[p] = num;
        }
        return count;
    }

    private int find(int[] A, int start, int end, int x) {//注意为左闭右开区间
        int mid = (start + end) / 2;
        if(A[mid] == x) {//注意相等时的处理
            while(A[mid] == x) mid++;
            return mid;
        }
        if(A[mid] > x) {
            return mid == start ? start : find(A, start, mid, x);
        }
        else {
            return mid + 1 == end ? end : find(A, mid + 1, end, x);
        }
    }

这个二分查找要写准确，其实比较困难。而且关键是虽然查找的时间复杂度是$$O(logN)$$，但是插入时插入点后的数组需要复制，依然是$$O(N)$$时间复杂度。

3 二叉查找树

2中的方法提示我们，需要找到一种插入与查找都是$$O(logN)$$时间复杂度的数据结构与算法，可以用一个二叉树来实现，对每个节点，使得其右子树中的节点都大于自己，而左子树的小于等于自己，当插入一个新节点时，维护该节点的右子树大小。

    public int count(int[] A) {
        Node root = new Node(A[0]);
        int count = root.getAnti(A[0]);
        for(int i = 1; i < A.length; i++) {
            root.insert(A[i]);
            count += root.getAnti(A[i]);
        }
        return count;
    }

    class Node {
        int rightSize = 0;
        Node left, right;
        int val;
        public Node(int val) {
            this.val = val;
        }

        public void insert(int val) {
            if(val <= this.val) { //注意相等归到左边
                if(left!=null) {
                    left.insert(val);
                }
                else {
                    left = new Node(val);
                }
            }
            else {
                if(right!=null) {
                    right.insert(val);
                }
                else {
                    right = new Node(val);
                }
                rightSize++;
            }
        }

        public int getAnti(int val) {
            if(val == this.val) return rightSize;
            if(val > this.val) return right.getAnti(val);
            return rightSize + 1 + left.getAnti(val);
        }
    }

这个数据结构其实能动态维护逆序数的个数，如果数组是流式进入的，也能随时得出结果。时间复杂度为$$O(NlogN)$$。

4 归并排序

求逆序数，可以这样递归求解，把数组分为左右两部分，先求两部分单独的逆序数，再求右半部分小于左半部分的数量，三者的和就是结果。问题是怎么求右半部分小于左半部分的数量，如果两部分都是有序的，那么可以在线性时间进行归并排序，计算相应的逆序数。比如两个序列 {1，3，6}和{2，4，5，7}，在归并时出现左大于右时，共有 {3，2}、{6，4}，{6，5}三种情况，其中{3，2}时，注意到左边比3大的同样比2大，因此情况计数为2。类似的，每次出现左大于右时，应当考虑左边剩下的数字也大于右边。这里相当于给右边每个元素一个计数，这里很微妙的是，由于归并方向是从左到右，如果计数记在左边，则{6，4}和{6，5}会出现重复计数。

    public int count(int[] A) {
        int[] aux = new int[A.length]; //辅助归并的数组
        return mergeCount(A, aux, 0, A.length);
    }

    public int mergeCount(int[] A, int[] aux, int start, int end) {//注意区间左闭右开
        int mid = (start + end) / 2;
        if(mid == start) return 0;
        int left = mergeCount(A, aux, start, mid);
        int right = mergeCount(A, aux, mid, end);

        System.arraycopy(A, start, aux, start, end - start);
        int i = start;
        int j = mid;
        int count = 0;
        for(int k = start; k < end; k++) {
            if(i >= mid) A[k] = aux[j++];
            else if(j >= end) A[k] = aux[i++];
            else if(aux[i] > aux[j]) {
                A[k] = aux[j++];
                count += (mid - i);//注意计数的个数是左边大于aux[j]的元素数量。
            }
            else {
                A[k] = aux[i++];
            }
        }
        return left + right + count;
    }

这种方法的效率和归并排序是一样的，为$$O(NlogN)$$。

一般的假设我们有面值为$$(a_1,a_2,…a_n) $$的硬币,其中$$ a_1<a_2<…<a_n$$，那么组成面值$$m$$共有多少种可能的情况？

按照一般找钱的顺序，我们从大钱开始考虑，这样剩下的面值才能比较迅速的减小。

1.递推式1

考虑美分的情况，假设我们要组成面值101，记组合数为f(101)，如果使用了一个25分的，那么剩下的情况数应该是f(76)，但是注意，这个f(76)已经不能使用25分的硬币了，简单起见，我们把硬币种类编号引入组合数，当可以用编号1~k时，组合数记为f(m,k)，所以上面的分析可以记为组合数f(101,5)，使用了一个25分时，剩下的情况数为f(76, 4)，针对25美分的使用，可以得到下表

将第二列的数字相加，就得到了结果。现在要求的问题简化了，只需要考虑面值为1，2，5，10的情况，同样的以f(76, 4)为例，可以化简为f(76,3),f(66,3)…f(6,3)，这样递归迭代下去，我们最终要解决的子问题是f(m,1)，用一种面值来组成m，显然，只需要面值m能被$$a_1$$整除即可，由此结束了递归迭代。

$$ f(m, n) = f(m, n-1) + f(m-a_n, n-1) + …+f(m%a_n, n-1)$$

按照这种思路，直接写成Java代码如下:

    public int countCoins(int n, int[] coins) {
        if(n < 0) return 0;
        return countCoins(n, coins.length - 1, coins);
    }

    public int countCoins(int n, int level, int[] coins) {
        if(level == 0) {
            return n % coins[0] == 0 ? 1 : 0;
        }
        int ways = 0;
        for(int i = 0; i*coins[level] <= n; i++) {
            ways += countCoins(n-i*coins[level], level-1, coins);
        }
        return ways;
    }

2. 递推式1的动态规划

在1中，我们通过不断的减去大的硬币面值，求解各个子问题，得到最终的结果，不难发现，这些子问题存在很多重复，比如考虑如下的计算路径：f(101, 5)->f(76, 4)->f(16,3)…和f(101, 5)->f(26, 4)->f(16,3)…后面的计算时完全重合的，因此，如果把这些计算结果缓存起来，可以大大提高计算的速度，这就是动态规划的思想。我们需要建立如下的一张表，以下考虑计算f(6,5)

注意到我们的递推式，每次分解出很多项，那么在动态规划填表时，也就需要很多项目相加才行。动态规划时，先填满第一行，再根据递推式计算第二行，直到计算最后一行。

由此得到Java代码如下：

    public int countCoins(int n, int[] coins) {
        if(n < 0) return 0;
        int[][] ways = new int[coins.length][n + 1];
        for(int j = 0; j <= n; j++) {
            ways[0][j] = j % coins[0] == 0 ? 1 : 0;
        }
        for(int i = 1; i < coins.length; i++) {
            for(int j = 0; j <= n; j++) {
                if(j < coins[i]) {
                    ways[i][j] = ways[i-1][j];
                }
                else {
                    for(int k = 0; k*coins[i] <= j; k++) {
                        ways[i][j] +=  ways[i-1][j-k*coins[i]];
                    }
                }
            }
        }
        return ways[coins.length - 1][n];
    }

注意到最后一行其实只需要计算最后一个元素。（因为它只跟前一行相关），所以上述代码还可以修改节约时间，不过代码会变得不太美观，这里就不写了。

3 递推式2及其动态规划

我们发现，递推式1中，一项被分解成多项，导致计算过程中做了相当多的加法，能不能简化一下呢？

还是考虑f(101,5)，我们可以这样考虑，首先不使用25美分，情况数为f(101,4)，其次是使用25美分的情况，那么至少要使用一个25美分，如果去掉这个25美分，则相当于剩下的76美分，既可以使用25美分，也可以不用，实际上就是f(76,5)，由此得到递推关系$$ f(m, n) = f(m-a_n, n) + f(m, n-1)$$，这样在动态规划填表时，每次取上一行的数与本行之前相距$$a_n$$的数相加。注意当$$m<a_n时，f(m, n) = f(m, n-1)$$。

由此得到动态规划的代码如下：

    public int countCoins(int n, int[] coins) {
        if(n < 0) return 0;
        int[][] ways = new int[coins.length][n + 1];
        for(int j = 0; j <= n; j++) {
            ways[0][j] = j % coins[0] == 0 ? 1 : 0;
        }
        for(int i = 1; i < coins.length; i++) {
            for(int j = 0; j <= n; j++) {
                if(j < coins[i]) {
                    ways[i][j] = ways[i-1][j];
                }
                else {
                    ways[i][j] = ways[i-1][j] + ways[i][j-coins[i]];
                }
            }
        }
        return ways[coins.length - 1][n];
    }

4 递推式2的简化

仔细考察我们填表的过程，填第二行时，左边的较小元素和第一行一样，右边较大的元素在第一行的基础上加上本行较小的一个元素，所以其实只需要存储一行元素就行了，计算 $$f(m, n)$$时， $$f(m-a_n, n)$$在左边已经计算出来了，而$$f(m, n-1)$$直接使用自身存储便可。由此得到更加简化的动态规划代码：

    public int countCoins(int n, int[] coins) {
        if(n < 0) return 0;
        int[] ways = new int[n + 1];
        for(int j = 0; j <= n; j++) {
            ways[j] = j % coins[0] == 0 ? 1 : 0;
        }
        for(int i = 1; i < coins.length; i++) {
            for(int j = coins[i]; j <= n; j++) {
                ways[j] += ways[j-coins[i]];
            }
        }
        return ways[n];
    }

考虑第一行，如果设置ways[0] = 1，j<coins[0]时，ways[j] = 0,那么第一行同样可以用递推式ways[j] += ways[j-coins[i]]得到。代码可进一步简化如下：

    public int countCoins(int n, int[] coins) {
        if(n < 0) return 0;
        int[] ways = new int[n+1];
        ways[0] = 1;
        for(int i = 0; i < coins.length; i++) {
            for(int j = coins[i]; j <= n; j++) {
                ways[j] = ways[j] + ways[j-coins[i]];
            }
        }
        return ways[n];
    }

1 插入法

这种算法最直观，基于排列的递推定义。符合所谓减治法的思想，或者说是数学归纳法的思想，如果n-1个元素已经排好，我们只需要把第n个元素插入这些排列中所有可能的位置即可，每个元素有n个位置可以插入，刚好是(n-1)!*n=n!种情况。如果插入的时候，方向先从右到左，再从左到右循环，那么每两个相邻的排列将只有最小的差异，即只有某两个相邻元素相异。比如已经有12,21则12从右到左插入3，21从左到右插入3，最终得到123,123,312,321,231,213。具体的Java代码如下，这是一个递归算法。

public static ArrayList<int[]> getPermutations(int n) {
        ArrayList<int[]> permutations = new ArrayList<>();
        if(n <= 0) return permutations;
        if(n == 1) {
            permutations.add( new int[]{1});
            return permutations;
        }
        ArrayList<int[]> remainders = getPermutations(n-1);
        for(int i = 0; i < remainders.size(); i++) {
            int[] remainder = remainders.get(i);
            for(int j = 0; j < n; j++) {
                int[] permutation = new int[n];
                if(i % 2 ==0) {//insert from right to left
                    System.arraycopy(remainder, 0, permutation, 0, n - 1- j);
                    permutation[n - 1 - j] = n;
                    System.arraycopy(remainder, n - 1 - j, permutation, n - j, j);
                }
                else {//inset from left to right
                    System.arraycopy(remainder, 0, permutation, 0, j);
                    permutation[j] = n;
                    System.arraycopy(remainder, j, permutation, j + 1, n - 1- j);
                }
                permutations.add(permutation);
            }
        }
        return permutations;
	}

2 JohnsonTrott算法

在Johnson-Trotter算法中，每次循环都进行一次满足条件的相邻元素的交换，直到不存在满足条件的可交换的元素，此时说明所有排列的情况均已输出，算法结束。

具体过程如下：

1. 初始化所有元素的移动方向为左，输出序列本身
2. 移动最大的可移动的元素(当元素移动方向上的元素比自己小时，才能移动)
3. 反转所有比移动元素大的所有元素的移动方向
4. 重复2~3步，直到不能移动为止

具体例子

上面的算法流程有些抽象，现在举个例子来加深理解。假设现在要计算$${1,2,3}$$所有排列。首先是将所有元素的移动方向为标记为向左，我们可以表示成这样$${\overleftarrow{1},\overleftarrow{2},\overleftarrow{3}}$$，然后根据算法流程中的步骤2，移动最大的可移动元素。这里的可移动元素是指在其移动方向上的相邻元素比自己小时，例如$$\overleftarrow{2},\overleftarrow{3}$$都是可移动元素，因为在他们的移动方向上(左移)的相邻元素:1,2分别比2,3小，而每次都只移动这些可移动元素中最大的那个项。接着，在每次交换完成之后，寻找所有比当前交换元素大的元素，将他们的移动方向反转一下。

下面列出$${1,2,3}$$在计算过程中所有的情况 $$ \begin{align} &{\overleftarrow{1},\overleftarrow{2},\overleftarrow{3}}\ &{\overleftarrow{1},\overleftarrow{3},\overleftarrow{2}}\ &{\overleftarrow{3},\overleftarrow{1},\overleftarrow{1}}\ &{\overrightarrow{3},\overleftarrow{2},\overleftarrow{1}}\ &{\overleftarrow{2},\overrightarrow{3},\overleftarrow{1}}\ &{\overleftarrow{2},\overleftarrow{1},\overrightarrow{3}}\ \end{align} $$

Java代码如下：

public static ArrayList<int[]> getPermutations(int n) {
        ArrayList<int[]> permutations = new ArrayList<>();
        if (n <= 0) return permutations;
        int[] first = new int[n];
        boolean[] mobile = new boolean[n];
        for(int i = 0; i < n; i++) {
            first[i] = i + 1;
            mobile[i] = true;//true:left; false:right;
        }
        permutations.add(first);

        while(true) {
            int[] last = permutations.get(permutations.size()-1).clone();
            int k = findLargestMobile(last, mobile);
            if(k == -1) break;
            int max = last[k];
            int neighbor = mobile[k] ? k - 1 : k + 1;
            swap(last, k, neighbor);
            swap(mobile, k, neighbor);
            reverseLarger(last, mobile, max);
            permutations.add(last);
        }
        return permutations;
    }

    private static int findLargestMobile(int[] array, boolean[] mobile) {
        int k = -1;// -1 means can't find mobile element
        int max = -1;
        for(int i = 0; i < array.length; i++) {
            int j = mobile[i] ? i - 1: i + 1;
            if(j < 0 || j >= array.length) continue;
            if(array[i] > array[j] && array[i] > max) {
                max = array[i];
                k = i;
            }
        }
        return k;
    }

    private static void reverseLarger(int[] array, boolean[] mobile, int max) {
        for(int i = 0; i < array.length; i++) {
            if(array[i] > max) mobile[i] = !mobile[i];
        }
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    private static void swap(boolean[] array, int i, int j) {
        boolean temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

3 字典序生成法

字典序生成法在当前已经生成的排列上寻找下一个字典序的排列：

1. 找到最长的递减序列后缀，记这个序列的前一个元素为i，如果找不到i，则证明已经生成了最后一个完全倒序的排列，生成完毕。
2. 在前述后缀中，找到比元素i大的最小元素j，并交换i和j；
3. 将后缀逆序排列。
4. 重复1到3。

比如排列123654，首先找到后缀654，在找到中间最小大于3的4，交换得到124653，然后将后缀逆序得到124356,又如排列123645，找到后缀5，交换得到123654，后缀只有一个，逆序后不变仍未123654。

具体的Java代码如下：

public static ArrayList<int[]> getPermutations(int n) {
        ArrayList<int[]> permutations = new ArrayList<>();
        if(n <= 0) return permutations;
        int[] first = new int[n];
        for(int i = 0; i < n; i++) first[i] = i + 1;
        permutations.add(first);

        while(true) {
            int[] last = permutations.get(permutations.size()-1).clone();
            int i = n - 1;
            while(i > 0) {
                if(last[i] > last[i-1]) {
                    break;
                }
                i--;
            }
            if(i==0) break;

            int j = n - 1;
            while(j >= i) {
                if(last[j]>last[i-1]) {
                    break;
                }
                j--;
            }
            swap(last, i-1, j);

            int k = n - 1;
            while(i < k) {
                swap(last, i, k);
                i++;
                k--;
            }
            permutations.add(last);
        }
        return permutations;
    }

4 序数法

这个方法把n!个排列与0n!-1之间的数一一对应起来，这样，我们就可以按照0n!-1的次序，逐一生成相关的排列。这个对应的关键在于0~n!-1之间的数m，可以用如下的方式表示： $$m=a_{n-1}\cdot (n-1)!+a_{n-2}\cdot (n-2)!+…+a_1\cdot 1!$$,其中$$0\leq a_i\leq i$$，

故m对应序列$$(a_{n-1}, a_{n-2},…a_1)$$，现在再把这个序列和排列一一对应起来，n-1位的序列对应n位的排列。

$$a_i$$ 表示排列p中的数i+1所在位置的右边比它小的数的个数。比如对于排列p=4213，4,3,2的逆序数分别为3，0，1，由此对应为$$(a_2,a_1,a_0)$$，反过来呢，如果知道了逆序数$$(a_2,a_1,a_0)==(3,0,1)$$,也可以一一恢复出排列来。比4小的有3个，4只能放最左边，比3小的为0个，3只能放最右边，比2小的一个，2放第二个位置，剩下的放1，故为4213。

Java代码如下：

    public static ArrayList<int[]> getPermutations(int n) {
        ArrayList<int[]> permutations = new ArrayList<>();
        if (n <= 0) return permutations;
        int[] factorials = new int[n+1];
        factorials[0] = 1;
        for(int i = 1; i <=n; i++) {
            factorials[i] = i * factorials[i - 1];
        }// init factorial array
        for(int m = 0; m < factorials[n]; m++) {
            int remainder = m;
            int[] permutation = new int[n];
            for(int i = n-1; i >=0; i--) {
                int count = remainder / factorials[i];
                remainder = remainder % factorials[i];
                setPosition(permutation, count, i + 1);
            }
            permutations.add(permutation);
        }
        return permutations;
    }

    private static void setPosition(int[] permutation, int count, int num) {
        int zeros = 0;
        for(int i = permutation.length - 1; i >=0; i--) {
            if(permutation[i] == 0) zeros++;
            if(zeros == count + 1) {
                permutation[i] = num;
                break;
            }
        }
    }

5 轮转法

基准序列$$p_1p_2…p_{n-1}p_n$$，先逐步生成以$$p_1$$开头的所有排列：

1. 先生成以$$p_1p_2…p_{n-2}$$开头的所有排列$$p_1p_2…p_{n-2}p_{n-1}p_{n}$$和$$p_1p_2…p_{n-2}p_{n}p_{n-1}$$
2. 再生成以$$p_1p_2…p_{n-3}$$打头的排列，除了前述2个排列外，再将其后三位从左至右轮转2次，得到4个新排列，一共6个排列；
3. 再生成以$$p_1p_2…p_{n-4}$$打头的排列，除了前述6个排列外，再将其后四位从左至右轮转3次，得到18个新排列，一共24个排列；
4. 依次类推，一直到生成以$$p_1$$开头的所有排列为止。

然后将基准序列从左到右轮转一次，生成以$$p_2$$开头的所有排列，依次类推，直到生成以$$p_n$$开头的所有排列。

java代码如下：

    public static ArrayList<int[]> getPermutations(int n) {
        ArrayList<int[]> permutations = new ArrayList<>();
        if (n <= 0) return permutations;
        int[] first = new int[n];
        for(int i = 0; i < n; i++) {
            first[i] = i + 1;
        }
        for (int i = 0; i < n; i++) {
            if(i > 0) {
                rotateLeft(first, 0, n);
            }
            int[] base = first.clone();
            permutations.addAll(rotateBase(base));
        }
        return permutations;
    }

    private static ArrayList<int[]> rotateBase(int[] base) {
        ArrayList<int[]> permutations = new ArrayList<int[]>();
        permutations.add(base);
        for(int prefixSize = base.length - 2; prefixSize >= 1; prefixSize--) {
            int currentSize = permutations.size();
            for(int i = 0; i < currentSize; i++) {
                int[] last = permutations.get(i);
                for(int j = 0; j < base.length - prefixSize - 1; j++) {
                    int[] rotated = last.clone();
                    rotateLeft(rotated, prefixSize, base.length);
                    permutations.add(rotated);
                    last = rotated;
                }
            }
        }
        return permutations;
    }

    private static void rotateLeft(int[] permutation, int start, int end) { 
      // rotate from left to right
        int temp = permutation[start];
        for(int i = start; i < end - 1; i++) {
            permutation[i] = permutation[i + 1];
        }
        permutation[end-1] = temp;
    }

6 回溯法

我们将问题形象化，假如你手里有编号为1、2、3的3张扑克牌和编号为1、2、3的三个盒子。现在需要将这3张扑克牌分别放入3个盒子里，并且每个盒子有且只有一张扑克牌。总共有几种放法呢？

首先你来到了1号盒子面前，你现在手里有3张扑克牌，先放哪一张好呢？很显然三者都要尝试，那就姑且约定一个顺序：每次到一个盒子面前，都先放1号，再放2号，最后放3号。于是你在一号盒子里放入了编号为1的扑克牌。来到2号盒子面前，由于之前的1号扑克牌已经不在手中，按照之前约定的顺序，你将2号牌放到了2号盒子里。3号也是同样。你又往后走当你来到第4个盒子面前，诶，没有第四个盒子，其实我们不需要第4个盒子，因为手中的扑克牌已经放完了。

你发现了吗？当你走到第四个盒子前的时候，已经完成了一种排列，即“1 2 3”。然而并没有到此结束，产生了一种排列之后，你需要立即返回。现在你已经退到了3号盒子面前，你需要取回之前放在3号盒子中的扑克牌，再去尝试看看还能否放别的扑克牌，从而产生一个新的排列。于是你取回了3号牌，但由于你手中只有3号牌，你只能再次退回到2号盒子面前。

你回到2号盒子后，收回了2号牌。现在你的手中有2张牌了，分别是2号和3号牌。按照之前的约定，现在需要往2号盒子中放3号扑克牌（上次放的是2号牌）。放好后，你来到3号盒子面前，将手中仅剩的2号牌放入了3号盒子。又来到了4号盒子面前，当然没有4号盒子。此时又产生了一个新的排列“1 3 2”。

接下来按照刚才的步骤去模拟，便会依次生成所有排列：“2 1 3”、“2 3 1”、“3 1 2”和“3 2 1”。

Java代码实现如下：

    public static ArrayList<int[]> getPermutations(int n) {
        ArrayList<int[]> permutations = new ArrayList<>();
        if (n <= 0) return permutations;
        boolean[] visited = new boolean[n];
        int[] current = new int[n];
        dfs(permutations, current, visited, 0);
        return permutations;
    }

    private static void dfs(ArrayList<int[]> permutations, int[] current, boolean[] visited, int step) {
        int n = current.length;
        if(step == n) {
            permutations.add(current.clone());
            return;
        }
        for(int i = 0; i < n; i++) {
            if(!visited[i]) {
                current[step] = i + 1;
                visited[i] = true;
                dfs(permutations, current, visited, step + 1);
                visited[i] = false;
            }
        }
    }

当然，如果改用栈，也可以变成非递归的版本。

后记

对一个问题用不同的算法解决，可以综合复习各种算法思路。

另外重要的一点就是，如果看过一个算法没有写代码实现过，很可能会有一些没有真正理解的细节存在。

如果以后再发现好的算法，还会再补充。

我目前电脑主要使用的操作系统是Windows 10，但是我倾向于使用一些可以跨平台使用的软件，这样万一我想换平台则成本比较低。下面主要列举的是软件，可能会适当涉及在线服务。

1 操作系统

• Windows 10 ：所有的笔记本、台式机、Surface都使用Windows 10了，一是安全起见，二来我也觉得Windows 10还是比较好用的。开启了Bash On Ubuntu On Windows子系统后，也不用装其他的命令行工具，甚至Linux系统也用得很少了。
• Deepin Linux ：现在已经过了喜欢折腾系统的阶段，觉得操作系统最好开箱即用，而深度在这一点上做到了极致，预装了很多国人必备的软件比如WPS、QQ等。虽然在主力笔记本上使用三硬盘双系统，但是其实现在用得也不多。

2 文本与写作

• Office365 ：其实还是很喜欢Office软件，之前在工作中用得不少，现在买了Office 365服务，其实也用得不多，可能用最多是Excel了。
• Typora ：非常好用的markdown编辑器，这篇博客就是这么写的。
• Jekyll + Github Pages：这是现在的主力写作平台，在诸多静态博客生成器中选择了Jekyll，只是因为这是GitHub默认支持的，懒得折腾了。

3 浏览器

• Chrome：主力浏览器。其中重要的插件包括AdBlock、Checker Plus for Gmail™、Proxy SwitchyOmega、Save to Pocket、惠惠购物助、印象笔记·剪藏等。
• IE11：没办法，工行只能用IE。
• Firefox：现在用得比较少了，出于感情因素一直装着。

4 通信软件

• TIM：替代QQ，没有杂七杂八的东西。
• 微信 for Windows 10：发现都是腾讯家的。
• Telegram：刚刚接触，看重它的保密通信。

5 系统增强

• BandZip：压缩软件，界面清爽，功能强大。
• CCleaner：垃圾清理软件。
• Geek Unіnstaller：一款小巧的软件卸载工具，卸载时会查找注册表与垃圾文件。
• RightMenuMgr：右键管理工具，可以删除一些不需要的右键项目。
• FastCopy：文件快速拷贝工具。
• f.lux：屏幕色温自动调节工具。
• Everything：非常强大的文件搜索工具。
• Wox：快速启动工具。
• WGestures ：全局鼠标手势工具。

6 下载工具

• 迅雷极速版：虽然迅雷越来越水，但是这款极速版至少还没什么广告，是个比较纯粹的下载工具。
• 百度网盘：可能是我用的唯二的百度服务了，另外一个是百度糯米。
• 人人影视Pro：下载人人影视的作品很方便。
• Resilio Sync：偶尔下点小东西，基于bittorrent原理的网盘工具。

7 影音娱乐

• 射手播放器：虽然很久不更新了，但基本上还是万能播放器，最好的是还能自动下载字幕。
• 网易云音乐UWP：主要在网易云音乐听歌，顺便本地歌曲播放也一起搞定了。
• 多多猫app：可以看漫画的插件式强大软件，不过我也很少看就是了。

8 开发工具

• Visual Studio 2017：工作中主用Visual Studio，自己的个人电脑习惯装最新版的。宇宙第一IDE，名不虚传。配上JetBrain家的Reshaper插件，写C#简直是所向无敌。
• Intelij IDEA：偶尔也写写Java代码，再装上插件，写Pyhton之类的也毫无压力。
• Visual Studio Code：又是微软出品的强大文本编辑器，装上插件后当轻量级的IDE用，写写Python，改改网站代码之类的。
• Anaconda：一套完整的Python配套软件环境，包括数据分析常用的各种利器，今年开始研究机器学习，这是一个利器。
• Octave：Matlab的开源版，偶尔写写简单的Matlab代码，或者当计算器算算矩阵。
• Xshell ：远程连接VPS时很好用。
• GitExtension：一整套Git的解决方案，包括Git的GUI界面，以及文件比较工具等。
• AutoHotkey：自动化脚本工具。

9 安全软件

• WIndows Defender：不爱装其他杀毒软件，基本上等于裸奔了。
• VeraCrypt：加密软件。

10 阅读软件

• Kindle：偶尔也在电脑上用一下。
• calibre：现在所有的电子书都交给它来管理了。
• LightReader：轻量级的epub阅读器。
• 福昕阅读器领鲜版：Foxit Reader的国内版，有pdf编辑功能。
• DrowBoard PDF：在Surface上看PDF是神器。

11 其他

• 印象笔记高级账户：它的特点是在各种笔记软件中比较简约均衡，Office365中的OneNote我也用，但是感觉太重了。
• 科学上网工具：v2ray、XX-Net、Shadowsocks、Lantern，需要多种手段互为备份。
• ZeroNet：最近刚接触的新鲜玩意儿，基于类似比特币的原理构建的P2P内容网络。
• paint.net：偶尔改个图，当PhotoShop用。
• Zotero：收集论文资料用。
• Oracle VM VirtualBox：虚拟机软件。
• FileZilla：FTP软件。
• GeoGebra：一款有趣的几何作图软件。
• Bither：一款比特币官方推荐的国人开发的比特币钱包。
• TeamViewer：给家人远程桌面解决问题时用。