Ruby Roadmap

Open a topic for notes and resources. Mark it done when you are ready to move on.

29 stages · 114 topics 0% done
Ruby
✓ Open Classes & Monkey Patching
✓ method_missing & respond_to_missing?
✓ Foundations
✓ define_method & Dynamic Definition
✓ Class Evaluation (class_eval, instance_eval)
✓ Core Concepts
✓ Constant Lookup & Const_missing
✓ Hook Methods (inherited, included, extended)
✓ DSL Building with instance_eval & block context
✓ Binding & eval Context Manipulation
✓ Intermediate Skills
✓ Block, Proc, Lambda Differences
✓ Closures & Binding Capture
✓ Advanced Topics
✓ Symbol#to_proc & & Operator
✓ Block Scope & Local Variables
✓ Currying with Procs
✓ Enumerable with Blocks
✓ Expert Level
✓ Block-Local Variables (Block Arguments)
✓ Module Include vs Prepend vs Extend
✓ Mastery
✓ Module nesting & self
✓ Method Resolution Order (MRO)
✓ Concern Pattern (ActiveSupport)
✓ Namespace as Module
✓ Ecosystem
✓ Module#ancestors & Lookup Path
✓ Autoloading with Zeitwerk
✓ Architecture
✓ Refinement Scope & Activation
✓ Refine vs Monkey Patch
✓ Refinement Inheritance
✓ using Method & Scope Control
✓ Optimization
✓ Refining Core Classes Safely
✓ Refinement & method_missing
✓ Deployment
✓ Refinement Limitations
✓ GC Generations (RGenGC)
✓ Mark & Sweep Phases
✓ Write Barriers
✓ Phase 11
✓ ObjectSpace & T_MASK
✓ Memory Leak Detection (objspace)
✓ Phase 12
✓ GC Tuning Parameters
✓ Reference Counted Objects (T_DATA, T_FILE)
✓ Thread Basics & GVL
✓ Mutex & ConditionVariable
✓ Phase 13
✓ Fiber & Cooperative Scheduling
✓ Ractor (Ruby 3.0+)
✓ Phase 14
✓ Ractor Message Passing (send, receive)
✓ Shareable vs Unshareable Values
✓ Concurrent Ruby (ThreadPool, Future)
✓ Ruby C API (VALUE, rb_define_method)
✓ Phase 15
✓ Creating Extension with extconf.rb
✓ Memory Management in C (GC guards)
✓ Phase 16
✓ Exception Handling in C Extensions
✓ Ruby Data Types & TypedData
✓ Inline C with Rice
✓ FFI with fiddle
✓ Phase 17
✓ RSpec DSL (describe, context, it)
✓ RSpec Mocks (allow, expect, receive)
✓ Phase 18
✓ Minitest Spec & Assert
✓ Factory Bot & Fixtures
✓ Capybara Integration
✓ VCR for HTTP Record/Replay
✓ Phase 19
✓ Property Testing (rantly)
✓ DSL via instance_eval
✓ Phase 20
✓ DSL via block-passing & yield
✓ Rake & Thor DSL
✓ Config DSL Pattern
✓ Builder DSL with method_missing
✓ Phase 21
✓ Matcher DSL (RSpec)
✓ Internal vs External DSLs
✓ Phase 22
✓ Profiling with stackprof & ruby-prof
✓ JIT Compilation (YJIT, MJIT)
✓ Allocation Profiling
✓ GC Tuning for Throughput
✓ Phase 23
✓ C Extension Hot Paths
✓ Memory Instrumentation
✓ Phase 24
✓ Fiber vs Thread Performance
✓ Case Pattern Matching (Ruby 3.0)
✓ Array Pattern (in [a, *rest])
✓ Hash Pattern (in {key: value})
✓ Phase 25
✓ Find Pattern (in [*, pattern, *])
✓ Value & Variable Patterns
✓ Phase 26
✓ Pattern Matching Guards (if)
✓ Deconstruct & Deconstruct Keys
✓ taint & Trust Levels
✓ $SAFE Levels (deprecated)
✓ Phase 27
✓ Command Injection Prevention
✓ SQL Injection Prevention (Sanitize)
✓ Phase 28
✓ Rails Security (CSRF, XSS, Session)
✓ Brakeman Static Analysis
✓ Serialization & YAML.load Risks
✓ Phase 29
Text version of this roadmap

