Introduction

This talk, delivered by Matheus Richard at RailsConf 2025, explores the internal workings of the Ruby programming language, specifically aimed at Rails developers. Without requiring C experience, it demystifies how Ruby interprets, parses, and executes code, highlighting how these processes impact Rails applications.

Key Points

• Origins and Necessity

  • Ruby, created in the mid-1990s, is the foundation of Rails. Understanding Ruby’s internals helps Rails developers write better, more efficient code.

• How Ruby Reads Code

  • The process mirrors how humans understand text: tokenization (lexing), parsing (structuring relationships), and finally evaluation for meaning. Similar stages exist in Ruby’s code processing pipeline.

• Building an Interpreter (Step-by-Step)

  • Demonstration of constructing a simplified interpreter with:
  • Tokenization: Breaking input into tokens using regex.
  • Parsing: Constructing an Abstract Syntax Tree (AST) by analyzing tokens.
  • Interpretation: Traversing the AST to produce a result by evaluating nodes recursively.
  • Example walkthroughs illustrate tokenizing and parsing numeric expressions, constructing ASTs, and interpreting them for results like a simple calculator.

• From Tree-Walking to Virtual Machine

  • Until Ruby 1.8, the interpreter directly traversed the AST, making evaluation easy but slow due to non-sequential data structures affecting CPU cache efficiency.
  • Ruby 1.9 introduced compilation to bytecode, interpreted by a stack-based Virtual Machine (VM), improving performance 2-4 times.
  • Compilation flattens trees into sequential instruction arrays, which the VM executes more efficiently using a stack.

• Real-World Examples and Insights

  • Examples from the Ruby source highlight similarities between the simple interpreted model and Ruby’s real RB_eval C function, demonstrating how constructs (like logical operators) handle control flow.
  • Fast-path optimizations: Ruby creates specialized bytecode instructions for common operations (e.g., adding constants like 0 and 1) to further accelerate execution.

• The Importance of Parsers in the Ecosystem

  • Rails, Rubocop, editors, and other tools each use different Ruby parsers, leading to fragmentation and lag in adopting new Ruby features.
  • The Prism project aims to unify Ruby parsing, providing a single parser (now default in Ruby 3.4 and used by multiple implementations and tools) for consistency across the ecosystem.

• Impact of Ruby’s Evolving Internals

  • Ruby’s constant evolution, with multiple JIT compilers now available, can outperform C extensions for certain workloads (evidenced by Shopify’s benchmarks and young rewritten Ruby methods beating older C code).
  • The migration toward more Ruby-written internals makes contribution easier and code more maintainable.

Conclusion

• Understanding Ruby’s internals—tokenization, parsing, bytecode compilation, and VMs—not only illuminates Rails’ capabilities but helps developers write more efficient, maintainable applications.
• Ecosystem initiatives like Prism and advances in JITs indicate a future with faster, more unified Ruby tools.
• Developers are encouraged to explore beyond frameworks and gems, deepening their language knowledge for performance debugging and optimal code choices.

References and Further Learning

• Cited the book "Crafting Interpreters" as a practical resource.
• All the demo code is shared via a public GitHub repository.