Fundamentals of Software Engineering From Coder to Engineer (Nathaniel Schutta, Dan Vega) (Z-Library)

Nathaniel Schutta & Dan Vega From Coder to Engineer Fundamentals of Software Engineering

9 7 8 1 0 9 8 1 4 3 2 3 7 5 6 5 9 9 ISBN: 978-1-098-14323-7 US $65.99 CAN $82.99 SOF T WARE DEVELOPMENT What do you need to know to be a successful software engineer? Undergraduate curricula and bootcamps may teach the fundamentals of algorithms and writing code, but they rarely cover topics vital to your career advancement. With this practical book, you’ll learn the skills you need to succeed and thrive. Authors Nathaniel Schutta and Dan Vega guide your journey with everything from pointers to deep dives into specific topic areas that will help you build the skills that really matter as a software engineer. • Understand what software engineering is—and why communication and other soft skills matter • Learn the basics of software architecture and architectural drivers • Use common and proven techniques to read and refactor code bases • Understand the importance of testing and how to implement an effective test suite • Learn how to reliably and repeatedly deploy software • Know how to evaluate and choose the right solution or tool for a given problem Fundamentals of Software Engineering “ In this book, Dan and Nate quickly teach the essentials that years of formal education often fail to touch on. Their decades of experience shine through these pages as they tactfully distill the many dos and don’ts for professional developers.” Dr. Venkat Subramaniam, award-winning author and founder of Agile Developer, Inc. “Shockingly, no book exists which provides a holistic overview of what software engineering really entails in the modern world...until now. Filling a void that in hindsight seems huge, this book provides an outstanding overview of the many facets of software engineering, told from a practitioner’s standpoint.” Neal Ford, Distinguished Engineer at Thoughtworks Nathaniel T. Schutta is a cloud-focused architect at Thoughtworks. He coauthored Presentation Patterns, wrote Thinking Architecturally and Responsible Microservices, and teaches at the University of Minnesota. He’s also a seasoned speaker who regularly presents at worldwide conferences. Dan Vega, a Spring developer advocate at Broadcom and a Java Champion, has over 20 years of software development experience. A passionate problem-solver, he actively shares knowledge as a blogger, YouTuber, course creator, and speaker, inspiring fellow developers through continuous learning.

Praise for Fundamentals of Software Engineering Nate and Dan have distilled years of experience into amazing insights for both experienced and new developers! —Chris Kramer, principal AI engineer, Thoughtworks There has never been a more important time for a book like this. As early talent navigates the disruption of AI in the job market and the strain remote work places on traditional apprenticeships, this book offers the wisdom and guidance needed to grow, adapt, and succeed. —Christopher M. Judd, president of Judd Solutions In this book, Dan and Nate teach quickly the essentials that years of formal education often fail to touch on. Their decades of experience shine through these pages, as they distil tactfully many dos and don’ts for professional developers. —Dr. Venkat Subramaniam, award-winning author and founder, Agile Developer, Inc. Shockingly, no book exists which provides a holistic overview of what software engineering really entails in the modern world...until now. Filling a void that in hindsight seems huge, this book provides an outstanding overview of the many facets of software engineering, told from a practitioner’s standpoint. Like other books in the Foundations series, this one is an invaluable guide for both new engineers and experienced ones to backfill parts of the ecosystem they haven’t touched (or didn’t know about). Highly recommended. —Neal Ford, distinguished engineer at Thoughtworks

Every professional faces the uncertainty of “unknown unknowns.” How does one even prepare when they don’t know what to expect? How does one traverse unfamiliar terrain without having so much as a map? The journey toward software engineering, the deliberate act of moving away from being a “programmer” to an “engineer” has, for a long time, presented a similar conundrum. You are challenged with a tsunami of buzzwords, left navigating the choppy waters of an ever-changing landscape, and are confronted with the rising tide of AI’s influence in the workplace. It can be a daunting and overwhelming journey, both for newcomers and seasoned veterans alike. Fear not, because Nate and Dan have crafted the map that you’ve been looking for. This book lays out the fundamentals needed to transform your mindset into that of an engineer. This book isn’t about technologies—it’s about the skills that will equip you to not just survive, but thrive in today’s tempestuous enterprise. —Raju Gandhi, software craftsman, technophile, and teacher; author of Head First Software Architecture, Head First Git, and JavaScript Next

