7.0 wishlist?

[Lew]

Finding Jakarta Commons Collections might be difficult,

Actually, it isn't.

Hendrik tried to reasonably assert:

It was not intended as an insult. In fact, I have never in my life
intended anything as an insult. What I tried to point out is that it is
wiser to try to use the wisdom of other people, instead of doing
everything yourself.

Did I say not to suggest? Did I say not to ask? If so, I didn’t mean to.

Hendrik, your suggestions come across to normal people as quite reasonable.

 

[Lew]

"Harold Yarmouth" schreef:
False, to the extent that that is only a consequence of what the specification
explains. The JLS clearly states:

An abstract class is a class that is incomplete,
or to be considered incomplete. ....
A class type should be declared abstract only if the intent is
that subclasses can be created to complete the implementation.

It takes several paragraphs of explanation about that before it gets around to
mentioning,

A compile-time error occurs if an attempt is made to create an
instance of an abstract class using a class instance creation
expression (§15.9).

The primary purpose of the Java 'abstract' keyword according to the
specification, which "Harold" correctly points out rules in this matter, is to
enforce that the class is incomplete, not primarily that it is not instantiable.

Q.E.D.

 

[Hendrik Maryns]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Lew schreef:

Actually, it isn't.


Hendrik tried to reasonably assert:

Hendrik, your suggestions come across to normal people as quite reasonable.

I know, thanks for reassuring me. It is just so difficult not to react
to such posts, although I was the first to point out the uselessness!

H.
- --
Hendrik Maryns
http://tcl.sfs.uni-tuebingen.de/~hendrik/
==================
Ask smart questions, get good answers:
http://www.catb.org/~esr/faqs/smart-questions.html
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.9 (GNU/Linux)
Comment: Using GnuPG with SUSE - http://enigmail.mozdev.org

iEYEARECAAYFAkkRdsQACgkQBGFP0CTku6OvFwCgsZfX8FYCjbVk3kS8bZ+AnEBx
OZ4AniSu4X8JBVrIQkyO9VT+ERAKLVA+
=M+IV
-----END PGP SIGNATURE-----

 

[Harold Yarmouth]

Note that this newsgroup is *not* the place to go to suggest that Java
be changed.

Actually, this is the right newsgroup -- none of the other
comp.lang.java.* newsgroups is as good a fit as this one is. My
reasoning being as follows: clj.announce is right out as it's not for
discussions at all, but for announcements; this stuff would be off-topic
in clj.3d, beans, corba, databases, gui, help (I think), machine (that's
VM implementation right?), or security; that leaves clj.programmer and
softwaretools. I felt the former was a better fit, since language
design/change is an issue of interest to the programmers that use the
language, and language changes are really specification changes that
require tools like the compiler to be updated as side-effects.

Perhaps you think of language changes as merely compiler changes, and
thus think clj.softwaretools would have been a better fit.

Perhaps reasonable men can disagree about that.

Clearly, however, discussing language changes from the perspective of
programming in that language falls within the topic bounds of this
newsgroup, so you are out of line in insinuating that my post was
off-topic. It was considerably more on-topic than some of yours have
been (notably the ones that are 80% personal attacks by dry weight and
only 20% Java programming related -- and high in saturated fat too no
doubt!).

If your suggestions are as well-thought as you imply, then
the better route would be to go through the actual mechanisms to propose
new additions to Java.

Perhaps you've mistaken me for someone with access to people on the
inside track at Sun? I don't have the connections to put this sort of
thing before the people that sit on the relevant committees. Heck, I
don't even know what the relevant committees are, or very much else
about Sun's internal organization or any clubs, groups, or similar
liaisons it has with the wider developer community. I'm pretty much just
your run-of-the-mill lone-wolf, hired-gun Java programmer.

As for my opinions being "as good as facts," that is a poor
qualification.

It is what the evidence (your posts to this thread) suggests your
attitude to be. If it is not your actual attitude, then your posts to
this thread either are an unrepresentative sample or communicate your
true feelings poorly for whatever reason.

I have provided (albeit, to be honest, not in my first
posting) a citation of the people whose views /are/ as good as facts

Nobody's views are "as good as facts" except for mathematicians and
eyewitnesses, and even these only when they're right.

Otherwise there is always some room for error.

