notebooks/Quickstart.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ruby in Twenty Minutes\n",
    "\n",
    "This notebook takes notes from the [Ruby official quickstart](https://www.ruby-lang.org/en/documentation/quickstart/) tutorial.\n",
    "\n",
    "In the official guide, all examples are tested using the Interactive Ruby environment `irb`. But in order to have a copy of this tutorial, I have decided to use Jupyter instead.\n",
    "\n",
    "You can follow the [official documentation](https://github.com/SciRuby/iruby) for installing `iruby`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "  - [Hello World](#Hello-World)\n",
    "  - [Methods](#Methods)\n",
    "  - [Classes](#Classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello World\n",
    "\n",
    "`puts` is the basic command to print something out in Ruby."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "puts \"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we capture the result given by `puts` we can see that it is `nil`, which is Ruby’s absolutely-positively-nothing value. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods\n",
    "\n",
    "What if we want to say “Hello” a lot without getting our fingers all tired? We need to define a method!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":hi"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def hi\n",
    "  puts \"Hello World\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code `def hi` starts the definition of the method. It tells Ruby that we’re defining a method, that its name is `hi`.\n",
    "\n",
    "The next line is the body of the method, the same line we saw earlier: `puts \"Hello World\"`.\n",
    "\n",
    "Finally, the last line `end` tells Ruby we’re done defining the method.\n",
    "\n",
    "Ruby’s response `:hi` tells us that it knows we’re done defining the method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Brief, Repetitive Lives of a Method\n",
    "\n",
    "Now let’s try running that method a few times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "hi\n",
    "hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling a method in Ruby is as easy as just mentioning its name to Ruby. If the method doesn’t take parameters that’s all you need. You can add empty parentheses if you’d like, but they’re not needed.\n",
    "\n",
    "What if we want to say hello to one person, and not the whole world? Just redefine `hi` to take a name as a parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Carlos\n"
     ]
    }
   ],
   "source": [
    "def hi(name)\n",
    "  puts \"Hello #{name}\"\n",
    "end\n",
    "\n",
    "hi(\"Carlos\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Interpolation\n",
    "\n",
    "What’s the `#{name}` bit? That’s Ruby’s way of inserting something into a string. The bit between the braces is turned into a string (if it isn’t one already) and then substituted into the outer string at that point. You can also use this to make sure that someone’s name is properly capitalized:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Carlos\n"
     ]
    }
   ],
   "source": [
    "def hi(name = \"World\")\n",
    "  puts \"Hello #{name.capitalize}\"\n",
    "end\n",
    "\n",
    "hi \"carlos\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A couple of other tricks to spot here.\n",
    "\n",
    "One is that we’re calling the method without parentheses again. If it’s obvious what you’re doing, the parentheses are optional.\n",
    "\n",
    "The other trick is the default parameter `\"World\"`. What this is saying is “If the name isn’t supplied, use the default name of `\"World\"`”."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modules Group Code by Topic\n",
    "\n",
    "`Math` is a _built-in_ module for mathematics. Modules serve two roles in Ruby. This shows one role: grouping similar methods together under a familiar name. `Math` contains methods like `sqrt()`, `sin()` and `tan()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Math.sqrt(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "What if we want a real greeter around, one that remembers your name and welcomes you and treats you always with respect. You might want to use an object for that. Let’s create a “Greeter” class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":say_bye"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Greeter\n",
    "  def initialize(name = \"World\")\n",
    "    @name = name\n",
    "  end\n",
    "\n",
    "  def say_hi\n",
    "    puts \"Hi #{@name}!\"\n",
    "  end\n",
    "\n",
    "  def say_bye\n",
    "    puts \"Bye #{@name}, come back soon.\"\n",
    "  end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new keyword here is `class`. This defines a new class called Greeter and a bunch of methods for that class. Also notice `@name`. This is an instance variable, and is available to all the methods of the class. As you can see it’s used by `say_hi` and `say_bye`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Cris!\n",
      "Bye Cris, come back soon.\n"
     ]
    }
   ],
   "source": [
    "greeter = Greeter.new(\"Cris\")\n",
    "greeter.say_hi\n",
    "greeter.say_bye"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the `greeter` object is created, it remembers that the name is _Cris_. Hmm, what if we want to get at the name directly?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# greeter.@name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nope, can’t do it.\n",
    "\n",
    "### Under the Object’s Skin\n",
    "\n",
    "Instance variables are hidden away inside the object. They’re not terribly hidden, you see them whenever you inspect the object, and there are other ways of accessing them, but Ruby uses the good object-oriented approach of keeping data sort-of hidden away.\n",
    "\n",
    "So what methods do exist for `Greeter` objects?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:say_hi, :say_bye, :to_json, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :public_method, :method, :public_send, :singleton_method, :define_singleton_method, :extend, :clone, :to_enum, :enum_for, :<=>, :===, :=~, :!~, :nil?, :eql?, :respond_to?, :freeze, :inspect, :object_id, :send, :to_s, :display, :class, :frozen?, :tap, :then, :yield_self, :hash, :singleton_class, :dup, :itself, :!, :==, :!=, :__id__, :equal?, :instance_eval, :instance_exec, :__send__]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Greeter.instance_methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That’s a lot of methods. We only defined two methods. What’s going on here? Well this is all of the methods for `Greeter` objects, a complete list, including ones defined by ancestor classes. If we want to just list methods defined for `Greeter` we can tell it to not include ancestors by passing it the parameter `false`, meaning we don’t want methods defined by ancestors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:say_hi, :say_bye]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Greeter.instance_methods(false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s see which methods our `greeter` object responds to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter.respond_to?(\"name\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter.respond_to?(\"say_hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter.respond_to?(\"to_s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, it knows `say_hi`, and `to_s` (meaning convert something to a string, a method that’s defined by default for every object), but it doesn’t know name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Altering Classes—It’s Never Too Late\n",
    "\n",
    "But what if you want to be able to view or change the name? Ruby provides an easy way of providing access to an object’s variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:name, :name=]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Greeter\n",
    "  attr_accessor :name\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Ruby, you can reopen a class and modify it. The changes will be present in any new objects you create and even available in existing objects of that class. So, let’s create a new object and play with its `@name` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Greeter:0x00007f80880ae0c8 @name=\"Nico\">"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter = Greeter.new(\"Nico\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter.respond_to?(\"name\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter.respond_to?(\"name=\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Nico!\n"
     ]
    }
   ],
   "source": [
    "greeter.say_hi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Fran\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter.name = \"Fran\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Greeter:0x00007f80880ae0c8 @name=\"Fran\">"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Fran\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeter.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Fran!\n"
     ]
    }
   ],
   "source": [
    "greeter.say_hi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `attr_accessor` defined two new methods for us, `name` to get the value, and `name=` to set it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Greeting Anything and Everything, MegaGreeter Neglects None!\n",
    "\n",
    "This greeter isn’t all that interesting though, it can only deal with one person at a time. What if we had some kind of MegaGreeter that could either greet the world, one person, or a whole list of people?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":say_bye"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MegaGreeter\n",
    "  attr_accessor :names\n",
    "\n",
    "  # Create the object\n",
    "  def initialize(names = \"World\")\n",
    "    @names = names\n",
    "  end\n",
    "\n",
    "  # Say hi to everybody\n",
    "  def say_hi\n",
    "    if @names.nil?\n",
    "      puts \"...\"\n",
    "    elsif @names.respond_to?(\"each\")\n",
    "      # @names is a list of some kind, iterate!\n",
    "      @names.each do |name|\n",
    "        puts \"Hello #{name}!\"\n",
    "      end\n",
    "    else\n",
    "      puts \"Hello #{names}!\"\n",
    "    end\n",
    "  end\n",
    "\n",
    "  # Say bye to everybody\n",
    "  def say_bye\n",
    "    if @names.nil?\n",
    "      puts \"...\"\n",
    "    elsif @names.respond_to?(\"join\")\n",
    "      # Join the list elements with commas\n",
    "      puts \"Goodbye #{@names.join(\", \")}. Come back soon!\"\n",
    "    else\n",
    "      puts \"Goodbye #{@names}. Come back soon!\"\n",
    "    end\n",
    "  end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "Goodbye World. Come back soon!\n"
     ]
    }
   ],
   "source": [
    "mg = MegaGreeter.new\n",
    "mg.say_hi\n",
    "mg.say_bye"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Pablo!\n",
      "Hello Jesús!\n",
      "Hello Alberto!\n",
      "Hello Kevin!\n",
      "Hello Jaime!\n",
      "Goodbye Pablo, Jesús, Alberto, Kevin, Jaime. Come back soon!\n"
     ]
    }
   ],
   "source": [
    "mg.names = [\"Pablo\", \"Jesús\", \"Alberto\", \"Kevin\", \"Jaime\"]\n",
    "mg.say_hi\n",
    "mg.say_bye"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "...\n",
      "...\n"
     ]
    }
   ],
   "source": [
    "mg.names = nil\n",
    "mg.say_hi\n",
    "mg.say_bye"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cycling and Looping—a.k.a. Iteration\n",
    "\n",
    "If the `@names` object responds to `each`, it is something that you can iterate over, so iterate over it and greet each person in turn.\n",
    "\n",
    "```ruby\n",
    "if @names.respond_to?(\"each\")\n",
    "  # @names is a list of some kind, iterate!\n",
    "  @names.each do |name|\n",
    "    puts \"Hello #{name}!\"\n",
    "  end\n",
    "end\n",
    "```\n",
    "\n",
    "`each` is a method that accepts a block of code then runs that block of code for every element in a list, and the bit between `do` and `end` is just such a block. A block is like an anonymous function or lambda. The variable between pipe (`|`) characters is the parameter for this block.\n",
    "\n",
    "What happens here is that for every entry in a list, `name` is bound to that list element, and then the expression `puts \"Hello #{name}!\"` is run with that name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Consider Yourself Introduced\n",
    "\n",
    "So that’s it for the quick tour of Ruby. There’s a lot more to explore, the different control structures that Ruby offers; the use of blocks and `yield`; modules as mixins; and more. I hope this taste of Ruby has left you wanting to learn more.\n",
    "\n",
    "If so, please head on over to our Documentation area, which rounds up links to manuals and tutorials, all freely available online."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 3.0.0",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "3.0.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}