Walking in unfamiliar shoes: Ruby feels weird to me.
Tags: ruby, firsttime, programminglanguages
Published: 2017-03-22 05:02:47

---
title: "Walking in unfamiliar shoes: Ruby feels weird to me."
published: true
description: I've been using python for years, and I just wrote my first program in ruby. There are some things that feel weird to me. This is not a very informative post, but more of a diary of my experience as a first-time user.
cover_image: http://c1.staticflickr.com/7/6038/6269207855_0fe756cc0b_n.jpg
tags: ruby, first-time, programming languages
---

*Cover image credit: [Chris Evans](https://www.flickr.com/photos/drumminhands/6269207855)*

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

## No methods for function method calls


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: `gets().chomp()`

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. `instance.foo`)

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.

## Some smaller things

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 `load` and `require` though.

Re-opening classes was another interesting tidbit I found. If you do

```ruby
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.