7.0 wishlist?

[Andrea Francia]

There's probably plenty of these floating around already, but here's
bits of mine:

....

What I would like to find in the new JDK is a javadoc tool that support
something like reStructuredText.

 

[Lew]

I don't use such IDEs but I'm fairly sure, they do never barf for
unused parameter names.

They have an option to mark unused parameters. I usually leave that option
unchecked, personally.

 

[Mike Schilling]

They have an option to mark unused parameters. I usually leave that
option unchecked, personally.

At times unused parameters are unavoidable, e.g. when a base class
method simply throws an UnsupportedOperationException.

C++ has a pretty nice solution here, though. If a method is declared
as, say,

void method(String s, int)

(that is, when a parameter's type is given with no name) it signals
that that parameter is unused.

 

[Hendrik Maryns]

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

Harold Yarmouth schreef:

Please keep in mind that being rude to me without justification
generally doesn't work.

You have a funny interpretation of the word ‘rude’. (Maybe this was,
but my previous comment certainly wasn’t. I would categorize it under
‘advice’.)

In the case that it can be immutable, there could be just the single
instance. As things stand, the only way to achieve that is to slap it in
a static final constant. In many cases this is the best practise anyway,
if the array makes sense to name and make easily changed by programmers.
But in some cases, it really doesn't. For instance if you have an array
of the hex digits used in only one place in your code, it's never going
to change and it's pretty obvious what it is (rather than being a "magic
value") if it occurs as a literal at point-of-use. It's just that
currently it can't really, without using the new syntax that will make a
copy every time.

I’m not following you here, sorry. You snipped some context, but my
question was why you called new Object[] {array, literal} a wasteful
duplicate. Duplicate of what? If your suggested syntax {array,
literal} were allowed, this would create an array instance as well.

You write ‘copy every time’. I think I’m getting it: you suggest
{array, literal} would be interned, similar to "string literal". In
that case the above makes sense and I will not comment on the usefulness
of interning arrays, since I have no idea about it, but right now, they
aren’t, so your argument about a duplicate just doesn’t make sense.

If you're worried that letting immutable arrays get used in such
contexts could somehow cause problems, keep in mind that this is already
possible:

int[] foo = {1, 2, 3};
...
fooMethod(1, foo, 3);

I don’t get it, foo is mutable.

It shouldn't be, since it's a direct reference to a literal (rather than
to "new int[]{1, 2, 3}".

Right, so indeed you want literals to be interned. You didn’t write
that in your original proposal, hence the confusion. In the current
setting, your suggested syntax would just be syntactic sugar; if,
however, arrays would be interned (which I seriously doubt will happen,
btw), then it would make more sense.

That's not the issue. The issue is that copying a collection is O(n) and
copying it twice thus can be significantly slower than copying it once
if n gets large enough.
ACK.


It works, but it's crude and has crummy and verbose syntax.

Oh, I totally agree with you on that one. I would simply write
Map<Kye, Valeu> vars = new HashMap<Kye, Valeu>();
vars.put(kye1, valeu1);
vars.put(kye2, valeu2);

And most of the typing would be done by Eclipse.

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

iEYEARECAAYFAkkPGXgACgkQBGFP0CTku6Mg3ACgwmuueNLHEQffdVjxeyB00vGM
Vl0AnRP6bJaHb6PXKiEqfoQ2/u8WjbpC
=/8f6
-----END PGP SIGNATURE-----

 

[Andreas Leitgeb]

C++ has a pretty nice solution here, though. If a method is declared
as, say,
void method(String s, int)
(that is, when a parameter's type is given with no name) it signals
that that parameter is unused.

That is exactly what Harold proposed for Java.

My own opinion is, that it's not worth the trouble
changing Java in this particular point.

 

[Hendrik Maryns]

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

Harold Yarmouth schreef:

I think I'm beginning to find unprovoked personal insults quite
tiresome. If Emily Post ever stumbled across this newsgroup, she'd go
white as a sheet!

Since when is pointing out a misunderstanding an insult?

No; the needed gamut of collection classes should be (and mostly already
is) in java.util.

I agree with that, but it doesn’t make the statement less true that, if
java.util (or whatever other package provided by Sun) does not contain
the wanted behavior, it is smart to go look for libraries that do
provide it. Other people probably have thought about that problem
before, and probably longer than you have (yet).

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

iEYEARECAAYFAkkPH3EACgkQBGFP0CTku6O+5ACeKxOaNXtQ9EApxS0VJjKkKIfQ
ob8An3IHXswYWigRc0Edi6x7QKV99u73
=c5fp
-----END PGP SIGNATURE-----

 

[Hendrik Maryns]

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

Harold Yarmouth schreef:

It's generally pretty clear what this does in GUI setup code:

FooButton.addActionListener(new ActionListener() {
public void actionPerformed (ActionEvent e) {
fooAction();
}
}

with

private void fooAction () {
...
}

somewhere else in the class.

You’re right, I should probably start refactoring my code to extract
some more methods out of anonymous inner classes.

It is meant to mean "this class cannot be instantiated".

Since we don’t agree here, it seems like arguments are needed. I’d
start with http://en.wikipedia.org/wiki/Abstract_type and claim that it
favors my view of the matter: an abstract class is supposed to be
subclassed. A final class forbids this and as such the combination of
those keywords if forbidden.

I can't think
of anything in Java much more "abstract" (in the English sense) than a
utilities class with no instances.

Fine, but the keyword has its specific semantic meaning and as is often
the case in computer languages, these do not always relate to the
meaning of the word in the real world.

Copy array into list, copy list into some other collection, instead of
copy array into some other collection.

You do know that the objects themselves are not copied, only references?
But still, you are right, it is a double copy.

But uggg-leee!

LOL

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

iEYEARECAAYFAkkPJpsACgkQBGFP0CTku6Nv3wCffpMifdDPczyupoyjvRF81cvG
tgIAoKG+bQn8CVJuBi4IH6PHZID84e70
=gX0V
-----END PGP SIGNATURE-----

 

[Hendrik Maryns]

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

Andreas Leitgeb schreef:

but rare and non-verbose enough to not matter all that much.

I don't use such IDEs but I'm fairly sure, they do never barf for
unused parameter names.

Oh, but you can make them to. E.g. Eclipse: Window → Preferences → Java
→ Compiler → Errors/Warnings → Parameter is never read: you can set it
to Ignore, Warning or Error.

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

iEYEARECAAYFAkkPK3sACgkQBGFP0CTku6MEsACfaHn9uryH0UJZDtEf1c4flk7m
YZsAn3RhvcG7TtpS3i20HPQbC29jwO1g
=TWo+
-----END PGP SIGNATURE-----

 

[Hendrik Maryns]

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

Andrea Francia schreef:

...

What I would like to find in the new JDK is a javadoc tool that support
something like reStructuredText.

I’d like to see Javadoc generated HTML validate (preferably in Strict,
but even Transitional would be a start), or have an option to generate
XHTML.

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

iEYEARECAAYFAkkPK9YACgkQBGFP0CTku6NaagCfUKWgQ1OWTID12S2oW2hFDWUb
7kkAoKIZmOoQcQ+LavRMyEhcGUve/GWZ
=wVBa
-----END PGP SIGNATURE-----

 

[Andreas Leitgeb]

Oh, but you can make them to. E.g. Eclipse: Window → Preferences → Java
→ Compiler → Errors/Warnings → Parameter is never read: you can set it
to Ignore, Warning or Error.

Lew (iirc) also said so.
I fail to see any sense in this option, and even more so (fail) as it
even seems to be a Java-specific option. (I'd rather understand it,
if it were an "all-languages, incl C++" scoped option.)

To me it seems about as useful as an option that warns me about
methods that do not have any multiplications in their body.

Why would anyone turn this option on? I'm curious.
I might of course just miss a sane usecase.

 

[Mike Schilling]

That is exactly what Harold proposed for Java.

My own opinion is, that it's not worth the trouble
changing Java in this particular point.

It's a fully compatible change (all existing code still works) and has no
run-time consequences; to me, that means the bar for making the change is
low. It would be unfortunate to make it the only syntax change in a
release, since it forces changes to all compilers, debuggers, code
analyzers, etc, but if it's only one of several changes, it would probably
be the most minor one.

 

[Harold Yarmouth]

Harold Yarmouth schreef:

You have a funny interpretation of the word ‘rude’.

I don't think so. If I say something, and someone pops up and bluntly
says "a poor way", then that someone was rude, at least by the standards
of civil discourse in my particular neck of the woods (if not, say,
those in New York City).

There are far more diplomatic ways to express a difference of opinion,
ones that do not impugn publicly the competence or intelligence of
whoever you are disagreeing with.

Why are you jumping into what's essentially become a personal argument
between me and Joshua Cranmer, anyway? It has nothing whatsoever to do
with Java. Really you ought to just let it drop.

On a side note, there seem to be several people here who are prone to be
disdainful and disrespectful to anyone that they don't agree with.
Whether it's their intention or not, they give off a distinct aura of
having the attitude that anyone that they don't agree with on matters of
opinion is an imbecile.

I wonder why this is? (Perhaps they are from New York?)

I’m not following you here, sorry. You snipped some context, but my
question was why you called new Object[] {array, literal} a wasteful
duplicate. Duplicate of what? If your suggested syntax {array,
literal} were allowed, this would create an array instance as well.

A single (unmodifiable) instance at class-load time instead of an
instance every time the new-expression was evaluated.

You write ‘copy every time’. I think I’m getting it: you suggest
{array, literal} would be interned, similar to "string literal".

Yes, when the array elements were compile-time constants. But having to
use "new Foo[]" at point of use would defeat that, since it would create
a copy every time. When a modifiable array is needed, this syntax would
still be available to make a modifiable copy of the constant array; it
just wouldn't be mandatory.

your argument about a duplicate just doesn’t make sense.

Your failure to understand it is not the same thing as me writing
nonsense, and I'll thank you to stop being insulting towards me in public.

Right, so indeed you want literals to be interned. You didn’t write
that in your original proposal, hence the confusion. In the current
setting, your suggested syntax would just be syntactic sugar

Even that, by itself, is not useless.

If your dislike of this proposal is out of concern that it will be
abused and arrays that *should* be named and placed in the constant
declarations won't be, please keep in mind that your argument against it
is then also an argument in favor of banning integer or string literals
in method calls, among other things.

Oh, I totally agree with you on that one. I would simply write
Map<Kye, Valeu> vars = new HashMap<Kye, Valeu>();
vars.put(kye1, valeu1);
vars.put(kye2, valeu2);

That's just going back to square 1.

 

[Joshua Cranmer]

There's probably plenty of these floating around already, but here's
bits of mine:

FWIW, this is a useful link that I just found today:
<http://developers.sun.com/learning/javaoneonline/j1sessn.jsp?sessn=TS-5581&yr=2008&track=javase>.

It's a presentation of some key features that should make Java 7 and
also some guidelines for new features (including how to formally propose
them!).

In short, what's in:

* Add some way to specify that something should never be null. Perhaps a
! or a * before or after the variable name or type name.

@NotNull, of course (see slide 46). Other aides are @Interned,
@Readonly, and @Immutable (see JSR 308). They actually spend a slew of
slides on how this entire process works.

What's probably out:

* When a type has a one-argument plus() method, + can be used when the

From the slides (49):
Long-term evolution: areas of non-interest
* User-defined operator overloading
* Multimethods
* Macros
* Dynamic typing [this is especially a "over my dead body", as they
stress at multiple times the value of static typing.]

Sounds like operator overloading is going to face an uphill struggle.

* Full closures.

The presentation is mum on closures--not surprising since there are
equally vocal activists on both sides decrying that Java is (hyperbole
here) crap for not having them and that Java will be crap if it has them
(As Neil Grafter once pointed out, BGGA is the only closures solution
its main proponents will accept, but it's also the only closures
solution that is a non-starter for its detractors). On the whole,
though, the language they use seems to indicate to me that they would be
extremely wary of accepting closures. Note that it may merely be
confirmation basis, since I personally am wary of closures (slide 9 is
the strongest basis for this statement that I see).

The said presentation dealt with language issues and not API issues.
With respect to language issues, this quote from Gosling is appropriate:
"Just say no, until threatened with bodily harm."

Several of the language features you present would probably, at least in
their current forms, violate several of the conditions they give for new
language features. In any case, they do tell you how you would go about
suggesting features, i.e., the Kitchen Sink Language approach (better
known as "actually implement it and see what happens.").

 

[Harold Yarmouth]

Read the archives of c.l.j.p of around 1.5-2 years ago, especially those
posts from someone whose first alias is Twisted. Then you'll understand.

I don't. *He* may have said nasty things about Joshua, but I don't see
how that is at all relevant to the question of whether or not *I* have
done so.

And if he did so two whole *years* ago, and no more recently than
three-quarters of that span, then it seems fruitless to dredge up such
ancient history anyway. Fruitless and, perhaps, dangerous -- do you want
to reignite some presumably-acrimonious dispute from ages past? I'd have
thought you had better uses for your time, as with everyone else in this
newsgroup who'd have to read or filter all of the resulting
probably-non-Java-related spewage.

In short, this Twisted might search usenet for mentions of his name, or
might still be lurking, and now he might pounce. And none of this has
anything whatsoever to do with me anyway.

 

[Joshua Cranmer]

I don't. *He* may have said nasty things about Joshua, but I don't see
how that is at all relevant to the question of whether or not *I* have
done so.

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

 

[Harold Yarmouth]

All the sorts of comments that cause Paul to go into a bloody rage when
said to him, but of course, perfectly all right when said by him.

Once again, I don't see any relevance. What some guy named Paul would or
would not do in response to some remarks has no bearing on things when
those remarks were said to Joshua Cranmer instead, and whether or not he
would say the same remarks has no bearing on whether or not I would.

And not true. You were not insulting Paul, gratuitously or otherwise.

No, he was insulting me.

Why do I have the funny feeling that I've just stepped into the Twilight
Zone or something? I propose some things for Java, which is constructive
and on-topic; Joshua replies solely to dump on me, for some reason that
only his therapist is probably qualified to assess; I take umbrage at
being dismissed in such a disdainful manner with little in the way of
actual argument and with zero diplomacy whatsoever; and then you, for
some reason, take umbrage at my actually speaking up in my own defense
and in defense of my suggestions. And then people start talking about
some ancient dispute between Joshua and some other guy, and drop the
name of some *other* other guy, and seem to think that it's somehow
relevant.

Is this the general treatment people can expect here if they suggest
that something about Java be changed? To have their fairly long and
detailed suggestions rejected summarily with a brusque "that's awful"
type of reply, one that doesn't even hint that the replyer even bothered
to read or think about the proposal in detail before making his
judgment, and one that implies that his judgment carries some kind of
official stamp of finality -- that his opinions on the matter are as
good as facts?

And is disagreeing with such a person some kind of taboo here? The
over-the-top reaction to my standing up to what looked more like
bullying than reasoned criticism certainly seems to suggest so.

If that is indeed the case, then I won't be posting to this group any
more, once I have disentangled myself from this debate and the one in
the Date/Calendar thread.

(Note that I have not claimed that Joshua's response was actually not
based in reason; for all I know, it actually was. But it was phrased in
a manner that didn't indicate that it was -- just a quick brush-off,
without any written reasoned explanations for his opinions and
disagreement with my proposals. If he had real, thought-out reasons for
rejecting something, though, why not explain his reasoning? Why just
appear to be dismissing it out of hand, *and* in a manner that suggests
that he thinks I'm an idiot? And even if he *does* think that I'm an
idiot for proposing some of those things, why make that opinion public,
when doing so can accomplish nothing except to possibly start a fight
that in turn can not conceivably serve any legitimate,
Java-discussion-related purpose here? Where I come from, people are
taught from an early age that if you disagrees with someone else's ideas
you should explain, rationally and without name-calling or other
nastiness, why you disagree, or simply ignore them, rather than try to
start a fight.)

 

[Harold Yarmouth]

It is used internally a lot.

Fortunately, the internals can conceivably be redesigned without
changing the interface.

 

[Joshua Cranmer]

Is this the general treatment people can expect here if they suggest
that something about Java be changed? To have their fairly long and
detailed suggestions rejected summarily with a brusque "that's
awful" type of reply, one that doesn't even hint that the replyer
even bothered to read or think about the proposal in detail before
making his judgment, and one that implies that his judgment carries
some kind of official stamp of finality -- that his opinions on the
matter are as good as facts?

Note that this newsgroup is *not* the place to go to suggest that Java
be changed. 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.

As for my opinions being "as good as facts," that is a poor
qualification. I have provided (albeit, to be honest, not in my first
posting) a citation of the people whose views /are/ as good as facts,
and one can in general extrapolate from Java's history, most notably an
extreme frugality in core language additions.

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.

And is disagreeing with such a person some kind of taboo here? The
over-the-top reaction to my standing up to what looked more like
bullying than reasoned criticism certainly seems to suggest so.

No, but preceding to insult someone is. 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. I'm
not sure if that's just because we've built up extremely thick skins and
many of the more embroiled folk on this forum (e.g., Twisted, zerg,
etc.) have not-so-thick skins...

Your response to that riposte was far more insulting and represented the
taboo escalation.

Where I come from, people are taught from an early age that if you
disagrees with someone else's ideas you should explain, rationally
and without name-calling or other nastiness, why you disagree, or
simply ignore them, rather than try to start a fight.
Quotation:

Sure I have. Did you even bother to read my entire post before
clicking "Take A Crap All Over It And Send" in your news reader?

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--which I might add, you were quite terse
in your original posting as well--while the same quality does not seem
to be present in this first counter-riposte.

 

[Harold Yarmouth]

The primary purpose of unchecked conversions is to facilitate migration
to generics at disparate times.

No, unchecked conversions have other, commonplace uses.
Frameworks/reflection, for starters, and there are other cases where
they can't always be avoided because the compiler sometimes just isn't
smart enough to prove everything the programmer can about what types can
actually be occurring where.

I feel that your response is inadequate.

I frankly don't give a shit, and furthermore, I am getting rather fed up
with your unpleasant attitude toward me. Shape up or stop posting
replies to my posts.

My response was not inadequate. It's possible that your comprehension of
it was. In fact, given the way you are behaving, at this point I'd say
it's even likely.

My guess is that you're dead-set against operator overloading, probably
at least partly for emotional reasons, and that is why you refuse to
actually seriously read and consider proposals for them, and furthermore
why you respond with mild but noticeable rudeness whenever the subject
comes up here.

My suggestion, if your opinion is set in stone and not subject to
further debate, is that you simply ignore other peoples' discussions of
operator overloading and allow them to have such discussions in peace.

See
<http://groups.google.com/group/comp...a94b1020c6/d1a9b67ddd23f8f9?#d1a9b67ddd23f8f9>
for the start of a thread in which I discussed this particular issue at
length

Sorry, but if you want to explain your reasoning, you'll have to
actually explain your reasoning, not fob me off with some URL that's so
long it won't work (with this news software at least) anyway.

Pointing someone to a canned response is not a discussion, and the
purpose of this newsgroup (like most newsgroups) is discussion, not
shooting down everything anyone says with prefabricated, non-negotiable
responses.

Other postings on that thread reveal my opinions on operator
overloading more clearly.

Oh, this thread has sufficed to make your opinion of operator
overloading more-than-adequately clear.

The problem here is that you apparently feel the need to try to shut
down discussion and impose your opinion on everyone else, by punishing
anyone who tries to discuss operator overloading in an open-minded way.
Said punishment accomplished by being nasty to whoever dared to do so
and by insulting that person in public. Anyone that stands up for
himself and calls you on doing so, of course, gets another dose for his
efforts.

Fortunately for free speech and democracy, you've just stumbled across
someone who will continue to stand up to your bullying and will not
knuckle under to such a childish and anemic form of intimidation. (And
you'd find I'd still not knuckle under to considerably worse forms of
intimidation, if you had as much ability to use force against me as I
suspect you wish you did.)

The appropriate behavior in response to finding speech you don't like on
the Internet is to ignore it, not flame whoever wrote it. Usually
applied to pornography and politics, but equally applicable to operator
overloading.

* You cannot assume that any operation is commutative. Even for stuff
like multiplication (matrix multiplication is, in fact,
non-commutative), the LHS could be causing a mutation and therefore need
to be evaluated before the RHS.

The contract for .plus should include commutativity. That leaves .times.
There, one could specify that if times is noncommutative there be a
..leftHandedTimes (or whatever name seems most suitable) that reverses
the roles of LHS and RHS.

* "Inverting" operations is often perilous. Dividing by a matrix is
conceptually equivalent to multiplying by its (pseudo)inverse, but
inversion is one of the worst things one can do where solving a matrix
equation is preferred.

So is using floats for currency.

It is not the job of the language designer to enforce against every
conceivable misuse of a language feature, least of all to do so by
simply refusing to add any features at all for fear that they might
otherwise be abused.

I can easily picture misuse of / for matrices, but I can easily picture
intelligent use, too. For example, instead of actually inverting the
matrix, .invert or .dividedBy or similarly can generate an object that
symbolically represents the operation applied to the curried arguments,
and only when some method is invoked to try to extract an ordinary
number of some sort out of a chain of computations does the object
representing that chain and its bound arguments begin to perform actual
numeric calculations, which it may then do using whatever strategy seems
appropriate -- perhaps even employing the Strategy Pattern under the
hood to do so. It might, for example, end up performing row reduction of
the matrix together with some other stuff using a numerically-stable
algorithm when used one way, and simply invert the matrix when all you
have is "System.out.println(m.invert());". (In this case, the
inverted-matrix object's toString method would calculate the inverse and
print the results. Probably by row-reducing the matrix adjoined to an
identity matrix, in the textbook-recommended fashion.)

The main thread on which I discussed this

is not relevant to the present discussion. As I have already indicated,
I am not here to argue with canned replies. I am here to have civil and
intelligent discussions with educated adult human beings.

It follows that if you are not interested in doing so then you are not
interested in me, and I therefore recommend that you ignore (or even
killfile) me rather than continue this.

The authority is by the people in charge of the languages--in Java's
case, the JSR expert groups.

The problem here is that you seem to be behaving as if you are
arrogating that authority for your own personal use. Even if you
actually sit on one of those expert groups, you are one voice among
many, and therefore pretending to be somehow "in charge of Java" is
deceptive as well as rude.

No language exists in a vacuum; note that Java's generics feature
is roughly based on C++'s templates, at least in terms of syntax.

But this was not mandatory. It could have been done differently; it just
didn't turn out to be.

(In this case, there don't seem to be all that many alternatives anyway,
other than to change the delimiters to other than < and >. Also,
arguably the use of a very C++-like syntax was a *bad* move because the
semantics are quite different owing to type erasure.)

LISP is not close to Java

My point was that it was one of the first successful high-level
languages, so if your "rule" that languages can't deviate too much from
what else is popular at the time had any actual force, we wouldn't even
be sitting here having this discussion about operator overloading --
you'd have just shot down my suggestion to allow infix notation for
common arithmetic operators instead.

... that makes no sense

To you, perhaps.

To make it less verbose than my example requires several orthogonal steps:
1. A constructor that takes an array of pair objects.

Easily done.

2. A "neat" way to create pair objects.

Pair literals could be added, surely.

3. Reduced verbosity in array creation expressions.

Also quite possible.

If either of the last two does not happen, the creation will end up
being more verbose.

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

In my experience with languages such as C and C++

Your experience with "languages such as C and C++" is not relevant. We
are discussing Java. Your experience with Java is thus the only thing
along those lines that would be relevant.

"... our reactions to basic proposals before repeating the proposal
without adding anything new to say."

So your objection is now that I was *unoriginal* in some way?

No idea exists in a vacuum. You'd be hard pressed to find any idea that
was 100% "original" in this or any other newsgroup, or anywhere else for
that matter.

If you have nothing new to say (as evidenced by your repeatedly pointing
me to some URL with some canned pre-written response you have for all
proposals of operator overloading in Java), and you don't think I have
anything original to say either, then why are you saying anything at
all? Why not just ignore this thread entirely? Why choose to join it and
then complain that it's "not original enough" for your liking? Why go so
far as to actually denigrate the thread's OP for being "unoriginal"? It
can't possibly serve any constructive, Java-discussing purpose for you
to do so, after all.

Why not just step out of the way and let other people discuss any
Java-related topic they please, by just staying out of those topics that
you find tiresome, repetitive, or otherwise uninteresting or annoying,
and especially those to which you don't have anything novel to add?

Why tear someone down for making an effort to be helpful?

Especially, why blast them IN PUBLIC for doing so?

Is making a good-faith effort to be helpful such a serious crime?

It's not that I don't like them, it's just that no one bothers to add
anything new, so it's the same bloody stuff being repeated once every
month or so.

If that's your opinion, then you should just ignore the subject whenever
it comes up. Attacking everyone who wants to participate in such
discussions, simply for doing so, is inappropriate behavior and even,
I'd argue, an affront to the concept of free speech.

I would expect that someone should avoid repeating points belabored to
death before posting something.

I would expect that someone should respect the right of the people to
peacably assemble and discuss Java programming here. If some people here
wish to have a civil, level-headed discussion of operator overloading, I
see nothing in the newsgroup charter to forbid it, or to justify your
hostility towards them for doing so.

Though I notice something else interesting -- you seem to be focusing
that hostility upon me, rather than distributing it evenly among all
those who have participated in this thread in a less "my mind is made
up, operator overloading sucks" fashion. Perhaps because I'm the OP of
the thread in which the subject came up?

No matter. It is inappropriate behavior for an adult to complain about
the topic of a non-off-topic post to an unmoderated Usenet newsgroup,
and inappropriate behavior for an adult to be personally rude and
denigrating towards another person without just cause. I had been
inoffensive and civil when you first publicly impugned my intelligence
and/or competence, and I consider your doing so therefore to have been
uncalled-for.

It doesn't take much effort to determine if what you are about to
add is something that has been recently discussed

Why should I? It's not off-topic for this newsgroup, so if I want to
discuss it, that's well within my rights. And if you *don't* want to
discuss it, ignoring me is well within yours. If, as you seem to be
trying to imply, *nobody* wants to discuss it, they can *all* ignore me.
That they haven't, and that some have been interested rather than
hostile, suggests to me that it is *not* true that *nobody* wants to
discuss it, and your apparent efforts to derail a discussion among
consenting adults is thus especially offensive to anyone who values
freedom of speech and democracy.

If you don't like people discussing operator overloading here, killfile
the phrase, or the threads where it comes up. If you think there should
be a Java programming forum that doesn't have operator overloading
discussions, go start one. PHPBB is free and open source and hosting is
cheap these days, or you could promote the creation of
comp.lang.java.programming.no.operator.overloading.discussions.please.moderated
(or simply go ahead and create
alt.lang.java.programming.no.operator.overloading.discussions.please.moderated).

Perhaps, though, you like to unthinkingly and uncritically bash operator
overloading and anyone who you suspect may not be dead-set against it,
and would much rather do that than simply ignore the entire topic.

In that case, I'd suggest instead
alt.java.operator.overloading.sucks.sucks.sucks as an appropriate group
to create to suit your fancy while leaving those of us who like to
discuss operator overloading in Java civilly to do so here in peace.

 

[Harold Yarmouth]

Harold Yarmouth schreef:

Since when is pointing out a misunderstanding an insult?

Pointing out a misunderstanding, in and of itself, is not an insult.

Publicly accusing a specific person of stupidity, on the other hand, is
an insult.

This is a forum for discussing Java programming, not for assigning blame
and arguing over who is at fault.

But now that you've raised the issue of blame and now that my
intelligence and competence have been publicly called into question by you:

If there was a misunderstanding, and if it was a particular person's
fault, then it was your fault, not mine.

I agree with that, but it doesn’t make the statement less true that, if
java.util (or whatever other package provided by Sun) does not contain
the wanted behavior, it is smart to go look for libraries that do
provide it.

How do you find such? For things like adding .xpm image support you
search for ".xpm image support java" or ".xpm image library java"; for
esoteric math stuff "math library java"; etc.; but searching for
collections will lead directly to Sun's java.util API docs and related
content, and will lead to little else.

(Indeed:
http://www.google.ca/search?q=colle...s=org.mozilla:en-US:official&client=firefox-a
Collections (Java 2 Platform SE v1.4.2)
Trail: Collections (The Javaâ„¢ Tutorials)
[PDF] Collections in Java
Overview of the collections Package
Java Collection Framework
Get started with the Java Collections Framework - JavaWorld
Amazon.com: Java Collections: John Zukowski: Books
Primitive Collections for Java
[PDF] Java Collections Framework
Java Generics and Collections | O'Reilly Media

Of these, only two are not about the java.util collections. Primitive
Collections for Java provided collections for unboxed primitive types,
more or less obsoleted by Java 5 generics and autoboxing. Overview of
the collections Package seems to be about a port of the Smalltalk
collections to Java. The functionality, aside from Bag, is basically a
duplicate of what's in java.util, but with different class and method
names in general, and a different mechanism for getting unmodifiable
collections (explicitly instantiate unmodifiable classes rather than
call wrapping methods).

No WeakValueHashMap or anything similar.

Say, anyone noticing a sharp drop in the utility of Google results
lately? Often half or more of the top ten links have no "Cached" and the
content at the other end of the link, and that Google's result list
excerpted, is behind a paywall in some manner or another. Either it's
only available by ordering a physical book or it requires signup. I've
had to filter JSTOR because that site produced so many Google hits I
couldn't use on so many diverse topics, and there's a ton of other
candidates for the same treatment, mostly scientific journal sites. If
you ask me, it's dishonest for Google results to show excerpt text that
isn't actually part of what's available without any registration at the
link destination. The question is who is being dishonest, Google or the
sites? I think the sites must be doing something sneaky, like letting
Googlebot see things behind the paywall, but Google must be being
somewhat permissive too; they really should verify that what Googlebot
is seeing is the same as what is freely accessible one click away from
the search result link. One way to do that would be to make the result
links redirects that go through a Google URL, also letting them get more
stats on search use, and whenever one is used, Google visits the site
after a random delay, disguised as a normal user, and compares what it
sees with what the index says Googlebot saw. If they're different, the
site gets its pagerank nuked for its efforts. That and adding an option
to exclude book results and anyone who wanted to could have the old,
pre-2007-or-so Google back.)

Other people probably have thought about that problem
before, and probably longer than you have (yet).

I don't know if this was intended as an insult, or just as a silly
suggestion that nobody be allowed to suggest or ask for anything without
first getting a comp sci Ph.D. or something.

Regardless, there is nothing in the newsgroup charter that says that any
kind of certification, degree, or other qualification or measurement of
experience or expertise is a prerequisite for posting here. So I have
not transgressed any rules and I will therefore resist any attempt to
judge me or sentence me, by you or by anyone else, for any supposed
transgressions.