Beginning Software Engineering

by Stephens, Rod

• ISBN13: 9781118969144
• ISBN10: 1118969146
• Edition: 1st
• Format: Paperback
• Copyright: 2015-03-23
• Publisher: Wrox

Summary

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

Author Biography

About the author

Rod Stephens started out as a mathematician, but while studying at MIT he discovered the joys of computer algorithms and has been programming professionally ever since. The author of more than 30 books, Rod is an award-winning instructor who speaks regularly at programming conferences and user's group meetings.

Visit us at wrox.com where you have access to free code samples, Programmer to Programmer forums, and discussions on the latest happenings in the industry from around the world.

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