书名：代码整洁之道（第2版·英文版）
定价：169.8
ISBN：9787115538215
作者：[美] 罗伯特·C. 马丁（Robert C. Martin）
版次：第1版
出版时间：2026-06

内容提要：
本书系统阐述了编写高质量软件的核心原则与实践。 全书分为“代码”“设计”“架构”“匠艺”4个部分，从基础命名、函数、测试准则，到设计的 SOLID原则、组件原则、并发编程、架构边界，直*程序员的职业素养，构建了完整的软件质量知识体系。本书融合了作者近年来的新思考，新增了对 AI 辅助编程的探讨，强调在新时代下*原则的持续价值。本书包含大量代码示例与重构案例，旨在帮助读者掌握构建易理解、易维护、易扩展代码的具体方法，适合所有致力于提升代码质量的软件开发人员、架构师、技术负责人以及计算机相关专业学生阅读参考。



作者简介：
罗伯特·C. 马丁（Robert C. Martin），*软件开发大师，设计模式和敏捷开发先驱，被后辈程序员尊称为“鲍勃大叔”。他自1970年起从事软件开发工作，是Uncle Bob Consulting公司的*，并与儿子迈卡·马丁（Micah Martin）共同创立了Clean Coders公司。他在各类期刊和博客上发表了数百篇文章，并常受邀在国际会议上发表主题演讲，著有《敏捷软件开发》（Agile Software Development）、《代码整洁之道》（Clean Code）、《代码整洁之道：程序员的职业素养》（The Clean Coder）、《整洁架构之道》（Clean Architecture）、《敏捷整洁之道》（Clean Agile）、《匠艺整洁之道》（Clean Craftsmanship）、《函数式设计》（Functional Design）和《我们程序员》（We, Programmers）等多部**。他曾担任C++ Report主编3年，并且是敏捷联盟的*任主席。

目录：
目录

Chapter 1: Clean Code / 整洁的代码 1
1.1　There Will Be Code / 要有代码 2
1.2　Bad Code / 烂代码 3
1.2.1　Attitude / 态度 4
1.2.2　The Primal Conundrum / 难题 5
1.3　The Art of Clean Code / 整洁代码的艺术 5
What Is Clean Code / 什么是整洁的代码 6
1.4　Putting All This Together / 综述 9
1.4.1　 Why Should We Be Clean / 代码为什么要整洁 9
1.4.2　 Productivity / 生产力 10
1.4.3　 Livability / 宜居性 13
1.5　We Read More Than We Write / 读比写多 13
1.6　The Boy Scout Rule / 童子军军规 14

PART I Code / 第 一部分 代码

