I found it extremely interesting that the software market would allow for such failures and inconsistencies. Under normal circumstances, a free market economy will will drive companies to strive to produce the best product and the best price. However, it seems that companies are in fact getting away with producing mediocre products. After the initial production, the software companies then stand behind their disclaimer and hope for the best. Of course, because of the relative novelty of the software industry and the rate of growth, such inconsistencies are able to slip by.
I could point in many different directions and say they are to blame of not preventing program failures. Although software producers are in fact protected, we all know that they are at fault for producing a defective product. Their problems may lye on the way they conceptualize programs. Of course, it would be to simple and obvious to blame the programmers. In reality, the blame can be spread evenly. Software compilers, testing methods, and even the software user can be the contributing factor to a program's failure.
"What categories of people might be to blame when a program fails, and in what way might they have contributed to the failure?"
PROGRAM DEVELOPERS could take the blame when a program fails since they created it and perhaps should have been expected to make it work correctly by (everyone, but particularly...)
Their INVESTORS, who may have had unrealistic expectations (and made unrealistic demands) about what the program should do, how long it should take to develop, and how reliable it should be. The resulting program, and the programmers themselves, perhaps should have been policed more strictly by
Their LAWYERS, who could be responsible for ensuring that the product meets certain standards, but these standards have to be set by
THE GOVERNMENT or INDUSTRY OVERSIGHT GROUPS, which perhaps should be responsible for setting standards for programs and programmers, thus ensuring that programs meet certain minimal requirements for usability before it goes out to
OUTLETS/MIDDLEMEN, who also might be responsible for ensuring that the programs they're selling/installing will work for the
USERS, whose constant demands for better and faster systems that do more push the other groups to put unreliable programs on the marker, who perhaps ought to know that no program is 100% reliable, and who should have had enough knowledge of the program before they used it to figure out if and how it would fail and how to fix it before it affected
THE GENERAL PUBLIC (affected by users such as banks, supermarkets, the government, the medical establishment, etc.), who perhaps should know better than to completely trust their lives/money/information to anything that has any connection to a computer (impossible and extreme, I know, but I wanted to implicate everyone possible), and whose extreme demands for faster, better services push the users to demand systems beyond programmers capabilities.
Categories of people: programmers, marketers, consumers, business people/management.
Here are my thoughts. Obviously, at the very basic level, we are wont to blame the programmers because they are the ones who developed the program and presumably lacked the foresight or thoroughness to account for the failure. however, there are also many confounding factors we must account for. assuming these programmers work for a large corporation, they are developing something for someone else. this means that they have less discretion and control over what they are programming. they may foresee problems which are dismissed by management because the management is either unable to see the gravity of the situation or doesn't care because they are ruthless and want to make a profit even if it means taking advantage of the customer. (for these same reasons, the management may also push the product out on the market too early (with more bugs) despite advice from their programmers.)
this is where the marketers come in. again, they have the ability to advertise the program as whatever they want, which may or may not meet reality. in this way the programmers are further misrepresented and the public is misled. the misled public/consumers are then disappointed either due to high expectations about what the program can do, ignorance about how to use the program, or both. the consumers have contributed to the failure because they have bought into the idea that the large corporation wants to sell them, leaving the programmers with even less authority, and perpetuating the viscous cycle.
(yes, i do believe that consumers have the responsibility of having some computer knowledge and using common sense. i know that programs should be user-friendly, but the programmer should also be able to expect that people will have reasonable expectations and at least read the instructions.)
1.) Users: User failure to operate program correctly, failure to input correct data in the correct manner, failure to understand what to do in a problem situation with a particular program.
2.) Programmers: Programmers can produce program code with errors or fail to notice or fix a mistake.
3.) Development: A development team can fail to yield reliable program code by inadequately testing the program, using methods that fail to turn up all errors. Inadequate testing can take the form of problems in code checking, understanding, or through procedural incompetence by the team leader or organizer(s).
4.) Requesting Industry: The industry that requests a program product may fail to specify the needs which the program should meet adequately or fail to implement the computer system in a manner in which it works properly. In cases, where an industry has standards, those standards may be inadequate, or the standards may not be followed. Then, this question is important: Should programmers be certified?
5.) Age and other factors: Software age can also effect reliability as well as compatibilities between old/new computers and old/new software. Another factor is digital limitation--that digital programming can produce errors of state which analog methods are free from, and it can be impossible to exhaustively test a program which contains code that is too complex and would require too much time to test to be worth the cost with respect to time. Moreover, often it is thought that program correction leads to more mistakes during editing. Clearly, a delicate cost/benefits efficiency analysis must be made in determining how to make programs "reliable."
I think that while blame can sometimes be placed on program users insofar as they may use software inappropriately, more of the blame for program malfunctions should be placed on those at the software production end itself. While I don't think it at all reasonable, or perhaps even possible, for software designers to create bug and glitch-free programs, I think they definitely have the responsibility to at least acknowledge and make their project managers aware of a program's shortcomings and limitations, and not knowingly design poor programs just because they are under time constraints.
It should be the responsibility of project managers not only to relay these limitations to those higher up (with the hope that the consumer will eventually become aware of these shortcomings/glitches), but to ensure that some reasonable degree of program verification and derivation take place in the process of a program's development.
Ultimately, it should be the responsibility of those that will eventually market and sell the final product to decide whether a program is fit for release; if the quality of a program is really poor, by whatever standards, it shouldn't be marketed. Of course, odds that many companies will think twice about quality as long as the product will sell are probably not very high.
Certainly, there is a degree to which program error and malfunction has to be expected no matter how meticulous the development, given that software development is hardly an exact science. But it seems like development standards could definitely stand to be raised and better maintained at all levels.
The irony is too thick. I minimize Outlook Express to work with Adobe PhotoShop. I finished with Adobe and I saved my graphics and closed. During the closing of Adobe, my computer froze. Outlook doesn't save the email I have typed to you answering the question. My apologizes for the hostile tone of the following email. The frustration is not directed at you, rather, my frustration is directed at computers in general.
What categories of people might be to blame when a program fails, and in what way might they have contributed to the failure?
The first category of people to blame when a program fails is all people with the name, "Bill Gates."
The second category is hardware producers that contributed to program failure by: * 1.) Failing to cooperate with users * 2.) Failing to cooperate with software producers * 3.) Lacking effective technical support * 4.) Lacking backup systems * 5.) Pursuing pipedreams at the expense of more realistic goals * 6.) Overemphasizing speed at the expense of reliability * 7.) Mixing old and new code * 8.) Relying on patches to fix problems instead of producing quality hardware to begin with * 9.) Making systems too complex for users to understand or to use effectively * 10.) Emphasizing profits over quality
The third category is corporations (Dell, Compaq, Gateway) contributed to program failure by: * 1.) Going along with what the software and hardware developers do * 2.) Not offering user training with the purchase of computers
The fourth category is software producers contributed to program failure by: * 1.) Lacking of backup systems * 2.) Lacking coordination from program to program (WordPerfect, Microsoft Office, and Lotus Works are examples) * 3.) Over-relying on patches * 4.) Mixing old and new code when patches are used * 5.) Not testing software to the extent it can and should be tested * 6.) Forcing the user to pay for upgrades instead of the software manufactures admitting that they were unable to produce a quality product in the first place * 7.) Not acknowledging faults in their product and allowing the user to go around the faults * 8.) Making software too complex for users to understand and use effectively * 9.) Emphasizing profits over quality
Users contributed to program failure by: * 1.) Being general incompetence * 2.) Thinking they know what is going on with computers and really being incompetent (much more dangerous than someone who is incompetent and recognizes their inadequacy) * 3.) Overdepending on computers * 4.) Improperly using software (using the software for a purpose other than the intended purpose, as defined by the software manufacturer)
Many of the issues could be addressed if a system of peer-review was instituted. If the code doesn't work it shouldn't be published. Establishing certain standards of reliability to be enforced by an agency external to software and hardware manufactures would increase the reliability of their products.
Computer programs are generally reliable, but they are definitely not perfect and their malfunctions can cause serious damage. When errors do occur, I naturally blame the programmer his/herself, because they obviously did not spend enough time debugging the program. However, Chapter 5 of Forrest and Morrison says that even a relatively simple program of correcting incorrect states at 100 per minute, "software testers would need some 4X10^24 years to exhaustively test the array of possible states that this piece of software might conceivably take." Taking this into consideration, I cannot blame the programers, since it seems to be not in their power to make a program 100% fullproof. So the solution is that programmers just have to make their lives easier - make it easier and simpler to test all the possibilities of a particular program. Forrest and Morrison suggest getting rid of "spaghett-like code that programmers tended to produce using the earliest high-level languages, such as FORTRAN and COBOL." They also suggest increasing program verification and derivation via mathmatics and bettering the environment programmers have to work, by providing them with better software tools and such. In any event, program debugging is very expensive and the cost is also a limiting factor. So in conclusion, I can blame no one really, at least before we make it realisticly possible to make programs totally unflawed.
Oh, so many people to blame, so little space in which to blame them. The first, and most obvious to me, is the person who created the particular line of code that failed. This person obviously didn't do enough work in testing the program to ensure that all the features worked in all situations. How could you do such a thing!?! The next most obvious to me is the programmer's supervisor, or the design team supervisor or head, or whoever was directly in charge of the person who wrote the failing code. This supervisor would also have been in charge of dealing with testing and also obviously didn't realize that the failing programmer was inept at writing his code. Next most obvious to me is Bill Gates. Bill Gates is directly responsible in some way for almost any computer problem you encounter that deals with software. Most of that goes directly to the crappy nature of Windows, but also to the way he has influenced programmers of other platforms to also program poorly. I would also consider whoever owned the company involved in the production of the program responsible(these corporate attacks only work if the program was designed, of course by a corporation; I'm thinking of a problem I might have with Corel Word Perfect, but I admit that some of these won't apply always). These owners include stockholders and anyone who has any real stake in the company's success, because they obviously haven't provided any of the people in the command chain with sufficient rewards for proper programming. Also to blame are the programmers' parents, who must have failed in raising their child to be a good and proper programmer (not saying they failed in any other way). I also blame the users of the program because in a capitalist society such as this one, the power they exert over the software agency to produce programs at a faster, and therefore buggier, rate may have rushed the programmer unduly. Let the man do his job, would you?? I think it is also pertinent to blame Bill Gates again for giving the programmer added incentive to not care about his program enough and just hope that it became so popular that he would be a multi-billionaire and monopolize a certain software aspect, the one in which his program failed. I also blame Mark French, for being a roaring asshole who causes everyone's day to be a little less bright (except for his girlfriend, I suppose), and therefore must have caused the programmer's life to be a little less bright and he must have missed a ";" when he needed it or something. I also blame the capitalist society for the pressures it exerts on the society which then causes the programmer to write failing code. Next on my list of people to blame are the socialists. If they're so good, then why didn't the Union of Soviet Socialist Republics work? Why don't they just shut up and let capitalism work for a little while and improve itself? GEEZ!!! I also blame Robert Norton Noyce '49 for co-inventing the transistor and causing computers to be what they are today. Furthermore, I blame the first mathematician to ever dream up a computing machine to help with his figures; he should have used his frickin' hand to write it all out!! I next blame Bill Clinton for causing the entire world a distraction for more time than his stupid Arkansan, Oxford-educated face is worth. I also blame Bill Gates one more time for having stolen the Windows concept from Steve Jobs and the Apple folks in the first place; it would have been a better operating system Apple's way. Steve Jobs and Apple are also to blame for allowing Bill Gates to steal Windows and be such a conniving bastard. I blame Canada for being too weak to be their own country and causing too many bad television shows, which obviously affected the programmers' creative ability by making him that much more stupid. I blame the entire city of Centralia, Illinois, for being decadent and self-promoting and for adversely affecting any person who has ever come within 10 miles of the town, possibly including the programmer but if not than almost definitely someone who has come into contact at some point with him. I blame the inventors of the programming language for not providing a more flexible language, and I blame the inventors of other inflexible programming languages for that same reason. I blame the inventors of flexible programming languages for being too flexible. I blame God for creating an imperfect world in which the programmer was permitted to make a mistake, and I blame all the bad drivers in America for making everyone's life a little less safe, which probably caused the programmer a little stress, too. I'm not done, but if I don't stop now I'll be up all night writing this and it's probably just dumb and annoying anyway; therefore, I blame myself for the programmer's failure because I'm dumb and annoying and irritating enough that caused enough people to have bad days such that it eventually got to the programmer and so it has to be my fault.
Disclaimer Often, these pages were created "on the fly" with little, if any, proofreading. Any or all of the information on the pages may be incorrect. Please contact me if you notice errors.
This page may be found at http://www.math.grin.edu/~rebelsky/Courses/CS105/2000S/Questions/question.29.html
Source text last modified Wed Feb 16 08:16:03 2000.
This page generated on Wed Mar 15 09:18:53 2000 by Siteweaver. Validate this page's HTML.
Contact our webmaster at firstname.lastname@example.org