small medium large xlarge

Software Design X-Rays: Fix Technical Debt with Behavioral Code Analysis


Cover image for Software Design X-Rays

Software Design X-Rays

Fix Technical Debt with Behavioral Code Analysis


Are you working on a codebase where cost overruns, death marches, and heroic fights with legacy code monsters are the norm? Battle these adversaries with novel ways to identify and prioritize technical debt, based on behavioral data from how developers work with code. And that’s just for starters. Because good code involves social design, as well as technical design, you can find surprising dependencies between people and code to resolve coordination bottlenecks among teams. Best of all, the techniques build on behavioral data that you already have: your version-control system. Join the fight for better code!

Printed in full color.

Choose Your Format(s)

  • $24.95 In Stock
    • Beta: What do I get?

  • Ebooks are DRM free.

  • Ebook delivery options.

  • The Paper Book will ship on 2018-02-10 (roughly).

About this Title

Pages: 270 (est)
Published: 2018-02-10
Release: B3.0 (2018-01-05)
ISBN: 978-1-68050-272-5

Use statistics and data science to uncover both problematic code and the behavioral patterns of the developers who build your software. This combination gives you insights you can’t get from the code alone. Use these insights to prioritize refactoring needs, measure their effect, find implicit dependencies between different modules, and automatically create knowledge maps of your system based on actual code contributions.

In a radical, much-needed change from common practice, guide organizational decisions with objective data by measuring how well your development teams align with the software architecture. Discover a comprehensive set of practical analysis techniques based on version-control data, where each point is illustrated with a case study from a real-world codebase. Because the techniques are language neutral, you can apply them to your own code no matter what programming language you use. Guide organizational decisions with objective data by measuring how well your development teams align with the software architecture. Apply research findings from social psychology to software development, ensuring you get the tools you need to coach your organization toward better code.

If you’re an experienced programmer, software architect, or technical manager, you’ll get a new perspective that will change how you work with code.

What You Need

You don’t have to install anything to follow along in the book. The case studies in the book use well-known open source projects hosted on GitHub. You’ll use CodeScene, a free software analysis tool for open source projects, for the case studies. We also discuss alternative tooling options where they exist.

Contents & Extracts

This book is currently in beta, so the contents and extracts will change as the book is developed.

  • Introduction
  • Prioritize and React to Technical Debt
    • Why Technical Debt Isn’t Technical
      • Questioning Technical Debt
      • The Perils of Quantifying Technical Debt
      • Mine the Collective Intelligence of Your Organization
      • Prioritize Improvements Guided by Data
    • Identify Code with High Interest Rates
      • Measure Interest Rates
      • Prioritize Technical Debt with Hotspots
      • Evaluate Hotspots with Complexity Trends
      • Use X-Ray to Get Deep Insights into Code
      • Escape the Technical Debt Trap
      • Exercises
    • Coupling in Time: A Heuristic for the Concept of Surprise
    • Pay off Your Technical Debt
    • The Principles of Code Age
      • Stabilize Code by Age
      • The Three Generations of Code
      • Refactor Your Package Structure
      • Scale from Files to Systems
      • Exercises
  • Work with Large Codebases and Organizations
    • Spot Your System’s Tipping Point
      • Is Software Too Hard?
      • Divide and Conquer with Architectural Hotspots
      • Analyze Subsystems
      • Fight the Normalization of Deviance
      • Toward Team-Oriented Measures
      • Exercises
    • Beyond Conway’s Law
      • Software Architecture Is about Making Choices
      • Measure coordination needs
      • Code Ownership and Diffusion of Responsibility
      • Analyze Operational Team Boundaries
      • Social Groups: The Flip Side to Conway’s Law
      • Combine Social and Technical Information
    • Towards Modular Monoliths through the Social View of Code
      • Dodge the Silver Bullet
      • Layered architectures and the cost of consistency
      • Monolithic Alternatives: Use Case and Feature-Centric
      • Discover Bounded Contexts Through Change Patterns
      • The Perils of Feature Teams
      • Clean and Dirty Architectures
      • Exercises
    • Systems of Systems: Analyzing Multiple Repositories and Microservices
      • Analyze Code in Multiple Repositories
      • Compare Hotspots across Repositories
      • Track change patterns in distributed systems
      • Measure Technical Sprawl
      • Distribution Won’t Cure the Dependency Blues
      • Exercises
    • An Extra Team Member: Predictive and Pro-Active Analyses
      • Detect Deviating Evolutionary Patterns
      • Catch the Absence of Change
      • Guide On- and Off-Boarding with Social Data
      • Off-boarding and knowledge loss
      • Facilitate Retrospectives with Feedback Loops
      • Know the Biases and Workarounds for Behavioral Code Analysis
      • Your code is still a crime scene
      • Exercises


Adam Tornhill is a programmer who combines degrees in engineering and psychology. He’s the founder of Empear, where he designs tools for software analysis. Adam is the author of Your Code as a Crime Scene, Lisp for the Web, and Patterns in C. His other interests include modern history, music, and martial arts.