If it were just a matter of opinion, you could have left it like that a long time ago, but instead you have presented a long series of factual claims intended to show that yours is the only reasonable opinion, and I am merely responding to them. For example, your claim of exponential complexity was not just a matter of hyperbole, you backed it up with an explanation: "...because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all." If that is no longer your position, say so, and we can move on.

Another recurring factual claim is that there is a set of people that will understand this issue only if it is presented in a very specific way. Putting aside, for the moment, the question of how well that worked out in practice, let's look at what characteristics you have ascribed to your target: 1) They didn't get it as presented in the original article; 2) They have read what the JLS says about it, but did not understand it there; 3) They could not be led, through a suitable explanation, to follow what the JLS says; 4) Any explanation based on computing basics would be beyond their grasp; 5) Despite all this, they understand (and not just think they understand) the more complex issue of argument-passing in C++. It seems unlikely there is anyone in this set. In particular, while there seem to be people in group 3, I doubt any of them have made it into group 5.

As for an alternative explanation, we have, for example, eslaught's post: https://news.ycombinator.com/item?id=9249285 The first paragraph gets to the essential point with admirable directness, without using any comparison to a language that has a particularly complex array of argument-passing cases.

It's always been a matter of opinion. Most people don't take conversational prose literally and argue against it as if it was a fact that needed refuting.

For example, it is your opinion that C++ argument-passing is more complex; it is mine that it is more explicit and easier to reason about. Notice how I don't take your claim and call it a fact and write pages about how you must back up your claim with some more evidence before I'll buy it.

Most people would recognize that "...because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all" is not just "conversational prose", it was intended to to look like a factual argument for a proposition (notice the use of "because".) If it doesn't need refuting, that is only because it is so obviously wrong.

I think many people would agree that, since you challenged me to present an example, and I did, then it is quite reasonable for me to ask if it has changed your opinion that any alternative to your approach would be infeasibly more complicated, and if not, why not.

I'm sorry, where did I say that "any alternative to my approach would be infeasibly more complicated"?

It is true that while you have tried repeatedly to imply there is no viable alternative, you have not explicitly ruled out some so-far unmentioned alternative. Nevertheless, you were very explicit when you made this argument against one class of alternatives:

"Sure you could do it that way. But it becomes exponentially more complicated because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all. Neither is ideal."

So it is reasonable for me to ask if the example you asked for changes your mind on this issue.

I asked you to write up an example using stack frames and addresses independent of any language. You have yet to do it.

The comment you linked to is much more reasonable than that and only introduces a little more complexity. But it is still more complex in my opinion because it uses both stacks/locals and heaps/objects as well as referencing C++, and I don't think someone who confuses Java for a pass-by-reference language will understand that any better.

If your goal in all of this is to try to change my opinion, you will need to keep trying. Why you would spend all this time on it is beyond me, but since I enjoy correcting your fallacies and you seem to enjoy grasping for ways to appear like you've accomplished something with all of your replies, we could be doing this for quite a while.

Keep it coming.

