Rubyists are abandoning Ruby because of concurrency. Fauxy is a faux object, faux functional language that hopes to solve those concurrency issues.

1. Long Live the Rubyists!
Kane Baccigalupi
@rubyghetto

2. Life After Ruby

3. But WHY???
:(

4. Ruby is!
• expressive

5. “hello ” * 4
“hello hello hello hello ”

6. Ruby is!
• expressive
• principle of least surprise

7. “hello”.empty?
“hello”.include?(“hell”)

9. Ruby is!
• expressive
• principle of least surprise
• powerful

10. class Object
def wat
“wat? wat?”
end
end
“foo”.wat # “wat? wat?”

11. Ruby is!
• expressive
• principle of least surprise
• powerful
• libs!

12. Rails!

13. So what’s
the problem???

15. Oh crap!
Concurrency :(

17. –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."

18. Where’s the goo?

19. Where’s the goo?
MUTABLE STATE

20. Where’s the goo?
MUTABLE STATE
def cambiarse!
@changed = true
end

21. Functional
Programming
to the rescue!
Functional programmers believe functional
programming is about keeping state immutable

22. Mutating Ruby:
greeting = “hello"
greeting.upcase!
greeting.gsub!("HELL", “heaven")
greeting # “heavenO”

23. Non-Mutating Ruby:
greeting = “hello"
greeting.upcase.gsub("HELL", “heaven")
greeting # “hello”

24. 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)))))

25. Object Oriented
programming to the
rescue!
Object oriented programmers believe object oriented
coding is breaking code into modular abstractions

26. Immutable Objects?

27. FAUXY!

28. FAUXY!
Faux Objects

29. FAUXY!
Faux Functional

30. FAUXY!
Oops, no logo though

31. FAUXY!
Oops, no logo though.
And `1 + 1` still doesn’t equal `2`

32. Lexing
Breaking a string of characters into
a string of tokens
1 + 1
<integer 1> <id ‘+’> <integer 1>

33. 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>))
)

34. Interpretation
Taking 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

35. FAUXY!
What does it look like though?

36. 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' }
}

37. FAUXY! - Pipes & Streams
a(x) >> b(:foo, _.value) >> c(_, 'bar')
DataParser.new(data) >> DbRecord.new(_).create

38. 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
}
}

39. FAUXY!
Watch it happen:
github.com/baccigalupi/fauxy

40. 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

41. ME!
Kane Baccigalupi
@baccigalupi
Ruby/Rails/JS
Rescue Coding