跟随器反馈回路电阻_如何将短反馈回路设置为单独编码器

跟随器反馈回路电阻

I’ve spent the last couple years as a solo freelance developer. Comparing this experience to previously working in companies, I’ve noticed that those of us who work alone can have fewer iterative opportunities for improvement than developers who work on teams.

在过去的几年中，我以自由开发者的身份工作。与以前在公司工作过的经验相比，我注意到与团队工作的开发人员相比，我们一个人工作的迭代机会更少。

In order to to have opportunity to improve, we need to embrace the concept of a short feedback loop. This is a process of incorporating new learning from observation and previous experience continuously over a short period of time. This process has to be manufactured by people working mostly alone, instead of, as is often the case, adopted when you join a team.

为了有机会进行改进，我们需要采用短反馈循环的概念。这是一个在短时间内连续从观察和以前的经验中学到新知识的过程。这个过程必须由人大多是独自工作，而不是进行制造，这是常有的情况下，当你加入一个团队采用。

In this post, I hope to share what I’ve learned about setting yourself up to improve quickly and continuously as a solo coder.

在这篇文章中，我希望分享我所学到的关于如何设置自己的知识，以便快速，连续地提高自己作为独立编码员的能力。

关于反馈循环 (About feedback loops)

United States Air Force Colonel John Boyd developed the concept of the OODA loop, OODA being an acronym for observe, orient, decide, act. In military operations, this illustrates a process of decision-making based on the constant ingestion of new information:

美国空军上校约翰·博伊德(John Boyd)提出了OODA循环的概念，OODA是观察，定向，决定和行动的首字母缩写。在军事行动中，这说明了基于不断吸收新信息的决策过程：

Observe: Obtain raw information about unfolding circumstances and the current environment.

观察：获取有关进展情况和当前环境的原始信息。

Orient: Put raw observations in context. Consider such things as relevancy to the current situation and previously gained knowledge and expertise.

方向：将原始观察结果放在上下文中。考虑与当前状况和先前获得的知识和专长相关的事物。

Decide: Make a plan for moving towards your goal.

决定：制定实现目标的计划。

Act: Execute the plan.

行动：执行计划。

Since it’s a loop, the act stage leads directly back into the observe stage. This is the critical “feed back” concept that enables increasingly successful iterations. It’s widely applicable beyond military operations — you may recognize it as the origin of the PDCA (plan-do-check-act) method.

由于是循环，因此动作阶段直接回到观察阶段。这是至关重要的“反馈”概念，可以使迭代越来越成功。它广泛应用于军事行动之外-您可能会认为它是PDCA (计划执行检查行动)方法的起源。

I like the OODA loop, as it’s a succinct illustration of a general feedback loop. Many concepts and working methods build on the idea of feedback loops, including DevOps and agile software development methods.

我喜欢OODA循环，因为它是一般反馈循环的简洁说明。许多概念和工作方法都基于反馈循环的思想，包括DevOps和敏捷软件开发方法。

开发团队反馈循环 (Development team feedback loop)

Let’s look at what some components of a feedback loop for a developer on a team might look like:

让我们看一下团队中开发人员的反馈循环的某些部分可能是什么样的：

Direction from product owners or reviews from users
产品负责人的指示或用户的评论
Daily scrum/standup with whole team
每天与整个团队一起狂欢/站立
Prioritization with developer team
与开发团队优先
Individual coding and testing
个别编码和测试
Peer code review
对等代码审查
Deployment and performance monitoring
部署和性能监控

Implicit in these steps is the support of co-workers and management — in other words, someone to answer to. How can a solo freelance developer create a similar environment of accountability?

这些步骤中隐含的是同事和管理层的支持-换句话说，是要回答的人。一位自由职业开发人员如何创建类似的问责环境？

开发人员反馈循环 (Solo developer feedback loop)

Here are some possible steps that an individual freelance developer can implement to create a short feedback loop:

自由职业者开发人员可以执行以下一些步骤来创建简短的反馈循环：

Build discipline
建立纪律
Clarify concrete top-level goals
明确具体的最高目标
Prioritize and plan mid-level and low-level goals
优先安排和计划中级和低级目标
Automate your work
自动化您的工作
Block out time for code review
抽出时间进行代码审查
Block out time for process review
抽出时间进行流程审查
Update your goals and processes with the results of your reviews
用评论结果更新您的目标和流程

I’ll cover each of these stages in detail below.

我将在下面详细介绍每个阶段。

