第Ⅰ篇管理人力资源
第1章 在今天的某个地方，一个项目正在失败
问题的实质
高科技幻觉 

 第2章 做吉士汉堡，卖吉士汉堡 错误限额 管理：莽汉的定义 人员储备 一个稳定状态的项目就是死胡同 我们还没有时间来考虑这项工作 只有时间来做这项工作

 第3章 维也纳在等着你 使用西班牙人理论的管理 来自后方的一句话 世上没有加班这回事 工作狂 生产力：赢得战役和输掉战争 反复

 第4章 质量——如果时间许可 逃避优秀 质量是免费的，但 否决权

 第5章 重新研究帕金森定律 帕金森定律和牛顿定律 要是见过我说的那位， 你就不会这么说了 来自新南威尔士大学的一些数据 帕金森定律主题的变化

 第6章 苦杏仁苷 在睡觉时减肥 七个女妖 这就是管理 …… 第Ⅱ篇 办公环境 第7章 家具警察 第8章 朝九晚五无所为 第9章 在空间上省钱 第10章 脑力时间与体力时间 第11章 电话 第12章 把门带上 第13章 采取保护步骤

 第Ⅲ篇 适当人选 第14章 霍恩布洛尔因子 第15章 雇用一个变戏法的人 第16章 很高兴在这里 第17章 自愈系统

 第Ⅳ篇 培育高生产力团队 第18章 整体大于部分的总和 第19章 黑衣团队 第20章　团队自杀 第21章 一顿意大利通心粉晚宴 第22章 思想开放 第23章 促使团队形成的亲和力

 第Ⅴ篇 在这里工作应该很开心 第24章 混乱和秩序 第25章 “自由电子” 第26章 霍尔加·丹斯克

 第Ⅵ篇 《人件》续集 第27章 再访团队自杀 第28章 竞争 第29章 过程改进步骤 第30章 使变更成为可能 第31章 人力资本 第32章 公司的学习 第33章 管理上的最大罪行是…… 第34章 社区的形成 注释 参考文献

