Intro xxiii 
1 the interactive web: Reacting to the Virtual World 1
2 storing data: Everything Has Its Place 33
3 exploring the client: Browser Spelunking 85
4 decision making: If There’s a Fork in the Road, Take It .. 135
5 looping: At the Risk of Repeating Myself 189
6 functions: Reduce, Reuse, Recycle 243
7 forms and validation: Getting the User to Tell All 289
8 wrangling the page: Slicing and Dicing HTML with the DOM 343
9 bringing data to life: Objects as Frankendata 393
10 creating custom objects: Having It Your Way with Custom Objects 449
11 kill bugs dead: Good Scripts Gone Wrong 485
12 dynamic data: Touchy-Feely Web Applications 537

引子——这本书适合谁
组织结构篇
双龙会——CTO与技术总监
人，是人，真的是人——团队文化
四套马车——团队配合
大长今——项目经理
走钢索的人——架构师 

 过程管理篇 一个人在战斗——老系统维护 兄弟连——项目开发 我要飞得更高——新产品战略 波、波、波——产品生命周期 定风波——产品定位 焦油坑——项目需求调研 文档知多少——设计文档编写方法 沙场秋点兵——开发团队练兵 百变金刚——企业业务开发平台架构 代码那些事儿——代码编写规范 风语者——软件测试 蛋白质女孩——产品文案 恶魔吹着笛子来——售前经理 修女也疯狂——售前、项目管理、实施适用的演示方法 水至清则无鱼——软件费用报价方法 量贩式实施一实施费用报价方法 将服务费用进行到底——服务费用报价方法 黑衣人——打造实施顾问 实施经理的工具箱——实施过程管理 灯塔客户——试点实施 客服顾问的工具箱——客服支持

 激励考核篇 那根胡萝卜——团队激励 一天到晚游泳的鱼——员工绩效考核

 职业发展篇 七里香——新人入职手册 敢问路在何方——员工职业发展出路 财主家也没有余粮了——创业小作坊职业发展出路 终结者——CTO职业发展出路

 未来趋势篇 兵临城下——未来企业管理软件领域的新挑战 像咨询师一样思考——发展IT咨询业务 无间道——未来不会再有研发和销售 轻骑兵——未来软件开发模式 沙尘暴——令人焦虑的技术时代 色即是空——虚公司

 心路成长篇 我就是一个香港导演——关联性思维 方法为什么——皆在一个“心”字 懈寄生——帮助过我的那些书那些人 一分钟先生——自我时间管理 达芬奇密码——从游击队到正规军 亢龙有悔——方法反思 ……

概览
引子
1 设计模式入门 欢迎来到设计模式世界
2 观察者模式 让你的对象知悉现况
3 装饰者模式 装饰对象
4 工厂模式 烘烤OO的精华
5 单件模式 独一无二的对象
6 命令模式 封装调用
7 适配器模式与外观模式 随遇模式
8 模板方法模式 封装算法
9 选代器与组合模式 管理良好的集合
10 状态模式 事物的状态
11 代理模式 控制对象访问
12 复合模式 模式中的模型
13 与设计模式相处 真实世界中的模式
附录A：剩下的模式
索引

第一部分 基础
第1章 开篇 3
1.1 一次友好的对话 3
1.2 准确的问题描述 4
1.3 程序设计 4
1.4 实现概要 5
1.5 原理 6
1.6 习题 7
1.7 深入阅读 9 

 第2章 啊哈! 算法 11 2.1 三个问题 11 2.2 无处不在的二分搜索 12 2.3 基本操作的威力 13 2.4 排序 15 2.5 原理 16 2.6 习题 17 2.7 深入阅读 18 2.8 变位词程序的实现(边栏) 18

 第3章 数据决定程序结构 21 3.1 一个调查程序 21 3.2 格式信函编程 23 3.3 一组示例 25 3.4 结构化数据 26 3.5 用于特殊数据的强大工具 27 3.6 原理 28 3.7 习题 29 3.8 深入阅读 30

 第4章 编写正确的程序 33 4.1 二分搜索的挑战 33 4.2 编写程序 34 4.3 理解程序 36 4.4 原理 38 4.5 程序验证的角色 39 4.6 习题 40 4.7 深入阅读 42

 第5章 编程小事 43 5.1 从伪代码到C程序 43 5.2 测试工具 44 5.3 断言的艺术 46 5.4 自动测试 48 5.5 计时 49 5.6 完整的程序 50 5.7 原理 51 5.8 习题 51 5.9 深入阅读 52 5.10 调试(边栏) 53

 第二部分 性能 第6章 程序性能分析 57 6.1 实例研究 57 6.2 设计层面 59 6.3 原理 60 6.4 习题 61 6.5 深入阅读 61

 第7章 粗略估算 63 7.1 基本技巧 64 7.2 性能估计 66 7.3 安全系数 68 7.4 Little定律 69 7.5 原理 70 7.6 习题 70 7.7 深入阅读 71 7.8 日常生活中的速算(边栏) 72

 第8章 算法设计技术 73 8.1 问题及简单算法 73 8.2 两个平方算法 74 8.3 分治算法 75 8.4 扫描算法 77 8.5 实际运行时间 77 8.6 原理 79 8.7 习题 80 8.8 深入阅读 81

 第9章 代码调优 83 9.1 典型的故事 83 9.2 急救方案集锦 84 9.3 大手术——二分搜索 88 9.4 原理 91 9.5 习题 92 9.6 深入阅读 94

 第10章 节省空间 95 10.1 关键在于简单 95 10.2 示例问题 96 10.3 数据空间技术 99 10.4 代码空间技术 101 10.5 原理 103 10.6 习题 104 10.7 深入阅读 105 10.8 巨大的节省(边栏) 105

 第三部分 应用 第11章 排序 109 11.1 插入排序 109 11.2 一种简单的快速排序 110 11.3 更好的几种快速排序 113 11.4 原理 115 11.5 习题 116 11.6 深入阅读 117

 第12章 取样问题 119 12.1 问题 119 12.2 一种解决方案 120 12.3 设计空间 121 12.4 原理 123 12.5 习题 124 12.6 深入阅读 125

 第13章 搜索 127 13.1 接口 127 13.2 线性结构 129 13.3 二分搜索树 132 13.4 用于整数的结构 134 13.5 原理 135 13.6 习题 136 13.7 深入阅读 137 13.8 一个实际搜索问题(边栏) 137

 第14章 堆 141 14.1 数据结构 141 14.2 两个关键函数 143 14.3 优先级队列 145 14.4 一种排序算法 148 14.5 原理 150 14.6 习题 150 14.7 深入阅读 152

 第15章 字符串 153 15.1 单词 153 15.2 短语 156 15.3 生成文本 158 15.4 原理 163 15.5 习题 163 15.6 深入阅读 164 第1版跋 165 第2版跋 167 附录A 算法分类 169 附录B 估算测试 173 附录C 时空开销模型 175 附录D 代码调优法则 181 附录E 用于搜索的C++类 187 部分习题提示 191 部分习题答案 195 索引 221