建立纪律 (Build discipline)

More of a prerequisite than a stage in itself, building discipline is what enables our short feedback loop to work. Nothing else in this article will be helpful unless we have the skill to do something we don’t want to do. Discipline is most certainly a skill. It can be learned, trained, and improved just like any other.

建立纪律本身比阶段本身更重要，但前提是要使我们的简短反馈回路能够正常工作。除非我们有技巧去做我们不想做的事，否则本文中的其他内容将无济于事。纪律无疑是一种技能。可以像其他任何方法一样学习，培训和改进它。

Why is discipline so important? Because when we’re crunching to get a project completed this Friday evening, we’re not going to want to write a good commit message. We’re not going to want to clean up the code comments. We just want to see the darn thing go, Hello, git push -f.

为什么纪律如此重要？因为当我们努力在这个星期五晚上完成一个项目时，我们不想写一个好的提交信息。我们不想清理代码注释。我们只想看看该死的东西， 嗨，git push -f 。

It’s in those moments that discipline enables us to not miss an opportunity to practice, learn, and improve our work process. Discipline helps us avoid Friday night commits that turn into Monday morning git reset --hards.

正是在这些时刻，纪律使我们不能错过实践，学习和改善工作流程的机会。纪律帮助我们避免周五晚上的提交变成星期一早上的git reset --hard 。

明确具体的最高目标 (Clarify concrete top-level goals)

Whether working for a client or bootstrapping our own best-new-app-ever, we won’t be able to measure any progress or improvements without something to measure them against.

无论是为客户工作还是引导我们自己有史以来最好的新应用程序，如果没有针对它们的衡量标准，我们将无法衡量任何进度或改进。

When I’m discussing a new project with a client, I always speak in terms of concrete achievements. This could take the form of accomplishing a specific feature by a certain date, or deciding what the MVP looks like to a user. This is as much for my benefit as my client’s. By agreeing, in writing, what will be achieved and when, my client and I have clearly defined top-level goals and can both assess how the project is progressing.

当我与客户讨论新项目时，我总是会说具体的成就。这可以采取在某个日期之前完成特定功能的形式，也可以决定MVP对用户的外观。这对我和我的客户都一样有利。通过书面协议，将实现什么目标以及何时达成协议，我和我的客户已经明确定义了最高目标，并且都可以评估项目的进展情况。

When I’m working for myself, I treat myself as I would a client. I make a commitment, in writing, describing what will be achieved, and when. This can be something as simple as a goals list for the week, or as detailed as a kanban board.

当我为自己工作时，我会像对待客户一样对待自己。我以书面形式做出承诺，描述将要实现的目标以及何时实现。这可以像一周的目标列表一样简单，也可以像看板一样详细。

The point of having a concrete goal, however, is not to stick to it at all costs. It’s important to set an expectation, with ourselves and with our clients, that the goals will be revisited at mutually-agreeable dates over the course of the project. This enables the all-important “feed back” part of the loop.

但是，有一个具体目标的目的不是要不惜一切代价坚持下去。与我们自己和我们的客户一起设定期望是很重要的，在整个项目过程中将在双方同意的日期重新确定目标。这样可以实现循环中最重要的“反馈”部分。

优先安排和计划中级和低级目标 (Prioritize and plan mid-level and low-level goals)

Few goals are achieved all in one step. Even the simple process of making a peanut butter and jelly sandwich (a favourite computer programming teaching example) can be broken down into successively smaller, more precise instructions. While we humans may not require the granularity that a computer program does, goals that are chunked into time-boxed, achievable steps are much more easily digested. ?

几乎没有一个目标可以全部实现。甚至制作花生酱和果冻三明治的简单过程(最喜欢的计算机编程教学示例 )也可以分解为依次更小的更精确的说明。虽然我们人类可能不需要计算机程序所需要的粒度，但将目标分解为时间限制，可实现的步骤变得更加容易了。？

Start with the mid-level goals, and make each step concrete. If the goal is to release a new open source web app, for example, the steps might look like this:

从中级目标开始，然后将每个步骤具体化。例如，如果目标是发布新的开源Web应用程序，则步骤可能如下所示：

Complete app JavaScript
完整的应用JavaScript
Create front end and stylesheet
创建前端和样式表
Do local tests
做本地测试
Set up cloud server
设置云服务器
Deploy app to cloud
将应用程序部署到云
Do tests
做测试
Add repository to GitHub
将存储库添加到GitHub
Post on Hacker News
在黑客新闻上发布
Profit!!!
利润！！！

