DEV Community: 0x-2FA

100 Days of Learning Ruby: Day #4

0x-2FA — Mon, 10 Jan 2022 20:25:22 +0000

OOP in Ruby (Part II)

Last time we learnt what is Object Oriented Programming and we started to learn how it is implemented in Ruby, today we will continue learning about OOP in Ruby.

What is attr_accessor, attr_reader and attr_writer?
Inheritance in Ruby

Setup for Today

Create a new folder called Day_4, then create a new file with the name oop2.rb and finally open it up in a text editor of your choice.

cd 100_days_of_ruby/
mkdir Day_4 && cd Day_4/ && touch oop2.rb
codium .

What is attr_accessor, attr_reader and attr_writer?

Last time we created the following class:

class Dog

  def initialize()
    @age = 3
  end

  # return the age of the dog
  def GetAge()
    return @age
  end

  # set the age of the dog
  def SetAge(age)
    @age = age
  end

end

And we used the SetAge method to set the dog's age and the GetAge to retrieve the dog's age. But why create these methods ourselves when Ruby can do it for us.

To understand that let's firstly see that we can't just simply access the age attribute/variable but we need to call the GetAge or SetAge method.

For example add the above class to our file and then below that add the following lines of code:

dog = Dog.new  # creating a new Dog object

puts dog.age   # trying to print the age of our object

If you try to run this code you will end up with an error saying undefined method 'age'. We cannot access the attribute age without calling our GetAge method.

Let's modify our Dog class a bit:

class Dog

  attr_accessor :age

  def initialize()
    @age = 3
  end

end

dog = Dog.new   # creating a new Dog object

puts dog.age    # printing the initialized age of our dog object

dog.age = 5     # modifying the age attribute

puts dog.age    # printing the new age of our dog object

Now if we run our program we can see that we have no errors. Also we can see that we removed our SetAge and GetAge methods and we added the line attr_accessor :age.

So what happened is that when we declare a class attribute with attr_accessor Ruby will automatically create a Getter and a Setter method for that attribute.

If we only wanna have a Getter for an attribute then we declare it with attr_reader and if we only wanna have a Setter for an attribute we declare it with attr_writer.

Add the following lines of code to our class to demonstrate the above:

attr_reader :name
attr_writer :dob  # dob = date of birth

def initialize()
  @age = 3
  @name = 'Snoopy'
  @dob = '13-06-2003'
end

Now go ahead and print the name and the dob of the Dog object. You can print the attribute name cause it is declared with attr_reader but you can't print the attribute dob cause it's declared with attr_writer.

Inheritance in Ruby

This blog is already kinda lengthy and I don't wanna over do it so I'm not gonna go over what Inheritance is, I'm just gonna show you how it's done in Ruby.

Add the newly created Animal class before the Dog class and change the class Dog slightly:

class Animal

  def Eat(food)
    puts "I like to eat #{food}"
  end

  def Sleep()
    puts "I'm going to sleep."
  end

  def Drink()
    puts "I drink lots of water"
  end

end

class Dog < Animal
  attr_accessor :age
  attr_reader :name
  attr_writer :dob  # dob = date of birth

  def initialize()
    @age = 3
    @name = 'Snoopy'
    @dob = '13-06-2003'
  end

end

So in Ruby a class can inherit the methods and the attributes of another class with the symbol <.
Here we can see that the class Dog inherits 3 methods from the class Animal. We can now modify our program again to use these functions from a Dog object.

Add the following to the end of our program:

puts dog.Eat("Meat")
puts dog.Drink
puts dog.Sleep

We will end Day #4 here but again we haven't learnt everything about OOP in Ruby, I decided to cover more advanced OOP concepts a bit later, so some time in the series there is going to be a Part III. Next time we will learn about the Control Flow of our Ruby program (if statements, loops etc).

I was a bit hasty with this one cause I don't have much time to practice and learn ruby these days. That's also the reason that I don't create these blogs more often.

Anayways thanks for joining, I will see you next time!

100 Days of Learning Ruby: Day #3

0x-2FA — Tue, 04 Jan 2022 16:46:54 +0000

Originally when I was writing this blog I was going through what is Object Oriented programming (OOP) and then how we do it in ruby but the blog post became lengthy and I'm not here to teach programming. I'm just sharing my journey of learning Ruby in a tutorial style.

So instead I provided some links that can help you learn everything I was trying to teach you about OOP.

Day 3: Understanding Ruby a bit more