To paraphrase Ian Fleming: No, Mr. Noakes [, I don't expect you to admit to even changing your mind], I expect you to continue to offer evasions, misrepresentations, irrelevancies and self-contradictions in an attempt to rewrite the record.

Your response is exactly what we could predict: after a couple of posts in which you try to ignore the first paragraph of eslaught's post, you attempt to rewrite the issue by bringing in his following two paragraphs, which are about a different topic (ironically, their topic is the unsuitability of C++ for this discussion!) The first paragraph stands on its own and is not dependent on, or even supported by, on the following two paragraphs.

So you really would like us to believe that your judgement is such that you find this straight-to-the-point ("you still have no way to modify the variable binding on the caller's stack") argument slightly more complicated than yours, which includes a couple of other long, snide-remarks-laden threads (something you obviously have a predilection for), and a couple in which you finally abandoned your approach, telling people to read the JLS instead?

Tobani, for one, found eslaught's post helpful: "I get what you are saying."

Furthermore, the most you are claiming now is only that eslaughts's post (even in its entirety, including the parts not relevant to this discussion) is just a little more complicated than yours. This is very different from your initial claim (despite your attempt to mis-characterize it as "conversational prose" when it contains an explicit argument attempting to establish a fact - see my recent post above.) Even if we consider the use of 'exponential' as misleading hyperbole, it is still a claim that any such alternative would be inordinately more complex. Therefore, the fact that you are now arguing for only a little more complexity is a tacit admission that you now realize your initial claim was mistaken.

Until you are ready to demonstrate some level of courage in your convictions, there is no point in me posting an alternative explanation here, only to have you willfully misrepresent it in the same way as you did for eslaught's post. If, however, some genuine third party joins in the discussion and requests it, I will be happy to present an alternative.

> after a couple of posts in which you try to ignore the first paragraph of eslaught's post

I wasn't ignoring it - it was irrelevant.

> This is very different from your initial claim

No it isn't - I never claimed anything about eslaught's post, directly or indirectly, before that.

> 'exponential' [...] it is still a claim that any such alternative would be inordinately more complex

You repeat this as often as you can, like it's somehow your only real point here. And every time, I point out that I made no such claim. The only claim I made was that your specific explanation (which you never actually wrote), which you said would include stack frames, machine addresses, and the like, would be much more complex than referring to C++, in my opinion.

You haven't refuted that, even though I am amused that you keep trying.

You also haven't changed my opinion, and as you can guess, I'm equally amused that you keep trying there too.

Continue, please.

No problem - these replies practically write themselves. I usually have a good idea what I am going to write even before I read your next evasion, and you keep giving me new material to work with.

A case in point: your attempt to claim that eslaught's explanation is irrelevant. Of course, it is not - characteristically, you have offered no counter to my explanation of how it gets directly to the point - and of course you were not thinking it was irrelevant when you tried to argue that it is marginally more complicated than your approach. Only after I pointed out that by doing so, you had tacitly admitted to a complete reversal of your position, did it occur to you that it was a mistake, and decided that you would have been better off claiming that the explanation is irrelevant, even though that claim won't stand up. So instead of expunging one of your inconsistencies, you have added another case where you contradict yourself in attempting to rewrite the record.

You also claim that this isn't what you were thinking of. Well, if you didn't think through the full scope and implications of what you were writing, that would be yet another mistake on your part, wouldn't it? We are, however, now entitled to wonder why, precisely, you think you can retrospectively rule this explanation out. As I wrote before, until you can demonstrate the integrity of committing to something definite that you will not attempt to rewrite later, there's no reason for me to post an explanation here.

You seem to start your posts with a lot of rhetoric, and then you repeatedly fall flat on your face with substance.

> you had tacitly admitted to a complete reversal of your position

> until you can demonstrate the integrity of committing to something definite

My position has never changed, nor has my opinion. I still believe C++ was a useful analogy to the problem at hand (people misunderstanding Java references and pass-by-reference), and I still believe that any explanation involving machine addresses and stack frames that you could write (which you continue to refuse to do) would be more complex than comparing to C++.

If you care to take your umpteenth failed swing at that, go right ahead. I already know what's going to happen though. "Failed attempt at rhetoric, misrepresenting of opponent's position, arguing against the failed position".

I should advise you, though, that if you are going to keep wasting your own time flailing around in this thread, you should try to have a modicum of self-respect by sticking to what I say in your replies. Arguing against positions that don't exist may make you feel like you are getting somewhere, but really all you are doing is entertaining me.

But if that's your goal, and I'm misunderstanding you, then ignore the previous paragraph, and keep it coming :)

So I have been advised by jj not to continue. Coincidentally, in what I think was an unrelated yet eerily similar experience, a squirrel hissed at me from its tree while I was running today.

Once again, you attempt to rewrite the record, this time with a bland statement that you might now wish you had limited yourself to, but so long as you insist that you have not changed your mind on anything, then then I have the option to mention the various arguments you have offered for what was a much more emphatic position - to give just one example: "Sure you could do it that way. But it becomes exponentially more complicated because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all. Neither is ideal." That is not just "more complex", and it is not just an opinion, it contains an argument (an apparently faulty one, but an argument nevertheless.)

So long as you continue to deceptively misrepresent your former opinions and statements, there is no point in me posting an alternative here for it to be similarly misrepresented, but I will repeat my offer to do so if a third party gets involved.

As most of your last post was devoted, once again, to claiming (without any attempt at justification) that I don't have a leg to stand on, it seems negligent of you to omit making an attempt at a refutation of even one of the many points I have raised in the course of this thread - anyone would think that it is yourself who you are actually describing. I am sure it is just an oversight, so here's one example for you to tackle, left unanswered from the very post you were replying to: what do you think is wrong with eslaught's explanation?

> what do you think is wrong with eslaught's explanation?

Who said anything was wrong with it? All I ever said about it was this:

https://news.ycombinator.com/item?id=9393447

