0%

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
    2. Engineering—The Practical Application of Science
    3. What Is Software Engineering?
    4. Reclaiming “Software Engineering”
    5. How to Make Progress
    6. The Birth of Software Engineering
    7. Shifting the Paradigm
    8. Summary
    9. 2 What Is Engineering?
    10. Production Is Not Our Problem
    11. Design Engineering, Not Production Engineering
    12. A Working Definition of Engineering
    13. Engineering != Code
    14. Why Does Engineering Matter?
    15. The Limits of “Craft”
    16. Precision and Scalability
    17. Managing Complexity
    18. Repeatability and Accuracy of Measurement
    19. Engineering, Creativity, and Craft
    20. Why What We Do Is Not Software Engineering
    21. Trade-Offs
    22. The Illusion of Progress
    23. The Journey from Craft to Engineering
    24. Craft Is Not Enough
    25. Time for a Rethink?
    26. Summary
    27. 3 Fundamentals of an Engineering Approach
    28. An Industry of Change?
    29. The Importance of Measurement
    30. Applying Stability and Throughput
    31. The Foundations of a Software Engineering Discipline
    32. Experts at Learning
    33. Experts at Managing Complexity
    34. Summary
  14. Part II Optimize for Learning
    1. 4 Working Iteratively
    2. Practical Advantages of Working Iteratively
    3. Iteration as a Defensive Design Strategy
    4. The Lure of the Plan
    5. Practicalities of Working Iteratively
    6. Summary
    7. 5 Feedback
    8. A Practical Example of the Importance of Feedback
    9. Feedback in Coding
    10. Feedback in Integration
    11. Feedback in Design
    12. Feedback in Architecture
    13. Prefer Early Feedback
    14. Feedback in Product Design
    15. Feedback in Organization and Culture
    16. Summary
    17. 6 Incrementalism
    18. Importance of Modularity
    19. Organizational Incrementalism
    20. Tools of Incrementalism
    21. Limiting the Impact of Change
    22. Incremental Design
    23. Summary
    24. 7 Empiricism
    25. Grounded in Reality
    26. Separating Empirical from Experimental
    27. “I Know That Bug!”
    28. Avoiding Self-Deception
    29. Inventing a Reality to Suit Our Argument
    30. Guided by Reality
    31. Summary
    32. 8 Being Experimental
    33. What Does “Being Experimental” Mean?
    34. Feedback
    35. Hypothesis
    36. Measurement
    37. Controlling the Variables
    38. Automated Testing as Experiments
    39. Putting the Experimental Results of Testing into Context
    40. Scope of an Experiment
    41. Summary
  15. Part III Optimize for Managing Complexity
    1. 9 Modularity
    2. Hallmarks of Modularity
    3. Undervaluing the Importance of Good Design
    4. The Importance of Testability
    5. Designing for Testability Improves Modularity
    6. Services and Modularity
    7. Deployability and Modularity
    8. Modularity at Different Scales
    9. Modularity in Human Systems
    10. Summary
    11. 10 Cohesion
    12. Modularity and Cohesion: Fundamentals of Design
    13. A Basic Reduction in Cohesion
    14. Context Matters
    15. High-Performance Software
    16. Link to Coupling
    17. Driving High Cohesion with TDD
    18. How to Achieve Cohesive Software
    19. Costs of Poor Cohesion
    20. Cohesion in Human Systems
    21. Summary
    22. 11 Separation of Concerns
    23. Dependency Injection
    24. Separating Essential and Accidental Complexity
    25. Importance of DDD
    26. Testability
    27. Ports & Adapters
    28. When to Adopt Ports & Adapters
    29. What Is an API?
    30. Using TDD to Drive Separation of Concerns
    31. Summary
    32. 12 Information Hiding and Abstraction
    33. Abstraction or Information Hiding
    34. What Causes “Big Balls of Mud”?
    35. Organizational and Cultural Problems
    36. Technical Problems and Problems of Design
    37. Fear of Over-Engineering
    38. Improving Abstraction Through Testing
    39. Power of Abstraction
    40. Leaky Abstractions
    41. Picking Appropriate Abstractions
    42. Abstractions from the Problem Domain
    43. Abstract Accidental Complexity
    44. Isolate Third-Party Systems and Code
    45. Always Prefer to Hide Information
    46. Summary
    47. 13 Managing Coupling
    48. Cost of Coupling
    49. Scaling Up
    50. Microservices
    51. Decoupling May Mean More Code
    52. Loose Coupling Isn’t the Only Kind That Matters
    53. Prefer Loose Coupling
    54. How Does This Differ from Separation of Concerns?
    55. DRY Is Too Simplistic
    56. Async as a Tool for Loose Coupling
    57. Designing for Loose Coupling
    58. Loose Coupling in Human Systems
    59. Summary
  16. Part IV Tools to Support Engineering in Software
    1. 14 The Tools of an Engineering Discipline
    2. What Is Software Development?
    3. Testability as a Tool
    4. Measurement Points
    5. Problems with Achieving Testability
    6. How to Improve Testability
    7. Deployability
    8. Speed
    9. Controlling the Variables
    10. Continuous Delivery
    11. General Tools to Support Engineering
    12. Summary
    13. 15 The Modern Software Engineer
    14. Engineering as a Human Process
    15. Digitally Disruptive Organizations
    16. Outcomes vs. Mechanisms
    17. Durable and Generally Applicable
    18. Foundations of an Engineering Discipline
    19. Summary
  17. Index
18.224.37.68