Hacker News new | past | comments | ask | show | jobs | submit login

What in the world are you talking about?

> you attempt to use a couple of tired old rhetorical ploys

I do no such thing.

> Your argument here depends on the misunderstanding that all explanations in computer science are abstract

Not at all.

> That is not so; a discussion of argument-passing can be (and is) done in terms of addresses and stack frames.

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.

> are of no help to anyone who doesn't have a solid understanding of C++, anyway

You just need a basic understanding. This isn't advanced stuff here. People learn Java's object references the very first time they

    Thing x = y; y->something(); // Why has x changed?
and they learn C++ references and pointers ... well from the start.

These are week-one concepts for anyone learning the languages.

> This is just as well, or how else would anyone have understood this stuff before they had C++?

Most people have no trouble understanding the concept in week one of Java, or C++, or whatever other language they are learning. And the rest get it from the fundamentals. But those aren't the people in this thread who continue to confuse the issue.

If someone can't take the phrase "pass-by-reference" and the phrase "Java object reference" and understand that the two uses of the word "reference" mean different things, even after reading the simple-to-understand definitions of each, then they really need above-and-beyond help. This isn't "dive into CS theory" or "show them the machine-level stack frames and register contents", this is "try whatever you can that might help them". C++ is a very valid place to go for these folks.




Good day to you, too! You haven't disappointed in the latest of your daily diatribes!

'What in the world are you talking about?'

Here we have another common rhetorical ploy, the attempt to insinuate that the other party is not making sense, without actually refuting her arguments. If not used carefully, however, it has the unfortunate side-effect of giving the impression that you alone cannot figure it out.

But do keep the snide asides coming (not that I think you are likely to stop). If it were not for them, I would have left this thread long ago, satisfied that we had reached an amicable agreement to disagree.

You follow with a few flat denials of things I wrote. You can do that until the cows come home, but unless you can offer actual refutations of the arguments I presented in support of those claims, you are just blowing hot air.

'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.'

Now we come to something that has the verisimilitude of a rational argument, and we can immediately see why you were reluctant to go there, despite the manifest failings of the alternatives you tried. The first question that comes to mind is, exponential in what? What, precisely, leads to an exponential growth in complexity? Note that the sentence quoted here claims exponentially more complication even if you stick to one specific implementation of one specific language runtime, so make sure that your explanation covers that case, or I will have to return to it. Also make sure that your explanation somehow avoids applying to C++, and covers how we ever managed to figure this all out before we had C++.

Furthermore, the implication that it has to be presented using one extant runtime or another is fallacious. One can discuss argument passing using stack frames and addresses without getting into how C++ or any other specific language implements it, and the empirical proof of that can be found in any number of elementary comp. sci. textbooks.

Your 'its so simple' argument is a non-sequitur, as you are making the fallacy that if the concept is simple, then any explanation will be simple. In reality people can, and do, tie themselves in knots over simple issues - Zeno's paradoxes are a case in point. In fact, the simplicity argument goes against you - it's so simple, yet you ended up retroactively qualifying your use of pointer as 'abstract pointer' and spend time in drawing analogies between C++ pointers and Java references.

And if its so simple, how come that there are people who are just not getting it? Maybe, just maybe, the problem is in how it is presented.

The question of whether an approach via C++ is helpful, and whether your particular approach (using qualified analogies between C++ and Java) helps, are separate issues. I could go into how well your approach worked in practice, though I don't think that is necessary at this point (unless you choose to go there), except to point out that you repeatedly abandoned this approach in favor of a purely Java one, telling people to 'read the JLS.'


I didn't even bring up C++ - the article did, dlubarov commented about it, and you asserted that C++ references and Java references were the same. That's where I joined - to correct your fallacy.

Perhaps it really is simple, and you are afraid to admit that maybe you didn't get a simple concept either, until your eyes were opened by the very posts you spend walls of text refuting. I know it is not a pleasant feeling, but it's acceptable to own up to it. No amount of text or thesaurus consultation will fix your mistake.

Or, if that's too much pride for you to abandon, then you can continue to stand behind your original claim that references in C++ and Java are the same for this discussion (or any other - but I posit that there is no discussion, except for maybe "the word reference in both phrases has the same spelling"), then I feel for you. I really do.

Good day!


You were correct on the references issue (which was not as you present it here, which is typical), but mistaken over the cause of length of this thread, which comes from an unbroken series of faulty arguments you presented in an attempt to support the notion that using C++ was the only option in explaining the issue. The last one was a risible claim about the literally exponential complexity of the alternatives.

So here's a difference between us: I freely acknowledge correct arguments, while you silently slink away from your mistakes, and try to pretend you never made them. I am happy to have third parties figure out who is being immature here.

Top O' the morning to you!


Every one of my corrections was accurate.

I also don't believe I ever claimed that C++ was the option.

I own up to my mistakes the instant they are apparent. If you believe I should be owning up to something but I haven't yet, it is because either I wasn't wrong, or the argument against me wasn't coherent.

