Inhaltsverzeichnis

Vorwort

Preface to the Third Edition

An introductory course in Software Engineering remains one of the hardest subjects to teach. Much of the difficulty stems from the fact that Software Engineering is a very wide field which includes a wide range of topics. Consequently, what should be the focus of an introductory course remains a challenge with many possible viewpoints.

This third edition of the book approaches the problem from the perspective of what skills a student should possess after the introductory course, particularly if it may be the only course on software engineering in the student's program. The goal of this third edition is to impart to the student knowledge and skills that are needed to successfully execute a project of a few person-months by employing proper practices and techniques. Incidently, a vast majority of the projects executed in the industry today are of this scope-executed by a small team over a few months. Another objective of the book is to lay the foundation for the student for advanced studies in Software Engineering.

Executing any software project requires skills in two key dimensions- engineering and project management. While engineering deals with issues of architecture, design, coding, testing, etc., project management deals with planning, monitoring, risk management, etc. Consequently, this book focuses on these two dimensions, and for key tasks in each, discusses concepts and techniques that can be applied effectively on projects.

The focus of the book remains as the first course in software engineering, and it retains its character of having a running case study with most of the outputs available. This edition draws upon my experience during my sabbaticals with two software companies-Infosys Technologies and Microsoft Corporation-and my practice-oriented book Software Project Management in Practice (Addison-Wesley, 2002) to bring, in addition to the concepts, more elements of how these concepts are actually applied in practice.

In this edition, new material has been added on current practices, out dated material has been removed, and discussion has been sharpened. The following key additions have been made:

• In "Software Process" a discussion on the timeboxing model for iterative development and on inspection process

• In "Requirements Analysis and Specification" a description of Use Cases

• A new chapter on "Software Architecture"

• In "Project Planning" some practical techniques for estimation, scheduling, tracking, risk management, etc.

• In "Object Oriented Design", discussion on UML and on concepts like cohesion, coupling, and open-closed principle

• In "Coding" many additions have been made. These include refactoring, test driven development, and pair programming, as well as a discussion on common coding defects, coding standards, and some useful coding practices.

• In "Testing" a discussion on pair-wise testing as an approach for functional testing, defect tracking, and defect analysis and prevention

In addition to the old case study, a new case study has been added. Various work products of the case studies, including the SRS, architecture document, project plan, design document, code, and test plan, have been made available through the Web site.

A Web site has been created for this edition. In addition to outputs of the case studies, implementations of some of some of the examples are also available from the site. The site will soon include presentation slides for teaching, as well as other instructional material like examples and illustrative studies. The URL of the website is:

http://www.cse.iitk.ac.in/Jalote-SEbook

I would like to express my gratitude to many people who helped me in preparing the case study. These include Kapil Narula, Ragesh Jaiswal, Vivek Pandey, Nilesh Lunawat, and Rajneesh Malviya. My special thanks to Vipindeep Vangala and Raghu Lingampally whose help in manuscript and Web site preparation allowed me to focus on the contents.

Pankaj Jalote

Klappentext

An Integrated Approach to Software Engineering introduces software engineering to advanced-level undergraduate and graduate students of computer science. It emphasizes a case-study approach whereby a project is developed through the course of the book, illustrating the different activities of software development. The sequence of chapters is essentially the same as the sequence of activities performed during a typical software project. All activities, including quality assurance and control activities, are described in each chapter as integral activities for that phase of development. Similarly, the author carefully introduces appropriate metrics for controlling and assessing the software process.

Chapters in this revised edition, updated for today's standards, include these new features:

• Software Process: a discussion on the timeboxing model for iterative development and on inspection process
• Requirements Analysis and Specification: a description of Use Cases
• Software Architecture: an additional chapter for this edition
• Project Planning: some practical techniques for estimation, scheduling, tracking, and risk management
• Object Oriented Design: a discussion on UML and on concepts such as cohesion, coupling and open-closed principle
• Coding: sections on refactoring, test driven development, pair programming, common coding defects, coding standards, and some useful coding practices
• Testing: a presentation on pair-wise testing as an approach for functional testing, defect tracking, and defect analysis and prevention

The text, bolstered by numerous examples and chapter summaries, imparts to the reader the knowledge, skills, practices and techniques needed to successfully execute a software project.

ISBN 0-387-20881-X

springeronline.com