Nathaniel Schutta and Dan Vega Fundamentals of Software Engineering From Coder to Engineer

978-1-098-14323-7 [LSI] Fundamentals of Software Engineering by Nathaniel Schutta and Dan Vega Copyright © 2026 Code Monkey LLC and Nathaniel Schutta. All rights reserved. Published by O’Reilly Media, Inc., 141 Stony Circle, Suite 195, Santa Rosa, CA 95401. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://oreilly.com). For more information, contact our corporate/institutional sales department: 800-998-9938 or corporate@oreilly.com. Acquisitions Editor: Louise Corrigan Development Editor: Rita Fernando Production Editor: Aleeya Rahman Copyeditor: Charles Roumeliotis Proofreader: Sharon Wilkey Indexer: Krsta Technology Solutions Cover Designer: Susan Thompson Cover Illustrator: José Marzan Jr. Interior Designer: David Futato Interior Illustrator: Kate Dullea November 2025: First Edition Revision History for the First Edition 2025-10-30: First Release See http://oreilly.com/catalog/errata.csp?isbn=9781098143237 for release details. The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. Fundamentals of Software Engineering, the cover image, and related trade dress are trademarks of O’Reilly Media, Inc. The views expressed in this work are those of the authors and do not represent the publisher’s views. While the publisher and the authors have used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the authors disclaim all responsibility for errors or omissions, including without limitation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsibility to ensure that your use thereof complies with such licenses and/or rights.

For Jen, Isabella, and Juliana, my heart, my world, my everything. —Dan For Christine and Everett, your love and support mean everything to me. —Nate

Table of Contents Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xv 1. Programmer to Engineer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 An Engineer by Any Other Name 1 Fundamentals Matter 2 The Many Paths to Becoming a Software Engineer 3 What You Were Taught Versus What You Need to Know 4 Embrace the Lazy Programmer Ethos 5 The Value of a Fresh Set of Eyes 7 Don’t Solution Too Quickly 8 Apply the Golden Rule to Software 11 Wrapping Up 11 Putting It into Practice 12 Additional Resources 12 2. Reading Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 The Challenge of Working with Existing Code 15 Cognitive Biases 17 Approaching Unfamiliar Code 18 Software Archeology 20 Effective Code-Reading Strategies 25 Leveraging IDE Features 25 Reading Tests for Insight 31 Practice Makes Perfect 33 Wrapping Up 34 Putting It into Practice 35 Additional Resources 35 vii

3. Writing Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 Don’t Reinvent the Wheel 38 What Is Good Code? 39 Less Is More 41 The Zeroth Law of Computer Science 42 Beware Boilerplate Code 42 Favor Composition over Inheritance 42 Favor Short Methods 43 Write Code to Be Read 43 The Problem with Code Comments 45 Tests as Documentation 46 Avoid Clever Code 47 Code Reviews 48 Avoid the Checkbox Code Review 48 It Is Hard to Be Criticized 49 Fostering Trust 50 Learning New Languages 50 Wrapping Up 52 Putting It into Practice 52 Additional Resources 53 4. Modeling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 What Is Software Modeling and Why Do We Do It? 56 Which Diagrams Do You Need? 58 Context Diagrams 60 Component Diagrams 60 Class Diagrams 61 Sequence Diagrams 62 Deployment Diagrams 63 Data Models 65 Additional Diagrams 66 Modeling Best Practices 67 Keep It Simple 67 Know Your Audience 68 Be Careful with Your Color Choices 68 Establish Standards and Templates 69 Tools 69 Wrapping Up 71 Putting It into Practice 71 Additional Resources 72 viii | Table of Contents

