Mastering Ruby Programming: Basics to Advanced Projects

Bootstraps you into Ruby literacy by exploring basic syntax and program execution. Learn to run Ruby, manage multi-file projects, and use core concepts, operators, and conditional statements.

Explore Ruby basics: local, instance, class, and global variables, constants, keywords, and object methods. Create a Celsius to Fahrenheit converter and save and run .rb programs from the command prompt.

Convert Celsius to Fahrenheit in Ruby and verify syntax with ruby -c -w. Practice keyboard input, to_i conversion, and basic file I/O with puts and print.

Read a Celsius value from temp.dat, convert it to Fahrenheit using Celsius multiplied by nine divided by five plus 32, and write the result to a file.

Explore the Ruby standard library by navigating the lib and arc directories, examining files like CGI.rb, files_utils.rb, and drb.rb, and learn how to load site_ruby, vendor_ruby, and gems extensions.

Explore how Ruby loads external files and extensions using require, load, and require_relative, compare when files are loaded multiple times, and manage load paths.

Explore the out-of-the-box ruby tools and key command-line switches, including the interpreter, gem, and rake, with syntax-checking and scripting options like -c, -e, and -v.

Explore using dash r to require files at startup, plus verbose, version, and help options; practice with ERB and IRB interactive sessions and gem installation basics.

Learn Ruby object oriented design by creating objects, defining methods with parameters, and sending messages to perform actions and data conversions, including a C2F example.

Explore how Ruby evaluates expressions and returns values through method calls, including literals and string concatenation, and learn to define a ticket object with printing methods.

Explore how Ruby uses objects, methods, and string interpolation to build output and examine boolean state with true, false, and nil, including if expressions and availability checks.

Display the object_id of Ruby objects to reveal identity. Compare strings and numbers to see that strings usually have different IDs, while numbers may share IDs.

Discover how Ruby objects respond to messages with respond_to? to verify capability. Use introspection and send to query a ticket object's venue, performer, seat, price, or event.

Explore Ruby method arguments, including required and optional parameters, default values, and variable numbers of arguments using asterisk notation, with focus on correct parameter order and binding.

Explain how Ruby handles the order of parameters and arguments by binding required, default, and splat parameters, showing how the asterisk collects leftovers into a sponge array.

Explore how Ruby manages local variables: their scope in method definitions, naming rules, and assignment producing object references; see how in-place string changes affect all references.

Explore overriding methods in Ruby by defining instance methods inside a class, creating objects with new, and observing how the latest method definition replaces the former.

Explore how Ruby objects maintain state with instance variables, enabling per-object data like price and name, and learn to initialize and access this state across methods.

Define a ticket class with an initialize method to set venue and date as instance variables during object creation, and read them with getter methods while exploring setter conventions.

Master Ruby setter methods and the price equal syntax to modify attributes like ticket price, using set_price and price_equal, with syntactic sugar and data validation insights.

Discover how Ruby uses attributes as read and write methods for instance variables, with attr_reader, attr_writer, and attr_accessor, using symbols for concise access to venue, date, and price.

Explore ruby inheritance by defining publication with publisher accessors, and magazine inherits publisher and editor. Understand single inheritance, object ancestry, and how modules extend functionality beyond classes.

Explore how Ruby treats classes as objects and how class objects can spawn new instances. Create class objects with the class keyword or class.new, then define skeleton methods like most_expensive.

Master class methods on the class object with a temperature converter implementing c2f and f2c, and define and access constants for a ticket venues list.

Explore how modules organize Ruby programs, mix in behavior to classes or objects, and how include and prepend differ from inheritance, including the kernel module and method lookup.

Explore using modules in Ruby by building a cargo hold example and examining method lookup and conflicts when a class and a mixin define the same method.

Trace how Ruby's method lookup resolves report for an object through a module mixed into class C and its subclass D, with precedence rules and method_missing behavior.

Explore mixing in modules with the same method name using include and prepend, observe method lookup order, and learn how super enables jumping to the next definition in Ruby 2.0.

Explore the super keyword in Ruby to wrap and extend methods across modules and classes, covering method lookup, super argument forwarding, and method_missing interception.

Define a person class that tracks name, friends, and hobbies, enables queries like all_with_friends and all_with_hobbies, and uses method_missing to route dynamic searches.

Explore nesting of classes and modules in Ruby, compare mixins and inheritance, and examine method lookup, dynamic method handling, and design decisions for flexible architectures.

Explore Ruby’s self object as the current or default object across top level, class, module, and method definitions, and master how scope and context change identifier resolution.

Explore how self behaves in Ruby's instance, skeleton, class methods, and singleton methods, showing how the receiver becomes self and how memory addresses reveal object identity.

Master how self acts as the default receiver for method calls in Ruby, using dotless syntax, the class object, and setter methods to streamline message sending.

Learn how instance variables belong to the current object via self and how class objects differ. Understand scope and how to determine which object owns an instance variable.

Explore how Ruby global scope and local scope shape visibility of global, local, and class variables, plus how self and constants relate across methods and classes.

Master Ruby local scope using class, module, and method blocks; observe how a is scoped and printed, how self relates to scope, and how recursion creates new local scopes.

Explore class variable syntax in Ruby and how class variables share state between a class and its instances, plus constant lookup and scope rules.

Explore how the car class uses class variables and class methods to track total cars and per-make counts, and examine their scope and visibility.

Learn how class variables are shared by a parent-child hierarchy in Ruby, examine their pros and cons for maintaining class state, and switch to class instance variables.

Explore the Ruby class hierarchy through a baking scenario, defining cake, batter, flour, and egg, and enforce private methods in Baker to control explicit receivers and self calls.

Understand Ruby private and protected methods, including explicit receiver rules for setters with self, how protected allows inter-object calls, and the concept of top level methods.

Define top level methods to become private instance methods of Object, invoke them without a receiver, and access them through the method lookup path, with puts and print in Colonel.

Master Ruby control flow with conditional execution using if and case, including else branches, negation with not or exclamation, and the unless form; cover single-line and modifier forms.

Explore how Ruby evaluates if and else if conditionals, including local variable creation from assignment inside tests, the = vs == distinction, and handling nil and match results.

Explore Ruby case statements, the case equality method three equal sign, and when clauses that match on values or object state, ending with end, illustrated by a ticket example.

Explore Ruby's case statements, using triple equal comparisons and when clauses to match tickets by venue, and understand the return value and nil outcomes.

Master Ruby looping by exploring the loop method, break and next controls. Learn conditional loops with while, until, and begin-end forms, including post block and modifier variants.

Explore Ruby iteration with for loops and code blocks, converting Celsius to Fahrenheit and using yield to drive custom iterators, including curly braces versus do..end and map behavior.

Explore Ruby times and my_times, showing how a method yields to a block while returning once, and how each and map drive array iteration with blocks.

Explore creating custom iterators in Ruby by reimplementing map with each, and master block parameters, variable scope, and block local parameters to write robust, scoped code.

Explore how Ruby handles runtime errors by raising and rescuing exceptions, using begin–end and rescue, and review common exceptions like runtime error, no method error, and IO error.

Raise and handle Ruby exceptions to control flow, using raise with a specific error or a runtime error and optional messages. Rescue exposes the exception and its backtrace and message.

Discover Ruby's built in essentials, including literal constructors for strings, arrays, hashes, ranges, symbols, and more. Learn to define operator methods and use syntactic sugar for clean, idiomatic code.

Explore how Ruby uses bang methods and unary operators to customize in-place text transformations, such as plus and minus for strings, and the destructive versus non-bang counterparts.

Discover built-in and custom Ruby conversion methods such as to_s, to_sym, to_a, to_i, and to_f, and learn how overriding these methods and using inspect affect object representations.

