distributed systems vs compositionality
TRANSCRIPT
![Page 1: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/1.jpg)
Distributed Systems vs.
CompositionalityDr. Roland Kuhn
@rolandkuhn — CTO of Actyx
![Page 2: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/2.jpg)
Caveat:
This presentation shows unreleased APIs!
![Page 3: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/3.jpg)
Weird starting point:
π calculus
![Page 4: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/4.jpg)
What is a calculus?
• syntax for writing down a computation
• reduction rules for evaluating the syntax
4
![Page 5: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/5.jpg)
π 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 aP
��� !P��� 0 (2)
![Page 6: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/6.jpg)
π calculus: the reductions
6
TAU : ⌧.P +M ! P (3)
REACT :
�x(y).P +M
����xhzi.Q+N
�!
�z/y P
��Q (4)
PAR :
P ! P
0
P |Q ! P
0|Q (5)
RES :
P ! P
0
newxP ! newxP
0 (6)
STRUCT :
P ! P
0
Q ! Q
0 if P ⌘ Q ^ P
0 ⌘ Q
0(7)
2
Robin Milner et al, 1992
![Page 7: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/7.jpg)
An example reduction
7
P = new z
⇣(xhyi.0 + z(w).whyi.0)
��� x(u).uhvi.0��� xhzi.0
⌘possibility1
possibility2
![Page 8: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/8.jpg)
An example reduction
8
P = new z
⇣0
��� yhvi.0��� xhzi.0
⌘
![Page 9: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/9.jpg)
An example reduction
9
P = new z
⇣(xhyi.0 + z(w).whyi.0)
��� x(u).uhvi.0��� xhzi.0
⌘
possibility2
![Page 10: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/10.jpg)
An example reduction
10
P = new z
⇣(xhyi.0 + z(w).whyi.0)
��� zhvi.0��� 0
⌘onlyonepossibility
![Page 11: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/11.jpg)
An example reduction
11
P = new z
⇣vhyi.0
��� 0��� 0
⌘
![Page 12: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/12.jpg)
An example reduction
12
P = vhyi.0
![Page 13: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/13.jpg)
There’s more!
• structural congruence allows symbolic manipulation • rename, reorder sums, expand recursion, …
• bi-simulation describes functional equivalence
13
![Page 14: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/14.jpg)
So, what is a calculus?
• a way to write down computations
• a means to reason about computations
• a tool to compose computations
14
![Page 15: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/15.jpg)
Composition
![Page 16: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/16.jpg)
Composition in the π calculus
• you can • run computations sequentially
• run computations concurrently
• synchronize concurrent computations
16
![Page 17: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/17.jpg)
Composing processes
17
new cA
⇣Pclient
��� PserviceA
⌘
channelwhereserviceAisreachable
willsendtocAandeventuallyreactto
response
willreacttocAandeventuallysendbackaresponse
![Page 18: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/18.jpg)
We need protocols!
![Page 19: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/19.jpg)
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
![Page 20: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/20.jpg)
Session types
• Session: a unit of conversation
• Session Type: the structure of a conversation,a sequence of interactions in acommunication-centric program model
• originally only binary sessions,multiparty session types introduced 2008
• primitives aresending, receiving, sequence, choice, recursion
20
http://groups.inf.ed.ac.uk/abcd/
![Page 21: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/21.jpg)
Session types example
21
Sreqresp = !Request(params) . ?Response(result) (8)
Sreqresp = ?Request(params) . !Response(result) (9)
![Page 22: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/22.jpg)
But is it safe? Does it compose?
22
Pclient PserviceA PbackendA
PserviceB PbackendB
![Page 23: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/23.jpg)
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
![Page 24: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/24.jpg)
Composing Actor Behavior
![Page 25: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/25.jpg)
Behavior composition
25
new cinternal
⇣PserviceA
��� PclientB
⌘
![Page 26: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/26.jpg)
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) } }
![Page 27: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/27.jpg)
We need reusable composable behavior snippets!
![Page 28: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/28.jpg)
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
![Page 29: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/29.jpg)
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)
![Page 30: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/30.jpg)
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)) }
![Page 31: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/31.jpg)
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) }}
![Page 32: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/32.jpg)
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
![Page 33: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/33.jpg)
Outlook
![Page 34: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/34.jpg)
Tracking effects
• lifted representation of Process allows tracking of effects
• embedding of session type in π calculus exists
• verify Process against a session type
34
![Page 35: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/35.jpg)
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]
![Page 36: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/36.jpg)
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
![Page 37: Distributed systems vs compositionality](https://reader031.vdocuments.mx/reader031/viewer/2022021919/587941e41a28ab23468b65d3/html5/thumbnails/37.jpg)
©Actyx AG 2016 – All Rights Reserved