While many modern languages offer similar features, Ruby consistently delivers a seamless and joyful experience. Whether you're building a startup MVP, a scalable enterprise application, or a lightweight API, Ruby has you covered with frameworks like Rails and Sinatra.

Despite the growing popularity of JavaScript and Python, Ruby remains a valuable language to learn, not just for its utility, but for how it teaches you to write clean, expressive, and maintainable code.

If you've heard of Ruby but never used it, this tutorial is the perfect starting point. Designed to be completed in an afternoon, it offers a glimpse into what makes Ruby so beloved by developers. While it doesn't cover every aspect of the language, Ruby's intuitive nature ensures you'll be well prepared to dive right into frameworks like Sinatra or Rails after completing it.

Code Playbacks

Code playbacks are a unique way to learn about programming. They are guided walkthroughs of code, allowing you to see not just the code itself but also the thought process behind it. This approach helps you understand not only what the code does, but why it was written that way. Here is a short video to show how to move through a code playback:

By registering on Playback Press, you’ll gain access to an AI assistant that can answer your questions about the code. This makes learning even more interactive and personalized. Watch this video to see how to work with it:

A Brief Introduction to Ruby

You can find my entire collection of Ruby code playbacks in my free book, "A Brief Introduction to Ruby". Here's a quick look at what you'll learn:

Highlights

• 1.1 Hello Ruby!!!: Write your first Ruby program and learn how to run it from the terminal.

• 1.2 Variables and Types: Explore Ruby's variables, constants, and string interpolation.

• 1.3 Selection and Looping: Master control flow with if statements, loops, and ranges.

• 1.4 Arrays: Work with arrays, one of Ruby's most versatile data structures.

• 1.5 Hashes: Learn about hashes, Ruby's equivalent of dictionaries or associative arrays.

• 1.6 Methods: Write reusable code with methods, parameters, and return values.

• 1.7 Closures: Discover how to pass code into methods and execute it with yield.

• 1.8 Iterators: Simplify data iteration with Ruby's powerful higher-order methods.

• 1.9 Classes in Ruby: Build objects with classes, instance variables, and inheritance.

• 1.10 Interacting Classes: Create cooperating classes and explore Ruby's "duck typing."

• 1.11 Unit Testing in Ruby: Write tests to ensure your code works as expected.

Conclusion

Ready to start your Ruby journey? Begin with the first playback and experience how fun and intuitive Ruby can be. Whether you're a complete beginner or an experienced developer, there's something here for everyone!

I’d love to hear your thoughts! Feel free to share your comments, questions, or feedback via email: mark@playbackpress.com. Your input helps me improve and create even better content.

If you’ve found this tutorial helpful, consider supporting my work through GitHub Sponsors. Your contributions help cover hosting costs and keep Playback Press free for everyone. Thank you for helping me continue creating educational resources for the developer community!

Which Ruby do you have?

MacOS comes with a "system Ruby" pre-installed.

Use the which command to see where Ruby is installed:

$ which ruby
/usr/bin/ruby

If you see /usr/bin/ruby, it is the pre-installed macOS system Ruby.

It's fine to use the system Ruby for running sysadmin scripts, as long as you don't alter the system Ruby by attempting to update it or add gems.

But you don't want to use it when you are developing projects in Ruby.

Ruby for development

For developing projects with Ruby, you should Install Ruby with Homebrew or use a version manager such as asdf, chruby, rbenv, or rvm.

A version manager helps if you're juggling multiple projects and can't update all at once. For a guide that compares version managers and shows the best way to install Ruby, see my article Install Ruby on a Mac.

But why not use the macOS default Ruby? Let's take a look at the reasons why it's a bad idea to use the Mac default Ruby for development.

Gem installation hassles

RubyGems are the ready-made software libraries that make development easy and fun in Ruby. Most Ruby projects use at least a few gems.

