model with actors and implement with akka
TRANSCRIPT
Model with actors and implement with Akka
ITLC Hanoi, Oct 5 2015Ngoc Dao
https://www.linkedin.com/in/ngocdaothanh
https://github.com/ngocdaothanhhttps://github.com/xitrum-frameworkhttps://github.com/netty
https://www.atlassian.com/software
Favorite languages: Ruby, Erlang, Scala
My Scala style: Use Scala as ifScala = 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
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 beginnerPlease ask questions/discuss whenever you want
https://www.facebook.com/groups/720666194693928
http://www.slideshare.net/ngocdaothanh/develop-realtime-web-with-scala-and-xitrum
Xmas 2014New year 2015
More photos:Scala VN →Photos →Albums
http://www.meetup.com/scalasyd/https://github.com/scalasyd/scalasyd
● 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
Part 1/2:[What] Actor model
Benefit of actors in one sentenceC/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.
● 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/
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 ~ objectmethod call ~ msg sending
● Scala supports both actors and OOP objects(Erlang only supports actors)
Actor vs Thread● Thread: n dimensions, hard to reason about.● Actor: 1D, one thing at a time.
var1
var2
Actor vs ThreadThread:● 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.
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
Actor vs FutureActor:
● 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)
Some actor pitfallsSend 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.
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
Useful links● Concurrent Programming for Scalable Web
Architectureshttp://berb.github.io/diploma-thesis/index.html
● Functions + Messages + Concurrency = Erlanghttp://www.infoq.com/presentations/joe-armstrong-erlang-qcon08
Part 2/2:[How] Create actors with Akka[Demo]Multiplayerwebchess game
Chess gameSimple 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.
Useful linksAkka doc:http://akka.io/docs/
Chess:
● UCI (Universal Chess Interface) protocol:https://en.wikipedia.org/wiki/Universal_Chess_Interface
● Stockfish (world’s top open source UCI engine):https://github.com/official-stockfish/Stockfish
● JStockfish (JNI wrapper):https://github.com/ngocdaothanh/JStockfish
● Chessground (web UI):https://github.com/ornicar/chessground
● Chess.js (JavaScript logic):https://github.com/ornicar/chess.js
Chinese chess:
● UCCI (Universal Chinese Chess Interface) protocol:http://www.xqbase.com/protocol/cchess_ucci.htm
● UCCI engines:https://github.com/huygithub/hoxServer/tree/master/plugins