Chapter 2: Clean That Code! / 清理那些代码！ 19
2.1　The Cleaning Process / 清理过程 30
2.2　Conclusion / 小结 37
2.3　Postscript: Future Bob Playing with Grok3 /
附记：未来的鲍勃体验Grok3 37
2.4　Postscript Conclusion / 附记小结 40
Chapter 3: First Principles / *要原则 41
3.1　Everything Small, Well Named, Organized, and Ordered / 一切*要小巧、命名得当、组织有序且排序合理 42
Functions / 函数 42
3.2　A More Significant Example / 更明显的例子 44
Independent Deployability / 独立部署 68
3.3　A Final Thought / *的思考 68
Chapter 4: Meaningful Names / 有意义的名称 71
4.1　Use Intention-Revealing Names / 使用表意明确的名称 72
4.1.1　Build a System of Names / 构建命名体系 73
4.1.2　Avoid Disinformation / 避免误导 74
4.1.3　Make Meaningful Distinctions / 做有意义的区分 75
4.1.4　Use Pronounceable Names / 使用读得出来的名称 76
4.1.5　Use Searchable Names / 使用可搜索的名称 77
4.1.6　Use Names of Appropriate Length / 使用长度适宜的名称 78
4.1.7　Avoid Encodings / 避免使用编码 80
4.1.8　Use Appropriate Parts of Speech / 使用恰当的词性 81
4.1.9　Consider Keyword Parameters / 考虑关键词参数 82
4.1.10　Don’t Be Cute / 别玩儿梗 83
4.1.11　Pick One Word per Concept / 每个概念对应一个词 83
4.1.12　Use Solution Domain Names / 使用源自解决方案领域的名称 83
4.1.13　Use Problem Domain Names / 使用源自所涉问题领域的名称 84
4.1.14　Add Meaningful Context / 添加有意义的上下文 84
4.1.15　Don’t Add Gratuitous Context / 不要添加没用的上下文 86
4.2　Final Words / 小结 87
Chapter 5: Comments / 注释 89
5.1　Compensating for Failure / 弥补失败 90
5.1.1　Hidden or Obscured Comments / 隐藏或被遮掩的注释 90
5.1.2　Lying Comments / 撒谎的注释 91
5.1.3　Comments That Are Too Intimate / 过于细节化的注释 92
5.1.4　Comments Do Not Make Up for Bad Code /
注释不能美化烂代码 92
5.1.5　Explain Your Intent in Code / 用代码阐释意图 92
5.2　Good Comments / 好注释 92
5.2.1　Legal Comments / 法律信息 93
5.2.2　Informative Comments / 信息量充足的注释 93
5.2.3　Explanation of Intent / 解释意图 94
5.2.4　Clarification / 阐释 95
5.2.5　Warning of Consequences / 警示后果 96
5.2.6　Amplification / 强调 96
5.2.7　Javadocs (and Their Ilk) in Public APIs /
公共API中的Javadoc及同类文档 97
5.3　Bad Comments / 烂注释 97
5.3.1　Mumbling / 喃喃自语 97
5.3.2　Redundant Comments / 多余的注释 98
5.3.3　Misleading Comments / 误导性注释 99
5.3.4　Redundancy and Imprecision / 冗余和不* 99
5.3.5　Mandated Comments / 循规式注释 102
5.3.6　Journal Comments / 日志式注释 102
5.3.7　Noise Comments / 噪声注释 103
5.3.8　Scary Noise / 可怕的噪声 105
5.3.9　TODO Comments / TODO注释 106
5.3.10　Use a Function or a Variable Instead of a Comment / 能用函数或变量*不用注释 106
5.3.11　Position Markers / 位置标记 107
5.3.12　Attributions and Bylines / 归属与署名 107
5.3.13　Commented-Out Code / 被注释掉的代码 107
5.3.14　HTML Comments / HTML注释 108
5.3.15　Nonlocal Information / 非本地信息 109
5.3.16　Too Much Information / 信息过多 109
5.3.17　Unobvious Connection / 不明显的关联 110
5.3.18　Function Headers / 函数头部注释 110
5.3.19　Javadocs in Nonpublic Code / 非公共代码中的Javadoc 111
5.3.20　Example / 示例 111
5.4　Conclusion / 小结 115
Chapter 6: Formatting / 规范代码格式 117
6.1　The Purpose of Formatting / 规范代码格式的目的 118
6.2　Vertical Formatting / 纵向格式 118
6.2.1　Vertical Openness between Concepts / 概念间的纵向留白 120
6.2.2　Vertical Density / 纵向紧密度 121
6.2.3　Vertical Distance / 纵向距离 122
6.2.4　Variable Declarations / 变量声明 122
6.2.5　Dependent Functions / 相关函数 125
6.2.6　Conceptual Affinity / 概念关联性 126
6.3　Horizontal Formatting / 横向格式 127
6.3.1　Horizontal Openness and Density / 横向留白与紧密度 128
6.3.2　Horizontal Alignment / 横向对齐 129
6.3.3　Indentation / 缩进 130
6.3.4　Breaking Indentation / 违反缩进规则 132
6.4　Team Rules / 团队规则 132
6.5　Uncle Bob’s Formatting Rules / 鲍勃大叔的代码格式规则 133
Chapter 7: Clean Functions / 整洁的函数 137
7.1　Small! / 短小 138
7.1.1　Well-Written Prose / 好散文 139
7.1.2　One Level of Abstraction per Function / 每个函数一个抽象层级 139
7.2　Reading Code from Top to Bottom: The Stepdown Rule / 自顶向下读代码：下梯规则 140
Entanglement / 纠缠 142
7.3　switch Statements / switch语句 142
7.4　Clean Functions: A Deeper Look / 深入探讨整洁的函数 144
7.4.1　Contextual / 上下文相关 144
7.4.2　Nameable / 可命名 145
7.4.3　Insulated / 被隔离 148
7.4.4　Homogenous / 同质 151
7.4.5　Pure / 纯一 153
7.4.6　Partial Purity / 部分纯一性 155
7.5　Conclusion / 小结 157
Chapter 8: Function Heuristics / 关于函数的经验之谈 159
8.1　Function Arguments / 函数参数 159
8.1.1　Variadic Arguments / 可变参数 161
8.1.2　More Than Three / 参数多于3个？ 161
8.1.3　Keyword Arguments / 关键字参数 161
8.1.4　Flag Arguments / 标识参数 161
8.1.5　Output Arguments / 输出参数 162
8.1.6　Error Codes / 错误码 163
8.2　Command Query Separation / 命令-查询分离 164
8.3　Prefer Exceptions to Returning Error Codes / 使用异常替代返回错误码 165
8.3.1　Caveat Emptor / 责任自负 165
8.3.2　Extract try/catch Blocks / 抽离try/cache代码块 167
8.3.3　Error Handling Is One Thing / 错误处理*是一件事 168
8.3.4　The Dependency Magnet of Error Codes / 错误码的依赖磁铁 168
8.4　DRY: Don’t Repeat Yourself / DRY：别重复自己 169
8.4.1　Simple Repeated Code / 简单重复的代码 169
8.4.2　Similar Code / 相似代码块 170
8.4.3　Loop Duplication / 循环重复 174
8.4.4　Accidental versus Essential Duplication / 偶合重复与本质重复 177
8.5　Side Effects / DRY：副作用 177
8.5.1　We Are Bad at This / 力有未逮 178
8.5.2　Functional Languages / 函数式编程语言 178
8.5.3　Object-Oriented Languages / 面向对象编程语言 180
8.6　Structured Programming / 结构化编程 181
8.6.1　Sequence / 顺序结构 182
8.6.2　Selection / 选择结构 182
8.6.3　Iteration / 循环结构 182
8.7　This Is Too Much to Constantly Keep in Mind / 太多应牢记的事 183
8.8　Conclusion / 小结 184
Chapter 9: The Clean Method / 整洁的方法 185
9.1　Make It Right / 把它改好 186
9.2　Example / 示例 188
Considering the Design and Architecture / 考虑设计与架构 204
9.3　Conclusion / 小结 210
Chapter 10: One Thing / 只做一件事 211
10.1　Extract Method Refactoring / 提取方法重构 212
This Shouldn’t Be Controversial / 不应置疑 214
10.2　What Are Large Functions Anyway / 到底什么是巨大函数 217
Extraction and Classes / 提取与类 235
10.3　Conclusion / 小结 239
Chapter 11: Be Polite / 保持得体 241
11.1　The Newspaper Metaphor / 报纸隐喻 243
Be Polite / 保持得体 244
11.2　The Stepdown Rule: Once Again / 再谈下梯规则 245
11.3　The Abstraction Roller Coaster / 抽象过山车 246
11.4　This Is How We Write, but Not How We Want to Read / 这么写，但不想这么读 246
Chapter 12: Objects and Data Structures / 对象与数据结构 249
12.1　What Is an Object / 何为对象 250
12.2　Data Abstraction / 数据抽象 251
12.3　Data/Object Antisymmetry / 数据/对象的反对称性 252
12.4　The Law of Demeter / 得墨忒耳律 255
12.4.1　Trainwrecks / 火车失事 256
12.4.2　Hybrids / 混合结构 256
12.4.3　Hiding Structure / 隐藏结构 257
12.5　Data Transfer Objects / 数据传输对象 258
12.5.1　The Object/Relational “Impedance Mismatch” / 对象/关系“阻抗不匹配” 259
12.5.2　Using Objects and Data Structures / 使用对象和数据结构 259
12.6　switch Statements / switch语句 260
12.6.1　The OO Solution / 面向对象解决方案 263
12.6.2　Not So Fast, Johnson / 别高兴得太早 264
12.7　The OO/Procedural Trade-off / 选择面向对象还是选择过程式 264
12.8　But What About Performance / 性能怎么办 265
12.9　Conclusion / 小结 265
Chapter 13: Clean Classes / 整洁的类 267
13.1　Classes and Modules versus Files / 类和模块与文件对比 267
13.2　What Should a Class Contain / 类应该包含什么 268
13.2.1　Characterizing Class Design / 类设计的特征 269
13.2.2　Heuristics and Characteristics / 经验与特征 270
13.2.3　When Is a Class Too Large / 类什么时候算过大 271
13.2.4　Policies in Code / 代码中的策略 273
13.2.5　Where Reasons to Change Hide / 变更理由隐藏之处 274
13.2.6　Fixing the Problem / 修正问题 275
13.2.7　An Overly Open Implementation / 一种过度开放的实现 277
13.2.8　Should We Do Anything Now / 该做点什么吗 278
13.2.9　What About Now / 现在怎么办 278
13.2.10　Closed, Cohesive, Single-Responsibility Classes / 闭合、高内聚、单一职责的类 282
13.2.11　When Policies Change / 策略改变时 284
13.2.12　Is This Overengineering / 这算过度工程化吗 284
13.2.13　Simpler Testing / 更简单的测试 285
13.2.14　Enter AI / 接入AI 286
13.2.15　It Will Be Wrong / 它会犯错 287
Chapter 14: Testing Disciplines / 测试准则 289
14.1　Discipline 1: Test-Driven Development (TDD) / 准则1：测试驱动的开发（TDD） 291
The Three Laws of TDD / TDD三法则 291
14.2　Discipline 2: Test && Commit || Revert (TCR) / 准则2：测试 && 提交 || 回退（TCR） 292
14.3　Discipline 3: Small Bundles / 准则3：小规模增量开发 293
14.4　Design / 设计 293
14.5　Discipline / 准则 294
14.5.1　Tedious, Boring, and Slow / 枯燥、烦琐且低效 294
14.5.2　Debugging / 调试 294
14.5.3　Documentation / 文档 295
14.5.4　Reliability / 可靠性 295
14.5.5　Design / 设计 296
14.5.6　Reprise / 总结回顾 296
14.5.7　The Angel and the Devil / 天使与恶魔 297
14.5.8　Muzzling the Devil / 驯服心魔 297
14.5.9　Complications and Loopholes / 复杂情况与漏洞 298
14.5.10　Costs and Repercussions / 代价与影响 299
14.6　Keeping Tests Clean / 保持测试整洁 299
14.7　Tests Enable the -ilities / 测试赋能 300
Chapter 15: Clean Tests / 整洁的测试 303
15.1　Domain-Specific Testing Language / 用于测试的领域特定语言 307
15.1.1　Composed Assertions / 组合断言 307
15.1.2　Composed Test Results / 组合测试结果 307
15.1.3　Dual Standard / 双重标准 309
15.1.4　The Single Assert Rule / 单一断言规则 309
15.1.5　The Single Act Rule / 单一执行规则 310
15.2　F.I.R.S.T. / F.I.R.S.T 310
15.2.1　Fast / 快速 310
15.2.2　Isolated / 独立 310
15.2.3　Repeatable / 可重复 310
15.2.4　Self-Validating / 自验证 311
15.2.5　Timely / 及时 311
15.3　Test Design / 测试设计 311
15.4　Conclusion / 小结 311
Chapter 16: Acceptance Testing / 验收测试 313
16.1　The Acceptance Testing Discipline / 验收测试准则 314
16.1.1　The Discipline / 准则 315
16.1.2　The Continuous Build / 持续构建 316
16.2　Conclusion / 小结 316
Chapter 17: AIs, LLMs, and God Knows What / AI、LLM和天知道还有啥东西 317
17.1　Programming by Prompt / 用提示词编程 319
17.1.1　Infancy / 起步阶段 324
17.1.2　A SWAG / 斗胆盲猜 324
17.2　Conclusion / 小结 328

