Cover image credit: Chris Evans
I've been using Python for years, but I recently wrote my first bit of ruby. There are many things that felt weird to me, which I guess is normal when you're writing in a language that's new to you.
I'm going to start with the weirdest thing to me
In python, the expression
foo.bar means "look in the current scope and any outer scopes for a thing named
foo, then, get an attribute named
bar from it."
In ruby, what this expression seems to mean, as far as I understand (please let me know whether my mental model is right) "Look up a thing called
foo in the current scope or any outer scopes. If it's a method, call it with no arguments, directly use the value. On the result, look for a method called
bar, and call it with no arguments."
So for example:
gets.chomp calls the method
gets, and calls
chomp on the result. (in ruby, this gets a line of input from stdin, and then removes trailing whitespace.)
In Python, to get the same result, if the functions had the same name, you'd do:
It often felt to me like ruby would need a lot less syntactic sugar if they just required brackets for method calls. For example, you don't need an
@ for instance fields if you can just access them with
this.field. There would be no need for the
instance.method(:foo)method to access a method, since you just access it by refering to its name without adding brackets (i.e.
But in the end, I guess it just feels weird to me that referring to a variable and calling a method with no arguments have exactly the same syntax.
The way you end blocks with
end felt weird at the start, but I actually really like this. Most editors automatically indent code blocks anyway, so there's no need to enforce it in the language like Python does. What I like about ruby's
end is that it is clear how many code blocks you're closing. If you have long blocks of indented code (yes I know you shouldn't), it's often hard in Python to see which code block you're closing.
Another thing I found strange is that
require doesn't load things into their own namespace. If you
import something in python, anything in the
something module will be available under the
something namespace. Most ruby programs seem to fix this by putting things in a
module declaration, but having to syntactically declare this feels weird. I do like the distinction between
Re-opening classes was another interesting tidbit I found. If you do
class A def foo # do stuff end end class A def bar # do stuff end end
After this code, class A will have a
foo and a
bar method. I found this useful when toying around in the interactive ruby shell, but I imagine this could get confusing in larger ruby projects, since there's nothing in this class declaration telling me that there's another part of this class written somewhere else.
I'm not sure I like implicit returns. Growing up a pythonista, I've always believed that explicit is better than implicit.
I still need to completely wrap my head around blocks, Procs and lambda's.
So that wraps it up.