Scientific opinions backed by experimental data are next best. By the
time we get down into plain-jane opinions, or (especially) media poll
results, we're in guesswork territory. Aside from exit polls at
elections; those have a funny tendency to actually be fairly accurate.

and one can in general extrapolate from Java's history, most notably an
extreme frugality in core language additions.

Some of those proposals at that web site bug me (and not just that
they're in the form of evil PDF and some of the pages are actually cut
off in midsentence).

Particularly @Immutable and @ReadOnly -- right near a table that reminds
me that "const" is a currently-unused reserved word.

And @NonNull being "not too verbose" because it will occur "only every
75 lines" probably came from the same source as most statistics:
directly out of somebody's butt. I have declarations of type parameters
and references that are intended to be never-null at a rate of about ONE
PER LINE OF CODE, nearly two whole orders of magnitude more frequent
than that statistic suggests, in the codebases I work with. Many lines
have no declarations but the lines full of repeated type names, method
declarations with many arguments, and other sources of multiple @NonNull
candidate locations on a single line more than make up for these.

I'd expect at least ONE order of magnitude more frequency than they
suggested. One every seven or eight lines on average, not seventy or
eighty. Especially if you prefer many short methods and little utility
classes to a few big monolithic god-objects and prime-mover methods.

What you originally presented was a list of "here's some features." In
general, the burden of proof is on you to show why one should integrate
the feature, which you didn't provide. I was no less terse in my riposte
than you were in your original posting.

Why did you feel that my original posting needed a "riposte"? That word
choice suggests that you felt that my original posting constituted some
sort of an attack. Perhaps you're emotionally attached to "how Java
works now". That means your opinions expressed here may be biased and
not wholly based on pragmatism. (And you could always just stick with
Java 6 from now on if it really matters to you. In this newsgroup we
regularly hear from people that still use Java 1.3!)

And I did provide justifications for my proposed features, at least to
the extent that I didn't think each's usefulness should be 100%
self-evident to any experienced Java programmer.

No, but preceding to insult someone is.

You were the first to insult someone in this thread, and I was your target.

The best way for me to
characterize my initial riposte is that I was blunt, which I do not see
as insulting, nor (it seems) does it seem insulting to many people.

Surprise! I'm not "many people". I'm me.

I'm not sure if that's just because we've built up extremely thick
skins

It probably is. If your behavior is representative of how people
generally treat one another around here, every non-newbie here probably
has built up an extremely thick skin. Thus perpetuating the problem.

Your response to that riposte was far more insulting

It didn't even sink to the level of responding in kind.

I wrote:

: How so?
: Not if the class is not under your control for whatever reason.

and similar things that seem innocuous, and

: Not true.
: Awkward and clunky.

and such, which are no worse than your bluntness in the previous
message, and

: No, it is not, and I will thank you to stop gratuitously insulting me.
: If you have nothing pleasant or constructive to say, might I suggest
: that you keep your mouth shut in the future?
: You aren't posting to discuss this, are you? You're just posting to
: shit all over it
: Now you've gone from "nonconstructive" to "just plain bloody-minded".

which are mostly phrased quite politely considering the extreme
provocation, which was, if you'll recall a direct accusation of poor
intelligence or competence. My response: to call you on your bad manners
and suggest that you not bother to post posts that consist purely of
negativity and hostility with no constructive content whatsoever.

Or perhaps it's the one use of a swear word that you find objectionable,
more objectionable than you seemed to think your own calling me an idiot
to be?

If so, I guess we again disagree. You must consider scatological
language use to be a much worse offense than I do, or perhaps
namecalling a milder one.

Cultural differences, perhaps.

Clearly, for whatever reason, we've got off on the wrong foot.

This seems to be more a case of "do as I say, not as I do"--to my
knowledge, I did not perform any "name-calling or other nastiness"
besides being terse and blunt

You more or less called me an idiot in public. I consider that to easily
qualify as "name-calling or other nastiness". And my rather witty
riposte (to something that DID deserve a riposte!) was pointing out that
you not only had nothing but negativity to post (and not even with all
of the steps of your reasoning, assuming there had even been any,
spelled out -- my math teacher gave students poor grades if the answers
were wrong, but the Fs were reserved for the ones that also didn't show
their work) but apparently hadn't even bothered to read the entirety of
the post before making up your mind that it deserved only a terse, blunt
form reply basically saying "No, no, no, no, no, no, and no, and btw
you're an idiot for even suggesting half this stuff."