出版者的话
译者序
前言
第1章 引论
1.1 语言处理器
1.2 一个编译器的结构
1.2.1 词法分析
1.2.2 语法分析
1.2.3 语义分析
1.2.4 中间代码生成
1.2.5 代码优化
1.2.6 代码生成
1.2.7 符号表管理
1.2.8 将多个步骤组合成趟
1.2.9 编译器构造工具 

 1.3 程序设计语言的发展历程 1.3.1 走向高级程序设计语言 1.3.2 对编译器的影响 1.3.3 1.3 节的练习

 1.4 构建一个编译器的相关科学 1.4.1 编译器设计和实现中的建模 1.4.2 代码优化的科学

 1.5 编译技术的应用 1.5.1 高级程序设计语言的实现 1.5.2 针对计算机体系结构的优化 1.5.3 新计算机体系结构的设计 1.5.4 程序翻译 1.5.5 软件生产率工具

 1.6 程序设计语言基础 1.6.1 静态和动态的区别 1.6.2 环境与状态 1.6.3 静态作用域和块结构 1.6.4 显式访问控制 1.6.5 动态作用域 1.6.6 参数传递机制 1.6.7 别名 1.6.8 1.6 节的练习 1.7 第1章的总结 1.8 第1章的参考书目

 第2章 一个简单的语法制导翻译器 2.1 引言 2.2 语法定义 2.2.1 文法定义 2.2.2 推导 2.2.3 语法分析树 2.2.4 二义性 2.2.5 运算符的结合性 2.2.6 运算符的优先级 2.2.7 2.2 节的练习

 2.3 语法制导翻译 2.3.1 后缀表示 2.3.2 综合属性 2.3.3 简单语法制导定义 2.3.4 树的遍历 2.3.5 翻译方案 2.3.6 2.3 节的练习

 2.4 语法分析 2.4.1 自顶向下分析方法 2.4.2 预测分析法 2.4.3 何时使用产生式 2.4.4 设计一个预测语法分析器 2.4.5 左递归 2.4.6 2.4 节的练习

 2.5 简单表达式的翻译器 2.5.1 抽象语法和具体语法 2.5.2 调整翻译方案 2.5.3 非终结符号的过程 2.5.4 翻译器的简化 2.5.5 完整的程序

 2.6 词法分析 2.6.1 剔除空白和注释 2.6.2 预读 2.6.3 常量 2.6.4 识别关键字和标识符 2.6.5 词法分析器 2.6.6 2.6 节的练习

 2.7 符号表 2.7.1 为每个作用域设置一个符号表 2.7.2 符号表的使用 2.8 中间代码生成 2.8.1 两种中间表示形式 2.8.2 语法树的构造 2.8.4 三地址码 2.8.5 2.8 节的练习 2.9 第2章的总结

 第3章 词法分析 3.1 词法分析器的作用 3.1.1 词法分析及解析 3.1.2 词法单元、模式、词素 3.1.3 词法单元的属性 3.1.4 词法错误 3.1.5 3.1 节的练习

 3.2 输入缓冲 3.2.1 缓冲区对 3.2.2 哨兵标记

 3.3 词法单元的规约 3.3.1 串和语言 3.3.2 语言上的运算 3.3.3 正则表达式 3.3.4 正则定义 3.3.5 正则表达式的扩展 3.3.6 3.3 节的练习

 3.4 词法单元的识别 3.4.1 状态转换图 3.4.2 保留字和标识符的识别 3.4.3 完成我们的连续性例子 3.4.4 基于状态转换图的词法分析器的体系结构 3.4.5 3.4 节的练习

 3.5 词法分析器生成工具Lex 3.5.1 Lex的使用 3.5.2 Lex程序的结构 3.5.3 Lex中的冲突解决 3.5.4 向前看运算符 3.5.5 3.5 节练习

 3.6 有穷自动机 3.6.1 不确定的有穷自动机 3.6.2 转换表 3.6.3 NFA接受输入字符串 3.6.4 确定的有穷自动机 3.6.5 3.6 节的练习

 3.7 从正则表达式到自动机 3.7.1 从NFA到DFA的转换 3.7.2 NFA的模拟 3.7.3 NFA模拟效率 3.7.4 从正则表达式构造NFA 3.7.5 字符串处理算法的效率 3.7.6 3.7 节的练习

 3.8 词法分析器生成工具的设计 3.8.1 被生成的词法分析器的结构 3.8.2 基于NFA的模式匹配 3.8.3 词法分析器使用的DFA 3.8.4 实现向前看运算符 3.8.5 3.8 的练习

 3.9 基于DFA的模式匹配器的优化 3.9.1 NFA的重要状态 3.9.2 根据抽象语法树计算得到的函数 3.9.3 计算nullable、firstpos及lastpos 3.9.4 计算followpos 3.9.5 根据正则表达式构建DFA 3.9.6 最小化一个DFA的状态数 3.9.7 词法分析器的状态最小化 3.9.8 在DFA模拟中用时间换取空间 3.9.9 3.9 节的练习 3.9.10 第3章的总结 3.11 第3章参考文献

 第4章 语法分析 4.1 引论 4.1.1 语法分析器的角色 4.1.2 代表性的文法 4.1.3 语法错误的处理 4.1.4 错误恢复策略

 4.2 上下文无关文法 4.2.1 上下文无关文法的正式定义 4.2.2 符号表示的惯例 4.2.3 推导 4.2.4 语法分析树和推导 4.2.5 二义性 4.2.6 验证文法生成的语言 4.2.7 上下文无关文法和正则表达式 4.2.8 4.2 节的练习

 4.3 设计文法 4.3.1 词法分析和语法分析 4.3.2 消除二义性 4.3.3 左递归的消除 4.3.4 提取左公因子 4.3.5 非上下文无关的语言构造 4.3.6 4.3 节的练习

 4.4 自顶向下的语法分析 4.4.1 递归下降的语法分析 4.4.2 FIRST和FOLLOW 4.4.3 LL(1)文法 4.4.4 非递归的预测分析 4.4.5 预测分析中的错误恢复 4.4.6 4.4 节的练习

 4.5 自底向上的语法分析 4.5.1 归约 4.5.2 句柄剪枝 4.5.3 移入-归约语法分析技术 4.5.4 移入-归约语法分析中的冲突 4.5.5 4.5 节的练习

 4.6 LR语法分析技术介绍：简单LR技术 4.6.1 为什么使用LR语法分析器？ 4.6.2 项和LR(0)自动机 4.6.3 LR-语法分析算法 4.6.4 构造SLR-分析表 4.6.5 可行前缀 4.6.6 4.6 节的练习

 4.7 更强大的LR语法分析器 4.7.1 规范LR(1)项 4.7.2 构造LR(1)项集 4.7.3 规范LR(1)分析表 4.7.4 构造LALR语法分析表 4.7.5 LALR语法分析表的高效构造方法 4.7.6 LR语法分析表的压缩 4.7.7 4.7 节的练习

 4.8 使用二义性文法 4.8.1 用优先级和结合性解决冲突 4.8.2 “悬空-else”二义性 4.8.3 LR语法分析中的错误恢复 4.8.4 4.8 节的练习

 4.9 语法分析器的生成工具 4.9.1 语法分析器的生成工具Yacc 4.9.2 使用Yacc处理二义性文法 4.9.3 用Lex创建Yacc的词法分析器 4.9.4 Yacc中的错误恢复 4.9.5 4.9节的练习 4.10：第4章的小结 4.11 第4章的参考文献

 第5章 语法制导的翻译 5.1 语法制导定义 5.1.1 继承属性和综合属性 5.1.2 在一棵语法分析树的结点上对一个SDD求值 5.1.3 5.1 节的练习

 5.2 SDD的求值顺序 5.2.1 依赖图 5.2.2 属性求值的顺序 5.2.3 S-属性定义 5.2.4 L-属性定义 5.2.5 具有受控副作用的语义规则 5.2.6 5.2 节的练习

 5.3 语法制导翻译的应用 5.3.1 抽象语法树的构造 5.3.2 类型的结构 5.3.3 5.3 节的练习

 5.4 语法制导的翻译方案 5.4.1 后缀翻译方案 5.4.2 后缀SDT的语法分析栈实现 5.4.3 产生式内部带有语义动作的SDT 5.4.4 从SDT中消除左递归 5.4.5 L-属性定义的SDT 5.4.6 5.4 节的练习

 5.5 实现L-属性的SDD 5.5.1 在递归下降语法分析过程中进行翻译 5.5.2 边扫描边生成代码 5.5.3 L-属性的SDD和LL语法分析 5.5.4 L-属性的SDD的自底向上语法分析 5.5.5 5.5 节的练习 5.6 第5章的总结 5.7 第5章的参考文献 第6章 中间代码生成 第7章 运行时刻环境 第7章 总结 第8章 代码生成 第9章 机器无关优化 第10章 指令级并行 第11章 并行性和局部性的优化 第12章 过程间分析

