The document discusses differences between Ruby and Scala programming languages. Some key similarities include both being class-based object-oriented languages with functional features. Differences include Scala using explicit types while Ruby is dynamically typed, and Scala having separate concepts of methods and functions while Ruby blurs the distinction. The document also compares features like class definitions, collections, functions as values, and enhancing existing classes.

1. TEST

4. Hello, is there Rubyist?

5. (When I moved)
From Ruby
to Scala
@todesking
https://www.flickr.com/photos/7armyjmtc/14249465709

6. Who:
@todesking
uses twitter and GitHub
web: todesking.com

7. Working at
Platinum Sponsor

8. My background
• Sistem Integrator(2008-2012)
• Buisiness batches
• Recommendation system
• With Java
• Social game servicer
• Browser based social game server
• With Rails
• DSP servicer
• Adverting technology(Real-time bidding, user trakcing, machine
learning)
• With Scala
• Vim

9. What is DSP
Ad
Clients
DSP SSP
I'm here Pages
real time bidding(RTB)
Web
• "Demand Side Platform"
• You can find detailed description in at Internet.

10. Today I NOT talk to:
• How to build high-performance system
• DO THE RIGHT THING and KEEP GOING,
thats all.
• How to speed up compilation time
• BUY FASTER MACHINE
• Whitch is greatest language
• Every language has own good things
• BE PEACEFUL

11. I moved from Ruby
to Scala, in this April
• That is smoother than I thought.
• Basically, Ruby and Scala has common attributes
• object-oriented and functional paradigm
• Modern features for productivity and fun

12. Ruby and Scala is Class-based Object
Oriented language
• Class based object oriented language
class Person(val name:String, val age:Option[Int]) {
def hello():Unit = {
class Person < Struct.new(:name, :age)
def hello
puts "Hello there, my name is #{name}."
end
end
println(s"Hello there, my name is ${name}.")
}
}

13. At first: Common attributes of Ruby
and Scala
• Class based object oriented language with
functional features
def sumOfAge(people:Seq[Person]):Int = {
people.map(_.age).flatten.foldLeft(0)(_ + _)
}
def sum_of_age(people)
people.map(&:age).compact.reduce(0, &:+)
end

14. At first: Common attributes of Ruby
and Scala
• "Fun" language
• "Rubyをキメると気持ちいい"(Matz)
• I can't translate it...
•  → 
• "Maybe most important is that programming in
Scala tends to be very enjoyable."

15. Today's theme:
How these languages do things
in different way

16. Class definition
class Person(val name:String, val age:Option[Int])
val person = new Person("tode sking", Some(31))
class Person < Struct.new(:name, :age)
end
person = Person.new("tode sking", 31)

17. Class definition in Ruby
"class" for class
definition
class Person < Struct.new(:name, :age)
"<" means "extends" Create new instance of Struct
WHAT?!
Creating new instance at class definition?!?!

18. Let's begin most plain case
class Person
def initialize(name, age)
@name = name
@age = age
end
def name; @name; end
def name=(val); @name = val; end
def age; @age; end
def age=(val); @age = val; end
end
"def" for method
definition
method named "initialize"
is treated as ctor
"@name" is instance variable
getter and setter methods
Lot of boilerplate

19. Auto generating accessor method
in Ruby
class Person
def initialize(name, age) ...
attr_reader :name
attr_reader :age
end
"attr_reader" is keyword for
generating accessor method
"attr_writer" and "attr_reader"
is also available
NO, actually it is not
KEYWORD
It just a METHOD.

20. Auto generating accessor method
in Ruby
attr_accessor :name
≒
define_method("name") { @name }
define_method("name=") {|val| @name = val }
≒
def name; @name; end
def mane=(val); @name = val; end

21. Ruby is DYNAMIC language
• EVERYTHING is object
• Class is object too
• o = Object.new; o.class => Object
• If you want to create new class, try A = Class.new
• (assign constant A to fresh class object)
• To define a method to A, try A.define_method(:foo){...}
• (actually, define_method is "private". You should
use A.instance_eval { define_method(:foo) ... })

22. It called "Macro" in Ruby
• Such method called "macro"(Actually, it is just a
method!!)
• Ruby has no "compile-time". all execution is in
"runtime"

23. Defining accessor method:
Ruby and Scala
• scala
• var foo
• roughly equal to { private[this] var foo_; def foo
= foo_ }
• specialized syntax for accessor
• Ruby
• attr_*
• Enhance class definition with DSLs