Did you really expect me to respond in a nicer way? Some people I know
would have brushed your post off with a one-line, top-posted,
no-trimming "**** you, Mr. Negative, did I even ask for your opinion
jerkwad?" (only with extra bonus spelling errors and awful grammar, free
while supplies last!) or even just "**** you".

Oh, and pardon me for using the F word, albeit only as illustration.

you were quite terse in your original posting as well

The difference being, *I* wasn't being negative or taking potshots at
someone in *my* posting.

 

[Harold Yarmouth]

I was referring to the fact that (in my eyes at least), Lew was in part
parodying Twisted.

I don't see how Twisted is even relevant here, sorry.

Regardless of Lew's intent, his post came off as an accusation that I'd
engaged in name-calling. The closest I'd come was to suggest that you'd
clicked "Take A Crap All Over This And Send" in your news software,
clearly a tongue-in-cheek suggestion and one that does not say anything
about your character, intelligence, or competence. (Unlike some of the
things that you and others have insinuated about me!)

 

[Harold Yarmouth]

I was completely parodying Harold and anyone "else" who uses that phrase.

To my knowledge, I have never used that phrase at all, save by quoting
it in (so far) exactly three Usenet posts. If you hadn't used it first
yourself, that number would be zero.

So if users of that phrase need parodying for some reason beyond my ken,
it looks like I should be way, way down the list -- and below *you* on it.

 

[Harold Yarmouth]

I have used it to get a next() and prev() functionality of enums (think
I used something similar in Pascal or Turbo Pascal). So for me having a
clearly defined value has it's "value" ;-)

OK.

Although the functionality you describe can be implemented without that,
though perhaps not quite as easily. Having next and prev fields in your
enum, for instance, set by the element initializers and a constructor,
and forming them essentially into a doubly-linked list. That might
actually be faster, if more coding effort, than a numeric
implementation. Especially if you make the list circular: modulus tends
to be a slow operation, and avoiding modulus means using conditionals.
Reference copying should be very fast and reference copying doesn't
involve the risk of branch mis-prediction.

 

[Joshua Cranmer]

Actually, this is the right newsgroup -- none of the other
comp.lang.java.* newsgroups is as good a fit as this one is.

The places to go are the mailing lists /designed/ to talk about
including new features into the Java core.

Perhaps you've mistaken me for someone with access to people on the
inside track at Sun?

You don't need connections. Anyone can post to the relevant mailing
lists. Note that people also tend to be more responsive to ideas if
people have the code to back it up. To paraphrase the editor of HTML 5,
Tim Berners Lee only got HTML accepted by actually writing a server and
a client, not merely hypothesizing that it would be good to have.

I have declarations of type parameters
and references that are intended to be never-null at a rate of about ONE
PER LINE OF CODE,

I am going to guess that this is hyperbole, since this would imply that
you are declaring new variables at roughly the rate of one per line of code.

Surprise! I'm not "many people". I'm me.

I do not know your personality; I can only extrapolate based on the
average of the groups among which I interact until I receive information
that counteracts the assumptions.

Okay, that just sounds pretentious... :-/

You more or less called me an idiot in public.

The most I have done, to my recollection, is suggest that you
unknowingly made fallacious statements. That, as I discussed in one of
my posts (I do not recall which one), is not the same as calling you,
explicitly or implicitly, an idiot.

 

[Harold Yarmouth]

Which is to facilitate migration of generics.

No, unchecked conversions have other, commonplace uses, as I just got
through explaining. Now the final word on that matter has been said, so
please don't keep arguing this point.

such unchecked conversions will be unnecessary with reified generics.

That's an argument for reifying generics, not an argument against
allowing a programmer to cast to an interface with matching signatures.

Such casts would also be intended to typically be temporary, until
whoever owned the target class got around to tacking on the appropriate
"implements Foo".

Hey! You guessed wrong!

Hey! You just insulted me again!

What is your beef with me, anyway?

I actually support operator overloading.

That claim is not consistent with a single other word you've written in
this thread, and frankly inconsistent with a great many of those.

Your proposals are not adequately addressing these hurdles.

I didn't ask for your opinion of how "adequately" I do anything, and
I'll thank you not to broadcast negative such opinions in any public place!

