Complete Developers Guide: Ruby on Rails & React with Redux

Master how to write and print Ruby programs, explore strings and prints, and grasp variables, assignment, and basic data types like arrays and hashes through a hands-on console walkthrough.

Learn that numbers in Ruby are objects and how to perform arithmetic with plus, minus, star, slash, and modulo. Explore integers and floats, variable assignment, incrementing, and order of operations.

Master Ruby strings by using double and single quotes, concatenation, and interpolation to build and print text. Practice getting user input with gets and chomp, and understand literals versus variables.

Explore booleans and nil in Ruby, distinguishing true and false from strings, and using comparison operators (==, !=, >, <, >=, <=) to yield true or false.

Explain how re-assignment of variables doesn't update a previously stored value, and how Ruby evaluates code as expressions with order of operations, parentheses, and references to objects.

Discover how methods act on receivers, how to call them on objects, and how return values and arguments determine Ruby behavior.

Discover that in Ruby, operators are methods on the left object, and prints like puts, p, and print are kernel methods. Learn about syntactic sugar and optional parentheses.

Learn to define Ruby methods with def and end, including calls without a receiver, argument handling, return values, implicit and explicit returns, and side effects like puts.

This lecture explains chaining methods in Ruby, showing how to call methods on a return value or pass a return value as argument with swap case, reverse, and square sum.

Explore Ruby's built-in methods, including type conversion with to_s, to_i, and to_f, and note that exclamation and question mark methods signal dangerous side effects or boolean results.

Learn to define Ruby methods with optional arguments and default values, handle required versus optional parameters, and understand left-to-right argument assignment and flexible arity.

Explore Ruby variable scope across methods and objects, distinguishing local vs instance variables, understanding visibility within the main object, and using arguments to access values while keeping scope small.

Create arrays in Ruby with square brackets and commas, storing objects of different types. Print arrays with puts or p, check emptiness, and reuse them by assigning to a variable.

Access Ruby arrays by zero-based index or reverse lookup, and slice with start and length. Use negative indices to count from the back and get subarrays.

Learn to add, replace, delete, and insert elements in Ruby arrays using index assignment, push, pop, shift, delete by index or value, and join arrays with plus or in-place concat.

Explore hashes in Ruby, learn how keys map to values like a dictionary, distinguish symbols from strings, use hash rocket and alternate syntax, set defaults, and nest hashes and arrays.

Explore managing Ruby hashes, including adding key-value pairs, setting defaults, deleting keys, and using constructor notation; learn to access, increment, and retrieve keys, values, and unique entries.

Explore ruby's random number generation, using sample, shuffle! and pop to build a lottery game, while refactoring with descriptive names, default values, and the dry principle.

Explore how Ruby uses if else conditionals to drive program decisions, with booleans, comparisons, and end syntax to create binary choices in code.

Master ruby conditionals by using if, else if, and else to handle multiple outcomes, including nested conditionals, a default response, and simple comparisons with ==.

Discover how Ruby case statements replace long if-elsif chains by checking a single expression against multiple values, and learn to normalize input with to_i, downcase, and strip.

Learn how to write one-line if statements in Ruby, using inline conditions, the ternary operator, and conditional expressions to streamline code and handle early returns.

Explore boolean values in Ruby, including true and false, and learn how logical negation via not flips values. Practice double negation and or operators in conditionals.

Explore the logical and operator in Ruby by linking two true statements, compare language and arithmetic intuition, and review truth tables with true/false, as applied to access control examples.

Explore the inclusive or in Ruby by evaluating boolean expressions for real-world conditions, such as pet deposits and museum discounts, using true/false checks and equality operators.

Explore building a one-round rock paper scissors simulator in Ruby, refactoring conditionals with case statements, arrays of win/lose scenarios, and boolean logic for clear, readable outcomes.

Explore truthiness in Ruby by using non boolean values in conditionals, nil checks, and short-circuit evaluation. Learn conditional assignment with or equals to safely set defaults and prevent errors.

Explore while loops and until loops in Ruby, learn their control flow and conditions. Avoid infinite loops and off-by-one errors by practicing with examples and careful incrementing.

Replace awkward while loops with ruby for loops to iterate arrays and ranges, using indices to modify arrays and understanding dot dot vs dot dot dot ranges.

Discover how to replace for loops with Ruby iterators such as each and each_with_index, using blocks, managing scope, and updating array elements.

