Introduction to Ruby & Ruby on Rails

Introduction to Ruby & Ruby on Rails
Marcelo Correia Pinheiro
http://salizzar.net - @salizzar - https://github.com/salizzar
Wednesday, October 2, 13

More one programming language?
Maybe, depends on you
Today, knowledge of compiled /
bytecoded / interpreted programming
languages are requirements in market
to programmers that wants to work in
*nice real world*
“A language that doesn’t aﬀect the way
you think about programming, is not
worth knowing.” Perlis, Alan (ALGOL)
wat

Tell me more
Ruby is a general-purpose Object-Oriented Programming language.
But we can consider it as a “hybrid language”, due for their functional-
paradigm support
Created by Yukihiro Matsumoto (aka Matz) in Japan, 1995
Heavily inspired on Smalltalk with some ﬂavor of Eiﬀel, Lisp, Python and
others
Current version: 2.0

Ruby Philosophy
“A programming language for human beings”.
Expressive code
Powerful expansion by Metaprogramming / Functional Paradigm
Make programming more fun
Be productive

Ruby Community
One of most innovative and active today:
Ruby on Rails
TDD / BDD, Conﬁguration Management
A LOT of libraries that inspired other communities (Python, Go, Java, C# etc)
Has created other Virtual Machine implementations (default is MRI):
JRuby (runs on JVM)
Rubinius (written in C++ with LLVM)
Maglev (written in Smalltalk)
RubyMotion (runs on iOS and OSX)

Who uses Ruby
On Planet Earth:
Twitter (meh)
NASA
Google
Groupon
Github
A lot of startups

Who uses Ruby
In HUEland:
Locaweb
Globo.com
UOL
Abril
A lot of startups

Time to code
In this keynote, we will see:
IRB (Interactive Ruby Shell)
Flow Control Mechanisms
Ruby Main Classes
Classes, Modules and Mix-ins
Some Ruby STDLIB classes
Ruby Libraries

Many dynamic languages oﬀers a shell for fun and learn, Ruby too
Shipped version is better than otthers REPL shells
Just type in your terminal:
$ irb

Is very nice, but...
Let’s look at pry, an improvement to irb:
$ pry
[1] pry(main)> def hello(fella)
[1] pry(main)* puts "Hello, #{fella}! :)"
[1] pry(main)* end
=> nil
[2] pry(main)> hello 'marcelo'
Hello, marcelo! :)
=> nil

if / else
[1] pry(main)> require 'date'
=> true
[2] pry(main)> condition = Date.today.sunday?
=> true
[3] pry(main)> if condition then
[3] pry(main)* puts 'condition is true'
[3] pry(main)* else
[3] pry(main)* puts 'condition is false'
[3] pry(main)* end
condition is true
=> nil
[4] pry(main)> puts 'condition is true' if condition
condition is true
=> nil

unless / else
=> true
[2] pry(main)> condition = Date.today.monday?
=> false
[3] pry(main)> unless condition then
[3] pry(main)* puts 'condition is false'
[3] pry(main)* else
[3] pry(main)* puts 'condition is true'
[3] pry(main)* end
condition is false
=> nil
[4] pry(main)> puts 'condition is false' unless condition
condition is false
=> nil

while
[1] pry(main)> i = 1
[2] pry(main)> while i <= 3
[2] pry(main)* puts i ; i += 1
[2] pry(main)* end
1
2
3
[4] pry(main)> begin
[4] pry(main)* end while i <= 3
1
2
3

until
[2] pry(main)> until i > 3
[2] pry(main)* end
1
2
3
[4] pry(main)> begin
[4] pry(main)* end until i > 3
1
2
3

for each
[1] pry(main)> for i in (1..3)
[1] pry(main)* puts i
[1] pry(main)* end
1
2
3
[2] pry(main)> (1..3).each do |i|
[2] pry(main)* puts i
[2] pry(main)* end
1
2
3

Ruby Main Classes
String
Symbol
Fixnum
Bignum
Range
Float
Date
Time
Array
Hash
Proc
Lambda
Regexp

