软件工程实践导论 有关方法、设计、实现、管理之三十六计PDF|Epub|txt|kindle电子书版本网盘下载

软件工程实践导论 有关方法、设计、实现、管理之三十六计PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

目录1

绪论1

0.1 历史的回顾1

0.2　软件的定义2

0.3 什么是软件工程？5

0.4 软件工程的大环境7

0.5　软件工程究竟像什么？8

0.5.1　雪球理论——做软件就像滚雪球9

0.5.2 软件工程拆控制论——软件生产过程是个离散多环控制系统10

0.5.3　兵法三十六计的启示11

0.6　本书的组织13

方法篇17

1 经济为本17

1.1 投入产出的概念18

1.2　经济为本的启示20

1.2.1 为技术而技术是条死胡同20

1.2.2 以经济原则指导软件项目的决策过程21

1.2.3　按照产品规律来营销软件产品21

1.2.4 以收益为依据规划设计产品23

小结23

2　用户为先25

2.2.1　界面设计和风格26

2.2　用户友好的交互界26

2.1　用户需求分析26

2.2.2　界面的本地化27

2.3　软件安装和部署28

2.4　用户培训和技术认证30

2.5　用户大会和开发人员网络30

2.6　用户文档31

2.7 用户支持和反馈31

2.8 系统升级和版权管理32

2.9　软件咨询服务34

小结35

3.1　什么是软件需求？37

3　管理需求37

3.2 了解需求39

3.3 记录需求41

3.4 追踪需求42

3.5　在变化中管理需求43

小结44

4　及早集成47

4.1　软件工程项目的风险49

4.2 及早集成才能滚雪球50

4.3 少食多餐51

小结52

5　连续验证53

5.1 有关测试的理论54

5.2 测试自动化55

5.3 软件缺陷跟踪系统的概念和实际应用57

5.3.1 软件缺陷的生命周期58

5.3.2 欲穷千里目，更上一层楼58

5.4 软件的“测不准”原理59

5.5　另类的验证59

小结60

6　控制变化61

6.1 循序渐进62

6.2 同步协调64

小结65

7　规范流程67

7.1 规范要点68

7.2 CMM69

7.3 Rational Unified Process70

7.4 极限编程70

7.5 发展方向71

17.4.1 隐含规则 （173

小结73

8　快速原型75

8.1　软件中的“概念车”75

8.2　大行不顾细谨77

8.3　走向产品78

小结79

9　借鸡下蛋81

9.1 外包81

9.2 买进83

9.3　开放代码运动84

小结86

10　开放标准89

10.1　开放的意义89

10.2　开放标准的种类91

10.3　支持开放标准92

小结93

11 避繁就简97

设计篇97

11.1.1 面向履历表的设计97

11.1 “不简单”的设计97

11.1.2　“难得糊涂”的设计98

11.1.3　委员会式的设计99

11.2　简单就是金钱99

11.3　简单才真的不简单100

11.4　关键是平衡103

11.5　皇帝的新衣104

小结105

12　因地制宜107

12.1　有没有万能钥匙？107

12.2　考量的因素108

12.3　软件设计中的若干对矛盾110

12.4　要马儿跑又要马儿不吃草116

小结117

13　变中求静119

13.1　变在那里？119

13.2　针对变化而设计122

13.2.1 数据和代码的分离122

13.2.2　输入数据和配置参数的分离124

13.2.3 不变的和常变的代码分离125

13.3　灰色地带127

13.4　XML和数据化129

小结130

14.1 巨人的肩膀131

14　分层平台131

14.2　为什么软件要分层？132

14.2.1 层次提升132

14.2.2 隐藏细节133

14.2.3 标准互换134

14.3　分层的原则135

14.3.1 实现和接口分离原则135

14.3.2　单向性原则135

14.4.1 OSI模型136

14.3.3 服务接口的粒度提升原则136

14.4　典型的分层设计136

14.4.2　三层应用结构138

14.5　分层的网络化138

14.5.1 客户／服务器计算模式138

14.5.2　万维网的拓展139

14.6　应用编程接口 API139