Register

Index

A

Abstract data type, 310
Abstraction, 251
- data, 253
- functional, 252
Acceptance testing, 506
Accessing uninitialized memory, 395
Activity diagram, 340
Adaptive maintenance, 7
Aggregation, 314, 335
Agile approach, 46
Algorithm design, 374
All defs criterion, 493
All uses criterion, 493
Alternate statement rule, 439
Analysis, 85, 89, 149
- data flow modeling, see Structured analysis
- for Case Study 1 (Scheduling), 152
- for Case Study 2 (PIMS), 156
- informal approach, 90
- level of detail, 87
- object-oriented analysis, see Objectoriented analysis
- problem partitioning, 89
- projection, 89
- prototyping, see Prototyping
- similarity with design, 87
- structured analysis, see Structured analysis
- transition to specification, 87, 117
Architecture, see Software architecture

Architecture description language, 193
Assignment axiom, 438
Associations, 105
Axiomatic approach for verification, 437
- alternate statement rule, 439
- an example, 441
- assignment axiom, 438
- iteration rule, 440
- loop invariant, 441
- post condition, 437
- pre condition, 437
- program specification, 438
- rule of composition, 439
- rule of consequence, 440

B

Base class, 315
Behavioral testing, see Black-box testing
Black-box testing, 472
- boundary value analysis, 475
- cause effect graphing, 477
- equivalence class partitioning, 473
- error guessing, 483
- example, 475, 476, 478, 481, 485
- pair-wise testing, 480
- state-based testing, see State-based testing

Bottom up design, 254
Bottom-up approach to coding, 409
Boundary value analysis, 475
- an example, 476
- selecting test cases, 476
Branch testing, 489
Buffer overflow, 397
Bug, see Fault, Error

Build process, 416

C

Capability Maturity Model, 15, 70
Case study 1 (Scheduling)

- design analysis, 299 

- design metrics, 299
- development process, 245
- estimation, 245
- implementation of 00
- design, 463
- implementation of the function-oriented design, 462
- object-oriented design, 364
- problem analysis, 152
- project planning, 245
- software architecture, 203
- structured design, 294
- test plan, 539
Case study 2 (PIMS)
- development process, 246
- estimation, 246
- implementation of the design, 463
- object-oriented design, 368
- problem analysis, 156
- project planning, 246
- software architecture, 203
- test plan, 540
Causal analysis of defects, 517
Cause effect graphing, 477
- an example, 478
- selecting test cases, 479
Cause-effect diagram, 518
- an example, 520
- steps for constructing, 518
Central transforms, 270
Change request frequency, 148
Chief programmer team, 224
Class, 104, 307, 309
- container, 346
- hierarchy, 316
- inheritance, see Inheritance
- methods, 311
- operation types, 310
- relationship to abstract data types 310
- relationship to objects, 310
- state modeling, 378
Class diagram, 104, 331
- drug store example, 105
- restaurant example, 111
Client-server interaction of objects, 312
Client-server style, 181
COCOMO, 215
- cost driver attributes, 216
- distribution with phases, 216
- effort multipliers, 216
- example, 218
- project types, 215
- schedule distribution, 221
- schedule estimation, 220
Code inspection, 429
Code inspection checklist, 429
Code reading, 430
Code verification, 429, 457
- code reading, 430
- combining different techniques, 451
- cost effectiveness of techniques, 450
- dynamic analysis, 431
- effectiveness of different techniques, 450
- formal verification, see Axiomatic approach for verification
- inspection, 429
- model checking, 431
- static analsyis, see Static analysis
- unit testing, see Unit testing