出版者的话
专家指导委员会
译者序
前言
第一部分 基础篇
第1章 全景图
1.1 计算系统
1.1.1 计算系统的分层
1.1.2 抽象
1.2 计算的历史
1.2.1 计算硬件的简史
1.2.2 计算软件的简史
1.2.3 预言
1.3 计算工具和计算学科
小结
练习
思考题 

 第二部分 信息层 第2章 二进制数值和记数系统 2.1 数字分类 2.2 自然数 2.2.1 位置记数法 2.2.2 二进制、八进制和十六进制 2.2.3 其他记数系统中的运算 2.2.4 以2的幂为基数的记数系统 2.2.5 把十进制数转换成其他数制的数 2.2.6 二进制数值和计算机 小结 练习 思考题

 第3章 数据表示法 3.1 数据和计算机 3.1.1 模拟信息和数字信息 3.1.2 二进制表示法 3.2 数字数据的表示法 3.2.1 负数表示法 3.2.2 实数表示法 3.3 文本表示法 3.3.1 ASCII字符集 3.3.2 Unicode字符集 3.3.3 文本压缩 3.4 音频信息表示法 3.4.1 音频格式 3.4.2 MP3音频格式 3.5 图像和图形的表示法 3.5.1 颜色表示法 3.5.2 数字化图像和图形 3.5.3 图形的矢量表示法 3.6 视频表示法 小结 练习 思考题

 第三部分 硬件层 第4章门和电路 4.1 计算机和电学 4.2 门 4.2.1 非门 4.2.2 与门 4.2.3 或门 4.2.4 异或门 4.2.5 与非门和或非门 4.2.6 门处理回顾 4.2.7 具有更多输入的门

 4.3 门的构造 4.4 电路 4.4.1 组合电路 4.4.2 加法器 4.4.3 多路复用器 4.5 存储器电路 4.6 集成电路 4.7 CPU芯片 小结 道德问题：电子邮件隐私权 练习 思考题

 第5章 计算部件 5.1 独立的计算机部件 5.2 存储程序的概念 5.2.1 冯？诺伊曼体系结构 5.2.2 读取一执行周期 5.2.3 RAM和ROM 5.2.4 二级存储设备 5.2.5 触摸屏 5.3 非冯？诺伊曼体系结构 小结 道德问题：生物信息学研究和deCODE Genetics公司的案例 练习 思考题

 第四部分 程序设计层 第6章问题求解和算法设计 6.1 问题求解 6.1.1 如何解决问题 6.1.2 应用Polya的问题求解策略 6.2 算法 6.2.1 计算机问题求解 6.2.2 执行算法 6.2.3 开发算法 6.3 伪代码 6.3.1 执行一个伪代码算法 6.3.2 伪代码的功能 6.3.3 伪代码示例 6.4 自顶向下设计方法 6.4.1 一个通用的实例 6.4.2 一个计算机实例 6.4.3 方法总结 6.4.4 测试算法 6.5 面向对象方法 6.5.1 面向对象 6.5.2 设计方法 6.5.3 一个通用的实例 6.5.4 一个计算机实例 6.6 几个重要思想 6.6.1 信息隐蔽 6.6.2 抽象 6.6.3 事物命名 6.6.4 程序设计语言 6.6.5 测试 小结 道德问题：计算机专业人员许可 练习 思考题

 第7章 低级程序设计语言 7.1 计算机操作 7.2 抽象的分层 7.3 机器语言 7.4 一个程序实例 7.4.1 问题和算法 7.4.2 程序 7.5 汇编语言 7.5.1 Pep／7汇编语言 7.5.2 伪代码操作 7.5.3 “Hello”程序的汇编语言版本 7.5.4 一个新程序 7.5.5 具有分支的程序 7.5.6 具有循环的程序 7.6 其他重要思想 7.6.1 抽象 7.6.2 测试 7.6.3 测试计划实现 小结 道德问题：软件盗版和版权 练习 思考题

 第8章 高级程序设计语言 8.1 翻译过程 8.1.1 编译器 8.1.2 解释器 8.2 程序设计语言的范型 8.3 命令式语言的功能性 8.3.1 布尔表达式 8.3.2 强类型化 8.3.3 输入／输出结构 8.3.4 控制结构 8.3.5 复合数据类型 8.4 面向对象语言的功能性 8.4.1 封装 8.4.2 继承 8.4.3 多态性 小结 道德问题：开源软件的发展 练习 思考题

 第9章 抽象数据类型和算法 9.1 抽象数据类型 9.2 实现 9.2.1 基于数组的实现 9.2.2 链式实现 9.3 列表 9.3.1 列表的基本操作 9.3.2 其他列表操作 9.4 排序 9.4.1 选择排序 9.4.2 冒泡排序 9.4.3 快速排序 9.5 二分检索法 9.6 栈和队列 9.6.1 栈 9.6.2 队列 9.6.3 实现 9.7 树 9.7.1 二叉树 9.7.2 二叉检索树 9.7.3 其他操作 9.7.4 图 9.8 程序设计库 小结 道德问题：使用计算机的恶作剧和欺诈行为 练习 思考题

 第五部分 操作系统层 第10章 操作系统 10.1 操作系统的角色 10.1.1 内存、进程和CPU管理 10.1.2 批处理 10.1.3 分时操作 10.1.4 其他OS要素 10.2 内存管理 10.2.1 单块内存管理 10.2.2 分区内存管理 10.2.3 页式内存管理 10.3 进程管理 10.3.1 进程状态 10.3.2 进程控制块 10.4 CPU调度 10.4.1 先到先服务 10.4.2 最短作业优先 10.4.3 循环调度法 小结 道德问题：数字版权管理和关于sony公司的根目录案件的争论 练习 思考题

 第11章 文件系统和目录 11.1 文件系统 11.1.1 文本文件和二进制文件 11.1.2 文件类型 11.1.3 文件操作 11.1.4 文件访问 11.1.5 文件保护 11.2 目录 11.2.1 目录树 11.2.2 路径名 11.3 磁盘调度 11.3.1 先到先服务磁盘调度法 11.3.2 最短寻道时间优先磁盘调度法 11.3.3 SCAN磁盘调度法 小结 道德问题：垃圾邮件 练习 思考题

 第六部分 应用程序层 第12章 信息系统 12.1 信息管理 12.2 电子制表软件 12.2.1 电子数据表公式 12.2.2 循环引用 12.2.3 电子数据表分析 12.3 数据库管理系统 12.3.1 关系模型 12.3.2 关系 12.3.3 结构化查询语言 12.3.4 数据库设计 12.4 信息安全 12.4.1 机密性、完整性和可用性 12.4.2 密码学 小结 道德问题：加密 练习 思考题

 第13章 人工智能 13.1 思维机 13.1.1 图灵测试 13.1.2 AI问题的各个方面 13.2 知识表示 13.2.1 语义网 13.2.2 检索树 13.3 专家系统 13.4 神经网络 13.4.1 生物神经网络 13.4.2 人工神经网络 13.5 自然语言处理 13.5.1 语音合成 13.5.2 语音识别 13.5.3 自然语言理解 13.6 机器人学 13.6.1 感知一规划一执行范型 13.6.2 包孕体系结构 13.6.3 物理部件 小结 道德问题：HIPAA（健康保险携带和责任法案） 练习 思考题

 第14章 模拟、图形学和其他应用程序 14.1 什么是模拟 14.1.1 复杂系统 14.1.2 模型 14.1.3 构造模型 14.1.4 排队系统 14.1.5 气象模型 14.1.6 其他模型 14.1.7 必要的计算能力 14.2 计算机图形学 14.2.1 光的工作原理 14.2.2 物体形状 14.2.3 光模拟 14.2.4 复杂对象的建模 14.2.5 让物体动起来 14.3 嵌入式系统 14.4 电子商务 14.5 计算机安全 14.5.1 恶意代码 14.5.2 安全攻击 小结 道德问题：入侵大学的计算机系统，查询 录取程序中某人的录取状态 练习 思考题

 第七部分 通信层 第15章 网络 15.1 连网 15.1.1 网络的类型 15.1.2 Internet连接 15.1.3 包交换 15.2 开放式系统和协议 15.2.1 开放式系统 15.2.2 网络协议 15.2.3 TCP／IP 15.2.4 高层协议 15.2.5 MIME类型 15.2.6 防火墙 15.3 网络地址 小结 道德问题：无所不在的计算 练习 思考题

 第16章 万维网 16.1 Web简介 16.1.1 搜索引擎 16.1.2 即时消息 16.1.3 博客 16.1.4 cookje 16.2 HTML 16.2.1 基本的HTML格式 16.2.2 图像和链接 16.3 交互式Web页 16.3.1.1 ava小程序 16.3.2 Java服务器页 16.4 XML 小结 道德问题：写博客 练习 思考题

 第八部分 总结 第17章 计算的限制 17.1 硬件 17.1.1 算术运算的限制 17.1.2 部件的限制 17.1.3 通信的限制 17.2 软件 17.2.1 软件的复杂度 17.2.2 当前提高软件质量的方法 17.2.3 臭名昭著的软件错误 17.3 问题 17.3.1 算法比较 17.3.2 图灵机 17.3.3 停机问题 17.3.4 算法分类 小结 道德问题：深度链接 练习 思考题 参考文献

