Let’s Talk About Ruby

LET’S TALK ABOUT

ruby

Ian Bishop @ianbishop

Ruby is

Ruby is

simple in appearance,

Ruby is


but is very complex inside,

Ruby is



just like our human body

Ruby is



just like our human body - Yukihiro “matz” Matsumoto

philosophy

principle of

least surprise

principle of least surprise

array.length string.length() collection.size()

principle of least surprise

array.length string.length() collection.size() array.length string.length collection.length

features

everything is an object

5.times do print “Everyone loves ruby!” end

everything is an object

5.times

everything is a message

/abc/ === “abc” => true

“abc” === /abc/ => false




/abc/

/abc/


/abc/

/abc/.send


/abc/ ===

/abc/.send(:===


/abc/ === “abc”

/abc/.send(:===, “abc”)


/abc/ === “abc” => true /abc/.send(:===, “abc”) => true





case “HELLO” when /^[a-z]*$/ “lowercase” when /^[A-Z]*$/ “uppercase” end

=> “uppercase”


case “HELLO” when “hello” “lowercase” when “HELLO” “uppercase” end

=> “uppercase”




dynamic runtime

a = [1,2,3] a.first => 1 a.second

NoMethodError: Undefined method ‘second’ for [1, 2, 3]:Array

dynamic runtime

class Array def second if self.length > 1 return self[1] end nil end end

dynamic runtime

a = [1,2,3] a.first => 1 a.second

dynamic runtime

a = [1,2,3] a.first => 1 a.second => 2

DEALING WITH

data

using collections

a = [1,2,3]

using collections

a = [1,2,3,“meow”]

using collections

a.each do |x| puts x end 1 2 3 meow

using collections

a.each

using collections

a.each do |x|

end

using collections

a.each do |x| puts x

end

using collections

a.each do |x| puts x

end 1 2 3 meow

.each

Iterate over elements in a collection

.map

Iterate over elements in a collection,

returning a new collection of

elements of the same size

using map

a = [1,2,3]

using map

a = [1,2,3] a.map

using map

a = [1,2,3] a.map do |x|

end

using map

a = [1,2,3] a.map do |x|

2 * x end

using map

a = [1,2,3] a.map do |x|

return 2 * x end

using map

a = [1,2,3] a.map do |x|

2 * x end

using map

a = [1,2,3] a.map do |x|

2 * x end => [2,4,6]

.map


returning a new collection of

elements of the same size

.select


returning elements which match a

specified criteria

using select

a = [1,2,3]

using select

a = [1,2,3] a.select

using select

a = [1,2,3] a.select do |x|

end

using select


x.odd? end

using select


x.odd? end => [1,3]

.select


returning elements which match a

specified criteria

.reduce

Combines all elements in a collection

using a binary operation, returning

an accumulator value.

using reduce

a = [1,2,3]

using reduce

a = (1..100)

using reduce

a = (1..100) a.reduce

using reduce

a = (1..100) a.reduce do |sum, x|

end

using reduce


sum + x end

using reduce


sum + x end => 5050

.reduce




.reduce




using reduce (again)

a = (1..100) a.reduce


a = (1..100) a.reduce(:*)


a = (1..100) a.reduce(:*) =>933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000…

SOLVING

HARDER

PROBLEMS

generating poker hands

building a deck of cards

suits = %w(S C H D)


suits = %w(S C H D) => [“S”, “C”, “H”, “D”]


suits = %w(S C H D) => [“S”, “C”, “H”, “D”] “S C H D”.split /\s+/ => [“S”, “C”, “H”, “D”]


suits = %w(S C H D) faces =


suits = %w(S C H D) faces = (2..10).to_a


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A)

[1, 2, 3]

[“a”, “b”, “c”]

[1, 2, 3]

x

[“a”, “b”, “c”]

[1, “a”], [1, “b”], [1, “c”],

[2, “a”], [2, “b”], [2, “c”],

[3, “a”], [3, “b”], [3, “c”]

cross product


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces)


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces) => [[“S”, 2], [“S”, 3], …, [“S”, “A”], [“C”, 1], …, [“C”, “A”], …]


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces) => [“S2”, “S3”, …, “SA”, “C1”, …, “C2”, …]

join(sep=$,) -> str

Returns a string created by converting each element

of the array to a string, seperated by sep.

[ “a”, “b”, “c”].join => “abc” [ “a”, “b”, “c”].join(“-”) => “a-b-c”


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces) deck = deck.map do |pair| pair.join end


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces) deck.map! do |pair| pair.join end


.map!


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces) deck.map! do |pair| pair.join end


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces) deck.map! { |pair| pair.join }


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces).map(&:join)


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces).map(&:join)

sample(n) -> new_ary Choose n random elements from the array.

The elements are chosen by using random

and unique indices in order to ensure that an

element doesn’t repeat itself unless the array

already contained duplicate elements.


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces).map(&:join) deck.sample(5)


suits = %w(S C H D) faces = (2..10).to_a + %w(J Q K A) deck = suits.product(faces).map(&:join) deck.sample(5) => [“C2”, “D5”, “S7”, “D8”, “C8”]

LET’S TALK ABOUT

MAP REDUCE

LET’S TALK ABOUT

MAP REDUCE ©

Count of URL Access Frequency

The map function processes logs of web page

requests and outputs <URL, 1>. The reduce

function adds together all values for the same

URL and emits a <URL, total count> pair.

from Introduction to Parallel Programming and MapReduce (Google)

counting url access frequency

log


log => [“example.com”, “google.com”, “userevents.com”, “unb.ca”, “frederictonug.net”, ..]




function adds together all values for the same

URL and emits a <URL, total count> pair.


generate count pairs

count_pairs = log.map do |url| [url, 1] end




function adds together all values for the same URL

and emits a <URL, total count> pair.


BUT FIRST

Collection of key-value

pairs.

Similar to an array, except

indexing is done via unique

keys.

brief introduction to hashes

my_hash = { :abc => 5, “def” => 9 }


my_hash = { :abc => 5, “def” => 9 } my_hash[:abc]


my_hash = { :abc => 5, “def” => 9 } my_hash[:abc] => 5


my_hash = { :abc => 5, “def” => 9 } my_hash[:abc] => 5 my_hash[“def”] = 14


my_hash = { :abc => 5, “def” => 9 } my_hash[:abc] => 5 my_hash[“def”] = 14 => { :abc => 5, “def” => 14 }




function adds together all values for the same URL

and emits a <URL, total count> pair.


combining count pairs

count_pairs.reduce


count_pairs.reduce({})


count_pairs.reduce({}) do |hash, pair| end


count_pairs.reduce({}) do |hash, pair| url, count = pair end


count_pairs.reduce({}) do |hash, pair| url, count = pair if hash.has_key? url hash[url] += count end


count_pairs.reduce({}) do |hash, pair| url, count = pair if hash.has_key? url hash[url] += count else hash[url] = count end end


count_pairs.reduce({}) do |hash, pair| url, count = pair if hash.has_key? url hash[url] += count else hash[url] = count end hash end


log = [“example.com”, “google.com”, “example.com”, “unb.ca”]


log = [“example.com”, “google.com”, “example.com”, “unb.ca”] => { “example.com” => 2, “google.com” => 1, “unb.ca” => 1 }

Technology

Let’s Talk About Ruby