My proposals were quite adequate in every meaningful respect. They were
not detailed specifications covering every single corner case -- I leave
that sort of thing to higher geeks on the totem pole. If you'd have
preferred to see a post full of detailed specification proposals, rather
than broad use-case based proposals, well, too bad. This newsgroup is
not solely for posting things you like. Its charter constrains the topic
to Java programming and related topics, and no farther. Language change
proposals seem on-topic enough to me.

An appropriate response by you would have been any of:
* None at all;
* "Please provide more details regarding suggestion X";
* "How do you plan to address possible problem Y?"

Yours was none of the above. Yours was full of things resembling:
* "That will never work!"
* "I don't like this."
* "Are you crazy?!"
* "Idiot. That's completely pointless, and won't work besides."

(Though the epithets were less explicit than above, those are basically
accurate capsule summaries of the semantic content of the things you wrote.)

It looked like unreasoning negativity about the proposals (liberally
sprinkled with strongly implied negative opinions of the proposer), not
like either reasoned objections OR requests for further detail.

If you really intended the latter, perhaps you should work on your
communication skills.

I'm trying to save bandwidth and breath.

You can save more bandwidth and breath by not replying at all. In fact,
by insulting me, dissing my proposals without explaining why, and
generally pissing me off, you ended up *wasting* bandwidth and breath
arguing with me for several further iterations. Your strategy backfired,
sir!

Brevity at the expense of no longer communicating your true meaning
(e.g. "Idiot, that will never work" taking the place of a detailed
suggestion of problems that would need to be overcome, or a request for
more detail from the proposer) is too much brevity.