Now that we have the very very basics of ruby down it's time to learn more about it. Today we are going to learn the following:

Introduction to Object Oriented Programming (OOP)
OOP in Ruby (Part I)

Setup for Today

Create a new folder called Day_3, then create a new file with the name oop.rb and finally open it up in a text editor of your choice.

cd 100_days_of_ruby/
mkdir Day_3 && cd Day_3/ && touch oop.rb
codium .

Introduction to Object Oriented Programming (OOP)

Everyone has heard of Object Oriented Programming and probably everyone has used it at least one in their career. So let's learn some things about it.

What is Object Oriented Programming (OOP)?

The wiki has a nice definition:

Object-oriented programming (OOP) is a programming paradigm based on the concept of objects, which can contain data and code: data in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).

There is some fancy terminology here such as Programming Paradigm and we need to understand that first to be able to learn about OOP.

What is a Programming Paradigm?

Basically a programming paradigm is the concept by which the methodology of a programming language adheres to. Paradigms are important because they define a programming language and how it works.

There are a lot of paradigms out in the wild and in fact ruby is a multi paradigm language (aka supports more than one paradigm). We are not gonna discuss other programming paradigms today but here is an amazing site where you can learn more about them https://cs.lmu.edu/~ray/notes/paradigms/.

The Basic Idea of OOP

What are four basic principles of Object Oriented Programming?

What Is Object-Oriented Programming? The Four Basic Concepts of OOP

OOP in Ruby (Part I)

In most (if not all) ruby programs everything depends on objects. In fact most of the time in ruby you are creating new objects without even knowing it and that's because everything in ruby is an object. Also every object is obviously an instance of a class.

We can test that by adding the following lines of code to our program:

puts "Hello, World!".upcase # prints HELLO, WORLD!
puts "Hello, World!".class  # prints String

Yes, we called a method on a plain string and that's because this "plain" string is in fact an object and it's an object of the class String.

Defining our own Classes in Ruby

This is very simple, just add the following to our program:

class Dog

end

We just created our own class with the name Dog, it doesn't have any code yet but we will gradually add more things to it.

Defining our own Methods

Methods are super important to any Ruby class. Let's create our own by adding the following lines to our Dog class:

class Dog

  # return the age of the dog
  def GetAge()

  end

end

As you can see we defined a new method called GetAge that at the moment doesn't do anything.

The way we define methods in ruby is pretty easy. Start with the def keyword followed by the name of your method, it can be anything you want, then a number of parameters and finally to close it we use the keyword end.

Keep in mind that we don't always need to have parameters to every method. In our case the method GetAge() doesn't have any parameters cause it simply doesn't need one.

Note: Generally you can name your methods however you want but don't name them initialize that's a special method that we will learn a bit later.

Also method names in ruby are generally written in snake_case so it would be better to write it like this get_age() but I'm used to methods being in PascalCase so that's why we wrote it GetAge().

Instance variables

These are just variables but defined inside of a class. Instance variables are available only to each instance of the class.

Add the following to our Dog class:

class Dog

  # return the age of the dog
  def GetAge()
    return @age
  end

end

The @age is an instance variable, so instead of saying for example age = 4 we have to add the @ symbol @age = 4. That's the only difference in terms of syntax.

Also here we typed return @age, this is how we return a value from a method and it's the same with a lot of other programming languages. In ruby though we can omit the keyword return and just type @age. That's because in ruby every method returns the result of the last expression, in our case it will just return the value of @age.

But I like to always know what a method returns as I go through someone's code (even mine), so I like to explicitly return a value from a method.

Lastly add the following method to our Dog class:

class Dog

  # return the age of the dog
  def GetAge()
    return @age
  end

  # set the age of the dog
  def SetAge(age)
    @age = age
  end
end

Defining an object of class Dog

Add the following lines of code after the Dog class:

my_dog = Dog.new()   # create a new object of class Dog

puts my_dog.class    # print the class of the my_dog object

puts my_dog.GetAge() # print the age of the dog before setting it
my_dog.SetAge(4)
puts my_dog.GetAge() # print the age of the dog after setting it

Special initialize method

The initialize method is a special type method that we can define in every class. What it does it's pretty simple, if we have it defined it will execute as soon as we create a new instance (object) of the class. To test it let's define it in our Dog class:

class Dog

  def initialize()
    @age = 3
  end

  # return the age of the dog
  def GetAge()
    return @age
  end

  # set the age of the dog
  def SetAge(age)
    @age = age
  end

end