第一篇 必知必会的基础知识
第1章 英雄还看今朝——Android简介 20
1.1 群雄割据的手机市场   20
1.1.1 手机市场的两颗新星       20
1.1.2 手机操作系统的5大元老       21
1.2 Android的未来及特点 22
1.2.1 得中国市场者得天下       22
1.2.2 全新的概念带来全新的体验   22
1.3 Android开发环境的搭建    22
1.3.1 SDK的安装及环境配置   22
1.3.2 Eclipse集成开发环境的搭建   23
1.3.3 模拟器的创建和运行       24
1.4 第一个Android应用程序的开发       25
1.4.1 第一个Android程序 26
1.4.2 Android应用程序的调试 27
1.5 Android应用程序运行的内部机制    29
1.5.1 Android应用程序的项目结构 30
1.5.2 Android 应用程序的系统架构       31
1.5.3 Android 应用程序框架    32
1.5.4 Android 运行时       32
1.5.5 系统库       33
1.5.6 Linux内核 34
1.6 本章小结      34
第2章 数风流人物——当前流行游戏类型简介    35
2.1 AVG冒险游戏     35
2.1.1 游戏玩法   35
2.1.2 视觉效果   35
2.1.3 游戏设计   36
2.2 PZL益智类游戏   36
2.2.1 游戏玩法   36
2.2.2 视觉效果   37
2.2.3 游戏设计   37
2.3 ACT动作游戏      38
2.3.1 历代游戏介绍   38
2.3.2 未来动作游戏的发展       39
2.4 RPG角色扮演类游戏 40
2.4.1 历代游戏介绍   40
2.4.2 Android平台游戏移植     42
2.5 STG射击类游戏 43
2.5.1 游戏的分类       43
2.5.2 游戏的玩法       44
2.5.3 游戏设计   44
2.6 FPS第一人称视角射击游戏      44
2.6.1 游戏玩法   44
2.6.2 视觉效果   45
2.6.3 游戏设计   45
2.7 SLG策略游戏      46
2.7.1 游戏的玩法       46
2.7.2 视觉效果   46
2.7.3 游戏设计   47
2.8 SPT体育类游戏   47
2.8.1 游戏的玩法       47
2.8.2 视觉效果   47
2.8.3 游戏设计   47
2.9 本章小结      48
第3章 不积跬步，无以至千里—游戏开发基础知识    49
3.1 游戏中的声音      49
3.1.1 迅雷不及掩耳的即时音效       49
3.1.2 一个即时音效的例子       50
3.1.3 背景音乐播放技术   53
3.1.4 简单音乐播放器实现       55
3.2 手机中的数据库——SQLite       59
3.2.1 SQLite数据库简介   59
3.2.2 SQLite数据库的基本操作       60
3.2.3 SQLite操作数据库的简单应用       60
3.3 文件I/O 64
3.3.1 轻松访问SD卡 64
3.3.2 访问手机中的存储文件夹       67
3.3.3 读取assets中的文件 68
3.4 存储简单数据的利器——Preferences       70
3.4.1 Preferences简介       70
3.4.2 Preferences实现显示上次登录时间       70
3.5 SURFACEView在游戏中的使用       72
3.5.1 SurfaceView简单操作      72
3.5.2 简单动画场景的绘制       73
3.6 本章小结      78
第4章 千里之行，始于足下—3D开发基础知识 79
4.1 OpenGL ES 简介 79
4.1.1 师出名门的OpenGL ES   79
4.1.2 三角形组成的世界   80
4.1.3 第一个OpenGL ES三角形      82
4.2 不同的绘制方式   87
4.2.1 点和线的绘制   87
4.2.2 索引法绘制三角形   93
4.2.3 顶点法绘制三角形   101
4.3 不一样的投影，不一样的世界   103
4.3.1 正交投影   103
4.3.2 透视投影   104
4.3.3 两种投影的比较       105
4.3.4 近大远小的原理       112
4.4 本章小结      114
第5章 愿君多采撷，此物最相思——光照效果的开发       115
5.1 五彩缤纷的源泉——光源   115
5.1.1 光源的开启及关闭   115
5.1.2 设定光源的数量       116
5.1.3 定向光       117
5.1.4 定位光       118
5.2 光源的颜色   119
5.2.1 环境光       119
5.2.2 散射光       120
5.2.3 镜面反射光       121
5.3 材料反光属性的法官——法向量及材质   121
5.3.1 法向量的作用   121
5.3.2 光照的开启及关闭例子   122
5.3.3 物体的材质       128
5.3.4 设定光源数量的例子       128
5.4 两个物体发光的例子   132
5.4.1 定位光例子的实现   132
5.4.2 自发光物体加运动光源的实现       135
5.4.3 MySurfaceView.java详解 137
5.5 面法向量与点平均法向量   143
5.5.1 面法向量的应用       143
5.5.2 点平均法向量的应用       145
5.6 本章小结      146
第6章 为伊消得人憔悴—纹理映射       147
6.1 3D世界的花衣——纹理贴图     147
6.1.1 指定纹理   147
6.1.2 分配纹理坐标   148
6.1.3 纹理贴图三角形的实现   149
6.1.4 纹理贴图球体的构建       153
6.2 使用纹理映射构建地月模型      161
6.2.1 浩瀚星空中的地月系       161
6.2.2 地月系的案例讲解   162
6.3 纹理拉伸      170
6.3.1 纹理拉伸的原理与用途   170
6.3.2 纹理拉伸案例讲解   172
6.4 纹理过滤      175
6.4.1 最近点采样       175
6.4.2 线性纹理过滤   176
6.4.3 mipmap：多重细节层      176
6.5 视角的合理设置   177
6.5.1 不同视角的3D世界 177
6.5.2 合理视角案例讲解   178
6.6 本章小结      180
第7章 海阔凭鱼跃，天高任鸟飞—3D基本形状的构建      181
7.1   圆柱体 181
7.1.1 圆柱体的几何方程   181
7.1.2 圆柱体的OpenGL ES实现      182
7.2 圆锥体   190
7.2.1 圆锥体的几何方程   190
7.2.2 圆锥体的OpenGL ES实现      190
7.3 圆环      193
7.3.1 圆环的几何方程       193
7.3.2 圆环的OpenGL ES实现 193
7.4 抛物面   196
7.4.1 抛物面的几何方程   196
7.4.2 抛物面的OpenGL ES实现      197
7.5 双曲面   199
7.5.1 双曲面的几何方程   199
7.5.2 双曲面的OpenGL ES实现      200
7.6 螺旋面   202
7.6.1 螺旋面的几何方程   202
7.6.2 螺旋面的OpenGL ES实现      203
7.7 本章小结      205
第8章 执子之手，与子偕老——坐标变换    206
8.1 理解坐标变换      206
8.1.1 坐标变换的实质       206
8.1.2 重要的堆栈操作       207
8.2 缩放变换      208
8.2.1 缩放变换原理分析   208
8.2.2 OpenGL ES中的缩放变换实现       208
8.3 平移变换      211
8.3.1 平移变换理论概览   211
8.3.2 OpenGL ES中的平移变换实现       212
8.4 旋转变换      213
8.4.1 旋转变换原理概述   213
8.4.2 OpenGL ES中的旋转变换实现       214
8.5 复合变换的简单案例——地月系模型      215
8.6 用复合变换模拟现实世界   216
8.7 本章小结      218
第9章 孤帆远影碧空尽—摄像机与雾特效    219
9.1 摄像机   219
9.1.1 摄像机的简介   219
9.1.2 摄像机的设置   220
9.2 雾特效   221
9.2.1 雾特效的相关知识   221
9.2.2 雾特效核心代码       222
9.3 摄像机与雾特效实现沙漠中的金字塔      222
9.3.1 场景部件——四面体和太阳东升西落   223
9.3.2 场景部件——星空类       226
9.3.3 场景的创建       229
9.3.4 摄像机Up方向变换效果 232
9.4 本章小结      233
第10章 假作真时真亦假——混合 234
10.1 什么是混合 234
10.2 源因子和目标因子    235
10.2.1 源因子和目标因子的默认实现方式     235
10.2.2 预定义常量分析     235
10.2.3 常用的组合方式     236
10.2.4 启用混合 237
10.3 混合案例    237
10.3.1 一个混合的简单案例     237
10.3.2 带光晕和云层效果的地月系模型 241
10.3.3 滤光器中的世界     245
10.4 本章小结    250
第11章 蓦然回首，那人却在灯火阑珊处—3D高级技术    251
11.1 标志板 251
11.1.1 标志板技术概述     251
11.1.2 标志板的案例 252
11.2 飘扬的旗帜 254
11.2.1 旗帜飘动效果原理 254
11.2.2 飘扬旗帜案例讲解 255
11.3 山地的生成技术 257
11.3.1 灰度图地形技术概述     257
11.3.2 灰度图生成3D地形       258
11.3.3 地形场景效果的提升     261
11.4 镜像技术     263
11.4.1 镜像技术的简介     264
11.4.2 镜像技术的实现     265
11.4.3 镜像技术的提升     267
11.5 本章小结     268
第12章 心有灵犀一点通——传感器      269
12.1 传感器简介 269
12.1.1 磁场传感器简介     269
12.1.2 光传感器简介 269
12.1.3 距离传感器简介     270
12.1.4 加速度传感器简介 270
12.1.5 姿态传感器简介     271
12.1.6 SensorSimulator模拟器的配置     273
12.2 传感器的数据传输    276
12.2.1 加速传感器的数据传输 276
12.2.2 姿态传感器的数据传输 278
12.3 传感器实例——平衡球    279
12.4 本章小结    287
第13章 千锤万凿出深山——游戏中的数学与物理      288
13.1 必知必会的几何知识 288
13.1.1 三维笛卡儿坐标系 288
13.1.2 向量 288
13.1.3 加减法     290
13.1.4 向量的点积     291
13.1.5 向量的叉积     291
13.1.6 空间平面的确定     292
13.2 不可或缺的物理世界 293
13.2.1 重力系统 293
13.2.2 碰撞 298
13.2.3 完全弹性碰撞 299
13.2.4 带有能量损失的弹性碰撞     302
13.2.5 粒子系统 303
13.3 本章小结    311
第14章 山舞银蛇，原驰蜡象—AI基本理念 312
14.1 AI简介       312
14.1.1 什么是智能     312
14.1.2 什么是游戏AI 312
14.2 AI引擎的基本组成与设计       313
14.2.1 智能体     313
14.2.2 处理机与感知 314
14.2.3 导航 314
14.3 游戏AI中图的搜索   315
14.3.1 深度优先搜索 315
14.3.2 广度优先搜索 321
14.3.3 Dijkstra搜索    325
14.3.4 广度优先A算法的实现 329 14.3.5 Dijkstra A算法的实现   332
14.3.6 A与非A算法之间的比较   334
14.4 模糊逻辑    336
14.4.1 普通集合 336
14.4.2 模糊集合 337
14.4.3 模糊语言变量 339
14.4.4 模糊规则 339
14.5 本章小结    340
第15章 独上高楼，望尽天涯路——开发小秘籍 341
15.1 地图设计器 341
15.1.1 不可或缺的地图设计器 341
15.1.2 简单的地图设计器 341
15.2 多键技术    347
15.2.1 增加游戏可玩度的多键技术 347
15.2.2 多键技术的实例演示     348
15.3 虚拟键盘    350
15.4 查找表技术 351
15.5 状态机 352
15.6 AABB边界框     354
15.6.1 AABB的表达方法 355
15.6.2 计算AABB     355
15.6.3 AABB与边界球的比较 356
15.6.4 球与球的碰撞 357
15.6.5 两个AABB的碰撞 358
15.6.6 球与AABB的碰撞 361
15.7 穿透效应    363
15.8 拾取技术    367
15.8.1 拾取技术的原理     367
15.8.2 拾取技术的实现     369
15.9 天空盒与天空穹 377
15.9.1 天空盒的介绍 377
15.9.2 天空穹的介绍 380
15.10 本章小结   382
第二篇 案 例 实 战
第16章 体育类游戏—《疯狂投篮》      384
16.1 游戏的背景及功能概述    384
16.1.1 背景概述 384
16.1.2 功能简介 384
16.2 游戏的策划及准备工作    388
16.2.1 游戏的策划     388
16.2.2 Android平台下游戏的准备工作   388
16.3 游戏的架构 389
16.3.1 游戏中用到的主要技术 389
16.3.2 各类的简要介绍     389
16.3.3 游戏的框架简介     391
16.4 游戏公共类的设计与实现 393
16.4.1 主类BasketballActivity的实现      393
16.4.2 游戏常量类的介绍 396
16.5 游戏菜单界面类的设计与实现 398
16.5.1 游戏开始菜单的框架设计     398
16.5.2 游戏开始菜单的实现     399
16.5.3 游戏帮助、关于、加载及结束界面的设计与实现     402
16.6 游戏界面的设计与实现    402
16.6.1 游戏界面的框架设计     402
16.6.2 游戏界面的实现     404
16.7 游戏界面中主要场景的绘制及篮球运动 407
16.7.1 游戏中墙壁、地板、球和篮板等的绘制     407
16.7.2 篮板的整体绘制     409
16.7.3 篮球的运动实现     410
16.8 游戏界面的碰撞检测及物体拾取    413
16.8.1 篮球与篮框的碰撞检测 413
16.8.2 篮球与墙壁、地板和屋顶的碰撞检测 416
16.8.3 手机屏幕拾取技术 418
16.9 游戏的优化与改进    419
第17章 益智类游戏—《旋转积木》      421
17.1 游戏的背景及功能概述    421
17.1.1 背景概述 421
17.1.2 功能简介 421
17.2 游戏的策划及准备工作    424
17.2.1 游戏的策划     424
17.2.2 Android平台下游戏的准备工作   424
17.3 游戏的架构 425
17.3.1 游戏中用到的主要技术 425
17.3.2 各类的简要介绍     425
17.3.3 游戏的框架简介     427
17.4 地图设计器的开发    428
17.5 游戏公共类的设计与实现 431
17.5.1 主类MainActivity的实现      431
17.5.2 游戏常量类的介绍 434
17.6 游戏菜单界面类的设计与实现 437
17.6.1 游戏开始菜单的框架设计     438
17.6.2 游戏开始菜单的实现     439
17.6.3 游戏帮助、关于、设置及胜利界面的设计与实现     441
17.7 游戏界面的设计与实现    442
17.7.1 游戏界面的框架设计     442
17.7.2 游戏触控方法的实现     443
17.7.3 游戏界面的实现     445
17.7.4 生成纹理ID的方法       448
17.8 游戏界面中主要场景的绘制    449
17.8.1 游戏中背景、移表板、图标的绘制     449
17.8.2 地图的绘制     450
17.8.3 积木的绘制     451
17.9 游戏界面的动画效果 453
17.9.1 积木转动的动画效果     453
17.9.2 游戏失败、获胜的动画效果 457
17.10 游戏界面的碰撞检测      458
17.11 游戏的优化与改进   460
第18章 休闲类游戏—《摩天大楼》      461
18.1 游戏的背景及功能概述    461
18.1.1 背景概述 461
18.1.2 功能简介 461
18.2 游戏的策划及准备工作    465
18.2.1 游戏的策划     465
18.2.2 Android平台下游戏的准备工作   465
18.3 游戏的架构 466
18.3.1 游戏中用到的主要技术 466
18.3.2 各类的简要介绍     467
18.3.3 游戏的框架简介     468
18.4 游戏公共类的设计与实现 469
18.4.1 主类GL_Demo的实现   469
18.4.2 游戏常量类的介绍 474
18.5 游戏菜单界面类的设计与实现 475
18.5.1 游戏开始菜单的框架设计     475
18.5.2 游戏开始菜单的实现     476
18.5.3 游戏帮助、关于、设置、加载及胜利界面的设计与实现 481
18.6 游戏界面的设计与实现    481
18.6.1 游戏界面的框架设计     481
18.6.2 游戏界面的实现     483
18.7 游戏界面中主要场景的绘制    487
18.7.1 游戏中背景、地板、建筑块的绘制     487
18.7.2 树的绘制 487
18.8 游戏界面的碰撞检测 488
18.9 游戏的优化与改进    492
第19章 动作类游戏—《3D空战》 493
19.1 游戏的背景及功能概述    493
19.1.1 背景概述 493
19.1.2 功能简介 494
19.2 游戏的策划及准备工作    496
19.2.1 游戏的策划     496
19.2.2 Android平台下游戏的准备工作   497
19.3 游戏的架构 498
19.3.1 游戏中用到的主要技术 498
19.3.2 各类的简要介绍     498
19.3.3 游戏的框架简介     500
19.4 游戏公共类的设计与实现 502
19.4.1 主类GL_Demo的实现   502
19.4.2 游戏常量类的介绍 503
19.5 游戏菜单界面类的设计与实现 504
19.5.1 游戏菜单的框架设计     504
19.5.2 游戏菜单的实现     506
19.5.3 游戏帮助、关于、设置、加载及胜利界面的设计与实现 509
19.6 游戏界面的设计与实现    509
19.6.1 游戏界面的框架设计     509
19.6.2 游戏界面的实现     511
19.7 游戏界面中飞机的绘制    513
19.8 游戏中的运动线程和碰撞检测 515
19.9 游戏的优化与改进    525
第20章  桌面类游戏—《激情台球》      527
20.1 游戏的背景及功能概述    527
20.1.1 背景概述 527
20.1.2 功能简介 527
20.2 游戏的策划及准备工作    531
20.2.1 游戏的策划     531
20.2.2 Android平台下游戏的准备工作   532
20.3 游戏的架构 533
20.3.1 游戏中用到的主要技术 533
20.3.2 各类的简要介绍     533
20.3.3 游戏的框架简介     535
20.4 网络端的开发    536
20.4.1 服务器的简要介绍 536
20.4.2 服务器的代码介绍 537
20.4.3 客户端线程的代码介绍 542
20.5 游戏公共类的设计与实现 545
20.5.1 主类MyActivity的实现 545
20.5.2 游戏常量类的介绍 549
20.6 游戏菜单界面类的设计与实现 551
20.6.1 游戏开始菜单的框架设计     552
20.6.2 游戏菜单的动画实现     555
20.6.3 游戏帮助、关于、设置及胜利等界面的设计与实现 556
20.7 游戏界面的设计与实现    557
20.7.1 游戏界面的框架设计     557
20.7.2 游戏中onKeyDown方法的实现   558
20.7.3 游戏界面的实现     560
20.8 游戏界面中主要场景的绘制    563
20.8.1 仪表板、地板的绘制     563
20.8.2 台球桌的绘制 564
20.8.3 球的绘制 566
20.9 游戏中的碰撞检测    567
20.9.1 球与球台边角碰撞检测的原理     567
20.9.2 球与球碰撞检测的原理 569
20.9.3 球与球台边角碰撞检测的实现     570
20.9.4 球与球碰撞检测的实现 574
20.9.5 球运动线程的实现 576
20.10 游戏的优化与改进   578
第21章 射击类游戏—《抢滩登陆》      579
21.1 游戏的背景及功能概述    579
21.1.1 背景概述 579
21.1.2 功能简介 579
21.2 游戏的策划及准备工作    583
21.2.1 游戏的策划     583
21.2.2 Android平台下游戏的准备工作   583
21.3 游戏的架构 584
21.3.1 游戏中用到的主要技术 584
21.3.2 各类的简要介绍     585
21.3.3  游戏的框架简介     588
21.4 游戏公共类的设计与实现 589
21.4.1 主类Activity的实现      590
21.4.2 游戏常量类的介绍 594
21.5 游戏菜单界面类的设计与实现 598
21.5.1 游戏菜单界面的框架设计     598
21.5.2 游戏菜单界面的实现     600
21.5.3 游戏帮助、关于及结束界面的设计与实现 604
21.6 游戏界面的设计与实现    605
21.6.1 游戏界面的框架设计     605
21.6.2 游戏界面的实现     607
21.7 游戏界面中主要场景的绘制及实物运动 613
21.7.1 游戏中的绘制 613
21.7.2 灯塔的整体绘制     614
21.7.3 物体的运动实现     616
21.8 游戏中的碰撞检测    621
21.9 游戏的优化与改进    625
第22章 竞技类游戏—《乡村飙车》      627
22.1 游戏的背景及功能概述    627
22.1.1 背景概述 627
22.1.2 功能简介 627
22.2 游戏的策划及准备工作    631
22.2.1 游戏的策划     631
22.2.2 Android平台下游戏的准备工作   632
22.3 游戏的框架介绍 634
22.3.1 游戏中用到的主要技术 634
22.3.2 各类的简单介绍     635
22.3.3 游戏的框架介绍     638
22.4 游戏公共类的设计与实现 640
22.4.1 主类Activity_GL_Racing的实现 640
22.4.2 游戏常量类的介绍 645
22.5 游戏菜单类的设计与实现 649
22.5.1 游戏主菜单的设计与实现     650
22.5.2 游戏加载界面的设计与实现 651
22.5.3 游戏历史界面的设计与实现 656
22.5.4 游戏帮助、设置、关于、选择等界面的设计与实现 658
22.6 游戏界面的设计与实现    659
22.6.1 游戏界面的框架设计     659
22.6.2 游戏界面的实现     661
22.6.3 传感器应用与多点触控技术 665
22.7 游戏界面中主要场景的绘制    666
22.7.1 游戏界面中场景的分层绘制及渲染优化     667
22.7.2 游戏界面中地图赛道的生成与绘制     669
22.7.3 场景部件的绘制     671
22.7.4 游戏中汽车的加载 673
22.7.5 游戏中树的绘制技术     677
22.7.6 场景中游戏辅助部件的绘制 679
22.8 游戏中的碰撞检测及行驶圈数判定 681
22.8.1 汽车与公路部件的碰撞检测 683
22.8.2 汽车行驶圈数判定 685
22.8.3 汽车与可碰撞部件的碰撞检测及其动画实现     686
22.9 游戏的优化与改进    688

