Variables as Pointers

Variables are pointers to a place (or address space) in memory. This is a very important concept to understand.

a = "Baguette"

#    a = "Baguette"
#    ^        ^
#    |        |
# variable  object

Label which refere to a physical memory address in the computer is another term used to describe variables.

Reassignment vs Mutability

Examples are probably the fastest way to get the point accross. Here is two to illustrate the point above.

Reassignment

First let’s see what happen when we reassigne a variable to a completly different address in memory:

a = 'Hello there'
b = a

puts a  # Hello there
puts b  # Hello there

a = 'General Kenobi'

puts a  # General Kenobi
puts b  # Hello there

This can be schematized like this:

                             |
                             |  +---+             +------------------+
  a = 'Hello there'          |  | a |  -------->  | 'Hello there'    |
                             |  +---+             +------------------+
                             |
-----------------------------+------------------------------------------
                             |
                             |  +---+
                             |  | a |  ---+
                             |  +---+      \
                             |              \     +------------------+
  b = a                      |               +--> | 'Hello there'    |
                             |              /     +------------------+
                             |  +---+      /
                             |  | b |  ---+
                             |  +---+
                             |
-----------------------------+------------------------------------------
                             |
                             |  +---+             +------------------+
                             |  | a |  -------->  | 'General Kenobi' |
                             |  +---+             +------------------+
  a = 'General Kenobi'       |
                             |  +---+             +------------------+
                             |  | b |  -------->  | 'Hello there'    |
                             |  +---+             +------------------+
                             |
-----------------------------+------------------------------------------

a = 'General Kenobi' reassigned the variable a to a completely different address in memory. It is now pointing to a new string.

Mutability

a = 'Hello'
b = a

puts a  # Hello
puts b  # Hello

a << ' there'

puts a  # Hello there
puts b  # Hello there

Using the principle of label we discussed above, we can illustrate the code above like the schema below:

                             |
                             |  +---+             +------------------+
  a = 'Hello'                |  | a |  -------->  | 'Hello'          |
                             |  +---+             +------------------+
                             |
-----------------------------+------------------------------------------
                             |
                             |  +---+
                             |  | a |  ---+
                             |  +---+      \
                             |              \     +------------------+
  b = a                      |               +--> | 'Hello'          |
                             |              /     +------------------+
                             |  +---+      /
                             |  | b |  ---+
                             |  +---+
                             |
-----------------------------+------------------------------------------
                             |
                             |  +---+
                             |  | a |  ----+
                             |  +---+       \     +------------------+
  a << ' there'              |               +--> | 'Hello there'    |
                             |  +---+       /     +------------------+
                             |  | b |  ----+
                             |  +---+
                             |
-----------------------------+------------------------------------------

This time, a << ' there' results in mutating the caller, modifying the existing string, which is also pointed to by the variable b.

Both a and b are pointing to the same thing.

Mutation are performed on objects referenced by variables, not variables themselves.

Sources: