<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>IGAOZP</title>
        <link>https://paragraph.com/@igaozp-2</link>
        <description>undefined</description>
        <lastBuildDate>Mon, 20 Jul 2026 18:29:36 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>en</language>
        <image>
            <title>IGAOZP</title>
            <url>https://storage.googleapis.com/papyrus_images/57cf9339553374d270c751a090f0b3e93ae0f41054a3847ba3a0acfb6ab67e2a.png</url>
            <link>https://paragraph.com/@igaozp-2</link>
        </image>
        <copyright>All rights reserved</copyright>
        <item>
            <title><![CDATA[《纳瓦尔宝典》摘要]]></title>
            <link>https://paragraph.com/@igaozp-2/MevrxDjGypJ6CKUkF1iv</link>
            <guid>MevrxDjGypJ6CKUkF1iv</guid>
            <pubDate>Fri, 07 Feb 2025 12:36:01 GMT</pubDate>
            <description><![CDATA[该文章为笔者读《纳瓦尔宝典》（The Almanack of Naval Ravikant: A Guide to Wealth and Happiness）时所记摘要，录以备考假以时日待作感悟。认识财富创造的原理如何致富（不靠运气）：追求财富，而不是金钱或地位。财富是指在你睡觉时仍能为你赚钱的资产。金钱是我们转换时间和财富的方式。地位是你在社会等级体系中所处的位置。创造财富和坚持道德标准是可以兼得的。如果你内心鄙视财富，财富就会对你避而远之。无视一味追求社会地位的人。他们获得地位的手段就是攻击创造财富的人。依靠出租时间是不可能致富的。你必须拥有股权（企业的部分所有权），才能实现财务自由。获得财富的一个途径，就是为社会提供其有需求但无从获得的东西，并实现规模化。选择一个有长期发展前景的行业，找到可以长期合作的人。互联网极大地拓展了职业空间，但大多数人还没有清晰地认识到这一点。培养迭代思维。生活中所有的回报，无论是财富、人际关系，还是知识，都来自复利。选择聪明过人、精力充沛的商业伙伴，但更重要的是，他们要正直诚信。不要跟愤世嫉俗和消极悲观的人合作。他们的预言会自我实现。学会销售，学...]]></description>
            <content:encoded><![CDATA[<p>该文章为笔者读《纳瓦尔宝典》（The Almanack of Naval Ravikant: A Guide to Wealth and Happiness）时所记摘要，录以备考假以时日待作感悟。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">认识财富创造的原理</h2><p>如何致富（不靠运气）：</p><ul><li><p>追求财富，而不是金钱或地位。<strong>财富是指在你睡觉时仍能为你赚钱的资产</strong>。金钱是我们转换时间和财富的方式。地位是你在社会等级体系中所处的位置。</p></li><li><p>创造财富和坚持道德标准是可以兼得的。如果你内心鄙视财富，财富就会对你避而远之。</p></li><li><p><strong>无视一味追求社会地位的人。他们获得地位的手段就是攻击创造财富的人。</strong></p></li><li><p><strong>依靠出租时间是不可能致富的。你必须拥有股权（企业的部分所有权），才能实现财务自由。</strong></p></li><li><p><strong>获得财富的一个途径，就是为社会提供其有需求但无从获得的东西，并实现规模化。</strong></p></li><li><p>选择一个有长期发展前景的行业，找到可以长期合作的人。</p></li><li><p>互联网极大地拓展了职业空间，但大多数人还没有清晰地认识到这一点。</p></li><li><p>培养迭代思维。生活中所有的回报，无论是财富、人际关系，还是知识，都来自复利。</p></li><li><p>选择聪明过人、精力充沛的商业伙伴，但更重要的是，他们要正直诚信。</p></li><li><p>不要跟愤世嫉俗和消极悲观的人合作。他们的预言会自我实现。</p></li><li><p>学会销售，学会构建，两技傍身，势不可当。</p></li><li><p>用专长、责任感和杠杆效应武装自己。</p></li><li><p>专长指的是无法通过培训获得的知识。如果社会可以培训你，那么社会也可以培训他人来取代你。</p></li><li><p>要想有所专长，就要追求真正的兴趣和热爱，而不是盲目追逐热点。</p></li><li><p>累积专长的过程，对你而言就像玩耍，对他人来说则很吃力。</p></li><li><p>专长的传授需要通过师傅带徒弟的方式完成，而无法通过学校教育完成。</p></li><li><p><strong>专长往往具有高度的技术性或创造性，不能被外包或自动化。</strong></p></li><li><p>培养责任感，勇于以个人名义承担商业风险。社会将根据责任大小、股权多少和杠杆效应回报你。</p></li><li><p>「给我一根足够长的杠杆和一个支点，我就能撬动地球。」——阿基米德</p></li><li><p><strong>要想获得财富，就必须充分利用杠杆效应。商业杠杆来自资本、劳动力和复制边际成本为零的产品（代码和媒体）。</strong></p></li><li><p>资本是指金钱。要想获得融资，需要运用自己的专长和责任感，并表现出良好的判断力。</p></li><li><p>劳动力杠杆就是让别人为你工作。这是最古老、争夺最激烈的一种杠杆。拥有劳动力杠杆会让你的父母觉得你很了不起，但不要过度追逐劳动力杠杆。</p></li><li><p>资本和劳动力是需要获得许可才能使用的杠杆。人人都在追逐资本，但得有人愿意出资。人人都想领导他人，但得有人愿意追随。</p></li><li><p><strong>代码和媒体是不需要许可就能使用的杠杆。这两个杠杆是新富阶层背后的杠杆。你可以创建软件和媒体，让它们在你睡觉时为你工作。</strong></p></li><li><p>有一大批机器人可供我们免费使用。为了提高热效率、节约空间，这些机器人就集中放在数据中心。用起来吧。</p></li><li><p>如果不会写代码，那就出书、写博客、做视频、录播客。</p></li><li><p>杠杆是判断力的倍增器。</p></li><li><p>判断力从经验中来，但可以通过学习基本技能快速建立起来。</p></li><li><p>没有所谓的「商业」技能。不要把时间浪费在商业杂志和商业课程上。</p></li><li><p><strong>学习微观经济学、博弈论、心理学、说服术、伦理学、数学和计算机。</strong></p></li><li><p>读比听快，做比看快。</p></li><li><p>你应该忙得没时间社交，但依然把日程安排得井然有序。</p></li><li><p><strong>设定一个大胆的个人时薪，并严格执行。如果解决一个问题节省的成本低于时薪，那就忽略问题；如果外包一项任务的成本低于时薪，那就选择外包。</strong></p></li><li><p>工作时要拼尽全力，毫无保留。不过，共事的人和工作的内容比努力程度更重要。</p></li><li><p>在自己选择的职业领域里做到全球顶尖。不断重新定义自己的事业，直到理想成为现实。</p></li><li><p>世界上没有快速致富的教程。即使有，那也只是提供教程的人想从你身上赚钱。</p></li><li><p>运用专长，发挥杠杆效应，最终你会得到自己应得的。</p></li><li><p>当你终于变得富有时，你会意识到，这并不是你最初的追求。但这是后话，此处暂且不提。</p></li></ul><p><strong>总结：把自己产品化。一个是「自己」，一个是「产品化」。「自己」具有独特性，「产品化」是发挥杠杆效应；「自己」具有责任感，「产品化」需要专长。「自己」其实也具有专长。</strong></p><p>如果想要实现致富的长期目标，你就应该问问自己：<strong>「这是我真正想要的东西吗？我的规划目标是我真正想要的吗？」</strong> 得到肯定的答案后，再问问自己：<strong>「我实现产品化了吗？我实现规模化了吗？我选择规模化的方式是劳动力、资本，还是代码或媒体？」</strong> 由此可见，「把自己产品化」这个阐述方便简单，便于记忆。</p><p>金钱是我们转移财富的方式。金钱是社会的信用符号，具有调用别人时间的能力。</p><p>你真正想要的其实是财富。财富就是在你睡觉时也可以帮你赚钱的资产。财富是可以进行生产的工厂和机器人。财富是不分昼夜为客户服务的计算机程序。财富也可以是银行里被投资于其他资产或业务的钱。</p><p>技术让消费变得更大众化，也让生产变得更集中。在某个领域做到全球顶尖的人，现在可以为世界上任何人提供自己的产品或服务。</p><p><strong>某种东西一旦得到广泛应用，它就不再是科技了。</strong></p><p><strong>社会总是需要新事物。如果想变得富有，你就要弄清楚你能为社会提供哪些其有需求但无从获得的东西，而提供这些东西对你来说又是轻松自然的事情，在你的技术和能力范围内。</strong></p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">找到天赋所在，积累专长</h2><p>专长无法被教授，但可以被学习。</p><p>在「成为自己」这件事情上，没有人能比得过你。其实，<strong>人生大部分时间都是在寻找，寻找那些最需要你的人，寻找那些最需要你的事情。</strong></p><p><strong>通常情况下，专长属于知识领域的边缘地带。有些领域尚处于发轫或发展阶段，有些领域研究难度很大，这些领域更容易产生专长。</strong> 如果你在研究的时候不是百分之百投入，其他百分之百投入的人就会超过你。他们的表现会比你好不是一点儿，而是很多，因为我们讨论的是创意领域的竞争。<strong>在创意领域，复利效应非常明显，杠杆效应也非常明显。</strong></p><p><strong>有了互联网，只要你在自己的领域做到最好，只要你能规模化你所提供的特别内容，那么就算你的兴趣很小众，你也能有所发展。</strong></p><p>「只有独辟蹊径，才能避开竞争。」<strong>从本质上看，竞争就是模仿，与他人竞争，是因为你跟别人在做一样的事情</strong>。但是，每个人都是独一无二的，不要模仿他人。</p><p>最好的工作与委任或学位无关。<strong>最好的工作是终身学习者在自由市场中的创造性表达</strong>。</p><p><strong>致富最重要的技能是成为终身学习者，无论想学什么，你都得找到途径和方法。以前的赚钱模式是读 4 年大学，拿到学位，在某个专业领域干上 30 年。现在不一样了，时代的发展日新月异，必须在 9 个月内掌握一门新专业，而这门专业在 4 年后就过时了。但在专业存在的这 3 年里，你可以变得非常富有。</strong></p><p>比起成为一名数字营销专家或点击优化专员，知道如何增强沟通说服力更重要。打好基础非常关键。在基础知识层面得 90 分或 100 分远胜于盲目地深入钻研。当然，有些东西你需要深入研究，否则你只能做到「样样都通，样样稀松」，无法实现人生目标。<strong>一个人只能在一两件事上做到精通，而这一两件事通常是让你痴迷的事情。</strong></p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">投资交友，着眼长远</h2><p>个人声誉方面也存在复利效应。如果一个人声誉良好，数十年如一日，不断打造和积累自己的声誉，这个人就一定会得到关注和重视。而如果一个人才华横溢，却没有利用声誉的复利效应，相比之下，注重声誉的人的价值就会高出其成千上万倍。</p><p>你应该在经过深思熟虑后，清醒地认识到自己需要从大多数事情（人际关系、工作、学习）中找到可以尽全力去付出的那部分，以充分获取复利效应。我不是说那 99% 的事情都不要做，因为我们很难确定剩下的 1% 到底是什么。我的意思是：努力找到不会被浪费的 1%。这1%对你是有意义的，值得你用余生去追求。一旦找到，你就要心无旁骛，全力以赴。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">承担责任</h2><p>获得财富需要杠杆。杠杆可以来自劳动力、资本、代码或媒体。劳动力和资本等大多数杠杆需要有给予方。要获取劳动力，必须有人追随你。要获得资本，需要有人为你提供资金、管理资产或机械设备。</p><p>要得到劳动力或资本，必须建立信誉，尽可能以个人信誉做担保，而这种操作存在风险。因此，责任是把双刃剑：进展顺利，责任人会得到褒奖；一旦失败，责任人就会首当其冲。</p><p>明确的责任分配非常重要。没有责任，就没有动力。没有责任，就无法建立可信度。但责任也意味着风险：失败的风险，被羞辱的风险，以个人名誉承担失败的风险。</p><p>那些有能力以个人名义在公众面前承担失败风险的人，会获得很大的原动力。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">创立企业或买入股权</h2><p>如果你是通过出租时间来换取报酬的，即使从事律师和医生等高薪职业，你能够获得的报酬也非常有限，不足以让你实现财务自由。而如果拥有企业股权，你就可以获得被动收入——即使你在度假，企业也在帮你赚钱。</p><p>如果不持有企业股权，个人投入和收益的关联性就会非常强。几乎所有领取月薪的工作，即便是律师或医生这样的高薪职业，也需要投入时间才能获得相应的收入。</p><p>如果不持有企业股权，睡觉的时候没有收入，退休以后没有收入，度假期间也没有收入。总之，收入是相对固定的，根本无法实现实质性突破。</p><p><strong>从本质上看，上班就是给人打工。而企业所有者在承担风险和责任的同时也拥有知识产权和品牌效应。所以，他们支付给你的报酬一定低于你创造的价值。为了让你工作，他们会给你提供最低限度的报酬。这个最低限度的报酬可能很高，但依然不是真正的财富，因为你退休后，这份收入将难以为继。</strong></p><p>拥有企业股权意味着可以获得企业发展的收益。</p><p>但通常情况下，真正的财富是通过创建公司或者通过投资创造出来的。投资公司也是买入企业的股权。这些都是获得财富的途径。总之，<strong>真正的财务自由都不是靠单纯地投入大量时间来实现的</strong>。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">找到杠杆</h2><p>想要打造良好的职业基础，就要追随自己真正的求知欲上下求索，而不是盲目跟风眼下赚钱的热门行业。</p><p>正是在独特的热爱和爱好的驱动下，我们才得以掌握只有自己或一小部分人才知道的知识。如果能够把求知欲和兴趣爱好结合、相融，我们就更有可能找到自己的所爱。</p><p>如果一件事物一开始让你兴致盎然，后来又让你觉得索然无味，那么它只是暂时分散了你的注意力，并不是你心智上真正的好奇所在。请继续寻找。</p><p>如果在追随好奇心和求知欲的过程中又满足了社会需求，你就能得到优厚的经济回报。</p><p><strong>你更有可能获得这个社会还不能通过培训提供的技能。如果社会可以培训他人，这些人就可以取代你。如果你可以被轻易取代，社会就不需要为你支付重酬。要时刻牢记，掌握社会所需的独门绝技才是占据职业制高点的不二法门。</strong></p><p>认真想一想，社会上还有哪些尚未得到满足的需求，而你怎样才能成为第一个提供相关产品或服务的人，并将其规模化。这才是赚钱真正的挑战。</p><p>第一种是<strong>劳动力杠杆</strong>，也就是让别人给你打工。劳动力杠杆是一种最古老的杠杆，但在现代社会，这种杠杆的效果并不是最好的。我甚至认为这是一种最落后的杠杆。因为管理他人是一件非常复杂、极具挑战的工作，需要高超的领导技巧，弄不好管理者会落个众叛亲离、被手下生吞活剥的下场。</p><p>资本是第二种相对较好的杠杆形式。<strong>资本杠杆就是用钱来扩大决策的影响力</strong>。资本是一种更现代的杠杆形式，利用资本杠杆有一定的难度，需要一定的技能。在 20 世纪，人们曾经利用资本杠杆获得了惊人的财富。资本杠杆是 20 世纪杠杆的主要形式。</p><p>最后一种杠杆是最新出现的，也是普通人最触手可及的。这种杠杆就是 <strong>「复制边际成本为零的产品」</strong>。</p><p>其中包括<strong>书籍、媒体、电影、代码</strong>。在所有不需要他人许可就能使用的杠杆中，代码可以说是最强大的一种——只需要一台计算机就够了。</p><p>复制边际成本为零的产品是最值得研究的杠杆，也是最重要的杠杆。这是一种全新的杠杆形式，问世仅几百年。这种杠杆始于印刷机。广播媒体加速了其发展，而互联网和编程的出现更是使其产生了爆发式增长。不需要他人为你打工，也不需要他人给你投资，你就可以把劳动成果放大成百上千倍。</p><p><strong>新杠杆最重要的特点之一就是，使用它们或获得成功都无须经过他人的许可。要使用劳动力杠杆，就得有人决定追随你。要使用资本杠杆，就得有人给你提供资金，你再去进行投资或开发产品。</strong></p><p>无论处于人生的哪个阶段，努力的目标都是不断提高自己的独立性，而不是升职加薪。拥有独立性，为自己独特的产出成果负责（而不是像打工一样为投入的时间负责），这才是最理想的状态。</p><p><strong>每周工作 40 小时是工业时代的产物。知识劳动者的时间安排与运动员如出一辙，有训练和冲刺的时间，也有休息和重新评估的时间。</strong></p><p>投入和产出之所以脱节，是因为工具和杠杆的存在。一个职业的创造性越高，其投入与产出的不匹配性越高。而投入和产出高度相关的职业很难创造财富，从事这种职业也很难给自己带来财富。</p><p><strong>想加入一家伟大的科技公司，销售技能和构建技能必备其一。如果二者都不具备，那就去学习。</strong></p><p>销售和构建是两个非常宽泛的概念。构建产品很难，因为涉及多个变量，涵盖设计、开发、制造、物流、采购等环节，甚至还包括服务的设计和运营。因此，「构建」的定义非常多元。每个行业都定义了各自的「构建者」。在我们科技行业，「构建者」是首席技术官，是程序员，是软件工程师和硬件工程师。即便是洗衣行业，也存在「构建者」。洗衣行业的「构建者」就是设计洗衣服务的人，是确保流程正常运转的人，是确保所有衣服在正确的时间被运送至正确地点的人，等等。</p><p>另一个概念是销售。销售的定义同样很宽泛。销售不一定是针对个体顾客销售产品，也可以指市场营销、媒体传播、人才招聘、资金募集、员工激励、公共关系等，涉及面非常广。</p><p>不要做可能会让你全盘皆输的事情。不要孤注一掷、铤而走险。相反，要把赌注押在那些胜算较大、能带来巨大利益的事情上。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">用判断力赚钱</h2><p>我认为每个人都应该立志掌握某些领域的专业知识，并以此赚取经济回报。如果能够在实际工作中最大化地利用杠杆，无论是机器人、计算机，还是其他任何人或技术，那么我们都可以成为自己时间的主人，因为没有人会考核我们在工作中投入了多少时间，我们只需要对自己的产出负责。</p><p><strong>首席执行官的报酬之所以很高，就是因为杠杆效应。在判断力和能力上，毫厘之差都会有天壤之别。</strong></p><p>只要在优秀的基础上稍微提高一点儿，做到卓越（比如把完成 1/4 英里的短跑成绩提高零点秒），经济回报就会呈数量级增加。而杠杆效应进一步放大了经济回报的差异。在杠杆时代，在自己的领域做到极致非常重要。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">分清主次，聚焦重点</h2><p><strong>给自己的时间设定价格，用时薪计算时间价值。如果用花钱的方式节省的时间价值更高，那就花钱，不要犹豫。要想真的赚到钱，先要相信你自己很值钱。</strong></p><p>要从时间成本的角度做决策，如果做某件事外包的成本低于时薪，那就外包；如果不做的损失低于时薪，那就不做；如果花钱请人的成本低于时薪，那就花钱请人。甚至做饭也是同样的道理，你可能想吃健康的家常菜，但是如果可以外包，那就外包吧。</p><p><strong>在商业世界里，大多数人在玩零和游戏，少数人在玩正和游戏，他们在人群中寻找志同道合者。</strong></p><p><strong>这世上的游戏不外乎两种。第一种是金钱游戏。金钱不能解决所有问题，但可以解决所有和金钱有关的问题。大家都明白这一点，所以每个人都想赚钱。但与此同时，许多人内心深处觉得自己是赚不到钱的，所以，他们不喜欢看到创造财富的故事。他们会攻击整个商业体系，宣称「赚钱是邪恶的，不应该赚钱」。但其实他们在玩第二种游戏，这种游戏叫地位游戏。他们之所以说「我不需要钱，我不想要钱」，是因为他们想占领高地，让别人高看一眼。地位就是一个人在社会等级中的位置。</strong></p><p>在人类进化史上，财富创造是近代才出现的活动，是一个正和游戏。而地位之争自古有之，是一个零和游戏。那些攻击财富创造的人往往只是为了追求地位。</p><p>玩愚蠢的游戏，就只能赢得愚蠢的奖品。</p><p><strong>最重要的是，要在重大决定上花更多时间。人生早期有三个重大决定：在哪里生活，和谁在一起，从事什么职业。</strong></p><p>找到自己擅长的领域，然后用自己的技能去帮助他人：提供免费的产品或服务，主动向世界传递善意。好人终有好报。只要始终如一，假以时日，付出就一定能获得相应的回报。但不要计较自己付出了多少——一旦开始计较，耐心就会被消耗殆尽。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">找到如玩耍般的工作</h2><p>在人类社会形成之初，每个人都扮演着狩猎者或采集者的角色，自己劳动养活自己。农业社会伊始，社会等级开始形成。工业革命和工厂的出现极大地强化了社会的等级划分，因为没有人可以凭一己之力拥有或建立一家工厂。<strong>但由于互联网的诞生和发展，现代社会越来越回归到每个人为自己劳动的时代。</strong></p><p>退休就是不再为了想象中的明天而牺牲今天。当你能活在当下，内心充盈地度过每一天时，你就达到了退休的状态。</p><p>第一种方法是存钱。只要存款够多，被动收入（不用动一根手指）就能满足开销。第二种方法是把开销降为零——出家修行。第三种方法是做自己热爱的事情，完全乐在其中，有钱没钱无所谓。所以，实现退休状态有很多种方法。</p><p>避开竞争陷阱的方法就是做独一无二的自己，找到自己能做到独步天下的事情。做到最好，只因热爱。如果你真的热爱一个事物，那就追随本心，努力找到利用它满足社会真实需求的切入点，利用杠杆效应扩大规模，以个人名义担起责任。这样，在承担风险的同时，你也将获得相应的回报，拥有自己所提供产品或服务的所有权或股权，然后持续精进。</p><p>毫无保留地爱，随心所欲地创造，无忧无虑地玩耍。</p><p>我永远都在「工作」。但是，别人眼里的工作于我而言就像是玩耍。正因如此，我才确信没有人可以在我的领域与我匹敌。因为我觉得工作就是玩耍，所以我可以一天玩 16 个小时。如果有人想跟我竞争，那么他们肯定会输，因为他们不可能一周工作 7 天，每天工作 16 个小时。</p><p>钱不是万恶之源。钱本身是无罪的，真正有害的是对钱的贪欲。从道德层面看，追求金钱并不是坏事，它跟人品没什么关系，但是，贪欲对人是有害的。</p><p>人之所以永远不会感到满足，是因为欲望这个开关一旦被打开，就不会在某个具体数字面前自动关停，正所谓欲壑难填。所以，不要以为赚到某个数额的钱，人自然就会满足了、停手了。</p><p>赚钱的目的是解决财务问题，满足物质需求。<strong>我认为，摆脱金钱贪念最好的办法就是，赚了钱之后不要升级自己的生活方式。赚到钱的人往往会自然而然地提高生活水准。假设你一次性赚到一大笔钱，而不是靠日积月累。此时你依然保持着原有的生活方式，还没来得及升级，你的金钱就会远远超出你的实际需求和欲望，这反而让你达到一种财务自由的状态。</strong></p><p>我把自由看得高于一切。我说的自由是多种多样的：想做什么就做什么的自由，不想做什么就不去做的自由，不受自我情绪或外界影响的自由，等等。自由是我最珍视的价值。</p><p>硅谷最成功的人分为两类。第一类是做风险投资的人，因为他们非常多元化，控制着曾经是稀缺资源的东西。第二类是极为擅长识别公司发展阶段和前景的人。这些人会精准地找到下一个多宝箱或爱彼迎，在公司的产品和服务刚刚与市场需求相衔接时加入它们。这些人拥有公司扩大规模急需的背景和专业知识，也能找到合适的引荐人。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">如何获得运气</h2><p>在获得财富的过程中，你要排除「运气」这个不可控因素。</p><p>第一种运气是不期而遇的运气，一个人的好运完全源于他控制范围之外、意料之外的事情，比如获得意外之财、遇到贵人等等。</p><p>第二种运气源于坚持不懈、孜孜不倦、屡败屡战、不断尝试，是靠个人主动创造机会获得的。你释放了大量能量，使出浑身解数，移山倒海，一往无前。就好像在做科学实验，把不同的试剂混合在一起，看看能产生什么结果。因为你不懈地努力，不停地奋进，不断地释放能量、积蓄力量，所以好运找到了你。</p><p>第三种获得好运的方式就是善于发现好运。如果你在某个领域技艺娴熟、经验丰富，那么当这个领域实现了意外突破时，你就会在第一时间洞悉，这时，其他不熟悉这个领域的人会无动于衷。这就是增加对好运的敏感性，幸运会眷顾有准备的大脑。</p><p>第四种运气是最奇妙、最难得的一种，那就是打造独特的个性、独特的品牌、独特的心态，让运气找到你。</p><p>获得好运的方法：希望好运不期而至。·不停地折腾，直到撞上大运。·做好心理准备，对别人错过的机会保持敏感。·把你所做的事情做到极致。精益求精，直到名副其实。让机会自动找到你，让运气成为必然。</p><p>第四种运气总结一下就是，以某种方式塑造自己的性格，之后就由性格决定命运。</p><p><strong>「在一个长线游戏中，似乎每个人都在让彼此变得富有。而在一个短线游戏中，似乎每个人都在让自己变得富有。」</strong></p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">保持耐心</h2><p>江山易改，本性难移。所谓「性格决定命运」，就是一个人不断重复自己的行为模式，好的坏的、优点缺点，最终会得到与自己的行为相对应的结果。始终主动付出、不断奉献，不要斤斤计较、患得患失。</p><p>在物质世界里，金钱不能给人带来快乐，不能解决人的健康问题，不能让所有家庭变得美满和睦，不能让人免受情绪波动的困扰。但金钱可以买到自由，可以解决许多外在的问题。所以，赚钱是一个合情合理的奋斗目标。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">判断力</h2><p>把时间花在省钱上是不会致富的。省出时间来赚钱才是正确的思路。</p><p>我对智慧的定义是**「知道个人行为的长期后果」**，用于解决外部问题的智慧其实就是判断力。或者说，智慧和判断力是高度关联的：一个智慧而富有判断力的人，首先要知道个人行为的长期后果，然后做出正确的决策并付诸行动。</p><p>在杠杆时代，一个正确的决策可以帮你赢得一切。不付出努力，就无法培养判断力，也不会获得任何杠杆。</p><p>在前进的过程中，方向比速度更重要，特别是运用了杠杆以后。在每个岔路口选对方向，其重要程度要远远超过前进的努力程度。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">如何清晰地思考？</h2><p>真正的知识具有内在的关联性，就像一根链条，从基础层面到应用层面环环相扣。</p><p>如果在需要用到一些概念时却无法通过基础知识推导出来，你就会迷失在现有知识的迷宫中，你就成了简单的背诵机器。</p><p>阻碍我们看清现实的最大因素就是我们对现实「应有的样子」有先入为主的印象。</p><p>痛苦时刻的一个定义是：当你看到事物的真面目不是你本来想要的样子时，你是痛苦的。</p><p>难点在于看清真相。要看清真相，就必须摆脱自我，因为自我不想面对真相。自我越弱小，对自己反应的限制越少，对自己想要的结果的执念越低，就越容易看清现实。</p><p>悠闲的大脑才能产生伟大的创意。一个倍感压力、案牍劳形、四处奔波、焦头烂额的人，是没有办法思考的。所以，一定要为思考挤出时间。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">摆脱自我束缚，认清世界真相</h2><p>要持续成长，很重要的一点是学会打破现有的条件反射，改掉不良习惯。</p><p>要善于剖析自我，梳理每个习惯是怎样形成的。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">学习决策技巧</h2><p>要选择从长期来看让我们受益最大的做法，而不是只顾眼前得失。</p><p>当把成功归于自己时，你要更加谨慎，因为难免出现认知偏差。</p><p>自由的表现之一就是可以心口如一，表达自己的真实想法。诚实和自由高度统一，相辅相成。</p><p>具体地表扬，泛泛地批评。</p><p>如果要提出批评意见，不要批评某个人，可以批评工作方法，或者批评某一类行为。如果要表扬，那就找到一个榜样，表扬这个特定的人。这样有助于维护你身边人的自尊心和身份感，获得他们的支持，让他们为你所用，而不是与你作对。</p><p>人们好像很难从本质上理解决策的杠杆效应。我可以举例说明，如果我管理着 10 亿美元的资产，而且我的决策正确率比其他人高出 10%，我就能通过一个判断、一个决策创造出 1 亿美元的价值。这就是决策的杠杆效应。随着现代科技的发展、劳动力规模的扩大和资本的不断积累，决策也将发挥越来越大的杠杆效应。</p><p>越觉得自己无所不知，规避和处置风险的方法越少。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">发现好的心智模型</h2><p>所谓的心智模型，其实就是有助于调取你所学知识的简单方法。</p><p>有一种理论认为，文明的存在是为了解决交配权的分配问题。从纯粹的性选择角度看，人类社会精子充足，卵子稀少，所以存在分配问题。究其根本，人类的所有发明和成就都是为了解决交配权的分配问题。人生的很多问题都可以从进化论、热力学、信息论和复杂性理论中找到解释和预测。</p><p>成功的关键并不在于做出正确判断，而在于避免做出错误判断。</p><p>如果不能深刻理解供求关系、劳资关系、博弈论等问题，你就不可能在商业上取得成功，甚至也无法很好地适应现代社会。</p><p>委托和代理问题非常容易理解。恺撒大帝有句名言：「如果你想完成一件事，那就亲自去做。如果不想完成，那就派人去做。」他的意思是，如果想把事情做好，你就必须自己去做。如果你是委托人，你就会有主人翁的责任感，因为在意结果，所以你会做得很好。而如果你是代理人，你就是在为别人做事，你可能会做得很糟糕，因为你不在乎。你追求的是自身利益最大化，而不是委托人资产最优化。</p><p>公司规模越小，每个人越会觉得自己是委托人、是主人。越不觉得自己是代理人，工作就会做得越出色。增加所获报酬与创造价值之间的相关性，可以改变员工的认知，让他们越发觉得自己是委托人，而不仅仅是代理人。</p><p><strong>要吃透基础数学，真正掌握加减乘除、复利计算、概率论和统计学。</strong></p><p>对那些声称「科学」站在自己一边的人来说，最重要的原则，同时也是他们理解得最不透彻的原则，就是可证伪性。如果不能做出可证伪的预测，那就不是科学。要让人们相信某个理论是真理，这个理论就应该具有预测能力，而且必须是可证伪的。</p><p>如果你难以抉择，答案就是否定的。原因是，现代社会充满了选择，有成千上万个选择。我们生活在一个有 70 亿人口的星球上，我们和互联网上的每个人都相互连接，世界上有成千上万的职业供我们选择。大千世界，芸芸众生，选择永远不缺。</p><p>一个重大决策可能会影响未来十几年，甚至几十年的人生轨迹。创业可能需要 10 年时间。一段恋情可能会持续 5 年甚至更久。搬到一个城市可能会住上 10 年、20 年。这些决定都将产生深远的影响。人做不到绝对确定，但是我们一定要在非常确定的情况下再做出决定。</p><p><strong>一条简单的人生经验：如果在一个艰难的决定上意见不统一，你就应该选择短期内更痛苦的道路。</strong></p><p><strong>如果面对两个选择，利弊各占 50%，你就应该选择短期内更艰难、更痛苦的道路。</strong></p><p>从本质上看，两条道路中的一条会带来短期痛苦，而另一条会在未来引发更长久的痛苦。为了回避矛盾，大脑会本能地选择摆脱短期痛苦。</p><p>前提条件是，两个选择利弊相当，但如果一条道路会带来短期痛苦，那么它也会带来长期收益。而根据复利效应，长期收益才是你想要的。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">学会热爱阅读</h2><p>不要比谁读书更快。书越好，你越要慢慢阅读、慢慢吸收。</p><p>大部分图书都有一个论点（我讲的是非虚构类作品，不是小说），作者提出一个论点，引用海量实例证明自己的观点，然后用自己的观点去论证世界上各种各样的现象。一旦觉得自己已经明白了这个论点，我就不再读下去了。这样的书太多了，我称其为伪科学畅销书。别人会问我：「这本书你读了吗？」我总是说读过了，其实我可能只读了两章，但书的主旨我已经了解了。</p><p>阅读数学、科学和哲学领域的经典作品。不要读畅销书，不要看新闻。避免加入任何所谓的「读书俱乐部」，避免追求任何的社群认同。把真理置于社群认同之上。</p><p><strong>在解决问题时，问题越古老，解决方案存在的时间越长。</strong></p><p>任何流传了两千年的图书都经过了许多代人的甄别和筛选，其中的一般性原则更有可能是正确的。我想重新开始阅读这类书。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">幸福是一种技能</h2><p>有钱确实能提高幸福感，但金钱其实只发挥了很小的作用。幸福感的提升主要是因为，随着时间的推移，我逐渐认识到，让自己幸福对我来说是最重要的事，我也运用了大量技巧来培养自己的幸福感。</p><p>现在，我认为幸福就是一种不需要主动作为的状态。当把「缺憾感」从生活中剔除时，幸福感就会油然而生。</p><p>当感到生命中并不缺少什么时，大脑就会处于休眠状态，不再追忆昨天，也不再畅想明天，不会悔不当初，也不会谋求未来。</p><p>人们往往误将积极乐观的想法和行为等同于幸福。</p><p>幸福就是消除缺憾感之后的感受。</p><p>真正的幸福只是内心平和的副产品，主要还是源于接受现实，而不是改变外部环境。</p><p>理性很强的人可以通过训练自己的无感反应获得平和，即学会漠视自己无法控制的事物。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">幸福是一种选择</h2><p>我们无条件地听从自己脑海中的声音，以为这个声音就是一切真理的来源。殊不知，大脑也是可塑的，每一天都是崭新的。记忆和身份只是来自过去的负担，让我们无法自由自在、心无旁骛地活在当下。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">幸福需要心境平和</h2><p>你要意识到，是焦虑感让你感到不快乐。而这种焦虑感源于一连串不断涌现的想法。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">欲望是主动选择的不开心</h2><p>从根本层面上看，从自身以外的事物中寻求幸福，本身就是缘木求鱼。当然，我并不是说物质世界不重要。作为一种社会性动物，人需要去履行一些社会职责。人的一生就是在力所能及的范围内减少无序状态，即所谓**「局部熵减」**，这是你的人生责任。</p><p>欲望就是你跟自己的约定，约定的内容是：不得到我想要的东西，我是不会快乐的。我觉得大部分人都没有意识到，这就是欲望的本质。我们每天都生活在欲望中，又奇怪为什么自己不快乐。我已然认识到，欲望是我痛苦的来源。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">成功不一定带来幸福</h2><p>幸福就是满足现状。而成功源于对现状的不满，是对现状的改造。两者只能选一个。</p><p>生存和繁衍的本能驱使人们劳作，而享乐适应让我们步履不停。幸福的秘诀在于，知道何时停下劳作的脚步，开始随心去玩耍。</p><p>对现在的我来说，真正的赢家是那些已经完全退出游戏的人，甚至根本不玩游戏的人，是那些已经超越了游戏的人。这些人的内心无比强大，有极强的自控力和清醒的自我意识，他们不需要从任何人那里获得任何东西。</p><p>在现实生活中，内心的平和状态不是一劳永逸的，也不会是一成不变的。心理状态总在不断变化。在大多数情况下，接受并顺应现实，是获得幸福的核心技能。</p><p>平和是静态的幸福，幸福是动态的平和。只要愿意，你就随时可以把平和激活，使之变成幸福。但是大部分时间你想要的其实是被封印的幸福，即平和。如果你是一个内心平和的人，那么无论做什么事你都可以获得幸福的体验。</p><p>获得内心平静的唯一方法是摒弃「问题」这个概念。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">嫉妒是幸福的敌人</h2><p>我在生活中努力摆脱「应该」这个词。当「应该」在脑海中出现时，其背后隐藏的是负罪感或社会规训。如果做一件事是因为「应该」，那就表示你内心是不想这么做的，而违背自己的心意会让你变得痛苦不堪。因此，我努力在生活中减少「应该」做的事。</p><p>而现实是，生活就是一场单人游戏。人独自出生，独自死亡，独自解读人世间的一切。你的记忆只属于你一个人。你出生前无人在意，你离开人世后也无人在意，你存在于人世间只是短短几十年，人生就是一场单人游戏。</p><p>嫉妒是一种有害的情绪，因为归根到底，它并不能改善你的生活，只会让你不快乐，而你嫉妒的那个人仍然是成功的、美丽的，仍然拥有你所嫉妒的一切。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">幸福源于好习惯</h2><p>获取平和与幸福其实是一种技能，这种技能不是与生俱来的。</p><p>工作时，和比自己更成功的人在一起。玩耍时，和比自己更快乐的人在一起。</p><p>可以通过养成好习惯来获取。不喝酒、不吃糖可以提高情绪的稳定性，远离社交媒体（脸书，Snapchat 和推特）也可以提高情绪的稳定性。玩电子游戏会带来短暂的快乐（我一度痴迷于游戏），但会摧毁长期的幸福。喝咖啡也属于用长期健康换取短期兴奋。这些不受你控制的外界因素会刺激你体内多巴胺的分泌，刺激因素一旦消失，多巴胺水平就会下降。</p><p>从本质上讲，生活的过程就是用精心培养的好习惯替换那些在不经意间养成的坏习惯，努力成为一个更幸福的人。你的幸福指数最终取决于你的习惯和你花最多时间与之相处的人。</p><p>最幸福和最乐观的人会选择五只正确的黑猩猩做朋友。</p><p>如果我意识到自己正在对别人评头论足，我就会停下来自问：「我能不能正面解读这件事？」我过去常常因为一些事情感到恼火，但现在总会尝试看到积极的一面。刚开始，我可能需要花几秒钟，动用理性分析才能想出一种积极的解读方式。</p><p>新闻的目的就是让人感到焦虑和愤怒。但新闻背后的科学、经济学、教育和冲突趋势是有积极意义的。</p><p>政治、学术和社会地位都是零和游戏。正和游戏才能造就积极向上的人。</p><p>阳光、运动、正向思考和色氨酸，这些不是药物，但都可以增加大脑中的血清素，使人始终保持健康、清醒、积极、乐观。</p><p>这就是改变习惯的步骤：首先，知道自己要做什么；其次，知道该怎么做；再次，把规划告诉朋友，让一致性偏见发挥作用；最后，严格自律，知行合一，进行自我重塑，直至蜕变成全新的自己。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">于接受中寻找幸福</h2><p>试图改变现状是一种欲望。在成功改变现状之前，欲望会让人感到痛苦。所以不要总想着去改变外部环境。在任何特定的时间段，只选择一个最有价值的欲望，作为自己的奋斗目标和动力之源。</p><p>无论面对何种状况，你都有三种选择：改变现状，接受现状，逃避现状。很多人在遇到问题时会踟蹰不前，陷入空想：希望改变现状却没有横下一条心去改变，希望转身离开却没有毅然决然地离去，同时又不能心平气和地接受现状。</p><p>这种纠结和回避的态度正是人生中大部分痛苦的来源。我在脑海里对自己说得最多的就是两个字：接受。</p><p>所谓接受，就是无论结果如何，都可以泰然处之；就是保持心态平衡，大脑专注；就是退一步海阔天空；就是观大势，顾全局，谋长远。</p><p>一个方法是退后一步，回顾经历过的痛苦。我还会把这些痛苦写下来：上次分手，上次生意失败，上次健康出问题，后来都发生了什么？这样我就可以看到在随后的几年里我的成长和进步。</p><p>另一个应对小挫折的方法就是换个角度看问题。当我遭遇挫折时，部分自我会立即做出消极反应。但现在我已经学会自问：「这种情况有什么积极的意义吗？」</p><p>如何学会接受无法改变的事情？从根本上说，就是学会坦然面对死亡。</p><p>死亡是人的一生中最重大的事情。人终有一死，选择正视、承认死亡而不是逃避死亡，将赋予人生巨大的意义。我们在一生中会花费大量时间试图逃避死亡。我们的很多奋斗目标都可以归结为对永生的追求。</p><p>相对于宇宙，你就像一只在夜空中闪烁的萤火虫，你的生命转瞬即逝。如果能彻底认识到你所做的一切不过是徒劳，你就能获得巨大的幸福感和平和感，因为你会意识到，生命不过是一场游戏。但生命是一场有趣的游戏。在这场游戏中，唯一重要的事情就是，随着生命的展开，你要不断地体验现实。</p><p>既然如此，你为什么不以最积极的方式去诠释自己经历的一切呢？</p><p>宇宙的幸福值并不是恒定的，别人不会因为你不幸福而变得更加幸福。</p><p>你在地球上所拥有的时间稍纵即逝，无比宝贵，你一定要好好珍惜。你要把直面和正视死亡放在第一位。人的一生，不否认、不回避死亡是极其重要的，因为这是你学会坦然接受无法改变的事情、活在当下的本原。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">选择做自己</h2><p>你唯一应该做的事，是你自己想做的事。别人总希望你以特定的方式做事，但如果不再费心去揣摩别人的期待，你就能听到自己脑海中那个微弱的声音。那个声音代表了你真实的想法。倾听它，你就可以做自己了。</p><p>在「做自己」这件事情上，没有人能与你竞争。你永远不会像我一样擅长做我自己，我也永远不会像你一样擅长做你自己。当然，做人要虚心聆听，博采众长，但不要盲目模仿。模仿他人纯属徒劳。</p><p>相反，每个人都有独一无二的资质技能、专业知识、能力才干、个人欲望，这些是世界上其他人所没有的，是先天基因和后天经验共同作用的结果。</p><p>不要基于别人正在做的事为你自己列清单、做决策。你永远不会成为他们，你永远都不擅长做另一个人。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">选择关爱自己</h2><p>情绪上的大起大落让我们无比焦虑。生物进化的目标本来是适应物质的匮乏。为了应对匮乏，基因决定了我们看到糖分、酒精、毒品就难以抗拒，遇到亲密关系也无法拒绝。</p><p>但是，现代人生活在一个富足的世界里，面对琳琅满目、应有尽有的一切，当我们的基因一直在说「要要要」的时候，我们本该拒绝，但我们的身体已经不知道如何说不了。</p><p>所以，在现代社会，我们逐渐背离了符合自然规律的生活习性，形成了病态的生活方式。</p><p>人的大脑和身体存在备用机制，大自然的这种设计是有意义的。例如，在冰期，人类在没有很多植物可供食用的环境中进化。</p><p>后来，在备用机制的作用下，人们选择多种植物作为自己的食物。到现在，人类食用植物已有几千年的历史。我虽然并不认为植物对身体有害，但我感觉接近原始的饮食结构应该更好</p><p>让人产生饥饿感的食物是糖。糖会给你的身体发出这样的信号：「在我们进化的环境中竟然有这么好的食物资源。」于是你会迫不及待地摄取糖分。问题在于，糖效应凌驾于脂肪效应之上。</p><p>在高脂高糖的饮食中，糖会让人产生饥饿感，脂肪会提供卡路里，从而导致暴饮暴食。这也是为什么所有的甜点都含有大量的脂肪和碳水化合物。</p><p>糖和脂肪的结合是致命的，在饮食中我们必须注意避免摄入此类食物。</p><p>膳食中的脂肪会带来饱腹感，糖会导致饥饿感。但糖效应占据主导地位，所以我们需要相应地控制自己的食欲。</p><p>最常见的借口就是「我没时间」。表面上说的是「我没时间」，但其实说的是，「这对我来说不是优先事项」。</p><p>生活中的所有事情都一样，如果愿意做出短期的牺牲，你就会得到长期的好处。我的体能教练耶日·格雷戈雷克是个非常聪明的人。他总是说：「选择简单模式，人生会越来越困难；选择困难模式，人生会越来越简单。」</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">冥想+精神力量</h2><p>情绪是生物进化的产物，能预测当前事件对未来的影响。在现代社会环境中，情绪反应通常是夸张的，甚至是错误的。</p><p>我发现，对我最有效的一种冥想叫「无选择觉知」，或叫「无评判觉知」。这种冥想方式就是在处理日常事务时（最好有跟大自然接触的机会），不跟任何人交谈，练习接受自己所处的当下时刻，不做任何评判。既不去想，「那边有个流浪汉，我最好到马路对面去」，也不要看着跑步的人暗想，「这人身材走样了，我的身材比他好」。</p><p>第二种方法是超觉冥想，就是通过反复唱诵，在头脑中制造一种白噪声来掩盖自己的想法。第三种方法就是对自己的想法保持高度敏锐和警觉。通过观察自己的想法，你会意识到很多想法都源于恐惧。</p><p>在你识别出恐惧的那一刻，恐惧感自然就消失了。一段时间过后，你的思绪就会平静下来。</p><p>我学到的第四种冥想方法是，坐在那里闭上眼睛，每天至少一个小时。此时，你以臣服的姿态接受发生的一切，不争取，不对抗。如果有想法在头脑中涌现，那就任其涌现。</p><p>洞察冥想是在「调试模式」下运行大脑，最终你会意识到自己只是一个大程序的子程序。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">选择自我塑造</h2><p>说「打算」，就是在拖延，就是在给自己找借口。不过，即使没有把想法付诸行动，至少也要对自己真实的心理活动保持觉知：「虽然我说我想做这件事，但其实并不是真的想。因为如果真的想，我早就去做了。」</p><p>有想法就直接采取行动，就是这么简单。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">选择自我成长</h2><p>「要建立系统，而不是设定目标。」运用你的判断力确定什么样的环境有助于你茁壮成长，然后在周围创造一个这样的环境，由此增加成功的概率。</p><p>第一条原则是阅读，广泛地阅读。阅读面要广，不要局限于社会认可的书，更不要局限于我推荐的书。要为了阅读而阅读，培养对阅读的热爱。</p><p>第二条原则是，掌握与阅读技巧相关的数学和说服技能。这两种技能有助于你在现实世界里活得游刃有余、畅行无阻。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">选择解放自己</h2><p>勇气不是在枪林弹雨中冲锋陷阵，而是不在乎别人怎么想。</p><p>不要花自己的时间去取悦别人。别人快不快乐是他们的问题，不是你的问题。你快乐了，别人也会快乐。你快乐了，别人会问你是如何快乐起来的，他们会从中学到点儿什么，但是你没有责任让别人快乐。</p><p>观察自己愤怒时的样子。愤怒就是对情况失去控制时的表现。愤怒是跟自己的契约，你同意让自己陷入身体、精神和情感的混乱，直到现实发生改变。</p><p>愤怒本身就是一种惩罚。一个愤怒的人试图把你的头摁到水下，但同时他也在溺水。</p><p>自我意识和自我发现没有终点，是毕生的功课，我们在这条路上不断精进。人生没有一个有意义的答案，也没有人可以完全解决人生的所有问题，除非你成为一个大彻大悟的人。也许有人能最终做到，但我知道我不太可能做到，因为我已经被卷入这场无休止的「老鼠竞赛」。在最好的情况下，我能做到偶尔抬头看看天上的云。</p><p>孤独的个体召唤出非人的意志力，进行断食、冥想、锻炼……对抗大批科学家和统计学家以充足的食物、药物和电子屏幕为武器制造出的垃圾食品、标题党新闻、无限的色情内容、无穷无尽的游戏、令人上瘾的毒品。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">生命的意义</h2><p>你做的任何事情都将烟消云散，你存在的一切痕迹都将无处可寻。人类终将灭亡，地球也会荡然无存。即使是移民火星的群体也会消失。无论你是艺术家、诗人、征服者、贫民，还是其他任何人，几代人过后，都不会有人记得你。总之，生命没有任何意义。</p><p>作为生命系统，我们所做的一切都是在推动宇宙加速达到热寂。创作艺术、研究数学、组建家庭、发明计算机、创建文明等等——所有这些更复杂的系统都在使宇宙加速达到热寂。你正在把我们推向「万物一体」的终极境界。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">按照自己的价值观生活</h2><p>在对别人撒谎之前，你必须先对自己撒谎。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">我们唯一拥有的是当下</h2><p>除了当下，一切都是不存在的。没有人能够回到过去，也没有人能够以任何有意义的方式成功地预测未来。唯一存在的就是此时此地，就是你恰好存在的这个时刻和在宇宙空间里的这个位置。</p><p><strong>灵感本易逝，行动应当时。</strong></p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">纳瓦尔推荐的图书</h2><p>《无穷的开始：世界进步的本源》</p><p>《理性乐观派：一部人类经济进步史》</p><p>《基因组：生命之书23章》</p><p>《红色皇后：性与人性的进化》</p><p>《自下而上：万物进化简史》</p><p>《万物解释者：复杂事物的极简说明书》</p><p>《趣味物理寻答集》</p><p>《主权个体：把握向信息时代的过渡》</p><p>《现实不似你所见：量子引力之旅》</p><p>《七堂极简物理课》</p><p>《竞争策略：策略博弈论入门》</p><p>《万物理论（启蒙的视角）》</p><p>《杰德·麦肯纳笔记本》</p><p>《杰德演讲#1》</p><p>《杰德演讲#2》</p><p>《全然的自由：克里希那穆提要义》</p><p>《塞涅卡之道：斯多葛派大师的实用书信》</p><p>《改变你的心智》</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">纳瓦尔的写作</h2><p>纳瓦尔的写作生命公式一（2008年）这些是我写给自己的笔记。如果参照系不同，计算方法就会有所不同。这些不是定义，而是成功的算法。欢迎读者提供自己的见解。</p><p>幸福 = 健康 + 财富 + 良好的人际关系</p><p>健康 = 锻炼 + 饮食 + 睡眠</p><p>锻炼 = 高强度耐力训练 + 体育运动 + 休息</p><p>饮食 = 天然食物 + 间歇性禁食 + 植物</p><p>睡眠 = 不要闹钟 + 8～9小时 + 昼夜节律</p>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[如何给基于 Turborepo 的项目添加新应用？]]></title>
            <link>https://paragraph.com/@igaozp-2/turborepo</link>
            <guid>y7qpZHwQALfLjxBVeu4m</guid>
            <pubDate>Sun, 12 Feb 2023 03:47:18 GMT</pubDate>
            <description><![CDATA[前言阅读本文章，需要你：已经了解 Turborepo 是什么？已经使用 Turborepo 完成模板项目的初始化不知道怎么再已有的项目中添加新的应用基础概念想要在项目中添加新的应用，我们需要先看一下当前的项目目录结构。我们使用 Turborepo 初始化的项目中，会包含 apps 和 packages 目录。根据官方文档描述，这是一个约定的目录结构，简单来说：apps 目录应该包含我们通常开发的可启动的应用程序，例如 Next.js 或 Svelte 应用程序。packages 目录应该包含被其他应用依赖的包，一般是公共的模块。所以，如果我们要添加新的应用，最终的效果是要体现在 apps 目录中的。经过相关的查询和摸索，添加新应用需要如下的操作：在 apps 目录下，新建新项目的目录，目录名称不能与其他应用重复在新的应用目录下，完成新项目的初始化在整个项目的根目录下，完成整个项目的更新示例下面是以添加 Vue 应用为示例，展示整个操作流程：在 apps 目录下新建文件夹，目录名称以 vue-learn 作为示例。在 vue-learn 目录下，执行 Vue 应用的初始化脚本，这里...]]></description>
            <content:encoded><![CDATA[<h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">前言</h2><p>阅读本文章，需要你：</p><ol><li><p>已经了解 <strong>Turborepo</strong> 是什么？</p></li><li><p>已经使用 <strong>Turborepo</strong> 完成模板项目的初始化</p></li><li><p>不知道怎么再已有的项目中添加新的应用</p></li></ol><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">基础概念</h2><p>想要在项目中添加新的应用，我们需要先看一下当前的项目目录结构。我们使用 <strong>Turborepo</strong> 初始化的项目中，会包含 <code>apps</code> 和 <code>packages</code> 目录。根据官方文档描述，这是一个约定的目录结构，简单来说：</p><ul><li><p><code>apps</code> 目录应该包含我们通常开发的可启动的应用程序，例如 <strong>Next.js</strong> 或 <strong>Svelte</strong> 应用程序。</p></li><li><p><code>packages</code> 目录应该包含被其他应用依赖的包，一般是公共的模块。</p></li></ul><p>所以，如果我们要添加新的应用，最终的效果是要体现在 <strong>apps</strong> 目录中的。经过相关的查询和摸索，添加新应用需要如下的操作：</p><ol><li><p>在 <code>apps</code> 目录下，新建新项目的目录，目录名称不能与其他应用重复</p></li><li><p>在新的应用目录下，完成新项目的初始化</p></li><li><p>在整个项目的根目录下，完成整个项目的更新</p></li></ol><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">示例</h2><p>下面是以添加 <strong>Vue</strong> 应用为示例，展示整个操作流程：</p><ol><li><p>在 <code>apps</code> 目录下新建文件夹，目录名称以 <code>vue-learn</code> 作为示例。</p></li><li><p>在 <code>vue-learn</code> 目录下，执行 <strong>Vue</strong> 应用的初始化脚本，这里使用 <code>pnpm create [email protected]</code> 来初始化应用，根据相关提示完成应用的初始化。初始化完成后，目录中应该包含 <strong>Vue</strong> 项目的正常目录结构和模板代码、配置。</p></li><li><p>在整个 <strong>Turborepo</strong> 项目的根目录中（apps 目录的上一层），执行 <code>pnpm install</code>，完成整体项目的更新。</p></li><li><p>使用 <strong>Turborepo</strong> 项目中 <code>package.json</code> 自带的 <code>dev</code> 脚本，或者使用 <code>turbo run dev --parallel</code> 命令，校验新增的应用能否正常启动，如果新增应用的前端页面可以正常展示则完成整个新建流程。</p></li></ol><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">总结</h2><p>这是只是针对笔者在 Turborepo 使用过程中遇到问题的一点简单方案。其中一些概念解释和操作并不能保证是合理和正确的，只是经过自身简单的理解和实践总结的，有条件的尽量先查阅最新的官方文档和搜索信息。</p>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
            <enclosure url="https://storage.googleapis.com/papyrus_images/8485ba7c7483816c48eb7ab438d2016e253c2f1f74377bdafaf6cb2cd8d18bc0.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[《Software Engineering at Google》 笔记 01：软件工程是什么？]]></title>
            <link>https://paragraph.com/@igaozp-2/software-engineering-at-google-01</link>
            <guid>AMrVcKACPV7dkEXegbY6</guid>
            <pubDate>Fri, 18 Nov 2022 14:41:58 GMT</pubDate>
            <description><![CDATA[https://qiangmzsx.github.io/Software-Engineering-at-Google/#/zh-cn/Chapter-1_What_Is_Software_Engineering/Chapter-1_What_Is_Software_Engineering 软件工程可以被认为是 「随着时间推移而整合的编程」。 本书强调了三个基本原则，我们认为软件组织在设计、架构和编写代码时应该牢记这些原则：时间和变化 ​代码如何展期生命周期内进行适配。规模和增长 ​一个组织如何适应它的发展过程。权衡和成本 ​一个组织如何根据时间和变化以及规模和增长的经验教训做出决策。 编程和软件工程之间有三个关键的区别：时间、规模和权衡取舍。在一个软件工程项目中，工程师需要更多关注时间成本和需求变更。在软件工程中，我们需要更加关注规模和效率，无论是对我们生产的软件，还是对生产软件的组织。最后，作为软件工程师，我们被要求做出更复杂的决策，其结果风险更大，而且往往是基于对时间和规模增长的不确定性的预估。 了解时间对程序的影响的一种方法是思考「代码的预期生命周期是多少？」通常，周期短的...]]></description>
            <content:encoded><![CDATA[<p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://qiangmzsx.github.io/Software-Engineering-at-Google/#/zh-cn/Chapter-1_What_Is_Software_Engineering/Chapter-1_What_Is_Software_Engineering">https://qiangmzsx.github.io/Software-Engineering-at-Google/#/zh-cn/Chapter-1_What_Is_Software_Engineering/Chapter-1_What_Is_Software_Engineering</a></p><p>软件工程可以被认为是 <strong>「随着时间推移而整合的编程」</strong>。</p><p>本书强调了三个基本原则，我们认为软件组织在设计、架构和编写代码时应该牢记这些原则：</p><ul><li><p><strong>时间和变化</strong> ​代码如何展期生命周期内进行适配。</p></li><li><p><strong>规模和增长</strong> ​一个组织如何适应它的发展过程。</p></li><li><p><strong>权衡和成本</strong> ​一个组织如何根据时间和变化以及规模和增长的经验教训做出决策。 编程和软件工程之间有三个关键的区别：时间、规模和权衡取舍。</p></li></ul><p>在一个软件工程项目中，工程师需要更多关注时间成本和需求变更。在软件工程中，我们需要更加关注规模和效率，无论是对我们生产的软件，还是对生产软件的组织。最后，作为软件工程师，我们被要求做出更复杂的决策，其结果风险更大，而且往往是基于对时间和规模增长的不确定性的预估。</p><p>了解时间对程序的影响的一种方法是思考「代码的预期生命周期是多少？」</p><ul><li><p>通常，周期短的代码不受时间的影响。对于一个只需要存活一个小时的程序，你不太可能考虑其适应基础库、操作系统（OS）、硬件或语言版本的新版本。这些短期系统实际上“只是”一个编程问题，就像在一个维度中压缩得足够扁的立方体是正方形一样。随着我们扩大时间维度，允许更长的生命周期，改变显得更加重要。在十年或更长的时间里，大多数程序依赖关系，无论是隐式的还是显式的，都可能发生变化。这一认识是我们区分软件工程和编程的根本原因。</p></li><li><p>如果在软件的预期生命周期内，你能够对任何有价值的变化做出反应，无论是技术还是商业原因，那么你的项目是可持续的。重要的是，我们只关注能力——你可能因为缺乏价值或其他优先事项而选择不进行特定的升级。当你基本上无法对基础技术或产品方向的变化做出反应时，你就把高风险赌注押在希望这种变化永远不会变得至关重要。对于短期项目，这可能是一个安全的赌注。几十年后，情况可能并非如此。</p></li></ul><p>另一种看待软件工程的方法是考虑规模。有多少人参与？随着时间的推移，他们在开发和维护中扮演什么角色？</p><p>团队协作带来了新的问题，但也提供了比任何单个程序员更多的潜力来产生有价值的系统。</p><p>软件工程与编程的不同之处在于需要做出的决策的复杂性及其风险。在软件工程中，我们经常被迫在几个路径之间做评估和权衡，有时风险很高，而且价值指标不完善。软件工程师或软件工程负责人的工作目标是实现组织、产品和开发工作流程的可持续性和管理扩展成本为目标。考虑到这些投入，评估你的权衡并做出理性的决定。有时，我们可能会推迟维护更改，甚至接受扩展性不好的策略，因为我们知道需要重新审视这些决策。这些决策应该是明确的和清晰的递延成本。</p><p><strong>Hyrum’s Law 海勒姆定律</strong>：「当一个 API 有足够多的用户的时候，在约定中你承诺的什么都无所谓，所有在你系统里面被观察到的行为都会被一些用户直接依赖。」</p><p>对随时间变化和维护的讨论必须了解海勒姆定律，正如对效率或热力学的讨论必须注意熵一样。仅仅因为熵从不减少并不意味着我们不应该努力提高效率。在维护软件时，海勒姆定律会适用，但这并不意味着我们不能对它进行规划或试图更好地了解它。我们可以减轻它，但我们知道，它永远不可能被根除。 海勒姆定律代表了一种实践知识，即使有最好的规划、最好的工程师和可靠的代码评审实践，我们也不能假设完全遵守已发布的契约或最佳实践。作为 API 所有者，通过明确地接口约定，你将获得一定的灵活性和自由度，但在实践中，给定更改的复杂性和难度还取决于用户对你的 API 的一些可观察行为的有用程度。如果用户不能依赖这些东西，那么你的 API 将很容易更改。如果有足够的时间和足够的用户，即使是最无害的变更也会破坏某些东西；你对变更价值的分析必须包含调查、识别和解决这些缺陷的难度。</p><p>依赖其依赖性的脆弱和未发布特性的代码可能被描述为「黑客」或「聪明」遵循最佳实践并为未来规划的代码更可能被描述为「干净」和「可维护」。两者都有其目的，但你选择哪一个关键取决于所讨论代码的预期生命周期。我们常说，「如果『聪明』是一种恭维，那就是程序，如果『聪明』是一种指责，那就是软件工程。」</p><p>最初的设计可能完全符合逻辑，并遵循合理的最佳实践。只有在向后兼容的变化演变之后，新的、更有效的选择才变得重要。虽然没有犯错误，但随着时间的推移，变化仍然是有价值的。</p><p>我们的工程师的工作量是否随着组织的规模而增长？工作是否随着代码库的大小而变多？如果这两种情况都是真实的，我们是否有机制来自动化或优化这项工作？如果没有，我们就有扩展问题。 自动化（这样一个人就可以做到更多）、整合/一致性（这样低级别的更改影响有限的问题范围）和专业知识（以便少数人就可以做得更多）。</p><p>如果安全问题是在产品投入生产后才发现的，修复的成本就非常高。如果在部署到生产之前就发现了安全问题，那也需要花费大量的工作来检测和修复问题，但成本更低些。如果你能够在最初的开发之前发现安全问题，将缺陷提交到版本控制就被发现，修复的成本更低：他们已经了解该功能；根据新的安全约束规范进行开发，要比提交代码后再让其他人分类标识并修复它更简单。</p><p>我们看到的一个普遍真理是，在开发人员的工作流程中发现的问题，通常可以降低成本。考虑开发人员工作流程的时间表，从左到右，从概念和设计开始，通过实施、评审、测试、提交、金丝雀和最终的生产部署来进行。在此时间线之前，将问题发现转移到“左侧”会使修问题解决成本更低</p><p>“成本”大致可以转化为努力的方向，可以包括以下任何或所有因素：</p><ul><li><p>财务成本（如金钱）</p></li><li><p>资源成本（如CPU时间）</p></li><li><p>人员成本（例如，工作量）</p></li><li><p>交易成本（例如，采取行动的成本是多少？）</p></li><li><p>机会成本（例如，不采取行动的成本是多少？）</p></li><li><p>社会成本（例如，这个选择将对整个社会产生什么影响？）</p></li></ul><p>工程团队的决策应该归结为几件事：我们这样做是因为我们必须这么做（法律要求、客户要求）。我们之所以这样做，是因为根据当前证据，这是我们当时能看到的最佳选择（由一些适当的决策者决策）。</p><p><strong>杰文斯悖论（Jevons Paradox）</strong>：「一种资源的消耗可能会随着使用效率的提高而增加。」</p><p>时间不仅会触发技术依赖和软件系统的变化，还会触发用于驱动决策的数据的变化。</p><p>本质上，在相关系统的生命周期内，需要不时地重新审视决策。对于长期项目而言，在做出初始决策后，有能力改变方向通常是至关重要的。更重要的是，这意味着决策者需要勇气承认错误。与人的本能相反，勇于承认错误的领导人受更多的尊重。</p><p>我们认为，区分相关但不同的术语「编程」和「软件工程」是很重要的。这种差异很大程度上源于随着时间的推移对代码的管理、时间对规模的影响以及面对这些想法的决策。编程是产生代码的直接行为。软件工程是一组策略、实践和工具，这些策略、实践和工具是使代码在需要使用的时间内发挥作用，并允许整个团队的协作。</p>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[关于控制论的一些资料]]></title>
            <link>https://paragraph.com/@igaozp-2/QB8ogt2HiwWxWBJuyL6J</link>
            <guid>QB8ogt2HiwWxWBJuyL6J</guid>
            <pubDate>Thu, 02 Jun 2022 14:09:33 GMT</pubDate>
            <description><![CDATA[整理收藏的一部分关于控制论的介绍及历史的资料视频【计算机博物志·人物篇】被遗忘的科学天才：沃尔特·皮茨【游戏社会学】赛博朋克是资本主义的终极形态吗？控制论革命的残酷真相万字长文！解析阿连德政府与赛博工程的兴亡史。【合集】文章控制论恐慌和互联网的起源苏联的控制论论社会主义控制论、加速主义（Accelerationist）梦想和堤昆（Tiqqun）噩梦机器政治——互联网的兴起和威权主义的新时代“那深沉而奇异的巨壑”：自由意志主义、新自由主义和计算机文化控制论如何将计算、反主流文化和设计联系起来控制论之父今天会如何看待人工智能?苏联计算机科学的复杂历史智利的社会主义控制论——赛博协同控制工程（Cybersyn Project）的历史书籍《人有人的用处》《控制论》《工程控制论》《控制论革命者-阿连德时代智利的技术与政治》]]></description>
            <content:encoded><![CDATA[<p>整理收藏的一部分关于控制论的介绍及历史的资料</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">视频</h2><ul><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.bilibili.com/video/BV1y5411D7a6">【计算机博物志·人物篇】被遗忘的科学天才：沃尔特·皮茨</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.bilibili.com/video/BV1NK4y1L7gw?p=1&amp;totalPage=2">【游戏社会学】赛博朋克是资本主义的终极形态吗？控制论革命的残酷真相</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.bilibili.com/video/BV1pP4y1Y78V?p=1&amp;totalPage=3">万字长文！解析阿连德政府与赛博工程的兴亡史。【合集】</a></p></li></ul><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">文章</h2><ul><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://matters.news/@conanxin/51118-%E6%8E%A7%E5%88%B6%E8%AE%BA%E6%81%90%E6%85%8C%E5%92%8C%E4%BA%92%E8%81%94%E7%BD%91%E7%9A%84%E8%B5%B7%E6%BA%90-bafyreih4pfwgtvl4kif6psr56yd4yted47lvwuwwmybm7s7kw3d53cbfve">控制论恐慌和互联网的起源</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://upwikizh.top/wiki/Cybernetics_in_the_Soviet_Union">苏联的控制论</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://conanxin.medium.com/%E8%AE%BA%E7%A4%BE%E4%BC%9A%E4%B8%BB%E4%B9%89%E6%8E%A7%E5%88%B6%E8%AE%BA-%E5%8A%A0%E9%80%9F%E4%B8%BB%E4%B9%89-accelerationist-%E6%A2%A6%E6%83%B3%E5%92%8C%E5%A0%A4%E6%98%86-tiqqun-%E5%99%A9%E6%A2%A6-75841bab70f6">论社会主义控制论、加速主义（Accelerationist）梦想和堤昆（Tiqqun）噩梦</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://matters.news/@conanxin/5214-%E6%9C%BA%E5%99%A8%E6%94%BF%E6%B2%BB-%E4%BA%92%E8%81%94%E7%BD%91%E7%9A%84%E5%85%B4%E8%B5%B7%E5%92%8C%E5%A8%81%E6%9D%83%E4%B8%BB%E4%B9%89%E7%9A%84%E6%96%B0%E6%97%B6%E4%BB%A3-zdpuAxcS62nxQPuZfwKZ3nqvZf53NjfnqgF3rXgNrc4JgRu4i">机器政治——互联网的兴起和威权主义的新时代</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://matters.news/@conanxin/13224-%E9%82%A3%E6%B7%B1%E6%B2%89%E8%80%8C%E5%A5%87%E5%BC%82%E7%9A%84%E5%B7%A8%E5%A3%91-%E8%87%AA%E7%94%B1%E6%84%8F%E5%BF%97%E4%B8%BB%E4%B9%89-%E6%96%B0%E8%87%AA%E7%94%B1%E4%B8%BB%E4%B9%89%E5%92%8C%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%96%87%E5%8C%96-zdpuAxKYGcLC8TtMFkHFnpAz2GqY33FafrhLEJCNJKE4RNVY8">“那深沉而奇异的巨壑”：自由意志主义、新自由主义和计算机文化</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://matters.news/@conanxin/21075-%E6%8E%A7%E5%88%B6%E8%AE%BA%E5%A6%82%E4%BD%95%E5%B0%86%E8%AE%A1%E7%AE%97-%E5%8F%8D%E4%B8%BB%E6%B5%81%E6%96%87%E5%8C%96%E5%92%8C%E8%AE%BE%E8%AE%A1%E8%81%94%E7%B3%BB%E8%B5%B7%E6%9D%A5-zdpuB1Bw6NpBB1UH8vTjuUHS9K1DsUy6FwwmnUVj5CzNs8TJN">控制论如何将计算、反主流文化和设计联系起来</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://matters.news/@conanxin/26241-%E6%8E%A7%E5%88%B6%E8%AE%BA%E4%B9%8B%E7%88%B6%E4%BB%8A%E5%A4%A9%E4%BC%9A%E5%A6%82%E4%BD%95%E7%9C%8B%E5%BE%85%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD-bafyreicbtrf6fr3hjli2jyjs4ejgf5ddorsoe3fjaohxtpdxchslcv6t7m">控制论之父今天会如何看待人工智能?</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://matters.news/@conanxin/50456-%E8%8B%8F%E8%81%94%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6%E7%9A%84%E5%A4%8D%E6%9D%82%E5%8E%86%E5%8F%B2-bafyreidmudj5hztmtaw7wqnabr6xc4z4xa4evnwquntpl74mk5nd5s4zre">苏联计算机科学的复杂历史</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://matters.news/@conanxin/55277-%E6%99%BA%E5%88%A9%E7%9A%84%E7%A4%BE%E4%BC%9A%E4%B8%BB%E4%B9%89%E6%8E%A7%E5%88%B6%E8%AE%BA-%E8%B5%9B%E5%8D%9A%E5%8D%8F%E5%90%8C%E6%8E%A7%E5%88%B6%E5%B7%A5%E7%A8%8B-cybersyn-project-%E7%9A%84%E5%8E%86%E5%8F%B2-bafyreiby3fpz3wqyghbonnuhticzitdbxc5etahqk4w6yefzmbyzro7tfa">智利的社会主义控制论——赛博协同控制工程（Cybersyn Project）的历史</a></p></li></ul><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">书籍</h2><ul><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://book.douban.com/subject/4928961/">《人有人的用处》</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://book.douban.com/subject/2356843/">《控制论》</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://book.douban.com/subject/1967264/">《工程控制论》</a></p></li><li><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://book.douban.com/subject/34998217/">《控制论革命者-阿连德时代智利的技术与政治》</a></p></li></ul>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[IdeaVim 自用配置分享]]></title>
            <link>https://paragraph.com/@igaozp-2/ideavim</link>
            <guid>80MYsOrSYm16Xw2tUugJ</guid>
            <pubDate>Wed, 05 Jan 2022 13:13:48 GMT</pubDate>
            <description><![CDATA[let mapleader = " " set clipboard=unnamedplus,unnamed set hlsearch set incsearch set ignorecase set smartcase set showmode set number set scrolloff=3 set history=100000 set multiple-cursors set commentary set easymotion set exchange set surround set ideajoin set clipboard+=ideaput set ideamarks set keep-english-in-normal-and-restore-in-insert set relativenumber set highlightedyank set NERDTree set showmode set so=5 set incsearch set nu set idearefactormode=keep set ideavimsupport let g:EasyMo...]]></description>
            <content:encoded><![CDATA[<pre data-type="codeBlock" text="let mapleader = &quot; &quot;

set clipboard=unnamedplus,unnamed
set hlsearch
set incsearch
set ignorecase
set smartcase
set showmode
set number
set scrolloff=3
set history=100000
set multiple-cursors
set commentary
set easymotion
set exchange
set surround
set ideajoin
set clipboard+=ideaput
set ideamarks
set keep-english-in-normal-and-restore-in-insert
set relativenumber
set highlightedyank
set NERDTree
set showmode
set so=5
set incsearch
set nu
set idearefactormode=keep
set ideavimsupport

let g:EasyMotion_override_acejump = 0
let g:argtextobj_pairs=&quot;[:],(:),&lt;:&gt;&quot;

map &lt;leader&gt;a :action $SelectAll&lt;CR&gt;
map &lt;leader&gt;x :action $Cut&lt;CR&gt;
map &lt;leader&gt;c :action $Copy&lt;CR&gt;
map &lt;leader&gt;z :action $Undo&lt;CR&gt;
map &lt;leader&gt;v :action $Paste&lt;CR&gt;

nnoremap &lt;esc&gt;&lt;esc&gt; :noh&lt;return&gt;
nnoremap gd :action GotoDeclaration
nnoremap ,e :action SearchEverywhere&lt;CR&gt;
nnoremap ,g :action FindInPath&lt;CR&gt;
nnoremap ,s :action FileStructurePopup&lt;CR&gt;

nnoremap gd :action GotoDeclaration&lt;CR&gt;
nnoremap gs :action GotoSuperMethod&lt;CR&gt;
nnoremap gi :action GotoImplementation&lt;CR&gt;
nnoremap gb :action JumpToLastChange&lt;CR&gt;

nnoremap U :action FindUsages&lt;CR&gt;
nnoremap R :action RenameElement&lt;CR&gt;

nnoremap == :action ReformatCode&lt;CR&gt;
vnoremap == :action ReformatCode&lt;CR&gt;

nnoremap [] :action OptimizeImports&lt;CR&gt;
vnoremap [] :action OptimizeImports&lt;CR&gt;

nnoremap cc :action CommentByLineComment&lt;CR&gt;
vnoremap cc :action CommentByLineComment&lt;CR&gt;

nnoremap &lt;C-CR&gt; :action ShowIntentionActions&lt;CR&gt;

nnoremap ,a :action GotoAction&lt;CR&gt;
vnoremap ,a :action GotoAction&lt;CR&gt;

xnoremap p &quot;0p
xnoremap p &quot;_dP

&quot; 搜索文件相关
nnoremap &lt;leader&gt;zc :action GotoClass&lt;CR&gt;
vnoremap &lt;leader&gt;zc :action GotoClass&lt;CR&gt;
nnoremap &lt;leader&gt;za :action GotoAction&lt;CR&gt;
nnoremap &lt;leader&gt;zh :action RecentChangedFiles&lt;CR&gt;
nnoremap &lt;leader&gt;zf :action GotoFile&lt;CR&gt;
nnoremap &lt;leader&gt;zd :action ActivateDebugToolWindow&lt;CR&gt;
nnoremap &lt;leader&gt;zr :action ActivateRunToolWindow&lt;CR&gt;
nnoremap &lt;leader&gt;zs :action ShelvedChangesToolbar&lt;CR&gt;
nnoremap &lt;leader&gt;zt :action ActivateTODOToolWindow&lt;CR&gt;
nnoremap &lt;leader&gt;zv :action ActivateVersionControlToolWindow&lt;CR&gt;
nnoremap &lt;leader&gt;zb :action ShowBookmarks&lt;CR&gt;
nnoremap &lt;leader&gt;zp :action ActivateProjectToolWindow&lt;CR&gt;

nnoremap &lt;Leader&gt;o :&lt;C-u&gt;action RecentProjectListGroup&lt;CR&gt;
noremap &lt;Space&gt;p :action SelectInProjectView&lt;CR&gt;
"><code>let mapleader <span class="hljs-operator">=</span> <span class="hljs-string">" "</span>

set clipboard<span class="hljs-operator">=</span>unnamedplus,unnamed
set hlsearch
set incsearch
set ignorecase
set smartcase
set showmode
set number
set scrolloff<span class="hljs-operator">=</span><span class="hljs-number">3</span>
set history<span class="hljs-operator">=</span><span class="hljs-number">100000</span>
set multiple<span class="hljs-operator">-</span>cursors
set commentary
set easymotion
set exchange
set surround
set ideajoin
set clipboard<span class="hljs-operator">+</span><span class="hljs-operator">=</span>ideaput
set ideamarks
set keep<span class="hljs-operator">-</span>english<span class="hljs-operator">-</span>in<span class="hljs-operator">-</span>normal<span class="hljs-operator">-</span>and<span class="hljs-operator">-</span>restore<span class="hljs-operator">-</span>in<span class="hljs-operator">-</span>insert
set relativenumber
set highlightedyank
set NERDTree
set showmode
set so<span class="hljs-operator">=</span><span class="hljs-number">5</span>
set incsearch
set nu
set idearefactormode<span class="hljs-operator">=</span>keep
set ideavimsupport

let g:EasyMotion_override_acejump <span class="hljs-operator">=</span> <span class="hljs-number">0</span>
let g:argtextobj_pairs<span class="hljs-operator">=</span><span class="hljs-string">"[:],(:),&#x3C;:>"</span>

map <span class="hljs-operator">&#x3C;</span>leader<span class="hljs-operator">></span>a :action $SelectAll<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
map <span class="hljs-operator">&#x3C;</span>leader<span class="hljs-operator">></span>x :action $Cut<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
map <span class="hljs-operator">&#x3C;</span>leader<span class="hljs-operator">></span>c :action $Copy<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
map <span class="hljs-operator">&#x3C;</span>leader<span class="hljs-operator">></span>z :action $Undo<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
map <span class="hljs-operator">&#x3C;</span>leader<span class="hljs-operator">></span>v :action $Paste<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap <span class="hljs-operator">&#x3C;</span>esc<span class="hljs-operator">></span><span class="hljs-operator">&#x3C;</span>esc<span class="hljs-operator">></span> :noh<span class="hljs-operator">&#x3C;</span><span class="hljs-keyword">return</span><span class="hljs-operator">></span>
nnoremap gd :action GotoDeclaration
nnoremap ,e :action SearchEverywhere<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
nnoremap ,g :action FindInPath<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
nnoremap ,s :action FileStructurePopup<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap gd :action GotoDeclaration<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
nnoremap gs :action GotoSuperMethod<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
nnoremap gi :action GotoImplementation<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
nnoremap gb :action JumpToLastChange<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap U :action FindUsages<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
nnoremap R :action RenameElement<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap <span class="hljs-operator">=</span><span class="hljs-operator">=</span> :action ReformatCode<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
vnoremap <span class="hljs-operator">=</span><span class="hljs-operator">=</span> :action ReformatCode<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap [] :action OptimizeImports<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
vnoremap [] :action OptimizeImports<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap cc :action CommentByLineComment<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
vnoremap cc :action CommentByLineComment<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap <span class="hljs-operator">&#x3C;</span>C<span class="hljs-operator">-</span>CR<span class="hljs-operator">></span> :action ShowIntentionActions<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

nnoremap ,a :action GotoAction<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>
vnoremap ,a :action GotoAction<span class="hljs-operator">&#x3C;</span>CR<span class="hljs-operator">></span>

xnoremap p <span class="hljs-string">"0p
xnoremap p "</span>_dP

<span class="hljs-string">" 搜索文件相关
nnoremap &#x3C;leader>zc :action GotoClass&#x3C;CR>
vnoremap &#x3C;leader>zc :action GotoClass&#x3C;CR>
nnoremap &#x3C;leader>za :action GotoAction&#x3C;CR>
nnoremap &#x3C;leader>zh :action RecentChangedFiles&#x3C;CR>
nnoremap &#x3C;leader>zf :action GotoFile&#x3C;CR>
nnoremap &#x3C;leader>zd :action ActivateDebugToolWindow&#x3C;CR>
nnoremap &#x3C;leader>zr :action ActivateRunToolWindow&#x3C;CR>
nnoremap &#x3C;leader>zs :action ShelvedChangesToolbar&#x3C;CR>
nnoremap &#x3C;leader>zt :action ActivateTODOToolWindow&#x3C;CR>
nnoremap &#x3C;leader>zv :action ActivateVersionControlToolWindow&#x3C;CR>
nnoremap &#x3C;leader>zb :action ShowBookmarks&#x3C;CR>
nnoremap &#x3C;leader>zp :action ActivateProjectToolWindow&#x3C;CR>

nnoremap &#x3C;Leader>o :&#x3C;C-u>action RecentProjectListGroup&#x3C;CR>
noremap &#x3C;Space>p :action SelectInProjectView&#x3C;CR>
</span></code></pre>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[可组合性是 VIM 最强大的理念]]></title>
            <link>https://paragraph.com/@igaozp-2/vim</link>
            <guid>z1H5xFfSJTEx0QrQOZGv</guid>
            <pubDate>Wed, 05 Jan 2022 13:13:29 GMT</pubDate>
            <description><![CDATA[个人认为 VIM 中各种指令的可组合性，是 VIM 保持经久不衰的最深层次的源泉，是实现各种高效操作的基石。 使用过 VIM 的人都知道，可以使用简短的 VIM 快捷键完成一些相对复杂的操作。以个人经常使用的快捷键 ciw 为例，ciw 并不是一个完整独立的命令，而是由 c、i、w 这 3 个命令组合起来，其中 c 为 Change 即修改，i 为 Inner 即内部，w 为 Word 即单词，整个命令组合并直译过来，即为“修改内部的单词”，实际上的效果是修改当前光标选中的单词。正是因为这些原子命令的可组合性，允许这些命令可以有机地结合，实现 1+1 > 2 的效果。一旦这种可组合性的特性让使用者产生印象，便会给人一种这样的隐喻：「组合中的指令是可以替换的」，使用者可能会通过自己的想法，在可组合的规则内自由的尝试其他的组合。例如将 ciw 中的 c 替换为 d，diw 这个指令即代表删除当前光标所在的单词，如果替换为 y，yiw 即代表复制当前光标所在的单词。VIM 在这样用户的自由地实践中，通常会诞生一些连作者都未曾设想的操作，这使得 VIM 在用户的使用「迭代」中迸发出惊人的...]]></description>
            <content:encoded><![CDATA[<p>个人认为 <strong>VIM</strong> 中各种指令的可组合性，是 <strong>VIM</strong> 保持经久不衰的最深层次的源泉，是实现各种高效操作的基石。</p><p>使用过 <strong>VIM</strong> 的人都知道，可以使用简短的 <strong>VIM</strong> 快捷键完成一些相对复杂的操作。以个人经常使用的快捷键 <code>ciw</code> 为例，<code>ciw</code> 并不是一个完整独立的命令，而是由 <em>c</em>、<em>i</em>、<em>w</em> 这 3 个命令组合起来，其中 <em>c</em> 为 Change 即修改，<em>i</em> 为 Inner 即内部，<em>w</em> 为 Word 即单词，整个命令组合并直译过来，即为“修改内部的单词”，实际上的效果是修改当前光标选中的单词。正是因为这些原子命令的可组合性，允许这些命令可以有机地结合，实现 1+1 &gt; 2 的效果。一旦这种可组合性的特性让使用者产生印象，便会给人一种这样的隐喻：「组合中的指令是可以替换的」，使用者可能会通过自己的想法，在可组合的规则内自由的尝试其他的组合。例如将 <code>ciw</code> 中的 <em>c</em> 替换为 <em>d</em>，<code>diw</code> 这个指令即代表删除当前光标所在的单词，如果替换为 <em>y</em>，<code>yiw</code> 即代表复制当前光标所在的单词。<strong>VIM</strong> 在这样用户的自由地实践中，通常会诞生一些连作者都未曾设想的操作，这使得 <strong>VIM</strong> 在用户的使用「迭代」中迸发出惊人的生产力。</p><p>可组合性不仅仅是 <strong>VIM</strong> 中最强大的理念，同时也是软件领域最为强大的武器。</p><ol><li><p>编程语言只提供少量的关键词及对应的约束规则，使用有限的元件「组合」出可运行的程序。</p></li><li><p>UNIX 中通过管道（pipe）将功能不同的程序组合成一个整体实现复杂的数据操作。</p></li><li><p>互联网中使用不同的通信协议或者 API 将不同的软件和服务组合起来，实现更加复杂的互动结构。</p></li></ol>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[Spring Boot 中实现服务端主动数据推送]]></title>
            <link>https://paragraph.com/@igaozp-2/spring-boot</link>
            <guid>Y4JO6bGQEhAIylIroKac</guid>
            <pubDate>Wed, 05 Jan 2022 13:12:09 GMT</pubDate>
            <description><![CDATA[在日常开发中通常使用 WebSocket 实现服务端的主动地数据推送，这里简单介绍两种其他的数据推送方案，ndjson 和 SSE。ndjsonndjson 全称 Newline Delimited JSON，即使用换行符分割的 JSON，同时能够保证每一行的内容都是一个完整的 JSON。这里使用 ndjson 并不是因为它可以实现服务端数据推送，而是凭借 ndjson 的数据格式的特性，作为服务端的 JSON 数据流的数据输出，来更好地帮助我们实现数据推送的效果。 这里使用 Spring Boot 作为基础的服务端框架，简单演示一下相关代码及功能。首先要确保项目依赖中包含 spring-boot-starter-webflux 依赖包。 代码示例@GetMapping(value = "ndjson", produces = MediaType.APPLICATION_NDJSON_VALUE) Flux&#x3C;Data> ndjson() { return dataStream(); } private Flux&#x3C;Data> dataStream() { ret...]]></description>
            <content:encoded><![CDATA[<p>在日常开发中通常使用 <code>WebSocket</code> 实现服务端的主动地数据推送，这里简单介绍两种其他的数据推送方案，<code>ndjson</code> 和 <code>SSE</code>。</p><h2 id="h-ndjson" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">ndjson</h2><p><strong>ndjson</strong> 全称 <strong>Newline Delimited JSON</strong>，即使用换行符分割的 JSON，同时能够保证每一行的内容都是一个完整的 JSON。这里使用 ndjson 并不是因为它可以实现服务端数据推送，而是凭借 <strong>ndjson</strong> 的数据格式的特性，作为服务端的 JSON 数据流的数据输出，来更好地帮助我们实现数据推送的效果。</p><p>这里使用 <strong>Spring Boot</strong> 作为基础的服务端框架，简单演示一下相关代码及功能。首先要确保项目依赖中包含 <code>spring-boot-starter-webflux</code> 依赖包。</p><p>代码示例</p><pre data-type="codeBlock" text="@GetMapping(value = &quot;ndjson&quot;, produces = MediaType.APPLICATION_NDJSON_VALUE)
Flux&lt;Data&gt; ndjson() {
    return dataStream();
}

private Flux&lt;Data&gt; dataStream() {
    return Flux.interval(Duration.ofSeconds(1))
            .take(5)
            .map(i -&gt; new Data(i, Instant.now()));
}
"><code>@GetMapping(value <span class="hljs-operator">=</span> <span class="hljs-string">"ndjson"</span>, produces <span class="hljs-operator">=</span> MediaType.APPLICATION_NDJSON_VALUE)
Flux<span class="hljs-operator">&#x3C;</span>Data<span class="hljs-operator">></span> ndjson() {
    <span class="hljs-keyword">return</span> dataStream();
}

<span class="hljs-keyword">private</span> Flux<span class="hljs-operator">&#x3C;</span>Data<span class="hljs-operator">></span> dataStream() {
    <span class="hljs-keyword">return</span> Flux.interval(Duration.ofSeconds(<span class="hljs-number">1</span>))
            .take(<span class="hljs-number">5</span>)
            .map(i <span class="hljs-operator">-</span><span class="hljs-operator">></span> <span class="hljs-keyword">new</span> Data(i, Instant.now()));
}
</code></pre><p>代码中定义了一个私有方法用来生成数据流，效果是每隔 1 秒生成一条数据。在 <code>@GetMapping</code>中指定了 <code>MediaType.APPLICATION_NDJSON_VALUE</code> 作为数据的响应格式。</p><h2 id="h-sse" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">SSE</h2><p><strong>SSE</strong> 全称 <strong>Server-sent events</strong>，即服务器发送事件，服务端可使用 <strong>SSE</strong> 生成相应的数据流。</p><p>代码示例，同样需要 <strong>WebFlux</strong> 支持。</p><pre data-type="codeBlock" text="@GetMapping(value = &quot;sse&quot;, produces = MediaType.TEXT_EVENT_STREAM_VALUE)
Flux&lt;Data&gt; sse() {
    return dataStream();
}

private Flux&lt;Data&gt; dataStream() {
   return Flux.interval(Duration.ofSeconds(1))
            .take(5)
            .map(i -&gt; new Data(i, Instant.now()));
}
"><code>@GetMapping(value <span class="hljs-operator">=</span> <span class="hljs-string">"sse"</span>, produces <span class="hljs-operator">=</span> MediaType.TEXT_EVENT_STREAM_VALUE)
Flux<span class="hljs-operator">&#x3C;</span>Data<span class="hljs-operator">></span> sse() {
    <span class="hljs-keyword">return</span> dataStream();
}

<span class="hljs-keyword">private</span> Flux<span class="hljs-operator">&#x3C;</span>Data<span class="hljs-operator">></span> dataStream() {
   <span class="hljs-keyword">return</span> Flux.interval(Duration.ofSeconds(<span class="hljs-number">1</span>))
            .take(<span class="hljs-number">5</span>)
            .map(i <span class="hljs-operator">-</span><span class="hljs-operator">></span> <span class="hljs-keyword">new</span> Data(i, Instant.now()));
}
</code></pre><p>与 <strong>ndjson</strong> 方案唯一的不同是，数据响应的格式替换为了<code>MediaType.TEXT_EVENT_STREAM_VALUE</code>。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">总结</h2><p>虽然 <strong>ndjson</strong> 和 <strong>SSE</strong> 方案都可以实现服务端的数据推送，但这两种的数据通信都是单向通信，只能从服务端到客户端，无法实现双向通信，需要根据自身的场景需要酌情考虑使用。</p><p>项目的完整代码可参考 <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://github.com/igaozp/surabaya/blob/f8cc3573759ac22f63801e54edde563f6706a1ec/spring/src/main/java/xyz/andornot/controller/StreamJsonController.java">StreamJsonController</a>。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">参考内容</h2><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://nurkiewicz.com/2021/08/json-streaming-in-webflux.html">https://nurkiewicz.com/2021/08/json-streaming-in-webflux.html</a></p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.ruanyifeng.com/blog/2017/05/server-sent_events.html">https://www.ruanyifeng.com/blog/2017/05/server-sent_events.html</a></p>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[【Java 回炉计划】01：基础知识流水账]]></title>
            <link>https://paragraph.com/@igaozp-2/java-01</link>
            <guid>I2s8G1GNBcfQMtWifkRr</guid>
            <pubDate>Wed, 05 Jan 2022 13:11:37 GMT</pubDate>
            <description><![CDATA[详细内容可参考大佬整理的资料 Java 拾遗卷1：语言特性 · 语雀，以下的内容是从个人角度觉得需要额外记录的内容。面向对象里氏代换原则（Liskov Substitution Principle, LSP）：凡是父类能够出现的地方，都可以用子类替换。 多态是一种允许子类或接口可以有多种实现的特性，这种特性使得代码在运行时，同一个行为可能在不同的情况下，具有不同的表现形式。 子类 Override 父类方法时需要满足以下 4 个条件：方法的访问权限不能变小（private < package < protected < public）。返回类型能够向上转型成为父类的返回类型。异常也要能向上转型成为父类的异常。方法名、参数类型及个数必须严格一致。把这个案例看明白：class A { public void m(A a) { System.out.println("AA"); } public void m(D d) { System.out.println("AD"); } } class B extends A { @Override public void m(A a) { S...]]></description>
            <content:encoded><![CDATA[<p>详细内容可参考大佬整理的资料 <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.yuque.com/inuter/nghb49">Java 拾遗卷1：语言特性 · 语雀</a>，以下的内容是从个人角度觉得需要额外记录的内容。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">面向对象</h2><p><strong>里氏代换原则</strong>（Liskov Substitution Principle, LSP）：凡是父类能够出现的地方，都可以用子类替换。</p><p>多态是一种允许子类或接口可以有多种实现的特性，这种特性使得代码在运行时，同一个行为可能在不同的情况下，具有不同的表现形式。</p><p>子类 <code>Override</code> 父类方法时需要满足以下 4 个条件：</p><ol><li><p>方法的访问权限不能变小（private &lt;  package &lt; protected &lt; public）。</p></li><li><p>返回类型能够向上转型成为父类的返回类型。</p></li><li><p>异常也要能向上转型成为父类的异常。</p></li><li><p>方法名、参数类型及个数必须严格一致。</p></li></ol><p>把这个案例看明白：</p><pre data-type="codeBlock" text="class A {
    public void m(A a) {
        System.out.println(&quot;AA&quot;);
    }

    public void m(D d) {
        System.out.println(&quot;AD&quot;);
    }
}

class B extends A {
    @Override
    public void m(A a) {
        System.out.println(&quot;BA&quot;);
    }

    public void m(B b) {
        System.out.println(&quot;BD&quot;);
    }
}

class C extends B {
}

class D extends B {
}

public class Test {

    public static void main(String[] args) {
        A a = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        a.m(a); // BA
        a.m(b); // BA
        a.m(c); // BA
        a.m(d); // AD
    }
}
"><code><span class="hljs-keyword">class</span> <span class="hljs-title class_">A</span> {
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">m</span><span class="hljs-params">(A a)</span> {
        System.out.println(<span class="hljs-string">"AA"</span>);
    }

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">m</span><span class="hljs-params">(D d)</span> {
        System.out.println(<span class="hljs-string">"AD"</span>);
    }
}

<span class="hljs-keyword">class</span> <span class="hljs-title class_">B</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_">A</span> {
    <span class="hljs-meta">@Override</span>
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">m</span><span class="hljs-params">(A a)</span> {
        System.out.println(<span class="hljs-string">"BA"</span>);
    }

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">m</span><span class="hljs-params">(B b)</span> {
        System.out.println(<span class="hljs-string">"BD"</span>);
    }
}

<span class="hljs-keyword">class</span> <span class="hljs-title class_">C</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_">B</span> {
}

<span class="hljs-keyword">class</span> <span class="hljs-title class_">D</span> <span class="hljs-keyword">extends</span> <span class="hljs-title class_">B</span> {
}

<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title class_">Test</span> {

    <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">main</span><span class="hljs-params">(String[] args)</span> {
        <span class="hljs-type">A</span> <span class="hljs-variable">a</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">B</span>();
        <span class="hljs-type">B</span> <span class="hljs-variable">b</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">B</span>();
        <span class="hljs-type">C</span> <span class="hljs-variable">c</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">C</span>();
        <span class="hljs-type">D</span> <span class="hljs-variable">d</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">D</span>();
        a.m(a); <span class="hljs-comment">// BA</span>
        a.m(b); <span class="hljs-comment">// BA</span>
        a.m(c); <span class="hljs-comment">// BA</span>
        a.m(d); <span class="hljs-comment">// AD</span>
    }
}
</code></pre><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">类</h2><p>普通的内部类可以与外部类互相访问私有属性。</p><p>构造方法调用的途径：</p><ul><li><p>通过 <code>new</code> 关键字</p></li><li><p>在子类的构造方法通过 <code>super</code> 关键字调用父类的构造方法</p></li><li><p>通过反射的方式获取并调用</p></li></ul><p>在创建类对象时，会先执行父类和子类的静态代码块，然后再执行父类和子类的构造方法。另外，静态代码块只会执行一次，而构造方法在每次实例化对象时都会被执行。</p><h2 id="h-and" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">接口&amp;注解</h2><p>注解是一种接口，但使用 <code>@interface</code> 修饰符修饰。</p><ul><li><p><code>@Target</code> 注解用于限定注解的适用范围</p></li><li><p><code>@Retention</code> 注解用于表示一个注解保存到哪个阶段</p></li><li><p><code>@Inherited</code> 注解仅作用于类，默认情况下，父类的普通注解不能被子类继承，但如果父类的注解被 <code>@Inherited</code> 注解修饰，则该注解可以被子类自动继承。</p></li></ul><p>Java 8 新增了一个 <code>@Repeatable</code> 元注解，使得某些注解可在同一元素上修饰多次。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">常用数据类型及问题</h2><p>Java 语言规范中并没有规定 <code>boolean</code> 类型数据的大小，其大小与 JVM 有关。</p><p>子类对象允许转换为父类对象，但父类对象不允许强制转换为子类对象。</p><p>由于计算机无法准确表示浮点数，<code>BigDemical</code> 不要使用入参为 <code>double</code> 类型的构造方法，而优先使用入参为 <code>String</code> 类型的构造方法。</p><p><code>RoundingMode</code> 类</p><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.yuque.com/inuter/nghb49/gakkv5?inner=g5LDq">https://www.yuque.com/inuter/nghb49/gakkv5?inner=g5LDq</a></p><p><code>BigDecimal</code> 类重写了 <code>equals</code> 方法，当且仅当两个 <code>BigDecimal</code> 对象表示的数值和 <code>scale</code> 都相同时，返回为 <code>true</code> ，如果两个对象表示的数值相同，但 <code>scale</code> 不同，返回 <code>false</code>。</p><p>如果希望只比较两个对象表示的数值，可以使用 <code>compareTo()</code> 方法</p><p>所有包装类都是 <strong>immutable</strong> 的（不可修改，不可继承），自动装箱都是通过包装类的 <code>valueOf()</code> 方法实现的，自动拆箱都是通过包装类的 <code>xxxValue()</code> 方法实现的。只有在自动装箱时（即调用 <code>valueOf()</code> 方法），相应的缓存机制才会生效。</p><p>对于 <code>表达式 1 ？ 表达式 2 ： 表达式 3</code> ，如果 <code>表达式 2</code> 和 <code>表达式 3</code> 有一项是基本数据类型，而另一项是对应的包转类型，那么包装类型的结果应该自动拆箱。</p><h2 id="h-string" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">String</h2><p>先看如下代码，判断变量 <code>str1</code> 和 <code>str2</code> 的值分别为什么？</p><pre data-type="codeBlock" text="String str1 = 1 + 2 + &quot;3&quot;;	// 33
String str2 = &quot;1&quot; + 2 + 3;	// 123
"><code>String str1 <span class="hljs-operator">=</span> <span class="hljs-number">1</span> <span class="hljs-operator">+</span> <span class="hljs-number">2</span> <span class="hljs-operator">+</span> <span class="hljs-string">"3"</span>;	<span class="hljs-comment">// 33</span>
String str2 <span class="hljs-operator">=</span> <span class="hljs-string">"1"</span> <span class="hljs-operator">+</span> <span class="hljs-number">2</span> <span class="hljs-operator">+</span> <span class="hljs-number">3</span>;	<span class="hljs-comment">// 123</span>
</code></pre><p>如果用 <code>+</code> 操作符进行拼接时，拼接对象包含其它类型的常量。则左边第一个字符串常量前的所有 <code>+</code> 操作符都会视为加运算。</p><p>在循环体内，字符串的链接方法应该使用 <code>StringBuilder</code> 的 <code>append</code> 方法，而不是使用 <code>+</code> 操作符。</p><p>字符串的长度等于字符串所包含的 Unicode 代码点总数，即 length() 方法返回的是 Unicode 代码点总数。</p><p><strong>代码点</strong>（<em>code point</em>）是 Unicode 独有的定义，最简单的理解是：Unicode 中的每个字符都是一个代码点。说白了就是，“字符”在 Unicode 中被称为“代码点”。</p><p><strong>代码单元</strong>（<em>code unit</em>）是代码点的最小组成单位，可以理解为“一个代码点是由多个代码单元组成的”。根据一个代码单元所占内存的大小，可以分为 UTF-8、UTF-16、UTF-32。比如 UTF-8 就表示一个代码单元占用 8 个 bit，即 1 个字节。</p><p>那对于 UTF-8 来说，一个字符（或代码点）包含几个代码单元呢，答案是 1 - 4 个代码单元。这类似于计算机组成原理中说的“变长编码”或“赫夫曼编码”，中心思想是“使用频率较高的字符的编码长度尽可能的小”。</p><ul><li><p>UTF-8：一个代码点可能由 1- 4 个代码单元组成，一个代码单元占用 1 个字节；</p></li><li><p>UTF-16：一个代码点可能由 1- 2 个代码单元组成，一个代码单元占用 2 个字节；</p></li><li><p>UTF-32：一个代码点由 1 个代码单元组成，一个代码单元占用 4 个字节。</p></li></ul><h2 id="h-jvm" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">JVM</h2><h3 id="h-" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>静态常量池</strong></h3><p>静态常量池也称为 <strong>class 文件常量池</strong>，它是指 class 文件中的 <strong>Contant Pool</strong> 结构，可以通过 <code>javap -verbose</code> 工具反编译 class 文件查看。</p><p>静态常量池只是 class 文件的一个部分，仅存在于 class 文件中，与 JVM 无关。静态常量池用于存放编译阶段生成的各种<strong>字面量</strong>和<strong>符号引用</strong>。</p><p><strong>字面量</strong>包括字符串（如 String str = “a”）、基本类型的常量（即 <code>final</code> 修饰的变量）。<strong>符号引用</strong>包括类和方法的全限定名（如 <code>String</code> 类的全限定名为 <code>java/lang/String</code>）、字段的名称和描述符、方法的名称和描述符。</p><h3 id="h-" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>运行时常量池</strong></h3><p>运行时常量池是方法区的一部分，全局共享。</p><p>当类被加载到内存中时，JVM 会将 class 文件中的静态常量池内容加载到运行时常量池中。在解析阶段，JVM 会把符号引用替换为直接引用（对象的索引值）。</p><h3 id="h-" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>字符串常量池</strong></h3><p>字符串常量池也是方法区的一部分，全局共享。可以认为字符串常量池是一个对 <code>String</code> 进行缓存的结构。</p><h3 id="h-and" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>方法区&amp;永久代</strong></h3><p>**方法区（Method Area）**是 Java 虚拟机规范中的一个概念，主要用来存放已被虚拟机加载的类的相关信息，包括类的信息、运行时常量池、字符串常量池等。</p><p>但 Java 虚拟机规范并未规定如何实现方法区，而常用的 <strong>HotSpot</strong> 虚拟机使用永久代（<strong>PermGen</strong>）来实现方法区，所以习惯将方法区称为永久代，但其实这两者并不等价。</p><h2 id="h-object" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Object 类</h2><p><code>wait()</code><strong> 方法和 </strong><code>Thread.sleep()</code><strong> 方法有什么区别</strong> ？</p><ul><li><p><code>sleep()</code> 是 <code>Thread</code> 类中的静态方法，而 <code>wait()</code> 是 <code>Object</code> 类中本地方法；</p></li><li><p><code>sleep()</code> 不会释放锁，而 <code>wait()</code> 会释放，并自动加入到等待队列中；</p></li><li><p><code>sleep()</code> 不依赖于 synchronized 关键字，但 <code>wait()</code> 依赖，即 <code>wait()</code> 只能在 synchronized 块内使用；</p></li><li><p><code>sleep()</code> 不需要被主动唤醒（休眠之后退出阻塞），但 <code>wait()</code> 需要使用 <code>notify()</code> / <code>notifyAll()</code> 唤醒。</p></li></ul><p>Java 语言规范规定 <code>equals()</code> 方法必须具备以下几个特性：</p><ul><li><p><strong>自反性</strong>：如果 <code>x</code> 不为 <code>null</code> ， <code>x.equals(x)</code> 返回 <code>true</code> （ <code>x.equals(null)</code> 返回 <code>false</code> ）</p></li><li><p><strong>对称性</strong>：如果 <code>x.equals(y)</code> 为 <code>true</code> ，则 <code>y.equals(x)</code> 为 <code>true</code></p></li><li><p><strong>传递性</strong>：如果 <code>x.equals(y)</code> 为 <code>true</code> 且 <code>y.equals(z)</code> 为 <code>true</code> ，则 <code>x.equals(z)</code> 为 <code>true</code></p></li><li><p><strong>一致性</strong>：如果 <code>x</code> 和 <code>y</code> 未修改，则 <code>x.equals(y)</code> 的结果应该不变</p></li></ul><p><strong>equals 与 hashCode 默认原则</strong></p><ul><li><p>只要重写 <code>equals</code> ，就必须重写 <code>hashCode</code></p></li><li><p>如果 <code>equals()</code> 返回 <code>true</code>，则 <code>hashCode()</code> 必须也返回 <code>true</code></p></li><li><p>如果 <code>equals()</code> 返回 <code>false</code>，那 <code>hashCode()</code> 可以返回 <code>true</code> 或 <code>false</code></p></li><li><p>因为 <code>Set</code> 存储的是不重复的对象，依据 <code>hashCode</code> 和 <code>equals</code> 进行判断，所以 <code>Set</code> 存储的对象必须重写这两个方法</p></li><li><p>如果自定义对象作为 <code>Map</code> 的 key，那么必须重写这两个方法</p></li></ul><p><strong>equals 方法重写流程</strong></p><ol><li><p>可以先进行指针判断，如果是同一个对象，则直接返回 <code>true</code> ；</p></li><li><p>判断传入的参数是否为 <code>null</code> ，如果是，直接返回 <code>false</code> ；</p></li><li><p>判断两个对象的类型是否相同，如果不同，直接返回 <code>false</code> ；</p></li><li><p>在确保类型相同的前提下进行强制类型转换，再对逐一对字段进行比较。</p></li></ol><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">泛型</h2><p>泛型本质是类型参数化，其与 JVM 无关，仅在编译时做语法检查，编译后被替换，这就是所谓的“类型擦除”。对于类型擦除，总结为一句话就是：<strong>无边界，替换为 Object ；有边界，替换为边界</strong>。</p><p>在编译一个泛型子类或泛型接口实现类时，编译器可能会生成一个 synthetic method，这种方法就叫桥接方法（bridge method）。桥接方法的出现是为了解决类型擦除对多态的破坏。</p><p><strong>正确理解 &lt;? extends T&gt; 与 &lt;? super T&gt;</strong></p><ul><li><p><code>&lt;? extends T&gt;</code> 表示对象要么是 T 类型，要么是 T 的子类；</p></li><li><p><code>&lt;? super T&gt;</code> 表示对象要么是 T 类型，要么是 T 的父类。</p></li></ul><p><strong>如何选择 &lt;? extends T&gt; 和 &lt;? super T&gt;</strong></p><ul><li><p><strong>不论是 </strong><code>&lt;? extends T&gt;</code><strong> 还是 </strong><code>&lt;? super T&gt;</code><strong> ，都是以类型 </strong><code>T</code><strong> 为中心的；</strong></p></li><li><p><strong>如果你想使用 </strong><code>T</code><strong> 类型对象，则用 </strong><code>&lt;? extends T&gt;</code><strong> ；如果你想添加 </strong><code>T</code><strong> 类型对象，则用 </strong><code>&lt;? super T&gt;</code><strong> 。</strong></p></li></ul><p><code>&lt;?&gt;</code> 称为无界通配符（unbounded wildcard），可以匹配任何类型，但赋值之后就不能再添加元素了（ null 可以），只能进行获取或删除操作。</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">异常</h2><p><code>Error</code> 类及其子类和 <code>RuntimeException</code> 类及其子类被称为 <strong>Unchecked Exception</strong>；其它所有继承自 <code>Throwable</code> 接口的子类（包括 <code>Exception</code> 类自身）则称为 **Checked Exception。**Checked Exception 需要在代码中显式处理，否则会编译出错。</p><p><code>NoClassDefFoundError</code> 和 <code>ClassNotFoundException</code> 有什么不同 ？</p><ul><li><p><code>ClassNotFoundException</code> 表示在运行时找不到指定的类，如调用 <code>Class.forName()</code> 方法时，如果找不到目标类，则抛出该异常。</p></li><li><p><code>NoClassDefFoundError</code> 表示未找到目标类的定义，如在编译成功后，故意删除一个类的 class 文件，在执行程序时，就会抛出该错误</p></li></ul><p>当存在 <code>try</code> 时，可以只有 <code>catch</code> 代码块，也可以只有 <code>fianlly</code> 代码块，但就是不能只有 <code>try</code> 部分。</p><p><code>finally</code> 是在 <code>return</code> 表达式运行后执行的，此时要 <code>return</code> 的结果已经被先暂存起来，等 <code>finally</code> 代码块执行结束后再返回之前暂存的返回值。</p><p><strong>不要在 </strong><code>finally</code><strong> 代码块中执行 </strong><code>return</code><strong> 语句。</strong></p><h3 id="h-finally" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0"><strong>为什么 finally 代码块总能被执行？</strong></h3><p>因为编译器在编译 Java 代码时，会复制 <code>finally</code> 代码块，并分别放在 <code>try-catch</code> 所有正常执行路径及异常执行路径的出口中，这样不管发生什么情况， <code>finally</code> 代码块都会执行。</p><p><code>Throwable</code> 类的（直接或间接）子类不能是泛型类</p><h2 id="h-" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">反射</h2><p><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.yuque.com/inuter/nghb49/op33g0?inner=IimI7">https://www.yuque.com/inuter/nghb49/op33g0?inner=IimI7</a></p><p>其中 <code>getFields()</code> 、 <code>getConstructors()</code> 、 <code>getMethods()</code> 三个方法返回所有 public 修饰的属性和方法（包括从父类继承的）；而 <code>getDeclaredFields()</code> 、 <code>getDeclaredConstructors()</code> 、 <code>getDeclaredMethods()</code> 则仅返回本类定义的属性和方法，但不限于 <code>public</code>。</p>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[IDEA 编译大项目报错问题解决]]></title>
            <link>https://paragraph.com/@igaozp-2/idea</link>
            <guid>1cx3aX0IMl1coh3VquFF</guid>
            <pubDate>Wed, 05 Jan 2022 13:10:52 GMT</pubDate>
            <description><![CDATA[最近使用 IDEA 启动 Java 项目时发现在编译阶段出现如下的错误：java.lang.OutOfMemoryError: GC overhead limit exceededjava.lang.InternalErrorjava.lang.OutOfMemoryError: Java heap space出现上述的错误，通常在项目工程比较大的时候才会出现。此时只需要调整 IDEA 的设置， 将 File | Settings | Build, Execution, Deployment | Compiler 中的 Shared build process heap size(Mbytes) 配置的阈值适当提高，问题通常便会解决。]]></description>
            <content:encoded><![CDATA[<p>最近使用 IDEA 启动 Java 项目时发现在编译阶段出现如下的错误：</p><ul><li><p><code>java.lang.OutOfMemoryError: GC overhead limit exceeded</code></p></li><li><p><code>java.lang.InternalError</code></p></li><li><p><code>java.lang.OutOfMemoryError: Java heap space</code></p></li></ul><p>出现上述的错误，通常在项目工程比较大的时候才会出现。此时只需要调整 IDEA 的设置， 将 <strong>File | Settings | Build, Execution, Deployment | Compiler</strong> 中的 <strong>Shared build process heap size(Mbytes)</strong> 配置的阈值适当提高，问题通常便会解决。</p>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
        <item>
            <title><![CDATA[使用 JConsole 简单排查死锁线程]]></title>
            <link>https://paragraph.com/@igaozp-2/jconsole</link>
            <guid>Rg4X4MxSG2apTn4hWNOZ</guid>
            <pubDate>Sat, 11 Dec 2021 12:01:21 GMT</pubDate>
            <description><![CDATA[最近在工作中遇到了 HTTP 请求长时间未响应的情况，初步判断是代码问题导致产生死锁，遂简单学习了下 JDK 中自带的 JConsole 工具。 以 Windows 为例，工具存放在 JDK 目录下的 bin/jconsole.exe，双击运行即可。 使用步骤：新建连接，选择本地或远程的应用进程，并连接。切换至线程选项卡。点击左下方的「检测死锁」按钮。如果存在死锁进程，会展示对应的线程信息，同时展示线程死锁相关的堆栈信息，排查堆栈信息即可找到问题根源。]]></description>
            <content:encoded><![CDATA[<p>最近在工作中遇到了 HTTP 请求长时间未响应的情况，初步判断是代码问题导致产生死锁，遂简单学习了下 JDK 中自带的 JConsole 工具。 以 Windows 为例，工具存放在 JDK 目录下的 bin/jconsole.exe，双击运行即可。</p><p>使用步骤：</p><ol><li><p>新建连接，选择本地或远程的应用进程，并连接。</p></li><li><p>切换至线程选项卡。</p></li><li><p>点击左下方的「检测死锁」按钮。如果存在死锁进程，会展示对应的线程信息，同时展示线程死锁相关的堆栈信息，排查堆栈信息即可找到问题根源。</p></li></ol>]]></content:encoded>
            <author>igaozp-2@newsletter.paragraph.com (IGAOZP)</author>
        </item>
    </channel>
</rss>