Each of the above examples encapsulates many smaller, low-level goals — we can think of these as our to-do list items. For example, “Set up cloud server” might involve:

上面的每个示例都封装了许多较小的低级目标-我们可以将它们视为待办事项。例如，“设置云服务器”可能涉及：

Research cloud providers
研究云提供商
Decide on service and sign up
确定服务并注册
Set up server/instance
设置服务器/实例
Add integrations
添加集成
Test deployment
测试部署

Our parameters for chunk sizes and what constitutes a “step” may be different from one another, and will likely change from project to project. If your mid-level and low-level steps clearly define a concrete path for achieving the top-level goals you set, then you’re in good shape. Later on, evaluating the decision process that brought us to these mid-level and low-level goals enables us to bring our feedback loop full circle.

我们关于块大小和构成“步骤”的参数可能彼此不同，并且可能因项目而异。如果您的中级和低级步骤明确定义了实现您设定的最高目标的具体路径，那么您就处于良好状态。稍后，评估将我们带到这些中级和低级目标的决策过程，使我们能够将反馈循环带入一个完整的圈子。

自动化您的工作 (Automate your work)

I recently read a great article entitled Manual Work is a Bug. It discusses a process by which successful developers document and eventually automate their work. The beauty of this idea is in its simplicity. By writing down the things we do manually, we’re able to correct and refine our processes. By refining our processes, we can more easily translate them into code snippets and scripts. With a collection of scripts that we can string together, we can automate our work.

我最近读了一篇很棒的文章，标题为“ 手工工作是一个错误” 。它讨论了成功的开发人员记录并最终使他们的工作自动化的过程。这个想法的优点在于其简单性。通过写下我们手动执行的操作，我们可以纠正和完善我们的流程。通过完善我们的流程，我们可以更轻松地将它们转换为代码段和脚本。有了我们可以串在一起的脚本集合，我们可以使我们的工作自动化。

Automating work isn’t only about saving time. It reduces haven’t-had-my-coffee-yet errors, minimizes cognitive load allowing more room for creativity, and allows our processes to be repeatable across collaborators and projects. It help shorten our feedback loop by ensuring we aren’t doing the same thing three times in three different ways.

自动化工作不仅仅是节省时间。它可以减少尚未发生的咖啡错误，最大程度地减少认知负担，为创造力留出更多空间，并使我们的流程在合作者和项目之间可重复。通过确保我们不会以三种不同的方式进行三次相同的操作，这有助于缩短反馈循环。

We can begin to automate by starting our own personal wiki. If we build a habit of writing down every manual thing we do, no matter how basic it may seem at the time, we give ourselves more opportunities to spot patterns, and thus possible integrations and improvements.

我们可以通过启动自己的个人Wiki开始自动化。如果我们养成写下我们所做的每项手动操作的习惯，无论当时看起来多么基础，我们都会给自己更多的机会来发现模式，从而可能进行集成和改进。

The first time we do something manually, we write out the steps. The second time, we follow the steps. This gives us the opportunity to correct and refine them based on what we’ve learned since the first time.

第一次手动执行操作时，我们会写出步骤。第二次，我们按照步骤进行。这使我们有机会根据自第一次以来所学到的知识对它们进行校正和改进。

Over successive iterations, we might replace parts of manual commands with variables. We might find handy snippets of bash scripts that automate just a part of our task. As long as we keep revising and improving our personal wiki, we’re moving towards automation.

在连续的迭代中，我们可能会用变量替换部分手动命令。我们可能会发现一些方便的bash脚本片段，这些片段可以使我们的任务自动化。只要我们不断修订和改进我们的个人Wiki，我们就会朝着自动化迈进。

抽出时间进行代码审查 (Block out time for code review)

It’s all too easy to commit messy code when we work alone. We think, who’s going to see it? I’ll fix it later. Each time that happens, though, we’re building a habit. It’s a bad one.

当我们独自工作时，提交凌乱的代码太容易了。我们认为， 谁会看到它？ 稍后再解决。 但是，每次发生这种情况时，我们都会养成一种习惯。真不好

Working alone means there’s no one likely to give feedback on our commits when we’re doing something that doesn’t make sense, or that could be improved. Instead, we have to actively seek out opportunities to improve. Open source communities are amazing for this. There’s a wealth of information available to us in terms of coding styles, examples of refactored code, and a smorgasbord of snippets that achieve that-thing-we-were-trying-to-do but in fewer lines. We can learn all we please, if we just block out the time to do it.

