Beginning Software Engineering

Discover the foundations of software engineering with this easy and intuitive guide

In the newly updated second edition of Beginning Software Engineering, expert programmer and tech educator Rod Stephens delivers an instructive and intuitive introduction to the fundamentals of software engineering. In the book, you’ll learn to create well-constructed software applications that meet the needs of users while developing the practical, hands-on skills needed to build robust, efficient, and reliable software.

The author skips the unnecessary jargon and sticks to simple and straightforward English to help you understand the concepts and ideas discussed within. He also offers you real-world tested methods you can apply to any programming language.

You’ll also get:

• Practical tips for preparing for programming job interviews, which often include questions about software engineering practices
• A no-nonsense guide to requirements gathering, system modeling, design, implementation, testing, and debugging
• Brand-new coverage of user interface design, algorithms, and programming language choices

Beginning Software Engineering doesn’t assume any experience with programming, development, or management. It’s plentiful figures and graphics help to explain the foundational concepts and every chapter offers several case examples, Try It Out, and How It Works explanatory sections.

For anyone interested in a new career in software development, or simply curious about the software engineering process, Beginning Software Engineering, Second Edition is the handbook you’ve been waiting for.

ROD STEPHENS is a former Microsoft MVP, programmer, and award-winning instructor who speaks regularly at programming conferences and users’ group meetings. He has written more than 250 magazine articles as well as 37 books that have been translated into at least ten different languages on topics including C#, Python, and other languages. He runs the popular C# Helper and VB Helper web sites.

Introduction xxvii

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 7

Deployment 9

Maintenance 10

Wrap-Up 10

Everything All at Once 11

Summary 12

What You Learned in This Chapter 13

Chapter 2: Before The Beginning 15

Document Management 16

Historical Documents 19

Email 19

Code 22

Code Documentation 22

Application Documentation 25

Summary 26

What You Learned in This Chapter 27

Chapter 3: The Team 29

Team Features 30

Clear Roles 30

Effective Leadership 30

Clear Goals 31

Consensus 32

Open Communication 32

Support for Risk-Taking 33

Shared Accountability 33

Informal Atmosphere 34

Trust 34

Team Roles 34

Common Roles 35

More-Specialized Roles 36

Informal Roles 36

Roles Wrap-Up 37

Team Culture 37

Interviews 40

Interview Puzzles 40

The Bottom Line 41

Physical Environment 41

Creativity 41

Office Space 43

Ergonomics 43

Work-Life Balance 45

Collaboration Software 46

Searching 46

Overload 47

Outsourcing 47

Summary 48

What You Learned in This Chapter 50

Chapter 4: Project Management 53

Executive Support 54

Project Management 56

PERT Charts 57

Critical Path Methods 62

Gantt Charts 65

Scheduling Software 67

Predicting Times 68

Get Experience 69

Break Unknown Tasks into Simpler Pieces 70

Look for Similarities 71

Expect the Unexpected 71

Track Progress 73

Risk Management 74

Summary 76

What You Learned in This Chapter 79

Chapter 5: Requirements Gathering 81

Requirements Defined 82

Clear 82

Unambiguous 83

Consistent 84

Prioritized 84

Verifiable 88

Words to Avoid 89

Requirement Categories 89

Audience-Oriented

Requirements 90

Business Requirements 90

User Requirements 90

Functional Requirements 91

Nonfunctional Requirements 92

Implementation Requirements 92

FURPS 92

FURPS+ 93

Common Requirements 96

Gathering Requirements 96

Listen to Customers (and Users) 97

Use the Five Ws (and One H) 98

Who 98

What 98

When 98

Where 98

Why 99

How 99

Study Users 99

Refining Requirements 100

Copy Existing Systems 101

Clairvoyance 102

Brainstorm 103

Recording Requirements 106

UML 107

User Stories 107

Use Cases 108

Prototypes 108

Requirements Specification 109