Explore mapping arrays in Ruby: use map and each to transform collections, convert ranges with to_a, and mutate in place with map!, contrasting new array creation with in-place updates.

Explore Ruby iterators for filtering data with methods like select, reject, and find, returning arrays or single objects, and booleans via any and all.

Explore Ruby's reduce (inject) to sum arrays, build totals, and perform binary operations, using blocks or symbols with starting values to accumulate costs, profits, and strings.

Learn how to iterate over hashes in Ruby using each, each with index, and map, printing keys and values, with ordered hashes and key-value pairing.

Learn how Ruby uses ranges and integers with iterators. Compare two dots versus three dots and use up to or times to loop without creating a range object.

Design and implement a ruby-based repl calculator that reads, evaluates, and prints results from user input in an infinite loop, with commands like add, subtract, multiply, divide.

Explore object oriented programming by defining objects and their class, distinguishing instances from classes, and examining how state and methods, including class and instance methods, define object behavior.

Define a custom class with the class keyword and create objects using new. Initialize accepts arguments, stores them in instance variables, and accessors provide getter and setter access.

Explore Ruby inheritance by defining a parent class with shared methods, and subclasses that inherit those instance methods, then override them using super to extend behavior.

Discover how Ruby distinguishes class methods from instance methods using new and initialize, and how self and class << self define class methods for inheritance.

Explore how self points to the current object in Ruby across main, class, and instance contexts, and how to define class and instance methods with private and a hamburger example.

Explore scope in Ruby by comparing local, instance, and class variables and how each belongs to a different context, noting class variables shared across instances and subclasses.

Discover how Ruby uses modules as mixins to simulate multiple inheritance, include modules to share behavior, and build flexible class hierarchies with lead engineers and managers.

Build a deck with a dealer and a player, using composition and encapsulation. Generate cards from suits and values, implement draw and shuffle, and expose private methods within the object.

Design and implement a rock paper scissors game using object oriented programming, with a player class, computer player subclass, and a game class that manages rounds, moves, and scoring.

Explore how to define Ruby methods that take a block, using yield and block_given? to add flexibility, implement iterators like each and map, and handle optional blocks.

Define and implement custom iterator methods in Ruby, such as a custom each, using while loops and yield, and explore Enumerable integration, monkey patching cautions, and group by criteria.

Learn how procs extend blocks in Ruby, turning blocks into objects, passing procs to methods, and converting between proc and block with the and symbol, with cube and square examples.

Compare vanilla procs and lambdas in Ruby, created by proc, Proc.new, or lambda with the -> syntax. Learn arity and return differences, plus storing and passing them as objects.

Explore how Ruby closures preserve variables from their defining scope using procs and lambdas. See how these closures access shared state across methods and keep variables alive beyond their scope.

Demonstrating Ruby closures, the video builds a string with a returned proc that appends input to an outer string, showing independent string states and preserved variables across scopes.

Set up the Ruby development environment by installing Xcode command line tools, Homebrew, and the latest Ruby; learn terminal basics, directory navigation, and Sublime Text setup.

Explore creating, renaming, moving, copying, and deleting directories and files on the Ruby command line, using mkdir, rm, mv, cp, and touch, with recursive options.

Explore standard output, redirection, and reading text files in Ruby, using echo, cat, and less, and distinguish absolute versus relative paths from root or home.

Learn how to print to standard output, redirect and append to files with echo and operators, use cat and less for long files, and distinguish absolute and relative paths.

Create symbolic links to access ruby project folders quickly from your home directory and enable Sublime to run from the command line by placing its binary in your PATH.

Configure Sublime Text for Ruby by adjusting default and user settings, translating tabs to spaces, and using syntax-specific options to manage indentation and color schemes.

Master the Sublime Text editor workflow for Ruby projects by organizing files in folders, using tabs and split views, and leveraging keyboard shortcuts for search, sidebar toggling, and in-editor builds.

Explore sublime text's multiple cursors for efficient edits across code and practice Ruby with IRP, the interactive Ruby shell, to test and load code.

Split ruby code into multiple files and load them with require relative; run code from files, and learn that require returns true on first load and false on subsequent loads.

require_relative creates a new scope, so local variables don’t transfer between files, while instance variables and methods on the main object remain accessible across required files.

Split the rock paper scissors program into separate class files and load them with a main file, using Ruby conventions for camel case classes and underscore file names via require_relative.

Learn to load Ruby libraries and gems with require and require_relative, including standard library and Ruby gems. Install and use gems with gem install, using colorize and peepy as examples.