
Software Structure by Design
A Practical Handbook of Clean Architecture, Modular Design, Refactoring, and Maintainable SoftwareBy Rohan DasguptaLength14h 43m
About this audiobook
You already know your codebase is hard to change. This book tells you which decisions made it that way and what to do next.
Software structure is not a matter of taste. It is a set of decisions about coupling, cohesion, and dependency direction that determine how much every future change will cost. Software Structure by Design is a practical handbook for developers, tech leads, and anyone inheriting a codebase they did not design. It shows you how to read the structure you have, understand why it resists change, and reshape it without stopping delivery.
The book moves from principles to boundaries to the hard work of making structure stick. You will learn to treat coupling and cohesion as a cost you can measure, invert dependencies so frameworks and databases sit at the edges instead of the centre, and draw component boundaries that survive a release. Separate chapters handle the database boundary, the web boundary, and the honest trade between a modular monolith and services. Then you make the structure durable with fitness checks, the humble object pattern, characterisation tests, strangler migrations, and decision records. A complete worked application runs through every boundary at the end, tying the techniques together.
What you will learn:
• Read coupling and cohesion as a cost, not an abstraction, and use that reading to prioritise refactoring
• Apply paradigms as constraints that shape design rather than as academic rules
• Put design principles to work in real code, including dependency inversion and stable abstractions
• Draw component boundaries that hold up across releases and team changes
• Design the domain layer so business rules stay independent of delivery mechanisms
• Place the database and the web/UI at the edges with clear, testable boundaries
• Choose between a modular monolith and services based on honest trade-offs, not fashion
• Test the architecture itself with fitness checks, characterisation tests, and the humble object pattern
• Refactor toward structure safely using strangler migrations and document decisions so the structure survives
Written for developers, tech leads, and architects who need to improve an existing system rather than start from a blank page, this book assumes you can write code and want to make the code you have easier to change. If you are responsible for a codebase that has grown beyond its original design, this handbook gives you a clear path from diagnosis to durable structure.
Audiobook details
Rating★★★★★ 4.8 (10)
Includes Amazon
GenreTechnology
Length14 hrs 43 mins
Narrated byListen with 1,000+ voices
FormateBook with Audio
Publish dateSep 27, 2026
LanguageEnglish
Table of contents
1Software Structure by Design
2Foreword
3Preface
4About This Book
5Chapter 1: What Structure Buys You
Show all chaptersShow less
61.1 The Cost of Change
71.2 Coupling as a Cost Multiplier
81.3 Cohesion and the Shape of a Module
91.4 Reading a Codebase for Structure
101.5 Architecture Shows Up in Delivery Speed
111.6 What This Book Will and Will Not Claim
12Chapter 2: Paradigms as Constraints
132.1 Structured Programming as Control-Flow Discipline
142.2 Object Orientation as Dependency Direction
152.3 Functional Programming as State Restriction
162.4 Choosing Constraints Deliberately
17Chapter 3: Design Principles in Practice
183.1 Single Responsibility as Reason to Change
193.2 Open-Closed and the Shape of Extension Points
203.3 Substitution and Honest Contracts
213.4 Interface Segregation and Client-Side Shape
223.5 Dependency Inversion and Who Owns the Interface
233.6 When Principles Conflict
24Chapter 4: Component Boundaries
254.1 What a Component Is
264.2 Cohesion Principles for Components
274.3 Coupling Principles for Components
284.4 Breaking Cycles
294.5 Release Units and Versioning Discipline
30Chapter 5: Dependency Direction and Inversion
315.1 Plugin Architecture and the Direction of Control
325.2 Ports and Adapters
335.3 Keeping Frameworks at the Edge
345.4 Boundary Crossing Costs
35Chapter 6: The Domain Layer
366.1 Entities and Identity
376.2 Value Objects
386.3 Use Cases as Application Operations
396.4 Invariants and Where They Live
406.5 Keeping the Domain Free of Frameworks
41Chapter 7: Boundaries for the Database
427.1 Repositories as Domain-Facing Ports
437.2 Mapping Between Domain and Schema
447.3 The Schema as a Replaceable Detail
457.4 Transactions and Consistency Boundaries
467.5 Migrating the Schema Safely
47Chapter 8: Boundaries for the Web and UI
488.1 Controllers as Thin Translators
498.2 Request and Response Models
508.3 Presenters and View Models