Before coding, remember
It’s all about OOP.
Everything is object (strings, numbers etc)
All objects are passed by reference in method calls
Object communicates themselves by message exchange (Smalltalk
philosophy)

Before coding, remember
$ pry
[1] pry(main)> 2 + 2
=> 4
[2] pry(main)> 2.send(:+, 2)
=> 4

Ruby Main Classes: String
So. Simple. No. Mistery.
As all Ruby Core classes, contains a lot of useful methods for mundane-
daily-manipulation

[1] pry(main)> message = 'Hi, HUEland!'
=> "Hi, HUEland!"
[2] pry(main)> message.size
=> 12
[3] pry(main)> message.gsub(/HUEland/, 'Brazil')
=> "Hi, Brazil!"
[4] pry(main)> message.split(', ')
=> ["Hi", "HUEland!"]

Exercise 01: given a string, loop inside their chars and output respective
char and ASCII code
Tip #1: ‘c’.ord returns ASCII code
Tip #2: string[i] returns respective char in string (default index is 0)
Tip #3: to print string, puts string[i].ord

Ruby Main Classes: Symbol
Symbols are strings that are stored as unique identiﬁers in memory
In other words, when you create a symbol and uses it in your program,
all references to these symbol appoints to same instance while
application is running

Ruby Main Classes: Symbol
[1] pry(main)> symbol = :HUEland
=> :HUEland
[2] pry(main)> symbol.object_id
=> 677228
[3] pry(main)> :HUEland.object_id
=> 677228

Ruby Main Classes: Fixnum
Well-known as Integer, but with some diﬀerences
Ruby stores numbers in memory based on machine architecture (native
machine word - 1 byte)
If a number is insanely big and exceeds upper and lower bounds, is
converted to a Bignum automagically

[1] pry(main)> universe_answer = 42
=> 42
[2] pry(main)> universe_answer.chr
=> "*"
[3] pry(main)> universe_answer.zero?
=> false

Exercise 02: write a Fibonacci method with recursion

Ruby Main Classes: Bignum
As name says, a <censored> big
number
It’s like Higgs Boson particle on
daily programming, nobody has
ever seen

Ruby Main Classes: Bignum
[1] pry(main)> fixnum = 2 ** 62 - 1
=> 4611686018427387903
[2] pry(main)> fixnum.class
=> Fixnum
[3] pry(main)> bignum = fixnum + 1
=> 4611686018427387904
[4] pry(main)> bignum.class
=> Bignum

Ruby Main Classes: Range
Believe me: is a range. (meh)
You don’t need to create arrays of
indexes [ 1..5 ] or create famous
“i” variables to be used in a while
loop, just use (1..5).each

[1] pry(main)> range = (1..3)
=> 1..3
[2] pry(main)> range.each { |i| puts i }
1
2
3
=> 1..3
[3] pry(main)> range.reverse_each { |i| puts i }
3
2
1
=> 1..3

Exercise 03: From 1 to 100, print number and if is prime
Tip: use the following method
If is strange, don’t worry; you will understand it soon :)
def prime?(x)
(2 .. Math.sqrt(x)).each { |n| return false if x % n == 0 }
true
end

Ruby Main Classes: Float
A ﬂoat (O’RLY?)
As all Ruby classes, contains
some interesting methods (RTFM)

Ruby Main Classes: Float
[1] pry(main)> pi = Math::PI
=> 3.141592653589793
[2] pry(main)> pi.ceil
=> 4
[3] pry(main)> pi.floor
=> 3
[4] pry(main)> pi.denominator
=> 281474976710656
[5] pry(main)> pi.modulo(1)
=> 0.14159265358979312

Ruby Main Classes: Date
Meh.
Support for Julian Calendar and
other RFC methods
Support arithmetical operations
with integers and other types

Ruby Main Classes: Date
=> true
[2] pry(main)> today = Date.today
=> #<Date: 2013-09-21 ((2456557j,0s,0n),+0s,2299161j)>
[3] pry(main)> today.day
=> 21
[4] pry(main)> today.month
=> 9
[5] pry(main)> today.year
=> 2013
[6] pry(main)> today.sunday?
=> true
[6] pry(main)> today - 4
=> #<Date: 2013-09-27 ((2456553j,0s,0n),+0s,2299161j)>

