AboutTeamsPricing
New content added weeklyLive

Master Ruby with Adaptive AI.

Master Ruby across 25 topics - Foundations, OOP and Blocks, and Meta Programming and Advanced Ruby - guided by Leyaa's adaptive intelligence.

3Parts
25Topics
219Patterns
55hEst. duration
Start Learning Free
Ruby
Ruby Course
3 - part learning journey
Beginner
Foundations
9 topics · 80 patterns
Beginner
Intermediate
OOP and Blocks
8 topics · 74 patterns
Intermediate
Advanced
Meta Programming and Advanced Ruby
8 topics · 65 patterns
Advanced
Begin Part 1: Foundations
✦ Course Structure

Your Ruby Journey in 3 Parts

Each part builds on the last - a deliberate progression from beginner to advanced.

Beginner
Beginner
Part 1: Foundations
Covers Ruby Basics and Runtime, Variables and Data Types, String Operations and 6 more topics.
9Topics
80Patterns
View topics
Intermediate
Intermediate
Part 2: OOP and Blocks
Covers Blocks, Procs, and Lambdas, Enumerable and Collection Processing, Classes and Objects and 5 more topics.
8Topics
74Patterns
View topics
Advanced
Advanced
Part 3: Meta Programming and Advanced Ruby
Covers Metaprogramming Fundamentals, Advanced Metaprogramming, Regular Expressions and 5 more topics.
8Topics
65Patterns
View topics
Curriculum

Everything You'll Learn

Explore every topic and pattern in the course.

Ruby

