Implicit instantiation (was Re: was Re: Ada / C++ comparison paper anymore)

["Mark Lundquist" <no.spam@getalife.com>]

"Patrick Hohmeyer" <pi3_1415926536@yahoo.ca> wrote in message
news:o0qU7.21560$J%2.3180364@news20.bellglobal.com...
>
> But this is the C way of doing things :
> Let's give the programmer all the possibilities
> and it's up to him to use them wisely.
>

Well, let's look at that statement:

    "Let's give the programmer all the possibilities, and it's up to him to
use them wisely."

What is wrong with that?  On the face of it, that actually looks pretty
good.  It seems like the appropriate thing to say to grownups.

So how is that "the C way of doing things"?  What do you really mean?

The problem with C (and C++)  is that to use the language safely, you must:

1) Have command of a large knowledge base of "pitfalls" and "gotchas".  For
C++ this is a special trouble because so many of the pitfalls seem to
involve rather advanced concepts in the language that nonetheless come into
play in rather simple code.

2) Be extra-careful, and

3) Adopt various "defensive programming" practices to protect your code
against others (and yourself, in case (2) fails).


It's that kind of situation that Ada was engineered to avoid.  Not
protecting people from themselves who insist on criminally negligent
programming.  What you want is not "safety scissors", but a powerful tool
with a sharp cutting edge, that is safe when used responsibly.

My suggestion is not "the C way of doing things".

Some language features cause problems in other languages, but the problems
aren't due to the general concept itself (e.g. implicit instantiation), but
to the form it takes in the language and especially in the context of the
general foundation provided by the rest of the language.  So if you start
with a language that has a weak type system and a weak module system, it
makes a minefield of the language and of course the specific features (e.g.
genericity) are going to manifest the problems caused by the underlying
weakness.  Not recognizing this leads to prejudice and FUD about language
features.

By the way, there is no "slippery slope" here.  It's not a case of "oh sure,
today implicit instantiation, tomorrow who-knows-what".  That would be a
very bogus, straw-man argument.

Implicit instantiation would not make Ada into "C without brackets".  That
is just plain silly.

-- mark