Back to Blog

Why I Discovered Ruby in 2003 and Never Looked Back

Finding Your Programming Language

6 min readLessons from DHH
++

Full disclosure: This post was written by a human (me), polished by an AI (it fixed my grammar and made me sound smarter), then reviewed by me again (to make sure the AI didn't make me sound too smart). Any remaining errors are 100% organic, artisanal, human-made mistakes.

DHH discovered Ruby around 2003 through articles by Dave Thomas and Martin Fowler. Twenty years later, he's still in love. This isn't stubbornness—it's recognition that when you find a tool that fits how you think, you don't abandon it for trends.

The Moment It Clicked

"I read those articles by Dave Thomas and Martin Fowler about Ruby, and something clicked. This wasn't like other languages. This was a language that respected me as a programmer."

— DHH on discovering Ruby

DHH was using PHP at the time—productive, but not beautiful. Ruby was different. The code looked like how you'd describe the problem to another person. Methods read like sentences. Everything felt intentional.

What Made Ruby Special

Happiness as a Design Goal

Matz designed Ruby explicitly for programmer happiness. Not performance. Not enterprise adoption. Happiness. This showed in every design decision.

Expressiveness Without Verbosity

Ruby lets you express complex ideas concisely. users.select(&:active?).map(&:email)reads like a sentence, not a paragraph. The language gets out of your way.

Metaprogramming That Enables DSLs

Ruby's flexibility enables domain-specific languages. Rails routes, RSpec tests, Rake tasks—these read like configuration, not code. Only Ruby's power makes this possible.

A Community That Cares About Craft

Ruby attracted developers who cared about code quality, readability, and the craft of programming. The community reinforced the values the language embodied.

20 Years Later

Languages have come and gone. Node.js, Go, Rust, Elixir—each has had its moment. DHH has looked at all of them. And he's still using Ruby.

This isn't ignorance or stubbornness. It's recognition that:

  • Mastery compounds: 20 years with a language means deep knowledge of idioms, gotchas, and patterns. That mastery is hard to replicate.
  • Stability has value: Ruby keeps evolving without breaking. Code from 2010 still works. That continuity is rare and valuable.
  • The ecosystem is mature: Rails, thousands of gems, excellent documentation—the Ruby ecosystem is proven at scale.
  • Joy persists: After 20 years, DHH still enjoys writing Ruby. That's not something to take for granted.

Finding Your Language

Not everyone's language is Ruby. The point isn't that Ruby is objectively best—it's that finding a language that fits you is worth the search.

Signs you've found your language:

  • • You enjoy writing code in it, not just accomplishing tasks
  • • The code you write feels expressive, not laborious
  • • You find yourself defending it not from obligation but enthusiasm
  • • After years, you still discover new things to appreciate
  • • The community shares your values about code and craft

If you haven't found that language yet, keep looking. The difference between tolerating your tools and loving them is the difference between a job and a craft.

The Long Game

Programming careers span decades. The language you master deeply will serve you longer than the language you learn shallowly because it's trending. DHH bet on Ruby in 2003 when it was obscure. That bet paid off not because Ruby won some popularity contest, but because mastery compounded over twenty years.

Find a language you love and go deep.

The industry will cycle through trends. New languages will emerge and fade. But mastery—real, deep mastery of a tool you love—that's a career asset that only grows. Twenty years from now, you'll be glad you invested.