Ruby — Learning Library

Ruby — a learning library
Start Here
Start Here
Objects and Values
Objects and Values
- Everything is an object, even 1 and nil
  Everything is an object, even 1 and nil
- Only nil and false are falsy
  Only nil and false are falsy
- A symbol is a name, not a string
  A symbol is a name, not a string
- Ruby has four kinds of equality
  Ruby has four kinds of equality
- A variable is a reference, not a box
  A variable is a reference, not a box
- freeze is shallow and raises FrozenError
  freeze is shallow and raises FrozenError
- Strings are mutable; << keeps the object
  Strings are mutable; << keeps the object
- Duck typing asks respond_to?, not class
  Duck typing asks respond_to?, not class
Methods and Arguments
Methods and Arguments
- Parentheses are optional, but the space is not
  Parentheses are optional, but the space is not
- The last expression is the return value
  The last expression is the return value
- Arguments: positional, keyword, splat and block
  Arguments: positional, keyword, splat and block
- Default arguments are evaluated on every call
  Default arguments are evaluated on every call
- Bang means dangerous, question mark means predicate
  Bang means dangerous, question mark means predicate
- Operators are methods, except the ones that are not
  Operators are methods, except the ones that are not
- self is the implicit receiver
  self is the implicit receiver
- &. skips the call when the receiver is nil
  &. skips the call when the receiver is nil
- A setter returns its argument, not its body
  A setter returns its argument, not its body
Blocks Procs and Lambdas
Blocks Procs and Lambdas
- Blocks are not objects
  Blocks are not objects
- Procs and lambdas differ in arity and return
  Procs and lambdas differ in arity and return
- Closures capture variables, not values
  Closures capture variables, not values
- &:sym calls Symbol#to_proc
  &:sym calls Symbol#to_proc
- it and _1 name the block's parameter
  it and _1 name the block's parameter
- next, break and return leave a block differently
  next, break and return leave a block differently
- An iterator is a method that yields
  An iterator is a method that yields
- Procs curry and compose
  Procs curry and compose
Collections
Collections
- Past the end, an array gives nil, not an error
  Past the end, an array gives nil, not an error
- A missing key is nil, and Hash.new([]) shares its default
  A missing key is nil, and Hash.new([]) shares its default
- Two dots include the end, three dots exclude it
  Two dots include the end, three dots exclude it
- Set is a core class in 4.0 and keeps insertion order
  Set is a core class in 4.0 and keeps insertion order
- Assignment destructures, and blocks auto-splat
  Assignment destructures, and blocks auto-splat
- Struct is mutable, Data is not
  Struct is mutable, Data is not
- Define <=> and Comparable gives you the rest
  Define <=> and Comparable gives you the rest
Enumerable and Iteration
Enumerable and Iteration
- Enumerable is a mixin: write each, get the rest
  Enumerable is a mixin: write each, get the rest
- Most loops you would write are one Enumerable call
  Most loops you would write are one Enumerable call
- inject makes the block's value the next accumulator
  inject makes the block's value the next accumulator
- lazy runs the chain one element at a time
  lazy runs the chain one element at a time
- An Enumerator has a cursor: next, peek, rewind
  An Enumerator has a cursor: next, peek, rewind
- sort_by keys once, sort many times, neither is stable
  sort_by keys once, sort many times, neither is stable
Classes and Modules
Classes and Modules
- Instance variables are private
  Instance variables are private
- private means "no receiver"
  private means "no receiver"
- Classes are open
  Classes are open
- Mixins: include, extend, prepend
  Mixins: include, extend, prepend
- Method lookup walks ancestors; super continues it
  Method lookup walks ancestors; super continues it
- Constants are found lexically, then through ancestors
  Constants are found lexically, then through ancestors
- Class variables are shared with subclasses
  Class variables are shared with subclasses
- A module is a namespace, and cannot be instantiated
  A module is a namespace, and cannot be instantiated
The Object Model
The Object Model
- Every object has a class of its own
  Every object has a class of its own
- new is allocate then initialize
  new is allocate then initialize
- puts calls to_s, p calls inspect
  puts calls to_s, p calls inspect
- A Hash key needs eql? and hash, not ==
  A Hash key needs eql? and hash, not ==
- Refinements are lexical, not global
  Refinements are lexical, not global
- Object sits on Kernel on BasicObject
  Object sits on Kernel on BasicObject
- dup is a fresh copy, clone is a faithful one
  dup is a fresh copy, clone is a faithful one
Errors and Exceptions
Errors and Exceptions
- rescue, else and ensure run in a fixed order
  rescue, else and ensure run in a fixed order
- A bare rescue catches StandardError, not everything
  A bare rescue catches StandardError, not everything
