What's inside

Skim it tonight, dive deeper Friday morning, keep it open in a browser tab between talks. The Time Machine and Cheat Sheet are the highest-leverage sections — read those even if you read nothing else.

1. 01Time Machinewhat changed since 2008
2. 02Modern Syntax Cheat Sheetold vs new, side by side
3. 03Pattern Matching Deep-Divethe biggest leap since blocks
4. 04Concurrency Modelsthreads vs fibers vs ractors
5. 05YJIT and the Performance EraRuby is fast now
6. 06The Library Galaxycanon · niche · curiosities
7. 07The Modern Rails StackHotwire, Solid, Kamal
8. 08Phlex, ViewComponent, ERBthe view-layer wars
9. 09Open Source to Readcode worth studying
10. 10People to Followyour new feed
11. 11Conference Survival Kithallway tactics
12. 12Two-Evening Study Plantonight + Friday morning
13. 13Glossaryevery word they'll drop
14. 14Quick Reference Cardtear-out cheat sheet

01Time Machine

You started in the Ruby 1.8 / Rails 2 era. The world is now Ruby 3.4 and Rails 8. Here's the highlight reel of what landed while you were doing other things.

The five shifts that matter most

1. Hash syntax flipped. { :name => "Steve" } is now { name: "Steve" }. The rocket is legacy code smell, not your default.
2. Keyword arguments became real. Method signatures look totally different — def greet(name:, greeting: "hi") with required kwargs is the modern norm.
3. Pattern matching landed (3.0). case/in destructures hashes and arrays with type and shape constraints. It's the biggest language addition since blocks.
4. YJIT made Ruby fast. Free 15–40% speedup on real Rails apps with one flag. Shopify runs it at planet scale.
5. Concurrency story matured. Threads still exist. Fibers + Async became viable for I/O. Ractors exist for true parallelism (still rough).

02Modern Syntax Cheat Sheet

Old vs new, side by side. If you can read every block on these pages without flinching, you're 80% of the way to "looks fluent in a code review."

Hash literals

# Then
user = { :name => "Steve", :role => :admin }

# Now (2.0+)
user = { name: "Steve", role: :admin }

# Now-now (3.1+) — shorthand pulls from local var
name = "Steve"
role = :admin
user = { name:, role: }

Method arguments

# Then — positional with options hash
def greet(name, opts = {})
  greeting = opts[:greeting] || "hi"
  "#{greeting}, #{name}"
end

# Now — required and optional keyword args
def greet(name:, greeting: "hi")
  "#{greeting}, #{name}"
end

# Anonymous forwarding (3.0+ for blocks, 3.2+ for everything)
def log(...)
  puts caller.first
  inner(...)
end

Safe navigation and one-liners

user&.address&.city            # nil if any link is nil

JSON.parse(str) rescue {}        # one-line rescue

def square(x) = x * x            # endless method (3.0+)

return :ok if all_good?          # trailing conditional, still cool

Block parameter shorthand

%w[hi there].map(&:upcase)       # symbol-to-proc, ages old

[1,2,3].map { _1 * 2 }           # numbered (2.7+)
[1,2,3].map { it * 2 }           # named (3.4+) — preferred now

Value objects without the boilerplate

# Then — Struct, mutable by default
Money = Struct.new(:amount, :currency) do
  def +(other) = Money.new(amount + other.amount, currency)
end

# Now — Data is immutable, kwarg-constructed
Money = Data.define(:amount, :currency) do
  def +(other) = with(amount: amount + other.amount)
end

m = Money.new(amount: 10, currency: "USD")
m.amount        # 10
m.amount = 20   # NoMethodError — Data is frozen
m2 = m.with(amount: 99)  # creates a new one

Pattern matching, the headline feature

case api_response
in { status: 200, body: { items: [first, *rest] } }
  process(first, rest)
in { status: (400..499) => code, body: { error: String => msg } }
  raise ClientError.new(code, msg)
in { status: 500.. }
  retry_later
end

# Rightward assignment — pull a value out of a hash
{ name: "Steve", role: :admin } => { name:, role: }
puts name   # "Steve"

# In-line check — returns true/false
{ a: 1, b: 2 } in { a: Integer }   # => true

Iteration helpers you should know

"hello world".chars.tally
# => {"h"=>1, "e"=>1, "l"=>3, "o"=>2, " "=>1, "w"=>1, "r"=>1, "d"=>1}

[1, 2, 3, 4].sum { |n| n * n }      # 30

%w[a b c d].each_cons(2).to_a       # => [["a","b"], ["b","c"], ["c","d"]]
%w[a b c d].each_slice(2).to_a      # => [["a","b"], ["c","d"]]

# Lazy for huge or infinite sequences
(1..Float::INFINITY).lazy
  .map  { it ** 2 }
  .select { it.even? }
  .first(5)
# => [4, 16, 36, 64, 100]

# Hash with default block — the "group by" pattern
groups = Hash.new { |h, k| h[k] = [] }
words.each { groups[it.length] << it }

Tap and then for fluent chains

User.new(params)
  .tap(&:save)                       # side effect, returns self
  .then { Mailer.welcome(it) }       # transform, returns new value
  .deliver_later

03Pattern Matching, Deep

The single feature most likely to confuse you mid-talk. Worth 20 minutes of focused study because once it clicks, it changes how you write Ruby.

The shape of it

Three forms exist. Memorize them all.

# 1. case/in — full branching
case value
in Integer => n if n > 0
  "positive int #{n}"
in [String, *]
  "array starting with a string"
in { status: 200 }
  "ok"
else
  "no match"
end

# 2. Rightward assignment — assert and destructure (raises NoMatchingPatternError)
{ name: "Steve", age: 47 } => { name:, age: }

# 3. Boolean test — returns true/false
{ status: 200 } in { status: Integer }   # => true

Patterns you can match

Custom deconstruction

Any object can opt into pattern matching by defining deconstruct (for arrays) or deconstruct_keys (for hashes).

class Point
  attr_reader :x, :y
  def initialize(x, y) = (@x, @y = x, y)
  def deconstruct       = [x, y]
  def deconstruct_keys(keys) = { x:, y: }
end

p = Point.new(3, 4)

case p
in [0, 0]            then "origin"
in { x: 0 }          then "on y-axis"
in { x:, y: } if x == y then "diagonal"
in [Integer, Integer] then "anywhere else"
end

04Concurrency Models

Ruby has three primitives for doing more than one thing at once. They're not interchangeable. Knowing which to reach for is a marker of fluency.

The pragmatic guidance

For 99% of Rails code, you'll never write a thread, fiber, or ractor by hand — Puma uses threads, Falcon uses fibers, Sidekiq has a worker pool. You just need to know which model your tools use, so you don't fight them.

# Async — the modern way to do concurrent I/O
require 'async'
require 'async/http/internet'

