Learn Scala for realtime web with Xitrum

Develop realtime and
distributed web
with Scala and Xitrum
Ngoc Dao
Saigon Xmas 2014
Hanoi New Year 2015

http://www.toptal.com/scala/why-should-i-learn-scala
http://cacm.acm.org/magazines/2014/4/173220-unifying-functional-and-object-
oriented-programming-with-scala/fulltext

Slides will be shared at:
http://www.slideshare.net/ngocdaothanh
This talk is long.
Please ask question immediately when you have one.
For questions/discussions after this talk, please post to:
https://www.facebook.com/groups/720666194693928
You can also post to scala-user group:
https://groups.google.com/d/forum/scala-user

About me
Working at Mobilus in Tokyo: http://mobilus.co.jp/
● Server side
● Android, iOS
Interests:
● Realtime and distributed systems
● Web frameworks
(have been written several for Erlang, Scala, Java)
● Big data, analytics (learning Apache Spark)
Open source:
● https://github.com/ngocdaothanh
● https://github.com/xitrum-framework
● https://github.com/sinetja
● https://github.com/netty

Scala@Japan
● Meetups: ~monthly (in Tokyo)
● Conferences: yearly
○ 2013:
http://scalamatsuri.org/2013/en/program/index.html
○ 2014:
http://scalamatsuri.org/en/program/index.html
http://scalamatsuri.org/en/unconference/index.html

