【外评】15 年前我给自己的一系列编程建议
我终于觉得自己是个像样的程序员了，所以我想以 “如果是我，会怎样做才能更快达到这个境界？”的想法来写一些建议，会很有趣。我并不是说这对每个人都是好建议，只是说这对我来说是个好建议。
如果你（或你的团队）经常自寻死路，那就先找个好地图吧
我不知道有多少次，我在一个团队中，系统中有些东西很容易被搞砸，但没有人想过如何让犯错变得更难。
我在做 iOS 开发时，使用了 CoreData，并订阅了大量视图的变化。订阅回调来自触发更改的同一线程。有时是主线程，有时是后台线程。重要的是，在 iOS 开发中，只能在主线程上进行 UI 更新，否则应用程序就会崩溃。因此，一个新的订阅可能运行正常，但如果有人从后台线程触发更改，或者稍后添加用户界面更新，它就会崩溃。
这一点大家都能坦然接受，在对团队新人的审查中也经常出现这种情况。每隔一段时间，就会有一次漏网之鱼，当我们看到崩溃报告时，就会去添加 DispatchQueue.main.async。
我决定解决这个问题，花了十分钟更新了我们的订阅层，改为在主线程上调用订阅器，这样就避免了一整类崩溃，也减轻了一点心理负担。
我并不是想说 “看看这些白痴，明明代码库中有明显的问题，却不去解决”，因为任何人只要花几分钟思考一下，就会发现问题的所在。这些问题的存在很奇怪，因为从来没有一个自然的时间来解决它们。当你刚入职的时候，你并不想改变什么大事。所以你可能会觉得这很奇怪，但你不应该去改变一堆你还在学习的东西。当你在团队中工作一段时间后，这些问题就会逐渐消失。
这是一种心态的转变。你只需要偶尔提醒自己，当这些事情缠身时，你有能力让自己和团队的生活更轻松。
评估你在质量和速度之间的权衡，确保它适合你的情况
在实施速度和对正确性的信心之间，总会有一个权衡。因此，您应该问自己：在我目前的情况下，是否可以交付错误？如果这个问题的答案不会影响您的工作方式，那么您就过于僵化了。
在我的第一份工作中，我从事的是与数据处理有关的新建项目，这些项目拥有良好的系统，可以追溯性地重新处理数据。出错的影响非常小。在这种环境下，正确的应对方法是稍微依赖护栏，因为可以，所以走得更快。你不需要 100% 的测试覆盖率，也不需要庞大的质量保证流程，因为这会拖慢开发速度。
在我的第二家公司，我正在开发一款有数千万人使用的产品，其中涉及高价值的金融数据和个人身份信息。哪怕是一个小错误，都会导致死无葬身之地。我以蜗牛般的速度发布功能，但我也认为那一年我可能发布了 0 个错误。
通常情况下，你不在第二家公司。我见过很多开发人员在这种编程方式上犯错误。在错误不是关键任务的情况下（例如，99% 的网络应用程序），快速交付和快速修复错误比花时间确保在第一次尝试时就交付原始功能更有意义。
磨刀不误砍柴工
你需要经常重命名事物、查看类型定义、查找引用等；在这方面你应该很快。你应该知道编辑器中的所有主要快捷键。你应该是一个自信而快速的打字员。熟悉操作系统。熟练掌握 shell。了解如何有效使用浏览器开发工具。
我已经知道有人会在评论中说：”你不能整天都在调整你的 neovim 配置，有时你也需要砍树”。不过，我从未见过有人真的过度使用这些工具；我在新工程师身上看到的最大 “绿旗 “之一，就是他们在选择和熟练使用工具时的谨慎程度。
如果你无法轻松地解释为什么某件事情很困难，那么这就是偶然的复杂性，也许值得解决。
在我的职业生涯中，我最喜欢的经理有一个习惯，当我声称某件事很难实现时，他会逼问我。他的回答往往是 “这不就是在 Y 时发送 X 的问题吗”，或者 “这不就是我们几个月前做的 Z 的问题吗”？我想说的是，这些都是非常高层次的反对意见，而不是我试图解释的我们正在处理的实际函数和类的问题。
我认为传统的观点是，管理者这样简化事情只会让人讨厌。但令人震惊的是，很多时候，当他催促我时，我会意识到我所解释的大部分复杂性都是附带的复杂性，而我其实可以先解决这些问题，从而使问题变得像他说的那样微不足道。这种事情往往也会让未来的修改变得更容易。
尝试解决更深层次的错误
想象一下，您在 dashboard 中安装了一个 React 组件，该组件处理从当前登录用户的状态中获取的 User 对象。您在 Sentry 中看到一个错误报告，其中用户在呈现时为空。你可以快速添加 if (!user) 返回 null。或者你可以再深入调查一下，发现注销函数进行了两次不同的状态更新–第一次是将用户设置为空，第二次是重定向到主页。将两者互换，现在任何组件都不会再出现这个 bug，因为在仪表板中用户对象永远不会为空。
继续进行第一种错误修复，结果就是一团糟。继续进行第二种错误修复，你就会拥有一个干净的系统和对不变式的深刻理解。
不要低估挖掘历史来调查一些错误的价值
我一直很擅长调试奇怪的问题，通常使用的工具包是 println 和调试器。因此，我从来没怎么用过 git 来了解 bug 的历史。但对于某些 bug 而言，这是至关重要的。
最近，我的服务器遇到了一个问题，它似乎一直在泄露内存，然后被OOM杀死并重启。我怎么也找不到原因。所有可能的罪魁祸首都被排除了，我无法在本地重现，感觉就像蒙着眼睛扔飞镖。
我查看了提交历史，发现它是在我添加 Play Store 支付支持后开始出现的。我万万没想到，这只是几个 http 请求。原来，在第一个访问令牌过期后，它就陷入了获取访问令牌的无限循环中。也许每个请求只增加了 1KB 左右的内存，但如果在多个线程上每隔 10 毫秒重试一次，内存就会迅速增加。通常这种情况会导致堆栈溢出，但我使用的是 Rust 中的异步递归，它不会导致堆栈溢出。我从来没想过会出现这种情况，但当我被迫去研究一段特定的代码时，我知道一定是它导致了这种情况，突然间，我就想到了这个理论。
我不知道什么时候该这么做，什么时候不该这么做。这是一种直觉，是对错误报告的一种不同的 “呵呵”，引发了这种调查。随着时间的推移，你会逐渐形成这种直觉，但只要知道有时在你陷入困境时这种直觉是非常宝贵的就足够了。
同样，如果问题可以用 git bisect 来解决，那就试试吧–这意味着 git 历史上的小提交、快速自动测试问题的方法，以及你知道的一个坏提交和一个好提交。
糟糕的代码会给你反馈，完美的代码不会。尽量少写糟糕的代码
编写糟糕的代码非常容易。但要写出完全遵循所有最佳实践的代码，并经过单元测试、集成测试、模糊测试和突变测试，也是非常容易的。因此，很多编程工作都是在寻找平衡点。
如果你偏向于快速编写代码，那么你偶尔就会被技术债务所困扰。你会学到 “我应该为数据处理添加大量的测试，因为事后往往无法纠正”，或者 “我真的应该仔细考虑表格的设计，因为在不停机的情况下更改东西会非常困难”。
如果你偏向于编写完美的代码，就不会得到任何反馈。所有事情都要花费很长时间。你不知道自己在哪些方面花了时间，在哪些方面浪费了时间。反馈机制对学习至关重要，而你却得不到。
我说的 “糟糕 “不是指 “我记不住创建哈希图的语法，所以用了两个内循环来代替”，而是指 “糟糕”：
我没有重写我们的数据摄取，使这种特定状态无法体现，而是在我们的不变式上，在几个关键检查点上添加了几个断言
我们的服务器模型与我们要编写的 DTO 完全相同，所以我只是将其序列化，而不是编写所有的模板，我们以后可以根据需要编写 DTO
我跳过了这些组件的测试，因为它们都很琐碎，其中一个出错也没什么大不了的
让调试更容易
多年来，我学到了很多让软件更容易调试的小技巧。如果你不努力让调试变得简单，那么随着软件变得越来越复杂，你将花费大量时间来调试每个问题。你会害怕进行修改，因为即使是几个新的 bug 也可能要花上一周的时间才能弄明白。
下面是一些例子来说明我的意思：
- 关于 Chessbook 后台
- 我有一个命令可以将用户的所有数据复制到本地，这样我就可以只用一个用户名就轻松地重现问题了
- 我使用 OpenTelemetry 跟踪每个本地请求，这样就能很容易地查看请求是如何耗费时间的。
- 我有一个作为pseudo-REPL 的 scratch 文件，每次更改都会重新执行。这样就能很容易地调出一些代码并对其进行处理，从而更好地了解发生了什么。
- 在暂存环境中，我将并行性限制为 1，这样就能更直观地解析日志。
- 对于前端
- 我有一个 debugRequests 设置，可以防止乐观加载数据，从而更容易调试请求
- 我有一个 debugState 设置，它会在每次更新后打印出程序的整个状态，以及一个漂亮的变化差异表
- 我有一个小函数文件，可以让用户界面进入特定状态，这样当我试图修复错误时，就不必一直点击用户界面来进入该状态。
保持警惕，看看有多少调试时间花在设置、重现和事后清理上。如果超过 50%，你就应该想办法让它变得更容易，即使这次需要的时间会稍长一些。在其他条件相同的情况下，随着时间的推移，错误应该会越来越容易修复。
在团队中工作时，你通常应该问这样一个问题
从 “试图自己解决所有问题 “到 “向同事询问所有问题”，我认为大多数初入职场的人都偏向于前者。总有人在代码库里待的时间更长，或者比你更了解 X 技术，或者比你更了解产品，或者是更有经验的工程师。在某个地方工作的前 6 个月里，你有很多次可能要花一个多小时才能弄明白一件事，或者几分钟就能得到答案。
提出问题。只有在几分钟内就能找到答案的情况下，这样做才会让人讨厌。
代码交付节奏非常重要。认真思考怎样才能快速、频繁地交付
初创企业的发展空间有限。项目有最后期限。当你辞职自立门户时，你的积蓄只能支撑几个月。
理想情况下，你在一个项目上的速度只会随着时间的推移而加快，直到你以超乎想象的速度推出功能。要实现快速交付，你需要很多东西：
- 不易出现错误的系统
- 团队之间的快速周转时间
- 愿意砍掉新功能中需要花费 50% 工程时间的 10% 部分，并有远见地知道这些部分是什么
- 一致的可重用模式，可将其组合成新的屏幕/功能/端点
- 快速、轻松部署
- 不会拖慢工作进度的流程；不稳定的测试、缓慢的 CI、挑剔的线程、缓慢的 PR 审核、将 JIRA 奉为信仰等等。
- 还有数不清的其他问题
代码交付速度慢应该像中断生产一样值得事后检讨。我们的行业不是这样运行的，但这并不意味着你不能亲自追随 “快速交付 “这颗北极星。
本文文字及图片出自 A Bunch of Programming Advice I’d Give To Myself 15 Years Ago
你也许感兴趣的：
- 【外评】软件复杂性的三大法则（或：为什么软件工程师总是脾气暴躁）
- 【外评】我对 The Clean Coder 的看法
- 【外评】我为什么编程
- 【外评】我们应该将编程法则视作谚语
- 【译文】40 亿条 if 语句
- 现在开始，把代码里的 else 丢掉！
- 程序员提交 PR 的理想长度是多少？有人答：50 行代码！
- 别再说 “技术债” 了！
- 经历多次重写，苹果平台最强科学计算器PCalc背后的故事
- 世界级编程大师Bob 大叔为“干净代码”辩护遭质疑：时代变了，别用Clean Code那套要求我们了！
我要补充一点。你不是你的工作。在工作中不要把事情放在心上。如果你与公司格格不入，千万不要害怕离开。
我离职的原因有几个，主要是糟糕的经理、增加的报酬和糟糕的代码……。
如果有人在你的公司写出了糟糕的代码，以至于你知道这将在日后对你造成困扰，那么你可以一走了之。
不要让任何人难堪，也不要上报给经理，解释代码有多糟糕。我曾经遇到过这样的情况：我们团队中的某个人编写的代码实际上是在装模作样。为此，我和团队中的一半人发生了激烈的争吵。最后，我被罚了两周的时间，而我的经理却说，哦，你一直都是对的。
人生苦短，不能和无能的人打交道。
有趣的是，根据开头，这条评论的方向与我的预期完全不同。
当你写到 “不要把工作中的事情放在心上 “时，我以为你会说一些关于各种谦逊的事情–在代码审查中尽量按照要求进行修改而不是推脱，如果有人改写了你写的东西也不要觉得委屈，等等–以及看到更广阔的前景–代码的存在是为了服务于业务目的，有时业务目的的优先级与你狭隘地希望代码应该朝哪个方向修改的想法并不一致。
我想说的是，你评论的其余部分给出了一些非常个人化的例子–你对代码有强烈的主人翁感，以至于当你无法如你所愿地控制它时，你就会放弃。说白了，我是在争论开头部分与评论的其他部分不符，而不是真正的整体信息，对我来说，这更像是 “你不需要忠于职守”，而不是 “不要针对个人”。
我在其他评论中做了更多解释，但在这种情况下，我面对的是根本不会编程的人。
这不是一个 “哦，如果我换个方式就好了 “的问题，更像是这家公司充满了不知道自己在做什么的人，我宁愿不在这里。
我要说的是，面试时绝对不能谈论现任雇主的代码问题。面试你的人会认为你是一个为制表符和空格争论不休的怪人。没有足够的细微差别。
也许我想说的是，当一家公司不适合你时，你不应该耿耿于怀。
我非常同意你的观点。
“我不喜欢你的变量名 “和 “这段代码太乱了，任何改动都必须根据 20 种不同情况下的 20 个主要功能进行手动检查 “这两者之间存在巨大差异。
作为一名软件工程师，我的进步很大程度上来自于将自我与我所做的事情分离开来。这很难做到，因为你编写的代码是你心理模型的强烈反映，你理应感到与代码之间存在某种联系。
在代码审查中巧妙地处理这种事情需要练习。
根据我的经验，最优秀的程序员团队在解决问题时都会把自我意识放在一边。
100%同意你的观点。我所在过的最好的团队，无论事情进展顺利与否，都非常和谐。每个人都团结一致，共同完成任务。每隔一段时间，我们都会遇到别人写的一些糟糕的代码，然后彼此开怀大笑，然后把它解决掉。每个人都互相支持。
除非你在工作地点上有很大的灵活性，否则这种建议在自由落体的 IT 就业市场上已经越来越不适用了。
与 2003 年至 2022 年期间相比，可以随意跳槽的开发人员要少得多。
就我的情况而言，在找到另一份工作之前，低调行事要容易得多。结果，我在工作中造成了很大的压力，编写这些代码的工程师公开憎恨我……。
通常情况下，如果有人在代码库中加入了错误代码，那就是一个更广泛的文化问题，你不可能解决这个问题。
> 除非你在工作地点方面有很大的灵活性，否则这种建议在自由落体式的 IT 就业市场上越来越不适用了。> 与 2003 – 2022 年相比，可以随意跳槽的开发人员要少得多。
需要引用。优秀的开发人员现在和以前一样抢手。
需求可能是存在的，但如果你有一个行之有效的方法，能在招聘过程中被认可为 “优秀的开发人员”，我很乐意听听。
参考资料。向你的优秀开发人员打听他们认识的优秀开发人员。
轶事来袭：我工作过的一家公司就有这样一位推荐人。他们面试失败了。推荐员工感到难以置信。我被要求重新面试他们。他们看起来确实不错，也拿到了录用通知。这次经历耽误了时间，给候选人留下了不好的印象，于是他们接受了另一份工作。
我的观点是，面试优秀开发人员的结果可能是随机的。也许一个糟糕的开发人员的随机结果的概率也较小，但肯定会发生。
不过……定义一下 “好”。有些人只有在合适的团队和环境中才能发挥出惊人的能力。
我见过一些这样的情况：
公司说 “寻找 X 方面的专家”。
X 方面的专家走进房间。
面试官：”你在 Y 方面的能力如何？”
X 专家：”我对 Y 有一点了解，但不是太多。我在工作中主要使用 X；我可以向你展示如何使用 X 来解决问题。
采访者：”感谢您抽出时间，再见”
当我试图弄清楚为什么会发生这种情况时，得到的答案通常都是一些愚蠢的说法，比如”人力资源部发布了招聘启事，他们不知道我们真正需要什么”，或者 “是的，我们仍在寻找 X 方面的专家，但我们更急需 Y 方面的专家”。(后者仍然无法解释为什么他们拒绝了 X 方面的专家，却没有问他有关 X 的任何问题，但对说这话的人来说，这似乎很有道理）。
我认为这位家长评论者是从求职者的角度来提问的，而不是从企业或招聘经理寻找开发人员的角度。
除非你发明了互联网或其他什么，否则没有一家 FAANG 甚至二级公司是靠推荐信工作的。
即便如此，还是有一个著名的故事：流行的 MacOS FOSS 软件包管理器 Homebrew 的开发者在苹果公司的面试中失败了。
我不明白为什么一个流行软件包的维护者会面试失败。拥有一个受欢迎的软件包与编码能力无关，更多的是与在正确的时间写出正确的东西有关。
他不是 “流行软件包的维护者”。
他是 Homebrew 的创建者/设计者和主要开发者，Homebrew 是几乎所有 MacOS 开发者都在使用的开放源码软件<<软件包管理器>>。
他将一个想法付诸实践，使其具备了生产条件，并被数百万用户使用。
我不在乎原始编码能力（卡马克风格），如果建立这样一个大型项目还不能证明至少是开发能力的话，那就什么也证明不了了。
这是供求关系。即使你很 “优秀”，也有很多其他 “优秀 “的人在找工作。有些人甚至可能比你更优秀！或者至少更善于推销自己。
营销自己现在比以往任何时候都更重要。人工智能的出现给招聘双方都带来了噪音问题：求职者利用工具生成必要的文件（有针对性的简历、求职信、社交资料），招聘人员则使用扫描工具剔除不包含神奇关键词或短语的内容。
很难比较时间段。当我申请的 95% 的工作都是远程工作时，我仍然无法理解这意味着什么。
还有其他数据点需要考虑：
– 更高的利率和更少的风险投资资金意味着更少的初创企业和更少的招聘人数
– 大量科技企业裁员
关于你提到的对 “优秀 “开发人员的需求，我认为这很可能是真的。我不知道如何将这一点与面试无法识别优秀开发人员的问题区分开来。一个 “优秀 “的开发人员是由个人、他们的生活、团队、代码库、领导力、流程、技术债务等因素决定的。
“优秀的开发人员现在和以往一样抢手”。
需要引用。
市场并没有自由落体。或者说，只有刚从大学毕业的初级开发人员才会自由落体。如果你是技术熟练的资深开发人员，就不要相信这些无稽之谈，要对自己有信心。这只是冒名顶替综合症的一种延伸，我经常在很多人身上看到这种现象。
两年前，如果你技术精湛、资历深厚，你会与其他 5-10 名合格的候选人竞争。现在是 100 多人。
正是如此。
入门级市场越来越饱和。中级职位的需求正在缓慢上升。但是，如果你是一名技术熟练的资深员工，你仍然很抢手。否则，你的简历可能很烂，或者你的技能不如大多数资深人士。
不要随便跳槽。但如果你对目前的工作不满意，也要积极寻找更好的机会。
请给 “自由落体 “下个定义。据我所知，似乎有很多有趣的职位空缺。歇斯底里的招聘少了，但工作很多（而且比 15 年前无休止的 CRUD 更有趣）。
我不同意。如果你有问题，你应该尝试将问题升级。这对公司更好……对你的同事也更好（他们可能也有这些问题！）如果你把问题上报了，但没有任何改变，那么你就该走了。如果你无论如何都要离开，不妨先试着把事情改变得更好。
是的。我听说过 “发言权 “和 “退出权 “的说法。这是你几乎总能使用的两种策略：基本上，要么大声说出来，要么离开。
如果所有关心问题的人都离开了，组织就更难解决问题了。这是组织腐化的一种形式。
我们中的大多数人都擅长其中一种，而不擅长另一种。比如，我的本能反应就是在不喜欢工作时辞职。这很好，但有些情况几乎肯定是可以挽救的。而我本可以帮上忙。有些人试图无限期地解决工作场所的问题，甚至不惜损害自己的利益，即使这种情况很可能无法挽救，他们也应该离开那里。
我认为学习这两种技能真的很重要。当我感到压力的时候，我也会提醒自己，这两种方法都可以选择。
这个模型来自赫希曼的论文《出口、声音和忠诚》。https://en.wikipedia.org/wiki/Exit,_Voice,_and_Loyalty。
感觉有点像虚假的二分法，因为至少还有一个选择：等待。如果你相信情况会好转，失效只是暂时的，那么什么都不做就是明智之举，这既不是 “发言权”，也不是 “退出”。
完全正确–这不是二分法。这只是两个碰巧广泛适用的策略。根据您所面临的具体问题，几乎总有其他策略可供选择。(也许你可以解雇相关人员。也许有技术解决方案。也许你可以寻求帮助。等等等等）。
这确实取决于具体情况。
重要的是要认识到，那些不称职的开发人员之所以能够生存下来，往往是因为他们深受决策人员的喜爱。如果你对他们的工作表现提出质疑，那么你就等于挑起了一场很快就会输掉的战斗。我见过有人在提出对这样的人的担忧时被晾在一边，即使他们是对的，也会让他们在下一次求职时处于更糟糕的境地。
在大多数情况下，我倾向于同意 OP 的观点，即在这种情况下，员工的正确做法是保持低调并开始寻找工作。如果情况还没有到完全无法忍受的地步，就没有必要直接递交两周的离职通知，但还是值得寻找出口。
我同意这取决于具体情况，但我想说明的是，升级或离开并非二选一。你可以两者兼顾。如果你输了，至少你尝试过。我曾经过早地离开过一些工作，并为此后悔不已。我本可以做得更多，也应该做得更多。也许，无论如何我都会失败。公司政治和公司文化是一股强大的力量。
现实情况是，许多直接管理者对下属的日常工作知之甚少，因为他们的亲力亲为不够。他们应该检查工作成果。举个例子：他们至少应该查看 PR，甚至亲自参与代码审查。如果你向我熟悉的一些 “工程经理 “提出这个建议，他们会说这不是他们的工作，你提这个建议简直是疯了。(我也会告诉他们我不同意这种说法。）这就是为什么同事需要将性能问题上报：因为许多决策人员并不知道发生了什么。
或者
听我说完
你要公开让另一个同事难堪这可不是个好主意
我需要澄清的是，本可以写得更好的功能代码和什么都做不了的代码是不同的。
我曾在一家公司工作过，那里有三四个人写的代码什么都不做，但看起来功能正常。试想一下，一个 API 可以检查另一个服务的状态，而你只需编写代码，让它总是返回 200。
与其试图拯救一个组织，不如去别的地方。我就是这么做的，而且还得到了 3 万美元的加薪。
不一定。你可以把事情上报给你的上司。或者是他们的老板。他们会和同事谈论此事。不必（也不应该）公开质询。也许你可以做一些一对一的辅导，尝试帮助他们。也许你没有足够的耐心去尝试。当然，大多数时候离开会更容易些。
代码方面是灰色的。我见过一些 “能用 “的代码，但在性能、质量、重复性、安全问题等方面都有令人无法接受的问题，几乎不能算 “能用”，当然也无法维护。屎是擦不亮的。
我没有这样的经历，我基本上是被告知，我应该闭嘴，习惯于使用那些在功能上什么都做不了的代码。
后来当我抱怨时，我的经理却说，虽然代码什么都做不了，但它能让我们的指标看起来更好。
想象一下
function1(){ ApiCall(“1”) }
function2(){ ApiCall(“2) }
一遍又一遍。
我会告诉他们我不会闭嘴，这是一个影响产品质量的大问题。然后，我会向老板的老板反映此事，开始抱怨老板工作不力，鼓励虚假、无意义的指标来玩弄系统。也许他们会受不了，让你滚蛋。不过可能不会。破损组织的特点是解雇任何人都要花很长时间，所以在你找其他工作的时候要利用这一点。
与另谋高就、一走了之相比，这似乎是个大工程。
我不是想改变世界，我只是想赚钱，这样我就能存钱，最好能在 50 岁之前退休。
如果说我在生活中学到了什么，那就是你需要选择你想打的仗。
如果选项 A 是与许多人争论，公开揭露多层次的无能，以至于我的经理和同事都会恨我……。
与之相比，选择 B，低头做事，直到我可以跳槽，然后希望下一个地方没有那么糟糕。
我选 B。
超越你的工资等级，你什么也得不到。
我的意思是，如果你不关心公司、产品或项目，那么是的，你是对的。低调行事，继续前进。有些争斗绝对不值得。如果你关心的不仅仅是你的薪水，也许就值得。
你真的在乎某个无能的人讨厌你吗？我讨厌和无能的人一起工作，所以有些相互的感觉是完全没问题的。这甚至可以改善情况，至少是暂时的：他们会减少与你的互动，以避免冲突，因为大多数人都比较避免冲突。
坏印象会传染。有些 “无能者 “拥有政治资本。
在我看来，给人贴上 “无能 “的标签是一面鲜艳的橙色旗帜。有时确实如此，但更多时候是真正缺乏尊重。
>function1(){ ApiCall(“1”) }
>function2(){ ApiCall(“2) }
引用前面的内容，看到这个，告诉我写这个的人是有能力的。
礼貌的说法是 “可能存在技能不匹配”。
很多人都会被慢慢 “漂流 “到自己并不胜任的编程岗位上。
归根结底，我不是什么超级英雄，我并不想大幅改善我工作的每家公司。
如果你和同事相处得不好，你可以走人。总是说这是为了钱，你永远不知道你还能见到谁。
> 引用前面的内容，看看这个，告诉我写这篇文章的人是否称职。
我不能，也不能根据二手调侃对他们做任何漫无边际的概括。
> 礼貌的说法是 “可能存在技能不匹配”。
这不仅是客气话，可能还很实际。也许这个人在其他方面有很高的技能，如果应用到这项工作中，会很有价值。
> 很多人都会被慢慢 “漂流 “到他们并不适合的编程岗位上。
就像我一样。我没有接受过正规的 CS 教育，在很多方面都不合格。但到目前为止，我已经创造了大约 1000 个工作岗位。我还教过 CS，在大学课程中讲过 CS。我敢肯定，如果我们见面，你会认为我不称职，因为我们对世界和工作的看法似乎大相径庭。
> 说到底，我并不是什么超级英雄，我并不是想大幅改善我工作的每家公司。
我并不认为只要真诚地做好自己的工作，在尊重他人的基础上进行专业互动，努力让世界（以及你所接触的世界的每一部分）变得更好，甚至不变得更糟，就是超级英雄。这只是最基本的。
> 如果你和同事关系不融洽，你可以离开。总是说是钱的问题，你永远不知道会再见到谁。
是的，绝对是这样，只要看起来是正确的选择，就可以改变角色。我希望每个人都能拥有这样的自由，感到安全，没有负罪感。追求幸福。即使说是为了钱，我也无法反驳，除非这样做掩盖了其他一些伤害他人的事实。
对我来说，这还不够。这样写代码可能是有原因的。也许需要为 `function1` 提供函数引用，以便将其作为回调函数传递。也许应该给它取一个有意义的名字，而不是 “function1″。
>我的意思是，如果你不关心公司、产品或项目，那么是的，你是对的。低调行事，继续前进。有些争斗绝对不值得。如果你关心的不仅仅是你的薪水，也许就值得。
没错！
我不在乎薪水之外的任何工作。我不是要改变世界。我不指望我所做的任何事情能带来真正的改变。
老实说，你的反应是可以理解的。你试图合法地改进工作，付出额外的努力，而他们却因此对你很不好。
但归根结底，很多地方都不是这样的。
有很多人更关心自己的手艺，而不是自我。而这可以让你获得更多的回报。
我赞同你的观点。有很多优秀的经理对产品的关心超过了对团队指标的关心。同样，同事们也会关心进步。不要让一个糟糕的经理决定你在下一份工作中如何做事。
同样，关心客户和同事的人也很多。与这样的团队合作才是王道。
不过，根据我的经验，这种情况只是暂时的，总有一天会过去（从容应对并对自己的行为负责）。
> 破产组织的特点是，他们永远不会解雇任何人，所以在你寻找其他工作时，要利用这一点。
我的上一家公司在很多方面都很糟糕，动不动就炒人。
编写测试用例并提交错误。
这是一个困难的升级。在与老板交谈时，几乎总是最好讨论业务问题的解决方案，特别是那些老板的经济激励目标。
说到其他问题，你突然就成了 “那个 “人。老板甚至可能不再听你说话，认为你才是问题所在，而不是那个讨厌的孩子。
> 听我说完。你会让另一位同事公开难堪。这不是个好主意
我们在一起工作时，都应该假定自己是能够接受反馈的成年人。如果同事做得不好，就和他们谈谈。如果他们不听，就升级。如果升级不起作用，那就是不合适。
> 然后你要公开让另一位同事难堪。这可不是个好主意。
如果他们真的罪有应得，那就值得了。
与此相关的是，当计算机抛出错误时，它并不关心你，也不会对你进行评判。出错的是你的代码，而不是你自己。别再自怨自艾了，快去修复它吧。
我发现把所有的错误都归咎于愚蠢的电脑不懂倾听是很有帮助的，然后再梳理代码，找出电脑太笨而无法理解的地方。当我找到它时，我意识到我在匆忙中不小心对电脑说错了话，而电脑正在尽最大努力取悦我，我纠正了它，并保证下次会解释得更好，然后向它道歉。
我发现把无生命的东西外化是一种治疗方法。
听起来你已经准备好接受管理了！
除了不是你的工作之外。我离开了一个有有趣的工作、优秀的管理层、优秀的同事和优厚的薪酬/福利/发展空间的地方。这个地方曾被我视为梦寐以求的工作。
我为什么离开呢？因为我有点厌倦了，想尝试一些不同的东西。我想尝试建立自己的公司。目前进展顺利。(到现在已经有 14 个月了）
我不是我的工作，因此我可以自由地追求我想要的东西。
按要求行事，回家与家人团聚
这对有些人来说没问题，但另一些人则想让自己感觉到，他们在工作和准备工作（如上学）中度过的三分之二的人生是有意义的。对有些人来说，打卡和领工资是不够的。
对我来说，工资是不够的，所以我决定不过度工作，这样我就可以把时间花在陪伴家人、学习、烹饪等方面。
我仍然有战斗的冲动，但我也意识到，战斗比一味地逼迫更加细致入微。也许最好的办法就是推一把，等待下一次机会。在组织中找到你可以信任的人。玩游戏。或者有时就像其他人一样，冷静下来，投入最少的工作。
在美国的个人收入是中位数家庭收入的 2-3 倍（甚至更高！）（更不用说其他轻松超过其他家庭一年以上收入的报酬了）。
如果说 4 年的学校生活和每天在空调房里坐几个小时还不够有成就感的话，也许这些人应该在他们与世隔绝的科技泡沫之外，去了解其他人的观点。
我愿意用 “同事的代码很烂，但我不喜欢 “来换取轻松模式的生活。
这完全没有错。只是有些人（包括我自己）的习惯不同而已。
我用副业挠痒痒
这很酷，但往往感觉潜在的影响力较小。我的看法略有不同–也许我很幸运，能够有幸发挥自己的影响力–尽管我不太可能从经济上获益。
> 如果有人在你的公司写出了糟糕的代码，以至于你知道这将会在日后对你造成困扰，那么你可以一走了之。
在我看来，造成这种情况的最大原因之一，就是代码编写者知道他们不会在公司里收拾烂摊子。
这有点像 “鸡生蛋，蛋生鸡”。
> 尝试解决更深一层的错误
这是我在指导初级人员或审查代码时要向他们传授的主要内容之一。
当我不得不反复要求资历更深的人深入挖掘并修复更深层次的问题时，这也是我认为一个人工作水平过高的最大信号之一。
你需要花时间了解错误发生的原因，否则你只能修补墙纸，而不是修复水管漏水。
> 你需要花时间了解错误发生的原因，否则你只能修补墙纸，而不是修复水管漏水。
我想很多人都想深入探究，但在冲刺任务之间却没有时间。与找到解决方案之前未知的探索时间相比，管理层通常会推回已经足够好的解决方案。
当然，这可能会有很大的不同，但我从不害怕在这一点上与管理层抗衡。一半情况下，他们根本不需要知道。而另一半时候……他们会怎么做？解雇我？好吧，那他们的项目里就只剩下贴墙纸的人了，而我就会在别的地方好好工作。
(当然，有时修补墙纸才是正确的做法，但很少有管理层能够准确评估这种权衡）。
是啊，到了一定程度，我就不再在乎管理层的想法，而只是做我认为正确的事。我通常不会得到我认为在预防未来问题方面应得的认可，但也没有人抱怨。
作为资深员工，部分工作就是在这些限制条件下工作。在这种情况下，我会推回我的经理，告诉他们为什么从长远来看，根除错误会节省我们的时间，如果他们仍然不松口，我会用沙袋装一些时间来完成冲刺任务，以根除错误。
这就是为什么团队必须提前与管理层就 “完成 “的定义达成一致，以避免日后出现这种争论。此外，管理层还必须明白，速度/估计是用于长期规划的描述性指标，而不是短期的描述性指标。
我最近在一个硬件环境中遇到了这个问题。为了 “修复 “一个错误，设计人员没有了解根本原因，而只是将第一个症状隐藏起来。在一个错误代价非常高昂的领域，这种做法令人望而生畏。
对症下药。总是好建议。
我很惊讶有这么多人无法理解 “5 个为什么”。这些人基本上都喜欢壁纸和腻子。
这些建议中的大部分我都已经采纳了，但还有这一部分：
> 如果你无法轻易解释为什么某件事情很困难，那么它就是偶然的复杂性，也许值得解决
真是大开眼界。希望我下次在实现复杂功能时能记住这些。问题是，我觉得这些东西在我还是初级开发人员的时候帮不上什么忙。很多东西都太微妙了。
寻址 “可能有歧义。写注释来解释为什么这样做是对的、需要这样做？或者在修改代码时不考虑他们是否对代码库的其他部分有足够的了解。
还有一种可能是，他们还没有理解，无法轻松解释。
加入团队的一个关键部分就是要保持开放的态度，我不理解的东西并不意味着没有理解的东西。
有时会有理解，有时理解的人却离开了团队。这就是为什么值得写一些好的提交信息，并在遇到有趣的代码时回头读一读的原因。我的很多提交信息大意都是：”我这样做是为了向后兼容一直以来的工作方式。但在我看来还是很滑稽。”这样，至少未来的人知道我这样做的理由并不充分，如果他们愿意，可以深入研究或通过 PM 来签署更好的意见。
绝对同意这一点。
读代码比写代码更难，很多人都没有耐心。
相反，在这样的情况下，他们宁愿花时间重新学习过去的经验教训，因为他们认为应该以某种方式行事，如果他们不能立即明白为什么要以某种方式行事，那么他们的行为（不管是无意的还是其他的）就好像不可能理解。
特别是在比较棘手的情况下，值得在代码本身以及源代码控制中加入更多的前言。
通常情况下，一个或另一个都会受到影响，有时值得详细描述这些组件是如何协同工作的，或者有多个用例需要依赖这些组件（因此不是一个简单的更改或解决方案）。
没有人能轻易解释为什么早期（20 世纪 50 年代至 70 年代）的聚变反应堆如此困难。肯定是因为每个人都很愚蠢，都在制造自己的问题。
没有人能解释为什么科拉茨猜想如此难以证明。一定是因为每个人都太愚蠢了，给问题增加了偶然的复杂性。为什么每个人都如此愚蠢？
或者，也许，也许，这些建议完全是胡说八道，有些问题之所以难，我们并不完全理解。去写一个可靠的反应式库吧，它能按照人们的期望运行。哦，你写不出来？那你最好解释清楚为什么这么难，否则显然都是你的错。
这样的建议与实际情况完全不符，显然应该完全忽略这位作者。
一个好的教育者的标志就是–虽然可能需要大量的时间和基础概念的积累–通过通俗易懂的语言来启发人们了解其课题的复杂性。
很多时候，研究论文和类似的文章都是写给那些已经对其代表主题根深蒂固的受众的，因此那些基本原理就不再被讨论了，所以当你说到 “没有人能解释…… “时，也许这就是你的出发点；但我想说的是，很多人都能解释，而且已经解释了。也许只是需要大量的语言、纸张、图纸和类似的东西。
而且，即使/当有非常困难的事情需要证明时，传说中的 “你 “正在研究的事情也不太可能是令人难以置信的困难事情之一。
有句话说，真正理解一件事的标志就是能把它描述给一个孩子听。这也是 Thing Explainer 和 ELI5 存在的原因。
“优秀的教育工作者 “不是在解决棘手的问题，而是在传授长期存在的问题的长期解决方案。在软件工程中，针对长期存在的问题的长期解决方案被称为 “包 “或 “库”，通常只需一条命令就能将其包含在内。我们说的是构建软件，而不是教学。
“向孩子解释 “是在人类几十年后才理解的。费曼也许能向孩子解释量子力学，但量子力学在当时已经有大约 90 年的历史了。没有人会说迈克尔逊和莫利在他们的实验中引入了 “偶然的复杂性”，因为他们无法解释为什么衍射图样看起来如此奇怪。他们研究实际难题的几率有多大！？他们一定很蠢。
你忽略了我对核聚变能量的评论，也没有举例说明为什么科拉兹猜想很难。没人知道。第一个深刻理解科拉兹猜想为何如此困难的人，将是解决它的人。当你接近人类理解的边缘时，生活就是这样。
> 当你接近人类理解的边缘时，生活就是这样。
恰恰相反。站在软件工程的最前沿非常容易。这门学科（可以说）已有 100 年的历史。问题的空间深不可测。软件工程适用于任何其他学科：随便选一个学科，你都能立刻找到大量围绕如何应用软件方法解决该问题的未解（难）问题。
当行业中的任何人解决了一个具体问题，这个具体问题就永远解决了，对每个人来说都是免费的。所以，如果你不是在解决一个难题，你在做什么？复制/粘贴别人的成果？
融合：湍流，再加上奈弗-斯托克斯（Naiver-Stokes）是众所周知的难点，再加上电磁场，再加上核聚变的放热状态变化在自由能中引入了不连续的跃迁。
科拉茨：如果用任意参数替换 1 和 3，康威证明这一类问题是不可判定的，因此任何特定实例都可能是任意困难的。
真正精彩的回答。我不确定 “它可以被概括为一个不可判定的问题 “是否真的能解释它为什么难，因为 5n + 1 问题非常容易（证伪），而且同样可以被概括。关于 “融合 “的所有观点都很好，但我想说的是，他们花了一些时间（至少几个月）才意识到这是毁坏他们机器的原因。请记住，这是对 “如果你无法轻易解释为什么某件事情很困难，那么它就是偶然的复杂性 “这一说法的反例–也就是说，你遇到的所有困难都是你的错（因此实际问题一定很简单，而你一定很愚蠢）。
> 我不确定 “它可以被概括为一个不可判定的问题 “是否真的能解释为什么它很难….。
哈！我同意这个观点。）
不知道 15 年意味着什么，但如果这是我的起点的话：
(渎神警告）
– 跳过低级阶段，尽可能往高级阶段发展。抛弃 C、汇编、硬件。学习 python、ruby 和 js。从没接触过 C++，因为它太烂了？很好。
– 所有的钱都在客户手里。如果你从别人那里拿钱，最好的情况是，同样的工作，你拿的钱还不到四分之一。到处都是没用的水蛭，他们认为你是个神奇的赚钱机器。一旦你有信心，就绕开他们。
– 阅读 SICP、HTTP、TAOUP，但不要把它们放在心上。认真对待你所学到的任何想法，并根据实际情况进行广泛测试，因为脱离实际的想法可能听起来很好。
– 务实是唯一的方法。不要听信那些在想象中跳来跳去的业内农民，他们都是疯子。编程中的宗教比现实中的宗教更可怕。编程中的宗教信仰多如牛毛。不要争论，随他们去吧。其实自己测试方法和学习自己的方法很容易。这些大多只是习惯，一旦学会就不会有什么区别。
– 只有当你们是非常好的沟通者时，一起做事情才会变得更快。善于沟通的人很少，而你不是。
>跳过低层次，尽可能往高层次发展。抛弃 C、汇编、硬件。学习 python、ruby 和 js。从没接触过 C++，因为它太烂了？很好。
根据我的个人经验，我认为长期使用不同的高级和低级编程语言，是我与那些计算机基础知识薄弱的人/同事（在我的例子中，顺序是 Basic、Pascal、C、Perl、C/C++、PHP、JS 等）不同的地方。这也取决于项目，但这只是我的一点看法。
我会把它改写为 “既懂高级语言，也懂低级语言，并尽可能使用高级语言”。
了解低层次可以避免在高层次上自取灭亡。
我想你是对的，我应该把它分成两部分。首先是学习低级的 “工作原理”–这很有用。其次是编写实际的低级代码–我建议自己不要这样做。
所以，我想
– 学习套接字、文件系统和进程如何工作，阅读 apue，学习 jits/编译器如何工作。但不要写严肃的 C 语言，即使你足够聪明，那也是浪费时间。
这是我第一次看到 taoup 被推荐，而且还是在我尝试提出它的时候。如果你想在 Linux 领域工作，它和 Steven 的书一样，都是基础性的集体知识，但它却从未被提及：(
> 所有的钱都掌握在客户手中。如果你从别人那里拿钱，最好的情况是，你拿不到四分之一的钱，却做着本质上相同的工作。无用的水蛭到处都是，他们认为你是一个神奇的赚钱机器。一旦你有信心，就绕开他们。
我更好的建议是，除非你拥有自己的店铺或自己是自由职业者，否则就不要做涉及外部客户的工作。他们总是对价格和截止日期很敏感，这就会导致工作条件更差、薪水更低。从事资金充足、能带来收入的内部项目才是王道。你的工作条件也会好很多，因为客户是个混蛋，不能成为你不断加班或做其他无聊事的借口。
很好奇你为什么要跳过低级别的工作。薪酬？行业？知识没有帮助？
因为我最后做的 “商业 “事情远非低级，而且我有点喜欢它，再也不想回到 C/asm 中去了。
我很喜欢这个。虽然那些说它对新手来说太高深的评论者说得有道理，但我觉得这些问题仍然值得他们在学习过程中思考和回味。
唯一的例外是 “糟糕的代码会给你反馈，完美的代码不会。偏向于写糟糕的代码”。我对坏代码的经验是，它不会告诉我太多东西，相反，它会给我带来难以捉摸、令人费解的谜团。从注意事项和示例中，我认为作者试图表达的意思与此截然不同；类似于 “不要执着于完整性 “或其他理想软件的概念–我可以补充说，尤其是这种性质的教条式概念。
坏代码》的建议是给有完美主义倾向的人（显然就像作者 15 年前一样）的。
我的建议是：写简单、愚蠢、重复的代码，但要努力做到前后一致。
连贯、愚蠢的代码真的很容易在视觉上进行解析。重复的代码会消失在背景中，而不同之处则会突显出来。代码越多，就越容易看出哪些代码是组合在一起的（数据聚合/结构），整体流程应该是怎样的（控制、条件、顺序等）。然后，就更容易将一些因素考虑进去，或者如何更清晰地表达代码的作用。
但同样，一致性是关键。代码可以是 “坏的”，但进行简单的编辑，如重命名和重新排序，将它们归类到简洁的注释中，使结构保持清晰是非常有益的。
年轻时的我会做相反的事情：代码复杂而不连贯。我认为是急躁妨碍了我，我急于建立抽象概念，过早地将一些东西因素化，或者尝试用不同的方法来表达同一类东西（玩弄代码）。
每个程序员都有自己的倾向和历程，因此他们需要听取不同的建议，以便暂时忽略这些建议，但在某一时刻，当他们意识到这些建议的原因时，就会有一个 “啊哈 “时刻。
我认为这句话可以表述为：”偏向于加快发货速度。
也就是说，在大多数情况下，出现错误的成本非常低，以至于更快的反馈循环所带来的好处大大超过了更严格的开发流程所带来的好处。
(此外，缺陷的数量会随着投入的精力增加而逐渐趋近于零，即收益递减）。
同意。”完美 “的代码是不存在的，但好的代码在编写时会考虑到缺陷的发生，并在适当的层次上公开信息，以便人们在需要时获得所需的反馈。
我认为你从这句话中理解错了；作者说的更多的是你从最终用户和/或客户那里获得的反馈，而不是调试信息之类的开发反馈。
不，我指的是作为开发人员，当你意识到哪些 “糟糕 “的决定最终会成为技术债务，哪些是完全没问题的，只是节省了时间时，你所得到的反馈。
我不同意的一点是关于编辑的事情。
当我开始编码时，我花了几个小时来调整我的 vimrc 文件，学习所有基本随机的快捷方式，处理 vimscript 的荒谬之处（以及调试相互破坏的 vim 插件）。(这感觉就像真正的工作，而我却什么也没做出来。
现在，我只需用默认设置打开 vscode，就能马上提高工作效率。谁在乎什么编辑器，vscode 已经足够好了。
但也许只是 vim 太烂了，我应该一直用 emacs，我也不知道。
大多数事情都需要平衡。我发现，如果我每隔几周就试着学习一两个新功能或快捷键，最终我就会对我广泛使用的工具如虎添翼。
打字速度固然不错，但我不认为它是一个重要指标。这就好比有人在路上从你身边飞驰而过，而你却在下一个红灯时看到了他。其他事情也会拖慢你的速度，比如代码审查或需要等到规定时间才能部署。此外，copilot 和高级自动完成等功能也会让它变得不那么重要。
现在，我只需用默认设置打开 vscode，就能马上提高工作效率。
我马上就被光标行周围的巨大矩形、当前单词的高亮以及一切的跳跃性所困扰。在 vscode 中编码的感觉就像在巴西音乐节上写书。而且，它还不能随意做一些简单的事情，比如正确缩进或人性化的片段。解压缩 vscode 所需的工作量简直相当于从头开始创建 .vimrc。
一样。我也不知道为什么，但 VSCode 给我的感觉就像是在广告里编程，让我毛骨悚然。
我是个新手。我只用过 VSCode 和 sublime。这两种编辑器在从其他地方复制代码时都有一个问题，那就是每次缩进都会莫名其妙地出错。如果你说的是这个问题，有没有一种编辑器能正确解决这个问题？谢谢
我说的是嵌套缩进，就像这样：
f(a, b, g(c, d ) )由于缩进规则（简单的 regexes）的工作方式，Vscode 无法正确缩进。像 “prettier “这样的格式化工具是存在的，但它们只能格式化整个文件。也许可以试试（缺点是你完全受其摆布）。
我猜你遇到的问题要么是自动缩进，要么是部分选中行的问题（当选中行的两端都不接触时）。Vscode 和 sublime 应该也有办法在不重新缩进的情况下 “原始粘贴”。试着复制适当的非局部行和/或在第 0 列粘贴原始行，移除自动缩进，然后添加你的缩进。我知道这很乏味，但我见过很多用 MS 风格编辑器编辑的人，他们都有这个问题。大多数人只是把它当作生活中的一个事实。
作为 vim 用户，我恐怕帮不上什么忙。我的复制粘贴几乎总是以行为导向（V 模式下复制的行总是粘贴在当前行之后，无论光标在哪里），而且缩进规则非常强大，所以很少出现缩进错误的情况。我还有 gv> 和 gv= 来重新缩进粘贴的文本。我想在 stackoverflow（stackexchange）或 HN 上问问哪些常用编辑器有整行模式，或者 vscode/sublime 插件可以帮助解决这个问题。
在 Sublime 中，有一个命令可以在匹配缩进的同时进行粘贴。我认为在大多数平台上默认是 Ctrl+Shift+V。也许这就是你要找的？
作者声称，对开发工具的深入了解是一般熟练程度的良好指标，但如果是学习如何使用编辑器让你变得熟练呢？毕竟，没有人会在熟悉 Emacs 的同时不经意间成为 Lisp 的实践者（如果不是爱好者的话）！
我也是如此，现在我是函数式编程、Clojure、Scheme 等的忠实粉丝，这种经历和对特定代码编写方式的接触无疑让我成为了一名更好的程序员。听起来你在使用 Vimscript 时也有类似的经历：)
> 没有人在熟悉 Emacs 之后不经意间成为 Lisp 的实践者（如果不是爱好者的话）。
你可能会这么想，直到你遇到一个对 “底层 Lisp 东西 “一无所知的 Emacs 狂热拥护者。
我讨厌 vimscript。
我也一样。我大部分时间不是在打字，而是在思考。因此，精通 vim 或加快打字速度并不会让我变得更好。这并不是说我不赞成擅长打字。我对自己的键盘非常熟悉，可以触摸键入，我还知道一些 vscode 特有的键盘快捷键，但它们都很直观，如果我不想用，也有图形用户界面可供选择。
我认为每个人都有不同的阈值，从哪里开始收益开始急剧下降。虽然我完全赞同 “不要浪费时间对编辑器进行微调 “的观点，但一些小的快捷方式和工具却能让我在代码编辑方面更加流畅，而投入却很少。其中一个突出的例子就是 Sublime Text 所普及的多光标支持（现在我在 vscode 中一直使用它）。它消除了 80% 的重复键入或符号重构工作，而在旧的集成开发环境中，这些工作都需要通过菜单来完成。它就像现在人人都会的复制/粘贴快捷键一样，给人一种基本的感觉。
是的，我倾向于在发现自己重复使用相同的上下文菜单时才进行调整。这也是我最近学习键盘快捷键或映射快捷键的唯一目的。我还真没学过太多快捷键。最好的快捷键就是你提到的多光标编辑。
除了多光标，可录制的键盘宏也为我节省了大量时间。我非常怀念 vscode 中的这些功能
对我来说，这取决于任务。
如果我必须找出一个错误，或者有很多接触点的东西，是的，可能打字会少一些，思考会多一些。
但如果是一个新的基本自包含功能，我通常会思考一段时间，然后知道我需要构建什么，下一步就是写出堆积如山的代码。在短时间内从无到有，从少到多是非常有用的。
我的一位同事在使用 dvorak 时争辩说，因为用它打字更快，所以他是一个更好的程序员。
我从不认为打字速度对编程有多重要。但他的写作速度确实快得惊人。
打字速度是一个有趣的指标。
如果工具和键入设置允许快速迭代，并能快速完成迭代，那么相同代码的发布就会更快。选择一种可能需要更多工作的语言/框架也会拖慢你的速度。
更快地打字似乎有助于更快地思考，更快地排除故障。
打字速度过快可能会给人带来麻烦，因为打字速度过快可能会让人无法思考，也可能会让人过度关注一些可能会让你的工作无效的事情。
我让所有员工都做 typeracer.com。不是为了分数的高低，而是为了看到分数的发展，了解打字速度与快速思考的重要性。
输入代码本来就比写句子慢，所以如果你能在书面交流中打出更快的句子，那么输入代码也会更快，即使不是全速打字。
我很庆幸自己在本科阶段同时开始学习 vim 和 C。当然，vscode 已经足够好了，但除了工具本身，调整自己的工具也能获得很多价值。
制作东西并不一定是目标。探索才有价值。
我只需用默认设置打开 vi，就能立即取得成果。我试过 VS Code，试了半个小时都无法运行 “hello world “示例。
谁在乎其他编辑器，vi 就足够好了。
> 我只是用默认设置打开 vi，马上就有了工作效率。我试过 VS Code，试了半个小时都无法运行 “hello world “示例。
我认为你已经学会了 vim（否则你就不会 “马上就有成效”–你甚至不知道如何输入文本或保存文件），而你显然从未尝试过 vscode。这怎么能算是公平的比较呢？
没关系。做适合自己的事。我只是不认为无休止地玩编辑器是一种很好的消磨时间的方式。它会让你觉得自己在做实际的工作，而实际上并没有。我是这么认为的。
如果你是那种喜欢没完没了地玩编辑器的人，你才会没完没了地玩编辑器。
我的 vimrc 是多年来根据我的需要一点点设置的。几年后，我根据自己的经验，对我真正需要和不需要的东西进行了一次大修。现在我很少改动其中的任何内容。如果我开始使用一种新语言，也许会改动几行。
尽管如此，我使用的大部分 vim 仍然是为了理解缓冲区和动作，这不需要任何配置。
如今，你可以用一种真正的语言（lua）来编写 neovim 配置。我使用了一个名为 “Lazy “的预定义配置，它能实现 vscode 所能实现的一切。然后我开始调整快捷方式，删除和添加插件，学习更多 lua 语言。
然后，在我知道自己想要什么之后，我从头开始写我的配置，只写我想要的插件、设置和按键。
对我来说，这是一个非常有趣的过程。我喜欢简单地使用我的编辑器。它让我想编码。vscode 是一款了不起的软件，但我却无法从 vscode 中获得同样的乐趣或自定义功能。
e：在链中回复了错误的评论，但观点是正确的！自定义是我进入编程行业的原因。在 linux 上制作状态栏、调整配色方案等等。不要因为这不是你喜欢的工作方式，就讨厌修补匠。它可能非常有价值
VS Code 的启动设置真是一团糟。但作为一个编辑器，它就是一个编辑器。你可以就这样使用它。它工作得很好，有很好的默认设置，你可以用热键打开终端，等等。
我的工作效率很少受到与计算机连接速度的限制。我也一样，我只是用 intellij 来处理所有事情。
自从开始编程以来，我一直在使用 neovim。我进行了一些初始设置，并对其进行了一两次调整，但它对我来说绝不是浪费时间的来源。最近，我不得不改用 VSCode，在学习所有开箱即用的按键绑定时遇到了很多问题，而且没有我习惯的望远镜和模糊查找窗口也让我的工作效率大打折扣。当我能够跳回 neovim 时，真是如释重负。
vscode 至少是我的图形界面文本编辑器……但它还在不断成长:)
我们不应该把学习新东西的时间浪费在其他已经熟悉的东西上。
如果新工具（即 vscode）能导入您的 neovim 设置，并为您提供等效的设置，那就太好了。
比较一下 neovim 和 vscode 的沉没成本时间可能会更有趣。Neovim 肯定比 vim 更精良，所以完全有可能非常接近。
如果 vim 用户想学习类似 vscode 的东西，他们只需在 vscode 中安装一个 vim 扩展，就能用 vim 键浏览大部分 vscode。Youtube 上有很多这样的教程。
如果不安装 vim 扩展，就很难使用网页浏览器。
的确，如果你花时间为自己超级定制了任何设置（目前我正在研究我的宇航设置），我有时会遇到的问题是，我必须在 neovim 中定制的东西，可能已经内置在 vscode 或其他东西中，反之亦然。
重复是为了建立肌肉记忆，类似于在 vim 中建立相同的按键。
我很幸运，在我有大量空闲时间的时候，我对 vim 的使用已经达到了得心应手的地步。
在我没带设置的时候，我的 vscode 就很好用，但我使用 neovim 时的设置是向前迈进了一步，但 vscode 有时还是会在我所处的位置出现问题，这时我就会想办法让它表现得更好一些。
作为 vim 用户，我认为两个世界都有各自的弊端。
Vim 有：良好的编辑模式、良好的设置、可编程性、神秘的控件和语言。
Ms-style 通常有：广泛的插件系统、糟糕的设置、糟糕的编辑模式。
我希望能有一种编辑器/IDE，它既有好的编辑模式、好的设置、可编程性和丰富的插件系统，又没有复杂的控件和语言。
基本上就是把 vim 改成 ms++，把 vimscript 换成 ts，在其周围添加可选的常规 vscode。在我看来，这样的编辑器会将它们一网打尽。
我想我的意思是，很多时候人们说某种工具（或语言，或任何东西）更简单，其实他们的真正意思是他们已经习惯了。
事实上，你使用某样东西是因为它能引起你的共鸣（或者说它是你唯一的资源），然后你就会精通它，然后其他东西就会成为你的障碍。
我不认为这一点与配置编辑器/环境有关，而只是与了解编辑器/环境有关。有些功能会经常出现：查找文件、查找类、转到实现、查找引用、重命名变量等。
几乎所有的编辑器/辅助工具都有做这些事情的方法，但有多少开发人员手动做这些事情却让我大跌眼镜。
在某些生态系统中，工具并不是那么好用。以 ruby on rails 为例：如果你按照集成开发环境对代码布局的期望来做，效果还可以，但生成的方法和变量除了名字什么都没有–没有文档、没有源代码、没有可 google 的标识符，什么都没有。在这种情况下，除了调出轨迹（或库）源代码来尝试辨别其意图外，别无他法。
根据我的经验，lisp 也有这样的问题，即在一般意义上很难工具化，就像多年前编写 c/c++ 一样（也许现在对宏生成符号等东西的识别能力有所提高）。
> lisp 也有一般意义上的工具化非常困难的问题
大多数常用的 lisp 工具已经存在于语言本身。像 inspect、trace、describe 和 apropos 这样的工具已经与大多数集成开发环境相当。对于某些动态语言和魔法方法，我同意你的看法。要回溯被调用的确切函数可能很难。但只要代码遵循生态系统惯例（PhpStorm 中的 Laravel 插件），你总能设计出一些工具。
Vim（以及其他可配置的编辑器）的好处在于，可以很容易地将现有工具与编辑器本身结合起来，而无需将扩展本身作为一个完整的项目。
我发现这是动态语言的一个缺点。C++ 和 Java 等语言的集成开发环境在跳转到定义、显示引用、执行自动重构等方面都相对快速和准确。我很少看到任何编辑器或集成开发环境在处理 TypeScript、Python 和其他非常动态的语言时能达到同样的精确度，即使最近由于 LSP 和更好的工具而有所改进。理论上，几乎任何东西都可以在运行时打补丁–即使这样做是个糟糕的主意，而且每个风格指南都说不要这样做–对于工具来说，在处理动态语言时做出与处理静态语言时相同的假设是不安全的。
> 现在，我只需用默认设置打开 vscode，就能马上提高工作效率。
看着普通开发人员使用他们最常用的工具如此缓慢，我总是感到非常痛苦。使用鼠标/触摸板滚动/选择单词的速度慢得令人难以置信。学习和配置可定制的文本编辑器，就不会碍手碍脚了。
编程主要是通过 “转到定义 “和类似的代码操作来阅读和浏览代码。只要能快速完成这些操作，就能立即极大地提高工作效率。
100%同意默认设置。我认为真正学习集成开发环境的功能至关重要。是的，打字速度快与编程毫无关系，但能够跳转到符号、进行重构、使用键盘快捷键等却能缩小手脑之间的差距。
这可能是我最喜欢的 XKCD：”值得花时间吗？¹”（Is it worth the time?¹），它展示了两个重要的观点。如果你很少做某件事情，那么花时间将其自动化的投资回报率并不高。但是，如果你经常做的事情只需要一分钟甚至几秒钟的时间，那么你就可以花费大量的时间对其进行优化，并在以年为单位的时间框架内获得丰厚的回报。
我认为，花时间学习如何高效地使用我的工具，并将常见任务自动化，是一种合理的投资。编辑器就是一个很好的例子。当然，我可以启动任何常见的编辑器，然后高效地编写代码。但在我所选择的完全定制的编辑器中，我可以插入和调整常见的代码模式，而使用模板和宏，我只需花 10-30 秒就能完全键入这些代码。我只需敲击三下键盘，就能跳转到屏幕上可见的任何位置。我可以看到我经常使用的各种文件类型的语法高亮显示，包括一些没有现成定义的不常见文件类型，还能在工作时实时看到几种不同编程语言的警告。
每次使用这些功能都能为我节省几秒钟时间，但每天又能节省多少时间呢？到现在为止，为设置这些功能所付出的努力可能已经得到了 100 倍的回报！没有延迟也是一种质的提升，因为这意味着一旦我准备好开始写作，我就能以最快的速度完成写作，而不是一直被拖住或被打断。
¹ https://xkcd.com/1205/
> 如果你很少做某件事情，那么花时间将其自动化的投资回报率就不会很高。
对于代码编辑，也许是这样。但在一般的软件工程中，有些任务我可能每年都要做一次，甚至更少，但因为我不记得细节，这些任务总是比它们需要做的痛苦得多，而无论何时，只要我将其中的哪怕一部分自动化（或者是，只是将文档记录得更好一些），就会发现这是非常值得的。比如引导新环境、一些与数据库相关的工作等。
将所有命令粘贴到随身携带的文档中，似乎能为每年 1-4 次的任务自动化带来 90% 的好处。
花费时间的不是键入命令，而是记住要键入哪些命令。
多做难做的事。https://martinfowler.com/bliki/FrequencyReducesDifficulty.ht…
当然，我尝试 “自动化”，或者至少将我所做的几乎所有事情都编写成脚本。
我这样做几乎都是出于重现和记录的目的。
可能不值得花时间去自动完成这些工作，但我总是会花时间记录这些工作，通常是在黑曜石中，这样我以后可以很容易地找到它们。
我非常喜欢把事情写下来，以备将来参考。写日记记录我使用了哪些命令，或者把这些知识转移到 README 或维基页面上供他人查看，这些都是低投入但有时高回报的习惯。即使是很少做的事情，如果下次能节省很多时间，也能证明记录的努力是值得的。
同样，如果自动化工作只是将这些命令逐字复制到 shell 脚本或类似文件中，那么时间往往花得很值。但正如 XKCD 所演示的那样，当你开始花费更多时间让脚本变得更 “灵活 “时，就会陷入陷阱。将硬编码值转化为参数。从环境中查找上下文。在多个开发平台上。在暂存、UAT 和生产部署中也是如此。还有详细的帮助文本来解释这一切，并说明如果没有明确指定，一切的默认值是多少。然后事实证明，无论如何，你实际上每六个月才会运行一次脚本，而且无论如何都不会使用 95% 的额外灵活性……
我把 XKCD 打印出来贴在我的隔间墙上。我经常引用它来解释为什么不应该实现某些要求的功能等。
我经常使用它，以至于公司里很多非技术人员也开始采用它。
> 但也许只是 vim 很烂，我应该一直用 emacs，我也不知道。
老实说，是的，我觉得就是这样。好吧，vim 作为文本编辑器并不烂，但如果你真正想要的是 VS Code，那它就太烂了。不过，Emacs 并不烂。我现在很少花时间调整 Emacs 的配置，但即使花时间也是为了解决 VS Code 用户不得不忍受的问题。我看着他们的肩膀。他们忍受了很多。
学习 vim 会让你学会代码编辑的新思路，如果你用 ssh 登录机器，学习 vim 也很有用。我认为学习本身就有价值，而且我认为即使你回到 vscode，它也可能教会你如何更好地导航，比如你可能意识到文件树并不那么有效，最好通过模糊搜索来导航。
此外，还有一种集体观点认为，让微软垄断编辑器市场可能会带来灾难性后果。
我持保留意见。当我更痴迷于 Flow State 时，我确实看到了花闲暇时间阅读文档（尤其是发布说明）和键盘快捷键映射来找到更快的方法来做我经常做的事情所带来的好处。
也许我遇到了收益递减点。也许是因为我不再经常 “像地狱一样编码 “了，但这是我养成的习惯。我一直下定决心要重新开始，但事实上我并没有这么做，这也许在告诉我一些事情。也许我已经用其他更有价值的事情填满了业余时间。
这个
我资历尚浅，但根据我的经验，从长远来看，与团队的工具链合作比与之对抗要好得多。
我曾在一些团队工作过，安装 neovim 会让 IT 部门感到困惑，因为他们不会收到这些请求（甚至可能不知道它的存在！）。
这有点像一些生产力博客，他们沉迷于自己使用的记事本、笔和应用程序，花大量时间纠结/拖延无关紧要的事情。无论我使用什么编辑器，我仍然会学习过去 15 年来一直使用的快捷键，但我的大部分时间都花在了思考和讨论问题上，而不仅仅是在编辑器上打字。
当软件开发人员自信地认为软件不可能提高他们的工作效率时，我总是略感悲伤。
你开始编码的时候，有 vscode 吗？现在有了 lazyvim，如果你想 “只用 vim”，可以跳过所有的微调。
虽然 VSCode 也能或多或少地有效使用。有很多快捷键和技巧可以让你的工作效率提高 10 倍，即使可能还比不上 vim。
十行多光标，当然。你可以在几秒钟或几分钟内提高 10 倍的效率。我认为，在两周时间内，因为掌握了编辑器中的高级技巧和窍门而使工作效率提高 3 倍的人几乎为零。说 10 倍似乎太夸张了
15 年前我会给自己的一个建议：
在企业界，要非常擅长管理。你只需要在编程方面足够优秀，就不会被解雇。每个人对软件技术都有自己的看法，没有人去衡量任何东西，所以这实际上只是一场人气/工具游戏。唯一的目标就是保住饭碗或从软件中晋升，精通软件只是分散目标的注意力而已。
如果你想在编程方面取得优异成绩，那就把它当作一种爱好，并正确地设定你的期望值，即这只是一种爱好。
我真的很讨厌这种态度。这简直是自取灭亡。要想在事业上有所发展，唯一的办法就是成为一个毫无价值的小中层管理者寄生虫？我宁愿辞职。我知道这是一种普遍的想法：只要编程的时间足够长，你就永远不用再做了，然后你就会得到一份舒适的工作，告诉其他人该做什么，花几个小时在毫无价值的会议上，提出一些短视的 “倡议 “来提高你的狗屁指标，这样你就可以爬得更高，一遍又一遍地玩你那可笑的游戏，同时吸干真正的员工正在做的工作的血。不幸的是，你甚至可能是对的，对于某些只关心用尽可能少的工作赚尽可能多的钱的变态自恋狂来说，这是最佳策略。但有些人希望在职业生涯中做得更多，而不是成为寄生在他人辛勤工作上的黏糊糊的小虫子。
你对管理的态度也是自取灭亡。好的管理者会确保员工没有处理错问题，清除障碍，保护团队不受上层干扰。
这与我的经历不符。我开发功能的速度比团队其他成员都要快，还实施了很多业内不为人知的做法。结果，我们交付了更多的产品，我也得到了晋升。
如果有人说，没有经过测量的东西只是一种观点，你也要区别对待。你所做的大多数重要决定都是无法衡量的（但有很多决定是可以衡量的），但这并不意味着没有好的和坏的决定。
你能详细解释一下你所说的管理是什么意思吗？
不是 OP，但我想说的是，一般来说，能让业务人员满意的非工程方面的事情。项目规划、任务委派、仪表盘和指标（如果能获得客户反馈，那将是一大优势）、设定并遵守最后期限，以及知道如何推销自己。
有一种古老的（也是非常正确的）智慧认为，如果你在两天内解决了一个复杂的问题，业务人员不会认为 “哇，这家伙在两天内就解决了这个问题，真是聪明又勤奋”。他们会想：”哦，这个问题肯定不难解决。让我们给他分配额外的工作吧”。在职业生涯中，成为一名优秀的工程师只会让你走得更远。
撰写充分、清晰的文件，精确的沟通，尽职尽责地完成所有工时表，记录已完成的工作，参加所有要求的会议，并始终按时完成工作。
[已删除］
我见过的所有 “10 倍程序员 “都比 “看钟人 “更容易被利用，更容易被当作公司的奴隶。
在开会时，我会 “俯首帖耳”，和颜悦色。到了周五晚上，我下班后和女朋友去约会，却不得不让 Slack 保持沉默，因为那个 10x 的家伙被骗去开发一些奇怪的功能，而不是去享受生活。最后，我还是拿着同样的薪水和股权。在这里，谁才是真正被行业压得喘不过气来的人？
你的工资和股权与业绩最好的人是不一样的。很少有公司会在不考虑业绩的情况下统一加薪和发放奖金。
如果你的经理在乎工作效率，那么 10 倍速的程序员会更有优势。
绩效与薪酬之间的相关性真的很弱。
以我的经验来看，可能也是负相关，因为大多数工作似乎都是由初级员工完成的，而最资深的员工却在忙着时不时地修复一些他们前段时间写的东西上的漏洞。
同意。我提高工作效率的主要动机是腾出工作时间供个人使用。就是这样。当我成为 10 倍开发者，每天有效工作 1-2 个小时时，我会把这当作一个不可告人的秘密。我知道，我不会因为工作效率的提高而多拿 10 倍的薪水，我也知道，只要我一提，机构就会想方设法以各种非生产性的理由从我这里拿走这些时间。
我是作为一家奖励生产力的公司的经理告诉你的。我们会根据领导和同事的反馈意见来确定进修百分比和奖金。
高级打卡者只能拿到基本工资，几乎没有更多。由于绩效奖金股票的叠加，职称较低的高绩效人员很容易在几年内超过职称较高的人员。
如何衡量生产率？
当然可以。过于努力想成为一名伟大的工匠的问题在于，你会变得感情用事。你的大多数同行不会有这种情况，也不会理解。
还有人提到，你成为了 10 倍开发者，却在职业生涯中被超越。这绝对是非常现实的。
> 你的建议基本上就是在每天的会议上奴颜婢膝、唯命是从，在分配的时间之外一分钟也不能离开你的工作岗位，参加所有的弯腰会议，并在接受会议时表现得和颜悦色，准确无误地说出他们想让你说的话，并永远做他们想让你做的人，即一个没有原则、取悦于人的大绿帽子，没有人能够真正信任或尊重你。
我到底读到了什么？
我觉得这是一个不伦不类的人可能会反刍的那种杂谈
文书工作远比实际工作重要。至少就赢得加分和晋升而言，Jira 票据（或其他）的更新和高度细化，以及按冲刺/进度等分类的组织，当然还有与队友的实际状态沟通，往往比你完成的任何实际代码的价值都要高得多。
这与我的想法不谋而合。我为赚钱而做的编程与我作为业余爱好而做的编程截然不同。
如果不把它们分开，我很快就会失去热情。
[删除]
你是对的，但 OP 也是对的。如果你能做好政治工作，你就能通过增加筹码超过 10 倍的程序员。所以，我想两者都要努力。
刚开始编程时，这些建议太抽象了。
你只能理解他们，因为你经历过这些情况，这意味着你没有经验。
我会说（特别是对年轻的自己说）：
– 实践是无可替代的。少看教程，多编码。
– 不要再执着于质量：你还没有达到可以提供质量的水平。做肮脏的事。做得不好。但要出货。有些人会生你的气，他们是对的。但还是要做。是的，重启有用户的服务器。是的，提交意大利面条。你会达到你想要的水平，避免做这一切。
– 用户并不关心技术。他们关心的是结果。
– 为了达到目的而做一些事情是值得的。只要把它与上述观点分开，就不会产生冲突。
– 编程是一场与复杂性的斗争。反复强调。把这句话写在便签上。根据它做出决定。你会做得很烂，但请尝试。
– 你有冒名顶替综合症，因为你就是个冒名顶替者。你真的很糟糕。没关系，医生在学习救人的同时，也会伤害别人很多年。别担心。会好起来的。
– 你要相信一切都会好起来的。从长远来看，你会在这方面做得更好。但在短期内你会发现问题所在。你会找到解决办法。只要你坚持不懈，即使过程漫长而不公平，也会成功的。即使现在感觉并非如此。
– 正确的团队比正确的技术更重要。如果你是孤军奋战，那就时常与那些能让你振作起来的人联系。
“当你开始编程时，这些建议太抽象了”
我得出的结论是，这类文章的作用并不在于读者（无论年轻与否）会立即正确地将所有课程应用到生活中。
它更多的是让人们意识到他们目前可能还没有看到的问题，以及他们目前可能还没有意识到的解决方案。这是为了缩短学习曲线，而不是消除学习曲线。
一个学了一年的程序员无论读什么书，都不可能把自己读成一个学了 20 年的程序员。但在 5 年的水平上，我认为你会看到很多不同：有人从不考虑自己的技术，从不鞭策自己，只是低头做下一个 bug；而有人哪怕只是偶尔读到这样的文章，思考如何将其应用于自己的当前情况，并从中汲取精华……这可能与两年后读到完全相同的文章所汲取的精华完全不同。
是的，反驳 “你不知道你不知道的东西”。
这些似乎和我的一样抽象，甚至更抽象，而且至少我在可以举例的地方提供了例子。你批评我的帖子是 “一般性建议+例子”，然后又提出你自己的一般性建议，却没有例子，这感觉很奇怪。
此外，我知道这只是一个比喻，但医生绝对不会在试图救人的过程中伤害他人数年之久，这与我们的职业截然不同。
我认为你们试图针对不同的受众。你的建议主要针对的是已经从事程序员工作的人，而家长评论中的建议主要针对的是完全的初学者。
例如这条提示：
– 实践是不可替代的。少看教程，多编码。
直接针对绝对初学者的一个常见错误。许多初学者会阅读（或者更糟糕的是，观看）大量的编码教程，却很少动手实践。这是一个完全的初学者都会遇到和理解的问题。
另一方面，您的建议
> 如果你（或你的团队）经常自寻烦恼，那就把枪修好吧。
是针对使用内部工具开展大中型项目的人员。这不是一个完全的初学者会遇到的情况，而是一个已经在编程领域工作了一段时间的人会遇到的情况。
我并不认为你的建议过于抽象，对于初学者来说，这些建议实在是太高深了。
这并不一定是坏事；也许 15 年前的你已经具备了理解和使用你的提示所需的基本知识。
我并没有把这看成是对你帖子的批评，只是把它看成是另一种观点。你的帖子更有条理，可能也经过了深思熟虑，而这个人的只是一种观点。没必要辩解。
我对医生的经验是，年长的医生要好得多。如果我需要做一些精细的手术，我想找 50-65 岁左右的医生。他们知道自己在做什么，不会乱来，而且他们见过的病例足够多，知道是的，你的病例是他们见过的最常见的病例，而且这种治疗方法有效，那种治疗方法无效。
我非常喜欢 “你应该知道编辑器中的所有主要快捷键。你应该是一个自信而快速的打字员。你应该对操作系统了如指掌。你应该精通 shell。你应该知道如何有效使用浏览器开发工具”。
对于像 PM 这样的职业和角色来说，打字技能被严重低估了。
我认为你们两位都提供了某种世代相传的建议，就像父母为孩子提供人生建议一样。不幸的是，或者说幸运的是，他们必须先从自己的失败中吸取教训。
我从事开发工作 30 多年了：
> – 实践是无可替代的。少看教程，多编码。
我会把这句话改成 “写点东西吧！”
很多时候，我发现自己成了 “完美是好的敌人 “的典型例子–我会考虑完美的解决方案，而不是写一些*现在*能用的东西，然后重构以达到完美。TDD就是这样。
其他方面
– 小心测试版和老板。如果它能运行，只要你的经理看到了，它就一定会被运走。许多经理无法估算维护一个勉强够好的东西的未来成本。
– 经典孔子语录”吾闻而忘之。我见而我忆。我行我素”。如果你有足够的兴趣去阅读一些技术/语言/框架，那就写点东西吧（再来一次！）。
– 除了你的主要语言和生态系统外，至少学习一种其他语言和生态系统。即使语法上相似（例如 C++、Java、C#）。
> 实践是不可替代的。少看教程，多写代码。
在过去，这可能对你自己是个好建议，在很多时候对很多人也是个好建议，但如果把它作为一般性建议，我会犹豫不决。阅读他人编写的代码是学习有价值的东西（从基本模式和算法到语言特点和习语）的重要途径，这一点不应被低估。如果你在一个团队中工作，无论如何都会这样做，但也有可能写了很多代码却没有意识到有更好的方法。
不过，我要指出的是，阅读代码与阅读教程并不相同。阅读代码时会有一种意向性和专注性，而当你对代码了解不多时，这种意向性和专注性就会缺失，因此你最终可能会陷入学习多个教程却没有真正亲自尝试的陷阱。
教程中包含一些代码，其目的是让新程序员能够理解这些代码，使其具有示范性和简单性，因此我不会将其视为阅读代码的一部分。实用代码并不总是具备这些特性，不过如果你只阅读教程中的代码，肯定会错过很多东西。
我完全同意 “实践是不可替代的 “这一说法，我甚至可以说，你读到的代码如果没有运行和调整，就不能算数。
试图从教程中学习成为一名开发人员，就好比试图通过阅读锯子、射钉枪等的使用说明书成为一名木匠。
要学习如何执行计算机程序，就得阅读相关书籍。
对于什么是教程，我们可能有不同的看法。在线教程的质量参差不齐，但像 Python 官方教程 https://docs.python.org/3/tutorial/ 这样的教程是很好的资源。我甚至认为这两个类别并不相互排斥–我会把《计算机程序的结构与解释》既称为一本书，又称为教程。不同的人可能觉得不同的资源最有帮助。
此外，”要学习如何执行计算机程序，就去阅读相关书籍。”与原评论中的 “没有什么可以替代实践 “相矛盾，我不太满意。
我不会称它为教程。它是参考手册，只是增加了字数和一些关于 pip 等的内容，让尚未入门的人更容易接受。
你需要从阅读开始，否则你很可能一事无成，每天使用网络浏览器的几乎所有办公室白领都能在不阅读相关书籍的情况下自行了解 JS 控制台和应用程序开发，这就是最好的证明。比起教程，我更推荐书籍。
但是，正如我所说的，你需要构建东西，并向其他构建者学习。
这确实不是一般的建议，这是给我的具体建议，我以前经常打着学习的幌子拖延时间。
我也一样。我也会陷入同样的陷阱。再看一篇文章、一本教程、一本书的另一个章节……只是为了确保我理解了这些概念；而实际上有什么帮助呢？只是编码、出错、修正、出错、修正，等等。
我绝对同意，阅读他人的代码是一种很好的学习方法，尤其是如果你花时间逐行拆解，并查找他们使用的语言特性和函数、结构等。
我认为，因为你分叉了一个项目并想继续下去，所以阅读代码来理解它，这与遵循教程是截然不同的。
但除非你以前写过糟糕的代码，否则你不会意识到哪种方式更好。
切题，但我认为这就是试图从设计模式中学习的问题所在。
我读到了关于设计模式的文章，并试图应用它们。
这是一种落后的做法，不会产生任何好东西。
我开始反过来理解它们：
– 编码，解决问题。
– 阅读他人的资料。
– 然后重新发明半个糟糕的设计模式。
– 后来，看着一本书：”哦哦，这就是我想做的 “或 “哦哦，这就是那个源代码中的片段”。
– 现在，我可以和别人讨论这种模式，并根据它来命名我的代码实体。
设计模式是一种交流工具。
> 你有冒名顶替综合症，因为你就是个冒名顶替者。你真的很糟糕。没关系，医生在学习救人的过程中伤害了很多人。
什么医疗事故？
犯错或做出合理但最终不正确的决定并不是渎职。医生也是人，和我们一样，当然也和你一样。如果你认为医疗系统比实际上更像一个安全网，那就太可怕了，但你抱怨的是生命的不稳定性，而不是医学。
不过，”别担心，你是个冒牌货，但你只能通过搞砸来学习 “绝对不是医生学习工作的方式。
希波克拉底誓言不是’首先，只要你在学习，就做一些伤害’。
约翰霍普金斯大学最近的一项研究称，美国每年有超过 25 万人死于医疗事故。
冒名顶替没关系。
在你的印象中，医学界认为这样做可以吗？
给我看一家医院，我就给你看那些工作过度、睡眠不足的年轻医生，他们必须处理文书工作，在游说严重的领域里游刃有余。
但即使没有这些，问题是，当你不知道的时候，你就会犯错误。
而当你的工作是照顾病人时，错误就会伤害他们。
这是事物的本质。
去年，我经历了 3 次医疗失误，其中一次差点要了我的命，都是那些好心的专业人士造成的。
闭上眼睛假装没有发生这种事，充其量只是天真。
但人们总得有个起点。他们不可能永远停留在理论上。再多的准备也无法避免犯下可怕的错误。
既然我们不能全天候为每个实习生安排一名经验丰富的医生，那就暂时没有真正的解决办法。
编程也是一样。
医疗工业联合体显然是这么认为的，否则就会大幅降低病人负担，为医学院提供更多名额，并提供更好的工作条件，从而减少失误。但这一切都没有发生，而是默认了医疗失误导致的死亡。
他们显然接受了。看看他们管理住院医生项目的方式就知道了。在极少的监督下，他们让那些可怜的孩子累得半死。只有最虚伪的人才会在出错时假装是意外。这个系统显然是为了害人而设计的。
是的。没有什么是完美的。他们选择的补救措施就是依靠保险。我们称医生的办公室为 “诊所 “是有原因的。
你认为他们之所以被称为诊所，是因为这个词的用法不太常见，它的意思是业余学习者，暗示他们没有经验/没有经过培训？
而不是指从业者工作的地方？(而不是指从业者工作的地方？）
有，但不是你暗示的那样。
是啊，让我们去建造一些偷工减料的桥梁，顺便撞毁一些飞机吧。
新手可能会觉得自己是冒牌货，但我们不应该拿这样的统计数据来举例说明为什么可以这样做。
我真不敢相信人们会这样想。
飞机和桥梁的质量控制可以集中进行，因此可以设置大量冗余。
即便如此，波音公司的丑闻也表明这并非刀枪不入。
医学也是如此。医生的数量远远超过安全网的数量。此外，飞机失事会上报，需要花钱和公关。而医生就不一样了。
飞机行业本质上并不更道德，只是更需要承担责任。医疗行业的责任则要淡化得多。
我们并不想为人们的学习付出代价。我真希望去年我没有吃错药。
只是目前的系统还无法做到这一点。
所以，你可以感到内疚，停止行动，但你不会学到东西。你不会成长。实际上，你会在更长的时间里伤害别人，因为你仍然会犯错。
或者，你也可以坦然面对，接受不可避免的事实：做事意味着要给世界带来实际的后果。
如果你愿意，你可以用一生去改变整个系统，让它变得更好。但我不认为这个主题中的任何人现在正在这样做。
我确实看到很多人骑着高头大马，但却无所事事，因为他们在寻找一种永远不会破坏任何东西的方法。
比如我。多年来
当然，我们是人类。这一点无可争议。
然而，将人命损失作为学习算法的一部分正常化，则是一种心理变态。犯错是有时间和地点的…在关键任务情况下，也就是在训练和其他任何地方，我们都应该渴望采取保障措施，防止因失误而造成生命损失。
在医学领域，很多死亡都可以通过加强护理来避免。在这方面，它与工程学并无不同。更大的问题在于决策者将利益置于生命之上。而这个话题中的这种心态正是对这种行为的推波助澜。太恶心了
我认为你误解了这里两个不同点之间的单一观点。
最初的短语是 > 医生在学习救人的过程中伤害了人们多年
然后是别人关于错误/渎职致死的单独回复。
因此，似乎没有人在表达你正确地抨击的心态（至少就我在评论中看到的而言）。但是，由于这与我们都希望传授给自己的经验教训有关（在我看来，这是因为我们希望让自己对未来的经验教训负责），让我们来谈谈评论中的大象。
将死亡，尤其是可预防的死亡正常化，绝对不是这里任何人的建议（就我所了解的情况而言）。
将责任常态化，承认我们可能造成伤害，并为此做些什么，这似乎更符合上述评论。
正如你自己所说，有一个时间和地点，这无疑是我们希望为那些年轻的或刚开始学习编程、医学或工程学以外的任何学科的人所培养的。
没有人说死亡和损失是可以接受和正常化的，而是说在现实世界中，我们需要有一定的存在感，知道无论如何，它们都会在一定程度上发生。因此，我们要为我们能够预防的事情承担责任，并牢记这一点，努力将我们的能力推向更高的境界。不幸的是，对于一些人来说，这来自于经验。而对于其他人来说，他们可以通过考虑后果和后果的严重程度来着手解决这个问题；正如上述评论所证明的那样，至少是暗示性的。
幸运的是，这些并不是培养负责任心态的唯一途径，但它们可以是这样的，即使你发现字面上的措辞并不如此。当然，我不能证明他人的 “真实 “感受，但其他人也不能……但本着这种精神，请考虑一下：反过来，你的责任感似乎也乐于发现在哪些方面，这种想法可以成为它本来可以阻止的事情的理由，要么是专门为这个角色打造的挡箭牌，要么是出于方便而共同采用的挡箭牌。这也是不可或缺的，因为我们始终需要避免自满，因此也必须促进这种警惕性，使其成为负责任心态整体的一个健康部分 — — 以免我们成为我们试图防止的东西。
正如你所说，存在着更大的问题，但这种想法并不一定是问题的理由，而且确实可以成为另一种对抗问题的工具。更多的责任感，对我们的意图、行动和后果的更多关注？这将被证明是我们真正解决更大问题所不可或缺的，所以我们必须认识到，要解决这个问题，需要不同的途径，毕竟，这个问题有许多不同的理由，而这些理由都需要被有力地驳斥，并显示出它们的本质。这样做并不能解决问题，而只是我们需要采取的众多步骤之一。
无论如何，这种对自己和对他人的警觉和警惕，将通过相互促进而自我提升。如果有人必须把后果的严重程度想象成发展这种能力的一部分，那就这样吧。反过来，他们最终也会努力保持这种警惕，因为他们有责任这样做，否则他们最终可能会采取与你所担心的心态完全相同的行动和后果，即使他们实际上并没有 “打算 “这样做。学习永无止境，错误也永远不会停止，因此我们必须认识到这一真理的全貌；即使我们只能在有限的能力范围内尽力而为。
> 最近，约翰霍普金斯大学的一项研究称，美国每年有超过 25 万人死于医疗失误。做个冒牌货也没关系。
这就是我最初回复的内容，至少在我看来，这似乎意味着预防性死亡是 “冒名顶替阶段 “的某种培训税。也许这并非发帖人的本意。
感谢您深思熟虑的回复。
有点尖刻，但我想补充一点
– 不要从列表中读取意见，并将其视为福音。适应你所从事的工作，你就会形成自己的观点，但现在要有经验来解释原因。每个人都需要承受足够多的打击，直到你大脑中的模式寻求区接管为止。
也许还可以补充一点：试着在一个角色上待足够长的时间，以便真正感受到自己行为的后果。如果你能在传呼机上待上一段时间就更好了。我知道如今在一份工作上呆很长时间并不时髦，而且传统观点认为这对你的薪水也没有什么好处，但有一件事会让你明白，你所做的决定究竟是好是坏。
我曾在一些岗位上工作过，直到多年后才真正了解到决策的真正影响。我很庆幸自己能有足够长的时间来经历这些。
亲身经历很重要。
我有一个糟糕的程序员朋友。
他比我遇到的大多数人都更擅长创造实际产品，因为他的生计岌岌可危：他只能靠网站赚钱。
因此，他不是活在抽象的最佳实践理念中，而是在过去的二十年里，在资源匮乏的情况下，不得不让网站盈利。
他做到了。
10 年过去了，他还在问我如何编写 git 命令。而我仍在向他学习，从我的实践中剔除大量的废话。
直接与工程的财务结果挂钩，会让你很快放弃 Scrum 而选择 Scheme…
在我离开一个组织很久之后，我还曾被要求重新编写代码，并在10-12-15年后重新审查我自己的代码。在现实世界中看到决策的积极和消极方面是很难从阅读中获得的，而且我认为即使你在同一个组织中待了那么久也很难获得。在组织内部，你会合理化代码、团队和组织随着时间推移而发生的许多变化，因此可能更难更客观地看待代码所产生的影响。
我曾为某些决定感到自豪，但也意识到了其他决定的长期负面影响。在某些情况下，试图与他人分享经验和 “智慧 “或 “教训 “本身就是一种挑战，因为你很容易被认为是 “不了解 “当前趋势的 “老人”。有些问题是长青的、根本性的，但对于经验不足的人来说，很难理解为什么有些事情是真正的核心。我不确定在很多情况下经验是否可以替代。
我完全同意这个建议，十多年来一直如此。我认为，如果你知道是自己造成了这样的后果，就能更好地吸取教训。你有可能会明白自己当时的假设与现在的假设有什么不同，从而让你清楚地看到应该吸取的教训。
我同意，当你有足够的信息时再形成你的观点。
例如，如果你无法在两种数据结构或技术之间做出决定，那就选择其中一种并添加评论：
// 我不确定
我同意，这相当于
> – 实践是不可替代的。少看教程，多编码。
是的，没错。在我看来，”列出你必须知道的所有事情 “的观点有点过于具体。(而不是太抽象）
多年前，在我职业生涯的起步阶段，我也曾引用过类似的话，”因为 X 说过，所以应该这样做 “对我一点帮助都没有。
这感觉就像是在与 “资历太浅 “绝缘，因为你可以全盘照搬别人的想法清单，这样就可以了。但是，因为初入职场而犯错，恰恰是形成这些观点的基础。
很好的建议（比 OP 更好）。在你意识到自己已经精疲力竭，而且没有得到那个促销机会，而是给了那个骑自行车的毫无价值的同事之前，这个建议还是有用的，因为他显然更不配。
积极性、工作效率一扫而空。你根本不关心工作、团队、代码质量、编造的截止日期或实际问题。
真正的成熟从现在开始。你要学会欣赏自己的极限，看清什么才是真正重要的，尽管别人在说什么，并观察谁在打电话，他们的目的是什么。
最后，当你选择了一条道路，而且这条道路似乎行之有效时，你就会在理想主义的公关评论和下一次面试之间找到平衡。
直到健康或孩子等其他事情动摇了你的想法。
放轻松，对你来说，你比你的工作更重要。15 年后，只有你的家人和孩子会记得你在工作中度过的周末。多出去走走，在各种艺术中寻找慰藉。享受你无痛的身体，直到永远。让平日出现在周末之间，而不是相反。多笑。好好吃饭。感受周围的环境。交朋友，留住朋友。留下美好回忆。不要把生命浪费在琐碎的追求上。如果一项工作真的那么重要和有意义，它就会表现出来。不要去寻找它。
不要再执着于质量：你还没有达到能够提供质量的水平。做肮脏的事。做得不好。但要出货。
你会达到你想要的水平，从而避免做这些事。
如果未来的你已经达到了这个水平，而你团队中的人却在运送意大利面条，那该怎么办？
我觉得这是个糟糕的建议，真的，你需要执着于质量和发展，但你不能因此而放弃出货。在时间有限的情况下，尽最大努力做到干净，但也要接受脏的事实。
我认为以干净为目标是好的，但当你刚起步时，真的很难确定什么是干净。
我觉得模仿你在前几份工作中看到的东西是最理想的。(就像向了解你工作内容的同事请教一样）这可能是很好的代码启发，也可能是平庸的代码启发。无论哪种方式，你都能获得一些关于哪些决策会导致哪些结果以及结果 “感觉 “如何的信息。
如果日后需要在代码库中修改其中的一个或多个决定，执行者将获得一个统一的代码库！在随意的地方进行独特的抽象和修复会增加重构的难度。
执迷不悟会让你停滞不前。
或者这不是执着。
而是关心。
很少有人能像史蒂夫-乔布斯那样吹毛求疵，并真正完成一个项目。
我当然做不到，这是给年轻的我的建议。
那你就找一个新的团队吧，否则你就可以用经典的 “把一个微不足道的小山头作为你的快乐之路，并做好死在上面的准备 “的套路了。
这些列表中的大多数建议都不是针对任务的 “编程”，而是针对工作/职位的 “编程”。这没有问题，我只是希望它能标注为 “软件工程建议 “或 “给程序员的建议”。其中很少有关于编程本身的内容，这份清单总体上还不错。
这只是一个老程序员的唠叨，他还没有完全意识到 “编程 “在很大程度上已经成为一种社会活动，网上信息无所不包，还有语言和图书馆生态系统等。我在想，如果这些信息在我那个年代都能找到，我会内化多少呢？看起来，我可能会在读到这些信息后点头同意，却忘记了在相关的时候加以应用，而没有经过一些艰苦的磨合（我就是这样学到这些信息的）。
至于实际的编程建议，我想强调的是首先要查看数据。从初始条件到后置条件。不同之处在于你的程序/函数要做什么，但前/后条件都应能完全描述为有效的静态状态。一旦理解了这一点，问题就迎刃而解了，代码在很大程度上就是管道，只有一小部分应用了功能转换。我们太注重 “代码 “的形式和风格了，似乎把它当成了主要的东西，而不是完成主要任务的工件：想想看，任何时候似乎都有花哨的抽象，而这些抽象并没有提供抵消其复杂性的价值。联系到帖子中的一个观点，如果你无法将遇到的困难与需要完成的逻辑转换（例如从数据库状态到状态）联系起来，那么这很可能是自己造成的（也可能是由于数据库模式选择不当造成的）。同样，请求/响应格式选择不当–基本上是系统间的管道不畅（由于处理的是信息，本质上并不困难）。
> 为了达到目的而做一些事情是值得的。只要把它与上面的观点分开，这样它们就不会冲突。
对于新的独立开源模块来说，这是一个很好的用途：可以随意尝试你不想证明其合理性的风格、技术或目标。(或者你开始实验，然后放弃，不向任何人展示）。
例如，当我制作大量软件包来帮助构建 Racket 生态系统时，我已经制作了一个 HTML 写作软件包，但我渴望做一个在编译时使用语法扩展而不是动态 s 表达式的软件包。于是我就做了，作为一个单独的软件包： https://www.neilvandyke.org/racket/html-template/
我不记得有谁说过他们看到了它的价值，但我喜欢它，我搔到了痒处，为我的编程技巧锦囊又增添了一项技能。
> 没关系，医生在学习救人的过程中也会伤害别人很多年。
现代医学教育不是这样的。
是啊，我周围都是医学专家。
确实如此。
他们经常犯严重的错误他们隐瞒错误他们撒谎
他们的自尊和事业都岌岌可危。
他们没有足够的资源可用，没有足够的时间，病人太多，他们精疲力竭。
总之，他们是人类系统中的人类。
> 是啊，我周围都是医学专家
事实上你就是。你正在和一个人说话。
你的原话完全忽略了你在培训期间设置的大量障碍。根据我的亲身经历，我可以告诉你，学生们通常都很有自知之明，知道自己在学习，而且学习时间很短。我所见过的最严重的错误几乎都是由于自上而下的领导问题造成的人员不足和漏洞。那些小错误和偷工减料都是疲于奔命的人造成的。
没有人接受把 “伤害人 “作为培训的一部分。这是一种荒谬的说法。
我喜欢这句话，但我认为所有建议都有一个问题，那就是需要它的人无法使用它，而有能力使用它的人已经知道它。
实践出真知。学习、阅读等也可以作为补充。
软件开发就是如此。武术也是如此。国际象棋也是如此（这三件事我都投入了一些精力来取得进步）。我曾教过武术，但我给不了人们什么神奇的建议，能让他们立即进入下一个阶段，他们需要经历和努力才能进步。有老师的帮助（很大）。
* 用户不关心技术。他们关心的是结果。
在用户关心技术的程度上，他们关心的是性能，而不是代码有多 “干净”，或者你是否使用了最新的框架。用户讨厌软件运行缓慢或占用过多内存。
大多数用户并不知道一款软件会占用多少内存。但他们关心用户体验，这意味着他们会关心用户界面是否会挂起或反应迟钝。
没错。我想更进一步说，他们根本不在乎你的应用程序。他们只是想做一些事情，而你的应用程序质量的好坏，就是看它对完成任务有多大的阻碍。
可悲的是，这其中包含了功能（易于开发，框架可能会帮助你更快地完成开发）、适应性（易于使用的简洁抽象）和性能。
找到平衡点总是很难，但它们都很重要！
如果产品的目标用户是那些使用自己的命令、脚本和插件来扩展功能的用户/社区，那么我们就需要在这两者之间找到一个平衡点。
是的，我完全同意。其他因素都是内部优化。让我感到不解的是，当一个团队想要换上新技术，并进行叉车升级，只为使用新的热门技术来实现某些功能时。
100%。这一点在游戏开发领域尤为明显，你会看到那些漏洞百出、制作粗糙（在编码基础上）的游戏大卖数百万份，并改变了整个行业。最初的第一代《口袋妖怪》游戏可能就是最好的例子，不过我敢肯定，从雅达利时代开始，任何逆向设计过任何游戏的人都可能会感到疑惑：”他们到底在想什么？
但这并不重要。这些游戏设计得很好，玩起来很有趣，数百万人都很喜欢。
你关于复杂性的观点可以用这句话来重新表述：”开发人员被复杂性所吸引，就像飞蛾扑火，结果往往是一样的。
我也经历过这种情况，但我一直不明白为什么会出现这种现象。
是因为我们在理解问题之前就开始添加抽象概念吗？
就像，在一定的临界点上，过于简单会让事情变得过于复杂，所以人们开始引入抽象概念来降低复杂性。但往往是抽象错了，结果一不小心，复杂性反而更高了，更难解开了。
一定有一个术语来形容这种 “波浪手 “吧？
编辑：天哪，在手机上使用典型语言太难了
这是因为，当你在处理事情的过程中，脑子里已经有了大量的上下文，再增加一点小麻烦感觉就像是可以忽略不计的麻烦（尤其是如果新的麻烦表面上是为了减少一些复杂性，或者是为了更快地发布的话），但这些麻烦迟早会累积到任何开发人员的理解极限（甚至更高）。因此，开发人员往往会在他们所能处理的复杂性极限附近工作，而对于那些脑子里没有相同背景的人（比如开发人员自己）来说，这确实超出了他们能够有效处理的范围。
从另一个角度看，这也是一种熵：增加复杂性的方法比减少复杂性的方法多得多。这也是生物生命随着时间的推移变得越来越复杂的原因，唯一的标准就是是否适合生存和繁衍。
弗雷德-布鲁克斯（Fred Brooks）也提到过一个常用术语，即偶然复杂性。偶然性强调了开发者引入复杂性的非故意性质。
意外复杂性不就是不属于问题领域的复杂性吗？例如，在提供内容/下载的背景下，意外复杂性就是缓存、代理、CDN（等）。基本上，这些东西都是我们处理或优化下载时必须处理的，但本质上并不属于 “下载文件 “问题的一部分？
我从来没有真正理解过 “做个冒牌货没关系”、”做个坏蛋没关系 “之类的话…互联网上有很多人都在说 “我是开发人员，我不知道自己在做什么，哈哈 “之类的话。
说真的，你可能缺乏经验，也可能什么都不懂，但你显然不应该是个冒牌货，你应该对自己的能力充满信心，不断进步，了解自己还不懂的东西。
要对自己所做的事情负责，要有主人翁精神，不要轻易以 “太复杂 “为借口。你是专业人士，你要为此获得报酬。
>做脏事。做得不好。但要出货。有些人会生你的气，他们是对的。但还是要做。是的，重启有用户的服务器。是的，提交意大利面条。你会达到你想要的水平，避免做这一切。
我认为，尝试并失败比不尝试要快得多。
我有非常严重的冒名顶替综合症。
你可能是。但你的大多数同事也是）
大多数成年人都是穿着大肉服的孩子，他们经常装模作样。
我在 35 岁时开始活得像个不完全没有价值的人。
这么说并不是为了骄傲，只是想说，如果你认为人类应该做得更好，那么你第一个要评判的人就是你自己。
很明显，你没有达到自己的标准。
你的标准越高，你达到这些标准所需的时间就越长。
而更快达到目标的方法就是无视羞耻感，无论如何都要去做。因为如果你不这样做，你的成长就会更慢，你造成的伤害也会更大，时间也会更长。
真实的生活意味着真实的后果。
这也会让你对他人更加宽容。更宽容
别担心，你不是一个真正的冒牌货。你只是不小心落到了一个别人希望你成为冒牌货的位置上。假戏真做吧，直到你真正成为一个真正的冒牌货。
在这个充斥着冒牌货的世界里，半真半假的冒牌货才是王道。
> – 用户不关心技术。他们在乎的是结果。
经验丰富的成熟工程师和科技企业领导者甚至在今天都忘记了这一点。用户并不关心你的产品是用人工智能制造的，但技术人员就是不肯闭口不谈生成式人工智能、LLM、变形金刚以及所有这些本应属于实施细节的狗屁东西。用户根本不关心香肠的制作过程。
但投资者在乎，对于许多初创企业来说，他们需要吸引的客户就是投资者。
我也不明白为什么投资者会在乎。产品 A 是用传统算法做出来的，产品 B 是用人工智能和法学硕士做出来的，产品 C 是用魔法和巫术做出来的。但它们做的都是一模一样的事情。为什么投资者更愿意投资产品 B 呢？
这篇文章很棒。我特别喜欢 “糟糕的代码会给你反馈，完美的代码不会。我从来没有想过，花时间编写 “完美 “代码意味着你无法弄清代码的哪些方面是真正重要的。
这很有意思。如果让我来补充这份清单，我会加入这些对我有帮助的内容：
– 学习函数式编程。通过学习，我终于 “弄懂 “了编程，并能更轻松地解决问题。在我准备放弃之前。
– 学习 CS 历史。我学的是用户体验（UX），所学到的大多是计算机思维的一个方面，即用勺子喂用户，然后把东西拿走。还有其他一些软件和设计概念化的方法，可以让我减少幻灭感。
– 学习基础知识：数据结构、网络、性能、操作系统、安全、Unix、数学。这些知识在业界被严重忽视，结果我们只能使用我们实际上并不了解的超级复杂系统。
“学习基础知识：数据结构、网络、性能、操作系统、安全、Unix、数学。这些在业界被严重忽视，结果我们只能使用我们实际上并不了解的超级复杂系统”。
我有时会为我的团队开设 “命令行基础 “课程。只要能够理解基础知识，他们就能胜过任何不理解的团队。
你必须了解你的建筑基础。否则，连地基都会出问题。
> 你必须了解你正在建设的土地。否则，连地基都会出问题
没错，说得好。了解了基础知识，就能打下更坚实、更安全的基础，因为你能更好地了解自己能做什么，避免层层抽象。
你能分享一下日程安排吗？我也想举办类似的课程，但不知从何入手。
当然可以！这门课程假定每个人都有 macOS，但并不针对 Mac。
* Introduction Quick history of Unix * When you log in Difference between login and interactive shells System shell files vs user shell files .zshenv for environment variables like PATH, EDITOR, and PAGER .zprofile for login shells, we don't use it .zshrc for interactive shells Your login files are scripts, and can have anything in them * Moving Around ** Where am I? pwd = "print working directory" stored in variable $PWD Confusingly, also called current working directory, so you may see CWD or cwd mentioned ** What is here? ls ls -al ls -alt . prefix to filenames makes them hidden . is also the current directory! .. means the parent directory ** Finding my way around cd cd - dirs | sed -e $'s/ /\n/g' ** Getting Help From The Man man 1 zshbuiltins manpage sections ** PATH echo $PATH | sed -e $'s/:/\n/g' zshenv PATH setting ** Environment Variables env | sort EDITOR variable ** History ctrl-r vs up arrow ** Permissions Making something executable ** Prompts zsh promptinit zsh prompt -l ** Pipes Iterate to show how pipes work cat ~/.zshrc | grep PATH ** Commands *** BSD vs GNU commands BSD are supplied by Apple, and Apple often uses old versions GNU are installed via homebrew, and match those commands available in Linux我希望能有更多的文章谈到集成测试比单元测试更有用。我个人认为，单元测试被高估了，它很少能给团队带来所需的信心，告诉他们某些东西是否已经准备就绪，而对常见工作流程的集成测试意味着，即使引入了一个错误，受影响的用户也很少。
这一点太重要了。我曾在几家公司工作过，他们认为自己的集成测试没问题，单元测试的覆盖率也大于 90%，但每周都会出现登录或认证流程错误。他们绝对厌恶 e2e 测试。只要我能让测试登录并创建和读取一条记录，并将其纳入发布流程（最好是在合并到主程序和部署工件生成之后），那么网站就不会每周都出问题了。客户的痛苦和几个小时的开发工作都省了。
根据我的经验，如果你正在开发一个核心库或工具，API 就是产品，而且会被很多其他团队甚至是开源公司广泛使用，那么单元测试就显得非常重要。如果你在产品团队，单元测试可能就是浪费时间。
> 如果你无法轻易解释为什么某件事情很困难，那么它就是附带的复杂性，可能值得解决。
这一条很好，自从我当上经理以来就一直遵循着。多亏了你，当我觉得我们面对的是如此复杂的问题时，我知道了如何将这一反对意见应用于 “按 “人。
我很少看到我完全同意的建议。这是我少有的完全同意所有建议的时候。
这里大部分建议都很合理，但有一点让人不爽！–
“在错误不是关键任务的情况下（例如 99% 的网络应用程序），快速交付和快速修复错误比花时间确保在第一次尝试时就交付原始功能更有意义”。
在 99% 的网络应用程序中，你的最终用户不可能告诉你你发布了一个错误，而你的错误将永远存在，让用户感到沮丧，并在他们放弃你的网站时让你的客户损失金钱。遥测技术也帮不了你，因为你会误解它提供的观察结果。
同意兄弟姐妹的意见，这些都太抽象了。下面是我的：
基础知识：
– 生态系统胜过语言和语法
– 使用枯燥乏味、久经考验的技术
– 使用关系数据库完成繁重的工作
– 避免缓存，除非有充分的理由
– 代码整洁源于简单，而非优雅
– 提高代码阅读能力比提高代码编写能力更有价值
专业：
– 在好的行业中建设有趣的代码库，你会成长得更快
– 改进业务比改进代码的杠杆作用更大
– 寻找导师比自学成才更有优势
– 进行 T 型购买与构建对比：构建秘诀，尝试购买其他部分
可能遗漏了很多。
> 评估您在质量和速度之间做出的权衡
非常重要！但区分质量的种类也很重要。使用次优算法、糟糕的标识符或复制粘贴的代码总能在日后修复。但有些问题，如糟糕的数据库模式，则很难在以后修复。
如果你是初学者，我建议你对这些建议持怀疑态度。你几乎肯定没有资格鉴定质量，所以不要故意留下任何问题。
作者关于了解您的业务背景和错误的潜在影响的评论对我很有启发。
我见过太多团队为几千名用户使用 Facebook 规模的解决方案。
我见过开发人员在一个完全次要的操作平台上，为低流量和非关键数据而工作，速度慢得让人抓狂，害怕交付代码。这一切都是因为产品人员的任务被误导了。
可悲的是，我还见过几乎不具备安全实践和知识的团队在金融服务环境中乐此不疲地编写垃圾代码。
我的团队都能理解自己的定位，并全情投入。每季度发布的金融服务产品坚如磐石，架构良好。批量文件处理系统只有几十个最终用户，他们与我们的开发人员密切合作，调整算法，有时我们会在一天内多次发货，并在生产中重新运行批次。
要想取得成功，团队必须知道你是处于美国国家航空航天局（NASA）级别，还是处于生命危险级别，还是处于业务关键级别，还是处于某种程度上的关键级别，或者只是一个不错的工具，另外还要了解现金流/预算情况。作为一名开发人员，你可能不了解所有这些情况，但你要尽可能多地了解这些情况。
当然，还要了解谁是用户，谁是客户，并据此确定优先级。
我个人属于 “不错的工具 “级别，但目前正在为其他团队提供 “关键业务 “级别的支持，因此我在做任何事情时都会尽量采用同样的严谨态度。在类似的情况下，也考虑一下你的家属也是有意义的。
我对新软件工程师的建议
– 总是想着如何简化你编写的代码，因为简单的代码更容易维护和调试。
– 比起聪明的代码，你更愿意写笨代码。聪明的代码有利于编程竞赛。当需要调试或重构时，聪明的代码在生产中就会变得非常糟糕。
– 始终考虑提高软件产品的可用性。用户不关心代码。他们关心的是产品的用户体验。
– 一旦发现可用性方面的小问题，应立即修复，因为这些问题通常是终端用户最讨厌的。
– 不要一开始就用一些流行的设计模式编写代码。只需编写最简单的代码，解决给定的任务。之后，最好的设计模式会从解决特定任务的代码中有机地发展出来。
VictoriaMetrics 的开发目标基于以下规则 – https://docs.victoriametrics.com/goals/
我在 “傻瓜代码 “上更进一步。编写易于推理、理解和掌握含义的代码。
我曾在交易台做过很长时间的支持和工程工作，我们的 SLA（服务水平协议）的中断时间在 30 秒到 5 分钟之间。有了超级简单的代码，即使不一定是业务问题，也能很容易理解代码的问题所在，这样就能继续生活，让业务继续前进。
在编写简单代码时，我经常提醒大家，第一份工作代码并不是要提交的代码。就像编辑文本草稿一样，一旦代码可以工作，现在就是修剪它、简化它的时候了。
或者简而言之，KISS！
(保持简单愚蠢！）。
是的，与次优排序算法相比，用户会更注意到只有一半可见的按钮。
我有一个：
学习如何自如地实现和处理状态机。
它可能是最有用的抽象之一，如果实现得好，就能在不影响性能的情况下实现出色的可扩展设计。
最能引起我共鸣的一点是 “在团队中工作时，你通常应该提出问题”，每当有人在职业生涯初期向我寻求建议时，我都会重复这一点（或者说，我希望自己在刚开始工作时能被告知的一点是 “在团队中工作时，你通常应该提出问题”。
在我职业生涯的早期，我花了大量时间阅读不明确或过时的文档、研究代码等，而我本可以问坐在我旁边的人，并在 5 分钟内得到答案。有时，我甚至不知道该问谁，但如果我直接问我的技术主管，他一定能给我指出正确的方向。
说它能把你的总体时间从几个小时缩短到 5 分钟，可能有点夸张，因为你首先需要花时间弄清楚你想问什么问题。不过，即使你最终只花了 30 分钟而不是 3 个小时进行调查，这也是值得的。
不过，另一方面，我真的希望人们在提问前至少花 10 分钟来挖掘代码或阅读文档。
首先，阅读代码在一般情况下是新手应该做的一件好事，而且这也是一项应该在平时培养的技能。
其二，你可能真的会找到你要找的东西，并回答自己的问题！当你意识到自己已经开始自给自足时，你会感到非常高兴。
第三，你会为我提供更多的背景信息，这将使我更容易给你答案。”嘿，这个函数怎么没有返回我所期望的内容 “这个问题比 “这个函数说它会返回用户在给定工作区中访问过的项目列表，但它返回的却是一个空列表；我检查了我的本地数据库，我认为它有一组很好的种子数据，而且从函数来看，没有什么明显的过滤掉用户的内容，这到底是怎么回事？
我的第一份工作是在一家咨询公司，他们有一条很好的规则，基本上就是 “提问时要表现出主动性”。这句话的意思是，如果你问如何做 X，你应该先研究和思考一下，然后你可以说：”我认为 Y 是我做 X 的方法，我的方向对吗？
很多时候，你会回答自己的问题，然后再回答 Y。如果没有，这也会让被问者省去一些跑腿的工作，并表明你不是想让他们替你做工作，而是尊重他们的时间。
或者，甚至可以说：”我看到 X Y Z 正在发生，这似乎与问题不符，我们能进一步讨论一下吗？”
我同意，现在我也会遇到这样的问题，但我很难将 “当我刚接触这个代码库时，这样做可以节省我大量的时间 “与 “为什么你连最基本的尽职调查都做不到，甚至连你想做什么都搞不清楚 “统一起来。(正如我所提到的–找出正确的问题仍然很重要！）。
要找到正确的平衡点很难，我同意作者的观点，但我也同意，至少我（根据我的经验，大多数初级工程师）太偏向于自我激励了。
当然，我也注意到，有些人在本应更了解的情况下却提出问题，这让我很沮丧，我也不知道是应该对他们宽容一些，还是应该指责他们没有付出那么一点点努力。
两种情况都有。我见过的最常见的情况肯定是问一件事的时间太长。另一种情况是问了太多琐碎的问题，而这些问题是你几分钟就能查到的，或者是你的工作应该知道的。
我认为问题在于，知道什么时候该问，这就像很多事情一样，是一项随着经验的积累而不断提高的技能。尤其是对新人来说，这一点并不明显。我还认为，如果你是前辈，就应该对后辈更加宽容。我们都是过来人。
我认为，要求太慢往往更容易在雪球滚大之前被发现。问得太快往往是习惯性的，而且似乎会造成更大的伤害，因为在管理项目时很难注意到，而且往往是在 “配对 “的模糊支持下。
“不要低估挖掘历史调查一些 bug 的价值”。这是很有价值的建议，它特别强调了全局状态的风险和了解运行时的好处。浏览器已经普及了火焰图，堆栈跟踪会向你显示出错时刻的帧，但全局状态会在多个堆栈跟踪中存活下来，而你正在查看的堆栈跟踪可能不是（很可能不是）问题的原因。全局状态、堆、外部系统等会随着时间和连续调用而变化。即使在单线程环境中也是如此，而在一般的多线程环境中则要复杂得多。我经常觉得初学者并不清楚这一点，也不清楚如何在这种情况下调查错误。
诀窍不在于提供建议。关键在于他们能听到建议。
下个月，我将在软件行业工作 30 年。这意味着，15 年前的我比大多数人有更多的共同语言。
有五年经验的我怀疑很多事情是真的，但却忽略了一些重要的事情。我可能要先确认其中一些事情，然后再继续讨论困难的部分，以满足他的自负。
但是，谁又能说，少了 “冒失鬼综合症 “的我会是一个更好的人呢？不，从过去吸取教训的主要价值在于改善未来，而不是怀旧、遗憾或 “如果”。
分享别人能够听到的建议是一方面，让那些希望更快、更轻松地达到目标的人成为听众是另一方面。
曾经有一段时间，有太多的初级开发人员想要学习所有的东西，并经历了自己学习所有东西的阶段，却没有考虑其他人是否也经历过类似的事情。
认为自己不合格可能意味着你在学习某些东西时也有一种深思熟虑的好方法。
如果认为自己已经合格，而现在还为时过早，则可能意味着其他原因。
无论我的工作做得多好，对自己的工作抱有健康的不信任，在很多情况下都有助于它变得更好，哈哈。
我给自己的一个编程建议是，在大型项目中，确保适当的约束比功能性更重要。你希望在几年后再回到代码区域时（不需要看它），所有添加的内容都仍然有意义。你不想看到的模式应该很难实现–自然的惯性会阻止它发生。设计出 “允许人们做任何事情 “的东西，看似好处多多，但从长远来看，最终会带来很多问题。
一个合理的论点可能是，应该对其进行监督/监管，但这在实践中比看起来要难得多。很多组织都是相当分散的，这意味着没有一个中央实体能做主（我认为这也许是件好事）。如果在系统中设计了适当的限制，那么这种耗费精力的讨论甚至一开始就不需要发生。
从根本上说，在 t0 增加限制条件，就增加了未来的自由度。编码有点像一个花园–你需要确保花园在成长的过程中是有意义的。
“糟糕的代码会给你反馈，完美的代码不会。偏向于写糟糕的代码”。
这可能是一种相当愤世嫉俗的说法（这对我很有启发，可能因为我相当愤世嫉俗），但我不知道初级开发人员是否会真正理解这一点。
我想说的是：不要试图为没有人完全理解的业务规则建立完美的抽象概念，而是尽可能高效地简化用户的生活，从而获得满足感。
我在其中一篇文章中提到的一个变体是 “做蠢事 “来找到正确的抽象。我见过很多代码，如果有人做了蠢事，这些代码就不需要写了。反过来说，我也见过很多代码，如果在写完愚蠢的解决方案后，他们回去想出一个更好的解决方案，那么这些代码就会简单得多。我想这就是我的收获：原型。
> 花时间打磨斧头几乎总是值得的
我经常听到这样的建议。但我觉得真的需要对它进行限定。我曾经参与过一些项目，但由于人们总是专注于 DX、项目管理和其他工具，这些项目从未产生过真正的价值。
有时，我们只需要使用手头的工具，而不必担心是否有更好的工具。
> 我们的服务器模型与我们要写的 DTO 完全相同，所以我只是将它们序列化，而不是写所有的模板，如果需要的话，我们以后可以根据需要写 DTO
我曾在一个系统中工作，该系统使用生成的 protobuf 类型在各处的服务之间进行通信。在系统的任何组件中，绝对没有任何东西不直接依赖于生成的 protobuf 代码。更糟糕的是，我们调用的一个后端系统有多个端点，这些端点使用相同的名称来处理相似但略有不同的事情，因此并不存在单一的乘客类型，而是在不同的包中存在大量不同的乘客类型。
> 更新我们的订阅层，改为在主线程上调用订阅器
我经常这么做，但最近已经不那么频繁了，因为我不想强制切换线程，除非我知道我将调用 UIKit 函数（并不总是影响用户界面的东西。很多 UIKit 的 “后台 “函数也需要主线程）。相反，我在 API headerdoc 说明中明确提到了线程状态（”- 参数处理程序：简单、无参数、尾部完成。可在任何线程中调用。”）。
> 写出糟糕的代码很容易。但要写出绝对遵循所有最佳实践、测试覆盖率达到 100%、经过模糊测试和突变测试的代码也很容易–你的初创公司会在你完成之前就把钱花光。因此，很多编程工作都是在寻找平衡点。
情况似乎正在迅速发生变化。15 年前，还没有先进的代码生成 LLM，虽然在对语言和系统不甚了解的情况下依靠它们来生成核心逻辑仍然有点不靠谱，但现在看来，它们在生成测试和发现与你的团队认为的最佳实践之间的偏差方面已经相当不错了。
它擅长生成什么样的测试？我希望它能让我开始用 Jest 和 React 测试库为一个已经存在但未经测试的代码库编写测试。对于我也能快速编写测试的小型组件，它似乎还可以，但对于更大、更杂乱的东西，它就会接收到无用的、失败的测试。
这根本不是一个好建议。很难正确理解它，而且很可能在 5 年后，当作者到达另一个阶段时就会改变。
我的建议要简单得多：1.大部分时间你都要处理测试。学习如何专业地处理文本。这包括 vim、bash、sed、awk、perl 和一般的 regexes，包括 lookbehinds 等。这是值得的。它需要几年的时间来学习，但即使是基本选项也能让你掌握如何更快地完成工作的文化和方法。大多数程序员在交换文本文件中的两列或查找无法打印的字符时都会遇到困难。
2.认真学习热键。它们比 UI 更一致、更统一，学习如何更改它们，哪些工具更适合它们，并组织一些记忆方案。这样会有很多收获，而且会进入身体记忆，释放心理空间。
3.学习如何编辑自己的代码，而不是创建多个文件和文件夹。至少阅读一次 git 手册。了解补丁是如何工作的，什么是交互式 rebase，以及如何来回合并不同分支的不同修改。这样你就能自由地在更大范围内对代码进行实验。
4.学习如何快速测试任何框架/代码。会有无数次这样的情况：一些垃圾代码无法产生所需的结果，而你应该能够快速证明这一点。为此，P.1 是非常宝贵的。我有自己的 json、xml、rest、kafka 和文本日志解析器和 diff，还有一些云、数据库和搜索客户端，我在切换工作时会对它们进行调整。这些程序大部分都是用标准的 unix 工具编写的，如果需要，还可以重新打印（我经常在高安全性环境中工作）。这也将我与每个企业中不同的（非）标准工具隔离开来，只有在我已经知道答案并需要向同行证明时，我才会退而求其次。
其他的都是主观臆断，可有可无。你可以喜欢或讨厌你的工作，可以喜欢制表符或空格，可以喜欢弱输入或强输入，但以上几点一定会让你的工作变得更快。至于如何利用剩下的时间，那就是你的决定了。
文章写得很好，我同意其中的大部分内容。与 “只管问问题 “相辅相成的一点是，要学会知道何时转向。如果你遇到了阻碍，不管是等待队友、客户，还是等待一个棘手问题的答案，都可以考虑转向另一项任务，从而轻松取胜。
理想情况下，你转向的任务应该只需要极少的上下文切换就能开始。这样你就不会失去工作效率。通常情况下，如果阻碍你的是一个棘手的问题，而你稍后又回到了这个问题上，你可能会在离开一段时间后有一个好主意作为奖励。
在过去的二十年里，我花了大量的时间来调整我的 vim 配置。过去几年，我一直在使用 vscode，很少跳转到 vim 来做一些文本处理（我通常可以用原始安装来做这些）。
我会告诉自己，将会出现一种名为 “SPA “的新前端架构，以及与之相关的名为 React.js 的新框架。而我应该远离它们。
非常棒的建议！根据我的经验，我想补充几点：
– 工程师花在阅读代码上的时间远远多于编写代码。因此，编写易于阅读的代码比编写花哨/复杂的代码更重要，因为这样可以节省几行代码。
– 上述观点的延伸。在公司内制定编码标准非常重要，这样任何人都可以对代码的不同部分进行修改。如果一名工程师最终使用自己的标准编写代码，那么每次其他人需要调试该代码时，团队中其他人的工作就会变得更加困难。
这是我见过的最好的建议之一。尤其是关于在快速交付和无错误代码交付之间找到平衡的部分。
太多工程师认为他们的工作是 “优秀的代码编写者”，而不是 “增值者”。
这里似乎有一些很好的建议！关于深入挖掘错误原因和查看代码库历史以获取更多信息的观点确实值得牢记。
记住要多问问题也很有道理。我们总是会担心自己会打扰别人太多，同时也要考虑是否需要尽早寻求帮助，以确保自己不会走错路，同时又不能在没有尝试自己修复的情况下就询问每一件小事，这两者之间的平衡问题……
> 如果你无法轻易解释为什么某件事情很困难，那么它就是偶然的复杂性，也许值得解决
这就是我对 git 的看法。
它是那个时代的产物，所面对的要求和限制已不再重要。在多人保存方面，我们拥有比当时强大得多的工具。
但我认为 git 已经变得无处不在，即使是不需要模仿 git 数据模型的新解决方案，最终也会因为熟悉而带来复杂性。
> 如果你（或你的团队）经常自寻死路，那就把枪修好吧
如果你在一家有合理 “管理层 “的合理公司工作，那么采取这一措施是合理的。如果你不幸在一个即使有令人信服的数据也拒绝承认存在问题的经理手下工作，那你就要做好痛苦的准备了。在这种情况下，什么都不能做，因为 “我们一直都是这么做的，做一些事情可能会让别人不高兴”。在这种情况下，真的是时候放弃并寻找新的出路了，因为一般情况下是没有希望扭转这种局面的。
> 如果你无法轻易解释为什么某件事情很困难，那么它就是偶然的复杂性，也许值得解决
见上文。”我们一直都是这么做的，有人已经习惯了这种工作流程，所以我们不能改变它”。有时，这会导致一种合理的切斯特顿栅栏情况，在这种情况下，你会想要重新组合并重新思考。否则，你就会陷入疯狂的境地。以后者为目标。
> 尝试解决更深层次的问题
“没时间了！我们还有很多其他项目！”却对这都是自己造成的事实视而不见（或者最好是把头埋进沙子里，试图忽略）。
> 不要低估挖掘历史记录以调查一些错误的价值
“我们不能改变这种情况，因为我们的某个接近管理层的人做出了这样的决定，这可能会把他们赶走”。很好，把他们赶走，这是真正解决问题的唯一办法。理想的情况是，雇用他们的管理层也被赶走。
> 在团队中工作时，你通常应该问这样一个问题
“你凭什么质疑我们的智慧？你有什么资格提出其他建议，这在生产中是行之有效的”。
这些都是开始对话的好东西，但你必须在一个愿意改变并愿意采纳你的建议的组织中开始对话。不要浪费宝贵的生命去试图改变无法改变的东西，无论你多么希望看到它改变。
这不是针对内容，而是针对网站对文字和背景颜色的选择：做得非常好，在暗色模式下很容易阅读。
再来一个：让开发人员的速度成为你们的首要任务之一。
你应该能够向团队中的任何人提供版本库 URL，让他们在五分钟内运行单元测试和本地集成测试，而无需事先了解相关知识。
有趣的是，他随口就提到 JIRA 会拖慢你的工作。我知道他的团队是在其他地方进行问题跟踪的？
对于开发人员和项目管理人员来说，什么方法处理速度更快？
这始终取决于团队。我所说的团队，指的是在项目中从事某种独立工作的人员（他们不需要关心其他部分的细枝末节）。问题跟踪是一种工具，但项目经理总是希望工具变成流程。于是就有了每日例会、故事点、史诗和固定冲刺（又称假截止日期）。
把工具当工具用。作为开发人员，添加需要团队关注的问题和任务，在票据上添加注释，以便保存知识。作为管理者，如果票单需要在特定时间内完成，就安排票单，使用任务和其他字段来管理工作量。做这些都是为了帮助团队完成工作。其他任何事情都是阻碍。
正确，但 JIRA 不是 SCRUM。
为什么作者提到 JIRA 是一种流程？他是否觉得与其他工具相比，JIRA 运行缓慢或复杂？还是他认为使用 JIRA 意味着项目经理强迫团队遵循一个不需要的流程？
> 还是他认为使用 JIRA 意味着项目经理强迫团队遵循不需要的流程？
我想一定是这样。我们在工作中使用 JIRA。我们的流程非常非常简单。我们创建问题、分配问题、解决问题，然后在部署完成后关闭问题。极少繁琐。
我还可以访问客户的 JIRA。从开始处理一个问题到说它已部署到测试环境中，他们有 6-7 个步骤。再经过 5-6 个步骤，才说已经在 prod 中交付。我看了这些步骤的流程图，头都大了。
这更像是一个微妙的玩笑，而不是什么实质性的东西。我觉得 JIRA 只要不是宗教信仰就没问题。
我是照字面意思理解的，抱歉 ^^
谢谢您的宝贵建议！
> 继续做第一种错误修复，结果就是一团糟。
为了避免一团糟，在设计时要牢记 “快速失败 “原则，这样才能更接近错误发生的位置。
我认为这对于编码和解决问题的技巧来说非常重要。我还想补充一条职业建议：你受雇为企业解决问题，而不是解决技术问题。如果你无法解释你所做的事情如何为企业带来实际的改变，你就需要反思一下你的时间都花在了什么地方。我见过太多的技术团队过于专注于技术问题，而无法理解为什么他们无法获得更多的员工、资金或认可。写支票的人不会关心代码。
我给自己的建议
完成你正在做的事情。
非常有道理，如果你不钻牛角尖的话，解决更深一层的错误可能会非常有价值。
15 年前？购买比特币
买比特币怎么样？
> 不要低估挖掘历史调查一些错误的价值
在我的公司里，大约有两个人专门从事考古探险，以了解引入错误的时间和原因，我就是其中之一。很多时候，我发现这种行为是在十多年前故意引入的，有时是为了解决我没有想到的边缘情况。历史是宝贵的！
(不幸的是，对我来说最常见的用法是 “嗅觉测试”，我从历史记录中了解到代码是谁写的，然后根据我对他们技能的现有评估，决定我应该对该代码有多大的怀疑）。
e; 哦，对了，还有一个有点有趣的故事。就在本周，我看到了一些我不喜欢的行为，于是去查看了代码的历史记录。我不喜欢的代码是我写的。但我给它留下了足够好的评论，我才意识到其实根本没有问题，我的期望是错误的。
编程是一个年轻的领域，有很多迭代，很难有好的建议。我本该自创一种编程语言！
我喜欢作者关于 “偶然复杂性 “的观点。不过我想指出的是，即使你能解释某些东西为什么复杂，也并不意味着它就应该复杂。
当谈到 “技术债务 “这个话题时，我总是告诉我所在的团队，要把重点放在那些能在未来提高我们的速度或敏捷性的任务上。我认为，许多编码任务实际上随着时间的推移会产生负的开发成本，因为这些任务减少的未来工作的开发成本要高于当前的实施成本。(当然，问题是这些任务在当前冲刺阶段的开发成本是正数，所以要说服决策者就得靠运气了……）。
Codeisforhumans.com
> 你需要经常重命名事物、查看类型定义、查找引用等；你应该在这方面很快。你应该知道编辑器中的所有主要快捷方式。
程序员喜欢认为这很重要。如果你所做的只是最基本的工作，那么最大限度地使用键盘快捷键所 “节省 “的时间完全无关紧要。你的大部分时间都花在了阅读代码、思考代码和思考你要写的代码上。
当任何程序员强调他们完成这些基本任务的速度有多快时，我的假设是他们不太适应实际的编程工作，而是试图 “git gud “键盘向导的废话。
> 我的假设是，他们不太适应实际的编程工作，而是试图在键盘向导的废话中 “git gud”。
只要能让你晚上睡觉就行。