Module 1: Unlearn Programming to Learn Ruby

Understanding the permissive nature of Ruby

Exploring Ruby's human-friendly vocabulary

Reshaping your way of thinking to code in Ruby

The importance of transcribing thoughts directly into Ruby code

Module 2: Classes and Objects

Understanding the fundamentals of Object-Oriented Programming in Ruby

Learning how to define classes and create objects in Ruby

Creating and initializing objects using the `new` method in Ruby

Defining methods within a Ruby class

Module 3: Variables, Constants, and Literals

Understanding different types of variables in Ruby

Learning about instance, class, global, and local variables

Exploring the use of constants in Ruby

Working with literals: strings, integers, floats, arrays, and hashes

Module 4: Operators

Understanding mathematical operators in Ruby

Learning how to use logical operators (`&&`, `||`, `!`) in Ruby

Exploring range operators (`..`, `...`) and how to create ranges

Using bitwise operators (`&`, `|`, `^`, `~`) in Ruby

Module 5: Conditional Statements

Understanding the `if...else` statement for conditional execution

Learning how to use the `if` and `unless` modifiers

Using the `unless` statement for negative conditions

Exploring the `case` statement for multi-way branching

Module 6: Loops

Understanding the `while` loop for repetitive execution

Learning the `for` loop to iterate over a range or collection

Using the `next` keyword to skip iterations in a loop

Breaking out of loops using the `break` keyword

Module 7: Methods

Understanding the basics of defining and calling methods

Learning how to set default values for method parameters

Using the splat operator to handle variable arguments

Defining and using class methods

Module 8: Blocks

Understanding the concept of blocks in Ruby

Learning how to use the `yield` keyword to invoke blocks

Checking for the presence of a block using `block_given?`

Passing blocks to methods and calling them with `block.call`

Module 9: Modules and Mixins

Understanding what modules are and how to define them

Learning how to include and extend modules in classes

Using modules for namespacing to avoid name collisions

Exploring the concept of composition over inheritance using modules

Module 10: Strings

Learning how to create and manipulate strings in Ruby

Understanding string interpolation and concatenation

Exploring common string methods like `upcase`, `downcase`, and `reverse`

Working with special characters and multiline strings

Module 11: Arrays

Understanding how to create and access arrays in Ruby

Learning how to add and remove elements in arrays

Exploring various array methods such as `length`, `first`, `last`, and `sort`

Working with nested arrays and iterating over array elements

Module 12: Hashes

Understanding how to create and access hashes in Ruby

Learning how to add, update, and remove key-value pairs in hashes

Exploring common hash methods such as `keys`, `values`, `delete`, and `merge`

Iterating over hash key-value pairs and setting default values

Module 13: Exceptions

Understanding how to raise and handle exceptions in Ruby

Learning to use `rescue`, `else`, and `ensure` for robust error handling

Exploring multiple exception handling and creating custom exceptions

Ensuring consistent execution with the `ensure` block

Module 14: Date & Time

Understanding how to work with the `Time` class in Ruby

Learning how to format, add, and subtract time using `Time` objects

Working with the `Date` class for date-only operations

Understanding how to parse date strings and combine dates with times

Module 15: Ranges

Learning how to create and use ranges in Ruby

Understanding how to iterate over ranges and check for range membership

Using ranges with numbers, letters, and dates

Applying ranges in conditional statements for better readability

Module 16: Symbols

Understanding what symbols are and their unique characteristics in Ruby

Exploring the `Symbol` class and its methods in Ruby

Understanding how symbols differ from strings in terms of memory efficiency and immutability

Applying symbols in various contexts, such as method names, variables, and hash keys

Bonus: OOP in Ruby

Understanding the basics of Object-Oriented Programming (OOP) in Ruby

Learning about class definitions, objects, and the `initialize` method

Exploring instance variables, methods, and access control in Ruby classes

Understanding class inheritance, method overriding, and operator overloading

Applying the `freeze` method and understanding class constants in Ruby

MINI-PROJECTS

Completing a course alone isn't enough to become a skilled Rubyist.

You need to apply your knowledge to a structured codebase, giving you real-world experience in how professional Ruby projects are organized.

That's why we've added two exciting mini-projects to complement our Ruby for Beginners course:

1. FileOrganizer

In this project, you'll create a script to organize files in a directory by their extensions.

For example, .jpg files go into an Images folder, .txt files go into a Documents folder, and so on.

The codebase is structured as a production-ready gem, offering you a taste of how professional Ruby projects are managed.

2. FileEncryption

In this project, you'll apply Ruby concepts to create a command-line tool that can encrypt and decrypt files using straightforward algorithms like the Caesar Cipher.

The Caesar Cipher algorithm is a simple encryption technique where each letter in the plaintext is shifted a certain number of positions up or down the alphabet.

The codebase is also designed as a production-ready gem, giving you practical experience with how professional Ruby projects are organized.