Librería Portfolio

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 Defi ned 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

Configuration 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

Multipl