第1部分 简介
　第1章 温故而知新
　　1.1 从HELLO WORLD 说起
　 1.2 万变不离其宗
　　1.3 站得高，望得远
　　1.4 操作系统做什么
　　1.5 内存不够怎么办
　　1.6 众人拾柴火焰高
　　1.7 本章小结
第2部分 静态链接
　第2章 编译和链接
　　2.1 被隐藏了的过程
　　2.2 编译器做了什么
　　2.3 链接器年龄比编译器长
　　2.4 模块拼装——静态链接
　　2.5 本章小结
　第3章 目标文件里有什么
　　3.1 目标文件的格式
　　3.2 目标文件是什么样的
　　3.3 挖掘SIMPLESECTION.O
　　3.4 ELF 文件结构描述
　　3.5 链接的接口——符号
　　3.6 调试信息
　　3.7 本章小结
　第4章 静态链接
　　4.1 空间与地址分配
　　4.2 符号解析与重定位
　　4.3 COMMON 块
　　4.4 C++相关问题
　　4.5 静态库链接
　　4.6 链接过程控制
　　4.7 BFD 库
　　4.8 本章小结
　第5章 WINDOWS PE/COFF
　　5.1 WINDOWS 的二进制文件格式PE/COFF 134
　　5.2 PE 的前身——COFF
　　5.3 链接指示信息
　　5.4 调试信息
　　5.5 大家都有符号表
　　5.6 WINDOWS 下的ELF——PE
　　5.7 本章小结
第3部分 装载与动态链接
　第6章 可执行文件的装载与进程
　　6.1 进程虚拟地址空间
　　6.2 装载的方式
　　6.3 从操作系统角度看可执行文件的装载
　　6.4 进程虚存空间分布
　　6.5 LINUX 内核装载ELF 过程简介
　　6.6 WINDOWS PE 的装载
　　6.7 本章小结
　第7章 动态链接
　　7.1 为什么要动态链接
　　7.2 简单的动态链接例子
　　7.3 地址无关代码
　　7.4 延迟绑定（PLT）
　　7.5 动态链接相关结构
　　7.6 动态链接的步骤和实现
　　7.7 显式运行时链接
　　7.8 本章小结
　第8章 LINUX 共享库的组织
　　8.1 共享库版本
　　8.2 符号版本
　　8.3 共享库系统路径
　　8.4 共享库查找过程
　　8.5 环境变量
　　8.6 共享库的创建和安装
　　8.7 本章小结
　第9章 WINDOWS 下的动态链接
　　9.1 DLL 简介
　　9.2 符号导出导入表
　　9.3 DLL 优化
　　9.4 C++与动态链接
　　9.5 DLL HELL
　　9.6 本章小结
第4部分 库与运行库
　第10章 内存
　　10.1 程序的内存布局
　　10.2 栈与调用惯例
　　10.3 堆与内存管理
　　10.4 本章小结
　第11章 运行库
　　11.1 入口函数和程序初始化
　　11.2 C/C++运行库
　　11.3 运行库与多线程
　　11.4 C++全局构造与析构
　　11.5 FREAD 实现
　　11.6 本章小结
　第12章 系统调用与API
　　12.1 系统调用介绍
　　12.2 系统调用原理
　　12.3 WINDOWS API
　　12.4 本章小结
　第13章 运行库实现
　　13.1 C 语言运行库
　　13.2 如何使用MINI CRT
　　13.3 C++运行库实现
　　13.4 如何使用MINI CRT++
　　13.5 本章小结
附录A
　A.1 字节序（BYTE ORDER）
　A.2 ELF 常见段
　A.3 常用开发工具命令行参考
索引

