Learn to Code with Ruby | Discount Coupon for Udemy Course

Welcome to Learn to Code with Ruby! In this lesson, we introduce the language, its history, and some of its advantages/disadvantages relative to other languages.

Learn about object-oriented programming (OOP), a paradigm that views a software program as a collection of objects that interact with one another. Practice applying OOP principles to real-world objects.

In this lesson, we discuss how to install the latest version of Ruby.

In this lesson, we access the Terminal application on a Mac, which is used to issue text commands to the operating system. We explore popular commands like pwd, ls, and cd to traverse directories and explore their contents.

In this lesson, we'll install the XCode Command Line Tools, a technical prerequisite for installing Ruby on a macOS computer.

In this listen, we install Homebrew, a software package manager for macOS. We run Homebrew from our Terminal and use it to download/install applications.

In this lesson, we install the rbenv Ruby version manager, which enables us to download and install multiple versions of Ruby on the same machine.

In this lesson, we use rbenv to install Ruby on our macOS operating systems. We target the latest version of Ruby at the time of installation.

In this lesson, we download Visual Studio Code, the free text editor in which we'll be writing our Ruby code throughout the course. We also discuss the benefits of using such a tool.

In this lesson, we introduce the PowerShell command-line application and some common commands including ls for listing files/folders and cd for directory navigation.

In this lesson, we use our system settings to determine if our Windows version is 32-bit or 64-bit.

In this lesson, we walk through the process of installing Ruby on a Windows machine. We also use Powershell to confirm the language was installed properly.

In this lesson, we download Atom, the text editor in which we'll be writing our code throughout the course. We also discuss the benefits of using such a tool.

In this lesson, we'll add VSCode and its corresponding Terminal command, code, to our system PATH, which enables the Terminal to locate the software from any directory on our computer.

Download the course materials for the course in a single zip file.

In this lesson, we write our first Ruby program, which outputs the text Hello World to the screen.

In this lesson, we learn how to run our Ruby file using the ruby program from our Terminal.

In this lesson, we dive into Interactive Ruby (IRB), a REPL (Read Evaluate Print Loop) program for playing around with the Ruby programming language.

In this optional lesson, we'll review the concepts we introduced in this course section.

In this lesson, we'll learn more about the puts method, which outputs text to the Terminal/output when the program runs. The puts method adds a line break to the end of the output. Like other methods in Ruby, it can be invoked with and without parentheses. We can also use commas to output multiple elements with the put method; Ruby will separate each one with a line break.

In this lesson, we'll introduce escape characters, which are special symbols we can use in a Ruby string. Escape characters add special effects like line breaks, tabs, and  symbols/characters to a string. We escape the expected pattern of output, which is Ruby outputting the literal characters that we've typed.

In this lesson, we introduce the print method, another way to output text to the screen. The print method is similar to puts but it does not add a line break to the end of the output.

In this lesson, we learn about the p method, which outputs a "technical" version of the object/output. For example, the p method will print a string with double quotes around the content. It exists primarily for the benefit of developers.

In this lesson, we'll learn how to use comments to ask Ruby to ignore specific lines of code. We create a comment with a hashtag/octothorpe (#) symbol. We can place the hashtag at the beginning of a line or after a line of valid Ruby code. Comments enable developers to leave explanations, metadata, annotations, diagrams, jokes, and more in their program.

In this lesson, you'll how to create multiline comments using =begin and =end.

In this lesson, we'll discuss the differences between integers and floating-point numbers and their syntax in Ruby.

In this lesson, we'll learn the symbols for mathematical operations including addition, subtraction, multiplication, division, and modulo.

In this lesson, we'll learn how to concatenate (join) two strings together using the + operator.

In this lesson, we'll learn about errors/exceptions in Ruby including TypeError, which Ruby raises when we provide an invalid type of object for an operation.

Review the concepts introduced so far in this section of the course.

Review everything we learned in this section of the course including output methods, comments, exceptions, concatenation, and more.

