ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

Search in Book Reviews

The ACCU passes on review copies of computer books to its members for them to review. The result is a large, high quality collection of book reviews by programmers, for programmers. Currently there are 1918 reviews in the database and more every month.
Search is a simple string search in either book title or book author. The full text search is a search of the text of the review.
    View all alphabetically
‘Quality Code’ Software Testing Principles, Practices, and Patterns
Stephen Vance
Addison-Wesley Professional (2013)
Matthew Jones
Testing Patterns
Appeared in:

Reviewed: July 2015

This book is quite high level and manages to cover most aspects of a very broad subject in a bit over 200 pages. The focus is on traditional unit testing, i.e. the tests we write as we code, or to test existing code at low level. There is nothing specific about system, security, acceptance testing etc, although many of the techniques and ideas can be applied to all flavours of testing. Example code is mainly Java. As a C++ programmer with only a passing knowledge of Java I found this language bias largely irrelevant because the examples are short and the code self documenting.

The book starts with a section on ‘Principles and Practices’, introducing the current ideas, best practice and terminology. As you would hope, there’s lots of good stuff here, and it ensures readers of all levels are prepared for the rest of the book. For a complete novice it might be a little brief but all the concepts and terms can be found on the web if more detail is required.

The majority of the book is taken up by part II: ‘Testing and Testability Patterns’. This is a catalogue of patterns and techniques grouped thematically into chapters. The final chapter in the section stood out to me as it tackles something usually completely avoided when discussing testing, namely ‘Parallelism’. This relatively lengthy chapter introduces some clever tricks and techniques for finding seams in concurrent code, giving you way to control your code to make testing reliable, or at least more predictable. It gave me hope that I might just consider tackling this subject systematically next time I have a problem, rather than just giving up or trying black magic.

The final part of the book is a couple of short worked examples, one in Java and one in Javascript. The languages are secondary, since the chapters are mainly prose, with plenty of discussion around a limited number of listings, ending with a useful retrospective discussion.

My only real complaint was that there was very little mention of TDD, and the ‘Design and Testability’ chapter was one of the shortest. It might have been a conscious choice to skim over this since its a large subject, and not for the faint hearted (or, realistically, a beginner).

I started out not liking this book because it didn’t contain any bold assertions or novel ideas. But that’s because I was hoping for something ground breaking like the GOOS book, and I think this is really a ‘software testing primer’. As a text book, it is comprehensive, detailed without waffling, and backed up with good references to take you further should you wish. The discussion often places the subject in a wider software engineering context, considering other factors such as compromises and pitfalls. This makes it clear that testing and quality can not be considered in isolation.

Overall I would recommend this book to junior programmers, or anyone coming to the subject for the first time. It would also serve well as a companion text to a training course. If your bookshelf already contains a few up to date coding and testing bibles then I don’t think you will find much novelty in this book, although it might fill a few knowledge gaps.