卓有成效的工程师 pdf mobi txt word epub 下载 2024

本书总结出一个强大的框架——杠杆率，用来推断、分析工作的有效性与影响力，包含了一系列可落地且经过验证的策略作为框架的补充，读者可以立即应用这些策略来提高工作成效。

全书分为三个部分，第一部分从提高成效的思维模式切入，第二部分深入探讨持续提升执行力并取得工作进展的关键策略，在第三部分作者转换角度，阐述了创造长期价值的方法。

前言

第一部分 树立正确态度

1 聚焦高杠杆率工作

2 精益求精，优化学习方式

3 定期调整优先级

第二部分 执行，执行，再执行

4 投资迭代速度

5 正确度量改进目标

6 尽早且频繁验证想法

7 提升项目估算能力

第三部分 构建长期价值

8 权衡质量与务实

9 最小化运营负担

10 为团队成长投资

结语

附录A

致谢

作者 | 埃德蒙·刘（Edmond Lau）

埃德蒙·刘是 Quip 公司软件工程师，正着力构建一个生产力套件，以提高团队的效率。在此之前，他是 Quora 的初创成员之一，曾经领导工程团队致力于用户的增长，并为新软件工程师制定入职培训和指导计划。到 Quora 工作之前，他曾在 Ooyala 公司担任分析技术负责人，在谷歌担任搜索质量软件工程师。他获得了麻省理工学院计算机科学的学士和硕士学位。现居于加利福尼亚州的帕洛阿尔托。访问他的网站 TheEffectiveEngineer，可以看到他分享的更多经验、故事和习惯，能够帮助软件工程师提高生产力和效率。他热衷于帮助工程团队建立强大的文化，他的文章曾被刊登在《福布斯》《Slate》《财富》《时代》等杂志上。他是麻省理工学院和斯坦福大学的客座讲师，并在初创公司发表过关于建立卓越的工程师文化的演讲。

译者 | 万学凡，数字化转型专家，行业知名敏捷转型顾问，InfoQ2020、2021年度中国十大IT产业推动者。《EDGE：价值驱动的数字化转型》《如何写出好程序》《敏捷回顾：反模式与重构引导实践》《解决方案架构师手册》《AI重新定义企业》《内容智能：打赢每一场运营战争》《Go语言学习指南》等书译者。凯捷中国数字化团队总经理，首席咨询顾问。

译者 | 顾宇

腾讯 PCG 平台与内容事业群 T11 研发效能专家，长期专注于企业数字化转型、企业 IT 治理和软件研发效能提升，及规模化敏捷（SAFe）、领域驱动设计（DDD）、微服务架构、DevOps 和云原生技术实践。在多年软件开发和咨询过程中积累了丰富的实践和教学经验。曾参与信通院《研发运营一体化（DevOps）能力成熟度模型 第3部分：持续交付》《研发运营一体化（DevOps）能力成熟度模型 第5部分：应用设计》《分布式应用架构评估标准 第1部分：微服务平台》等标准的编写，及多家大型企业 DevOps 成熟度评估、指导。

暂无出版社相关信息，正在全力查找中！

暂无相关书籍摘录，正在全力查找中！

在线阅读地址：卓有成效的工程师在线阅读

在线听书地址：卓有成效的工程师在线收听

在线购买地址：卓有成效的工程师在线购买

暂无原文赏析，正在全力查找中！

书籍介绍

本书总结出一个强大的框架——杠杆率，用来推断、分析工作的有效性与影响力，包含了一系列可落地且经过验证的策略作为框架的补充，读者可以立即应用这些策略来提高工作成效。

全书分为三个部分，第一部分从提高成效的思维模式切入，第二部分深入探讨持续提升执行力并取得工作进展的关键策略，在第三部分作者转换角度，阐述了创造长期价值的方法。

• 作者： R2D2 发布时间：2022-11-10 11:52:48

  ROI；程序员相关管理、效率部分书籍内容小结

• 作者： Stanley Wind 发布时间：2022-11-15 09:13:37

  杠杆率，时常记住让自己只做高价值的事。

  结尾又升华了一下，生活也不只有高价值的事。btw看完更想去外企大公司了。。。

• 作者： 高端洋气大黄瓜 发布时间：2022-09-18 20:21:23

  适合新人

• 作者： matheecs 发布时间：2022-09-29 19:39:29

  有些参考价值

• 作者： 杨逸 发布时间：2022-11-02 09:18:50

  可以实操的书，五年左右，成为高级工程师后应该做的事情。