Coding, 19, 391
- bottom-up approach, 409
- errors, see Coding errors
- goal of, 391
- incremental coding, 410
- of function-oriented design of case study 1, 462
- of OO design of the case study 1, 463
- of OO design of the case study 2, 463
- pair programming, 413
- process, 409
- refactoring, see Refactoring
- test driven development, 411
- top-down approach, 409
Coding errors
- accessing unitialized memory, 395
- arithmetic exceptions, 396
- array index out of bounds, 396
- buffer overflow, 397
- enumerated data type, 396
- freeing an already freed resource,
- lack of unique addresses, 395
- memory leaks, 393
- NULL dereferencing, 394
- off by one, 396
- string handling, 397
- synchronization, 395
Coding standards, 406
- commenting and layout, 408
- conventions for statements, 407
- conventions on files, 407
- naming conventions, 406
Cohesion, 257, 325, 359
- determining, 260
- levels, 258
Cohesion metric, 387
Collaboration diagram, 337
Combinatorial testing, 481
Commenting, 408
Communicating processes style, 183
Comparison of different V&V techniques, 449
Competent programmer hypothesis, 499
Complexity metrics, 453
Component and connector view, 167, 188, 200
- blackboard style, 179
- client-server style, 181
- communicating processes style, 183
- component types, 169
- components, 167
- connector implementation, 171
- connector type, 170
- connectors, 169
- example, 172
- n-tier structure, 181
- object-oriented style, 182
- peer-to-peer style, 182
- pipe and filter style, 176
- pipe and filter style example, 178
- publish-subscribe style, 182
- shared data style example, 179
- shared-data style, 178
- styles, 176, 200
Configuration management, see Software configuration management Consistency checkers, 382
Constructor of an object, 310
Container classes, 346
Context diagram, 97, 99
Control flow based testing
- an example, 495
- criteria, 488
Control flow graph, 383, 384, 488
Corrective maintenance, 6
Correctness of design, 248
Cost estimation, see Estimation

Cost of correcting errors, 35
Cost of fixing requirement errors, 83
Cost schedule milestone graph, 240
Coupling, 255, 323, 358
- between classes, 358
Coupling effect, 499
Coverage analysis, 503
Critical design review, 381
Cross referencing of requirements, 141
Cyclomatic complexity, 383
Cyclomatic complexity based testing, 491

D

Data abstraction, 253
Data bindings, 386
Data dictionary, 91, 94
- example, 94
- restaurant example, 101
Data flow based testing, 491
- all defs criterion, 493
- all uses criterion, 493
- an example, 495
- def/use graph, 492
Data flow diagram, 91, 267, 346
- common errors, 95
- conventions, 92
- example, 91
- leveled, 94
- restaurant example, 99, 100
- rules for construction, 93
Data flow modeling, see Structured analysis

Debugging, 444
Def/use graph, 492
Defect, 14
- classification, 514
- closure, 515
- life cycle, 513
- logging and tracking, 513
- prevention, see Defect prevention
- severity, 514
- severity classification, 514
- types, 514
Defect arrival and closure trends, 515
Defect distribution, 35
Defect injection and removal cycle, 227
Defect prevention, 36, 516
- an example, 520
- at organization level, 516
- at project level, 516
- causal analysis, 517
- cause-effect diagram, 518
- Pareto analysis, 517
- root cause analysis, 520
- solutions, 520
Defect removal efficiency, 522
Defects, 239
Delphi approach, 236
Depth of inheritance tree, 357
Design, 18
- architecture, see Software architecture

- detailed, see Detailed design
- high level, see System design

Design analysis of the case study, 299
Design constraints, 122
Design heuristics, 276
Design methodology, 248
Design metrics, 283
- graph impurity, 284
- identifying error prone modules, 289
- information flow metrics, 288
- network metrics, 284
- of object-oriented design, see OOD Metrics
- stability, 285
Design principles, 248
Design review, 281, 381
Design review checklist, 282, 381
Design specification, 260, 265
Design verification, 281
Design walkthrough, 380
Desk review, 431
Destructor of an object, 310
Detailed design, 18, 247, 371, 388
- algorithm design, 374
- PDL, 371
- state modeling of classes, 378
- stepwise refinement, 375
- verification, 380
Detailed design review, 381
Development process, 16, 27, 37
- a step, 29
- agile approach, 46
- comparison of models, 50
- entry criteria for a step, 30
- ETVX specification, 30
- exit criteria for a step, 30
- extreme programming, 46
- iterative development, see Iterative development
- iterative enhancement model, 44
- prototyping, see Prototyping
- rational unified process, 46
- spiral model, 45
- timeboxing model, see Timeboxing model
- waterfall model, see Waterfall model

Dynamic analysis, 431
Dynamic binding, 322
Dynamic modeling, 343

E

Efficiency, 13
Efficiency of design, 249
Effort, 239
Effort estimation, see Estimation
Encapsulation, 307
Equivalence class partitioning, 473
- an example, 475
- selecting test cases, 474
ER diagram, 104
Error, 465, see also Defect