PART II Design / *部分 设计

Chapter 18: Simple Design / 简单设计 331
18.1　YAGNI / YAGNI 333
18.2　Covered by Tests / 测试覆盖 333
18.2.1　An Asymptotic Goal / 渐进目标 333
18.2.2　Design / 设计？ 334
18.3　Maximize Expression / 揭示意图 334
18.3.1　The Underlying Abstraction / 底层抽象 336
18.3.2　Tests: The Other Half of the Problem / 测试：问题的后半部分 337
18.4　Minimize Duplication / *小化重复 337
Accidental Duplication / 偶合重复 338
18.5　Minimize Size / *小化规模 339
Simple Design / 简单设计 339
Chapter 19: The SOLID Principles/ SOLID原则 341
19.1　SRP: The Single Responsibility Principle / SRP：单一职责原则 343
19.1.1　Accidental Duplication / 偶合重复 344
19.1.2　Solutions / 解决方案 345
19.1.3　Higher Levels / 更高层级 346
19.2　OCP: The Open-Closed Principle / OCP：开放-闭合原则 347
19.2.1　A Thought Experiment / 思想实验 347
19.2.2　Directional Control / 方向控制 350
19.2.3　Information Hiding / 信息隐藏 350
19.2.4　Conclusion / 小结 351
19.3　LSP: The Liskov Substitution Principle / LSP：里氏替换原则 351
19.3.1　LSP and Design / LSP与设计 352
19.3.2　Taxi Aggregator / 出租车调度聚合平台 353
19.4　ISP: The Interface Segregation Principle / ISP：接口分离原则 354
19.4.1　ISP and Language / ISP与编程语言 355
19.4.2　ISP and Design / ISP与设计 355
19.5　DIP: The Dependency Inversion Principle / DIP：依赖倒置原则 356
19.5.1　Stable Abstractions / 稳定抽象 358
19.5.2　Factories / 工厂模式 359
19.5.3　Concrete Components / 具体组件 360
Chapter 20: Component Principles / 组件原则 363
20.1　Components / 组件 364
20.2　A Brief History of Components / 组件简史 364
20.2.1　Relocatability / 可重定位 367
20.2.2　Linkers / 连接器 367
20.3　Component Cohesion / 组件内聚性 368
20.3.1　The Reuse/Release Equivalence Principle (REP) / REP：复用/发布等价原则 369
20.3.2　The Common Closure Principle (CCP) / CCP：共同封闭原则 370
20.3.3　The Common Reuse Principle (CRP) / CRP：共同复用原则 371
20.3.4　The Tension Diagram for Component Cohesion / 组件内聚性张力图 372
20.3.5　In Summary… / 小结 373
20.4　Component Coupling / 组件耦合 373
20.4.1　The Acyclic Dependencies Principle (ADP) / ADP：无循环依赖原则 374
20.4.2　The Stable Dependencies Principle (SDP) / SDP：稳定依赖原则 379
20.4.3　The Stable Abstractions Principle (SAP) / SAP：稳定抽象原则 383
20.5　Conclusion / 小结 387
Chapter 21: Continuous Design / 持续设计 389
21.1　Continuous Change / 持续变更 390
21.2　Continuous Design / 持续设计 391
21.3　Sailing on the Four Cs of Continuous Design / 　　 航行于持续设计的4C考量之上 392
21.3.1　Clarity / 清晰性 393
21.3.2　Conciseness / 简洁性 398
21.3.3　Confirmability / 可验证性 406
21.3.4　Cohesion / 内聚性 416
21.4　When Else Do We Design / 还需要在何时进行设计 420
21.4.1　Up-front Design / 设计前置 420
21.4.2　Readying for Work / 为工作做准备 421
21.4.3　Starting Work / 开始工作 421
21.4.4　Doing Work / 做工作 422
Chapter 22: Concurrency / 并发编程 423
22.1　Why Concurrency / 为什么要并发 424
22.1.1　Myths and Misconceptions / 传言与误解 425
22.1.2　Challenges / 挑战 426
22.2　Concurrency Defense Principles / 并发防御原则 427
22.2.1　Single Responsibility Principle / 单一职责原则 427
22.2.2　Corollary: Limit the Scope of Data / 推论：限制数据的作用域 427
22.2.3　Corollary: Use Copies of Data / 推论：使用数据副本 428
22.2.4　Corollary: Threads Should Be as Independent as Possible / 推论：线程应尽可能独立 428
22.3　Know Your Language and Library / 了解你使用的语言和库 428
Thread-Safe Collections / 线程*工具集 429
22.4　Know Your Execution Models / 了解执行模型 429
22.4.1　Producer-Consumer / 生产者-消费者模型 430
22.4.2　Readers-Writers / 读者-写者模型 430
22.4.3　Dining Philosophers / 哲学家进餐问题 431
22.5　Beware Dependencies between Synchronized Methods / 　　 警惕同步方法之间的依赖 431
22.6　Keep Synchronized Sections Small / 保持同步区短小 431
22.7　Writing Correct Startup and Shutdown Code Is Hard / 　　 正确的启动代码和关闭代码难以编写 432
22.8　Testing Threaded Code / 测试线程代码 432
22.8.1　Treat Spurious Failures as Candidate Threading Issues / 将偶发失败看作潜在的线程问题 433
22.8.2　Get Your Nonthreaded Code Working First / 先让非线程代码工作 433
22.8.3　Make Your Threaded Code Pluggable / 编写可插拔的线程代码 434
22.8.4　Make Your Threaded Code Tunable / 编写可调优的线程代码 434
22.8.5　Run with More Threads Than Processors / 运行比处理器数量多的线程 434
22.8.6　Run on Different Platforms / 在不同平台上运行 434
22.8.7　Instrument Your Code to Try and Force Failures / 安插试错代码，尝试并强制代码失败 435
22.9　2025 Update and Report from the Field / 2025年实战更新及报告 437
Data Integrity / 数据完整性 437
22.10　Conclusion / 小结 442

