[LINK] What's a reasonable level of code-checking?

[Craig Sanders]

On Thu, Aug 17, 2006 at 10:22:17AM +1000, Richard Chirgwin wrote:
> There is an important point, however, given that there is a
> significant group of advocates who evangelise the adoption of free
> software among non-expert users.
>
> The reason it is so hard to establish a reasonable level of
> "product trust" between end user and any software author is that
> software writing all-to-frequently refuses to assume the burdens of
> engineering.
>
> For example: "I was too busy to check the speedometer" is, as you say,
> a stupid excuse. However, "I did not check the elevator motor bolts
> before riding to the 14th floor" is reasonable for everybody. Where
> is the line between what I should check (the speedometer) and what I
> should reasonably expect someone else to check (the elevator motor
> bolts)? - The line is drawn by expertise and responsibility. I cannot
> be asked to take responsibility for the elevator because I don't have
> the expertise; I expect that the relevant building authorities will
> set standards, and that engineers will keep to those standards.

yes, in this case, whoever installed the elevator would have the
responsibility to verify that it was safe.

OTOH, if you purchased an elevator kit and installed it yourself then
you would have a responsibility to read and follow the instructions -
and also to actually have, or acquire, a clue about what you are doing.

free software is more like a kit than like a packaged product. and
frankly, if you couldn't be bothered acquiring even minimal skills and
clue, then DON'T USE IT.

> Software needs to adopt the disciplines of engineering, and frankly
> the exclusionist expert mentality could just as well be dropped down
> an abandoned mineshaft and nobody would notice...

i really don't care what the mainstream public uses - i do, however,
care if the software that *I* like to use is no longer available because
the whining clueless public (or, more likely, politicians grandstanding
and claiming to do it on behalf on an utterly indifferent public)
demand that software developers take responsibility for the users' own
negligence and ignorance.

computers and software are and always will be inherently complex
devices. with complexity comes bugs as well as difficulty and confusion,
especially for those who are unwilling to make an effort to understand.
expecting that complexity to simplified to the point of a toaster (or
even a VCR - which is still beyond most people to operate correctly) is
just absurd fantasy and marketing drivel.

some kinds of software can not be made into a completely polished
product that can be used by novice end-users WITHOUT completely
destroying or at least severely crippling the utility value of that
software. web servers, for instance, are reasonably complicated pieces
of software that can't be simplified for people who don't know what they
are doing without eliminating most of the features that make it valuable
to people who DO know what they are doing.

what i'm saying here is that while the novice end-user market is by far
the largest market for software, that does not mean that there is no
market for other kinds of software - particularly software for experts
or for people who are willing to put in the time and effort to become
expert.

FOSS tends to cater for that smaller market. if novices can make use
of it too, that's fine, but it would be a serious mistake to expect
software that primarily caters to experts to drop that focus and instead
cater exclusively to novices.

in short, some software is for consumers who want to do nothing more
than consume a product. and some software is for participants who
want to be actively involved (to a greater or lesser degree) in the
development, debugging, and refining process.

eliminating the latter by legislating for onerous legal liabilities will
not actually make the former any better or safer, it will just remove a
choice for those who don't need or want to be spoonfed.

craig

-- 
craig sanders <cas at taz.net.au>           (part time cyborg)