Ruby — Topic Index

Below is an index of articles grouped by topic. Click a heading to jump to the section.

Programming

• ActiveRecord::Relation vs ActiveRecord Objects in Rails
  • Understand the difference between ActiveRecord::Relation and model objects in Rails — lazy loading, query chaining, and when to use find vs where.
• alias and alias_method in Ruby: Complete Guide
  • A comprehensive guide to using alias and alias_method in Ruby for method aliasing, metaprogramming, code reuse, and Rails patterns.
• AOP Programming in Ruby
  • Understanding Aspect-Oriented Programming (AOP) in Ruby - patterns, implementation, and use cases for separating cross-cutting concerns.
• Autoload in Rails: Complete Guide to Constant Autoloading
  • Understanding autoload in Rails - how Rails automatically loads constants and modules based on directory structure and naming conventions. Covers classic autoloader and Zeitwerk.
• Avoiding Duplicate HTML IDs in Rails Forms
  • How to avoid duplicate HTML element IDs in Rails when rendering multiple forms on the same page — using the namespace option and modern form helpers.
• Debugging Capistrano Deploy Failures: Lessons in Dependency Management
  • A real-world debugging story: fixing a Capistrano deploy failure caused by a gem major version bump, with lessons on dependency management and semantic versioning.
• define_attribute_methods in Rails: Complete Guide to Dynamic Attribute Methods
  • A comprehensive guide to define_attribute_methods in Rails - generating attribute accessors, mutators, and query methods dynamically for ActiveRecord models.
• How to Create a Gem For JavaScript and CSS Libraries
  • How to Create a Gem For JavaScript and CSS Libraries
• Object-Oriented Programming in Ruby: Objects, Classes, and the Object Model
  • A deep dive into Ruby’s object model — how objects, classes, modules, and the method lookup chain work, with comparisons to Python and Go.
• 在有多个模型关联操作的情况下，使用Callbacks保证数据的一致性
  • 在有多个模型关联操作的情况下，使用Callbacks保证数据的一致性

Ruby

• alias and alias_method in Ruby
  • Learn how to use alias and alias_method in Ruby — renaming methods, wrapping behavior, and the key differences between the two.
• attr_accessor, attr_reader, and attr_writer in Ruby
  • A complete guide to Ruby’s attribute accessors — attr_accessor, attr_reader, and attr_writer — with examples, custom implementations, and best practices.
• attr_checked函数在《ruby元编程》中的实现
  • attr_checked函数在《ruby元编程》中的实现
• Class Instance Variables in Ruby: Inheritance, Accessors, and Rails class_attribute
  • A deep dive into Ruby class instance variables — how they differ from class variables, how inheritance works, and how Rails class_attribute builds on them.
• Class Methods and Singleton Methods in Ruby
  • A complete guide to Ruby class methods — the three ways to define them, singleton methods, inheritance, and practical patterns.
• class variable and class instance variable and class_attribute in Ruby
  • class variable and class instance variable and class_attribute in Ruby
• Class Variables in Ruby: @@var Explained
  • A complete guide to Ruby class variables (@@var) — how they work, how they behave with inheritance, thread safety concerns, and why class instance variables are usually preferred.
• Class Variables vs Class Instance Variables in Ruby
  • Understand the difference between class variables (@@var) and class instance variables (@var) in Ruby — how they behave with inheritance and when to use each.
• class_eval and instance_eval in Ruby
  • class_eval和instance_eval的用法总结
• Constants and Namespaces in Ruby
  • A complete guide to Ruby constants — how constant lookup works, namespacing, the :: operator, and common pitfalls with nested classes.
• Content Class Methods
  • Content Class Methods
• Dynamic Dispatch in Ruby: send, public_send, and Method Objects
  • A complete guide to Ruby’s dynamic dispatch — using send, public_send, and method objects to call methods dynamically, bypass visibility, and build flexible APIs.
• Dynamic Languages and Runtime Errors: Ruby’s Late Binding Risks
  • Understand the risks of Ruby’s dynamic nature — methods that fail only at runtime, how to mitigate them with tests and static analysis, and what this means for production code.