Validation and Verification 110

Changing Requirements 110

Digital Transformation 111

What to Digitize 111

How to Digitize 112

Summary 113

What You Learned in This Chapter 116

Chapter 6: High-Level Design 117

The Big Picture 118

What to Specify 119

Security 119

Hardware 120

User Interface 121

Internal Interfaces 122

External Interfaces 123

Architecture 124

Monolithic 124

Client/Server 125

Component-Based 127

Service-Oriented 128

Data-Centric 130

Event-Driven 130

Rule-Based 130

Distributed 131

Mix and Match 132

Reports 133

Other Outputs 134

Database 135

Audit Trails 136

User Access 136

Database Maintenance 137

NoSQL 137

Cloud Databases 138

Configuration Data 138

Data Flows and States 139

Training 139

UML 141

Structure Diagrams 142

Behavior Diagrams 145

Activity Diagrams 145

Use Case Diagram 146

State Machine Diagram 147

Interaction Diagrams 148

Sequence Diagram 148

Communication Diagram 150

Timing Diagram 150

Interaction Overview Diagram 151

UML Summary 151

Summary 151

What You Learned in This Chapter 152

Chapter 7: Low-Level Design 155

Design Approaches 156

Design-to-Schedule 157

Design-to-Tools 158

Process-Oriented Design 158

Data-Oriented Design 159

Object-Oriented Design 159

Hybrid Approaches 159

High, Low, and Iterative Design 160

OO Design 160

Identifying Classes 161

Building Inheritance Hierarchies 162

Refinement 163

Generalization 165

Hierarchy Warning Signs 167

Object Composition 167

Database Design 168

Relational Databases 168

First Normal Form 170

Second Normal Form 174

Third Normal Form 176

Higher Levels of Normalization 179

When to Optimize 180

Summary 180

What You Learned in This Chapter 182

Chapter 8: Security Design 185

Security Goals 186

Security Types 186

Cybersecurity 188

Shift-Left Security 189

Malware Menagerie 189

Phishing and Spoofing 193

Social Engineering Attacks 195

Crapware 197

Password Attacks 198

User Access 201

Countermeasures 201

Cyber Insurance 202

Summary 203

What You Learned in This Chapter 207

Chapter 9: User Experience Design 209

Design Mindset 210

UI vs. UX 210

UX Designers 211

Platform 212

User Skill Level 214

Beginners and Beyond 216

Configuration 217

Hidden Configuration 218

Models 219

Metaphors and Idioms 220

Case Study: Microsoft Word 221

Design Guidelines 225

Allow Exploration 225

Make the Interface Immutable 227

Support Commensurate Difficulty 227

Avoid State 228

Make Similar Things Similar 228

Provide Redundant Commands 230

Do the Right Thing 231

Show Qualitative Data, Explain Quantitative Data 232

Give Forms Purpose 232

Gather All Information at Once 233

Provide Reasonable Performance 234

Only Allow What’s Right 235

Flag Mistakes 235

Form Design 236

Use Standard Controls 236

Decorating 237

Displaying 237

Arranging 237

Commanding 238

Selecting 238

Entering 239

Display Five Things 240

Arrange Controls Nicely 241

Summary 241

What You Learned in This Chapter 242

Chapter 10: Programming 245

Tools 246

Hardware 246

Network 247

Development Environment 248

Source Code Control 249

Profilers 249

Static Analysis Tools 249

Testing Tools 249

Source Code Formatters 250

Refactoring Tools 250

Training 250

Collaboration Tools 250

Algorithms 251

Top-Down Design 252

Programming Tips and Tricks 255

Be Alert 255

Write for People, Not the Computer 255

Comment First 256

Write Self-Documenting Code 259

Keep It Small 259

Stay Focused 261

Avoid Side Effects 261

Validate Results 262

Practice Offensive Programming 264

Use Exceptions 266

Write Exception Handlers First 266

Don’t Repeat Code 267