14.7　服务编程接口 SPI141

小结142

15　内外有别143

15.1 MVC结构144

15.2 万维网应用也要内外有别吗？146

15.3　模型的设计147

15.4　正交化设计148

小结149

16　模块封装151

16.1 软件芯片151

16.2　静态模块的粒度152

16.2.1 函数153

16.2.2 文件153

16.2.3 类154

16.2.4　相关类集合154

16.3.1 构件155

16.3.2　插入件155

16.3　动态模块155

16.2.5 子系统155

16.3.3 进程156

16.3.4　可执行应用157

16.3.5　企业运行环境157

16.4　模块关系的分析157

16.4.1　代码类关系158

16.4.2　数据类关系158

16.5　模块划分159

16.5.1　分割的原则159

16.6.1 复用情形下的新问题160

16.6　软件构件复用的理想160

16.5.2　模块间的通信160

16.6.2　没有金刚钻，别揽瓷器活162

小结163

17　合约接口165

17.1　软件世界的“合同”165

17.2　编程接口设计的“五项基本原则”166

17.3 网络条件的新问题171

17.4　从“貌合”到“神合”173

17.4.2 言行一致174

17.5　非编程式接口175

小结175

18　面向对象177

18.1 面向对象的三性178

18.1.1　继承性和逻辑三段论178

18.1.2 封装性180

18.1.3 多态性181

18.2　继承“税”182

18.2.1 多包“含”182

18.2.2　单重继承183

18.3　面向对象的建模和UML183

18.3.1 软件建模183

18.3.2 建模语言184

18.4　双向工程185

18.5 面向对象的编程语言187

小结　188

19　巧用模板189

19.1　变模板为“魔”板190

19.1.1 编程190

19.1.2 代码生成191

19.1.3 数据转换193

19.1.4 产生文档194

19.2 通用模板语言和引擎195

19.2.1　Velocity196

19.2.2　XSLT200

19.3.3 模板MVC203

19.3.2　模板的模块化203

19.3.1　模板流水线203

19.3　模板也要正交吗？203

小结204

20　能伸能缩205

20.1　伸缩性要从设计抓起205

20.2　结构设计的适应性206

20.2.1　并行度规划206

20.2.2 逻辑分层和物理分布207

20.2.3 同步还是异步207

20.2.4 资源的竞争和平衡207

20.3.1　调用函数重入208

20.3　多线程安全性208

20.3.2　变量可见度209

20.3.3　死锁和保护210

20.4　算法可伸缩211

20.4.1　算法并行的可能性211

20.4.2　线性化算法的必要性211

20.4.3　递归算法212

小结214

21　套用成解215

21.1 框架215

21.2 面向对象方法中的设计定式219

21.2.1　生成类定式219

21.2.2　行为类定式221

21.2.3　结构类定式226

小结228

22　见好就收229

22.1　软件设计的使命229

22.2　见好不收的误区231

22.2.1 追求完美231

22.2.2 画蛇添足232

22.2.3　清谈误国232

小结233

23　决不重复237

23.1 重复是万恶之首237

实现篇237

23.2　典型的代码重复238

23.2.1 常量重复239

23.2.2 变量或者属性的重复241

23.2.3　代码重复243

23.2.4　逻辑性重复246

23.2.5　结构性重复247

23.3　代码之外的重复248

23.3.1 代码和数据库定义的重复248

23.3.2 代码和库函数的重复249

23.3.3 代码和注释的重复250

23.3.4　测试说明和用户需求的重复250

23.3.6　代码注解和文档251

23.3.5　设计和代码的重复251

小结252

24　通俗易懂253

24.1 写代码和写文章253

24.2　代码的认知模型254

24.3 误区种种257

24.3.1 飞流直下三千尺，疑是银河落九天257

24.3.2 为人性僻耽佳句，语不惊人死不休258

24.3.3 千呼万唤始出来，犹抱琵琶半遮面260

24.3.4 爱上层楼，为赋新词强说愁263

24.4 入乡随俗265

小结267

25　精益求精269

