Forum: Ruby On Symbols

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Devin M. (Guest)
on 2005-12-30 15:40
(Received via mailing list)
Hey, all you lurkers:

Have any of the explanations in the thread (What is the difference
between :foo and "foo" ?) helped you understand symbols? A combination
of them? Or a combination of a couple of explanations, and an irb
session? Which ones? Why? If you don't want to get involved in (what
seems to be turning into) a flamewar, email me personally (hint: don't
click "Reply" :P), and I'll compile the results anonymously.

I think we all agree that everybody learns differently, and so I think
we're in dire need of feedback from somebody other than Chad (no
offense).

Devin
Ryan L. (Guest)
on 2005-12-30 18:26
(Received via mailing list)
I don't know, they have always made sense to me, which is why I didn't
post in that other thread. I think people are just overthinking
things.

Zen and the Art of Ruby P.ming: Symbols just are.

Ryan
J. Ryan S. (Guest)
on 2005-12-30 18:38
(Received via mailing list)
On Dec 30, 2005, at 11:25 AM, Ryan L. wrote:

> Zen and the Art of Ruby P.ming: Symbols just are.

/agreed

~ ryan ~
Mark S. (Guest)
on 2005-12-30 18:54
(Received via mailing list)
On Friday 30 December 2005 13:39, Devin M. wrote:
> Hey, all you lurkers:

Hello.

>
> Have any of the explanations in the thread (What is the difference
> between :foo and "foo" ?) helped you understand symbols? A combination
> of them? Or a combination of a couple of explanations, and an irb
> session? Which ones? Why? If you don't want to get involved in (what
> seems to be turning into) a flamewar, email me personally (hint: don't
> click "Reply" :P), and I'll compile the results anonymously.

Yes, the thread has definitely helped my understanding (but I wouldn't
like to
offer up my own explanation of how they work ;) ). It's hard to pinpoint
any
one thing that made it click, but I think the host/port example on the
second
half of this page seemed to make the most difference to me:

http://microjet.ath.cx/WebWiki/2005.12.27_UsingSym...

I found the examples of when to use symbols the most useful. In fact,
I'd say
they're essential, at least for me.

Thanks everyone.

Mark
Christian N. (Guest)
on 2005-12-30 19:49
(Received via mailing list)
Ryan L. <removed_email_address@domain.invalid> writes:

> Zen and the Art of Ruby P.ming: Symbols just are.

+1
Gregory B. (Guest)
on 2005-12-30 20:13
(Received via mailing list)
On 12/30/05, Christian N. <removed_email_address@domain.invalid> wrote:
> Ryan L. <removed_email_address@domain.invalid> writes:
>
> > Zen and the Art of Ruby P.ming: Symbols just are.
>
> +1

+1 more.  People will understand them if they just use them.
Steve L. (Guest)
on 2005-12-30 20:25
(Received via mailing list)
On Friday 30 December 2005 01:13 pm, Gregory B. wrote:
> On 12/30/05, Christian N. <removed_email_address@domain.invalid> wrote:
> > Ryan L. <removed_email_address@domain.invalid> writes:
> > > Zen and the Art of Ruby P.ming: Symbols just are.
> >
> > +1
>
> +1 more.  People will understand them if they just use them.

I disagree. I was using them quite often, but didn't understand them at
all.

Now, thanks to this 99 post thread, I believe I understand them at an
intuitive level, and I understand them enough to correctly code with
them
every time.

As we speak, I'm writing symbol documentation for the Ruby N. who has
no
concept (so far) of Ruby internals or Ruby customs.

And nobody even gave me two cents :-)

SteveT

Steve L.
http://www.troubleshooters.com
removed_email_address@domain.invalid
Gregory B. (Guest)
on 2005-12-30 20:31
(Received via mailing list)
On 12/30/05, Steve L. <removed_email_address@domain.invalid> wrote:

> As we speak, I'm writing symbol documentation for the Ruby N. who has no
> concept (so far) of Ruby internals or Ruby customs.
>
> And nobody even gave me two cents :-)

I think you'll get nickels, dimes, quarters, and other such change if
you can put an end to this seemingly bottomless topic.
Yohanes S. (Guest)
on 2005-12-30 20:47
(Received via mailing list)
Gregory B. <removed_email_address@domain.invalid> writes:

> On 12/30/05, Steve L. <removed_email_address@domain.invalid> wrote:
>
>> As we speak, I'm writing symbol documentation for the Ruby N. who has no
>> concept (so far) of Ruby internals or Ruby customs.
>>
>> And nobody even gave me two cents :-)
>
> I think you'll get nickels, dimes, quarters, and other such change if
> you can put an end to this seemingly bottomless topic.

I think this topic will be terminated by the coming year-end holiday
more so than any concensus or documentation.


YS.
Dan S. (Guest)
on 2005-12-30 21:20
(Received via mailing list)
What a long, sometimes interesting, sometimes confusing thread that
has been (and apparently continues to be)!

For me, symbols weren't very mysterious. I'm a Ruby N. but I've
been  programming in languages that use symbols (e.g., Smalltalk) for
a long time. I thought the most cogent response was the one that said
all the discussion about what symbols *really* are under the covers
were implementation details. I got it.


On Dec 30, 2005, at 5:39 AM, Devin M. wrote:

> I think we all agree that everybody learns differently, and so I
> think we're in dire need of feedback from somebody other than Chad
> (no offense).
>
> Devin
>
>



-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
Dan S.
Technology Visionary - Technology Assessment - Documentation
"Looking at technology from every angle"
http://www.eclecticity.com
Ron M (Guest)
on 2005-12-31 00:22
(Received via mailing list)
Ryan L. wrote:
> I don't know, they have always made sense to me...

Ruby symbols surprised me a bit because unlike most
Lisps, Ruby's symbols aren't garbage collected.

I still don't understand if that is an implementation
detail or something fundamental about symbols in Ruby
that makes them uncollectable.  The answer to that
question would say a lot about where it's a good
idea to use symbols.

> Zen and the Art of Ruby P.ming: Symbols just are.

In all languages with symbols, symbols just are.
But in some languages they are, to varying degrees different.

> On 12/30/05, Devin M. <removed_email_address@domain.invalid> wrote:
>>Have any of the explanations in the thread (What is the difference
>>between :foo and "foo" ?) helped you understand symbols?

The explanations that contrasted Ruby symbols with symbols
in other languages helped me.


Symbols mostly similar but a little different to Ruby's
are present in many languages (Lisp, Dylan).

Other languages have similar concepts with a different
name (Interned strings in Java).

Other languages use the same term to describe something
quite different (Lex/Yacc, APL's symbols, a linker's
symbol table in C) - but that's mostly a different
concept since the running program itself will rarely
care about the symbols.
Chad P. (Guest)
on 2005-12-31 01:37
(Received via mailing list)
On Sat, Dec 31, 2005 at 01:25:29AM +0900, Ryan L. wrote:
> I don't know, they have always made sense to me, which is why I didn't
> post in that other thread. I think people are just overthinking
> things.
>
> Zen and the Art of Ruby P.ming: Symbols just are.

 += 1

