Learn how to use Ruby and Angular 2. Become a web developer

Learn to write your first Ruby program, print strings to the console with puts, print, or p, and use comments. Explore variables, assignment, arrays, hashes, and numbers.

Explore how numbers work in Ruby as objects, using variables to store values and perform arithmetic with +, -, *, /, %, **, and understand integers, floats, and operation precedence.

Learn Ruby string fundamentals: compare double and single quotes, use literals and variables, master concatenation and interpolation, and handle user input to format output.

Explore boolean values in Ruby, including true, false, and nil, and learn to use comparison operators such as ==, !=, >, <, >=, <= to evaluate conditions.

Discover how Ruby evaluates expressions, assigns values, and uses variables as object references, including concatenation and the effect of reassigning variables on existing values.

Learn how methods work in Ruby, including receivers, return values, and arguments. See how to call methods on objects and use examples like reverse, next, include, and insert.

Explore how Ruby treats operators and prints as methods in disguise. Learn when to use parentheses and why puts, p, and print behave as kernel methods.

Learn to define Ruby methods with def and end, call them with or without receivers, handle arguments and returns, and understand implicit and explicit returns plus side effects.

Explore chaining method calls in Ruby by calling methods on return values and by passing return values as arguments, illustrated with swapcase and square sum examples.

Explore ruby's built-in methods for converting objects with to_s, to_i, and to_f, and distinguish exclamation mark destructive methods from safe ones and question mark boolean checks.

Learn to define Ruby methods with optional arguments and defaults, and how Ruby assigns parameters from left to right across varying argument counts.

Explore how scope governs variable visibility in Ruby methods, distinguishing local and instance variables, and learn to pass variables as arguments to access data inside methods.

Discover how arrays in Ruby serve as collections that hold multiple objects; create, print, and inspect arrays using square brackets, puts, and p, and manage empty or mixed-type arrays.

Explore how to access and manipulate arrays in Ruby, including index-based lookups, slicing, reverse lookups, and using negative indices to count from the back.

Learn Ruby array manipulation: add or replace by index, push or pop, shift from the front, delete by index or value, and join arrays with plus or concat.

Explore Ruby hashes, the core key-value collection, including symbol keys, hash rocket syntax, default values, and nested structures with arrays and hashes for representing contact cards and related data.

Learn to create and modify Ruby hashes by adding, deleting, and retrieving key-value pairs, setting default values, and using the hash constructor. Extract keys, values, and unique arrays from hashes.

Explore Ruby's random number generation and array methods to implement a lottery simulator, comparing sample, shuffle!, and dangerous methods, while applying refactoring and dry code principles.

Learn conditionals and boolean logic in Ruby using if else statements to decide actions. See booleans, comparisons, and input-driven decisions in practical examples like rain and numbers.

Master multiway conditionals in Ruby using if-else chains with LCF, cover greater, lesser, and equal cases, and implement a default else for unanticipated input from gets and chomp.

Discover how Ruby's case statement replaces repetitive else-if chains by checking a single expression against multiple values, and normalize user input with to_i, downcase, and strip.

Learn how Ruby treats conditionals as expressions to write cleaner if statements, including one-line forms and the ternary operator, plus early returns and boolean logic.

Explore boolean logic in ruby by examining booleans true and false and the not operator. Apply double negation in conditionals to control flow.

Explain how the logical and operator requires both statements to be true, using truth tables, Ruby examples, and the boolean arithmetic analogy from George Boole.

Explore how conditionals and boolean logic work, focusing on inclusive or, examples with pet deposits and museum discounts, and using the turnaround (ternary) operator to simplify expressions.

Learn to build a one round rock paper scissors simulator in Ruby, exploring conditionals, boolean logic, and refactoring strategies using arrays, case statements, and simple objects.

Explore how Ruby treats non-boolean values in conditionals, identifying truthy and falsy values, using nil checks, short-circuiting, and conditional assignment to write safer code.

Explore loops in Ruby, including while and until, and learn to avoid off-by-one errors and infinite loops through clear loop termination.

Replace while loops with a for loop to iterate over arrays, and learn ranges with two dots versus three dots, including the end keyword and modifying array elements by index.

Learn how Ruby uses iterators like each and each with index to replace for loops, using blocks to process arrays and modify elements in place.

Explore Ruby iterators like map and each, including map! and in-place updates, range to array conversion with to_a, and creating new arrays (squares, cubes) while preserving the original collection.

