干净代码:敏捷软件工艺手册

书中描述

即使是糟糕的代码也能发挥作用。但是,如果代码不干净,它可能会让开发组织屈服。每年都有无数的时间和大量的资源因为编写糟糕的代码而丢失。但事情不一定非得这样。

著名的软件专家Robert C. Martin提出了一个革命性的范例干净代码:敏捷软件工艺手册.Martin已经和他Object Mentor的同事们合作,将他们“动态”清理代码的最佳敏捷实践提炼成一本书,这本书将向您灌输软件工匠的价值观,并使您成为更好的程序员——但只有在您努力工作的情况下。

你要做什么工作?您将阅读代码——大量代码。你会被挑战去思考这些代码的正确之处和错误之处。更重要的是,你将面临挑战,重新评估你的职业价值和你对你的手艺的承诺。

干净代码分为三个部分。第一部分描述了编写干净代码的原则、模式和实践。第二部分包括几个日益复杂的案例研究。每个案例研究都是清理代码的练习——将有一些问题的代码库转换为可靠且有效的代码库。第三部分是回报:在创建案例研究时收集的启发式和“气味”的单章。其结果是一个知识库,它描述了我们编写、阅读和干净代码时的思考方式。

读者会从这本书中得到理解

  • 如何区分好代码和坏代码
  • 如何编写好代码,如何将坏代码转化为好代码
  • 如何创建好的名称,好的函数,好的对象,好的类
  • 如何格式化代码以获得最大的可读性
  • 如何在不模糊代码逻辑的情况下实现完整的错误处理
  • 如何进行单元测试并实践测试驱动开发

这本书是任何对产生更好的代码感兴趣的开发人员、软件工程师、项目经理、团队领导或系统分析人员的必读书目。

