Question

According to tryruby.org, the usage of a symbol uses one memory allocation, and then points to its single allocation, whereas storing multiple strings, even if they are the same, stores multiple instances in the memory. So, much like how MP3 and other compression or optimization methods work, what considerations go into switching from multiple strings to refactoring to usage of symbols to take advantage of the repetition? As soon as you have two duplicates? Only when you notice performance drops? A logarithmic calculation? Other considerations or viewpoints?

I am programmer interested in learning strong positive convention practice, that is why I am asking.

Answer 1

A symbol is basically an immutable, interned string. That means, it can’t be changed in place (e.g. by using gsub!) and it is guaranteed that two usages of the same symbol always return the same object:

"foo".object_id == "foo".object_id
# => false

:foo.object_id == :foo.object_id
# => true

Because of that guarantee, symbols are never garbage collected. Once you have “created” a symbol, it will be kept forever in the current process.

Generally, you should use symbols when you have a static string, or at a least limited number of them, such as keys in hashes or to reference methods. Using symbols here ensure that you are always getting the same object back.

With ordinary strings, depending on how you compare them, it is possible that you get different objects back. With ordinary strings it is possible to have two or more that look like they are the same, but are actually not the same (see the example above).