Topics A–Z

Level: reference · for anyone looking for a page by the name they know it by

Every lesson, listed under its title, its folder name and the words a reader might search for. The arrow reads this name → the page that covers it; the dash gives the page's claim. Generated from the lessons' own titles and one-line claims — see the crosswalk for the same pages arranged by idea beside their Python spellings.

• #{} calls to_s; format is printf — "#{expr}" evaluates any expression and calls to_s on the result
• &. skips the call when the receiver is nil — receiver&.method(args) returns nil without calling anything
• &:sym calls Symbol#to_proc — &x in an argument list calls x.to_proc and attaches the result as the block; a symbol's to_proc is a lambda…
• 0.1 + 0.2 != 0.3, and 2.5.round is 3 — A Ruby Float is the same 64-bit double as a Python float
• 1 + 1.5 works because Integer asks Float to coerce — When Integer#+ meets an operand it does not know, it calls that object's coerce and adds the pair it gets back
• 1 == 1.0 is true, but {1 => :a}[1.0] is nil — Ruby's == compares an Integer with a Float by value
• 1/3r and BigDecimal("0.1") are exact where Float is not — Ruby ships two exact number types beside Float
• 503 → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• 504 → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• 7 / 2 is 3: integer division floors — Ruby's / on two Integers is Python's //

A

