Case sensitivity (was Re: no title)

Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbdm1i7.1k5.randhol+abuse@kiuk0152.chembio.ntnu.no...
> Case SenSitIvitY is a bAD ThiNg IMHO. It reduces readability as you need
> to be sure you spelt it correctly according to the definition. One could
> in fact have a GetString and getstring and Getstring and
> getString procedure.

IMHO, case sensitivity would help ensure consistency of names, so you don't
have Text_IO, Text_Io, text_io and TEXT_IO in the same program, and would
also enable using common words like In, Out, For, At for identifiers. Things
like GetString vs. getstring and others are better handled by using some
coding standard and naming convention, in my opinion. Given that it's
standard in Ada to use Identifiers_Like_This, I think case sensitivity
wouldn't do any harm.

And I agree with the rest of your post.

Sergey.

Re: Case sensitivity (was Re: no title)

[Bobby D. Bryant]

On Mon, 02 Jun 2003 12:41:25 +0200, Sergey Koshcheyev wrote:

> IMHO, case sensitivity would help ensure consistency of names, so you don't
> have Text_IO, Text_Io, text_io and TEXT_IO in the same program [...]

Sounds to me like a big pile of bugs just waiting to happen.

-- 
Bobby Bryant
Austin, Texas

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Sergey Koshcheyev wrote:
> 
> "Preben Randhol" <randhol+abuse@pvv.org> wrote in message
> news:slrnbdm1i7.1k5.randhol+abuse@kiuk0152.chembio.ntnu.no...
>> Case SenSitIvitY is a bAD ThiNg IMHO. It reduces readability as you need
>> to be sure you spelt it correctly according to the definition. One could
>> in fact have a GetString and getstring and Getstring and
>> getString procedure.
> 
> IMHO, case sensitivity would help ensure consistency of names, so you don't
> have Text_IO, Text_Io, text_io and TEXT_IO in the same program, and would
> also enable using common words like In, Out, For, At for identifiers. Things
> like GetString vs. getstring and others are better handled by using some
> coding standard and naming convention, in my opinion. Given that it's
> standard in Ada to use Identifiers_Like_This, I think case sensitivity
> wouldn't do any harm.

Why should the language care how you type it? If you use Gnat you will
notice it has a switch which does this for you. If you use Emacs it also
will. The problem is when you introduce errors in you program due to
wrong cases that is more severe.


-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbdmc9d.46d.randhol+abuse@kiuk0152.chembio.ntnu.no...
> Why should the language care how you type it?

For consistency.

> If you use Gnat you will notice it has a switch which does this for you.
If you use Emacs it also will.

Yes, the switch is fine, but it still doesn't let me name a function
parameter "At", for example.

> will. The problem is when you introduce errors in you program due to
> wrong cases that is more severe.

How can I introduce an error due to wrong case, having strong type checking
and all the other safeguards?

Besides, do you really use all the freedom that case insensitivity gives
you? Do you type Text_IO differently every time you need to name it? I
myself much prefer consistent naming. The compiler could also warn me about
names not following conventions, but still let me use reserved words as
identifiers (and Ada currently prohibits using many common English words).

By the way, I know about Java and Hashtable vs HashMap, but in Ada it could
be just the same, with Hashtable and Hash_Map. I don't view it as an
argument against case sensitivity.

Sergey.

Re: Case sensitivity (was Re: no title)

[Bobby D. Bryant]

On Mon, 02 Jun 2003 13:56:57 +0200, Sergey Koshcheyev wrote:

> "Preben Randhol" <randhol+abuse@pvv.org> wrote in message
> news:slrnbdmc9d.46d.randhol+abuse@kiuk0152.chembio.ntnu.no...
>> Why should the language care how you type it?
> 
> For consistency.
> 
>> If you use Gnat you will notice it has a switch which does this for
>> you.
> If you use Emacs it also will.
> 
> Yes, the switch is fine, but it still doesn't let me name a function
> parameter "At", for example.
> 
>> will. The problem is when you introduce errors in you program due to
>> wrong cases that is more severe.
> 
> How can I introduce an error due to wrong case, having strong type
> checking and all the other safeguards?

What if Records and RecordS have the same type?

And even if they don't, who wants to go fix a bunch of case-typos and then
recompile?

FWIW I've worked in environments that used case-sensitive languages, and a
large proportion of the bugs I've fixed in my whole life were the result
of people using identifiers with the wrong case.  (Second in number only
to use of global variables in elegant disdain for the fact that other
procedures were also using them.)

-- 
Bobby Bryant
Austin, Texas

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Sergey Koshcheyev wrote:
> "Preben Randhol" <randhol+abuse@pvv.org> wrote in message
> news:slrnbdmc9d.46d.randhol+abuse@kiuk0152.chembio.ntnu.no...
>> Why should the language care how you type it?
> 
> For consistency.

But it *is* consistent in that capitalisation is not a factor.

> Yes, the switch is fine, but it still doesn't let me name a function
> parameter "At", for example.

Why shouldn't you?

> How can I introduce an error due to wrong case, having strong type checking
> and all the other safeguards?

Because if you with and use package A and B and they both have a
getstring procedure which does differnt things.

   GetString (Input : String)  in package A and
   getstring (input : string)  in package B

Now if you say: GetString (Some_Input), but you really meant getstring
(input : string) as you want to use the function in B your complier
won't complain because GetString /= getstring. However if it is case
insensitive (as it is now) the compiler will ask you to spesify which
function you want because it cannot tell as getstring = GetString

> Besides, do you really use all the freedom that case insensitivity gives
> you? Do you type Text_IO differently every time you need to name it? I
> myself much prefer consistent naming. The compiler could also warn me about
> names not following conventions, but still let me use reserved words as
> identifiers (and Ada currently prohibits using many common English words).

Such as?

> By the way, I know about Java and Hashtable vs HashMap, but in Ada it could
> be just the same, with Hashtable and Hash_Map. I don't view it as an
> argument against case sensitivity.

Huh?

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Preben Randhol wrote:
> Sergey Koshcheyev wrote:
>> Yes, the switch is fine, but it still doesn't let me name a function
>> parameter "At", for example.
> 
> Why shouldn't you?

Opps sorry misread what you said. Ok then it is the rules of ACT that
prohibits this. But it doesn't matter which case it is. I always write
Put_Line New_Line etc.. because to *me* this is more reable, but I don't
want to force this on others. Beside if there is a New_Line and a
new_line which should I choose?

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Arthur Evans Jr]

I think case sensitivity is a great idea.

However, I (and a few others) fought this fight over 20 years ago
in DR meetings, and lost. Ada-83 didn't have case sensitivity, and
there's no way any revision of Ada will ever add it to the
language. No such a non-upward-compatible change will be made.

But, you say, all possible errors introduced into a program by this
change will be caught by the cpmpiler and can then be easily fixed.
It's true that the errors will be caught, but irrelevant. Fixing
these errors might be reasonable in a small program, say a few tens
of thousands of lines. But it just isn't practical in the really
big programs that Ada was designed for -- many tens of millions of
lines written at multiple locations.

Have this discussion on comp.lang.ada if you want to -- it's fun.
But don't expect anything said in this thread to influence the
design of Ada 200Y.

Art Evans

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Arthur Evans Jr" <ev_remove_this_ans@evans.pgh.pa.us> wrote in message
news:ev_remove_this_ans-0206030924320001@dap-208-40-156-130.nfas.perrysville.sns234.pa.stargate.net...
> Have this discussion on comp.lang.ada if you want to -- it's fun.
> But don't expect anything said in this thread to influence the
> design of Ada 200Y.

I don't. I just want to tell my arguments and hear what others have to say.
But it's not too important for me.

Sergey.

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Bobby D. Bryant" <bdbryant@mail.utexas.edu> wrote in message
news:pan.2003.06.02.12.46.09.593560@mail.utexas.edu...
> FWIW I've worked in environments that used case-sensitive languages, and a
> large proportion of the bugs I've fixed in my whole life were the result
> of people using identifiers with the wrong case.  (Second in number only
> to use of global variables in elegant disdain for the fact that other
> procedures were also using them.)

OK, I don't have much practical experience, so I can't argue with that (I
thought that these bugs would not be that common). So, probably, the Ada
designers did the right thing.

I just hate it when I can't use "At", "For" or "In", because they're
reserved.

Sergey.

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbdmifm.532.randhol+abuse@kiuk0152.chembio.ntnu.no...
> Preben Randhol wrote:
> > Sergey Koshcheyev wrote:
> >> Yes, the switch is fine, but it still doesn't let me name a function
> >> parameter "At", for example.
> >
> > Why shouldn't you?
>
> Opps sorry misread what you said. Ok then it is the rules of ACT that
> prohibits this. But it doesn't matter which case it is. I always write

No, it's because "At" is a reserved word. Also reserved are "Of", "In",
"Range", "Use", all of them being quite common.

> Put_Line New_Line etc.. because to *me* this is more reable, but I don't
> want to force this on others. Beside if there is a New_Line and a
> new_line which should I choose?

I don't understand the question. New_Line, of course :-)

I don't want complete freedom and anarchy, but just to be able to use
capitalized identifiers which collide with reserved words, and are thus
unusable.

What about some form of "case preservance"? So that you wouldn't be allowed
to have identifiers which differ only in case (except for those colliding
with keywords), but once you have an identifier named aBc, you have to spell
it the same way everywhere?

All of these ideas don't have anything to do with Ada200X or Y, of course -
I don't really want to propose changing a language which thousands of people
will use daily, when I myself don't have much programming experience.

Sergey.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Sergey Koshcheyev wrote:
> I just hate it when I can't use "At", "For" or "In", because they're
> reserved.

Ah now I understand you. I thought you meant that you couldn't use At
that the switch made you write it as at.

But reverse words is something most languages have.

   for For in In..Loop loop
      null;
   end loop;

You would like to write that? ;-)

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Sergey Koshcheyev wrote:
> "Preben Randhol" <randhol+abuse@pvv.org> wrote in message
> news:slrnbdmifm.532.randhol+abuse@kiuk0152.chembio.ntnu.no...
>> Preben Randhol wrote:
>> > Sergey Koshcheyev wrote:
>> >> Yes, the switch is fine, but it still doesn't let me name a function
>> >> parameter "At", for example.
>> >
>> > Why shouldn't you?
>>
>> Opps sorry misread what you said. Ok then it is the rules of ACT that
>> prohibits this. But it doesn't matter which case it is. I always write
> 
> No, it's because "At" is a reserved word. Also reserved are "Of", "In",
> "Range", "Use", all of them being quite common.

I haven't experienced the need to use any of them.
> 
>> Put_Line New_Line etc.. because to *me* this is more reable, but I don't
>> want to force this on others. Beside if there is a New_Line and a
>> new_line which should I choose?
> 
> I don't understand the question. New_Line, of course :-)

I mean there could be a New_Line and a new_line procedure. One adding a
linefeed to Standard_Out the other to Standard_Error

> I don't want complete freedom and anarchy, but just to be able to use
> capitalized identifiers which collide with reserved words, and are thus
> unusable.

This means you have then defined all reserved words as lowercase.

Anyway I think you will find that it is no problem that Ada isn't case
sensitive when you get used to it :-)

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbdmo62.5rv.randhol+abuse@kiuk0152.chembio.ntnu.no...
>    for For in In..Loop loop
>       null;
>    end loop;
>
> You would like to write that? ;-)

Well, I can't imagine a situation where this example would make sense (can
you?), but if there were such a situation, then why not? You can already
write nonsense code in many other ways in Ada.

Sergey.

Re: Case sensitivity (was Re: no title)

[Bill Findlay]

On 2/6/03 15:35, in article
slrnbdmo62.5rv.randhol+abuse@kiuk0152.chembio.ntnu.no, "Preben Randhol"
<randhol+abuse@pvv.org> wrote:

> Sergey Koshcheyev wrote:
>> I just hate it when I can't use "At", "For" or "In", because they're
>> reserved.
> 
> Ah now I understand you. I thought you meant that you couldn't use At
> that the switch made you write it as at.
> 
> But reverse words is something most languages have.
>>>>>>^
A perfect anagram in context! 8-)
-- 
Bill-Findlay chez blue-yonder.co.uk ("-" => "")

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbdmon4.5rv.randhol+abuse@kiuk0152.chembio.ntnu.no...
> Sergey Koshcheyev wrote:
> > No, it's because "At" is a reserved word. Also reserved are "Of", "In",
> > "Range", "Use", all of them being quite common.
>
> I haven't experienced the need to use any of them.

Of course, one can usually find synonyms, so maybe you just didn't notice
the need when you had it :-) But sometimes synonyms don't come so easily to
mind, or are non-standard names for standard things (for example, one can
use Interval instead of Range, but it then might make the reader (me) wonder
whether an Interval is the same as Ada range, or if it's an open interval,
etc.).

> >> Put_Line New_Line etc.. because to *me* this is more reable, but I
don't
> >> want to force this on others. Beside if there is a New_Line and a
> >> new_line which should I choose?
> >
> > I don't understand the question. New_Line, of course :-)
>
> I mean there could be a New_Line and a new_line procedure. One adding a
> linefeed to Standard_Out the other to Standard_Error

Doesn't seem to me like a useful naming convention :-) Have you actually
encountered anything like this in real code?

> > I don't want complete freedom and anarchy, but just to be able to use
> > capitalized identifiers which collide with reserved words, and are thus
> > unusable.
>
> This means you have then defined all reserved words as lowercase.

This would also be enough.

> Anyway I think you will find that it is no problem that Ada isn't case
> sensitive when you get used to it :-)

I agree, humans can get used to things much worse. I just find it irritating
sometimes. Also when I look through AdaGIDE source for example, I see some
of the keywords are in uppercase, some are in lowercase, identifiers look
sometimes Likethis, sometimes LikeThis, sometimes Like_This... Well, one can
probably get used even to this.

Ok, this topic isn't probably worth discussing much more.

Sergey.

RE: Case sensitivity (was Re: no title)

[Robert C. Leif]

My experience with XML, which is case sensitive, has convinced me that case
sensitivity is one of the worst possible changes for Ada. The case
sensitivity of XML has caused me to waste very large amounts of time. Bill
Gates' one major contribution to software engineering was that he made DOS
case insensitive. I believe that one of the major problems with the POSIX
family of operating systems is case sensitivity. Case sensitivity is
definitely a significant contributor to user hostility.
Bob Leif

RE: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <mailman.11.1054567285.12990.comp.lang.ada@ada.eu.org>, "Robert C. Leif" <rleif@rleif.com> writes:
> My experience with XML, which is case sensitive, has convinced me that case
> sensitivity is one of the worst possible changes for Ada. The case
> sensitivity of XML has caused me to waste very large amounts of time. Bill
> Gates' one major contribution to software engineering was that he made DOS
> case insensitive.

VMS commands, from which some of the DOS commands seem to be taken,
are quite case-blind.

