Applied Software Project Management!

By: Satwinder

It's not often that a software project management book comes along that is practical, easy to read and stacked full of ready to use process scripts. Andrew Stallman and Jennifer Greene have done just that with recent book Applied Software Project Management.

There are too many books about software project management or software engineering which are dry, overly complex and boring, but this book is not one of them. It was a joy to read because their style of writing is clear without being simplistic and the authors describe things in just the right amount of detail. It seems they understand their audience and set out to write in an extremely helpful and practical way. They have certainly achieved this.
Part one of the book covers tools and techniques that can be applied on projects. Project planning, estimation, scheduling, reviews, requirements, design and programming and testing each have their own chapter. Part two is about using project management effectively and has chapters on understanding change, management and leadership, managing an outsourcing project and process improvement.

Stallman & Greene certainly appear to know a lot about problems that face software teams. As early as the introduction they describe the need to overcome chronic problems and this theme is continued throughout the book. For each problem, there is always at least one proposed solution. For example, they describe a common scenario whereby senior managers do not trust the estimates of the technical team, somehow believing that the technical team is deliberately over-estimating in order to give themselves some slack time. Their proposed solution is to involve these managers in the estimation process so they can see the estimates being made in a transparent and systematic fashion. They then go on to describe in detail how to run a Wideband Delphi estimation session and provide examples of templates and documents that can be used during such sessions. They also provide a valuable process script for teams to follow.

Subsequent chapters cover planning, scheduling, reviews, requirements, design and testing. Whilst most of these chapters cover each topic in reasonable detail, the section on design is lacking in detail and provides no description about what kind of design deliverables might be produced nor any detailed description of what these design deliverables might contain. This is in contrast to the requirements chapter which contains process scripts for requirements elicitation and analysis as well as a detailed description of use cases and software requirements specifications documents.

The authors might want to reconsider some of the examples they use. They describe the process of recapturing code in order to make it more maintainable and use an example of some Java code which they gradually refractor over several iterations. At the end of this process they say why recapturing would be applicable in situations where code is spaghetti-like. This is fine, except they use an example of very un-spaghetti-like Java code to refractor. By doing this it looks to me that they fall into a common programmers trap of code beautification where programmers spend time from the schedule iteratively improving code that works just fine in order to write the perfect? code, class or object. I've seen this happen on projects where there simply wasn't the time in the schedule to allow this, and it certainly didn't bring any additional business benefits to the stakeholders. However this is a minor gripe.

I would have liked to have seen more pages devoted to risk management. Time and again, not managing risks is cited as a reason why projects fail. The authors do describe risk management in a cursory way, for more details visit to yet the book would benefit from a better description of how and why risk management should be done throughout the project, not just in the early stages of project planning.

Iterative approaches on the other hand assume that requirements will change during the project either because users gain a better understanding of what they need, or because of changes to the business environment. Based upon this assumption, iterative methods are designed to better manage this changing environment. With waterfall approaches, for more details visit to changes in requirements often require the project to revisit earlier stages with a corresponding increase in costs and effort. The authors spend barely a page on the Rational Unified Process (RUP) and the authors should look more closely into how their practical advice and processes might be used on alternative iterative approaches to the waterfall approach.

Article Directory:

| More

Please Rate this Article


Not yet Rated

Click the XML Icon Above to Receive Software Articles Articles Via RSS!

Powered by Article Dashboard