• 读书摘要

  作者：逸水流觞 发布时间：2020-05-28 12:45:45

  高效的工程师是那些被认为可以把事情搞定的人。同时，是可以高效率的把事情搞定的人。

  高效工程师聚焦在价值和影响力上。

  Part 1: Adopt the Right Mindsets

  Focus on High-Leverage Activities

  Use Leverage as Your Yardstick for Effectiveness

  杠杆率 = 产出 / 时间

  简单的说就是 ROI，投入产出比。

  时间是最宝贵的资源。

  Increase Your Leverage in Three Ways

  提高杠杆率的三个途径：

  减少做某件事的时间

  增加做某件事的产出

  换到有更高杠杆率的事情上去

  翻译成三个问题：

  如何缩短完成这件事情的时间？

  如何提高这件事情的产出价值？

  有什么值得花费我时间的事情可以产出更多的价值？

  Direct Energy Toward Leverage Points, Not Just Easy Wins

  聚焦于高杠杆率的事情

  Key Takeaways

  使用杠杆率来评价你的工程效率

  有条理的提升你时间的杠杆率

  集中关注在支点上

  Optimize for Learning

  持续优化学习是高效工程师的一项非常高杠杆的活动

  Adopt a Growth Mindset

  拥抱成长性思维，意味着对你可以改变的各个方面都承担责任，而不是将失败和缺点都归咎于你无法掌控的事情。

  Invest in Your Rate of Learning

  学习也遵循指数增长曲线

  越早优化学习，可以享受越久的复利

  微小的差异在长期未来也能产生巨大的差别

  把自己当作是创业或 beta 版的产品，需要每天不断的投资、迭代

  Seek Work Environments Conducive to Learning

  寻求有利于学习的工作环境

  寻找公司或者团队的六个因素：

  快速成长

  培训

  开放

  节奏

  人

  自主性

  Dedicate Time on the Job to Develop New Skills

  在工作中花时间发展新技能

  每天花 1-2 小时整块时间。对你长期未来能够更加高效投资。

  可以对你工作的领域或者使用的工具有着更深刻的理解。

  也可以获得临近学科的经验。（工作上下游相关其他工种的知识经验）

  十条建议：

  学习公司内最好的工程师的核心抽象代码。特别是在大型公司。

  写更多的代码。针对提高编码能力，和阅读代码相比，练习是更高杠杆率的活动。

  浏览内部提供的技术或者教育材料。

  掌握你所使用的编程语言。

  将代码发送给最严格的批评家评审。

  在要改进的地方学习。

  参加你感兴趣的项目设计讨论会。

  从事各种各样的项目。

  确保你所在的团队里，至少还有几个你可以向他们学习的工程师。

  毫不畏惧的跳入你不懂的代码中。

  Always Be Learning

  持续不算的学习

  学习的机会并不局限于工作场所。其他技能也值得学习。

  学什么：

  学习新的编程语言和框架。

  在当前高需求的技能上投资。

  读书。

  加入一个讨论组。

  参加一些技术会议、讲座等。

  建立并维系一些强有力的关系网。

  关注一些技术博客。

  写一些东西。

  做一些业余项目。

  追寻你所热爱的事情。

  Key Takeawsys

  为自己负责

  不要降低学习速度

  寻找可以持续成长的工作环境

  利用工作机会提高技术技能

  在工作场所之外学习

  Prioritize Regularly

  规律性的制定优先级

  Track To-Dos in a Single, Easily Accessible List

  跟踪所有的 TO-DO 在一个单一、容易找到的列表里

  关注于当前立即可以产生价值的，和重要不紧急的。

  Focus on What Directly Produces Value

  关注当下可以立即产生价值的事情

  公司关注的是你创造的价值。价值例如产品推进，用户获取，销售额等，而不是开了多少会、写了多少代码。

  Focus on the Important and Non-Urgent

  关注重要但不紧急的事情。

  我们每天都被紧急的事情淹没：开会、邮件、电话、bug、DDL。其中有些是重要的，有些并不是。

  重要、紧急：高优问题、DDL 等

  不重要、紧急：大多数的 email、电话、会议

  重要、不紧急：职业生涯规划、建立了强人际关系、读书、建立新的高效习惯、构建工具以改善工作流、学习新的语言等等

  Protect Your Maker’s Schedule

  保护你的时间表。

  和其他专业工作相比，软件工程师需要更多长、持续的时间段来提高工作效率。

  尽可能的将会议安排在连续的时间段或者一天的早晚，而不是分散这些会议。

  Limit the Amount of Work in Progress

  限制同时在进行中的项目数量。

  人脑的并发处理能力非常有限。

  Fight Procrastination with If-Then Plans

  通过 if-then 计划来避免拖延。

  例如，收集一系列的 20 分钟内可以完成的短任务，如代码评审、写面试反馈、回邮件、调查小 bug、写测试等。

  Make a Routine of Prioritization

  制定优先顺序。

  养成重新回顾这些优先计划的习惯。

  Key Takeaways

  写下并 review to-dos

  做有直接价值的事情

  做重要但是不紧急的事情

  减少上下文切换

  使用 if-then 计划和拖延作斗争

  养成制定优先级的习惯

  Part 2: Execute, Execute, Execute

  Invest in Iteration Speed

  高效工程师在迭代速度上进行大量的投资。

  Move Fast to Learn Fast

  迭代的越快，你能越快的知道这些工作是否有效。

  持续部署是提供给你用于加快迭代速度的有力工具之一

  Invest in Time-Saving Tools

  节省时间的工具可以带来丰厚的回报。

  更快的工具会被使用的更多。

  值得花费一些努力去寻找一个更平滑的方式以便降低从现有工作流切换到新的工具的成本。

  Shorten Your Debugging and Validation Loops

  缩短调试和验证的时间周期。

  下一次，当你修复一个 bug 或者迭代一个新的 feature，发现自己又在重复进行同样的行为的时候，停下来。想一想，你是否可以缩短这个时间周期。

  Master Your Programming Environment

  熟练你的编程环境。

  在版本控制里跟踪变更

  编译、构建代码

  跑单元测试

  重启开发中的 Web Server

  测试一个表达式的行为

  查找文档

  跳到函数定义

  在文本编辑器里重新格式化代码或者数据

  找到函数的调用方

  重新排列桌面窗口

  导航到文件的特定位置

  入手点：

  熟练你喜欢的文本编辑器或者 IDE：Emacs、VIM or something else

  学习至少一个高产、高级的编程语言：Python、Ruby

  熟悉 UNIX 或者 Windows 的 shell 命令：grep、sort、uniq、wc、awk、sed、xargs、find

  更加习惯于使用键盘而不是鼠标

  自动化你的手工操作

  使用交互式解释器来测试自己的想法：Python、Ruby、JavaScript

  使运行单元测试尽可能的快和简单

  Don’t Ignore Your Non-Engineering Bottlenecks

  不要忽视你的非工程的瓶颈

  优化迭代速度的最佳策略和优化系统性能一样：找出最大的瓶颈，然后解决它们。

  高效工程师会找出并处理这些最大的瓶颈，尽管可能这些瓶颈并不涉及到写代码或者不在他们的舒适区内。

  一个常见的瓶颈就是对其他人工作的依赖。

  沟通对于推进与人相关的瓶颈点至关重要。

  另一个常见的瓶颈类型是获得关键决策者的批准。

  第三种瓶颈是项目启动之后的审查流程。

  在大公司，解决这些瓶颈可能超出了你的影响范围，而你能做的最好的事情是围绕它们开展工作。在小的初创公司，你通常都可以直接解决瓶颈本身。

  Key Takeways

  迭代的越快，学的越多

  在工具化上投资

  优化你的 debug 工作流

  掌握你手艺的基础

  全面了解你的迭代循环

  Measure What You Want to Improve

  衡量你要改进的地方

  Use Metrics to Drive Progress

  使用指标来驱动进步

  如果你不能衡量它，你就不能改进它。

  好的指标可以实现许多目标

  当随着时间的推移而可视化时，好的指标有助于防止将来的回归。

  好的指标可以推动进步

  一个好的指标可以让您衡量一段时间内的效果，并将你正在做的事情与可能要进行的其他活动进行比较

  很难衡量目标并不意味着不值得做。

  Pick the Right Metric to Incentivize the Behavior You Want

  挑选正确的指标来激励你想要的行为

  指标选择：

  最大化影响

  可行动的

  反应迅速同时健壮

  Instrument Everything to Understand What’s Going On

  监控一切以便理解到底发生什么

  Internalize Useful Numbers

  内部化有用的数字还可以帮助您发现数据测量中的异常

  了解有用的数字可以明确改进的领域和范围

  有用的数字：

  注册用户数、日活、月活

  每秒请求数

  数据存储容量上限

  每天读写数据量

  支持一个特定服务需要的服务器数量

  不同的服务的吞吐量

  流量的增长率

  页面平均加载时长

  产品不同部分之间的流量分布

  不同的 Web 浏览器、移动设备、操作系统的流量分布

  Be Skeptical about Data Integrity

  对数据完整性保持着怀疑态度

  有时候会混淆相关性和因果关系

  Key Takeaways

  衡量进度

  小心的选择最高层的指标

  监控你的系统

  知道你的数据

  优先考虑数据完整性

  Validate Your Ideas Early and Often

  尽早并且经常性的验证你的想法

  尽快根据用户反馈来优化

  尽早并经常验证我们的想法有助于我们完成正确的事情

  Find Low-Effort Ways to Validate Your Work

  找到低成本的方式来验证你的工作

  一个可行的验证想法的方式是花 10% 的投入构建一个小而又足够信息的原型

  Continuously Validate Product Changes with A/B Testing

  持续通过 A/B 测试来验证产品变更

  Beware the One-Person Team

  当心一人团队

  建立有效的反馈渠道：

  保持开放，乐于接受反馈

  尽早经常的提交代码评审

  请求最严格的评审者来评审代码

  询问同事的想法看法

  先设计系统的接口和 API

  投入编码前先展示你的设计文档

  如果可能，请对正在进行的项目进行结构设计，以便与队友共享一些上下文

  在投入太多时间之前，对有争议的问题寻求讨论和支持

  Build Feedback Loops for Your Decisions

  建立你的决定反馈循环

  设计实验验证你的猜想，不论好坏，从实验结果中学习

  Key Takeaways

  迭代的去处理问题，以避免浪费投入

  将大的实现拆分成小模块验证以降低风险

  使用 A/B 测试来持续的验证你的产品假设

  当工作在一个独立项目中时，寻求一个定期的外部反馈

  采取积极的态度去验证你的决定

  Improve Your Project Estimation Skills

  项目估期是高效工程师需要学习的最难的技能之一。

  Use Accurate Estimates to Drive Project Planning

  使用准确的估期来驱动项目计划

  一些策略：

  拆分项目成小的任务

  估期建立在任务需要多久完成，而不是你或者其他人希望多久完成

  将估期视为概率分布，而不是最佳情况

  让实际做这项工作的人来估期

  当心锚定偏差

  使用多种方式来估计同样的任务

  警惕神话般的人月：加人缩短不了工期

  通过历史数据来验证估期

  使用时间盒子来限制任务的增长

  允许别人挑战你的估期

  Budget for the Unknown

  给未知事物留下缓冲预算

  Define Specific Project Goals and Measurable Milestones

  设定明确的项目目标和可衡量的里程碑

  明确定义的目标提供了一个重要的过滤器，用于将任务列表中的必须有与最好有分开

  定义特定项目目标的第二个好处是，它可以在关键利益相关者之间建立清晰度和一致性。

  Reduce Risk Early

  尽早暴露并降低风险

  如何降低集成风险？尽早做端到端的脚手架和系统整合测试。

  Approach Rewrite Projects with Extreme Caution

  极其谨慎的重写项目

  有重写经验的工程师，倾向于把大的项目重写分解成一系列的小项目。

  Don’t Sprint in the Middle of a Marathon

  不要在马拉松比赛中冲刺

  工作时长增加，每小时工作效率降低

  和你想象的相比，你可能比计划表落后的更多

  额外的工作会压垮团队成员

  增加工作时长会伤害成员的工作热情

  随着截止日期的临近，沟通的开销会增加

  最后冲刺会产生大量的技术债

  当延期时：

  确保每个人都了解造成时间表迄今延误的主要原因

  重新制定现实的时间表

  如果距离重新修订的时间表很远，随时准备放弃冲刺

  Key Takeaways

  将估期纳入到项目计划中

  项目表中流出缓冲时间

  定义可衡量的里程碑

  先做风险大的任务

  明确加班的局限性

  Part 3: Build Long-Term Value

  Balance Quality with Pragmatism

  务实兼顾质量

  Establish a Sustainable Code Review Process

  建立可持续的代码评审流程

  好处：

  尽早发现 bug 和设计缺陷

  增加对代码变更的责任心

  建立正面的如何写好代码的样例

  共享知识

  提升长期的敏捷度

  Manage Complexity through Abstraction

  通过抽象来管理复杂度

  通过降低原始问题的复杂度变成一个简单容易理解的问题

  降低未来的维护成本并且更加容易后续功能迭代

  解决一个复杂的问题一次，未来就可以使用很多次

  好的抽象应该是：

  容易学习

  在没有文档的情况下依然容易使用

  很难误用、用错

  足够强大以满足需求

  容易扩展

  对使用者很合适

  Automate Testing

  自动化测试

  Repay Technical Debt

  偿还技术债

  技术债不会只是在我们做快速、肮脏的变通工作时才会积累起来。每当我们在不完全了解问题空间的情况下编写软件时，我们的第一个版本最终都可能设计得不如我们所希望的那么干净。

  成为一个高效工程师的关键是在面临 DDL 的时候，可以引入一定的技术债，但同时也会周期性的偿还技术债。

  高效工程师花费有限的时间以最高的杠杆率偿还债务——代码库中人流密集的部分中花费最少的时间进行修复。

  Key Takeaways

  建立代码 review 的文化

  在好的软件抽象上投入以简化困难的问题

  通过自动化测试提高代码质量

  管理你的技术债

  Minimize Operational Burden

  Embrace Operational Simplicity

  高效工程师关注于简单性上。

  拥有复杂架构设施带来一系列的维护问题：

  工程师的专长经验被分散到多个系统上

  复杂性带来潜在人员的单点故障问题

  新成员面临着陡峭的学习曲线

  投入到提升抽象程度、库和工具的资源被分散到不同的系统上

  可以解决我们的问题并且可以降低未来的维护成本的方案是什么？

  Build Systems to Fail Fast

  快速失败

  快速失败并不意味着让程序给终端用户崩溃。可以用全局的异常处理，快速上报这些错误，但优雅的给普通用户异常降级处理。

  Relentlessly Automate Mechanical Tasks

  无情的自动化机械任务

  每次你做了某些机器可以完成的工作，问问自己是否值得自动化这些工作。

  Make Batch Processes Idempotent

  让批处理任务保持幂等性

  无副作用，可重试

  Hone Your Ability to Respond and Recover Quickly

  磨练你的快速响应和恢复的能力

  针对主要的故障，最有效的防御措施就是经常失败。

  建立快速恢复的能力。

  将时间和精力集中在我们的快速恢复能力上，比起一开始就预防失败，具有更高的杠杆作用。

  Key Takeaways

  先做简单的事情

  快速失败以便快速找到问题的根源

  使决策过程自动化

  旨在实现幂等和可重试

  计划和练习失败模式

  Invest in Your Team’s Growth

  但是，如果您想提高效率，那么重要的是要认识到，建立一支强大的团队和积极的文化具有相当大的影响力。

  在职业生涯的早期就思考如何帮助您的同事成功，这会灌输正确的习惯，进而养成您自己的成功。

  Make Hiring Everyone’s Responsibility

  让招聘成为每个人的责任

  良好的面试过程可以实现两个目标。 首先，它筛选可能在团队中表现出色的人员类型。 其次，它使候选人对团队，任务和文化感到兴奋。

  花时间和你的团队一起考虑清楚，到底哪些特性对于潜在候选人是你最关心的

  周期性的回顾讨论当前面试流程的有效性

  设计面试问题，带有多个层次深度，以便能够适配不同能力水平的面试者

  控制面试节奏以便获得更高的信噪比

  通过迅速发出简短答案来探测广阔的表面来扫描危险信号

  在面试中经常另一位团队成员配对

  不要害怕使用非常规的面试方法，只要它们能帮助您确定团队所关心的信号

  Design a Good Onboarding Process

  设计一个良好的入职流程

  第一印象很重要。 良好的初始经验会影响工程师对工程文化的理解，影响其交付未来影响的能力，并根据团队的工作重点指导他的学习和活动。

  入职流程的四个目标：

  新工程师尽快提升产出

  传授团队文化和价值

  使新工程师拥有成功所需的广泛基础知识

  通过社交方式将新工程师整合到团队中

  Share Ownership of Code

  共享代码的主人翁意识

  当你成为某个项目的瓶颈时，你就失去了做其他事情的灵活性。

  策略：

  避免一个人的团队

  互相 review 代码和设计

  在整个团队中轮换任务

  保持代码的可读性和质量

  针对软件设计和架构进行技术演讲

  文档化。不论是设计文档还是代码注释

  记录完成工作所需的复杂工作流程或非显而易见的解决方法

  花时间在教学和指导其他团队成员上

  Build Collective Wisdom through Post-Mortems

  通过事后复盘来建立集体智慧

  Build a Great Engineering Culture

  建立伟大的工程师文化

  伟大的工程师文化：

  为迭代速度而优化

  持续无情的追求自动化

  建立正确的软件抽象

  通过代码评审关注高质量的代码

  维护一个互相尊重的工作环境

  建立一个共享的代码主人翁意识

  在自动化测试上投入

  分配实验性时间

  培养持续学习和提升的文化

  雇佣最优秀的人才

  Key Takeaways

  帮助周围的同事成功

  让招聘成为高优先级的事情

  在入职流程和 mentor 机制上投入

  建立代码的共享主人翁意识

  沉淀集体智慧

  建立伟大的工程师文化

