Slashdot Mirror
Calling Software Reliability Into Question
phillymjs writes "CNN is running a story on software reliability, and how the lack of it may cost more and more lives as technology creeps further into everyday products. It appears a debate is finally starting amongst everyday (read: non-geek) people about vendor liability for buggy software. Some opponents of the liability push are unsurprising: Says the story, 'Microsoft contends that setting [reliability] standards could stifle innovation, and the cost of litigation and damages could mean more expensive software.' The article also says, however, that consumers' favortism of flashy products over reliable ones is partly to blame for the current state of software."
I like what Microsoft has been doing qith security these days, quite frankly. The new security features in Windows Server 2003 look innovative and very modern, and quite easy to use.
Linux may be secure when configured correctly, but Windows Server 2003 looks to be the most secure OS out of the box at the moment.
Abortion is advocated only by persons who have themselves been born.
--Ronald Reagan
...could reliability standards stifle innovation? How hard is it to design something that works well and is extremely robust, yet, be creative and innovative in its design?
So...basically people are just finding out now that not all software is as perfect as it is intended to be?
Great..I'm gonna have to explain this one to my parents...
The anti-salmon
It is, but monday was just not long enough ::)
You know it makes sense, a little reminder from jointm1k.
The trouble is, the more accustomed users become to bugs, the harder it is to get them reported and fixed. If my computer crashes, I just reset it and get back to work. I don't bother to investigate what caused the bug, to try to reproduce it, to contact the vendor (hah!) and try to work out the problem. Crashes occur much too frequently for that.
OTOH, if computers were reliable enough to crash only once every few years, then users might report every crash that happens, the vendor can diagnose it, and fix the bug or family-of-bugs so that it never happens again. This is roughly what happens when a mainframe crashes, I believe - it's a big event.
Imagine if when your microwave crashed, you could call some hotline, they would come and replace the microwave and take away the old one for analysis. Instead, even on complex software systems the standard first resort for the help line is 'reboot and see if it goes away'.
-- Ed Avis ed@membled.com
What's wrong with flashy stuff for somethings? I like flashy (i.e. sometimes buggy) software for my laptop. I don't mind if my beta-version browser crashes once in a while because I get the new features.
My servers, OTOH, are another story. I wouldn't use anything but Debian (for linux, that is) because it is incredibly stable. My two Debian boxes on woody stable run 2+ yr old software. Guess what? They don't crash. I didn't upgrade from potato right away, but waited a little while.
Consumers are generally willing to accept more buggy software because they don't run servers. So what if Word crashes once in a while? Most consumers are so conditioned to it that they don't think another thing of it.
I realize that mail servers, electricity systems, and space probes need stable software, but most consumers don't administer these things. They use browsers, email, and cell phones that don't cause (much) physical harm when they crash.
Remember, one thing M$ does well is pay lawyers.
IMO if a company is unwilling to supply you with the source code (under whatever license) to let you see and fix problems that exist they should have no possible exemption from litigation, no matter what POS EULA they persuade you to sign.
They are asking you to place your trust in them that their code is good enough to bet your business on. If their software is not all it's cracked up to be and you had no chance to check their claims (but instead had to take their word for it) then they clearly are responsible for breaking their word.
Unless they told you that it was a buggy product that you couldn't rely on in the first place... now that would make for amusing adverts.
(Can you imagine Windows boxes with cigarette-health-warning style labels on them saying "The Computer-General warns that this product may be bad for your business.")
Beep beep.
The company with the most to gain from this (with its unique cash reserve - Microsoft) is the company most in opposition...
Yes, I said it. I'll say it again. Microsoft could gain *alot* from this movement.
With their resources, they are the ones that could easily afford a true source-code audit the likes of which the BSDs are only beginning to approach.
They could build an operating system that fully, completely, and truly matches the concept of "secure by default" and they have the resources, manpower, and ability to do so.
But, instead, they oppose it. Building a secure system is against corporate culture, so they won't do it.
Thanks xBSD!
I have no problem with your religion until you decide it's reason to deprive others of the truth.
Isn't the trend towards "flashy products" rather than reliable ones the same reason why current marketing pushes sex rather than product qualities (Pepsi, A&F, etc), movies flaunt big-name actors and actresses, and people won't go see a movie unless it has a high PG-13 or R rating (PG? It's got to be boring). This is the same reason why Legos now has 3-piece dumptrucks and 8-piece Hogwarts castles. Why is this? Dumbed-down education? Why is it that people have just started to gobble up whatever the media tells them rather than understanding what they need for themselves. *sigh* What's society coming to?
I've often thought about how many products use simple programs and stuff to run correctly...like traffic light systems...right now they work pretty well and everything goes together properly. However, the day that cities decide to have a central server run the traffic lights so they can...say, control traffic around accident areas...things will go wrong. The "foolproof" software will cause all sorts of problems.
I don't see this so much as software causing problems as much as the tendency we have to make what used to be simple things really complicated. One example I have in my life is a train system that runs around inside a building by the ceiling at a camp I work at. The system looks really nice..and it could work well. However, having a couple of electrical engineers volunteer their time to make the system made it very different. Now, what could have been a simple on off switch is a whole panel with an LCD display and all sorts of error lights and little IR detectors on the track to make sure the train is in the right place. It is a geek paradise...but the train NEVER works. Despite all the fancy assembly code they have running the whole thing, it doesn't work. An on/off switch would have worked..I'm certain of it!
As we complicate more and more appliances with complex software, there are going to be more problems. Heck..what's gonna happen next time your toaster oven timer crashes...you could burn down a house!
The caveman had something going for them...
The anti-salmon
And Bill Gates turns to the CEO of GM Motors and says, 'Why is your technology moving so slowly? If you advanced at the same rate as we do, we would have flying cars by now!' Immediatly the CEO of GM turnes to Billy and says, 'Because the government doesn't allow us to build cars that crash 4 times a day.'
I'd say that most non-geek users are completely ignorant of software reliability. A computer just has errors. They have grown to accept that. To them that's why they have a warranty and that's why tech support exists. The typical windows 9x users believes that a restart is the natural second step to every click or change they make. I knew a girl that thought an illegal operation meant she could go to jail (for what she did not know.) So the first step in making software companies more reliable and more accountable is educating the common users. If people know what they are getting is bad their excuse wont be that Dell sold them a shitty computer, it will be that Software Maker X sold them buggy crappy software. Until then companies like Microsoft will run-amuck.
Moreover, how innovative has MS (or anyone else) been about reliability? Adding new features like embedding full-length motion pictures into Word documents (apologies to Neal Stephenson) is one kind of 'innovation,' but it comes at the cost of gains in stability. One could argue, and people have, that most commercial software is derivative anyhow, and its mass adoption has stifled opportunities to create more stable products.
And finally, do we really need that many new twists on things? I'm not saying stop research or trying new things, but mainframes running COBOL code have been hosting most of the world's financial and business information for decades, and they are legendary for their stability, with low incidence of data corruption and uptimes measured in years to decades.
"Hardly used" will not fetch you a better price for your brain.
This is part of the reason that much commercial software has so many problems. The consumer wants their programs cheap and they want their programs released two weeks ago. Sacrifices in the development and testing cycles are constantly being made in order to bring the product in at a lower cost and in a shorter timeframe.
I hate liberals. If you are a liberal, do not reply.
Not to worry, the same article will be posted on Slashdot again tomorrow, possibly sooner.
10 steps for builidng a successful software product:
1) Fire half (perhaps all) of your programming staff. Most of them don't know know the difference between a heap and a stack, don't have a clue beyond the Java language, and if faced with the prospect of learning x86 assembly language, they'd faint.
2) Hire people that *do* know the difference between a heap and a stack, perhaps have written in some assembly somewhere (even if just in college), and have figured out how to use a few more languages besides Java.
3) When doing #2, ignore college degrees. Whether or not someone has one doesn't indicate whether or not they're a good programmer, at least until our the majority of our school system can actually teach the *relevant* skills.
4) Plan. Plan. Plan. Document. Plan. Flowchart. Plan. Plan. Discuss. Plan. Discuss. Plan. Document. Plan.
5) Code.
6) Discuss. Test. Fix. Discuss. Test. Fix.
7) Refactor
8) Repeat 6-7 until all the software has been reduced to the simplest, most error-free possible codebase for its functionality.
9) QA. (Yup, this happens *after* the testing in (6)!)
10) Ship.
-- sigs cause cancer.
"The idea that we depend on something that's inherently untrustworthy is very frightening," he says.
This is such crap. Software is not inherrently untrustworthy. The fatal incidents cited all appear more due to human error rather than software bugs, as has happened since man started building machines.
If software was so inherrently buggy no one would get on a plane or dare trust a traffic control signal.
As for making manufacturers liable, you can but I would expect a negatibe response rather than an improvement. I am in favour of anything that improves software quality but I think what is most overlooked when people talk about 'buggy' software is logic errors, and misinterpretation/misexplanation of user requirements. If the developers/manufactures are to be held liable should we not then turn around and litigate against the subject experts who helped build the use case's?. What about the users who misuse/abuse their software causing unexpected results or loss?
If developers/manufactures do become liable then the insurance and testing costs will probably drive the price of software beyond the reach of the individual.
Do not try to read the dupe, thats impossible. Instead, only try to realize the truth
What truth?
There is no dupe
I guess I've had a different experience with reliability than most of the posters here have had.
Given a piece of software that has both Windows and Linux versions, the Windows version is almost always more reliable/less buggy.
The Linux version usually seems to have been done as an afterthought, and most of the development work goes into the NT product.
I'd like to choose the Linux version everytime, but for most software, the Linux implementation just isn't there yet.
As long as companies like Microsoft are around to pump money into lobbyist firms and election campaigns, we'll never see a software-reliability law that's actually beneficial to consumers.
I'm pretty much willing to settle for some sort of truth-in-software-advertising law... so when William H. Macy's voice tells us that Microsoft's server software is totally secure and reliable, it also has to tell us that Microsoft's EULA says that if this turns out not to be so, tough shit on you for believing it in the first place.
~Philly
It is certainly true that users place reliability very low on their list of priorities when buying products, but that does not necessarily means that they don't value reliability. It merely means that they take reliability for granted.
:-).
For example, the last time I filled in a car survey, I didn't put "does not explode when ignition key turned" anywhere on the form.
The problem is a fundamental one. There are way, way, way too many possible parties to blame. The only logical reaction for MS if such a law was enacted would be to immediately cease running any software that wasn't authorized by MS (with approriate fees, bars for competing programs, etc.), a situation that I imagine they see only in their fondest dreams. Legislation like this would be the perfect excuse. To be honest, even I would barely question their right to secure their system if they are going to be held responsible for its flaws.
As for the idea that open source software should be exempt - I doubt that you'd accept the idea that cars should be exempt from safety standard if they provided you with the blueprints
I started using computers ca. 1979, when my dad got a TRS-80. I don't remember ever encountering a single software bug on that system, although the hardware certainly had its problems.
But does that mean that quality is getting worse? The OS on that machine was on ROM, and was about 4 kb. A modern OS weighs in at many, many megabytes. It's possible that the number of bugs per line of code has actually been going down.
Another possible metric is how often the user encounters a bug. By this metric, non-OSS consumer-level software has certainly been getting much, much worse. I switched to Linux from MacOS, and my average number of bugs encountered per day went from maybe 5-10 to some number less than one.
Some things have definitely changed since 1979:
Find free books.
Why should liability be software or hardwar based?
If i design a system to move some gears via an operator pressing big electronic buttons as a mechanical engineery, why should an electronic engineer who designs a program to operate the gears be exempt?
We are both designing a system to do a job. As an electronic engineer, I make my system based on some OS, so either I or the OS manufacturer (which, I add, licences an OS, if it is used against the license terms, it is my liability) has the liability.
Don't be lazy allocating responsibility.
Why can't there be a "cutting edge" in reliability?
Because software needs to be thoroughly tested before it can be called reliable. "Cutting edge" software tends to be poorly (relativly speaking) tested, since it hasn't had that much time in the real world.
Therefore, for instance, Debian stable still uses kernel 2.2 by default (alltough there's a 2.4 installation flavour), because it's well tested and reliable. As a result, I've never experienced inconsistency or crashes with a Debian stable release.
(Now, if you want cutting edge Debian, there's always Debian Sid (also known as unstable)).
"Because software needs to be thoroughly tested before it can be called reliable. "Cutting edge" software tends to be poorly (relativly speaking) tested, since it hasn't had that much time in the real world."
This is circular. You nearly imply "cutting edge" is not reliable by default. This is a mistake. If there is a market demand for reliability on the consumer level, then it may need a cutting edge solution: New diagnostics or testing mechanisms. Perhaps OSS is that cutting-edge methodology and it simply has not caught on everywhere.
..the notion that vendors would be liable for *bugs they know about* has some merit. Think about it. If the large companies-we'll pick on MS because it's such a good example-were forced to fix bugs in a timely manner, then they would need to accept bug reports. They would also have to release bug reports as soon as they knew about them, ie, they couldn't sit on a critical exploit and let people hang out in the wind for months and months. Once a report was made to them, it would then become an official bug they couldn't ignore. They'd have two choices then, switch to open source to find as many bugs as possible in the shortest time, or keep paying claims forever because they ignored bugs. Either way they would release less of better quality, not really a bad idea. If they wanted to hire professional beta testers, so what? More paid jobs. I don't see that as being all that bad. Nope, I don't.
Open source -FOSS- is in a unique position because it's "free". There can't be any damages if you haven't paid for it, or at least that could be part of "the law" written into it.
Normally I'm against new laws, but instituting some sort of consumer protection should be in order, if these companies want to make serious profits all the time. There are very few examples of consumer products out there that have no liability at all attached to them. With just a short time reflection on it, I can't think of any off hand, just *some* software. Eventually it's going to happen, so better to sort it out now, it really should have been sorted out 30 years ago, IMO. I tell you what will cause it too, if it's not done voluntarily in advance and adhered to, the first uber killer mass virus or trojan that makes code red or slammer look like a case of the sniffles, a net-killer. You'll get ten times worse legislation out of washington if the software community waits until that happens.
I'd say it's bound to happen sometime, too. The article cites 50 some odd billion a year already in losses due to either bad or insecure programs, you have something bad happens that does ten times that in one day or something, you WILL see the mother of all knee-jerk reactions from "the software consumers".
Well, OK, say that "something" is needed - What would be reasonable, but still not stifle development? One would be outright sales of software, not just renting -licensing of software. You buy it, you OWN it. You get it at such and such a date, as of that date it worked as advertised, after that date, well, up to the vendor then, anything "new" that needs to be added is up to them, from free unlimited patches and updates to pay-for individual bugfixes and exploits as you go, forever. Could be a yearly lease thing, whatever. For-profit vendors would get on the ball pretty quickly then if they charged too much or it didn't work all the time. they'd be forced into auditing as the most important part of production. Hmm, is this a bad idea really? The software is sold as "works on this and this, won't work with that and that". Yes, that would make software developers tend to work around just a few pieces of hardware and one or two OSs max no doubt. It would also be very expensive. Very expensive. Maybe people would go to the no liability but free stuff then? And I can see various versions in between those two extremes.
Could there be set limits per incident? Perhaps. Max liability, perhaps.
How about classifications of software?
"Entertainments" might be of lower criticality (so less liable in terms of maximum cash) then say the pacemaker software, or auto-controlling software. "Communications" like browsers and email and chat would be in the middle someplace in those terms of criticality. If your business depends on UPS or FEDEX to ship widgets, and they constantly don't get there or they are smashed, those companies would be sued out of existence. but if your widgets are electronic, well? It's just your tough luck as the consumer then, the software and the infrastructure has let you down, but they all get to say
Forcing companies to disclose bugs in this way could only serve to allow users to make more educated purchasing decisions on the basis of software reliability.
Imagine that I wrote some software that I *knew* was buggy, and then sold it to a hospital or into another situation where people's lives were at risk. Imagine then that one of the bugs I knew about before selling the software killed someone. Why shouldn't I be responsible for that?
The real right answer is to move that 50% to testing, double project timelines, add diagnostics and plan for quality from the very beginning.
Medical devices controlled by software have stringent FDA approval cycles. Basically you establish the quality of the engineering process, document the heck out of it, and then show clinical effectiveness in random control trials.
What I find fascinating is that legal basis for this is Food and Drug Act -- for the protection of the public as the reason. But the more important side benefit for the approval process is to protect physicians from liability. It's frightfully expensive. And, BTW, physicians *don't have to do this* if they are involved in active oversight when using an experimental device.
Conclusion: Most software products should be viewed as experimental devices which are being used by competent individuals and which therefore all liability is absorbed by the user. Check your EULA and GPL.
Overall this article is regrettably superficial and quite predictable given the history of the quotees, which in the case of Peter Neumann goes back at least 25 years. Not much has changed. Even the examples have the same kind of air about them.
Don't expect progress any time soon. Usually we need some kind of highly visible public disaster (e.g., like the recent nightclub fires) to motivate action.
You want verified design? Cool, you can get it. You can get a design that is gaurenteed to have no bugs and to never crash. This exists today, however you need to be prepared to PAY for it, in many ways.
First, say goodbye to the concept of being able to load your own apps or run it on your own hardware. If the company is going to certify that everything will be bug free, they need to know that a 3rd party isn't going to fuck that up. Your system will be verified to run on a certian hardware and using certian software. You will not change any of that without consulting the company first to do a verification of the proposed changes, or you'll invalidate the gaurentee and service contract. After all, you can have 100% stable code, but if a peice of hardware has a dodgy kernel mode driver it doesn't matter, that can being the system down.
Second, you will have the access restricted. You won't be able to just put this system on teh Internet to be accessed in any way you like, it will be accessed only through verified channels. You cannot potentially have the integrity compramised by clients sending unforseen data to it so all access must be controlled.
Finally, you will pay in terms of price. IF you want a system of this level you are not getting it for under a thousand dollars. Think 6 or 7 figures, plus a yearly matenence contract since you yourself aren't allowed to maintain it.
We have systems of this level in the real world. Like the AT&T/Lucent phone switches that run most of your phone network. We have one at the university and know what? IT never goes down, it didn't even go down when they upgraded it from a 5ESS to a 7R/E. It is 100% reliable. However, it is totally inflexable. We can't mess arnound with new technologies with it, it does phones and it does them only one way. We don't even work on it directly, it came with two technicians as part of the service contract. Oh, and it cost nearly 20 million dollars.
Look, if you want to have a computer market where anyone is free to build hardware and assemble it how they like, and you can freely use whatever software you want, you have to accept that there WILL be problems and you won't get verified design. The big part of a verified design is just that, verification. You check EVERY part of the design and make sure it works properly with the other parts and has no errors. Well the problem is that hardware, software, and user interaction are all a part of that and all have to be restricted. Once a design has been tested and verified, it can't be changed without reverfying.
So, if you really want 100% reliability, and can afford it in terms of monetary cost and teh sacrafices you have to make, then don't whine, go and get it. Talk to IBM, EMC, Dell or the like. They'll design you a system to do what you need that will never crash ever. However you'll need to decide what it needs to do and be happy with that, because you won't be able to change it, and you'll have to pay a real cash premium for it.
I disagree about the article's assertion that there is no liability for defects in software.
I deal with embeddeded controls in industrial control equipment all of the time. I just had to change my insurance company last year and my rates went up because companies are being held accountable and insurance companies are paying out when people screw up. Many companies don't want to insure programmers anymore. Sounds like the hammer is coming down to me.
You may not be able to sue MS the next time Excel craps out on you but I assure you that you could sue a programmer because the system that he programmed dumped 1000 gallons of a toxic substance into your containment area or because you just released a toxic cloud of ammonia from your plant.
When the stakes are high, programmers tend to have to test a lot more. You still have to remain economically viable though. Three lines of code a day may work for NASA but the rest of us can't afford to be that inefficient. Of course the stuff that I can blow up is at most worth 10's of millions of $, not billions.
When it comes to embedded control apps, I don't think that things are much worse than they are for our physical counterparts. Yeah a plane crashed because of a bug in an altitude control system but they also crash because of other design problems in the mechanical, electrical, and materials engineering areas. I don't think that programmers are any less aware that lives depend on their work than any other type of engineer.
If you are doing number crunching types of applications, you also tend to run the code through a battery of tests. You can definitely be sued for screwing that stuff up.
Now little controllers in your dishwasher and your run of the mill desktop apps are held to a lower standard, I agree. You are rewarded by the market for getting new stuff out the door cheaply and quickly. You can certainly argue that it shouldn't be that way but the masses have spoken. If your stuff gets too far out of hand then the market will let you know. MS is definitely feeling the pressure from OSS and rightly so. I can bet you that they are atleast trying to respond. I can definitely see a big improvement between the Windows XP that I run on my notebook and desktop and the NT 4 that I ran a few years ago. I can also see that Windows 2000 is much better than NT 4 was on the server, but it isn't good enough yet and that is why a lot of people are moving to Linux for things like web servers, DB machines, etc. The market is speaking.
I would say that programmers are ultimately held accountable. I would hate to see things swing too far out of hand as I do think that it would ultimate stiffle innovation.
Circular thinking. Find the golden tool required to reduce (dramatically) the time and expense to "debug it, redesign it, retest it, certify it, and release it". If you think it can be done, then you may not be the person to do it. I'm not either but problems should be seen as opportunities. How do I open all these cans quickly...
There is no golden tool, or to quote a more famous source (Frederick P Brooks, Jr) there's no silver bullet.
The article discusses the magic tool idea saying the Sustainable Computing Consortium "wants to create automated tools that analyze software and rate its reliability." But the problem with reliability is it's BIG. Not only must your program not crash, not leak resources, not have race conditions, and not degrade in performance over time, but it also needs to be doing the right thing during all of this (you know, what the software was written for in the first place). Finally the software has to be able to do all of this in the face of all the possible failures the system could throw at it. That's no small feat. Now what type of tool will work across the board? I won't stand in the way of someone trying to make one, but honestly I don't see it happening.
There are a lot of different testing techniques that solve different parts of these problems. And each application is going to need it's own unique testing methods in addition to tried and true techniques. But all of this testing is going to take time to develop and/or adapt to the product at hand and finally run. And as you discover reliability bugs you may be blocked before you can find (and fix) more. So it will take a long time to work through the issues.
But your original question is "Why can't there be cutting edge reliability?". And the answer is that there can be, but it has to be what the consumer demands. If the consumer will choose features over reliability that's what the market will deliver. This is simple - if you spend time doing all of this testing and improvement to your product someone else will ship the unreliable product first and everyone will use that. They may curse the developers name while they're using it, but they'll use it. Meanwhile they're improving their product AND getting revenues, and you're just improving your product. They end up having more money to improve their product, and they win.
In cases like NASA the customer demands it, and they get it. A magic tool is a long way off - our code needs a lot more metadata before a magic tool can even begin to tell what's going on.
Of course, EULAs make further restrictions intended to keep consumers uninformed -- barring benchmarking, sometimes barring other criticism (does Frontpage still have that clause?), not allowing security flaws to be published, etc.
Even with source, false advertising is quite possible, and should be punishable if we are to have a free market. It is now, but not done with great vigor.
Anyway, I guess my point is that this isn't a free market, and that the free market cannot be achieved with laissez faire policies.
Price, features, speed and reliability. Pick some but you can't have all.
To write almost bugfree software, like DoD / NASA (just be sure to check the specs for metric or not), the price is astronomical. Despite the obscene profit margin, Windows would be *much* more expensive if written by the same standards.
Also, adding features is another reason for instability. Not only commercial software, but also OSS software has been accused on focusing too much on adding features. In the commercial world because features sells, and OSS I think mainly because adding features is more fun than debugging an elusive bug that only happens on friday 13th under a full moon.
Another thing is speed. Particularly games are running the latest beta drivers on a tweaked and retweaked engine for speed. This is happening both in the high-end (pushing eyecandy) and in the low-end (pushing playability for low power machines). Don't expect perfect stability from that.
In short, I think the market would normally work this one out by itself. When delivering appliances I feel you should have the same liability as for the rest of the car. I mean whether the brakes fail because of a mechanical or electronic (software) design flaw, is not very relevant. However, for a typical software program that operates only on your computer processing information, I don't see this as very useful. Requiring some kind of standard would not change the basic trade-off, and it's not the producers' fault that the consumers aren't valuing reliability and security. They aren't willing to pay the price in form of money (How many complain about the price of Windows already), features (Go Linux. More stable, less features though) or speed (How many complain about the speed of Java that tries to abstract away from bugs related to not properly terminated strings, pointers arithmetic and array indexes out of bound?). So what did you expect?
Kjella
Live today, because you never know what tomorrow brings
Lots of people don't even WANT reliable sofware - at least, they don't want to pay for it. I'll happily accept my software crashing once a week if it saves me $300 on the cost of what would otherwise be $100 software. The last thing we need is to have the software industry start to look like the healthcare industry, where everyone pays 3x what they should to cover the insurance in case someone needs to sue someone else.
If you need absolutely, positively reliable software for some purpose, than contract with a company who is willing to provide it, and pay the price it takes to get it. But Joe Blo software user should have to foot the bill because someone ELSE wants to force ALL software to be reliable under penalty of multi-million dollar lawsuit. If I sell an operating system designed to let you play MP3s and video games and browse the internet for $99, and you use it you run your mission-critical application that causes you to lose $100 million when it crashes, why should I be liable because you used my (albeit buggy) tool for a $100 million mission critical ap? It's YOUR job to assure that you are using the correct tools for the job, NOT the guy who makes the tools!
It's like cars - just because your transmission goes out doesn't mean you get to sue the manufacturer. You get your transmission fixed if you've purchased a car with warranty terms that allow it to be fixed, and otherwise you pay for it yourself.
paintball
This isn't really a huge issue, it's just illustrating the need for another certification program. Look at the semiconductor market: There's semiconductors that you can use in everything, then there's semiconductors rated MILSPEC and Hospital grade, which have been tested and are approved in critical situations. Same damn semiconductor more or less, just has been exhaustively tested. They usually cost many times that of the other part, but you KNOW it will work, 'cause whoever made it is going to stand behind it.
We need the same thing for software. Someone to set up some guidelines, and provide certification to software that is going to be used in a critical application. Hell, maybe even the UL could open a division and do it. It is plain stupid to assume authors have liability over all software written, especially in the open source world. However, if I buy a product, and its software has been certified by a trustworthy organization, I'd feel better about myself.
Because software needs to be thoroughly tested before it can be called reliable.
/. contributors have consistently ignored the role played by trusted components such as VMs and safe compilers. Bottom line is that we all need to get away from the mindset engendered by years of Unix and C hacking and recognise that not all problems are going to be solved by employing programming whizzes or spending a fortune on testing.
This is not strictly true. I know that my Java program will never have a buffer overrun because it is impossible for me to produce JVM instructions that corrupt buffers or alter pointers. Therefore, I can download and run any Java program to my Java smartphone without invalidating the phone's network certification.
Throughout this discussion, I've noticed that
If something is inherently unreliable then you don't need to fix it: you find ways to live with it. A perfect example of this is the internet itself. TCP is a reliable transport provided over IP, an unreliable internetworking layer.
Make no mistake: IP is explicitly and deliberately unreliable. This keeps it simple, and allows upper layers to choose appropriate quality of service parameters for their application.
How this relates to the issue of unreliable application software is fuzzy: but its pretty obvious that humans have adapted to the reality of the situation: the power-cycling protocol is just one example of the ways in which we cope.
If a situation is life-critical, then I'd be happier knowing that the system is designed to cope with glitches then if the system assumes these glitches have been tested out of existance. Cosmic Rays really do exist, so some level of unreliability is guarenteed!
Opinions my own, statements of fact may contain errors
In most places, free-as-in-beer stuff is already fundamentally a special case, because unless something of value changes hands in both directions, you don't have a contract.
Of course, free-as-in-speech software neither deserves nor should get any special privileges. If you make money by selling me an OS that happens to be GPL'd, open source, or otherwise "free", that's still something you're selling me. "Oh, you should have looked at all the source code for Linux and spotted the critical bug for yourself" isn't much of an excuse at that point; I'm paying you to have done that for me.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
What they should do is remove any legal weight from clauses along the lines of "This software comes with no warranty of any kind, including fitness for any particular purpose..."
If you're taking my money for it, it should be fit for something, just the same as any other product, and just the same as any other sales pitch, I should be given a fair and accurate description of what the software I'm paying for is or isn't fit to do.
Part of the problem here is that most people on this thread seem to be thinking in absolutes: "if Word crashes, I can sue MS for [evil grin and pinkie finger to mouth] one million dollars!" It's not about 100% reliability, it's about reliable enough. A word processor doesn't need to be bug-free, it just needs to be reliable enough to write my documents under normal circumstances. MS might reasonably be expected to pay some compensation for excessive downtime due to their carelessness with the recent product activation issue, but not if Word crashes because of some incompatibility with other software on your machine about which they can do nothing.
Surely it should all come down to fair and reasonable marketing claims (don't say it's 100% reliable if it ain't) and fair and reasonable compensation when those claims are found to be erroneous (if you said it was in good faith, but it turned out not to be, you give me back some reasonable amount in compensation, depending on how effectively you addressed the problem once it was discovered).
If you want 99.99999% up-time for your server, you can buy from someone who claims to provide it, paying whatever the going rate is for it, and expect to get it (or compensation). However, you aren't entitled to assume that WinXP is suitable for running operating theatre laser surgery algorithms "just because" and then sue MS when it doesn't live up to the job you've foolishly given it.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
reliability. further, we expect more and more features and expect it at a low price. People who design software, do so on language that is backwards compatible with ones 20 years ago, namely C++, which carries some of the many failures on many levels into living applications. Now the language is not wrong, but how many people really considered writing their applications, say in Lisp, Scheme or Forth. Each language has its advantages, yet economics of software development demand that people should use most widespread language, so that it would not be as hard to hire decent software developers. What most managers do not realize is that by choosing a language they meddle in the affairs of those who know the field much better... The is whole stigma with using software tools, languages being the core. And often it is decided by managers who do not carry responsibility for development and manintenace of the software. And even if they do common fallacies used to justify imposition of specific tools onto software teams. ... except games! So what do you expect? Incomplete requirements, unfit tools ... list goes on and on. Very few people are able to cut through the bullshit, and crap in general to get a very good software package out. Nevermind treat their employees right. Bugs is corporate software are just some of the sysmptoms corporate world bearing off, core of the problem being, is sheer miscommunication in way public companies are handled - which is what most of software companies are.
However sometimes teams are fortunate enought to have choice in matter of tools, yet they never really have the way to verify that something they have created is exactly what a customer needs. Scrutiny by expert users is often absent from software development
In the end it is all about compromises and vision. Software bugs are just side effects, that will exaterbate any main problems a software company has. (that is bugs in tested and released software).
Plus something that was not tested for and does not have fatal outcome on the program is not a bug, i'd rather qualify it as a glitch...
my 2c.
Choosing high level languages does NOT remove potential faults. It simply delegates those faults elsewhere. In some cases thats a reasonable tradeoff for the performance hit of a VM, in some cases it isn't.
True-ish.
But what about the many bugs in most JVM's? Are you sure that your java code won't tickle these bugs and bring the whole system down? What about bugs that aren't just buffer overflows? What about it dropping a fork bomb on the system? What about memory leaks (harder with Java, but still very possible)? What about running out of memory?
As far as I can tell the only way to get code that doesn't flop over in these situations is by "employing programming whizzes or spending a fortune on testing".
Yes, Ada was designed from the ground up for reliability, and experience has shown that it substantially reduces bugs, particularly post-deployment bugs, the most expensive kind. I'm amazed that nobody else mentioned this. Oh well, nobody will read this comment anyway.
I watch Brit Hume on Fox News
However, it is still questionable whether closed source -- as it is typically sold -- really leads to informed consumers, even without restrictions Software is not particularly transparent, and its flaws may not be readily apparent. Buyer Beware is not the free market.
Actually, Microsoft software is quite reliable. Reliability does not, however, imply security or stability. My friends' MS software crashes quite reliably. ;)