Defer Optimization 267

Summary 269

What You Learned in This Chapter 270

Chapter 11: Algorithms 273

Algorithm Study 274

Algorithmic Approaches 275

Decision Trees 275

Knapsack 275

The Eight Queens Problem 276

Exhaustive Search 277

Backtracking 278

Pruning Trees 279

Branch and Bound 279

Heuristics 280

Greedy 281

Divide and Conquer 282

Recursion 283

Dynamic Programming 285

Caching 287

Randomization 287

Monte Carlo Algorithms 287

Las Vegas Algorithms 288

Atlantic City Algorithms 289

State Diagrams 289

Design Patterns 290

Creational Patterns 291

Structural Patterns 291

Behavioral Patterns 292

Design Pattern Summary 293

Parallel Programming 293

Artificial Intelligence 295

Definitions 295

Learning Systems 296

Natural Language Processing 297

Artificial Neural Network 297

Deep Learning 297

Expert System 298

Artificial General Intelligence 298

Algorithm Characteristics 301

Summary 302

What You Learned in This Chapter 304

Chapter 12: Programming Languages 307

The Myth of Picking a Language 308

Language Generations 311

First Generation 311

Second Generation 311

Third Generation (3GL) 312

Fourth Generation 313

Fifth Generation 314

Sixth Generation 314

IDEs 315

Language Families 316

Assembly 316

Imperative 317

Procedural 317

Declarative 318

Object-Oriented 318

Functional 319

Specialized 319

Language Family Summary 319

The Best Language 319

Summary 323

What You Learned in This Chapter 324

Chapter 13: Testing 327

Testing Goals 329

Reasons Bugs Never Die 330

Diminishing Returns 330

Deadlines 330

Consequences 330

It’s Too Soon 330

Usefulness 331

Obsolescence 331

It’s Not a Bug 331

It Never Ends 332

It’s Better Than Nothing 333

Fixing Bugs Is Dangerous 333

Which Bugs to Fix 334

Levels of Testing 334

Unit Testing 335

Integration Testing 336

Regression Testing 337

Automated Testing 337

Component Interface Testing 338

System Testing 339

Acceptance Testing 340

Other Testing Categories 341

Testing Techniques 342

Exhaustive Testing 342

Black-Box Testing 343

White-Box Testing 344

Gray-Box Testing 344

Testing Habits 345

Test and Debug When Alert 345

Test Your Own Code 346

Have Someone Else Test Your Code 346

Fix Your Own Bugs 348

Think Before You Change 349

Don’t Believe in Magic 349

See What Changed 350

Fix Bugs, Not Symptoms 350

Test Your Tests 350

How to Fix a Bug 351

Estimating Number of Bugs 351

Tracking Bugs Found 352

Seeding 353

The Lincoln Index 353

Summary 355

What You Learned in This Chapter 357

Chapter 14: Deployment 359

Scope 360

The Plan 361

Cutover 362

Staged Deployment 362

Gradual Cutover 363

Incremental Deployment 365

Parallel Testing 365

Deployment Tasks 365

Deployment Mistakes 366

Summary 368

What You Learned in This Chapter 370

Chapter 15: Metrics 371

Wrap Party 372

Defect Analysis 372

Species of Bugs 373

Discoverer 373

Severity 374

Creation Time 374

Age at Fix 374

Task Type 375

Defect Database 376

Ishikawa Diagrams 376

Software Metrics 379

Qualities of Good Attributes and Metrics 381

Using Metrics 382

Process Metrics 384

Project Metrics 384

Things to Measure 385

Size Normalization 387

Function Point Normalization 389

Count Function Point Metrics 390

Multiply by Complexity Factors 391

Calculate Complexity Adjustment Value 392

Calculate Adjusted FP 394

Summary 395

What You Learned in This Chapter 398

Chapter 16: Maintenance 401

Maintenance Costs 402

Task Categories 404

