Re: How to check variables for uniqueness ?
"John Ersatznom" <j.ersatz@nowhere.invalid> wrote in message
news:eoivjd$u5e$1@aioe.org...
This seems to be excessively technical when the matter under discussion is
simply capitalizing strings.
The above sentence, as perceived by a linguist, is probably akin to the
statement "This seems to be excessively technical, when the matter under
discussion is simply not putting bugs into our software in the first place."
stated by a pointy-haired boss, as perceived by a typical programmer.
[...]
It is simply erroneous to expect String.toUpperCase() to map characters
one-to-one in the way that English case mapping works. I can't, it isn't
supposed to, and it doesn't...
No, it is not erroneous to expect a method to do exactly and only what its
name implies.
Note that the name of the method is not
"String.mapCharactersOneToOneInTheWayThatEnglishCaseMappingWorks()" but
rather "String.toUpperCase()". Perhaps due to your limited exposure of
languages (e.g. only English), you are unable to conceive of scenarios were
converting a text from lower case to uppercase might not work in the same
way that it does in English? That is why I gave an example to you, and
repeatedly ask you not to simply take my word for it, and run it yourself,
to see what the results were.
It is erroneous, of course, to give a method a name that is misleading. If
toUpperCase needs a lengthy documentation block explaining why its
behavior is surprising, then it's a sure bet that it should not have been
named that, since it's apparently really
toUpperCaseAndDoesSomeExtraStuffToo.
I believe that having "?".toUpperCase() yield "SS" is surprising only to
those who are unfamiliar with the ? character. Probably to most German
speakers, this behaviour is very non-surprising, and in fact, expected.
[...]
It sounds like toUpperCase has a "badly misleading" name since it
(supposedly) does transformations that go well beyond what is normally
meant by everyday blokes by "to upper case", and the method name is
supposed to be a reasonably meaningful capsule summary for everyday blokes
of what the method does.
I think "everyday blokes" are unqualified to have any expectations of
have the concepts of upper case and lower case mean in an international
setting. These blokes may have a good idea of what these concepts mean in
their particular language, but unless they are linguists, they probably have
no idea what these concepts might mean in other languages. Such blokes are
probably unqualified to request that the linguists and the unicode
consortium redefine their concept of uppercase and lowercase to suit said
blokes.
Similarly, an everyday bloke might be surprised about the output of the
following Java program:
<code>
public class Test {
public static void main(String args[]) {
System.out.println(0.1 + 0.2 == 0.3);
}
}
</code>
But unless said bloke studied numerical computing, or at the very least,
has a understanding of the binary representation system for numbers, said
bloke is probably unqualified to request that the computer scientists and
IEEE redefine floating point computation to suit said blokes.
If a method is supposed to do behavior that's surprising for any English
speaker but not for a German speaker, maybe it should have a German rather
than an English name? :)
I claim that there exists at least one English speaker for which its
behaviour is not surprisingly (me).
If it's supposed to do locale-dependent stuff, then it should have a
version that accepts a Locale object.
It does. See the JavaDocs.
The version that doesn't shouldn't surprise English speakers;
It doesn't surprise me.
Are you basically saying that it should not surprise ANY English
speaker? What if I had a cousin, "Surprised Sally" we call her, who is
surprised at everything. And she's an English speaker. No matter what the
implementation of toUpperCase is, it would surprise her.
Or are you basically saying that it should not surprise *you*? If so,
then maybe you should apply for a position on the unicode consortium, so
that when the next version of Unicode comes out (6.0?), perhaps you will
have exerted enough influence on the standard such that toUpperCase will no
longer surprise you.
the version that does shouldn't surprise anyone familiar with its
locale-specific behavior for the locale actually used. Having
locale-dependent behavior invoked randomly without explicit use of Locale
objects, and which furthermore doesn't use the system locale, is by itself
a sign of a questionable design as well as a sure source of bugs and
problems.
What locale were you using, and what did you expect the uppercase form
of "?" to be in that locale?
[...]
[*] Arguably the concept "same spelling" is flawed in the context of
Unicode
case mapping.
A concept like "same spelling" can't be flawed. It's generally accepted
that "color" and "colour" are the same word, but have different spellings,
right?
You'll have to define the terms "spelling" and "word" outside of the
context of any one particular language (e.g. you can't assume only the Latin
alphabet) before I can agree or disagree with your claim.
While "two" and "too" are different words spelled differently that sound
the same, "tomato" and "tomato" are the same word spelled the same but
pronounced differently
Ditto.
and "ant" (the bug) and "ant" (the build tool) are different words both
spelled and pronounced the same.
Could we possibly get a bigger hint? =P
- Oliver