Now run our program again and pay attention that the first puts my_dog.GetAge() instead of printing nothing, it now prints the value 3 cause when we did my_dog = Dog.new() we basically created a new object and it immediately called the initialize method.

We will end Day #3 here but we haven't learnt everything about OOP in Ruby that's because this blog became a bit lengthy so I decided to break it into two parts. So next time we will continue with OOP in Ruby and learn more things such as inheritance.

Thanks for joining, I will see you next time!

100 Days of Learning ruby - Day #2

0x-2FA — Sat, 01 Jan 2022 18:39:05 +0000

Day 2: Basics of ruby

We are continuing our journey of learning ruby and today we are going to learn the following:

Basic data types
Single and Multi line Comments
Using methods
Basic math operations
Fun with Strings

Setup for Today

Create a new folder called Day_2, then create a new file with the name basics.rb and finally open it up in a plain text editor of your choice.

cd 100_days_of_ruby/
mkdir Day_2 && cd Day_2/ && touch basics.rb
codium .

Basic Data Types

Type the following to your text editor:

# Assigning values to variables

apples = 4 # Integer
hello = "Hello" # String
money = 6.5 # Float
is_adult = true # Boolean

In ruby you don't have to define the type of a variable before being able to assign a value to it. For example in C++ you would say int apples = 4 in ruby though you can simply assign any value to any variable that you want.

Ruby as you can see has all the basic data types that you see in other languages too. We can have Integers, Strings, Floats and Booleans.

Single and Multi line Comments

If you noticed the first line of our file starts with #, in ruby this is how you create a comment.

Comments are super useful for us developers that are going to look the code of an app. If you are building a new app and you want other people to contribute to your project, leaving comments to explain how something works is a very good habit to build. It will help others understand what you wrote but also it will help you too, if for example you haven't looked at a piece of code in a long time it can be hard to remember what exactly you were doing.

So comments are always useful and you should use them when you think that a piece of code needs some sort explanation.

There are two types of comments in ruby:

Single line comments

# I'm a single line comment. Everything we type after the character # is a comment.

Multi line comments

=begin
I'm a multi line comment.
We can type anywhere in between =begin and =end

And we can have as many lines as we want! 
=end