Or by "major contribution to software engineering" did you mean
"not messing it up" :-)

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Sergey Koshcheyev wrote:
> 
> Of course, one can usually find synonyms, so maybe you just didn't
> notice the need when you had it :-) But sometimes synonyms don't come
> so easily to mind, or are non-standard names for standard things (for
> example, one can use Interval instead of Range, but it then might make
> the reader (me) wonder whether an Interval is the same as Ada range,
> or if it's an open interval, etc.).

Well I usually make descriptive variables. I mean if I needed to use
Range I would more likely call it Concentration_Range (or Conc_Range) ad
Voltage_Range etc.. Then you have your range and it also tell you a bit
more what range it is.

> Doesn't seem to me like a useful naming convention :-) Have you
> actually encountered anything like this in real code?

But this is the problem with case sensitivity.

> 
> I agree, humans can get used to things much worse. I just find it
> irritating sometimes. Also when I look through AdaGIDE source for
> example, I see some of the keywords are in uppercase, some are in
> lowercase, identifiers look sometimes Likethis, sometimes LikeThis,
> sometimes Like_This... Well, one can probably get used even to this.

Well being slightly annoyed is better than having a buggy code to annoy
over ;-) But I think I would be more annoyed in a case sensitive
language than you in a case insensitive :-)

PS: Note Ada is case sensistive. It is not ADA nor ada, but the case
sensitivity goes no further :-)
-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Martin Dowie]

"Sergey Koshcheyev" <serko84@hotmail.com> wrote in message
news:bbf9kl$7kt$1@ns.felk.cvut.cz...
>
> "Preben Randhol" <randhol+abuse@pvv.org> wrote in message
> news:slrnbdm1i7.1k5.randhol+abuse@kiuk0152.chembio.ntnu.no...
> > Case SenSitIvitY is a bAD ThiNg IMHO. It reduces readability as you need
> > to be sure you spelt it correctly according to the definition. One could
> > in fact have a GetString and getstring and Getstring and
> > getString procedure.
>
> IMHO, case sensitivity would help ensure consistency of names, so you
don't
> have Text_IO, Text_Io, text_io and TEXT_IO in the same program, and would
> also enable using common words like In, Out, For, At for identifiers.
Things
> like GetString vs. getstring and others are better handled by using some
> coding standard and naming convention, in my opinion. Given that it's
> standard in Ada to use Identifiers_Like_This, I think case sensitivity

While you will find lots of code that does conform to the "new" Ada95 style,
you will also find loads of guys still using the old Ada83 style. If you
want
to ensure that everyones code is consistent use a pretty-printer and/or peer
reviews (preferable a PP).

No case sensitively please...

Re: Case sensitivity (was Re: no title)

[Mike Silva]

"Sergey Koshcheyev" <serko84@hotmail.com> wrote in message news:<bbf9kl$7kt$1@ns.felk.cvut.cz>...
> 
> IMHO, case sensitivity would help ensure consistency of names, so you don't
> have Text_IO, Text_Io, text_io and TEXT_IO in the same program, and would
> also enable using common words like In, Out, For, At for identifiers. Things
> like GetString vs. getstring and others are better handled by using some
> coding standard and naming convention, in my opinion. Given that it's
> standard in Ada to use Identifiers_Like_This, I think case sensitivity
> wouldn't do any harm.

Going back to first principles, different case does not change the
meaning of words (at least in English!).  Cup and cup and CUP are all
the same.  I'm sure it was only a matter of laziness or a desire for
greater speed that caused case sensitivity to be included in many
languages.  In either case, they broke the rules of language meaning
by causing Cup and cup and CUP to be different things.  The question
is, do you *really* need Cup and cup and CUP to be different?  I know
it's a common C idiom, e.g. to declare:

CUP cup;

But I think that's just more laziness -- surely one could think of a
more suitable name for this particular CUP variable!

Anyway, I think the key point is that Ada follows conventional
language useage, while case-sensitive languages don't.

Mike

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Mike Silva wrote:
> Going back to first principles, different case does not change the
> meaning of words (at least in English!).

YOU ARE 100% WRONG!

You may also want to read Winnie the Pooh.

Re: Case sensitivity (was Re: no title)

[tmoran]

With the coming of handwriting recognition shouldn't case sensitivity
logically be extended to consider a letter "A" in lower case OEM font
different from not only "A" in upper case OEM font, but also different
from cursive script, Gothic, etc?  Just visualize what a program might
look like.
<gd&r>

Re: Case sensitivity (was Re: no title)

[Bobby D. Bryant]

On Mon, 02 Jun 2003 18:40:57 +0000, tmora wrote:

> With the coming of handwriting recognition shouldn't case sensitivity
> logically be extended to consider a letter "A" in lower case OEM font
> different from not only "A" in upper case OEM font, but also different
> from cursive script, Gothic, etc?  Just visualize what a program might
> look like.
> <gd&r>

Does the semantics of a program change when you print it with a different
font...?

Inquiring minds want to know!

-- 
Bobby Bryant
Austin, Texas

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

tmoran@acm.org wrote:
> Just visualize what a program might look like.

It might look like a mathematics paper, where such
font differences have long been used to distinguish
different types of entities.

Re: Case sensitivity (was Re: no title)

[Georg Bauhaus]

tmoran@acm.org wrote:
: With the coming of handwriting recognition shouldn't case sensitivity
: logically be extended to consider a letter "A" in lower case OEM font
: different from not only "A" in upper case OEM font, but also different
: from cursive script, Gothic, etc?  Just visualize what a program might
: look like.

No need to run, because, historically, the small and capital letters
of the Latin alphabet in Europe had originally evolved from what could
be considered different ways of handwriting, using a non-ASCII alphabet
with only one representation for each character (Uncial).
See e.g.  http://allchin.org/alcuin.html

There Are Still People Who Think that Capital Letters At Very Simplistically
Determined Positions In Words Are Their Best Use...

Georg,
: <gd&r>

Re: Case sensitivity (was Re: no title)

[tmoran]

>> Just visualize what a program might look like.
>
>It might look like a mathematics paper, where such
>font differences have long been used to distinguish
>different types of entities.
  Ah, taking over maintenance of a 500 KSLOC program that looks like
a 500,000 line math proof - what a delight.

Re: Case sensitivity (was Re: no title)

[Alexander Kopilovitch]

Preben Randhol <randhol+abuse@pvv.org> wrote in message news:<slrnbdmo62.5rv.randhol+abuse@kiuk0152.chembio.ntnu.no>...
>   for For in In..Loop loop
>      null;
>   end loop;
>
>You would like to write that? ;-)

Better question is: You would like to *read* that? ;-)



Alexander Kopilovitch                      aek@vib.usr.pu.ru
Saint-Petersburg
Russia

Re: Case sensitivity (was Re: no title)

[Mike Silva]

Hyman Rosen <hyrosen@mail.com> wrote in message news:<1054578576.281946@master.nyc.kbcfp.com>...
> Mike Silva wrote:
> > Going back to first principles, different case does not change the
> > meaning of words (at least in English!).
> 
> YOU ARE 100% WRONG!

Well, Hyman, I think you're just messing with me, but how is your
sentence different than "you are 100% wrong!"

Which words changed meaning?

Certainly by convention there is a difference of emphasis with all
caps, but how would you translate that into program identifiers?

int CUP;  // the critical variable for this function!
int cup;  // a much-less important variable

> You may also want to read Winnie the Pooh.

Always a good suggestion, but not, maybe, for the reasons you imagine!

SO THERE!

Re: Case sensitivity (was Re: no title)

[Mike Silva]

"Bobby D. Bryant" <bdbryant@mail.utexas.edu> wrote in message news:<pan.2003.06.02.18.51.49.881243@mail.utexas.edu>...
> On Mon, 02 Jun 2003 18:40:57 +0000, tmora wrote:
> 
> > With the coming of handwriting recognition shouldn't case sensitivity
> > logically be extended to consider a letter "A" in lower case OEM font
> > different from not only "A" in upper case OEM font, but also different
> > from cursive script, Gothic, etc?  Just visualize what a program might
> > look like.
> > <gd&r>
> 
> Does the semantics of a program change when you print it with a different
> font...?
> 
> Inquiring minds want to know!

What about font size?  Should e.g. tasks written in larger font sizes
have higher priority?

I think we could leave the C-obfuscators in the dust with these new
developments!

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Mike Silva wrote:
> Well, Hyman, I think you're just messing with me

Well, yes, of course. But more seriously, since we
use capitalization for proper nouns, words do change
meaning that way, for example, polish and Polish.

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <1054591015.933523@master.nyc.kbcfp.com>, Hyman Rosen <hyrosen@mail.com> writes:
> Mike Silva wrote:
>> Well, Hyman, I think you're just messing with me
> 
> Well, yes, of course. But more seriously, since we
> use capitalization for proper nouns, words do change
> meaning that way, for example, polish and Polish.

Not always.

	"Polish is important"

has a different meaning in a treatise on foreign language studies
vs. one about care of army boots.

So the significance of capitalization in English is overloaded,
and provides only _hints_, not an absolute proof of meaning.

Something providing only hints is appropriate for local coding
standards, not for compiler enforcement.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Mike Silva wrote:
>> Well, Hyman, I think you're just messing with me
> 
> Well, yes, of course. But more seriously, since we
> use capitalization for proper nouns, words do change
> meaning that way, for example, polish and Polish.

In Norwegian we don't have this except for names either person or
country. :-)

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Randy Brukardt]

Preben Randhol wrote in message ...
>Sergey Koshcheyev wrote:
>> I don't want complete freedom and anarchy, but just to be able to use
>> capitalized identifiers which collide with reserved words, and are
thus
>> unusable.
>
>This means you have then defined all reserved words as lowercase.


Right. And that would be very bad for existing code. Our Ada 83 coding
standard used Title case reserved words:

    Procedure Foo Is
        MAX : Constant Integer := 10;
    Begin
        If Expr > MAX Then ...
    End Foo;

The entire Janus/Ada compiler is formatted like this. I'm pretty sure
that I'd have an opinion on a language change which made all of that
code illegal. :-) :-)

                Randy.

Re: Case sensitivity (was Re: no title)

[Randy Brukardt]

Larry Kilgallen wrote in message ...
>In article <mailman.11.1054567285.12990.comp.lang.ada@ada.eu.org>,
"Robert C. Leif" <rleif@rleif.com> writes:
>> My experience with XML, which is case sensitive, has convinced me
that case
>> sensitivity is one of the worst possible changes for Ada. The case
>> sensitivity of XML has caused me to waste very large amounts of time.
Bill
>> Gates' one major contribution to software engineering was that he
made DOS
>> case insensitive.
>
>VMS commands, from which some of the DOS commands seem to be taken,
>are quite case-blind.

Bill Gates bought MS-DOS from Seattle Computer; it was already case
sensitive then. (I think I still have my Seattle Computer "86-DOS"
manuals.)

Tim Patteson borrowed much of the design for 86-DOS from CP/M-80 (the
most widely used PC OS at the time).

Gary Kindall borrowed much of the design of CP/M from PDP-11 operating
systems. (That's as far back as my personal knowledge goes.) I suppose
VMS got its commands from the same source.

>Or by "major contribution to software engineering" did you mean
>"not messing it up" :-)

Probably; Bill Gates had as much to do with the early design of MS-DOS
as I did. Come to think of it, it is possible that I indirectly had some
influence on early MS-DOS, as we did have some contact with the
developers at Seattle Computer before Microsoft bought MS-DOS.

In any event, it's hard to determine who invented what, other than you
can be pretty sure that the people taking credit for things did not
invent them! :-)

             Randy.

Re: Case sensitivity (was Re: no title)

[Steve]

"Sergey Koshcheyev" <serko84@hotmail.com> wrote in message
news:bbf9kl$7kt$1@ns.felk.cvut.cz...
>
> "Preben Randhol" <randhol+abuse@pvv.org> wrote in message
> news:slrnbdm1i7.1k5.randhol+abuse@kiuk0152.chembio.ntnu.no...
> > Case SenSitIvitY is a bAD ThiNg IMHO. It reduces readability as you need
> > to be sure you spelt it correctly according to the definition. One could
> > in fact have a GetString and getstring and Getstring and
> > getString procedure.
>
> IMHO, case sensitivity would help ensure consistency of names, so you
don't
> have Text_IO, Text_Io, text_io and TEXT_IO in the same program, and would
> also enable using common words like In, Out, For, At for identifiers.
Things
> like GetString vs. getstring and others are better handled by using some
> coding standard and naming convention, in my opinion. Given that it's
> standard in Ada to use Identifiers_Like_This, I think case sensitivity
> wouldn't do any harm.

IMHO, case sensitivity does not ensure consistency of names.  It permits you
to have Text_IO, Text_Io, text_io and TEXT_IO in the same program, that all
do different things (Yuk!).  Having seen this sort of thing in some C code,
I think it's a very bad thing and does do harm.

Now if you want to add a compiler switch that warns if the same identifier
appears in different places with different casing... I think that is a good
idea.  Maybe a smart IDE could even pop-up a list of casings for the same
identifier and let you choose the "right" one.

Steve
(The Duck)

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> do different things (Yuk!).  Having seen this sort of thing in some C code,
> I think it's a very bad thing and does do harm.

Oh, but it's SO cool to write

   int Func (FILE *file) {}

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Wesley Groleau wrote:
> Oh, but it's SO cool to write
>   int Func (FILE *file) {}

Case sensitivity is clearly a matter of taste, but Ada already
allows the same name to refer to multiple things. Indeed, that's
usually touted as an advantage over C and C++:
     type color is ( red, green, blue );
     type mood is ( cheerful, angry, blue );
This means that just looking at an identifier, I can't immediately
know what it is - I may have to analyze a complicated overload to
figure it out, or have my IDE do that for me. If it turns out that
I used the identifier in an incorrect context, the compiler will
tell me. So since we're already in this situation, I fail to see
how case sensitivity makes things any worse, except that some people
just don't like it.

That bit of C code cited above is perfectly natural to a C programmer,
who would find it instantly readable and indeed would be unlikely to
even give it a second thought.

Re: Case sensitivity (was Re: no title)

[John R. Strohm]

"Randy Brukardt" <randy@rrsoftware.com> wrote in message
news:vdntjj5epb7ea0@corp.supernews.com...
> Preben Randhol wrote in message ...
> >Sergey Koshcheyev wrote:
> >> I don't want complete freedom and anarchy, but just to be able to use
> >> capitalized identifiers which collide with reserved words, and are
> thus
> >> unusable.
> >
> >This means you have then defined all reserved words as lowercase.
>
>
> Right. And that would be very bad for existing code. Our Ada 83 coding
> standard used Title case reserved words:
>
>     Procedure Foo Is
>         MAX : Constant Integer := 10;
>     Begin
>         If Expr > MAX Then ...
>     End Foo;
>
> The entire Janus/Ada compiler is formatted like this. I'm pretty sure
> that I'd have an opinion on a language change which made all of that
> code illegal. :-) :-)

Gee, ya think so???

I've seen two very common case conventions set into stone in programming
standards documents on Ada projects, both at the same company.

One group demanded that reserved words be all upper case, and that
identifiers be lower case or mixed case.

Another group demanded that reserved words be all lower-case and identifiers
be all upper-case.

Somehow, neither of these groups had ever heard of the psychological studies
that show that mixed and lower case are easier for humans to read.  You'd
think some of them never even heard that lower case HAD been invented.

