Author: Donald Belcham & Kyle Baley
Publisher: Manning, 2010
Aimed at: .NET programmers working with existing projects
Pros: Good introduction to methgodologies in general
Cons: Rarely confronts .NET issues
Reviewed by: Alex Armstrong
If the term "brownfield application" makes you feel slightly apprehensive you have the right idea. Think toxic waste, think old and crumbling buildings to demolish, think legacy code.
Brownfield development means taking over or continuing to work with a big code base. This is a scary and usually depressing situation to be in. The reason is that every programmer is struck with the conviction that it would all be so much better to throw it all away and start again. This "software is changeable" idea is probably much of the reason that agile methods with their "tear it up and start again" approach to software creation - sorry that should be "refactoring" - are so attractive.
This book is aimed at .NET programmers who have the "brownfield" problem. This raises a number of questions immediately - in particular what is so special about .NET programmers when working with existing projects?
The book starts off with promise. It presents a small story of "twilight stars" a project that you have to take over. It's an engaging story and, if you have done anything like it then you will recognise the events. From here we have a discussion of what makes taking on an existing project different - but there doesn't seem to be any particular specialization to .NET. What is said could apply to any project. Towards the end of the chapter we also have a very general discussion of when and when not to re-write the entire project. This could have had some .NET issues worked in - VB 6 to VB, C# 2.0 to C# 4.0 and so on but no - it is completely general. By the end of the chapter the waffle is beginning to dominate. Most of Chapter 1 would not be out of place in any book on programming methodology - brownfield or greenfield, .NET or any framework.
Chapter 2 is about version control. Again it is completely general and rarely even mentions a particular version control system. The comments are all very reasonable and amount to common traps and pitfalls. Chapter 3 moves on to continuous integration Chapter 4 is on automated testing - a general account with a few examples in C#. Chapter 5 is on metrics and code analysis, again it is more or less a general account of the ideas with little customisation for the .NET environment. Chapter 6, the final chapter in the first part of the book, is on defect management and again it is a very general account of the problems and how to manage the process.
By this point in the book I would have forgotten that it was about brownfield projects if it hadn't been for the occasional use of the term. I hoped that the second half of the book might move back to the topics promised in the title.
Chapter 7 is on object-oriented practices and after a brief mention of ASP .NET it launches into another completely general account of the advantages of objects. There is a moment in the middle of the chapter where it looks as if the principles might be applied to the brownfield problem but this moment passes and the authors go back to the general by way of discussing agile ideas.
Chapter 8 is on re-layering your application and it is here we first meet a chapter that is about working with existing code. The theme continues in Chapter 9 with a look at dependencies and in Chapter 10 and 11 we look at the UI and data access. Finally chapter 12 deals with external dependencies and the book closes with a chapter of encouragement and motivation.
The second part of the book is indeed more about the problems that arise when working with existing projects but even here it has a large tendency to wander off and describe standard methods and techniques. How you regard this second part, and indeed the whole of the book, depends very much on how much prior knowledge you you have of methodologies.
You can probably tell that I wasn't impressed by this book. The odd thing is that in many ways I was. It is a good account of what you should know about software development methodologies... but it really isn't about brownfield development and it isn't about .NET brownfield development.
For example, consider the problem that any brownfield .NET developer is faces with - to transition to WPF from Windows Forms. This really is a big problem but the only real consideration it gets in this book is WPF as an implementation of the presenter pattern. Similarly there are lots and lots of very specifically .NET questions that arise whenever you have to take over an existing project that are ignored in this book.
Even if you concentrate on the "brownfield" aspect of things there are lots of real problems that go beyond standard methodology that aren't considered. For example, how do you explore a code base? What tools are there to help you find out how an existing code base works and how should you manage the task?
On balance this is a presentation of well known programming methodology with the word "brownfield" inserted at regular intervals. As a methodology book it is quite good but as a book claiming to help you get on top of an existing .NET project it hardly gets off the starting blocks.