Atjaunināt sīkdatņu piekrišanu

Your Code As A Crime Scene [Mīkstie vāki]

3.72/5 (448 ratings by Goodreads)
  • Formāts: Paperback / softback, 190 pages, colour illustrations
  • Izdošanas datums: 05-May-2015
  • Izdevniecība: The Pragmatic Programmers
  • ISBN-10: 1680500384
  • ISBN-13: 9781680500387
Citas grāmatas par šo tēmu:
  • Mīkstie vāki
  • Cena: 47,34 €*
  • * Šī grāmata vairs netiek publicēta. Jums tiks paziņota lietotas grāmatas cena
  • Šī grāmata vairs netiek publicēta. Jums tiks paziņota lietotas grāmatas cena.
  • Daudzums:
  • Ielikt grozā
  • Pievienot vēlmju sarakstam
  • Formāts: Paperback / softback, 190 pages, colour illustrations
  • Izdošanas datums: 05-May-2015
  • Izdevniecība: The Pragmatic Programmers
  • ISBN-10: 1680500384
  • ISBN-13: 9781680500387
Citas grāmatas par šo tēmu:

Jack the Ripper and legacy codebases have more in common than you'd think. Inspired by forensic psychology methods, you'll learn strategies to predict the future of your codebase, assess refactoring direction, and understand how your team influences the design. With its unique blend of forensic psychology and code analysis, this book arms you with the strategies you need, no matter what programming language you use.

Software is a living entity that's constantly changing. To understand software systems, we need to know where they came from and how they evolved. By mining commit data and analyzing the history of your code, you can start fixes ahead of time to eliminate broken designs, maintenance issues, and team productivity bottlenecks.

In this book, you'll learn forensic psychology techniques to successfully maintain your software. You'll create a geographic profile from your commit data to find hotspots, and apply temporal coupling concepts to uncover hidden relationships between unrelated areas in your code. You'll also measure the effectiveness of your code improvements. You'll learn how to apply these techniques on projects both large and small. For small projects, you'll get new insights into your design and how well the code fits your ideas. For large projects, you'll identify the good and the fragile parts.

Large-scale development is also a social activity, and the team's dynamics influence code quality. That's why this book shows you how to uncover social biases when analyzing the evolution of your system. You'll use commit messages as eyewitness accounts to what is really happening in your code. Finally, you'll put it all together by tracking organizational problems in the code and finding out how to fix them. Come join the hunt for better code!

What You Need:

You need Java 6 and Python 2.7 to run the accompanying analysis tools. You also need Git to follow along with the examples.

Foreword ix
Michael Feathers
Acknowledgments xi
1 Welcome!
1(12)
About This Book
1(1)
Optimize for Understanding
2(2)
How to Read This Book
4(2)
Toward a New Approach
6(1)
Get Your Investigative Tools
7(6)
Part I Evolving Software
2 Code as a Crime Scene
13(10)
Meet the Problems of Scale
13(2)
Get a Crash Course in Offender Profiling
15(1)
Profiling the Ripper
16(1)
Apply Geographical Offender Profiling to Code
17(1)
Learn from the Spatial Movement of Programmers
18(4)
Find Your Own Hotspots
22(1)
3 Creating an Offender Profile
23(12)
Mining Evolutionary Data
23(3)
Automated Mining with Code Maat
26(2)
Add the Complexity Dimension
28(2)
Merge Complexity and Effort
30(1)
Limitations of the Hotspot Criteria
30(1)
Use Hotspots as a Guide
31(2)
Dig Deeper
33(2)
4 Analyze Hotspots in Large-Scale Systems
35(12)
Analyze a Large Codebase
35(3)
Visualize Hotspots
38(2)
Explore the Visualization
40(1)
Study the Distribution of Hotspots
41(4)
Differentiate Between True Problems and False Positives
45(2)
5 Judge Hotspots with the Power of Names
47(8)
Know the Cognitive Advantages of Good Names
47(3)
Investigate a Hotspot by Its Name
50(2)
Understand the Limitations of Heuristics
52(3)
6 Calculate Complexity Trends from Your Code's Shape
55(12)
Complexity by the Visual Shape of Programs
55(2)
Learn About the Negative Space in Code
57(2)
Analyze Complexity Trends in Hotspots
59(4)
Evaluate the Growth Patterns
63(1)
From Individual Hotspots to Architectures
64(3)
Part II Dissect Your Architecture
7 Treat Your Code As a Cooperative Witness
67(10)
Know How Your Brain Deceives You
68(3)
Learn the Modus Operandi of a Code Change
71(1)
Use Temporal Coupling to Reduce Bias
72(4)
Prepare to Analyze Temporal Coupling
76(1)
8 Detect Architectural Decay
77(14)
Support Your Redesigns with Data
77(1)
Analyze Temporal Coupling
78(5)
Catch Architectural Decay
83(4)
React to Structural Trends
87(2)
Scale to System Architectures
89(2)
9 Build a Safety Net for Your Architecture
91(14)
Know What's in an Architecture
91(2)
Analyze the Evolution on a System Level
93(1)
Differentiate Between the Level of Tests
94(5)
Create a Safety Net for Your Automated Tests
99(4)
Know the Costs of Automation Gone Wrong
103(2)
10 Use Beauty as a Guiding Principle
105(16)
Learn Why Attractiveness Matters
105(2)
Write Beautiful Code
107(1)
Avoid Surprises in Your Architecture
108(3)
Analyze Layered Architectures
111(2)
Find Surprising Change Patterns
113(3)
Expand Your Analyses
116(5)
Part III Master the Social Aspects of Code
11 Norms, Groups, and False Serial Killers
121(12)
Learn Why the Right People Don't Speak Up
122(2)
Understand Pluralistic Ignorance
124(3)
Witness Groupthink in Action
127(1)
Discover Your Team's Modus Operandi
128(4)
Mine Organizational Metrics from Code
132(1)
12 Discover Organizational Metricsin Your Codebase
133(14)
Let's Work in the Communication Business
133(2)
Find the Social Problems of Scale
135(3)
Measure Temporal Coupling over Organizational Boundaries
138(3)
Evaluate Communication Costs
141(4)
Take It Step by Step
145(2)
13 Build a Knowledge Map of Your System
147(16)
Know Your Knowledge Distribution
147(5)
Grow Your Mental Maps
152(3)
Investigate Knowledge in the Scala Repository
155(3)
Visualize Knowledge Loss
158(3)
Get More Details with Code Churn
161(2)
14 Dive Deeper with Code Churn
163(12)
Cure the Disease, Not the Symptoms
163(1)
Discover Your Process Loss from Code
164(4)
Investigate the Disposal Sites of Killers and Code
168(3)
Predict Defects
171(3)
Time to Move On
174(1)
15 Toward the Future
175(8)
Let Your Questions Guide Your Analysis
175(2)
Take Other Approaches
177(4)
Let's Look into the Future
181(1)
Write to Evolve
182(1)
A1 Refactoring Hotspots
183(4)
Refactor Guided by Names
183(4)
Bibliography 187(4)
Index 191
Adam Tornhill combines degrees in engineering and psychology to get a different perspective on software. He works as an architect and programmer and also writes open-source software in a variety of programming languages. He's the author of the popular book Lisp for the Web and has self-published a book on Patterns in C. Other interests include modern history, music, and martial arts