Re: Case sensitivity (was Re: no title)

[John R. Strohm]

<tmoran@acm.org> wrote in message news:ZSMCa.812515$OV.748440@rwcrnsc54...
> With the coming of handwriting recognition shouldn't case sensitivity
> logically be extended to consider a letter "A" in lower case OEM font
> different from not only "A" in upper case OEM font, but also different
> from cursive script, Gothic, etc?  Just visualize what a program might
> look like.
> <gd&r>

Hey, you think that's bad?

Wait until someone puts out an Ada compiler that actually UNDERSTANDS about
Greek letters.  Watch what the guidance, navigation, and control guys do to
you then...

Re: Case sensitivity (was Re: no title)

[John R. Strohm]

"Bobby D. Bryant" <bdbryant@mail.utexas.edu> wrote in message
news:pan.2003.06.02.18.51.49.881243@mail.utexas.edu...
> On Mon, 02 Jun 2003 18:40:57 +0000, tmora wrote:
>
> > With the coming of handwriting recognition shouldn't case sensitivity
> > logically be extended to consider a letter "A" in lower case OEM font
> > different from not only "A" in upper case OEM font, but also different
> > from cursive script, Gothic, etc?  Just visualize what a program might
> > look like.
> > <gd&r>
>
> Does the semantics of a program change when you print it with a different
> font...?
>
> Inquiring minds want to know!

I hope not!

I was having a lot of fun a few years ago.  I had my Emacs preferences set
to use this really nice bold italic font...

Re: Case sensitivity (was Re: no title)

[Jean-Pierre Rosen]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1102 bytes --]


"Mike Silva" <snarflemike@yahoo.com> a �crit dans le message news:
20619edc.0306021018.6ee4dd09@posting.google.com...
> Going back to first principles, different case does not change the
> meaning of words (at least in English!).  Cup and cup and CUP are all
> the same.  I'm sure it was only a matter of laziness or a desire for
> greater speed that caused case sensitivity to be included in many
> languages.
In C, an identifier is a character string that designates a memory address.
The rule is simple: different character strings designate different
addresses.

This is normal for a low level language which is directed to the machine.

In a high level language like Ada, which is directed to the human reader,
and identifier has a meaning in natural language. And as you point out,
the meaning in natural language does not depend on casing.

Too bad that many languages that call themselves "high level" inherited
the low level view of C.

--
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: Case sensitivity (was Re: no title)

[Jean-Pierre Rosen]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 692 bytes --]


<tmoran@acm.org> a �crit dans le message news:
ZSMCa.812515$OV.748440@rwcrnsc54...
> With the coming of handwriting recognition shouldn't case sensitivity
> logically be extended to consider a letter "A" in lower case OEM font
> different from not only "A" in upper case OEM font, but also different
> from cursive script, Gothic, etc?  Just visualize what a program might
> look like.
Without kidding, in Java where programs are supposed to be written in
Unicode, an upper case greek Alpha (A) is different from an uppercase
latin A.

--
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: Case sensitivity (was Re: no title)

[Vinzent Hoefler]

Wesley Groleau wrote:

>Oh, but it's SO cool to write
>
>   int Func (FILE *file) {}

What about

|int File (FILE *file) { ... }

?


SCNR,

Vinzent.

Re: Case sensitivity (was Re: no title)

[Georg Bauhaus]

Bobby D. Bryant <bdbryant@mail.utexas.edu> wrote:
: 
: Does the semantics of a program change when you print it with a different
: font...?

Might depend on the meaning of semantics.

-- Georg

Re: Case sensitivity (was Re: no title)

[Georg Bauhaus]

Hyman Rosen <hyrosen@mail.com> wrote:
: tmoran@acm.org wrote:
:> Just visualize what a program might look like.
: 
: It might look like a mathematics paper, where such
: font differences have long been used to distinguish
: different types of entities.

In A+ (a Free APL dialect) you have a choice of either
using A+ operator symbols or ASCII words for the same
thing.

Re: Case sensitivity (was Re: no title)

[Martin Dowie]

"Steve" <nospam_steved94@attbi.com> wrote in message news:<ZXTCa.1089424$F1.129227@sccrnsc04>...
> IMHO, case sensitivity does not ensure consistency of names.  It permits you
> to have Text_IO, Text_Io, text_io and TEXT_IO in the same program, that all
> do different things (Yuk!).  Having seen this sort of thing in some C code,
> I think it's a very bad thing and does do harm.
> 
> Now if you want to add a compiler switch that warns if the same identifier
> appears in different places with different casing... I think that is a good
> idea.  Maybe a smart IDE could even pop-up a list of casings for the same
> identifier and let you choose the "right" one.

Just use a Pretty-Printer! Make it part of your config control process
that
before checking anything in it is passed through the PP. This should
be enough to keep all you code consistent.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

John R. Strohm wrote:
> that show that mixed and lower case are easier for humans to read.  You'd
> think some of them never even heard that lower case HAD been invented.

Sidenote: I heard recently on the radio that the reason it is called
upper case and lower case was that in the old bookprinting times (I
think it was from Guthenberg if I recall correctly) the capital letters
were stored in the upper case (drawer) while the small letters where
stored in the lower case.  And from this the names came. Can anybody
comfirm this?

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <ZXTCa.1089424$F1.129227@sccrnsc04>, "Steve" <nospam_steved94@attbi.com> writes:

> IMHO, case sensitivity does not ensure consistency of names.  It permits you
> to have Text_IO, Text_Io, text_io and TEXT_IO in the same program, that all
> do different things (Yuk!).  Having seen this sort of thing in some C code,
> I think it's a very bad thing and does do harm.

You omitted 60 other possible capitalizations.

I suppose one could write a C program with all variables named "variable"
but with various capitalizations.  _That_ should answer those people who
claim Ada can do anything C can do.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
>      type color is ( red, green, blue );
>      type mood is ( cheerful, angry, blue );

This doesn't have to do with upper case or lower case it has to do with
English language.

And I guess your solution would be:

   type color is ( Red, Green, blue );
   type mood is ( cheerful, angry, Blue );

;-)

> This means that just looking at an identifier, I can't immediately
> know what it is - I may have to analyze a complicated overload to
> figure it out, or have my IDE do that for me. If it turns out that
> I used the identifier in an incorrect context, the compiler will
> tell me. So since we're already in this situation, I fail to see
> how case sensitivity makes things any worse, except that some people
> just don't like it.

You are trying to make soup by cooking a nail I see.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> You are trying to make soup by cooking a nail I see.

Excuse me? I'm putting forward a perfectly reasonable argument.

The reason I've heard cited for case insensitivity is that with
case sensitivity, you have one English word in your program
which stands for multiple things, which is confusing, for example
if you are doing the "telephone test" for code readability (that
is, seeing if someone else can understand the code upon hearing
it read instead of looking at it). But since Ada already allows
one English word to stand for multiple things, I don't find this
argument convincing.

Re: Case sensitivity (was Re: no title)

[Vinzent Hoefler]

Hyman Rosen wrote:

>if you are doing the "telephone test" for code readability (that
>is, seeing if someone else can understand the code upon hearing
>it read instead of looking at it).

Never heard of that. Interesting idea anyway. ;-)

>But since Ada already allows
>one English word to stand for multiple things, I don't find this
>argument convincing.

Well, even English allows one word standing for multiple things so
that the actual meaning depends on the context.

I'd say, in most areas the context is Ada would be more often clear
(in the end we are talking about overloading here) than it would be in
C (consider BUF_LEN vs. buf_len, quite common I'd say). Well, my
personal view is probably distorted.

Personally I'd rather would like Ada to be case-sensitive with the
restriction that identifiers should never be the same, regardless of
how they are written, so I wouldn't allow Buf_Len and BUF_LEN to be in
the same view at the same time, but OTOH I would clearly distinct
between the two.
This would render the "advantages" of case-sensitivity completely
useless but force the programmers to have a consistent style in all
places without any style check or pretty printers. :-P

BTW, you might have fun trying
<http://www.fecyk.ca/spamalbum/56k/this-function-is-void.mp3> for a
"telephone test". As you can probably guess from the name, it's C. ;-)


Vinzent.

-- 
Parents strongly cautioned  --  this  posting  is  intended for mature
audiences  over  18.  It  may  contain some material that many parents
would not find suitable for children and may include intense violence,
sexual situations, coarse language and suggestive dialogue.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Jean-Pierre Rosen wrote:
> In a high level language like Ada, which is directed to the human reader,
> and identifier has a meaning in natural language.

     type color is ( red, green, blue );
     type mood is ( cheerful, angry, blue );

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:

> The reason I've heard cited for case insensitivity is that with
> case sensitivity, you have one English word in your program
> which stands for multiple things, which is confusing, for example
> if you are doing the "telephone test" for code readability (that
> is, seeing if someone else can understand the code upon hearing
> it read instead of looking at it). 

> But since Ada already allows one English word to stand for multiple
> things, I don't find this argument convincing.

It is English which allows for one word to mean multiple things. How is
it better that your coulours are capitalised while moodes are not? Then
one have to remember that for this and this and that it is Mixed
capitalisation and for that it is upper case and this lower case etc...
It is far easier to rather better to use different words than to simply
change the case.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Vinzent Hoefler wrote:
> This would render the "advantages" of case-sensitivity completely
> useless but force the programmers to have a consistent style in all
> places without any style check or pretty printers. :-P

And the gain is what?

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Jean-Pierre Rosen wrote:
>> In a high level language like Ada, which is directed to the human reader,
>> and identifier has a meaning in natural language.
> 
>      type color is ( red, green, blue );
>      type mood is ( cheerful, angry, blue );

Please explain how you do this in a real C++ program? 

   type color is ( Red, Green, Blue );
   type mood is ( Cheerful, Angry, blue );

?

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> It is far easier to rather better to use different
 > words than to simply change the case.

The point remains that I may want to use the same word
in different cases to mean different things. The C
example of upper case as the type and lower case as the
object is an example. Ada says I can't do that. Why?
Because having one English word mean two different things
is confusing? But Ada already allows that. So it's an
arbitrary decision made by people who don't like case
sensitivity forcing their view on those who do.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> Please explain how you do this in a real C++ program? 
>    type color is ( Red, Green, Blue );
>    type mood is ( Cheerful, Angry, blue );

In C or C++, an enumeration declaration is not a scope.
In C++, if you need overloaded enumerators, you must wrap
them in a namespace and then always qualify the duplicates.

     namespace color { enum e { Red, Green, Blue }; }
     namespace mood { enum e { Cheerful, Angry, Blue }; }
     using namespace color;
     using namespace mood;
     color::e my_c1 = Red;
     color::e my_c2 = color::Blue;
     mood::e my_m1 = Angry;
     mood::e my_m2 = mood::Blue;

No C++ programmer would declare mood the way you did,
with some enumerators capitalized and others not (except
perhaps for sentinel ones). But in C++ it would not be
unusual for someone to write
     class Frob { /* ... */ };
     Frob frob;

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Preben Randhol wrote:
>> It is far easier to rather better to use different
> > words than to simply change the case.
> 
> The point remains that I may want to use the same word
> in different cases to mean different things.

And my point is that this is a bad idea(tm) as it is more error prone
than using two distinct words :-)

> example of upper case as the type and lower case as the
> object is an example. Ada says I can't do that. Why?
> Because having one English word mean two different things
> is confusing? But Ada already allows that. So it's an
> arbitrary decision made by people who don't like case
> sensitivity forcing their view on those who do.

Yes and for better reasons than to like case-sensitivity.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> And my point is that this is a bad idea(tm)

And *my* point is that while it may be a bad idea,
Ada already allows it in the case of function
overloading, including enumerators.

Re: Case sensitivity (was Re: no title)

[John R. Strohm]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1054651042.211055@master.nyc.kbcfp.com...
> Preben Randhol wrote:
> > It is far easier to rather better to use different
>  > words than to simply change the case.
>
> The point remains that I may want to use the same word
> in different cases to mean different things. The C
> example of upper case as the type and lower case as the
> object is an example. Ada says I can't do that. Why?
> Because having one English word mean two different things
> is confusing? But Ada already allows that. So it's an
> arbitrary decision made by people who don't like case
> sensitivity forcing their view on those who do.

No, Hyman, it was a decision made by people who recognized, at the time that
the decision had to be made, that there were still a lot of organizations
who would be using the language who were still stuck with upper case only
development environments.

I don't think you appreciate just how common IBM mainframes were in the
military-industrial complex software development world.  IBM mainframes
DIDN'T HAVE LOWER CASE for programming.  Period.  This is also why there
were the alternate character choices (: for # for based numbers, for
example): some of those machines didn't HAVE # characters available.

If you mandate case sensitivity, you blow reuse completely out of the water.
A retread C programmer writes a program using case sensitivity to
discriminate among various variables, and he gives a copy to someone at
GD/FW, which only has upper case, and there isn't a DAMNED thing GD can do
to make use of it.  Making the language case-insensitive fixes that problem,
by preventing it from ever occurring.

Re: Case sensitivity (was Re: no title)

[Robert I. Eachus]

Preben Randhol wrote:

> Sidenote: I heard recently on the radio that the reason it is called
> upper case and lower case was that in the old bookprinting times (I
> think it was from Guthenberg if I recall correctly) the capital letters
> were stored in the upper case (drawer) while the small letters where
> stored in the lower case.  And from this the names came. Can anybody
> comfirm this?

Sure, when I was in high school my brother and I earned our spending 
money running a printing business.  We bought the press and equipment 
(including over 150 drawers of type) from a widow whose husband had been 
running a printing business out of the basement of her home.  She wanted 
to sell the house, but needed to get all of that stuff out of the basement.

The press and type drawers still exist, as a 'living museum' at Eckerd 
College in Saint Petersburg, FL.  You know you are old when they start 
putting your things in a museum!

Re: Case sensitivity (was Re: no title)

[Vinzent Hoefler]

Preben Randhol wrote:

>Vinzent Hoefler wrote:
>> This would render the "advantages" of case-sensitivity completely
>> useless but force the programmers to have a consistent style in all
>> places without any style check or pretty printers. :-P
>
>And the gain is what?

s/is/would be/, please. I wouldn't seriously support such an approach.

The gain would be forcing a consistent style to the programmer without
falling back to a machine-based pretty printer.

Call that sadism or so. ;-)


Vinzent.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

John R. Strohm wrote:
 > Making the language case-insensitive fixes that problem,
> by preventing it from ever occurring.

You might be right if the language were case-insensitive,
but it isn't. Character and string literals are sensitive
to case. It's only identifiers which ignore case. So your
hypothetical mainframe environment couldn't handle
     Put("Hello, world!");

And speaking of such primitive environments, I started
programming in college on a very early UNIX system on a
PDP-11 using uppercase-only terminals that used rolls of
paper, not display screens. The drivers translated all
input to lower case internally, and if you wanted upper
case, you escaped the letter with a backslash. The system
would then print such actual upper case letters with a
backslash prefix. So it was certainly possible to use
mixed case even on such a platform.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Vinzent Hoefler wrote:
> The gain would be forcing a consistent style to the programmer without
> falling back to a machine-based pretty printer.
> 
> Call that sadism or so. ;-)

