Reviewed: January 2014
I really struggled to see what this book is for. When in a charitable mood I think that it might have been intended as an introductory text to give beginners an introduction to all the practices they should be aware of as a professional software developer – a broad overview to get them asking the right questions and to prepare the ground for reading some important books later. This is not what the book claims to be, though it could indeed be a less daunting prospect than a bookshelf-crushing collection of essential reading presented all at once. On less charitable days, I think the author must have chosen to publish this as a book because you can't sell a one-page bibliography.
The rather harsh judgement stems from my question about the purpose of the book. This volume of 400 or so pages is not (obviously!) a comprehensive guide to patterns, testing, refactoring, coding style and object oriented design. Instead it takes samples of good advice from a range of classic works on these topics. These are perhaps a good start in explaining the importance and usefulness of knowing and understanding concepts that the profession finds useful, but it's not enough to go very far with applying them. A reader not already familiar with the referenced works will need to read those too, so why not give them just enough to whet their appetite for that? This book is a lot longer than it needs to be and would be better as a thin volume of Practices every programmer should know – giving the flavour of these, illustrating why they are important and helping readers to identify which ideas warrant the most immediate attention in their own circumstances.
A reader who is already familiar with the cited texts will not learn anything new from this book. The author seems to lack of a clear understanding of just who his audience is. Sometimes he refers to books and their authors as though they are already known to the reader and only later, if at all, pauses to introduce them. The referenced titles and names are in fact almost certainly already well-known to ACCU members. The back-cover claim that the book ‘provides developers, project leads and testers powerful new ways to collaborate, achieve immediate goals, and build systems that improve in quality with each iteration’ (my emphasis) is not accurate. They are new only in the sense that they are not universally known and adopted ways. That they are not universal is evident from the author’s banging of a professionalism drum, which gets increasingly irritating with every repetition. There seems little point in labouring the value of adopting professional practices to a reader who has already shown some regard for their own development by picking up a book they hope to learn from.
Clarity of purpose is lacking not just in writing for a particular audience but also in expounding the theme set out in the book’s title. The term ‘Emergent Design’ is used in two different contexts: how software development processes have changed over time, and how a software system can be designed to evolve smoothly over time rather than inevitably decay as changes come along. The former does not really warrant space in this book; how we came to reach our current understanding of what constitutes good software development practice is of little use, even for those with experience of how things once were, in a book which will be read to learn how to do things better within a very different paradigm. The latter theme is more apposite; the author should have stuck to this and kept the book more focused on the value of important current practices. With a couple of small exceptions the book’s advice on these is not poor advice – but it is a rather random rehashing of subset of ideas from a good, solid collection of other, well-respected works. My recommendation is to cut to the chase and read the books in the bibliography instead.