• Equality and Comparison in Ruby: ==, eql?, equal?, <=>, and ===
  • A complete guide to Ruby’s equality and comparison operators — ==, eql?, equal?, <=>, and === — what each means and when to use each.
• Essential Ruby Articles and Learning Resources
  • A curated collection of essential Ruby articles covering modules, metaprogramming, equality operators, and the Ruby object model.
• Hash vs Struct in Ruby: When to Use Each
  • A complete guide to Ruby’s Hash and Struct — their differences, use cases, and when Struct is the better choice for structured data.
• Implementing a blank? Helper in Ruby
  • Learn how to implement and use a blank? helper in Ruby — handling nil, empty strings, whitespace, and falsy values cleanly.
• include vs extend in Ruby: Adding Methods to Classes and Objects
  • A complete guide to Ruby’s include and extend — how they differ, when to use each, and the classic pattern for adding both instance and class methods via a module.
• include vs extend in Ruby: Clear Rules, Real Patterns
  • Understand exactly how include and extend work in Ruby, with method lookup rules, common mistakes, and production patterns.
• Instance Methods in Ruby: Definition, Binding, and Singleton Methods
  • A complete guide to Ruby instance methods — the three ways to define them, singleton methods, unbound methods, and dynamic method definition.
• instance_eval, instance_exec, class_eval, and module_eval in Ruby
  • A complete guide to Ruby’s context-switching methods — instance_eval, instance_exec, class_eval, and module_exec — with practical use cases and security considerations.
• Interface Inheritance vs Implementation Inheritance in Ruby and Go
  • Understand the difference between interface inheritance and implementation inheritance, with practical examples in Ruby and Go.
• Loops and Iteration in Ruby: A Complete Guide
  • A complete guide to loops and iteration in Ruby — times, upto, each, while, until, loop, map, select, and when to use each.
• method_missing in Ruby: Ghost Methods and Dynamic Dispatch
  • A complete guide to Ruby’s method_missing — how it works, practical use cases, and how to implement it safely with respond_to_missing?.
• public, private, and protected Methods in Ruby
  • A complete guide to Ruby’s method visibility: public, private, and protected — what they mean, how they work, and when to use each.
• Rails mattr_accessor详解
  • Rails mattr_accessor详解
• Ruby Args 参数处理：位置参数、关键字参数与可变参数
  • 系统讲解 Ruby 参数机制：位置参数、默认值、可变参数、关键字参数、转发参数和常见坑位。
• Ruby Class Extension Pattern: Adding Class Methods via Modules
  • Learn the Ruby class extension pattern — using self.included and extend(ClassMethods) to add both instance and class methods when a module is included.
• Ruby class_attribute详解
  • Ruby class_attribute详解
• Ruby prepend vs include: Module Composition Guide
  • Learn how Ruby’s prepend works, how it differs from include, and when to use each for module composition and method wrapping.
• Ruby: Strengths, Weaknesses, and When to Use It
  • An honest assessment of Ruby as a programming language — its strengths in expressiveness and developer happiness, its performance trade-offs, and where it fits in 2026.
• Sessions in Rails: How They Work and Best Practices
  • A complete guide to sessions in Rails — how they work, storage options, security considerations, and best practices for authentication.
• Shopping Cart Goods Count Update in Rails(class variable)
  • Shopping Cart Goods Count Update in Rails(class variable)
• Singleton Methods and the Singleton Class in Ruby
  • A complete guide to Ruby’s singleton methods and singleton class — what they are, how they work, and how they underpin class methods and Ruby’s object model.
• Thinking About ActiveRecord::Concern
  • Thinking About ActiveRecord::Concern
• Understanding class_eval, module_eval and instance_eval
  • Understanding class_eval, module_eval and instance_eval
• Understanding self in Ruby
  • A complete guide to understanding self in Ruby — what it refers to in different contexts, how it works in classes, modules, and singleton methods.
• Using Class Variables for Counters and Shared State in Ruby
  • Practical patterns for using Ruby class variables as counters — with thread safety, inheritance considerations, and better alternatives.

If you find missing articles or inaccurate groupings, run ./scripts/update_index.py with appropriate flags.