Lambda the Ultimate

The Wikipedia page on evaluation strategies conflates "pass by value" with "call by value". Is this authoritative? Does anyone know where "pass by value" and "pass by reference" were first defined?

"Pass by reference" is described as an evaluation strategy such as found in assembly with registers, where modifying a local in a child scope modifies the local seen in a parent scope, eg. updating a callee-save register changes the value seen by the caller after returning.

"Pass by value" describes the strategy where arguments of the parent scope cannot be modified in a child scope, even though the value itself can be modified. This is, rightly or wrongly, conflated with call-by-value. For instance, the following type in OCaml, type Foo = { mutable x:int }, is still "passed by value" even though mutations in the child scope are visible in the parent. This doesn't seem mutually exclusive with "pass by reference" though, since one cannot distinguish between mutating a Foo and mutating the local in the parent of Foo.

"Pass by sharing" seems like a useful distinction that would resolve a lot of this confusion, but isn't in common use.

Is this the authoritative meaning of these terms? Is there an original or authoritative source where these terms are defined more rigourously?

There seems to be great confusion surrounding this issue, particularly when you consider that "value types" and "reference types" are both considered to be "passed by value" in Java. In other words, the evaluation strategy terminology is inconsistent with the terminology used to describe a language's primitive values.

However, if the terms were used consistently, introducing side-effects to a type would change it from a value type into a reference type. Any pointers to authoritative references would be much appreciated.