• A backtrace is data you can read — caller returns an Array of Strings shaped file:line:in 'Klass#method', caller_locations returns the same…
• A bare rescue catches StandardError, not everything — rescue with no class list means rescue StandardError, and SystemExit, Interrupt, NoMemoryError,…
• A Binding is a scope you can carry around — binding packages a method's local variables, its self and its name into an object that eval, ERB#result and…
• A DSL is instance_eval plus stored blocks — A Ruby DSL is ordinary method calls made readable by three tricks
• A Fiber is a coroutine you resume by hand — Fiber.new { } makes a block that runs only when you resume it and stops wherever it calls Fiber.yield; values…
• A Hash key needs eql? and hash, not == — A Hash finds a key by calling hash and then eql?
• A method is a value once you ask for it — obj.method(:name) hands back a Method bound to obj, and Klass.instance_method(:name) an UnboundMethod you…
• A Minitest test is a plain class — Minitest, a bundled gem, runs every test_* method of a Minitest::Test subclass in a seeded random order and…
• A missing key is nil, and Hash.new([]) shares its default — h[:zz] is nil where d["zz"] raises KeyError; fetch is the raising form; Hash.new(0) returns a default…
• A module is a namespace, and cannot be instantiated — module Shop is a named box for classes, constants and methods
• A pin compares; a bare name binds — Inside a pattern a bare name always binds
• A setter returns its argument, not its body — obj.x = 5 is a call to the method x=, but as an expression it evaluates to 5 whatever the method body returns
• a sized queue that refuses → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• A string key and a symbol key are two keys — {"a" => 1}[:a] is nil because "a" and :a are different objects of different classes, JSON.parse always…
• A symbol is a name, not a string — A Ruby symbol is an immutable name of which exactly one object exists per spelling
• A variable is a reference, not a box — Assignment copies a reference, never the object, so after b = a a mutating method such as << on b is seen…
• added → Hooks fire when code is defined, not when it runs — inherited, included, extended, prepended, method_added, singleton_method_added and const_added are…
• allocate → new is allocate then initialize — Point.new(1, 2) is a class method that does two things
• alternatives → A pin compares; a bare name binds — Inside a pattern a bare name always binds
• An Enumerator has a cursor: next, peek, rewind — Any each called without a block returns an Enumerator; next pulls one value from it, peek looks at the next…
• An iterator is a method that yields — A class earns the whole Enumerable toolbox by writing one each that yields and including the module; `return…
• An object can list its methods and variables — methods, instance_methods(false), instance_variables, instance_method(:x).parameters, source_location,…
• and or precedence → and/or bind lower than = — Ruby has two pairs of boolean operators
• and/or bind lower than = — Ruby has two pairs of boolean operators
• argf → gets returns nil at EOF, and reads ARGV's files first — gets returns the next line with its newline and nil at end of input
• argument → A setter returns its argument, not its body — obj.x = 5 is a call to the method x=, but as an expression it evaluates to 5 whatever the method body returns
• arguments → Arguments: positional, keyword, splat and block — A Ruby parameter list has eight kinds of slot
• arguments → Default arguments are evaluated on every call — A Ruby default is an expression that runs each time the method is called without that argument, so def f(a = [])…
• arguments positional keyword and splat → Arguments: positional, keyword, splat and block — A Ruby parameter list has eight kinds of slot
• Arguments: positional, keyword, splat and block — A Ruby parameter list has eight kinds of slot
• argv → ARGV holds strings and ENV is not a Hash — ARGV is an Array of Strings, $0 is the script name as it was invoked, ENV is a Hash-like object whose values…
• argv env and exit status → ARGV holds strings and ENV is not a Hash — ARGV is an Array of Strings, $0 is the script name as it was invoked, ENV is a Hash-like object whose values…
• ARGV holds strings and ENV is not a Hash — ARGV is an Array of Strings, $0 is the script name as it was invoked, ENV is a Hash-like object whose values…
• arrays → Past the end, an array gives nil, not an error — a[10] on a four-element array is nil, a[5] = 99 pads the gap with nil, and a slice is a[1..2] (end…
• arrays and negative indexes → Past the end, an array gives nil, not an error — a[10] on a four-element array is nil, a[5] = 99 pads the gap with nil, and a slice is a[1..2] (end…
• assignment → Assignment destructures, and blocks auto-splat — a, b = 1, 2, a, *rest = list and (a, b), c = pair, 3 read like Python
• Assignment destructures, and blocks auto-splat — a, b = 1, 2, a, *rest = list and (a, b), c = pair, 3 read like Python

B

• backpressure → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• backtraces → A backtrace is data you can read — caller returns an Array of Strings shaped file:line:in 'Klass#method', caller_locations returns the same…
• backtraces and caller → A backtrace is data you can read — caller returns an Array of Strings shaped file:line:in 'Klass#method', caller_locations returns the same…
• bang → Bang means dangerous, question mark means predicate — A trailing ! marks the more dangerous of two versions of a method
• bang and question methods → Bang means dangerous, question mark means predicate — A trailing ! marks the more dangerous of two versions of a method
• Bang means dangerous, question mark means predicate — A trailing ! marks the more dangerous of two versions of a method
• basic → Object sits on Kernel on BasicObject — Object.ancestors is [Object, Kernel, BasicObject] and Object itself defines no public methods
• basic object and kernel → Object sits on Kernel on BasicObject — Object.ancestors is [Object, Kernel, BasicObject] and Object itself defines no public methods
• bigdecimal → 1/3r and BigDecimal("0.1") are exact where Float is not — Ruby ships two exact number types beside Float
• binding → A Binding is a scope you can carry around — binding packages a method's local variables, its self and its name into an object that eval, ERB#result and…
• binding and eval → A Binding is a scope you can carry around — binding packages a method's local variables, its self and its name into an object that eval, ERB#result and…
• block → File.open with a block closes the file for you — File.open(name, mode) { |f| … } closes the file when the block ends and evaluates to the block's value; Python's…
• blocks → Blocks are not objects — A block is syntax attached to one method call
• blocks → next, break and return leave a block differently — next v ends this run of the block with v as its value, break v ends the method the block was given to and…
• blocks are not objects → Blocks are not objects — A block is syntax attached to one method call
• break → next, break and return leave a block differently — next v ends this run of the block with v as its value, break v ends the method the block was given to and…
• building → A DSL is instance_eval plus stored blocks — A Ruby DSL is ordinary method calls made readable by three tricks
• building a dsl → A DSL is instance_eval plus stored blocks — A Ruby DSL is ordinary method calls made readable by three tricks
• bundler → Gems are versioned; Bundler pins them — A gem is a versioned package that RubyGems can activate by name (gem "x"), some ship inside Ruby (default gems),…
• bytecode → Ruby shows you its bytecode and its syntax tree — RubyVM::InstructionSequence.compile(src).disasm lists the YARV instructions the interpreter will execute and…

C

• call → Default arguments are evaluated on every call — A Ruby default is an expression that runs each time the method is called without that argument, so def f(a = [])…
• caller → A backtrace is data you can read — caller returns an Array of Strings shaped file:line:in 'Klass#method', caller_locations returns the same…
• capture → Closures capture variables, not values — A block, proc or lambda carries the variables around it
• case → case/in matches shape, not just value — case … in tests a value against a pattern
• case → case/when asks ===, and every class answers it its own way — case x when y calls y === x, and === is an ordinary method: a class answers with is_a?, a Range with…
• case in pattern matching → case/in matches shape, not just value — case … in tests a value against a pattern
• case when uses threequals → case/when asks ===, and every class answers it its own way — case x when y calls y === x, and === is an ordinary method: a class answers with is_a?, a Range with…
• case/in matches shape, not just value — case … in tests a value against a pattern
• case/when asks ===, and every class answers it its own way — case x when y calls y === x, and === is an ordinary method: a class answers with is_a?, a Range with…
• catch → throw and catch are not exceptions — catch(:tag) { … throw :tag, value … } is a labelled non-local jump: throw unwinds to the matching catch, which…
• cause → Exceptions have a cause — A raise that runs while a rescue clause is handling another exception records that exception as the new one's…
• chaining → tap returns the receiver, then returns the block's value — x.tap { … } yields x to the block and returns x whatever the block returned, so a debugging puts can sit…
• changed → What changed, 1.9 to 4.0 — Ruby's releases each added a few things you will meet in old code and new
• class → Class variables are shared with subclasses — @@count is one variable, owned by the class that first assigns it and seen by every subclass and every instance
• class → Set is a core class in 4.0 and keeps insertion order — In Ruby 4.0 Set needs no require and is written in C, Set[3, 1, 2] iterates as 3, 1, 2, and an element is…
• class → instance_eval moves self, class_eval moves def — Both evals run a block with self set to the receiver; the difference is where a def inside lands
• class variables are shared → Class variables are shared with subclasses — @@count is one variable, owned by the class that first assigns it and seen by every subclass and every instance
• Class variables are shared with subclasses — @@count is one variable, owned by the class that first assigns it and seen by every subclass and every instance
• Class.new makes a class; a constant names it — Class.new(Base) { ... } returns a class object with no name, Foo = klass gives it the name of the first constant…
• classes → Classes are open — class String written a second time does not make a new class
• classes → Custom exceptions subclass StandardError — Inherit from StandardError (never Exception), give initialize a default message and pass it to super, add…
• classes → Every object has a class of its own — A method defined on one object
• classes → Class.new makes a class; a constant names it — Class.new(Base) { ... } returns a class object with no name, Foo = klass gives it the name of the first constant…
• Classes are open — class String written a second time does not make a new class
• classes at runtime → Class.new makes a class; a constant names it — Class.new(Base) { ... } returns a class object with no name, Foo = klass gives it the name of the first constant…
• clone → dup is a fresh copy, clone is a faithful one — dup and clone both make a new object with the same instance variables, and both are shallow
• closures → Closures capture variables, not values — A block, proc or lambda carries the variables around it
• closures capture variables → Closures capture variables, not values — A block, proc or lambda carries the variables around it
• Closures capture variables, not values — A block, proc or lambda carries the variables around it
• coercion → 1 + 1.5 works because Integer asks Float to coerce — When Integer#+ meets an operand it does not know, it calls that object's coerce and adds the pair it gets back
• command → The command line is part of the language — ruby takes flags for running code (-e), checking it (-c), warning about it (-w, -W:category), loading…
• comments → Ruby has block comments and a data section — Ruby comments with #, with =begin/=end blocks that must start at column 0, and with magic comments the parser…
• comments and documentation → Ruby has block comments and a data section — Ruby comments with #, with =begin/=end blocks that must start at column 0, and with magic comments the parser…
• common → Common error messages — Twenty-nine errors you will meet in your first month of Ruby, each with the code that raises it, the message Ruby…
• Common error messages — Twenty-nine errors you will meet in your first month of Ruby, each with the code that raises it, the message Ruby…
• comparable → Define <=> and Comparable gives you the rest — <=> answers -1, 0, 1 or nil ("these do not compare"); include Comparable turns that one method into <,…
• comparable and spaceship → Define <=> and Comparable gives you the rest — <=> answers -1, 0, 1 or nil ("these do not compare"); include Comparable turns that one method into <,…
• comparing → 1 == 1.0 is true, but {1 => :a}[1.0] is nil — Ruby's == compares an Integer with a Float by value
• comparing int and float → 1 == 1.0 is true, but {1 => :a}[1.0] is nil — Ruby's == compares an Integer with a Float by value
• composition → Procs curry and compose — Proc#curry turns an n-argument lambda into a chain of one-argument lambdas, >> and << compose any two…
• condition → Mutex guards, Queue hands over, ConditionVariable waits — Mutex#synchronize makes count += 1 exact across ten threads, a Queue moves work from one thread to another and…
• constants → Constants are found lexically, then through ancestors — A bare constant name is resolved by the lexical nesting the code was written in (Module.nesting), then through the…
• constants and lexical scope → Constants are found lexically, then through ancestors — A bare constant name is resolved by the lexical nesting the code was written in (Module.nesting), then through the…
• Constants are found lexically, then through ancestors — A bare constant name is resolved by the lexical nesting the code was written in (Module.nesting), then through the…
• core → Set is a core class in 4.0 and keeps insertion order — In Ruby 4.0 Set needs no require and is written in C, Set[3, 1, 2] iterates as 3, 1, 2, and an element is…
• coroutines → A Fiber is a coroutine you resume by hand — Fiber.new { } makes a block that runs only when you resume it and stops wherever it calls Fiber.yield; values…
• curry → Procs curry and compose — Proc#curry turns an n-argument lambda into a chain of one-argument lambdas, >> and << compose any two…
• curry and composition → Procs curry and compose — Proc#curry turns an n-argument lambda into a chain of one-argument lambdas, >> and << compose any two…
• custom → Custom exceptions subclass StandardError — Inherit from StandardError (never Exception), give initialize a default message and pass it to super, add…
• custom exception classes → Custom exceptions subclass StandardError — Inherit from StandardError (never Exception), give initialize a default message and pass it to super, add…
• Custom exceptions subclass StandardError — Inherit from StandardError (never Exception), give initialize a default message and pass it to super, add…

D

• dash → Warnings go to stderr, and -w finds more of them — warn prints to stderr; -w sets $VERBOSE to true and makes Ruby report unused variables, redefined methods,…
• data → Struct is mutable, Data is not — Struct.new(:x, :y) makes a record you can build positionally or by keyword and then change; `Data.define(:lat,…
• date → Time is an instant, Date is a calendar day — a Time is a point on the timeline with an offset attached
• deconstruct → deconstruct and deconstruct_keys let any object be matched — An array pattern calls the subject's deconstruct and a hash pattern calls deconstruct_keys(keys)
• deconstruct and deconstruct keys → deconstruct and deconstruct_keys let any object be matched — An array pattern calls the subject's deconstruct and a hash pattern calls deconstruct_keys(keys)
• deconstruct and deconstruct_keys let any object be matched — An array pattern calls the subject's deconstruct and a hash pattern calls deconstruct_keys(keys)
• default → A bare rescue catches StandardError, not everything — rescue with no class list means rescue StandardError, and SystemExit, Interrupt, NoMemoryError,…
• default → A missing key is nil, and Hash.new([]) shares its default — h[:zz] is nil where d["zz"] raises KeyError; fetch is the raising form; Hash.new(0) returns a default…
• default → Default arguments are evaluated on every call — A Ruby default is an expression that runs each time the method is called without that argument, so def f(a = [])…
• default arguments are evaluated each call → Default arguments are evaluated on every call — A Ruby default is an expression that runs each time the method is called without that argument, so def f(a = [])…
• Default arguments are evaluated on every call — A Ruby default is an expression that runs each time the method is called without that argument, so def f(a = [])…
• define → define_method turns a block into a method — define_method(:name) { ... } installs a method whose body is a closure
• Define <=> and Comparable gives you the rest — <=> answers -1, 0, 1 or nil ("these do not compare"); include Comparable turns that one method into <,…
• define method → define_method turns a block into a method — define_method(:name) { ... } installs a method whose body is a closure
• define_method turns a block into a method — define_method(:name) { ... } installs a method whose body is a closure
• destructuring → Assignment destructures, and blocks auto-splat — a, b = 1, 2, a, *rest = list and (a, b), c = pair, 3 read like Python
• destructuring assignment → Assignment destructures, and blocks auto-splat — a, b = 1, 2, a, *rest = list and (a, b), c = pair, 3 read like Python
• differ → Procs and lambdas differ in arity and return — Every proc and lambda is a Proc, but a lambda checks its argument count and returns from itself, while a proc…
• dir → Pathname#/ joins, and Dir.glob is sorted — Pathname is an object with /, basename, extname, parent, children, exist? and read; Dir.glob…
• division → 7 / 2 is 3: integer division floors — Ruby's / on two Integers is Python's //
• docstrings → Ruby has no docstrings — A Ruby method carries no documentation at run time
• documentation → Ruby has block comments and a data section — Ruby comments with #, with =begin/=end blocks that must start at column 0, and with magic comments the parser…
• dots → Two dots include the end, three dots exclude it — 1..5 is five numbers and 1...5 is four; a Range can be endless (1..), beginless (..5), made of Strings…
• dsl → A DSL is instance_eval plus stored blocks — A Ruby DSL is ordinary method calls made readable by three tricks
• duck → Duck typing asks respond_to?, not class — Ruby code asks an object what it can do
• duck typing and respond to → Duck typing asks respond_to?, not class — Ruby code asks an object what it can do
• Duck typing asks respond_to?, not class — Ruby code asks an object what it can do
• dup → dup is a fresh copy, clone is a faithful one — dup and clone both make a new object with the same instance variables, and both are shallow
• dup clone and frozen state → dup is a fresh copy, clone is a faithful one — dup and clone both make a new object with the same instance variables, and both are shallow
• dup is a fresh copy, clone is a faithful one — dup and clone both make a new object with the same instance variables, and both are shallow

E

• else → rescue, else and ensure run in a fixed order — The body runs first; then rescue if it raised or else if it did not; then ensure, always
• ensure → rescue, else and ensure run in a fixed order — The body runs first; then rescue if it raised or else if it did not; then ensure, always
• enumerable → Enumerable is a mixin: write each, get the rest — A class that defines each and says include Enumerable gains map, select, sort_by, min_by, include?,…
• enumerable → Most loops you would write are one Enumerable call — map, select, reject, find, partition, group_by, tally, each_slice, each_cons, zip, flat_map,…
• enumerable is a mixin → Enumerable is a mixin: write each, get the rest — A class that defines each and says include Enumerable gains map, select, sort_by, min_by, include?,…
• Enumerable is a mixin: write each, get the rest — A class that defines each and says include Enumerable gains map, select, sort_by, min_by, include?,…
• Enumerator#next runs the block on its own Fiber — each, to_a, map and first run an Enumerator's block where they are called, on the calling fiber; next…
• enumerators → An Enumerator has a cursor: next, peek, rewind — Any each called without a block returns an Enumerator; next pulls one value from it, peek looks at the next…
• enumerators → Enumerator#next runs the block on its own Fiber — each, to_a, map and first run an Enumerator's block where they are called, on the calling fiber; next…
• enumerators → lazy runs the chain one element at a time — map and select on an ordinary collection each run to the end and build an array before the next stage starts;…
• enumerators run on fibers → Enumerator#next runs the block on its own Fiber — each, to_a, map and first run an Enumerator's block where they are called, on the calling fiber; next…
• env → ARGV holds strings and ENV is not a Hash — ARGV is an Array of Strings, $0 is the script name as it was invoked, ENV is a Hash-like object whose values…
• eql → A Hash key needs eql? and hash, not == — A Hash finds a key by calling hash and then eql?
• eql and hash for hash keys → A Hash key needs eql? and hash, not == — A Hash finds a key by calling hash and then eql?
• equality → Ruby has four kinds of equality — equal? is identity, == is value, eql? is value without type conversion (the test Hash keys use), and ===…
• equals → x ||= v assigns when x is nil or false — x ||= v is x || (x = v): it assigns when x is nil or false and leaves every other value alone, so it…
• error → A bare rescue catches StandardError, not everything — rescue with no class list means rescue StandardError, and SystemExit, Interrupt, NoMemoryError,…
• error → Common error messages — Twenty-nine errors you will meet in your first month of Ruby, each with the code that raises it, the message Ruby…
• error → Nothing matched: case/in raises, case/when returns nil — A case/in with no matching branch and no else, and a rightward value => pattern, raise NoMatchingPatternError
• error → freeze is shallow and raises FrozenError — freeze makes one object immutable
• eval → A Binding is a scope you can carry around — binding packages a method's local variables, its self and its name into an object that eval, ERB#result and…
• eval → instance_eval moves self, class_eval moves def — Both evals run a block with self set to the receiver; the difference is where a def inside lands
• evaluated → Default arguments are evaluated on every call — A Ruby default is an expression that runs each time the method is called without that argument, so def f(a = [])…
• Every object has a class of its own — A method defined on one object
• everything → Everything is an expression, even def and class — Every Ruby construct
• everything → Everything is an object, even 1 and nil — Every Ruby value
• everything is an expression → Everything is an expression, even def and class — Every Ruby construct
• Everything is an expression, even def and class — Every Ruby construct
• everything is an object → Everything is an object, even 1 and nil — Every Ruby value
• Everything is an object, even 1 and nil — Every Ruby value
• exception → Custom exceptions subclass StandardError — Inherit from StandardError (never Exception), give initialize a default message and pass it to super, add…
• exceptions → Exceptions have a cause — A raise that runs while a rescue clause is handling another exception records that exception as the new one's…
• Exceptions have a cause — A raise that runs while a rescue clause is handling another exception records that exception as the new one's…
• exceptions have a cause → Exceptions have a cause — A raise that runs while a rescue clause is handling another exception records that exception as the new one's…
• exit → ARGV holds strings and ENV is not a Hash — ARGV is an Array of Strings, $0 is the script name as it was invoked, ENV is a Hash-like object whose values…
• exit → exit raises SystemExit — exit is not a system call but a raise of SystemExit, so ensure clauses and at_exit handlers run, a `rescue…
• exit at exit and system exit → exit raises SystemExit — exit is not a system call but a raise of SystemExit, so ensure clauses and at_exit handlers run, a `rescue…
• exit raises SystemExit — exit is not a system call but a raise of SystemExit, so ensure clauses and at_exit handlers run, a `rescue…
• expression → Everything is an expression, even def and class — Every Ruby construct
• expression → The last expression is the return value — A Ruby method returns the value of the last expression it evaluated, so return is only for leaving early
• extend → Mixins: include, extend, prepend — include inserts a module into the class's ancestor chain behind the class, prepend inserts it in front so…
• external → An Enumerator has a cursor: next, peek, rewind — Any each called without a block returns an Enumerator; next pulls one value from it, peek looks at the next…
• external enumerators → An Enumerator has a cursor: next, peek, rewind — Any each called without a block returns an Enumerator; next pulls one value from it, peek looks at the next…

F

• false → Only nil and false are falsy — Ruby has exactly two falsy values, nil and false; 0, 0.0, "", [] and {} are all truthy and no class…
• fiber → Thread.current[:x] is fiber-local, not thread-local — Thread.current[:x] is scoped to the fiber that set it
• fibers → A Fiber is a coroutine you resume by hand — Fiber.new { } makes a block that runs only when you resume it and stops wherever it calls Fiber.yield; values…
• fibers → Enumerator#next runs the block on its own Fiber — each, to_a, map and first run an Enumerator's block where they are called, on the calling fiber; next…
• fibers are coroutines → A Fiber is a coroutine you resume by hand — Fiber.new { } makes a block that runs only when you resume it and stops wherever it calls Fiber.yield; values…
• file → File.open with a block closes the file for you — File.open(name, mode) { |f| … } closes the file when the block ends and evaluates to the block's value; Python's…
• file open with a block → File.open with a block closes the file for you — File.open(name, mode) { |f| … } closes the file when the block ends and evaluates to the block's value; Python's…
• File.open with a block closes the file for you — File.open(name, mode) { |f| … } closes the file when the block ends and evaluates to the block's value; Python's…
• flags → The command line is part of the language — ruby takes flags for running code (-e), checking it (-c), warning about it (-w, -W:category), loading…
• float → 1 == 1.0 is true, but {1 => :a}[1.0] is nil — Ruby's == compares an Integer with a Float by value
• floats → 0.1 + 0.2 != 0.3, and 2.5.round is 3 — A Ruby Float is the same 64-bit double as a Python float
• floats and rounding → 0.1 + 0.2 != 0.3, and 2.5.round is 3 — A Ruby Float is the same 64-bit double as a Python float
• floors → 7 / 2 is 3: integer division floors — Ruby's / on two Integers is Python's //
• for loops do not scope → for loops do not make a scope — for and while are syntax and open no scope
• for loops do not make a scope — for and while are syntax and open no scope
• fork → fork copies the process; wait collects its status — fork makes a second process that is a copy of this one
• fork copies the process; wait collects its status — fork makes a second process that is a copy of this one
• formatting → Numbers become text with format, to_s(16) and % — format speaks C's mini-language
• formatting → #{} calls to_s; format is printf — "#{expr}" evaluates any expression and calls to_s on the result
• forms → raise has four forms — raise "msg" is a RuntimeError, raise Klass an instance whose message is the class name, raise Klass, "msg"…
• four → Ruby has four kinds of equality — equal? is identity, == is value, eql? is value without type conversion (the test Hash keys use), and ===…
• four → raise has four forms — raise "msg" is a RuntimeError, raise Klass an instance whose message is the class name, raise Klass, "msg"…
• four kinds of equality → Ruby has four kinds of equality — equal? is identity, == is value, eql? is value without type conversion (the test Hash keys use), and ===…
• freeze → freeze is shallow and raises FrozenError — freeze makes one object immutable
• freeze and frozen error → freeze is shallow and raises FrozenError — freeze makes one object immutable
• freeze is shallow and raises FrozenError — freeze makes one object immutable
• frozen → dup is a fresh copy, clone is a faithful one — dup and clone both make a new object with the same instance variables, and both are shallow
• frozen → freeze is shallow and raises FrozenError — freeze makes one object immutable

G

• gemfile → Gems are versioned; Bundler pins them — A gem is a versioned package that RubyGems can activate by name (gem "x"), some ship inside Ruby (default gems),…
• gems → Gems are versioned; Bundler pins them — A gem is a versioned package that RubyGems can activate by name (gem "x"), some ship inside Ruby (default gems),…
• Gems are versioned; Bundler pins them — A gem is a versioned package that RubyGems can activate by name (gem "x"), some ship inside Ruby (default gems),…
• gems bundler and gemfile → Gems are versioned; Bundler pins them — A gem is a versioned package that RubyGems can activate by name (gem "x"), some ship inside Ruby (default gems),…
• gets → gets returns nil at EOF, and reads ARGV's files first — gets returns the next line with its newline and nil at end of input
• gets returns nil at EOF, and reads ARGV's files first — gets returns the next line with its newline and nil at end of input
• glob → Pathname#/ joins, and Dir.glob is sorted — Pathname is an object with /, basename, extname, parent, children, exist? and read; Dir.glob…
• gotchas → Twenty-three Python traps for a Ruby programmer — The twenty-three places where a Ruby reflex gives the wrong answer in Python
• gotchas → Twenty-three Ruby traps for a Python programmer — The twenty-three places where a Python reflex gives the wrong answer in Ruby
• gotchas for python programmers → Twenty-three Ruby traps for a Python programmer — The twenty-three places where a Python reflex gives the wrong answer in Ruby
• gotchas for ruby programmers in python → Twenty-three Python traps for a Ruby programmer — The twenty-three places where a Ruby reflex gives the wrong answer in Python
• guards → A pin compares; a bare name binds — Inside a pattern a bare name always binds
• guards → x ||= v assigns when x is nil or false — x ||= v is x || (x = v): it assigns when x is nil or false and leaves every other value alone, so it…
• gvl → Threads are OS threads that take turns under the GVL — Thread.new { } starts a real OS thread that shares every object with the others; join waits and re-raises…

H

• haproxy → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• hash → A Hash key needs eql? and hash, not == — A Hash finds a key by calling hash and then eql?
• hashes → A missing key is nil, and Hash.new([]) shares its default — h[:zz] is nil where d["zz"] raises KeyError; fetch is the raising form; Hash.new(0) returns a default…
• hashes and default values → A missing key is nil, and Hash.new([]) shares its default — h[:zz] is nil where d["zz"] raises KeyError; fetch is the raising form; Hash.new(0) returns a default…
• hooks → Hooks fire when code is defined, not when it runs — inherited, included, extended, prepended, method_added, singleton_method_added and const_added are…
• Hooks fire when code is defined, not when it runs — inherited, included, extended, prepended, method_added, singleton_method_added and const_added are…
• hooks inherited included method added → Hooks fire when code is defined, not when it runs — inherited, included, extended, prepended, method_added, singleton_method_added and const_added are…

I

• implicit → self is the implicit receiver — Every Ruby call has a receiver, and when you write none it is self
• include → Mixins: include, extend, prepend — include inserts a module into the class's ancestor chain behind the class, prepend inserts it in front so…
• included → Hooks fire when code is defined, not when it runs — inherited, included, extended, prepended, method_added, singleton_method_added and const_added are…
• Indentation is convention in Ruby, syntax in Python — Ruby runs mis-indented code and ruby -w only warns when an end sits under the wrong column, while Python refuses…
• indexes → Past the end, an array gives nil, not an error — a[10] on a four-element array is nil, a[5] = 99 pads the gap with nil, and a slice is a[1..2] (end…
• inherited → Hooks fire when code is defined, not when it runs — inherited, included, extended, prepended, method_added, singleton_method_added and const_added are…
• initialize → new is allocate then initialize — Point.new(1, 2) is a class method that does two things
• inject → inject makes the block's value the next accumulator — inject feeds each block result back in as the accumulator, so a block that ends in an assignment hands the next…
• inject and each with object → inject makes the block's value the next accumulator — inject feeds each block result back in as the accumulator, so a block that ends in an assignment hands the next…
• inject makes the block's value the next accumulator — inject feeds each block result back in as the accumulator, so a block that ends in an assignment hands the next…
• inspect → puts calls to_s, p calls inspect — Every object answers two questions
• instance → Instance variables are private — An @variable belongs to one object and can be read or written only by that object's own methods
• instance → instance_eval moves self, class_eval moves def — Both evals run a block with self set to the receiver; the difference is where a def inside lands
• instance eval and class eval → instance_eval moves self, class_eval moves def — Both evals run a block with self set to the receiver; the difference is where a def inside lands
• Instance variables are private — An @variable belongs to one object and can be read or written only by that object's own methods
• instance_eval moves self, class_eval moves def — Both evals run a block with self set to the receiver; the difference is where a def inside lands
• int → 1 == 1.0 is true, but {1 => :a}[1.0] is nil — Ruby's == compares an Integer with a Float by value
• integer → 7 / 2 is 3: integer division floors — Ruby's / on two Integers is Python's //
• integer division floors → 7 / 2 is 3: integer division floors — Ruby's / on two Integers is Python's //
• integers → Integers never overflow: 2 ** 200 is just an Integer — Ruby has one Integer class with no ceiling
• integers are unbounded → Integers never overflow: 2 ** 200 is just an Integer — Ruby has one Integer class with no ceiling
• Integers never overflow: 2 ** 200 is just an Integer — Ruby has one Integer class with no ceiling
• interpolation → #{} calls to_s; format is printf — "#{expr}" evaluates any expression and calls to_s on the result
• interpreter → YJIT and ZJIT are switches, not defaults — MRI (RUBY_ENGINE == "ruby") always runs YARV bytecode through its interpreter; YJIT (since 3.1) and ZJIT (new in…
• introspection → An object can list its methods and variables — methods, instance_methods(false), instance_variables, instance_method(:x).parameters, source_location,…
• irb → irb echoes every value; a script does not — irb is a read–eval–print loop: each line's value is printed with inspect, _ holds the last one, an exception…
• irb and the repl → irb echoes every value; a script does not — irb is a read–eval–print loop: each line's value is printed with inspect, _ holds the last one, an exception…
• irb echoes every value; a script does not — irb is a read–eval–print loop: each line's value is printed with inspect, _ holds the last one, an exception…
• it and numbered parameters → it and _1 name the block's parameter — A block with no |x| can read its arguments as _1, _2, … (Ruby 2.7) or as it (Ruby 3.4); they are parameters…
• it and _1 name the block's parameter — A block with no |x| can read its arguments as _1, _2, … (Ruby 2.7) or as it (Ruby 3.4); they are parameters…
• iterator → An iterator is a method that yields — A class earns the whole Enumerable toolbox by writing one each that yields and including the module; `return…

J

• jits → YJIT and ZJIT are switches, not defaults — MRI (RUBY_ENGINE == "ruby") always runs YARV bytecode through its interpreter; YJIT (since 3.1) and ZJIT (new in…
• jits and the interpreter → YJIT and ZJIT are switches, not defaults — MRI (RUBY_ENGINE == "ruby") always runs YARV bytecode through its interpreter; YJIT (since 3.1) and ZJIT (new in…
• json → JSON.parse gives string keys; YAML.load is safe — JSON is text for everyone and loses what JSON cannot say
• json yaml and marshal → JSON.parse gives string keys; YAML.load is safe — JSON is text for everyone and loses what JSON cannot say
• JSON.parse gives string keys; YAML.load is safe — JSON is text for everyone and loses what JSON cannot say

K

• kernel → Object sits on Kernel on BasicObject — Object.ancestors is [Object, Kernel, BasicObject] and Object itself defines no public methods
• keys → A Hash key needs eql? and hash, not == — A Hash finds a key by calling hash and then eql?
• keys → A string key and a symbol key are two keys — {"a" => 1}[:a] is nil because "a" and :a are different objects of different classes, JSON.parse always…
• keys → deconstruct and deconstruct_keys let any object be matched — An array pattern calls the subject's deconstruct and a hash pattern calls deconstruct_keys(keys)
• keyword → Arguments: positional, keyword, splat and block — A Ruby parameter list has eight kinds of slot
• killing → Timeout.timeout interrupts a thread from outside — Timeout.timeout(0.2) { sleep 5 } raises Timeout::Error after a fifth of a second because a watcher thread calls…
• kinds → Ruby has four kinds of equality — equal? is identity, == is value, eql? is value without type conversion (the test Hash keys use), and ===…

L

• lambdas → Procs and lambdas differ in arity and return — Every proc and lambda is a Proc, but a lambda checks its argument count and returns from itself, while a proc…
• last → The last expression is the return value — A Ruby method returns the value of the last expression it evaluated, so return is only for leaving early
• lazy → lazy runs the chain one element at a time — map and select on an ordinary collection each run to the end and build an array before the next stage starts;…
• lazy enumerators → lazy runs the chain one element at a time — map and select on an ordinary collection each run to the end and build an array before the next stage starts;…
• lazy runs the chain one element at a time — map and select on an ordinary collection each run to the end and build an array before the next stage starts;…
• lexical → Constants are found lexically, then through ancestors — A bare constant name is resolved by the lexical nesting the code was written in (Module.nesting), then through the…
• library → Text lives in the Ruby text library — a Ruby String is bytes plus an encoding label
• line → The command line is part of the language — ruby takes flags for running code (-e), checking it (-c), warning about it (-w, -W:category), loading…
• lives → Text lives in the Ruby text library — a Ruby String is bytes plus an encoding label
• load → require loads once; load runs every time — require and require_relative run a file once and remember it in $LOADED_FEATURES; load runs a file every…
• load shedding → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• locals → Thread.current[:x] is fiber-local, not thread-local — Thread.current[:x] is scoped to the fiber that set it
• lookup → Method lookup walks ancestors; super continues it — A call searches the receiver's ancestors from left to right and stops at the first class or module that defines…
• loops → for loops do not make a scope — for and while are syntax and open no scope

M

• marshal → JSON.parse gives string keys; YAML.load is safe — JSON is text for everyone and loses what JSON cannot say
• matching → Nothing matched: case/in raises, case/when returns nil — A case/in with no matching branch and no else, and a rightward value => pattern, raise NoMatchingPatternError
• matching → case/in matches shape, not just value — case … in tests a value against a pattern
• means → private means "no receiver" — A private method can be called only without an explicit receiver (or with self.), a protected method only from…
• messages → Common error messages — Twenty-nine errors you will meet in your first month of Ruby, each with the code that raises it, the message Ruby…
• method → A method is a value once you ask for it — obj.method(:name) hands back a Method bound to obj, and Klass.instance_method(:name) an UnboundMethod you…
• method → Hooks fire when code is defined, not when it runs — inherited, included, extended, prepended, method_added, singleton_method_added and const_added are…
• method → Method lookup walks ancestors; super continues it — A call searches the receiver's ancestors from left to right and stops at the first class or module that defines…
• method → define_method turns a block into a method — define_method(:name) { ... } installs a method whose body is a closure
• method → method_missing needs respond_to_missing? — method_missing(name, *args) runs only after normal lookup has failed, and it must call super for names it does…
• method lookup and super → Method lookup walks ancestors; super continues it — A call searches the receiver's ancestors from left to right and stops at the first class or module that defines…
• Method lookup walks ancestors; super continues it — A call searches the receiver's ancestors from left to right and stops at the first class or module that defines…
• method missing and respond to missing → method_missing needs respond_to_missing? — method_missing(name, *args) runs only after normal lookup has failed, and it must call super for names it does…
• method objects and unbound methods → A method is a value once you ask for it — obj.method(:name) hands back a Method bound to obj, and Klass.instance_method(:name) an UnboundMethod you…
• method_missing needs respond_to_missing? — method_missing(name, *args) runs only after normal lookup has failed, and it must call super for names it does…
• methods → A method is a value once you ask for it — obj.method(:name) hands back a Method bound to obj, and Klass.instance_method(:name) an UnboundMethod you…
• methods → Bang means dangerous, question mark means predicate — A trailing ! marks the more dangerous of two versions of a method
• methods → Operators are methods, except the ones that are not — +, -@, [], []=, <=>, << and even ! are ordinary methods you define with def, and 1 + 2 is 1.+(2)
• minitest → A Minitest test is a plain class — Minitest, a bundled gem, runs every test_* method of a Minitest::Test subclass in a seeded random order and…
• minitest and unittest → A Minitest test is a plain class — Minitest, a bundled gem, runs every test_* method of a Minitest::Test subclass in a seeded random order and…
• missing → method_missing needs respond_to_missing? — method_missing(name, *args) runs only after normal lookup has failed, and it must call super for names it does…
• mixin → Enumerable is a mixin: write each, get the rest — A class that defines each and says include Enumerable gains map, select, sort_by, min_by, include?,…
• mixins → Mixins: include, extend, prepend — include inserts a module into the class's ancestor chain behind the class, prepend inserts it in front so…
• mixins include extend prepend → Mixins: include, extend, prepend — include inserts a module into the class's ancestor chain behind the class, prepend inserts it in front so…
• Mixins: include, extend, prepend — include inserts a module into the class's ancestor chain behind the class, prepend inserts it in front so…
• modifier → rescue works as a modifier, for StandardError only — expr rescue fallback evaluates expr and, if it raises a StandardError, yields fallback instead; it binds…
• modifiers → unless negates if; modifiers hang off the end of a line — Ruby spells if not as unless and while not as until, lets any statement carry if, unless, while or…
• modules → A module is a namespace, and cannot be instantiated — module Shop is a named box for classes, constants and methods
• modules as namespaces → A module is a namespace, and cannot be instantiated — module Shop is a named box for classes, constants and methods
• Most loops you would write are one Enumerable call — map, select, reject, find, partition, group_by, tally, each_slice, each_cons, zip, flat_map,…
• multiple → return a, b returns one Array — Ruby has no tuple: return a, b builds an Array, multiple assignment takes it apart, and a count mismatch silently…
• multiple return values → return a, b returns one Array — Ruby has no tuple: return a, b builds an Array, multiple assignment takes it apart, and a count mismatch silently…
• mutable → Strings are mutable; << keeps the object — A Ruby String is a mutable object
• mutex → Mutex guards, Queue hands over, ConditionVariable waits — Mutex#synchronize makes count += 1 exact across ten threads, a Queue moves work from one thread to another and…
• Mutex guards, Queue hands over, ConditionVariable waits — Mutex#synchronize makes count += 1 exact across ten threads, a Queue moves work from one thread to another and…
• mutex queue and condition variable → Mutex guards, Queue hands over, ConditionVariable waits — Mutex#synchronize makes count += 1 exact across ten threads, a Queue moves work from one thread to another and…

N

• names → A symbol is a name, not a string — A Ruby symbol is an immutable name of which exactly one object exists per spelling
• namespaces → A module is a namespace, and cannot be instantiated — module Shop is a named box for classes, constants and methods
• naming → Indentation is convention in Ruby, syntax in Python — Ruby runs mis-indented code and ruby -w only warns when an end sits under the wrong column, while Python refuses…
• navigation → &. skips the call when the receiver is nil — receiver&.method(args) returns nil without calling anything
• negative → Past the end, an array gives nil, not an error — a[10] on a four-element array is nil, a[5] = 99 pads the gap with nil, and a slice is a[1..2] (end…
• new → new is allocate then initialize — Point.new(1, 2) is a class method that does two things
• new allocate and initialize → new is allocate then initialize — Point.new(1, 2) is a class method that does two things
• new is allocate then initialize — Point.new(1, 2) is a class method that does two things
• next → next, break and return leave a block differently — next v ends this run of the block with v as its value, break v ends the method the block was given to and…
• next break and return in blocks → next, break and return leave a block differently — next v ends this run of the block with v as its value, break v ends the method the block was given to and…
• next, break and return leave a block differently — next v ends this run of the block with v as its value, break v ends the method the block was given to and…
• nil → Only nil and false are falsy — Ruby has exactly two falsy values, nil and false; 0, 0.0, "", [] and {} are all truthy and no class…
• nil → x ||= v assigns when x is nil or false — x ||= v is x || (x = v): it assigns when x is nil or false and leaves every other value alone, so it…
• nil false and truthiness → Only nil and false are falsy — Ruby has exactly two falsy values, nil and false; 0, 0.0, "", [] and {} are all truthy and no class…
• no docstrings → Ruby has no docstrings — A Ruby method carries no documentation at run time
• no matching pattern error → Nothing matched: case/in raises, case/when returns nil — A case/in with no matching branch and no else, and a rightward value => pattern, raise NoMatchingPatternError
• nothing → Ractors share nothing that is not frozen — A Ractor runs a block on a thread with a lock of its own, so two Ractors run Ruby code at the same time
• Nothing matched: case/in raises, case/when returns nil — A case/in with no matching branch and no else, and a rightward value => pattern, raise NoMatchingPatternError
• number → Numbers become text with format, to_s(16) and % — format speaks C's mini-language
• number formatting → Numbers become text with format, to_s(16) and % — format speaks C's mini-language
• numbered → it and _1 name the block's parameter — A block with no |x| can read its arguments as _1, _2, … (Ruby 2.7) or as it (Ruby 3.4); they are parameters…
• Numbers become text with format, to_s(16) and % — format speaks C's mini-language
• numeric → 1 + 1.5 works because Integer asks Float to coerce — When Integer#+ meets an operand it does not know, it calls that object's coerce and adds the pair it gets back
• numeric coercion → 1 + 1.5 works because Integer asks Float to coerce — When Integer#+ meets an operand it does not know, it calls that object's coerce and adds the pair it gets back

O

• object → Everything is an object, even 1 and nil — Every Ruby value
• object → The GC answers comparisons, not counts — GC.start, GC.stat, ObjectSpace and WeakRef let a program watch its own heap, but only comparisons are stable
• object → Object sits on Kernel on BasicObject — Object.ancestors is [Object, Kernel, BasicObject] and Object itself defines no public methods
• object → inject makes the block's value the next accumulator — inject feeds each block result back in as the accumulator, so a block that ends in an assignment hands the next…
• object space and gc → The GC answers comparisons, not counts — GC.start, GC.stat, ObjectSpace and WeakRef let a program watch its own heap, but only comparisons are stable
• Object sits on Kernel on BasicObject — Object.ancestors is [Object, Kernel, BasicObject] and Object itself defines no public methods
• objects → A method is a value once you ask for it — obj.method(:name) hands back a Method bound to obj, and Klass.instance_method(:name) an UnboundMethod you…
• objects → Blocks are not objects — A block is syntax attached to one method call
• Only nil and false are falsy — Ruby has exactly two falsy values, nil and false; 0, 0.0, "", [] and {} are all truthy and no class…
• open → Classes are open — class String written a second time does not make a new class
• open → File.open with a block closes the file for you — File.open(name, mode) { |f| … } closes the file when the block ends and evaluates to the block's value; Python's…
• operators → Operators are methods, except the ones that are not — +, -@, [], []=, <=>, << and even ! are ordinary methods you define with def, and 1 + 2 is 1.+(2)
• operators are methods → Operators are methods, except the ones that are not — +, -@, [], []=, <=>, << and even ! are ordinary methods you define with def, and 1 + 2 is 1.+(2)
• Operators are methods, except the ones that are not — +, -@, [], []=, <=>, << and even ! are ordinary methods you define with def, and 1 + 2 is 1.+(2)
• optional → Parentheses are optional, but the space is not — Ruby lets you leave the parentheses off a call and off a def, so a bare name is a call
• or equals and nil guards → x ||= v assigns when x is nil or false — x ||= v is x || (x = v): it assigns when x is nil or false and leaves every other value alone, so it…
• other → system returns true, false or nil — system returns true for exit 0, false for any other status and nil when the command could not be started;…

P

• parameters → it and _1 name the block's parameter — A block with no |x| can read its arguments as _1, _2, … (Ruby 2.7) or as it (Ruby 3.4); they are parameters…
• parentheses → Parentheses are optional, but the space is not — Ruby lets you leave the parentheses off a call and off a def, so a bare name is a call
• parentheses are optional → Parentheses are optional, but the space is not — Ruby lets you leave the parentheses off a call and off a def, so a bare name is a call
• Parentheses are optional, but the space is not — Ruby lets you leave the parentheses off a call and off a def, so a bare name is a call
• passenger → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• Past the end, an array gives nil, not an error — a[10] on a four-element array is nil, a[5] = 99 pads the gap with nil, and a slice is a[1..2] (end…
• pathname → Pathname#/ joins, and Dir.glob is sorted — Pathname is an object with /, basename, extname, parent, children, exist? and read; Dir.glob…
• pathname dir and glob → Pathname#/ joins, and Dir.glob is sorted — Pathname is an object with /, basename, extname, parent, children, exist? and read; Dir.glob…
• Pathname#/ joins, and Dir.glob is sorted — Pathname is an object with /, basename, extname, parent, children, exist? and read; Dir.glob…
• pattern → Nothing matched: case/in raises, case/when returns nil — A case/in with no matching branch and no else, and a rightward value => pattern, raise NoMatchingPatternError
• pattern → case/in matches shape, not just value — case … in tests a value against a pattern
• pin → A pin compares; a bare name binds — Inside a pattern a bare name always binds
• pin guards and alternatives → A pin compares; a bare name binds — Inside a pattern a bare name always binds
• positional → Arguments: positional, keyword, splat and block — A Ruby parameter list has eight kinds of slot
• precedence → and/or bind lower than = — Ruby has two pairs of boolean operators
• prepend → Mixins: include, extend, prepend — include inserts a module into the class's ancestor chain behind the class, prepend inserts it in front so…
• print → puts adds a newline, print does not, p shows inspect — puts writes to_s plus a newline it does not double, flattening arrays, printing nil as an empty line and an…
• private → Instance variables are private — An @variable belongs to one object and can be read or written only by that object's own methods
• private → private means "no receiver" — A private method can be called only without an explicit receiver (or with self.), a protected method only from…
• private means no receiver → private means "no receiver" — A private method can be called only without an explicit receiver (or with self.), a protected method only from…
• private means "no receiver" — A private method can be called only without an explicit receiver (or with self.), a protected method only from…
• proc → &:sym calls Symbol#to_proc — &x in an argument list calls x.to_proc and attaches the result as the block; a symbol's to_proc is a lambda…
• processes → fork copies the process; wait collects its status — fork makes a second process that is a copy of this one
• processes fork and wait → fork copies the process; wait collects its status — fork makes a second process that is a copy of this one
• procs → Procs and lambdas differ in arity and return — Every proc and lambda is a Proc, but a lambda checks its argument count and returns from itself, while a proc…
• procs and lambdas differ → Procs and lambdas differ in arity and return — Every proc and lambda is a Proc, but a lambda checks its argument count and returns from itself, while a proc…
• Procs and lambdas differ in arity and return — Every proc and lambda is a Proc, but a lambda checks its argument count and returns from itself, while a proc…
• Procs curry and compose — Proc#curry turns an n-argument lambda into a chain of one-argument lambdas, >> and << compose any two…
• programmers → Twenty-three Python traps for a Ruby programmer — The twenty-three places where a Ruby reflex gives the wrong answer in Python
• programmers → Twenty-three Ruby traps for a Python programmer — The twenty-three places where a Python reflex gives the wrong answer in Ruby
• programs → system returns true, false or nil — system returns true for exit 0, false for any other status and nil when the command could not be started;…
• public → send reaches private methods; public_send does not — obj.send(:name, *args) calls a method by name and ignores visibility, public_send honours it, and __send__…
• puts → puts adds a newline, print does not, p shows inspect — puts writes to_s plus a newline it does not double, flattening arrays, printing nil as an empty line and an…
• puts print p and pp → puts adds a newline, print does not, p shows inspect — puts writes to_s plus a newline it does not double, flattening arrays, printing nil as an empty line and an…
• puts adds a newline, print does not, p shows inspect — puts writes to_s plus a newline it does not double, flattening arrays, printing nil as an empty line and an…
• puts calls to_s, p calls inspect — Every object answers two questions
• python → Twenty-three Python traps for a Ruby programmer — The twenty-three places where a Ruby reflex gives the wrong answer in Python
• python → Twenty-three Ruby traps for a Python programmer — The twenty-three places where a Python reflex gives the wrong answer in Ruby
• pythonic → There is more than one way, and one obvious way — Ruby's idioms

Q

• question → Bang means dangerous, question mark means predicate — A trailing ! marks the more dangerous of two versions of a method
• queue → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• queue → Mutex guards, Queue hands over, ConditionVariable waits — Mutex#synchronize makes count += 1 exact across ten threads, a Queue moves work from one thread to another and…
• queue full → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…

R

• ractors → Ractors share nothing that is not frozen — A Ractor runs a block on a thread with a lock of its own, so two Ractors run Ruby code at the same time
• ractors share nothing → Ractors share nothing that is not frozen — A Ractor runs a block on a thread with a lock of its own, so two Ractors run Ruby code at the same time
• Ractors share nothing that is not frozen — A Ractor runs a block on a thread with a lock of its own, so two Ractors run Ruby code at the same time
• raise → raise has four forms — raise "msg" is a RuntimeError, raise Klass an instance whose message is the class name, raise Klass, "msg"…
• raise has four forms → raise has four forms — raise "msg" is a RuntimeError, raise Klass an instance whose message is the class name, raise Klass, "msg"…
• raise has four forms — raise "msg" is a RuntimeError, raise Klass an instance whose message is the class name, raise Klass, "msg"…
• random → Random.new(42) gives the same numbers every run — A seeded Random is a function of its seed
• random with a seed → Random.new(42) gives the same numbers every run — A seeded Random is a function of its seed
• Random.new(42) gives the same numbers every run — A seeded Random is a function of its seed
• ranges → Two dots include the end, three dots exclude it — 1..5 is five numbers and 1...5 is four; a Range can be endless (1..), beginless (..5), made of Strings…
• ranges two dots and three → Two dots include the end, three dots exclude it — 1..5 is five numbers and 1...5 is four; a Range can be endless (1..), beginless (..5), made of Strings…
• rational → 1/3r and BigDecimal("0.1") are exact where Float is not — Ruby ships two exact number types beside Float
• rational and bigdecimal → 1/3r and BigDecimal("0.1") are exact where Float is not — Ruby ships two exact number types beside Float
• receiver → private means "no receiver" — A private method can be called only without an explicit receiver (or with self.), a protected method only from…
• references → A variable is a reference, not a box — Assignment copies a reference, never the object, so after b = a a mutating method such as << on b is seen…
• refinements → Refinements are lexical, not global — refine String do … end inside a module builds a Refinement, and using that module activates it from that line…
• Refinements are lexical, not global — refine String do … end inside a module builds a Refinement, and using that module activates it from that line…
• refuses → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• relative → require loads once; load runs every time — require and require_relative run a file once and remember it in $LOADED_FEATURES; load runs a file every…
• repl → irb echoes every value; a script does not — irb is a read–eval–print loop: each line's value is printed with inspect, _ holds the last one, an exception…
• require → require loads once; load runs every time — require and require_relative run a file once and remember it in $LOADED_FEATURES; load runs a file every…
• require require relative and load → require loads once; load runs every time — require and require_relative run a file once and remember it in $LOADED_FEATURES; load runs a file every…
• require loads once; load runs every time — require and require_relative run a file once and remember it in $LOADED_FEATURES; load runs a file every…
• rescue → rescue works as a modifier, for StandardError only — expr rescue fallback evaluates expr and, if it raises a StandardError, yields fallback instead; it binds…
• rescue → rescue, else and ensure run in a fixed order — The body runs first; then rescue if it raised or else if it did not; then ensure, always
• rescue as a modifier → rescue works as a modifier, for StandardError only — expr rescue fallback evaluates expr and, if it raises a StandardError, yields fallback instead; it binds…
• rescue ensure else and retry → rescue, else and ensure run in a fixed order — The body runs first; then rescue if it raised or else if it did not; then ensure, always
• rescue works as a modifier, for StandardError only — expr rescue fallback evaluates expr and, if it raises a StandardError, yields fallback instead; it binds…
• rescue, else and ensure run in a fixed order — The body runs first; then rescue if it raised or else if it did not; then ensure, always
• respond → Duck typing asks respond_to?, not class — Ruby code asks an object what it can do
• respond → method_missing needs respond_to_missing? — method_missing(name, *args) runs only after normal lookup has failed, and it must call super for names it does…
• retry → rescue, else and ensure run in a fixed order — The body runs first; then rescue if it raised or else if it did not; then ensure, always
• return → A setter returns its argument, not its body — obj.x = 5 is a call to the method x=, but as an expression it evaluates to 5 whatever the method body returns
• return → next, break and return leave a block differently — next v ends this run of the block with v as its value, break v ends the method the block was given to and…
• return → return a, b returns one Array — Ruby has no tuple: return a, b builds an Array, multiple assignment takes it apart, and a count mismatch silently…
• return a, b returns one Array — Ruby has no tuple: return a, b builds an Array, multiple assignment takes it apart, and a count mismatch silently…
• rounding → 0.1 + 0.2 != 0.3, and 2.5.round is 3 — A Ruby Float is the same 64-bit double as a Python float
• ruby → There is more than one way, and one obvious way — Ruby's idioms
• ruby → Twenty-three Python traps for a Ruby programmer — The twenty-three places where a Ruby reflex gives the wrong answer in Python
• ruby → What changed, 1.9 to 4.0 — Ruby's releases each added a few things you will meet in old code and new
• Ruby has block comments and a data section — Ruby comments with #, with =begin/=end blocks that must start at column 0, and with magic comments the parser…
• Ruby has four kinds of equality — equal? is identity, == is value, eql? is value without type conversion (the test Hash keys use), and ===…
• Ruby has no docstrings — A Ruby method carries no documentation at run time
• Ruby shows you its bytecode and its syntax tree — RubyVM::InstructionSequence.compile(src).disasm lists the YARV instructions the interpreter will execute and…
• ruby versions what changed → What changed, 1.9 to 4.0 — Ruby's releases each added a few things you will meet in old code and new
• run → Enumerator#next runs the block on its own Fiber — each, to_a, map and first run an Enumerator's block where they are called, on the calling fiber; next…
• running → system returns true, false or nil — system returns true for exit 0, false for any other status and nil when the command could not be started;…
• running other programs → system returns true, false or nil — system returns true for exit 0, false for any other status and nil when the command could not be started;…
• runtime → Class.new makes a class; a constant names it — Class.new(Base) { ... } returns a class object with no name, Foo = klass gives it the name of the first constant…

S

• safe → &. skips the call when the receiver is nil — receiver&.method(args) returns nil without calling anything
• safe navigation → &. skips the call when the receiver is nil — receiver&.method(args) returns nil without calling anything
• scope → Constants are found lexically, then through ancestors — A bare constant name is resolved by the lexical nesting the code was written in (Module.nesting), then through the…
• scope → for loops do not make a scope — for and while are syntax and open no scope
• see → Ruby shows you its bytecode and its syntax tree — RubyVM::InstructionSequence.compile(src).disasm lists the YARV instructions the interpreter will execute and…
• seed → Random.new(42) gives the same numbers every run — A seeded Random is a function of its seed
• self → self is the implicit receiver — Every Ruby call has a receiver, and when you write none it is self
• self is implicit → self is the implicit receiver — Every Ruby call has a receiver, and when you write none it is self
• self is the implicit receiver — Every Ruby call has a receiver, and when you write none it is self
• send → send reaches private methods; public_send does not — obj.send(:name, *args) calls a method by name and ignores visibility, public_send honours it, and __send__…
• send and public send → send reaches private methods; public_send does not — obj.send(:name, *args) calls a method by name and ignores visibility, public_send honours it, and __send__…
• send reaches private methods; public_send does not — obj.send(:name, *args) calls a method by name and ignores visibility, public_send honours it, and __send__…
• set → Set is a core class in 4.0 and keeps insertion order — In Ruby 4.0 Set needs no require and is written in C, Set[3, 1, 2] iterates as 3, 1, 2, and an element is…
• set is a core class → Set is a core class in 4.0 and keeps insertion order — In Ruby 4.0 Set needs no require and is written in C, Set[3, 1, 2] iterates as 3, 1, 2, and an element is…
• Set is a core class in 4.0 and keeps insertion order — In Ruby 4.0 Set needs no require and is written in C, Set[3, 1, 2] iterates as 3, 1, 2, and an element is…
• setters → A setter returns its argument, not its body — obj.x = 5 is a call to the method x=, but as an expression it evaluates to 5 whatever the method body returns
• setters return the argument → A setter returns its argument, not its body — obj.x = 5 is a call to the method x=, but as an expression it evaluates to 5 whatever the method body returns
• share → Ractors share nothing that is not frozen — A Ractor runs a block on a thread with a lock of its own, so two Ractors run Ruby code at the same time
• shared → Class variables are shared with subclasses — @@count is one variable, owned by the class that first assigns it and seen by every subclass and every instance
• singleton → Every object has a class of its own — A method defined on one object
• singleton classes → Every object has a class of its own — A method defined on one object
• sized → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• sized queue → A SizedQueue that refuses is the 503 behind "queue full" — Passenger answers a Rails app's requests from a fixed pool of processes, 6 by default, through a request queue with a…
• sort → sort_by keys once, sort many times, neither is stable — sort_by computes each element's key exactly once and sort { |a, b| … } recomputes at every comparison, but Ruby…
• sort stability and sort by → sort_by keys once, sort many times, neither is stable — sort_by computes each element's key exactly once and sort { |a, b| … } recomputes at every comparison, but Ruby…
• sort_by keys once, sort many times, neither is stable — sort_by computes each element's key exactly once and sort { |a, b| … } recomputes at every comparison, but Ruby…
• space → The GC answers comparisons, not counts — GC.start, GC.stat, ObjectSpace and WeakRef let a program watch its own heap, but only comparisons are stable
• spaceship → Define <=> and Comparable gives you the rest — <=> answers -1, 0, 1 or nil ("these do not compare"); include Comparable turns that one method into <,…
• splat → Arguments: positional, keyword, splat and block — A Ruby parameter list has eight kinds of slot
• stability → sort_by keys once, sort many times, neither is stable — sort_by computes each element's key exactly once and sort { |a, b| … } recomputes at every comparison, but Ruby…
• standard → A bare rescue catches StandardError, not everything — rescue with no class list means rescue StandardError, and SystemExit, Interrupt, NoMemoryError,…
• standard error is the default → A bare rescue catches StandardError, not everything — rescue with no class list means rescue StandardError, and SystemExit, Interrupt, NoMemoryError,…
• state → dup is a fresh copy, clone is a faithful one — dup and clone both make a new object with the same instance variables, and both are shallow
• status → ARGV holds strings and ENV is not a Hash — ARGV is an Array of Strings, $0 is the script name as it was invoked, ENV is a Hash-like object whose values…
• stdin → gets returns nil at EOF, and reads ARGV's files first — gets returns the next line with its newline and nil at end of input
• stdin gets and argf → gets returns nil at EOF, and reads ARGV's files first — gets returns the next line with its newline and nil at end of input
• string → A string key and a symbol key are two keys — {"a" => 1}[:a] is nil because "a" and :a are different objects of different classes, JSON.parse always…
• string → #{} calls to_s; format is printf — "#{expr}" evaluates any expression and calls to_s on the result
• string and symbol keys → A string key and a symbol key are two keys — {"a" => 1}[:a] is nil because "a" and :a are different objects of different classes, JSON.parse always…
• string formatting and interpolation → #{} calls to_s; format is printf — "#{expr}" evaluates any expression and calls to_s on the result
• strings → Strings are mutable; << keeps the object — A Ruby String is a mutable object
• strings are mutable → Strings are mutable; << keeps the object — A Ruby String is a mutable object
• Strings are mutable; << keeps the object — A Ruby String is a mutable object
• struct → Struct is mutable, Data is not — Struct.new(:x, :y) makes a record you can build positionally or by keyword and then change; `Data.define(:lat,…
• struct and data → Struct is mutable, Data is not — Struct.new(:x, :y) makes a record you can build positionally or by keyword and then change; `Data.define(:lat,…
• Struct is mutable, Data is not — Struct.new(:x, :y) makes a record you can build positionally or by keyword and then change; `Data.define(:lat,…
• style → Indentation is convention in Ruby, syntax in Python — Ruby runs mis-indented code and ruby -w only warns when an end sits under the wrong column, while Python refuses…
• style and naming → Indentation is convention in Ruby, syntax in Python — Ruby runs mis-indented code and ruby -w only warns when an end sits under the wrong column, while Python refuses…
• super → Method lookup walks ancestors; super continues it — A call searches the receiver's ancestors from left to right and stops at the first class or module that defines…
• symbol → A string key and a symbol key are two keys — {"a" => 1}[:a] is nil because "a" and :a are different objects of different classes, JSON.parse always…
• symbol → &:sym calls Symbol#to_proc — &x in an argument list calls x.to_proc and attaches the result as the block; a symbol's to_proc is a lambda…
• symbol to proc → &:sym calls Symbol#to_proc — &x in an argument list calls x.to_proc and attaches the result as the block; a symbol's to_proc is a lambda…
• symbols → A symbol is a name, not a string — A Ruby symbol is an immutable name of which exactly one object exists per spelling
• symbols are names → A symbol is a name, not a string — A Ruby symbol is an immutable name of which exactly one object exists per spelling
• system → exit raises SystemExit — exit is not a system call but a raise of SystemExit, so ensure clauses and at_exit handlers run, a `rescue…
• system returns true, false or nil — system returns true for exit 0, false for any other status and nil when the command could not be started;…

T

• tap → tap returns the receiver, then returns the block's value — x.tap { … } yields x to the block and returns x whatever the block returned, so a debugging puts can sit…
• tap then and chaining → tap returns the receiver, then returns the block's value — x.tap { … } yields x to the block and returns x whatever the block returned, so a debugging puts can sit…
• tap returns the receiver, then returns the block's value — x.tap { … } yields x to the block and returns x whatever the block returned, so a debugging puts can sit…
• text → Text lives in the Ruby text library — a Ruby String is bytes plus an encoding label
• Text lives in the Ruby text library — a Ruby String is bytes plus an encoding label
• text lives in the text library → Text lives in the Ruby text library — a Ruby String is bytes plus an encoding label
• the bytecode you can see → Ruby shows you its bytecode and its syntax tree — RubyVM::InstructionSequence.compile(src).disasm lists the YARV instructions the interpreter will execute and…
• the command line flags → The command line is part of the language — ruby takes flags for running code (-e), checking it (-c), warning about it (-w, -W:category), loading…
• The command line is part of the language — ruby takes flags for running code (-e), checking it (-c), warning about it (-w, -W:category), loading…
• the enumerable toolbox → Most loops you would write are one Enumerable call — map, select, reject, find, partition, group_by, tally, each_slice, each_cons, zip, flat_map,…
• The GC answers comparisons, not counts — GC.start, GC.stat, ObjectSpace and WeakRef let a program watch its own heap, but only comparisons are stable
• The last expression is the return value — A Ruby method returns the value of the last expression it evaluated, so return is only for leaving early
• the last expression is the value → The last expression is the return value — A Ruby method returns the value of the last expression it evaluated, so return is only for leaving early
• the ruby way and the pythonic way → There is more than one way, and one obvious way — Ruby's idioms
• There is more than one way, and one obvious way — Ruby's idioms
• thread → Thread.current[:x] is fiber-local, not thread-local — Thread.current[:x] is scoped to the fiber that set it
• thread locals are fiber locals → Thread.current[:x] is fiber-local, not thread-local — Thread.current[:x] is scoped to the fiber that set it
• Thread.current[:x] is fiber-local, not thread-local — Thread.current[:x] is scoped to the fiber that set it
• threads → Threads are OS threads that take turns under the GVL — Thread.new { } starts a real OS thread that shares every object with the others; join waits and re-raises…
• threads → Timeout.timeout interrupts a thread from outside — Timeout.timeout(0.2) { sleep 5 } raises Timeout::Error after a fifth of a second because a watcher thread calls…
• threads and the gvl → Threads are OS threads that take turns under the GVL — Thread.new { } starts a real OS thread that shares every object with the others; join waits and re-raises…
• Threads are OS threads that take turns under the GVL — Thread.new { } starts a real OS thread that shares every object with the others; join waits and re-raises…
• threequals → case/when asks ===, and every class answers it its own way — case x when y calls y === x, and === is an ordinary method: a class answers with is_a?, a Range with…
• throw → throw and catch are not exceptions — catch(:tag) { … throw :tag, value … } is a labelled non-local jump: throw unwinds to the matching catch, which…
• throw and catch → throw and catch are not exceptions — catch(:tag) { … throw :tag, value … } is a labelled non-local jump: throw unwinds to the matching catch, which…
• throw and catch are not exceptions — catch(:tag) { … throw :tag, value … } is a labelled non-local jump: throw unwinds to the matching catch, which…
• time → Time is an instant, Date is a calendar day — a Time is a point on the timeline with an offset attached
• time and date → Time is an instant, Date is a calendar day — a Time is a point on the timeline with an offset attached
• Time is an instant, Date is a calendar day — a Time is a point on the timeline with an offset attached
• Timeout.timeout interrupts a thread from outside — Timeout.timeout(0.2) { sleep 5 } raises Timeout::Error after a fifth of a second because a watcher thread calls…
• timeouts → Timeout.timeout interrupts a thread from outside — Timeout.timeout(0.2) { sleep 5 } raises Timeout::Error after a fifth of a second because a watcher thread calls…
• timeouts and killing threads → Timeout.timeout interrupts a thread from outside — Timeout.timeout(0.2) { sleep 5 } raises Timeout::Error after a fifth of a second because a watcher thread calls…
• to s inspect and p → puts calls to_s, p calls inspect — Every object answers two questions
• toolbox → Most loops you would write are one Enumerable call — map, select, reject, find, partition, group_by, tally, each_slice, each_cons, zip, flat_map,…
• tracepoint → TracePoint sees every call and return — TracePoint.new(:call, :return) { |tp| … }.enable { … } reports every method the VM enters and leaves
• TracePoint sees every call and return — TracePoint.new(:call, :return) { |tp| … }.enable { … } reports every method the VM enters and leaves
• truthiness → Only nil and false are falsy — Ruby has exactly two falsy values, nil and false; 0, 0.0, "", [] and {} are all truthy and no class…
• Twenty-three Python traps for a Ruby programmer — The twenty-three places where a Ruby reflex gives the wrong answer in Python
• Twenty-three Ruby traps for a Python programmer — The twenty-three places where a Python reflex gives the wrong answer in Ruby
• Two dots include the end, three dots exclude it — 1..5 is five numbers and 1...5 is four; a Range can be endless (1..), beginless (..5), made of Strings…
• typing → Duck typing asks respond_to?, not class — Ruby code asks an object what it can do

U

• unbound → A method is a value once you ask for it — obj.method(:name) hands back a Method bound to obj, and Klass.instance_method(:name) an UnboundMethod you…
• unbounded → Integers never overflow: 2 ** 200 is just an Integer — Ruby has one Integer class with no ceiling
• unittest → A Minitest test is a plain class — Minitest, a bundled gem, runs every test_* method of a Minitest::Test subclass in a seeded random order and…
• unless → unless negates if; modifiers hang off the end of a line — Ruby spells if not as unless and while not as until, lets any statement carry if, unless, while or…
• unless until and modifiers → unless negates if; modifiers hang off the end of a line — Ruby spells if not as unless and while not as until, lets any statement carry if, unless, while or…
• unless negates if; modifiers hang off the end of a line — Ruby spells if not as unless and while not as until, lets any statement carry if, unless, while or…
• until → unless negates if; modifiers hang off the end of a line — Ruby spells if not as unless and while not as until, lets any statement carry if, unless, while or…
• uses → case/when asks ===, and every class answers it its own way — case x when y calls y === x, and === is an ordinary method: a class answers with is_a?, a Range with…

V

• value → The last expression is the return value — A Ruby method returns the value of the last expression it evaluated, so return is only for leaving early
• values → A missing key is nil, and Hash.new([]) shares its default — h[:zz] is nil where d["zz"] raises KeyError; fetch is the raising form; Hash.new(0) returns a default…
• values → return a, b returns one Array — Ruby has no tuple: return a, b builds an Array, multiple assignment takes it apart, and a count mismatch silently…
• variable → Mutex guards, Queue hands over, ConditionVariable waits — Mutex#synchronize makes count += 1 exact across ten threads, a Queue moves work from one thread to another and…
• variables → A variable is a reference, not a box — Assignment copies a reference, never the object, so after b = a a mutating method such as << on b is seen…
• variables → Class variables are shared with subclasses — @@count is one variable, owned by the class that first assigns it and seen by every subclass and every instance
• variables → Closures capture variables, not values — A block, proc or lambda carries the variables around it
• variables → Instance variables are private — An @variable belongs to one object and can be read or written only by that object's own methods
• variables are references → A variable is a reference, not a box — Assignment copies a reference, never the object, so after b = a a mutating method such as << on b is seen…
• versions → What changed, 1.9 to 4.0 — Ruby's releases each added a few things you will meet in old code and new

W

• wait → fork copies the process; wait collects its status — fork makes a second process that is a copy of this one
• warnings → Warnings go to stderr, and -w finds more of them — warn prints to stderr; -w sets $VERBOSE to true and makes Ruby report unused variables, redefined methods,…
• warnings and dash w → Warnings go to stderr, and -w finds more of them — warn prints to stderr; -w sets $VERBOSE to true and makes Ruby report unused variables, redefined methods,…
• Warnings go to stderr, and -w finds more of them — warn prints to stderr; -w sets $VERBOSE to true and makes Ruby report unused variables, redefined methods,…
• What changed, 1.9 to 4.0 — Ruby's releases each added a few things you will meet in old code and new
• writing → An iterator is a method that yields — A class earns the whole Enumerable toolbox by writing one each that yields and including the module; `return…
• writing an iterator → An iterator is a method that yields — A class earns the whole Enumerable toolbox by writing one each that yields and including the module; `return…

X

• x ||= v assigns when x is nil or false — x ||= v is x || (x = v): it assigns when x is nil or false and leaves every other value alone, so it…

Y

• yaml → JSON.parse gives string keys; YAML.load is safe — JSON is text for everyone and loses what JSON cannot say
• YJIT and ZJIT are switches, not defaults — MRI (RUBY_ENGINE == "ruby") always runs YARV bytecode through its interpreter; YJIT (since 3.1) and ZJIT (new in…