5. Automated Testing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 Benefits of Automated Testing 73 Acts as Documentation 74 Improves Maintainability 74 Boosts Your Confidence 75 Leads to Consistency and Repeatability 76 Types of Automated Testing 77 Unit Tests 78 Integration Tests 78 End-to-End Tests 79 What Mix of Tests Should You Be Writing? 79 What You Should Not Test 80 Code Coverage 80 Writing Tests 81 Getting Started 81 Assertions 82 Writing Unit Tests 83 Mocking 84 Writing Integration Tests 86 Writing End-to-End Tests 87 Wrapping Up 88 Putting It into Practice 88 Additional Resources 90 6. Exploring and Modifying Unfamiliar Systems. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 Understanding Unfamiliar Codebases 91 Start with the Big Picture 92 Understand the Execution Flow 95 Build Mental Models Incrementally 105 A Sample Process 109 Making Changes Safely 110 Refactoring Safely 111 The Scout Rule 112 Small, Reversible Changes 114 Wrapping Up 118 Putting It into Practice 118 Additional Resources 119 7. User Interface Design. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 Designing for Everyone 121 What Is Usability? 123 What Is Accessibility? 124 Table of Contents | ix

What Are Localization and Internationalization? 125 Know Your User 126 Secondary Users 127 You Are Not Your User 127 Impact of Culture 129 Maximizing Usability 130 Principles of Design 131 Contrast 131 Repetition 132 Alignment 132 Proximity 133 Applying the Principles of Design 135 Make the Right Thing the Obvious Thing 139 The Importance of Good Error Messages 145 Destructive Actions 146 Wrapping Up 149 Putting It into Practice 149 Additional Resources 150 8. Working with Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Understanding Data Types and Formats 152 Structured Versus Unstructured Data 152 Common Data Formats 155 Specialized Data Considerations 158 Storing Your Data Effectively 160 Database Types and Their Use Cases 161 Data Persistence and Management 166 Database Connections and Transactions 170 Consistency Models and Caching Strategies 171 Planning for Data Growth 177 Querying and Managing Data Performance 179 Efficient Query Writing 179 Tools and Best Practices 183 Data Migration and Transformation 188 Understanding Data Movement Fundamentals 188 Handling Schema Changes 190 Wrapping Up 193 Putting It into Practice 194 Additional Resources 195 9. Software Architecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 What Is Architecture? 197 x | Table of Contents

Trade-Offs 199 Architecture Versus Design 201 Quality Attributes 202 Identifying Quality Attributes 203 Gaining Stakeholder Alignment 204 Architectural Styles 206 The Agile Architect 206 Fitness Functions 208 Architectural Diagrams 209 Architectural Decision Records 210 Wrapping Up 212 Putting It into Practice 212 Additional Resources 213 10. To Production. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 The Complexities of Production Environments 216 Users Are Unpredictable 216 “But It Works on My Machine” 217 Building Production-Ready Code 220 Performance Optimization 220 Environment-Specific Configurations 221 Error Handling and Logging 225 Security Essentials 226 Deployment Pipeline 233 Deployment Environments 234 Version Control Strategies 235 Deployment Automation 239 Deployment Strategies 243 Continuous Integration and Continuous Deployment 244 Production System Monitoring and Maintenance 248 Monitoring 248 System Maintenance 249 Wrapping Up 251 Putting It into Practice 252 Additional Resources 253 11. Powering Up Your Productivity. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 Optimizing Your Development Environment 255 Know Your Development Tools 256 Build Your Own Lightsaber 256 Leverage the Power of the Command Line 258 Harness the Power of Keyboard Shortcuts 260 Table of Contents | xi