We use single line comments when we want to give a sort explanation to a line of code. And we use multi line comments when we want to explain something in depth (don't over do it though).

Using methods

We won't go over what methods are in depth today but we will need them. So for now methods provide a useful functionality that you can call on an object. Don't worry about it too much and add the following lines of code to our program.

puts apples.is_a?(Integer)
puts apples.is_a?(String)

Now run the program by typing ruby basics.rb. The output should be the following:

true
false

We have assigned apples = 4 so the variable apples is an Integer. Now we called the method is_a? to check what type is the variable apples. Obviously when we say apples.is_a?(Integer) it returns true since apples has the value 4 and returns false when we check if it's a String.

Basic math operations

Add the following to our program:

# Basic math operations

x = 5
y = 12

puts x + y # Addition

puts x - y # Subtraction

puts x * y # Multiplication

puts y / x # Division

puts y % x # Modulo

puts x ** 2 # Exponent

These are very self explanatory so I won't go over them. What I wanna highlight though is that when we are calculating a Division or a Modulo operation we always want one of our variables to be of type Float.

Here x and y are both Integers so when do y / x then answer will always be an Integer. Sometimes that's not a problem, for example if we had 6 / 3 that would be equal to 2 which is an Integer. But in our case we have 12 / 5 which is equal to ~2.4.

In our output we can see that the result of y / x is 2 which is wrong. To fix that we need to simply make either x or y a Float.

x = 5.0
y = 12

Run it again and you will notice that now the output is 2.4 as it should be.

Fun with Strings

As we know already a string is everything that's between " ". But there are a lot of things that we can do with Strings, we can manipulate them in a lot of ways.

Add the following to our program:

# Fun with Strings

puts "Hello," + " " + "World!" # Concatenating strings

age = 22 # age is an Integer

puts "I'm #{age} years old!" # Interpolating

Let's break everything down. In the first line we are concatenating three strings together. It might be weird at first that we are using the + plus symbol for concatenating strings but that's common with many languages.

Later we define a variable called age and assign it the value 22. But on the next line we did something weird, we used the # symbol inside of a string.

This is how we do Interpolation in ruby, we basically do #{var} and that will "embed" the value of a variable to a String.

We will end day #2 by just playing around with some String methods.

Add the following to our program:

puts hello.reverse # print the string in reverse order

puts hello.upcase # print the string with every letter being upercase

puts hello.downcase # print the string with every letter being lowercase

puts hello.length # print the length of the string 

puts hello.empty? # check if the string is empty => returns false cause it's not the case

puts "".empty? # check if the string is empty => returns true cause we have an empty string

I have explained every method with a comment even though most of them are self explanatory.

Tomorrow we will go over OOP in ruby and learn a lot more about how ruby really works.

Thanks for joining, I will see you tomorrow!

100 Days of Learning ruby - Day #1

0x-2FA — Fri, 31 Dec 2021 11:45:41 +0000

Introduction

Hi, I wanted to learn ruby and what better way than taking up the challenge of #100daysofcode. To be honest I'm not totally new to ruby, but I'm by no means an expert.

The plan is to code in ruby everyday for at least 1 hour. At the end of the session I will create a new blog here highlighting everything new I learnt in a tutorial style. This way I'm teaching you what I learnt by explaining every detail, this will only benefit me by forcing me to actually understand what I'm doing instead of just typing things.

I think that these blog posts will also help you learn ruby with me, so I welcome everyone who wants to learn ruby.

Note: I probably won't be covering Ruby on Rails or any other framework. People often mistake ruby with Ruby on Rails, so I wanted to make this disclaimer.

With all of that out of the way, let's start learning!

Day 1: Up and Running

The first thing we need to do is to install ruby and installing it can be a bit tricky some times. Depending on your operating system the process of installing ruby might be different.

Windows

To install ruby on a Windows machine it's actually pretty easy thanks to RubyInstaller. I won't go over how to install ruby using RubyInstaller cause it's really easy, just follow the steps of the installer and you will be good to go.
Gnu/Linux

Installing ruby on a Gnu/Linux machine is a bit harder depending on how much comfortable you are with the terminal of course. As far as I know there is not a one click installer for ruby as RubyInstaller for Windows. On Gnu/Linux you generally have two options:
- Package Manager
  
  Using the package manager of your distribution is generally not advised cause most of the time it doesn't have an up to date version of ruby. So I would avoid using this option even though it's easier.
- Using a Version Manager
  
  This option is generally preferred cause not only you can install the latest version of ruby but you can also manage multiple versions of ruby in your system. There are a lot of options and I will highlight the most used ones. We can use rvm (ruby version manager), rbenv with ruby-build and finally ruby-install with chruby.

Installing rvm

I'm going to use rvm for installing and managing ruby on my machine. I'm not going to go over how to install rvm since they have a really nice guide over on their website.

Just follow the instructions here and you will have rmv installed on your system in no time.

Check if you have rvm installed correctly by typing the following on your terminal:

rvm --version

You should have something similar to this:

rvm 1.29.12-next (master) by Michal Papis, Piotr Kuczynski, Wayne E. Seguin [https://rvm.io]

Installing ruby

Now that we have rvm we can easily install any version of ruby with one command. You can find all of this info on their page here.
Type the following command to install ruby 3.0.2 on your system:

rvm install 3.0.2

After this is done go ahead and use that version:

rvm use 3.0.2

Note: I have already installed ruby 3.0.2 on my system and currently the latest version of ruby is 3.1.0 and this won't affect my 100 days of code but if you want the latest version of ruby go with 3.1 instead.

Now if we did everything correctly we should have ruby 3.0.2 installed on our system, to check this type the following:

ruby --version

If you see the following then you have correctly installed ruby and we are ready to begin learning.

ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-linux]

Hello, World!

We will end day #1 of learning ruby by creating our very first ruby program. As everyone knows your first program when learning a new programming language is always the infamous Hello, World! program.

So let's begin by creating a new folder called Day_1 and then create a new ruby file with the name hello.rb.

cd 100_days_of_ruby/
mkdir Day_1 && cd Day_1/ && touch hello.rb

Now open hello.rb in a plain text editor of your choice. Type the following and save the file:

puts "Hello, World!"

To run this simple ruby program open up a terminal and type the following command:

ruby hello.rb

You will see the output Hello, World! in your terminal.

Explanation

This is a very simple ruby program with not much going. We are basically printing Hello, World! on our screen.

We do that by using the keyword puts, which prints a string of characters and also goes to the next line. We provided a string of characters by typing Hello, World! inside of " ". Finally to run the program we typed ruby hello.rb. Basically when we want to run a ruby program we just type ruby and the path to our .rb file.

Thanks for joining, I will see you tomorrow!