Newsgroups: comp.lang.c++
From: kanze@lts.sel.alcatel.de (James Kanze US/ESC 60/3/141 #40763)
Subject: Re: comments on "A critique of C++"
Date: 11 May 1995 17:13:41 GMT

In article <D88qKv.ALM@research.att.com> ark@research.att.com (Andrew
Koenig) writes:

|> In article <D8572L.J7D@syacus.acus.oz.au> ian@syacus.acus.oz.au (Ian Joyner) writes:
|> > t.lbl.gov>

|> > Absolutely. What I am arguing against is those who argue that C/C++
|> > is superior because of case sensitivity. The advantages are non
|> > existant, and there are subtle, but nothing to get too worried
|> > about disadvantages, but they are real.

|> >>YAWN<<

|> I have used languages that are case-sensitive, case-insensitive,
|> and monocase.  In practice I find little to recommend one over
|> another.

|> However, for C and C++ to have different rules about case sensitivity
|> would be really confusing.  Nothing more to say.

I've got an idea.  Since people feel so strongly about this, some for
and some against, let's satify both sides.

I propose we make the even letters case sensitive, and the odd ones
case insensitive:-).
-- 
James Kanze         Tel.: (+33) 88 14 49 00        email: kanze@gabi-soft.fr
GABI Software, Sarl., 8 rue des Francs-Bourgeois, F-67000 Strasbourg, France
Conseils en informatique industrielle --
                              -- Beratung in industrieller Datenverarbeitung



Newsgroups: comp.lang.c++
From: rmartin@rcmcon.com (Robert Martin)
Subject: Re: comments on "A critique of C++"
Organization: R. C. M. Consulting Inc. 708-918-1004
Date: Wed, 10 May 1995 07:43:20 GMT

mikem@yosemite.eai.com (Mike McCarty) writes:

>rmartin@rcmcon.com (Robert Martin) wrote:
>|> This thread has gone on and on and on.  I take this as a demonstration
>|> of the inverse proportional relationship between the time invested in
>|> an argument, and its significance.
>|> 

>I find this an interesting comment coming from a man who has followed-up only
>God knows how many posts about the use of the word 'pure' in relation to
>the C++ language.

>He who has never sinned may now cast the first stone... Thank you.

Toche'.  Although you will note that I am also usually *not* the one
who insists on getting the last word in those arguments.


-- 
Robert Martin       | Design Consulting   | Training courses offered:
Object Mentor Assoc.| rmartin@rcmcon.com  |   Object Oriented Analysis
2080 Cranbrook Rd.  | Tel: (708) 918-1004 |   Object Oriented Design
Green Oaks IL 60048 | Fax: (708) 918-1023 |   C++

From: JSULLIVA@fhcrc.org (John Sullivan)
Newsgroups: comp.lang.c++,comp.std.c++.comp.std.c
Subject: Re: comments on "A critique of C++"
Date: Thu, 11 May 1995 09:09:10
Organization: Fred Hutchinson Cancer Research Center

>>>>YAWN<<
>>I have used languages that are case-sensitive, case-insensitive,
>>and monocase.  In practice I find little to recommend one over
>>another.
>>However, for C and C++ to have different rules about case sensitivity
>>would be really confusing.  Nothing more to say.
>>                                --Andrew Koenig

>I thought C and C++ are "different" languages and need different ISO/ANSI
>standards...why do C and C++ have to align so closely...???
>I bet next you will be saying that the C++ standard can just "replace"
>the C standard...:)
 >Jim Fleming            /|\      Unir Corporation       Unir Technology, Inc.

Just a little history, C++ was designed so that C code would compile under a 
C++ compiler.  They're different languages, but C++ is backwards-compatible 
with C.  Mr. Koenig found pretty much the only interesting thing about this 
interminable case-sensitivity debate. 

John S


From: blume@dynamic.cs.princeton.edu (Matthias Blume)
Newsgroups: comp.lang.c++
Subject: Re: comments on "A critique of C++"
Date: 08 May 1995 15:19:38 GMT
Organization: Princeton University


Ok, Ian, after our little private e-mail dispute you seem to be
determined to take it to the public...  I'm getting more and more
disappointed.

In article <D854Bs.Ixs@syacus.acus.oz.au> ian@syacus.acus.oz.au (Ian Joyner) writes:

   blume@dynamic.cs.princeton.edu (Matthias Blume) writes:

   >In article <D7xIqC.Hvu@syacus.acus.oz.au> ian@syacus.acus.oz.au (Ian Joyner) writes:

   >   But case sensitivity introduces potential for errors that won't be
   >   picked up syntactically. For example:

   >   int i, I;

   >   Further down you might mistype or assign to the wrong i, and the
   >   compiler will trust you because you 'know what you are doing', in
   >   the usual C style.

   >By the same line of argument we should consider all letters the same
   >if they appear close together on the keyboard.

   How do you figure that? Please don't misrepresent my arguments.
   Indeed if I type a k instead of an i in an identifier, the compiler
   will reject it. Your attempted reductio ad absurdum is absurd.