第1章 初识Hadoop
数据！数据！
数据存储与分析
与其他系统相比
关系型数据库管理系统
网格计算
志愿计算
Hadoop 发展简史
Apache Hadoop和Hadoop生态圈 

 第2章 关于MapReduce 一个气象数据集 数据的格式 使用Unix工具进行数据分析 使用Hadoop分析数据 map阶段和reduce阶段 横向扩展 合并函数 运行一个分布式的MapReduce作业 Hadoop的Streaming Ruby版本 Python版本 Hadoop Pipes 编译运行

 第3章 Hadoop分布式文件系统 HDFS的设计 HDFS的概念 数据块 namenode和datanode 命令行接口 基本文件系统操作 Hadoop文件系统 接口 Java接口 从Hadoop URL中读取数据 通过FileSystem API读取数据 写入数据 目录 查询文件系统 删除数据 数据流 文件读取剖析 文件写入剖析 一致模型 通过 distcp并行拷贝 保持 HDFS 集群的均衡 Hadoop的归档文件 使用Hadoop归档文件 不足

 第4章 Hadoop I/O 数据完整性 HDFS的数据完整性 LocalFileSystem ChecksumFileSystem 压缩 codec 压缩和输入切分 在MapReduce中使用压缩 序列化 Writable接口 Writable类 实现定制的Writable类型 序列化框架 Avro 依据文件的数据结构 写入SequenceFile MapFile

 第5章 MapReduce应用开发 配置API 合并多个源文件 可变的扩展 配置开发环境 配置管理 辅助类GenericOptionsParser，Tool和ToolRunner 编写单元测试 mapper reducer 本地运行测试数据 在本地作业运行器上运行作业 测试驱动程序 在集群上运行 打包 启动作业 MapReduce的Web界面 获取结果 作业调试 使用远程调试器 作业调优 分析任务 MapReduce的工作流 将问题分解成MapReduce作业 运行独立的作业

 第6章 MapReduce的工作机制 剖析MapReduce作业运行机制 作业的提交 作业的初始化 任务的分配 任务的执行 进度和状态的更新 作业的完成 失败 任务失败 tasktracker失败 jobtracker失败 作业的调度 Fair Scheduler Capacity Scheduler shuffle和排序 map端 reduce端 配置的调优 任务的执行 推测式执行 重用JVM 跳过坏记录 任务执行环境

 第7章 MapReduce的类型与格式 MapReduce的类型 默认的MapReduce作业 输入格式 输入分片与记录 文本输入 二进制输入 多种输入 数据库输入(和输出) 输出格式 文本输出 二进制输出 多个输出 延迟输出 数据库输出

 第8章 MapReduce的特性 计数器 内置计数器 用户定义的Java计数器 用户定义的Streaming计数器 排序 准备 部分排序 总排序 二次排序 联接 map端联接 reduce端联接 边数据分布 利用JobConf来配置作业 分布式缓存 MapReduce库类

 第9章 构建Hadoop集群 集群规范 网络拓扑 集群的构建和安装 安装Java 创建Hadoop用户 安装Hadoop 测试安装 SSH配置 Hadoop配置 配置管理 环境设置 Hadoop守护进程的关键属性 Hadoop守护进程的地址和端口 Hadoop的其他属性 创建用户帐号 安全性 Kerberos和Hadoop 委托令牌 其他安全性改进 利用基准测试程序测试Hadoop集群 Hadoop基准测试程序 用户的作业 云上的Hadoop Amazon EC2上的Hadoop

 第10章 管理Hadoop HDFS 永久性数据结构 安全模式 日志审计 工具 监控 日志 度量 Java管理扩展(JMX) 维护 日常管理过程 委任节点和解除节点 升级

 第11章 Pig简介 安装与运行Pig 执行类型 运行Pig程序 Grunt Pig Latin编辑器 示例 生成示例 与数据库比较 PigLatin 结构 语句 表达式 类型 模式 函数 用户自定义函数 过滤UDF 计算UDF 加载UDF 数据处理操作 加载和存储数据 过滤数据 分组与连接数据 对数据进行排序 组合和分割数据 Pig实战 并行处理 参数代换

 第12章 Hive 第13章 HBase 第14章 ZooKeeper 第15章 开源工具 第16章 实例分析

