Update cookies preferences

Software Design X-Rays: Fix Technical Debt with Behavioral Code Analysis [Paperback / softback]

4.14/5 (304 ratings by Goodreads)
  • Format: Paperback / softback, 200 pages, height x width: 235x191 mm
  • Pub. Date: 31-May-2018
  • Publisher: Pragmatic Bookshelf
  • ISBN-10: 1680502727
  • ISBN-13: 9781680502725
Other books in subject:
  • Paperback / softback
  • Price: 52,74 €
  • This book is not in stock. Book will arrive in about 2-4 weeks. Please allow another 2 weeks for shipping outside Estonia.
  • Quantity:
  • Add to basket
  • Delivery time 4-6 weeks
  • Add to Wishlist
  • Format: Paperback / softback, 200 pages, height x width: 235x191 mm
  • Pub. Date: 31-May-2018
  • Publisher: Pragmatic Bookshelf
  • ISBN-10: 1680502727
  • ISBN-13: 9781680502725
Other books in subject:

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!

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 towards 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. TThe 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.

Acknowledgments ix
The World of Behavioral Code Analysis xi
Part I Prioritize and React to Technical Debt
1 Why Technical Debt Isn't Technical
3(12)
Questioning Technical Debt
3(3)
The Perils of Quantifying Technical Debt
6(4)
Mine Your Organization's Collective Intelligence
10(3)
Prioritize Improvements Guided by Data
13(2)
2 Identify Code with High Interest Rates
15(20)
Measure Interest Rates
15(4)
Prioritize Technical Debt with Hotspots
19(5)
Evaluate Hotspots with Complexity Trends
24(3)
Use X-Rays to Get Deep Insights into Code
27(4)
Escape the Technical-Debt Trap
31(2)
Exercises
33(2)
3 Coupling in Time: A Heuristic for the Concept of Surprise
35(16)
Uncover Expensive Change Patterns
35(2)
Detect Cochanging Files
37(7)
The Dirty Secret of Copy-Paste
44(2)
The Power of Language-Neutral Analyses
46(2)
Exercises
48(3)
4 Pay Off Your Technical Debt
51(22)
Follow the Principle of Proximity
51(6)
Refactor Congested Code with the Splinter Pattern
57(7)
Build Temporary Tests as a Safety Net
64(3)
Turn Hotspot Methods into Brain-Friendly Chunks
67(3)
The Curse of a Successful System
70(3)
5 The Principles of Code Age
73(20)
Stabilize Code by Age
73(3)
The Three Generations of Code
76(6)
Refactor Your Package Structure
82(5)
Scale from Files to Systems
87(1)
Exercises
87(6)
Part II Work with Large Codebases and Organizations
6 Spot Your System's Tipping Point
93(24)
Is Software Too Hard?
93(3)
Divide and Conquer with Architectural Hotspots
96(4)
Analyze Subsystems
100(7)
Fight the Normalization of Deviance
107(5)
Toward Team-Oriented Measures
112(1)
Exercises
113(4)
7 Beyond Conway's Law
117(24)
Software Architecture Is About Making Choices
117(2)
Measure Coordination Needs
119(6)
Code Ownership and Diffusion of Responsibility
125(4)
Analyze Operational Team Boundaries
129(5)
Social Groups: The Flip Side to Conway's Law
134(4)
Combine Social and Technical Information
138(3)
8 Toward Modular Monoliths through the Social View of Code
141(24)
Dodge the Silver Bullet
141(3)
Layered Architectures and the Cost of Consistency
144(3)
Monolithic Alternatives: Use Case and Feature-Centric
147(4)
Discover Bounded Contexts Through Change Patterns
151(4)
The Perils of Feature Teams
155(6)
Clean and Dirty Architectures
161(1)
Exercises
162(3)
9 Systems of Systems: Analyzing Multiple Repositories and Microservices
165(24)
Analyze Code in Multiple Repositories
165(5)
Compare Hotspots Across Repositories
170(3)
Track Change Patterns in Distributed Systems
173(7)
Measure Technical Sprawl
180(5)
Distribution Won't Cure the Dependency Blues
185(2)
Exercises
187(2)
10 An Extra Team Member: Predictive and Proactive Analyses
189(22)
Detect Deviating Evolutionary Patterns
189(8)
Catch the Absence of Change
197(3)
Guide On- and Offboarding with Social Data
200(5)
Know the Biases and Workarounds for Behavioral Code Analysis
205(2)
Your Code Is Still a Crime Scene
207(2)
Exercises
209(2)
A1 The Hazards of Productivity and Performance Metrics
211(4)
Adaptive Behavior and the Destruction of a Data Source
211(1)
The Situation Is Invisible in Code
212(3)
A2 Code Maat: An Open Source Analysis Engine
215(6)
Run Code Maat
215(1)
Data Mining with Code Maat
215(2)
Visualizations
217(4)
A3 Data Mining with Git, cloc, and CodeScene
221(6)
Behavioral Code Analysis with Git
221(2)
A Brief Introduction to cloc
223(1)
Export Analysis Data from CodeScene
224(3)
A4 Hints and Solutions to the Exercises
227(8)
Solutions: Identify Code with High Interest Rates
227(1)
Solutions: Coupling in Time
228(1)
Solutions: The Principles of Code Age
229(1)
Solutions: Spot Your System's Tipping Point
229(1)
Solutions: Modular Monoliths
230(2)
Solutions: Systems of Systems
232(1)
Solutions: An Extra Team Member
232(3)
Bibliography 235(4)
Index 239
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.