Error guessing, 483
Error report, 512
Errors in coding, see Coding errors

Estimation, 208, 242
- a bottom-up approach example, 21
- bottom-up approach, 213
- building models, 211
- COCOMO, see COCOMO
- delphi approach, 209
- for case study 1 (Scheduling), 245
- models, 211
- multivariable models, 215
- person-months, 209
- single variable models, 211
- size estimation, 212
- top-down approach, 212
- uncertainties, 209
Exhaustive testing, 470
External interface requirements, 123
Extreme programming, 46, 413, 417

F

Factoring, 267, 273
Failure, 466
Failure intensity, 523
Fan-in of modules, 276
Fan-out of modules, 276
Fault, see also Error, Defect
- multi-mode, 481
- single-mode, 480
Fault tolerance, 123
Finite state automata, 379
Fishbone diagram, 519
- an example, 520
Formal verification of programs, see Axiomatic approach for verification

Function point analysis, 142
- advantages, 146
- drawbacks, 146
- parameter complexity, 143
- parameters, 143
- relationship to LOC, 145
- unadjusted function points, 144
- weights, 144
Function-oriented design, 247
Function-oriented design of the case study, 294
Functional abstraction, 252
Functional modeling, 345
Functional requirements, 121
Functional testing, see Black-box testing

Functionality, 13

G

Generic types, 347
Graph impurity metric, 284

H

Halstead's measures, 452, 454
Hardware-software cost, 4
High level design, see System design

I

Identifying redundancies in code, 432
Impact analysis, 68
Incremental development, 410, 445, 457
- refactoring, see Refactoring
- test driven development, 411
Industrial strength software, 2, 3, 22
Inflow of a module, 288
Information flow metrics, 288
Information hiding, 401, 402
Inheritance, 104, 315
- base class, 315
- class hierarchy, 316
- multiple, 320
- non-strict, 320
- repeated, 321
- strict, 319
- subclass, 315
- superclass, 315
Inspection process, 54, 74, 429
- checklists, 56
- defect log, 58
- experiments to evaluate benefits, 61
- group review meeting, 56
- guidelines for work products, 60
- moderator, 55
- moderator responsibilities, 59
- overview and preparation, 55
- planning, 55
- reviewer responsibilities, 60
- rework and follow up, 58
- roles and responsibilities, 59
- scribe, 57
- self-preparation log, 56
- self-review, 56
- some characteristics, 54
- summary report, 58
- summary report example, 58
Integration testing, 506
Interaction diagram, 336
Internal documentation of programs, 408
Iron triangle, 15
Ishikawa diagram, 518
ISO9000, 15
Iterative development, 74
- iterative enhancement model, 44
- spiral model, 45
- strengths, weaknesses, and applicability, 50
- timeboxing model, see Timeboxing model

Iterative enhancement model, 44

K

Knot count, 455

L

Lack of cohesion in methods, 359
Layers of abstraction, 254
Least squares approach, 529
Leveled data flow diagram, 94
Levels of testing, 505
Life cycle of a defect, 513
Liskov substitution principle, 329
Live variables, 454
Logic design of modules, 374
Loop invariant, 441

M

Maintainability, 13
Maintenance, 6
- adaptive, 7
- corrective, 6
- costs, 7
Manpower ramp-up in a project, 220
Mean time to failure, 523
Measurements
- defects, 239
- effort, 239
- size, 239
Memory leaks, 393
Methods of a class, 311
Metrics, 21, 383, 451
- cohesion metric, 387
- complexity measures, 453
- cyclomatic complexity, 383
- data bindings, 386
- defect removal efficiency, 522
- for design, see Design metrics
- for object-oriented design, see Metrics for OOD
- function points, see Function point analysis
- graph impurity, 284
- Halstead's, 452
- information flow metrics, 288
- knot count, 455
- live variables, 454
- network metrics, 284
- process metrics, 21
- product metrics, 21
- productivity, 522
- reliability, 521
- size measures, see Size
- span, 455
- stability, 285
- text size, 142
- topological complexity, 456
Metrics analysis of the case study design, 299
Metrics for OOD, 356, 361
- coupling between classes, 358
- depth of inheritance tree, 357
- lack of cohesion in methods, 359
- number of children, 358
- response for a class, 359
- weighted methods per class, 356
Model checking, 431
Modularity, 253, 291
Module size, 403
Monitoring and control, 242
Most abstract inputs, 269
Most abstract outputs, 269
Multi-mode faults, 481
Multiple inheritance, 320
Musa's basic model, see Reliability model