About you
I guess you already know OOP.
Functional programming:
● How many of you have used Ruby?
(somewhat functional, popular)
● Have used a more functional language?
(Lisp, Haskell, Erlang, Clojure, F# etc.)
Scala looks like Java and runs on JVM. It’s convenient if
you already know Java:
● How many of you have used Java?
● Have used Scala?

● Why use Scala? Compare with Java, Ruby, Node.js etc.
● Books, sites
Getting started:
● Install Scala
● Ways to run Scala program: Hello World
Scala = OOP + functional:
● Learn Scala’s functional feature via collections
● Learn Scala’s OOP feature via the Animals exercise
Some tools:
● Development:
○ REPL (Read–Eval–Print Loop), SBT (Scala Build Tool)
○ IDEs: Eclipse, IntelliJ
● Production:
○ xitrum-package
○ Scalive
PART 1/5: Scala overview

● Web app ≈ normal app + routing
● Xitrum:
○ Compare with Scalatra, Lift, Play
○ Basic usage:
■ Add routes to the previous demos
■ respondXxx
○ Swagger UI, Swagger Codegen
○ Metrics
○ i18n
PART 2/5: Use Scala for web

● Compare with Node.js
● Future and future composition
● Actor model and Akka actor
↑ NEW programming paradigm
A language that doesn't change the way you
think about programming is not worth
learning.
○ Actor vs Thread
○ Actor vs Future
○ Some pitfalls
● Akka FSM
PART 3/5: Use Scala for concurrency

● Realtime web
● WebSocket, Socket.IO, SockJS
● Tictactoe web game
PART 4/5: Use Scala for realtime web

PART 5/5: Use Scala for distributed systems
Compare with Redis
Remoting:
● Akka remoting
Clustering:
● Akka clustering
● Glokka
● Hazelcast
Scale Tictactoe to multiple servers

● Trendy: Used by by Apple, Foursquare, Guardian, LinkedIn,
Netflix, Quora, Sony Pictures Entertainment, Twitter, UK Guardian
etc.
● Compare with Java, Ruby, Node.js etc.
● Language: ≈ Java + Ruby
○ Fast speed of Java + nice syntax of Ruby:
Faster than Ruby + syntax nicer than Java
○ Flexible:
■ Static + dynamic:
Compiled to Java .class or run as script like Ruby
■ OOP of Java + functional of Ruby
http://www.quora.com/Why-is-Swift-so-similar-to-Scala
● Not only a good language: Scala has toys
○ Ecosystem: Can reuse all Java libs
○ Concurrent/parallel: Future, Akka (≈ Erlang)
○ Big data: Apache Spark
Why use Scala?

Books, sites
● http://www.scala-lang.org/documentation/
● http://twitter.github.io/effectivescala/
● https://github.com/lauris/awesome-scala
● https://github.com/akullpp/awesome-java
● Search

Learn Scala “enough” to do projects
How much is “enough”?

Level A1:
Beginning application programmer
● Java-like statements and expressions:
standard operators, method calls,
conditionals, loops, try/catch
● class, object, def, val, var, import, package
● Infix notation for method calls
● Simple closures
● Collections with map, filter, etc
● for-expressions
http://www.scala-lang.org/old/node/8610

Level A2:
Intermediate application programmer
● Pattern matching
● Trait composition
● Recursion, in particular tail recursion
● XML literals

Level A3:
Expert application programmer
● Folds, i.e. methods such as foldLeft,
foldRight
● Streams and other lazy data structures
● Actors
● Combinator parsers

Level L1:
Junior library designer
● Type parameters
● Traits
● Lazy vals
● Control abstraction, currying
● By-name parameters

Level L2:
Senior library designer
● Variance annotations
● Existential types (e.g., to interface with Java
wildcards)
● Self type annotations and the cake pattern
for dependency injection
● Structural types (aka static duck typing)
● Defining map/flatmap/withFilter for new kinds
of for-expressions
● Extractors

Level L3:
Expert library designer
● Early initializers
● Abstract types
● Implicit definitions
● Higher-kinded types
A1 → A2/L1 → A3/L2 → L3

Install Scala
1. Download from
http://www.scala-lang.org/
2. Config PATH:
PATH=path/to/scala-2.11.4/bin:$PATH
REPL (Read–Eval–Print Loop) demo:
scala command

Ways to run Scala program
● println("Hello World")
● Run as script with scala
● Compile with scalac and run with scala
● Compile with scalac and run with java

SBT (Scala Build Tool)
http://www.scala-sbt.org/
● Dependency library manager + build tool
● Like “gem” + “rake” of Ruby
● Like Maven, Gradle
● Has plugins to generate project files for IDEs,
like Eclipse and IntelliJ
● Has plugins to collect and package .jar files,
ready to deploy to production environment
(Make, Ant are just build tools, not dependency library
managers)

Install SBT
1. Download from
http://www.scala-sbt.org/download.html
2. Config PATH:
PATH=path/to/sbt/bin/dir:$PATH
sbt:
java -Xms256M -Xmx512M
-jar `dirname $0`/sbt-launch-0.13.7.jar "$@"
Learn SBT:
http://www.scala-sbt.org/documentation.html

Simple SBT-based project structure

build.sbt
organization := "com.mycompany"
name := "hello"
version := "1.0"
scalaVersion := "2.11.4"
scalacOptions ++= Seq("-deprecation", "-feature", "-unchecked")
javacOptions ++= Seq("-source", "1.6", "-target", "1.6")
libraryDependencies += "tv.cntt" %% "xitrum" % "3.21"
libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.1.2"
Packaged .jar file:
hello_2.11-1.0.jar

$ sbt tasks
console Starts the Scala interpreter
compile Compiles sources
clean Deletes files produced by the build
run Runs a main class
package Produces project jar file
publish Publishes project jar file to a repository
publish-local Copies project jar file to ~/.ivy2
test Executes all tests
test-only Executes the tests provided as arguments
test-quick Executes the tests that either failed before

SBT plugins
http://www.scala-sbt.org/release/docs/Community-Plugins.html
Generate Eclipse project:
https://github.com/typesafehub/sbteclipse
Generate IntelliJ project:
https://github.com/mpeltonen/sbt-idea
Package project:
https://github.com/xitrum-framework/xitrum-package

Hello World demo
● sbt console
● sbt run
● sbt eclipse
● Run in Eclipse
● Debug in Eclipse
● sbt xitrum-package
● Run with java
● Add dependency library
http://search.maven.org/
● Scalive

Rules of thumb
Use dependency manager:
● Do not download dependency libraries
manually
● Do not commit dependency libraries
IDEs:
● Generate project files for IDEs
● Do not commit project files

Scala = OOP + functional
Unifying Object-Oriented and Functional Programming
http://web.stanford.edu/class/cs94si/OOPFP.pdf

Functional language
● Pass a function as an argument to another
function
=> Convenient syntax
f(123, g)
f(123, {
// ...
})
● Immutable data structures
=> Thread-safe
○ Tail recursion

Learn Scala’s functional feature via
collections
● From a collection, create another collection of same size
=> map
● From a collection, create another collection of larger size
=> flatMap
● From a collection, create another collection of smaller size
=> filter
● From a collection, create one element
=> foldLeft, foldRight, reduce
http://www.scala-lang.org/api/current/index.html#scala.collection.Seq

val a = 1
var b = 1
b = 2
val → immutable:
val c = Seq(1, 2, 3)
var → immutable:
var d = Seq(1, 2, 3)
d = Seq(4, 5, 6)
val → mutable:
val e = Array(1, 2, 3)
e(0) = 4
var → mutable:
var f = Array(1, 2, 3)
f = Array(4, 5, 6)
f(0) = 4

val VS var
immutable VS mutable collection
Order of preference (best practice):
● val
● var
● val → immutable: strictly functional
● var → immutable
● val → mutable
● var → mutable: do not use
Some languages only allow val → immutable
Scala is flexible:
var and mutable are OK to use in small, closed scope

For your curiosity: How to write
programs with only constants?
Example problem:
Without var, mutable:
● Generate a collection of positive numbers
that are <= n, and are multiple of 3 or 5.
gen(n: Int): Seq[Int]
● Calculate sum of all numbers in a collection.
sum(nums: Seq[Int]): Int

With var and mutable
import scala.collection.mutable.ArrayBuffer
def gen(n: Int): Seq[Int] = {
val buf = ArrayBuffer[Int]()
var i = 1
while (i <= n) {
if (i % 3 == 0 || i % 5 == 0)
buf.append(i)
i += 1
}
buf
}

val nums = 1 to n
nums.filter { i =>
i % 3 == 0 || i % 5 == 0
}
}
for {
i <- 1 to n
if (i % 3 == 0 || i % 5 == 0)
} yield i
}

