JoelQ

The History of Rails in 10 Blog Posts

Here are the notes for my RailsConf 2025 talk The History of Rails in 10 Blog Posts (video, slides)

Calling nostalgic veterans and newbies alike! We’re traveling through time on a tour of some of the most influential blog posts to hit the Rails community over the past two decades. With stops at iconic locations including in testing, service objects, and JavaScript, you won't want to miss it! Bring your chrono-passport and see you in 2003!

List of Articles

1. FatModel, Skinny Controller - Foundational, refined what MVC means in the context of Rails
2. Waiting for a Factory Girl - Changed the way the Rails community writes tests to this day

JoelQ

fib = Hash.new do |hash, n|
  puts "calculating fib #{n}"
  
  # base case
  if n == 0 || n == 1
    hash[n] = 1
  else
    # recursive case
    hash[n] = hash[n - 1] + hash[n - 2]
  end

JoelQ

# This imagines `.unfold` to be an alternate constructor for `Enumerator` that's
# more complex than `.produce` but not as custom as the full `.new`. It follows the rules
# of anamorphisms (at least for arrays, not sure if this genericises to other structures)
class CustomEnumerator
  def self.unfold(seed, &block)
    Enumerator.new do |yielder|
      loop do
        seed, value = block.call(seed)
        raise StopIteration if value.nil?

JoelQ

class Tally
  def self.empty
    new({})
  end

  def initialize(raw)
    @raw = empty_hash.merge raw.slice(:small, :medium, :large)
  end

  # Accessors

JoelQ

How not to implement a multi-step form

"That ticket touches the wizard code? Why don't YOU take that one". The wizard in question is so gnarly my colleagues are afraid to touch it.

Looking at the code through the lens of conditional cardinality reveals what went wrong and how we can make things better. This mental model will change the way you think about structuring logic and help you take your conditional code from scary to delightful.

Description

This talk is aimed at an intermediate to advanced audience. While it will driven by a practical example (refactoring a multi-step form), it will mainly be about some more theoretical principles and mental models for structuring conditional code.

JoelQ

The Math Every Programmer Needs

Abstract

Leave your fear of math behind along with the equations and symbols, we're headed to Ruby-land! On this whirlwind tour, we’ll explore how to write better conditionals with Boolean algebra, figure out how many test cases we need with combinatorics, a mental model for breaking down large tasks with graph theory, and more.

You’ll leave this talk equipped to better do your job with some ideas, techniques, and mental models from the wonderfully practical world of discrete math.

Details

JoelQ

class Tree
  attr_reader :val, :left, :right

  def self.empty
    EmptyTree.new
  end

  def self.leaf(val)
    new(val, empty, empty)
  end

JoelQ

class Dollar
  attr_reader :cents

  def initialize(cents:)
    @cents = cents
  end

  def hash
    [self.class, cents].hash
  end

JoelQ

require "date"

class Month
  include Comparable

  MONTHS_PER_YEAR = 12

  def self.from_date(date)
    self.from_parts(date.year, date.month)
  end

JoelQ

class Tree
  attr_reader :value, :left, :right

  def initialize(value, left, right)
    @value = value
    @left = left
    @right = right
  end

  def reduce(initial, &block)