In Extreme Programming Explained, Kent Beck notes that optimism is an occuplational hazard of programming. Excess optimism, in the guise of enthusiasm, is a serious pitfall for game developers in particular:
Rein in enthusiasm? Now why would we ever want to do that? Isn't keeping the team motivated one of the most important factors of game development? Doesn't every management book you've ever read stress how important it is to keep the team motivated? The thing is, almost by definition, videogame developers are motivated. I've never seen a videogame where the developers didn't want to put more features and content into the game than they could possibly have time for. Motivation and enthusiasm, in this industry, is just about a given. Where this hurts us is when:We need to rein ourselves in. We could tell everyone on the team that they suck and their ideas are valueless, but that may be going too far in the other direction.
- We do a bunch of things halfway and don't have time to take them all to completion: we might have been able to finish one whole level in the time it took to do those two levels halfway.
- We save bug-fixing for later, and the cost of fixing those bugs goes up.
- We cut corners and work inefficiently.
- We do the wrong things: our pet features, or the publisher's pet features, instead of what's important for the game.
Most software developers are highly motivated by nature; the real art of managing programmers lies in knowing when to demotivate them. Two of Steve McConnell's classic software development mistakes are related to optimism. First, the distinction between optimism and wishful thinking:
I am amazed at how many problems in software development boil down to wishful thinking. How many times have you heard statements like these:"None of the team members really believed that they could complete the project according to the schedule they were given, but they thought that maybe if everyone worked hard, and nothing went wrong, and they got a few lucky breaks, they just might be able to pull it off."Wishful thinking isn't just optimism. It's closing your eyes and hoping something works when you have no reasonable basis for thinking it will. Wishful thinking at the beginning of a project leads to big blowups at the end of a project. Wishful thinking undermines meaningful planning and may be at the root of more software problems than all other causes combined."Our team hasn't done very much work to coordinate the interfaces among the different parts of the product, but we've all been in good communication about other things, and the interfaces are relatively simple, so it'll probably take only a day or two to shake out the bugs."
"We know that we went with the low-ball contractor on the database subsystem and it was hard to see how they were going to complete the work with the staffing levels they specified in their proposal. They didn't have as much experience as some of the other contractors, but maybe they can make up in energy what they lack in experience. They'll probably deliver on time."
"We don't need to show the final round of changes to the prototype to the customer. I'm sure we know what they want by now."
"The team is saying that it will take an extraordinary effort to meet the deadline, and they missed their first milestone by a few days, but I think they can bring this one in on time."
Optimism is fine if it's based on actual data; this is where prototyping and tracer code comes in handy.
The second optimism-related classic development mistake is heroics. Nobody wants to be the "guy who said it couldn't be done", but I've personally seen the project destruction wrought by developer heroics – and frankly, I'd rather work with the cynics:
Some software developers place a high emphasis on project heroics, thinking that the certain kinds of heroics can be beneficial. But I think that emphasizing heroics in any form usually does more harm than good. In the case study, mid-level management placed a higher premium on can-do attitudes than on steady and consistent progress and meaningful progress reporting. The result was a pattern of scheduling brinkmanship in which impending schedule slips weren't detected, acknowledged, or reported up the management chain until the last minute. A small development team held an entire company hostage because they wouldn't admit that they were having trouble meeting their schedule. An emphasis on heroics encourages extreme risk taking and discourages cooperation among the many stakeholders in the software-development process.Some managers encourage this behavior when they focus too strongly on can-do attitudes. By elevating can-do attitudes above accurate-and-sometimes-gloomy status reporting, such project managers undercut their ability to take corrective action. They don't even know they need to take corrective action until the damage has been done. As Tom DeMarco says, can-do attitudes escalate minor setback into true disasters.
The opposite of can-do attitudes isn't can't-do but simple pragmatism. I'm a firm believer in the it's always better to under-promise and over-deliver policy. Rather than saying "It can't be done!", promise only what is essential – but continue to develop alternatives and contingency plans as time permits. Being realistic doesn't mean giving up; it takes a lot more bravery to acknowledge the unknown than it does to blindly promise the world.
The problem is that most managers want "can do" attitude because that suites THEM the most (they can pass on the good news to upper management) and makes them look good. If things start to go wrong, they can always blame you for promising what you can't deliver.
The reason is that they are not interested in the success of the product, just their own well-being. If this project fails, they'll just move on to the other. It's extremely hard for an honest, pragmatic developer to get out of this situation.
In the end, developers start overpromising just to get managers off their back, and many, many software projects fail (sigh).
Drazen Dotlic on May 8, 2005 2:00 AMdevelopers start overpromising just to get managers off their back
If you have poor management, your options are limited. You can try to nudge them in the right direction. Or, you can take control of the project and run it the right way internally, and put whatever public face on it you need to in the status meetings with the manager.
Jeff Atwood on May 9, 2005 12:52 PMgood words~!
I have translated it into Chinese and put in my Blog, I have put the track and your name on it also ~!
a href="http://blog.xuite.net/zealousage/ZEAX/4508420"http://blog.xuite.net/zealousage/ZEAX/4508420/a
ZEAX on November 30, 2005 9:41 AMThis is a great post, Jeff, but... I have a different definition of optimism. I really REALLY agree with you about all the problems you point out--and how rampant and harmful they are--but I don't agree that optimism and enthusiasm are usually the root cause.
Much of what you mention can be traced to one or more of the following: greed, fear/feeling trapped, or just plain stupidity.
The TRULY optimistic do believe in a positive outcome, but NOT one that's out of touch with reality. As an optimist--and former game developer--my idea of an optimistic, positive outcome was that I would find a company committed to a practical view of software development *even if that meant the company would lose jobs or clients to developers/companies who claim they can do it for less money and in less time.*
Optimism is NOT about deluding yourself into thinking you can pull off heroics, it's about believing that you don't NEED heroics in order to be successful. Optimism is about having faith and hope that there ARE clients/projects/managers out there who care enough to set a smart, realistic schedule.
The companies/managers who *care* enough about the quality of work (nobody does their best work under extreme stress and sleep deprivation), and especially about the well-being of the developers, are not somehow more pessimistic or less enthusiastic... they are simply brave (willing to say no to a client or their boss), smart, and caring.
I do agree that "enthusiasm" can lead to problems with "pet features". No doubt there, and the fixes aren't always practical... although like so many other things, having developers spend more time interacting with real users (or better yet - doing a stint in tech support!!) can help.
No, I say that the *true* optimist believes that software development does NOT have to be so brutal and stressful, and believes that saying "no" to a client will not only NOT mean the end of your business, but will in fact lead to more long-term success. Most heroics and overpromising are simply greed and/or fear, masquerading as optimism.
But that's just me ; )
One thing that goes hand-in-hand with the wishful thinking discussed in this article is poor memory. Allow me to explain. The first time wishful thinking kicks in, people are overly optimistic and think that a software release will get out the door on time, even if all indications are to the contrary. That's understandable, once. But in many organizations, people don't learn from that mistake, and then for the next release cycle, continue the wishful thinking, make all the same mistakes, and put out another late release. Then for the third release cycle, it happens again.
If people just remembered what had happened in all the previous releases, then they would at least have some ammunition to combat the optimism. However, in my experience this sort of organizational memory is frighteningly uncommon.
witten on October 2, 2006 5:15 AMMost heroics and overpromising are simply greed and/or fear, masquerading as optimism.
I agree. Perhaps the better term is "selfish optimism".
That said, software developers are, generally speaking, notoriously and almost comically optimistic. Developers should try to err on the side of cynicism and/or pragmatism to combat this propensity. It's also a lot safer to work with a cynic. Not necessarily more fun, mind you, but the odds of total project destruction are significantly lower.
Jeff Atwood on October 3, 2006 10:01 AMIf people just remembered what had happened in all the previous releases, then they would at least have some ammunition to combat the optimism. However, in my experience this sort of organizational memory is frighteningly uncommon.
I'm not sure that's optimism-- that's just plain amnesia. It's a huge problem. There are some key metrics that are relatively easy to collect, and that can help a lot:
http://www.codinghorror.com/blog/archives/000681.html
Without historical data of any kind, you'll never make it off Gilligan's Island:
http://www.codinghorror.com/blog/archives/000017.html
Jeff Atwood on October 3, 2006 10:05 AMOptimism occurs because 90% of programmers think they are in the top 10% of their field. This isnt unique to IT. It is a common human condition. We are eager to prove that we really are better than average. Our own self worth holds higher value than the success of a project, and we will gladly risk the project to achieve it, in spite of the odds. And we subconciously avoid calculating the odds!
James Collie on December 1, 2008 6:08 AMThe comments to this entry are closed.
|
|
Traffic Stats |