Hehe Sorry to hard to keep track of sarcasms here :-) Perhaps tag the
paragraphs? ;-)

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[David C. Hoos]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbdp21r.1lk.randhol+abuse@kiuk0152.chembio.ntnu.no...
> John R. Strohm wrote:
> > that show that mixed and lower case are easier for humans to read.
You'd
> > think some of them never even heard that lower case HAD been invented.
>
> Sidenote: I heard recently on the radio that the reason it is called
> upper case and lower case was that in the old bookprinting times (I
> think it was from Guthenberg if I recall correctly) the capital letters
> were stored in the upper case (drawer) while the small letters where
> stored in the lower case.  And from this the names came. Can anybody
> comfirm this?
>
Yes. From
http://www.etymonline.com/c2etym.htm

case (2) - "receptacle," c.1300, from O.N.Fr. casse, O.Fr. chasse, from L.
capsa "box," from capere "to take, hold." The verb meaning "examine,
inspect" (usually prior to robbing) is Amer.Eng. slang first recorded 1915.
Staircase is from 1663. Artillery sense is from 1667, from case-shot "small
projectiles put in cases" (1625). Reference in the printing trade (first
recorded 1588) to the two trays where compositors keep their types in
separate compartments for easy access led to upper case for capitals and
lower case for small letters.
 > -- 
> Preben Randhol                    http://www.pvv.org/~randhol/
> _______________________________________________
> comp.lang.ada mailing list
> comp.lang.ada@ada.eu.org
> http://ada.eu.org/mailman/listinfo/comp.lang.ada
>

Re: Case sensitivity (was Re: no title)

[Jean-Pierre Rosen]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 616 bytes --]


"Hyman Rosen" <hyrosen@mail.com> a �crit dans le message news:
1054649187.11497@master.nyc.kbcfp.com...
> Jean-Pierre Rosen wrote:
> > In a high level language like Ada, which is directed to the human
reader,
> > and identifier has a meaning in natural language.
>
>      type color is ( red, green, blue );
>      type mood is ( cheerful, angry, blue );
>
So what?
The identifier is overloaded in natural language, and Ada
just follows the natural language.

--
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: Case sensitivity (was Re: no title)

[Robert A Duff]

Hyman Rosen <hyrosen@mail.com> writes:

> Preben Randhol wrote:
> > It is far easier to rather better to use different
>  > words than to simply change the case.
> 
> The point remains that I may want to use the same word
> in different cases to mean different things. The C
> example of upper case as the type and lower case as the
> object is an example. Ada says I can't do that. Why?
> Because having one English word mean two different things
> is confusing? But Ada already allows that. So it's an
> arbitrary decision made by people who don't like case
> sensitivity forcing their view on those who do.

Well, that last sentence is sort of silly.  *Every* rule of every
programming language is a decision made by people forcing their decision
on other people don't like that rule.  Call it an "arbitrary" rule, if
you like.  ;-)

Anyway, what lots of folks seem to be missing is that there are more
choices than "case sensitive" or "case insensitive".  The rule I favor
would be for overload resolution to be case insensitive, but to have an
extra legality rule saying you have to use the right case.  This is
essentially what you get if you use the GNAT switch that somebody
mentioned.  For example:

    procedure FOO(X: Integer);
    procedure Foo(X: Boolean);

    Foo(True);

would use types, and not case, to resolve which foo you're talking about
(the Boolean one).  But if you say:

    FOO(True); -- illegal

it would still resolve to the Boolean foo, but you get an error because
you spelled it with the wrong case.  FOO(123) would be OK.

If we further allow everything to be overloaded (not just subprograms,
and then bogusly pretend that enumeration literals are subprograms),
then your example:

    function Put(string: String);

would be fine.  Presumably, the "String" after ":" would resolve to the
type name in Standard, since that's what is expected after ":".  ("The
type of type is type.")

The case sensitive rule says you can declare "Foo: Integer; FOO: Integer;",
which is clearly confusing.  The case insenstive rule says you can't do
that, but you can declare "Foo: Integer;" and then refer to it as FOO,
which I think damages readability.  The more complicated rule I outlined
above solves *both* problems.

Somebody elsewhere in this thread denigrated this:

    function Put(string: String);

as being too "lazy" to come up with good names.  I don't agree.
We've had endless debates as to whether it should be "A_String: String"
versus "String: String_Type" and all kinds of other variations on
those.  But it seems to me that "string/String" is a perfectly good
name for a type, and for a parameter of that type.  A_String doesn't
help; it doesn't add any information (references make it obvious on
context).  And with this idea, case helps distinguish, but can never
confuse.  A language should not be about punishing programmers who are
too "lazy" to jump through hoops, but should be about aiding the writing
of readable code.

Many folks have advocated using more-descriptive names for the objects.
For example, City_Name instead of A_String.  That's of course a good
idea when there *is* a more descriptive name, but for general-purpose
parameters, it doesn't work.  Put takes *any* string; there is no
adjective such that Adj_String would aid understanding of the program.

Of course, neither the Ada rule nor the C rule is going to change.  (I'm
on the ARG, and I would certainly never vote for a grossly incompatible
language change!)  I just find it interesting to discuss better
alternatives.

- Bob

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Robert A Duff wrote:
> 
> Many folks have advocated using more-descriptive names for the objects.
> For example, City_Name instead of A_String.  That's of course a good
> idea when there *is* a more descriptive name, but for general-purpose
> parameters, it doesn't work.  Put takes *any* string; there is no
> adjective such that Adj_String would aid understanding of the program.

No, but neither do you need to use the word String in the first place :

   procedure Put(Item : in  String);

i would say English is quite rich in words and I don't see why one
cannot use them :-)

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Jean-Pierre Rosen wrote:
> So what? The identifier is overloaded in natural
 > language, and Ada just follows the natural language.

But I thought that Ada was supposed to value safety
and readability over many other considerations.
Shouldn't that be grounds for disallowing overloads?

But in any case, since Ada already allows one word
to have many meanings, what is wrong with allowing
the case of a word to matter? After all, as long as
my argument types were sufficiently varied, I could
create a package where every single method had the
same name. Of course that would be obfuscated, and so
it's my responsibility to use better names. But Ada
permits the obfuscation. In the same way, I could
create a package where case was used confusingly,
but I could also create a package where case was
used well and meaningfully. But in this case, Ada
refuses to let me do this. Therefore, I can only
conclude that this is a prejudice of the designers
rather than a legitimate design decision.

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

Hyman Rosen wrote:
> And *my* point is that while it may be a bad idea,
> Ada already allows it in the case of function
> overloading, including enumerators.

(FILE *file)

in my opinion is the _only_ reasonable use of
case sensitivity in a program.

In subprogram overloading, if the two same-named
functions do not do similar things, then it's probably
very poor design.

In enumerations, it doesn't happen very often,
but when it does, avoiding the disadvantage of
having to give something an illogical name to
avoid a collision is probably worth the need
to occasionally qualify it for the compiler.

The human reader has a greater talent at intuiting
meaning from context than the compiler, so confusion
is unlikely.

In the case of FILE *file; there is also no confusion,
but this is a style issue NOT enforced by the compiler.

Since I type more English than Ada or C, my mind is not
very talented at remembering that Position is not position,
and when a compiler "does me a favor" (as so many of them
do) by assuming the undeclared item is a function returning
int, .....

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> Many folks have advocated using more-descriptive names for the objects.
> For example, City_Name instead of A_String.  That's of course a good
> idea when there *is* a more descriptive name, but for general-purpose
> parameters, it doesn't work.  Put takes *any* string; there is no
> adjective such that Adj_String would aid understanding of the program.

Well, I've already said that FILE *file is the only place
I can justify case sensitivity, but even there I'd prefer
something more descriptive for the formal object.

As for vague names for general-purpose parameters, there
are usually alternatives.  A few examples:

 From    Item   Index
To      Str    Substring
Out_Of  Into   Result
Angle   ....

Note that I am trying to express the abstraction, i.e.,
what we are doing, rather than the implementation, i.e.,
what kind of data representation we are doing it with.

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> What about
> 
> |int File (FILE *file) { ... }

/* Files the FILE file in the appropriate directory,
    and returns the number of the directory */

??  :-)

Re: Case sensitivity (was Re: no title)

[Mike Silva]

Hyman Rosen <hyrosen@mail.com> wrote in message news:<1054649187.11497@master.nyc.kbcfp.com>...
> Jean-Pierre Rosen wrote:
> > In a high level language like Ada, which is directed to the human reader,
> > and identifier has a meaning in natural language.
> 
>      type color is ( red, green, blue );
>      type mood is ( cheerful, angry, blue );

GADFLY Hyman, hyman;  // work with me here! ;-)

int shoo_away( GADFLY g );

  shoo_away( Hyman );

Did the right GADFLY get shoo'ed away?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Mike Silva wrote:
> Did the right GADFLY get shoo'ed away?

I'm willing to accept Ada's case insensitivity
as long as you're willing to admit that there's
no reason for it :-)

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
news:wccznkzjcvc.fsf@shell01.TheWorld.com...
>     function Put(string: String);
>
> would be fine.  Presumably, the "String" after ":" would resolve to the
> type name in Standard, since that's what is expected after ":".  ("The
> type of type is type.")

I'd probably even allow

procedure Put (String : String);

(even though it will sound like too much a heresy :-))

Or are there places where it would be too confusing?

Sergey.

Re: Case sensitivity (was Re: no title)

[Robert A Duff]

"Sergey Koshcheyev" <serko84@hotmail.com> writes:

> "Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
> news:wccznkzjcvc.fsf@shell01.TheWorld.com...
> >     function Put(string: String);
> >
> > would be fine.  Presumably, the "String" after ":" would resolve to the
> > type name in Standard, since that's what is expected after ":".  ("The
> > type of type is type.")
> 
> I'd probably even allow
> 
> procedure Put (String : String);
> 
> (even though it will sound like too much a heresy :-))

I agree.  I'm an Ada advocate, and also a heretic.  ;-)

> Or are there places where it would be too confusing?

It could never be allowed in Ada, because we have things like
String'Last.  But in a different language, one could declare that
ambiguous.

In general, I think a good language-design principle should be:
anything that might be confused by the programmer should be illegal.

- Bob

Re: Case sensitivity (was Re: no title)

[Randy Brukardt]

Robert I. Eachus wrote in message <3EDCB918.8020905@attbi.com>...
>Preben Randhol wrote:
>
>> Sidenote: I heard recently on the radio that the reason it is called
>> upper case and lower case was that in the old bookprinting times (I
>> think it was from Guthenberg if I recall correctly) the capital
letters
>> were stored in the upper case (drawer) while the small letters where
>> stored in the lower case.  And from this the names came. Can anybody
>> comfirm this?
>
>Sure, when I was in high school my brother and I earned our spending
>money running a printing business.  We bought the press and equipment
>(including over 150 drawers of type) from a widow whose husband had
been
>running a printing business out of the basement of her home.  She
wanted
>to sell the house, but needed to get all of that stuff out of the
basement.
>
>The press and type drawers still exist, as a 'living museum' at Eckerd
>College in Saint Petersburg, FL.  You know you are old when they start
>putting your things in a museum!


My Dad had a small printing press when he was young, which I sent up in
my parents basement and used some in my teenage years. It had a number
of type fonts as well. It still exists - in my parents basement.

In any case (pun intended), the standard type drawer layout had the
upper case in small bins on the left, and lower case in larger bins (of
different sizes, with 'e' being the largest) on the right. (Or is it the
other way around?) But that layout may be a relatively recent invention
(early 19th century?).

                       Randy.

Re: Case sensitivity (was Re: no title)

[James Rogers]

Hyman Rosen <hyrosen@mail.com> wrote in 
news:1054651042.211055@master.nyc.kbcfp.com:

> Preben Randhol wrote:
>> It is far easier to rather better to use different
> > words than to simply change the case.
> 
> The point remains that I may want to use the same word
> in different cases to mean different things. The C
> example of upper case as the type and lower case as the
> object is an example. Ada says I can't do that. Why?
> Because having one English word mean two different things
> is confusing? But Ada already allows that. So it's an
> arbitrary decision made by people who don't like case
> sensitivity forcing their view on those who do.

In English the meaning of words does not change because of
case. Look at the poetry of e.e.milne (his spelling, not mine).

English does have capitalization conventions, but none of those
conventions change the meaning of a word. In this sense English
is case insensitive. Is the meaining of the word "is" different
when the first letter is upper case?

Jim Rogers

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> is case insensitive. Is the meaining of the word "is" different
> when the first letter is upper case?

That depends on what the meaning of 'is' is.

Couldn't resist.....

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

James Rogers wrote:
> In English the meaning of words does not change because of case.

That is not true, since English encompasses proper nouns.
The words "Polish" and "polish" are quite different. Also,
written English, especially technical writing, can include
capitalized acronyms which mean something different than
the equivalent lower case word. And do I have to remind
you how often people on this newsgroup complain when they
see someone refer to ADA instead of Ada?

Re: Case sensitivity (was Re: no title)

[Ole-Hjalmar Kristensen]

Hyman Rosen <hyrosen@mail.com> writes:

> John R. Strohm wrote:
>  > Making the language case-insensitive fixes that problem,
> > by preventing it from ever occurring.
> 
> You might be right if the language were case-insensitive,
> but it isn't. Character and string literals are sensitive
> to case. It's only identifiers which ignore case. So your
> hypothetical mainframe environment couldn't handle
>      Put("Hello, world!");
> 
> And speaking of such primitive environments, I started
> programming in college on a very early UNIX system on a
> PDP-11 using uppercase-only terminals that used rolls of
> paper, not display screens. The drivers translated all
> input to lower case internally, and if you wanted upper
> case, you escaped the letter with a backslash. The system
> would then print such actual upper case letters with a
> backslash prefix. So it was certainly possible to use
> mixed case even on such a platform.
> 

Try that with Univac fieldata on punched cards :-)
It was actually a nice system to program on...

-- 
Ole-Hj. Kristensen

******************************************************************************
* You cannot consistently believe this sentence.
******************************************************************************

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Mike Silva wrote:
>> Did the right GADFLY get shoo'ed away?
> 
> I'm willing to accept Ada's case insensitivity
> as long as you're willing to admit that there's
> no reason for it :-)

Of course there is reasons for it as have been itterated over and over.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Wesley Groleau wrote:
> 
>> is case insensitive. Is the meaining of the word "is" different
>> when the first letter is upper case?
> 
> That depends on what the meaning of 'is' is.

In Norwegian is means ice (or ice-cream although that is really iskrem)
;-) Maybe computer languages should be language-sensitive too ;-)

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <0egDa.45243$fT5.9340@nwrdny01.gnilink.net>, Hyman Rosen <hyrosen@mail.com> writes:
> James Rogers wrote:
>> In English the meaning of words does not change because of case.
> 
> That is not true, since English encompasses proper nouns.
> The words "Polish" and "polish" are quite different. Also,
> written English, especially technical writing, can include
> capitalized acronyms which mean something different than
> the equivalent lower case word. And do I have to remind
> you how often people on this newsgroup complain when they
> see someone refer to ADA instead of Ada?