PART III Architecture / 第三部分 架构

Chapter 23: The Two Values of Software / 软件的两大价值 445
Keeping Options Open / 保留可能性 446
Chapter 24: Independence / 独立性 449
24.1　Use Cases / 用例 450
24.2　Operation / 运行 450
24.3　Development / 开发 451
24.4　Deployment / 部署 451
24.5　Leaving Options Open / 保留可能性 451
Chapter 25: Architectural Boundaries / 架构的边界 453
25.1　What Lines Do You Draw, and When / 　　 何时划定边界，划定怎样的边界 454
25.2　Plug-in Architecture / 插件架构 456
25.3　Case Study: FitNesse / 案例研究：FitNesse 457
25.4　Conclusion / 小结 459
Chapter 26: Clean Boundaries / 整洁的边界 461
26.1　Third-Party IoT Framework: Lots o’ Boundaries / 　　 第三方物联网框架：诸多边界 462
26.2　UI/Application Boundary / 用户界面/应用边界 466
26.2.1　SOLID and Hexagonal Architecture / SOLID原则与六边形架构 469
26.2.2　Exploring and Learning Boundaries / 探索和学习边界 470
26.2.3　Using Code That Does Not Yet Exist / 使用尚不存在的代码 473
26.3　Clean Boundaries / 整洁的边界 474
Chapter 27: The Clean Architecture / 整洁的架构 475
27.1　The Dependency Rule / 依赖规则 476
27.1.1　Entities / 实体层 477
27.1.2　Use Cases / 用例层 477
27.1.3　Interface Adapters / 接口适配层 478
27.1.4　Frameworks and Drivers / 框架与驱动层 478
27.1.5　Only Four Circles / 只有4个圈层吗 478
27.1.6　Crossing Boundaries / 跨越边界 479
27.1.7　What Data Crosses the Boundaries / 什么数据会跨越边界 479
27.1.8　A Typical Scenario / 典型场景 479
27.2　Conclusion / 小结 481