序
前言
第一部分 论架构
第1章 什么是架构
1.1 简介
1.2 创建软件架构
1.3 架构结构
1.4 好的架构
1.5 美丽的架构
1.6 致谢
1.7 参考文献 

 第2章 两个系统的故事：现代软件神话 2.1 混乱大都市 2.2 设计之城 2.3 说明什么问题 2.4 轮到您了 2.5 参考文献

 第二部分 企业级应用架构 第3章 伸缩性架构设计 3.1 简介 3.2 背景 3.3 架构 3.4 关于架构的思考

 第4章 记忆留存 4.1 功能和约束 4.2 工作流 4.3 架构关注点 4.4 用户反应 4.5 结论

 第5章 面向资源的架构：在Web中 5.1 简介 5.2 传统的Web服务 5.3 Web 5.4 面向资源的架构 5.5 数据驱动的应用 5.6 应用面向资源的架构 5.7 结论

 第6章 数据增长：Facebook平台的架构 6.1 简介 6.2 创建一个社会关系Web服务 6.3 创建社会关系数据查询服务 6.4 创建一个社会关系Web门户：FBML 6.5 系统的支持功能 6.6 总结

 第三部分 系统架构 第7章 Xen和虚拟化之美 7.1 简介 7.2 Xenoservers 7.3 虚拟化的挑战 7.4 半虚拟化 7.5 Xen的变换形式 7.6 改变的硬件，改变的Xen 7.7 经验教训 7.8 延伸阅读

 第8章 Guardian：一个容错操作系统环境 8.1 Tandem/16，将来所有的计算机都会像这样构建 8.2 硬件 8.3 机械布局 8.4 处理器架构 8.5 处理器间总线 8.6 输入/输出 8.7 进程结构 8.8 消息系统 8.9 文件系统 8.10 民间传说 8.11 弊端 8.12 后继者 8.13 延伸阅读

 第9章 JPC：一个纯Java的x86PC模拟程序 9.1 简介 9.2 概念验证 9.3 PC架构 9.4 Java性能技巧 9.5 把4GB放入4GB：这不起作用 9.6 保护模式的危险 9.7 从事一项毫无成功希望的斗争 9.8 劫持JVM 9.9 最终灵活性 9.10 最佳安全性 9.11 第二次做会更好

 第10章 元循环虚拟机的力量：JikesRVM 10.1 背景 10.2 与运行时环境相关的传言 10.3 JikesRVM简史 10.4 一个自足执行的运行时自举 10.5 运行时组件 10.6 经验教训 参考文献

 第四部分 最终用户应用架构 第11章 GNUEmacs：滋长的特性是其优势 11.1 使用中的Emacs 11.2 Emacs的架构 11.3 滋长的特性 11.4 另外两个架构

 第12章 当集市开始构建教堂 12.1 简介 12.2 KDE项目的历史和组织结构 12.3 Akonadi 12.4 ThreadWeaver

 第五部分 语言与架构 第13章 软件架构：面向对象与面向功能 13.1 概述 13.2 示例 13.3 面向功能解决方案的模块性评价 13.4 面向对象视图 13.5 面向对象模块性的评价和改进 13.6 代理：将操作封装到对象中 致谢 参考文献

 第14章 重读经典 14.1 所有东西都是对象 14.2 类型是隐式定义的 14.3 问题 14.4 砖块和灰浆建筑架构 参考文献 跋