25.1 回炉改造的目的269

25.2　有备才能无患271

25.2.1 单元测试的概念和应用272

25.2.2　谁来测试测试代码？275

25.2.3　集成开发环境275

25.2.4 版本控制276

25.2.5　两个“动不得”276

25.3　典型的回炉办法276

25.3.1 去除重复276

25.3.3 清理门户277

25.3.2 返朴归真277

25.3.4 面向侧面编程278

小结278

26　优化性能281

26.1 多一事不如少一事282

26.2　擒贼先擒王，打蛇找七寸284

26.3　优化的方法285

26.3.1 算法本身285

26.3.2　经典代码优化方法286

26.3.3 面向对象编程语言的优化291

26.3.4 并行计算293

26.3.5 体系结构296

26.4　也别太执著298

小结298

27　照猫画虎299

27.1 书法临帖的启示299

27.2　软件工程中的“拿来主义”301

27.3　“猫”在哪里？302

27.4　邯郸学步的“戒”鉴304

27.5 解剖麻雀305

小结306

28　严堵漏洞307

28.1 资源泄漏307

28.1.1 内存泄漏307

28.1.2 网络资源泄漏309

28.1.3　其他资源泄漏310

28.2 防范性编程311

28.2.1 空指针检查311

28.2.2　返回值检查312

28.2.3 存取控制313

28.2.4 想不到的命名覆盖315

28.2.5　例外不例外317

28.2.6 宣检319

28.2.7 明知山有虎，须要绕道行320

小结321

28.3 习惯成自然321

29　雁过留声323

29.1 版本控制概念和使用323

29.1.1 有迹可循——变化的历史轨迹323

29.1.2 协同工作——创建分支互不影响325

29.1.3 灵活配置——创建多样性327

29.2 使用版本控制工具的注意事项329

29.2.1 有所选择329

29.2.2 勤做备份330

29.3　代码的注解330

29.4 Log的使用和一般原则332

小结334

30.1 不是选择的选择335

30　自动流程335

30.2　哪些要自动化？336

30.2.1 部分代码和文档生成336

30.2.2 软件的编译和包装发布337

30.2.3 质量测试338

30.2.4 日常维护339

30.3 与其他信息系统的集成339

30.4　还要人的参与吗？340

小结341

31　利器常新343

31.1 常用工具344

31.2 锦上添花347

31.3　语言的语言348

31.4 专业联络349

31.5　知识库框架351

小结353

管理篇357

32　分工协作357

32.1 软件管理的特殊性357

32.1.1 人的因素357

32.1.2 项目359

32.2 组织结构359

32.2.1　外科手术队360

32.2.2　导演和制片人361

32.2.4　分工不分家362

32.2.3　三驾马车362

32.3　雪球式成长363

32.4 民主和集中363

小结364

33　目标驱动365

33.1　代码量之谜365

33.2 三个臭皮匠抵上一个诸葛亮？366

33.3　“聪明”五项基本原则367

33.4　激励机制368

33.5 人才战略370

33.5.1　管理梯队和技术梯队370

33.5.2 师傅和徒弟370

33.5.3 培养计划371

小结372

34　常来常往373

34.1 升级须知373

34.2　沟通的重要性374

34.2.1 与客户的交流374

34.2.2 项目团队之间的交流374

34.2.3 开发队伍内部的交流375

34.3 沟通形式375

34.3.1 开会375

34.3.2 电子邮件376

34.4 技术审查377

34.3.3 正式文档377

34.5　开发环境的“风水”378

34.6　分布式开发团队的沟通380

小结381

35　有张有弛383

35.1 阶段性调整383

35.2 发布聚会384

35.3 不妨换换口味385

35.4 需要锲而不舍吗？387

35.5 7＋1＞8387

小结388

36.1　经验之经验389

36　不断总结389

36.2 学而不思则罔，思而不学则殆391

36.3 怎么总结393

36.3.1　两个基本原则393

36.3.2 总结形式393

36.4 从实践中来再回到实践中去394

小结395

后记397

参考文献399

网络资源403

附录　兵法三十六计405