Which says nothing about it being wrong.

In fact, to back up my opinion that his post is slightly more complex, and perhaps harder to understand, here's a thread where I in fact use an even simpler explanation than eslaught's, and the person I was explaining this to still didn't get it. Even they brought up C++ to try to clarify their position, and it turns out that by doing so they actually ended up proving themselves wrong.

So in at least one concrete case, using C++ was actually better (more precise with fewer words and examples).

https://news.ycombinator.com/item?id=9248590

But I really did mean that I was entertained by watching you make stuff up and repeatedly fail at whatever your goal is, so by all means, don't stop now :)

It is said that for a goldfish, each turn around its bowl is a new experience, because it remembers nothing of its previous circuits. You appear to be in the same situation, unaware that each claim you make is contradicted by something you wrote earlier.

Take, for example, "all I ever said about it was this". What you actually did was first make the claim you are now repeating, and then, when I pointed out that doing so completely contradicted your original position, you changed your mind and decided that Eslaught's explanation was irrelevant (https://news.ycombinator.com/item?id=9433742). Now that I have asked on what grounds you consider it to be irrelevant, you have circled back around to your original position, creating a lose-lose situation in which you have contradicted yourself regardless of what your actual opinion is.

You have reached the point of creating epicycles of contradictions within contradictions, as all this is going on within your larger contradiction of first claiming inordinate complexity of any alternative to your approach and then trying to rewrite that as being merely a claim that there is necessarily some slight increment in complexity in avoiding C++. Let's look again at what you actually wrote:

"Sure you could do it that way. But it becomes exponentially more complicated because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all." https://news.ycombinator.com/item?id=9266387

That is not a claim of just slightly more complexity, and the phrase following 'because' is an attempt to offer some sort of explanation for this claim. It is obvious to anyone that you have changed your mind on this, and you have never attempted to offer any justification for the 'because' phrase, but so long as you insist that you have not changed your mind, it is not unreasonable for me to point out that you are still wrong even after one more turn around the bowl.

Furthermore, in attempting to present an example, you are having a problem with logical quantifiers. Putting aside the absurdity of claiming to believe that this sorry dialog is simpler and more straightforward than Eslaught' straight-to-the-point paragraph (the first one in https://news.ycombinator.com/item?id=9249285), one example cannot establish the general claim you originally stated, and your attempt to do so is simply an error in logic.

I see that my goldfish analogy is not quite complete - your revolutions are getting faster and tighter. This is not so much the trajectory of a goldfish in a bowl as one being flushed down the toilet.

Two goldfish swim around a bowl. One follows the other, preaching about how sad it is to swim in circles all day...

> I pointed out that doing so completely contradicted your original position

And I pointed out to you that I haven't contradicted myself.

Since you seem to have lost the thread, I'll help you out.

    https://news.ycombinator.com/item?id=9486220

Do you think you can find your way? Or should I link to the rest of it?

> It is obvious to anyone that you have changed your mind on this

I haven't changed my mind at all. Where did I say I have? Can you link to it for me please?

> I have asked on what grounds you consider it to be irrelevant

You didn't ask that. You asked "what do you think is wrong with eslaught's explanation?" I'll link you there too...

    https://news.ycombinator.com/item?id=9549017

> in which you have contradicted yourself regardless of what your actual opinion is

You keep using that word. I do not think it means what you think it means.

Looks like I was right about my prediction:

    https://news.ycombinator.com/item?id=9486220

Please come up with something new to entertain me. Don't get me wrong... this "contradiction" and "your opinion is wrong" quest was fun, but if it's all you've got, let me know - I'm only interested in wasting my time on such a vapid conversation if I continue to get a kick out of it. To do that, though, I need some new crazy from you. Old crazy doesn't cut it any more.

And try not to take so long to do it. I do so look forward to reading your ridiculous replies; you took so long on this past one that I thought you might have finally gotten some sense somewhere.

I'm glad I was wrong :)

It seems that every time I say something, you feel the need to parrot it back, except that you often get it wrong in a way that shows you just don't get it. For example, after I described a couple of your bogus arguments as rhetorical tricks, you decided to call some of my words rhetoric, when they were simply ridicule. Now that I have found occasion to make a goldfish analogy, for some reason you seem compelled to also mention goldfish, but you do so in a way that quite obviously applies slightly (or exponentially, as you would put it) more to you than me.

This form of discourse, in which one party simply repeats back the claims of the other, as if they were applicable without having anything to support the reversal of attribution, might be called the "no, you are" style, on account of this being a phrase that is commonly used by its main adopters. As it happens, there is a video on that subject, and as you have repeatedly said how much amusement you get out of these exchanges, we can expect this will probably have you rolling on the floor: https://www.youtube.com/watch?v=ZRx8PFdurgo

With regard to more substantive matters, I think you should know that if you post a link to a claim that was made without any supporting evidence or justification, it does not magically gain those things in consequence. On the other hand, links that did have those things originally retain them, so we can see that your earlier statement

"Sure you could do it that way. But it becomes exponentially more complicated because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all." (https://news.ycombinator.com/item?id=9266387)

stands in contradiction to your later attempted rewrite

"The only claim I made was that your specific explanation (which you never actually wrote), which you said would include stack frames, machine addresses, and the like, would be much more complex than referring to C++, in my opinion." (https://news.ycombinator.com/item?id=9433742)

Just to be clear, you didn't try limiting it to a statement by me until after you had made the first statement and I pointed out its problems (https://news.ycombinator.com/item?id=9269186), and not even then, immediately. Only after I showed that you couldn't explain it away as 'conversation' did you try to rewrite it as in the second quote above.

more significantly, you have refused to offer any justification for the phrase "because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all", which Eslaught demonstrated to be false, while you are apparently still claiming never to have been wrong.

I repeat my statement that I will present an explanation once you show the courage of your convictions by saying what, in your opinion, is wrong with Eslaught's straight-to-the-point explanation:

"Except you still have no way to modify the variable binding on the caller's stack. This is what all of us in the "Java is call-by-value" camp keep yammering on about: changing a value on the heap (an array or object in Java) is not the same as changing a variable on the stack (a local variable in Java). In Java, you can never touch local variables on parent functions' stacks, therefore, Java cannot be considered pass-by-reference."

You are trying to wriggle out of dealing with this one by making a distinction between "wrong" and "invalid", an act of desperation which underscores that you have run out of ideas. If Eslaught's statement is invalid, then it is wrong as a refutation of your original statement, but you have no argument for that however you choose to put it.

Of course, it is utterly self-serving for someone who tried to dismiss one of his bigger mistakes as 'conversation' to be pedantic over usage now.

One of the more revealing things in your responses are the points you try to ignore. In my previous post I showed that you had made a fundamental error in logic, which you have ignored, so we can add it to the list of mistakes you haven't made. That said, even though your logical error means that the example you gave there is not relevant in the way you claimed, it is worth looking at. As you yourself point out, Solipsism introduces C++ into the discussion and messes it up. That's the best example you can offer of how C++ simplifies the explanation? Really? It's obvious to anyone just how self-serving your arguments are.

Given your copycat tendencies, can we anticipate a video in your next reply? And will it be self-referential? The one thing we can be sure of is that there will be another reply.

I got so excited when I saw the wall of text! I thought, "I will surely be entertained, for there must be some new crazy somewhere in there".

But I was wrong.

You are still going on about old crazy. You still think you can tell someone what their opinion should be, or that they shouldn't use phrases like "exponentially more complex" and "much more complex" without them being incorrectly and repeatedly accused of being contradictory.

And you still think that the confused folks in this thread understand the distinction between "local variable object references" and "the objects they reference", even though you yourself are referring to Solipsism's thread in which he does not understand that even after translating it to a language he is more familiar with?

Sorry mate. But don't despair, I'll give you one more shot. But bring some new crazy please, and shorten up your ramblings a bit.

Or I'm afraid I'm going to lose interest :(

It's good to have the old JJ back! - the one who wasn't afraid to display his impotent apoplexy. It's so much more entertaining (and probably honest) than the faux bonhomie that you rather heavy-handedly affected in your last few responses. I could tell, somehow, that you were still there.

And you return bearing a gift, in the form of your paragraph about Solipsism's comments. Firstly, you are making the logical error of trying to affirm a general claim with a specific instance. This means that the example cannot possibly settle the matter in your favor, but it can still do damage: your best example of the helpfulness of C++ in explaining Java argument-passing is a case where someone used C++ and got it wrong. This is risible, and your statement about Solipsism's familiarity with C++ only makes it more so. Thanks, JJ! While your act of self-implosion makes my opinion moot, I personally would advise Solipsism to read Eslaught's explanation, with special attention to the first paragraph of his last post (https://news.ycombinator.com/item?id=9249285)

Beyond that, I see you are again trying to rewrite this thread by repeating a couple of excuses that have already been effectively refuted: "it's just my opinion" and "it's just conversation."

You seem to think that calling a statement an opinion immunizes it from being wrong, but it doesn't work that way. An opinion (or set of them) that is self-contradictory is wrong, and similarly, so is an opinion that is contrary to established fact. These opinions are not even worth giving any further consideration; notable examples include flat- and hollow-earth theories, and creationism.

So, putting aside for the moment your self-serving attempt to have everything except your mistakes taken literally, even a 'conversational' reading of "Sure you could do it that way. But it becomes exponentially more complicated because you need to either stick to one specific implementation of one specific language runtime, or you have to deal with explaining them all" finds that you are claiming a stack-frame based explanation will necessarily be inordinately complicated, and even more so when read in its original context (including your precursor posts.) So when you judged (in what is surely a minority self-serving opinion) that Eslaught's explanation was only "slightly" more complex than a C++-based one, you tacitly admitted that your original 'opinion' doesn't hold water. As soon as I pointed out that you had done this, you changed your opinion of Eslaught's explanation, now claiming that it was invalid in some way. Not only was this itself a change in your stated opinion (and a dead giveaway that you knew this to be so), but you created a contradiction with your first evaluation of Eslaught's explanation: if it is being judged as slightly more complicated than the one you prefer, then it is has already passed muster (and nobody but you would question that, anyway.) This is just one more example of how your attempt to claim you have made no mistakes has led you into making more.

But the idea that you are merely presenting your opinion is itself an attempt to rewrite the record. Your original claim was to have made no mistakes, and you only tried to pass your mistakes off as opinion, and thereby claim for them an imaginary immunity from being evaluated, once you realized your factual claims did not stand up. For example, take the clause following "because" in the first quote above. In the context of its use (i.e, following "because"), it has only one purpose: you are presenting this as a basis in fact for your claim of complexity (and also perhaps that you meant 'exponentially' literally, even though it doesn't work as such; whether you are a reliable reporter of your opinions is an issue we will get to later (hint: you are not even a reliable reporter of what is in the record for all to see.)) The 'because' clause is a factual claim refuted by Eslaught, and this in turn shows that even if the cause before 'because' is taken 'conversationally', the statement as a whole is contrary to fact.

We can tell where you know you are wrong by your repeated avoidance of the issue, and the above "because" clause and Eslaught's explanation are two of the more blatant and repeated cases (the latter after your backfiring attempt to dismiss it.) Because we can see that you know you are wrong, and yet continue to insinuate that my refutations are faulty without daring to make definitive claims, we have to conclude that you are probably dissembling, which in turn means that we cannot necessarily take any of your statements about what your opinions were at face value, and can only go on what you wrote - which is the way it started anyway, despite your attempt to rewrite this discussion as one about your opinions.

The entertainment value asymptotically approaches zero for me when your updates are this sporadic, verbose, and vapid.

I'll assume you are done dancing, given the continued weakening of your performance. But if I am mistaken, and you do abandon your current trajectory for something new and interesting, perhaps I'll come watch again.

It's a shame, because I did so enjoy your early work. Seeing someone adopt such an arrogant position, only to flail about for this long in a spectacular display of nothing at all... well schadenfreude is the word I would choose for it.

Don't give up.

How sweet of you! No sooner did I mention how enjoyable it was to see your impotent apoplexy return, than you let loose another volley (I hope this doesn't come across as churlish, but I have to say that while the impotence is unparalleled, the apoplexy is not quite at the level it reached before you realized you were signalling your frustration at having your every argument refuted.)

On the subject of arguments, I see that this is the first time in I-can't-be-bothered-to-count that you have you have not tried to insinuate (without an actual argument) that the points I made in my preceding post are invalid (IIRC, the last time you tried an actual argument, it was the fiasco in which you ended up attempting to pass off 'slightly' as a conversational synonym for 'exponential'.) Could it be that you have finally realized what Mark Twain was going on about in his well-known aphorism about keeping quiet or removing doubt? Or, after having taken another turn around the bowl (https://news.ycombinator.com/item?id=9610430), will you once again repeat the same old insinuations that failed before? My money is on the latter.

If you are unsure where to start, may I suggest (once again) that you attempt an actual explanation (as opposed to either merely insinuating that there is an explanation to be found somewhere, or attempting to rewrite your original claims as something completely different) as to why you think Eslaught's explanation does not refute your original claim about the complexity of all stack-frame-based explanations?