In a case-sensitive language, indeed, if you type `I' instead of `i',
the compiler will reject it...  Your attempt to reduce my reductio ad
absurdum ad absurdum is absurd.  (Sorry for the latin-english mixup. :)

   >   No. As above, case sensitivity can lead to semantic problems

   >What?!  That's interesting news to me.  The choice of alphabet creates
   >semantic problems... go figure!

   And also don't argue in such a way that you are so surprised because you
   think what I am saying is stupid.  I am putting the case.  Hopefully,
   some people will see the sense in it.

Unfortunately, this is impossible.  Nobody can see something which
does not exist... (except for hallucinations) :)

   Because you don't want to does
   not entitle you to argue in absurdities.  If you can point out any flaws
   and misconceptions in my arguments, then I and everyone else will learn
   from that.  I don't want to be caught up in one of these internet flak
   wars. 

In this case -- why don't you simply stop pushing this
case-(in)sensitivity issue?!

   OK, now to your point.  The semantic problem is that you have used the
   same letter to denote two different entities in the same scope.

No, since `I' and `i' are clearly different I'm using two different
letters to denote different things in the same scope.

   Granted that errors that arise out of
   that will be extremely rare.

Not more or less frequently than any other typo.

   Even more rare will they get out to
   production systems, and even more rarely, will that end up in a life
   threatening situation, and more rarely in death.  However, tell that to
   the astronauts of Challenger who died because the probably failure of o
   rings was so low, that no one considered what the combination of factors
   was. 

By this argument we should all immediately stop programming anything
in any language.

   The programming community continues to be negligent, because the
   egos are so large,

C'mon!

   that C programmers can be trusted, and it must
   be alright because it is like that in C.

BS.  (sorry).  I like case-sensitivity no matter whether C uses it or
not.

   Because people passionately believe that case
   sensitivity is right, does not make it right.

Because you passionately believe that case sensitivity is wrong, does
not make it wrong.

   (And I know someone
   is going to reply and say but I must passionately believe that
   case-insensitivity is right. Well hopefully you can see that
   my arugments are based on a more objective approach. Safety is
   something that you must be objective about.)

This has nothing to do with safety.  You want a language that is
somewhat resistant against typos.  For some reason you have picked the
case of letters as your enemy.  You are fighting a strawman this way.
You admit yourself that bugs due to this problem are extermely rare.
Your argument is centered around the habits of English speakers.  I
have told you in private e-mail that in German, for example, the wrong
case of a letter is treated like any other spelling mistake.  If you
are insisting on making the language insensitive to case-distinction
errors, then I challenge you to also make it resistant against other
common spelling mistakes, too.  This would be useful, because with the
complicated spelling rules in English mistakes *other than*
upper-case/lower-case mixup will be far more common.

   >   English words are made up of 26 distinct letters. The capitalisation
   >   of them does not in general change the word, or its meaning.

   >This is perhaps true in English.  It isn't true in other languages.
   >And it also doesn't have anything to do with programming.

   If you think it has nothing to do with programming, then why do
   we bother to choose natural language names? Saying this is not
   true in other languages is arguing by exception. We should not
   make programming languages more complex unnecessarily, because
   you can think of natural language exceptions.

Well, let's say English is the exception here... :)

   This comes down to equivalences. The graphical forms 'f' and 'F'
   represent the same letter. The world is full of equivalences.
   For example in music based on the well tempered scale, the notes
   A# and Bb are enharmonic equivalences, ie the same note. Because
   they are represented by different notation does not make them
   different. The graphical forms '4' and 'four' represent the same
   notion.

Oho -- this argument again.  Ok, then let's make programming languages
insensitive against the distinction between `4' and `four', `the
smallest odd prime' and `3', `Haus' and `house', ...  See where this
is leading?  You just picked one instance of the many equivalences
between symbols we use in everyday life and demand we should consider
them the same in programming.  This is ridiculous, because your choice
is arbitrary and unnecessary.

   An example also comes from Piaget's work on child psychology.

Oh, there we go -- finally we come to the ultimate truth: psychology
...  Please, stop it!

   Piaget
   calls this "conservation". This quote is from "Psychology and Life"
   by Philip Zimbardo. "When an equal amount of lemonade is poured
   into two glasses, children of ages 5, 6, and 7 all report that
   the glasses contain the same amount; but when the lemonade from one
   glass is poured into a tall, thin glass, they have differing opinions.
   The 5 year olds know that the lemonade in the tall galss is the
   same lemonade (qualitative identity), but they believe that somehow
   it has become more. The 6 year olds are uncertain about the nature
   of the changed quantity, but also say the tall glass has more. The
   7 year olds know there is no difference between the amounts. The
   younger children rely on appearance; the older ones rely on a rule.
   The also take into account two dimensions - height and width - while
   the younger children center on a single, perceptually salient
   dimension - the height of the glass - which is usually a cue for "more.""

