In article <MPG.11d9519b6eea605a989c02@news.mindspring.com>,
Stan Brown <brahms@mindspring.com> wrote:
>Something I've been wondering about is why footnotes and examples in the
>Standard are non-normative.

What would it mean if examples were normative? That implementations
must include them in their documentation? That implementations must
accept them ?(what about incorrect examples?)

If the example and the main text differ, which one takes precedence?

In short, I think that no value would be added if examples were
normative?

Regards,
Martin



[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <7l0s6a$r68$1@hahn.informatik.hu-berlin.de>,
Martin von Loewis <loewis@informatik.hu-berlin.de> wrote:
>What would it mean if examples were normative? That implementations
>must include them in their documentation? That implementations must
>accept them ?(what about incorrect examples?)

Incorrect examples would be a defect that should be fixed, just like any
other inconsistency in the document.

>If the example and the main text differ, which one takes precedence?

If two different sentences in the main text differ, which one takes
precedence?

>In short, I think that no value would be added if examples were
>normative?

If the text were ambiguous, and an example resolved the ambiguity,
implementors would be required to implement the language as indicated by
the example.  Since examples are non-normative, implementors are permitted
to ignore them completely and just do what the text says; if it's
ambiguous, they can presumably choose any of the possibilities, even though
it contradicts an example.

I'm not saying that examples should be normative, I'm just pointing out
that there could be value in doing so.  I think one of the reasons they
aren't is to force the authors of the text to be clear, rather than relying
too much on examples.  It's like requiring software engineers to write
detailed design documents rather than just relying on the source code.

--
Barry Margolin, barmar@bbnplanet.com
GTE Internetworking, Powered by BBN, Burlington, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Barry Margolin wrote:
>
> In article <7l0s6a$r68$1@hahn.informatik.hu-berlin.de>,
> Martin von Loewis <loewis@informatik.hu-berlin.de> wrote:
> >What would it mean if examples were normative? That implementations
> >must include them in their documentation? That implementations must
> >accept them ?(what about incorrect examples?)
>
> Incorrect examples would be a defect that should be fixed, just like any
> other inconsistency in the document.

I believe that the basic idea is that ideally every key statement in the
standard is made in one and only one place in normative text. That
avoids the danger of having something changed inconsistently in the
multiple places it is said. However, non-normative text can freely
duplicate normative text, because if it's updated inconsistently, it
remains clear which one applies.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Something I've been wondering about is why footnotes and examples in the
Standard are non-normative. Sometimes I find that the footnotes add
information that is not in the main text, or at least not explicit. And
the examples can be critical in understanding the normative statements of
the Standard.

Is this merely a historical and required practice for ISO standards(*),
or is there some reason why the C++ committee made this decision on its
own merits?

(*) And if so, does anyone know how and why it arose?

--
Stan Brown, Oak Road Systems, Cleveland, Ohio, USA
                                    http://www.mindspring.com/~brahms/
My reply address is correct as is. The courtesy of providing a correct
reply address is more important to me than time spent deleting spam.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <MPG.11d9519b6eea605a989c02@news.mindspring.com>,
brahms@mindspring.com (Stan Brown) wrote:

> Something I've been wondering about is why footnotes and examples in the
> Standard are non-normative. Sometimes I find that the footnotes add
> information that is not in the main text, or at least not explicit. And
> the examples can be critical in understanding the normative statements of
> the Standard.

I was thinking about this, and I came to the conclusion that it's a
psychological thing - you have a certain understanding by reading the main
text, and then the note either agrees with this, giving you the feeling
that you understand it well, or disagrees, in which you go back and try to
understand the main text better.

They are in the standard, after all, so I'm not sure what you'd like
changed. Are you gaining some understanding from the notes alone, without
any agreement from the main text? Maybe your understanding isn't correct,
then.

> Is this merely a historical and required practice for ISO standards(*),
> or is there some reason why the C++ committee made this decision on its
> own merits?
>
> (*) And if so, does anyone know how and why it arose?

I think that either way, the decision was made for a reason.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Stan Brown wrote:
>
> Something I've been wondering about is why
> footnotes and examples in the
> Standard are non-normative. Sometimes I find
> that the footnotes add
> information that is not in the main text, or
> at least not explicit. And
> the examples can be critical in understanding
> the normative statements of the Standard.

The intent is that normative text should be
necessary and sufficient to define the language.

The rest (non normative text) is usefull additionnal
information; the committe cares about the correctness
of such information (and will correct any incorrect
code example, note or footnote), but it shouldn't be
necessary to fully define the abstract semantic of the
C++ language.

In practice some notes give important informations
available nowhere else and they should be taken
seriously. Sometimes notes are moved to normative
text when the committee realises that no other
normative text covers it.

> Is this merely a historical and required practice
> for ISO standards(*),

I think it's an ISO standard.

--

Valentin Bonnard
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]