Async do
  internet = Async::HTTP::Internet.new
  urls = %w[https://a.com https://b.com https://c.com]

  results = urls.map do |url|
    Async { internet.get(url).read }   # fires off concurrently
  end.map(&:wait)
end

05YJIT & The Performance Era

If a 2014-era Rubyist time-traveled to today, the most shocking thing wouldn't be the syntax — it'd be how fast Ruby got.

What YJIT is

YJIT (Yet-another-just-in-time-compiler) is a JIT compiler written in Rust, built into Ruby itself since 3.1. It watches your code as it runs and compiles hot paths to native machine code. It was developed at Shopify and runs in production on every Shopify storefront.

Turning it on

# CLI flag
ruby --yjit script.rb

# Env var
RUBY_YJIT_ENABLE=1 bundle exec rails server

# In code
RubyVM::YJIT.enable

# In Rails (config/environments/production.rb)
config.yjit = true   # default in Rails 7.2+

Other speed wins worth knowing

Frozen string literals

# frozen_string_literal: true   # magic comment, top of file

# Every string literal is frozen — no allocation on repeat use
def status_label = "active"   # one String object, forever

Bootsnap

Shopify gem (bundled with Rails) that caches compiled code, autoload paths, and YAML. Cuts Rails boot time by 50%+ on cold starts.

Fast JSON, fast everything

oj (Optimized JSON) is 4–8× faster than stdlib JSON. brotli for compression. nokogiri for XML/HTML. The Ankane gems are reliably fast.

06The Library Galaxy

A field map of gems by orbit: the inner planets you'll see in every app, the outer-belt specialists, and the comets — weird and wonderful.

The canon — every Rails dev knows these

The "modern Rails" power-ups

The dry-rb & functional Ruby orbit

A whole parallel ecosystem favoring small, composable objects over Rails-y conventions. Common at Stripe, Shopify, and shops that came out of the Trailblazer school.

Specialists, niche gems, and curiosities

07The Modern Rails Stack

Rails 8 is opinionated about the whole stack now — front to back, deploy included. Here's what a "fresh rails new" gives you in 2026.

Hotwire decoded

The Solid trio

Rails 8 ships Solid Queue, Solid Cache, and Solid Cable — Postgres-or-SQLite-backed implementations of background jobs, caching, and websockets. The narrative: you don't need Redis to run a Rails app anymore. (You can still use Redis. Many do.)

08Phlex, ViewComponent, ERB

The view layer is where Ruby has the most active aesthetic debate right now. You'll hear all three names. Here's what each one looks like.

ERB — the classic

<!-- app/views/users/show.html.erb -->
<h1><%= @user.name %></h1>
<ul>
  <% @user.posts.each do |post| %>
    <li><%= link_to post.title, post %></li>
  <% end %>
</ul>

ViewComponent — server-rendered components

# app/components/user_card_component.rb
class UserCardComponent < ViewComponent::Base
  def initialize(user:)
    @user = user
  end

  def admin? = @user.role == :admin
end

# app/components/user_card_component.html.erb
<div class="card <%= 'admin' if admin? %>">
  <h3><%= @user.name %></h3>
</div>

# Use it
<%= render UserCardComponent.new(user: @user) %>

Phlex — HTML in pure Ruby

class UserCard < Phlex::HTML
  def initialize(user:)
    @user = user
  end

  def view_template
    div(class: card_class) do
      h3 { @user.name }
      p { "Joined #{@user.created_at.to_date}" }
      a(href: user_path(@user)) { "View profile →" }
    end
  end

  private

  def card_class
    @user.admin? ? "card admin" : "card"
  end
end

# In a controller / view
render UserCard.new(user: @user)

Choosing between them

09Open Source to Read

Reading great Ruby is the fastest way to absorb modern style. Here's a curated tour, ordered easiest-to-hardest.

Read for code quality & idioms

Read to see real apps

10People to Follow

The Ruby community is small, friendly, and remarkably accessible. These are the names you'll hear referenced in talks and hallway chats.

Core & legends

Library authors worth following

Newsletters & podcasts

• Ruby Weekly — Peter Cooper. The canonical Ruby newsletter. Subscribe.
• Short Ruby News — Lucian Ghinda. Excellent and visual.
• Remote Ruby — Chris Oliver, Jason Charnes, Andrew Mason. Friendly weekly podcast.
• The Bike Shed — thoughtbot. Long-running, deep on practice.
• Ruby on Rails Podcast — currently hosted by Brittany Martin.

11Conference Survival Kit

Ruby people are some of the friendliest in tech. The community has a strong "Matz is nice and so we are nice" (MINASWAN) ethos. Lean into it.

Hallway track tactics

• "I started in 1.8 and I'm rusty" is a great icebreaker. Old-timers will light up; younger devs will be curious about the journey.
• Ask "what does X buy you over Y?" — works for any tool comparison. Signals you're thinking, not lost.
• Find the conference Slack/Discord before day one. Most regional confs have one. Hallway track really starts there.
• Lunch is the best track. Don't sit alone. Sit with strangers. Ruby people are unusually open to "mind if I join you?"
• Remember names by the gem they wrote. "Oh you're the Pagy person!" makes someone's day.

Conversation starters that work

If a talk goes over your head

1. Don't panic. Half the room is faking it too.
2. Write down the vocabulary, not the content. Look it up after.
3. Find the speaker after — speakers love "I didn't fully follow X but it sounded important; can you point me at a starter resource?"
4. Check the talk's slides/repo on the conference website afterward — most Ruby speakers post code/slides publicly.

The vocabulary survival list

If someone uses one of these and you blank, here's the 6-second mental cache:

12Two-Evening Study Plan

Designed for tonight + Friday morning before the conf opens. ~2 hours total. Don't aim for fluency — aim for recognition.

Tonight (~90 min)

1. Read sections 01–03 of this guide (Time Machine, Cheat Sheet, Pattern Matching). ~25 min
2. Open irb and type every code block from Section 02. Don't paste — type. Muscle memory beats reading. ~30 min
3. Solve one pattern-matching exercise. Open a scratch file:

   # Given an API response shape like:
   #   { status: 200|400|500, body: { ... } | { error: "..." } }
   # write a method that returns:
   #   :ok | :client_error | :server_error
   # using ONE case/in statement.

   ~15 min
4. Skim sections 06–08 (libraries, Rails stack, view layer wars). Don't memorize — just absorb the shape. ~20 min

Friday morning (~30 min)

1. Re-skim Section 11 (Conference Survival Kit) on the way to the venue. ~10 min
2. Read one Hotwire example — the Turbo handbook intro on hotwired.dev. ~10 min
3. Pick the talk that scares you most from the schedule. Read its abstract carefully and Google any unfamiliar word. ~10 min

During the conf

• Keep this guide open in a browser tab — Section 13 (Glossary) is your panic button.
• Note unfamiliar terms during talks; look them up at lunch.
• One real conversation > ten passive talks. Prioritize the hallway.

13Glossary

Every term you might hear, with a one-sentence definition. Bookmark this page; refer often.

14Quick Reference Card

The minimum-viable cheat sheet. Print this page if nothing else; it covers ~90% of what you'll see in a modern Rails codebase.

{ name: "x", role: :admin }
{ name:, role: }              # 3.1+
def f(name:, age: 18); end
def f(...); inner(...); end

arr.map(&:upcase)
arr.map { it * 2 }            # 3.4+
arr.map { _1 * 2 }            # 2.7+
arr.each_with_object({}) { |x, h| h[x] = x.size }

user&.address&.city
JSON.parse(s) rescue {}
def square(x) = x * x

case x
in Integer => n if n > 0
in [a, *rest]
in { status: 200, body: }
end

x in { ok: true }              # boolean
{a:1} => { a: }                # destructure

Money = Data.define(:amt, :cur)
m = Money.new(amt: 5, cur: "USD")
m.with(amt: 10)               # new copy

arr.tally
arr.sum { it * 2 }
arr.each_cons(2)
arr.each_slice(3)
arr.partition(&:even?)
hash.transform_values { it * 2 }
hash.filter_map { |k, v| k if v > 0 }

(1..).lazy.select(&:prime?).first(10)

obj.tap(&:save)            # side effect
   .then { wrap(it) }      # transform

rails new app --css=tailwind \
              --javascript=importmap \
              --database=sqlite3
bundle exec rails db:migrate
RUBY_YJIT_ENABLE=1 bundle exec puma