But those complaints are stylistic, not because there was a lack of
understanding of what is meant.  Local rules about capitalization
can be applied, just as local rules about indenting or local rules
about the positioning, style or presence(!) of comments.  None of
these affect the correctness of the program, and the manner in which
they affect the maintainability of the program is a matter for local
decisionmaking.

Re: Case sensitivity (was Re: no title)

[Jim Rogers]

Hyman Rosen <hyrosen@mail.com> wrote in message news:<0egDa.45243$fT5.9340@nwrdny01.gnilink.net>...
> James Rogers wrote:
> > In English the meaning of words does not change because of case.
> 
> That is not true, since English encompasses proper nouns.
> The words "Polish" and "polish" are quite different. Also,
> written English, especially technical writing, can include
> capitalized acronyms which mean something different than
> the equivalent lower case word. And do I have to remind
> you how often people on this newsgroup complain when they
> see someone refer to ADA instead of Ada?

Besides "Polish" and "polish" you will find few exceptions.
Strictly speaking, acronyms are not English. They are technical
terms relating to a narrow discipline. The basic linguistic
structure of English is the word. Acronyms are not words.
Acronyms are abbreviations for phrases.

The exception you mentioned for "Polish" and "polish" has some
interesting roots. Historically speaking, English develops 
primarily as a spoken language. In fact, until the 19th Century
there was no standardized spelling for English. Andrew Jackson
is quoted as saying "I don't give a damn for a man who cannot
spell a word at least two different ways." The result is that
English has very inconsistent spelling rules. When Webster published
his dictionary he somewhat arbitrarily chose spelling for words.
He did not first develop a consistent set of spelling rules. Note
that different dialects of English still disagree on spelling.
In England "organisation" is spelled differently than in the
United States ("organization").

Jim Rogers

Re: Case sensitivity (was Re: no title)

[Leif Roar Moldskred]

Hyman Rosen <hyrosen@mail.com> writes:

> James Rogers wrote:
> > In English the meaning of words does not change because of case.
> 
> That is not true, since English encompasses proper nouns.
> The words "Polish" and "polish" are quite different. 

Except that "polish" can also be written "Polish" in some cases - note
the difference in meaning between the two "Polish" below.

"Polish the silverware, please."
"Polish imports of silverware has increased."

Also, it's not the capital "P" that sets the meaning of the word
"Polish", but the context. In the sentence below the correct meaning
of the word "Polish" is read even when it's written in the wrong case.

"The polish silverware"


-- 
Leif Roar Moldskred

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> Of course there is reasons for it as have been itterated over and over.

People are certainly repeating reasons over and over,
nut I haven't seen any that hold water. The one that
seems to appear most often is that a word should mean
the same thing regardless of its case, because that
mimics natural language. That fails on two grounds,
first that in natural language, case does affect
meaning (eg., polish vs. Polish, Ada vs. ADA), and
second that in Ada, one word may be overloaded to
have several meanings.

Another reason claimed that Ada was designed so that
it could be developed in environments that didn't
support lower case development, but that fails since
Ada programs can contain lower-case string and character
literals which must be preserved.

The only legitimate reason I've seen is that insensitivity
to case allows people to alter the case of identifiers to
conform to local conventions regardless of how they are
declared in their source packages, in the same way that they
can change formatting conventions. It can be argued as to
how much of a benefit this actually is, but if this kind of
thing is allowed, Ada should also support the sprinkling of
underscores into identifiers without changing their meaning,
just as it does for numbers.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Jim Rogers wrote:
> Strictly speaking, acronyms are not English. They are technical
> terms relating to a narrow discipline.

And programs are full of technical terms relating to the
narrow discipline in which they are working. So you make
my point for me.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Preben Randhol wrote:
>> Of course there is reasons for it as have been itterated over and over.
> 
> People are certainly repeating reasons over and over,
> nut I haven't seen any that hold water. 

Well that is your view. I find that case sensitivity increases bugs a
very compelling reason.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> I find that case sensitivity increases bugs a
> very compelling reason.

How does case sensitivity increase bugs? In a case
sensitive language, if you use one case and the
name was declared with a different case, your code
will not compile. If two names differ only in case,
and, say, one names a type and the other an object,
the code will again fail to compile if you switch
them. I suppose if someone deliberately went out of
their way to create obfuscated code, it could cause
errors, but then you can do the same in Ada by using
a mix of names like a01, aO1, a0l, and aOl.

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <1054735867.264510@master.nyc.kbcfp.com>, Hyman Rosen <hyrosen@mail.com> writes:
> Preben Randhol wrote:
>> Of course there is reasons for it as have been itterated over and over.
> 
> People are certainly repeating reasons over and over,
> nut I haven't seen any that hold water. The one that
> seems to appear most often is that a word should mean
> the same thing regardless of its case, because that
> mimics natural language. That fails on two grounds,
> first that in natural language, case does affect
> meaning (eg., polish vs. Polish, Ada vs. ADA), and
> second that in Ada, one word may be overloaded to
> have several meanings.

Hyman, I think you win the prize for repeating over and over in this topic :-)

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Preben Randhol wrote:
>> I find that case sensitivity increases bugs a
>> very compelling reason.
> 
> How does case sensitivity increase bugs? 

If you read previous posts you will see.

> If two names differ only in case,
> and, say, one names a type and the other an object,

No, no and. They differ only in case, what then?

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

RE: Case sensitivity (was Re: no title)

[Lionel.DRAGHI]

| -----Message d'origine-----
| De: Hyman Rosen [mailto:hyrosen@mail.com]
...
| How does case sensitivity increase bugs?
Take a look at the unmaintanable code howto. Some of the funny code
obfuscation examples use case sensitivity.

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <eisner.encompasserve.org comp.lang.ada:101490>, Hyman Rosen <hyrosen@mail.com> writes:

> How does case sensitivity increase bugs? In a case
> sensitive language, if you use one case and the
> name was declared with a different case, your code
> will not compile. If two names differ only in case,
> and, say, one names a type and the other an object,
> the code will again fail to compile if you switch
> them.

But if they do _not_ have that difference, the code might compile.

    declare
        Index : integer := 27;
    begin
        for index in my_array'range loop
            if my_array ( Index ) > current_maximum
            then
                current_maximum := my_array ( index );
                Index := index;
            end if;
        end loop;
    end;

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
>>How does case sensitivity increase bugs? 
> If you read previous posts you will see.

OK, I went back and read the previous posts. I found exactly one
post, by Booby D. Bryant, who claimed that "a large proportion
of the bugs I've fixed in my whole life were the result of people
using identifiers with the wrong case". There were no examples,
so it's hard to evaluate how typical this might be.

Then there was one post by you, giving an example of how you
might call the wrong routine if two different packages had a
method with the same spelling but different case, and the same
argument types, whereas currently, you would be required to
disambiguate by specifying the package name. I find that less
than compelling as well - what prevents you from specifying
the wrong package, after all?

>>If two names differ only in case,
>>and, say, one names a type and the other an object,
> 
> No, no and. They differ only in case, what then?

Then you have to know which one you want, and use it.
If you have objects named L00P and LOOP, you are in
the same position. But it's an odd situation to have
things of the same sort that differ only in case. It's
very seldom that I see anything like that, and I program
mostly in case sensitive languages.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Then you have to know which one you want, and use it.

QED.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Larry Kilgallen wrote:
> But if they do _not_ have that difference, the code might compile.
> 
>     declare
>         Index : integer := 27;
>     begin
>         for index in my_array'range loop
>             if my_array ( Index ) > current_maximum
>             then
>                 current_maximum := my_array ( index );
>                 Index := index;
>             end if;
>         end loop;
>     end;

If I'm not mistaken, the following code *does* compile.

     for index in my_array'range loop
         declare
             Index : integer := 27;
         begin
             if my_array ( Index ) > current_maximum
             then
                 current_maximum := my_array ( index );
                 Index := index;
             end if;
         end;
     end loop;

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> Hyman Rosen wrote:
>>Then you have to know which one you want, and use it.
> QED.

I didn't realize that knowing which variable you want
to use is a cardinal sin. In your own example of
A.GetString versus B.getstring, you will have to know
whether you want A or B, after all. And if it was
A.Get_String and B.GetString, case insensitivity
wouldn't help at all.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Lionel.DRAGHI@fr.thalesgroup.com wrote:
 > Some of the funny code obfuscation examples
 > use case sensitivity.

Deliberately bad code is hardly a justification.

But since we've been arguing about readability
and English usage and so on, what is the reason
for allowing digits in identifiers? After all,
until 133t-speak emerged, natural language did
not use digits in words, and that would prevent
confusion between 0 and O and 1 and l.

Re: Case sensitivity (was Re: no title)

[Jim Rogers]

Hyman Rosen <hyrosen@mail.com> wrote in message news:<1054736576.85233@master.nyc.kbcfp.com>...
> Jim Rogers wrote:
> > Strictly speaking, acronyms are not English. They are technical
> > terms relating to a narrow discipline.
> 
> And programs are full of technical terms relating to the
> narrow discipline in which they are working. So you make
> my point for me.

I do not see how this makes your point.
Most acronyms are commonly used with only upper case 
notation. For instance, one I am dealing with is AFSCN.
There is no acronym in the same domain with the same
letters but a different mixture of case.

For such acronyms case sensitivity is no advantage, since
AFSCN and afScn must refer to the same acronym. The use of
upper case is a convention rather than a requirement.

Making a case-sensitive distinction between AFSCN and afScn
would only compound confusion. 

In an Ada program I would expect values corresponding to an
acronym to be defined as enumeration values. Variables should
not be named after an acronym. Acronyms have a constant value.
Variables have variable values. Acronyms map more correctly to
enumeration values in Ada and C++, or constants in either language,
than to variables.

Is it considered good style to have functions with the following
names all in the same C++ program: 
  Main
  MAIN
  mAin
  MaIn

I do not believe this is considered a good coding style. Why not?
It takes full advantage of case sensitivity, which C and C++ deem
good. The problem is that the function "main" has a very special
role in a C or C++ program. Similarly named functions can be
confusing to the maintainer of the program. Of course, the compiler
has no problem distinguishing between the different symbols.
Coding style issues always deal with problems for the reader and
maintainer of the code. 

Case sensitivity was left out of Ada to prevent the kind of
overloading of symbols that causes clear confusion. Common Ada
development environments will enforce case consistency for
neatness. The difference between this and requiring case
sensitivity is that in Ada this is merely a coding style issue.
In C++ it becomes a coding style and syntax issue. The compiler
may have a different opinion of the meaning of an identifier than
does the human reader of the code. Such differences of opinion
can be problematic.

Jim Rogers

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Jim Rogers wrote:
> In an Ada program I would expect values corresponding to an
> acronym to be defined as enumeration values. Variables should
> not be named after an acronym. Acronyms have a constant value.
> Variables have variable values. Acronyms map more correctly to
> enumeration values in Ada and C++, or constants in either language,
> than to variables.

If my Iraq-bound bomber has a single very large explosive device
on it, I don't see any reason why the type describing that device
shouldn't be called 'MOAB' and why its single instance object
shouldn't be called 'moab'.

If I'm serializing some objects to a file, I don't see why I
shouldn't do
     enum { SNAP, CRACKLE, POP };
     void serialize(stream &o, const Snap &v)    { o << SNAP    << v; }
     void serialize(stream &o, const Crackle &v) { o << CRACKLE << v; }
     void serialize(stream &o, const Pop &v)     { o << POP     << v; }

> It takes full advantage of case sensitivity, which C and C++ deem good.

We want to take advantage of case sensitivity in a good way,
using the commonality of spelling but the distinction of case
as a way of communicating with the reader of the code. Ada
cannot mandate a good choice of names, but has prevented a
potential good choice of names on the grounds of trying to
eliminate one small set of possible bad choices. I don't buy
that argument at all.


> The compiler may have a different opinion of the meaning of an
 > identifier than does the human reader of the code. Such differences
 > of opinion can be problematic.

But that happens as soon as any overloading, or even hiding,
is allowed.

Re: Case sensitivity (was Re: no title)

[David C. Hoos]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1054756824.267420@master.nyc.kbcfp.com...
> Jim Rogers wrote:
> > In an Ada program I would expect values corresponding to an
> > acronym to be defined as enumeration values. Variables should
> > not be named after an acronym. Acronyms have a constant value.
> > Variables have variable values. Acronyms map more correctly to
> > enumeration values in Ada and C++, or constants in either language,
> > than to variables.
>
> If my Iraq-bound bomber has a single very large explosive device
> on it, I don't see any reason why the type describing that device
> shouldn't be called 'MOAB' and why its single instance object
> shouldn't be called 'moab'.
>
> If I'm serializing some objects to a file, I don't see why I
> shouldn't do
>      enum { SNAP, CRACKLE, POP };
>      void serialize(stream &o, const Snap &v)    { o << SNAP    << v; }
>      void serialize(stream &o, const Crackle &v) { o << CRACKLE << v; }
>      void serialize(stream &o, const Pop &v)     { o << POP     << v; }
>
> > It takes full advantage of case sensitivity, which C and C++ deem good.
>
> We want to take advantage of case sensitivity in a good way,
> using the commonality of spelling but the distinction of case
> as a way of communicating with the reader of the code. Ada
> cannot mandate a good choice of names, but has prevented a
> potential good choice of names on the grounds of trying to
> eliminate one small set of possible bad choices. I don't buy
> that argument at all.

Well, the EPA, the CDC, et al. mandate the elimination of "a small set of
bad" molecules (e.g. small being on the oder of parts per billion or parts
per million), in our food, drink, and air, so where people's lives are at
stake,
many programmers (I, for one) do "buy that argument."

>
>
> > The compiler may have a different opinion of the meaning of an
>  > identifier than does the human reader of the code. Such differences
>  > of opinion can be problematic.
>
> But that happens as soon as any overloading, or even hiding,
> is allowed.
>
> _______________________________________________
> comp.lang.ada mailing list
> comp.lang.ada@ada.eu.org
> http://ada.eu.org/mailman/listinfo/comp.lang.ada
>

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

David C. Hoos wrote:
> Well, the EPA, the CDC, et al. mandate the elimination of "a small set of
> bad" molecules (e.g. small being on the oder of parts per billion or parts
> per million), in our food, drink, and air, so where people's lives are at
> stake, many programmers (I, for one) do "buy that argument."

Your analogy is in error. If we're going to make chemical
analogies, then I might compare this to medical marijuana,
where the government has outlawed all uses of a substance
despite arguments that it may have medical benefits (and
is fun to use :-)

Re: Case sensitivity (was Re: no title)

[Simon Wright]

jimmaureenrogers@worldnet.att.net (Jim Rogers) writes:

> I do not see how this makes your point.
> Most acronyms are commonly used with only upper case 
> notation. For instance, one I am dealing with is AFSCN.

I wish this were so here. The UK press has decided that if an acronym
is pronounceable it is to be spelt with title case (eg, Department for
Environment, Food & Rural Affairs => Defra).

My wife points out that there is a strong historical precedent in
Radar, but I don't have to like it!

