Delivering on Scope

Many writers on project management tell us that project management is about delivering the project on time and on budget, with a special emphasis that project management is about the 3 constraints of quality, cost, and time.

Turner writes that project management is about managing the scope and the organization, and that quality, cost, and time are just constraints.  Consider that the reason for the project is the work to be done (in order to reap the benefits of the project). 

Without the work, there is nothing.  Next, consider that the project organization is what does the work.  Without them, there is nothing.  The other three features: quality, cost, and time are not the purpose of the project. They are simply constraints. 

Handbook of Project-based Management

Succeeding by not failing

We keep on building systems that experience failure mainly because we don't learn from our previous failures.  In fact, if only we made a formal effort to study the cause of previous failures, the 'vast majority' of failures would disappear.  This seems to be the thesis of a  book on system failures from Joyce Fortune and Geoff Peters.

The phrase 'system failure' normally brings up the usual suspect of 'computer/information system failure' , and that's not surprising. Information Systems chalk up more than their fair share of failures, or at least the failures that are interesting enough to make the news. One of the reasons is that these systems tend to have so much failure is that they are so embedded in organizational life that there are so many points of interaction and therefore so many points at which failure can occur.

Information Systems are also now so entwined in our social and cultural life that we experience failures almost every day, from a dropped internet connection, to a stolen credit card number.

 

While failures will always happen, a lot less of them would happen if only organizations made proper, formal reviews of what caused previous failures, and then apply the lessons learned, argues Fortune and Peters.   To aid in this noble aim, they have devised an approach called the Systems Failure Approach, an approach solidly grounded in the principles of systems thinking.  SFA lets its user extract failure events from the real world, construct a systems model of the failure using systems techniques and, from the understanding gained come up with a lesson that can be applied back to the real world.

On Agile...

You've heard said it before: in order to learn one must have an open mind.

I think sometimes the opposite is better. Keep a closed mind. Let the new idea try to make its way in with difficulty. Let it argue itself in with facts. Let it convince you of its correctness. Once convinced, make it your own. If the idea has enough merit, it can make its way in.

I've been trying to like the Agile methods, but for reasons I still cannot pin down, I am still pessimistic about these approaches. There is no doubt they work. Sometimes. But that's not a criticism. Nothing works everywhere. Agile's more moderate proponents have never suggested that is applicable everywhere.

I should clarify that I am pessimistic mainly about the XP approach, since that is the methodology I am most familiar with among the agile methodologies. I am still agnostic about the rest.

These methodologies have been developed because of the unworkability of the one-pass waterfall approach. In an ideal world, where people do not make mistakes, the one-pass waterfall is the simplest and most efficient approach to developing software: complete the requirements in one phase, then complete the design, then complete the programming, then complete the testing, and finally, complete the acceptance, and we're done.

But since we're not mistake-proof, the waterfall is simply impossible as an approach, and no one in their right mind will attempt to develop software using this model. Except in the business world, of course.

Here's one of my issues. No one has been complaining that the programming phase of a waterfall approach comes out with a program that does not match the design documents. No one has been complaining that the design documents do not match the specified requirements. In other words, the problem is not with the design phase and it is not with the programming phase. The problem is, and always have been, that the specified requirements do not match the actual requirements.

If that is true, then it is the domain of requirements analysis that is at fault. They come up with the faulty requirements. The domain of software design and programming is just fine -- give us the correct requirements and we'll give you the correct software.

An approach that tries to fix the system development problem by fixing the software design and development phases rather than the requirements phase is looking under the wrong lamppost. And I think Agile is doing just that.

Be that as it may, I'm currently reading Robert Martin's Agile Software Development and have more to say on the topic.