Ruby Main Classes: Time
Date with time (hour, minutes and seconds)
IMPORTANT: Ruby have two Time implementations:
A class from Core, that have a lot of methods
A module from STDLIB that contains parsing feature and other
methods

Ruby Main Classes: Time
1] pry(main)> now = Time.now
=> 2013-09-21 13:35:24 -0300
[2] pry(main)> require 'time'
=> true
[3] pry(main)> now = Time.parse "#{Date.today} #{Time.now.strftime "%H:%M:%S"}"
=> 2013-09-21 13:36:13 -0300

Ruby Main Classes: Array
Meh.
A LOT of useful methods like
select, collect, reverse, sort and
others
Accepts anything (numbers,
strings, constants etc)

[1] pry(main)> primes = [ 1, 2, 3, 5, 7, 11 ]
=> [1, 2, 3, 5, 7, 11]
[2] pry(main)> pingu_speaking = %w(emmgpiqncqa cefpgqiqmeuolg pxregmeuyytg)
=> ["emmgpiqncqa", "cefpgqiqmeuolg", "pxregmeuyytg"]
[3] pry(main)> moms_heart = [ :one, 2, 'three', Float ]
=> [:one, 2, 'three', Float]
[4] pry(main)> primes.select(&:odd?)
=> [1, 3, 5, 7, 11]
[5] pry(main)> moms_heart.reject { |item| item.is_a?(Symbol) }
=> [2, "three", Float]

Exercise 04: From 1 to 100, store prime numbers in a array
Tip: use previous exercise to help

Ruby Main Classes: Hash
A dictionary (O’RLY?)
Shares same behavior of Array,
accepts anything as keys/values
You can do some fun routines
with it

[1] pry(main)> moms_heart = { 1 => :one, :two => 2, 3.0 => 'three' }
=> {1=>:one, :two=>2, 3.0=>"three"}
[2] pry(main)> moms_heart[3.0]
=> "three"
[3] pry(main)> moms_heart.keys
=> [1, :two, 3.0]
[4] pry(main)> moms_heart.values
=> [:one, 2, "three"]
[5] pry(main)> moms_heart['daddy']
=> nil
[6] pry(main)> moms_heart[:float] = Float
=> Float
[7] pry(main)> moms_heart[:float]
=> Float

Exercise 05: From 1 to 100, stores in a hash the last digit of a prime
number as a key and value inside a array

Ruby Main Classes: Proc
Time to get real fun.
Ruby is a hybrid language, right? YES
Let’s talk about some Computation
Theory
First-class citizens
Anonymous functions
Closures & Blocks

In Ruby, as documentation says:
“Proc objects are blocks of
code that have been bound to a
set of local variables. Once
bound, the code may be called
in diﬀerent contexts and still
access those variables.”

[1] pry(main)> def get_factor(factor)
[1] pry(main)* Proc.new { |n| factor ** n }
[1] pry(main)* end
=> nil
[2] pry(main)> factor_of_2 = get_factor(2)
=> #<Proc:0x000000014cec48@(pry):2>
[3] pry(main)> factor_of_2.call(5)
=> 32
[4] pry(main)> factor_of_3 = get_factor(3)
=> #<Proc:0x0000000135df30@(pry):2>
[5] pry(main)> factor_of_3.call(4)
=> 81

Ruby Main Classes: Lambda
Lambda is a Proc, with
*important* diﬀerences
A lambda checks arity of
arguments passed
return keyword behaves
diﬀerently compared to Proc
instances

[1] pry(main)> def get_a_lambda(fella)
[1] pry(main)* ret = lambda { return "Lambda hello, #{fella}" }
[1] pry(main)* ret.call
[1] pry(main)* "#{fella}, you will see this message"
[1] pry(main)* end
=> nil
[2] pry(main)> def get_a_proc(fella)
[2] pry(main)* ret = Proc.new { return "Proc hello, #{fella}" }
[2] pry(main)* ret.call
[2] pry(main)* "#{fella}, you will never see this message"
[2] pry(main)* end
=> nil
[3] pry(main)> get_a_lambda('Marcelo')
=> "Marcelo, you will see this message"
[4] pry(main)> get_a_proc('Marcelo')
=> "Proc hello, Marcelo"