--
Chad P. [ CCD CopyWrite | http://ccd.apotheon.org ]

This sig for rent:  a Signify v1.14 production from
http://www.debian.org/
Chad P. (Guest)
on 2005-12-31 01:37
(Received via mailing list)
On Fri, Dec 30, 2005 at 10:39:34PM +0900, Devin M. wrote:
>
> I think we all agree that everybody learns differently, and so I think
> we're in dire need of feedback from somebody other than Chad (no offense).

None taken.

--
Chad P. [ CCD CopyWrite | http://ccd.apotheon.org ]

"Real ugliness is not harsh-looking syntax, but having to
build programs out of the wrong concepts." - Paul Graham
Austin Z. (Guest)
on 2005-12-31 02:40
(Received via mailing list)
On 30/12/05, Ron M <removed_email_address@domain.invalid> wrote:
> Ruby symbols surprised me a bit because unlike most
> Lisps, Ruby's symbols aren't garbage collected.
>
> I still don't understand if that is an implementation
> detail or something fundamental about symbols in Ruby
> that makes them uncollectable.  The answer to that
> question would say a lot about where it's a good
> idea to use symbols.

Probably an implementation detail. That doesn't mean you can't ignore
it, but it means that it's generally a good idea to use Symbols in a
lot of places. Just don't pretend that they're immutable Strings.
They're not. If you want that, freeze the String.

-austin
Ron M (Guest)
on 2005-12-31 04:05
(Received via mailing list)
Austin Z. wrote:
> Probably an implementation detail. That doesn't mean you can't ignore
> it, but it means that it's generally a good idea to use Symbols in a
> lot of places. Just don't pretend that they're immutable Strings.
> They're not. If you want that, freeze the String.
>

I think the big difference is if you want to use symbols
for values that come from external sources for long-running
processes like servers.

If symbols are garbage collected in Ruby 2, the answer is
yes, you could use them in all the places that you'd
use interned strings in Java or symbols in lisp.

If not, the answer is no, then you probably only want to
use symbols on values that the author of the program is
totally in control of; or in short lived processes.
Jim F. (Guest)
on 2005-12-31 04:41
(Received via mailing list)
On 12/30/05, Ron M <removed_email_address@domain.invalid> wrote:
>
>
> I think the big difference is if you want to use symbols
> for values that come from external sources for long-running
> processes like servers.
>
> If not, the answer is no, then you probably only want to
> use symbols on values that the author of the program is
> totally in control of; or in short lived processes.


Hmm, sounds like that could be used as an exploit to kill a rails
server.
Don't they use a lot of symbol <=> string conversion for their SQL
queries
or URL accesses?
Harpo (Guest)
on 2005-12-31 13:54
(Received via mailing list)
Steve L. wrote:

> And nobody even gave me two cents :-)

Ask for more, try three.

Funny new year !
Dave H. (Guest)
on 2006-01-05 00:08
(Received via mailing list)
On Dec 30, 2005, at 5:39, Devin M. wrote:

> Hey, all you lurkers:
>
> Have any of the explanations in the thread (What is the difference
> between :foo and "foo" ?) helped you understand symbols?

I've just started trying to find these discussions and read them
because I haven't been at all clear on the difference, so I'll get back
to you on what does work.

However, although I don't meant to pick on szpak specifically, he did
provide a sterling example of what doesn't work, at least for me, and I
have worked professionally as a writer of documentation....

	"A symbol in Ruby is similar to a symbol in Lisp

I don't know Lisp. Or Java. Unless you know that your reader is already
familiar with your reference, it's not helpful to use it.

  	in that the symbol is a name, or more precisely a named atom

"Atom" is undefined here. I know what an atom is. My desk is made of
them. This is apparently some other kind of atom...

	which can also respond to a request to expose itself as a number
(to_i) or a string (to_s).

Neither names nor atoms respond to requests in my world. The use of
"expose" is even more confusing.

	In this case a Ruby symbol is similar to a Lisp keyword symbol

Is a Lisp keyword symbol different than a Lisp symbol?

	(which is also prefixed by a colon (:), at least in some versions of
Lisp).

Sometimes?

	However, in Lisp a symbol has much greater functionality.
	For example, a Lisp symbol can also be bound to a value, a property
list, or a function.

I definitely don't need to know what *else* a Lisp symbol can do. I
would like to know what Ruby symbols *are* bound to, if not values,
property lists, or functions. (I'm going to guess "string.")

	In briefest, my understanding of symbol in Ruby is that it is an
interned string used as a name
	("interned" meaning that it is entered into memory as a single, atomic
entity, a monad -
	there is just one of it, with a single pointer to it).

Aha. I do know what a string is, and the definition of "interned" is
supplied. However, the definition
isn't very helpful. We're back to "atomic," with the implication that
"normal" strings aren't atomic.
Then there's "monad," but that's also undefined.



Again, this isn't intended to be a criticism of szpak specifically. He
just provided a nice short example of what I see over and over again on
this list. I don't know Lisp. I don't know Java. I don't know
Smalltalk. I don't know PHP, or Python, or Perl, or C (plain, plussed,
objective, or sharp). It's nice that there are lots of people on the
list who do, and if you're trying to explain some part of Ruby to them,
by all means, use common references. But don't assume we newbies know
this stuff until we tell you.

Me, I know SQL, and AppleTalk, and REXX, and Modula-2, and Pascal, and
real (not Real) BASIC, with line numbers. I decided I needed to learn a
new language, something I could script and web and just generally do
whatever I needed to do in. I picked Ruby.

Do I expect the myriad references to Python and Java to suddenly vanish
from the list? Of course not. I'm just saying, if there's some big
discussion about threading that uses Java as the counterexample, don't
be surprised if I ask that same question a week later.
Dave H. (Guest)
on 2006-01-05 00:20
(Received via mailing list)
On Dec 30, 2005, at 8:52, Mark S. wrote:

>  I think the host/port example on the second
> half of this page seemed to make the most difference to me:
>
> http://microjet.ath.cx/WebWiki/
> 2005.12.27_UsingSymbolsForTheWrongReason.html

Ack. I'm glad that helped somebody, but it was meaningless for me. It
still had nothing about what a symbol *is*. Until I find out what they
actually are, I can use them only by parrotting. "When I type
attr_reader, I have to do that colon-name thing, which then turns into
an @name thing later for no visibly logical reason. But that's what you
do, so I do it. La la la."

However, the link on that page seems to be much more useful to *me*.

http://onestepback.org/index.cgi/Tech/Ruby/
SymbolsAreNotImmutableStrings.red

[thinking]

Nope, still don't know what they are.

For pity's sake, though, do NOT respond to my message by trying to
explain them. I haven't finished reading all the messages yet, but
apparently there are a couple million, so no point in adding new ones
just yet!
Dave H. (Guest)
on 2006-01-05 00:50
(Received via mailing list)
On Jan 4, 2006, at 14:06, Dave H. wrote:

>
> On Dec 30, 2005, at 5:39, Devin M. wrote:
>
>> Hey, all you lurkers:
>>
>> Have any of the explanations in the thread (What is the difference
>> between :foo and "foo" ?) helped you understand symbols?

Gregory B.'s examples showing object IDs have provided some hints,
although I now feel an awful lot like Alice:

	'You are sad,' the Knight said in an anxious tone: 'let me sing you a
song to comfort you.'
	'Is it very long?' Alice asked, for she had heard a good deal of
poetry that day.
	'It's long,' said the Knight, 'but very, VERY beautiful. Everybody
that hears me sing it--either it brings the TEARS into their eyes, or
else--'
	'Or else what?' said Alice, for the Knight had made a sudden pause.
	'Or else it doesn't, you know. The name of the song is called
"HADDOCKS' EYES."'
	'Oh, that's the name of the song, is it?' Alice said, trying to feel
interested.
	'No, you don't understand,' the Knight said, looking a little vexed.
'That's what the name is CALLED. The name really IS "THE AGED AGED
MAN."'
	'Then I ought to have said "That's what the SONG is called"?' Alice
corrected herself.
	'No, you oughtn't: that's quite another thing! The SONG is called
"WAYS AND MEANS": but that's only what it's CALLED, you know!'
	'Well, what IS the song, then?' said Alice, who was by this time
completely bewildered.
	'I was coming to that,' the Knight said. So saying, he stopped his
horse and let the reins fall on its neck: then, slowly beating time
with one hand, and with a faint smile lighting up his gentle foolish
face, as if he enjoyed the music of his song, he began.


I'm developing the very strong suspicion that no explanation of symbols
will get far unless it's part of a broader context that includes
variables and references.

dblack said:
> a = "string" # a contains a reference to that string
and Gregory provided examples that indicate something more complicated:
the `a' above contains a reference to an object, created especially for
that variable, that contains six characters. Doing it again with
variable `b' gives you an identical twin.

>  a = 1        # a contains the actual (immediate) value 1

Except the example would seem to contradict this statement. `a' `b' and
`c' do not contain actual anythings. They contain references to the
same object, that object which is the value "1".

Maybe. I guess it depends on what, exactly, the .object_id method
returns, or on what "actual" or "immediate" means. It would appear it
means something much less immediate than I'd expect.

"Named number" is beginning to make sense, to the degree that it's now
clear there's some kind of serious difference between strings and (some
kinds of?) numbers in Ruby.

On the other hand, there's still some serious ambiguity, because
Gregory's numbers and strings were put into variables, but the symbols
weren't stored in variables. What I need to figure out is how does a
symbol differ from a string literal, numeric literal, or variable, not
how it differs from a string or number IN a variable.

Onward.....

Once again, a gentle reminder: please feel free to comment on the
learning process I'm documenting if you like, but do NOT respond if
you're going to try to explain more about symbols and whatnot. Thanks!
Ross B. (Guest)
on 2006-01-05 01:08
(Received via mailing list)
On Wed, 04 Jan 2006 22:06:00 -0000, Dave H.
<removed_email_address@domain.invalid>
wrote:

> However, although I don't meant to pick on szpak specifically, he did
> provide a sterling example of what doesn't work, at least for me, and I
> have worked professionally as a writer of documentation....
>
> 	"A symbol in Ruby is similar to a symbol in Lisp
>
> I don't know Lisp. Or Java. Unless you know that your reader is already
> familiar with your reference, it's not helpful to use it.
>

Maybe (maybe?) there aren't any really good references out there on what
a
Ruby symbol is. And maybe you don't know Lisp. Maybe I don't either. But
at least we both have a much wider field to Google now...
unknown (Guest)
on 2006-01-05 01:14
(Received via mailing list)
Hi --

On Thu, 5 Jan 2006, Dave H. wrote:

> much less immediate than I'd expect.
I've always conceptualized it as pretty much a value vs. pointer
difference.  I avoid the word "pointer" because (a) Matz never calls
it that, and (b) it's not a matter of physical memory, but a Ruby-side
notion of reference.  Still, it's close to the same idea.

Fixnums, Symbols, true, false, and nil get assigned directly to
variables.  For other objects, variables get a reference to the
object.  References, like variables, are not themselves objects.
They're part of a kind of language substratum on which the object
system floats.

I think that's all there is to it.  In fact, in a sense there's even
less to it, since Ruby handles any necessary de-referencing for you,
so you don't have to make any explicit distinction in your code.

> Once again, a gentle reminder: please feel free to comment on the learning
> process I'm documenting if you like, but do NOT respond if you're going to
> try to explain more about symbols and whatnot. Thanks!

I'm giving myself a directly-quoted-person exemption :-)


David

--
David A. Black
removed_email_address@domain.invalid

"Ruby for Rails", from Manning Publications, coming April 2006!
http://www.manning.com/books/black
unknown (Guest)
on 2006-01-05 02:27
(Received via mailing list)
Quoting removed_email_address@domain.invalid:

> Fixnums, Symbols, true, false, and nil get assigned directly to
> variables.

It may be helpful to think of them as objects which are addressed
directly by their values.

-mental
Jim W. (Guest)
on 2006-01-05 02:49
DAB wrote:
> Fixnums, Symbols, true, false, and nil get assigned directly to
> variables.  For other objects, variables get a reference to the
> object.  References, like variables, are not themselves objects.
> They're part of a kind of language substratum on which the object
> system floats.

True, but ...

> [...] In fact, in a sense there's even
> less to it, since Ruby handles any necessary de-referencing for you,
> so you don't have to make any explicit distinction in your code.

I think that this second statement is much more important than the
first.  The fact that 1073741823 is direct and 1073741824 is a reference
makes very little difference 99.99% of the time.

Understanding that Fixnums, Symbols and the such are direct is good for
groking implementation details, but provides little insight in using
Ruby.  The fact we can pretend that everything is a reference is a
marvelous feature of the Ruby object model.

Just MHO.

--
-- Jim W.
unknown (Guest)
on 2006-01-05 03:00
(Received via mailing list)
Hi --

On Thu, 5 Jan 2006, Jim W. wrote:

>> less to it, since Ruby handles any necessary de-referencing for you,
>> so you don't have to make any explicit distinction in your code.
>
> I think that this second statement is much more important than the
> first.  The fact that 1073741823 is direct and 1073741824 is a reference
> makes very little difference 99.99% of the time.
>
> Understanding that Fixnums, Symbols and the such are direct is good for
> groking implementation details, but provides little insight in using
> Ruby.  The fact we can pretend that everything is a reference is a
> marvelous feature of the Ruby object model.

It is indeed.  I think one reason I'm so immediate-value-aware is the
history of discussions of ++, the absence of which makes sense in
light of the immediate value thing (with numbers).  And I guess I'd
put that at a middle level -- not something you really need to know to
use Ruby, but not quite an implementation detail either; more of a
language design thing.


David

--
David A. Black
removed_email_address@domain.invalid

"Ruby for Rails", from Manning Publications, coming April 2006!
http://www.manning.com/books/black
Chad P. (Guest)
on 2006-01-05 04:21
(Received via mailing list)
On Thu, Jan 05, 2006 at 07:06:00AM +0900, Dave H. wrote:
>
> However, although I don't meant to pick on szpak specifically, he did
> provide a sterling example of what doesn't work, at least for me, and I
> have worked professionally as a writer of documentation....
>
> 	"A symbol in Ruby is similar to a symbol in Lisp
>
> I don't know Lisp. Or Java. Unless you know that your reader is already
> familiar with your reference, it's not helpful to use it.

To be fair, I think the only reason he discussed the comparison of Ruby
symbols to Lisp symbols is this (I use "he" in the generic here):

I wasn't getting a clear picture of what a Ruby symbol actually was from
most of the comments about it, until I saw some evidence that it bore an
at least passing resemblance to a Lisp symbol.  While I'm no leet lisp
haxxor type, I do have a halfway decent notion of what a symbol is in
Lisp, so I pursued that comparison as a means of helping *me* understand
what a Ruby symbol was, and szpak was responding to that.  In other
words that was kinda directed at me, and it did help me a bit to
understand Ruby symbols, so as a special case explanation it did exactly
what it needed to.

That having been said, if you'd like to try approaching the problem of
uderstanding a Ruby symbol by way of learning what a Lisp symbol is and
differentiating it from a Ruby symbol, let me know.  I'll see if I can
accomodate you.  As far as my understanding of the subject goes, that
seems to be the shortest path from zero to grokking.

--
Chad P. [ CCD CopyWrite | http://ccd.apotheon.org ]

print substr("Just another Perl hacker", 0, -2);
unknown (Guest)
on 2006-01-05 06:10
(Received via mailing list)
On Jan 4, 2006, at 7:49 PM, Jim W. wrote:
> The fact we can pretend that everything is a reference is a
> marvelous feature of the Ruby object model.

+1

In fact I think of Fixnum and Symbol literals as
just special variables pre-bound to references to particular
objects in the way that uninitialized instance variables
are pre-bound to the nil object, but unlike variables you
can't vary the binding.  I'd call them constants but then
everyone would get confused with that whiny group of variables
that start with an uppercase letter and then complain every-
time something changes.

Gary W.
Amr M. (Guest)
on 2006-01-05 07:26
The longish 'foo' vs :foo thread was helpful to me as a "nuby" in terms
of understanding the ruby Symbols. Personally, I like to see the dirty
details of what happens when a symbol is encountered in teh token
stream:

For example, for me it would be instructional to hear from a Ruby expert
as to what the interpreter does when it sees :foo or some such.

I don't think the discussions of lower level details are all bad. Most
of us maybe new to Ruby, but most if not all, have quite a few years in
computing, so there might still be instructional value in giving the
details on what exactly happens when a ruby 'Symbol' is encountered in
the token stream.

It might benefit those who wish to look a little deeper.

thanks to all the experts for taking the time to go over this for the
benefit of us newcomers. (and then going the extra mile to ask whether
it made sense.. now that's truly refreshing to see in an online
community) :)

Cheers,

-A



Devin M. wrote:
> Hey, all you lurkers:
>
> Have any of the explanations in the thread (What is the difference
> between :foo and "foo" ?) helped you understand symbols? A combination
> of them? Or a combination of a couple of explanations, and an irb
> session? Which ones? Why? If you don't want to get involved in (what
> seems to be turning into) a flamewar, email me personally (hint: don't
> click "Reply" :P), and I'll compile the results anonymously.
>
> I think we all agree that everybody learns differently, and so I think
> we're in dire need of feedback from somebody other than Chad (no
> offense).
>
> Devin
(Guest)
on 2006-01-05 09:23
(Received via mailing list)
Here is a short breakdown of how symbols (and other immediates are
implemented):

A variable holds a value. That value is a integer. The value of the
integer determines what it means. For example:

If the integer is odd, then the remaining bits of the integer are a
Fixnum value.

This means that if you do

a = 0

the interpreter stores in the local variable table the value
0x00000001. If you had assigned 4 to a, then the value would be
0x00000041. This allows for all Fixnums to not require additional
memory to represent. The same goes for true, false, nil, and symbols.
For the first 3, they are:

Name      Backend Integer Value
=========================
false        0
true         2
nil            4
undef      6 (This isnt accessible from native ruby code, but is used
internally)

For symbols, the least significant byte is 0x0e and the upper 3 bytes
are a integer. The integer is uniquely assigned value for a string.
Think about it as the table index for a string. By using a symbol, you
basically allocate a string once and then refer to it by the index it
occupies in a special symbol table. For example, the first time the
symbol :evan is seen, a string containing "evan" is created and stored
in the symbol table at, say, index 9323. The variable that was assigned
:evan gets assigned
((9223 << 8 ) | 0x0e). The next time :evan is seen, "evan" is looked up
in the symbol table to obtain 9232 again.

So, to review:

a = :evan

a.to_i            # => 9232 (the index in the symbol table)
a.object_id    # => 2363406 (the index << 8 | 0x0e)
a.to_s           # => the reference to the string object located at
index 9232 in the symbol table

The ruby runtime rules take the integer value and apply the rules to
determine what it means. If it's odd, it's a Fixnum immediate value. If
it's 0,2,4, or 6, it's a "core" immediate value. If it has the LSB is
0x0e, it's a symbol. Otherwise, it's a pointer to a memory address that
holds the information about the object.

Thats the end of days leason! Hope it helps!

Evan Webb // removed_email_address@domain.invalid
Timothy H. (Guest)
on 2006-01-05 14:30
(Received via mailing list)
removed_email_address@domain.invalid wrote:
>
> Thats the end of days leason! Hope it helps!
>
> Evan Webb // removed_email_address@domain.invalid
>

Nicely done, Evan! Very good explanation. Thanks!
Amr M. (Guest)
on 2006-01-05 20:47
removed_email_address@domain.invalid wrote:
> Here is a short breakdown of how symbols (and other immediates are
> implemented):
>
...

> By using a symbol, you
> basically allocate a string once and then refer to it by the index it
> occupies in a special symbol table. For example, the first time the
> symbol :evan is seen, a string containing "evan" is created and stored
> in the symbol table at, say, index 9323. The variable that was assigned
> :evan gets assigned
> ((9223 << 8 ) | 0x0e). The next time :evan is seen, "evan" is looked up
> in the symbol table to obtain 9232 again.
>
> So, to review:
>
> a = :evan
>
> a.to_i            # => 9232 (the index in the symbol table)
> a.object_id    # => 2363406 (the index << 8 | 0x0e)
> a.to_s           # => the reference to the string object located at
> index 9232 in the symbol table
>
> The ruby runtime rules take the integer value and apply the rules to
> determine what it means. If it's odd, it's a Fixnum immediate value. If
> it's 0,2,4, or 6, it's a "core" immediate value. If it has the LSB is
> 0x0e, it's a symbol. Otherwise, it's a pointer to a memory address that
> holds the information about the object.
>
> Thats the end of days leason! Hope it helps!
>
> Evan Webb // removed_email_address@domain.invalid

Thanks Evan, much appreciated!

This is how I understand it now:

1. When the interpreter sees :<string> it looks in the "symbol table"

2. if it finds the value, it returns the int index (or the computed
object_id?) of it otherwise creates a new entry

3. somestringofchars.object_id returns something which is a function (in
mathematical sense) of the index of somestringofchars in the symbol
table. (i.e., indexofsymbolstring << 8 | 0xE0 )

4. ':' is just a way of giving the interpreter the heads up that a
symbol is coming up in the token stream (ie we think we know what we're
talking about, can you please look it up in the symbol table? nice
interpreter.. nice interpreter)

5. some object_id values are computed differently, for example the
session below (I don't know why, its a hole in my understanding of how
object_id's are assigned):

irb(main):054:0> false.object_id
=> 0
irb(main):055:0> 0.object_id
=> 1
irb(main):056:0> true.object_id
=> 2
irb(main):057:0> 1.object_id
=> 3
irb(main):058:0> nil.object_id
=> 4
irb(main):059:0> def.object_id       # not sure why
irb(main):060:1> undef.object_id     # possibly cuz its strictly
internal

6. Whether a token is valid or not, it gets added to the symbol table
and an object_id _can be_  computed from the symbol based on what type
of symbol it is (only if its a valid object methinks). Otherwise an
error is thrown.

8. there is a separate table which holds the variables. I'm not sure if
this is true from what I've seen in irb, it looks like a variable's
symbol gets stored in the symbol table as well or at least a symbol
which may point to its value location.

:8.1 Every time we refer to a variable var , the interpreter uses the
:var thingy
 so if we did xx="Hi there", there would be an :xx created, but I don't
know how to get to "Hi there" from :xx (:xx.to_s just gives me "xx")

9. a symbol is just an atomic representation (AFA-the user-IC) of a
token added to the symbol table and exposed via the Symbol class so we
can use it if we want to instead of creating new string objects for
referring to things like methods etc and incurring needless overhead
(however small it might be).

10. I'm guessing Ruby interpreter needs symbols for its own housekeeping
(obviously)  but the implementers were just being nice and allowed end
users to use them too for certain specific situations (I can't think of
a good example ).

So, basically, the first thing the interpreter does is, it takes the
token and stuffs it in the symbol table, then it figures out what to do
with it (steps 1..n) . And since we have access to the symbol for a
given reference, why not use that instead of referring to it via a
string object which gets created anew every time we referr to it. Even
though the end result is the same.

thanks,

-A
Jacob F. (Guest)
on 2006-01-05 20:57
(Received via mailing list)
If I may make one correction/clarification to an otherwise *excellent*
explanation of the implementation...

On 1/5/06, removed_email_address@domain.invalid 
<removed_email_address@domain.invalid> wrote:
> For symbols, the least significant byte is 0x0e and the upper 3 bytes
> are a integer. The integer is uniquely assigned value for a string.
> Think about it as the table index for a string. By using a symbol, you
> basically allocate a string once and then refer to it by the index it
> occupies in a special symbol table. For example, the first time the
> symbol :evan is seen, a string containing "evan" is created and stored

Clarification: a *C* string containing "evan" is created...

> a.object_id    # => 2363406 (the index << 8 | 0x0e)
> a.to_s           # => the reference to the string object located at
> index 9232 in the symbol table

Correction: a.to_s returns a reference to a new String object
containing the same sequence of characters as the C string in the
symbol table. This is visible when you compare the result of
#object_id on subsequent calls to a.to_s:

irb> a = :evan           # => :evan
irb> a.to_s.object_id    # => 1657424
irb> a.to_s.object_id    # => 1653204

> The ruby runtime rules take the integer value and apply the rules to
> determine what it means. If it's odd, it's a Fixnum immediate value. If
> it's 0,2,4, or 6, it's a "core" immediate value. If it has the LSB is
> 0x0e, it's a symbol. Otherwise, it's a pointer to a memory address that
> holds the information about the object.
>
> Thats the end of days leason! Hope it helps!

Thanks, Evan! Aside from those minor, pedantic corrections, it was
indeed an excellent lesson.

Jacob F.
(Guest)
on 2006-01-05 22:33
(Received via mailing list)
Jacob,

Correct. The symbol table holds pointers to C strings and new String
objects are created with each call to Symbol#to_s.

I should note that Symbols are native ruby access to the ruby runtime
ID type. It's this reason that C strings are stored in the symbol
table, because the C functions for using ID's (rb_intern and
rb_id2name) use/return char * and ID.
Simon Kröger (Guest)
on 2006-01-05 22:42
(Received via mailing list)
Just because there seems to be so much confusion i would like to
point out some minor flaws in your post so nobody else stumble over
them. (Correct me please if the error is on my side)

removed_email_address@domain.invalid wrote:
>
> a = 0
>
> the interpreter stores in the local variable table the value
> 0x00000001. If you had assigned 4 to a, then the value would be
> 0x00000041. This allows for all Fixnums to not require additional

no, i think it would store 0x00000009 because only the first bit
is reserved, not the first nibble. ( 4 << 1 | 1)

>
> For symbols, the least significant byte is 0x0e and the upper 3 bytes
> are a integer. The integer is uniquely assigned value for a string.
> Think about it as the table index for a string. By using a symbol, you
> basically allocate a string once and then refer to it by the index it
> occupies in a special symbol table. For example, the first time the
> symbol :evan is seen, a string containing "evan" is created and stored
> in the symbol table at, say, index 9323. The variable that was assigned
> :evan gets assigned
> ((9223 << 8 ) | 0x0e). The next time :evan is seen, "evan" is looked up

This should obviusly be ((9232 << 8 ) | 0x0e)

> in the symbol table to obtain 9232 again.
>
> So, to review:
>
> a = :evan
>
> a.to_i            # => 9232 (the index in the symbol table)
> a.object_id    # => 2363406 (the index << 8 | 0x0e)
> a.to_s           # => the reference to the string object located at
> index 9232 in the symbol table

This seems to create a copy each time. (at least if there is no ruby
string around)

> The ruby runtime rules take the integer value and apply the rules to
> determine what it means. If it's odd, it's a Fixnum immediate value. If
> it's 0,2,4, or 6, it's a "core" immediate value. If it has the LSB is
> 0x0e, it's a symbol. Otherwise, it's a pointer to a memory address that
> holds the information about the object.
>
> Thats the end of days leason! Hope it helps!
>
> Evan Webb // removed_email_address@domain.invalid

Thanks this may be realy helpfull for those who want to understand
symbols and have a decent idea how interpreters work.

cheers

Simon
This topic is locked and can not be replied to.