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

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.218.234.83