Re: Case sensitivity (was Re: no title)

[Mike Silva]

Kilgallen@SpamCop.net (Larry Kilgallen) wrote in message news:<biijN$2Wg7Lp@eisner.encompasserve.org>...
> In article <1054735867.264510@master.nyc.kbcfp.com>, Hyman Rosen <hyrosen@mail.com> writes:
> > Preben Randhol wrote:
> >> Of course there is reasons for it as have been itterated over and over.
> > 
> > People are certainly repeating reasons over and over,
> > nut I haven't seen any that hold water. The one that
> > seems to appear most often is that a word should mean
> > the same thing regardless of its case, because that
> > mimics natural language. That fails on two grounds,
> > first that in natural language, case does affect
> > meaning (eg., polish vs. Polish, Ada vs. ADA), and
> > second that in Ada, one word may be overloaded to
> > have several meanings.
> 
> Hyman, I think you win the prize for repeating over and over in this topic :-)

Or did you mean over and Over and ovEr and oVeR and... :-)

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> We want to take advantage of case sensitivity in a good way,
> using the commonality of spelling but the distinction of case
> as a way of communicating with the reader of the code. Ada

My grandfather used to say, "It's the same thing, only different."

Re: Case sensitivity (was Re: no title)

[Robert I. Eachus]

Randy Brukardt wrote:

> My Dad had a small printing press when he was young, which I sent up in
> my parents basement and used some in my teenage years. It had a number
> of type fonts as well. It still exists - in my parents basement.

Well if you ever want to get rid of it in exchange for a tax deduction, 
now you know how.

> In any case (pun intended), the standard type drawer layout had the
> upper case in small bins on the left, and lower case in larger bins (of
> different sizes, with 'e' being the largest) on the right. (Or is it the
> other way around?) But that layout may be a relatively recent invention
> (early 19th century?).

No, that it the right way around for triple-width cases.  Lower case e 
was the largest bin, just to the right of the right full divider.  (Type 
was made of a lead alloy and was heavy, so the type cases need dividers 
from the front to the back of the drawer so they didn't sag in the middle.)

We had several type cases with around 24 double with drawers, they 
usually had lower case and small caps in one drawer, and lower case in 
another, with racks on top to support two drawers.  With around a dozen 
different type cases we could and did pull out all of the drawers we 
needed for a job, put them on top of various cases, grab a compositor's 
stick and start setting type.  I couldn't set type as fast as I can 
type, but even a full page of text only took a couple hours. (And if it 
had some mathematical formulas in it that was a nice break, when you 
went looking for the right Greek font, then had to remember the Greek 
alphabet to know where to look for say a rho.

RE: Case sensitivity (was Re: no title)

[Lionel.DRAGHI]

| -----Message d'origine-----
| De: Hyman Rosen [mailto:hyrosen@mail.com]
...
| 
| Lionel.DRAGHI@fr.thalesgroup.com wrote:
|  > Some of the funny code obfuscation examples
|  > use case sensitivity.
| 
| Deliberately bad code is hardly a justification.

Deliberately or not, those bugs are just impossible in Ada.

Except for upward compatibility with C, and fortunatly this doesn't apply to
Ada, case sensitivity has no Pros, just Cons. 
Why on earth would you waste your time evaluating the Cons?

-- 
Lionel

RE: Case sensitivity (was Re: no title)

[Lionel.DRAGHI]

| -----Message d'origine-----
| De: Hyman Rosen [mailto:hyrosen@mail.com]
...
| 
| We want to take advantage of case sensitivity in a good way,
| using the commonality of spelling but the distinction of case
| as a way of communicating with the reader of the code. Ada
| cannot mandate a good choice of names, but has prevented a
| potential good choice of names on the grounds of trying to
| eliminate one small set of possible bad choices.
Your code example is pretty, but using different names instead of different
casing is as easy and less error prone.
So, Ada has prevented an always bad choice. 

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Lionel.DRAGHI@fr.thalesgroup.com wrote:
> case sensitivity has no Pros, just Cons.

As I said, it's clear to me that case insensitivity
is simply a prejudice of the language designers that
was forced upon all the users.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Lionel.DRAGHI@fr.thalesgroup.com wrote:
> Your code example is pretty, but using different names
 > instead of different casing is as easy and less error prone.

If that were the case, then overloading would not be legal.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Lionel.DRAGHI@fr.thalesgroup.com wrote:
>> case sensitivity has no Pros, just Cons.
> 
> As I said, it's clear to me that case insensitivity
> is simply a prejudice of the language designers that
> was forced upon all the users.
> 

Whatever

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <1054822431.105080@master.nyc.kbcfp.com>, Hyman Rosen <hyrosen@mail.com> writes:
> Lionel.DRAGHI@fr.thalesgroup.com wrote:
>> case sensitivity has no Pros, just Cons.
> 
> As I said, it's clear to me that case insensitivity
> is simply a prejudice of the language designers that
> was forced upon all the users.

In the same way that case sensitivity was forced on the C* users
as a prejudice of the language designers.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Larry Kilgallen wrote:
> In article <1054822431.105080@master.nyc.kbcfp.com>, Hyman Rosen <hyrosen@mail.com> writes:
>> Lionel.DRAGHI@fr.thalesgroup.com wrote:
>>> case sensitivity has no Pros, just Cons.
>> 
>> As I said, it's clear to me that case insensitivity
>> is simply a prejudice of the language designers that
>> was forced upon all the users.
> 
> In the same way that case sensitivity was forced on the C* users
> as a prejudice of the language designers.

Not to forget that C* programmers wants a design where they are free to
make as many bugs as possible.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Sergey Koshcheyev]

"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnbdupj6.88r.randhol+abuse@kiuk0152.chembio.ntnu.no...
> Larry Kilgallen wrote:
> > In article <1054822431.105080@master.nyc.kbcfp.com>, Hyman Rosen
<hyrosen@mail.com> writes:
> >> Lionel.DRAGHI@fr.thalesgroup.com wrote:
> >>> case sensitivity has no Pros, just Cons.
> >>
> >> As I said, it's clear to me that case insensitivity
> >> is simply a prejudice of the language designers that
> >> was forced upon all the users.
> >
> > In the same way that case sensitivity was forced on the C* users
> > as a prejudice of the language designers.
>
> Not to forget that C* programmers wants a design where they are free to
> make as many bugs as possible.

Oh, I believe this is called an ad hominem attack. How about some arguments
instead of "whatever"?

Sergey.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Larry Kilgallen wrote:
> In the same way that case sensitivity was forced on the C* users
> as a prejudice of the language designers.

Sure. Anyway, I finally remembered that Pascal is case-insensitive,
so it makes sense that Ada is as well, just for that.

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <1054830968.330764@master.nyc.kbcfp.com>, Hyman Rosen <hyrosen@mail.com> writes:
> Larry Kilgallen wrote:
>> In the same way that case sensitivity was forced on the C* users
>> as a prejudice of the language designers.
> 
> Sure. Anyway, I finally remembered that Pascal is case-insensitive,
> so it makes sense that Ada is as well, just for that.

From my perspective, the command language for my operating system is
case-blind, so it makes sense.

Obviously Unix fans would feel differently.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Sergey Koshcheyev wrote:
> Oh, I believe this is called an ad hominem attack. How about some arguments
> instead of "whatever"?

Seeze how many times do one have to present the same arguments?

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Larry Kilgallen wrote:
> Obviously Unix fans would feel differently.

I don't :-)

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Stephen Leake]

Hyman Rosen <hyrosen@mail.com> writes:

> If I'm not mistaken, the following code *does* compile.
> 
>      for index in my_array'range loop
>          declare
>              Index : integer := 27;
>          begin
>              if my_array ( Index ) > current_maximum
>              then
>                  current_maximum := my_array ( index );
>                  Index := index;
>              end if;
>          end;
>      end loop;

Yes, it does, and it has a bug. If the language was not
case-sensitive, the bug would be easier to see.

-- 
-- Stephe

Re: Case sensitivity (was Re: no title)

[Stephen Leake]

Simon Wright <simon@pushface.org> writes:

> jimmaureenrogers@worldnet.att.net (Jim Rogers) writes:
> 
> > I do not see how this makes your point.
> > Most acronyms are commonly used with only upper case 
> > notation. For instance, one I am dealing with is AFSCN.
> 
> I wish this were so here. The UK press has decided that if an acronym
> is pronounceable it is to be spelt with title case (eg, Department for
> Environment, Food & Rural Affairs => Defra).

which is why case sensitivity is bad :).

> My wife points out that there is a strong historical precedent in
> Radar, but I don't have to like it!

In that case, the acronym became a word. I would normally not
capitalize it: " the radar shows rain in the northeast".

-- 
-- Stephe

Re: Case sensitivity (was Re: no title)

[Larry Hazel]

Robert C. Leif wrote:
> My experience with XML, which is case sensitive, has convinced me that case
> sensitivity is one of the worst possible changes for Ada. The case
> sensitivity of XML has caused me to waste very large amounts of time. Bill
> Gates' one major contribution to software engineering was that he made DOS
> case insensitive. I believe that one of the major problems with the POSIX
> family of operating systems is case sensitivity. Case sensitivity is
> definitely a significant contributor to user hostility.
> Bob Leif
> 
pragma (Case Sensitive)
...
...
...
pragma (Case Insensitive)

Maybe 2 or 3 programmers would ever use it, but everybody would be happy.

Larry

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> Except for upward compatibility with C, and fortunatly this doesn't apply to
> Ada, case sensitivity has no Pros, just Cons. 

Although I certainly think the "cons" FAR outweigh
the "pros," there are some pros, and they have been
discussed.

Here's another:

  Case sensitivity means fewer CPU cycles for searching
  symbol tables and source files for a particular string.
  And less memory use for code and lookup tables to support
  case-folding.

Certainly a foolish trade-off today, but a concern at one time.

Re: Case sensitivity (was Re: no title)

[Stephen Leake]

Lionel.DRAGHI@fr.thalesgroup.com writes:

> Your code example is pretty, but using different names instead of different
> casing is as easy and less error prone.

Actually, making up good names for types and objects is a problem in
Ada. Some of us solve it by always appending _Type to type names:

type List_Type is ...

procedure Foo (List : in List_Type);

Some people don't like the _Type, and do something else:

type Lists is ...

procedure Foo (List : in Lists);

In a case sensitive language, this could be:

type List is ...

procedure Foo (list : in List);

I think that's a legitimate argument for case sensitivity. However, I
don't think it has as much weight as all the arguments on the other
side. I also think using Lists and List is just as bad!

> So, Ada has prevented an always bad choice.

I think that's too strongly worded. The issue is not black and white,
but shades of grey.

-- 
-- Stephe

Re: Case sensitivity (was Re: no title)

[Stephen Leake]

Hyman Rosen <hyrosen@mail.com> writes:

> Lionel.DRAGHI@fr.thalesgroup.com wrote:
> > Your code example is pretty, but using different names
>  > instead of different casing is as easy and less error prone.
> 
> If that were the case, then overloading would not be legal.

Too strongly worded. There are many enormous advantages to allowing
overloading, and the Ada team judged that they outweighed the
disadvantage of sometimes being confusing.

I certainly have an informal coding standard that says "don't name a
procedure 'Get' if it acts like 'Put'". But that doesn't mean I don't
want overloading.

For case sensitivity, there is a similar tradeoff; in this case, the
Ada team decided not to have case sensitivity.

In both cases, I agree with the choices, which is one of the reasons I
like Ada.

-- 
-- Stephe

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Stephen Leake wrote:
> Yes, it does, and it has a bug. If the language was not
> case-sensitive, the bug would be easier to see.

Huh? The language is Ada!

Re: Case sensitivity (was Re: no title)

[Larry Kilgallen]

In article <ullwgh20s.fsf@nasa.gov>, Stephen Leake <Stephe.Leake@nasa.gov> writes:
> Hyman Rosen <hyrosen@mail.com> writes:
> 
>> If I'm not mistaken, the following code *does* compile.
>> 
>>      for index in my_array'range loop
>>          declare
>>              Index : integer := 27;
>>          begin
>>              if my_array ( Index ) > current_maximum
>>              then
>>                  current_maximum := my_array ( index );
>>                  Index := index;
>>              end if;
>>          end;
>>      end loop;
> 
> Yes, it does, and it has a bug. If the language was not
> case-sensitive, the bug would be easier to see.

But mainly since the language is case-blind, programmers are not
tempted to declare multiple objects (explicit or implicit) with
such easily confused names.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Robert C. Leif wrote:
> The case sensitivity of XML has caused me
 > to waste very large amounts of time.

I'm curious. How? Is it just that you're mistyping
words in the wrong case?

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> I think that's a legitimate argument for case sensitivity. However, I
> don't think it has as much weight as all the arguments on the other
> side. I also think using Lists and List is just as bad!

I was once forced to read a two-inch thick user's manual for
a system that had two modes of operation.  Almost all commands
or operations behaved differently depending on the mode.

The manual was printed in all upper case
with poor print quality.  The names of the modes were:

EXECUTION
EXECUTIVE

Now THAT is a readability issue !  :-)

Re: Case sensitivity (was Re: no title)

[James Rogers]

Stephen Leake <Stephe.Leake@nasa.gov> wrote in news:ullwgh20s.fsf@nasa.gov:

> Hyman Rosen <hyrosen@mail.com> writes:
> 
>> If I'm not mistaken, the following code *does* compile.
>> 
>>      for index in my_array'range loop
>>          declare
>>              Index : integer := 27;
>>          begin
>>              if my_array ( Index ) > current_maximum
>>              then
>>                  current_maximum := my_array ( index );
>>                  Index := index;
>>              end if;
>>          end;
>>      end loop;
> 
> Yes, it does, and it has a bug. If the language was not
> case-sensitive, the bug would be easier to see.
> 

When I place this snippet into a real program I do get a clean
compile. The program does generate an exception at run time on
the first loop iteration.

with Ada.Text_Io;
use Ada.Text_Io;
procedure Badloop is 
   type Foo_Array is array (1 .. 10) of Integer; 
   My_Array        : Foo_Array := (10, 9, 8, 7, 6, 5, 4, 3, 2, 1);  
   Current_Maximum : Integer   := 1;  