表的内容

  1. 标题页
  2. 版权页
  3. 内容
  4. 前言
  5. 介绍
  6. 在封面上
  7. 第一章:干净的代码
    1. 将会有代码
    2. 糟糕的代码
    3. 拥有一团混乱的总成本
    4. 天空中的大设计
    5. 的态度
    6. 最初的难题
    7. 干净代码的艺术?
    8. 什么是干净的代码?
    9. 学校的思想
    10. 我们是作者
    11. 童子军规则
    12. 前传和原则
    13. 结论
    14. 参考书目
  8. 第二章:有意义的名称
    1. 介绍
    2. 使用寓意的名字
    3. 避免虚假信息
    4. 进行有意义的区别
    5. 使用可发音的名字
    6. 使用可搜索的名称
    7. 避免编码
    8. 匈牙利命名法
    9. 成员的前缀
    10. 接口和实现
    11. 避免精神映射
    12. 类名
    13. 方法名称
    14. 不很可爱
    15. 每个概念选一个词
    16. 不要双关语
    17. 使用解决方案域名
    18. 使用问题域名
    19. 添加有意义的上下文
    20. 不要添加不必要的上下文
    21. 最后的话
  9. 第三章:函数
    1. 小!
    2. 块和缩进
    3. 做一件事
    4. 内部分功能
    5. 每个函数都有一个抽象级别
    6. 从上到下阅读代码:降序规则
    7. Switch语句
    8. 使用描述性的名称
    9. 函数参数
    10. 常见的单细胞生物的形式
    11. 国旗参数
    12. 二元函数
    13. 三合会
    14. 参数对象
    15. 参数列表
    16. 动词和关键词
    17. 无副作用
    18. 输出参数
    19. 命令查询分离
    20. 首选异常而不是返回错误代码
    21. 提取Try / Catch块
    22. 错误处理是一回事
    23. Error.java依赖磁铁
    24. 不要重复自己
    25. 结构化程序设计
    26. 你怎么写这样的函数?
    27. 结论
    28. SetupTeardownIncluder
    29. 参考书目
  10. 第四章:评论
    1. 注释不能弥补糟糕的代码
    2. 用代码解释自己
    3. 好的评论
    4. 法律评论
    5. 信息评论
    6. 解释的意图
    7. 澄清
    8. 警告的后果
    9. TODO注释
    10. 放大
    11. 公共api中的Javadocs
    12. 不好的评论
    13. 喃喃地说
    14. 多余的评论
    15. 误导性的言论
    16. 规定的评论
    17. 日报》评论
    18. 噪音的评论
    19. 可怕的噪音
    20. 当你可以使用函数或变量时,不要使用注释
    21. 位置标记
    22. 关闭括号注释
    23. 归因和署名
    24. 注释掉的代码
    25. HTML注释
    26. 非局部信息
    27. 太多的信息
    28. Inobvious连接
    29. 函数头文件
    30. 非公共代码中的Javadocs
    31. 例子
    32. 参考书目
  11. 第五章:格式
    1. 格式化的目的
    2. 垂直格式
    3. 报纸的比喻
    4. 概念之间的垂直开放性
    5. 垂直的密度
    6. 垂直距离
    7. 垂直排序
    8. 水平格式
    9. 水平开放度和密度
    10. 水平对齐
    11. 缩进
    12. 假的范围
    13. 团队规则
    14. 鲍勃叔叔的格式规则
  12. 第6章:对象和数据结构
    1. 数据抽象
    2. 数据/对象不对称性
    3. 得墨忒耳定律
    4. 火车残骸
    5. 混合动力车
    6. 隐藏的结构
    7. 数据传输对象
    8. 活动记录
    9. 结论
    10. 参考书目
  13. 第七章:错误处理
    1. 使用异常而不是返回代码
    2. 先写你的Try-Catch-Finally语句
    3. 使用未经检查的异常
    4. 提供异常上下文
    5. 根据调用者的需求定义异常类
    6. 定义正常流程
    7. 不返回Null
    8. 不通过零
    9. 结论
    10. 参考书目
  14. 第八章:边界
    1. 使用第三方代码
    2. 探索和学习边界
    3. 学习log4j
    4. 学习测试比免费的好
    5. 使用还不存在的代码
    6. 干净的边界
    7. 参考书目
  15. 第九章:单元测试
    1. TDD的三大定律
    2. 保持测试清洁
    3. 测试启用-功能
    4. 干净的测试
    5. 特定于域的语言测试
    6. 双重标准
    7. 每个测试一个断言
    8. 每个测试单一概念
    9. F.I.R.S.T.
    10. 结论
    11. 参考书目
  16. 第十章:类
    1. 类组织
    2. 封装
    3. 班级应该小!
    4. 单一责任原则
    5. 凝聚力
    6. 在许多小班教学中保持凝聚力
    7. 组织变革
    8. 孤立的变化
    9. 参考书目
  17. 第十一章:系统
    1. 如何建造一座城市?
    2. 将构建系统与使用系统分开
    3. 主要的分离
    4. 工厂
    5. 依赖注入
    6. 扩大
    7. 横切关注点
    8. Java代理
    9. 纯Java AOP框架
    10. AspectJ方面
    11. 测试驱动系统架构
    12. 优化决策
    13. 当标准增加可论证的价值时,明智地使用标准
    14. 系统需要领域特定的语言
    15. 结论
    16. 参考书目
  18. 第十二章:出现
    1. 通过紧急设计获得清洁
    2. 简单设计规则1:运行所有测试
    3. 简单设计规则2-4:重构
    4. 没有重复
    5. 富有表现力的
    6. 最小的类和方法
    7. 结论
    8. 参考书目
  19. 第十三章:并发性
    1. 为什么并发?
    2. 神话和误解
    3. 挑战
    4. 并发性防御原则
    5. 单一职责原则
    6. 推论:限制数据的范围
    7. 推论:使用数据的副本
    8. 推论:线程应该尽可能独立
    9. 知道你的图书馆
    10. 线程安全的集合
    11. 了解你的执行模式
    12. 生产国和消费国
    13. Readers-Writers
    14. 哲学家就餐
    15. 注意同步方法之间的依赖关系
    16. 保持同步段较小
    17. 编写正确的关机代码是困难的
    18. 测试线程的代码
    19. 将伪失败视为候选线程问题
    20. 首先让你的非线程代码工作
    21. 让你的线程代码是可插入的
    22. 让你的线程代码可调
    23. 运行多于处理器的线程
    24. 在不同平台上运行
    25. 测试你的代码来尝试和强制失败
    26. 手工编码的
    27. 自动化
    28. 结论
    29. 参考书目
  20. 第十四章:连续改良
    1. 参数的实现
    2. 我是怎么做到的?
    3. Args:初稿
    4. 所以我不再
    5. 在渐进主义
    6. 字符串参数
    7. 结论
  21. 第十五章:JUnit的内部特性
    1. JUnit框架
    2. 结论
  22. 第十六章:重构SerialDate
    1. 首先,让它工作
    2. 然后做对
    3. 结论
    4. 参考书目
  23. 第十七章:气味和启发
    1. 评论
    2. C1:不恰当的信息
    3. C2:过时的评论
    4. C3:多余的评论
    5. 不良的书面评论
    6. C5:注释掉的代码
    7. 环境
    8. E1:构建需要不止一个步骤
    9. E2:测试需要不止一个步骤
    10. 功能
    11. F1:太多的参数
    12. F2:输出参数
    13. F3:国旗参数
    14. F4:死去的函数
    15. 一般
    16. G1:多语言在一个源文件
    17. G2:未实现明显的行为
    18. G3:边界上的不正确行为
    19. G4:覆盖安全
    20. G5:重复
    21. 错误的抽象级别的代码
    22. G7:依赖于其衍生品的基类
    23. 八国集团:太多的信息
    24. G9:死代码
    25. 十国集团:垂直分离
    26. 为G11:不一致
    27. G12:杂乱
    28. G13:人工耦合
    29. 八国:功能嫉妒
    30. G15:选择器参数
    31. 十六国集团:模糊的意图
    32. 类型:错误的责任
    33. G18:不恰当的静态
    34. G19:使用解释变量
    35. G20:函数名应该说明它们的功能
    36. 理解算法
    37. 使逻辑依赖成为物理的
    38. G23:选择多态性而不是If/Else或Switch/Case
    39. G24:遵循标准约定
    40. G25:将魔法数字替换为命名常量
    41. G26:精确
    42. G27:结构胜于公约
    43. G28:封装条件
    44. 避免否定条件句
    45. 函数应该做一件事
    46. G31:隐藏的时间耦合
    47. 不要武断
    48. 封装边界条件
    49. 函数应该只下降一个抽象级别
    50. G35:可配置数据保持在高级别
    51. 避免过渡导航
    52. Java
    53. J1:使用通配符避免长导入列表
    54. 不要继承常量
    55. 常量与枚举
    56. 的名字
    57. N1:选择描述性名称
    58. N2:在适当的抽象级别上选择名称
    59. N3:尽可能使用标准命名法
    60. 陶瓷:明确的名称
    61. N5:对长作用域使用长名称
    62. N6:避免编码
    63. N7:名称应描述副作用。
    64. 测试
    65. T1:测试不足
    66. T2:使用覆盖工具!
    67. T3:不要跳过琐碎的测试
    68. T4:一个被忽略的测试是一个关于歧义的问题
    69. T5:测试边界条件
    70. T6:在bug附近进行全面测试
    71. T7:失败的模式很有启发性
    72. T8:测试覆盖模式可以揭示
    73. T9:测试应该很快
    74. 结论
    75. 参考书目
  24. 附录A:并发2
    1. 客户机/服务器的例子
    2. 服务器
    3. 添加线程
    4. 服务器的观察
    5. 结论
    6. 可能的执行路径
    7. 数量的路径
    8. 更深入的研究
    9. 结论
    10. 知道你的图书馆
    11. 执行程序框架
    12. 非阻塞的解决方案
    13. Nonthread-Safe类
    14. 方法之间的依赖关系会破坏并发代码
    15. 容忍失败
    16. 基于客户机的锁定
    17. 基于服务器的锁定
    18. 增加吞吐量
    19. 单线程吞吐量计算
    20. 吞吐量的多线程计算
    21. 死锁
    22. 互斥
    23. 锁和等待
    24. 没有抢占
    25. 循环等待
    26. 打破互斥
    27. 打破锁和等待
    28. 打破抢占
    29. 打破循环等待
    30. 测试多线程代码
    31. 测试基于线程的代码的工具支持
    32. 结论
    33. 教程:完整的代码示例
    34. 客户机/服务器非线程
    35. 客户机/服务器使用线程
  25. 附录B: org.jfree.date.SerialDate
  26. 附录C:启发法的交叉参考
  27. 后记
  28. 指数
  29. 代码片段

产品信息

  • 标题:干净代码:敏捷软件工艺手册
  • 作者(年代):罗伯特·c·马丁
  • 上映日期(待定):2008年8月
  • 出版商(s):皮尔森
  • 国际标准图书编号:9780136083238