第1章 换个角度玩儿Excel
第1节 两招让你脱胎换骨
搞定源数据，不背菜单也能玩
聚焦汇总表，不用做来只用“变”
第2节 天下只有一张表
一个模板打天下
我的文件比你少
格式标准都会填
第3节 人人都能成高手 

 第2章 十宗罪进行时 第1节 表格中的“父子关系” 第2节 错误的“正确”做法毁了你的表格 换个地方写标题 顺着流程排字段 拆了隔断，连成一片 合计请等下回分解 化繁为简，去掉多余表头 千万别合并，单元格有一说一 缺啥别缺源数据 分手容易牵手难 别把Excel当Word 分类汇总不是手工活儿

 第3章 Excel超越你的想象 第1节 三表概念——难道Excel也是系统？ Excel和系统哪里不一样？ 如此解读默认三张表 第2节 左手企业系统，右手Excel 第3节 Excel决定企业存亡

 第4章 玩转透视表，工作的滋味甜过初恋 第1节 数据透视表初体验 数据透视表在哪里 数据透视表能做什么 数据透视表怎么做 第2节 早知如此，何必当初 “拖”出合计行 “变”出汇总表 拆分源数据的“偏方” 第3节 汇总报表，拖拽有“理” “躺着”不如“站着” 按“天”汇总要不得 不超过两个列字段 汇总跟着文字走 字段主次要分明 第4节 巧妙组合日期 日期字段怎么放 日期很特殊 正确的日期才特殊 第5节 追根溯“源” 第6节 关联数据齐步走 “！” 预约源数据 新建明细数据≠源数据 找得到的工具栏 关键时刻要备份 第7节 你还应该知道这几招 去掉数据的“分身” 汇总数排排站 可以复制的汇总表 第8节 找到初恋的感觉了吗？

 第5章 揭秘天下第一表的神奇“配方” 第1节 学Excel不是走单行线 第2节 五味良药“配”出天下第一表 第一味“顾全局”：背景确认 第二味“知目的”：明确需求 第三味“勾轮廓”：字段设定 第四味“定结构”：流程解析 第五味“细打磨”：表格装修

 第6章 图表，怎么简单怎么做 第1节 别把Excel中的图表当PPT做 第2节 心动不如行动 第3节 无外乎三种图表 俯视大饼 端正柱子 装“点”折线 第4节 一招美化你的图表 第5节 概念图——向左走向右走 第6节 让图表动一下

 第7章 埋头做表别忘了抬头看路 第1节 赢得同事的认可 建立“高品质”形象 好的经验书面总结 保管好报表 善于分享 第2节 赢得老板的认可 比吩咐的多做一点 汇报进度并按时完成 邮件就是你的脸 给老板做多选题 我真的不懂VBA 致谢