If you use the Mac system Ruby, running gem install will try to save gems to the system Ruby directory /Library/Ruby/Gems/2.6.0. That directory is owned by root, the system superuser. Ordinary users are not allowed to write to it (and you really shouldn't alter this folder).

If you try to install a gem, for example gem install rails, you'll get a permissions error:

ERROR: While executing gem ... (Gem::FilePermissionError)
You don't have write permissions for the /Library/Ruby/Gems/2.6.0 directory

It violates system security

Unix-based systems are powerful, so there's a workaround. You can install gems as a superuser to override the permissions restriction. But don't do this!

$ sudo gem install rails

Any time you are about to run sudo, you should stop and ask if you're about to shoot yourself in the foot.

In this case, you need sudo because you're altering system files that are managed by the OS. Don't do it! You may leave the system in a broken or compromised state. Even worse, a gem might contain malicious code that tampers with your computer.

Gem management

Experienced developers use Bundler to install gems and manage their dependencies.

Imagine you've got projects that use different versions of a gem (maybe there was a new gem release between your projects). Or maybe two different gems in your project rely on different versions of a dependent gem.

Bundler uses a Gemfile in your project directory to keep track of the gems you need. If you were to use sudo to install gems with the system Ruby, you'd end up with a mess of incompatible gems in the system Ruby directory.

You can work around the systems permission problem by installing Bundler with a command that uses your home directory for gems. But it's easier to install Ruby with Homebrew or use a version manager and use the Bundler that comes installed, which will correctly set up your local development environment.

Use the newest Ruby

When you start a project, use the newest Ruby release (it's 3.0 at the time this was written).

The system Ruby in macOS Catalina or Big Sur is Ruby 2.6.3, which is old. If you're just starting with Ruby, install with Homebrew and work on a project with Ruby 3.0. When you start building another project, it may be time to install a version manager so you can juggle projects with different Ruby versions.

MacOS after Big Sur

MacOS Big Sur is now the current version. Apple says:

"Scripting language runtimes such as Python, Ruby, and Perl are included in macOS for compatibility with legacy software. Future versions of macOS won’t include scripting language runtimes by default, and might require you to install additional packages."

If you're reading this at the end of 2021, the system Ruby may already be gone. If not, prepare yourself by installing Ruby with Homebrew or a version manager.

Enjoy Ruby

For developers planning to build web applications with Rails, I've written a guide, Install Rails on a Mac, which goes beyond Install Ruby on a Mac to show how to pick a version manager that will work with Node as well as Ruby.

Enjoy the pleasure of coding in Ruby! After all, it is known as a language dedicated to programmer happiness. But remember, the system Ruby is there for macOS, not for you.

A couple of months ago, when I learned Ruby-on-Rails for the first time, I had to work on a collaborative project with a coding partner. We kept running into issues, as he had a different version of Rails and Buby setup for the project. I couldn't wrap my head around how to install the versions the project needed.

Here's the guide I wish I had. It also shows you how to switch the version of Ruby or Rails you're using, depending on the projects you're working on.

First, let's get the latest version of Ruby installed. To do this, we need to install a package called RVM - Ruby version manager. This package lets us install ANY version of Ruby on our Ubuntu machine and allows us to switch between versions.

All the code here will be run using the Ubuntu CLI/terminal.

Installing RVM

1. First, we need to install a pre-requisite. Open up your Ubuntu terminal and type the command:

sudo apt-get install software-properties-common

Next, we need to add the PPA (Personal Package archive). A PPA is how we get files distributed by developers that are yet to make it to the official Ubuntu package/app store.

It's also a way for developers to distribute the latest versions of their software while waiting for Ubuntu to test and publish that software in the official store.

sudo apt-add-repository -y ppa:rael-gc/rvm

The command above adds the PPA to the list of locations we can download packages from on our Ubuntu machine.

Next, let's refresh our list of packages by running:

sudo apt-get update

Finally, let's install RVM itself.

sudo apt-get install rvm

Now restart your terminal for your changes to take effect. Then, type rvm version and hit enter to check that rvm is installed. You should get a response like this:

rvm 1.29.10 (manual) by Michal Papis, Piotr Kuczynski, Wayne E. Seguin [[https://rvm.io](https://rvm.io)]

Installing Ruby

Now we can install the latest Ruby version which is 2.7.1. Run the command rvm install 2.7.1. Alternatively, you can run rvm install ruby which will install the latest stable version (this will install v2.7.0).

To see what Ruby versions you have installed, run rvm ls. To switch between Ruby versions, run rvm use <version_number> (for example, rvm use 2.7.1).

Installing Ruby-on-Rails

The latest version of Rails is at 6.03. Rails is simply a Ruby gem, and with Ruby installed we can install Rails! Run gem install rails to install the latest version of Rails.

Finally, to check that all went well, run rails -v. You should get Rails 6.0.3.2 back, as this is the latest version at the time of publishing this article.

You can now start your first Rails project by typing rails new myapp.

Hey, you're now on Rails!

Ruby provides a variety of built-in methods you may use on numbers. The following is an incomplete list of integer and float methods.

Even:

Use .even? to check whether or not an integer is even. Returns a true or false boolean.

    15.even? #=> false
    4.even?  #=> true

Odd:

Use .odd? to check whether or not an integer is odd. Returns a true or false boolean.

    15.odd? #=> true
    4.odd?  #=> false

Ceil:

The .ceil method rounds floats up to the nearest number. Returns an integer.

    8.3.ceil #=> 9
    6.7.ceil #=> 7

Floor:

The .floor method rounds floats down to the nearest number. Returns an integer.

    8.3.floor #=> 8
    6.7.floor #=> 6

Next:

Use .next to return the next consecutive integer.

    15.next #=> 16
    2.next  #=> 3
    -4.next #=> -3

Pred:

Use .pred to return the previous consecutive integer.

    15.pred #=> 14
    2.pred  #=> 1
    (-4).pred #=> -5

To String:

Using .to_s on a number (integer, floats, etc.) returns a string of that number.

    15.to_s  #=> "15"
    3.4.to_s #=> "3.4"

Greatest Common Denominator:

The .gcd method provides the greatest common divisor (always positive) of two numbers. Returns an integer.

    15.gcd(5) #=> 5
    3.gcd(-7) #=> 1

Round:

Use .round to return a rounded integer or float.

    1.round        #=> 1
    1.round(2)     #=> 1.0
    15.round(-1)   #=> 20

Times:

Use .times to iterate the given block int times.

    5.times do |i|
      print i, " "
    end
    #=> 0 1 2 3 4

Math operations in Ruby

In Ruby you can perform all standard math operations on numbers, including: addition +, subtraction -, multiplication *, division /, find remainders %, and work with exponents **.

Addition:

Numbers can be added together using the + operator.

15 + 25 #=> 40

Subtraction:

Numbers can be subtracted from one another using the - operator.

25 - 15 #=> 10

Multiplication:

Numbers can be multiplied together using the * operator.

10 * 5 #=> 50

Division:

Numbers can be divided by one another using the / operator.

10 / 5 #=> 2

Remainders:

Remainders can be found using the modulus % operator.

10 % 3 #=> 1 # because the remainder of 10/3 is 1

Exponents:

Exponents can be calculated using the ** operator.

2 ** 3 #=> 8 # because 2 to the third power, or 2 * 2 * 2 = 8

Ruby has been in constant development since the 1990s. And like many languages, there have been syntax changes across versions. This means that it is important to be clear about which Ruby version your code expects.

Probably the most visible change came with Ruby 1.9. Previously, we wrote hashes like this:

  { :one => 1, :two => 2, :three => 3 }

This use of the ‘hashrocket’ operator (=>) was so common, that Ruby 1.9 provided a shorthand:

  { one: 1, two: 2, three: 3 }

This older code will run on any version, but the newer syntax will only run on Ruby 1.9+.

How does this cause problems?

For example, you might have decided to use a Gem which internally relies on Ruby 1.9 features. This means that your project now also relies on Ruby 1.9 features.

If you don’t specify which version of Ruby your project needs, it can be very confusing when code works on one machine, but not another.

As with most languages, it’s considered good practice to specify the version of Ruby that your code expects. This makes it much easier to manage multiple projects on your development machine, each expecting a different version of Ruby.

How do I specify my Ruby version?

There are a couple of tools which are popular for this, but both have agreed to share a common file. Many Ruby (or Rails) projects will include a simple .ruby-version file, which simply specifies a version number, for example:

2.4.2

Popular tools to help you manage your Ruby version are:

• Ruby Version Manager (RVM)
• rbenv

Let’s look at RVM.

Using RVM

RVM is typically installed (link) on a Linux, Unix or MacOS machine. It is very convenient because it hooks into the cd (change directory) command. So when you move to a new project, your .ruby-version is read automatically, and you’re automatically switched to the correct version of Ruby before you start working.

For example, you might have this sequence:

% cd ~/projects/older-project
% ruby --version

ruby 2.3.5p376 (2017-09-14 revision 59905) [x86_64-darwin16]

% cd ~/projects/newer-project
% ruby --version

ruby 2.4.2p198 (2017-09-14 revision 59899) [x86_64-darwin16]

(These examples are from a MacOS machine).

Other info on Ruby:

• An intro to Object-oriented Programming with Ruby
• Most common Ruby array methods you should know

true.class
 => TrueClass
false.class
 => FalseClass
nil.class
 => NilClass

true and false are Ruby’s native boolean values. A boolean value is a value that can only be one of two possible values: true or not true. The object true represents truth, while false represents the opposite. You can assign variables to true / false, pass them to methods, and generally use them as you would other objects (such as numbers, Strings, Arrays, Hashes).

nil is a special value that indicates the absence of a value – it is Ruby’s way of referring to “nothing”. An example of when you will encounter the nil object is when you ask for something that doesn’t exist or cannot be found:

hats = ["beret", "sombrero", "beanie", "fez", "flatcap"]

hats[0]
 => "beret" # the hat at index 0
hats[2]
 => "beanie" # the hat at index 2
hats[4]
 => "flatcap" # the hat at index 4
hats[5]
 => nil # there is no hat at index 5, index 5 holds nothing (nil)

Zero is not nothing (it’s a number, which is something). Likewise, empty strings, arrays, and hashes are not nothing (they are objects, which happen to be empty). You can call the method nil? to check whether an object is nil.

0.nil?
 => false
"".nil?
 => false
[].nil?
 => false
{}.nil?
 => false
nil.nil?
 => true
 # from the example above
hats[5].nil?
 => true

Every object in Ruby has a boolean value, meaning it is considered either true or false in a boolean context. Those considered true in this context are “truthy” and those considered false are “falsey.” In Ruby, only false and nil are “falsey,” everything else is “truthy.”

More Information:

• Learning Ruby: From Zero to Hero
• Idiomatic Ruby: writing beautiful code
• How to Export a Database Table to CSV Using a Simple Ruby Script

Ruby on Rails is an opinionated framework, and emphasizes the use of convention over configuration (CoC), and don't repeat yourself (DRY) practices. Rails can best be described as a model-view-controller (MVC) framework, and provides sensible defaults and structures for rapid application development. Lately, Rails has integrated an API module to make the creation of web-services faster and easier.

Ruby on Rails was created by David Heinemeir Hansson and is currently on it’s 6th version.

How to install Rails

Rails is downloaded in the same way as any other Ruby gem: with the gem install command. Before we download it, we’ll need to download Ruby. Afterwards we’re only 3 words away from starting with Ruby on Rails:

$ gem install rails

Rails ships with sqlite3 as the default database, which is a simple file on disk. You need to install MySQL or PostgreSQL if you want to use something more robust.

How to create a Rails application

1. After you install Ruby on Rails, it’s very simple to create a brand new application, we’ll just need 3 more words:

$ rails new your_application_name

2. If you want to use MySQL:

$ rails new <application_name> -d mysql

3. If you want to use Postgres:

$ rails new <application_name> -d postgresql

4. This command will create a folder with the _your_applicationname you informed in the last command. Next step is to go to the new directory you’ve just created:

$ cd your_application_name

5. Get the necessary gems and software packages before running your application:

$ bundle install

6. To run the rails server and see if everything went accordingly is also fast:

$ rails server

It couldn’t be anymore simple! Well, this isn’t actually 100% true, we could make it even smaller by reducing the rails server command to:

$ rails s

7. Now with your preferred browser, go to http://localhost:3000 and you’ll see: “Yay! You’re on Rails!”

Alternative method for creating a Rails application

1. Create a new directory:

$ mkdir <application_name>

2. Go into the new directory:

$ cd <application_name>

3. Create the Rails application using the Unix dot notation. This results in assigning the name of the directory to the new application:

$ rails new .

4. Start exploring the framework of the application you just created. To see a useful table of the folder structure, check out Getting Started with Rails.

Convention over Configuration

Convention over Configuration means a developer only needs to specify unconventional aspects of the application. For example, if there is a class Sale in the model, the corresponding table in the database is called sales by default. It is only if one deviates from this convention, such as calling the table “products sold”, that the developer needs to write code regarding these names. Generally, Ruby on Rails conventions lead to less code and less repetition.

What is MVC?

Model (Active record) contains the business logic and interacts with the database. Views (Action views) all of the HTML files and structure. Controller (Action controller) interacts with the views and model to direct the actions of the application.

DRY - Don’t Repeat Yourself

Don’t repeat yourself means that information is located in a single, unambiguous place. For example, using the ActiveRecord module of Rails, the developer does not need to specify database column names in class definitions. Instead, Ruby on Rails can retrieve this information from the database based on the class name.

Ruby on Rails is open source

Not only is it free to use, you can also help make it better. More than 4,500 people have already contributed code to Rails. It’s easier than you think to become one of them.

Length

The .length property returns the number of characters in a string including white-space.

"Hello".length #=> 5
"Hello World!".length #=> 12

Empty

The .empty? method returns true if a string has a length of zero.

"Hello".empty? #=> false
"!".empty?     #=> false
" ".empty?     #=> false
"".empty?      #=> true

Count

The .count method counts how many times a specific character(s) is found in a string.

This method is case-sensitive.

"HELLO".count('L') #=> 2
"HELLO WORLD!".count('LO') #=> 1

Insert

The .insert method inserts a string into another string before a given index.

"Hello".insert(3, "hi5") #=> Helhi5lo # "hi5" is inserted into the string right before the second 'l' which is at index 3

Upcase

The .upcase method transforms all letters in a string to uppercase.

"Hello".upcase #=> HELLO

Downcase

The .downcase method transforms all letters in a string to lowercase.

"Hello".downcase #=> hello

Swapcase

The .swapcase method transforms the uppercase latters in a string to lowercase and the lowercase letters to uppercase.

"hELLO wORLD".swapcase #=> Hello World

Capitalize

The .capitalize method make the first letter in a string uppercase and the rest of the string lowercase.

"HELLO".capitalize #=> Hello
"HELLO, HOW ARE YOU?".capitalize #=> Hello, how are you?

Note that the first letter is only capitalized if it is at the beginning of the string. ruby "-HELLO".capitalize #=> -hello "1HELLO".capitalize #=> 1hello

Reverse

The .reverse method reverses the order of the characters in a string.

"Hello World!".reverse #=> "!dlroW olleH"

Split

The .split takes a strings and splits it into an array, then returns the array.

"Hello, how are you?".split #=> ["Hello,", "how", "are", "you?"]

The default method splits the string based on whitespace, unless a different separator is provided (see second example).

"H-e-l-l-o".split('-') #=> ["H", "e", "l", "l", "o"]

Chop

The .chop method removes the last character of the string.

A new string is returned, unless you use the .chop! method which mutates the original string.

"Name".chop #=> Nam

name = "Batman"
name.chop
name == "Batma" #=> false

name = "Batman"
name.chop!
name == "Batma" #=> true

Strip

The .strip method removes the leading and trailing whitespace on strings, including tabs, newlines, and carriage returns (\t, \n, \r).

"  Hello  ".strip #=> Hello

Chomp

The .chomp method removes the last character in a string, only if it’s a carriage return or newline (\r, \n).

This method is commonly used with the gets command to remove returns from user input.

"hello\r".chomp #=> hello
"hello\t".chomp #=> hello\t # because tabs and other whitespace remain intact when using `chomp`

To Integer

The .to_i method converts a string to an integer.

"15".to_i #=> 15 # integer

Gsub

gsub replaces every reference of the first parameter for the second parameter on a string.

"ruby is cool".gsub("cool", "very cool") #=> "ruby is very cool"

gsub also accepts patterns (like regexp) as first parameter, allowing things like:

"ruby is cool".gsub(/[aeiou]/, "*") #=> "r*by *s c**l"

Concatenation

Ruby implements some methods to concatenate two strings together.

The + method:

"15" + "15" #=> "1515" # string

The << method:

"15" << "15" #=> "1515" # string

The concat method:

"15".concat "15" #=> "1515" # string

Index

The index method returns the index position of the first occurrence of the substring or regular expression pattern match in a string. If there is no match found, nil is returned.

A second optional parameter indicates which index position in the string to begin searching for a match.

"information".index('o') #=> 3
"information".index('mat') #=> 5
"information".index(/[abc]/) #=> 6
"information".index('o', 5) #=> 9
"information".index('z') #=> nil

Clear

Removes string content.

a = "abcde"
a.clear    #=> ""

Ruby Arrays form a core foundation in programming in Ruby, and most languages in fact. It is used so much that it would be beneficial to know and even memorize some of the most commonly used methods for arrays. If you want to know more about Ruby Arrays, we have an article about them.

For the purpose of this guide, our array will be as follows:

array = [0, 1, 2, 3, 4]

.length

The .length method tallies the number of elements in your array and returns the count:

array.length
=> 5

.first

The .first method accesses the first element of the array, the element at index 0:

array.first
=> 0

.last

The .last method accesses the last element of the array:

array.last
=> 4

.take

The .take method returns the first n elements of the array:

array.take(3)
=> [0, 1, 2]

.drop

The .drop method returns the elements after n elements of the array:

array.drop(3)
=> [3, 4]

array index

You can access a specific element in an array by accessing its index. If the index does not exist in the array, nil will be returned:

array[2]
=> 2

array[5]
=> nil

.pop

The .pop method will permantently remove the last element of an array:

array.pop
=> [0, 1, 2, 3]

.shift

The .shift method will permantently remove the first element of an array and return this element:

array.shift
=> 0  
array
=> [1, 2, 3, 4]

.push

The .push method will allow you to add an element to the end of an array:

array.push(99)
=> [0, 1, 2, 3, 4, 99]

.unshift

The .unshift method will allow you to add an element to the beginning of an array:

array = [2, 3]
array.unshift(1)
=> [1, 2, 3]

.delete

The .delete method removes a specified element from an array permanently:

array.delete(1)
=> [0, 2, 3, 4]

.delete_at

The .delete_at method allows you to permanently remove an element of an array at a specified index:

array.delete_at(0)
=> [1, 2, 3, 4]

.reverse

The .reverse method reverses the array but does not mutate it (the original array stays as is):

array.reverse
=> [4, 3, 2, 1, 0]

.select

The .select method iterates over an array and returns a new array that includes any items that return true to the expression provided.

array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
array.select { |number| number > 4 }
=> [5, 6, 7, 8, 9, 10]
array
=> [5, 6, 7, 8, 9, 10]

.include?

The include? method checks to see if the argument given is included in the array:

array = [1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]
array.include?(3)
=> true

#### .flatten
The flatten method can be used to take an array that contains nested arrays and create a one-dimensional array:

``` ruby
array = [1, 2, [3, 4, 5], [6, 7]]
array.flatten
=> [1, 2, 3, 4, 5, 6, 7]

.join

The .join method returns a string of all the elements of the array separated by a separator parameter. If the separator parameter is nil, the method uses an empty string as a separator between strings.

array.join
=> "1234"
array.join("*")
=> "1*2*3*4"

.each

The .each method iterates over each element of the array, allowing you to perform actions on them.

array.each do |element|
  puts element
end
=> 
0
1
2
3
4

.map

The .map method is the same as the .collect method. The .map and .collect methods iterate over each element of the array, allowing you to perform actions on them. The .map and .collect methods differ from the .each method in that they return an array containing the transformed elements.

array.map { |element| element * 2 }
  puts element
end
=> 
0
2
4
6
8

.uniq

The .uniq method takes in an array containing duplicate elements, and returns a copy of the array containing only unique elements—any duplicate elements are removed from the array.

array = [1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 8]
array.uniq
=> [1, 2, 3, 4, 5, 6, 7, 8]

.concat

The .concat method appends the elements from an array to the original array. The .concat method can take in multiple arrays as an argument, which will in turn append multiple arrays to the original array.

array = [0, 1, 2, 3, 4]
array.concat([5, 6, 7], [8, 9, 10])
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

More Information

• Ruby Array docs
• Six Ruby array methods you need to know
• Learning Ruby - from Zero to Hero

This is the code that you need to run. You can put it as a rake task and run it, or run it another way.

As you can see, first we import CSV— we need it to do the writing of the CSV file with the data from the database. We then choose the location and the name for the file that we want to export it to, which in our case will be a file called data.csv included under repository public.

Then we set the table that we want to export and start writing. We could also change the attributes that we want to export — we don’t have to include them all as they are in the database.

That’s it! It’s that simple and yet very helpful.

This article was originally published on Medium

I recently made a simple ideas board web app using ReactJS, Ruby-on-Rails and PostgreSQL. Below, I’ll walk you through the initial steps I took to set up basic unit tests for one of the features of my app, adding a new idea.

_Photo by [Unsplash](https://unsplash.com/photos/awU3XEzdU94?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText" rel="noopener" target="_blank" title="">Dan DeAlmeida on <a href="https://unsplash.com/search/photos/ideas?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText" rel="noopener" target="blank" title=")

Note: I’m not going to discuss the scope of tests in this post; rather, my focus is on understanding how to install some of the dependencies in order to be able to get started with writing the tests.

Background: ideas board set up

I used Node package manager to manage my project’s dependencies. If you’d like to code along, you’ll need to make sure you have Node installed on your computer.

Project features

In Rails

Models: Idea

Relationships: none

In React

Components: Navbar, IdeasContainer, Idea

Getting started with RSpec

I used RSpec to test the Rails part of my ideas board web app. To get started:

1. I added the gem ‘rspec-rails’, ‘~> 3.8’ to my gemfile.

2. I then ran bundle in my terminal window (making sure I was in the Rails directory).

3. Next, in my Rails directory, I created a new folder called spec. And then, another new folder inside that one called requests.

4. I created a new file called ideas_spec.rb. You can replace the name ideas_spec with the name of whichever model you want to test, making sure to include the _spec part to denote that it's a test file.

5. At the top of my ideas_spec.rb file, I added the following text:

require ‘rails_helper’

6. Then, in the same file, I included code describing the first test I wanted to run:

describe “add an idea”, :type => :request dodescribe “add an idea”, :type => :request do
before do
 post ‘/api/v1/ideas’
end
it ‘returns a created status’ do
  expect(response).to have_http_status(201)
end
end

7. To run my test, I typed rspec in my terminal window, making sure I was in my rails project directory.

If you’ve been following along, RSpec should run at this point and your first test should pass!

Getting started with Jest

I was pleasantly surprised to find out that the testing framework Jest is included with create-react-app! However, I also wanted to use Enzyme, a testing utility, for which I needed to install some dependencies.

1. To start off, I created a new folder called _tests_ in my app’s src directory.
2. In my client-side directory, I ran the following commands:

npm i -D react-test-renderer

npm install --save-dev jest-enzyme

npm install --save-dev enzyme enzyme-adapter-react-16

3. To configure Enzyme, I created a file in src called setupTests.js and included the following:

const Enzyme = require('enzyme');
const EnzymeAdapter = require('enzyme-adapter-react-16');
Enzyme.configure({ adapter: new EnzymeAdapter() });

4. Inside my _tests_ folder, I created a new file, called App.tests.js

5. I included the following text at the top of this file to import my components and all the testing functionality I wanted for all my tests:

import React from 'react';
import App from '../App';
import Idea from '../components/Idea';
import IdeasContainer from '../components/IdeasContainer';
import { create, update } from 'react-test-renderer';
import '../setupTests';
import { shallow, mount, render } from 'enzyme';
import { shallowToJson } from 'enzyme-to-json';

6. Underneath, I included my first unit test:

describe('Idea', () => {
  it('should render a new idea correctly', () => {
    const output = shallow(
      <Idea
      key="mockKey"
      idea={"1", "Test", "Test"}
      onClick={"mockFn"}
      delete={"mockFn2"}
      />
    );
    expect(shallowToJson(output)).toMatchSnapshot();
  });
});

7. I ran rails s in the server side directory and then npm start in the client side directory to start my ideas board on localhost:3001.

8. To run my first test, I typed the following into my terminal window (making sure I was in the client directory):

npm run test

If you’ve been following along, Jest should run at this point, your test should pass — and you’re in a great place now to write more tests!

For more information on the ideas board project, my repo can be found here.

If you made it this far, thanks for reading! I hope my post helped you get started with setting up your tests.

Object-oriented programming (OOP) is a programming paradigm organized around objects. At a high level, OOP is all about being able to structure code so that its functionality can be shared throughout the application. If done properly, OOP can lead to very elegantly written programs that have minimal code duplication.

This is opposed to procedural programming (PP), in which you build programs in sequential order and call methods when you want shared behavior between pages in the application. Common procedural programming languages include C and Go.

In this tutorial, you’ll learn the fundamental concepts of OOP for Ruby, an object-oriented programming language wherein everything is an object. We will be using Ruby since one of its defining attributes — in addition to its elegant syntax and readability — is how it implements OOP techniques. This makes it a great language to start learning OOP with.

We will cover:

• Creating classes
• Instantiating objects
• Initializing arguments
• Working with inheritance, and
• Private and public methods.

In learning these concepts, we will build out our own application: an API connector that communicates dynamically with an application that sends a text message. This will include walking through how to leverage concepts such as inheritance and object instantiation to make our code more scalable and reusable!

This brief tutorial is adapted from Next Tech’s Introduction to Ruby course, which includes an in-browser sandboxed environment and auto-checked interactive tasks to complete.

You can follow along with the code snippets in this tutorial using Next Tech’s sandbox which already has Ruby pre-installed. If you chose to use your own IDE, make sure Ruby is installed by following the instructions on the installation page.

Creating Classes

Before we begin, let’s define what an object is. At its core, an object is a self-contained piece of code that contains data (“attributes”) and behavior (“methods”) and can communicate with other objects. Objects of the same type are created from classes, which act as blueprints that define properties and behavior.

Creating a class in Ruby is fairly easy. To define a class, simply type the class word followed by the name of the class, and end it with the end word. Anything contained between class and end belongs to this class.

Class names in Ruby have a very specific style requirement. They need to start with a letter and if they represent multiple words, each new word needs also to be an uppercase letter — i.e. “CamelCase”.

We’ll start by creating a class called ApiConnector:

Classes in Ruby can store both data and methods. In many traditional OOP languages such as Java, you need to create two methods for each data element you want to be included in the class. One method, the setter, sets the value in the class. The other method, the getter, allows you to retrieve the value.

The process of creating setter and getter methods for every data attribute can be tiresome and leads to incredibly long class definitions. Thankfully Ruby has a set of tools called attribute accessors.

Let’s implement some setters and getters for some new data elements for our class. Since it’s an API connector, it would make sense to have data elements such as title, description, and url. We can add these elements with the following code:

When you merely create a class, it doesn’t do anything — it is simply a definition. In order to work with the class, we need to create an instance of it…we’ll cover that next!

Instantiation

To understand what instantiation is, let’s consider a real-world analogy. Let’s imagine that you’re building a house. The first task is to build a blueprint for the house. This blueprint would contain attributes and features of the house, such as the dimensions for each room, how the plumbing will flow, and so on.

Is the blueprint of the house the actual house? Of course not, it simply lists out the attributes and design elements for how the home will be created. So after the blueprint is completed, the actual home can be built — or, “instantiated”.

As explained in the previous section, in OOP, a class is the blueprint for an object. It simply describes what an object will look like and how it will behave. Therefore, instantiation is the process of taking a class definition and creating an object that you can use in a program.

Let’s create a new instance of our ApiConnector class and store it in a variable called api:

Now that we have an object created, we can use the api variable to work with the class attributes. For example, we can run the code:

[Out:]https://next.tech

In addition to creating attributes, you can also create methods within a class:

To access this method, we can use the same syntax that we utilized with the attribute accessors:

Putting this all together, running the full class code below will result in the url and the test_method message to be printed:

[Out:]"https://next.tech""testing class call"

Initializer Method

One thing you may find handy in Ruby development is the ability to create an initializer method. This 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.

Let’s update our ApiConnector to utilize an initializer method:

Within the initialize method, we created an instance variable for each of the parameters so that we can use these variables in other parts of the application as well.

We also removed the attr_accessor method since the new initialize method will take care of this for us. If you need the ability to call the data elements outside of the class, then you would still need to have the attr_accessor call in place.

To test if the initialize method is working, let’s create another method within the class that prints these values out:

Finally, we’ll instantiate the class and test the initialize method:

[Out:]"My title""My cool description""https://next.tech"

Working with optional values

Now, what happens when we want to make one of these values optional? For example, what if we want to give a default value to the URL? To do that, we can update our initialize method with the following syntax:

Now our program will have the same output even if we don’t pass the url value while creating a new instance of the class:

Using named arguments

Though this looks simple, passing arguments can get complex in real-world Ruby applications because some methods may take a large number of arguments. In such cases, it becomes difficult to know the order of arguments and what values to assign to them.

To avoid this confusion, you can utilize named arguments, like this:

You can enter the arguments without having to look at the order in the initialize method, and even change the order of the arguments without causing an error:

Overriding default values

What happens if we want to override a default value? We simply update our instantiation call like this:

This update will override our default value of https://next.tech, and calling api.testing_initializer will now print https://next.xyz as the URL.

Inheritance

Now, 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.

To start with, inheritance means your classes can have a hierarchy. It is best used when different classes have some shared responsibilities, since it would be a poor practice to duplicate code in each class for identical or even similar behavior.

Take our ApiConnector class. Let's say we have different API classes for various platforms, but each class shares a number of common data or processes. Instead of duplicating code in each of the API connector classes, we can have one parent class with the shared data and methods. From there, we can create child classes from this parent class. With the way that inheritance works, each of the child classes will have access to the components provided from the parent class.

For example, say we have three APIs: SmsConnector, PhoneConnector, and MailerConnector. If we wrote code individually for each of these classes, it would look like this:

As you can see, we are simply repeating the same code across different classes. This is considered a poor programming practice that violates the DRY (Don’t Repeat Yourself) principle of development. Instead, we can make an ApiConnector parent class, and each of the other classes can inherit the common functionality from this class:

By leveraging inheritance, we were able to cut all of the duplicate code throughout our classes.

The syntax for using inheritance is to define the child class name, followed by the &lt; symbol, then the parent class name — i.e. our SmsConnector, MailerConnector, and PhoneConnector classes inherit from the ApiConnector class .

Each of these child classes now has access to the full set of elements provided in the parent ApiConnector class. For example, if we create a new instance of SmsConnector with the following parameters, we can call the send_sms method:

[Out:]Sending SMS message with the title 'Hi there!' and description 'I'm an SMS message'.

A rule of thumb in OOP is to ensure that a class performs a single responsibility. For example, the ApiConnector class should not send SMS messages, make phone calls, or send emails since that would be three core responsibilities.

Private and Public Methods

Before we dive into private and public methods, let’s first go back to our original ApiConnector class and create a SmsConnector class that inherits from ApiConnector. In this class, we will create a method called send_sms that will run a script that contacts an API:

This method will send a title and url to an API, which will in turn send an SMS message. Now we can instantiate the SmsConnector class and call the send_sms message:

Running this code will contact the SMS API and send the message. You can go to the bottom of this page to see your message!

Now, using this example, let’s discuss the types of methods provided by classes.

The send_sms method is a public method. This means that anyone working on our class can communicate with this method. This may not seem like a big deal if you are working on an application that no one else is working on. However, if you build an API or code library that is open sourced for others to use, it's vital that your public methods represent elements of functionality that you actually want other developers to use.

Public methods should rarely, if ever, be altered. This is because other developers may be relying on your public methods to be consistent, and a change to a public method may break components of their programs.

So, if you can’t change public methods, how can you work on a production application? That’s where private methods come in. A private method is a method that is only accessed by the class that it is contained in. It should never be called by outside services. This means that you can alter their behavior, assuming that these changes don’t have a domino effect and alter the public methods that they may be called from.

Usually private methods are placed at the end of the file after all the public methods. To designate private methods, we use the private word above the list of methods. Let’s add a private method to our ApiConnector class:

Notice how we’re calling this method from the inside of the initialize method of the ApiConnector class? If we run this code, it will give the following output:

[Out:]A secret message from the parent class

Now child classes have access to methods in the parent class, right? Well, not always. Let’s remove the secret_method method from the initialize method in ApiConnector and try to call it from our SmsConnector child class, as shown here:

[Out:]Traceback (most recent call last):main.rb:29:in `<main>': private method `secret_method' called for #SmsConnector:0x000056188cfe19b0> (NoMethodError)

This is because the SmsConnector class only has access to the public methods from the parent class. The private methods are, by their nature, private. This means that they can only be accessed by the class that they are defined in.

So a good rule of thumb is to create private methods when they should not be used outside the class and public methods when they have to be available throughout the application or used by outside services.

Wrapping up

I hope you enjoyed this quick tutorial on the fundamental concepts of object-oriented programming in Ruby! We covered creating classes, attribute accessors, instantiation, initialization, inheritance, and private and public methods.

Ruby is a powerful object-oriented language used by popular applications, including our own here at Next Tech. With this foundational knowledge of OOP, you’re well on your way to developing your own Ruby apps!

If you’re interested in learning more about programming with Ruby, check out our Introduction to Ruby course here! In this course we cover core programming skills, such as variables, strings, loops, and conditionals, more advanced OOP topics, and error handling.

In computer science, there is the concept of a linear data structure, which means that the data are structured in a linear way in which order matters. There are Arrays and Linked Lists, but today I’ll be talking mostly about arrays, and a little about linked lists.

Most object-orientated languages come with Arrays, whereas most _f_unctional languages come with Linked Lists (see why in another one of my articles, mentioned at the bottom of this article).

There’s a good reason for this differentiation which we will dive into later. For now let’s just have a quick look at the differences between the two data structures. To do this, we’ll need to take a trip down memory lane.

Rewind Time

Objects and functions and everything that we know about computers, are fundamentally stored in bits and bytes in the computer.

In languages like Java and C, you have to explicitly declare the size of an array beforehand.

Hold up, but Ruby does not do that?

In Ruby, we use Array for our linear data structures. We can add seemingly infinite things into a Ruby array and it would not matter as far as we are concerned.

That’s great isn’t it?! That means arrays are infinitely large right? And that Ruby is the superior language? Lucky us!

But not so fast. pops your bubble

There are no infinite size arrays; what you see in Ruby is what we call a Dynamic Array, and it comes with a cost.

To understand what dynamic arrays are, let’s first take a look at how arrays are represented in memory. Since MRI Ruby (Matz’ Ruby Interpreter) compiles down to C code, we’ll look at how arrays are represented in C.

C-ing is believing

We’ll dive into a little bit of C code to help us C a little better… :)

In lower level languages like C, you have to deal with pointers and memory allocation yourself. Even if you have not dealt with C before (disclaimer — neither have I), you may have C-een one of the most (in)famous examples below:

Let’s break down this bit of code:

• malloc doesn't have any magic meaning behind it, it literally stands for memory allocation
• malloc returns a pointer
• malloc takes in an argument, which is the size the memory you want the program to allocate for you.
• 100 * sizeof(int) tells the program that we want to store 100 integers, so allocate us 100 * the size of what each integer would occupy.
• ptr/pointer stores reference to the memory address.

Timmy stores luggage!

If the above example did not really make sense, try this analogy. Think of memory allocation as a luggage concierge. It works like this:

• Timmy goes to the counter, tells the concierge that he has 2 pieces of luggage, about this big, and that that he’d like to store them in the storeroom.
• The concierge takes a look at the store room and go “Yes, we’ve got some room at the designated B4 area and will allocate that space to store your luggage".
• They hand Timmy a pick-up card with the designated area on it, B4 in our case.
• Timmy is happy, goes around doing whatever, and when he wants to pick-up his luggage, he goes back to the counter and shows them his pick-up card. “Have you C-een my luggage?”

In our example, Timmy’s luggage is the data, the pick-up card is the pointer (it states where Timmy’s bag is stored). The place that the concierge is storing Timmy’s luggage is the memory block, and the counter is the program.

By showing the counter (the program) Timmy’s card (pointer/memory address), Timmy can retrieve his luggage (data). Bonus? Because they know exactly where Timmy’s bag is stored — B4, this means that they can retrieve all Timmy's luggage relatively quickly!

Also, ever wondered why you access elements in array with index, like so?

This is because the array holds the references to the memory block, and the index is telling it the offset.

An analogy for that is if I ask you to look for Timmy in a queue of 20 people, you would logically have to ask each of them if they were Timmy. But, if I told you Timmy is the 6th (index) from the first person (your original pointer), you know exactly where to look.

Retrieving elements in arrays is fast exactly because of this — the program doesn’t have to look through all 100 elements to find what you’re looking for. If you’ve got the index, it just has to add the offset to the original memory address, and the droid that you were looking for will be right there!

What are dynamic arrays then?

So I’ve told you a little about how arrays are represented in memory, but now it’s time to talk about some cons.

Remember how you have to explicitly declare the amount of memory you need? This means that the array will find a spot that will fit exactly your size. There’s no guarantee that it will be able to fit more than what you have (because the memory block right behind it might be occupied).

Back to our luggage analogy: think of it as if Timmy was to store 2 pieces of luggage, and B4can store exactly 2 pieces of luggage, so they allocate that to Timmy. Now for some reason Timmy wants to store another piece of luggage, but B4 can't store 3 pieces, only 2, so what do they do?

They take all of his existing luggage, move it into a new spot that can fit more than 3 pieces, and then store all of them together.

That is an expensive operation but it’s exactly how memory works too!

In Ruby, you don’t have to declare a specific size before hand, but that’s because Ruby handles it for you automagically through dynamic arrays.

What a dynamic array does is that if the array is nearing its full capacity, it’ll automatically declare a new, bigger array and move all existing elements into it, and the old array is then garbage collected. How much bigger? The growth factor is usually 2; double the size of the current array.

In fact, don’t take my word for it.

Ruby has an ObjectSpace module that allows us to interact with current objects living in memory. We can use this module to take a peek at the memory usage of our dynamic array — sounds exactly like what we want!

I have written a small Ruby script that calculates the growth factor of the dynamic array. Feel free to take a look at it here, and if you do, you can see that Ruby arrays have a 1.5x growth factor (that is, they make an array that’s 50% bigger on every copy).

I know what arrays are, what are linked lists?

Keep in mind that although arrays and linked lists are both considered linear data structures, they have one big difference between them.

Elements in an array are stored literally right next to each other in memory (so we can have index for fast lookups). But nodes in linked lists have no such restriction (which is why there’s no index lookup for linked lists) — each and every item can be stored anywhere on the memory block.

It’s almost as if Timmy’s trying to store 5 pieces of luggage, and the concierge does not have a space and decides to leave them all over the place. Sounds unorganized?

Also if they are stored in different places, how do you know which bags are Timmy’s? Hint: Just keep track of the next node/bag! In our case, the concierge keeps them separately but with a tag on each of them that points to the next bag.

A node in a linked list consists of two parts — the data part and a pointer to the next node. This is how they’re able to maintain the linear part of it -- they still have the concept of order, they just don't have to be stored in order literally!

node = [ data | pointer ]

For example, given the following example stored in memory:

[C | D] [A | B] [B | C] [D | nil]

This bits look like it’s out of order — but if I had told you that the first element is A, you would be able to tell me the exact order of the list:

list = [A -> B -> C -> D -> nil]

There’s a lot of interesting things that you can do with linked lists which I’m not going to dive into here (also a lot on Big O that I didn’t talk about). But there are already a ton of good articles out there on data structures. If you made it here, I suggest you to read from Ali’s blogpost here.

thank u, next: an introduction to linked lists
_In this post, we are going to be talking about the linked list data structure in the language of "thank u, next" by…_dev.to

You can also read more about List/Cons on Wiki here.

Closing Note

I initially wrote this article for a slightly different topic — [ Elixir | Why Linked Lists?], but found it took way too long to explain how arrays work before I was able to explain explore why Elixir uses linked lists. So I have separated them into two articles.

In that article, I talk about why functional languages use linked lists as their linear data structure. Do check it out!

[ Elixir | Why Linked Lists? ]
_I've always thought data structures are cool, but you know what's cooler? Seeing them in the wild! While going through…_dev.to

Sources

1. https://medium.com/@rebo_dood/ruby-has-a-memory-problem-part-1-7887bbacc579 — This is where I found out about additional ObjectSpace methods by requiring it

Originally posted on dev.to

Rails 6.0 is almost here. The stable version will be released on April 30. The Rails 6.0 beta1 was released on January 15. As Rails releases always are, Rails 6.0 is also action-packed. There are two major frameworks newly introduced, Action Mailbox and Action Text. In this post, let's take a quick look at Action Text by using it in a small app.

courtesy:wikipedia

Action Text

Action Text allows us to bring rich text content and editing to Rails. This means we can perform operations like formatting text, embedding images, formatting links, adding lists and other editor-like feature to a text field.

This is done by including the Trix editor into the framework. The RichText content generated by the Trix editor is saved in its own RichText model that’s associated with any existing Active Record model in the application. All embedded images or other attachments are automatically stored using Active Storage.

Let us start building our Rails app which will be a blogger app. The app is created in Rails 6.0, so the ruby version must be >2.5.

In the terminal type

rails new blog --edge

The -- edge flag fetches the latest rails version or edge version of the rails.

Action Text expects web packer and ActiveStorage to be installed. The active storage is already present in the Rails app. So we need

gem “image_processing”, “~> 1.2” #uncomment from Gemfilegem ‘webpacker’

in the gem file.

Now run

bundle install.

Next, we need to create a config/webpacker.yml:

bundle exec rails webpacker:install

Now let us start our Rails Server.

Great, let’s quickly build our app. The app will have only one model Article.

Let us create a controller for articles:

rails g controller Articles index new create show edit update destroy — no-helper — no-test-frameworks

And then configure our routes:

Rails.application.routes.draw do resources :articlesend

Next, we need to create our model. Our Articles model will have two fields: they are title and text. text must be the field that accepts Rich Text Format. So in the migration, we need to add only the title field. The text field will be handled by ActionText.

Let’s generate the model

rails g model Articles title:string — no-test-framework

and run the migrations:

rails db:migrate

Now let us add ActionText part. For that first run

rails action_text:install

This will add all the dependencies required by Action Text. Most notably, this will add a new file javascript/packs/application.js and two action-storage migrations.

Run the migrations again using

rails db:migrate

Now we can add the text part of our model. Go to app/models/article.rb and add the following line

has_rich_text **:text**

text is the field name we are providing. It can be anything like body or content etc.

Now our model becomes

class Article < ApplicationRecord has_rich_text :textend

Before we build our form, let’s create our controller logic for the creation of articles:

class ArticlesController < ApplicationController  def create   @article = Article.new(article_params)   @article.save   redirect_to @article end

 private def article_params   params.require(:article).permit(:title, :text) end

end

We can now create the form for the blog. In app/views/articles/new.rb add the following form code:

<%= form_with scope: :article, url: articles_path, local: true do |form| %>

<p>    <%= form.label :title %><br>    <%= form.text_field :title %>  </p>   <p>    <%= form.label :text %><br>    <%= form.rich_text_area :text %>  </p>   <p>    <%= form.submit %>  </p><% end %>

Notice that for text field we are using form.rich_text_area which is provided by Action Text.

Let us render our page:

Awesome!!

We now have an awesome text editor for creating our article.

Before we start playing with the editor, let’s quickly implement the show functionality of the blog, so that we can see the articles we have created.

In app/controllers/articles_controller.rb add the following function:

 def show   @article = Article.find(params[:id]) end

Also, we need to create a view for this.

Create the file app/views/articles/show.html.erb and add the following code:

<p>Article Title:<strong><%= @article.title %></strong></p><p>Article Text:<strong><%= @article.text %></strong></p>

<%= link_to ‘Create new’,new_article_path %>

That's it. Our app is done. Now let's check the various features available in the text editor provided by ActionText.

We can see that ActionText provides almost all the functionalities of a normal rich text-editor like formatting the text as bold, italic, adding strike-throughs, quotes, links, dragging and dropping images, etc.

After saving this, we can see the saved post from the show page.

Great!

This is a very small example that displays the potential of ActionText. Hope it was helpful. Do give it a try.

A vast majority of web apps deal with rich content in some way. So I believe this new feature of Rails can make the lives of many developers easier.

Kudos to DHH and all the awesome people behind this.

https://github.com/amkurian/Rails-6.0_action_text_demo

Some Useful Links:

Action Text Overview - Ruby on Rails Guides
_Action Text OverviewThis guide provides you with all you need to get started in handling rich text content.After…_edgeguides.rubyonrails.org

In my opinion, one of the most powerful programming techniques is recursion. For readers new to programming — it is simply a function or method calling itself. To make the introduction simpler we have a method below that calls another method:

def outer_method(name)       (R1)
  inner_method + name
end
def inner_method             (R2)
  "Hello "
end
print outer_method("Steve") -> #"Hello Steve"

In the above method outer_method, which takes in a string as argument, calls inner_method, which simply returns the string “Hello “ inside it. Recursion is similar in that, say in this case, outer_method simply calls itself:

def outer_method(name)              (R3)
  outer_method("hello ") + name
end (R3)

One caveat, though, with code R3 above — it will run until the computer complains that resources are not enough to keep processing the method. It’s like running an infinite loop except that infinite loops don’t necessarily raise exceptions. The reason for this is that code R3 doesn’t have a ‘terminal state’ or a point where it doesn’t ‘recurse’ anymore.

We can solve this by including a terminal state:

def outer_method(name)                 (R4)
  return name if name == "hello "
  outer_method("hello ") + name
end

The first line inside the method definition simply states that if the argument name is equal to ‘hello’ then simply return name. That will then ignore any line after it. Therefore in the second line, the code outer_method(“hello “) will simply give the string “hello “ to be added to whatever name is in the main argument. So the same print outer_method(“Steve”) will result in the output “hello Steve” as well.

OK then, that may not be the best example for describing recursion (as the recursive version in this case doesn’t have that much advantage over the non-recursive one). But working on the binary tree height problem, we will see that recursion is so much simpler to understand and faster to run.

For this discussion let me put again the same example as I showed in the previous article:

Figure 1: Simple binary tree

which we can represent as the following array:

tree = [1, 7, 5, 2, 6, 0, 9, 3, 7, 5, 11, 0, 0, 4, 0] (T0)

The indices of the left and right children of any sub tree can be determined as follows:

left child of tree[i] is at index 2*i + 1 (T1)
right child of tree[i] is at index 2*i + 2 (T2)

If you’re puzzled about how the figure above became the array following it, I’ll direct you to read the previous article on the iterative method for clarification.

And again the formula for calculating the height of a binary tree, as well as the heights of any of its sub trees, is:

height = 1 + max of(left_child_height, right_child_height) (T3)

Now with these we can outline the steps to develop a recursive program.

Step 0: Set default values — To make the initial method call simple, I always like setting default values for the arguments that will change during each recursive call. Since we will repetitively compute heights, our indices will always change.

For instance, to find the height of the root’s (tree[0]) left child we will need to call the method on that left child (whose index is at 2*(0) + 1). Therefore, our method definition will be:

def tree_height_recursive(tree_array,i=0) (S0.1)

to indicate that for the initial call we are calling it on the root element. This will simply allow us to call tree_height_recursive by inputting only the tree_array. However, this also means, as we will see in the simulation afterwards, we can find the height of any sub tree by simply including its index as the second argument in the method call.

Step 1: Find terminal state — At which point do we simply return a value and not do any further recursive calls? In our binary tree problem, the terminal state is at:

return 0 if tree[i].nil or tree[i] == 0 (S1.1)

It simply says that if the element at index i does not exist or if its value is 0 then simply return 0. Logically, a non-existing sub tree will not have any height.

Step 2: Find the height of the left child — this is where the magic of recursion starts to benefit us. We don’t need any fancy code. No more declaring another array to hold the height of each element. No more multiple variable definitions for height indices and the heights themselves, just:

right_child_height = tree_height_recursive(tree_array, 2*i + 2)

We simply pass the index of the left child as second argument. Can you see why?

We do the same for finding the right child’s height next.

Step 3: Find the height of right child — Likewise, we simply do a recursive call to our method but passing the index of the right child as second argument:

right_child_height = tree_height_recursive(tree_array, 2*i + 2)

Now that we have the heights of the left and right children, we can now compute the total height.

Step 4: Calculate and return total height — As code T3 states, we just add 1 and the height of whichever is taller between the left and right children.

total_height = 1 + [left_child_height, right_child_height].max (S4.1)

Since S.4 will be the last statement in our method, then the evaluated total_height will be returned. Remember that if the conditions in S1.1 hold true (our terminal state) then none of Steps 2–4 will run and the method will simply return 0.

The full method below:

Comparing this to the iterative method, the recursive version took 3 fewer steps and 4 fewer variable definitions. The code also (excluding empty spaces and comments) is 7 lines fewer. On top of it, the recursive code will run 2x faster (using the benchmark built-in Ruby module). This is a big advantage if we’re running the method on binary trees hundreds of levels tall.

Now let’s do the same simulation as we did before. For the tree at T0 we run the recursive method:

tree = [1, 7, 5, 2, 6, 0, 9, 3, 7, 5, 11, 0, 0, 4, 0]

puts tree_height_recursive(tree_array)-> #should give us 4

Note that since we have a default i=0 in our method definition we don’t need to specify the index here because we are finding the height of the whole tree. To make this simulation more intuitive we shall create an imaginary array called call_stack where push every call to tree_height_recursive.

So then when we call the method the first time (the main call), we store it in a temporary variable ht_0 and push it to call_stack:

ht_0 = height of tree[0] = tree_height_recursive(tree_array,i=0)

call_stack = [ht_0]

We then run Step 1:

tree[0].nil? -> #falsetree[0] == 0 -> #false, it is 2

Since this results in false, we go ahead to Step 2:

since i= 0, then 2*i + 1 = 2*0 + 1 = 1:

left_child_height = tree_height_recursive(tree_array,1)

Since we cannot readily determine this height so then we push it again to call_stack:

ht_1 = left_child_height = tree_height_recursive(tree_array,1)

call_stack = [ht_0,ht_1]

Then upon doing Step 3:

ht_2 = right_child_height = left_child_height = tree_height_recursive(tree_array,)

call_stack = [ht0,ht1,ht2]

We cannot proceed to Step 4 until all the items in call_stack have been evaluated by our program and popped off from call_stack (which should happen for every time each height has been evaluated).

So we will also do the same for each of the succeeding heights. For instance, to compute ht1 we know that we have to compute for its own left and right children’s heights too. So that means the method will be called for them too. So as not to prolong this article, the reader is invited to try this on paper.

Ultimately, the method will be called recursively with i = 14 as second argument. Thus, at this point, call_stack will be:

call_stack = [ht0,ht1,ht2,ht3,ht4,ht5,ht6,ht7,ht8,ht9,ht10,ht11,ht12,ht13,ht14]

Now we will evaluate each. Note that from tree[7] up to tree[14] the elements don’t have any children. So we can simply evaluate their heights as 1 or 0 (depending on whether tree[i] is 0 or not (where i ≥ 7):

ht14 = 0

ht13 = 1

ht12 = 0

ht11 = 0

ht10 = 1

ht9 = 1

ht8 = 1

ht7 = 1

Again, when these heights are evaluated we simply pop them off successively from call_stack. After which, call_stack will appear as follows:

call_stack = [ht0, ht1, ht2, ht3, ht4, ht5, ht6]

Now, to evaluate ht6 we must remember that it is the call to tree_height_recursive(tree_array, 6). Inside this call we also call on the method to compute for the heights of the left and right children of tree[6]. These we previously already evaluated as ht13 and ht14. So then:

ht6 = 1 + [ht13, ht14].max = 1 + [1,0] = 1 + 1 = 2

So we now evaluate ht5, which is the height of tree[5]. We know the heights of its children are ht11 and ht12

ht5 = 1 + [ht11,ht12].max = 1 + [0,0].max = 1 + 0 = 1

Doing the same for ht4 to h1 (again the reader is invited to do the confirmation on paper):

ht4 = 1 + [ht9,ht10].max = 1 + [1,1].max = 1 + 1 = 2

ht3 = 1 + [ht7, ht8].max = 1 + [1, 1].max = 1 + 1 = 2

ht2 = 1 + [ht5, ht6].max = 1 + [1,2].max = 1 + 2 = 3

ht1 = 1 + [ht3, ht4].max = 1 + [2,2].max = 1 + 3 = 3

Again, we pop out each height from call_stack as we evaluate it so after evaluating ht1 the call_stack appears as follows:

call_stack = [ht0]

Now evaluating ht0 is returning to the main call to tree_height_recursive, so this is the remaining Step 4:

ht0 = 1 + [ht1, ht2].max = 1 + [3, 3].max = 1 + 3 = 4ortotal_height = 1 + [left_child_height, right_child_height].max

Which will return 4 as the result of the main method call.

As I keep mentioning, doing this on paper whether during the algorithm formulation or during simulation will help a lot in understanding it. This same method can also be used to determine the height of any of the sub trees inside the tree_array, for instance to determine only the height of the tree’s left child:

puts tree_height_recursive(tree_array, 1) -> #will print out 3

Or any of the lower sub trees:

puts tree_height_recursive(tree_array, 3) -> #will print out 2

Wrapping up

The key takeaway in creating a recursive algorithm, in my perspective, is setting the terminal state. Again, this is the scenario wherein the main method will not have to do any recursive call to itself. Without this, the method will just keep calling itself until the computer blows up (hyperbolically speaking…). When we have the terminal state we can easily set the arguments for the recursive calls and know that our method will safely return the value we expect.

Finally, working on algorithms challenge our minds to think. As software engineers, or even engineers in general, our main task is to solve problems. We, therefore, need to develop our critical thinking skills.

If for a problem, our first option is always ‘google it’ and copy/paste other people’s code without fully understanding the problem and the copied solution, then we are defeating ourselves.

So my suggestion is always have pen and paper ready and not immediately type code when faced with an algorithm challenge. Simulate the problem for simple inputs then come up with the code after you determine the steps (like I outlined them above).

Follow me on Twitter | Github