Strategic Automation 263 The Perpetual Pursuit of Productive Habits 264 Collaborative Learning 264 Personal Knowledge Management 265 Wrapping It Up 267 Putting It into Practice 267 Additional Resources 268 12. Learning to Learn. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 Cramming Doesn’t Work 270 Skills Acquisition 271 The Learning Habit 273 Learning Through AI 275 Fear of Missing Out 278 Where Should You Invest Your Time? 280 Practice Innovation 281 Architectural Briefings 283 Practice Grace 284 Wrapping Up 285 Putting It into Practice 285 Additional Resources 286 13. Mastering Soft Skills in the Tech World. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 Collaborative Communication 288 Communication Channels 288 Enterprise Operator 295 Know Your Audience 297 Practicing Influence 297 Understanding and Articulating Value 298 Strategic Approaches to Influence 298 Stakeholder Management 300 Time Management 301 Maker’s Schedule 302 Staying on Task 303 Wrapping Up 304 Putting It into Practice 304 Additional Resources 304 14. Career Management. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 Plan Your Career Path 305 Find What You’re Passionate About 306 Exploring Your Career Options 308 xii | Table of Contents

Walking Backward from Your Goals 312 Deliberate Skill Acquisition 313 Aligning Career Choices with Life Phases 316 Walking Your Career Path 319 Celebrate and Record Your Wins 319 Overcome Imposter Syndrome 320 Build Your Professional Community 322 Cultivating Your Professional Relationships 325 Acing Your Next Interview 326 Create Work–Life Balance 334 Wrapping Up 338 Putting It into Practice 339 Additional Resources 340 15. The AI-Powered Software Engineer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 What Is AI Really? 342 Demystifying AI Terminology 342 Understanding AI’s Capabilities and Limitations 348 AI as Your Pair Programmer 351 Standalone Chatbot Assistants 351 Inline IDE Assistants 352 Agentic AI IDE Environments 353 Prompt Engineering Fundamentals 355 What Is Prompt Engineering? 355 Essential Prompt Engineering Techniques 356 Advanced Prompt Engineering Techniques 358 How AI Might Shape Software Engineering 360 Will AI Take My Job? 361 Vibe Code Reviews 362 AI as Your Force Multiplier: From Writing Code to Problem-Solving 365 Wrapping Up 367 Putting It into Practice 368 Additional Resources 368 Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 Table of Contents | xiii

Preface Programmer, coder, developer—there are any number of titles used to describe peo‐ ple who create software, but what does it mean to be a software engineer? Despite the way software is often taught, being a software engineer is about far more than simply producing syntactically correct programs. Boot camps and universities typically focus on the mechanical aspects of writing code, creating people who are well-versed in programming. The body of knowledge required today to be a successful software engineer goes beyond learning a program‐ ming language; you must be well-versed in the full lifecycle of a software product. You must have a comprehensive understanding of more than just the syntax and grammar of a programming language; you must be well-versed in testing, architec‐ ture, modeling, and more. You must know how to work effectively with legacy code and how to reliably and repeatedly deploy code to production. To excel, be promoted, and to work on the most interesting projects, you must move beyond merely writing code; you must apply engineering principles across the entire development process. Even in the era of artificial intelligence (AI) and agentic coding tools, you must have a solid grasp of the fundamentals to wield AI tools properly. There are many paths to becoming a software engineer, from associate’s and under‐ graduate programs in computer science to intensive boot camps to teach yourself (Figure P-1). Early in your software engineering career, it can feel like you’ve just taken your first steps into a larger world. It can be overwhelming. We know, we’ve been there! Regardless of your background, if you’re a newly minted practitioner, you soon discover there is a vast array of critical topics you weren’t taught as part of a standard curriculum and skills you don’t have, which prevents you from advancing to more senior roles. xv

1 A contributing factor to the prevalence of imposter syndrome (discussed in Chapter 14) in the software industry. Figure P-1. There is a gap between what early-career software engineers are taught versus what they need in order to be successful and advance in their career There is a gap between what you learn in a boot camp or a computer science degree and what you need to know to become a successful software engineer.1 (Technical companies like Thoughtworks have stringent hiring practices, yet they still send their new hires through a boot camp, and they aren’t alone.) This book attempts to bridge that gap by giving you the context and grounding you need to chart your career path and helping you identify opportunities for personal and professional growth. Think of it as an onboarding guide for the early talent software engineer. This book aims to be your guide on that journey, to show you the things you may not know you don’t know. Who This Book Is For This book is specifically designed for new software engineers. Our goal is to show you the bigger picture of what it takes to become a true software engineer, beyond “just coding,” and what it takes to advance your career. xvi | Preface