第1章　整洁代码　1
1.1　要有代码　2
1.2　糟糕的代码　2
1.3　混乱的代价　3
1.3.1　华丽新设计　4
1.3.2　态度　4
1.3.3　迷题　5
1.3.4　整洁代码的艺术　5
1.3.5　什么是整洁代码　6
1.4　思想流派　10
1.5　我们是作者　11
1.6　童子军军规　12
1.7　前传与原则　12
1.8　小结　12
1.9　文献　13 

 第2章　有意义的命名　15 2.1　介绍　15 2.2　名副其实　16 2.3　避免误导　17 2.4　做有意义的区分　18 2.5　使用读得出来的名称　19 2.6　使用可搜索的名称　20 2.7　避免使用编码　21 2.7.1　匈牙利语标记法　21 2.7.2　成员前缀　21 2.7.3　接口和实现　22 2.8　避免思维映射　22 2.9　 类名　23 2.10　方法名　23 2.11　别扮可爱　23 2.12　每个概念对应一个词　24 2.13　别用双关语　24 2.14　使用解决方案领域名称　25 2.15　使用源自所涉问题领域的名称　25 2.16　添加有意义的语境　25 2.17　不要添加没用的语境　27 2.18　最后的话　27

 第3章　函数　29 3.1　短小　32 3.2　只做一件事　33 3.3　每个函数一个抽象层级　34 3.4　switch语句　35 3.5　使用描述性的名称　36 3.6　函数参数　37 3.6.1　一元函数的普遍形式　38 3.6.2　标识参数　38 3.6.3　二元函数　38 3.6.4　三元函数　39 3.6.5　参数对象　39 3.6.6　参数列表　40 3.6.7　动词与关键字　40 3.7　无副作用　40 3.8　分隔指令与询问　42 3.9　使用异常替代返回错误码　42 3.9.1　抽离Try/Catch代码块　43 3.9.2　错误处理就是一件事　44 3.9.3　Error.java依赖磁铁　44 3.10　别重复自己　44 3.11　结构化编程　45 3.12　如何写出这样的函数　45 3.13　小结　45 3.14　SetupTeardownIncluder程序　46 3.15　文献　48

 第4章　注释　49 4.1　注释不能美化糟糕的代码　50 4.2　用代码来阐述　51 4.3　好注释　51 4.3.1　法律信息　51 4.3.2　提供信息的注释　51 4.3.3　对意图的解释　52 4.3.4　阐释　53 4.3.5　警示　53 4.3.6　TODO注释　54 4.3.7　放大　54 4.3.8　公共API中的Javadoc　55 4.4　坏注释　55 4.4.1　喃喃自语　55 4.4.2　多余的注释　56 4.4.3　误导性注释　58 4.4.4　循规式注释　58 4.4.5　日志式注释　59 4.4.6　废话注释　59 4.4.7　可怕的废话　61 4.4.8　能用函数或变量时就别用注释　62 4.4.9　位置标记　62 4.4.10　括号后面的注释　62 4.4.11　归属与署名　63 4.4.12　注释掉的代码　63 4.4.13　HTML注释　64 4.4.14　非本地信息　64 4.4.15　信息过多　65 4.4.16　不明显的联系　65 4.4.17　函数头　66 4.4.18　非公共代码中的Javadoc　66 4.4.19　范例　66 4.5　文献　69

 第5章　格式　71 5.1　格式的目的　72 5.2　垂直格式　72 5.2.1　向报纸学习　73 5.2.2　概念间垂直方向上的区隔　73 5.2.3　垂直方向上的靠近　74 5.2.4　垂直距离　75 5.2.5　垂直顺序　79 5.3　横向格式　79 5.3.1　水平方向上的区隔与靠近　80 5.3.2　水平对齐　81 5.3.3　缩进　82 5.3.4　空范围　84 5.4　团队规则　84 5.5　鲍勃大叔的格式规则　85

 第6章　对象和数据结构　87 6.1　数据抽象　87 6.2　数据、对象的反对称性　89 6.3　得墨忒耳律　91 6.3.1　火车失事　91 6.3.2　混杂　92 6.3.3　隐藏结构　92 6.4　数据传送对象　93 6.5　小结　94 6.6　文献　94

 第7章　错误处理　95 7.1　使用异常而非返回码　96 7.2　先写Try-Catch-Finally语句　97 7.3　使用不可控异常　98 7.4　给出异常发生的环境说明　99 7.5　依调用者需要定义异常类　99 7.6　定义常规流程　100 7.7　别返回null值　101 7.8　别传递null值　102 7.9　小结　103 7.10 文献　104

 第8章　边界　105 8.1　使用第三方代码　106 8.2　浏览和学习边界　107 8.3　学习log4j　108 8.4　学习性测试的好处不只是免费　110 8.5　使用尚不存在的代码　110 8.6　整洁的边界　111 8.7　文献　112

 第9章　单元测试　113 9.1　TDD三定律　114 9.2　保持测试整洁　115 9.3　整洁的测试　116 9.3.1　面向特定领域的测试语言　118 9.3.2　双重标准　119 9.4　每个测试一个断言　121 9.5　F.I.R.S.T.　122 9.6　小结　123 9.7　文献　124

 第10章　类　125 10.1　类的组织　126 10.2　类应该短小　126 10.2.1　单一权责原则　128 10.2.2　内聚　129 10.2.3　保持内聚性就会得到许多短小的类　130 10.3　为了修改而组织　136 10.4　文献　139

 第11章　系统　141 11.1　如何建造一个城市　142 11.2　将系统的构造与使用分开　142 11.2.1　分解main　143 11.2.2　工厂　143 11.2.3　依赖注入　144 11.3　扩容　145 11.4　Java代理　148 11.5　纯Java AOP框架　150 11.6　AspectJ的方面　152 11.7　测试驱动系统架构　153 11.8　优化决策　154 11.9　明智使用添加了可论证价值的标准　154 11.10 系统需要领域特定语言　154 11.11 小结　155 11.12 文献　155

 第12章　迭进　157 12.1　通过迭进设计达到整洁目的　157 12.2　简单设计规则1：运行所有测试　158 12.3　简单设计规则2～4：重构　158 12.4　不可重复　159 12.5　表达力　161 12.6　尽可能少的类和方法　162 12.7　小结　162 12.8　文献　162

 第13章　并发编程　163 13.1　为什么要并发　164 13.2　挑战　165 13.3　并发防御原则　166 13.3.1　单一权责原则　166 13.3.2　推论：限制数据作用域　166 13.3.3　推论：使用数据复本　167 13.3.4　推论：线程应尽可能地独立　167 13.4　了解Java库　167 13.5　了解执行模型　168 13.5.1　生产者-消费者模型　169 13.5.2　读者-作者模型　169 13.5.3　宴席哲学家　169 13.6　警惕同步方法之间的依赖　169 13.7　保持同步区域微小　170 13.8　很难编写正确的关闭代码　170 13.9　测试线程代码　171 13.9.1　将伪失败看作可能的线程问题　171 13.9.2　先使非线程代码可工作　171 13.9.3　编写可插拔的线程代码　172 13.9.4　编写可调整的线程代码　172 13.9.5　运行多于处理器数量的线程　172 13.9.6　在不同平台上运行　172 13.9.7　装置试错代码　173 13.9.8　硬编码　173 13.9.9　自动化　174 13.10　小结　175 13.11　文献　175

 第14章　逐步改进　176 14.1　Args的实现　177 14.2　Args：草稿　183 14.2.1　所以我暂停了　195 14.2.2　渐进　195 14.3　字符串参数　197 14.4　小结　234

 第15章　JUnit内幕　235 15.1　JUnit框架　236 15.2　小结　249

 第16章　重构SerialDate　251 16.1　首先，让它能工作　252 16.2　让它做对　254 16.3　小结　266 16.4　文献　267

 第17章　味道与启发　269 17.1　注释　270 17.2　环境　271 17.3　函数　271 17.4　一般性问题　272 17.5　Java　288 17.6　名称　291 17.7　测试　294 17.8　小结　295 17.9　文献　296

 附录A　并发编程II　297 A.1　客户端/服务器的例子　297 A.1.1　服务器　297 A.1.2　添加线程代码　298 A.1.3　观察服务器端　299 A.1.4　小结　301 A.2　执行的可能路径　301 A.2.1　路径数量　302 A.2.2　深入挖掘　303 A.2.3　小结　305 A.3　了解类库　305 A.3.1　Executor框架　305 A.3.2　非锁定的解决方案　306 A.3.3　非线程安全类　307 A.4　方法之间的依赖可能破坏并发代码　308 A.4.1　容忍错误　309 A.4.2　基于客户代码的锁定　309 A.4.3　基于服务端的锁定　311 A.5　提升吞吐量　312 A.5.1　单线程条件下的吞吐量　313 A.5.2　多线程条件下的吞吐量　313 A.6　死锁　314 A.6.1　互斥　315 A.6.2　上锁及等待　315 A.6.3　无抢先机制　315 A.6.4　循环等待　315 A.6.5　不互斥　316 A.6.6　不上锁及等待　316 A.6.7　满足抢先机制　317 A.6.8　不做循环等待　317 A.7　测试多线程代码　317 A.8　测试线程代码的工具支持　320 A.9　小结　320 A.10 教程：完整代码范例　321 A.10.1　客户端/服务器非线程代码　321 A.10.2　使用线程的客户端/服务器代码　324 附录B　org.jfree.date.SerialDate　327 结束语　389

