From Ruby to Scala

Hello, is there Rubyist?

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

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

Working at Platinum Sponsor

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

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.

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

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

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}.") } }

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

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

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

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)

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?!?!

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

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.

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

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

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"

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

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

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[

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)

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}

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

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)

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)

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 }

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

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)

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

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

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.

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

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

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)

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!!

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 !!!!

http://www.todesking.com	849
http://feedly.com	6
http://localhost	4
https://www.inoreader.com	1

From Ruby to Scala

by todesking

on Sep 06, 2014

Statistics

Views

Actions

4 Embeds 842

Accessibility

Categories

Upload Details

Usage Rights

Report content

From Ruby to Scala Presentation Transcript