Learn how Ruby iterators filter collections using select, reject, any, all, and find (detect) with blocks, returning subarrays, booleans, or single results while avoiding mutation.

Learn how to use Ruby’s reduce (inject) to sum numbers in an array and perform any binary operation across a collection, including starting values and symbol shortcuts.

Learn to iterate over arrays, ranges, and hashes with each, map, and inject, and handle hash key–value pairs, keys, values, and indexed iterations in Ruby.

Learn to iterate in Ruby without creating a range by using integer iterators like up to and times; understand inclusive end points with .. vs ... and block variables.

Create a Ruby REPL calculator that processes add, subtract, multiply, and divide commands in an infinite loop, parsing input and using case statements for actions.

Explore the fundamentals of object oriented programming by distinguishing objects from their classes, defining instance and class methods, and illustrating object state with Ruby examples.

Define custom classes, create instance methods, and use initialize with instance variables to manage object state, then apply getters, setters, and attribute accessors.

Explore inheritance in Ruby by defining parent and child classes, where a subclass inherits instance methods from its super class and can override or extend them using super.

Explore the difference between instance and class methods in Ruby, how initialize sets up objects, how to define and inherit methods in subclasses, and the self keyword for class-level behavior.

Explain how the Ruby self keyword points to the current object, class, or main object, and how to define class and instance methods with receivers.

Explore variable scope in Ruby, distinguishing local, instance, and class variables, and learn how scope, methods, and inheritance shape access across classes and objects.

Explore object oriented design in Ruby by using modules as mixins to share methods across classes, enabling multi-inheritance behavior without instantiating modules.

Explore object oriented programming by modeling a card game with deck, dealer, and player classes, using composition over inheritance to connect objects and encapsulation with private methods.

Explore object oriented programming by modeling a rock paper scissors game with classes, inheritance, and a computer player, using loops, a REPL, and refactoring to track scores.

Discover how to define Ruby methods that take blocks, use yield and block_given, and implement flexible iterators like each and map with blocks.

define custom iterators in Ruby by implementing an array-specific custom each with a while loop and yield, returning self, and group by criteria to separate true and false.

Learn how blocks and procs let you treat code as objects in Ruby, convert between blocks and procs using to_proc, and pass multiple procs to methods for flexible iteration.

Explore the differences between vanilla procs and lambdas in Ruby, including argument handling, return behavior, and creation methods, with examples of wrapping code in arrays.

Explore closures, procs, and lambdas in Ruby and how they retain access to their defining scope. Learn how a proc can share or isolate captured variables across calls.

Explore closures through strings with a string builder example that uses procs to capture and preserve local variables, demonstrating how separate closures maintain independent state.

Set up a macOS ruby development environment by installing Xcode command line tools, homebrew, and ruby, then install Sublime Text and master essential terminal commands like pwd, ls, and cd.

Create, rename, move, and delete directories and files using mkdir, mv, rm, cp, and touch, while navigating with pwd and cd and handling spaces with quotes or escapes.

Explore standard output and how to print, redirect, and append text using echo and redirection operators. Learn to view files with cat and less, and distinguish absolute versus relative paths.

Explore how to work with standard output in Ruby and the command line, including echo and redirection to files, using cat and less, and mastering absolute versus relative paths.

Create a symbolic link from your home folder to a project directory. Set up Sublime to run from the command line, and use tree and man for help via PATH.

Learn to customize sublime text with the preferences files, focusing on ruby and syntax-specific settings. Set tab size to two spaces, convert indentation to spaces, and adjust color schemes.

Explore the Sublime Text development environment for Ruby projects, mastering folders, tabs, sidebars, quick file searches, multi-group layouts, and builds to test code.

Explore how to use Sublime Text's multiple cursors to edit across a file efficiently, including selecting all occurrences with keystrokes, and try the Ruby REPL (IRB) for quick code experimentation.

Split ruby code across multiple files (main file and other.rb) and load with require_relative; observe execution order and learn that require returns true first time, then false on subsequent loads.

Explore how require_relative creates a new scope in Ruby, and see how local variables disappear while instance variables, methods, and constants persist across files via the main object.

Organize Ruby projects by placing each class in its own file and using require_relative to compose a modular, readable main file, following camel case to snake case naming conventions.

Explore extending Ruby programs by requiring standard libraries and external gems, installing gems with gem install via jam, and using colorize and peepy to format output.