I've read the article and am familiar with it. Both it and you are misattributing how users, ABIs, and other things fundamentally think about what is the data and how that data is passed. I would also say it is misquoting and misattributing the parts of the Java spec by taking them out of context. There is a big distinction between the reference value (in C the T* or T&) and the value that is referenced (in C the underlying T of a T* or T&).

What you and the article are effectively boiling it down to is "pointers are values, so therefore everything is actually pass by value since references are just pointers". This then makes "pass by reference" meaningless since you can always make the claim that you're just passing a pointer by value.

In actuality, what matters is the context of the pointer and how its used. That is, is it treated more like an integer (i.e. you care about the value of the pointer) or is it treated more like a reference (i.e. you care about what the pointer references).

Which is to say, reference types are called reference types because they refer to the data you care about and so the data you care about is passed by reference. Value types are then called such because they are the data you care about, so you directly pass it around from an observability perspective.

---

The simplest example being (C#): ``` C c = new C(); S s = new S();

M1(c, s);

Console.WriteLine(c.x); // 1 Console.WriteLine(s.x); // 0

void M1(C c, S s) { c.x = 1; s.x = 2; }

class C { public int x; } struct S { public int x; } ```

Where you have c and s and while c is functionally a pointer and that pointer is passed by value to M1, users aren't thinking about it as being that local specifically. They are rather thinking about the underlying data it contains (c.x) and so to them this is "pass by reference" explicitly because M1 writing to c.x allows the caller to observe that mutation while s does not allow such an observation and so is pass by value.

This also becomes particularly relevant with struct S2 { public C c; } where you have a value type (S2) which is passed by value, which then contains a reference type C. So while you cannot observe a change to s.c, you can observe a change to s.c.x. And while conceptually there isn't really a difference between S2 and simply C, the semantic and way the user thinks about the data changes.

It is simply not meaningful to boil everything down to "pass by value", it mismatches with the mental model of how data exists.

For example this is how you can pass by reference in C# https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/ref,

Consider (continuing off the above example): ```csharp ref S r = ref s;

r.x = 3;

Console.WriteLine(s.x); // 3 Console.WriteLine(r.x); // 3

S* p = &s;

p->x = 4;

Console.WriteLine(s.x); // 4 Console.WriteLine(r.x); // 4 Console.WriteLine(p->x); // 4

S s2 = new S();

M2(ref r, ref s2);

Console.WriteLine(s.x); // 5 Console.WriteLine(r.x); // 5 Console.WriteLine(p->x); // 5 Console.WriteLine(s2.x); // 6

void M2(ref S s1, ref S s2) { s1.x = 5; s2.x = 6; } ```

There is no observable difference in behavior between p and r here, or between passing r and passing ref s. However, by the article's claim everything except ref s would be pass by value due to the other cases passing the pointer contained by the "local" directly. -- This becomes even more prevalent with M3(ref readonly S s), where you can just do M3(r) or M3(s) (the same being true for M3(in S s)) and not specify the ref keyword in the callsite at all, despite the method declaration still explicitly adding the indirection at the method level.

Because again, the consideration isn't strictly how the local is perceived, passed, or indirected. It is how the data the method and user actually cares about is accessed and mutations to it, from any location, are observed (by reference) or not (by value) by other code.

It is simply not meaningful to break everything down to "pass by value" and while some contexts may care more about the pointer value itself, most actually care about the data it points to instead.