Re: Is Ada the future? [was: Is C++ the future?]

[milod@netcom.com (John DiCamillo)]

Let me start by thanking you all for taking the time
to think before you respond to this thread.  I'm
really enjoying it and I'm learning a lot.

My point in carrying this on in public is to help
you (the Ada community) hone your arguments on some-
one in the commercial/C++ community.  'Cause if you
can't come up with some good ones, dual-use is doomed.

dweller@Starbase.NeoSoft.COM (David Weller) writes:
>John DiCamillo <milod@netcom.com> wrote:
>>dweller@Starbase.NeoSoft.COM (David Weller) writes:
>>
>>>	Range checking,
>>Trivially provided in C++ classes that need it.
>>
>We must have wildly different opinions of "trivial" then.

I'm sure we do: you are writing an array
class, and I am using one.

>problem with C++ is that it requires the programmer to write
>defensively.  "Caveat hackus", if you will.  Type checking, for
>instance, is provided only at the class level.  It's not possible to
>create an integer of type Oranges and one of Apples without artificially
>mashing them into classes and then going through an array of gyrations 
>to overload all operations.  The typedef is merely a synonym, 
>not a new type.

I agree with all this, but so what?  That's
what commercial class libraries are for.
Admittedly, the market isn't quite there yet
because of standardization and support issues,
but in general, I can choose to buy one of
several different libraries that will provide
the support I need.

>This is so fundamental to the difference 
>between Ada and C++ that I dare say it's the root
>of misunderstanding between the two "camps" (if one feels compelled
>to segregate the two -- I write in both languages, so I guess I'm a
>pariah :-).  The fundamental issue is this: Ada starts from the side
>of reliability and requires the programmer to unravel the safety
>where needed.  C++ starts from the side of "flexibility" (lack of
>safety, depending on your perspective :-) and forces the programmer
>to wrap up their nugget of data (members) with a layer of protection
>(classes). 

I agree with all this too, except that it's
not a source of misunderstanding.  Most of
the C++ programmers I know simply could not
care less about whether Ada9x is an OOPL or
not.  And this includes a guy whose first
language (in college) was Ada83.

>>>	Type checking within generics,
>>C++ provides this for every definition of that
>>phrase that I can think of.  I can only assume
>>that you mean something else.  Please elaborate.
>>
>Templates:   Grrrrr.   Write a class template.  Then repeat the
>template parameters _everywhere_.  Repeat them in your parameter
>lists, repeat them in your member functions, repeat them in your
>declarations.  "Ad naseum" is an understatement.  What's that got to
>do with reliability?  Not a damn thing, but it makes a BIG difference
>in readability.

Perhaps.  Although readability in C++ can
be helped by a thoughtful selection of
template parameter names.

>Again, type checking is loose, both in creation and elaboration of
>templates.  I owe you a better explanation on this one, but I'm short
>on time right now (should be doing my work on the Booch Component
>translation).

Yeah, slacker! ;-)

>>>	safe pointers
>>Can be provided, but not legislated.  In any
>>case, for programs of more than trivial com-
>>plexity, raw pointers are generally wrapped
>>in safe classes.
>>
>Wrap a pointer in a class and protect it?  Well, so
>much for simplicity....

But we really do this, and its just not that
big a deal.  We use handle/body classes to
get pass-by-value semantics and polymorphism
at the same time.  Instance management is
handled in a base class, and I don't have to
think about it.  We don't use built in arrays
at the application level, and in general
don't use pointers in unsafe ways.

>>More seriously, have ya got anything else?
>Yes, but out of time (as mentioned before).  I _do_ owe you a better
>explanation (I sure wouldn't be convinced by my reply here alone).
>Maybe others can chime in without letting this turn into a language
>flamewar (I know, I'm probably asking too much :-)

Yes, I would appreciate that too!

Oh, and thank you for the references yesterday.
I'm preparing a rebuttal to the 9x-cplus paper,
but I need some clarification on Ada 9x first:

How does polymorphism (dynamic dispatch) work
in Ada 9x?

Is Ada Covariant, Contravariant, or Invariant?

Could someone please explain "generic derived
types and generic formal packages" and how
they are different than C++ templates?

-- 
    c'iao,
    milo
================================================================
    John DiCamillo                        Pinin' for the fjords?
    milod@netcom.com                  What kind of talk is that?