NetNews Usenet Archive 1992 #26/NN_1992_26.iso/spool/comp/lang/c/16313

Internet Message Format | 1992-11-10 | 3.4 KB

Xref: sparky comp.lang.c:16313 comp.software-eng:4226
Path: sparky!uunet!cis.ohio-state.edu!magnus.acs.ohio-state.edu!usenet.ins.cwru.edu!agate!spool.mu.edu!uwm.edu!linac!att!cbnewsc!cbfsb!att-out!rutgers!ub!csn!raven!rcd
From: [e-mail] (Dick Dunn)
Newsgroups: comp.lang.c,comp.software-eng
Subject: Will we keep ignoring this productivity issue?
Summary: CAN we afford to ignore it?
Message-ID: <[e-mail]>
Date: 11 Nov 92 05:51:30 GMT
References: <[e-mail]> <[e-mail]> <[e-mail]>
Followup-To: comp.software-eng
Organization: eklektix - Boulder, Colorado
Lines: 55

This was in the "productivity of a C programmer" thread, about a week ago.
I haven't seen anyone picking up on it--esp. in comp.software-eng, where it
damned well *should* generate discussion!  Bob Munck ([e-mail].
unisys.com) wrote:

>...However, it is a fairly-well-established rule of thumb that
>very good programmers can be an order of magnitude or more productive than
>the average and do a good job...

We toss this number around a lot.  A couple years ago I tossed it at a
friend who does a lot of real-time, control-system, etc. programming...just
to test his reaction, since he's generally good for a strong opinion.  But
his retort came from a direction I hadn't expected: he said "It's more like
*two* orders of magnitude!  You get the first order-of-magnitude difference
when the code is written.  The second comes during maintenance."  (Cf. also
Mark Terribile's comments about changes being made to the best code, because
it's the code people can figure out how to change.)

Well, maybe the difference is an order of magnitude, maybe two.  Be very
conservative, go below the geometric mean; assume it's only a factor of 20.

*ONLY*???

How *can* we afford to be off pondering complexity metrics, bantering about
25% changes, gaping in awe at the occasional arguably-possible factor of
2, when there's this sort of fundamental difference that's been staring us
in the faces for the past several decades?

How many software businesses can really afford to ignore such large factors
in development cost?  Can they really afford (say) the difference between
$150,000 and $3 million in development cost? and even if they can, can they
afford the extra time-to-market?

>...I've always felt that the path to **IMPROVING
>SOFTWARE PRODUCTIVITY** should start with an investigation of why that's so and
>how to take advantage of it.  Instead, we are spending $hundreds of million$ to
>lower the skill level needed for programming.

Or, if I may reword what Bob said rather less kindly, we are spending vast
sums to get code out of the people who can't program, instead of finding
out how the folks who can program do it.

In fact, I suspect we'd even be better off just letting those who can, do,
and not pretending that those who can't, can.  "Negative productivity" is
too well known; if we weren't sending some fair fraction of our best pro-
grammers off to clean up the disasters created by some of our worst pro-
grammers, we'd have enough real skill to go around.

[To forestall some of the obvious criticism: I refer to a "programmer" as a
person who constructs programs--the whole things, doing what they're
supposed to do, with all the associated documentation.  I don't mean a
"coder" or a hacker of binary arcana.]
--
Dick Dunn    [e-mail]   -or-   raven!rcd    Boulder, Colorado
    ...Simpler is better.