A complete introduction to building robust and reliable software
Beginning Software Engineering demystifies the software engineering methodologies and techniques that professional developers use to design and build robust, efficient, and consistently reliable software. Free of jargon and assuming no previous programming, development, or management experience, this accessible guide explains important concepts and techniques that can be applied to any programming language. Each chapter ends with exercises that let you test your understanding and help you elaborate on the chapter's main concepts. Everything you need to understand waterfall, Sashimi, agile, RAD, Scrum, Kanban, Extreme Programming, and many other development models is inside!
- Describes in plain English what software engineering is
- Explains the roles and responsibilities of team members working on a software engineering project
- Outlines key phases that any software engineering effort must handle to produce applications that are powerful and dependable
- Details the most popular software development methodologies and explains the different ways they handle critical development tasks
- Incorporates exercises that expand upon each chapter's main ideas
- Includes an extensive glossary of software engineering terms
Table of Contents:
Introduction xxi
PART I: SOFTWARE ENGINEERING STEP‐BY‐STEP
CHAPTER 1: SOFTWARE ENGINEERING FROM 20,000 FEET 3
Requirements Gathering 4
High‐Level Design 5
Low‐Level Design 6
Development 6
Testing 6
Deployment 8
Maintenance 9
Wrap‐up 9
Everything All at Once 10
Summary 11
CHAPTER 2: BEFORE THE BEGINNING 15
Document Management 16
Historical Documents 18
E‐mail 19
Code 21
Code Documentation 22
Application Documentation 25
Summary 25
CHAPTER 3: PROJECT MANAGEMENT 29
Executive Support 30
Project Management 31
PERT Charts 33
Critical Path Methods 38
Gantt Charts 41
Scheduling Software 42
Predicting Times 42
Get Experience 44
Break Unknown Tasks into Simpler Pieces 44
Look for Similarities 45
Expect the Unexpected 45
Track Progress 46
Risk Management 47
Summary 49
CHAPTER 4: REQUIREMENT GATHERING 53
Requirements Defined 54
Clear 54
Unambiguous 55
Consistent 56
Prioritized 56
Verifiable 60
Words to Avoid 60
Requirement Categories 61
Audience‐Oriented Requirements 61
Business Requirements 61
User Requirements 62
Functional Requirements 63
Nonfunctional Requirements 63
Implementation Requirements 63
FURPS 64
FURPS+ 64
Common Requirements 66
Gathering Requirements 67
Listen to Customers (and Users) 67
Use the Five Ws (and One H) 68
Who 68
What 68
When 69
Where 69
Why 69
How 69
Study Users 70
Refining Requirements 71
Copy Existing Systems 71
Clairvoyance 73
Brainstorm 74
Recording Requirements 76
UML 77
User Stories 77
Use Cases 78
Prototypes 78
Requirements Specification 80
Validation and Verification 80
Changing Requirements 80
Summary 81
CHAPTER 5: HIGH‐LEVEL DESIGN 87
The Big Picture 88
What to Specify 89
Security 89
Hardware 90
User Interface 91
Internal Interfaces 92
External Interfaces 93
Architecture 94
Monolithic 94
Client/Server 95
Component‐Based 96
Service‐Oriented 97
Data‐Centric 97
Event‐Driven 97
Rule‐Based 98
Distributed 98
Mix and Match 99
Reports 101
Other Outputs 102
Database 102
Audit Trails 103
User Access 103
Database Maintenance 104
Confi guration Data 104
Data Flows and States 105
Training 105
UML 105
Structure Diagrams 107
Behavior Diagrams 109
Activity Diagrams 110
Use Case Diagram 111
State Machine Diagram 112
Interaction Diagrams 113
Sequence Diagram 113
Communication Diagram 114
Timing Diagram 115
Interaction Overview Diagram 115
Summary 116
CHAPTER 6: LOW‐LEVEL DESIGN 119
OO Design 120
Identifying Classes 121
Building Inheritance Hierarchies 122
Refinement 123
Generalization 125
Hierarchy Warning Signs 126
Object Composition 127
Database Design 127
Relational Databases 128
First Normal Form 130
Second Normal Form 134
Third Normal Form 135
Higher Levels of Normalization 137
Summary 138
CHAPTER 7: DEVELOPMENT 143
Use the Right Tools 144
Hardware 144
Network 145
Development Environment 146
Source Code Control 147
Profilers 147
Static Analysis Tools 147
Testing Tools 147
Source Code Formatters 147
Refactoring Tools 148
Training 148
Selecting Algorithms 148
Effective 149
Efficient 149
Predictable 151
Simple 152
Prepackaged 152
Top‐Down Design 153
Programming Tips and Tricks 155
Be Alert 155
Write for People, Not the Computer 156
Comment First 157
Write Self‐Documenting Code 159
Keep It Small 160
Stay Focused 161
Avoid Side Effects 162
Validate Results 163
Practice Offensive Programming 165
Use Exceptions 166
Write Exception Handers First 167
Don’t Repeat Code 167
Defer Optimization 167
Summary 169
CHAPTER 8: TESTING 173
Testing Goals 175
Reasons Bugs Never Die 175
Diminishing Returns 175
Deadlines 175
Consequences 176
It’s Too Soon 176
Usefulness 176
Obsolescence 177
It’s Not a Bug 177
It Never Ends 177
It’s better than Nothing 178
Fixing Bugs Is Dangerous 178
Which Bugs to Fix 179
Levels of Testing 179
Unit Testing 179
Integration Testing 181
Automated Testing 182
Component Interface Testing 183
System Testing 184
Acceptance Testing 185
Other Testing Categories 185
Testing Techniques 186
Exhaustive Testing 186
Black‐Box Testing 187
White‐Box Testing 188
Gray‐Box Testing 188
Testing Habits 189
Test and Debug When Alert 189
Test Your Own Code 189
Have Someone Else Test Your Code 190
Fix Your Own Bugs 192
Think Before You Change 193
Don’t Believe in Magic 193
See What Changed 193
Fix Bugs, Not Symptoms 194
Test Your Tests 194
How to Fix a Bug 194
Estimating Number of Bugs 195
Tracking Bugs Found 195
Seeding 197
The Lincoln Index 197
Summary 198
CHAPTER 9: DEPLOYMENT 203
Scope 204
The Plan 204
Cutover 206
Staged Deployment 206
Gradual Cutover 206
Incremental Deployment 208
Parallel Testing 209
Deployment Tasks 209
Deployment Mistakes 210
Summary 211
CHAPTER 10: METRICS 215
Wrap Party 216
Defect Analysis 216
Kinds of Bugs 217
Discoverer 217
Severity 217
Time Created 218
Age at Fix 218
Task Type 218
Ishikawa Diagrams 219
Software Metrics 222
Qualities of Good Attributes and Metrics 223
Using Metrics 224
Process Metrics 226
Project Metrics 226
Things to Measure 227
Size Normalization 229
Function Point Normalization 231
Count Function Point Metrics 232
Multiply by Complexity Factors 232
Calculate Complexity Adjustment Value 233
Calculate Adjusted FP 235
Summary 235
CHAPTER 11: MAINTENANCE 241
Maintenance Costs 242
Task Categories 243
Perfective Tasks 244
Feature Improvements 245
New Features 245
The Second System Effect 245
Adaptive Tasks 247
Corrective Tasks 248
Preventive Tasks 251
Clarification 252
Code Reuse 253
Improved Flexibility 254
Bug Swarms 254
Bad Programming Practices 255
Individual Bugs 256
Not Invented Here 256
Task Execution 256
Summary 257
PART II: PROCESS MODELS
CHAPTER 12: PREDICTIVE MODELS 265
Model Approaches 266
Prerequisites 267
Predictive and Adaptive 267
Success and Failure Indicators 268
Advantages and Disadvantages 268
Waterfall 270
Waterfall with Feedback 271
Sashimi 272
Incremental Waterfall 273
V‐Model 275
Systems Development Life Cycle 276
Summary 280
CHAPTER 13: ITERATIVE MODELS 283
Iterative Versus Predictive 284
Iterative Versus Incremental 286
Prototypes 287
Types of Prototypes 288
Pros and Cons 289
Spiral 290
Clarifications 293
Pros and Cons 294
Unified Process 295
Pros and Cons 296
Rational Unified Process 297
Cleanroom 298
Summary 299
CHAPTER 14: RAD 303
RAD Principles 305
James Martin RAD 308
Agile 309
Self‐Organizing Teams 311
Agile Techniques 313
Communication 313
Incremental Development 314
Focus on Quality 316
XP 317
XP Roles 318
XP Values 319
XP Practices 319
Have a Customer on Site 320
Play the Planning Game 320
Use Standup Meetings 321
Make Frequent Small Releases 322
Use Intuitive Metaphors 322
Keep Designs Simple 322
Defer Optimization 322
Refactor When Necessary 323
Give Everyone Ownership of the Code 323
Use Coding Standards 324
Promote Generalization 324
Use Pair Programming 324
Test Constantly 324
Integrate Continuously 325
Work Sustainably 325
Use Test‐Driven and Test‐First Development 325
Scrum 327
Scrum Roles 327
Scrum Sprints 328
Planning Poker 329
Burndown 330
Velocity 331
Lean 332
Lean Principles 332
Crystal 333
Crystal Clear 335
Crystal Yellow 336
Crystal Orange 337
Feature‐Driven Development 338
FDD Roles 338
FDD Phases 340
Develop a Model 340
Build a Feature List 340
Plan by Feature 341
Design by Feature 341
Build by Feature 342
FDD Iteration Milestones 342
Agile Unified Process 343
Disciplined Agile Delivery 345
DAD Principles 346
DAD Roles 346
DAD Phases 347
Dynamic Systems Development Method 348
DSDM Phases 348
DSDM Principles 349
DSDM Roles 350
Kanban 351
Kanban Principles 352
Kanban Practices 353
Kanban Board 353
Summary 355
Appendix: Solutions to Exercises 361
Glossary 417
Index 437