In this lesson, we'll learn about variables. A variable is a name we assign to a value in our program that is subject to change over time.

Declare various variables in a .rb file and use them in expressions throughout the program.

See the solution to the previous coding challenge.

Describe the NameError exception, which Ruby raises when it cannot recognize a name in your program.

Declare multiple variables and provide initial values to them on a single line.

Given two variables, swap the values they store.

Use shortcuts to perform an operation on a variable's value and assign the result back to the original variable.

Learn to declare constants, which are names for values that will not change over the program's execution.

Review everything we've learned in this course section including variables, constants, parallel variable assignment, and more!

Explain the differences between the Atom and VSCode text editors and why the lessons up ahead may look different.

• Begin our exploration of methods on various Ruby objects. A method is simply a message sent to an object
• Start discussion of return values, the final output of a method

See the solution to the previous coding challenge.

• Continue discussion of return values from objects
• Introduce the nil object which represents nothingness, blankness, or the absence of a value

• Utilize string interpolation to inject variables or calculations into a string
• Practice the interpolation syntax -- a hashtag followed by curly braces (#{})

• Use the gets method to collect input from the user
• Use the chomp method to chop off the newline from the end of a string
• Write a program to collect input from the user and print it out to them

Review the concepts introduced so far in this section of the course

• Call the .class method to return the class of the object, the blueprint from which it is built

• Utilize methods like to_s and to_s to convert numeric objects to strings and vice versa

• Learn about a new object type called a Boolean, which represents either true or false

• Explore predicate / Boolean methods available on objects which always return a true or false
• Call the odd? and even? methods on integer objects to see if they are odd or even

• Use the equality operator ( == ) to test whether two objects are equal

• Use the inequality operator ( != ) to test whether two objects are NOT equal

Review the concepts introduced so far in this section of the course.

• Use the < and > operators to compare whether one number is less than or greater than another
• Explore the related <= and >= operations to test less than / greater than or equal to

• Dive behind the scenes to see how Ruby processes basic arithmetic methods
• Begin a deep dive into arguments, which are inputs passed to a method call

• Continue exploration of parameters and arguments in more detail
• Call the between? predicate method to test whether a number falls in between two others

• Call some exclusive methods available on Float objects, which include a decimal component

• Use a popular programming shortcut to perform a mathematical operation on a variable and overwrite the variable's value

• Call the .times method on an integer to repeat a certain operation that number of times.
• Introduce the concept of blocks, an attachment to a method call that modifies its functionality

• Call the .upto and .downto methods on an integer to iterate from that number to another
• Further enhance our knowledge of blocks and block variables

• Call the .step method on an integer to iterate from that number to another at a frequent interval
• Further enhance our knowledge of blocks and block variables

Review the concepts introduced so far in this section of the course.

• Practice multiple syntactical options for creating a new String object.
• Call common methods like .length and .class on String objects.

• Use multiline strings to create strings that utilize more than one line.

• Learn the differences between using single vs. double quotes for creating strings.
• Double-quoted strings allow for interpolation and escape characters.

• Review the equality (==) and inequality (!=) operators
• Use the two operators on String objects

• Add / concatenate one string to another with concatenation operators / methods

• Call the .length or .size method to return the numbers of characters in the string
• See what happens when the methods are called on an empty string

• Use bracket syntax to extract a single character from a string

• Use bracket syntax with a few tweaks to extract multiple sequential characters from a string

• Introduce the Range object which represents an interval of numbers or characters
• Feed the range to the bracket syntax to extract sequential characters from a string

• Combine bracket syntax from previous lessons with the assignment operator (=) to mutate a string by assigning new characters

• Call the .downcase, .upcase, .capitalize, and .swapcase methods to modify the casing of a string
• The methods each return a new String object

• Call the .reverse method on a String to reverse the order of its characters

• Introduce bang methods, which mutate the original object the method is called on
• Bang methods are an alternative to reassigning the return value of a method call to the same variable

• Call the .include? predicate method to check if a certain substring is found in the string

• Call the .empty? predicate method to check if a string contains no characters
• Call the .nil? method which returns true only if called on a nil object

Review the concepts introduced so far in this section of the course.

• Introduce the purpose and syntax of a method.
• Transition to Atom Text editor and write our first method.

• Define local variables within a method.
• Local variables disappear as soon as the method is done executing.

• Add one or more arguments to a method to allow for input when the method is invoked
• A parameter is the name for an expected method argument

• Return a value from a custom method
• Differentiate between an explicit and implicit method return

• Discover the default return value of a method
• Explore why nil is the return value of the puts method

• Use the if statement, our first conditional, to evaluate code only if a condition evaluates to true

• Explore the concept of truthiness and falsiness in Ruby.
• false and nil are falsy in Ruby.
• All other objects are truthy.

• Add an elsif statement to check for the truthiness of another condition.
• Structure the code to follow a more complex logical path

• Fallback on the else keyword to execute code if no if or elsif condition above is met

• Employ the AND operator (&&) to check for multiple conditions in an if or elsif statement

• Employ the OR operator (||) to check if either one of two or more conditions is true.

Review the concepts introduced so far in this section of the course.

• Add parentheses when using && and || operators to establish the precedence for evaluating a condition

• Nest an if statement inside another to create a more complex logical path

• Call the .respond_to? predicate method to test whether an object can respond to a specific method

• Consolidate a simple if / else design by replacing it with the terser ternary operator

• Provide default / optional parameters to methods that will activate if the arguments are not passed on a method call

• Invoke one method from the body of another
• Invoke a method from inside a string using interpolation syntax

• Replace longwinded if / elsif / else statements with the case statement

• Utilize the exclamation point (!) to negate the value of an object and convert it to a Boolean
• Use two exclamation points (!!) to return the Boolean representation of an object.

• Use the unless keyword to simulate an "execute if false" condition for a piece of code.

• Begin discussion of a loop, an iteration that is repeated a specified number of times
• Introduce the while keyword for looping while a condition is true

• Continue discussion of loops and iterations
• Introduce the until keyword for looping until a condition is true

• Tackle Fizzbuzz, a popular coding challenge for beginners

• Replace simple if and unless statements with shorter inline statements
• The end keyword is not required with this simplified format

• Assign a value to a variable only if it is currently set to nil.
• Explore the advantages of this approach in professional code.

Review the concepts introduced so far in this section of the course.

• Introduce the Ruby Range object for storing an interval or sequence of numbers / characters
• Call the .class, .first, and .last methods on a Range object

See the solution to the previous coding challenge.

• Generate a Range object of alphabetic characters
• Explore the caveats of uppercase and lowercase character ranges

• Call the .size method on a Range object to see the size of its interval

• Use the .includes? predicate method to see if a value falls between a Range
• Use the === syntax to see if a value falls between a Range

• Explore the Ruby rand method to generate a random floating point number or integer
• Provide the method a Range argument to get a number in between the interval

Review the concepts introduced so far in this section of the course.

• Explain the Array object, a container to store other objects in a sequenced order.
• Create an empty array and call the .class method on it.

• Instantiate multiple arrays full of different data types.
• Nest one array within another.

• Utilize the %w syntax to easily generate an array of strings.
• Elements in the brackets are written without quotes or commas.

• Utilize the Array.new method to create a new array.
• Populate a new array with a consistent set of values.

• Use square bracket syntax to select an element from an array.
• The first array element will have an index position of 0.

• Call the .fetch method on an array to extract an element by index position.
• Compare the differences between square bracket syntax and .fetch

See the solution to the previous coding challenge.

• Extract multiple array elements with square bracket syntax
• Choose a starting point and the number of elements to select

• Feed a Range object to square brackets to extract multiple array elements.
• Review the differences between an inclusive and exclusive range.

• Call the .values_at method on an array to extract non-sequential array elements.
• Extract an array element more than once.

• Call the .slice method as an alternative to using square bracket syntax for array element extraction.

• Extract one or more array elements with familiar [] or .slice syntax.
• Overwrite the array element(s) with the equal sign (the assignment operator).

• Call the .length, .size, or .count methods to return the number of elements in an array.
• An empty array will return 0.

• Call the .empty? method which returns true if the array has no elements
• Call the .nil? method which returns true if called on a nil object.

• Call the .first and .last elements on an array to return the first and last elements.
• Call the two methods with an optional numeric argument to return an array of results.

• Call the .push method to add an element to the end of an array.
• Use the shovel operator (<<) to accomplish the equivalent of the .push method
• Call the .insert method to insert an element in a specific index position.

• Call the .pop method to remove an element from the end of the array.
• The .pop method also returns the element itself.

• Call the .shift method to remove an element from the beginning of the array.
• Call the .unshift method to add an element to the beginning of the array.

• Use the equality (==) and inequality (!=) operators to compare two arrays

• Use the spaceship operator (<=>) to compare two arrays together.
• -1 will be returned if the array on the left is less than the one on the right.
• 0 will be returned if the two array are equal.
• 1 will be returned if the array on the left is greater than the one on the right.

• Call the .to_a method on a Range object to convert it to an array

• Call the .is_a? predicate method on a variety of objects to test whether they inherit functionality from a specific class.
• The method will return true for an object's class or any of the superclasses above it.

Review the concepts introduced so far in this section of the course.

• Use the ri program from the Command Line to retrieve documentation on a Ruby class or an instance method

• Review blocks, which are attachments to methods that modify how they function.
• Review the two syntax options for a block (curly braces and do end).

• Call the .each method on an array to iterate over its elements one by one
• Provide the .each method a block to specify what to do on each iteration

• Provide block variables to an .each method block to represent the current array element being iterated over.

• Nest an .each method call within another .each method.

• Utilize the for loop to iterate over an array.
• Compare the differences between for and the .each method.
• See why the .each method is strongly preferred.

• Call the .each_with_index method to iterate over an array while keeping track of the index position.
• Provide a second block variable to hold the place of each index position.

• Tackle a programming problem that involves the .each_with_index method on an array.

• Call the .map or .collect method to iterate over an array, apply an operation to each element, and return a new array of the resulting elements.
• Practice the method with another challenge.

• Use the while and until loops as an alternative approach to iterate over array elements.

• Use the break keyword to break out of loop if a condition is met on an iteration.

• Use the next keyword to continue to the next iteration of a loop if a condition is met.

• Call the .reverse method on an array to rotate it, to present its elements in the opposite order.

• Call the .sort method to sort the elements in an array.
• The results will be in ascending order if an array consists of numeric element.
• The results will be in alphabetical order if an array consists of strings.

• Call the .concat method on an array to merge it with another array.

• Call the .max method on an array to return its largest element.
• Call the .min method on an array to return its smallest element.

• Call the .include? predicate method on an array to test whether it includes a value.

• Call the .index or .last_index method on an array to return the index position of the first occurrence of the argument.
• The methods will return nil if the element does not exist.

• Call the .select method on an array to return an array of elements for which the block condition evaluates to true.

• Call the .reject method on an array to return only those elements that do not fit the block condition.

• Place multiple variables on the left side of an assignment operator to unpack a multi-dimensional array and assign each nested element to a variable.

• Combine the functionalities of the .select and .reject methods in the .partition method, which returns a multidimensional array.

Review the concepts introduced so far in this section of the course.

• Call the .split method on a string to separate it by the occurrence of a delimiter and return an array of the results.

• Iterate over a string's characters by calling the .split or .chars method and then the .each method on the result array.
• An alternative is the .each_char method on the string.

• Call the .join method on an array to combine each of its elements and separate each with a delimiter.

• Call the .count method on a string to return the number of times a substring appears in the string.

• Call the .index method to return the first index position where the substring is found.
• Call the .rindex method to return the last index position where the substring is found.
• Emulate the functionality of the .index method with our own custom method.

• Call the .insert method to insert a character or characters at a specified index position in a string.

• Call the .squeeze method to remove all characters that occur two or more times in sequence.

• Call the .clear method on a string to rid it of content and return an empty string.

• Call the .delete method to remove all occurrences of the substring characters from the original string.

Review the concepts introduced so far in this section of the course.

• Review the idea of variables serving as pointers or references to objects
• Invoke the .dup method on an object to create a duplicate copy of the object.

• Use splat arguments in a method definition to allow for any number of arguments.

• Call the .any? and .all? predicate methods on array with a block argument specifying a condition.
• The methods return true if any or all of the blocks return true.

• Call the .find or .detect methods to return the first element of the array that matches the block's condition.

• Call the .uniq method on an array to remove all of its duplicates.
• Emulate the .uniq functionality in our own custom method.

• Call the .compact method to return a new array without any nil elements.
• Emulate the functionality in our own custom method.

• Call the .inject or .reduce methods to iterate over array while keeping track of the return values of the previous iterations.

• Call the .flatten method on array to remove all nested arrays.

• Call the .zip method to sync up elements across two or more arrays based on a common index position.
• Emulate this functionality in a custom method.

• Call the .sample method to extract a random element from the array.
• Provide a numeric argument to extract multiple elements.

• Repeat the elements in an array by multiplying it with the asterisk symbol.

• Create a union between two arrays that includes all items found in either (no duplicates included).

• Use the subtraction operator to remove array items that exist in another array.

• Use the & operator to identify elements common to two or more arrays.

Review the concepts introduced so far in this section of the course.

• Dive into hashes, a special object for storing key-value pairs that resembles a real-life dictionary

• Create hashes in Atom and extract values using square bracket syntax.

• Introduce the Symbol object, a lightweight string used to represent a name.
• Use symbols as the keys within a hash.

• Call the .to_s and .to_sym methods to convert symbols to strings and vice versa.

• Call the .fetch method to extract a value from a hash.
• The method returns nil by default if a key is not found.
• The return value in case of key absence can be customized.

• Use square bracket syntax or call the .store method to add a key-value pair to a hash.

• Call the .length method to return the number of key-value pairs
• Call the .empty? method to test whether the hash has no key-value pairs

• Iterate over a hash with the .each method.
• The block will require two block variables, one for the key and the other for the value.

• Invoke the .each_key and .each_value methods to iterate over just the keys or just the values of a hash.

• Call the .keys or .values methods to return arrays that contain only the keys or only the values from the hash.

Review the concepts introduced so far in this section of the course.

• Create a Hash object with a default value.
• See the advantages of not using the standard nil.

• Call the .to_a method on a hash to convert it to an array.
• See how Ruby uses a multi-dimensional array to maintain the connections betweens keys and values.

• Call the .sort and .sort_by methods to sort a hash by its keys or values.
• The return value will always be a new array object.

• Call the .key? and .value? predicate methods to test whether a key or value exists in the hash.
• The .has_key? and .has_value? methods are also available but these are deprecated.

• Explore the advantages of passing a hash as an argument to a method.
• A hash allows the values to be used in any order, which reduces error.
• Omit curly braces from hash when it is the last method argument.

• Call the .delete method on a hash to remove a key-value pair based on a key argument.

• Call the .select and .reject methods on a hash to extract key-value pairs whether either the key, the value, or both match a condition

• Call the .merge method on one hash to merge another hash into it
• Values from the second hash will overwrite those in the first if keys are identical.

• Tackle another Ruby programming problem! 
• Count the number of times each word appears in a sentence

Review the concepts introduced so far in this section of the course.

• Dive into a fresh unit on blocks, procs and lambdas.
• Offer a quick review of blocks

• Use the yield keyword within a method definition to transfer control to a block
• The yield keyword can be used more than once.

• Create a Proc, an object that functions as a saved block.
• Procs begin with Proc.new and otherwise use identical syntax to blocks.

• Use the .block_given? predicate method to yield control to a block only if a block is given to the method call.

• Yield arguments to the block following a method call
• Use familiar syntax (vertical pipes) to work with the arguments within the block body.

• Implement a custom .each method by utilizing a loop and yielding control of each array element to a block.

• Call a Proc object independently with the .call method
• Pass a Proc to a method that does not expect it as an argument

• Learn a shorthand syntax for passing a Ruby method like to_s or to_i as a Proc to another method.

• Formally add an expected Proc argument to a method definition.
• Create two different Procs and pass them to our method calls.

• Introduce the lambda object, which operates similarly to a Proc.
• Differentiate between the Proc and lambda objects.

• Walk through a refactoring example that utilizes lambdas to make a program tighter, terser and more adaptable to future change

• Explore the Time object which represents dates and times
• Call the .new and .now class methods on the Time class to create a few Time instances.

• Call multiple time and day-related methods on a Time object including .year, .month, .wday, and .yday.

• Call predicate methods on Time object including the day of week methods and the .dst? method.

• Use addition and subtraction operators on a Time object.
• Durations should be expressed in seconds.

• Call the methods mixed into the Time class from the Enumerable module.
• These include .between?, <, <=, >, and >=.

• Call the .to_s, .ctime, and .to_a methods on a Time object to convert it to various other data types.

• Call the .strftime method with a special syntax to convert a Time object to a string in a specific format.

• Call the .parse and .strptime methods to convert a string input into a valid Time object.
• The latter method requires a special syntax to designate the format that the Ruby interpreter should expect.

• Call the File.open class method to read a text file into Ruby.

• Call the File.open class method with an optional w argument to write to a text file using Ruby.

• Invoke the File.rename and File.delete methods to rename and delete a file using Ruby.
• Utilize the File.exists? predicate method to check for the existence of a file before performing an operation.

• Pass in arguments to a Ruby program through the Command Line.
• Use the ARGV array to capture and interact with command line arguments.

• Call the .load method to run another Ruby file in the present file.

• Call the .require and .require_relative methods to import another Ruby file into the current program.
• The .require method looks by default in the Ruby installation directory. Alter this with ./ syntax.
• The .require_relative method looks in the current directory.

• Call the .start_with? and .end_with? predicate methods to test whether a substring exists at either the beginning or end of a string.

• Invoke the .include? predicate method to test whether a substring is found anywhere within a string.

• Utilize the basic syntax of regular expressions (RegEx) to search for character matches within a string.

• Call the .scan method to return an array of all matches of the regular expression in a string.

• Explore the finer details of .scan including the provision of blocks to the method invocation.

• Use the period (.) to represent a wildcard, an occurrence of any character in a string.

• Understand the special use cases of a backslash in regular expressions.
• The backslash can be used to indicate digits, whitespace and more.

• Utilize characters to search for a RegEx match at the beginning or end of a string.

• Use the caret symbol (^) to exclude characters from a RegEx search.

• Call the .sub and .gsub methods to find and replace either the first or all occurrences of a RegEx match in a string.
• Utilize the bang versions of these methods.

• Navigate to Rubular.com, a popular resource for experimenting with Ruby regular expressions in your browser.

• Discuss the idea of an object and its blueprint, the class
• Understand the concept of an object's state, which is held by its instance variables

• Call the .class method on any Ruby object to return the class (blueprint) from which it is made.

• Call the .superclass method on a class to return its superclass, the class from which it inherits.
• Call the .ancestors method on a class to return an array of all superclasses and modules above it.
• The .ancestors method also represents the method lookup path, the order in which Ruby will look for an instance method on an object.

• Call the .methods method on an object to return an array of all methods that can be called on the object.

• Transition to Atom and create our first class definition.

• Review the idea of variables serving as object pointers or references
• Assign one variable to another to show how this operates.

• Define the .initialize method to set the object's initial state upon instantiation.
• Declare instance variables with default values within the definition.

• Define instance methods on the class. These will be available on all objects instantiated from the class.

• Define a custom .to_s method that will override the method inherited from the Object class.

• Use the self keyword within an instance method definition to refer to the object at hand.
• Call instance methods on the object from within another instance method.

• Define getter / reader methods to access the value of instance variables.

• Define setter / writer methods to set a new value for instance variables.

• Use Ruby's shorthand syntax for declaring getter and setter methods to replace our dense code.
• Three options are available: attr_writer, attr_reader, and attr_accessor.

• Modify our initialize definition in the Gadget class to include arguments.
• These arguments are passed when the .new class method is called on the class.

Review the concepts introduced so far in this section of the course

• Define a module with a constant and three methods.
• Identify the benefits of using modules, a toolbox of related functionality.

• Define multiple modules with identically named methods.
• See how modules create a protected namespace around each method.

• Review the require method to import a Ruby file into the present one.

• Call methods from Ruby's built in Math module.

• Explore Ruby's built in Comparable module, which is mixed into various classes to add compare functionality.
• Mix in the module into a new OlympicMedal class to allow comparisons.

• Define a custom Purchaseable module
• Mix in the module into multiple classes, including a superclass.

• Review the .ancestors method that is called on a class.
• Explore the method lookup path, the order in which Ruby looks for a method among superclasses and mixins.

• Use the prepend keyword in place of include to make a mixin's methods override those defined on a class.

• Use the extend keyword to add a module's methods to the class rather than its objects.

• Conclude with another built-in Ruby module, Enumerable, which grants access to over 50 methods related to iteration.

Review the concepts introduced so far in this section of the course.

• Define private methods on a class definition.
• Private methods cannot be called from outside the object.

• Define protected methods on a class definition.
• Protected methods can only be called from within the object or by an object made from the same clas.

• Validate that the input to a method is valid before modifying the object's state.

• Refactor our Gadget class to rely on instance methods to access instance variables.
• This approach is more future-proof.

• Define a reset method to alter multiple instance variables at once by calling numerous setter methods.

• Create a Struct, a lightweight class-like object that includes only instance variables.
• Integrate an AppStore module into the Gadget class definition.

• Use monkey patching to add new methods to Ruby's existing Array and String classes.

• Use monkey patching to add new methods to Ruby's existing Hash and Fixnum classes.

• Monkey patch a custom class after an object has been instantiated to see the impact of the class modification.

• Define class methods and class variables which will exist on the class instead of objects created from the class.

Review the concepts introduced so far in this section of the course.

• Introduce inheritance, superclasses, and subclasses

• Create a superclasses and two subclasses that inherit from it.

• Use < syntax to test whether a class inherits from another.
• Review the .ancestors method on a class.

• Call the .is_a? method to test if an object inherits from the class passed as the argument.
• Call the .instance_of? method to test if an object is directly instantiated from the class passed as the argument.

• Define exclusive methods on subclasses.
• These will only exist on objects created from the subclass, not anywhere else.

• Define a method on a subclass that overrides the same method on a superclass.

• Use the super keyword in a subclass method to invoke the same method in the superclass.

• Explore three different ways to use super: 
  • without parentheses
  • with parentheses and no arguments
  • with parentheses and arguments

• See how class variables can be used across subclasses to test how many instances of each class have been created.

• Declare a singleton method which will only exist on one instance of a class.
• A separate singleton class is created behind the scenes to contain this method.

• Modify the initialize method to expect a hash as an argument.
• See the advantages of this design approach.

• Continue refactoring the code from the previous lesson to make the class design even more adaptable to a hash argument.

Review the concepts introduced so far in this section of the course.

• Navigate across the RubyDoc.info site to look up documentation for various objects and instance methods.

• Navigate across the RubyDoc.info site to look up documentation for various class methods.

• Use rdoc to generate automatic browser-based documentation for a Ruby project.

• Add comments to Ruby code to allow rdoc to process it as documentation.
• Run rdoc to see the updated documentation.

• Celebrate finishing the 30+ hour course!

Explore the bonus content for the course!