面向对象软件工程(英文影印版)

Chapter Review 25
For Further Reading 25
Key Terms 26
习题 27
References 28
Chapter 2
Software Life-Cycle Models 32
学习目标 32
2.1 Software Development in Theory 32
2.2 Winburg Mini Case Study 33
2.3 LessonsoftheWinburgMiaiCaseStudy 37
2.4 Teal Tractors Mini Case Study 37
2.5 Iteration and Incrementation 38
2.6 Winburg Mini Case Study Revisited 42
2.7 Risks and Other Aspects of Iteration
and Incrementation 43
2.8 Managing Iteration and Incrementation 46
2.9 Other Life-Cycle Models 47
2.10 Comparison of[,ife-'Cycle Models 61
Chapter Review 62
For Further Reading 63
Key Terms 64
习题 64
References 65
Chapter 3
The Software Process 68
学习目标 68
3.1 The Unified Process 70
3.2 Iteration and lncrementation 72
3.3 The Requirements Workfiow 73
3.4 The Analysis Workflow 74
3.5 The Design Workfiow 76
3.6 The Implementation Workflow 77
3.7 The Test Workfiow 78
3.8 Postdelivery Maintenance 81
3.9 Retirement 82
3.10 The Phases of the Unified Process 82
3.11 One; versus Two-Dimensional Life-Cycle Models 87
3.12 Improving the Software Process 89
3.13 Capability Maturity Models 89
3.14 Other Software Process Improvement Initiatives 92
3.15 Costs and Benefits of Software Process Improvement 93
Chapter Review 95
For Further Reading 95
Key Terms 96
习题 97
References 97
Chapter 4
Teams 101
学习目标 101
4.1 Team Organization 101
4.2 Democratic Team Approach 103
4.3 Chief Programmer Team Approach 104
4.4 Beyond Chief Programmer and Democratic Teams 107
4.5 Synchronize-and-Stabilize Teams 111
4.6 Teams for Agile Processes 112
4.7 Open-SourceProgramming Teams 112
4.8 People Capability Maturity Model 113
4.9 Choosing an Appropriate Team
Organization 114
Chapter Review 115
For Further Readifig 115
Key Terms 115
Problems 116
习题 116
Chapter 5
The Tools of The Trade 118
学习目标 118
5.1 Stepwise Refinement 118
5.2 Cost-Benefit Analysis 124
5.3 Software Metrics 126
5.4 CASE 127
5.5 Taxonomy of CASE 128
5.6 Scope of CASE 130
5.7 Software Versions 133
5.8 Configuration Control 135
5.9 Build Tools -138
5.10 Productivity Gains with CASE
Technology 139
Chapter Review 141
For Further Reading 141
Key Terms 141
习题 142
References 143
Chapter 6
Testing 145
学习目标 145
6.1 Quality Issues 146
6.2 Non-Execution-Based Testing 148
6.3 Execution-Based Testing 153
6.4 What Should Be Tested? 154
6.5 Testing versus Correctness Proofs 158
6.6 Who Should Perform Execution-BasedTesting? 166
6.7 When Testing Stops 167
Chapter Review 167
For Further Reading 168
Key Terms 168
习题 169
References 170
Chapter 7
From Modules to Objects 173
学习目标 173
7.1 WhatlsaModule? 174
7.2 Cohesion 176
7.3 Coupling 181
7.4 Data Encapsulation 189
7.5 Abstract DataTypes 197
7.6 Information Hiding 199
7.7 Objecls 201
7.8 Inheritance, Polymorphism, and Dynamic Binding 205
7.9 The Object-Oriented Paradigm 207
Chapter Review 210
For Further Reading 211
Key Terms 211
习题 212
References 212
Chapter 8
Reusability and Portability 215
学习目标 215
8.1 Reuse Concepts 216
8.2 lmpediments to Reuse 218
8.3 Reuse Case Studies 219
8.4 Objects and Reuse 222
8.5 Reuse during Design and
8.6 More on Design Patterns 227
8.7 Categories of Design Patterns 235
8.8 Strengths and Weaknesses of Design Patterns 237
8.9 Reuse and Postdelivery Maintenance
8.10 Portability 239
8.11 Why Portability? 244
8.12 Techniques for Achieving Portability 245
Chapter Review 249
For Further Reading 249
Key Terms 250
习题 250
References 252
Chapter 9
Planning and Estimating 256
学习目标 256
9.1 Planning and the Software Process 257
9.2 Estimating Duration and Cost 258
9.3 Estimation Issues 270
9.4 Components of a Software Project Management Plan 271
9.5 Software Project Management Plan Framework 272
9.6 IEEE Software Project Management Plan 274
9.7 Planning Testing.. 277
9.8 Training Requirements 278
9.9 Documentation Standards 279
9.10 CASE Tools for Planning and Estimating 279
9.11 Testing the Software Project
Management Plan 280
Chapter Review 280
For Further Reading 280
Key Terms 281
习题 282
References 283
PART TWO
THE WORKFLOWS OF THE
SOFTWARE LIFE CYCLE 286
Chapter 10
The RequirementsWorkfiow 287
学习目标 287
10.1 Determining What the Client Needs 288
10.2 Overview of the Requirements Workflow 289
10.3 Understanding the Domain 283
10.4 The Business Model 290
10.4.1 Interviewing 290
10.4.20therTechniques 291
10.4.3 Use Cases 292
10.5 Initial Requirements 293
10.6 Initial Understanding of the Domain: The MSG Foundation Case Study 294
10.7 Initial Business Model: The MSG Foundation Case Study 297
10.8 Initial Requirements: The MSG Foundatipon Case Study 300
10.9 Continuing the Requirements Workflow The MSG Foundation Case Study 302
10.10 Revising the Requirements: The MSG Foundation Case Study 304
10.11 The Test Workfiow: The MSG Foundation Case Study 312
10.12 What Are Object-Oriented Requirements? 321
10.13 Rapid Prototyping 321
10.14 Human Factors 322
10.15 Reusing the Rapid Prototype 324
10.16 CASE Tools for the Requirements Workflow 324
10.17 Metrics for the Requirements Workflow 325
10.18 Challenges of the Requirements Workflow 325
Chapter Review 327
For Further Reading 327
Key Terms 327
Case Study Key Terms 328
习题 328
References 329
Chapter 11
The Analysis Workfiow 331
学习目标 331
11.1 The Specification Document 332
11.2 Informal Specifications 333
11.3 Correctness Proof Mini Case Study Redux 334
11.4 The Analysis Worktlow 335
11.5 Extracting the Entity Classes 337
11.6 The Elevator Problem 338
11.7 Functional Modeling: The Elevator Problem Case Study 338
11.8 Entity Class Modeling: The Elevator Problem Case Study 340
11.8.1 Noun Extraction 341
11.8.2 CRC Cards 343
11.9 Dynamic Modeling: The Elevator Problem Case Study 344
11.10 The Test Workflow: The Elevator Problem Case Study 347
11.11 Extracting the Boundary and Control Classes 351
11.12 The Initial Functional Model: The MSG Foundation Case Study 352
11.13 The Initial Class Diagram: The MSG Foundation Case Study 354
11.14 The Initial Dynamic Model: The MSG Foundation Case Study 357
11.15 Revising the Entity Classes: The MSG Foundation Case Study 359
11.16 Extracting the Boundary Classes: The MSG Foundation Case Study 360
11.17 Extracting the Control Classes: The MSG Foundation Case Study 361
11.18 Use-Case Realization: The MSG Foundation Case Study 362
11.19 Incrementing the Class Diagram: The MSG Foundation Case Study 380
11.20 The Software Project Management Plan: The MSG Foundation Case Study 382
11.21 The Test Workflow: The MSG Foundation Case Study 382
11.22 The Specification Document in the Unified Process 382
11.23 More on Actors and Use Cases 383
11.24 CASE Tools for the Analysis Workfiow 385
11.25 Challenges of the Analysis Workflow 385
Chapter Review 386
For Further Reading 386
Key Terms 387
Case Study Key Terms 387
习题 387
References 389
Chapter 12
The Design Workfiow 392
学习目标 392
12.1 Object-Oriented Design 393
12.2 Object-Oriented Design: The Elevator Problem Case Study 397
12.3 Object-Oriented Design: The MSG Foundation Case Study 400
12.4 The Design Workflow 402
12.5 The Test Workflow: Design 404
12.6 The Test Workfiow: The MSG Foundation Case Study 405
12.7 Formal Techniques for Detailed Design 405
12.8 Real-Time Design Techniques 406
12.9 CASE Tools for Design 407
12.10 Metrics for Design 408
12.11 Challenges of the Design Workflow 409
Chapter Review 410
For Further Reading 410
Key Terms 411
习题 411
References 412
Chapter 13
The Implementation Workflow 414
学习目标 414
13.1 Choice of Programming Language 414
13.2 Good Programming Practice 417
13.3 Coding Standards 422
13.4 Code Reuse 423
13.5 Integration 423
13.6 The Implementation Workflow 429
13.7 The Implementation Workflow: The MSG Foundation Case Study 429
13.8 The Test Workflow: Implementation 429
13.9 Test Case Selection 430
13.10 Black-Box Unit-Testing Techniques 433
13.11 Black-Box Test Cases: The MSG Foundation Case Study 436
13.12 Glass-Box Unit-Testing Techniques 436
13.13 Code Walkthroughs and Inspections 441
13.14 Comparison of Unit-Testing Techniques 441
13.15 Cleanroom 442
13.16 Testing Issues 443
13.17 Management Aspects of Unit Testing 445
13.18 When to Rewrite Rather than Debug a Code Artifact 446
13.19 Integration Testing 447
13.20 Product Testing 448
13.21 Acceptance Testing 449
13.22 The Test Workflow: The MSG Foundation Case Study 450
13:23 CASE Tools,for Implementation 450
13.24 CASE Tools for the Test Workflow 453
13.25 Metrics for the Implementation Workfiow 453
13.26 Challenges of the Implementation Workflow 454
Chapter Review 455
For Further Reading 455
Key Terms 456
习题 457
References 459
Chapter 14
Postdelivery Maintenance 462
学习目标 462
14.1 Development and Maintenance 462
14.2 Why Postdelivery Maintenance Is Necessary 464
14.3 What Is Required of Postdelivery Maintenance Programmers? 465
14.4 Post&livery Maintenance Mini Case Study 467
14.5 Management of Postdelivery Maintenance 468
14.6 Maintenance Issues 471
14.7 Postdelivery Maintenance Skills versus Development Skills 474
14.8 Reverse Engiheering 474
14.9 Testing during Postdelivery Maintenance 475
14.10 CASE Tools for Postdelivery Maintenance 476
14.11 Metrics for Postdelivery Maintenance 477
14.12 Postdelivery Maintenance: The MSG Foundation Case Study 477
14.13 Challenges of Postdelivery Maintenance 477
Chapter Review 478
For Further Reading 478
Key Terms 479
习题 479
References 480
Chapter 15
More on UML 482
学习目标 482
15.1 UML Is Not a Methodology 483
15.2 Class Diagrams 483
15.3 Notes 488
15.4 Use-Case Diagrams 488
15.5 Stereotypes 488
15.6 Interaction Diagrams 489
15.7 Statecharts 491
15.8 Activity Diagrams 494
15.9 Packages 496
15.10 Component Diagrams 497
15.11 Deployment Diagrams 497
15.12 Review of UML Diagrams 498
15.13 UMLand Iteration 498
Chapter Review 498
For Further Reading 499
Key Terms 499
习题 499
References 500
Bibliography 501
Appendix A
Term Project: Osric's Office Appliances and Decor 524
Appendix B
Software Engineering Resources 528
Appendix C
The Requirements Workflow: The MSG
Foundation Case Study 530
Appendix D
The Analysis Workflow: The MSG
Foundation Case Study 531
Appendix E
Software Project Management Plan:
The MSG Foundation Case Study 532
Appendix F
The Design Workflow: The MSG
Foundation Case Study 537
Appendix G
The Implementation Workflow: The MSG
Foundation Case Study (C++ Version) 542
Appendix H
The Implementation Workflow: The MSG
Foundation Case Study (Java Version) 543
Appendix I
The Test Workflow' The MSG Foundation Case Study... 544

.　　·In addition to the two running case studies that are used to illustrate the complete lifecycle, seven mini case studies highlight specific topics, such as the moving-target prob-lem, stepwise refinement, design patterns, and postdelivery maintenance.
　　·I stress the importance of documentation, maintenance, reuse, portability, testing, andCASE tools. It is no use teaching students the latest ideas unless they appreciate theimportance of the basics of object-oriented software engineering.
　　·Attention is paid to object-oriented life-cycle models, object-oriented analysis, object-oriented design, management implications of the object-oriented paradigm, and thetesting and maintenance of object-oriented software. Metrics for the object-orientedparadigm also are included. In addition, many briefer references are made to objects, aparagraph or even only a sentence in length. The reason is that the object-oriented paradigm is not just concerned with how the various workflows are performed but rather permeates the way we think about software engineering. Object technology pervades this book.
　　·The software process underlies the book as a whole. To control the process, we have to be able to measure what is happening to the project. Accordingly, there is an emphasis on metrics. With regard to process improvement, there is material on the capability maturity model (CMM), ISO/IEC 15504 (SPICE), and ISO/IEC 12207; the people capability maturity model (P-CMM) has been included in the chapter on teams.
　　·The book is language independent; the few code examples are presented in C++ and Java, and I have made every effort to smooth over language-dependent details and ensure that the code examples are equally clear to C++ and Java users. For example, instead of using tout for C++ output and 5ystem.out.println for Java output, I have utilized the pseudocode instruction print. (The one exception is the second case study, where complete implementation details are given in both C++ and Java.)
　　·This book contains over-600 references. I have selected current research papers as well as classic articles and books whose message remains fresh and relevant. There is no question that object-oriented software engineering is a rapidly moving field, and students therefore need to know the latest results and where in the literature to find them. At the same time, today's cutting-edge research is based on yesterday's truths, and I see no reason to exclude an older reference if its ideas are as applicable today as they originally were.
　　With regard to prerequisites, it is assumed that the reader is familiar with one high-level object-oriented programming language such as C++ or Java. In addition, the reader is expected to have taken a course in data structures.
　　How This Book Is Organized ..
　　This book is written for both the traditional one-semester and the newer two-semester software engineering curriculum, now growing in popularity. In the traditional one- semester (or one-quarter) course, the instructor has to rush through the theoretical material to provide the students the knowledge and skills needed for the term project as soon as possible. The need for haste is so that the students can commence the term project early enough to complete it by the end of the semester. To cater to a one-semester, project-based software engineering course, Part 2 of this book covers the software life cycle, workflow by workflow, and Part I contains the theoretical material needed to understand Part 2. For example, Part I introduces the reader to CASE, metrics, and testing; each chapter of Part 2 contains a section on CASE tools for that workflow, a section on metrics for that workflow, and a section on testing during that workflow. Part I is kept short to enable the instructor to start Part 2 relatively early in the semester. Furthermore, the last two chapters of Part 1 (Chapters 8 and 9) may be postponed, and then taught in parallel with Part 2. As a result, the class can begin developing the term project as soon as possible.
　　We turn now to the two-semester software engineering cumculum. More and more computer science and computer engineering departments are realizing that the overwhelming preponderance of their graduates find employment as software engineers. As a result, many colleges and universities have introduced a two-semester (or two-quarter) software engineering sequence. The first course is largely theoretical (but often includes a small project of some sort). The second course comprises a major team-based term project. This is usually a capstone project. When the term project is in the second course, there is no need for the instructor to rush to start Part 2.
　　Therefore, an instructor teaching a one-semester (or one-quarter) sequence using this book covers most of Chapters I through 7 and then starts Part 2 (Chapters 10 through 15). Chapters 8 and 9 can be taught in parallel with Part 2 or at the end of the course while the students are implementing the term project. When teaching the two-semester sequence, the chapters of the book are taught in order; the class now is fully prepared for the team-based term project that it will develop in the following semester.
　　To ensure that the key software engineering techniques of Part 2 truly are understood, each is presented twice. First, when a technique is introduced, it is illustrated by means of the elevator problem. The elevator problem is the correct size for the reader to be able to see the technique applied to a complete problem, and it has enough subtleties to highlight both the strengths and weaknesses of the technique being taught. Then, the relevant portion of the MSG Foundation case study is presented. This detailed solution provides the second illustration of each technique.
　　The Problem Sets
　　This book has five types of problems. First, there are running object-oriented analysis and design projects at the end of Chapters 10, 11, and 12. These have been included because the only way to learn how to perform the requirements, analysis, and design workflows is from extensive hands-on experience.
　　Second, the end of each chapter contains a number of exercises intended to highlight key points. These exercises are self-contained; the technical information for all the exercises can be found in this book.
　　Third, there is a software term project. It is designed to be solved by students working in teams of three, the smallest number of team members that cannot confer over a standard telephone. The term project comprises 14 separate components, each tied to the relevant chapter. For example, design is the topic of Chapter 12, so in that chapter the component of the term project is concerned with software design. By breaking a large project into smaller,well-defined pieces, the instructor can monitor the progress of the class more closely. Thestructure of the term project is such that an instructor may freely apply the 14 components to any other project that he or she chooses.
　　 Because this book has been written for use by graduate students as well as upper-class undergraduates, the fourth type of problem is based on research papers in the software engineering literature. In each chapter, an important paper has been chosen. The student is asked to read the paper and answer a question relating to its contents. Of course, the instructor is free to assign any other research paper; the For Further Reading section at the end of each chapter includes a wide variety of relevant papers.
　　The fifth type of problem relates to the case study. This type of problem has been included in response to a number of instructors who feel'that their students learn more by modifying an existing product than by developing a new product from scratch. Many senior software engineers in the industry agree with that viewpoint. Accordingly, each chapter in which the case study is presented has problems that require the student to modify the case study in some way. For example, in 'one chapter the s.tudent is asked what the effect would have been of performing the steps of the object-oriented analysis in a different order. To make it easy to modify the source code of the case study? it is available on the World Wide Web at www. mhhe.com/schach.
　　The website also has material for instructors, including a complete set of PowerPointlecture notes, and detailed solutions to all the exercises as well as to the term project. ...