re: type based aliasing again

["Michael J. Bedy" <mjbedy AT mtu.edu>]

*delurk*

  I am a grad student in computer science, who is doing thesis work in the
area of compilers. My main association with gcc (thus far), is however as
a user.

  I have been reading the archives of gcc (and egcs before that) for
probably over a year, and have seen this issue come up many times. As a
user, who also knows a bit about how this whole mess works (not in gcc
specifically, but in compilers in general), I would like to interject my
opinion.

  If it is feasable in gcc to implement warning that the code is invalid
according to ISO rules, and that at some point in the future the ability
of gcc to correctly compile it WILL go away, then I think this is the
correct path. Then the users really can't say that they wern't warned. It
also gives them time to fix the code. If they choose not to fix it, even
given the warnings, then it is indeed "their problem" when it no longer
becomes feasable to support this waring.

  I often find myself at odds with RMS, but in this I think he is right:
We need to be more concerned with what the users needs, especially as far
as something as crucial as gcc.

  One of the great advantages of the Open Source, or Free Software
(whichever you prefer) development model is the greatly reduced lack of
influence the pointy haired boss has on the project. Like anything else,
there is at least a bad side to this; comercial pressures to provide
backward compatability are not there. Unfortunatly, it seems that one of
the worst traits of the community is a rather cavilier attitude towards
backward compatability. 

  While I think the gcc community does a much better job then most at
preserving this backwards compatability, this particular issue seems to be
a hot spot for some reason. I can completely understand the feeling that
the users should just "fix their damn code," but it is not always feasable
to do so immediatly. 

  In addition, if I hadn't been reading this list for so long, I wouldn't
even know about this issue. Perhaps everybody working on gcc is to close
to the problem and doesn't realize that people outside the project don't
know/don't care about this, they just want their code to work. By issueing
a warning whenever possible, the user get real, immediate information that
something is wrong with his/her code.

  In short, and in general, I think it is good policy to, if possible,
include a warning whenever the behaviour of the compiler changes. I think
the worst solution possible is the current silent corruption that is
currently default in gcc.

  To conclude: I want to make sure I thank everybody on the gcc team for
their effort. As a compiler guy myself, I know how much work supporting a
compiler is. This message is not a flame, just an honest opinion from a
(fairly) long time user.

  Include my address in the cc: if you respond plese

   Thanks,
      - Mike
 
(p.s., sorry about the spelling....)