Without var and mutable
● Use recursion to loop
● Optimize: Use tail recursion
○ Use accumulator

// Stop condition
if (n < 3) return Seq()
// Recursion
if (n % 3 == 0 || n % 5 == 0)
gen(n - 1) :+ n
else
gen(n - 1)
}
Stackoverflow
if n is big enough

def genAcc(
n: Int, acc: Seq[Int]
): Seq[Int] = {
if (n < 3) return acc
// Tail recursion; Scala compiler will
// convert to “while” loop
if (n % 3 == 0 || n % 5 == 0)
genAcc(n - 1, n +: acc)
else
genAcc(n - 1, acc)
}
def gen(n: Int) = genAcc(n, Seq())

def genAcc(
n: Int, acc: Seq[Int]
): Seq[Int] = {
if (n < 3) return acc
if (n % 3 == 0 || n % 5 == 0)
genAcc(n - 1, n +: acc)
else
genAcc(n - 1, acc)
}
How to write programs with only
constants?
State is stored
at function arguments
State is set/changed
at function call

How I learn an OOP language:
● Learn basic syntax
● Learn collections
● Animals exercise:
abstraction, encapsulation,
inheritance, polymorphism
Learn Scala’s OOP feature via the
Animals exercise

Animals exercise
trait (interface) Animal
● name: String
● talk()
class Cat extends Animal
class Dog extends Animal
class Zoo
● addAnimal(a: Animal)
● talkAll()

scala-lang.org
→ /api/
Companion object
Class
Trait
http://youtu.be/GQxUEAXX_fE
How to read Scaladoc

● Web app ≈ normal app + routing
● Xitrum:
○ Compare with Scalatra, Lift, Play
○ Basic usage:
■ Add routes to the previous demos
■ respondXxx
○ Swagger UI, Swagger Codegen
○ i18n
PART 2/5: Use Scala for web

Web ≈ Routing
function
Input Output
function
Input Output

Web ≈ Routing
A web library/framework is not worth using if its routing feature sucks.
function
Request Response
function
ResponseRequest
Request
Request
Router

Xitrum
http://xitrum-framework.github.io/
Compare with Scalatra, Lift, Play
Demos:
https://github.com/xitrum-framework/xitrum-demos
Skeleton to create new project:
https://github.com/xitrum-framework/xitrum-new

● Basic usage:
○ Add routes to the previous demos
○ respondXxx
● Swagger UI, Swagger Codegen
● Metrics
● i18n
Xitrum

Compare with Node.js
Node.js:
● Single thread => Single core
● Complicate to scale to multiple cores or multiple
servers; except for shared-nothing (non-realtime)
systems
● Callback hell
Scala:
● Multiple threads; immutable data structures, future, and
actor provide more safety for multithread programming
● Easy to scale
● No callback hell