- raise has four forms
  raise has four forms
- Custom exceptions subclass StandardError
  Custom exceptions subclass StandardError
- Exceptions have a cause
  Exceptions have a cause
- rescue works as a modifier, for StandardError only
  rescue works as a modifier, for StandardError only
- throw and catch are not exceptions
  throw and catch are not exceptions
- exit raises SystemExit
  exit raises SystemExit
- Warnings go to stderr, and -w finds more of them
  Warnings go to stderr, and -w finds more of them
- Common error messages
  Common error messages
Control Flow and Pattern Matching
Control Flow and Pattern Matching
- Everything is an expression, even def and class
  Everything is an expression, even def and class
- unless negates if; modifiers hang off the end of a line
  unless negates if; modifiers hang off the end of a line
- and/or bind lower than =
  and/or bind lower than =
- case/when asks ===, and every class answers it its own way
  case/when asks ===, and every class answers it its own way
- case/in matches shape, not just value
  case/in matches shape, not just value
- A pin compares; a bare name binds
  A pin compares; a bare name binds
- deconstruct and deconstruct_keys let any object be matched
  deconstruct and deconstruct_keys let any object be matched
- Nothing matched: case/in raises, case/when returns nil
  Nothing matched: case/in raises, case/when returns nil
- for loops do not make a scope
  for loops do not make a scope
Metaprogramming
Metaprogramming
- send reaches private methods; public_send does not
  send reaches private methods; public_send does not
- define_method turns a block into a method
  define_method turns a block into a method
- method_missing needs respond_to_missing?
  method_missing needs respond_to_missing?
- instance_eval moves self, class_eval moves def
  instance_eval moves self, class_eval moves def
- Hooks fire when code is defined, not when it runs
  Hooks fire when code is defined, not when it runs
- A DSL is instance_eval plus stored blocks
  A DSL is instance_eval plus stored blocks
- Class.new makes a class; a constant names it
  Class.new makes a class; a constant names it
- An object can list its methods and variables
  An object can list its methods and variables
Under the Hood
Under the Hood
- A method is a value once you ask for it
  A method is a value once you ask for it
- A Binding is a scope you can carry around
  A Binding is a scope you can carry around
- TracePoint sees every call and return
  TracePoint sees every call and return
- The GC answers comparisons, not counts
  The GC answers comparisons, not counts
- Ruby shows you its bytecode and its syntax tree
  Ruby shows you its bytecode and its syntax tree
- YJIT and ZJIT are switches, not defaults
  YJIT and ZJIT are switches, not defaults
Concurrency and Parallelism
Concurrency and Parallelism
- Threads are OS threads that take turns under the GVL
  Threads are OS threads that take turns under the GVL
- Mutex guards, Queue hands over, ConditionVariable waits
  Mutex guards, Queue hands over, ConditionVariable waits
- A Fiber is a coroutine you resume by hand
  A Fiber is a coroutine you resume by hand
- Enumerator#next runs the block on its own Fiber
  Enumerator#next runs the block on its own Fiber
- Thread.current[:x] is fiber-local, not thread-local
  Thread.current[:x] is fiber-local, not thread-local
- Ractors share nothing that is not frozen
  Ractors share nothing that is not frozen
- fork copies the process; wait collects its status
  fork copies the process; wait collects its status
- Timeout.timeout interrupts a thread from outside
  Timeout.timeout interrupts a thread from outside
- A SizedQueue that refuses is the 503 behind "queue full"
  A SizedQueue that refuses is the 503 behind "queue full"
Io Files and the System
Io Files and the System
- File.open with a block closes the file for you
  File.open with a block closes the file for you
- puts adds a newline, print does not, p shows inspect
  puts adds a newline, print does not, p shows inspect
- ARGV holds strings and ENV is not a Hash
  ARGV holds strings and ENV is not a Hash
- system returns true, false or nil
  system returns true, false or nil
- gets returns nil at EOF, and reads ARGV's files first
  gets returns nil at EOF, and reads ARGV's files first
- Pathname#/ joins, and Dir.glob is sorted
  Pathname#/ joins, and Dir.glob is sorted
- JSON.parse gives string keys; YAML.load is safe
  JSON.parse gives string keys; YAML.load is safe
- Time is an instant, Date is a calendar day
  Time is an instant, Date is a calendar day
- #{} calls to_s; format is printf
  #{} calls to_s; format is printf
- Text lives in the Ruby text library
  Text lives in the Ruby text library
Tooling Testing and Gems
Tooling Testing and Gems
- require loads once; load runs every time
  require loads once; load runs every time
- Gems are versioned; Bundler pins them
  Gems are versioned; Bundler pins them
- A Minitest test is a plain class
  A Minitest test is a plain class
