The Rubraqsys curriculum is organized as a gradual learning path that connects foundational Ruby concepts with broader work involving objects, reusable components, data flow, validation, refactoring, and multi-component program structure. Each stage introduces a defined group of topics and then connects them with material studied earlier.

The curriculum is designed for independent study. Learners can review explanations, examine examples, complete exercises, and return to earlier sections whenever additional practice is useful.

Stage 01 — Ruby Foundations

The first stage introduces the basic structure of Ruby code and the role of individual values inside a program. Learners study how information is stored, changed, compared, and used in simple expressions.

Topics include:

• Variables
• Strings
• Numbers
• Boolean values
• Expressions
• Naming conventions
• Basic operators
• Simple code flow

This stage creates the foundation for later work with conditions, collections, and reusable methods.

Stage 02 — Program Logic

The second stage focuses on how Ruby code can respond to different situations and repeat selected operations. Learners begin working with conditions and loops inside practical coding tasks.

Topics include:

• Conditional statements
• Comparison operators
• Logical expressions
• Branching
• Nested conditions
• Loop structures
• Counters
• Repeated operations

Exercises combine stored values with decision-making and repeated actions.

Stage 03 — Collections

This stage introduces ways to organize several values inside one structure. Learners study how arrays and hashes can store information and how Ruby can process groups of values.

Topics include:

• Arrays
• Hashes
• Reading stored values
• Updating entries
• Adding and removing data
• Iteration
• Filtering
• Basic collection processing

Collections also provide a bridge between foundational topics and broader programming exercises.

Stage 04 — Methods

Learners begin organizing repeated behavior into named sections of code. Methods introduce a clearer way to divide tasks and reuse logic across different parts of a program.

Topics include:

• Method definitions
• Method calls
• Parameters
• Arguments
• Returned values
• Reusable logic
• Breaking larger tasks into smaller parts

Exercises encourage learners to examine where individual operations belong and how several methods can work together.

Stage 05 — Classes and Objects

This stage introduces object-oriented Ruby structures. Learners study how related data and behavior can be grouped inside classes and represented through individual objects.

Topics include:

• Classes
• Objects
• Instance variables
• Initialization
• Object methods
• Object state
• Collections of objects
• Class responsibilities

The focus remains on understanding how code structure changes when several objects become part of one program.

Stage 06 — Connected Components

Learners explore how classes and objects can share behavior and cooperate with one another.

Topics include:

• Class relationships
• Inheritance
• Modules
• Shared behavior
• Composition
• Object collaboration
• Method communication
• Responsibility separation

Exercises compare different ways of arranging related Ruby components.

Stage 07 — Data and Code Flow

This stage moves into broader work with data processing and program behavior. Learners examine how information moves between methods and how Ruby handles different processing situations.

Topics include:

• Blocks
• Yield
• Enumerable patterns
• File handling
• Exception handling
• Validation
• Data transformation
• Structured processing

Learners work with exercises that combine stored data, reusable methods, and controlled program flow.

Stage 08 — Program Structure

The curriculum then shifts toward broader program organization. Learners study how responsibilities can be distributed across multiple classes and reusable components.

Topics include:

• Architecture mapping
• Class responsibility
• Data flow
• Service objects
• Reusable modules
• Dependencies
• Processing stages
• Coordinated objects

Exercises encourage planning before implementation and reviewing relationships between components.

Stage 09 — Review and Refinement

This stage introduces systematic review of Ruby code. Learners examine existing structures and identify areas that may benefit from clearer organization.

Topics include:

• Behavior checks
• Expected outputs
• Boundary cases
• Refactoring
• Method size
• Naming
• Repeated logic
• Dependency review
• Responsibility review

Learners practice revising code while keeping its intended behavior consistent.

Stage 10 — Integrated Ruby Practice

The final curriculum stage brings previous topics together inside broader programming exercises. Learners work with several connected components and review how information moves through the full structure.

Topics include:

• Architecture planning
• Coordinated classes
• Modules
• Collections
• Blocks
• Validation
• Exception handling
• Reusable components
• Behavior checks
• Data pipelines
• Refactoring
• Multi-component exercises

This stage is focused on combining earlier Ruby concepts within a structured programming workflow.

How the Curriculum Connects

The Rubraqsys curriculum is arranged so that each stage builds on concepts introduced earlier. Variables become part of conditions, conditions become part of methods, methods become part of objects, and objects later become part of broader program structures.

Learners can move through the curriculum according to their current knowledge and preferred study pace. Earlier stages provide foundational material, while later stages introduce broader structural topics and more detailed programming exercises.

The purpose of the curriculum is to give learners a clear way to explore Ruby through connected topics, practical work, and gradual development of programming knowledge.