Intro to Ruby

Class 3


Girl Develop It is here to provide affordable and accessible programs to learn software through mentorship and hands-on instruction.

Some "rules"

  • We are here for you!
  • Every question is important
  • Help each other
  • Have fun

Homework Discussion

How was last week's homework? Do you have any questions or concepts that you'd like to discuss?


chatting = true
byes = 0
while chatting
  puts "Ask Grandma a question:"
  said = gets.chomp!
  if said == "BYE"
    byes += 1
    if byes > 2
      chatting = false
      puts "** Grandma is ignoring you **"
  elsif said == said.upcase
    year = 1930 + Random.rand(20)
    puts "NO, NOT SINCE #{year}!"
    puts "HUH?!  SPEAK UP, SONNY!"
puts "Thanks for chatting with Grandma"


puts "Enter a starting year in the format YYYY"
starting = gets.chomp!.to_i
puts "Enter an ending year in the format YYYY"
ending = gets.chomp!.to_i
puts "LEAP YEARS between #{starting} and #{ending}"

starting.upto(ending) do |year|
  divisible_by_4 = (year % 4) == 0
  not_divisible_by_100 = (year % 100) != 0
  divisible_by_400 = (year % 400) == 0
  is_leap_year = (divisible_by_4 && not_divisible_by_100)
                   || divisible_by_400
  if is_leap_year
    puts "#{year}"


  • Conditions - if, elsif, else
  • Loops - while, for
  • Arrays - [1,2,3] or %w(one two three)
  • Hashes - {"one" => 1, "two" => 2}

What we will cover today

  • Methods
  • Objects
  • Object Oriented Programming


A method is a name for a chunk of code

Methods are often used to define reusable behavior.

Let's look at a method we've already used:

=> false

=> "Fred"

If you have some code you want to reuse or organize, methods will help.

Let's Develop It!

Find the methods available on String and Integer

Do they have any similar methods?

=> "abd"

=> "aca"
=> 2
=> 0

Write a Method

Let's write a method together

def means define

subtract is the name of the method

x, y are parameters

x - y is the body of the method

x - y is also the return value

def subtract x, y
  x - y

Let's Develop It!

Let's write a method that takes in a number and tells us if it is even.

Hint: if number % 2 == 0, then it is even

def method_name(parameter)
  # method implementation

Method Return Value

Every Ruby method returns something.

Usually, it's the last statement in the method.

It could be the value sent to return if that came first.

def subtract(x,y)
  x - y
  'another thing'

return_value = subtract(5, 2)
puts return_value

def subtract(x,y)
  return x - y
  'another thing'

return_value = subtract(5, 2)
puts return_value

Arguments vs. Parameters

Technically speaking, arguments are passed and parameters are declared.

Note that the variable names don't have to match!

In this code, 5 is an argument and x is a parameter

def subtract(x,y)
  x - y

subtract(5, 2)

Splat Arguments

def greet(greeting, *names)
  names.each do |name|
    puts "#{greeting}, #{name}!"

>> greet("Hello", "Alice", "Bob", "Charlie")
Hello, Alice!
Hello, Bob!
Hello, Charlie!

Default Values

def eat(food = "chicken")
  puts "Yum, #{food}!"

>> eat
Yum, chicken!

>> eat "bananas"
Yum, bananas!

Default Hash Parameter

def add_to_x_and_y(amount, vals)
  x = vals[:x]
  y = vals[:y]
  x + y + amount

add_to_x_and_y(2, {:x => 1, :y => 2})

# same as...
add_to_x_and_y 2, :x => 1, :y => 2

# same as...
add_to_x_and_y 2, x: 1, y: 2

# same as...
add_to_x_and_y 2, y: 2, x: 1

Named Parameters

To pass variable parameters, or to pass named parameters, you can use an options hash

bake("Sourdough", :flour => "sour")
bake("Pumpernickel", :creamer => "butter")

def bake(name, options = {})
  flour = options[:flour] || "rye"
  creamer = options[:creamer] || "cream"
  puts "baking a nice #{flour} loaf with #{creamer}"

Methods & Variables

Local vars are only available in the methods where they were defined.

# Let's extract the length of the padded string into
# a local variable
def message(our_string)
  length = 80
  puts, "-")

def different_message(some_string)
  puts, "=")


An Object is the building block of a program.

Objects do things and have properties.

Object: Number
What can it do?
- Add
- Subtract
- Divide
- Multiply

What are some properties of your Number?
- Length
- Base
- Even

Object Class

Objects can be grouped by Class.

Classes define a template for objects. They describe what a certain type of object can do and what properties they have in common.

There are many kinds of objects, including String, Number, Array, Hash, Time, ...

To create an object we use .new

array = []
array =

now array refers to an object instance

Object Methods

Methods can be defined on objects.

array =

def array.delete
  puts "deleted the array"


Instance Variables

Represent object state

Names start with an @

Only visible inside the object

cookie =

def cookie.add_chips(num_chips)
  @chips = num_chips

def cookie.yummy?
  @chips > 100

cookie.yummy?   #=> true

Object Oriented Programming

  • Object Oriented Programming is one of many programming approaches: procedural, event-driven, functional, declarative...
  • These days, most programming is done in an OO language: Java, C#, C++.
  • All this means is that programs are organized around objects (data & methods).
  • You might choose OOP because Objects make things easier to understand and act as a natural way to modularize code. When a large code base is composed of many small Objects, it is easier to maintain and change.

OOP & Easy Understanding

Objects often take on names from their domain which makes them easy to conceptualize.

For example, without seeing my code, you can probably guess what a Bike object can do (or not do)

OOP & Encapsulation

One thing that makes code easier to maintain is Encapsulation which is one of the fundamentals of OOP.

Encapsulation is a nice way of saying 'put all my properties/behaviors in my capsule where other objects can't touch them'.

By assigning certain responsibilities to objects, code is more purposeful and less likely to be changed by accident.

OOP & Inheritance

Just as you inherited traits from your mom, your objects may inherit traits from other objects.

Inheritance is when you use one class as the basis for another.

You might use Inheritance if two objects have the same properties and methods. This way you don't need to write the same thing twice.

class MyString < String

my_string =

OOP & Polymorphism

  • Similar to inherited traits and behaviors, there are also polymorphic traits and behaviors.
  • Polymorphic means many forms.
  • Within OOP, this relates to different objects being able to respond to the same message in different ways.

[1, "abc"].each {|object| puts}



Practice: Do some of the exercises at the end of Chapter 8 of Learn to Program.

Prep: Read Chapter 9 of Learn To Program- don't try to do the exercises at the end yet, though.