- The command line is part of the language
  The command line is part of the language
- irb echoes every value; a script does not
  irb echoes every value; a script does not
- What changed, 1.9 to 4.0
  What changed, 1.9 to 4.0
- A backtrace is data you can read
  A backtrace is data you can read
- Ruby has no docstrings
  Ruby has no docstrings
Numbers
Numbers
- 7 / 2 is 3: integer division floors
  7 / 2 is 3: integer division floors
- Integers never overflow: 2 ** 200 is just an Integer
  Integers never overflow: 2 ** 200 is just an Integer
- 0.1 + 0.2 != 0.3, and 2.5.round is 3
  0.1 + 0.2 != 0.3, and 2.5.round is 3
- 1/3r and BigDecimal("0.1") are exact where Float is not
  1/3r and BigDecimal("0.1") are exact where Float is not
- 1 == 1.0 is true, but {1 => :a}[1.0] is nil
  1 == 1.0 is true, but {1 => :a}[1.0] is nil
- 1 + 1.5 works because Integer asks Float to coerce
  1 + 1.5 works because Integer asks Float to coerce
- Random.new(42) gives the same numbers every run
  Random.new(42) gives the same numbers every run
- Numbers become text with format, to_s(16) and %
  Numbers become text with format, to_s(16) and %
Idioms and Gotchas
Idioms and Gotchas
- There is more than one way, and one obvious way
  There is more than one way, and one obvious way
- x ||= v assigns when x is nil or false
  x ||= v assigns when x is nil or false
- tap returns the receiver, then returns the block's value
  tap returns the receiver, then returns the block's value
- return a, b returns one Array
  return a, b returns one Array
- A string key and a symbol key are two keys
  A string key and a symbol key are two keys
- Indentation is convention in Ruby, syntax in Python
  Indentation is convention in Ruby, syntax in Python
- Ruby has block comments and a data section
  Ruby has block comments and a data section
- Twenty-three Ruby traps for a Python programmer
  Twenty-three Ruby traps for a Python programmer
- Twenty-three Python traps for a Ruby programmer
  Twenty-three Python traps for a Ruby programmer
Resources
Resources
The crosswalk
Topics A–Z

14 — Tooling, testing and gems¶

One line: The machinery around a Ruby program — loading files, gems and Bundler, Minitest, the command line, irb, the release history, backtraces and the missing docstring — measured against Python's import, pip, unittest, python3 -i, traceback and __doc__.

A Python programmer arrives with a working model of all of this: import runs a module once and caches it in sys.modules; pip and a venv hold the packages a project needs and pyproject.toml declares them; unittest is a TestCase class with assert* methods; the >>> prompt echoes values; traceback and inspect read the stack; every function has a __doc__. Most of that model carries over with the names changed — require for import, $LOADED_FEATURES for sys.modules, gem/bundle for pip, Gemfile for the dependency list, Minitest::Test for TestCase, irb for the prompt, caller and backtrace for the stack.

Where it breaks is the interesting part. Ruby has three loading verbs to Python's one (require, require_relative, load) plus autoload; RubyGems can activate a gem version at run time, which import cannot; Minitest runs tests in a seeded random order and, as of Ruby 4.0's Minitest 6, no longer ships Minitest::Mock; the -I, -s and -S flags mean different things in the two interpreters; the Ruby prompt echoes assignments and defs because they are expressions; backtrace labels are Klass#method strings; and there is no docstring at all — a method knows only its source_location, and documentation is a comment convention that RDoc, YARD and ri read from the file.

Lesson	Level	The one thing
`require` loads once; `load` runs every time	201	`require` and `require_relative` share one once-list, `load` ignores it, `autoload` defers
Gems are versioned; Bundler pins them	201	default gems, bundled gems and core classes are three different things; `Gem::Version` compares as numbers
A Minitest test is a plain class	201	the seeded, shuffled run and its `runs, assertions, failures, errors, skips` line, next to `unittest`
The command line is part of the language	201	`-e -c -w -r -I -n -p -a -l -E --yjit --disable-gems --dump`, each run in a child and compared with `python3`'s letters
`irb` echoes every value; a script does not	101	the read–eval–print loop driven through a pipe, values only, beside `python3 -i` and `code.InteractiveConsole`
What changed, 1.9 to 4.0	201	a timeline table, and a program that checks which of its features this Ruby and this Python have
A backtrace is data you can read	201	`caller`, `caller_locations`, `backtrace`, `full_message` as labels, next to `traceback` and `inspect`
Ruby has no docstrings	101	`source_location` plus the comment above the `def`, read from the file, next to `__doc__` and `inspect.getcomments`

14 — Tooling, testing and gems¶

Read more¶