第1章 敏捷——高效软件开发之道 

 第2章 态度决定一切 1. 做事 2. 欲速则不达 3. 对事不对人 4. 排除万难，奋勇前进

 第3章 学无止境 5. 跟踪变化 6. 对团队投资 7. 懂得丢弃 8. 打破砂锅问到底 9. 把握开发节奏

 第4章 交付用户想要的软件 10. 让客户做决定 11. 让设计指导而不是操纵开发 12. 合理地使用技术 13. 保持可以发布 14. 提早集成，频繁集成 15. 提早实现自动化部署 16. 使用演示获得频繁反馈 17. 使用短迭代，增量发布 18. 固定的价格就意味着背叛承诺

 第5章 敏捷反馈 19. 守护天使 20. 先用它再实现它 21. 不同环境，就有不同问题 22. 自动验收测试 23. 度量真实的进度 24. 倾听用户的声音

 第6章 敏捷编码 25. 代码要清晰地表达意图 26. 用代码沟通 27. 动态评估取舍 28. 增量式编程 29. 保持简单 30. 编写内聚的代码 31. 告知，不要询问 32. 根据契约进行替换

 第7章 敏捷调试 33. 记录问题解决日志 34. 警告就是错误 35. 对问题各个击破 36. 报告所有的异常 37. 提供有用的错误信息

 第8章 敏捷协作 38. 定期安排会面时间 39. 架构师必须写代码 40. 实行代码集体所有制 41. 成为指导者 42. 允许大家自己想办法 43. 准备好后再共享代码 44. 做代码复查 45. 及时通报进展与问题

 第9章 尾声：走向敏捷 9.1 只要一个新的习惯 9.2 拯救濒临失败的项目 9.3 引入敏捷：管理者指南 9.4 引入敏捷：程序员指南 9.5 结束了吗 附录A 资源 索引