Software Design X-Rays »

Are you working on a codebase where cost overruns, death marches, and heroic fights with legacy code monsters are the norm? Use these novel ways to identify and prioritize technical debt, based on behavioral data from your team. Because good code involves social design, you can find surprising dependencies between people and code to resolve coordination bottlenecks among teams. Use the behavioral data that you already have: your version-control system. Join the fight for better code!

March PragPub »

• Clojure for Full Stack Development
• Code as Prose
• Fifty-two Stories in Fifty-two Weeks

Plus: On Tap, Swaine’s World, The PragPub Puzzle, Antonio on Books, From the Pragmatic Bookshelf, The BoB Page

Recently Released:

• Rediscovering JavaScript 
• Learn Functional Programming with Elixir 
• Programming Clojure, Third Edition 
• Rails 5 Test Prescriptions 

Tired of guessing at what's wrong? Ready to use some actual, empirical data from your project to help conquer technical debt? Check out Software Design X-Rays: Fix Technical Debt with Behavioral Code Analysis, now in print and shipping from pragprog.com/book/atevol. Read on below for an interview with the author.

And welcome to March! Roaring in like a lion we have this month's edition of PragPub magazine, now available from theprosegarden.com.

Enjoy!

/\ndy

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

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.

Now in print and shipping from pragprog.com/book/atevol.

Interview with the Author

1. Why did you decide to write this book? I've spent much of my career trying to improve existing code, and I found it progressively harder as software systems and organizations keep growing in scale. Even though the software industry has improved dramatically over the two decades I've been part of it, we do keep repeating avoidable mistakes by isolating our influences to technical fields. I wrote this book to provide that missing link between technical and social sciences. This blend, behavioral code analysis, lets us prioritize technical debt based on the most likely return on investment, evaluate our software architecture based on how well it supports the work we do, bridge the gap between developers and business oriented people, and much more. My goal was to take mainstream software development one step closer to a point where decisions — both technical and organizational — are influenced by data and research from multiple fields. I'm really, really happy with the end result and hope you'll enjoy it too.

2. What kind of experience would help readers get the most out of this book? To get the most out of this book you should be an experienced programmer, technical lead, or software architect. The most important thing is that you have worked on larger software projects and experienced the various pains and problems. You don't have to be a programming expert, but you should be comfortable looking at smaller code samples. Most of the discussions are on a conceptual level and since the analyses are technology-neutral, the book will apply no matter what programming language you work with.

3. What do you hope readers take away from this book? The key point in the book is to base decisions on data by putting numbers on our gut feelings. Software development, and in particular the people side of it, is notoriously hard to get right. By embracing behavioral code analysis we get to tap into the social side of code and start to measure things that we cannot deduce from the code alone, like communication and coordination needs, Conway's Law, and long-term complexity trends. I also want to point out that behavioral code analysis doesn't offer any silver bullets, nor does it intend to replace anything. Instead the techniques in this book are here to complement your existing expertise by focusing your attention on the parts of the system that need it the most.

4. How does this book compare to Your Code As A Crime Scene? Software Design X-Rays represents the evolution of the ideas from my previous book, Your Code As A Crime Scene. If you read the previous book, you're already familiar with hotspots and some of the change coupling metrics presented in chapters 2 and 3. These two concepts lay the foundation for the more advanced analyses, and the new book goes deeper into both areas. Most of the material points out new directions that I haven't covered before. Software Design X-Rays is of course also interdisciplinary and blends software engineering with psychology, but this time there are no direct forensic references.

5. What's your favorite part of the book? I like chapter 4 on refactoring patterns since it makes the technical debt detection techniques actionable by providing specific recommendations. I also enjoyed writing chapter 7, Beyond Conway's Law, that brings some valuable findings from group psychology into the software field. Those findings fill out the missing pieces in Conway's Law and help guide your organization towards better code. Finally, I have to mention the last chapter which explores preventive and predictive uses of behavioral code analysis. I like that chapter because the resulting information becomes like an extra team member that points out areas of the code in need of our attention as we code along.

Now in print and shipping from pragprog.com/book/atevol.

March PragPub Magazine

This month’s PragPub may look a little different to you. It’s the same magazine, but with a bit of refactoring: some components have been shifted around to reveal more of the underlying structure. Actually, if we did it right, you won’t even notice the change, you’ll just dive into the content. So what’s in the March issue, you ask?

A modern full stack developer needs to be able to write code that runs in three very different environments: back-end, web client, and mobile client. Each of these presents very different challenges and draws you into a different development ecosystem, with its own preferred language. In his ongoing series, Paul Butcher builds the case for Clojure as the ideal language to take on all these challenges. This month he focuses on the back end, using Clojure to create serverless deployments with AWS Lambda, functional user interfaces with React, and mobile apps with React Native.

Maintainable code is human-readable code. But the human reader will always be at best the second most important audience for your code: the most important audience is the target machine. Writing code that communicates well with the machine and with human readers is a perpetual challenge. Jay Wengrow decided to explore how to make code as human-readable as possible (and still machine-executable). His resulting article on code as prose takes several machine-readable Ruby programs and rewrites them for human readability. It turns out that a few basic principles can make your code much more human-friendly.

You know how some developing countries that were desperately behind in communications infrastructure leapfrogged wired technologies and caught up overnight by going straight to cellular? Bruce Tate thinks he sees a similar leapfrog opportunity in our profession. Right now our universities and conferences are failing to meet the needs of future programmers by teaching and certifying old technologies because they have too much investment in them not to. Meanwhile, our profession is hurt by its lack of diversity. “We have a singular chance to invest in a generation of underprivileged and underrepresented folks and catch them up by skipping a generation of languages,” Bruce says. And he’s actually walking the walk. In this issue’s Soapbox, Bruce shares what he’s up to and issues a couple of challenges to you.

What else? Columnists Marcus Blankenship and John Shade are here, of course, and Antonio Cangiano’s summary of new tech books, and a puzzle, and more.

We hope you enjoy it! Now available from theprosegarden.com.

Upcoming Author Appearances

Did You Know?

You can synch your ebooks among your devices via Dropbox, including updates! Just login to your account on pragprog.com, edit your profile, and connect your Dropbox account. See our FAQ for details.

Don't Get Left Out

Are your friends jealous that you get these spiffy email newsletters and they don't? Clue them in that all they need to do is create an account on pragprog.com (email address and password is all it takes) and select the checkbox to receive newsletters.

Are you following us on Twitter and/or Facebook? Here's where you can find us and keep up with the latest news and commentary, and occasional discounts:

Tell your friends! Tweet this

Follow us on Twitter: @pragprog, @pragpub, Andy Hunt @PragmaticAndy.

Andy Hunt
Publisher, Pragmatic Bookshelf

Books • eBooks • PragPub Magazine • Audiobooks and Screencasts
PragProg.com

Manage your subscription using your account, or permanently unsubscribe here.
Sent by the Pragmatic Programmers, LLC. • 9650 Strickland Rd Ste 103-255• Raleigh NC 27615