Mutation testing, 498
- competent programmer hypothesis, 499
- coupling effect, 499
- mutants, 499
- mutation operators, 499
- performance, 501

N

Nesting of constructs, 403
Network metrics, 284
Newton-Raphson method, 531
NULL dereferencing, 394

O

Object, 307
- behavior, 308
- constructor, 310
- destructor, 310
- identity, 309
- interface, 307
- relationships between, 312
- state, 308
Object modeling technique, 341, 342
Object-oriented analysis, 103, 342
- aggregation, 104
- assembly, 104
- associations, 105
- attributes, 108
- class, 104
- class diagram, see Class diagram
- defining services, 109
- generalization-specialization, 104
- identifying associations, 109
- identifying attributes, 108
- identifying classes, 107
- identifying structures, 108
- inheritance, 104
- methodology, 107
- relationship to design, 304
- relationship to ER diagram, 104
- restaurant example, 110
- services, 104
- transition to design, 305
- UML, see UML

Object-oriented design, 303
- aggregation, 314
- association between objects, 313
- class diagram, 342
- class hierarchy, 316
- cohesion, 325
- coupling, 323
- defining internal classes and operations, 346
- design guidelines, 329
- design patterns, 303
- dynamic modeling, 343
- functional modeling, 345
- Liskov substitution principle, 329
- methodology, 341
- metrics, see Metrics for OOD
- of case study 1 (Scheduling), 364
- of case study 2 (PIMS), 368
- open-closed principle, 327
- optimization, 347
- rate of returns example, 352
- relationship to analysis, 304
- state modeling of classes, 378
- UML, see UML
- word counting example, 349
OOP testing
- state based testing, 445
Open-closed principle, 327
Operational profile, 524
Orthogonal defect classification, 514
Outflow of a module, 288

P

Pair programming, 413
Pair-wise testing, 480, 481
- an example, 481
- generating test cases, 482
- objective, 481
Pareto analysis of defects, 517
- an example, 517
Partial correctness, 443
Path testing, 490
Peak team size, 220
Peer-to-peer style, 182
Performance requirements, 122
Pipe and filter style, 176
- example, 178
Polymorphism, 315, 321
Portability, 13
Post condition, 437
Postmortem analysis, 53
Pre condition, 437
Predictability of a Process, 31
Problem analysis, see Analysis

Problem of scale, 9
Problem partitioning, 89, 250
Process, see Software process

Process design language (PDL), 371
Process improvement, 36
Process management, 28, 69
- software engineering process group, 28
Process management process, 75
Process model, 26, 37, 73
Process planning, 208
Process Predictability, 31
Process tailoring, 27, 208
Process under statistical control, 32
Productivity, 1, 3, 4, 12, 522
Programmer time distribution, 33
Programming practices, 392, 402
- checking read return value, 404
- coding standards, see Coding standards
- control constructs, 402
- correlated parameters, 405
- empty if, while, 404
- importance of exceptions, 406
- information hiding, 402
- nesting of constructs, 403
- return from finally block, 405
- robustness, 403
- side effects, 403
- switch case with default, 404
- trusted data sources, 405
- use of gotos, 402
- use of user defined types, 402
Programming principles, 392
Project management, 10, 20, 27, 52, 74
- cost estimation, see Estimation
- monitoring and control, see Project monitoring and control

- planning, see Project planning, see Project planning

- postmortem analysis, 53
- process, 52
- project monitoring, 52
- project tracking, 52
- quality, see Quality plan
- relationship with development process, 54
- risk management, see Risk management
- scheduling, see Project scheduling

