Modern Software Engineering: Doing What Works to Build Better Software Faster

Book description

Improve Your Creativity, Effectiveness, and Ultimately, Your Code

In Modern Software Engineering, continuous delivery pioneer David Farley helps software professionals think about their work more effectively, manage it more successfully, and genuinely improve the quality of their applications, their lives, and the lives of their colleagues.

Writing for programmers, managers, and technical leads at all levels of experience, Farley illuminates durable principles at the heart of effective software development. He distills the discipline into two core exercises: learning and exploration and managing complexity. For each, he defines principles that can help you improve everything from your mindset to the quality of your code, and describes approaches proven to promote success.

Farley’s ideas and techniques cohere into a unified, scientific, and foundational approach to solving practical software development problems within realistic economic constraints. This general, durable, and pervasive approach to software engineering can help you solve problems you haven’t encountered yet, using today’s technologies and tomorrow’s. It offers you deeper insight into what you do every day, helping you create better software, faster, with more pleasure and personal fulfillment.

  • Clarify what you’re trying to accomplish

  • Choose your tools based on sensible criteria

  • Organize work and systems to facilitate continuing incremental progress

  • Evaluate your progress toward thriving systems, not just more "legacy code"

  • Gain more value from experimentation and empiricism

  • Stay in control as systems grow more complex

  • Achieve rigor without too much rigidity

  • Learn from history and experience

  • Distinguish "good" new software development ideas from "bad" ones

Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.

Table of contents

  1. Cover Page
  2. About This eBook
  3. Praise for Modern Software Engineering
  4. Title Page
  5. Copyright Page
  6. Pearson’s Commitment to Diversity, Equity, and Inclusion
  7. Dedication
  8. Contents
  9. Foreword
  10. Preface
  11. Acknowledgments
  12. About the Author
  13. Part I What Is Software Engineering?
    1. 1 Introduction
      1. Engineering—The Practical Application of Science
      2. What Is Software Engineering?
      3. Reclaiming “Software Engineering”
        1. How to Make Progress
      4. The Birth of Software Engineering
      5. Shifting the Paradigm
      6. Summary
    2. 2 What Is Engineering?
      1. Production Is Not Our Problem
      2. Design Engineering, Not Production Engineering
      3. A Working Definition of Engineering
      4. Engineering != Code
      5. Why Does Engineering Matter?
      6. The Limits of “Craft”
      7. Precision and Scalability
      8. Managing Complexity
      9. Repeatability and Accuracy of Measurement
      10. Engineering, Creativity, and Craft
      11. Why What We Do Is Not Software Engineering
      12. Trade-Offs
      13. The Illusion of Progress
      14. The Journey from Craft to Engineering
      15. Craft Is Not Enough
      16. Time for a Rethink?
      17. Summary
    3. 3 Fundamentals of an Engineering Approach
      1. An Industry of Change?
      2. The Importance of Measurement
      3. Applying Stability and Throughput
      4. The Foundations of a Software Engineering Discipline
      5. Experts at Learning
      6. Experts at Managing Complexity
      7. Summary
  14. Part II Optimize for Learning
    1. 4 Working Iteratively
      1. Practical Advantages of Working Iteratively
      2. Iteration as a Defensive Design Strategy
      3. The Lure of the Plan
      4. Practicalities of Working Iteratively
      5. Summary
    2. 5 Feedback
      1. A Practical Example of the Importance of Feedback
      2. Feedback in Coding
      3. Feedback in Integration
      4. Feedback in Design
      5. Feedback in Architecture
      6. Prefer Early Feedback
      7. Feedback in Product Design
      8. Feedback in Organization and Culture
      9. Summary
    3. 6 Incrementalism
      1. Importance of Modularity
      2. Organizational Incrementalism
      3. Tools of Incrementalism
      4. Limiting the Impact of Change
      5. Incremental Design
      6. Summary
    4. 7 Empiricism
      1. Grounded in Reality
      2. Separating Empirical from Experimental
      3. “I Know That Bug!”
      4. Avoiding Self-Deception
      5. Inventing a Reality to Suit Our Argument
      6. Guided by Reality
      7. Summary
    5. 8 Being Experimental
      1. What Does “Being Experimental” Mean?
      2. Feedback
      3. Hypothesis
      4. Measurement
      5. Controlling the Variables
      6. Automated Testing as Experiments
      7. Putting the Experimental Results of Testing into Context
      8. Scope of an Experiment
      9. Summary
  15. Part III Optimize for Managing Complexity
    1. 9 Modularity
      1. Hallmarks of Modularity
      2. Undervaluing the Importance of Good Design
      3. The Importance of Testability
      4. Designing for Testability Improves Modularity
      5. Services and Modularity
      6. Deployability and Modularity
      7. Modularity at Different Scales
      8. Modularity in Human Systems
      9. Summary
    2. 10 Cohesion
      1. Modularity and Cohesion: Fundamentals of Design
      2. A Basic Reduction in Cohesion
      3. Context Matters
      4. High-Performance Software
      5. Link to Coupling
      6. Driving High Cohesion with TDD
      7. How to Achieve Cohesive Software
      8. Costs of Poor Cohesion
      9. Cohesion in Human Systems
      10. Summary
    3. 11 Separation of Concerns
      1. Dependency Injection
      2. Separating Essential and Accidental Complexity
      3. Importance of DDD
      4. Testability
      5. Ports & Adapters
      6. When to Adopt Ports & Adapters
      7. What Is an API?
      8. Using TDD to Drive Separation of Concerns
      9. Summary
    4. 12 Information Hiding and Abstraction
      1. Abstraction or Information Hiding
      2. What Causes “Big Balls of Mud”?
      3. Organizational and Cultural Problems
      4. Technical Problems and Problems of Design
      5. Fear of Over-Engineering
      6. Improving Abstraction Through Testing
      7. Power of Abstraction
      8. Leaky Abstractions
      9. Picking Appropriate Abstractions
      10. Abstractions from the Problem Domain
      11. Abstract Accidental Complexity
      12. Isolate Third-Party Systems and Code
      13. Always Prefer to Hide Information
      14. Summary
    5. 13 Managing Coupling
      1. Cost of Coupling
      2. Scaling Up
      3. Microservices
      4. Decoupling May Mean More Code
      5. Loose Coupling Isn’t the Only Kind That Matters
      6. Prefer Loose Coupling
      7. How Does This Differ from Separation of Concerns?
      8. DRY Is Too Simplistic
      9. Async as a Tool for Loose Coupling
      10. Designing for Loose Coupling
      11. Loose Coupling in Human Systems
      12. Summary
  16. Part IV Tools to Support Engineering in Software
    1. 14 The Tools of an Engineering Discipline
      1. What Is Software Development?
      2. Testability as a Tool
      3. Measurement Points
      4. Problems with Achieving Testability
      5. How to Improve Testability
      6. Deployability
      7. Speed
      8. Controlling the Variables
      9. Continuous Delivery
      10. General Tools to Support Engineering
      11. Summary
    2. 15 The Modern Software Engineer
      1. Engineering as a Human Process
      2. Digitally Disruptive Organizations
      3. Outcomes vs. Mechanisms
      4. Durable and Generally Applicable
      5. Foundations of an Engineering Discipline
      6. Summary
  17. Index

Product information

  • Title: Modern Software Engineering: Doing What Works to Build Better Software Faster
  • Author(s): David Farley
  • Release date: December 2021
  • Publisher(s): Addison-Wesley Professional
  • ISBN: 9780137314942