Curriculum

How the Curriculum Works

The Railixoon learning line is arranged so each course adds a new layer of Ruby practice. Learners begin with basic syntax, then move into variables, conditions, methods, collections, loops, strings, files, errors, classes, objects, and small study projects.

Each course includes:

• 8 learning modules;
• Ruby code examples;
• exercises after each module;
• common mistakes;
• short recap;
• final practice section;
• glossary;
• mini reference section.

Detailed Curriculum Breakdown

1. Free Session — Introduction to Ruby

Free Session introduces Ruby through first code examples, basic concepts, and short exercises. It is an introductory course for learners who want to understand the Railixoon format.

Modules:

1. Ruby First Look — introduction to Ruby, basic language logic, and first code shape.
2. Code Shape Basics — reading short Ruby fragments and reviewing core elements.
3. Values and Output — working with text, numbers, and printed values.
4. Variable Starter — first work with variables and value names.
5. Small Expressions — short expressions, calculations, and value combinations.
6. Reading Code Slowly — careful line-by-line code reading.
7. First Practice Notes — short exercises for first Ruby concepts.
8. Review Path — key term review and preparation for the next course.

2. Path Session — Basic Ruby Syntax

Path Session explains the basic rules of writing Ruby code. The course helps learners understand syntax, comments, strings, numbers, and operators.

Modules:

1. Syntax Start Line — how a Ruby statement looks and how to read it.
2. Comments and Notes — using comments to explain code.
3. Strings and Numbers — working with text and numeric values.
4. Operators in Practice — basic operators for calculations and comparisons.
5. Code Layout — neat code placement in study examples.
6. Expression Review — how Ruby reads small expressions.
7. Syntax Reading Lab — exercises for reading short code blocks.
8. Syntax Mini Reference — compact reference for basic syntax forms.

3. Align Session — Variables, Conditions, Methods

Align Session combines three important topics: variables, conditions, and methods. The course shows how Ruby code can store data, make decisions, and reuse separate actions.

Modules:

1. Variable Alignment — naming values and working with variables.
2. Data Types Review — strings, numbers, boolean values, and basic types.
3. Condition Basics — using if, elsif, and else.
4. Comparison Logic — checks, comparisons, and logical conditions.
5. Method Shape — creating Ruby methods and understanding their role.
6. Parameters and Returns — passing data into methods and returning values.
7. Logic Combination Lab — combining variables, conditions, and methods in one example.
8. Alignment Review — recap of the main course logic.

4. Anchor Session — Collections, Loops, Simple Tasks

Anchor Session focuses on grouped data and repeated actions. The course explains arrays, hashes, loops, and small study tasks.

Modules:

1. Collection First Look — what grouped data means in Ruby.
2. Array Reading Practice — reading, adding, and changing array items.
3. Hash Basics — working with keys and values.
4. Loop Structure — repeated actions in Ruby.
5. Each in Practice — going through elements with each.
6. Conditions Inside Loops — combining checks and repetition.
7. Simple Task Lab — small tasks with arrays, hashes, and loops.
8. Collection Review — topic recap through a compact reference.

5. Drift Session — Strings, Files, Errors

Drift Session helps learners work with text, file examples, and error messages. The course shows how to read Ruby output carefully and adjust code after checking it.

Modules:

1. String Shape Review — how string values behave in Ruby.
2. String Methods Lab — common string methods in short examples.
3. Formatting Text — combining, splitting, and cleaning text.
4. File Reading Notes — basic logic of reading file content.
5. File Writing Concepts — how Ruby can create file-style output.
6. Error Message Reading — how to read error messages.
7. Debug Practice Room — adjusting small examples after review.
8. Drift Review — recap of strings, files, and error-reading patterns.

6. Loom Session — Classes and Objects

Loom Session introduces classes and objects. The course explains how Ruby describes objects, stores internal data, and places behavior inside classes.

Modules:

1. Class First Look — what a class is and what role it has.
2. Object Creation — creating objects from class definitions.
3. Instance Data — storing data inside an object.
4. Initialize Method — setting starting values with initialize.
5. Object Methods — methods inside classes.
6. Attribute Reading — working with readable and writable object data.
7. Object Interaction Lab — object interaction in short examples.
8. Loom Review — recap of class and object patterns.

7. Cloud Session — Small Ruby Project Structure

Cloud Session shows how to organize small Ruby projects. The course covers file layout, class roles, method placement, and code review habits.

Modules:

1. Project Shape Notes — what a small Ruby project looks like.
2. File Layout Basics — arranging files and folders in study examples.
3. Role Planning — defining the role of each code part.
4. Class Placement — placing classes inside the project structure.
5. Method Direction — methods with a focused action and understandable role.
6. Data Movement — movement of values between code parts.
7. Project Assembly Lab — combining files, classes, and methods into one example.
8. Structure Review — reviewing code organization and refining unclear areas.

8. Luma Session — Interaction Between Code Parts

Luma Session explains how Ruby code parts interact. The course focuses on method calls, object behavior, file links, and data movement.

Modules:

1. Connection Map — identifying the main parts of a Ruby program.
2. Method Call Flow — how methods call each other.
3. Data Transfer Notes — movement of values through code.
4. Object Collaboration — object interaction in small examples.
5. File-to-Code Links — how files support code organization.
6. Flow Reading Lab — reading a multi-part example from start to finish.
7. Interaction Practice — creating a small connected scenario.
8. Luma Review — recap of code interaction patterns.

9. Origin Session — Architecture Logic for Small Ruby Projects

Origin Session covers the logic behind small Ruby project organization. The course helps learners plan class roles, method boundaries, data routes, and code review.

Modules:

1. Architecture First Look — what organization means in a small Ruby project.
2. Responsibility Mapping — defining the roles of classes and files.
3. Method Boundaries — methods with a limited and understandable action.
4. Object Relationship Notes — links between objects inside a project.
5. Data Route Planning — where data starts, changes, and moves next.
6. Structure Review Lab — reviewing layout and finding unclear areas.
7. Rewrite Practice — rewriting selected fragments without losing the main logic.
8. Origin Review — recap of architecture patterns for small Ruby projects.

10. Echo Session — Final Ruby Reference and Study Project

Echo Session closes the Railixoon line as a final reference manual. The course combines syntax, variables, methods, collections, classes, files, data flow, and a final study project.

Modules:

1. Ruby Reference Review — recap of syntax, values, variables, and conditions.
2. Methods and Collections Recap — methods and grouped data in one context.
3. Object Structure Review — recap of classes, objects, and instance data.
4. File and Project Layout — placing code across several files.
5. Data Flow Review — movement of values through methods, objects, and collections.
6. Code Review Session — reviewing names, readability, and structure.
7. Final Study Project Build — assembling a broader Ruby example from several parts.
8. Echo Reference Wrap — final mini reference for review.