[ Snip several paragraphs of information all resulting from an incorrect

No. Nothing about me is "incorrect" and you will desist from publicly
insulting me now.

I thought we were making progress, but, sadly, I now see that you have
no intention of engaging in civil discourse, and indeed most of your
rudeness and your "miscommunications" have probably been quite deliberate.

(Why else would you have said all that you have about how it's been a
miscommunication and you're sorry for coming off as ruder than you
intended, then turn right around and engage in frank namecalling again?)

Operator overloading is (or at least should be) principally used for
mathematical constructs.
Agreed.

There are several structures for which operations are not commutative.

And generally, these are regarded as "multiplication-like" rather than
"addition-like". I DID take abstract algebra 101 in university you know.

Note that, in programming, even regular
addition is not necessarily commutative.

a + b == b + a, right? No.

((byteArray[i++] & 0xff) << 8) + (byteArray[i++] & 0xff) is no
(byteArray[i++] & 0xff) + ((byteArray[i++] & 0xff).

That's cheating -- the expressions for a and b have side effects. My
proposal can be amended to specify that temporaries be made and side
effects occur in the "expected" order:

z = x + y; -> t = x; u = y; z = x.plus(y); or z = y.plus(x);

If x and y are expressions with side effects, this will do the right
thing. (This is similar to how you'd make a C macro safer.)

I trusted the engineers at Sun to get little details like this right.
Apparently you don't trust them as much, so unless I come up with a
strategy to deal with such corner-cases, you assume the corner-cases
will cause trouble in production code down the line.

I find your lack of faith disturbing.

(There's also the question of whether x + y == y + x with doubles and
other fp types, even given roundoff, but the operation is conceptually
commutative even if it's only approximately so in actual implementation,
and code that relies on fp == equality is code that has a design flaw
regardless.

You're making assumptions which don't pan out.

You're making insulting insinuations about me in public which don't pan out.

Study some abstract algebra

This, I find to be exceptionally condescending and rude. How dare you
insinuate publicly that I'm uneducated in an area where I am, in fact,
educated!

Obviously in some cases inversion or division like operations just won't
make sense, or won't always work depending on the operands. This is not
a coherent argument against allowing operator overloading any more than
it is a coherent argument against allowing a method to be named
"dividedBy" that throws exceptions or is not present in Object and all
of its subclasses.

It's repeating the same thing over and over again.

Yes, you are. Fortunately I have found some people here that are, like
myself, educated adult human beings with a willingness to have civil and
intelligent discussions instead of repeating the same thing over and
over again.

Unfortunately, you do not appear to be one of these.

As I said, I do not wish to repeat myself when it adds nothing new.

Then either say something original or don't click "reply".

That would make me a politician.

Voted for Obama this time 'round. Next time, I don't know who I'll vote
for (since I don't even know who'll be running), but I do know I won't
be voting for you. (Sorry.)

Technically speaking, the United States /could/ declare war on China
tomorrow. Probably won't, though. Practically speaking, it is difficult
for Java to not have chosen C++ syntax for various reasons.

Well, as I said, there's not very many other plausible syntaxes in the
specific case of generic parameter lists, save for variation in the
choice of delimiters.

As I see it, all three would have to happen for any one to be
sufficiently valuable to warrant consideration for inclusion.

So, some things should happen at the same time as some other things.
This is the substance of your argument that none of them should happen
at all?

(What's the point of getting clean drinking water to that African
village? They'll just slaughter each other in war or die of malnutrition
or disease anyway. What's the point of peacemaking there? They'll just
die of cholera from their contaminated water supply anyway. Etc. How
fortunate for African villages that aid workers do not think as you
apparently do!)

You are discussing inclusion of a C/C++ feature.

I am discussing inclusion of a feature. What other languages might
happen to have similar features is not germane.

No, my objection is that you've added nothing to the debate.

In other words, your objection is that I was unoriginal.

OK, then.

Guilty as charged.

Now what are you going to do, lock me up along with about 6 billion
other people? I'd like to see you try.

I'm trying to help you by letting you do something: add value to a
currently valueless debate.

You are insulting me and engaging in unproductive discourse that
generates more heat than light in an effort to *help* me?

You think that being rude to me somehow enables me to do something I
otherwise didn't do?

I disagree. I think that all you've done is cloud the issue and clutter
up this entire thread with your negativty, *impeding* any discussion
you'd find valuable. The more time I have to spend defending myself
against unpleasant and inaccurate public insinuations made about me, the
less time I have to spend refining my proposals or discussing them
intelligently and in detail with other civil, rational adults. The more
such people are turned off from reading this entire thread because it
looks more like a pissing match than a reasoned debate (no thanks to
you) the fewer will engage in adding that "value" you apparently crave.

More generally, of the below three actions, precisely one can add value
to a Usenet debate, and one tends to subtract it, while the remaining
one has no effect. You get three guesses to determine which is which
(and there are only six possible permutations). Time starts now:

* Add value yourself by posting a reasoned and intelligent response.
* Flame one of the other participants for not adding enough value for
your tastes.
* Lurk instead of posting anything to the thread at all.

Maybe if I can clue you in enough, I can finally give you the help
you need...

As long as you cling to the attitude that Harold Yarmouth is a poor
uneducated idiot that has to be patronized and treated like a child
until eventually he might some day be able to contribute something of
value, instead of understanding that in fact Harold Yarmouth is an
intelligent and educated man who already can contribute plenty of value
(even if not all of it fits your *personal* definition of "of value"),
then we can not have any productive or worthwhile discussion about Java
and it would therefore be best for all concerned if you did not reply to
any more of my posts in this newsgroup.

Insulting, patronizing, rude nonsense like what you wrote above can
serve no constructive purpose here. All it might do is further inflame
tempers and "shed more heat than light".

Also, see above. (You have two guesses left after, apparently, one wrong
one, and half your time remains. Use it wisely!)

Pedantically, we're not discussing Java programming. We're discussing
Java features.

Java's features directly impact Java programming, and indeed are at the
very heart of Java programming.

[ More aggravating paragraphs based on a faulty assumption ]

The only faulty assumptions that have been made here have been made by
you. The only one being intentionally aggravating around here is you.

As I said, I don't hate operator overloading. I'd love for it to be
included.

Every previous post of yours implied exactly the opposite.

You have forgotten one of the more important lessons for being a
politician: stay on message, and say it clearly. You've apparently done
neither.

It's just that your proposal has flaws for which you have not
found, nor (apparently) seek to find, fixes.

As stated originally, it lacked detail and glossed over some areas. I
wouldn't precisely call that "has flaws". You may have made assumptions,
filling in the blanks (incorrectly) and then concluding that it "has
flaws". Heck, perhaps it actually does have flaws.

Merely accusing it of having flaws is not constructive, however.

Polishing and working out a very detailed all-i's-dotted-and-t's-crossed
specification was a task I figured to leave to greater minds than mine.

Instead, all I seem to have gotten is apparently-unreasoning criticism
from apparently-lesser ones -- though that appearance *may* be the
result of a simple refusal to communicate clearly on the part of the
critic in question.

 

[Harold Yarmouth]

You are implying interning again.

No, just a constant pool, like we already have.

I see no reason why [a,b] would not create a new pair in the
background each time.

No existing literal does so, other than primitive literals, and those
only because primitives are passed by value rather than by reference.

 

[Harold Yarmouth]

Harold Yarmouth schreef:

When did I write ‘blame’? When did I say you are at fault?

Where there is a punishment (for instance, execution, or imprisonment,
or public humiliation) there is some (perhaps unconscious)
blame-assignment going on.

The very fact of a punitive action, from a (virtual or real) slap in the
face on upwards, is a tacit accusation of fault.

Finding Jakarta Commons Collections might be difficult, but my point was
simply that it is worth looking for a library.

And *my* point, backed up by actual evidence, was that actually looking
for one draws a blank, which seems to mean that it is *not* worth doing.

Perhaps you think it is nonetheless worth doing a fruitless Google
search because it "builds character" or is educational or something of
the sort?

If so, I must say that I respectfully disagree.

If you don’t find one, that’s unfortunate, but no harm is done.

Time and effort expended on a wild goose chase (especially one known in
advance to be a wild goose chase, conducted anyway just to satisfy some
jerk on the Internet that insists it must be done) qualifies as "harm"
in my books. No offense.

It was not intended as an insult.

Silly suggestion it is then. I don't think that that suggestion needs
any further rebuttal than has already been given, so I guess that
concludes this side-discussion. (Unless, perhaps, you plan to become as
tiresomely repetitive as Joshua Cranmer.)

In fact, I have never in my life intended anything as an insult.

Not consciously, perhaps.

Actually, I find your statement above literally unbelievable. I don't
know a single person that didn't insult anyone ever, not even in the
schoolyard when they had a single-digit age, not even when given serious
provocation later in life.

Show me a person that's never insulted anyone (or used a four-letter
word, or any of several other things) and I'll show you a soiled diaper
within the next few hours.

What I tried to point out is that it is wiser to try to use the
wisdom of other people, instead of doing everything yourself.

This is increasingly amusing. First we have Joshua accusing me of being
insufficiently original, then you apparently accusing me of being
excessively so. While Joshua is equally unoriginal himself.

Did I say not to suggest? Did I say not to ask? If so, I didn’t
mean to.

Say? No. Imply?

"Only suggest in the approved manner or I'll flame you" is the message
that comes across from both you and Joshua -- and your respective
"approved manners" are apparently disjoint sets, so the implied threat
amounts to "don't suggest anything at all or at least one of us will
flame you".

Whether that in turn implies an instruction not to suggest I leave as an
exercise for the reader.

 

[Harold Yarmouth]

Actually, it isn't.

I expect it probably isn't -- given you are looking for "Jakarta
Commons" rather than "collection library".

However, people are not born knowing that the name "Jakarta Commons" is
somehow important and ought to magically pop into their heads later in
life if ever they decide to do a google search for collections libraries.

This fact may not be obvious, though, to someone who does know the name
in question. (Tongue-in-cheek.)

No, I wrote that. Please don't misattribute the quoted material in
Usenet posts. It is rude when it's done accidentally, never mind
intentionally, and in this case I don't see how it can possibly have
been an accident.

Hendrik, your suggestions come across to normal people as quite reasonable.

His suggestion appeared to amount to "if you don't have X amount of
experience, leave the suggesting to those that do".

I consider that contrary to the academic spirit of free inquiry,
contrary to the Usenet unmoderated-group spirit of free speech (within
the newsgroup topic bounds), AND contrary to basic manners and the
politeness norms of civilized society.

If that makes me "not normal", then I'm in distinguished company -- tens
of millions of people (at least) would agree with me.

 

[Harold Yarmouth]

Lew schreef:

No, I wrote that. Lew misattributed that quoted material. Please do not
compound his error by quoting the misattributed text without correcting
its attribution.

I know, thanks for reassuring me. It is just so difficult not to react
to such posts

What, precisely, do you mean by "such posts"? None of my posts have been
unreasonable in any way. I only reacted as any sane person would to an
apparent suggestion to "shut up and leave making these sorts of
suggestion to the experts" being posted to an unmoderated newsgroup.

 

[Harold Yarmouth]

Since the person who misunderstood has a pathological

I have no pathology. You have a pathology, however -- a pathological
compulsion to flood this newsgroup with off-topic, inflammatory posts
full of random-looking irrelevancies that often reference
random-seeming, not-present personages.

(It's that, or your mail/news software is misconfigured somehow such
that what should be private mail to various people is somehow winding up
in comp.lang.java.programmer.)

 

[Harold Yarmouth]

"Harold Yarmouth" schreef:

False

No, you're the liar, "Lew", and I'm finding your unprovoked, escalating
nastiness quite tiresome. So far, you have posted at least a dozen posts
either in direct response to posts of mine or indirectly referring to
same, and:
* Not one of them offers much useful, interesting Java-related material
* Almost all of them contain personal attacks or other similar
gratuitous and off-topic nonsense
* A lot of them contain frank nonsense that I can't begin to interpret,
stuff about people named Paul and Twisted. Whatever the meaning of
that material, one thing that's abundantly clear is that it has
nothing whatsoever to do with Java programming.
If you have nothing germane to the actual topic of this newsgroup and
the actual topic of this thread to post, I respectfully suggest that you
spare everyone's bandwidth and time by not posting more such pointless
randomness.

Oh, and regarding my calling you a liar?

First, in my opinion you are one, since you have been asked repeatedly
not to post incorrect things about me in public and have continued to do
so after receiving such requests, after having apparently read them (as
evidenced by your having posted a followup to at least one), and after
specifically being told that the information you were posting was
incorrect. Even if you didn't know it was incorrect the first time,
then, you did the second, and that makes you, in my opinion, a liar.

Second, at least now any further attacks by you won't be quite as
unprovoked. I may as well be hanged for a sheep as for a lamb, right?

The primary purpose of the Java 'abstract' keyword according to the
specification, which "Harold" correctly points out rules in this matter

My name is simply Harold, "Lew". No quotation marks.

I believe I already pointed this out to you once before, "Lew". By
ignoring that, you are displaying profound and undeserved
disrespectfulness towards me, "Lew".

 

[Harold Yarmouth]

Harold Yarmouth schreef:

[remaining attributions inexplicably missing]
I don't recall writing the latter sentence, yet it appears from the
number of >s to be from one of my earlier posts. I find this puzzling
and disturbing. I do hope nobody is trying to put words in my mouth here.

Thus, Hendrik is completely correct, and "Harold" is partially correct.

Au contraire; you appear to be "partially" an arsehole though.

 

[Harold Yarmouth]

Correcting a misattribution:

The only one who's misattributed anything in this thread, so far, is you.

"Harold" wrote:

This is both a misquotation and an arguable misattribution.

It is simply Harold, no quotation marks, and Hendrik's posts have all
correctly attributed my posts with a simple

Point contradicted by the evidence.

No, the only things contradicted by the evidence are your various nasty
insinuations about me personally. Said insinuations also being
completely off-topic for this newsgroup. Not that you seem to care about
accuracy, manners, OR topicality.

 

[Harold Yarmouth]

No.

Well, then why are you acting so surprised?

[some insulting sophistry deleted]

I don't care about the detailed, exact nuances of your negative opinions
of me. I care that you continue to publish those opinions a) publicly
and b) in an inappropriate forum for discussing the matter.

Please desist at once.

Do you think Albert Einstein is stupid? Do you think he never made a
mistake?

I never made any claims either way.

In fact, he made a mistake: the cosmological constant.

Apparently not -- I googled this and quickly found something about some
supernova(?) observations that indicated that there is a cosmological
constant. (Though that may have been misunderstood -- that's my attempt
to translate Eggheadese to English, and summarize, on an empty stomach
and under the influence of sleep deprivation, and so it might be suspect.)

It never generates them on the fly.

In other words, "exactly when it does which" has one component of "when
there's a body" and one component of "never".

So, what I said, but a bit more specific.

 

[Harold Yarmouth]

Andreas Leitgeb wrote: [transparent class wrapping]

Compared with mine, you left out the class-equivalence part.

I fully intended the wrap to test true with "instance of" the base, be
castable to the base, and so forth. You want two-way equivalence,

You wanted castability from wrapper to base, I wanted equivalence.

Got that.

Equivalence is always symmetric.

That, I've known since high school.

I found some page that proposed "#" for it, and gave arguments against
doing it with annotatons. It also had some flaws in it,

unlike mine,

but parts of it are quite reasonable. I'm talking of:
http://docs.google.com/View?docid=dfn5297z_2kjj2fk

text/html only, please. I've had my fill of PDFs and other non-HTML
document formats, and their finicky and trouble-prone viewer plugins,
for the day.

The flaw is with overriding methods that change the null-allowedness.
e.g.:
class Base { void foo(Foo f) { ... } } // Base.foo allows null arg.
class Sub extends Base { void foo(#Foo f) { ... } } // Sub.foo doesn't.
Since the compiler doesn't know what instance is really stored in a
Base typed reference, it cannot do the right check for null, so it's
inevitable to still check for null inside Sub.foo(...)'s body.

That's a pretty serious problem. Restrictions on parameters have to be
allowed only to be loosened, never tightened, in subclasses.

Obviously I'd allow adding * on returns and removing * on parameters but
not vice versa.

That's just the situation at hand:
A (null-allowed) field that at some point happens to be not null
shall be copied into a non-null other field.

At no point in time do we want to risk the null to enter the target
field, because even if we get a NPE afterwards, unrelated code in
a second thread may see the null before the the null-check in this
thread sees it

The null-check would be right after the bytecodes that did the
assignment in this case. Any code seeing the null in that brief time a)
got exceptionally unlucky and b) is ALSO part of the concurrency
problems, since it clearly got into a data race with an assignment in
another thread. So the NPE pointing there still points to part of the
bug and not to bug-free code elsewhere. It's as desirable behavior as
can probably be hoped for under the circumstances that such a bug exists.

The only ways to get this really safe is to either copy it to a
local variable first, check that, and only on success copy it to
the target, or have the principially same thing happening
on the stack at jvm-level, as I mentioned it above.

Those are options, though they might impact performance. My preference
was just for
a) helping programmers to get such assignments to a bare minimum, and
b) when a problem null does occur, get the NPE to be thrown where
there's really an error, inasmuch as that is feasible without too
much runtime penalty.

