The presentation by Dr. Roland Kuhn explores the concepts of distributed systems and compositionality through the lens of π calculus, emphasizing computation syntax, reduction rules, and the importance of protocols in ensuring communication safety. It discusses the challenges of behavior composition in distributed systems and introduces a new domain-specific language (DSL) inspired by π calculus to facilitate the composition of asynchronous actions. The session concludes with an outlook on tracking effects and ongoing theoretical work related to session types and process verification.

1. Distributed Systems
vs.
Compositionality
Dr. Roland Kuhn
@rolandkuhn — CTO of Actyx

2. Caveat:
This presentation shows unreleased APIs!

3. Weird starting point:
π calculus

4. What is a calculus?
• syntax for writing down a computation
• reduction rules for evaluating the syntax
4

5. π calculus: the syntax
5
Robin Milner et al, 1992
⇡ ::=
8
><
>:
x(y) receive y along x
xhyi send y along x
⌧ unobservable action
(1)
P ::=
X
i2I
⇡i.Pi P1|P2 new a P !P 0 (2)

6. π calculus: the reductions
6
TAU : ⌧.P + M ! P (3)
REACT : x(y).P + M xhzi.Q + N ! z/y P Q (4)
PAR :
P ! P0
P|Q ! P0|Q
(5)
RES :
P ! P0
new x P ! new x P0
(6)
STRUCT :
P ! P0
Q ! Q0
if P ⌘ Q ^ P0
⌘ Q0
(7)
Robin Milner et al, 1992

7. An example reduction
7
P = new z
⇣
(xhyi.0 + z(w).whyi.0) x(u).uhvi.0 xhzi.0
⌘
possibility 1
possibility 2

8. An example reduction
8
P = new z
⇣
0 yhvi.0 xhzi.0
⌘

9. An example reduction
9
P = new z
⇣
(xhyi.0 + z(w).whyi.0) x(u).uhvi.0 xhzi.0
⌘
possibility 2

10. An example reduction
10
P = new z
⇣
(xhyi.0 + z(w).whyi.0) zhvi.0 0
⌘
only one possibility

11. An example reduction
11
P = new z
⇣
vhyi.0 0 0
⌘

12. An example reduction
12
P = vhyi.0

13. There’s more!
• structural congruence allows symbolic
manipulation
• rename, reorder sums, expand recursion, …
• bi-simulation describes functional equivalence
13

14. So, what is a calculus?
• a way to write down computations
• a means to reason about computations
• a tool to compose computations
14

15. Composition

16. Composition in the π calculus
• you can
• run computations sequentially
• run computations concurrently
• synchronize concurrent computations
16

17. Composing processes
17
new cA
⇣
Pclient PserviceA
⌘
channel where
serviceA is reachable
will send to cA and
eventually react to
response
will react to cA and
eventually send back
a response

18. We need protocols!

19. What is a protocol?
• defines a communication discipline:
• who can send what kind of message, and when
• which kinds of message to expect, and when
• each distributed process must adhere to the
common protocol
• a global protocol can be checked for safety
19

20. Session types
• Session: a unit of conversation
• Session Type: the structure of a conversation,
a sequence of interactions in a
communication-centric program model
• originally only binary sessions,
multiparty session types introduced 2008
• primitives are
sending, receiving, sequence, choice, recursion
20
http://groups.inf.ed.ac.uk/abcd/

21. Session types example
21
Sreqresp = !Request(params) . ?Response(result)
Sreqresp = ?Request(params) . !Response(result)

22. But is it safe? Does it compose?
22
Pclient PserviceA PbackendA
PserviceB PbackendB

23. Protocols don’t compose!
• at least not in general, as far as we know
• some cases are (mostly?) okay
• non-cyclic
• non-interacting
• what a bummer!
⟹ let’s find a smaller problem to solve
23

24. Composing Actor Behavior

25. Behavior composition
25
new cinternal
⇣
PserviceA PclientB
⌘

26. 26
case class DoStuff(stuff: Stuff)
case class DoIt(it: It)
case class DoneSuccessfully(result: Result)
class MyActor(receptionist: ActorRef) extends Actor {
override def preStart(): Unit = receptionist ! Register
def receive = initializing
def initializing: Receive = {
case Registered =>
// do stuff
context.become(running)
}
def running: Receive = {
case DoStuff(stuff) =>
context.actorOf(Props[Child]) ! DoIt(???)
context.become(waitingForResult(stuff))
}
def waitingForResult(stuff: Stuff): Receive = {
case DoneSuccessfully(result) =>
// do stuff, e.g. replying
context.become(running)
}
}

27. We need reusable composable
behavior snippets!

28. Radical idea: π calculus within!
• idea sparked while listening to Alex Prokopec
• create DSL inspired by π calculus
• lifted representation of asynchronous actions
• combinators for sequential & parallel composition
28

29. What does it look like?
29
π calculus Akka Typed Sessions
new c P val serverChannel = channel[Command](128)
P initialize: Process[ActorRef[Request]]
π.P for {
backend ← initialize
server ← register(backend)
} yield run(server, backend)
P|Q fork(task): Process[Unit]
read(serverChannel) race timeout(1.second)
getThingA join getThingB
x(y) read(serverChannel): Process[Command]
x❬y❭ serverChannel.ref ! msg
(synchronous send operation not there, yet)

30. Example of a Server Process
30
def run(server: Channel[ServerCommand],
backend: ActorRef[BackendCommand])
: Process[Nothing] =
for {
cmd ← read(server)
} yield cmd match {
case GetIt(which, replyTo) =>
val spinOff =
talkWithBackend(which, backend)
.foreach(thing => replyTo ! GotIt(thing.weird))
fork(spinOff race timeout(5.seconds))
.then(run(server, backend))
}

31. Example of a Server Process
31
def talkWithBackend(which: String,
backend: ActorRef[BackendCommand])
: Process[TheThing] = {
val code = channel[Code](1)
val thing = channel[TheThing](1)
backend ! GetThingCode(0xdeadbeefcafeL, code.ref)
for {
c ← readAndSeal(code)
} yield {
c.magicChest ! GetTheThing(which, thing.ref)
readAndSeal(thing)
}
}

32. What does this have to do with Akka?
• Akka Typed Behavior to interpret Process
• channel reference is a lean child ActorRef
• this closes the gap between the Actor Model
and CSP/π
• Actors have stable identity but only one channel
• anonymous Processes have multiple channels
(with identity)
32

33. Outlook

34. Tracking effects
• lifted representation of Process allows
tracking of effects
• embedding of session type in π calculus exists
• verify Process against a session type
34

35. Irresponsible Speculation
35
// Effects is similar to HList (but a tree)
trait Process[T, E <: Effects] {
def map[U, UE <: Effects](f: T => Process[U, UE])
:Process[U, UE :*: E]
def join[U, UE <: Effects](p: Process[U, UE])
:Process[(T, U), UE :+: E]
def race // ???
}
def read[T](c: Channel[T]): Process[T, Recv[c.type]]
def write[T](ref: ActorRef[T]): Process[T, Send[ref.type]]
def fork[T, TE <: Effects](p: Process[T, TE])
: Process[Unit, NoEffect :|: TE]

36. Current State
• behaviors can be composed both sequentially
and concurrently
• effects are not yet tracked
• Scribble generator for Scala not yet there
• theoretical work at Imperial College, London
(Prof. Nobuko Yoshida & Alceste Scalas)
36

37. ©Actyx AG 2016 – All Rights Reserved