Curriculum

The complete structure of Lumiruby materials. Each level follows a logical progression — from foundational concepts to architecture, performance, and production engineering. Every course below is described in a consistent module-by-module format to clearly demonstrate structure, depth, and progression.

🟥 Free Pathway ($0)
MODULE 1: Ruby as an Object-Oriented Language (Week 1)

├─ Lesson 1.1: Everything Is an Object — practical meaning
├─ Lesson 1.2: self in the top-level context
├─ Lesson 1.3: Integer, String, and Array as objects
└─ Exercise: Exploring Ruby’s object model

MODULE 2: Type System & Dynamic Nature (Week 2)

├─ Lesson 2.1: Duck typing in practice
├─ Lesson 2.2: nil vs false vs empty values
├─ Lesson 2.3: object_id and frozen objects
└─ Exercise: Understanding object behavior in memory

MODULE 3: Symbols vs Strings (Week 3)

├─ Lesson 3.1: Memory and performance differences
├─ Lesson 3.2: Symbols as hash keys
├─ Lesson 3.3: Practical optimization examples
└─ Exercise: Comparing real-world usage

MODULE 4: Blocks as Core Ruby Concept (Week 4)

├─ Lesson 4.1: yield and block passing
├─ Lesson 4.2: &block as an argument
├─ Lesson 4.3: Introduction to Proc and Lambda
└─ Exercise: Writing methods that accept blocks

🟥 Pulse Forge ($50)
MODULE 1: Deep Work with Collections

├─ Lesson 1.1: map, select, reject
├─ Lesson 1.2: reduce / inject
├─ Lesson 1.3: Method chaining patterns
└─ Exercise: Transforming arrays and hashes

MODULE 2: Blocks as a Flexibility Tool

├─ Lesson 2.1: yield vs explicit block
├─ Lesson 2.2: block_given?
├─ Lesson 2.3: Using &block in real examples
└─ Exercise: Enumerable scenarios

MODULE 3: Iterators and Enumerable

├─ Lesson 3.1: each vs each_with_index
├─ Lesson 3.2: each_slice and lazy enumeration
├─ Lesson 3.3: Creating custom iterators
└─ Exercise: Building a custom Enumerable

MODULE 4: Proc and Lambda

├─ Lesson 4.1: Proc.new vs lambda
├─ Lesson 4.2: Return behavior differences
├─ Lesson 4.3: Usage in sort_by, group_by
└─ Exercise: Passing functions as objects

MODULE 5: Range and Other Enumerable Classes

├─ Lesson 5.1: (1..100).step usage
├─ Lesson 5.2: Date ranges in practice
├─ Lesson 5.3: Ranges in iteration logic
└─ Exercise: Implementing range-based logic

MODULE 6: Code Cleanliness Practice

├─ Lesson 6.1: Refactoring spaghetti code
├─ Lesson 6.2: Writing DSL-like syntax with blocks
├─ Lesson 6.3: Improving readability with chaining
└─ Final Exercise: Complex refactoring task

🟥 Vertex Flow ($100)
MODULE 1: Modules as a Composition Tool

├─ Lesson 1.1: module vs class
├─ Lesson 1.2: include vs extend vs prepend
├─ Lesson 1.3: Module.nesting and constants
└─ Exercise: Creating a reusable functional module

MODULE 2: Mixins in Action

├─ Lesson 2.1: Functional module patterns
├─ Lesson 2.2: Name conflicts and super
├─ Lesson 2.3: Concern-style organization
└─ Exercise: Refactoring behavior into mixins

MODULE 3: Singleton Methods and Metaclass

├─ Lesson 3.1: class << self
├─ Lesson 3.2: def self.included(base)
├─ Lesson 3.3: Eigenclass basics
└─ Exercise: Adding behavior dynamically

MODULE 4: Metaprogramming Foundations

├─ Lesson 4.1: define_method
├─ Lesson 4.2: class_eval vs instance_eval
├─ Lesson 4.3: method_missing for DSLs
└─ Exercise: Building a simple DSL

MODULE 5: Refinements and Safe Modifications

├─ Lesson 5.1: Using Refinement
├─ Lesson 5.2: Local method overrides
├─ Lesson 5.3: Avoiding global side effects
└─ Exercise: Controlled behavior modification

MODULE 6: Organizing Large Projects

├─ Lesson 6.1: Namespace modules
├─ Lesson 6.2: Autoloading basics
├─ Lesson 6.3: Avoiding “god objects”
└─ Exercise: Modular project structure

MODULE 7: Practical Architecture

├─ Lesson 7.1: Designing small frameworks
├─ Lesson 7.2: Validator/router example
├─ Lesson 7.3: Composition over inheritance
└─ Final Project: Build a micro-framework

