||New Reviews| |Software Methodologies| |Popular Science| |AI/Machine Learning| |Programming| |Java| |Linux/Open Source| |XML| |Software Tools| |Other| |Web| |Tutorials| |All By Date| |All By Title| |Resources| |About||
Keywords: Software development, programming
Title: Implementation Patterns
Author: Kent Beck
Publisher: Addison Wesley
Kent Beck should need no introduction. An influential figure in the world of software development, he has been in the forefront of two key movements in the development world: agile software development and unit testing. He was one of the original authors of the Agile Manifesto and one of the creators of extreme programming. If that were not enough he was also the co-developer, (with Erich Gamma), of JUnit, which helped popularised unit testing to a new generation of programmers and which has spawned similar testing frameworks across a range of platforms. In his latest book, 'Implementation Patterns', Beck turns his attention to code, and specifically how we can write code that communicates well and is therefore easier to understand and maintain.
Despite the word 'patterns' in the title, this isn't really a book that looks at the design patterns level of abstraction. It goes down a level and looks at code and code structure rather than how to solve specific architectural or functional requirements. To that end it's much more about how you actually write code - in this case Java, though the principles he describes apply directly to other object-oriented programming languages.
The patterns - and there are 77 of them described by Beck - are organised under ten different headings, including Class, State, Behaviour, Methods, Collections and Evolving Frameworks. There are also a couple of chapters on more generic and fundamental principles, such as minimising code repetition, naming fields, methods and classes to show intent and so on. While not down at the coding standards level, some of these should certainly inform any sensible set of standards.
The writing is generally clear, and there is even the occasional Kent Beck diagram (which should be familiar to readers of some of his other books). However at times it's not clear who his target audience is, as some of the implementation patterns he describes should be common sense to anyone but the greenest of novices. In many respects this feels like a collection of rules of thumb that Beck has accrued over the years, this is his voice of experience passing on accumulated wisdom to other developers. While this makes for an interesting read, it lacks the clear focus that some of the more obviously classic software development books. All that said, this is still a good read and should give most readers food for thought.
There are a number of overlaps between this book and others that look at similar material. For example Steve McConnell's 'Code Complete' and 'Code Reading' by Diomidis Spinellis tread some similar ground in their focus on the activity of coding and writing code that is readable and easy to understand. McConnell's book in particular provides excellent advice to the developer, though without the handy 'implementation patterns' label.
In all this is a good read, but it's by no means a radically new take on software development that some might have been expecting.