4. Favorite languages: Ruby, Erlang, Scala
My Scala style: Use Scala as if
Scala =
Java (performance, libs eco) +
Ruby (human oriented syntax) +
Erlang (functional, reactive)
Interests:
● Realtime and distributed systems
● Multiplayer games
● Web frameworks (wrote several for Erlang, Scala, Java)
"Soon we had three kinds of Scala
written at Twitter: Scala written by
people who wished it was Ruby, Scala
written by people who wished it was
Java, and Scala written by people who
wished it was Haskell."
http://www.gigamonkeys.com/flowers/
https://youtu.be/sYsHK81MTHI
5. Schedule
● [What] Explain about actor model:
~¼ of time
● [How] Explain about how to create actors with
Akka library, via multiplayer chess demo:
~ ¾ of time
Level: Scala beginner
Please ask questions/discuss whenever you want
10. ● Your workplace, your school etc.
● Your background, your favorite languages
● Do you know Scala?
● Why do you want to learn Scala?
● How do you know about this meetup?
● What do you expect from this meetup?
● etc. etc.
Please introduce yourselves
12. Benefit of actors in one sentence
C/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 and
sync vars manually.
Don't communicate by sharing memory;
share memory by communicating.
13. ● Actor =
states +
mailbox +
behaviors (msg handlers)
● From outside, can’t manipulate actors directly.
● To interact with an actor, must send msgs to it.
● Each actor has a mailbox, msgs are put to mailbox, and
processed one by one. ← An actor is like a single
threaded 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/
14. Actor vs OOP
“The Actor model adopts the philosophy that everything is an actor. This is
similar to the everything is an object philosophy used by some object-oriented
programming languages, but differs in that object-oriented software is typically
executed sequentially, while the Actor model is inherently concurrent.”
https://en.wikipedia.org/wiki/Actor_model
● An actor is somewhat similar to an object
=> Easy to learn/model:
actor ~ object
method call ~ msg sending
● Scala supports both actors and OOP objects
(Erlang only supports actors)
15. Actor vs Thread
● Thread: n dimensions, hard to reason about.
● Actor: 1D, one thing at a time.
var1
var2
16. 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.
17. Just like JVM automatically manages memory for you, so
that you don’t have to care about releasing memory
manually:
● Actor is a high level logical way to think, to model
programs. You don’t have to care about managing
threads and syncing vars manually.
● At lower level, actors still run above a managed thread
pool.
Actor vs Thread
18. Actor vs Future
Actor:
● Reactive: messaging, scheduling
● FSM (Finite State Machine)
● Monitoring
● 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: Run future A first, then B, then C etc.
● More typesafe (Akka 2.4.0 introduced “Akka Typed” feature)
19. Some actor 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.
20. 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
24. Chess game
Simple spec, focus on chess logic:
● Web, multiplayer
● Standard chess, no variations (chess 960 etc.)
● No reconnection on network disconnection
● No time
● No game watching
● No chat
● No etc.