begin
   for Index in My_Array'range loop
      declare
         Index : Integer := 27;  
      begin
         if My_Array ( Index ) > Current_Maximum
               then
            Current_Maximum := My_Array ( Index );
            Index := Index;
         end if;
      end;
   end loop;
   Put_Line("Current_Maximum:" & Integer'Image(Current_Maximum));
end Badloop;
    
Note that the above bad code is not solved by making your
language case sensitive.

A C example:

for(i = 0; i < 9; ++i) {
   int i = 27;
   if (My_Array[i] > currentMaximum) {
      currentMaximum = My_Array[i];
      i = i;
   }
{

The C compiler will compile this program without error.
The difference is that the C compiler will allow you to
access beyond the end of the array with no complaints.
In fact, this program will run for an at least one full
iteration, and possibly more. 

Ada still ends up being safer than C because it prevents
array bounds violations at run-time.

Jim Rogers

Re: Case sensitivity (was Re: no title)

[Simon Wright]

James Rogers <jimmaureenrogers@att.net> writes:

> When I place this snippet into a real program I do get a clean
> compile. The program does generate an exception at run time on
> the first loop iteration.
> 
> with Ada.Text_Io;
> use Ada.Text_Io;
> procedure Badloop is 
>    type Foo_Array is array (1 .. 10) of Integer; 
>    My_Array        : Foo_Array := (10, 9, 8, 7, 6, 5, 4, 3, 2, 1);  
>    Current_Maximum : Integer   := 1;  
> begin
>    for Index in My_Array'range loop
>       declare
>          Index : Integer := 27;  
>       begin
>          if My_Array ( Index ) > Current_Maximum
>                then
>             Current_Maximum := My_Array ( Index );
>             Index := Index;
>          end if;
>       end;
>    end loop;
>    Put_Line("Current_Maximum:" & Integer'Image(Current_Maximum));
> end Badloop;

GNAT 3.16a says (-gnatwaL => all warnings except elaboration order):

   smaug[60]$ gnatmake -g -O2 -gnatwaL badloop
   gcc -c -g -O2 -gnatwaL badloop.adb
   badloop.adb:5:04: warning: "My_Array" is not modified, could be declared constant
   badloop.adb:12:24: warning: value not in range of subtype of "Standard.Integer" defined at line 4
   badloop.adb:12:24: warning: "Constraint_Error" will be raised at run time
   badloop.adb:14:43: warning: value not in range of subtype of "Standard.Integer" defined at line 4
   badloop.adb:14:43: warning: "Constraint_Error" will be raised at run time
   badloop.adb:15:19: warning: useless assignment of "Index" to itself
   gnatbind -x badloop.ali
   gnatlink badloop.ali -g
   smaug[61]$ ./badloop

   raised CONSTRAINT_ERROR : badloop.adb:12 range check failed

without -gnatwaL, the first and last warnings are omitted.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Simon Wright wrote:
> 
> without -gnatwaL, the first and last warnings are omitted.

and with -gnaty switch (for Gnat 3.14p)


% gnatmake -gnaty badloop.adb 
gnatgcc -c -gnaty badloop.adb
badloop.adb:1:16: (style) bad casing of "Text_IO" declared at a-textio.ads:51
badloop.adb:2:15: (style) bad casing of "Text_IO" declared at a-textio.ads:51
badloop.adb:8:26: (style) bad capitalization, mixed case required
badloop.adb:12:23: (style) space not allowed
badloop.adb:13:16: (style) this token should be in column 10
badloop.adb:14:42: (style) space not allowed
badloop.adb:19:12: (style) space required
gnatbind -x badloop.ali
gnatlink badloop.ali

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[AG]

"Sergey Koshcheyev" <serko84@hotmail.com> wrote in message
news:bbf9kl$7kt$1@ns.felk.cvut.cz...
>
> "Preben Randhol" <randhol+abuse@pvv.org> wrote in message
> news:slrnbdm1i7.1k5.randhol+abuse@kiuk0152.chembio.ntnu.no...
> > Case SenSitIvitY is a bAD ThiNg IMHO. It reduces readability as you need
> > to be sure you spelt it correctly according to the definition. One could
> > in fact have a GetString and getstring and Getstring and
> > getString procedure.
>
> IMHO, case sensitivity would help ensure consistency of names, so you
don't
> have Text_IO, Text_Io, text_io and TEXT_IO in the same program

Say what ???

In the absence of case sensitivity those are all the same.

And they are, aint they? :-)

Re: Case sensitivity (was Re: no title)

[AG]

"Arthur Evans Jr" <ev_remove_this_ans@evans.pgh.pa.us> wrote in message
news:ev_remove_this_ans-0206030924320001@dap-208-40-156-130.nfas.perrysville
.sns234.pa.stargate.net...
> I think case sensitivity is a great idea.

You do? Suppose you've made a simple
typing error and wrote "I Think ..." etc.

Would that error change the meaning
of what you've said? I don't t[T]hink so.

So, why should it matter in computer
languages?

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1054591015.933523@master.nyc.kbcfp.com...
> Mike Silva wrote:
> > Well, Hyman, I think you're just messing with me
>
> Well, yes, of course. But more seriously, since we
> use capitalization for proper nouns, words do change
> meaning that way, for example, polish and Polish.

I thought you could do better that that :-)

How about "Polish the floor"
              vs "Polish floor" ?

That's one of the rare cases where you
really need AI (or not-so-A) to make
the head or tail of it. So what? How does
it make case-sensitivity somehow less
efficient in making a mess like that?  :-)

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> And they are, aint they? :-)

Why isn't Text_IO the same as TextIO?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> You do? Suppose you've made a simple
> typing error and wrote "I Think ..." etc.
> 
> Would that error change the meaning
> of what you've said? I don't t[T]hink so.

Sure it would. It woud mean that you were trying to
join the team of Tarzan, Tonto, and Frankenstein.
If your name was "Think". :-)

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1054735867.264510@master.nyc.kbcfp.com...

> The only legitimate reason I've seen is that insensitivity
> to case allows people to alter the case of identifiers to
> conform to local conventions regardless of how they are
> declared in their source packages, in the same way that they
> can change formatting conventions.

How about that reason (a bit boiled-down,
of course, but the same idea):

I'm not an experienced Unix guru so I have
to try and see if a command works. So I type
something like:  x/yz - doesn't work. So I type
X/yz - still doesn't work. So I call in an expert
who tells me that it should be x/Yz (not X/Yz
which I've also tried). When questioned *why*,
the answer is a shrug and a simple reply "that's Unix"

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> I'm not an experienced Unix guru so I have
> to try and see if a command works. So I type
> something like:  x/yz - doesn't work. So I type
> X/yz - still doesn't work. So I call in an expert
> who tells me that it should be x/Yz (not X/Yz
> which I've also tried). When questioned *why*,
> the answer is a shrug and a simple reply "that's Unix"

You could try reading the manual. (Also, x/yz is not like
any UNIX command, so you have boiled down the original
problem beyond anything that an experienced UNIX guru
could explain to you correctly.) UNIX command names are
nearly always lower case, but their option may be of
both cases, especially when there are many.

One clever case where the convention was violated was in the
name of the debugger on some UNIX system I used, SCO I think.
It came in two flavors, "dbxtra" and "dbXtra". The former
invoked a command-line version that ran in a terminal session,
while the latter ran using a GUI (under X Window, hence the name).

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1054647054.761122@master.nyc.kbcfp.com...

> The reason I've heard cited for case insensitivity is that with
> case sensitivity, you have one English word in your program
> which stands for multiple things, which is confusing, for example
> if you are doing the "telephone test" for code readability (that
> is, seeing if someone else can understand the code upon hearing
> it read instead of looking at it). But since Ada already allows
> one English word to stand for multiple things, I don't find this
> argument convincing.

Let's assume a language (like English) which mandates a capital
letter if a sentence starts with it. Would you really find it difficult
to read it if I changed "Let's" for "let's"? On the other hand, if you
had to read it over the phone and that difference really had some
meaning, how would you pronounce it?

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:p%xEa.45776$ca5.11096@nwrdny02.gnilink.net...
> AG wrote:
> > You do? Suppose you've made a simple
> > typing error and wrote "I Think ..." etc.
> >
> > Would that error change the meaning
> > of what you've said? I don't t[T]hink so.
>
> Sure it would.

Let me get it straight: Do you mean
that (to you) "I think" and "I Think"
mean different things?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> Let me get it straight: Do you mean
> that (to you) "I think" and "I Think"
> mean different things?

It was a joke, son. "Me Tarzan", you know? Get a grip.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
 > how would you pronounce it?

The same way, and then maybe add an explanation.
How would you pronounce Blue color and Blue mood?

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:xKyEa.45844$ca5.11517@nwrdny02.gnilink.net...

> You could try reading the manual.

Sure, if I had the time to dig through
the manual to find out which letter
to capitalise. Considering it doesn't
change a thing, looks like quite a bit
of a wasted time.

> (Also, x/yz is not like any UNIX
> command)

True. It was some sort of a shell
script (with x/yz being a path
parameter). I guess you could say
the shell (or it's docs) was at fault
(or me for that matter :-) But the
simple fact that I could type that
thing in case-insensitive version
without going to all the trouble
of looking it up or calling in some
help means a lot ...

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:T7zEa.45869$ca5.4753@nwrdny02.gnilink.net...
> AG wrote:
>  > how would you pronounce it?
>
> The same way, and then maybe add an explanation.
> How would you pronounce Blue color and Blue mood?
>

I would pronounce them "Blue color and Blue mood",
no problem there. But, if I had to to make sure that
the listener on the other side knows that it's "Blue Color"
vs "Blue color" I would have to go to some extra length
to make that happen. Wouldn't you?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> True. It was some sort of a shell
> script (with x/yz being a path
> parameter).

UNIX has case-sensitive filenames. Whining about this
is as silly as people whining about Ada's type system.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> I would pronounce them "Blue color and Blue mood",

I would pronounce them "lets - big L" or "lets - small l".

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:sozEa.45890$ca5.9138@nwrdny02.gnilink.net...
> AG wrote:
> > True. It was some sort of a shell
> > script (with x/yz being a path
> > parameter).
>
> UNIX has case-sensitive filenames. Whining about this
> is as silly as people whining about Ada's type system.
>

To quote from your original post which started that:

} The only legitimate reason I've seen is that insensitivity
} to case allows people to alter the case of identifiers to
} conform to local conventions

Unix conventions anyone?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> Unix conventions anyone?

Just because there's a legitimate use I can think of
for case insensitivity doesn't mean that I'm in favor
of it.

Re: Case sensitivity (was Re: no title)

[AG]

"Larry Kilgallen" <Kilgallen@SpamCop.net> wrote in message
news:HDynJhuPyL+5@eisner.encompasserve.org...
> > Hyman Rosen <hyrosen@mail.com> writes:
> >
> >> If I'm not mistaken, the following code *does* compile.
> >>
> >>      for index in my_array'range loop
> >>          declare
> >>              Index : integer := 27;
> >>          begin
> >>              if my_array ( Index ) > current_maximum
> >>              then
> >>                  current_maximum := my_array ( index );
> >>                  Index := index;
> >>              end if;
> >>          end;
> >>      end loop;

It also compiles fine if you replace "Index" with "index" - try it.
Which proves the point actually - they *are* the same.
Thanks for a good example :-)

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1054652619.86785@master.nyc.kbcfp.com...
> Preben Randhol wrote:
> > And my point is that this is a bad idea(tm)
>
> And *my* point is that while it may be a bad idea,
> Ada already allows it in the case of function
> overloading, including enumerators.
>
No, it does no such thing. The important difference
is that in overloading you (or compiler/language)
use context info to determine which overloaded
function was meant. What you seem to maintain
is that character cases of identifiers should matter
reagardless of context. In effect, they do determine
what the identifier is never mind the context. It may
be good, neutral or bad thing (IMHO it's very bad)
but it's certainly different from overloading issues.

For example, I presume you would allow things
like:

type x is (A, a);
type z is array(A..a) of ...

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:0egDa.45243$fT5.9340@nwrdny01.gnilink.net...
> James Rogers wrote:
> > In English the meaning of words does not change because of case.
>
> That is not true, since English encompasses proper nouns.
> The words "Polish" and "polish" are quite different.

Well, you've mentioned proper nouns. Not being a linguist
I can't tell for sure, but it seems a fair bet that what
disambiguates those two words is not the case of
the letter "P" but rather the role they play in the sentence
(verb vs noun).

Besides, I guess our Polish brethren must be getting
sick and tired of that word banded around as a sole
example of the (alleged) problem. Can you come up
with some others, not so flogged to death examples?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
 > Can you come up with some others, not so flogged to death examples?

ADA and Ada?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

I want case to matter so that I can simultaneously have
the same spelling but different case mean different things.
The most frequent argument I've seen against this is that
this will cause confusion for the readers of the code, to
have one word mean different things just because of case.
Therefore the overloading argument is relevant - you can
have one word that means different things even without case
distinction.

Do we have to go through all this yet again?

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:RFAEa.45995$ca5.18009@nwrdny02.gnilink.net...
> AG wrote:
>  > Can you come up with some others, not so flogged to death examples?
>
> ADA and Ada?
>

An acronym vs a person's name?  Really ...

Re: Case sensitivity (was Re: no title)

[AG]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:WJAEa.46002$ca5.5643@nwrdny02.gnilink.net...
> I want case to matter so that I can simultaneously have
> the same spelling but different case mean different things.
> The most frequent argument I've seen against this is that
> this will cause confusion for the readers of the code, to
> have one word mean different things just because of case.
> Therefore the overloading argument is relevant - you can
> have one word that means different things even without case
> distinction.
>
> Do we have to go through all this yet again?
>

Let's do a hypothetical experiment:

Reverse the cases of all the letters in what you wrote.

Or, just go random on them :-)

It sure would make it hard to read but would it change
the meaning one iota?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

I guess we have to go through it all again.