Strictly enforcing that there *never* is a null in such a reference,
even in the presence of incorrect code and data races, was not my
proposal. Perhaps it is something that you would like, though.

The real horror of it is that you see Javadocs all over Sun's own Swing
classes like this one:

/**
* <p>This method is public as an implementation side-effect.</p>
*/
public void actionPerformed (ActionEvent e) ...

Where I get into such situations, I either spend a one-letter name,
or some acronym, like "npe" when catching a NullPointerException,
no matter if I use it or not.

I tend to just use "e", for exceptions or events, unless nested catches
or whatever force me to use "e2" and beyond.

My main reasons for wanting the (minor) change of leaving unused
parameters and catches unnamed:
* Suppress unused warning for unused parameters and catches; then the
"unused" warning option can be turned on without being annoying, and
can help catch bugs or remind you of incomplete stuff.
* Get rid of the nested-catch-clause issue noted above, which annoyed
me recently in some I/O code with stuff like

try {
someStream.read(foo);
} catch (IOException e) {
try {
tryGettingFooFromASecondarySource();
} catch (IOException e2) {
try {
tryYetAnotherThing();
} catch (IOException e3) {
logError("foo", foobar);
throw new SomethingDidntWorkException("read(foo)");
}
}
}

The actual code was more involved, and had several successive catch
blocks on each try, and several separate try blocks in each case, so
keeping track of which e-number was already used in which scope was a
pain; the code lit up like a Christmas tree the first time the IDE got
around to linting it. It would have been a nightmare to fix it up with
older tools where you had to actually hit "compile" to compile, then it
sat there thinking for half an hour, and then you got only the first error.

I'm currently holding my fingers hoping never to need to catch e4.

I find eclipse's warning about unused parameters goofy, and would
turn it off anyway, if I ever used eclipse.

That's one of my points: turning on the "unused stuff" warning is
presently too annoying, largely because of unused catch variables and
event parameters.

 

[Andreas Leitgeb]

Doesn't this claim imply that such classes were *always* generated?
Unless, of course, the wording "in some manner" includes "sometimes not".