Learning Rails in 2017

So far this year has been surreal & hectic to say the least, and we’re basically halfway through. I started a new job late last year, which I expected to be challenging for plenty of reasons. Arguably the most important one: I was going to support a large codebase built in Ruby (on Rails).

In the past, I too have sinned from trash talking programming languages which I knew nothing about (including Ruby). A public apology is written in this blog post, with tips/notes/comments from my personal experience learning this amazing technology.

Two steps forward, never step back

Ruby and Rails are not the shiny new toys out there, not today. Before this gig, I worked for about a year with NodeJS, which I fell in love with. To be honest I didn’t expect to start off fresh with a new language & framework. Especially with the direction of recent tech tides, this didn’t seem like the obvious direction to follow.

Why do people/companies choose Java or .NET? Broadly because they look for a battle tested, full featured platform with enterprise support. Why choose NodeJS, Go, Elixir, Clojure? (you get the idea) Because I wanna go fast, amongst other reasons of course. But one might argue performance is what most adopters pursue when venturing down that path. Even though they might not need blazing speeds, and more often than not they don’t absolutely require that performance gain.

Why Ruby and Rails then? Because why not, but only partially. Platform maturity, developer happiness/productivity and open sourceness (if such a term makes sense) make up a great cocktail. We all want to get things done, right? I’m happy and proud to have added Ruby and Rails to my Tool Belt, which already has and will hopefully continue to help me get things done.

Getting started

If you’re looking for a step by step guide on getting started with Ruby on Rails this is where you should go. My perception is that, if you read and code along with the Getting Started tutorial from the official guides you will understand ~50% of what Rails is all about. Another ~30% lives in all the other guides from guides.rubyonrails.org.

Yes, I believe ~80% of what you need to know about Rails is available in a single website! That last ~20% is what the Pareto Principle is all about, you are forced to pour some hard work in to get past that threshold.

For somebody who is just getting started or is planning to, here are some concepts that gave me an “Aha! Moment” (involving both Ruby and Rails):

• “Not everything is plain Ruby, but everything is an object”. It might seem obvious for experienced Ruby devs, but it probably isn’t for beginners or coders experienced in old-school static typed languages. For example 1.week.ago is an ‘extension’ packaged with Rails that you need to explicitly import to use outside a Rails project. And Integers are objects themselves, which is why you were able to call functions on what a Java programmer knows as a primitive data type.
• You will hear about convention over configuration a lot on introductory tutorials and with a bit of practice you will later interiorize most of them. Some of the ones I struggled with at first were:
  • File names (controllers, models, views, helpers, etc) are commonly snake_cased, but their implementation (class name in the code) is CamelCased. Both of them in singular, since they will represent one object when used (i.e. User.new).
  • Model association names are declared in plural form, for example in user.rb you would write has_many :books to associate with book.rb. Unless they are a belongs_to or references association, which makes sense because they refer to a single record. The book model would read belongs_to :user.
  • Forms & routes might seem complex, especially when nesting, like form_for [@article, @article.comments.build]. Personally they are still tricky, especially when I want to instantiate a link to a custom route path outside the form. For this I still do a bit of trial and error, or the old trick of copy & paste from StackOverflow.
  • My suggestion again would be to experiment and trace along the getting started guide. You won’t confront the convention quirks of Rails until you derail yourself a bit (pun 100% intended).
• The yield command is analogous to “execute the block received”. This took me a few minutes of re-reading different explanations out there. When declaring a function with 2 parameters, it can actually receive 3. That extra (optional) parameter is a “callback-like” block. For example, when you iterate an array with array.each { |i| puts i } the underlying implementation of the array iterates over its elements and “yields” that element to the callback function you sent in. Coming from a NodeJS background, that simplified explanation using the term ‘callback’ makes sense to me. Also this StackOverflow answer elaborates a bit more if you’re curious.

Bookmarks

The next step after the official guides for me was to start looking for in-depth takes on certain topics. That type of knowledge only comes from experienced coders. Who has that precious knowledge we seek? Glad you asked, some of my bookmarks are (in no particular order):

• RubyTapas: Short screencasts with awesome insight on many different subjects. I really like the rake episodes (kind of outside RubyTapas, but same author and overlapping subjects).
• tenderlovemaking.com: What you’ll find in this website cannot be unseen - “The act of making love, tenderly” ( ͡° ͜ʖ ͡°)
• Schneems’s blog: Performance is a recurring topic in here. Regardless of the platform you code in, who doesn’t have a need for speed?
• The official docs: Learning a new framework means you will google “how does X works”, constantly. I’m sorry to say that sometimes API dock didn’t had the best up to date info I was looking for. Still helpful though, but I tend to check api.rubyonrails.org results first.
• ConFreaks: Entire RailsConf talks are in there from 2017, 2016 and probably previous ones as well, awesome material. Turbolinks 5: I Can’t Believe It’s Not Native! by Sam Stephenson is definitely the one that struck me the most, personal favorite so far (and this is coming from an iOS dev :wink:)
• Any talk from the late Jim Weirich: That video is amazing, and so are all the other ones that I’ve seen so far from him. His legacy touched my life too, years after he passed. Thanks a lot Jim.
• Podcasts of course: I’ve listened a couple of 5by5 & RubyRogues episodes, interesting indeed.

I would love to hear other interesting sources I’m missing, which I’m sure there are plenty. It’s also imperative to mention: At least browsing through the Readme of the gems you commonly use will decrease your ‘Rails does a lot of Magic under the hood’ perception, significantly.

It’s open source people, take advantage of being able to read code from some of the best coders in the business.

Everyday Cheatsheet

Short snippets I lookup quite often because they are useful (and I’m too lazy to memorize them):

• Rollback N migrations:

  rake db:rollback STEP=1
  

• Execute custom SQL statement on Rails console:

  results = ActiveRecord::Base.connection.execute("foo")
  

• STDOUT logging to file using tee (UNIX only I guess):

  STDOUT.reopen IO.popen "tee stdout.log", "a"
  STDERR.reopen IO.popen "tee stderr.log", "a"
  

• Docker logs STDOUT fix (flush):

  # From what I hear this comes with a performance penalty due to costly I/O
  STDOUT.sync = true
  

Conclusions

Every language and framework has a learning curve, no exceptions. I did felt that both Ruby and Rails are gentle for newcomers, and if you know JS/Java/Python (as plenty of CS graduates or even high school students sometimes do) you can be up and running quickly.

In my opinion using a framework is the only way to learn a framework. Have fun coding out there with whatever floats your boat these days, Pura Vida!