In this lesson, we are going into look into a fundamental concept called Object Oriented programming. If you're coming from other object-oriented programming languages, you may be familiar with some of these concepts, but still it's important you pay attention because Ruby embraces a very specific form of object-oriented programming compared with many other languages available today.

Ruby utilizes a unique syntax for creating setters and getters in a class, in this lesson we will walk through how to implement these important processes.

If you’re new to object oriented programming, a natural question to ask is: what does instantiation mean?

One thing you may find handy in Ruby development is to create an `initializer` method. If you're wondering **what is an initializer method?**, it is simply a method called `initialize` that will run every time when you create an instance of your class. In this method, you can give values to your variables, call other methods and do just about anything that you think should happen when a new instance of that class is created.

In this lesson, we are going to learn about an important object-oriented principle called inheritance. Before going into how it is executed in Ruby, let's see why it's important for building applications.

This is going to be a fun episode, as we are going to talk about sending an sms message. Also, we are going to be learning about private and public methods.

In this lesson, we are going to talk about another important concept in object-oriented programming called polymorphism. Polymorphism occurs when a class that inherits from a parent class changes the behavior of a method in the parent class.

Through my years of teaching, one of the most common questions I get from developers is how to best understand object oriented programming. OOP development can seem a bit intimidating if you've never used it before so I wanted to take a step back and give a high level perspective of how it can be used to build applications.

In this section of understanding the SOLID development pattern and how it applies to OOP we are going to walk through the single responsibility principle. While the concept of single responsibility has been around for a while it was popularized in 2003 by Uncle Bob.

Continuing on our discussion of SOLID development principles, in this guide I’m going to walk through the: open closed principle.

Continuing on our discussion of SOLID OOP development principles, in this guide we’re going to walk through the Liskov substitution principle.

As we make our way through the SOLID Development journey, it’s time we turned to the I in SOLID, which represents the: interface segregation principle.

In this guide we’re going to walk through the final element of the SOLID Development pattern, the: dependency inversion principle.