Long Live the Rubyists!Kane Baccigalupi

@rubyghetto

Life After Ruby

But WHY???

:(

Ruby is!

• expressive

“hello ” * 4

“hello hello hello hello ”

Ruby is!

• expressive

• principle of least surprise

“hello”.empty?

“hello”.include?(“hell”)

Ruby is!

• expressive

• principle of least surprise

• powerful

class Object

def wat

“wat? wat?”

end

end

“foo”.wat # “wat? wat?”

Ruby is!

• expressive

• principle of least surprise

• powerful

• libs!

Rails!

So what’s

the problem???

Oh crap!

Concurrency :(

–Tony Arcieri, creator of Celluloid gem

"Eventually you're in a place where

you're trying to build a jet engine out

of silly putty."

Where’s the goo?

Where’s the goo?

MUTABLE STATE

Where’s the goo?

MUTABLE STATE

def cambiarse!

@changed = true

end

Functional

Programming

to the rescue!

Functional programmers believe functional

programming is about keeping state immutable

Mutating Ruby:

greeting = “hello"

greeting.upcase!

greeting.gsub!("HELL", “heaven")

greeting # “heavenO”

Non-Mutating Ruby:

greeting = “hello"

greeting.upcase.gsub("HELL", “heaven")

greeting # “hello”

So let’s switch to

functional programming

(define checkbook (lambda ()

; This check book balancing program was written to illustrate

; i/o in Scheme. It uses the purely functional part of Scheme.

; These definitions are local to checkbook

(letrec

; These strings are used as prompts

((IB "Enter initial balance: ")

(AT "Enter transaction (- for withdrawal): ")

(FB "Your final balance is: ")

; This function displays a prompt then returns

; a value read.

(prompt-read (lambda (Prompt)

(display Prompt)

(read)))

; This function recursively computes the new

; balance given an initial balance init and

; a new value t. Termination occurs when the

; new value is 0.

(newbal (lambda (Init t)

(if (= t 0)

(list FB Init)

(transaction (+ Init t)))))

; This function prompts for and reads the next

; transaction and passes the information to newbal

(transaction (lambda (Init)

(newbal Init (prompt-read AT)))))

; This is the body of checkbook; it prompts for the

; starting balance

(transaction (prompt-read IB)))))

Object Oriented

programming to the

rescue!

Object oriented programmers believe object oriented

coding is breaking code into modular abstractions

Immutable Objects?

FAUXY!

FAUXY!Faux Objects

FAUXY!Faux Functional

FAUXY!Oops, no logo though

FAUXY!Oops, no logo though.

And `1 + 1` still doesn’t equal `2`

LexingBreaking a string of characters into

a string of tokens

1 + 1

<integer 1> <id ‘+’> <integer 1>

ParsingTaking a string of tokens and

converting it into tree of expressions

<integer 1> <id ‘+’> <integer 1>

(method_call,

(receiver, <integer 1>),

(message, <id ‘+’>),

(arguments, (<integer 1>))

)

InterpretationTaking the tree expression

and executing it as code!

(method_call,

(receiver, <integer 1>),

(message, <id ‘+’>),

(arguments, (<integer 1>))

)

• Find or build literal integer `1`

• Use Integer class to lookup `+`

method

• Find literal integer `1` again to use

as an argument

• Call `+` method with found literals

`1` and `1` as the receiver and

the message

FAUXY!What does it look like though?

FAUXY! - Multiple Dispatch

NumberToWords.Digit: Class.new(n) -> {

to-words: -> { convert(n) }

convert: -> (n: 1) { 'one' }

convert: -> (n: 2) { 'two' }

convert: -> (n: 3) { 'three' }

convert: -> (n: 4) { 'four' }

convert: -> (n: 5) { 'five' }

convert: -> (n: 6) { 'six' }

convert: -> (n: 7) { 'seven' }

convert: -> (n: 8) { 'eight' }

convert: -> (n: 9) { 'nine' }

}

FAUXY! - Pipes & Streams

a(x) >> b(:foo, _.value) >> c(_, 'bar')

DataParser.new(data) >> DbRecord.new(_).create

Aggregating State

Spec: Class.new(description, block) -> {

setup: -> {

results: List.new

}

run: -> {

block.run

}

assert: -> (value) {

results.add(value.to_boolean)

}

failure-count: -> {

results.count -> (boolean) { !boolean }

}

success?: -> {

results.count > 1 && failure-count == 0

}

}

FAUXY!Watch it happen:

github.com/baccigalupi/fauxy

Attributions

• Ruby icon: www.computersnyou.com

• Confreaks Screenshot of Ernie Miller @rubyconf 2014:

https://www.youtube.com/watch?v=EgjJYkuV0Sc

• Wat: https://www.destroyallsoftware.com/talks/wat

• Rails icon: en.wikipedia.org

• Moore’s Law: www.pcworld.com

• Celluloid: https://celluloid.io/

• Scheme example:

https://classes.soe.ucsc.edu/cmps112/Spring03/languages/scheme/Sche

meTutorialA.html#example

• Immutable Ruby Object Example:

https://github.com/socialchorus/slipcover/blob/master/lib/slipcover/databa

se.rb

• Presentation at: http://www.slideshare.net/baccigalupi/long-live-the-

rubyist

ME!Kane Baccigalupi

@baccigalupi

Ruby/Rails/JS

Rescue Coding