独自工作意味着当我们做的事情没有意义或可以改善时，就不可能有人就我们的承诺提供反馈。相反，我们必须积极寻找改善的机会。开源社区对此非常了不起。就编码样式，重构代码示例以及一小段代码片段而言，我们可以获得大量信息，这些代码片段可以实现我们想要尝试的事情，但是行数却更少。如果我们花时间去做，我们可以学到所有我们喜欢的东西。

Schedule your own code review at a time that makes sense for you and the project you’re working on. This might be each time you finish a fix or feature, or at regular intervals daily or weekly. If you have someone who can help, book them. There are also chatrooms full of people happy to lend a hand.

在您和您正在从事的项目有意义的时间安排您自己的代码审查。这可能是您每次完成修复或功能时，或者是每天或每周定期进行。如果您有可以帮助的人，请给他们预订。也有很多人乐于助人的聊天室。

Do some research on basic best practices for what you’re working on. Set yourself a time limit though, and take what you read with a grain of salt. There’s a lot of rabbit holes in that field. As a starting point, I’d recommend learning about DRY code, and watching Uncle Bob demand professionalism in software development.

对您正在研究的基本最佳实践进行一些研究。但是给自己设定一个时间限制，并带着一丁点盐来阅读。这个领域有很多兔子洞。首先，我建议您学习DRY代码，并观看Bob叔叔要求软件开发方面的专业知识。

代码审查清单 (Code review checklist)

Here’s my personal code review checklist, based off some general best practices. Feel free to use it as a starting point for your own!

这是基于一些常规最佳实践的个人代码检查清单。随意使用它作为您自己的起点！

Victoria’s Code Review Extravaganza!
维多利亚州的代码审查盛会！

- [ ] This solves a high-priority item.
-[]解决高优先级项目。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date. - [ ] A five-year-old could follow this, seriously it’s that readable.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。 -[] 5岁的孩子可以遵循此规则，这很容易阅读。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date. - [ ] A five-year-old could follow this, seriously it’s that readable. - [ ] Unit tests successfully pass.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。 -[] 5岁的孩子可以遵循此规则，这很容易阅读。 -[]单元测试成功通过。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date. - [ ] A five-year-old could follow this, seriously it’s that readable. - [ ] Unit tests successfully pass. - [ ] Master was merged into the branch and tested.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。 -[] 5岁的孩子可以遵循此规则，这很容易阅读。 -[]单元测试成功通过。 -[]母版合并到分支中并进行了测试。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date. - [ ] A five-year-old could follow this, seriously it’s that readable. - [ ] Unit tests successfully pass. - [ ] Master was merged into the branch and tested. - [ ] Formatting follows style guidelines.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。 -[] 5岁的孩子可以遵循此规则，这很容易阅读。 -[]单元测试成功通过。 -[]母版合并到分支中并进行了测试。 -[]格式遵循样式准则。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date. - [ ] A five-year-old could follow this, seriously it’s that readable. - [ ] Unit tests successfully pass. - [ ] Master was merged into the branch and tested. - [ ] Formatting follows style guidelines. - [ ] I cannot find any further edge cases or known defects.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。 -[] 5岁的孩子可以遵循此规则，这很容易阅读。 -[]单元测试成功通过。 -[]母版合并到分支中并进行了测试。 -[]格式遵循样式准则。 -[]我找不到更多的边缘情况或已知的缺陷。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date. - [ ] A five-year-old could follow this, seriously it’s that readable. - [ ] Unit tests successfully pass. - [ ] Master was merged into the branch and tested. - [ ] Formatting follows style guidelines. - [ ] I cannot find any further edge cases or known defects. - [ ] I would be happy if this code was publicly attributed to me.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。 -[] 5岁的孩子可以遵循此规则，这很容易阅读。 -[]单元测试成功通过。 -[]母版合并到分支中并进行了测试。 -[]格式遵循样式准则。 -[]我找不到其他边缘情况或已知缺陷。 -[]如果将此代码公开地归功于我，我会很高兴。