Exercise 06: rewrite Fibonacci method as a lambda

Ruby Main Classes: Regexp
Regular Expressions (O’RLY?)
If you never heard about it... don’t
worry, the day that you need to
extract some text patterns in log
ﬁles will come

[1] pry(main)> message = "Gooby pls xow em de code"
=> "Gooby pls xow em de code"
[2] pry(main)> a_pattern = /gooby/i
=> /gooby/i
[3] pry(main)> another = Regexp.new('pls xow em de code')
=> /xow em de code/
[4] pry(main)> message.gsub(a_pattern, 'Dolan').gsub(another, 'you shall not pass')
=> "Dolan you shall not pass"

You know how use it, let’s gonna exercise with a LIVE example replacing
all occurrences of aeiou with *

Ruby Classes
OK, Ruby seems to be cool. How I start to create some classes?
Let’s revisit inheritance and polymorphism.
Ruby have public, protected and private accessors
Ruby not have abstract classes and interfaces
Ruby not supports multiple inheritance, but with Modules we can
provide it (Mix-ins)

Ruby Classes
[1] pry(main)> class GeometricShape
[1] pry(main)* def get_area
[1] pry(main)* raise NotImplementedError.new
[1] pry(main)* end
[1] pry(main)* end
=> nil
[2] pry(main)> wat = GeometricShape.new
=> #<GeometricShape:0x0000000257dc10>
[3] pry(main)> wat.get_area
NotImplementedError: NotImplementedError
from (pry):3:in `get_area'

Ruby Classes
[4] pry(main)> class Square < GeometricShape
[4] pry(main)* attr_accessor :length
[4] pry(main)*
[4] pry(main)* @length ** 2
[4] pry(main)* end
[4] pry(main)* end
=> nil
[5] pry(main)> square = Square.new
=> #<Square:0x000000024326f8>
[6] pry(main)> square.length = 4
=> 4
[7] pry(main)> square.get_area
=> 16

Ruby Classes
[8] pry(main)> class Triangle < GeometricShape
[8] pry(main)* attr_accessor :base, :height
[8] pry(main)*
[8] pry(main)* (base * height) / 2
[8] pry(main)* end
[8] pry(main)* end
=> nil
[9] pry(main)> triangle = Triangle.new
=> #<Triangle:0x000000026b7248>
[10] pry(main)> triangle.base = 4 ; triangle.height = 5
=> 5
[11] pry(main)> triangle.get_area
=> 10

Ruby Classes
Exercise 07: create a Trapezium class that extends GeometricShape and
write get_area method

Ruby Modules / Mix-ins
Modules are a fragment of code
(methods, other classes, constants etc)
that we can include:
In classes
In other modules
We use to create namespaces too
In Ruby, we call action of including a
Module inside a class / other module
as Mix-in

[1] pry(main)> module GUI
[1] pry(main)* module Renderer
[1] pry(main)* def render
[1] pry(main)* "Rendering #{self.class.name} with Area #{self.get_area}... done"
[1] pry(main)* end
[1] pry(main)* end
[1] pry(main)* end
=> nil
[2] pry(main)> class Square
[2] pry(main)* include GUI::Renderer
[2] pry(main)* end
=> Square
[3] pry(main)> class Triangle
[3] pry(main)* include GUI::Renderer
[3] pry(main)* end
=> Triangle

[4] pry(main)> square = Square.new
=> #<Square:0x00000000e85c88>
[5] pry(main)> square.length = 3
=> 3
[6] pry(main)> square.render
=> "Rendering Square with Area 9... done"
[7] pry(main)> triangle = Triangle.new
=> #<Triangle:0x00000000f5f398>
[8] pry(main)> triagle.base = 3 ; triagle.height = 4
=> 4
[9] pry(main)> triangle.render
=> "Rendering Triangle with Area 6... done"

Ruby STDLIB Classes
Ruby provides *a lot* of useful classes
Check ruby-doc.org before starting
to code, maybe it is shipped :)
We will see the following:
Net::HTTP
Benchmark
Test::Unit

Ruby STDLIB Classes: Net::HTTP
A HTTP client to GET, POST, PUT and DELETE
HTTPS Support
Interface not so good, but community has created other libraries that
encapsulates calls in a better way

[1] pry(main)> require 'net/http'
=> true
[2] pry(main)> response = Net::HTTP.get(URI('http://www.terra.com.br'))
=> "<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">n<html><head>n<title>301 Moved
Permanently</title>n</head><body>n<h1>Moved Permanently</h1>n<p>The document has moved <a href=
"/portal/">here</a>.</p>n</body></html>n"
[3] pry(main)> hash = {}
=> {}
[4] pry(main)> response.chars.each do |c|
[4] pry(main)* hash[c.to_s] = hash[c.to_s].nil? ? 1 : hash[c.to_s] + 1
[4] pry(main)* end
=> "<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">n<html><head>n<title>301 Moved
Permanently</title>n</head><body>n<h1>Moved Permanently</h1>n<p>The document has moved <a href=
"/portal/">here</a>.</p>n</body></html>n"
[5] pry(main)> hash.keys.sort.each do |k|
[5] pry(main)* puts "'#{k}' = #{hash[k]}"
[5] pry(main)* end
=> (... a big input here ...)

Exercise 08: stores in a Hash all occurrences of chars given a URL that is
called using Net::HTTP

Ruby STDLIB Classes: Benchmark
Benchmark provides a way to
measure your code based on
elapsed execution time
A need-to-know to check
algorithm eﬃciency

[1] pry(main)> def fibonacci(x)
[1] pry(main)* return x if [ 0, 1 ].include?(x)
[1] pry(main)* fibonacci(x - 1) + fibonacci(x - 2)
[1] pry(main)* end
=> nil
[2] pry(main)> fib = lambda do |x|
[2] pry(main)* fib[x - 1] + fib[x - 2]
[2] pry(main)* end
=> #<Proc:0x000000029ec710@(pry):14 (lambda)>
[3] pry(main)> fibh = lambda do |x|
[3] pry(main)* Hash.new { |hash, n| hash[n] = n < 2 ? n : hash[n - 1] + hash[n - 2] }[x]
[3] pry(main)* end
=> #<Proc:0x000000031217d8@(pry):18 (lambda)>

[4] pry(main)> require 'benchmark'
=> true
[5] pry(main)> Benchmark.bm(15) do |b|
[5] pry(main)* b.report('fibonacci') { fibonacci(32) }
[5] pry(main)* b.report('fib') { fib.call(32) }
[5] pry(main)* b.report('fibh') { fibh.call(32) }
[5] pry(main)* end
user system total real
fibonacci 1.890000 0.000000 1.890000 ( 1.888704)
fib 2.700000 0.000000 2.700000 ( 2.697208)
fibh 0.000000 0.000000 0.000000 ( 0.000056)

Ruby STDLIB Classes: Test::Unit
Test. Your. Code.
If you never heard before about this,
seriously... LEARN.
Helps to create better software
No fear while refactoring
Check possible problems in future
Increases application design over
time

# 01_fibonacci.rb
def fibonacci(x)
return x if x == 0 || x == 1
fibonacci(x - 1) + fibonacci(x - 2)
end

require './01_fibonacci'
require 'test/unit'
class TestFibonacci < Test::Unit::TestCase
def test_fib
assert_equal(fibonacci(0), 0)
end
end

$ ruby 11_test_hash.rb
Run options:
# Running tests:
.
Finished tests in 0.000379s, 2641.7287 tests/s, 7925.1862 assertions/s.
1 tests, 3 assertions, 0 failures, 0 errors, 0 skips

For given exercises, write test FIRST :)
Exercise 09: write a TestCase for 2 + 2
Exercise 10: write a TestCase that asserts that our prime method is
correct for 4 scenarios
Tip: use assert_equal

Ruby Libraries
A Ruby Library is called a Gem.
Ruby community has created a canonical
repository: Rubygems.org
Create a library is easy, anyone can create
and share in repo; but:
Cover with tests ﬁrst;
Make it more generic as possible;
NO MONKEY PATCHES* (until you
know what you do)

Ruby Libraries
Ruby have a tool to map dependencies
and install/vendorize gems: bundler
It requires a Gemﬁle, a ﬁle that we add
all required gems to application work
Great advantage: we can ship a Ruby
app with all dependencies inside it
Of course, if we use native gems then
the destination must have the same
OS & architecture (x86, x86_64)

Ruby Libraries
Time to show how create a Ruby application from zero using bundler.

Ruby on Rails
A little introduction

Ruby on Rails: wat
A framework to create web applications.
Created by David Heinemeier Hansson (aka @dhh), Denmark 2004
David was attended in FISL 2005 as a speaker to show RoR
Apple was shipped RoR in 2007 in OSX Leopard

Ruby on Rails: !hype
Why Rails is so important?
RoR was the first web framework that effectively works well
Microsoft tried to resolve with first version of Microsoft.NET ASP.NET,
but create a state persistence in a stateless protocol (HTTP) was failed
as hell (ASPNET hidden fields storing >= 128Kb *zipped* strings)
Apache Struts works, but be ready to immerse in dozens of XML
configuration files to create a simple Hello World

Ruby on Rails: Follow my rules
Ruby on Rails is a great example of opinionated software.
Convention over Conﬁguration
Principle of Least Astonishment
KISS (Keep It Simple, Stupid)
DRY (Don’t Repeat Yourself)

Ruby on Rails: Architecture
Rails is a MVC (Model-View-Controller) framework.
Model: main business rules and persistence
View: presentation layer of data
Controller: a bridge between models and views, based on actions

Ruby on Rails: Models
Models are classes that maps entities in a database
Models uses ActiveRecord pattern to perform CRUD (Create / Read /
Update / Destroy) operations
Rails provides a agnostic interface to query in database with your
models
In other words, you don’t need to write SQL commands

Rails have support for principal RDBMS’s on market
MySQL, PostgreSQL
Microsoft SQL Server, Oracle Database
Rails supports NoSQL Databases very, very well:
CouchDB, MongoDB
Cassandra, Redis

Models contains a set of useful validations
Numeric
Regular Expression
Inclusion
Value is blank
etc

Ruby on Rails: Views
Views are the presentation layer of data.
In Rails, views are fragments of HTML code that will be parsed /
executed by the render engine to stream pure HTML to client
Default render engine: ERB
But you can choice others:
Markdown, HAML

Ruby on Rails: Controllers
Controllers are the man-in-the-middle of Models and Views.
Responsible to receive view data (HTML forms sent by POST/PUT/
DELETE) and create Model instances, orchestrate application logic
They *must* be little (tiny controllers, tiny models)
Are a entity that responds to a route

Ruby on Rails: Routes
To talk about routes, we must revisit or know what is REST.
An approach to handle resources based on HTTP verbs in WWW
GET /resource -> READ
POST /resource -> CREATE
PUT /resource -> UPDATE
DELETE /resource -> DELETE
We can talk per hours here, but learn by yourself. It is a requirement today.

Ruby on Rails: Migrations
When we need to create a entity in database, commonly a SQL script is
written to a DBA run it in a server.
With Migrations, we can create it without write any SQL script
Previous migrations are stored in database in order to avoid multiple
executions (ex: run a CREATE TABLE of a already existent table)

Ruby on Rails: It’s showtime
Let’s try to create a blog engine (OH NO, AGAIN!)

Questions?
Gooby pls sk ot me

Thank you!
Solved exercises on:
https://github.com/salizzar/introduction-to-ruby

Introduction to Ruby & Ruby on Rails

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Viewers also liked

Viewers also liked (20)

Similar to Introduction to Ruby & Ruby on Rails

Similar to Introduction to Ruby & Ruby on Rails (20)

Recently uploaded

Recently uploaded (20)

Introduction to Ruby & Ruby on Rails