b=5 #<= b points to an object 5

def test(a) #<= a points to the same object as b (5)
a=6 #<= a points to a new object 6
end

test(b) #<= returns 5

—————————-
b=[1,2,3]

def test2(a) #<= a points to the same object as b ([1,2,3])
a[0]=6 #<= a[0], which pointed to the first object in the array (1), now points to the new object 6
end

test2(b) #<= returns [6,2,3]

def dummy_method(valued)
some_thing=valued
return some_thing
end

now on the call of this method
dummy_method(valued=gets.chomp.to_i) #that is a normal call

but can i do like this to call

dummy_method(valued= print ” Enter your value” ,gets.chomp.to_i)

{ :some_id => 1, :something => 'one' }.reject{|k, v| k =~ /_id/ }
#=> {:some_id=>1, :something=>"one"}

Which is totally different from Ruby 1.9.1

{ :some_id => 1, :something => 'one' }.reject{|k, v| k =~ /_id/ }
#=> {:something=>"one"}

If you just make it k.to_s, your gist will give the same result on both versions of Ruby.
On the other hand, I can’t see where pass by reference is taking place…. can you elaborate?

http://gist.github.com/225709

def foo(bar)
bar.replace “if you can see this, bar was passed by value reference”
end

foo(bar)

puts bar

Saying that b is passed by value is as incorrect as saying that b is passed by reference. I am able to change bar via the parameter bar. That means that I do have a reference to bar in some sense. If what i received was simply a value copy, then I would not be able to reach the outer scope bar. if it was an actual pointer to bar, then I would be able to simply manipulate it as I do in C/C++. I understand the argument about the object_id, but claiming ruby is simply pass by value misses an important distinction. I was able to alter bar within foo when bar was passed as a parameter.