We've seen sevral examples of code which benefits from
case sensitivity (that is, it's used to good effect).
One was "FILE *file", another was enumerators which were
the same name as, but in different case than, the classes
they referred to. I like case sensitivity because I like
to have this naming possibility. I find the argument that
this is confusing and error-prone to be a feeble excuse
for what is a simple prejudice against this feature, no
doubt stemming from Ada's Pascal roots and antipathy
towards C. I find the argument that English is case-
insensitive to be simply incorrect.

OK?

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

AG wrote:
> An acronym vs a person's name?  Really ...

A woman's name.
A programming language.
The Americans with Disabilities Act.
The American Dental Association.
An Assistant District Attorney.
...

The reader of English, upon an encountering a word
which is all lower-case, capitalized, or all upper-case
will assign different provisional meanings to the word
based on that, even if he doesn't know what the word means.

Re: Case sensitivity (was Re: no title)

[Frank J. Lhota]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:xKyEa.45844$ca5.11517@nwrdny02.gnilink.net...
> One clever case where the convention was violated was in the
> name of the debugger on some UNIX system I used, SCO I think.
> It came in two flavors, "dbxtra" and "dbXtra". The former
> invoked a command-line version that ran in a terminal session,
> while the latter ran using a GUI (under X Window, hence the name).

The Unix version of "make" also violates the convention, in that if no make
script file is specified on the command line, it first tries to use the file
"Makefile" as a script, and if that is not available, it tries to use
"makefile". Needless to say, this can create problems when porting Unix code
to a case-insensitive OS.

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> We've seen sevral examples of code which benefits from
> case sensitivity (that is, it's used to good effect).
> One was "FILE *file", another was enumerators which were

One could argue that in this example, the code did _not_
benefit.  Perhaps if the language were case insensitive
the programmer would have put some thought into selecting
names that told more about what was happening.

Then again, maybe that wouldn't have been the case.

Can either side come up with one real-world incident
where an error occurred that would have been prevented
by case-sensitivity or by case-insensitivity?

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> The Unix version of "make" also violates the convention, in that if no make
> script file is specified on the command line, it first tries to use the file
> "Makefile" as a script, and if that is not available, it tries to use
> "makefile". Needless to say, this can create problems when porting Unix code
> to a case-insensitive OS.

How would this cause a problem?

On the Unix system, only one of the two filenames
will actually be used, and thus only that file needs
to be moved to the new OS.

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Frank J. Lhota wrote:
 > Needless to say, this can create problems when porting Unix code
> to a case-insensitive OS.

Why? If the first check succedes, then the file is there, and if it
fails, the second check will fail as well. What's the problem?

Re: Case sensitivity (was Re: no title)

[Warren W. Gay VE3WWG]

Hyman Rosen wrote:
> AG wrote:
>> I'm not an experienced Unix guru so I have
>> to try and see if a command works. So I type
>> something like:  x/yz - doesn't work. So I type
>> X/yz - still doesn't work. So I call in an expert
>> who tells me that it should be x/Yz (not X/Yz
>> which I've also tried). When questioned *why*,
>> the answer is a shrug and a simple reply "that's Unix"
> 
> You could try reading the manual. (Also, x/yz is not like
> any UNIX command, so you have boiled down the original
> problem beyond anything that an experienced UNIX guru
> could explain to you correctly.) UNIX command names are
> nearly always lower case, but their option may be of
> both cases, especially when there are many.

One should be aware that UNIX file names are not _always_
case sensitive. For example, if you mount a FAT file system
under Linux, the names will be presented in lowercase, and
will allow opens/creates with MiXed CaSe. Yet after file
creation, a ls on the name will show lowercase.

In more recent times, I have thought that perhaps UNIX/Linux
file systems would be better off caseless, with the proviso
that they'd be shown in one case only (lowercase of course,
in the spirit of UNIX). Yet to do so now, would be silly
because this would break a number of contributed programs.

I have always hated the way that Windows stores & displays
mixed case. I would be much happier if they were presented
in once case only (or at least had the option of being
presented so). But then, I've always hated file names that
had bad things like blanks in them anyway. Any file system
that uses a backslash in it is silly anyway ;-)

-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Warren W. Gay VE3WWG wrote:
 > But then, I've always hated file names that had bad
 > things like blanks in them anyway.

I think the biggest favor that Bill Gates ever did for
UNIX is to decide that programs should be installed in
a directory named "Program Files". UNIX had always
allowed blanks in filenames, but most programs failed
to handle them properly. Bill forced them to clean up
their act if they wanted to be portable.

Re: Case sensitivity (was Re: no title)

[Warren W. Gay VE3WWG]

Hyman Rosen wrote:
> Warren W. Gay VE3WWG wrote:
>  > But then, I've always hated file names that had bad
>  > things like blanks in them anyway.
> 
> I think the biggest favor that Bill Gates ever did for
> UNIX is to decide that programs should be installed in
> a directory named "Program Files". UNIX had always
> allowed blanks in filenames, but most programs failed
> to handle them properly. Bill forced them to clean up
> their act if they wanted to be portable.

This is more an issue of "shell programming" than anything
else, as most C/C++/Ada programs would have no issues
with the blank(s).  So I don't agree that Bill has done
us any favours 8-P

My issue with blanks in the file names is more on the lines
of appearances (combined with mixed case).

-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg

Re: Case sensitivity (was Re: no title)

[Warren W. Gay VE3WWG]

Frank J. Lhota wrote:
> "Hyman Rosen" <hyrosen@mail.com> wrote in message
> news:xKyEa.45844$ca5.11517@nwrdny02.gnilink.net...
> 
>>One clever case where the convention was violated was in the
>>name of the debugger on some UNIX system I used, SCO I think.
>>It came in two flavors, "dbxtra" and "dbXtra". The former
>>invoked a command-line version that ran in a terminal session,
>>while the latter ran using a GUI (under X Window, hence the name).
> 
> The Unix version of "make" also violates the convention, in that if no make
> script file is specified on the command line, it first tries to use the file
> "Makefile" as a script, and if that is not available, it tries to use
> "makefile". Needless to say, this can create problems when porting Unix code
> to a case-insensitive OS.

Actually, "makefile" is tried before "Makefile". For GNU make,
it also tries "GNUmakefile" before attempting to open "makefile".

This scheme is handy if you want to pre-empt the Makefile with
some changes you want to try (temporarily). This is especially
useful in a CVS like environment, when the change may not be
permanent.

In any case, none of this is a case for case-ness of files. ;-)

-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg

Re: Case sensitivity (was Re: no title)

[Wesley Groleau]

> Actually, "makefile" is tried before "Makefile". For GNU make,
> it also tries "GNUmakefile" before attempting to open "makefile".

The version of 'make' my last project used on Solaris
defaulted to 'Makefile' and _never_ tried 'makefile'
without nudging.

I had to use '-f makefile' in a script when an
application group wanted to use 'makefile'

Re: Case sensitivity (was Re: no title)

[Leif Roar Moldskred]

Hyman Rosen <hyrosen@mail.com> writes:

> A woman's name.
> A programming language.
> The Americans with Disabilities Act.
> The American Dental Association.
> An Assistant District Attorney.
> ...
> 
> The reader of English, upon an encountering a word
> which is all lower-case, capitalized, or all upper-case
> will assign different provisional meanings to the word
> based on that, even if he doesn't know what the word means.


Have you never encountered conventions such as this:

SMITH, JOHN - English explorer and principal founder of the first
permanent English settlement in North America at JAMESTOWN (q.v.)

or this:

Regarding your letter of 20th March, I must express my TOTAL
disagreement with ...

And, of course, since English is not just a written language, but also
a spoken one, English quite simply _can not_ be case sensitive. The
use of case in English is merely a convention to ease reading - it
never changes the meaning of the message.

-- 
Leif Roar Moldskred

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> 
> I think the biggest favor that Bill Gates ever did for UNIX is to
> decide that programs should be installed in a directory named "Program
> Files".  UNIX had always allowed blanks in filenames, but most
> programs failed to handle them properly. Bill forced them to clean up
> their act if they wanted to be portable.

Oh? What about windows programs? There was a lot of problems with the
space for a lot of them. Still are if the program is old enough. But the
consept of "Program Files" is stupid. In a Norwegian version of windows
it is called Programfiler. No space. So if you install some software
that has hard coded "Program Files" you will end up with two
directories: "Programfiler" and "Program Files" which is very annoying.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

RE: Case sensitivity (was Re: no title)

[Lionel.DRAGHI]

| -----Message d'origine-----
| De: Stephen Leake [mailto:Stephe.Leake@nasa.gov]
...
| 
| Some people don't like the _Type, and do something else:
| 
| type Lists is ...
| 
| procedure Foo (List : in Lists);
| 
| In a case sensitive language, this could be:
| 
| type List is ...
| 
| procedure Foo (list : in List);

Using _t or _type for the type, or the_ for the formal parameter is easy.
Some people may find this ugly, but, as you said, this hardly weight the
readability argument.

-- 
Lionel Draghi

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Leif Roar Moldskred wrote:
> Have you never encountered conventions such as this:
> SMITH, JOHN - English explorer and principal founder of the first
> permanent English settlement in North America at JAMESTOWN (q.v.)

Certainly, demonstrating exactly what I said. In this context,
upper case tells me that the words are index terms, for which
more information is available.

> Regarding your letter of 20th March, I must express my TOTAL
> disagreement with ...

And here too. What are you trying to show? I said that the
reader will use case to assign alternate meanings to words.
Here case is used for emphasis.

> And, of course, since English is not just a written language, but also
> a spoken one, English quite simply _can not_ be case sensitive.

This might be a better argument if English did not have homonyms!
     "He read the red book."
     "Don't underestimate the might of the mite."

Re: Case sensitivity (was Re: no title)

[Leif Roar Moldskred]

Hyman Rosen <hyrosen@mail.com> writes:

> Leif Roar Moldskred wrote:
> > Have you never encountered conventions such as this:
> > SMITH, JOHN - English explorer and principal founder of the first
> > permanent English settlement in North America at JAMESTOWN (q.v.)
> 
> Certainly, demonstrating exactly what I said. In this context,
> upper case tells me that the words are index terms, for which
> more information is available.

Preciesly - you get that from the _context_ and not from the
language. The meaning of the text doesn't change because of the
case. If English had been case sensitive, one could not have used case
to denote index terms, emphasis, person's names, chapter headings or
other similar uses - because the case would have been fixed by the
meaning.

You might as well argue that since the use of Hungarian notation in C
provides you with information about the varible, C is "Hungarian
notation sensitive." I maintain that the use of case in written
English is only a convention, and is not part of the language
itself. THIS IS ENGLISH TOO, after all.

> 
> > Regarding your letter of 20th March, I must express my TOTAL
> > disagreement with ...
> 
> And here too. What are you trying to show? I said that the
> reader will use case to assign alternate meanings to words.
> Here case is used for emphasis.

But the meaning of the word doesn't change, and the meaning of the
sentence doesn't change. Case is used merely as an aid in how to read
the sentence, it has no semantic meaning. Case in point, you could
equally well write the sentence above as "Regarding your letter of
20th March, I must express my _total_ disagreement with ..." 

> 
> > And, of course, since English is not just a written language, but also
> > a spoken one, English quite simply _can not_ be case sensitive.
> 
> This might be a better argument if English did not have homonyms!
>      "He read the red book."
>      "Don't underestimate the might of the mite."

I don't think the existence of homonyms invalidates the argument, but
on second thought I would say that the existence of spelling does - so
I'll withdraw it.

-- 
Leif Roar Moldskred

Re: Case sensitivity (was Re: no title)

[Warren W. Gay VE3WWG]

Wesley Groleau wrote:
> 
>> Actually, "makefile" is tried before "Makefile". For GNU make,
>> it also tries "GNUmakefile" before attempting to open "makefile".
> 
> 
> The version of 'make' my last project used on Solaris
> defaulted to 'Makefile' and _never_ tried 'makefile'
> without nudging.
> 
> I had to use '-f makefile' in a script when an
> application group wanted to use 'makefile'

Interesting.

I guess the usual caveat applies: "usually" ;-)

-- 
Warren W. Gay VE3WWG
http://home.cogeco.ca/~ve3wwg

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Leif Roar Moldskred wrote:
> Preciesly - you get that from the _context_ and not from the
> language.

The context tells you what the case means, but the case of each
word then tells you whether the meaning applies to the word.

Similarly, over the context of a certain piece of code, if I
see WIDGET, Widget, and widget used in a certain stylized way,
and then see FROB, Frob, and frob, I would assume that they
have equivalent meanings. It's not a vital feature - I could
use FROB_ID, FrobType, and frob instead, for example, but I
think it's nice to have, and I don't buy any of the IMHO
feeble arguments against it.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:

> It's not a vital feature - I could use FROB_ID, FrobType, and frob
> instead, for example, but I think it's nice to have, 
                            ^^^^^^^^^^^^^^^^^^^^^^^^^

> and I don't buy any of the IMHO feeble arguments against it.
                                  ^^^^^^^^^^^^^^^^

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Underline all you want. Of course this is just a style
issue! If Ada had decided to forbid the letter 'e' in
identifiers, it would still be a perfectly good language,
but it would annoy people who want to use that letter and
can't. Instead, we have a language which considers
Get_String and get_string but not GetString to be identical,
and distinguishes between F00L and FOOL. I consider that
perfectly arbitrary. If you insist upon insensitivity, I
would ban digits from identifiers, and allow '_' as a
non-semantic separator between letters just like it is used
in Ada numbers.

Re: Case sensitivity (was Re: no title)

[Preben Randhol]

Hyman Rosen wrote:
> Underline all you want. 

Well, you call others arguments feebel while your argument is simply
that you want to be able to write integer Fable, fabel. And perhaps
Integer Foo, foo. Whatever Integer then would have to mean as it would
be a type different from integer.

-- 
Preben Randhol                    http://www.pvv.org/~randhol/

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Preben Randhol wrote:
> Well, you call others arguments feebel while your argument is simply
> that you want to be able to write integer Fable, fabel.

Well, yes. If there's no good reason to prohibit something,
it should be allowed. And I haven't seen anything I would
consider to be a good reason.

Re: Case sensitivity (was Re: no title)

[Matthew Woodcraft]

Hyman Rosen wrote:
>I would ban digits from identifiers, and allow '_' as a non-semantic
>separator between letters just like it is used in Ada numbers.

I don't care about the case-sensitivity debate, but I think the second
suggestion is really bad.

I think the confusion caused by equating, say, 'keys_tripped' and
'key_stripped' would be enormously worse than any case-difference
issue.

This issue doesn't arise with numbers, of course.

-M-

Re: Case sensitivity (was Re: no title)

[Hyman Rosen]

Matthew Woodcraft wrote:
> I think the confusion caused by equating, say, 'keys_tripped' and
> 'key_stripped' would be enormously worse than any case-difference
> issue.

Hey, another one for my side! KeysTripped and KeyStripped would
cause the same problem now. But you're right about having word
separators count, so I withdraw that.

Re: Case sensitivity (was Re: no title)

[Matthew Woodcraft]

Hyman Rosen wrote:
>Matthew Woodcraft wrote:
>> I think the confusion caused by equating, say, 'keys_tripped' and
>> 'key_stripped' would be enormously worse than any case-difference
>> issue.

>Hey, another one for my side! KeysTripped and KeyStripped would
>cause the same problem now.

That's true. Thankfully I've never had to deal with someone who thought
it was reasonable to use capitalisation to indicate word boundaries in
a case-insensitive system.

-M-

RE: Case sensitivity (was Re: no title)

[Lionel.DRAGHI]

| -----Message d'origine-----
| De: Hyman Rosen [mailto:hyrosen@mail.com]
..
| Underline all you want. Of course this is just a style
| issue! If Ada had decided to forbid the letter 'e' in
| identifiers, it would still be a perfectly good language,
| but it would annoy people who want to use that letter and
| can't.
So not so perfect. 

| Instead, we have a language which considers
| Get_String and get_string but not GetString to be identical,
| and distinguishes between F00L and FOOL. I consider that
| perfectly arbitrary. If you insist upon insensitivity, I
| would ban digits from identifiers, and allow '_' as a
| non-semantic separator between letters just like it is used
| in Ada numbers.

Considering programming as a human activity is why Ada is a better langage.

- A normal human is used to read "get string", not "getstring". Identifer
with space is practically not possible, so the underscore do the job.
Get_String is still far easier to read than GetString. 
- A normal human will easily miss the "List" vs "list" difference, but he
won't confuse "List" and "The_List".
- A normal human prefer to read a phone number formatted 098 983 423 instead
of 098983423.
- A normal human understand "get string" exactly the same way than "Get
String". Allowing them to have different meaning is just setting traps.

Ada avoid traps as much as possible, increase readability as much as
possible, and without drawbacks.

-- 
Lionel Draghi.

Re: Case sensitivity (was Re: no title)

[Michael Bode]

Preben Randhol <randhol+abuse@pvv.org> writes:

> Oh? What about windows programs? There was a lot of problems with the
> space for a lot of them.

One of them was Access 97. Don't know about newer versions. Anyway it
took them at least 5 years to repair their own broken stuff.

-- 
PGP Key: http://home.t-online.de/home/michael_bode/downloads/michael_bode.key