第1章 引言 1
1.1 谁需要这本书 2
1.2 本书内容 2
1.2.1 本书结构 3
1.2.2 反模式分解 4
1.3 本书未涉及的内容 4
1.4 规约 5
1.5 范例数据库 6
1.6 致谢 8 

 第一部分 逻辑型数据库设计反模式

 第2章 乱穿马路 10 2.1 目标:存储多值属性 11 2.2 反模式:格式化的逗号分隔列表 11 2.2.1 查询指定账号的产品 11 2.2.2 查询指定产品的账号 12 2.2.3 执行聚合查询 12 2.2.4 更新指定产品的账号 12 2.2.5 验证产品ID 13 2.2.6 选择合适的分隔符 13 2.2.7 列表长度限制 13 2.3 如何识别反模式 14 2.4 合理使用反模式 14 2.5 解决方案:创建一张交叉表 14 2.5.1 通过账号查询产品和反过来查询 15 2.5.2 执行聚合查询 16 2.5.3 更新指定产品的相关联系人 16 2.5.4 验证产品ID 16 2.5.5 选择分隔符 17 2.5.6 列表长度限制 17 2.5.7 其他使用交叉表的好处 17

 第3章 单纯的树 18 3.1 目标:分层存储与查询 18 3.2 反模式:总是依赖父节点 19 3.2.1 使用邻接表查询树 20 3.2.2 使用邻接表维护树 21 3.3 如何识别反模式 22 3.4 合理使用反模式 23 3.5 解决方案:使用其他树模型 24 3.5.1 路径枚举 24 3.5.2 嵌套集 26 3.5.3 闭包表 29 3.5.4 你该使用哪种设计 33

 第4章 需要ID 34 4.1 目标:建立主键规范 35 4.2 反模式:以不变应万变 36 4.2.1 冗余键值 36 4.2.2 允许重复项 37 4.2.3 意义不明的关键字 38 4.2.4 使用USING关键字 38 4.2.5 使用组合键之难 39 4.3 如何识别反模式 39 4.4 合理使用反模式 40 4.5 解决方案:裁剪设计 40 4.5.1 直截了当地描述设计 40 4.5.2 打破传统 41 4.5.3 拥抱自然键和组合键 41

 第5章 不用钥匙的入口 43 5.1 目标:简化数据库架构 43 5.2 反模式:无视约束 44 5.2.1 假设无瑕代码 44 5.2.2 检查错误 45 5.2.3 “那不是我的错!” 45 5.2.4 进退维谷 46 5.3 如何识别反模式 46 5.4 合理使用反模式 47 5.5 解决方案:声明约束 47 5.5.1 支持同步修改 48 5.5.2 系统开销过度？不见得 48

 第6章 实体-属性-值 50 6.1 目标:支持可变的属性 50 6.2 反模式:使用泛型属性表 51 6.2.1 查询属性 53 6.2.2 支持数据完整性 53 6.2.3 无法声明强制属性 53 6.2.4 无法使用SQL的数据类型 53 6.2.5 无法确保引用完整性 54 6.2.6 无法配置属性名 55 6.2.7 重组列 55 6.3 如何识别反模式 56 6.4 合理使用反模式 56 6.5 解决方案:模型化子类型 57 6.5.1 单表继承 57 6.5.2 实体表继承 58 6.5.3 类表继承 60 6.5.4 半结构化数据模型 61 6.5.5 后处理 61

 第7章 多态关联 64 7.1 目标:引用多个父表 65 7.2 反模式:使用双用途外键 65 7.2.1 定义多态关联 65 7.2.2 使用多态关联进行查询 66 7.2.3 非面向对象范例 67 7.3 如何识别反模式 68 7.4 合理使用反模式 69 7.5 解决方案:让关系变得简单 69 7.5.1 反向引用 69 7.5.2 创建交叉表 69 7.5.3 设立交通灯 70 7.5.4 双向查找 71 7.5.5 合并跑道 71 7.5.6 创建共用的超级表 72

 第8章 多列属性 75 8.1 目标:存储多值属性 75 8.2 反模式:创建多个列 76 8.2.1 查询数据 76 8.2.2 添加及删除值 77 8.2.3 确保唯一性 78 8.2.4 处理不断增长的值集 78 8.3 如何识别反模式 79 8.4 合理使用反模式 79 8.5 解决方案:创建从属表 80

 第9章 元数据分裂 82 9.1 目标:支持可扩展性 83 9.2 反模式:克隆表与克隆列 83 9.2.1 不断产生的新表 84 9.2.2 管理数据完整性 84 9.2.3 同步数据 85 9.2.4 确保唯一性 85 9.2.5 跨表查询 86 9.2.6 同步元数据 86 9.2.7 管理引用完整性 86 9.2.8 标识元数据分裂列 87 9.3 如何识别反模式 87 9.4 合理使用反模式 88 9.5 解决方案:分区及标准化 89 9.5.1 使用水平分区 89 9.5.2 使用垂直分区 89 9.5.3 解决元数据分裂列 91

 第二部分 物理数据库设计反模式

 第10章 取整错误 94 10.1 目标:使用小数取代整数 94 10.2 反模式:使用FLOAT类型 95 10.2.1 舍入的必要性 95 10.2.2 在SQL中使用FLOAT 96 10.3 如何识别反模式 98 10.4 合理使用反模式 98 10.5 解决方案:使用NUMERIC类型 98

 第11章 每日新花样 100 11.1 目标:限定列的有效值 100 11.2 反模式:在列定义上指定可选值 101 11.2.1 中间的是哪个 102 11.2.2 添加新口味 103 11.2.3 老的口味永不消失 103 11.2.4 可移植性低下 103 11.3 如何识别反模式 104 11.4 合理使用反模式 104 11.5 解决方案:在数据中指定值 104 11.5.1 查询候选值集合 105 11.5.2 更新检查表中的值 105 11.5.3 支持废弃数据 105 11.5.4 良好的可移植性 106

 第12章 幽灵文件 107 12.1 目标:存储图片或其他多媒体大文件 107 12.2 反模式:假设你必须使用文件系统 108 12.2.1 文件不支持DELETE 109 12.2.2 文件不支持事务隔离 109 12.2.3 文件不支持回滚操作 109 12.2.4 文件不支持数据库备份工具 110 12.2.5 文件不支持SQL的访问权限设置 110 12.2.6 文件不是SQL数据类型 110 12.3 如何识别反模式 111 12.4 合理使用反模式 111 12.5 解决方案:在需要时使用BLOB 类型 112

 第13章 乱用索引 114 13.1 目标:优化性能 115 13.2 反模式:无规划地使用索引 115 13.2.1 无索引 115 13.2.2 索引过多 116 13.2.3 索引也无能为力 117 13.3 如何识别反模式 118 13.4 合理使用反模式 119 13.5 解决方案:MENTOR你的索引 119 13.5.1 测量 120 13.5.2 解释 121 13.5.3 挑选 122 13.5.4 测试 123 13.5.5 优化 123 13.5.6 重建 123

 第三部分 查询反模式

 第14章 对未知的恐惧 126 14.1 目标:辨别悬空值 127 14.2 反模式:将NULL作为普通的值,反之亦然 127 14.2.1 在表达式中使用NULL 127 14.2.2 搜索允许为空的列 128 14.2.3 在查询参数中使用NULL 128 14.2.4 避免上述问题 128 14.3 如何识别反模式 130 14.4 合理使用反模式 130 14.5 解决方案:将NULL视为特殊值 131 14.5.1 在标量表达式中使用NULL 131 14.5.2 在布尔表达式中使用NULL 132 14.5.3 检索NULL值 132 14.5.4 声明NOT NULL的列 133 14.5.5 动态默认值 134

 第15章 模棱两可的分组 135 15.1 目标:获取每组的最大值 135 15.2 反模式:引用非分组列 136 15.2.1 单值规则 136 15.2.2 我想要的查询 137 15.3 如何识别反模式 138 15.4 合理使用反模式 139 15.5 解决方案:无歧义地使用列 140 15.5.1 只查询功能依赖的列 140 15.5.2 使用关联子查询 140 15.5.3 使用衍生表 140 15.5.4 使用JOIN 141 15.5.5 对额外的列使用聚合函数 142 15.5.6 连接同组所有值 142

 第16章 随机选择 144 16.1 目标:获取样本记录 144 16.2 反模式:随机排序 145 16.3 如何识别反模式 146 16.4 合理使用反模式 146 16.5 解决方案:没有具体的顺序 146 16.5.1 从1到最大值之间随机选择 146 16.5.2 选择下一个最大值 147 16.5.3 获取所有的键值,随机选择一个 147 16.5.4 使用偏移量选择随机行 148 16.5.5 专有解决方案 149

 第17章 可怜人的搜索引擎 150 17.1 目标:全文搜索 150 17.2 反模式:模式匹配断言 151 17.3 如何识别反模式 152 17.4 合理使用反模式 152 17.5 解决方案:使用正确的工具 152 17.5.1 数据库扩展 153 17.5.2 第三方搜索引擎 157

 第18章 意大利面条式查询 162 18.1 目标:减少SQL查询数量 162 18.2 反模式:使用一步操作解决复杂问题 163 18.2.1 副作用 163 18.2.2 那好像还不够…… 164 18.3 如何识别反模式 165 18.4 合理使用反模式 165 18.5 解决方案:分而治之 166 18.5.1 一步一个脚印 166 18.5.2 寻找UNION标记 167 18.5.3 解决老板的问题 167 18.5.4 使用SQL自动生成SQL 168

 第19章 隐式的列 170 19.1 目标:减少输入 171 19.2 反模式:捷径会让你迷失方向 171 19.2.1 破坏代码重构 171 19.2.2 隐藏的开销 172 19.2.3 你请求,你获得 172 19.3 如何识别反模式 173 19.4 合理使用反模式 173 19.5 解决方案:明确列出列名 174 19.5.1 预防错误 174 19.5.2 你不需要它 175 19.5.3 无论如何你都需要放弃使用通配符 175

 第四部分 应用程序开发反模式

 第20章 明文密码 178 20.1 目标:恢复或重置密码 178 20.2 反模式:使用明文存储密码 179 20.2.1 存储密码 179 20.2.2 验证密码 180 20.2.3 在E-mail中发送密码 180 20.3 如何识别反模式 181 20.4 合理使用反模式 181 20.5 解决方案:先哈希,后存储 182 20.5.1 理解哈希函数 182 20.5.2 在SQL中使用哈希 183 20.5.3 给哈希加料 183 20.5.4 在SQL中隐藏密码 185 20.5.5 重置密码,而非恢复密码 186

 第21章 SQL注入 188 21.1 目标:编写SQL动态查询 189 21.2 反模式:将未经验证的输入作为代码执行 189 21.2.1 意外无处不在 190 21.2.2 对Web安全的严重威胁 190 21.2.3 寻找治愈良方 191 21.3 如何识别反模式 195 21.4 合理使用反模式 196 21.5 解决方案:不信任任何人 196 21.5.1 过滤输入内容 196 21.5.2 参数化动态内容 197 21.5.3 给动态输入的值加引号 197 21.5.4 将用户与代码隔离 198 21.5.5 找个可靠的人来帮你审查代码 200

 第22章 伪键洁癖 202 22.1 目标:整理数据 202 22.2 反模式:填充角落 203 22.2.1 不按照顺序分配编号 203 22.2.2 为现有行重新编号 204 22.2.3 制造数据差异 204 22.3 如何识别反模式 205 22.4 合理使用反模式 205 22.5 解决方案:克服心里障碍 205 22.5.1 定义行号 205 22.5.2 使用GUID 206 22.5.3 最主要的问题 207

 第23章 非礼勿视 209 23.1 目标:写更少的代码 210 23.2 反模式:无米之炊 210 23.2.1 没有诊断的诊断 210 23.2.2 字里行间 211 23.3 如何识别反模式 212 23.4 合理使用反模式 213 23.5 解决方案:优雅地从错误中恢复 213 23.5.1 保持节奏 213 23.5.2 回溯你的脚步 214

 第24章 外交豁免权 215 24.1 目标:采用最佳实践 215 24.2 反模式:将SQL视为二等公民 216 24.3 如何识别反模式 216 24.4 合理使用反模式 217 24.5 解决方案:建立一个质量至上的文化 217 24.5.1 陈列A:编写文档 218 24.5.2 寻找证据:源代码版本控制 220 24.5.3 举证:测试 222 24.5.4 例证:同时处理多个分支 223

 第25章 魔豆 225 25.1 目标:简化MVC的模型 226 25.2 反模式:模型仅仅是活动记录 227 25.2.1 活动记录模式连接程序模型和数据库结构 228 25.2.2 活动记录模式暴露了CRUD系列函数 228 25.2.3 活动记录模式支持弱域模型 229 25.2.4 魔豆难以进行单元测试 231 25.3 如何识别反模式 232 25.4 合理使用反模式 232 25.5 解决方案:模型包含活动记录 232 25.5.1 领会模型的意义 233 25.5.2 将领域模型应用到实际工作中 234 25.5.3 测试简单对象 236 25.5.4 回到地球 237

 第五部分 附录

 附录A 规范化规则 240 附录B 参考书目 252