Future
http://docs.scala-lang.org/overviews/core/futures.html
Think about Future as a thread pool with some
nice methods to:
● send tasks to it
● get results
● handle failures
● compose the above together

Future composition
f
f
f
f
f
f
f
f1
f2
f3
f
Think about Node.js callback hell!
● Future.sequence
● for comprehension

val taskParams = Seq(123, 456, 789)
val taskFutures: Seq[Future[String]] =
tasks.map { ms =>
future {
Thread.sleep(ms)
s"Result for $ms"
}
}
val gatheredFuture: Future[Seq[String]] =
Future.sequence(taskFutures)

val purchase = for {
usd <- future { con.getValue(USD) }
chf <- future { con.getValue(CHF) }
if isProfitable(usd, chf)
} yield connection.buy(amount, chf)
purchase onSuccess { amount =>
println("Purchased " + amount + " CHF")
}

↑ NEW programming paradigm
A language that doesn't change the way you
think about programming is not worth
learning.
Alan Perlis
(the first recipient of the Turing Award)
Actor model and Akka actor

Benefit of actor in one sentence
C vs Java:
You can use memory without having to release
memory manually.
Thread vs actor:
You can use concurrency without having to
create threads manually.
Don't communicate by sharing memory; share memory by
communicating.

Actor model
● Actor =
states +
mailbox +
behaviors (msg handlers)
● From outside, can’t manipulate actors directly.
● To interact with an actor, must send messages to it.
● Each actor has a mailbox, messages are put to mailbox,
and processed one by one. ← An actor is like a single
threaded process (each actor is like a Node.js process);
it doesn’t do more than one thing at a time.
http://www.cs.tsukuba.ac.jp/~yas/cs/csys-2013/2013-12-03/

Actor vs Thread
Thread:
● Heavy weight: Can only create not too many threads;
usually: 2000~5000
● Shared state ← Source of bugs
● Passive: Have to call object.method() to make the object
alive.
Actor:
● Light weight: Can create millions of actors;
usually: ~2.5 million actors/GB
● Self contained, shared nothing
● Active: Actors are alive by themselves. ← Easy to model
programs that have millions of on-going things (very high
level of concurrency), like MMOG games.

Actor vs Thread
● Thread: n dimensions, hard to reason about.
● Actor: 1D, one thing at a time.
var1
var1

Actor vs Thread
Just like JVM automatically manages memory
for you:
● Actor is a high level logical way to think, to
model programs.
● At lower level, actors run above a thread
pool.

Actor vs Future
Actor:
● Messaging
● Scheduling
● FSM
● Monitoring and supervision
● Location transparency
(actors on one server can send messages to actors on
another server)
=> Easier to scale out to multiple servers/clustering
Future:
● Syntax is easier to write
● Composable
● More typesafe

Akka http://akka.io/
(an implementation of the actor model)
Summary:
https://jraviton.wordpress.com/2015/01/16/lets-brush-up-on-scala-actors/

Demo: Counter
// First, define messages
object Counter {
case class Inc(amount: Int)
case class Dec(amount: Int)
}

import akka.actor.Actor
// Define actor state and message handlers
class Counter(name: String) extends Actor {
// Actor state
private var value = 0
...

...
import Counter._
// Message handlers
def receive = {
case Inc(amount) =>
value += amount
println(s"Value: $value")
case Dec(amount) =>
value -= amount
println(s"Value: $value")
}
}

import akka.actor.{ActorSystem, Props}
// Think of this as a thread pool
val system = ActorSystem("mysystem")
// Create actor reference (actor instance)
val c1 = system.actorOf(
Props(new Counter("mylock"))
)
// Send messages to the actor
c1 ! Counter.Inc(1)
c1 ! Counter.Dec(2)

Some pitfalls
Send mutable msgs between actors.
↑ May lead to bug, if actor A sends msg M to
actor B, state of B incorporates M, then M is
later changed by A.
=> Shared memory
Fix: Use immutable messages.

Some pitfalls
From inside actor:
anObject.foo(new Callback {
def onCallback() {
// Modify actor state directly
}
})
↑ May lead to bug, because the actor’s thread and the
callback’s thread may be 2 different threads. Remember:
An actor is like a single threaded process, can’t do more
than one thing at a time. An actor should be self contained,
shared nothing.
Fix: self ! msgFromCallback

