Java is Pass-by-Value
This article is overly pedantic.  Java's semantics are pass-by-value only of you consider that the "values" that are being passed are pointers.  But Java doesn't have first-class pointers, it has implicit pointers.  The only thing you can do with a Java pointer "value" is to tacitly dereference it.<p>In fact, you can write a swap(x,y) function in Java.  It goes something like this:<p><pre><code>    class foo { int value }
    
    void swap(foo x, foo y} {
      int temp = x.value;
      x.value = y.value;
      y.value = temp;
    }
</code></pre>
(Yes, I know this isn't valid Java.  Cut me a little slack here, OK?)<p>"But that's cheating" you protest.  "That's not swapping the value of X and Y, that's swapping the value of a slot in the values of X and Y, which happen to be objects."  Well, yeah.  So?  Compare that to this C code:<p><pre><code>  struct foo { int value }
  
  void swap(struct foo x, struct foo y) {
    [same code as above]
  }
</code></pre>
The effect of this function will be DIFFERENT.  Specifically, the C function will have no effect while the Java function will swap the value slots of X and Y because C lets you pass a structure as a value while Java does not.  All Java "values" are (tacit) pointers to objects [1].  Pounding your fist on the table and insisting that Java is pass-by-value because you can't write a swap(x,y) function obscures this crucial difference.<p>[1] OK, it also has ints and floats of various sizes.  But that's really it.