前言
第一部分 准备工作
第1章 熟悉工作环境和相关工具 / 2
1.1 调试工具Microsoft Visual C++ 6.0和OllyDBG / 2
1.2 反汇编静态分析工具IDA / 5
1.3 反汇编引擎的工作原理 / 11
1.4 本章小结 / 16
第二部分 C++反汇编揭秘
第2章 基本数据类型的表现形式 / 18
2.1 整数类型 / 18
2.1.1 无符号整数 / 18
2.1.2 有符号整数 / 18
2.2 浮点数类型 / 20
2.2.1 浮点数的编码方式 / 21
2.2.2 基本的浮点数指令 / 23
2.3 字符和字符串 / 26
2.3.1 字符的编码 / 27
2.3.2 字符串的存储方式 / 28
2.4 布尔类型 / 29
2.5 地址、指针和引用 / 29
2.5.1 指针和地址的区别 / 30
2.5.2 各类型指针的工作方式 / 31
2.5.3 引用 / 34
2.6 常量 / 35
2.6.1 常量的定义 / 36
2.6.2 #define和const的区别 / 37
2.7 本章小结 / 38
第3章 认识启动函数，找到用户入口 / 40
3.1 程序的真正入口 / 40
3.2 了解VC++ 6.0的启动函数 / 40
3.3 main函数的识别 / 44
3.4 本章小结 / 46
第4章 观察各种表达式的求值过程 / 47
4.1 算术运算和赋值 / 47
4.1.1 各种算术运算的工作形式 / 47
4.1.2 算术结果溢出 / 82
4.1.3 自增和自减 / 83
4.2 关系运算和逻辑运算 / 85
4.2.1 关系运算和条件跳转的对应 / 85
4.2.2 表达式短路 / 86
4.2.3 条件表达式 / 88
4.3 位运算 / 92
4.4 编译器使用的优化技巧 / 94
4.4.1 流水线优化规则 / 97
4.4.2 分支优化规则 / 101
4.4.3 高速缓存（cache）优化规则 / 101
4.5 一次算法逆向之旅 / 102
4.6 本章小结 / 109
第5章 流程控制语句的识别 / 110
5.1 if语句 / 110
5.2 if…else…语句 / 112
5.3 用if构成的多分支流程 / 115
5.4 switch的真相 / 119
5.5 难以构成跳转表的switch / 128
5.6 降低判定树的高度 / 133
5.7 do/while/for的比较 / 137
5.8 编译器对循环结构的优化 / 143
5.9 本章小结 / 148
第6章 函数的工作原理 / 149
6.1 栈帧的形成和关闭 / 149
6.2 各种调用方式的考察 / 152
6.3 使用ebp或esp寻址 / 155
6.4 函数的参数 / 158
6.5 函数的返回值 / 160
6.6 回顾 / 163
6.7 本章小结 / 165
第7章 变量在内存中的位置和访问方式 / 166
7.1 全局变量和局部变量的区别 / 166
7.2 局部静态变量的工作方式 / 169
7.3 堆变量 / 173
7.4 本章小结 / 177
第8章 数组和指针的寻址 / 178
8.1 数组在函数内 / 178
8.2 数组作为参数 / 181
8.3 数组作为返回值 / 185
8.4 下标寻址和指针寻址 / 189
8.5 多维数组 / 193
8.6 存放指针类型数据的数组 / 199
8.7 指向数组的指针变量 / 201
8.8 函数指针 / 204
8.9 本章小结 / 206
第9章 结构体和类 / 207
9.1 对象的内存布局 / 207
9.2 this指针 / 212
9.3 静态数据成员 / 217
9.4 对象作为函数参数 / 219
9.5 对象作为返回值 / 226
9.6 本章小结 / 231
第10章 关于构造函数和析构函数 / 233
10.1 构造函数的出现时机 / 233
10.2 每个对象都有默认的构造函数吗 / 243
10.3 析构函数的出现时机 / 245
10.4 本章小结 / 254
第11章 关于虚函数 / 256
11.1 虚函数的机制 / 256
11.2 虚函数的识别 / 261
11.3 本章小结 / 268
第12章 从内存角度看继承和多重继承 / 269
12.1 识别类和类之间的关系 / 270
12.2 多重继承   / 292
12.3 虚基类 / 298
12.4 菱形继承 / 299
12.5 本章小结 / 307
第13章 异常处理 / 308
13.1 异常处理的相关知识 / 308
13.2 异常类型为基本数据类型的处理流程 / 314
13.3 异常类型为对象的处理流程 / 323
13.4 识别异常处理 / 329
13.5 本章小结 / 341
第三部分 逆向分析技术应用
第14章 PEiD的工作原理分析 / 344
14.1 开发环境的识别 / 344
14.2 开发环境的伪造 / 353
14.3 本章小结 / 356
第15章 “熊猫烧香”病毒逆向分析 / 357
15.1 调试环境配置 / 357
15.2 病毒程序初步分析 / 358
15.3 “熊猫烧香”的启动过程分析 / 360
15.4 “熊猫烧香”的自我保护分析 / 366
15.5 “熊猫烧香”的感染过程分析 / 369
15.6 本章小结 / 379
第16章 调试器OllyDBG的工作原理分析 / 380
16.1 INT3断点 / 380
16.2 内存断点 / 385
16.3 硬件断点 / 390
16.4 异常处理机制 / 396
16.5 加载调试程序 / 402
16.6 本章小结 / 406
第17章 反汇编代码的重建与编译 / 407
17.1 重建反汇编代码 / 407
17.2 编译重建后的反汇编代码 / 410
17.3 本章小结 / 411
参考文献 / 412

第一部分 Hadoop——一种分布式编程框架
第1章 Hadoop简介 2
1.1 为什么写《Hadoop 实战》 3
1.2 什么是Hadoop 3
1.3 了解分布式系统和Hadoop 4
1.4 比较SQL数据库和Hadoop 5
1.5 理解MapReduce 6
1.5.1 动手扩展一个简单程序 7
1.5.2 相同程序在MapReduce中的扩展 9
1.6 用Hadoop统计单词——运行第一个程序 11
1.7 Hadoop历史 15
1.8 小结 16
1.9 资源 16 

 第2章 初识Hadoop 17 2.1 Hadoop的构造模块 17 2.1.1 NameNode 17 2.1.2 DataNode 18 2.1.3 Secondary NameNode 19 2.1.4 JobTracker 19 2.1.5 TaskTracker 19 2.2 为Hadoop集群安装SSH 21 2.2.1 定义一个公共账号 21 2.2.2 验证SSH安装 21 2.2.3 生成SSH密钥对 21 2.2.4 将公钥分布并登录验证 22 2.3 运行Hadoop 22 2.3.1 本地(单机)模式 23 2.3.2 伪分布模式 24 2.3.3 全分布模式 25 2.4 基于Web的集群用户界面 28 2.5 小结 30

 第3章 Hadoop组件 31 3.1 HDFS文件操作 31 3.1.1 基本文件命令 32 3.1.2 编程读写HDFS 35 3.2 剖析MapReduce程序 37 3.2.1 Hadoop数据类型 39 3.2.2 Mapper 40 3.2.3 Reducer 41 3.2.4 Partitioner：重定向Mapper输出 41 3.2.5 Combiner：本地reduce 43 3.2.6 预定义mapper和Reducer类的单词计数 43 3.3 读和写 43 3.3.1 InputFormat 44 3.3.2 OutputFormat 49 3.4 小结 50

 第二部分 实战

 第4章 编写MapReduce基础程序 52 4.1 获得专利数据集 52 4.1.1 专利引用数据 53 4.1.2 专利描述数据 54 4.2 构建MapReduce程序的基础模板 55 4.3 计数 60 4.4 适应Hadoop API的改变 64 4.5 Hadoop的Streaming 67 4.5.1 通过Unix命令使用Streaming 68 4.5.2 通过脚本使用Streaming 69 4.5.3 用Streaming处理键/值对 72 4.5.4 通过Aggregate包使用Streaming 75 4.6 使用combiner提升性能 80 4.7 温故知新 83 4.8 小结 84 4.9 更多资源 84

 第5章 高阶MapReduce 85 5.1 链接MapReduce作业 85 5.1.1 顺序链接MapReduce作业 85 5.1.2 具有复杂依赖的MapReduce链接 86 5.1.3 预处理和后处理阶段的链接 86 5.2 联结不同来源的数据 89 5.2.1 Reduce侧的联结 90 5.2.2 基于DistributedCache的复制联结 98 5.2.3 半联结：map侧过滤后在reduce侧联结 101 5.3 创建一个Bloom filter 102 5.3.1 Bloom filter做了什么 102 5.3.2 实现一个Bloom filter 104 5.3.3 Hadoop 0.20以上版本的Bloom filter 110 5.4 温故知新 110 5.5 小结 111 5.6 更多资源 112

 第6章 编程实践 113 6.1 开发MapReduce程序 113 6.1.1 本地模式 114 6.1.2 伪分布模式 118 6.2 生产集群上的监视和调试 123 6.2.1 计数器 123 6.2.2 跳过坏记录 125 6.2.3 用IsolationRunner重新运行出错的任务 128 6.3 性能调优 129 6.3.1 通过combiner来减少网络流量 129 6.3.2 减少输入数据量 129 6.3.3 使用压缩 129 6.3.4 重用JVM 132 6.3.5 根据猜测执行来运行 132 6.3.6 代码重构与算法重写 133 6.4 小结 134

 第7章 细则手册 135 7.1 向任务传递作业定制的参数 135 7.2 探查任务特定信息 137 7.3 划分为多个输出文件 138 7.4 以数据库作为输入输出 143 7.5 保持输出的顺序 145 7.6 小结 146

 第8章 管理Hadoop 147 8.1 为实际应用设置特定参数值 147 8.2 系统体检 149 8.3 权限设置 151 8.4 配额管理 151 8.5 启用回收站 152 8.6 删减DataNode 152 8.7 增加DataNode 153 8.8 管理NameNode和SNN 153 8.9 恢复失效的NameNode 155 8.10 感知网络布局和机架的设计 156 8.11 多用户作业的调度 157 8.11.1 多个JobTracker 158 8.11.2 公平调度器 158 8.12 小结 160

 第三部分 Hadoop也疯狂

 第9章 在云上运行Hadoop 162 9.1 Amazon Web Services简介 162 9.2 安装AWS 163 9.2.1 获得AWS身份认证凭据 164 9.2.2 获得命令行工具 166 9.2.3 准备SSH密钥对 168 9.3 在EC2上安装Hadoop 169 9.3.1 配置安全参数 169 9.3.2 配置集群类型 169 9.4 在EC2上运行MapReduce程序 171 9.4.1 将代码转移到Hadoop集群上 171 9.4.2 访问Hadoop集群上的数据 172 9.5 清空和关闭EC2实例 175 9.6 Amazon Elastic MapReduce和其他AWS服务 176 9.6.1 Amazon Elastic MapReduce 176 9.6.2 AWS导入/导出 177 9.7 小结 177

 第10章 用Pig编程 178 10.1 像Pig一样思考 178 10.1.1 数据流语言 179 10.1.2 数据类型 179 10.1.3 用户定义函数 179 10.2 安装Pig 179 10.3 运行Pig 180 10.4 通过Grunt学习Pig Latin 182 10.5 谈谈Pig Latin 186 10.5.1 数据类型和schema 186 10.5.2 表达式和函数 187 10.5.3 关系型运算符 189 10.5.4 执行优化 196 10.6 用户定义函数 196 10.6.1 使用UDF 196 10.6.2 编写UDF 197 10.7 脚本 199 10.7.1 注释 199 10.7.2 参数替换 200 10.7.3 多查询执行 201 10.8 Pig实战——计算相似专利的例子 201 10.9 小结 206

 第11章 Hive及Hadoop群 207 11.1 Hive 207 11.1.1 安装与配置Hive 208 11.1.2 查询的示例 210 11.1.3 深入HiveQL 213 11.1.4 Hive小结 221 11.2 其他Hadoop相关的部分 221 11.2.1 HBase 221 11.2.2 ZooKeeper 221 11.2.3 Cascading 221 11.2.4 Cloudera 222 11.2.5 Katta 222 11.2.6 CloudBase 222 11.2.7 Aster Data和Greenplum 222 11.2.8 Hama和Mahout 223 11.2.9 search-hadoop.com 223 11.3 小结 223

 第12章 案例研究 224 12.1 转换《纽约时报》1100万个库存图片文档 224 12.2 挖掘中国移动的数据 225 12.3 在StumbleUpon推荐最佳网站 229 12.3.1 分布式StumbleUpon的开端 230 12.3.2 HBase和StumbleUpon 230 12.3.3 StumbleUpon上的更多Hadoop应用 236 12.4 搭建面向企业查询的分析系统——IBM的ES2项目 238 12.4.1 ES2系统结构 240 12.4.2 ES2爬虫 241 12.4.3 ES2分析 242 12.4.4 小结 249 12.4.5 参考文献 250

 附录A HDFS文件命令 251