Perfective Tasks 404

Feature Improvements 406

New Features 406

The Second System Effect 407

Adaptive Tasks 408

Corrective Tasks 410

Preventive Tasks 414

Clarification 414

Code Reuse 415

Improved Flexibility 416

Bug Swarms 417

Bad Programming Practices 417

Individual Bugs 418

Not Invented Here 418

Task Execution 419

Summary 420

What You Learned in This Chapter 423

Part II: Process Models

Chapter 17: Predictive Models 427

Model Approaches 428

Prerequisites 428

Predictive and Adaptive 429

Success and Failure Indicators for Predictive Models 430

Advantages and Disadvantages of Predictive Models 431

Waterfall 432

Waterfall with Feedback 433

Sashimi 434

Incremental Waterfall 436

V-model 438

Software Development Life Cycle 439

Summary 442

What You Learned in This Chapter 444

Chapter 18: Iterative Models 445

Iterative vs. Predictive 446

Iterative vs. Incremental 448

Prototypes 449

Types of Prototypes 451

Pros and Cons 451

Spiral 453

Clarifications 455

Pros and Cons 456

Unified Process 457

Pros and Cons 459

Rational Unified Process 459

Cleanroom 460

Cowboy Coding 461

Summary 461

What You Learned in This Chapter 463

Chapter 19: RAD 465

RAD Principles 467

James Martin RAD 470

Agile 471

Self-Organizing Teams 473

Agile Techniques 474

Communication 474

Incremental Development 475

Focus on Quality 478

XP 478

XP Roles 479

XP Values 480

XP Practices 481

Have a Customer On-Site 481

Play the Planning Game 482

Use Stand-Up

Meetings 483

Make Frequent Small Releases 483

Use Intuitive Metaphors 484

Keep Designs Simple 484

Defer Optimization 484

Refactor When Necessary 485

Give Everyone Ownership of the Code 485

Use Coding Standards 486

Promote Generalization 486

Use Pair Programming 486

Test Constantly 486

Integrate Continuously 486

Work Sustainably 487

Use Test-Driven and Test-First Development 487

Scrum 488

Scrum Roles 489

Scrum Sprints 490

Planning Poker 491

Burndown 492

Velocity 494

Lean 494

Lean Principles 494

Crystal 495

Crystal Clear 498

Crystal Yellow 498

Crystal Orange 499

Feature-Driven

Development 500

FDD Roles 501

FDD Phases 502

Develop a Model 502

Build a Feature List 502

Plan by Feature 503

Design by Feature 503

Build by Feature 504

FDD Iteration Milestones 504

Disciplined Agile Delivery 506

DAD Principles 506

DAD Roles 506

DAD Phases 507

Dynamic Systems Development Method 508

DSDM Phases 508

DSDM Principles 510

DSDM Roles 511

Kanban 512

Kanban Principles 513

Kanban Practices 513

Kanban Board 514

Summary 515

What You Learned in This Chapter 517

Part III: Advanced Topics

Chapter 20: Software Ethics 523

Ethical Behavior 524

IEEE-CS/

ACM 524

ACS 525

CPSR 526

Business Ethics 527

NADA 528

Hacker Ethics 529

Hacker Terms 530

Responsibility 531

Gray Areas 533

Software Engineering Dilemmas 535

Misusing Data and the Temptation of Free Data 535

Disruptive Technology 536

Algorithmic Bias 537

False Confidence 537

Lack of Oversight 538

Getting Paid 539

Thought Experiments 539

The Tunnel Problem 540

The Trolley Problem 542

Summary 544

What You Learned in This Chapter 545

Chapter 21: Future Trends 547

Security 548

UX/UI 549

Code Packaging 550

Cloud Technology 551

Software Development 552

Algorithms 553

Tech Toys 554

Summary 555

What You Learned in This Chapter 556

Appendix: Solutions To Exercises 559

Glossary 631

Index 663

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.