• nil: Represents "nothing" or "no value". Only nil object responds true to .nil?
• empty: A method that returns true for collections with no elements (arrays, hashes, strings)
• blank: Rails addition that returns true for nil, empty collections, and whitespace-only strings

nil.nil?        # true
"".empty?       # true
[].empty?       # true
" ".blank?      # true (Rails only)

Double quotes allow string interpolation and escape sequences, while single quotes treat most characters literally (except for \' and \\).

name = "Alice"
puts "Hello #{name}"   # "Hello Alice"
puts 'Hello #{name}'   # "Hello #{name}"
puts "Line\nBreak"     # Line with actual break
puts 'Line\nBreak'     # "Line\nBreak" literally

Symbols are immutable, reusable constants represented internally by an integer value. They're often used as hash keys, method names, or status identifiers because they're memory-efficient - the same symbol always references the same object in memory.

:status.object_id == :status.object_id  # true
"status".object_id == "status".object_id  # false
# Common usage
user = { name: "John", age: 30 }  # symbols as hash keys

• puts: Outputs value with newline, returns nil, calls .to_s
• print: Outputs value without newline, returns nil, calls .to_s
• p: Outputs inspected value with newline, returns the value, calls .inspect

puts "Hello"    # Hello\n (returns nil)
print "Hello"   # Hello (returns nil)
p "Hello"       # "Hello"\n (returns "Hello")

• public: Can be called from anywhere (default)
• protected: Can be called by instances of the same class or subclasses
• private: Can only be called within the same instance (no explicit receiver)

class MyClass
  def public_method; end
  
  protected
  def protected_method; end
  
  private
  def private_method; end
end

• each: Iterates through elements, returns original array, used for side effects
• map: Transforms elements, returns new array with transformed values

numbers = [1, 2, 3]
numbers.each { |n| n * 2 }  # Returns [1, 2, 3]
numbers.map { |n| n * 2 }   # Returns [2, 4, 6]

• merge: Returns a new hash with combined key-value pairs
• merge!: Modifies the original hash in place (destructive)

h1 = { a: 1, b: 2 }
h2 = { b: 3, c: 4 }
h1.merge(h2)   # Returns { a: 1, b: 3, c: 4 }, h1 unchanged
h1.merge!(h2)  # h1 is now { a: 1, b: 3, c: 4 }

• flatten: Removes nested array structure, creating a single-level array
• compact: Removes nil values from array

[[1, 2], [3, [4]]].flatten  # [1, 2, 3, 4]
[1, nil, 2, nil, 3].compact  # [1, 2, 3]

MVC separates application into three components:

• Model: Handles data and business logic (ActiveRecord)
• View: Presents data to users (ERB templates)
• Controller: Coordinates between Model and View, handles requests

The flow: Request → Router → Controller → Model → Controller → View → Response

• Classes/Modules: CamelCase (UserAccount)
• Methods/Variables: snake_case (user_name)
• Constants: SCREAMING_SNAKE_CASE (MAX_USERS)
• Predicates: end with ? (empty?)
• Dangerous methods: end with ! (save!)

• Gemfile: Specifies gem dependencies and sources
• Gemfile.lock: Locks specific versions for consistent environments

Both ensure all developers and deployment environments use identical gem versions.

The safe navigation operator (&.) calls methods only if the receiver is not nil, preventing NoMethodError on nil objects.

user&.profile&.name  # Returns nil if any part is nil
# Equivalent to:
user && user.profile && user.profile.name

# With arrays
users&.first&.name  # Safe even if users is nil