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

Length: 256 pages
Edition: 1
Language: English
Publisher: Addison-Wesley Professional
Publication Date: 2021-12-06
ISBN-10: 0137314914
ISBN-13: 9780137314911
Sales Rank: #95691 (See Top 100 Books)

Amplify Your Creativity, Effectiveness, and Personal Fulfillment as a Software Professional

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: first, learning and exploration, and second, 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

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

Project Management Software