- [ ] This solves a high-priority item. - [ ] This is a complete implementation that follows the specification. - [ ] Off-topic changes were not included and have been added to backlog. - [ ] Variable names are meaningful and there are no magic numbers. - [ ] Correct and useful error messages are returned at every opportunity. - [ ] No debugging print statements were left in. - [ ] This code is DRY and modular. - [ ] This code is secure. Private and public code are well separated. - [ ] This code is its own documentation, or the documentation is up to date. - [ ] A five-year-old could follow this, seriously it’s that readable. - [ ] Unit tests successfully pass. - [ ] Master was merged into the branch and tested. - [ ] Formatting follows style guidelines. - [ ] I cannot find any further edge cases or known defects. - [ ] I would be happy if this code was publicly attributed to me. - [ ] I fully understand what the code does and the impact of the changes I made.
-[]解决高优先级项目。 -[]这是遵循规范的完整实现。 -[]主题外的更改未包括在内，已添加到积压中。 -[]变量名有意义，没有幻数。 -[]每次机会都会返回正确且有用的错误消息。 -[]没有留下任何调试打印语句 。-[]该代码是DRY且模块化的。 -[]此代码是安全的。 私人代码和公共代码分开很好。 -[]该代码是其自己的文档，或者该文档是最新的。 -[] 5岁的孩子可以遵循此规则，这很容易阅读。 -[]单元测试成功通过。 -[]母版合并到分支中并进行了测试。 -[]格式遵循样式准则。 -[]我找不到其他边缘情况或已知缺陷。 -[]如果将此代码公开地归功于我，我会很高兴。 -[]我完全了解代码的作用以及所做更改的影响。

- [ ] I actually verified that it actually does what I said it does.
- []我实际上验证了它确实按照我说的做。

Here is an excellent example of cleaning up code with some of the above points in mind.

考虑到上述几点，这是清理代码的一个很好的例子。

浪费时间进行流程审查 (Block out time for process review)

Just as we learn from reviewing our code, we refine our processes by reviewing them as well. Process review is most beneficial when visited at regular intervals throughout the project, not just after the project’s completion.

正如我们从检查代码中学到的一样，我们也通过检查代码来完善流程。在整个项目中(而不是在项目完成之后)定期进行过程检查时，过程审核最为有益。

For short-term projects, a good starting point for scheduling process reviews is at each half-mark — once midway through, and again after completion. Long-term projects may have reviews at each quarter-mark.

对于短期项目，安排流程审查的一个好的起点是在每个半关处-一次进行到中途，然后在完成后再一次。长期项目可能在每个季度标记都有审核。

处理复习题 (Process review questions)

Process review can be as simple as a short list of questions:

流程审查可以像一小段问题一样简单：

What were my top-level goals for this period? Did I meet them?
在此期间，我的最高目标是什么？我见过他们吗？
What were my mid-level and low-level goals for this period? Did I meet them?
在此期间，我的中级和低级目标是什么？我见过他们吗？
Would I have been better served with different or more specific goals? Why?
在不同的或更具体的目标上我能得到更好的服务吗？为什么？
Did I successfully remove or automate obstacles?
我是否成功消除或自动化障碍？
Did I stick to my code review schedule? Why or why not?
我遵守代码审查时间表了吗？为什么或者为什么不？
How might I remove obstacles next time?
下次如何清除障碍物？

Setting aside dedicated time for our process review can help us to answer questions like these thoughtfully and honestly. This allows us to squeeze out every bit of learning we can from our review, helping to shorten our feedback loop.

留出时间进行流程审查可以帮助我们周到而诚实地回答诸如此类的问题。这样一来，我们就可以从审查中吸取教训，从而缩短反馈周期。

用评论结果更新您的目标和流程 (Update your goals and processes with the results of your reviews)

All the performance data in the world is no good to us if we don’t put it into practice. With each successive code review, we can refine and add to our checklist. With what we learn from each process review, we can fine tune and improve our processes. The more we can invent concrete and observable ways to implement our learning, the more success we’ll have.

如果我们不付诸实践，世界上所有的性能数据对我们都是不利的。每次进行后续代码审查时，我们都可以优化并添加到清单中。借助从每次流程审核中学到的知识，我们可以调整和改进流程。我们越能发明出具体且可观察的方法来实施我们的学习，我们就会获得更大的成功。

Making a conscious effort to utilize and practice the things we’ve learned is the final, vital, component of our feedback loop. The more often we incorporate new learning, the shorter our loop becomes, allowing us to improve that much faster.

做出有意识的努力来利用和实践我们所学到的东西是反馈循环的最后，至关重要的组成部分。我们学习新知识的次数越多，循环就越短，从而使我们可以更快地改进它。