Ruby on Jake Worth

Why sleep Is Risky in Production Code

Thu, 05 Feb 2026 08:00:51 -0500

You might have heard that using blocking, waiting code, e.g., sleep in many languages, is discouraged. Why?

Origin of ActiveRecord

Tue, 22 Jul 2025 16:33:47 -0400

As a long-time Ruby on Rails programmer, I thought that the name ActiveRecord –the model layer of Rails’ MVC– was branding. I didn’t know that it’s an architectural pattern, described by Martin Fowler in the 2003 book Patterns of Enterprise Application Architecture.

An object that wraps a row in a database table or view, encapsulates the database access, and adds domain logic on that data.

https://www.martinfowler.com/eaaCatalog/activeRecord.html

The Factory Pattern, Explained in Ruby

Mon, 17 Oct 2022 00:00:00 +0000

In this post, I’ll explain what factories are and why you want them, using Ruby.

Why Ruby?

Thu, 30 Jun 2022 00:00:00 +0000

Why should someone learn Ruby in 2022? Ruby was my first programming language, and although I’ve drifted elsewhere, I write Ruby every day. Many people in my network are Ruby diehards. As a result, it’s been a long time since I’ve gotten the chance to sell someone on Ruby.

Hash Fetch Instead of If/Else

Sat, 16 Apr 2022 00:00:00 +0000

Conditional logic has its place, but often there’s a better alternative. Today, we’ll look at a Ruby solution: a hash with .fetch.

RSpec.describe vs. describe: Which Should I Use?

Sat, 02 Apr 2022 00:00:00 +0000

Ruby’s RSpec describe block has two common syntaxes. Which should you use?

Ruby's Frozen String Literal Comment: YAGNI

Wed, 09 Feb 2022 00:00:00 +0000

Open a production Ruby file, and you’ll often see this magic comment at the top.

# frozen_string_literal: true

Today I’d like to argue that most Ruby files do not need this comment. YAGNI— You Aren’t Going to Need It.

Find Stale Gems

Tue, 16 Nov 2021 14:19:45 -0500

Unused dependencies are bad: they increase the size of your project, slow down processes, require maintenance, and send incorrect messages to fellow developers about what’s important.

To get find unused dependencies in Ruby, I’ve been using gem stale:

gem stale

gem stale list gems along with most recent access times. If the last access time was the day you set up the app, that gem is a candidate for removal.

Ignore Rubocop Block Length Lint in RSpec

Tue, 09 Nov 2021 18:12:52 -0500

Linters are great, except when they aren’t. One example is Rubocop’s BlockLength lint. For example, I don’t care if my RSpec describe and context blocks are too long. Nontrivial test blocks will never be short enough to match a reasonable rule about blocks.

I’ve disabled this lint for these blocks with Rubocop’s configuration file:

# .rubocop.yml
Metrics/BlockLength:
IgnoredMethods: ['context', 'describe']

Opting out of just these blocks lets me enforce this rule everywhere else.

Object ID

Mon, 08 Nov 2021 09:51:01 -0500

Today I learned about the method __id__, aliased object_id, in Ruby. It returns a unique integer identifier for any Ruby object.

A few examples:

> Object.new.object_id
=> 7024702983434
> name = "jake"
=> "jake"
> name.object_id == name.object_id
=> true
> "thawed".object_id == "thawed".object_id
=> false
> "frozen".freeze.object_id == "frozen".freeze.object_id
=> true

I’ve never used this method in practice, but I hope to someday.

`group_by` with default

Fri, 05 Nov 2021 08:16:02 -0400

Here’s some code that made me do a double take.

something = items[nil]

It’s that [nil]. What’s going on here?

It turns out that items is the return of a call to Ruby’s group_by. group_by groups by whatever the block evaluates to, including nil.

[
 { shipping: 'fedex', id: 1 },
 { shipping: 'fedex', id: 2 },
 { id: 3 }
].group_by { |item| item[:shipping] }

=> {
 'fedex' => [{ shipping: 'fedex', id: 1 }, { shipping: 'fedex', id: 2 }],
 nil => [{ id: 3 }]
}

Hence the key nil.

Edit in Pry

Tue, 03 Aug 2021 16:30:47 -0400

Here’s a scenario: you’re hacking on Ruby code in pry, and it’s a mess. Blocks chained on blocks, variables named a and other_one, assignments to _. You can understand it, but nobody else can, and one extra } breaks everything.

The solution is the edit command. Typing edit in pry loads the current buffer into your editor of choice. Jump in there and turn those inline blocks into do/end, assign some variables, write a method: iterate on some quality code in the comfortable, predictable setting of your text editor.

Hash Equality

Wed, 05 May 2021 09:32:46 -0400

Ruby’s ‘principle of least surprise’ strikes me again. From the docs:

