Greetings

Ruby
1

Hello,

some months ago I started to use Python and to see the light.

Now my eyes are a bit burned so I went back to the darkness (for some
glittering red gem). I started Ruby.

I read almost the whole pragmatic programmer book without writing a
piece of code, except this: 15.times { puts ‘I love you, xxx’}, where
xxx were my girlfriend’s name. From that moment she also started to like
Ruby.

It is a good book. However, it is based on Ruby 1.6. I failed to find
something like “what changed from 1.6 to 1.8”. Can you help me?

Also, the reference is hard to read. It took a simple google session to
find the quoted-printable method (Array.pack(‘M’)). I think it could be
easier to find in the manual.

Setting up postgresql was quite easy (apt-get install libpgsql-ruby).
The documented PGconn.open method generated error, it said that it is
protected method. I use PGconn.new. Is it normal? I cannot skip the
‘port’ parameter with the new method.

On the whole I am happy with my first Ruby script and with the language
itself.

      Mage
2

On 1/23/06, Mage [email protected] wrote:

Ruby.

It is a good book. However, it is based on Ruby 1.6. I failed to find
something like “what changed from 1.6 to 1.8”. Can you help me?

The second edition of the book was released two years ago or so and
covers Ruby 1.8. You should read that one instead.

Here’s a pretty good summary of the changes in Ruby 1.8.
http://whytheluckystiff.net/articles/rubyOneEightOh.html

3

On Jan 23, 2006, at 9:56 AM, Mage wrote:

     Hello,

Hello and welcome to Ruby.

I read almost the whole pragmatic programmer book without writing a
piece of code, except this: 15.times { puts ‘I love you, xxx’},
where xxx were my girlfriend’s name. From that moment she also
started to like Ruby.

It is a good book. However, it is based on Ruby 1.6.

Actually, the current version of the Pickaxe covers very modern Ruby:

I strongly recommend picking it up.

I failed to find something like “what changed from 1.6 to 1.8”. Can
you help me?

The top hit from Google for “What’s new in Ruby 1.8” is:

http://whytheluckystiff.net/articles/rubyOneEightOh.html

:wink:

James Edward G. II

4

Joe Van D. wrote:

Thanx.

One of the things I don’t understand are the semicolons. When I read the
Book, it said:

class SomeThing
atrr_reader :x, :y
end

I figured out that the attr_reader need to get the name of the instance
variables.

However, what is this code good for?

def make_point_hash( point )
center = { :x => 1, :y => 2 }
big = { :r => 10 }
center.merge( big ).merge( point )
end
make_point_hash( { :x => 20 } )

#=> {:y=>2, :r=>10, :x=>20}

What is that those semicolons do?

Mage
5

I may be totally off base, being a Ruby N. myself, but I believe the
point of the :variable is sort of passing a HashMap to the method…for
instance:

inside the method
center = { :x => 1, :y => 2 }

you can refer to the parameters as :x and :y. As opposed to mandating
the prototype of the method being center(x, y).

The benefits I can see are variable length arguments, and the arguments
placed don’t have to be in the same order. Coming from java, I’m
actually a little wary about this, but I sort of understand the
usefulness, especially after reading the Rails book.

-Zach

6

On 1/23/06, Zach [email protected] wrote:

I may be totally off base, being a Ruby N. myself, but I believe the
point of the :variable is sort of passing a HashMap to the method…for
instance:

inside the method
center = { :x => 1, :y => 2 }

The fact that the right-hand side is surrounded by curly braces is
what makes it a Hash. Each key/value pair initially added to the Hash
looks like “key => value”. In this particular case, they decided to
use symbols for keys which is pretty common. The colon means that the
word following it is a symbol. They could have also used String keys.

There was a long discussion about what symbols are recently, so I
hesitate to try to simplify this, but here goes. Think of a symbol as
a string that will be the same object in memory each time you use it.
For example, “foo” and “foo” will be two different objects in memory,
but :foo and :foo will refer to the same object.

you can refer to the parameters as :x and :y.

Well, in a Hash they are called keys.

As opposed to mandating
the prototype of the method being center(x, y).

That’s a good point. Passing a Hash to a method, in a way, allows you
to pass arbitrary parameters if you think of the keys as being
parameter names the values as being parameter values.

The benefits I can see are variable length arguments, and the arguments
placed don’t have to be in the same order. Coming from java, I’m
actually a little wary about this, but I sort of understand the
usefulness, especially after reading the Rails book.

I don’t think it’s common in Ruby to use Hashes for this purpose.
Usually methods have fixed parameters and you don’t pass them in a
Hash.

7

I think you mean colons ( : ) not semicolons ( ; ) !

The colons denote Ruby symbols. There’s an article with some
explanation here:

http://glu.ttono.us/articles/2005/08/19/understanding-ruby-symbols

8

Mark V. wrote:

There was a long discussion about what symbols are recently, so I
hesitate to try to simplify this, but here goes. Think of a symbol as
a string that will be the same object in memory each time you use it.
For example, “foo” and “foo” will be two different objects in memory,
but :foo and :foo will refer to the same object.

I think I understand now, thanx.

I don’t think it’s common in Ruby to use Hashes for this purpose.
Usually methods have fixed parameters and you don’t pass them in a
Hash.

Actually, database connection parameters are good example for variable
length arguments. Sometimes you want to skip the port number and the
authentication data, other times you want only defne the user and the
database name.

      Mage
9

Exactly. I see Rails using this especially in generating views from ERB.
“Almost” every parameter can be omitted depending on how you want to
generate the view. (I’m mainly talking about the helper tags).

-Zach

10

On 1/23/06, Zach [email protected] wrote:

a block and sending it parameterized symbols?
In your previous example, you ARE passing a Hash to the link_to
method. Whenever all the parameters at the end are of the form “key =>
value”, Ruby automatically turns them into a single Hash object and
passes that to the method.

When you send a block to a method, you are giving it code that it can
choose to execute any number of times. The block always follows the
parameter list and must begin on the same line as the closing paren.
It starts with either “do” or “{”.

11

“The fact that the right-hand side is surrounded by curly braces is
what makes it a Hash. Each key/value pair initially added to the Hash
looks like “key => value”.”

I don’t know about the braces, but I was meaning more about the
Parenthesis (sorry about the type in the earlier example) for example:
|
link_to(“View Article”, :controller => “blah”, :action => “yay”, :id =>
1)|

I guess I’m clueless as to what the difference is now between sending it
a block and sending it parameterized symbols?

-Zach

12

Mark V. wrote:

link_to(“View Article”, :controller => “blah”, :action => “yay”, :id => 1)|

Great, thanks for the clarification!

-Zach

13

Mage wrote:

#=> {:y=>2, :r=>10, :x=>20}

What is that those semicolons do?

Mage

these articles on symbols were written for you:

http://glu.ttono.us/articles/2005/08/19/understanding-ruby-symbols
http://onestepback.org/index.cgi/Tech/Ruby/SymbolsAreNotImmutableStrings

http://microjet.ath.cx/WebWiki/2005.12.27_UsingSymbolsForTheWrongReason.html
http://www.rubycentral.com/faq/rubyfaqall.html#s6
http://moonbase.rydia.net/mental/blog/programming/ruby-symbols-explained.html