All Late Projects Are the Same (2011) [pdf]
systemsguild.com
systemsguild.com
If a project offered a value of 10 times its estimated cost, no one would care if the actual cost to get it done were double the estimate. On the other hand, if expected value were only 10 percent greater than expected cost, lateness would be a disaster. Yes it would be a disaster, but instead of obsessing over “What’s the matter with those software folks who didn’t deliver on the schedule we gave them?” we need to ask instead “Why did we ever kick off a project with such marginal expected value?”
The message for us software developers is: try to work only on what I call strategic projects: projects whose expected value is much greater than their cost could possibly be. That means they need to continue to pay benefits well into the future.
http://www.joelonsoftware.com/articles/FiveWorlds.html
not all software dev is the same.
Coming from games, every project I've been on was an original title. That meant it was 100% up to the team to decide the scope of the game. Most teams (not all) guess how much they can get done and don't plan for cutting features. "We're going to have 12 characters, 30 levels, 10 power ups, 45 enemies, 600 puzzles, online multiplayer, and IAP for 500 items". And then they just start making it. They run into 2 big problems.
1) They don't know if the game will be fun until they're 50-60% in. If they guessed wrong they're off schedule
2) They're attached to the vision and unwilling to cut stuff.
My point though is this doesn't fit "we didn't start early enough" IMO. They knew how much time they had. No one was/is dicating too much work. They can cut the scope at any time. But they rarely do.
There are solutions. 1 is to prototype with a small team. Unfortunately most teams can't do that as they'd have 90% of their staff doing nothing. Larger companies can do this or maybe if they switched to the Hollywood model, no employees only contractors, they could do it.
2 is to design so things can be cut and to check the schedule and start cutting. This one is hard for most teams because they see the game they imagined in their minds and it's not the game with stuff cut. Players though don't know what that vision is and so won't missed the cut features because they aren't aware of them.
Doesn't knowing how much time you have, and then not cutting scope when you see your plans don't fit into that time, count as not starting early enough?
I also came from games, and I agree that scope is rarely cut, and often self-inflicted. I was also under Mr. Very Large Publisher, and it was more complicated than that- we had control over scope, but not over schedule. We had control over how much work to do and the quality, but not the budget.
The major problem in my experience was that the team was excited, motivated and willing to work hard, so optimistic about their ability to do great things inside the limited budget and schedule. Therefore, they tried to do too much. All other things being equal, more time would have helped, every single time. Which can be summarized as "we didn't start early enough." That doesn't mean that actually starting earlier would have solved the problem. Actually starting earlier might have led to even larger plans. So, IMO "we didn't start early enough." is not meant to be taken literally, it's a way of understanding the problem, not a way to solve the problem.
If you know your deadline (most game devs do) and your 100% in control of your scope then it's up to you (the team) to pick a scope that fits your resources (people and time).
The original article talked about situations where people didn't know the scope or couldn't change it and often wasted lots of time not starting. I think those are fundamentally different situations.
The article implied once that people wasted time waiting to start, in reason #1: "Nobody had the guts to kick off the project until the competition proved it doable and desirable."
But reason #2 is where games that have a deadline and scope control fit in. "If the project were started long enough before its due date to finish on time, all involved would have had to face up to the fact from the beginning that it was going to cost a lot more than anyone was willing to pay."
You picked a scope that fits your resources, and yet you manage to run well past the deadline. You started it thinking you'd get it done in time, and yet you managed to run late. If you started earlier with the same deadline, scope, people, etc., you would finish on time. This might feel like a somewhat silly observation (which the author points out in advance) but it is nonetheless true for the situations you are describing. If you didn't finish on time, then you didn't start early enough. It's a slightly twisted way of saying your scope was bigger than you thought. It's not saying that actually starting earlier is the solution.
Reason #3 is entirely metaphorical. "No one knew that the project needed to be done until the window of opportunity was already closing." This is saying that you know your scope, and you have a deadline, but you didn't even think of the idea until it was too late. It is true to say that you didn't start early enough, but it is also true that you couldn't possibly have started it earlier, without a crystal ball.
The thrust here is not literal. I disagree that it loses any meaning at all, it just might not mean what you thought.
2.If the project were started long enough before its due date to finish on time, all involved would have had to face up to the fact from the beginning that it was going to cost a lot more than anyone was willing to pay."
In other words, projects are late because business justification is usually weak for software projects. When faced with "in order to ship this by 12monthsfromnow we need to hire 5 more software engineers today" management stalls.
While that's sometimes true, I read exactly the opposite. I read what he said as: 1- Software projects don't start until justification is strong, and 2- justification doesn't become strong until it's already too late.
So, the problem isn't (necessarily) that justification is weak, it's that strong justification is itself a red flag, because it's already too late to start if you have a really good business case for it, you should have started before you had all the data to prove you needed to start.
But, I don't think he's necessarily saying we should be able to somehow predict the future and start software projects before we know for sure we need them, he's just reflecting on patterns observed and providing more of a thought framework for dealing with these patterns.
Now if your project isn't easily separable in several relatively independent parts, you are screwed.
Amen to that.
Thinking this way acknowledges in advance that software is complex, it's more complex than you think it is, and any software project you start is likely to take longer than you think it will. Both sides of a software project or contract ought to know this and say it out loud before starting. More importantly, it underscores that a large software project nearly always starts under pressure. Rarely is something big and expensive undertaken without at least mildly unrealistic goals. Having been there many times, I know the management thinking is often that if we don't have pressure and forces squeezing every bit of developer performance toward unrealistic goals, then we won't even achieve the realistic goals, and we'll be even later than we are.
Contractors are probably most affected by and in need of this way of thinking, though I'm well aware of how hard it is to admit you might be late on something when you're trying to win a contract, especially when the competition makes impossible promises.
I'm currently working at a late project right now that started early enough, but took too long to hire enough people to finish the project in time, and didn't use the time at the beginning of the project well enough to gather information about the current and future processes. Maybe that's an example of what the author means, but it certainly gets more complicated than "started too late" quite quickly...
McConnell has a really good discussion of this in Rapid Development, calling it "The Fuzzy Front-end" of a project.
"Everyone knows" that certain projects "have" to be undertaken, but they will often just be talked about and talked about and talked about until it's too late to do anything but talk about not talking about things in future.
http://www.goodreads.com/book/show/946076.Why_Does_Software_...