Review By: Sameer Khanwalker
05/11/2004This small book includes two major parts. The first traces the path to evolutionary delivery and the second part also traces the path through evolutionary delivery. Might sound confusing, but actually it isn’t. The first part starts off by dealing with the problems in software engineering. There is a fairly detailed discussion on the different models for software development, including of course the major ones, i.e., the waterfall, the V model, the spiral model, and the matrix model.

There is an exhaustive discussion on the lessons in software development with the focus on the customer’s perspective and the developer’s problems. There is a very interesting fourth chapter in this part, “At the Mercy of the Project,” which talks about the different issues that lay siege to the project. This is followed by a detailed discussion on the waterfall model and why it is not really a problem. The first part ends with a discussion on evolutionary delivery and its advantages and problems.

The second part is almost totally about evolutionary delivery, starting with a discussion on strategy. There is a pretty good discussion on project infrastructure that touches upon some forgotten issues. Software configuration management and change control follow.

The book then discusses prioritization and planning deliveries. The chapter on testing provides a real-world perspective on the topic with great insight into the practical aspects of testing. A fairly routine chapter on software maintenance is followed by one last discussion on evolutionary delivery culture.

The briefness of this book is its strength. It can be read in parts like a coffee-table book, yet also provides more depth than many larger volumes on software engineering that I have read in the past.

The best part of this book is that the author has chosen not to follow the beaten path, which is to criticize the software development models. Instead, he puts the problems where they belong, with the project managers and not with the models. For example, the author has dealt very neatly with the waterfall model and chosen not to dwell on the so-called disadvantages of it that we have been told about for the last two decades. Whenever a project fails, the tendency has been to put the blame on the waterfall model. The two chapters on development models are, in fact, among the best that I have read in years.

The author also does not hesitate to bring us down from the lofty pedestals that we have placed ourselves on by stating in no uncertain terms that “software engineering” is perhaps still a misnomer, because, while engineering is precise, software engineering is not. It is still more of a craft than engineering.

The evolutionary delivery cycle is very effectively described in the second part. Prioritization and delivery planning are lifted above their pedantic levels that you would normally find in other books. The chapter on testing is very revealing. I have long to make developers understand the importance of testing their own code, but have almost always been ignored by project managers and consequently by the developers themselves. This book comes as a breath of fresh air. Independent testing is still required, but developers should not forget their own responsibility.

It is wonderful reading for everyone in the field of software engineering in general and a “must read” for all Project Managers.