🟥 Quantum Slate ($170)
MODULE 1: Ruby Internals

├─ Lesson 1.1: Garbage Collector basics
├─ Lesson 1.2: Object allocation & shapes
├─ Lesson 1.3: Frozen strings and memory models
└─ Exercise: Memory allocation analysis

MODULE 2: Performance Profiling Tools

├─ Lesson 2.1: rbspy, ruby-prof, stackprof
├─ Lesson 2.2: Reading flame graphs
├─ Lesson 2.3: Identifying hot spots
└─ Exercise: Profiling a slow script

MODULE 3: Concurrency Basics

├─ Lesson 3.1: Threads vs Processes vs Fibers
├─ Lesson 3.2: GVL reality
├─ Lesson 3.3: concurrent-ruby gem basics
└─ Exercise: Implementing concurrent tasks

MODULE 4: Collection & Algorithm Optimization

├─ Lesson 4.1: Array vs Hash vs Set
├─ Lesson 4.2: Custom hashing strategies
├─ Lesson 4.3: When to consider C-extensions
└─ Exercise: Benchmark comparisons

MODULE 5: Gems Ecosystem Optimization

├─ Lesson 5.1: Dependency analysis
├─ Lesson 5.2: Avoiding heavy side-effect gems
├─ Lesson 5.3: Bundle cleanup strategies
└─ Exercise: Optimizing a Gemfile

MODULE 6: Real-World Speed Patterns

├─ Lesson 6.1: Memoization patterns
├─ Lesson 6.2: Lazy loading
├─ Lesson 6.3: Batch processing
└─ Exercise: Refactoring for efficiency

MODULE 7: Debugging Performance Issues

├─ Lesson 7.1: Memory leak symptoms
├─ Lesson 7.2: Heap dump usage
├─ Lesson 7.3: Performance diagnostics workflow
└─ Exercise: Investigating a leak scenario

MODULE 8: Practical Optimization Cases

├─ Lesson 8.1: Speeding up API endpoints
├─ Lesson 8.2: Refactoring slow scripts
├─ Lesson 8.3: Working with large datasets
└─ Final Project: Performance refactoring case

🟥 Zenith Pathway ($190)
MODULE 1: Clean Code & SOLID in Ruby

├─ Lesson 1.1: Single Responsibility Principle
├─ Lesson 1.2: Open–Closed & Liskov in dynamic language
├─ Lesson 1.3: Identifying code smells
└─ Exercise: Refactoring for clarity

MODULE 2: Domain-Driven Design Basics

├─ Lesson 2.1: Ubiquitous Language
├─ Lesson 2.2: Entities & Value Objects
├─ Lesson 2.3: Repository pattern in Ruby
└─ Exercise: Modeling a domain

MODULE 3: Clean / Hexagonal Architecture

├─ Lesson 3.1: Layer separation
├─ Lesson 3.2: Dependency inversion
├─ Lesson 3.3: Folder structure organization
└─ Exercise: Architectural restructuring

MODULE 4: Design Patterns in Ruby Style

├─ Lesson 4.1: Strategy & Factory
├─ Lesson 4.2: Builder & Decorator
├─ Lesson 4.3: Observer with blocks
└─ Exercise: Pattern adaptation

MODULE 5: Test-Driven Development Practice

├─ Lesson 5.1: RSpec advanced features
├─ Lesson 5.2: Outside-in TDD
├─ Lesson 5.3: Testing edge cases
└─ Exercise: TDD workflow practice

MODULE 6: Event Sourcing & CQRS

├─ Lesson 6.1: Event modeling
├─ Lesson 6.2: Command/query separation
├─ Lesson 6.3: Simple implementation example
└─ Exercise: Building an event-driven module

MODULE 7: Refactoring to Clean Structure

├─ Lesson 7.1: Breaking monolithic classes
├─ Lesson 7.2: Service objects & interactors
├─ Lesson 7.3: Result objects
└─ Exercise: Structural refactoring

MODULE 8: Scalable Ruby Without Rails

├─ Lesson 8.1: Microservice-friendly design
├─ Lesson 8.2: Message bus basics
├─ Lesson 8.3: Background job patterns
└─ Exercise: Designing a scalable component

MODULE 9: Final Architecture Project

├─ Lesson 9.1: Domain module planning
├─ Lesson 9.2: Implementation with tests
├─ Lesson 9.3: Structure validation
└─ Final Project: Complete domain module build

🟥 Nexus Pathway ($210)
MODULE 1: Advanced Tooling & Environment Management

