Re: The great Java showcase (re: 2nd historic mistake)

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Patrick said

<<  That's a pretty cheap shot, Robert.  Plus, it's not necessarily
true.  There are applications that just beg for automatic memory
management, and if they happend upon one of these, they certainly
could have seen such an improvement.

  For my part, I'd guess that at least 40 to 50% of my time is
spent looking for memory allocation bugs in C++.

  If this isn't the case with you then, well, I suppose you're
just the greatest darn programmer in the whole world.>>


Well different people have different styles in programming. I personally
like programming, but hate debugging, so I perfer to spend my effort
getting this right to start with. But I realize others prefer to spend
their time debugging -- it's a matter of taste partly -- although I
suspect that a lot of people do spend far too much time with a debugger.

It's interesting to ask a roomful of C and C++ programmers how mnay of
them routinely use a dynamic debugger. You will get pretty much a 100%
response, plus a reaction that the question is curious.

If you ask the same question in a roomful of Ada programmers, you will
find a split, somewhere close to 50/50. 

That's partly a language difference, but also partly a style difference.

Particularly in C++, proper abstraction and encapsulation should make
it possible to minimize problems with dynamic allocation. Now I must
admit that most C and to somewhat lesser an extent C++ programmers
seem blissfully unaware of what abstraction is all about.

As for applications where you can get a factor of several productivtiy
improvement by using garbage collection, I think that is rubbish. Remember
I speak here as someone who fully knows the vale of garbage collection.
I wrote the SPITBOL systems (see the paper in SP&E, 1977, which describes
the interesting approach SPITBOL uses to GC), and was deeply involved in
the Algol-68 design.

So I know the advantage, and it is consderable, but the idea that GC alone
could cut down the time to design/document/code/test/integrate/productize
a product by a factor of several seems ludicrous to me.

Perhaps you are just talking about coding time -- even there the estimate
is way high.

You do NOT have to be the "greatest darn programmer in the whole world" to
avoid wasting 40-50% of your time looking for memory allocation bugs in
C++, you just need to create the proper abstractoins in the first place.

Now to be fair, you may well be spending this time on other people's
poorly written code, in which case the blame lies elsewhere.

But if you think my comment is a cheap shot, then you are far from being
sufficiently aware of what can be achieved by proper software process,
and this does NOT require super duper clever programmers, it is something
that can be achieved by good management, and good choice of techniques,
languages, and tools, with typical competent programmers, not super stars.