1. Foundations

  • Open Classes & Monkey Patching
  • method_missing & respond_to_missing?
  • define_method & Dynamic Definition

2. Core Concepts

  • Class Evaluation (class_eval, instance_eval)
  • Constant Lookup & Const_missing
  • Hook Methods (inherited, included, extended)

3. Intermediate Skills

  • DSL Building with instance_eval & block context
  • Binding & eval Context Manipulation
  • Block, Proc, Lambda Differences

4. Advanced Topics

  • Closures & Binding Capture
  • Symbol#to_proc & & Operator
  • Block Scope & Local Variables

5. Expert Level

  • Currying with Procs
  • Enumerable with Blocks
  • Block-Local Variables (Block Arguments)

6. Mastery

  • Module Include vs Prepend vs Extend
  • Module nesting & self
  • Method Resolution Order (MRO)

7. Ecosystem

  • Concern Pattern (ActiveSupport)
  • Namespace as Module
  • Module#ancestors & Lookup Path

8. Architecture

  • Autoloading with Zeitwerk
  • Refinement Scope & Activation
  • Refine vs Monkey Patch

9. Optimization

  • Refinement Inheritance
  • using Method & Scope Control
  • Refining Core Classes Safely

10. Deployment

  • Refinement & method_missing
  • Refinement Limitations
  • GC Generations (RGenGC)

11. Phase 11

  • Mark & Sweep Phases
  • Write Barriers
  • ObjectSpace & T_MASK

12. Phase 12

  • Memory Leak Detection (objspace)
  • GC Tuning Parameters
  • Reference Counted Objects (T_DATA, T_FILE)

13. Phase 13

  • Thread Basics & GVL
  • Mutex & ConditionVariable
  • Fiber & Cooperative Scheduling

14. Phase 14

  • Ractor (Ruby 3.0+)
  • Ractor Message Passing (send, receive)
  • Shareable vs Unshareable Values

15. Phase 15

  • Concurrent Ruby (ThreadPool, Future)
  • Ruby C API (VALUE, rb_define_method)
  • Creating Extension with extconf.rb

16. Phase 16

  • Memory Management in C (GC guards)
  • Exception Handling in C Extensions
  • Ruby Data Types & TypedData

17. Phase 17

  • Inline C with Rice
  • FFI with fiddle
  • RSpec DSL (describe, context, it)

18. Phase 18

  • RSpec Mocks (allow, expect, receive)
  • Minitest Spec & Assert
  • Factory Bot & Fixtures

19. Phase 19

  • Capybara Integration
  • VCR for HTTP Record/Replay
  • Property Testing (rantly)

20. Phase 20

  • DSL via instance_eval
  • DSL via block-passing & yield
  • Rake & Thor DSL

21. Phase 21

  • Config DSL Pattern
  • Builder DSL with method_missing
  • Matcher DSL (RSpec)

22. Phase 22

  • Internal vs External DSLs
  • Profiling with stackprof & ruby-prof
  • JIT Compilation (YJIT, MJIT)

23. Phase 23

  • Allocation Profiling
  • GC Tuning for Throughput
  • C Extension Hot Paths

24. Phase 24

  • Memory Instrumentation
  • Fiber vs Thread Performance: Performance considerations for fiber vs thread performance in Ruby significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.
  • Case Pattern Matching (Ruby 3.0)

25. Phase 25

  • Array Pattern (in [a, *rest])
  • Hash Pattern (in {key: value})
  • Find Pattern (in [*, pattern, *])

26. Phase 26

  • Value & Variable Patterns: Various pattern matching patterns emerge when working with value & variable patterns in Ruby. These patterns provide reusable solutions to common programming challenges.
  • Pattern Matching Guards (if)
  • Deconstruct & Deconstruct Keys

27. Phase 27

  • taint & Trust Levels
  • $SAFE Levels (deprecated)
  • Command Injection Prevention

28. Phase 28

  • SQL Injection Prevention (Sanitize)
  • Rails Security (CSRF, XSS, Session)
  • Brakeman Static Analysis

29. Phase 29

  • Serialization & YAML.load Risks