From: Jeremy Bopp <jeremy@...>
Date: 2011-07-26T14:16:20+09:00
Subject: Why aren't string literals treated similarly to symbols?

Explaining the difference between symbols and strings got me wondering
why string literals aren't treated similarly to symbols by the
interpreter.  To be clear it seems that string literals could be
allocated 1 time each, where duplicates simply reference the first
created instance.

The trick would be to make each reference to the literal a dup of the
singular, hidden instance.  With the COW semantics that dup'd strings
have (or should have), this should be a more memory efficient way to
deal with programs that have many instances of a string literal.

One such possibly common place that could benefit from this optimization
would be within frequently called methods or iterated loops that
directly use string literals for read-only purposes.  If a developer
wants to avoid the allocation problem of string literals as things
currently stand, he/she would have to be aware of this problem first and
then find ways to push his/her literals into constants or other exterior
references.

For example:

1.upto(2) do
  string = "example"
  puts string
end

Unless I misunderstand the current implementation in MRI, a loop such as
the one above would needlessly create a new instance of "good" for every
pass through the loop.  One possible fix would be something like:

string = "example"
1.upto(2) do
  puts string
end

In this trivial case, the solution is good enough, but the general case
requires more knowledge about how to optimize for the interpreter than
should be necessary.  I'm probably missing something obvious, so if
anyone knows what it is, please point it out.  Maybe MRI already does
this obvious thing.

-Jeremy