• 希望新的一年里，做一个有效率的工程师

  作者：memorykeeper 发布时间：2019-12-28 21:43:49

• 全书书摘总结

  作者：Siva 发布时间：2017-08-05 16:38:38

  阅读更多

  https://github.com/gaohailang/blog/issues/3

  书籍分为三个部分：

  1 adopt the right mindsets 摆正态度

  包含了识别和集中精力在 high-leverage activity，为学习而优化，优先级」

  2 execute, execute, execute 执行的艺术

  包含了加快迭代速度，为提高而measure衡量，经常和尽早的验证想法，提高项目预估

  3 build long-term value 长期价值

  在质量和实效间权衡，减少手动操作，给团队加把力

  这些习惯来自于reinforced by scientific research, stories from industry, and concrete examples.

  1 focus on high-leverage activities

  - use leverage to measure your engineer effectiveness

  - systematically increase the leverage of your time

  三种方法： 1 find ways to get an activity done more quickly, 2 to increase the impact of an activity, or 3 to shift to activites with higher leverage

  - focus your effort on leverage points / direct energy toward leverage points, not just easy wins

  招聘这件事就是需要花很长时间去做的（Facebook 好几年优化）

  Employees view themselves as the guardians of high standards, and hiring is a top priority for both managers and engineers. 招聘是头等大事. 高标准的守护者。但有些工程师 view recruiting and interviews as distractions from getting their work done. 如submit feedback immediately, first humnaly-possible time slot 如早上8点中午1点等

  同样比尔盖茨在慈善事业上也是. global economy worth ten of trillions of dollars, any philanthropic effort is relatively small. 所以需要 way to put in a dollar of funding or an hour of effort and benefit society by a hundred or a thousand times as much.

  2 optimize for learning 为学习而优化

  - own your story/adopt a growth mindset

  集中在自己能改变的事上，growth mindset，把失败看做提升的机会。

  - don't shorchange your learning rate

  学习也是复利，越积累越学越快的「easier to apply prior insights and lessons new things，为了长期的发展，早期加大学习的投入~

  - find work environments that can sustain your growth/seek work enviroments conducive to learning

  转组前的准备，向同事咨询和找到noboarding的机会，同时看看 how transparent they are internally, how fast they move, what your prospective co-workers are like, and how much autonomy you'll have. 六大因素for supporting high personal and professional growth rate. 1 fast growth, 2 training, 3 openess, 4 people, 5 pace,节奏 6 autonony

  节奏： • What percentage of time is spent on maintenance versus developing new products and features?

  节奏： • What tools does the team use to increase iteration speed?

  people： • Are there skills they can teach you?

  openness： • Do teams meet to reflect on whether product changes and feature launches were worth the effort? Do they conduct post-mortems after outages? 「迭代的思路去提升而不是一开始就寻求最佳实践等」

  - capitalize on opportunities at work to improve your technical skills/dedicate time on the job to develop new skills

  利用工作提供的机会来提升，如阅读你同事好的工程师的代码让他们code-review，参加公司的培训，公司出钱参加的课程和书籍等

  Study code for core abstractions written by the best engineers at your company.

  Write more code.

  Go through any technical, educational material available internally

  Master the programming languages that you use

  .

  Send your code reviews to the harshest critics

  Enroll in classes on areas where you want to improve. [coursera, edx, udemy

  , udacity

  ]

  Participate in design discussions of projects you’re interested in [

  Ask project leads if they’d mind you being a silent observer or even a participant in a design meeting

  ]

  Work on a diversity of projects [

  interleaved practice

  of different skills is more effective than repeated,

  massed practice

  of a single skill at preparing people to tackle unfamiliar problems.]

  Make sure you’re on a team with at least a few senior engineers whom you can learn from.

  Jump fearlessly into code you don’t know.

  - locate learning opportunities outside of the workplace / always be learning

  每天都提高1%，不必都是工程软件相关的，其他领域的都可以。因为更愉悦的学习者长期有益于成为高效的工程师

  在工作之外找到学东西

  - learn new programming languages and framework

  new skills can expand your mind and teach you how to think in different ways.

  - invest in skills that are in high demand 如看看job posting中，看业界潮流，如深度学习和mobile development等

  - read books

  Bill Gates reads a lot and mostly non-fiction, using books to discover how the world works. 速度2-3x faster提升，同时作者给出了书单

  - join a discussion group

  I’m a part of a few book clubs and reading groups that meet regularly for discussion at cafes and apartments.如本杰明富兰克林就参加很多这样的来 discuss and debate morals, politics, or natural philosophy.

  - attend talks, conferences, and meetups

  - build and maintain a strong network of relationships

  Lucky people dramatically increase the possibility of a lucky chance encounter by meeting a large number of people in their daily lives. 书籍 the luck factor 中有

  - follow bloggers who teach

  - write to teach

  帮助你更好的理解你熟悉的东西（甚至帮助你自己reflecting和学习）.

  - tinker on side projects

  打磨技术，articularly in areas of interest that you don’t typically engage in at work.跨界.

  - pursue what you love

  不要passive time spent aimlessly surfing TV channels or the web.

  3 Prioritize Regularly

  - track to-dos in a single, easily accessible list

  - focus on what directly produces value

  - focus on the important and non-urgent

  - protect your maker's schedule

  - limit the amount of work in progress

  - fight procrastination with if-then plans

  - make a routine of prioritization

  讲grow product's user. 增长团队。 deciated to the art of science of user growth, 优化how users flow into and out a product. 同时 data and metrics数据和指标，同时 run endless user experiments and optimizing conversion rates. 需要结合 engineering, data and product marketing to build their strategies. 和普通工程团队一样需要 building experimention frameworks, and analyzing metrics 同时不一样的是： the list of ideas for driving traffic and growth is extremely open-ended and spans virtually the entire product.

  最重要的是找到方法让做优先级和todolist成为习惯！

  prioritizing 很难因为它本身不create anything，而且消耗精力。不需要一直做。但是if have certian personal or professional goals that you want to achieve, prioritiization has very high leverage. - see its outsized impact on your ability to get the right things done.

  4 invest in iteration speed

  - the faster you can interate, the more you can learn

  - invest in time-saving tooling

  - optimze your debuging workflow [don't underestimate how much time get spent validating that your code works]

  the extra investment in setting up a minimal debugging workflow can help you fix annoying bug sonner and with less headache. 建立最小可用debug流程帮助快速进入诊断问题

  - master the fundamentals of your crafts [development environment 熟悉开发环境， pay off dividends throughout your career]

  知道如何在IDE/editor 中完成下面的事情：

  Compiling or building code

  Running a unit test or program

  Reloading a web page on a development server with new changes

  Testing out the behavior of an expression

  Looking up the documentation for a certain function

  Jumping to a function definition

  Reformatting code or data in text editor

  Finding the callers of a function

  Rearranging desktop windows

  Navigating to a specific place within a file

  其他相关事：

  Learn at least one productive, high-level programming language.

  Prefer the keyboard over the mouse

  Automate yoru manual workflow

  Test out ideas on an interactive interpreter

  Make it fast and easy to run just the unit tests associated with your current changes.

  - take a holistic view of your iteration loop [don't ignore any organizational and team-related bottlenecks that may be within your circle of influence] 提升公司与组织层面上的如infra，利用你影响力能触达的

  5 measure what you want to improve

  - measure your progress

  because it’s hard to measure a goal doesn’t mean that it’s not worthwhile to do so.

  常常问自己. is there some way to measure the progress of what i'm doing. 如果我做的无法 move a core metric, is it worth doing, or is there a missing key metric?

  - carefully choose your top-level metric

  the right metrics functions as North Star.

  1 hours worked per week vs. productivity per week

  2 click-through rates vs long click-through rates

  3 average response time vs 95yh or 99th percentile respopnse times [To decrease the 95th or 99th percentile, however, you’ll need to hunt down the worst-case behaviors in your system.]

  4 bugs fixed vs bugs outstanding

  5 registered users vs. weekly growth rate of registered user

  6 Weekly active users vs. weekly active rate by age of cohort [防止哪种用了不用的人- measure the fraction of users who are still weekly actives the nth week after signing up]

  a metric that, when optimized, maximizes impact for the team. [whether it’s products sold, rentals booked, content generated, or something else—enables you to compare the output of disparate projects and helps your team decide how to handle externalities]

  An actionable metric is one whose movements can be causally explained by the team’s efforts. 而不是哪种 page views, registered users count 等「可能是之前的报道引流的」，观察 things like signup conversion rate, or the percentage of registered users that are active weekly over time

  A responsive metric updates quickly enough to give feedback about whether a given change was positive or negative

  - instrument your system

  [The easier it is to instrument more metrics, the more often you’ll do it.] 使用Open-source tools like Graphite, StatsD, InfluxDB, Ganglia, Nagios, and Munin make it easy to monitor systems in near real-time.

  The first describes a high-level, big-picture activity, whereas the second is about gaining insight into what’s going on with systems that we’ve built. 你的系统需要越多越全面越好的instrument.

  Once they had some visibility into what was happening, they were able to add caching to bring down load times from 8 seconds down to 2, fix bugs to reduce error rates down from an egregious 6% to 0.5%. 建立dashboard 等

  They measure everything including “numbers of new registrations, shopping carts, items sold, image uploaded, forum posts, and application errors.” By graphically correlating these metrics with the times of code deployments, they’re able to quickly spot when a certain deployment goes awry.

  At Google, site reliability engineers use a monitoring system called Borgmon to collect, aggregate, and graph metrics and to send alerts when it detects anomalies.

  Twitter built a distributed platform called Observability to collect, store, and present a volume of 170 million individual metrics per minute

  LinkedIn developed a graphing and analytics system called inGraphs that lets engineers view site dashboards, compare metrics over time, and set up threshold-based alerts, all with a few lines of configuration

  - know your numbers [方便获取数据]

  - prioritize data integrity [bad data 可能会让你做出错误的决定]

  譬如 common latency numbers（见系统优化）

  6 validate your ideas early and often

  - approach a problem iteratively to reduce wasted effort.

  拆分到多个MVP迭代特性不要逞强

  -

  Reduce the risk of large implementations by using small validations

  - use a/b testing to continuously validate your product hypotheses

  - when working on a solo project, find ways of soliciting regular feedback

  - adopt a willingness to validate your decisions

  建立反馈机制用于收集数据来验证你工作价值和有效性

  7 improve your project estimation skills

  - incorporate estimates into the project plan

  Don’t let a desired target dictate the estimates.明确特定功能特性上线时间

  - allow buffer room for the unknown in the schedule

  - define measurable milestones

  - do the riskest takes first

  Reduce variance in your estimates and risk in your project by exploring the unknown early on 先做风险大的来提前暴露出unknown.

  - Approach rewrite projects with extreme caution

  - know the limits of overtime / don't sprint in the middle of a Marathon

  [Work overtime only if you’re confident that it will enable you to finish on time.]

  8 balance quality with pragramtism

  - establish a culture of reviewing code

  - invest in good software abstractions to simplify difficult problems

  - scale code quality with automated testing

  大胆重构前先要建立 suite of unit and integration tests. alleviate the fear of modifying what might otherwise be brittle code.

  - manage your technical debt

  不要花太多时间在maintain一个软件上。 if you spend all your resources paying off interest on your debt, you won't have enough time left to work on new things. focus on the debt that oncurs the most interest.

  9 minimize operational burden

  - do the simple thing first/embrace operational simplicity

  Simple solutions impose a lower operational burden because they’re easier to understand, maintain, and modify

  When you first start off trying to solve a problem, the first solutions you come up with are very complex, and most people stop there. But if you keep going, and live with the problem and peel more layers of the onion off, you can oftentimes arrive at some very elegant and simple solutions.

  - fail fast to pinpoint the source of errors/ build systems to fail fast

  系统有问题就尽早报错loudly！

  - automate mechanics over decision-making

  为什么不把自动化做了？ 短期没时间，能每一次都花10分钟会让人麻木而不去话一小时去构建自动化（其他如lack familiarity with automation tools, individuals act rationally according to their own self-interest but contrary to the group’s best long-term interests）

  distinguished between two types of automation: automating mechanics and automating decision-making. Automating the right decisions to make, particularly in the context of building systems that can heal and repair themselves when things go wrong, turns out to be much more challenging. 譬如LB一台机器挂了把流量全部导入到另一台会打死剩下的机器

  Validating that a piece of code, an interaction, or a system behaves as expected

  Extracting, transforming, and summarizing data

  Detecting spikes in the error rate

  Building and deploying software to new machines

  Capturing and restoring database snapshots

  Periodically running batch computations

  Restarting a web service

  Checking code to ensure it conforms to style guidelines

  Training a machine learning model

  Managing user accounts or user data

  Adding or removing a server to or from a group of services

  - aim for idompotence and reentrancy/make batch processes idempotent

  One technique to make batch processes easier to maintain and more resilient to failure is to make them idempotent. 让脚本执行多次也是冥等的[如网络问题，数据量大奔溃，服务没起来等]

  Perhaps it generates a monthly analytics report, produces a new search index, or archives stale user data. the ability to run infrequent processes at a more frequent rate than strictly necessary, to expose problems sooner.

  - plan and practice failure modes

  10 invest in your team's growth

  - help the people around you be successful

  - making hiring a priority

  - invest in onboarding and mentoring

  - build shared ownership of code / AB岗位

  When you’re the bottleneck for a project, you lose your flexibility to work on other things. High-priority bugs get routed to you more frequently because your expertise enables you to fix them faster.

  Avoid one-person teams.

  Review each other’s code and software designs.

  Rotate different types of tasks and responsibilities across the team.

  Keep code readable and code quality high.

  Present tech talks on software decisions and architecture.

  Document your software, either through high-level design documents or in code-level comments.

  Document the complex workflows or non-obvious workarounds necessary for you to get things done.

  Invest time in teaching and mentoring other team members.

  - debrief and document collective wisdom

  去询问 what worked and what didn't work. document and share the lessons so that valuable wisdom doesn't get lost

  - create a great engineer culture

  Appendix 作者书单，好的blogger

  PS：

  holy grails

  idempotent

  disparate

  holistic 全面的

  back-of-the-envelope calculation 粗略计算

  brittle 易碎的

  debrief 询问

  ramp up

  measles 麻疹

  philanthropic 慈善的

  jeopardy

• Notes on The Effective Engineer

  作者：Dufan 发布时间：2020-05-14 11:02:34

  入行近两年，工作过两个组，时常还是在burnout的时候困惑自己是否是一个合格的代码生产者，在不断的reorg间，怀疑自己做的项目是否真的有价值，如何能做一个开心且有效率的工程师。这本书也是作者思考这个问题搜集的资料和自己的思考，读的过程中好多坑也是自己亲身走过，想疯狂点头表示+1，合上书后投入到日常工作中，没过多久焦虑和不知所措又重新涌上来。下次burnout/不想工作的时候可以回看这篇书里节选的notes吸取一点阳光。

  （PS. 疫情前从library借走10本书简直是今年做过最好的决定，拖延症总是高估自己的阅读速度，之前两周的checking out period经常看到一半就需要还回去，这次county图书馆无限延长借阅时间简直不能太开心）

  Part 1 Adopt the right mindset

  #

  Leverage

  #

  - High-leverage activities behave similarly, letting you amplify your limited time and effort to produce much more impact.

  - 3 questions to ask:

  1. How can I complete this activity in shorter amount of time?

  2. How can I increase the value produced by this activity?

  3. Is there something else that I could spend my time on that would produce more value?

  - 3 solutions:

  1. automate parts of development/testing process that thus far done manually

  2. prioritize tasks based on how critical they are for launch so that you maximize the value of what you finally ship

  3. talk with customer support to understand value

  #

  Growth mindset

  #

  - own your story: write your own story instead of letting others define it

  - capitalize on opportunties at work to improve your technical skills

  - locate learning opportunities outside of the workspace

  - study code for core abstractions written by the best engineers at your company

  #

  Prioritize Regularly

  #

  - understand # of projects you can work on simulatneously; resist urge to take more (reduce context switches)

  - build routine to manage and execute on your own priorities

  - make if-then plans to combat procrastination

  - work on important and non-urgent (prioritize long-term investments that increase effectiveness)

  Part 2 Execute, Execute, execute

  - optimize iteration speed: identify biggest bottlenecks and figure out how to eliminate them.

  - optimize your debugging work flow

  - invest in tooling

  #

  Metrics

  #

  Good metrics

  1. help you focus on right thing

  2. drive forward progress

  3. help guard against future regression

  4. measure effectiveness, compare leverage

  #

  Data integrity

  #

  - log data liberally, in case it turns out useful later

  - build tools to iterate on data accuracy sooner

  - write E2E integration test to validate entire analytics pipeline

  - examine collected data sooner

  - cross-validate data accuracy by computing same metric in multiple ways

  - when a # look off, dig into early

  #

  Validate ideas early and often

  #

  - optimize for feedback asap, understand what user actuallly want and iterate on that feedback

  - create a feedback loop (soliciting regular feedback)

  #

  Improve project estimation

  #

  - budget for unknown

  - do the riskiest tasks first

  - reduce risk early: stub out incomplete module & assemble E2E system ASAP

  - think of estimate as probability distribution

  - beware of anchoring bias (ignore timeline your manager gives you first)

  - define specific project goals & measureable milestones (sharded)

  #

  Rewrite projects with caution

  #

  - add new features to new or old system

  - Frederick Brooks "second-system effect: difficulties in rewriting"

  - convert a large rewrite project into a series of smaller projects

  - using an incremental approach may increase overall amount of work but dramatically reduce risk is often worth it

  Part 3 Build Long-term value

  #

  Balance quality with pragmatisim

  #

  Bobby Johnson (director of FB engineer): "Instead of right/wrong. Look at it from work vs not work"

  - To the point where the processes provide deminishing returns on quality and actually reduce effectiveness.

  - Manage complexity through abstraction: create an abstraction too early, before you have a firm handle on the general problem you're solving, the resulting design can be overfitted to the available use case.

  #

  Technical Debt

  #

  - Since our initial understanding of problems always will be incomplete, incurring a little debt is unavoidable; it's just part of getting things done.

  - The key to being a more effective engineer is to incur TD when it's necessary to GTD for a deadline, but to pay off the debt periodically.

  - lightweight mechanism to pay off technical debt "Fixit week: with theme

  #

  Minimize Operational Burden

  #

  - keeping a system up and running, scaling a feature to support more users, fixing bugs, transferring an ever-growing body of institutional knowledge to new engineers --- all of these costs continue to tax a team's resources, even after a feature or system ships. When team is small, minimizing that tax is critical.

  - Steve Job on iPod: When you first start off trying to solve a problem, the first solutions you come up with are very complex, and most people stop there. But if you keep going, and live with the problem and peel more layers of the onion off, you can oftentimes arrive at some very elegant and simple solutions. Most people just don't put in the time or eneergy to get there.

  - Mike Krieger, Instagram CTO. Pick solid & proven technologies instead of new ones

  - "Do Simple thing first" mantra/core engineering tenet

  - Fail fast

  * crash at startup time when encoutnering config errors

  * Validate software inputs early

  * bubble up an error from external service you don't know how to handle

  * alert engineers about any invalid or inconsistent program state as early as possible

  * a lot of catches may not technically good slowly faling system. Make it difficult to discover what went wrong.

  #

  Automate Mecahnical tasks

  #

  - automatic mechancis

  - automate decision making

  #

  Batch process

  #

  - scripts executing a sequence of actions without human intervention

  - "idempotent"

  * make each process either fali entirely or succeed entirely

  * the ability to run infrequent process at a more frequent rate than strictly necessary to expose problem sooner

  - run batch process more frequently (a system check every 5 minutes to 10 minutes is not as good as every 60s and watch for consecutive failures)

  - Netflix: Chaos Monkey actively wreak havoc on their own system, develop the ability to recover quickly

  #

  Good interview process

  #

  - screen for the type of people likely to do well

  - get candidate excited about team/culture/mission

• 高效率工程师的成长之路

  作者：略显疲惫 发布时间：2022-10-04 16:08:21

  比较适用于程序员的效率提升，尽管已经工作多年，书中提高的各种工具也比较了解，但是仍然有许多点，对自己有较大的启发，尤其是最后一章团队提升的部分，受益匪浅。

  

  脑图

  写在前面

  Time is our most finite asset, and leverage—the value we produce per unit time—allows us to direct our time toward what matters most.

  Part 1: Adopt the Right Mindsets

  1.专注于高杠杆的事情，Focus on High-Leverage Activities

  leverage = impact produced / time invested

  提升杠杆的三种途径：

  减少投入时间

  提升impact

  转去做更高杠杆的事情

  2.优化学习曲线，Optimize for Learning

  学习曲线是指数增长的，我们越早地提升它，越能享受时间带来的复利。当我们把时间花在没有挑战性的任务上时，不仅觉得无聊，更重要的是浪费了快速提升的机会，沉默成本很高。

  寻找能促进我们学习的工作环境（公司成长性、培训、开放性、快节奏、共事的人）

  刻意练习，花时间去开发新技能

  去建立和维护一个强大的社交关系，认识的人多了，里面就会存在能带给你正面影响的人.（在做好筛选的情况下，增大自己的关系网，总有能帮助到你的人）

  3.要事为先，Prioritize Regularly

  把todo list写下来，用脑袋去做排序，但不做存储。

  做重要而不紧急的事情。重视提升效率的有长期价值的事情

  小技巧：在日程表上建假的会议，不能被其他人约上

  减少多线程的切换，比较耗费精力

  小技巧：通过看板功能（readyin processdone）来流转任务，根据自己的情况调整同时在处理的任务数

  通过if-then的逻辑缓解拖延症

  设计一个trigger来触发事情

  把排列优先级变成一个习惯，焦点都在高杠杆事情上

  Part 2: Execute, Execute, Execute

  4.提升迭代速度 Invest in Iteration Speed

  迭代的越快，能学的越多，不然会失去很多机会

  投入时间去优化工具（开发工具、debug工具）

  熟练掌握专业上最基础的知识

  5.量化目标 Measure What You Want to Improve

  如果你无法量化一件事情，你就无法提升它

  审慎地选择你的最重要的衡量指标，不同的指标会导致不同的方向和结果

  监控和量化你的系统，知道当前系统的运行情况。

  记住一些常用的数字，便于估计.

  重视数据的正确性. 错误的数据比没有数据更严重

  6.尽早开始验证你的想法 Validate Your Ideas Early and Often

  使用A/B test

  一个人做项目时，找到途径去索取日常的反馈

  不要一次做个大新闻，小步迭代，收集数据和反馈

  7.提升你的项目排期能力 Improve Your Project Estimation Skills

  针对未知的部分留出足够的buffer

  设计明确的milestones，让你知道当前是否落后进度

  优先做风险最高的事情

  减少加班，容易burn out

  具体建议

  把任务尽可能做原子层面的拆解

  把估计想成是概率分布，不是最优的情况

  让做事的人给出排期

  通过不同的方式去估计同一个任务

  敬畏“人月神话”，并不是直接堆人就能解决问题

  使用timebox去限制每个任务，防止走远了，超过预期时间

  Part 3: Build Long-Term Value

  8.平衡质量和实用主义 Balance Quality with Pragmatism

  平衡code review和开发速度，不过于死板

  自动化测试

  合理地管理技术债，不要投入过多精力导致无法开发新项目

  9.减轻日常运转的负担 Minimize Operational Burden

  优先做简单的功能，简单的系统易于理解、扩展和维护

  让error fail fast，不要留到最后才报告，不容易debug

  做系统故障处理的演练和计划，提升处理问题的自信心

  10.投资你的团队 Invest in Your Team’s Growth

  帮助你周围的人成功

  提高招聘的优先级

  完善新人入职流程和导师制度

  尽快的提升新人

  把团队的文化和价值观传递给新人

  把做成事情的基本元素教给新人

  让新人融入团队的社交圈子

  建立代码共享的ownership，让你有时间去做更高杠杆的事情

  单独的负责一个项目并不能体现你的价值

  建议

  减少一个人团队

  和其他人互相做代码code review和方案设计

  在团队内交替滚动不同的任务

  保持代码的可读性和代码质量

  做tech talk

  文档化

  投入时间指导团队成员

  群体智慧，记录项目中哪些的教训，哪些work哪些不work

  创建好的工程师文化

  优化迭代速度

  自动化

  好的软件抽象

  code review

  Build shared ownership of code.

  Allot experimentation time, either through 20% time or hackathons.

  Hire the best.

  写在后面

  在工作上提高效率，在陪伴家人时不要考虑这些，尽情享受生活。

  附原文摘录笔记：

  写在前面

  Time is our most finite asset, and leverage—the value we produce per unit time—allows us to direct our time toward what matters most.

  Part 1: Adopt the Right Mindsets

  1.Focus on High-Leverage Activities

  leverage = impact produced / time invested

  “Increase Your Leverage in Three Ways”：

  By reducing the time it takes to complete a certain activity.

  By increasing the output of a particular activity.

  By shifting to higher-leverage activities.”

  2.Optimize for Learning

  Learning follows an exponential growth curve. The earlier that you optimize for learning, the more time your learning has to compound. we tend to drastically underestimate the impact of small changes on our growth rate. But when we spend our work hours on unchallenging tasks, we’re not just boring ourselves and missing out on chances to learn—we’re also paying a huge opportunity cost in terms of our future growth and learning.

  Build and maintain a strong network of relationships. The more people they meet, the greater opportunity they have of running into someone who could have a positive effect on their lives.

  3.Prioritize Regularly

  “Write down and review to-dos. Spend your mental energy on prioritizing and processing your tasks rather than on trying to remember them. Treat your brain as a processor, not as a memory bank”

  Work on the important and non-urgent. Prioritize long-term investments that increase your effectiveness, even if they don’t have a deadline.

  Block off hours on your calendar (maybe even with a fake meeting) or schedule days like “No Meeting Wednesdays” to help consolidate chunks of time.

  Reduce context switches. Protect large blocks of time for your creative output, and limit the number of ongoing projects so that you don’t spend your cognitive energy actively juggling tasks.

  transitioning tasks through various columns on a board (e.g., “backlog,” “ready,” “in progress,” and “done”), and limiting the amount of work-in-progress according to your own bandwidth as determined by trial and error.

  Make if-then plans to combat procrastination. Binding an intention to do something to a trigger significantly increases the likelihood that you’ll get it done.

  Make prioritization a habit. Experiment to figure out a good workflow. Prioritize regularly, and it’ll get easier to focus on and complete your highest-leverage activities.”

  “Part 2: Execute, Execute, Execute”

  4.“Invest in Iteration Speed”

  The faster you can iterate, the more you can learn. Conversely, when you move too slowly trying to avoid mistakes, you lose opportunities.

  Invest in tooling.

  Optimize your debugging workflow.

  Master the fundamentals of your craft.

  5.“Measure What You Want to Improve”

  If you can’t measure it, you can’t improve it.

  Carefully choose your top-level metric. Different metrics incentivize different behaviors.

  Instrument your system. The higher your system’s complexity, the more you need instrumentation to ensure that you’re not flying blind.

  Know your numbers. Memorize or have easy access to numbers that can benchmark your progress or help with back-of-the-envelope calculations.

  Prioritize data integrity. Having bad data is worse than having no data, because you’ll make the wrong decisions thinking that you’re right.”

  6.“Validate Your Ideas Early and Often”

  Use A/B testing to continuously validate your product hypotheses.

  When working on a solo project, find ways of soliciting regular feedback.

  Adopt a willingness to validate your decisions. Rather than making an important decision and moving on, set up feedback loops that enable you to collect data and assess your work’s value and effectiveness.”

  7.“Improve Your Project Estimation Skills”

  Allow buffer room for the unknown in the schedule.

  Define measurable milestones. Clear milestones can alert you as to whether you’re on track or falling behind.

  Do the riskiest tasks first. Reduce variance in your estimates and risk in your project by exploring the unknown early on.

  Know the limits of overtime. Many teams burn out because they start sprinting before they’re even close to the finish line.

  So how do we produce accurate estimates that provide us the flexibility we need? Here are some concrete strategies:

  Decompose the project into granular tasks.”

  Think of estimates as probability distributions, not best-case scenarios

  Let the person doing the actual task make the estimate.”

  Use multiple approaches to estimate the same task.”

  Beware the mythical man-month”

  Use timeboxing to constrain tasks that can grow in scope.”

  “Part 3: Build Long-Term Value”

  8.“Balance Quality with Pragmatism”

  Find the right balance between code reviews and tooling to trade off code quality and development speed.

  Invest in good software abstractions to simplify difficult problems.

  Scale code quality with automated testing.

  Manage your technical debt. If you spend all your resources paying off interest on your debt, you won’t have enough time left to work on new things.

  9.Minimize Operational Burden

  Do the simple thing first. Simpler systems are easier to understand, extend, and maintain.

  Fail fast to pinpoint the source of errors. Make debugging easier by not masking your errors and by not deferring failures until later.

  Automate mechanics over decision-making.

  Plan and practice failure modes. Building confidence in your ability to recover lets you proceed more boldly.

  10.“Invest in Your Team’s Growth”

  Help the people around you be successful. The high rungs of an engineering ladder are reserved for those who make their co-workers more effective.

  Make hiring a priority.

  Invest in onboarding and mentoring. The more quickly you can ramp up new team members, the more effective your team will be. The more effective your team, the more freedom you have to tackle different projects.

  “So how do you create a good onboarding process for your team?”

  “Ramp up new engineers as quickly as possible.”

  “Impart the team’s culture and values.”

  “Expose new engineers to the breadth of fundamentals needed to succeed.”

  “Socially integrate new engineers onto the team”

  Build shared ownership of code. This will give you the flexibility to focus on other high-leverage activities.

  There’s a common misconception that being the sole engineer responsible for a project increases your value.”

  To increase shared ownership, reduce the friction that other team members might encounter while browsing, understanding, and modifying code that you write or tools that you build. Here are some strategies:

  Avoid one-person teams.

  Review each other’s code and software designs.

  Rotate different types of tasks and responsibilities across the team.

  Keep code readable and code quality high.

  Present tech talks on software decisions and architecture.

  Document your software, either through high-level design documents or in code-level comments.

  Document the complex workflows or non-obvious workarounds necessary for you to get things done.

  Invest time in teaching and mentoring other team members.

  Debrief and document collective wisdom. Reflect on projects with team members, learn what worked and what didn’t work, and document and share the lessons so that valuable wisdom doesn’t get lost.

  Create a great engineering culture. This will help you be more productive, streamline decisions, and recruit other strong engineers. You build a great culture by fostering the same habits you need to effectively deliver impact.”

  Based on my hundreds of interviews and conversations, I’ve found that great engineering cultures:

  Optimize for iteration speed.

  Push relentlessly towards automation.

  Build the right software abstractions.

  Focus on high code quality by using code reviews.

  Maintain a respectful work environment.

  Build shared ownership of code.

  Invest in automated testing.

  Allot experimentation time, either through 20% time or hackathons.

  Foster a culture of learning and continuous improvement.

  Hire the best.

  写在后面

  We enjoy plenty of leisure activities like traveling, hiking, salsa dancing, and spending time with family and friends without giving any thought to whether they’re high-impact or represent the optimal use of our time—and that’s how it should be. But when it comes to achieving our work and life goals, leverage is a powerful framework for helping us focus on the right things.

• 读后感

  作者：唐宋元明清 发布时间：2022-03-03 17:28:57

  最优秀的软件工程师在未来的公司里会寻找什么呢？带着这个问题进入本书的阅读，可以发现伟大的工程师文化在不同组织架构、不同形态的团队中出现类似，如迭代速度、自动化、软件抽象的理念、软件质量、共担责任以及优秀的团队文化。

  带着这些问题，可以在书中获得答案，这其实一点都不奇怪，因为最优秀的软件工程师喜欢把事情做好，而我们一直在讨论的高杠杆率投资恰恰就能使他们更快地完成工作。

  在书中，有一个十分有价值，但是却不“新颖”的观点，为什么说不“新颖”，是因为每个技术管理者都遇到过但却容易忽视的，那就是初始团队成员的价值观。每个技术管理者都需要思考，如何寻找最优秀的软件工程师，这个答案可以帮助我们做出更好的决策、更快地适应环境、吸引更强大的人才。