Project monitoring and control, 52, 237
- activity-level monitoring, 240
- cost schedule milestone graph, 240
- measurements, 239
- milestone analysis, 240
- status reports, 240
Project planning, 20, 52, 207
- case study 1 (Scheduling), 245
- case study 2 (PIMS), 246
- chief programmer team, 224
- democratic teams, 225
- effort estimation, see Estimation
- manpower ramp-up, 220
- peak team size, 220
- process planning, 208
- quality plan, 226, 229
- risk management, see Risk management
- schedule, see Project scheduling
- team structure, 224
Project scheduling, 219, 242
- an example, 223
- detailed schedule, 221
- distribution among different phases, 221
- estimation, 219
- flexibility, 219
- Microsoft project, 222
- milestones, 220
- overall schedule estimation, 219
- square root check, 220
Project tracking, 52
Projection, 89
Prototyping, 41, 74, 113
- cost, 42, 115
- cost-cutting methods, 42
- design prototype, 113
- development, 115
- evolutionary, 113
- horizontal, 114
- process, 41
- process suitability, 43
- restaurant example, 116
- selecting requirements, 114
- strengths, weaknesses, and applicability, 50
- throwaway, 41, 113
- vertical, 115
Proving correctness, see Axiomatic approach for verification

Psychology of testing, 471
Publish-subscribe style, 182

Q

Quality, 5, 12, 13, 82, 465
- defect injection and removal cycle, 227
- management approaches, 228
- procedural approach, 228
- quantitative management approach, 229
- using statistical process control, 229
Quality and productivity, Q&P, 15
Quality attributes, 12
Quality plan, 226, 229

R

Rational unified process, 46
Rayleigh curve, 220
Refactoring, 416
- an example, 419
- bad smells, 422
- impact on design, 418
- objective, 417
- risk mitigation, 418
- test suite, 418
- to improve classes, 426
- to improve hierarchies, 427
- to improve methods, 425
- unit testing, 420
Regression testing, 7, 506
Reliability, 6, 13, 14, 521, 522
- calendar and clock times, 524
- definition, 523
- failure intensity, 523
- mean time to failure, 523
- musa's basic model, see Reliability model
- operational profile, 524
Reliability model, 524
- an example, 532
- assumptions, 524
- failure data, 529
- parameter estimation, 529
- transition to calendar time, 532
Repeated inheritance, 321
Requirement analysis, see Analysis

Requirement change, 8, 15, 28, 84, 148
- change request, 68
- impact analysis, 68
- management process, 67, 148
Requirement errors, 82
Requirement metrics, 142, 150
- change request frequency, 148
- function points, see Function point analysis
- number of errors found, 147
- quality, 147
- text size, 142
Requirement specification, 81, 117, 159
- components, 120
- design constraints, 122
- desired characteristics, 118
- document structure, 125
- external interface requirements, 123
- functional requirements, 121
- IEEE standards, 125
- performance requirements, 122
- specification language, 124
- use cases, see Use cases

Requirement validation, 138
- cross-referencing, 141
- error types, 139
- review checklist, 140
- reviews, 140
Requirements, see Software requirements

Requirements activity, 80
Requirements review, 140
Restaurant example, 99, 110, 116
Reviews, see Inspection process Rework, 7, 8, 84
Risk management, 230, 242
- a practical approach, 237
- activities, 231
- an example, 237
- checklists of frequently occuring risks, 232
- delphi approach, 236
- risk, 230
- risk analysis, 234
- risk assessment, 232
- risk control, 236
- risk exposure, 235
- risk identification, 232
- risk monitoring, 236
- risk prioritization, 234, 237
- top 10
- risks, 232
Root cause analysis of defects, 520

S