But at least you finally capitulated. I didn't think you would, so you at least proved me wrong there.


I am hugely amused that you just could not resist making a statement that proves it is you who suffers from the obsession you accuse me of (not that there was any real doubt.) You remind me of the child who just cannot resist the marshmallow: https://www.youtube.com/watch?v=0mWc1Y2dpmY


Are you claiming that if I hadn't corrected your false statements quickly, and instead I had waited a short while, that you would have made additional false statements that you wouldn't otherwise have made? So that I could have enjoyed correcting you even more?

If that's true then I wish you would have said that up front like the experimenter in the video. Unlike the subjects, I would have had no problem delaying that gratification. My prize would have beaten a marshmallow any day.


Most people figure out as children that claiming the truth of something that is demonstrably false is a losing strategy. It doesn't even count as a rhetorical ploy; 'Go directly to fail' would be a more appropriate characterization.

A simple reading of this thread shows that I have merely been responding to specific claims of yours, in which the comparison of references was neither here nor there, once you chose to make an issue of whether your C++-comparison based explanation was the only feasible one remaining. When you could have left it as an amicable difference of opinions, you chose to double-down and insist that anything other than your opinion was flat-out wrong, which led you to make a series of increasingly poor arguments, culminating in the ridiculous claim that the alternatives would literally be exponentially more complex.

In each case (including the last), after I pointed out the flaws in your claims, you have neither accepted the point, nor offered any counter-argument. Instead, you circled around and tried to make a different argument for the same claim, as if there was not already a growing pile of refutations stacking up against it. If there was any doubt before that you suffer from the obsession you accuse me of, you effectively removed it by this behavior.

There is not much point in discussing anything with someone like you, but your sanctimonious rudeness to me and others makes it worthwhile.

'My prize would have beaten a marshmallow any day.' No surprise there - your juvenile motivations are plain for anyone to see.


> Most people figure out as children that claiming the truth of something that is demonstrably false is a losing strategy.

So the video had no point then? Because the video I saw was about delayed gratification, not the strategy of truths and falsehoods.

And I still await a clear idea of where I made a claim of truth and was mistaken. As I've said in the past, if you can show me that clearly, I'll capitulate. I've been patiently waiting through all of your long-winded responses for this, and have been disappointed so far.

In fact, you now have changed your characterization of my posts from "truths and claims" to "opinions", which most of them were all along (the only claim I believe I made that could be considered fact instead of opinion was the refutation of your C++ references-and-pointers equation, which you agreed I was correct on).

> A simple reading of this thread shows that I have merely been responding to specific claims of yours

I don't see that anywhere, actually.

> once you chose to make an issue of whether your C++-comparison based explanation was the only feasible one remaining

I also don't see this anywhere. What I do see is my claim that C++ is a useful comparison - but nowhere do I see myself claiming it is the "only" one, or the "only feasible" one.

Some of my quotes have been: "for the purposes of this discussion, it is very useful and illustrative to equate pass-by-reference to C++ references, and object references to C++ pointers, because the languages are similar and the concepts match up very well, and because these things are more explicit in C++" and "Seems like C++ is as good a choice as any" and "one could have defined everything without comparing to C++"...

> after I pointed out the flaws in your claims, you have neither accepted the point, nor offered any counter-argument

But you haven't actually pointed out any flaws in any of my claims.

> as if there was not already a growing pile of refutations stacking up against it

Please, point out the pile of refutations to the claim that C++ is useful in this discussion (not "only", just "useful)... especially since, refuting the notion that it is useful to someone means finding everyone who read it and getting them to admit that they found no use in it. If you do that, I'll certainly admit I was wrong.

> your sanctimonious rudeness

I see very little rudeness - the only clear cut case was in response to someone else who basically asked me what rudeness would look like and I gave an example referencing proggit. Care to quote any specific rudeness toward you? Be careful not to equate an unpleasant discussion with rudeness.

> your juvenile motivations

If you think truth is a juvenile motivation then I finally understand everything you've written.


Your attempt to deny what you wrote is as revealing as it is pathetic. The record stands for itself.


I was going to write the same thing.


Instead of replying in a manner I haven't heard since middle school, you could be writing a much-delayed explanation of your claim that a stack-frames-and-addresses explanation of pass-by-value would necessarily be "exponentially more complicated" than your C++-based approach.


I guess I am the middle schooler here because I'm going to point out that "you started it".

I won't even dwell on the hypocrisy of you trying to call me out for my rudeness right before you post this middle school nonsense.

If you don't think stack frames and addresses are far more complex a learning tool for this than references and pointers, that's your opinion. I disagree, and I think many would, but there's no factual claim here for you to refute, no matter how much you are grasping for one in this thread.

Go ahead and explain it your way to folks. See if it finally sinks in for those who didn't get it from the JLS or from the article. I'd be happy to watch the attempt. I don't think it'll work. Prove me wrong.


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 :)




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: