J
Jack
Jeffrey said:Making defect free software is *impossible*.
This is a silly thing to say, because [a] it's defeatist, and the
demonstration of a single defect-free software product will prove you wrong.
Even the simplest of shell scripts can break on another machine, or
in a different environment on the same machine.
Well, of course if you try to run Intel code on a Motorola processor, it
isn't going to work. That's not a defect.
Other software can muck it up, or the data the software works with
can throw a wrench in the works.
That *would be* a defect, and software that refuses to digest its own
data is b0rken.
And that doesn't even begin to address the fact that the machines
this alleged "perfect" software runs on are imperfect themselves, and
because of that, imperfect software *must* be written. Coders have no
choice.
Modern processors are esentially software abstractions anyway. So this
is begging the question.
<Beep> Repetition. Please make your argument; you are just baldlyThere's never be another piece of software released ever again. What
you're proposing is utterly impossible.
asserting that software has to have defects in it, because ... because
it has to. I don't agree.
Google me up. You aren't a very good guesser. You just couldn't be moreThe best coders in the world make mistakes, or aren't aware of all
the hardware quirks of every platform, or can't account for API
variations across different OS versions, or can't perfectly work
around the limitations of their tools, or can't guarantee that
another software won't step all over their own, or can't account for
every bit of possible data a software might encounter, or...... the
list goes on and on.
Lemme guess... you're not a coder, right?
wrong! In fact your wrongness is so completely wrong, that I'm in fits.
I've actually been coding since I was 13. I'm now 49. Yes, do the sums:
that means I was writing code in 1969, at school. That's more than
twelve years before the introduction of the IBM PC. The code was written
directly in machine-code (not assembly), for an IBM Schools Computer, a
machine based (I think) on the Intel 8008 microcontroller, basically a
4-bit processor. It had to be typed in as hexadecimal, because the
machine had no permanent storage, no operating system, and certainly no
kind of code translator. Floppy disks hadn't been invented. Phillips had
invented cassette-recorders only a couple of years previously, and
no-one at that time had had the notion of recording bits on cassette-tape.
The hex code was hand-translated from the binary in which it had to be
written. The program I wrote back then calculated tables of sidereal vs.
solar time (I was interested in astronomy as a kid). And it contained
mistakes.
I've been writing software on and off during most of the intervening 36
years, either for my own entertainment or as a trade. So you might want
to guess again? If you guess wrong the second time, you would have to be
incredibly stupid.
Yes, everyone makes misteaks. But there are quite simple ways of
protecting a software product against the mistakes the coders make.
Really good QA is just a backstop; working with a "buddy" coder, who
performs critical review *before* you write a routine, is one way of
avoiding silly mistakes. A lot of mistakes are perpetrated at the design
stage; assigning the right amount of effort to design (and design
review) can prevent a lot of mistakes. The coder should be testing his
own code units (subroutines or whatever) as he writes them, and he
should be testing them systematically - i.e. checking for boundary
cases, bad data, and exotic situations such as timing problems. The
original coder is in a position to devise tests that the QA dude
wouldn't have thought of.
Management has to be committed to software quality, and has to be
prepared to pay the salaries of really good people. And they have to be
prepared to keep paying, until the software is of merchantable quality.
Announcing the ship-date before the code has been written should cause a
software house's stock to crash through the floor (instead, it causes it
to rise - weird).
Yeah, "buddy programming" means that you have to pay two programmers,
when otherwise you might have got away with just paying one; but like I
said, making high-quality software products can't be done on the cheap.
Anyway, if the original code is of good quality, then the QA burden is
lower, and so is the support and maintenance burden.
The idea of "perfection" is perhaps a bit extreme; but I think it would
make a lot of difference if software manufacturers were simply expected
by their market to not ship products containing known defects (after
making best efforts to determine whether the planned shipment contained
any).
The widespread belief that making bug-free software is impossible is
responsible for an awful lot of misery. At the very least, a
professional programmer should aspire to making defect-free code. A
coder that thinks freedom from defects is impossible is a coder I
wouldn't hire.
Lemee guess... you're not a coder, right?