A: Both call-by-value and call-by-reference (termed evaluation strategies), have absolutely nothing to do with how variables are represented or communicated within a language. Evaluation strategy instead defines the extent to which a function is able to manipulate the environment from which it was called through the arguments it has received.
When you call a function, the way arguments are handled has a huge impact on how we, as developers, are able to reason about the state of the environment after a function has been called.
The Wikipedia entry for Evaluation Strategy is long, confusing and sometimes contradictory because the various terms have been inconsistently applied to languages throughout the years.
The most important distinguishing features of call-by-value is:
In call-by-value, a function can't make modifications to the calling environment by direct assignment to the arguments it has received. Everything in the argument list is a copy. Inside the function, any assignment to an argument changes the argument only for the remaining duration of the function body. From the point-of-view of the calling environment, no assignment was ever made.
Compare that to the definition of call-by-reference:
The example below clearly shows this behavior:
What About Objects!?
That Other call-by-value Language
Let's take a moment to look at an unquestionably call-by-value language: C.
Like everything else in C's call-by-value semantics, pointers are copied as well. One of the effects of this copying is that changes to a pointer's value are not visible to the outside world. On the other hand, the memory to which that pointer refers is clearly still mutable and those mutations are visible outside of the function.
The key point here is: no one will ever attempt to argue that C is call-by-reference simply because you are able to mutate whatever region of memory a pointer references. What matters is that the value of the pointer has been copied and that any changes to that pointer's value itself are not visible to the environment from which the function was called.
Before We Go
There is one more interesting detail to consider. In C, we can emulate a call-by-reference system by passing pointers for value-types and pointers-to-pointers for reference-types (on the heap). In that way it is possible, though quite laborious, to explicitly implement call-by-reference semantics in C.