Scenario, 130
Scenarios for modeling, 343
Schedule, 12, 239
Security, 123, 398
Semantic objects, 305
Sequence diagram, 335
Severity of defects, 514
Shared-data style, 178
- example, 179
Side effects, 403
Single-entry, single-exit constructs, 400
Single-mode faults, 480
Size, 4, 11, 212, 239, 452
- function points, see Function point analysis
- halstead's measure, 452
- lines of code, 452
- lines of code (LOC), 1, 4
- of some products, 11
Size estimation, 212
Software, 3
- costs, 4, 12
- industrial strength software, 2
- metrics, see Metrics
- problem of scale, 9
- productivity, 4
size, see Size
student system, 2
- Software architecture, 18, 159, 199
- allocation view, 165
- analysis, see Software architecture evaluation
- behavior description, 192
- blackboard style, 179
- case study 1 (Scheduling), 203
- case study 2 (PIMS), 203
- client-server style, 181
- combining views, 193
- communicating processes style, 183
- component and connector view, see Component and connector view
- definition, 160
- deployment view, 188, 340
- description, 161
- description language, 193
- designing, 200
- documenting, 190
- element catalog, 191
- elements, 164
- evaluation, see Software architecture evaluation
- example, 172
- example implementation, 185
- integrity, 185
- layered style, 182
- mismatch with implementation, 188
- module view, 164, 247
- object-oriented style, 182
- peer-to-peer style, 182
- pipe and filter style, 176
- pipe and filter style example, 178
- preserving integrity, 184
- primary view, 191
- publish-subscribe style, 182
- quality attributes, 194
- rationale, 191
- relationship among views, 165
- relationship between elements, 164
- relationship with design, 183
- role in analysis, 163
- role in communication, 161
- role in construction, 162
- role in reuse, 162
- shared data style example, 179
- shared-data style, 178
- stakeholders, 190
- styles, 200
- system context, 191
- views, 163, 165, 200
Software architecture analysis, 188
Software architecture evaluation, 194, 201
- an example, 196
- approaches, 194
- availability analysis, 198
- performance analysis, 189
- quality attributes, 194
- response time analysis, 198
- the ATAM approach, 195, 201
- tradeoffs, 196
Software configuration management, 28, 61, 62, 75, 225, 242, 414
- baselines, 64
- configuration control board, 67
- configuration controller, 67
- configuration identification, 64
- dependency between items, 64
- functionality, 63
- library management, 66
- life of an item, 65
- mechanisms, 64
- plan, 226
- process, 66
- relationship to development process, 62
- source code control, see Source code control status auditing, 67
- version control, 64
Software design, see Design

Software engineering, 2, 22
- definition, 8
- problem domain, 2
Software engineering process group, 28
Software fault, see Fault, Defect, Error

Software inspections, see Inspection process

Software process, 16, 25, 28, 73
- characteristics, 31, 73
- components, 27
- development process, see Development process
- early defect removal, 35
- ETVX specification, 30
- improvement, see Process improvement
- inspection process, see Inspection process
- management, 28
- non-engineering processes, 25
- predictability, 31
- product engineering processes, 28
- project management process, see Project management
- requirement change management process, see Requirement change specification, 29
- support for change, 34
- tailoring, 27, 208
- under statistical control, 32
Software process improvement, 69
Software quality, see Quality

Software Reliability, see Reliability

Software requirement process, 85
Software requirement specification, see Requirement specification

Software requirements, 7, 17, 79, 117, 148
- analysis, see Analysis
- case study 1 (Scheduling), 152
- case study 2 (PIMS), 156
- change, see Requirement change
- consistent, 119
- cost of fixing errors, 83
- definition, 80
- error types, 139
- errors, 82, 83, 139
- impact on development cost, 84
- impact on quality, 82
- metrics, see Requirement metrics
- modifiable, 120
- need, 81
- process, 85
- specification, see Requirement specification
- use cases, see Use cases
- validation, see Requirement validation
- verifiable, 119
Software size, see Size

Source code control, 414
- checkout, 414
- command types, 414
- conflicts, 415
- tools, 65, 414
- version maintenance, 415
Specification, 437
Specification language, 124
Spiral model, 45
Stability metrics for design, 285
Standards compliance, 123
State diagram, 340, 379
State modeling of classes, 378
- an example, 379
State-based testing, 484
- an example, 485
- coverage criteria, 486
- example of selecting test cases, 487
- of classes, 445
- selecting test cases, 485
- state model, 484
- test case selection criteria, 486
Statement coverage criterion, 489
Static analysis, 431
- by compilers, 432
- checkers, 433
- completeness, 432
- cost effectiveness, 436
- data flow anamolies, 432
- false positives, 436
- identifying redundancies, 432
- PREfix, 433
- soundness, 432
Statistical process control, 229
Stepwise refinement, 254, 375
- example, 376
Structural testing, see White-box testing

Structure chart, 261, 271
- an example, 261
- decision representation, 263
- iteration representation, 263
- module types, 263
- of the case study, 297
Structured analysis, 91
- context diagram, 97
- data dictionary, 91
- data flow diagram, 91
- man-machine boundary, 98
- methodology, 96
- modeling the current system, 97
- restaurant example, 99
Structured design methodology, 266, 291
- applying to case study, 294
- central transforms, 270
- design heuristics, 276
- factoring, 267, 273
- first level factoring, 271
- most abstract input, 269
- most abstract output, 269
- steps, 267
- transaction analysis, 277
- transform analysis, 277
Structured programming, 398, 457
Superclass, 315
System design, 18, 247
- abstraction, 251
- bottom up approach, 254
- correctness, 248
- efficiency, 249
- function-oriented design, see Structured design methodology
- modularity, 253
- object-oriented design, see Objectoriented design
- principles, 248
- problem partitioning, 250
- simplicity, 249
- specification, 265
- top down approach, 254
- verification, see Design verification

