Re: Printing Enum Variable Re: Linux World

[dewar@gnat.com]

In article <36DE53BC.1AE0@ddre.dk>,
  hm@ddre.dk_nospam wrote:
> robert_dewar@my-dejanews.com wrote:
> What really amazes me is that even though good people has
> spent good time designing a validation procedure where
> specific compilers are validated for specific operating
> systems, then one of these good people claims that
>
> 1. this procedure may validate combinations that in his
> own words behave annoying and silly and undoubtedly would
> be rejected by the marketplace.
>
> 2. the validation process would seriously broken, if it
> were to consider these problems.

If this amazes you, it is simply because you have
fundamental misunderstandings of what validation is
all about.

From one point of view it is amazing to *me* that people
still have these kinds of misconceptions, but on the other
hand we always have new people who have not been around,
and for whom we rerun old discussions :-) :-)

Validation has NOTHING to say about whether implementations
are usable. Remember that the first validation was of
Ada/Ed which was obviously unusable for anything even
vaguely serious (David, this was probably before your time,
but Ada/Ed was an executable specification that ran perhaps
6-7 decimal orders of magnitude slower than a production
compiler).

Validation merely measures one thing, whether your
implementation understands the semantic and syntactic
issues in the language definition, as tested reasonably
thoroughly, but of course not fully (no test is complete)
by the validation suite.

If you use a validated compiler, then you know the
implementors understand the language well, which is a good
thing, and you are perhaps less likely to find the kind
of bugs that involve two different compilers making subtly
different interpretations (e.g. a program that is legal
on one compiler and illegal on another). Note I say less
likely, not impossible!

Lots of people have lots of different ideas about what
make an Ada 95 compiler usable, here are some examples,
some from our customers, some from CLA:

  1) performance must be same as compiler xxx
  2) COM files must be buildable on NT :-)
  3) rep clauses recognized by compiler xxx must work
  4) garbage collection is required
  5) UTF-8 encoding for wide character is required
  6) 256 priority levels are required
  7) floating-point overflow checking is required
  8) full IEEE semantics for floating-point are required
  9) Latin-1 characters must come out "right" on my screen
 10) C++ interfacing must work
 11) -n32 mode must be supported on SGI
 12) loop unrolling must be controllable by a pragma
 13) tight packing is required for component size of 42
 14) clearer error msg is required for xxx
 15) every error msg should have an RM reference
 16) 64-bit integer support is required on all machines
 17) 64-bit integer support required with no run-time

OK, that's enough typing, I have to get back to work, I
could easily add another several hundred entries to the
list.

The point is that NONE of the above issues are even vaguely
validation issues.

Over time, people have kept making the mistake of assuming
that validation ensures usability. In real life it does not
even ensure 100% conformance, let alone usability. It is
generally the only objective test we have for conformance,
so it is common to at least consider it to be a test for
conformance, but to get confused with a test for usability
or marketability is a definite error!

Robert Dewar
Ada Core Technologies

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own