├─ Lesson 1.1: rbenv vs rvm vs asdf
├─ Lesson 1.2: Managing multiple Ruby versions
├─ Lesson 1.3: Bundler groups and gemsets
└─ Exercise: Environment configuration

MODULE 2: Deployment Patterns

├─ Lesson 2.1: Capistrano vs container deploy
├─ Lesson 2.2: Zero-downtime deployment
├─ Lesson 2.3: Blue-green basics
└─ Exercise: Deployment simulation

MODULE 3: Containerization & Orchestration

├─ Lesson 3.1: Dockerfile best practices
├─ Lesson 3.2: Multi-stage builds
├─ Lesson 3.3: Kubernetes basics
└─ Exercise: Container setup

MODULE 4: Observability Stack

├─ Lesson 4.1: Metrics with Prometheus
├─ Lesson 4.2: Logging strategies
├─ Lesson 4.3: Error tracking integration
└─ Exercise: Monitoring configuration

MODULE 5: Security in Ruby Applications

├─ Lesson 5.1: Static analysis tools
├─ Lesson 5.2: OWASP basics
├─ Lesson 5.3: Secrets management
└─ Exercise: Security audit checklist

MODULE 6: CI/CD Pipelines

├─ Lesson 6.1: GitHub Actions setup
├─ Lesson 6.2: Parallel testing
├─ Lesson 6.3: Automated deployment
└─ Exercise: Pipeline configuration

MODULE 7: Legacy Code Handling

├─ Lesson 7.1: Strangler pattern strategy
├─ Lesson 7.2: Characterization testing
├─ Lesson 7.3: Gradual refactoring approach
└─ Exercise: Legacy migration plan

MODULE 8: Scaling & Resilience Patterns

├─ Lesson 8.1: Circuit breaker pattern
├─ Lesson 8.2: Retry and rate limiting
├─ Lesson 8.3: Database pooling tuning
└─ Exercise: Resilience simulation

MODULE 9: Final Production Setup

├─ Lesson 9.1: Full Docker configuration
├─ Lesson 9.2: CI integration
├─ Lesson 9.3: Monitoring & secure config
└─ Final Project: Production-ready deployment

🟥 Prime Pathway ($500)
MODULE 1: Ruby Implementations Deep Dive

├─ Lesson 1.1: MRI vs YJIT vs MJIT
├─ Lesson 1.2: TruffleRuby & JRuby
├─ Lesson 1.3: Tuning YJIT
└─ Exercise: Benchmark comparison

MODULE 2: Ractors & Parallelism

├─ Lesson 2.1: Ractor.new basics
├─ Lesson 2.2: Shareable objects
├─ Lesson 2.3: Parallel patterns
└─ Exercise: Parallel computation example

MODULE 3: Advanced Concurrency Models

├─ Lesson 3.1: Actor model
├─ Lesson 3.2: Fiber-based async
├─ Lesson 3.3: Comparing concurrency paradigms
└─ Exercise: Async implementation

MODULE 4: JIT & AOT Optimization

├─ Lesson 4.1: Reading JIT logs
├─ Lesson 4.2: Warmup strategies
├─ Lesson 4.3: Experimenting with tuning
└─ Exercise: Performance measurement

MODULE 5: Writing C-Extensions

├─ Lesson 5.1: rb_define_method basics
├─ Lesson 5.2: Memory management
├─ Lesson 5.3: Rust extensions with Magnus
└─ Exercise: Simple C-extension

MODULE 6: Enterprise Ruby Patterns

├─ Lesson 6.1: Monorepo vs multi-repo
├─ Lesson 6.2: Feature flags
├─ Lesson 6.3: Gradual typing tools
└─ Exercise: Structural comparison

MODULE 7: Extreme Performance Tuning

├─ Lesson 7.1: Object shapes optimization
├─ Lesson 7.2: String interning
├─ Lesson 7.3: GC parameter tuning
└─ Exercise: Extreme benchmark case

MODULE 8: Migration & Modernization Strategies

├─ Lesson 8.1: Ruby version upgrades
├─ Lesson 8.2: Framework transitions
├─ Lesson 8.3: Modular monolith approach
└─ Exercise: Upgrade roadmap

MODULE 9: Research & Future-Proofing

├─ Lesson 9.1: Experimental Ruby features
├─ Lesson 9.2: Following Ruby core
├─ Lesson 9.3: Contribution basics
└─ Exercise: Proposal analysis

MODULE 10: Final Capstone Project

├─ Lesson 10.1: High-performance architecture design
├─ Lesson 10.2: Parallel + JIT integration
├─ Lesson 10.3: Observability and deploy pipeline
└─ Final Project: High-load Ruby service build