Re: C bug of the day

[kanze@gabi-soft.fr]

James Rogers <jimmaureenrogers@att.net> wrote in message
news:<Xns9398C9067948jimmaureenrogers@204.127.36.1>...
 > kanze@gabi-soft.fr wrote in
 > news:d6652001.0306120418.37a97d1c@posting.google.com:

 >  > James Rogers <jimmaureenrogers@att.net> wrote in message
 >  > news:<Xns9396BDBB14558jimmaureenrogers@204.127.36.1>...
 >  >> kanze@gabi-soft.fr wrote in
 >  >> news:d6652001.0306100323.338a2a1c@posting.google.com:

 >  >>  > That doesn't mean C++ is perfect, of course.  I'd rather have a
 >  >>  > language in which all of the defaults were fundamentally safe,
 >  >>  > but with the freedom to override them if you had special
 >  >>  > constraints, or even in cases where you came across a case
 >  >>  > which the language authors hadn't considered.  I don't know
 >  >>  > such a language, however; it may exist somewhere, but if it
 >  >>  > does, it certainly isn't very popular or wide spread.

 >  >> Since this was cross-posted to comp.lang.ada I think it is fair to
 >  >> mention that there is a language that meets your description
 >  >> above.  That language is Ada.

 >  > Permit me to be sceptical.  If your claim is that Ada has more of
 >  > the safe defaults than C++, I doubt anyone would dare argue it.  If
 >  > your claim is even that most of the defaults are the safe version,
 >  > from what little I know of the language, it would seem true.  But
 >  > to say that in 1983, they got everything right, including problems
 >  > that weren't even understood until significantly later.  Well, I'm
 >  > sceptical.  Perfection just isn't of this world.

 > I am sorry. I did not mean that Ada is perfect. I meant that Ada is a
 > fundamentally safe language with the ability to turn off checking if
 > you encounter a situation where checking presents a problem for you.

 >  > One point where I'm pretty sure Ada 83 didn't have the right
 >  > default (although they may have fixed it in Ada 95): garbage
 >  > collection.  While there are places where it is necessary to turn
 >  > garbage collection off (which seriously limits the use of a
 >  > language in which you cannot have untraced pointers, which the
 >  > garbage collector cannot see), the safe option is obviously to have
 >  > it on by default, no?

 > Is garbage collection always the right default? For web applications
 > this may be true. Ada was originally designed for hard real time
 > embedded systems. In 1983 and 1995 there was no way to implement
 > deterministic garbage collection for hard real time systems with
 > nanosecond timing requirements.

There still isn't, if you are talking about nanosecond timing
requirements.  In fact, at that level, there is no way to implement
dynamic memory at all.

 > That said, like C++, Ada does not prohibit garbage collection.

Perhaps a more relevant question would be: do comment implementations
have it?  Or is it used?  (But as others have mentionned, it may not be
used because typical Ada applications are in domains where it is NOT
appropriate.)

 >  >> Its defaults are fundamentally safe. It provides the ability to
 >  >> override the safety constraints whenever you choose to. Note how
 >  >> Ada differs from Java. You cannot turn off array bounds checking
 >  >> for Java. In Ada you can. In fact, many Ada compilers will
 >  >> optimize out bounds checking when they can determine the checks
 >  >> are unnecessary.

 >  > I believe that this is standard practice in all languages which
 >  > support array bounds checking.

 > This is standard practice in theory. For many languages the reality is
 > that such optimizations are rare because the compiler lacks the
 > information needed to prove the safety of removing the bounds checks.

The information isn't difficult to synthesize.  But generally speaking,
if the array bounds checking is part of the language, the compiler knows
it.  If your code is full of goto's, it is difficult for the compiler to
figure out when it can suppress the checking, but it isn't difficult to
realise that in a classical for loop, it doesn't have to check the
bounds each time through.

 >  >> In other words, you can arrive at the same level of safety which
 >  >> is the default for C++.

 > > And you're bragging about it:-) ?

 > No, I am being practical. You can remove all safety checks in Ada and
 > produce a program as unsafe as anything you might write in C. On the
 > other hand, you can write a C++ program carefully and produce a very
 > safe result. Note that there is a lot of crossover in safety here.

This sounds more like what I thought.  You can write junk in either
language, and you can write robust code in either.  It's just that one
language makes writing junk particularly easy, and the other makes
robust code easier.

--
James Kanze             GABI Software             mailto:kanze@gabi-soft.fr
Conseils en informatique oriente objet/
                            Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, Tl. : +33 (0)1 30 23 45 16

      [ Send an empty e-mail to c++-help@netlab.cs.rpi.edu for info ]
      [ about comp.lang.c++.moderated. First time posters: do this! ]