An admittedly biased Ada/C++ comparison, by Ed Schonberg

[pa.dec.com!nntpd2.cxo.dec.com!bonmot!wallace@decuac.dec.com (Richard Wal]

Gregory Aharonian (srctran@world.std.com) has put his finger on the real
issue behind the C++/Ada religious wars -- economics.

I can not agree with the slams that are put forward by Gregory.  The issue
behind the economic arguement is one that can be brought down to
implementation and education issues.  I list them here:

1) The "Law of first exposure" is the first criteria that sets an end user's
expectation of what to use as an implementation language.  The first exposure
that a potential programmer has is an inexpensive system (IBM/PC, Mac) in
high school (or at home) where the decision by the educational institution
(individual) is to maximize silicon over software.  So what is the cheapest
"real" language to use?  C of course (it used to be BASIC, remember?) because
a compiler is $100's per site or free (remember Apple's give-away?)  versus
$10,000's per site.  Next, if the student decides to attend university, the
next system seen is the Unix or Unix-style O/S with the "de facto" C
compiler, and if the University has sprung for a C++ compiler, that is
available too (don't forget the Gnu project G++...).

2) Now take that person to the job site and the "big machines" are the same
PC's and Mac's that were seen at high school and Sun/HP/Digital systems that
were seen at university; And of course, what language?  C/C++ of course.
Remember the silicon versus software cost issue?  It comes back in buckets
here because the software house is a)a VERY cost conscious operation, and
wants people in front of machines, and b) concerned with porting, so it will
choose a simple language that has alot of ports; and since C/C++ compilers are
dirt-simple to implement (not to mention de facto on Unix systems...) it is a
good business choice.

3) Gregory misses an important economic issue and that is the reliability of
the code that is produced under the C/C++ development paradigm.  I've seen
lots and lots of C code and now I'm seeing C++ code that has the same
trashed-out coding style I've seen from C "hot-shots."  I say to myself
"surely the compiler would have complained about that, if not then why not
the linter (we use several)?"  and the answer is that a) no the compiler
didn't, and won't, catch it, and b) the linter switches were turned off
because the programmer "didn't want to see that useless noise" that was
output.  These would have been fatal compilation errors out of *** ANY ***
Ada compiler I've used.  This is the issue that the U.S. Government wants.
Not to grow the individual (who is around for 20 years on a single program?)
but to grow the technology so that second-sourcing -- not a well understood
concept in the software industry -- can be done on the software of the
Government computer software.

Now if I could get an Ada given away to high schools and bundled with an O/S
then I don't think there would even be a C++...  but that is a topic for
another discussion.

Richard Wallace
Digital Equipment Corporation
301 Rockrimmon Blvd. South
CXO2-1/7A
Colorado Springs, CO 80919-2398
(719)548-2792
<wallace@cookie.enet.dec.com>

	"The opinions expressed are my own, Uncle Ken or Uncle Bob
	 may, or may not, agree with me."