Call by sharing (also known as "call by object" or "call by object-sharing") is an evaluation strategy first noted by Barbara Liskov in 1974 for the CLU language.[8] It is used by languages such as Python,[9] Java (for object references), Ruby, JavaScript, Scheme, OCaml, AppleScript, and many others.
call-by-sharing is call by value, but the value is always a reference.
It's always pass by value, but the value of the variable is a reference.
but the article also points out that the technical details around what a reference exactly is in any given language can be a bit prickly.
JavaScript isn't a low level language so the language spec simply describes how ECMAScript has to behave but does not specify how it has to be implemented. Engines such as V8 or SpiderMonkey can implement the runtime in whatever way they wish as long as the observable behaviour conforms to the specification.
So while it is correct to say that JavaScript behaves in the manner of "Call by Sharing", the implementation details are up to the actual runtime engine.
The caller and called routine communicate only through the argument and result objects; routines do not have access to any variables of the caller.
The remainder I would rephrase this way:
After the assignments of actual arguments to formal arguments, the caller and the called routine share values. If the called routine modifies a shared value, the modification is visible to the caller on return. The names used to denote the shared values are distinct in the caller and called routine; if a routine assigns a value to a formal argument variable, there is no effect on the caller. From the point of view of the invoked routine, the only difference between its formal argument variables and its other local variables is that the formals are initialized by its caller.
And in the case of JavaScript primitive values are immutable so:
If the called routine modifies a shared value, the modification is visible to the caller on return.
only applies to objects (aka compound data). For primitive values it is only possible to
assigns a value to a formal argument variable, there is no effect on the caller.
What hampers most people is the metaphor they use to visualise "variables".
In Java courses they tend to get told that "variables" are like boxes:
A primitive data box can hold one primitive value. You can "vary" by you putting a different value in the box.
An object box holds a remote control (reference) to the object. If you want to change something about the object, do it through the remote control. There may be multiple remote controls with a connection to the same object.
That metaphor doesn't work very well for JavaScript. That is why I typically don't use the terms "variable" and "assignment" but rather "name" and "bind".
A more useful metaphor for
letnumber=1983;
is writing "number" on a sticky note and sticking it the immutable number 1983. Then
number=number*10;
creates an entirely new immutable number 19830 and repositions the "number" sticky note to it.
On the other hand
letnumberParam=number;
simply writes "numberParam" on another sticky note and sticks it on the same immutable number 1983 leaving two separate sticky notes on it. Now
numberParam=numberParam*10;
creates an entirely new immutable number 19830 and repositions the "numberParam" sticky note to it while leaving the "number" sticky note on the original 1983.
So
constnumber=1983;
is writing "number" on a permanent label and sticking it on that immutable number 1983. That label cannot be "repositioned".
And the beauty of the "sticky note" metaphor is that works for objects and arrays as well.
constobj4=['a'];
So while obj4 is the permanent label for that particular array, the "sticky note" obj4[0] (a separate (indexed) name) can still be "repositioned" (to a different value) and more "sticky notes" obj4.push('b') can still be added.
On a technical level these "sticky notes" (or "permanent labels") are just references - the JavaScript way.
Thanks for this explanation here and also the "variables just point to values" mindset: in this post.
(Sorry for the long comment below in advance)
So let me try to summarize what I have learned here (hopefully is correct):
For primitive types a=1, JS variable holds a reference (address) to the actual memory location that stores the value.
For non-primitive types b=[1,2,3], the variable holds a reference (address) to the locations storing other references to the actual values of 1, 2, 3.
For primitive types, the value are immutable, and the reassignment is copy(value) on write!! like a=1;b=a; b and a hold the same references/address to the same memory location. A new memory is allocated only if we try to assign b=2 for example. (what if we assign b=1? since 1 is immutable, will a=1;b=1; result in both a and b hold references tht point to the same place that storing that immutable 1?
It is shocking that even for primitive types, the JS variable only holds a reference (address in JS) to the actual value.
So basically, 90%+ of the materials out there are wrong, like this
A variable is a container for a value, like a number we might use in a sum, or a string that we might use as part of a sentence.
I mainly have two questions here: First: I learned most of the knowledge of a programming language internal from C++. Any reference materials that I can read about the virtual memory level of JavaScript? Like the stack vs heap in C++. For example in this blog, it describes let name = 'John'; stores the value in the stack frame of the stack, which is wrong based on the discussion here (right?)
Second: The second question I have is entirely the opposite. If I don't want to touch on any details about virtual memory, how can I learn or teach others about JavaScript? Since JavaScript is a high-level programming language, we should not care about memory (unless we need to optimize). But it seems like it is impossible to teach the correct concept without touching the memory and addresses.
I appreciate the new metaphor you suggested here for JavaScript, but now I worry if that variable metaphor idea will differ in different languages (Java vs JavaScript or even others). What is the point of learning that metaphor (I believe metaphor is an abstraction that should be helpful in quickly picking up different languages)? All in all, my second question is more about what is the right level of abstraction to learn/teach a programming language without touching the internals but learning/teaching it correctly?
storing other references to the actual values of 1, 2, 3.
That depends as the runtime can optimize. See Elements kinds in V8. Also there are Typed Arrays which hold the actual (uniformly typed) values.
Ryan Cavanaugh
@searyanc
JavaScript performance is bananas, a thread.
Let's write a function to sum the values from a the 'val' property of each element in an array:
function sum(arr) { let acc = 0; for (let i = 0; i < arr.length; i++) { acc += arr[i].val; } return acc; }
1/10
00:01 AM - 23 Feb 2022
It is shocking that even for primitive types, the JS variable only holds a reference (address in JS) to the actual value.
Remember that the runtime is free to optimize whichever way it seems fit as long as the observable behaviour aligns with the language specification. However it is dictated that the conceptual behaviour of a value of a primitive type is that of an "immutable datum represented directly at the lowest level of the language". Immutability is easily explained with Strings; you can't change a string, you can only create a new one, so on "assignment" the let name is essentially being rebound to the new string. But Boolean, NullUndefined, Number, BigInt, and Symbol values all behave the same way by virtue of being primitive types. I seem to remember coming across some V8 source code where primitive JavaScript values (at least in some context) were represented by C++ classes.
So basically, 90%+ of the materials out there are wrong
It's a simplified mental model which mostly works and is easy to grasp for beginners.
which is wrong based on the discussion here (right?)
Again the runtime implementation isn't dictated. V8 has the "Ignition" interpreter and the "Turbofan" compiler so actual JS execution could be accomplished in very different ways depending on the level of optimization.
if that variable metaphor idea will differ in different languages (Java vs JavaScript or even others).
My metaphor isn't original. Given that in JavaScript primitive values are immutable it's unfortunate that the term "assignment" is being used as that implies PLOP (PLace-Oriented Programming), i.e. (re)placing a value inside a location giving rise to the notion of a "variable" as the value inside the location can vary. In value-oriented programming (typically practiced in functional languages)
letnumber=1983;
is binding the name number to the value 1983 while
number=number*10;
is rebinding the name number to the result of the number * 10 expression. With that terminology it is the binding that changes, not the value.
I only stumbled upon this because I got annoyed at const—until I discovered:
"The const declaration creates a read-only reference to a value. It does not mean the value it holds is immutable—just that the variable identifier cannot be reassigned."
So people keep saying that const works differently for primitive values and objects (overlooking completely that primitive values are already immutable). This is a perspective that becomes necessary because of the assignment/variable oversimplification that people learn in the beginning. The truth is much simpler:
const doesn't act on the value but on the binding—it's the binding that is constant and unchangeable. As a result the const behaviour is absolutely identical for primitive values and objects as the binding being constant does not affect the internal mutability of objects (which includes arrays).
If I don't want to touch on any details about virtual memory
I hope I conveyed that going to that level isn't actually necessary. Once you eliminate the notion of variables and assignments and replace them entirely with names and bindings, everything behaves entirely consistently. It's just that beginners material insists on starting with variables and assignments and then never adjust that initial mental model.
Thanks for your reply, let me study more with the given directions.
My imdidate response to this
Remember that the runtime is free to optimize whichever way it seems fit as long as the observable behaviour aligns with the language specification.
Yeah, it makes a lot of sense. For example, in C/C++, the "Optimization" I learned is like out-of-order execution (including speculation) and unfolding loops. I remember back then, I was shocked as well. Now I realize it is not just the JavaScript tutorials problem. One of the utimate problems is that the teaching materials don't separate what the language specifications are. But for non-specified behaviors, they are subjected to be changed/optimized. I think this is also a missing mental model puzzle here.
Back then, our university C++/Java course should also focus more on the language specifications first and make a clear separation between abstraction and implementation. Now I am confused about what I have learned (for all languages what their specifications/promises are).
For further actions, you may consider blocking this person and/or reporting abuse
We're a place where coders share, stay up-to-date and grow their careers.
The Wikipedia entry does mention Javascript too -
I have found this good article JavaScript, Ruby and C are not call by reference... will correct and update if this is the case...
The core message of that article is:
but the article also points out that the technical details around what a reference exactly is in any given language can be a bit prickly.
JavaScript isn't a low level language so the language spec simply describes how ECMAScript has to behave but does not specify how it has to be implemented. Engines such as V8 or SpiderMonkey can implement the runtime in whatever way they wish as long as the observable behaviour conforms to the specification.
So while it is correct to say that JavaScript behaves in the manner of "Call by Sharing", the implementation details are up to the actual runtime engine.
For a more terse reference - Call by Sharing:
The remainder I would rephrase this way:
And in the case of JavaScript primitive values are immutable so:
only applies to objects (aka compound data). For primitive values it is only possible to
What hampers most people is the metaphor they use to visualise "variables".
In Java courses they tend to get told that "variables" are like boxes:
That metaphor doesn't work very well for JavaScript. That is why I typically don't use the terms "variable" and "assignment" but rather "name" and "bind".
A more useful metaphor for
is writing "number" on a sticky note and sticking it the immutable number
1983. Thencreates an entirely new immutable number
19830and repositions the "number" sticky note to it.On the other hand
simply writes "numberParam" on another sticky note and sticks it on the same immutable number
1983leaving two separate sticky notes on it. Nowcreates an entirely new immutable number
19830and repositions the "numberParam" sticky note to it while leaving the "number" sticky note on the original1983.So
is writing "number" on a permanent label and sticking it on that immutable number
1983. That label cannot be "repositioned".And the beauty of the "sticky note" metaphor is that works for objects and arrays as well.
So while
obj4is the permanent label for that particular array, the "sticky note"obj4[0](a separate (indexed) name) can still be "repositioned" (to a different value) and more "sticky notes"obj4.push('b')can still be added.On a technical level these "sticky notes" (or "permanent labels") are just references - the JavaScript way.
^ this :)
Thanks for this explanation here and also the "variables just point to values" mindset: in this post.
(Sorry for the long comment below in advance)
So let me try to summarize what I have learned here (hopefully is correct):
a=1, JS variable holds a reference (address) to the actual memory location that stores the value.b=[1,2,3], the variable holds a reference (address) to the locations storing other references to the actual values of 1, 2, 3.a=1;b=a;b and a hold the same references/address to the same memory location. A new memory is allocated only if we try to assignb=2for example. (what if we assignb=1? since 1 is immutable, willa=1;b=1;result in both a and b hold references tht point to the same place that storing that immutable 1?It is shocking that even for primitive types, the JS variable only holds a reference (address in JS) to the actual value.
So basically, 90%+ of the materials out there are wrong, like this
from developer.mozilla.org/en-US/docs/L...
I mainly have two questions here:
First: I learned most of the knowledge of a programming language internal from C++. Any reference materials that I can read about the virtual memory level of JavaScript? Like the stack vs heap in C++. For example in this blog, it describes
let name = 'John';stores the value in the stack frame of the stack, which is wrong based on the discussion here (right?)Second: The second question I have is entirely the opposite. If I don't want to touch on any details about virtual memory, how can I learn or teach others about JavaScript? Since JavaScript is a high-level programming language, we should not care about memory (unless we need to optimize). But it seems like it is impossible to teach the correct concept without touching the memory and addresses.
I appreciate the new metaphor you suggested here for JavaScript, but now I worry if that variable metaphor idea will differ in different languages (Java vs JavaScript or even others). What is the point of learning that metaphor (I believe metaphor is an abstraction that should be helpful in quickly picking up different languages)? All in all, my second question is more about what is the right level of abstraction to learn/teach a programming language without touching the internals but learning/teaching it correctly?
That depends as the runtime can optimize. See Elements kinds in V8. Also there are Typed Arrays which hold the actual (uniformly typed) values.
Remember that the runtime is free to optimize whichever way it seems fit as long as the observable behaviour aligns with the language specification. However it is dictated that the conceptual behaviour of a value of a primitive type is that of an "immutable datum represented directly at the lowest level of the language". Immutability is easily explained with
Strings; you can't change a string, you can only create a new one, so on "assignment" theletname is essentially being rebound to the new string. ButBoolean,NullUndefined,Number,BigInt, andSymbolvalues all behave the same way by virtue of being primitive types. I seem to remember coming across some V8 source code where primitive JavaScript values (at least in some context) were represented by C++ classes.It's a simplified mental model which mostly works and is easy to grasp for beginners.
Again the runtime implementation isn't dictated. V8 has the "Ignition" interpreter and the "Turbofan" compiler so actual JS execution could be accomplished in very different ways depending on the level of optimization.
My metaphor isn't original. Given that in JavaScript primitive values are immutable it's unfortunate that the term "assignment" is being used as that implies PLOP (PLace-Oriented Programming), i.e. (re)placing a value inside a location giving rise to the notion of a "variable" as the value inside the location can vary. In value-oriented programming (typically practiced in functional languages)
is binding the name
numberto the value1983whileis rebinding the name
numberto the result of thenumber * 10expression. With that terminology it is the binding that changes, not the value.I only stumbled upon this because I got annoyed at
const—until I discovered:"The
constdeclaration creates a read-only reference to a value. It does not mean the value it holds is immutable—just that the variable identifier cannot be reassigned."So people keep saying that
constworks differently for primitive values and objects (overlooking completely that primitive values are already immutable). This is a perspective that becomes necessary because of the assignment/variable oversimplification that people learn in the beginning. The truth is much simpler:constdoesn't act on the value but on the binding—it's the binding that is constant and unchangeable. As a result theconstbehaviour is absolutely identical for primitive values and objects as the binding being constant does not affect the internal mutability of objects (which includes arrays).I hope I conveyed that going to that level isn't actually necessary. Once you eliminate the notion of variables and assignments and replace them entirely with names and bindings, everything behaves entirely consistently. It's just that beginners material insists on starting with variables and assignments and then never adjust that initial mental model.
Thanks for your reply, let me study more with the given directions.
My imdidate response to this
Yeah, it makes a lot of sense. For example, in C/C++, the "Optimization" I learned is like out-of-order execution (including speculation) and unfolding loops. I remember back then, I was shocked as well. Now I realize it is not just the JavaScript tutorials problem. One of the utimate problems is that the teaching materials don't separate what the language specifications are. But for non-specified behaviors, they are subjected to be changed/optimized. I think this is also a missing mental model puzzle here.
Back then, our university C++/Java course should also focus more on the language specifications first and make a clear separation between abstraction and implementation. Now I am confused about what I have learned (for all languages what their specifications/promises are).