Since everything is immutable and also there is nothing shared between 2 BEAM processes[1], there is no issue with that code in terms of concurrent processing.
[1] Well, in fact, large binaries are shared across processes, but as they are still immutable we do not get any problems because of this as well.
That code ignores two guidelines:
I’m not sure how anybody could be expected to “divine” this given that this was the first mention of it and since Erlang/Elixir’s BEAM implements a share-nothing architecture (as @NobbZ already mentioned).
i.e. there is no concept of “multi-threading” in Erlang/Elixir. If BEAM processes need to coordinate their activities they need to go through the BEAM process mailboxes.
The difference is more obvious in a language that has both.
Bindings introduce new variables, while assignments use existing ones.
my_var = 3 # bind my_var to 3
assert my_var == 3
# Assuming a version of Elixir with an assignment operator called `set`
#set my_var = 3 # COMPILATION FAIL
Bindings are subject to their own lexical scope, while assignment makes the new value accessible through the scope that the initial binding was in.
my_var = 3
if true do
my_var = 4
end
assert my_var == 3
my_var = 3
if true do
set my_var = 4
end
assert my_var == 4
Bindings can use any (irrefutable) pattern, while assignments require an lvalue.
{var1, var2} = {1, "super"}
assert var1 == 1
assert var2 == "super"
{var1, var2} = {1, "super"}
#set {var1, var2} = {2, "duper"}; # COMPILATION FAIL
Variable bindings may be of different types, even if they have the same name. In languages with a static type system, assignment cannot change a variable’s type:
x = 1
x = "awesome!"
assert x == "awesome!"
x = 1
#set x = "awesome!" # COMPILATION FAIL
That’s a good way to think of it, like OCaml has 3 syntax’s for this:
(* This creates a new immutable binding *)
let a = 42
(* `a` cannot be changed, only re-bound like how Elixir does it *)
(* This creates a new mutable binding *)
let b = ref 42
(* It can be changed within its scope *)
let () = b := 21
(* The `:=` operator means `to change where the binding points to` in a sense,
It returns empty tuple, so you can pattern match that as above, or ignore it.
It is indeed made purposefully cumbersome to minimize its use. *)
Maybe this is an intuitive way to think about the difference:
