Advance Your Coding Skills! Easy To Follow Ruby Fundamentals

Explore Ruby's high-level design that emphasizes ease of use, flexible syntax, and discoverability through dot notation, while understanding method aliases and minimal boilerplate for beginners.

Explore Ruby fundamentals and the Ruby way, then master object oriented programming with common patterns, and build real projects like a command line tic tac toe and Rails apps.

Prefer Mac OS 10 if you can, as the course assumes Mac usage; Windows can run in the browser, and Sublime Text is available, though Rails may be harder.

Write your first Ruby program and print strings to the console with puts, print, and p. Learn about variables and assignment, and store data as strings, numbers, arrays, and hashes.

Explore how Ruby treats numbers as objects, using literals and variables to perform arithmetic with +, -, *, /, %, and **, and understand integers and floats, parentheses guiding order.

Explore building and printing Ruby strings with concatenation and interpellation, compare double and single quotes, and get user input with gets and chomp.

Explore Ruby booleans, using true, false, and nil, with variables as light switches, then compare values via == and !=, note string case sensitivity and nil output.

Learn how reassigning variables affects values, what expressions are, how Ruby evaluates code as expressions with order of operations and parentheses, and that variables hold objects, not expressions.

Discover how methods operate on objects in Ruby, where the receiver calls a method and returns a value; use next, reverse, include, and insert with arguments.

Discover how Ruby treats operators and printing as methods, including methods in disguise and kernel methods, and learn when to use parentheses and understand receivers and return values.

Learn to define top-level and object methods in Ruby using def and end, call methods without a receiver, handle arguments, and manage implicit or explicit returns and side effects.

Explore chaining Ruby method calls by calling methods on return values or passing a return value as an argument, with examples like swap case, square sum, gets, and chomp.

Explore how Ruby objects listen to built-in methods, including to_s, to_i, and to_f conversions, and distinguish dangerous exclamation methods from boolean question methods.

Learn how to create Ruby methods with optional arguments and default values to make flexible function calls. Explore argument counting, assignment, and examples like print trio and greet with defaults.

Explore variable scope in Ruby by comparing local and instance variables across methods and objects, using bananas and dad examples to show visibility, access, and passing variables as arguments.

Explore arrays as Ruby's core collection, learn to create them with square brackets, assign them, and print contents with puts. Note empty arrays and arrays with mixed data types.

Master Ruby arrays by accessing elements with zero-based indices, using reverse lookups, slices, and negative indices to retrieve first, last, or subarrays.

Master Ruby array manipulation by adding, replacing, inserting, and deleting elements with push, pop, and shift. Join arrays with plus or concat to produce in-place changes, and delete by value.

Explore Ruby hashes as key-value dictionaries, learn symbol keys, default values, the two kinds of hashes, mapping keys to values and containing multiple fields, and nesting arrays and hashes.

Explore Ruby hashes by adding and deleting key-value pairs, setting defaults, and retrieving keys and values; learn the Hash constructor, default values, and converting to arrays with values and unique.

build a lottery simulator in Ruby to demonstrate random choices, using rand, sample, shuffle, and destructive methods, while refactoring to remove magic numbers and improve readability.

Explore Ruby conditionals and boolean logic with if and else, learn true and false, comparison operators, and basic input handling to drive binary decisions.

Explore multi-branch conditionals with if else if (LCF) in Ruby, replacing nested conditionals with readable branches. Use an else clause to handle invalid input with a default response.

Use a Ruby case statement to evaluate one expression against many values, replacing long if-else chains, and normalize user input with strip and downcase for flexible matches.

Discover how Ruby conditionals balance readability and conciseness by using if statements with and without else, single-line forms, and the ternary operator, treating conditionals as expressions.

Explore boolean arithmetic in ruby, using not, double negation, and or with true and false to show how conditional logic works.

Explore the and operator in boolean logic, linking two true/false statements, and compare boolean operations to arithmetic using truth tables and real-world examples like admin access.

Master inclusive or and boolean expressions in Ruby, using real examples like pet deposits and museum discounts to simplify conditionals and apply the ternary operator.

Develop a one-round rock paper scissors simulator in Ruby, exploring boolean logic and conditionals. Refactor with nested conditionals, case statements, arrays, and objects to improve readability and reduce complexity.

Explore how Ruby treats non boolean values in conditionals by examining truthy and falsie values, nil checks, and short circuiting to prevent errors and enable conditional assignment.

Master Ruby loops and iterators by exploring while and until constructs, understanding control flow, avoiding off-by-one errors, and preventing infinite loops.

Replace awkward while loops with for loops to traverse arrays and ranges. Learn to iterate with for item in array, use ranges (.. vs ...) and modify array elements.

Learn how Ruby uses iterators like each and each with index to replace for loops, with blocks and enumerators processing each element and enabling in-place array updates.

Explore Ruby iterators by using map and each to create new arrays, compare in-place map! mutations on ranges, and convert ranges to arrays with to_a for squares and cubes.

Learn how Ruby iterators filter collections with blocks, using select, reject, any, all, and find/detect to return subarrays, booleans, or a single item, with note on the destructive exclamation variant.

Explore Ruby loops and iterators by summing numbers in arrays with each and reduce (inject), starting from zero or an initial value, and learn symbol forms and string concatenation.

Learn to iterate over arrays, ranges, and hashes using each, each with index, map, select, and inject; handle key-value pairs, order in hashes, and key or value iteration.

Learn how to use Ruby ranges and integer iterators to loop efficiently, including inclusive vs exclusive ranges, using upto and times to avoid range objects, and how block variables behave.

learn to build a ruby read-evaluate-print loop calculator that parses user input, runs an infinite loop, and uses a case statement to perform add, subtract, multiply, and divide.

Discover how objects and classes relate in Ruby, differentiate instances from their class, and map object state to behavior through instance and class methods.

Create custom Ruby classes, define instance methods, and instantiate objects with initialize. Manage object state with instance variables and scope, using attribute readers, writers, and accessors.

Explore inheritance in Ruby, where a subclass inherits instance methods from a parent class. Learn to override with super and see dog and shape examples that illustrate is-a hierarchy.

Explore how Ruby defines instance and class methods, use initialize and attribute accessors, and implement inheritance with self and class syntax to extend objects.

Understand how the Ruby self keyword refers to the current object—main, class, or instance. Learn to define and call instance and class methods with receivers and recognize private method limits.

Examine scope in Ruby, comparing local, instance, and class variables, and how self, methods, blocks, and inheritance influence variable access and scope across the class and its subclasses.

Explore how include brings a module like management training into a class, enabling lead engineer and lead designer to use yelling, do math, and make pretty.

Create a deck, dealer, and player in Ruby to simulate card interactions, including hands, encapsulation, private methods, and composition over inheritance.

Refactor a rock paper scissors game into object-oriented Ruby, using classes, inheritance, and loops to support a REPL and continuous play with a computer player.

Learn how Ruby methods can take a block to customize operations using yield and block_given, and apply blocks with iterators like each and map.

Define a custom array iterator using a while loop and yield to a block, and create a group by criteria that returns yes and no groups, illustrating enumerable patterns.

Learn how blocks become procs, pass and call them, and convert between proc and block (including symbol to proc) to power multi-proc methods, map, and yield in Ruby.

Compare vanilla procs and lambdas, showing how lambdas behave like methods, enforce specific argument counts, and use return semantics, with creation via proc, lambda, and arrow syntax.

Explore closures in Ruby, showing how procs and lambdas capture local variables, keep state alive across calls, and reveal shared versus separate variable scopes in methods.

Explore closures in Ruby by building a string with a returned proc, showing how each string builder preserves its own captured variable and how separate procs maintain independent state.

Install and configure the macOS development environment by setting up Xcode command line tools, homebrew, and the latest ruby. Explore the terminal basics, including pwd, ls, cd, and navigate directories.

Explore creating, renaming, moving, copying, and deleting directories and files in the command line, including recursive operations, path navigation, and handling spaces with quotes or escape characters.

Explore standard output and command line techniques: print with echo, redirect to files with > and >>, and browse text with cat and less, while learning absolute and relative paths.

Learn to work with standard output, print with echo, and redirect to files using > and >>; use cat and less to view text, and master absolute versus relative paths.

Explore creating symbolic links to speed project access, using tree for directory structure, and consulting man pages, then set up Sublime Text to run in the terminal via path variable.

Learn how to customize Sublime Text for Ruby development by editing default and user preferences, using JSON-like settings to control tab size, translate tabs to spaces, and syntax-specific options.

Explore the Sublime Text editor and learn file management, tabs and groups, and quick searches and navigation for Ruby projects.

Learn to use Sublime Text's multiple cursors for efficient, multi-location edits with commands like command D and split lines, plus the IRP interactive shell for Ruby for quick testing.