前言
鸣谢
核对表目录
表目录
图目录
第1部分 打好基础
第1章 欢迎进入软件构建的世界
1.1什么是软件构建
1.2软件构建为何如此重要
1.3如何阅读本书
第2章 用隐喻来更充分地理解软件开发
2.1隐喻的重要性
2.2如何使用软件隐喻
2.3常见的软件隐喻
第3章 三思而后行：前期准备
3.1前期准备的重要性
3.2辨明你所从事的软件的类型
3.3 问题定义的先决条件
3.4需求的先决条件
3.5架构的先决条件
3.6花费在前期准备上的时间长度
第4章 关键的“构建”决策
4.1选择编程语言
4.2编程约定
4.3你在技术浪潮中的位置
4.4选择主要的构建实践方法 

 第2部分 创建高质量的代码 第5章 软件构建中的设计 5.1设计中的挑战 5.2关键的设计概念 5.3 设计构造块：启发式方法 5.4 设计实践 5.5对流行的设计方法的评论 第6章 可以工作的类 6.1类的基础：抽象数据类型（ADTs） 6.2 良好的类接口 6.3有关设计和实现的问题 6.4创建类的原因 6.5与具体编程语言相关的问题 6.6超越类：包 第7章 高质量的子程序 7.1创建子程序的正当理由 7.2在子程序层上设计 7.3好的子程序名字 7.4子程序可以写多长 7.5如何使用子程序参数 7.6使用函数时要特别考虑的问题 7.7宏子程序和内联子程序 第8章 防御式编程 8.1保护程序免遭非法输入数据的破坏 8.2断言 8.3错误处理技术 8.4异常 8.5隔离程序，使之包容由错误造成的损害 8.6辅助调试的代码 8.7确定在产品代码中该保留多少防御式代码 8.8对防御式编程采取防御的姿态 第9章 伪代码编程过程 9.1创建类和子程序的步骤概述 …… 第3部分 变量 第4部分 语句 第5部分 代码改善 第6部分 系统考虑 第7部分 软件工艺 参考文献 索引

第1部分 读取输入
第1章 初探语言应用 3
1.1 大局观 3
1.2 模式概览 5
1.3 深入浅出语言应用 9
1.4 为语言应用选择合适的模式 17
第2章 基本解析模式 21
2.1 识别式子的结构 22
2.2 构建递归下降语法解析器 24
2.3 使用文法DSL来构建语法解析器 26
2.4 词法单元和句子 27
第3章 高阶解析模式 49
3.1 利用任意多的向前看符号进行解析 50
3.2 记忆式解析 52
3.3 采用语义信息指导解析过程 52 

 第2部分 分析输入 第4章 从语法树构建中间表示 73 4.1 为什么要构建树 75 4.2 构建抽象语法树 77 4.3 简要介绍ANTLR 84 4.4 使用ANTLR文法构建AST 86 第5章 遍历并改写树形结构 101 5.1 遍历树以及访问顺序 102 5.2 封装访问节点的代码 105 5.3 根据文法自动生成访问者 107 5.4 将遍历与匹配解耦 110 第6章 记录并识别程序中的符号 131 6.1 收集程序实体的信息 132 6.2 根据作用域划分符号 134 6.3 解析符号 139 第7章 管理数据聚集的符号表 155 7.1 为结构体构建作用域树 156 7.2 为类构建作用域树 158 第8章 静态类型检查 181

 第3部分 解释执行 第9章 构建高级解释器 219 9.1 高级解释器存储系统的设计 220 9.2 高级解释器中的符号记录 222 9.3 处理指令 224 第10章 构建字节码解释器 239 10.1 设计字节码解释器 241 10.2 定义汇编语言语法 243 10.3 字节码机器的架构 245 10.4 如何深入 250

 第4部分 生成输出 第11章 语言的翻译 278 11.1 语法制导的翻译 280 11.2 基于规则的翻译 281 11.3 模型驱动的翻译 283 11.4 创建嵌套的输出模型 291 第12章 使用模板生成DSL 312 12.1 熟悉StringTemplate 313 12.2 StringTemplate的性质 316 12.2 从一个简单的输入模型生成模板 317 12.4 在输入模型不同的情况下复用模板 320 12.5 使用树文法来创建模板 323 12.6 对数据列表使用模板 330 12.7 编写可改变输出结果的翻译器 336 第13章 知识汇总 348 13.1 在蛋白质结构中查找模式 348 13.2 使用脚本构建三维场景 349 13.3 处理XML 350 13.4 读取通用的配置文件 352 13.5 对代码进行微调 353 13.6 为Java添加新的类型 354 13.7 美化源代码 355 13.8 编译为机器码 356 参考文献 359 索引 361

大象希形
再版序
写给读者的话
关于本书
如何阅读本书
免费下载资源使用说明
Part I  你需要了解
  第1章  为什么需要UML
    1.1  面向过程还是面向对象
    1.1.1  面向过程方法
    1.1.2  面向过程的困难
    1.1.3  面向对象方法
    1.1.4  面向对象的困难
    1.2  UML带来了什么
    1.2.1  什么是UML
    1.2.2  统一语言
    1.2.3  可视化
    1.2.4  从现实世界到业务模型
    1.2.5  从业务模型到概念模型
    1.2.6  从概念模型到设计模型
    1.2.7  面向对象的困难解决了吗
    1.3  统一过程简介
    1.3.1  RUP是什么
    1.3.2  RUP与UML
    1.3.3  RUP与软件工程
    1.3.4  RUP与最佳实践
    1.3.5  RUP与本书
  第2章  建模基础
    2.1  建模
    2.2  用例驱动
    2.3  抽象层次
    2.4  视图
    2.5  对象分析方法