24. Auto generating accessor method
in Ruby
class Person < Struct.new(:name, :age)
Create a new instance of
Struct
Struct is a kind of Class
≒
PersonBase = Struct.new(:name, :age)
class Person < PersonBase

25. Auto generating accessor method
in Ruby
Struct.new(:name, age) returns class that like
class (unnamed)
def initialize(name, age)
@name, @age = name, age
end
attr_accessor :name
attr_accessor :age
# other utility methods...
end[

26. Class definition
class Person(val name:String, val age:Option[Int])
val person = new Person("tode sking", Some(31))
class Person < Struct.new(:name, :age)
end
person = Person.new("tode sking", 31)

27. Function as value
• Scala:
• val f:Int => Int = _ + 1
• f(1) //=> 2
• val g:Any => String = _.toString
• Ruby
• f = ->(x){x + 1}
• f.call(1) or f[1] or f.(1)
• mehod and value is strongly separated
• g = ->(x){x.to_s}

28. Functions as value in other
languages
• Scheme: f, (f a b)
• javascript: f, f(a, b)
• Common Lisp: #'f, (f a b), (funcall #'f (list arg1
arg2))

29. Use function as value: Scala
case
• def foo(x:Int):String
• val f = foo // not works
• val f = foo _ // works
• def bar(f:Int => String)
• bar(foo) // works
• bar(x => x.toString)
• bar { x => x.toString }
• bar(_.toString)

30. Use function as value: Ruby
case
• def foo(x)
• f = method(:foo)
• f = ->(x){ foo(x) }
• def bar1(f)
• def bar2(&f)
• bar1(f)
• bar2 {|x| foo(x) }
• bar2(&f)

31. Use any object as function
• [1, 2, 3].map(&:to_s) #=> ["1", "2", "3"]
• map(&:to_s)
• It behave like Scala's map(_.toString)
• If block value is given, Ruby runtime call its
"to_proc" method and use the result value as
block.
• Ruby's Symbol class has to_proc method
• :to_s.to_proc #=> {|obj| obj.to_s }

32. Collections
• Literals
• Ruby: {}, []
• Scala: ()
• Neither list nor hash literals

33. Collections
Map HashMap
TupleN
LinkedHashMa
p
HashMap
Seq
immutabl
e
LinkedHashMa
p
List
Stack
mutable
Buffer
Traversabl
e
Enumerable
Hash
{key => value}
Array
[1, 2, 3]
(a, b)

34. Ruby has "Big" classes
• "Array" is generic, mutable data structure, it can,
push/pop, shift/pop, insert, indexed and
sequential access, and also used as tuple
• "Hash" is generic, mutable (and only) key-vakue
map structure in Ruby standard library

35. Transform collection in Big-class
style
• [1, 2, 3].map(&:to_s) #=> ["1", "2", "3"]
• Ruby has few Big collection classes. Everything
goes simple.

36. Transform collection in Scala
• Iterator[A].map(f:A => B):Iterator[B]
• List[A].map(f:A => B):List[B]
• BitSet.map(f:Int => Int):BitSet
• BitSet.map(f:Int => String):SortedSet[String]
• Magic "CanBuildFrom" implicit argument is used to
solve this problem.
• def map[B, That](f: (Int) ⇒ B)(implicit bf:
CanBuildFrom[A, B, That]): That
• Scala used types VERY MUCH.It's cool.

37. How to ehnahce existing class
in Scala
• implicit conversion
• subclassing

38. How to ehnahce existing class
in Ruby
• subclassing
• direct modification(simplly
overwrite/alias_method_chain)
• define singleton method
• include/extend
• refinements

39. How to handle "non-existens
value"
• Scala: Option[T]
• Ruby: ♥nil♥
• false and nil is "falsy". Other values are "truthy".
• obj.foo if obj # call obj.foo if obj is not nil
• obj.try(:foo) # same (ActiveSupport feature)

40. Conclusion
• Ruby and Scala is very different, but they share
same goal: be productive, be fun.
• There are many different approach to solve
problems.We can learn things and achieve fresh
surprise from other culture.
Have a fun with various programming!!

41. Today I want talk to:
• Libraries
• rubygems: High accessibility
• Source distribution
• Easy to publish
• maven repo: Top on Java ecosystem
• Some impedance missmatch
• Binary distribution
• Bit difficult to publish, especially official repo.
• Build/Task system
• Rake: Simple scripting with internal DSL
• Sbt: Type-safe and immutable dependency graph construction with cool := ++= <<= s
• It's Scala's way!!
• Community
• Ruby: Humanity
• Love emotional context
• Scala: Types
• Love Monads !!!!