3 parts · 25 topics · 219 patterns
Beginner
Part 1: Foundations9 topics · 80 patterns
Beginner
01
Ruby Basics and Runtime
8 patterns
What is Ruby
Why Ruby emphasizes developer happiness
How Ruby interprets code at runtime
IRB for interactive exploration
Running scripts with ruby command
Puts, print, and p output differences
Comments and documentation
Everything is an object mental model
02
Variables and Data Types
10 patterns
Why dynamic typing matters in Ruby
Local variables and naming conventions
Integer and Float number types
String creation (single and double quotes)
String interpolation with #{}
Symbol type and immutability
Boolean values (true, false, nil)
Nil as the absence of value
Type checking with .class and .is_a?
Dynamic typing vs strong typing
03
String Operations
8 patterns
Why strings are mutable in Ruby
String concatenation and <<
String methods (upcase, downcase, strip)
String slicing and indexing
Gsub and sub for replacement
Split and join methods
String freezing for immutability
Heredoc syntax for multiline strings
04
Operators and Expressions
9 patterns
Why operators are methods in Ruby
Arithmetic operators
Comparison operators
Spaceship operator (<=>)
Logical operators (&&, ||, !)
Ternary operator
Range operators (.. and ...)
Conditional assignment (||=)
Truthy and falsy values (only nil and false are falsy)
05
Control Flow
8 patterns
Why Ruby has multiple control flow styles
If, elsif, else statements
Unless for negated conditions
Case/when statement
Case with ranges and patterns
Inline if and unless (modifier form)
Ternary operator usage
Guard clauses pattern
06
Loops and Iteration
9 patterns
Why Ruby prefers iterators over loops
While loop
Until loop
For loop (rarely used in Ruby)
Loop method for infinite loops
Times method for counted repetition
Upto and downto methods
Break, next, and redo behavior
Each as the primary iterator
07
Methods
10 patterns
Why methods always return a value in Ruby
Method declaration with def
Implicit return (last expression)
Explicit return statement
Parameters with default values
Variable-length arguments (*args)
Keyword arguments
Method naming conventions (? and ! suffixes)
Predicate methods (ending with ?)
Bang methods (ending with !)
08
Arrays
9 patterns
Why arrays are fundamental in Ruby
Array creation methods
Accessing elements (indexing, first, last)
Array modification (push, pop, shift, unshift)
Array slicing and ranges
Array methods (length, include?, flatten)
Array sorting and reversing
Array comparison and set operations
Compact for removing nil values
09
Hashes
9 patterns
Why hashes are used everywhere in Ruby
Hash creation with symbols and strings
Accessing and setting values
Hash methods (keys, values, each)
Default values for missing keys
Merge and update methods
Hash as named parameters pattern
Symbol keys vs string keys decision
Dig method for nested access
Intermediate
Part 2: OOP and Blocks8 topics · 74 patterns
Intermediate
01
Blocks, Procs, and Lambdas
10 patterns
Why blocks are fundamental to Ruby
Block syntax (do..end and curly braces)
Yield to execute blocks
Block parameters
Block given? check
Proc creation and call
Lambda creation and behavior
Proc vs lambda differences (arity, return)
Method objects with method()
Closures and variable binding
02
Enumerable and Collection Processing
12 patterns
Why Enumerable is Ruby's most powerful module
Each for iteration
Map/collect for transformation
Select/filter for filtering
Reject for inverse filtering
Reduce/inject for accumulation
Find/detect for first match
Any?, all?, none? predicates
Group_by for categorization
Sort_by for custom sorting
Flat_map for nested flattening
Zip for combining arrays
03
Classes and Objects
9 patterns
Why everything is an object in Ruby
Class declaration syntax
Initialize method as constructor
Instance variables (@)
Attr_reader, attr_writer, attr_accessor
Instance methods
Self keyword behavior
To_s method for string representation
Object identity (equal? vs ==)
04
Class Methods and Variables
8 patterns
Why class-level behavior matters
Class methods with self prefix
Class variables (@@) and their dangers
Class instance variables as alternative
Constants in classes
Open classes (reopening classes)
Frozen objects
Object#dup and Object#clone
05
Inheritance
8 patterns
Why single inheritance in Ruby
Subclass with < operator
Super keyword behavior
Method overriding
Method lookup chain
Accessing parent methods
Protected and private visibility
Is_a? and kind_of? for type checking
06
Modules and Mixins
9 patterns
Why modules solve multiple inheritance
Module declaration syntax
Include for instance methods
Extend for class methods
Prepend for method chain insertion
Namespacing with modules
Module methods
Comparable module usage
Custom modules as mixins
07
Error Handling
9 patterns
Why error handling uses rescue
Begin/rescue/end blocks
Multiple rescue clauses
Exception hierarchy
Ensure for cleanup
Retry for reattempting
Raise for throwing errors
Custom exception classes
Rescue modifier (inline form)
08
File IO
9 patterns
Why file handling matters
File.read for entire content
File.readlines for line-by-line
File.write for writing
File.open with block (auto-close)
IO modes (r, w, a)
CSV library basics
JSON library basics
Dir operations for directories
Advanced
Part 3: Meta Programming and Advanced Ruby8 topics · 65 patterns
Advanced
01
Metaprogramming Fundamentals
8 patterns
Why metaprogramming is powerful in Ruby
Define_method for dynamic methods
Method_missing for catch-all
Respond_to_missing? convention
Send for calling methods dynamically
Class.new for dynamic class creation
Instance_variable_get and set
Open struct for dynamic objects
02
Advanced Metaprogramming
8 patterns
Why hooks enable framework building
Included hook
Inherited hook
Method_added hook
Class_eval and instance_eval
Module_eval for dynamic behavior
Define_method with closures
DSL building patterns
03
Regular Expressions
9 patterns
Why regex is powerful in Ruby
Regex literal syntax (/pattern/)
Match operator (=~)
Match method and MatchData
Capture groups
Named captures
Gsub with regex
Scan for all matches
Common patterns and character classes
04
Concurrent Programming
8 patterns
Why concurrency matters in Ruby
Thread creation and execution
Thread synchronization with Mutex
Thread safety concepts
GIL (Global Interpreter Lock) impact
Fiber for cooperative concurrency
Ractor for true parallelism
Process forking for parallelism
05
Gems and Bundler
8 patterns
Why gem management matters
Gem installation with gem install
Gemfile for project dependencies
Bundler for dependency resolution
Bundle exec for isolated execution
Gem versions and constraints
Creating a gem basics
RubyGems repository
06
Testing with RSpec and Minitest
8 patterns
Why testing is central to Ruby culture
Minitest basics (assert style)
RSpec describe and it blocks
RSpec expectations and matchers
Let and before hooks
Mocking and stubbing
Test doubles concept
Test-driven development workflow
07
Functional Patterns in Ruby
8 patterns
Why functional patterns complement OOP
Immutable data with freeze
Pure functions concept
Method chaining patterns
Curry and partial application
Lazy enumerators
Proc composition
Pipeline operator concept
08
Ruby Ecosystem and Best Practices
8 patterns
Why conventions matter in Ruby
Ruby style guide essentials
Rubocop for linting
YARD for documentation
Debugging with pry and byebug
IRB customization
Performance profiling basics
Ruby version management (rbenv, rvm)
Why Leyaa

Not just a course. A learning intelligence.

Leyaa doesn't just deliver content - it understands where you are, what you need, and how to get you there fastest.

Adaptive Diagnostics
Adaptive Diagnostics
Leyaa identifies which of the 219 patterns you've mastered and which need work - before you waste time on what you already know.
Pattern-Level Precision
Pattern-Level Precision
Every pattern gets a verdict - Learn, Practice, or Skip - so your study time goes exactly where it counts.
Intelligent Pacing
Intelligent Pacing
Leyaa reads your velocity across the whole course and adapts your focus list dynamically, keeping you in the optimal learning zone.
Before & After Visibility
Before & After Visibility
Every assessment creates a snapshot. Retake anytime to see exactly how much you've grown - topic by topic, pattern by pattern.
Learner Autonomy
Learner Autonomy
Leyaa recommends, never restricts. Override any suggestion and explore at your own pace - the system tracks everything regardless.
Clear Learning Path
Clear Learning Path
Foundations → OOP and Blocks → Meta Programming and Advanced Ruby - a structured journey where each part sets you up perfectly for the next.
Ruby

Ready to master Ruby?
Start your journey today

Start your diagnostic now. Build mastery across all 25 topics in under 15 minutes.

25 Topics
219 Patterns
Personalized roadmap
Leyaa Swift Bird