Part II  在学习中思考
  第3章  UML核心元素
    3.1  版型
    3.2  参与者
    3.2.1  基本概念
    3.2.2  发现参与者
    3.2.3  业务主角
    3.2.4  业务工人
    3.2.5  参与者与涉众的关系
    3.2.6  参与者与用户的关系
    3.2.7  参与者与角色的关系
    3.2.8  参与者的核心地位
    3.2.9  检查点
    3.3  用例
    3.3.1  基本概念
    3.3.2  用例的特征
    3.3.3  用例的粒度
    3.3.4  用例的获得
    3.3.5  用例和功能的误区
    3.3.6  目标和步骤的误区
    3.3.7  用例粒度的误区
    3.3.8  业务用例
    3.3.9  业务用例实现
    3.3.10  概念用例
    3.3.11  系统用例
    3.3.12  用例实现
    3.4  边界
    3.4.1  边界决定视界
    3.4.2  边界决定抽象层次
    3.4.3  灵活使用边界
    3.5  业务实体
    3.5.1  业务实体的属性
    3.5.2  业务实体的方法
    3.5.3  获取业务实体
    3.6  包
    3.7  分析类
    3.7.1  边界类
    3.7.2  控制类
    3.7.3  实体类
    3.7.4  分析类的三高
    3.8  设计类
    3.8.1  类
    3.8.2  属性
    3.8.3  方法
    3.8.4  可见性
    3.9  关系
    3.9.1  关联关系（association）
    3.9.2  依赖关系（dependency）
    3.9.3  扩展关系（extends）
    3.9.4  包含关系（include）
    3.9.5  实现关系（realize）
    3.9.6  精化关系（refine）
    3.9.7  泛化关系（generalization）
    3.9.8  聚合关系（aggregation）
    3.9.9  组合关系（composition）
    3.10  组件
    3.10.1  完备性
    3.10.2  独立性
    3.10.3  逻辑性
    3.10.4  透明性
    3.10.5  使用组件
    3.11  节点
    3.11.1  分布式应用环境
    3.11.2  多设备应用环境
  第4章  UML核心视图
    4.1  静态视图
    4.1.1  用例图
    4.1.2  类图
    4.1.3  包图
    4.2  动态视图
    4.2.1  活动图
    4.2.2  状态图
    4.2.3  时序图
    4.2.4  协作图
  第5章  UML核心模型
    5.1  用例模型概述
    5.2  业务用例模型
    5.2.1  业务用例模型主要内容
    5.2.2  业务用例模型工件的取舍
    5.2.3  何时使用业务用例模型
    5.3  概念用例模型
    5.3.1  概念用例模型的主要内容
    5.3.2  获得概念用例
    5.3.3  何时使用概念用例模型
    5.4  系统用例模型
    5.4.1  系统用例模型的主要内容
    5.4.2  获得系统用例
    5.5  领域模型
    5.5.1  读者须知
    5.5.2  基本概念
    5.5.3  领域模型的主要内容
    5.6  分析模型
    5.6.1  如何使用分析模型
    5.6.2  分析模型的主要内容
    5.6.3  分析模型的意义
    5.7  软件架构和框架
    5.7.1  软件架构
    5.7.2  软件框架
    5.7.3  何时使用架构和框架
    5.8  设计模型
    5.8.1  设计模型的应用场合
    5.8.2  设计模型的主要内容
    5.8.3  从分析模型映射到设计模型
    5.9  组件模型
    5.9.1  何时使用组件模型
    5.9.2  广义组件的用法
    5.10  实施模型
    何时使用实施模型
  第6章  统一过程核心工作流简介
    6.1  业务建模工作流程
    6.1.1  工作流程
    6.1.2  活动集和工件集
    6.1.3  业务建模的目标和场景
    6.2  系统建模工作流程
    6.2.1  工作流程
    6.2.2  活动集和工件集
    6.2.3  系统建模的目标
    6.3  分析设计建模工作流程
    6.3.1  工作流程
    6.3.2  活动集和工件集
    6.3.3  分析设计的目标
    6.3.4  推荐的分析设计工作流程简介
    6.4  实施建模工作流程
    6.4.1  工作流程
    6.4.2  活动集和工件集
    6.4.3  推荐的实施建模工作流程
  第7章  迭代式软件生命周期
Part III  在实践中思考
  第8章  准备工作
    8.1  案例说明
    8.2  了解问题领域
    8.2.1  了解业务概况
    8.2.2  整理业务目标
    8.3  做好涉众分析
    8.3.1  什么是涉众
    8.3.2  发现和定义涉众
    8.3.3  涉众分析报告
    8.4  规划业务范围
    8.4.1  规划业务目标
    8.4.2  规划涉众期望
    8.5  整理好你的思路
    8.5.1  划分优先级
    8.5.2  规划需求层次
    8.5.3  需求调研计划
    8.6  客户访谈技巧
    8.6.1  沟通的困难
    8.6.2  沟通技巧
    8.7  提给读者的问题
  第9章  获取需求
    9.1  定义边界
    9.1.1  盘古开天——从混沌走向清晰
    9.1.2  现在行动：定义边界
    9.1.3  进一步讨论
    9.1.4  提给读者的问题
    9.2  发现主角
    9.2.1  女娲造人——谁来掌管这个世界
    9.2.2  现在行动：发现主角
    9.2.3  进一步讨论
    9.2.4  提给读者的问题
    9.3  获取业务用例
    9.3.1  炎黄之治——从愚昧走向文明
    9.3.2  现在行动：获取业务用例
    9.3.3  进一步讨论
    9.3.4  提给读者的问题
    9.4  业务建模
    9.4.1  商鞅变法——强盛的必由之路
    9.4.2  现在行动：建立业务模型
    9.4.3  进一步讨论
    9.4.4  提给读者的问题
    9.5  领域建模
    9.5.1  风火水土——寻找构成世界的基本元素
    9.5.2  现在行动：建立领域模型
    9.5.3  进一步讨论
    9.5.4  提给读者的问题
    9.6  提炼业务规则
    9.6.1  牛顿的思考——揭穿苹果的秘密
    9.6.2  现在行动：提炼业务规则
    9.6.3  进一步讨论
    9.6.4  提给读者的问题
    9.7  获取非功能性需求
    9.7.1  非物质需求——精神文明是不可缺少的
    9.7.2  现在行动：获取非功能性需求
    9.7.3  进一步讨论
    9.7.4  提给读者的问题
    9.8  主要成果物
    提给读者的问题
  第10章  需求分析
    10.1  关键概念分析
    10.1.1  阿基米德杠杆——找到撬动地球的支点
    10.1.2  现在行动：建立概念模型
    10.1.3  进一步讨论
    10.1.4  提给读者的问题
    10.2  业务架构
    10.2.1  拼图游戏——我们也想造个世界
    10.2.2  现在行动：建立业务架构
    10.2.3  进一步讨论
    10.2.4  提给读者的问题
    10.3  系统原型
  第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.2.3  提给读者的问题
    11.3  用例实现
    11.3.1  绘制蓝图——世界将这样运行
    11.3.2  现在行动：实现用例
    11.3.3  进一步讨论
    11.3.4  提给读者的问题
    11.4  软件架构和框架
    11.4.1  设计架构——新世界的骨架
    11.4.2  什么是软件架构
    11.4.3  什么是软件框架
    11.4.4  软件架构的基本构成
    11.4.5  应用软件架构
    11.4.6  提给读者的问题
    11.5  分析模型
    11.5.1  设计功能零件——让世界初步运转起来
    11.5.2  现在行动：建立分析模型
    11.5.3  进一步讨论
    11.5.4  提给读者的问题
    11.6  组件模型
    11.6.1  设计功能部件——构建世界的基础设施
    11.6.2  现在行动：建立组件模型
    11.6.3  进一步讨论
    11.6.4  提给读者的问题
    11.7  部署模型
    11.7.1  安装零部件——组装一个新世界
    11.7.2  现在行动：建立部署模型
    11.7.3  提给读者的问题
  第12章  系统设计
    12.1  系统分析与系统设计的差别
    12.2  设计模型
    12.2.1  按图索骥——为新世界添砖加瓦
    12.2.2  现在行动：将分析模型映射到设计模型
    12.2.3  进一步讨论
    12.2.4  提给读者的问题
    12.3  接口设计
    12.3.1  畅通无阻——构建四通八达的神经网络
    12.3.2  现在行动：设计接口
    12.3.3  进一步讨论
    12.3.4  提给读者的问题
    12.4  包设计
    12.4.1  分工合作——组织有序世界才能更好
    12.4.2  现在行动：设计包
    12.4.3  进一步讨论
    12.5  提给读者的问题
  第13章  数据库设计
    13.1  关公战秦琼——面向对象与关系模型之争
    13.2  相辅相成——面向对象的数据库设计
    13.3  平衡的艺术——数据库设计的方法和策略
    13.3.1  OR-Mapping策略
    13.3.2  对象—关系平衡策略
    13.4  进一步讨论——数据库设计到底有多重要
  第14章  开发
    14.1  生成代码
    14.1.1  现在行动：生成代码
    14.1.2  进一步讨论
    14.2  分工策略
    14.2.1  纵向分工策略
    14.2.2  横向分工策略
    14.2.3  选择适合你的开发分工策略
Part IV  在提炼中思考
  第15章  测试
    15.1  质量保证——新世界需要稳健运行
    15.2  设计和开发测试例
    15.3  提给读者的问题
  第16章  理解用例的本质
    16.1  用例是系统思维
    16.2  用例是面向服务的
    16.3  善用用例方法
  第17章  理解用例驱动
    17.1  用例与项目管理
    17.2  用例与可扩展架构
  第18章  用例驱动与领域驱动
    18.1  用例驱动与领域驱动的差异
    18.2  领域驱动的理想与现实
    18.3  如何决定是否采用领域驱动方法
  第19章  理解建模的抽象层次
    19.1  再讨论抽象层次
    19.1.1  层次高低问题
    19.1.2  层次不交叉问题
    19.2  如何决定抽象层次
    19.3  抽象层次与UML建模的关系
  第20章  划分子系统的问题
    20.1  面向对象的子系统问题
    20.2  UC矩阵还适用吗
    20.3  如何划分子系统
  第21章  学会使用系统边界
    21.1  边界是面向对象的保障
    21.2  利用边界来分析需求
    21.2.1  边界分析示例一
    21.2.2  边界分析示例二
    21.3  边界意识决定设计好坏
  第22章  学会从接口认知事物
    22.1  怎样描述一件事物
    22.2  接口是系统的灵魂
  第23章  学会正确选择
    23.1  屁股决定脑袋——学会综合权衡
    23.2  理辩则明——学会改变视角
  第24章  学会使用设计模式
    24.1  如何学习设计模式
    24.2  如何使用设计模式
附录  UML视图常用元素参考
图目录
表目录
后记