Details

Beginning Software Engineering

2. Aufl.

von: Rod Stephens
35,99 €
Verlag:	Wiley
Format:	EPUB
Veröffentl.:	14.10.2022
ISBN/EAN:	9781119901716
Sprache:	englisch
Anzahl Seiten:	720

In den Warenkorb

Als Gutschein

DRM-geschütztes eBook, Sie benötigen z.B. Adobe Digital Editions und eine Adobe ID zum Lesen.

Beschreibungen

Titelbeschreibung

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: <ul> <li>Practical tips for preparing for programming job interviews, which often include questions about software engineering practices</li> <li>A no-nonsense guide to requirements gathering, system modeling, design, implementation, testing, and debugging</li> <li>Brand-new coverage of user interface design, algorithms, and programming language choices</li></ul>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.

Inhaltsverzeichnis

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

Autorenportrait

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.

Back cover copy

An intuitive and straightforward guide to the foundations of software engineering In the newly revised second edition of Beginning Software Engineering, veteran programmer and award-winning instructor Rod Stephens delivers the fundamentals of software engineering, showing you how to create well-constructed applications that meet users’ needs. You’ll learn the practical, hands-on skills you need to design and build software that’s robust, efficient, and reliable. The author avoids unnecessary jargon and sticks to simple and straightforward English that helps you understand the concepts and ideas he explains in the book. He also provides real-world tested methods you can apply to any programming language, including C#, Java, Python, and more. The book doesn’t assume any experience with programming, development, or management, and uses intuitive case examples and explanatory sections to highlight and simplify more advanced topics for beginning learners. Full of practical tips for preparing for programming job interviews—which often include questions about software engineering practices—and no-nonsense tutorials for requirements gathering, system modeling, design implementation, testing, and debugging, Beginning Software Engineering is perfect for anyone interested in a new career in software development as well as those simply curious about the software engineering process.