Good read
● Concurrent Programming for Scalable Web
Architectures
http://berb.github.io/diploma-thesis/index.html
● Functions + Messages + Concurrency =
Erlang
http://www.infoq.com/presentations/joe-armstrong-
erlang-qcon08
● Akka doc
http://doc.akka.io/docs/akka/2.3.8/scala.html

Akka FSM
● FSM: Finite State Machine
● Implemented based on actors
● Very good for realtime multiplayer games, to
manage states of game sessions and inter-
player interactions
Example:
Code Lock
https://github.com/ngocdaothanh/code-lock-fsm-akka

HTTP problem:
Server can send data to clients only one time.
Some years ago:
Flash (open TCP socket connection to server)
Now:
WebSocket
https://developer.mozilla.org/en-
US/docs/WebSockets/Writing_WebSocket_clie
nt_applications
Realtime web ≈ server push

WebSocket problem
New browsers are required:
● Internet Explorer: 10
● Firefox: 6
● Chrome: 4
● Safari: 5
● Opera: 12.10

WebSocket emulators
SockJS: WebSocket-like API
● JavaScript client:
https://github.com/sockjs/sockjs-client
● Protocol:
https://github.com/sockjs/sockjs-protocol
http://sockjs.github.io/sockjs-protocol/sockjs-protocol-0.3.3.html
● Closer to WebSocket, much simpler than Socket.IO
=> Server side support for many languages
Socket.IO: More complicate built-in features, like rooms
● http://socket.io/
● Node.js

SockJS
● Provides WebSocket-like API
● Supports all browsers, e.g. IE 6
● Transports: websocket xhr-streaming xdr-
streaming iframe-eventsource iframe-
htmlfile xhr-polling xdr-polling iframe-xhr-
polling jsonp-polling
● Requires
○ Client side: sockjs.js
○ Server side: SockJS protocol
implementation

var sock = new WebSocket('ws:
//domain/path');
};
sock.send(e.data);
};
};
var sock = new SockJS('http:
//domain/path');
};
sock.send(e.data);
};
};
WebSocket vs SockJS

Tictactoe web game
https://github.com/xitrum-framework/xitrum-tictactoe

Tictactoe web game
Exercises:
● Instead of letting player actors send messages directly
to each other, use an intermediate game actor for each
game.
● Let users other than the players watch games.
● Use Scala.js to convert game logic code written in Scala
to JavaScript, to share game logic code between server
side and client side.
http://www.scala-js.org/
● Use Akka FSM instead of become.

Compare with Redis
Remoting:
● Akka remoting
Clustering:
● Akka clustering
● Glokka
● Hazelcast
PART 5/5: Use Scala for distributed systems

Compare with Redis
Redis:
● Separate process
● Single point of failure
Akka, Hazelcast:
● In-process
=> Faster, easier to use
● Redundancy, failover

Akka remoting
http://doc.akka.io/docs/akka/2.3.8/scala/remoting.html

Akka clustering
http://doc.akka.io/docs/akka/2.3.8/scala/cluster-usage.html

Glokka
https://github.com/xitrum-framework/glokka
A Scala library that allows you to register and
lookup actors by names in an Akka cluster.

Hazelcast
Program ≈ Code + Data
Distributed Program ≈ Distributed Code + Distributed Data
Akka ≈ Distributed Code
Hazelcast ≈ Distributed Data + Distributed Code
http://hazelcast.org/
http://hazelcast.com/

http://docs.hazelcast.org/docs/3.4/manual/html/
● Distributed data structures: Map, Multimap, Queue, Set,
List, Topic (pub/sub), Lock, AtomicLong,
AtomicReference, Semaphore, CountDownLatch,
IdGenerator
● JCache
● Distributed ExecutorService
● Transaction
● MapReduce, Aggregators
● Integration: Hibernate, Servlet session replication,
Spring
● Client: Java, C++, .NET, REST, memcache

Only need to change Lobby lookup
=> Use Glokka
Config Akka cluster:
config/akka.conf

Learn Scala for realtime web with Xitrum

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Learn Scala for realtime web with Xitrum

Similar to Learn Scala for realtime web with Xitrum (20)

More from Ngoc Dao

More from Ngoc Dao (18)

Recently uploaded

Recently uploaded (20)

Learn Scala for realtime web with Xitrum