System testing, 506

T

Team structure, 224
Test case generation, 502
Test case review, 510
Test case specification, 509
Test criterion, 470
- generating test cases, 470
- inclusion or subsumption, 470
- reliability, 470
- validity, 470
Test driven development, 411, 417, 457
Test oracle, 468
Test plan, 507
- of case study 1, 539
- of case study 2, 540
Test summary report, 512
Testing, 3, 19, 465
- acceptance testing, 20, 506
- black-box, see Black-box testing
- defect logging, 513
- deliverables, 509
- error report, 20, 512
- exhaustive, 470
- functional, see Black-box testing
- integration testing, 19, 506
- levels of, 505
- mutation testing, see Mutation testing
- of object-oriented programs, 445
- process, 504
- psychology of, 471
- purpose of, 471
- regression, 7, 506
- structural testing, see White-box testing
- system testing, 19, 506
- test case execution and analysis, 511
- test case review, 510
- test case specification, 509
- test cases, 469
- test criterion, see Test criterion
- test oracle, 468
- test plan, 20, 507
- test report, 20
- test summary report, 512
- unit testing, see Unit testing
- white-box testing, see White-box testing

Testing process, 504
Timeboxing model, 46, 74
- a time box, 47
- execution with three stage time box, 48
- iteration completion times, 48
- pipelined execution of iterations, 47
- stages in a time box, 47
- strengths, weaknesses, and applicability, 50
- suitability, 50
- team size, 49
- team-wise activity, 49
- teams, 49
Tool support for testing, 502
Top down design, 254
Top-down approach to coding, 409
Topological complexity, 456
Total correctness, 443
Transaction analysis, 277
Transform analysis, 277

U

UML, 361
- activity diagram, 340
- aggregation, 335
- association between classes, 331
- class diagram, 331
- class hierarchy representation, 333
- collaboration diagram, 337
- components, subsystems, packages, 339
- interaction diagrams, 336
- part-whole relationship representation, 335
- sequence diagram, 335
- state diagram, 340
- stereotype, 341
- subtype, supertype relationship, 331
- tagged values, 341
- use case diagrams, 341
Unified modeling language, see UML

Unit testing, 19, 444, 458, 505
- an example, 446
- of classes, 420
- with Junit, 446
Usability, 13
Use case diagram, 131
Use cases, 128, 149
- actor, 129
- development, 136
- examples, 132, 136
- extension scenario, 130
- failure conditions, 137
- failure handling, 137
- level of detail, 138
- levels, 137
- main success scenario, 130, 137
- precondition, 132
- primary actor, 129
- refinement, 134
- scenario, 130, 343
- scope, 135
- summary level, 135
- use case diagram, 131
- writing them, 138
User-defined types, 402

V

Verification and Validation (V&V), 227
Verification of code, see Code verification

Verification of detailed design, 380

W

Waterfall model, 37, 74
- impact of linear ordering of phases, 38
- limitations, 40
- outputs, 38
- stages, 37
- strengths, weaknesses, and applicability, 50
Weighted methods per class, 356
Weinberg experiment, 392
White-box testing, 487
- an example, 495
- branch testing, 489
- control flow based, 488
- cyclomatic complexity based testing, 491
- data flow based, 491
- mutation testing, see Mutation testing
- path testing, 490
- statement coverage criterion, 489
- test case generation, 502
- tool support, 502
Work products, 29, 38

Reviews

From the reviews of the third edition: "Engineering and project management are the two major types of skills required in software engineering. This book discusses those skills. ... The book is well written and well organized; it starts with the most basic software engineering concepts, and then goes gradually toward the most advanced ones. The book ends with a comprehensive index, and an up-to-date list of references. I can recommend this book for all teachers who want to present a first course in software engineering for graduate students." (Soraya Kouadri Mostefaoui, ACM Computing Reviews, Vol. 49 (3), March, 2008)