Copying concept was always weird for me , when I learned GO it was like why? Why! Why GO favorite option is to work on a copy?! Today I make discovery that I will like to share.
I was reading a book "composing software" and I see an example about Shared State. "Shared-state concurrency means that concurrent computations communicate through reading and updating a shared location in memory."-source
I know the title said GO but the examples that let me understand the importance of copying in GO was an example in the book which is JavaScript , so the examples are in JavaScript.
Let's take a look at this example taken from the book.
// Shared state
const x = {
val: 2
};
// Mutates shared state
const x1 = () => x.val += 1;
// Mutates shared state
const x2 = () => x.val *= 2;
x1();
x2();
console.log(x.val); // 6
// This example is exactly equivalent to the above, except...
const y = {
val: 2
};
const y1 = () => y.val += 1;
const y2 = () => y.val *= 2;
// ...the order of the function calls is reversed...
y2();
y1();
// ... which changes the resulting value:
console.log(y.val); // 5
this code seems logical , but let's say we have 2 threads (or routines) accessing the same object x in same time. both of them are modifying the same object , so the output depends on race condition.
so to avoid this we use (yes you guess it) a copy!
const x = {
val: 2
};
const inc = x => ({...x, val: x.val + 1});
const double = x => ({...x, val: x.val * 2});
console.log(inc(double(x)).val); // 5
const y = {
val: 2
};
/*
Because the functions don't mutate, you can call
these functions as many times as you want, in any order,
without changing the result of other function calls.
*/
// These calls do nothing:
inc(y);
double(y);
console.log(inc(double(y)).val); // 5
the three dots ... are spread operator basically it will copy the propriety of the object and the function will return a new copy with modified value. Once I read this code I directly remembered GO , the idea in GO that everything is a copy was weird for me. And as we know go main feature is concurrency so everything as a copy seemed a very good and safe choice by go designers. so the advantage of working on a copy is safety , isolation , multi threading , but it also have disadvantage like deficiency.
That's why we like in GO to avoid as much as we can using pass as pointer.
that was my discovery today that I liked to share with community , please if you have more information that can help us , share it with us!