Making Software by Andy Oram (ed.) and Greg Wilson (ed.)
Publisher: O'Reilly Media
Our world of mainstream software development is driven by fashion. Methodologies come, make an impact on many organizations only to eventually be replaced with some new promising idea. The cemetery is getting stacked with a growing pile of dead methodologies. After CMM we were extreme before we became agile. Test-Driven Development should be used for everything. Oh, wait, we're behavior driven now. The progress is based on failures past. New methods to solve problems introduced by the previous silver bullet. While I personally see value in many of these ideas, something nasty happens the moment they hit the mainstream.
Our programming languages are no exception. As I started to program professionally (that is, I started to get paid) C++ was used to build virtually everything whether the language was a good fit or not. Then Java emerged and unleashed a paradigm shift of Kuhnian proportions only to break down under its own weight a decade later. Today, the world of programming languages is more diverse and promising than ever. And C++ is still around. What should we choose? Which methodologies and techniques should we rely on? Does it really matter what we choose? Are our failed projects to blame on methodologies or are we trying to address the wrong problems? Our answers to those questions carry severe consequences and are well-worth to study in depth.
My personal take is that software is on the border of our cognitive capabilities. Large-scale software development is hard. And it always will be. Given enough hindsight-bias it's easy to look back and identify all the mistakes we've made over the past decades. From the methodology heavy 90's, the OO craze to the XML-as-a-programming-language-since-my-favourite-technology-isn't-dynamic-enough some years ago. But we've also collectively learned a lot and made significant advancements in multiple fields. That's easy to miss. As I researched a book I'm currently writing I was surprised by the wealth of information available from the field of programming psychology. Making Software collects some of the recent findings in a highly recommended read. It's an overview of what we actually know about software development, what works in practice and why. It's a refreshing read compared to all opinionated dogmatism I usually encounter in books on development practices.
Making Software presents research on a wide variety of topics. Can we expect any improvement through the design patterns format? What are the relative virtues of pair programming? And do complexity metrics deliver on their promises? The essays are contributed by different authors. What they have in common is that they're all based on solid research. Sure, the scientific method may be far from perfect. Yet it's the best approach we know. We just have to be aware of its limitations and be careful to generalize the findings without significant data. Making Software is an excellent starting point for learning more about what actually works in our field and get an idea of the underlaying mechanisms. This book is a true eye-opener and an inspiring work. I got a lot of ideas from it and I recommend it without any reservations. It's a book that may indeed make a difference to the way you think about our craft.
Reviewed March 2013