But the fundamentals that we’ll discuss in this book aren’t just for beginners. Experi‐ enced engineers can also benefit from mastering these essential skills, especially if they’re looking to move up and take on more senior roles. Building a strong skill set is what will unlock opportunities for more responsibilities and promotion. What You Will Learn What are the skills you need to succeed and thrive? What separates the beginner from the experienced software engineer? From reading code, to writing code that’s readable, to testing, to work–life balance, to learning to learn—we will tell you everything you need to know (and even some things you didn’t know you needed to know). Most software engineers learn these things through trial and error, sometimes costing their projects dearly. But it doesn’t have to be that way! These skills are the fundamentals of software engineering that will set you up for a successful career and—unlike the flavor-of-the-day framework or the trendy language—these skills will last a lifetime. While this book isn’t meant to be an in-depth guide to any one topic, it will show you the universe of topics within software engineering, so you have enough information to understand the basic concepts. Throughout the book, we will share stories and experiences from our careers, giving you an opportunity to learn from our mistakes. Each chapter concludes with relevant resources and practical exercises to help you practice what you’ve learned. If a partic‐ ular chapter resonates with you, we encourage you to dive in and explore the topic! Navigating This Book Just as there is no one path to becoming a software engineer, there are many ways to approach this material. While most readers will likely begin by reading this book cover to cover, you can also “choose your own adventure” by reading chapters based on whatever topic interests you at the moment. As you progress in your career, tackle new projects, and encounter newly relevant topics, you may want to return to certain chapters for guidance. The book is broken into four sections. Part 1 begins with the core skills you need to be a successful software engineer. Part 2 explores the various technical practices you will encounter on projects, while Part 3 dives into the nuances of designing and building software. Part 4 focuses on your career growth and steps you can follow to take control of your journey. Preface | xvii

Here’s what you’ll find in this book: Part 1: Core Skills • Chapter 1, “Programmer to Engineer”, discusses the varied paths to becoming a software engineer and emphasizes the importance of foundational skills. • Chapter 2, “Reading Code”, is about how software engineers spend more time reading code than writing it. It provides strategies for navigating unfamiliar code. • Chapter 3, “Writing Code”, is all about the importance of writing code that is readable and maintainable. In essence, it illustrates why it’s more important to write for the developer than the computer. Part 2: Technical Practices • Chapter 4, “Modeling”, dives into the role of software modeling, aka the box- and-line diagrams you have encountered (or will encounter) on many projects, as a crucial aspect of communication among software engineers. • Chapter 5, “Automated Testing”, covers the benefits of automated testing for code quality and developer confidence. • Chapter 6, “Exploring and Modifying Unfamiliar Systems”, highlights strategies for effectively working with existing codebases. Whether you’re joining a new team or maintaining a legacy system, these skills will help you confidently con‐ tribute to any codebase. Part 3: Application Development and Design • Chapter 7, “User Interface Design”, is an overview of user interface design. It explains why understanding the user and applying design principles will help ensure that your software meets your users’ needs. • Chapter 8, “Working with Data”, is all about working with data, something nearly every software application does in some manner. It covers the essential skills you need to know to make informed decisions about data in your applications • Chapter 9, “Software Architecture”, explores the complexities of software archi‐ tecture, giving you some insights into the architectural trade-offs involved in every software project. • Chapter 10, “To Production”, talks about taking code to production. It discusses the unpredictability of real users and environments, and outlines strategies for building production-ready code. Part 4: Professional Development and Growth • Chapter 11, “Powering Up Your Productivity”, returns to your day-to-day work and the importance of building your personal toolkit. • Chapter 12, “Learning to Learn”, covers the importance of continuous learning. The chapter offers strategies for keeping up with an ever-changing field. xviii | Preface