PART IV Craftmanship / 第四部分 匠艺

“A Great Number” / “大量” 484
Eight Decades / 80多年 484
Nerds and Saviors / 书呆子与救世主 487
Notoriety / 名声 488
Role Models and Villains / 榜样与恶棍 489
We Rule the World / 我们“主宰”世界 490
Catastrophes / 灾难 491
The Oath / 程序员誓言 492
Chapter 28: Harm / 有害 495
28.1　No Harm to Society / 对社会无害 496
28.2　No Harm to Function / 对功能无害 497
28.3　No Harm to Structure / 对结构无害 499
28.4　Soft / 柔性 500
28.5　Tests / 测试 501
Chapter 29: No Defect in Behavior or Structure / 不损害软件行为或结构 503
29.1　Making It Right / 把它改好 504
29.1.1　What Is Good Structure / 什么是好结构 504
29.1.2　Eisenhower’s Matrix / 艾森豪威尔决策矩阵 506
29.2　Programmers Are Stakeholders / 程序员是利益相关者 507
29.3　Do Your Best / 尽己所能 508
Chapter 30: Repeatable Proof / 可重复证据 511
30.1　Dijkstra / 迪杰斯特拉 511
Proving Correctness / 证明正确性 512
30.2　Structured Programming / 结构化编程 514
30.3　Functional Decomposition / 功能分解 516
30.4　Test-Driven Development et al. / TDD及同类准则 517
Chapter 31: Small Cycles / 小周期 519
31.1　The History of Source Code Control / 源码控制史 519
31.1.1　Punch Cards / 打孔卡 519
31.1.2　Continuous Integration / 持续集成 523
31.1.3　Short Cycles / 短周期 524
31.2　Continuous Integration / 持续集成 524
31.3　Branches versus Toggles / 分支与功能开关 525
31.4　Continuous Deployment / 持续部署 527
31.5　Continuous Build / 持续构建 528
Chapter 32: Relentless Improvement / 持续打磨 529
32.1　Test Coverage / 测试覆盖率 529
32.2　Mutation Testing / 变异测试 530
32.3　Semantic Stability / 语义稳定性 530
32.4　Cleaning / 清洁 531
32.5　Creations / 创作成果 531
Chapter 33: Maintain High Productivity / 保持高生产力水平 533
33.1　Viscosity / 黏性 533
33.1.1　Building / 构建 534
33.1.2　Testing / 测试 534
33.1.3　Debugging / 调试 535
33.1.4　Deploying / 部署 535
33.2　Managing Distractions / 干扰管理 535
33.2.1　Meetings / 会议 536
33.2.2　Music / 音乐 536
33.2.3　Mood / 心情 537
33.2.4　The Flow / 心流 537
33.3　Time Management / 时间管理 538
Chapter 34: Work as a Team / 团队协作 539
34.1　Collaborative Programming / 协同编程 539
34.2　Open/Virtual Office / 开放式办公室/虚拟办公室 540
Chapter 35: Estimate Honestly and Fairly / 靠谱和合理地估算 543
35.1　Lies / 谎言 544
35.2　Honesty, Accuracy, Precision / 靠谱、*、* 544
35.3　Lessons from Me / 我的教训 545
35.3.1　Story #1: Vectors / 故事1：向量 545
35.3.2　Story #2: pCCU / 故事2：pCCU 546
35.3.3　The Lesson / 教训 547
35.4　Accuracy and Precision / *性与*性 547
35.5　Aggregation / 汇总 548
35.6　Honesty / 靠谱 549
35.7　Pressure / 压力 550
Chapter 36: Respect for Fellow Programmers / 尊重程序员同行 553
Chapter 37: Never Stop Learning / 永不停止学习 555
Afterword / 后记 557
Appendix: The Clean Code Debate / 附录A 激辩《代码整洁之道》 561
A.1　Introductions / 开篇 562
A.2　Method Length / 方法长度 563
A.3　Method Length Summary / 关于方法长度讨论的总结 575
A.4　Comments / 注释 576
A.5　Comments Summary / 关于注释讨论的总结 590
A.6　John’s Rewrite of PrimeGenerator / 　　 约翰对PrimeGenerator类的改写 591
A.7　A Tale of Two Programmers / 双“程”记 596
A.8　Bob’s Rewrite of PrimeGenerator2 / 　　 鲍勃对PrimeGenerator2类的改写 599
A.9　Test-Driven Development / TDD 603
A.10　TDD Summary / 关于TDD讨论的总结 612
A.11　Closing Remarks / 结束语 613
Bibliography / 参考文献 615