From the IEEE article Why Software Fails:
Last October, for instance, the giant British food retailer J Sainsbury had to write off its US $526 million investment in an automated supply-chain management system. Merchandise was stuck in the company's depots and warehouses and was not getting through to many of its stores. Sainsbury was forced to hire about 3000 additional clerks to stock its shelves manually.This is only one of the latest in a long, dismal history of [software] projects gone awry. Most IT experts agree that such failures occur far more often than they should. What's more, the failures are universally unprejudiced: they happen in every country; to large companies and small; in commercial, nonprofit, and governmental organizations; and without regard to status or reputation. The business and societal costs of these failures -- in terms of wasted taxpayer and shareholder dollars as well as investments that can't be made -- are now well into the billions of dollars a year.
The problem only gets worse as IT grows ubiquitous. This year, organizations and governments will spend an estimated $1 trillion on IT hardware, software, and services worldwide. Of the IT projects that are initiated, from 5 to 15 percent will be abandoned before or shortly after delivery as hopelessly inadequate. Many others will arrive late and over budget or require massive reworking. Few IT projects, in other words, truly succeed.
From Rapid Development:
If Las Vegas sounds too tame for you, software might just be the right gamble. Software projects include a glut of risks that would give Vegas oddsmakers nightmares. The odds of a large project finishing on time are close to zero. The odds of a large project being canceled are an even-money bet (Jones 1991).In 1998, Peat Marwick found that about 35 percent of 600 firms surveyed had at least one runaway software project (Rothfeder 1988). The damage done by runaway software projects makes the Las Vegas prize fights look as tame as having high tea with the queen. Allstate set out in 1982 to automate all of its office operations. They set a 5-year timetable and an $8 million budget. Six years and $15 million later, Allstate set a new deadline and readjusted its sights on a new budget of $100 million. In 1988, Westpac Banking Corporation decided to redefine its information systems. It set out on a 5-year, $85 million project. Three years later, after spending $150 million with little to show for it, Westpac cut its losses, canceled the project, and eliminated 500 development jobs (Glass 1992). Even Vegas prize fights don't get this bloody.
The history of software development is a tremendous success. Just look around you for evidence of that. But that success has a long, dark shadow that we don't talk about very much: it's littered with colossal failures. What's particularly disturbing is that the colossal failures keep recurring year after year. The names and dollar amounts may change, but the story is otherwise the same. Two recent examples are the Canadian gun registry and the FBI's Virtual Case File system.
If you're looking for more examples of colossal software project failure, you don't have to look very far:
You'd think that the software development industry would have matured over the last ten years. And it has:
The 10th edition of the annual CHAOS report from The Standish Group, which researches the reasons for IT project failure in the United States, indicates that project success rates have increased to 34 percent of all projects. That's more than a 100-percent improvement from the success rate found in the first study in 1994.Asked for the chief reasons project success rates have improved, Standish Chairman Jim Johnson says, "The primary reason is the projects have gotten a lot smaller. Doing projects with iterative processing as opposed to the waterfall method, which called for all project requirements to be defined up front, is a major step forward."
The Standish Group has studied over 40,000 projects in 10 years to reach the findings.
Project failures have declined to 15 percent of all projects, a vast improvement over the 31-percent failure rate reported in 1994. Projects meeting the "challenged" description -- meaning that they are over time, over budget and/or lacking critical features and requirements -- total 51 percent of all projects in the current survey.
Failing is OK. Failing can even be desirable. But you must learn from your failures, and that requires concerted postmortem introspection and analysis. I'd like to think that a large part of the statistical improvement cited above is attributable to sharp project managers and savvy developers who studied the first CHAOS report. Once you know what the common pitfalls are, it's easier to avoid them.
Another timely example might be the disasterous Seasprite helicopter program for the Australian Navy. $1bn spent, helicopters grounded, software problems are being mentioned explicitly.
http://www.theaustralian.news.com.au/story/0,20867,19145841-28737,00.html
Alastair on May 15, 2006 5:00 AMTheDailywtf.com is full of examples of why projects fail.
Ultimately, no one wants to take the blame, so analysis is as shallow as possible and no one learns and the companies frequently drive away their best workers while rehiring those they previously fired for complete and utter incompetence (except that those doing the hiring didn't know, because those doing the firing are too fearful of libel lawsuits to actually record theier full motivations)
I was in just such a company. We fired a useless employee who drove the other employees nutz and provided zero work in return. Several months later, the employee was back and untouchable inspite of the fact that any work that WAS produced failed to meet ANY of the requirements provided.
I left a few months later and the employee was still there wasting time, money, while distracting and driving away those who could could actually perform their jobs.
The company tanked about a year or so later. Once the people who can do their job leave and those who stay learns you can get paid for nothing, your company's life expectancy drops dramatically.
Xepol on May 15, 2006 5:29 AMIt's great that companies are starting to admit that failures exist. One of the problems that I've seen in our industry is that if a product of any sort ships, it's considered a success, whether it meets any requirements or not, and whether it makes any money or not. If it was late, over budget, and doesn't do what it's supposed to, it's still called a success because it shipped. The people involved can put it on their resume and get off to their next job before anyone realizes it was actually a failure, and they get to do it all over again!
Darrin on May 15, 2006 6:06 AMI think your two posts today are related -- at least one of the reasons that software projects get out of hand to become collosal failures has to do with ego. It's not as if people working on the project are clueless until the big rollout and then ... oh, dang. Someone, somewhere either refuses to admit, or refuses to hear, that there's something seriously wrong.*
That someone can also be the customer. We have a new central library here in Seattle, and a couple of years ago when it first opened, we got a behind-the-scenes tour. They had installed some hugely complex automated system for sorting returned books and putting them on appropriate carts -- something like what the post office does. Yet it was apparent even in our short visit that the system was a disaster -- we watched as they had to stop the line, as the various book-sorting machines made mistakes, and someone even showed us the hatch that someone climbed in every once in a while to retrieve books that had gotten stuck.
The folks running the thing were putting on a good face, but I wonder who the brave soul was who finally said "For the price of this system, we could have hired a hundred interns!"
This is also about where the hardware guys say "You see? Software isn't engineering -- this sort of stuff doesn't happen with real engineers." ("If Windows were a car, ... yadda-yadda.") Fortunately, we have the likes of Henry Petroski to remind us that more than one bridge has fallen down:
http://search.barnesandnoble.com/booksearch/isbnInquiry.asp?z=yisbn=0679734163itm=1
* Of course, there's also just simple nay-saying. When the Boeing 777 was being designed, I heard more than one old-timer say "That thing will never fly!" Because they'd used computers to design it, not pencils or whatever. Fortunately, Boeing persevered. :-)
My comments are biased by 10 years working for government on contract, but my sense of it is that we have good methodologies available, the failure is usually one of the following:
1) magical thinking by managers (eg: neglect a major project requiring 6 months for several years and then promise it can be delivered in 2 weeks when a crisis has developed as a result of said neglect);
2) most managers and programmers do not believe good methodology works, or do not know it even exists, and therefore will not practice it (people who do are thought of as 'dreamers');
3) programmers do not understand how to organize their work in a failsafe and consistant manner (eg: their work is a random pile of paper and randomly scattered files across several computers; they do not execute their own code or complete one routine before moving to the next, saying source code control and OOP programming is too much bother to learn, etc);
4) political sabotage by a vested interest (eg: worker stands to lose frequent free overseas trips and massive overtime 'maintaining' the faulty system sabotages the replacement system by ensuring that critical specs are kept secret or changed every few weeks; bad programmers fail to deliver in a way that causes the good programmers to fail on their deliverables, sometimes maliciously).
Obviously, despite having numerous detailed examples on hand, this is about as much as one can say in public.
While failure studies abound (I have much of the same material on my site), what isn't mentioned anywhere is the complexity of designing software. When I say designing software, I mean it is the source code that represents the design, nothing else matters.
Why is that? Why is designing software so complex? This is aside from requirements gathering and methodologies. While I can point at our industry as being unindustrialized compared to other industries (look at the electronics industry and ASIC design for example), it still does not explain some of the fundamental complexity issues while designing software.
I have made a case on my site that it really boils down to Brad Cox’s argument made several years ago where we don’t have a rich and vibrant market for reusing software components. Where components are supplied (from a catalog), reused on top of other components and assembled to produce a software solution. Until that day arrives, as Brad calls it, the Software Industrial Revolution, we are going to see more failure studies and more arguments to whether software design is computer science or software engineering.
while there's no shortage of blame (or praise) to go around, I point the finger directly at management, particularly the middle echelons of management.
When I started working for a large videogame developer/publisher - no name provided here, but you know who they are! - I was amazed to see task estimates being bidded and bartered as though they were arbitrary figures. Time and time again I ran into situations where I or a coworker gave considered estimates only to see management go to someone who wasn't even involved to get a competing (shorter) estimate. You can imagine which of those two numbers made it on to the project schedule.
Again and again we were told to "work smarter, not harder", yet the only manifestation of this I ever saw was to place more managers on a team when what was needed was an additional artist or engineer.
Surely project management has to be about more than getting Excel or Project to output nicely formatted fictions?
Gary R Boodhoo on May 16, 2006 12:52 PMAnother interesting article to add to your collection : "Why Big Software Projects Fail: The 12 Key Questions"
http://www.stsc.hill.af.mil/crosstalk/2005/03/0503Humphrey.html
Here is the abstract:
"In spite of the improvements in software project management over the last several years, software projects still fail distressingly often, and the largest projects fail most often. This article explores the reasons for these failures and reviews the questions to consider in improving your organization's performance with large-scale software projects. Not surprisingly, considering these same questions will help you improve almost any large or small project with substantial software content. The principal questions concern why large software projects are hard to manage, the kinds of management systems needed, and the actions required to implement such systems. In closing, the author cites the experiences of projects that have used the methods described and cites sources for further information on introducing the required practices."
This article has some valid points, but I think they are being shrouded a bit.
First of all, we hear about spectacular software failures because that's what makes news. How often do we hear "we just launched our new site, it's making our client millions and it went off without a hitch!" ? You don't. That's not news worthy. What is news-worthy is when a company loses billions because of software failure.
Also, a large percentage of the time (in my experience), projects are late and overbudget because people who know nothing about software development are the ones who make said budget. If I tell you it will take me a week to write X, and you budget me 2 days, that's not my fault.
Yes, as developers we should be held accountable for our code and we should strive to get better, which I think is the point of this article. However, to say that we've got a "long dismal history" is misleading at best.
Jeremy on May 17, 2006 10:58 AMI have to agree that part of the reason software projects fail is they fo not obey the laws of physics. when a brige or hardware component is designed the requirements are very specific. a bridge builder knows it needs to support trafic in both directions with known sizes and known weights. however when a software bridge is being designed(as to be used to do data conversion) the incoming data is many times more complex, sometimes the data is garbled but you never see half a car drive across a bridge.
Andrew Ray on May 18, 2006 9:27 AMAnother interesting article to add to your collection : "Why Big Software Projects Fail: The 12 Key Questions"
Thank you for pointing this out. I've read that before, and it's a great one.
My point is: hardware is less complex
I'm not sure it's always less complex, but you're playing by God's rules when you develop hardware, which are a lot more stable:
http://www.codinghorror.com/blog/archives/000298.html
By the way, you can't compare software to hardware because of complexity. Why do you think hardware is as thin layer as possible everything else being software? Because it's cheeper to make software doing same things than to make hardware I think. Why is it cheaper? Because you do a lot of design/test/redesign work in hardware but you can go away without it in software and that's what makes it cheeper... You can always skip testing if You have no time left, making software copies costs virtually nothing anyway. Whereas in hardware you pay for the materials and such so to make one more copy costs you some money, to make a change in design costs you even more (e.g. new assembly line).
My point is: hardware is less complex, a lot more time is spent when designing hardware. Which results in hardware being more reliable. As simple as that I guess...
Your link to Failure Rate is hilarious: Coding Horror + Failure Rate = "Sorry, this key is disabled..."
oscar on July 18, 2006 2:45 AMWhen you think of the amount of castles and cathedrals that have sunk into motes...
Brian on July 23, 2007 8:02 AMI guess if you over exaggerate anything is possible.
loolcakes on July 24, 2007 6:46 AMWriting software is easy. Managing people is hard. Large software projects by definition involve the coordinated inputs of huge numbers of people. Those people must be managed so the sum of their inputs deliver the project to a useful end state. Therefore, large software projects are prone to various failure modes, and so long as they rely on people to steer them, always will be.
This principle is just as true of tin-bending as bit-smashing. It is no difficult feat to come up with similarly impressive lists of projects to build "real stuff" that came in grotesquely late and over budget, or were cancelled altogether. The US Dept. of Defense alone could fill entire books with lists of their failed hardware projects.
KJA on July 25, 2007 4:26 AMAnother thing to note is that that cost of software failure is not just in the lost productivity and increased investment, sometimes there is a necessity to pursue litigation so that business can attempt to recoup losses. That means hiring expert witnesses like software failure experts and the like, and the issues that occur because of the original problems continue long after they source has been rectified.
ChrisJ on March 21, 2008 10:05 AMwhat in your opinion is the most frequent cause of software failure.do you know which was the most silly software failure
mohsin on February 26, 2009 9:12 AMI agree with Asterion 99.999%. Probably a sampling error...
Mitch, yeah, read that article but did not change my opinion.
Source code is not design. Design is design. Trivial perhaps, but undeniable.
It can be easily demonstrated that source code is *not* design by just compiling it (or interpreting it).
If what you (Mitch) states as true "Source code is design", is true then it follows that object code is design. Machine code is design. Voltages are design etc. etc.
Where does that leave us?
I think design is a bit (heh, heh) more than voltages, don't you?
Malcolm on June 18, 2009 2:37 AMIn many organisations iterative is not an option. Typically these are large organisations requiring stage gates or accreditations to be met. And empirically, from 11 years of contracting, it is obvious to me these organisations suffer the most from runaway project syndrome.
The almost ubiquitous push for SOA from large organisations is only going to exacerbate the problem, since SOA only helps to lock organisations into simultaneous releases of large numbers of systems and hence the waterfall process. I'd really like to see KPI's from a few organisations that have done SOA to prove that it really improves delivery times, becuase while the upside is unclear, the downside is very evident.
In many organisations iterative is not an option. Typically these are large organisations requiring stage gates or accreditations to be met. And empirically, from 11 years of contracting, it is obvious to me these organisations suffer the most from runaway project syndrome.
The almost ubiquitous push for SOA from large organisations is only going to exacerbate the problem, since SOA only helps to lock organisations into simultaneous releases of large numbers of systems and hence the waterfall process. I'd really like to see KPI's from a few organisations that have done SOA to prove that it really improves delivery times, becuase while the upside is unclear, the downside is very evident.
Ben on June 22, 2009 11:17 AMThese stories highlight the importance of a fail fast mentality. It's pretty hard to accidentally blow a half a billion dollars on a project with short iterations. You find problems early and either correct them quickly, change your scope, or cut your losses.
It's wild that people work so hard to fail so colossally. I'm sure that all these projects had huge specifications representing thousands of hours of analysis and word processing. What could have gone wrong?
Jon Galloway on February 6, 2010 9:46 PMMitch, Mitch, Mitch.
Source code is not design. That is the thinking that causes project failures.
I think people are starting to understand that the Gang of Four patterns are often implementation patterns and not design patterns - so it is a common delusion.
The myth that "the design is in the code" has been spouted by many so-called Gurus including Gates who's precious Microsoft has now turned tail and is investing heavily on getting requirements and design right because the knock-on cost of post production fixes is hitting the bottom line.
Problems I see with some of the data on this page includes mixing up “gotten a lot smaller” with a move away from waterfall. Note the missing historical context of “build it all from scratch” to use of substantial open architectural frameworks which is what distinguishes them old daize with the rich open frameworks that are available today.
Smaller projects are bound to be statistically more "successful" (all things being equal) so I am not sure that the info has necessarily transcribed the source info correctly.
The problem with waterfall is the same problem with agile. No software constructionist goes back to the requirement engineering fraternity to pick up on the latest best practice in RE.
If you look at the flip, for example, between "successful" and "failed" projects you could account for it simply "a lot smaller" projects.
So how do you interpret the "limp" still being proportions as the old daize of waterfall.
Have a look around at other data.
The statisticians are still calling on my old favourite - no clown is spending time on getting the requirements sorted.
You see agile is great but unfetted requirements don't make sense from a business perspective. Sure, hotshot developers want to have their faces licked and feel god-like but in the end the bottom line is no requirement baseline, no stopping condition.
Are YOU there yet?
Asterion on February 6, 2010 9:46 PMSource code IS design...Open your mind~
Source code IS design...Open your mind~
Ramonoski on July 30, 2010 5:33 PMTo be honest with you, source code is the only reason you can program.
Ramonoski on July 30, 2010 5:35 PMIf we can get more people to understand the source code then we can move forward rapidly.
Ramonoski on July 30, 2010 5:37 PMThe comments to this entry are closed.
|
|
Traffic Stats |