Equality— Two hashes are equal if they each contain the same number of keys and if each key-value pair is equal to (according to Object#==) the corresponding elements in the other hash.

An example:

hash = { 7 => 35, "c" => 2, "a" => 1 }
doppelganger = { "a" => 1, "c" => 2, 7 => 35 }
hash == doppelganger #=> true

Show Proc Source Location

Wed, 28 Apr 2021 17:02:11 -0400

Today I was investigating a Ruby Proc created in a gem, and I wanted to know how it was defined. Other than reading source code, there doesn’t seem to be a good way to do this! Prove me wrong.

We can get close by using Ruby’s #source_location function on Proc:

some_proc.source_location
=> ["/gems/2.4.0/bundler/gems/spree/core/app/models/spree/order.rb", 34]

This command shows us the line where Proc is defined. Go there to continue source-diving.

Steps Within Steps

Wed, 21 Apr 2021 16:51:29 -0400

Cucumber step definitions are useful for explaining in detail the actions a user might take on your site. But after a while, they become repetitive. Certain sequences of steps, like a user signing in, happen frequently in a robust test suite. We should not have to repeat them all every time we build a feature.

One solution is calling several steps from within another step:

Given 'I am a signed in developer' do
 steps %Q{
 Given I am a developer with credentials
 And I see the homepage
 When I click sign in
 Then I see the signin page
 When I enter my credentials
 And I click the sign in button
 Then I see my username in the upper right
 }
end

When you assert the topmost Given, all steps in the block will be interpolated and called. You still get the confidence of a rigorous test, but with a more concise declaration.

Upgrade Rubygems

Wed, 21 Apr 2021 09:28:21 -0400

To update rubygems:

gem install rubygems-update
update_rubygems
gem update --system

Reset a Gem

Tue, 20 Apr 2021 17:12:51 -0400

If you’ve been mucking around in your Ruby dependencies, bundle pristine is your friend; it resets all of the gems in your Gemfile to their pristine condition.

This can be a slow on a big project. Target the specific gems you worked on today with:

$ bundle pristine <gemname>

Augmenting an Object With the Proxy Pattern

Fri, 26 Feb 2021 00:00:00 +0000

Let’s look at the proxy pattern in Ruby.

Porting TIL from Rails to Phoenix: Initial Commits

Tue, 29 Nov 2016 00:00:00 +0000

Last week, I started a new project: porting Today I Learned from Ruby on Rails to Phoenix (Elixir).

Server Side Sorting in Ruby

Tue, 28 Jun 2016 00:00:00 +0000

Recently a friend asked me this question about server-side sorting in Rails. Here’s the question and my answer.

From One End to the Other in Ruby

Sun, 06 Mar 2016 00:00:00 +0000

A while back I tackled the following programming challenge:

From One End to the Other: Find the smallest possible (positive) integer that ends in a six such that if that six is removed and placed in front of the remaining digits of the number, the resulting number will be four times as large as the original.

Variable Hoisting in Ruby

Wed, 10 Feb 2016 20:45:51 -0600

This afternoon my pair and I spent quite a while on a subtle bug. The culprit? Variable hoisting.

Take this file:

class Test
 def self.hoist
 require 'pry'; binding.pry;
 bar = 1
 end
end

Test.hoist

When we hit the PRY debugger, what will the value of bar be? I would have thought it would raise NameError, because bar has seemingly not yet been defined.

Wrong:

$ ruby test.rb
From: /test.rb @ line 4 Test.hoist:
2: def self.hoist
3: require 'pry'; binding.pry;
=> 4: bar = 1
5: end
[1] pry(Test)> bar
=> nil

When Ruby parses a file, it ‘hoists’ each variable to the top of its scope, declaring and setting it to nil, even if that variable is never assigned by our code. So variables inside an if false conditional get hoisted and set to nil, as described in this blog post.

Succeed, Precede, and Surround in Haml

Wed, 06 Jan 2016 21:59:41 -0600

Haml’s design makes HTML and Ruby tricky to mix inline. But we have Haml helper methods to make it easier.

Here is succeed in action:

Developer at
= succeed ', ' do
= link_to "Hashrocket", "https://hashrocket.com/"

This becomes:

Developer at
<a href="https://hashrocket.com/">Hashrocket</a>,

Notice the comma at the end, outside of the a tag?

precede and surround work in a similar fashion, and do what we’d expect.

http://haml.info/docs/yardoc/file.REFERENCE.html#succeed

Ruby's Kernel::abort

Thu, 05 Nov 2015 18:30:56 -0600

Today I used Ruby’s Kernel::abort for the first time. It’s one of those incredibly useful methods I can’t believe I’ve never seen before.

Observe:

# abort.rb {1}
def no_message
 abort
end

def message
 abort('Process terminated')
end

$ irb
2.2.2 :001 > require './abort'
=> true
2.2.2 :002 > no_message
$ irb {1}
2.2.2 :001 > require './abort'
=> true
2.2.2 :002 > message
Process terminated
$

Use it to bail from a script.

Accessor Performance Gap

Sun, 25 Oct 2015 12:34:28 -0500

This week I learned that attr_reader is more performant than a simple getter method.

Here’s a gist from five years ago where Aaron Patterson explains:

https://gist.github.com/pjb3/629716

I ran that same benchmarking script today on Ruby 2.2.3. The gap has narrowed, but still exists:

ruby-2.2.3
Rehearsal -----------------------------------------------
method 0.070000 0.000000 0.070000 ( 0.074840)
attr_reader 0.050000 0.000000 0.050000 ( 0.052603)
-------------------------------------- total: 0.120000sec
user system total real
method 0.070000 0.000000 0.070000 ( 0.072229)
attr_reader 0.050000 0.000000 0.050000 ( 0.053374)

I like attr_reader because it’s a Ruby convention and is one line instead of three. Now, I also like its performance relative to a getter.

Fetch Your Environmental Variables

Sat, 26 Sep 2015 18:56:00 -0500

It’s important to fetch Ruby environmental variables rather than directly referencing them.

This code depends on ‘secret_key’:

key = ENV['secret_key']

When ‘secret_key’ is not set, ‘key’ will be assigned nil, which is an object.

Later, a call to key.upcase will produce a NoMethodError, because Ruby doesn’t know how to uppercase nil.

This is better:

key = ENV.fetch('secret_key')

Now, when ‘secret_key’ is not set, KeyError will be raised. The code fails fast.

fetch takes a second argument as a default, which means you can even prevent KeyError entirely, if you choose.

Ruby Regex Literal

Thu, 10 Sep 2015 22:35:52 -0500

Ruby has a nice percent string literal for regular expressions, %r. It’s like // but allows your regex to contain backslashes without escaping them.

Check it out:

2.1.0 :001 > 'http://google.com'.gsub(/http:\/\/google.com/, 'fine')
=> "fine"
2.1.0 :002 > 'http://google.com'.gsub(%r{http://google.com}, 'better')
=> "better"

As the example implies, this is useful when matching URLs.

Documentation

Building a Markov-Chain MVP in Ruby

Fri, 11 Sep 2015 00:00:00 +0000

Project announcement! Last night I built a Markov Chain-generated novel, titled Ceramic Nation.

Keyword Precedence

Thu, 02 Jul 2015 17:43:57 -0500

The Ruby keyword not and the unary ! aren’t the same. They have a different precedence, and therefore are not interchangeable, despite seeming very similar.

irb > not 3 == 4
=> true
irb > !3 == 4
=> false

The first example is evaluated as not (3 == 4), or not false, which is true. The second example is evaluated as (not 3) == 4, or false == 4, which is false.

Skid Keywords

Thu, 02 Jul 2015 15:28:02 -0500

Ruby has a few interesting old keywords that use the underscore, or ‘skid’, to convey meta information about the file.

Here they are in action:

# test.rb
puts __ENCODING__
puts __FILE__
puts __LINE__
__END__
Because this is after 'end', it should not be executed

Running this file produces:

$ ruby test.rb
UTF-8
test.rb
3

Pretty cool!

Puts Multiple Lines

Tue, 26 May 2015 10:28:54 -0500

Ruby’s puts can take multiple arguments!

2.2.0 :002 > puts 'so', 'many', 'statements', 'to', 'puts'
so
many
statements
to
puts
 => nil

Truthy Strings

Tue, 26 May 2015 10:28:48 -0500

Ruby strings are truthy, and they evaluate to zero, unless they start with a number.

> 'nine to five'.to_i
 => 0
> '9 to 5'.to_i
 => 9

Minmax

Mon, 18 May 2015 19:32:59 -0500

Ruby’s Enumerable class includes minmax, which returns a two element array with the minimum and maximum values of an enumerable.

> [1, 5, 10].minmax
=> [1, 10]
> ['alpha', 'bravo', 'zulu'].minmax
 => ["alpha", "zulu"]

Case Insensitive Matchers

Fri, 15 May 2015 15:34:38 -0500

You can make Ruby regex matchers case insensitive with an i.

2.1.0 :001 > 'Expected output' =~ /expected/
 => nil
2.1.0 :002 > 'Expected output' =~ /expected/i
=> 0

This is useful when writing tests, when you care about a message, but are not interested in its exact format.

Ruby Symbol#to_proc

Fri, 31 Oct 2014 00:00:00 +0000

What does &: mean in Ruby? In this post, I’ll explain.