*sigh* -- what does this have to do with the case-sensitivity?

   Alas, in terms of conceptual thinking in computer science, it seems we
   have a bunch of 5 year olds.

Don't make me older than I am!

   The difference is that at least by the
   same person is 7, they will have changed their outlook, on how much
   lemonade there is, whereas the computer person will still be arguing
   that 'f' and 'F' are different, especially since they have different
   ASCII codes.

They *are* different.  I always thought they were -- even long before
I knew what ASCII code is.  Don't even try to explain why I think `F'
and `f' are different!  There really *is* the same amount of lemonade
-- this can be measured.  You say `f' and `F' are the same -- but
there is no way to measure this.  It's just your definition that makes
them the same.

   Well does that also mean that if you translate the program
   to EBCDIC or some other code, you have a substantially different
   computation?

As I said -- `F' and `f' are different to me as long as I know these
two letters.  Long before I learned that letters can be encoded as
numbers.  It would have been funny to argue with my German teachers to
convince them to not deduct points for case-distinction errors...  I
wish you would have been there.  With your rhetoric skills it might
have worked... :)

   If you can't understand these principles of equivalences,
   no wonder programming languages and compilers are so misunderstood,
   and raise such religious fervour and passions.

You are the one who misunderstands equivalences.  Equivalences are not
God-given.  They are man-made.  They are arbitrary.  If you choose to
consider `F' and `f' the same -- fine.  But I don't.  I know that the
two are strongly related.  I know that they are equivalent under a
certain definition.  But this does not mean that everyone has to
regard them the same everytime and everywhere.

   Given the small but real potential for error, [ ... ]

Small - yes.  Real - I don't think so!

Regards, (and, please, give it a rest!)
--
-Matthias

Newsgroups: comp.lang.c++
From: kanze@lts.sel.alcatel.de (James Kanze US/ESC 60/3/141 #40763)
Subject: Re: comments on "A critique of C++"
In-Reply-To: mat@mole-end.matawan.nj.us's message of Tue, 2 May 1995 04:33:04 GMT
Date: 11 May 1995 17:39:54 GMT

In article <1995May2.043304.11489@mole-end.matawan.nj.us>
mat@mole-end.matawan.nj.us writes:

|> In article <3ntrp2$4qk@News1.mcs.com>, jim.fleming@bytes.com (Jim Fleming) writes:

|> > *Some* people still feel that "language design" should be done by people
|> > with some artistic or stylistic ability.

|> Yes.  Such people are often heard arguing for `purity' in language design ...

Guilt by association.
-- 
James Kanze         Tel.: (+33) 88 14 49 00        email: kanze@gabi-soft.fr
GABI Software, Sarl., 8 rue des Francs-Bourgeois, F-67000 Strasbourg, France
Conseils en informatique industrielle --
                              -- Beratung in industrieller Datenverarbeitung



From: hnsngr@sirius.com (Ron Hunsinger)
Newsgroups: comp.lang.c++
Subject: Re: comments on "A critique of C++"
Date: Thu, 11 May 1995 15:59:53 -0700
Organization: Sirius Connections

In article <KANZE.95May11191341@slsvhdt.lts.sel.alcatel.de>,
kanze@lts.sel.alcatel.de (James Kanze US/ESC 60/3/141 #40763) wrote:

> I've got an idea.  Since people feel so strongly about this, some for
> and some against, let's satify both sides.
> 
> I propose we make the even letters case sensitive, and the odd ones
> case insensitive:-).

No, no. This is completely backwards.

The odd letters should be case sensitive, and the even ones case insensitive.
After all, "sensitive" begins with an odd letter, and "insensitive" with an
even one.

(Hey, it makes as much sense as the FORTRAN rule for INtegers.)

Of course, it might me more PC (notice the integration of an even letter 
with an odd) to insist that upper case letters be sensitive while lower
case letters may be insensitive. Call it affirmative action.

:)

-Ron Hunsinger

From: matt@dogbert.lbl.gov (Matthew Austern)
Newsgroups: comp.lang.c++,comp.std.c++.comp.std.c
Subject: Re: comments on "A critique of C++"
Date: 12 May 1995 17:26:35 GMT
Organization: University of California at Berkeley

In article <JSULLIVA.300.00092764@fhcrc.org> JSULLIVA@fhcrc.org (John Sullivan) writes:

> Just a little history, C++ was designed so that C code would compile under a 
> C++ compiler.  They're different languages, but C++ is backwards-compatible 
> with C.

Make that *almost* backwards compatible.  I suspect that very few C
programs of any size will compile as C++ code without at least a
couple of changes.
--
Matt Austern				      matt@physics.berkeley.edu
http://dogbert.lbl.gov/~matt