Discover Ruby's conversion methods, including array conversion with two underscores a and the star operator, string representations with two underscores s, and numeric conversions with two underscores i and f.

Explore boolean states in Ruby, examining true, false, and nil as objects and truth values. See how expressions evaluate for conditionals like if.

Explore how Ruby treats true, false, and nil as both boolean values and objects, and practice evaluating expressions in IRB to grasp their boolean behavior.

Explore how Ruby compares objects, from equality tests to the comparable module, define <=> in a class, and inspect object capabilities with methods.

Inspect how objects reveal skeleton and instance methods, track method lookup paths via includes and modules, and query private, public, and protected methods using IRB on strings and classes.

Explore Ruby scalar objects, focusing on strings and symbols, their creation, manipulation, interpolation, and comparison; cover string literals, single vs double quotes, and percent notation.

Learn how Ruby here documents create multi-line strings with customizable delimiters, interpolation, and escaping rules, including flush-left and hyphen variants, with practical examples.

Manipulate strings at the lowest level by retrieving substrings with index and range. Set and combine strings using square brackets, plus, and slice; search with substrings and regex.

Explore Ruby string handling from concatenation and interpolation to querying, including include?, start_with?, end_with?, empty?, size, count, index, rindex, ord, and chr.

Master string comparisons and transformations in ruby, using the spaceship operator for ordering and the double equals for equality, then apply formatting and padding with upcase, downcase, capitalize, and rjust/ljust.

Explore content transformation in Ruby by applying padding, center, stripping whitespace, and transforming strings with chop, chomp, clear, replace, delete, crypt, and succ.

Explore ruby string conversions with to_i bases 2 to 36 and oct/hex shortcuts, and review string encoding, utf-8 defaults, and symbol immutability and the symbol table.

Explore how symbols serve as method arguments and hash keys in Ruby, compare them with strings, and learn syntax options and performance benefits for hash lookups.

Explore how numbers are objects in Ruby, from fixnum and bignum to the numeric class, covering integer versus floating point, division rules, hex and octal bases, and to_i conversions.

Explore how Ruby handles times and dates, using date, time, and DateTime classes, and Date.parse and Date.new constructors to create, query, and format time values.

Explore creating and querying date time objects in Ruby, format them with strftime-style strings, convert between date, time, and date time, and perform simple date arithmetic.

Explore how arrays and hashes serve as Ruby's core container objects, comparing their ordering and indexing. Learn to create, manipulate, convert between arrays and hashes, and iterate with index.

Explore Ruby's array constructors by using array.new, the literal square-bracket form, the array method, and percent notation. Learn how to specify size, initialize elements, and nest arrays.

Master array manipulation in ruby by learning shift and pop, including element removal and return values. Explore combining arrays with concat, plus, and replace, and distinguish replace from reassignment.

Master Ruby array operations by inserting, retrieving, and removing elements using square bracket notation, values_at and slice, and manage beginnings and ends with unshift, push, and pop.

Discover Ruby array transformation techniques, including flatten with level control and in-place options, reverse and join, uniq and compact, and essential querying methods like size and empty.

Mastering Ruby hashes: store key-value pairs, perform quick lookups, and create hashes using literal, hash.new, hash[], and the top-level hash method, with practical examples.

Learn to insert, retrieve, and remove hash pairs in Ruby by using square brackets and the store method, handle unique keys, and use fetch and values_at with defaults.

Demonstrates default hash values and non-existent keys, using Hash.new with a block to auto-create keys, and contrasts destructive update with non-destructive merge for combining hashes.

Explore how to define methods that accept hashes and named keyword arguments in Ruby, including required and optional keywords, defaults, and a keyword sponge parameter.

discover how ranges and other collections leverage enumerable, and how including enumerable in a custom class via each enables iteration, enumerators, and methods like find.

Explore Ruby enumerable methods for searching and selecting: use each and find with blocks, include? and all? on arrays, hashes, and ranges, and leverage procs and lambdas for failures.

Explore Ruby enumerable boolean queries with find_all and select to filter, reject to exclude, and grep, then group_by and partition to organize results.

Explore enumerable searching in Ruby by using first, take, drop, min, and max on arrays and hashes, with examples and notes on infinite iterables and custom criteria.

Discover the enumerable family around the each method in Ruby, including reverse_each, each_with_index, each_slice, each_cons, and inject, with cycle iteration and finite versus infinite behavior.

The lecture shows building playing card and deck classes, generating a cards array by cycling suits and ranks, and explains inject (reduce) for summing with irb examples, ending with map.

Explore how ranges define start and end points, distinguish inclusive and exclusive syntax, and use creation and inclusion tests such as begin, end, or include and cover.

Explore the Ruby Set class, its creation with Set.new, uniqueness rules, and core operations like union, intersection, difference, and add or delete.

Explore the map method in ruby, which returns a new array by applying a block to each element, and learn about in-place map! and string iteration like each_byte.

Sort enumerable objects in Ruby by defining a spaceship operator or using a sort block, and organize arrays or objects by price or year.

Discover how enumerators differ from iterators, implement the each method via a code block or an existing enumerable, and use map, select, and take on an enumerator.

Explore the next dimension of enumerability in Ruby by creating and attaching enumerators to existing objects, exploring implicit enumerators, and mastering each, inject, and select workflows.

Discover how enumerator semantics hook the each method to a target object's methods, yielding map, select, or inject results while preserving the original collection.

Explains how Ruby enumerators maintain state to control iteration, contrasts with iterators, and shows hooking enumerator logic to non-enumerable objects to enable map and select.

Explore enumerator method chaining in Ruby, showing how to reduce intermediate objects with lazy enumerators and with_index, and how to work with infinite collections using lazy select.

Explore Ruby regular expressions for pattern matching and text processing. Learn how expressions are objects, perform match operations, write and apply regex in Ruby for filtering, substitution, and splitting strings.

Explore Ruby's pattern matching with the equal tilde operator and the match method, testing strings against regex and building patterns with literals, dot wildcard, and character classes.

Explore matching and substring captures in Ruby by using parentheses to isolate subpatterns, access captures with dollar variables and the match data object, and handle success or failure.

Discover Ruby regex techniques through match data, including pre_match, post_match, and begin/end, and master quantifiers, anchors, and modifiers with examples like phone number matching and mr or mrs.

Explore how regular expressions use quantifiers such as zero or more, one or more, and optional in patterns, and how greedy and non-greedy matching with backtracking affects matches.

Master ruby regexp anchors, using beginning and end of line and string, end of file, and word boundaries; explore repetition with braces, capturing groups, and common pitfalls.

Explore zero-width lookahead and lookbehind assertions to match patterns without consuming characters, and learn conditional matches in Ruby regex. Master modifiers i, m, and x to control case, multi-line behavior.

Explore converting strings and regular expressions in ruby, including interpolation inside regex, escaping special characters, and using RegExp methods such as match and scan.

Mastering Ruby programming basics to advanced projects introduces common methods that use regular expressions, including scan, match, split, sub, and gsub, with captures and grep.

Explore Ruby's IO class and standard streams, learn how stdin, stdout, and stderr drive file handling and enumerable IO objects for robust input/output operations.

Redirect Ruby's stdout and stderr to a file in write mode, observe a division by zero error, and explore keyboard input with gets and getc.

Explore Ruby's built-in file class for opening, reading, writing, and seeking, then compare line-based and byte-based reads using methods like get, read_line, read, read_lines, and rewind.

Learn how Ruby file objects manage position, using getc, getbyte, read, and seek, with rewind and pos to navigate lines and bytes efficiently.

Master Ruby operations by writing to files with put s or print, using write mode (w) and append mode (a); read with file read and process lines with a block.

Explore file enumerability in Ruby by using File.open with blocks, iterating with each, and leveraging inject to compute averages without loading entire files.

Handle Ruby file IO exceptions and error numbers to understand what goes wrong in file operations. Query file objects with file test and stat methods, and query directories with dir.

Explore Ruby directory manipulation by iterating directory entries with entries or globbing, filtering hidden files, and summing non-hidden file sizes. Create, navigate, and remove directories with mkdir, chdir, and rmdir.

Explore Ruby file handling through the standard library's file utils, pathname, stringio, and open-uri interfaces to copy, move, delete, and read files, with dry run and no write safety.

Explore the path name class to create and manipulate path name objects, including base name and extension, and use the string IO class to treat strings as IO for testing.

Explore how Ruby enables object individuation through singleton methods and the singleton class, and learn to tailor per-object behavior with extend, class methods, and core class modifications.

Define class methods by opening the singleton class with self. Explore how the method lookup path traverses modules and the class and how to include modules in a singleton class.

Explore how including a module into an object's singleton class makes module methods take precedence over the original class in the method lookup path.

Modify Ruby core classes and modules with understanding of singleton classes and metaclasses, and learn the risks of changes using match and gsub that return nil and affect chains.

Examine pass-through overrides in Ruby, where a new method calls the original and adds behavior. Use extend for object or class-level augmentation, while considering collision risks and Active Support examples.

Extend lets you modify a class object after it exists by mixing a module into its singleton class, giving per-object access to new methods and enabling safe core object refinements.

Explore refinements in Ruby, using refine and using to temporarily extend String with a shout method, and examine basic object and the builder XML example via method_missing.

Explore Ruby's proc objects as callable, runnable entities, compare them with method objects, and learn creating and using procs with proc.new, lambda, and block conversion, including closures.

Learn how blocks convert to procs, capture code blocks as proc objects, and use procs in place of blocks with ampersand, including two_underscore_proc behavior for mapping arrays.

Explore symbol hash to proc in Ruby for concise code, using ampersand colon syntax with map and capitalize, and learn how procs act as closures.

Explore Ruby closures by building a counter using a proc that preserves state across calls, then contrast procs with lambdas—arity, return behavior, and explicit creation.

Explore how to treat methods as objects in Ruby, create bound and unbound method objects, bind them across classes, and inspect the eval family for runtime code execution.

Explore the eval family of methods, including eval, instance_eval, and class_eval, and how they execute code in Ruby. Recognize the dangers of arbitrary code execution and the role of $SAFE.

Explore parallel execution in Ruby by creating and managing threads, inspecting thread state, and building a threaded TCP server to serve dates and support a chat server.

Explore threading in Ruby by creating, managing, and inspecting threads, and build a threaded date server using TCP server to serve date to multiple clients without blocking.

Build a Ruby chat server using sockets and threads that broadcasts messages to all chatters and handles joins, leaves, and thread-variable behavior.

Explore how Ruby threads isolate variables with a per-thread stash of values, manipulate thread keys, and implement a threaded rock-paper-scissors game.

Learn how to issue system commands from Ruby using the system method and backticks, inspect the process status, handle missing programs, and see practical examples like date, cat, and grep.

Explore Open3 in Ruby to communicate with external programs via two-way pipes, using standard input, output, and error, with threads coordinating a cat process.

Explore Ruby callbacks, hooks, and runtime introspection to react to events and customize behavior. See method_missing for delegation and a cookbook example that forwards unrecognized messages to recipes.

Explore Ruby's method_missing and respond_to_missing to intercept undefined methods, and learn how included, prepended, and extended callbacks hook modules into classes to define instance and class methods.

Explore Ruby's singleton class behavior with module inclusion and extension, and learn how inherited, const_missing, and method_added callbacks shape objects and classes.

Explore Ruby's object capabilities by querying methods and listing non-private methods. Examine runtime hooks, callbacks, and how class and module objects share methods, with practical examples.