Player is loading...
Akka Streams to the Extreme
Heiko Seeberger, independent consultant
Wednesday, June 12, 2019 · 11:16 a.m. · 45m 41s
Actors are a powerful yet highly focussed and rather low-level tool. Often there are better ways to implement certain aspects of a domain. In this talk we share our experiences with using Akka Streams at the core of the web services created at MOIA which offers ride sharing services. We will argue that streams are a better fit to implement the typical processes of web applications and we will investigate how Akka Streams can be used to protect against overload, enable lossless redeployments and – by using some advanced features – even enable something like "stream sharding".
Embed
Transcriptions
Note: this content has been automatically generated.
00:00:00
this is already in excellent example for extreme stream i
00:00:05
mean stream of people flowing into this room almost endlessly
00:00:14
so
00:00:16
to the two thousand and ten i was giving a presentation at the first colour days
00:00:20
i think it was about um a scholar d. s. l. for always g. i. and
00:00:27
a little later oh my head it was g. i. support talker
00:00:33
unfortunately
00:00:36
um and all this cycle sort of closes because i'm talking about
00:00:40
talk again here it is tenth or is it the ninth anniversary
00:00:45
i don't know two thousand ten until two thousand nineteen whatever it's called the tenth
00:00:53
we're glad here anyway
00:00:56
okay so in this presentation i would like
00:01:00
to talk about some advanced features of our screens not necessarily extreme but i think
00:01:08
it sounds good string extreme a preview
00:01:13
knows august region is what has been using our constraints if that's too okay
00:01:21
so what i'm going to show you is already used in production at more yeah
00:01:27
my office of rights sharing in a couple of a german cities like hamburg in hanover
00:01:33
and uh when i became case in the project last year um
00:01:40
i had the chance to work on a particular sub project which was a
00:01:45
green few project and we decided to use a lot of hockey streams in it
00:01:49
what you're seeing today is not the actual code base of more yeah but um
00:01:57
very simplified form of the things which are really used there
00:02:04
my yeah ah office ride sharing with those beautiful shuttles i've shown in
00:02:08
the previous slide the running on a. w. s. using common it is
00:02:13
they have a mike ushers architecture for large
00:02:18
parts of their systems and for some sources
00:02:22
they are using hawk h. e. p. and for some they are also using a cluster
00:02:28
anything one no more about how to manage not
00:02:31
classroom could burnett is you can later date fifteen thirty
00:02:36
go to talk of my body more 'cause you will who's looking at maya will cover all the details
00:02:45
so uh when i was in case the project we
00:02:47
had the following situation which is a simplification in this diagram
00:02:52
there's not a c. p. a. p. i. offering probe off and uh jason endpoints
00:02:59
then taking his people crests and marketing them to the main requests and then going
00:03:07
for actors which most of you probably do when you use ah k. g. p. right
00:03:12
um and then some actors talk to other actors
00:03:17
which might even live on different nodes as shown here
00:03:22
now what do you think could be a problem in
00:03:26
the scenario where and couldn't just decides to shut down part
00:03:32
any ideas
00:03:40
okay i couldn't hear anything sorry for that um
00:03:45
you could lose requests right
00:03:48
in particular if corners decides to shut on o. d.
00:03:52
while this actor here has not yet to flight to this act over there
00:03:57
the request which has started no day kind of get completed so you lose
00:04:02
that request and potentially more guys losing a customer so that's no good um
00:04:09
so what could we do against that first of all we could use a feature of ah casey key
00:04:17
which is the terminate method which is defined on the server binding class
00:04:24
interestingly that has been headed around june last year and
00:04:30
eight give you what you want it does no longer accept
00:04:34
new connection but it brings existing connections so until this termination deadline
00:04:39
um all the requests that had been accepted will be completed in only then
00:04:46
the shutdown of uh the actresses double continue
00:04:52
this is really good and we had it that in the meantime initially we didn't know about it
00:04:57
but in the meantime we added but the question is is this good enough let's revisit this picture here
00:05:06
the term it method refers to the server binding so if there's not a accepts request
00:05:14
recognise was shut down no day all does good disorder will be
00:05:19
delay but what with going as want to shut down not be
00:05:25
well
00:05:26
no does not related to any h. t. p. request
00:05:29
directly so logic shown here sorry here on or be
00:05:37
that's not really the type of movie so we would still lose requests
00:05:43
and it's not good has said so we needed to come up with something better
00:05:49
in our design idea was why not implement all the request handing processes with august frames
00:05:56
yeah
00:05:59
using extremes would also give us other benefits for example tightness
00:06:04
well that's ah type actors market type now
00:06:09
but expenses also typed and pressure so this seems like a great year and
00:06:18
you more detail request having process conceptually the flow from
00:06:22
a request to response or to either arrow or response and
00:06:29
in this design approach actors only used for for state which is spanning
00:06:34
multiple processing stages all processes to put data transformation use screams and for
00:06:41
a long live state use actors to use a lot less
00:06:46
actors and for and the the one in processes the meticulous processes
00:06:55
they need to be suitably broke into the corny shut down to no
00:06:59
longer accept new requests and the lady shut down and to accept requests
00:07:03
have been processed and that means have been processed across the whole type one here
00:07:09
and this is still the actor type i'm sorry the high level design of all
00:07:14
the new approach would be that we have those
00:07:18
running streams running processes here the red boxes on
00:07:23
the multiple notes and he if request comes in
00:07:28
it runs through various stages in this process and at some point
00:07:33
this process branches out to some other running process on another note
00:07:39
and a response from that process comes back here and so on and
00:07:43
so on and it's important that those processes those two processes in this example
00:07:49
are typically hooked into cornish certain of their respective machines to avoid losing requests
00:07:56
that id or make sense
00:08:01
great so if it would be a compares the composition nobody
00:08:07
hard work for me to stay you could compose your overall system from
00:08:13
steps from logical steps from clothes or maybe even more complicated
00:08:18
or complex grass but you could have reasonably small a size
00:08:26
processing steps and of course you get back pressure on him which
00:08:31
is not the case if you uh have basically route that is directly asking an actor
00:08:39
and the most important thing last last week long it's
00:08:44
because there are some challenges and i'm trying to address those during the rest of the pro uh talk
00:08:50
so how can we link okay should be routes and processes then how can we connect to running
00:08:56
processes i mean what does that mean it all and how can you can stream across class the notes
00:09:06
these uh probably interesting questions you unless you have them already solved
00:09:10
but normally defined a flow you material is it everything is local
00:09:16
elements don't branch out of the flow into some other running stream and so
00:09:20
on so these are really interesting challenges and we have sold all of them
00:09:27
and just all those we have applied those tools so these are all these advanced features of
00:09:34
our streams like flow with context and to be honest that isn't get used it more yeah
00:09:41
hopefully we will get their source humour chalk hills which sink
00:09:46
ref or so a screen press for remote screaming and restructuring
00:09:52
do you know all these who knows all of these in has used all of those
00:09:57
okay who is used at least one of these
00:10:01
okay that's that makes sense okay so i have a very simplified demo harm
00:10:07
it's i should be endpoint coal shovel text you pass a text like candles on
00:10:12
and then after shorty lay which is the first processing stage
00:10:17
you have not processing stage that shuffles the individual well out words
00:10:22
like yeah you can always lead to the the woodlands or i dunno part you can
00:10:27
still read it probably uh if you know what the region was so that's the simplified demo
00:10:34
let me just run it for you here to make sure everything works
00:10:43
okay that's listening to that and two seconds delay and then the
00:10:48
results are great you write again two seconds today probably differently shuffled yes
00:10:58
so let's try to solve the first challenge how to
00:11:02
link okay she wrote in process it's not have cheaper out
00:11:10
in this scenario looks like there's if we focus on
00:11:13
this part here we have a path shuffle text we
00:11:18
to get word or h. p. work we extract
00:11:21
parameter text and then we wanna create the shuffle text
00:11:27
and then we complete the request shall takes the future string
00:11:32
and this demo here at that stage we are already using
00:11:37
a oh i'm a flow or running stream um which is defined here
00:11:45
so we have a single requests method that starts with the source thing or
00:11:52
home of the text to be shuffled them we go via the flow which defined up there
00:12:01
and this flow has this day and it doesn't matter
00:12:05
a sink with forty two because that's the best number ever
00:12:09
and then it branches out to another fellow
00:12:12
sorry screen because it runs this other flow
00:12:16
is that the flow is called shuffle word in chapel bird is called with all the words
00:12:23
after splitting the initial text but blank oh okay and then we met back to to
00:12:31
proper outcome of this flow also the type process type is
00:12:35
flow up here from the command shuffle text to text chart
00:12:41
of course this is not what we want
00:12:45
in the a. p. i. because here re our
00:12:47
material arising on running this stream for every request
00:12:52
that doesn't fit into our design it you're in our design idea we wanna have a long a long
00:12:56
lasting long running flows was yeah it's because only those
00:13:01
can probably hook up into the corn it shut down
00:13:04
and also apply back pressure to all the back end
00:13:08
systems like uh i don't know um can is is so
00:13:13
or a eighteen q. p. or whatever is used in talking to external services
00:13:17
where we have people do weight limits and things like that so we cannot just
00:13:21
we run for every request flow because then all these things don't apply because or single is not really
00:13:29
something where you can apply rate limits and stuff right okay so this is just
00:13:34
for the demo to make it work so we need to find a better way and
00:13:40
in order to feed something in to a running screen we can
00:13:45
use a source q. store skew is a source which material arises
00:13:51
to something called source q. or even source q. with complete
00:13:55
but we can we can order with complete for this talk
00:13:59
and you have to pass the buffer size we just use
00:14:02
one here and an overflow strategy for the endpoints of our processes
00:14:09
clock news seems to be a good strategy because this gives us fail fast of our service
00:14:15
itself is overloaded if the process cannot accept any new requests
00:14:21
it it will drop the new request and that means that we can immediately tell
00:14:26
the client has you could find that the service unavailable five o. three
00:14:33
um the source q. has an offer method so
00:14:36
we can offer requests are elements into the running stream
00:14:43
that gives us a future of all for a cue offer result which
00:14:47
could be huge or dropped was somehow or other era which should not happen
00:14:55
now how do we get things out of the running stream not do that
00:15:00
we have to pass along a promise okay um if you look at that
00:15:05
this example share with a source q. which
00:15:10
takes request and the problem is for the response
00:15:15
and then after
00:15:17
running this process here or feeding sorry feeding goes to goes into that
00:15:21
process we um have a thing for each where we complete the promise
00:15:30
and this complete promise all that relate future can then be used to complete h. t. p. request as you see in a moment
00:15:37
what we also have to consider here is what that means for the process
00:15:42
our sauce q. is no require a it takes no other couples or pairs of requesting promise
00:15:49
well that means that our process needs to to read along a promise is that nice
00:15:57
if we think this is nice good yeah it's not nice at all and therefore
00:16:05
we use a new feature can flow with context which is essentially just a wrapper around
00:16:12
a flow of here a and context to objects and then
00:16:20
i'm offering all the methods you know like map and filter which
00:16:24
only work on the first elements of the context is transparently threaded along
00:16:31
so without process now the full context which takes request
00:16:35
and the promise of theirs for the response producing a response
00:16:39
and not changing the type of the context object which could be done
00:16:44
but we don't do it then we can call map and all these things only on the request
00:16:50
we could even then at some point when we needed to get back to
00:16:55
to pulse according as flow because then we have the request and the promise response
00:17:02
with these tools in place
00:17:05
let's try to make our example little better
00:17:12
okay so what has been prepared now is the following easy we're still in the a. p. i. e.
00:17:20
so in the a. p. high down there in the
00:17:24
route we change things but before we can change things
00:17:29
we need to set up a proper running
00:17:33
flow and we call that processor because the processor
00:17:39
is for running processes okay i hope you like the wording
00:17:45
so let's take a source talk you
00:17:50
and uh the type here should be from
00:17:54
shuffle the text sorry shuffle text to promise
00:18:01
no text shuffled size one in overflows credit g. drop it
00:18:09
good them be we go via our um um text
00:18:15
shove uh i thought process that is handed in as a parameter here
00:18:21
mm than we do our for each sorry go to sink dot for each
00:18:33
here we get out
00:18:36
the pairs again so we have our shuffle text and we
00:18:40
have the promise and we can try to complete the promise
00:18:46
successfully of course and then we just run that sorry we have a mature lies in scope so with this will run
00:18:55
which means here we get our source q. with complete a call
00:19:02
no this is running stream and we can feed requests into it and that's what we're going to do down there
00:19:09
you promise and for that purpose we're using an expiring promised because we wanna have a timeout right um
00:19:17
and expanding promises just the to the class just define sure
00:19:23
not too hard to understand you can take a look later if you wanna see more details
00:19:29
the promise which expires at the first time i've given here so we take our shuffle
00:19:36
no text shuffle or processor and we
00:19:42
offer the top all of this um
00:19:47
shuffle text command with the text that has been
00:19:51
extracted from the request and our promised tax shuffled
00:19:56
yeah okay cool so that we can offer and then we will get back future so we had
00:20:08
use flat map and look at whether this week rest and promise for the response topple could be included
00:20:18
if so we have our promise text shuffled
00:20:23
um
00:20:26
we can um get the future from the promise and we can call map to extract
00:20:33
the text which is should actually be the shuffled
00:20:37
string in other cases like crops we fail the future
00:20:48
with the process uh unavailable i'm just some name um process on
00:20:53
available is just a case class except from defined in this project
00:21:00
and case other which should not happen but we still need to take care
00:21:04
of that also failed with processor i wrote with the cost of the okay
00:21:13
so this is really all we need so we get sorry wrong the shuffle text here
00:21:19
is a few frustrating so that is what we get from feeding the request into this wrong street
00:21:27
we get it out again as a future string and that we can use to complete the request
00:21:33
cool let's see whether this works
00:21:37
uh_huh
00:21:45
okay listening one too yeah since work in nice
00:21:51
thing is if i now send a lot of requests
00:21:55
and you have seen us for put the buffer sizes to one and i have the delay and all that um
00:22:04
we get a couple of responses haven't started so he can see
00:22:11
five o. three so was unavailable five o. three so isn't available
00:22:15
he two hundred and two hundred four requests to could be in q. would the others
00:22:21
were dropped and rejected the fail fast fashion i think this is really nice
00:22:29
okay that was the first step um
00:22:33
but we have achieved now is that we can hand requests with local
00:22:39
um processors are we need to be able to branch
00:22:43
out into other processes and then branch out into remote processes
00:22:50
okay so how can we link to processes to running processes to squeeze
00:22:57
well there's physical merge cup
00:23:00
the merge that is a little bit like this show skew
00:23:07
because it allows you to connect into a running stream but it doesn't have this
00:23:14
overflow strategy thingy because you don't really offer it's really for linking two streams and therefore
00:23:21
the link screen will just back pressure the other one that's what we want
00:23:26
if we have screens that branch out into sub streams but just upstream spot
00:23:31
yeah branch out into other screens and then the result of this other streams
00:23:35
go back and we did what don't wanna drop anything on the back pressure right
00:23:40
dropping should only happen at the very end of the overall process so the marriage top
00:23:47
allows us to start with the sauce for some
00:23:49
elements we again have to use request and response topple
00:23:55
ah then we go via some process this again has
00:23:58
to be a flow with context to thread along the
00:24:02
um the promise which is no longer promised by the way it's already respond
00:24:06
d. sorry for that ah you could you could be a problem is locally
00:24:11
but if you wanna move on to the cluster where we wanna compose
00:24:17
all streams which run on there is no it's we can no longer use a promise you know why
00:24:25
yeah promises don't get civilised
00:24:29
we we knew that that was the tried
00:24:33
it took us more than five minutes to figure out what does not work station
00:24:40
that was me yeah funny thing so respond he's just an actor ref
00:24:45
which gets initialised with that promise and just actor f. can remotely decent around and
00:24:53
you can send a response message to the respond the actor the typed actor and
00:24:59
we received two spawns in time it would complete the promise else you fulfil the
00:25:04
promise so it's more or less every multiple promise you could say which is next
00:25:11
good um so therefore the whole thing looks very similar to
00:25:14
before but it's not a source cute it's the marriage happened here
00:25:19
in this thing for each we have to stand this
00:25:22
response message to the rest of the actor f. okay
00:25:27
but other than that emerge out is similar so we can hook into some
00:25:31
other strain um well and that's all good then let me show you that
00:25:39
oh
00:25:45
where do you wanna move here
00:25:50
okay a couple things i think prepare but they're still question marks in the code
00:25:55
so let's first take a look at is wow um tax stuff or and watch a flower again
00:26:02
um the workshop for now is
00:26:07
flow with context um with the respond the of what shuffled
00:26:13
um and in order to to run that process
00:26:19
we need to apply what i've just shown you so we go for the much dot dot so sorry
00:26:25
um do we need the types your i don't know that's showed up types
00:26:37
what's wrong solos yeah here we go okay well um there we go via our
00:26:44
process uh so we are in the works of uh okay then we go to
00:26:53
this sink got for v. h. t. is the new machine i'm having a hard time typing
00:27:01
as you can see 'em that we have the word shuffled and we have the the spongy
00:27:08
and we can say responded banning the rest on d. dot spawns what shuffle
00:27:16
um and then we finally can say i'm re just work great well i'm not this is all
00:27:24
we have to do is your handiwork shuffle or um this is still essentially the same process like
00:27:29
before just having the word very very simple process using this method here which is not important to
00:27:34
know this was the algorithm for something you little birds um let's go to the tax stuff or
00:27:42
um and maybe for you to better understand that let me go back to this
00:27:48
diagram here now that the tax software would be on this node right
00:27:54
um and at some point it would try to branch out into the virtue of uh
00:28:00
which might reside on a different note it will not reside there yet
00:28:04
but then the next that but it would still already be a box of it on
00:28:10
a red box running scream of its own okay so how do we get into that
00:28:17
into that um let's after ah i have
00:28:22
forgot to mention what we get back from
00:28:26
the merge cup when we um the material as it only called run method we
00:28:30
get back i think okay so the sink is to be used by other flows
00:28:38
at the sink arbitrary times and every time it gets the mature material i
00:28:43
still it can it can be mature as outer times and all these other
00:28:47
flows uh online streams of tomatoes nation can then send elements
00:28:52
into let's think which means they end up here and that's also and then the flow through this well linked
00:28:59
screen today for what we have is the think of shuffle
00:29:04
word spongy watch i thought okay that's what we have now
00:29:09
we need to respond to you right so here we have our supple word command uh_huh uh_huh
00:29:16
first we need to create respond be so that's a little hard
00:29:23
you knock typed um and therefore i'm i'm using an tied to your
00:29:29
so um that's first quite a promise with l. p.
00:29:33
equals harm it's we have this uh topple we need
00:29:40
something's wrong here
00:29:43
one too many
00:29:45
no um yeah this all the thank you who
00:29:54
has key and then recreate responding you so we go to the un type system
00:30:00
and type system taught spawn anonymous we can cause come up anonymous because
00:30:05
we have the coexistence conversions here on
00:30:10
the behaviour is or i'm responding e.
00:30:15
um and that takes this promise and the timeout the workshop for process timeout
00:30:21
okay now we have a shuffle board come and we have a promise and i'm type system we were trying all of that
00:30:28
for the time being you will see why so shuffle word
00:30:34
um or promise um the respond e.
00:30:38
which we should assign two of those
00:30:46
okay cool now we have that in order to feed the shuffle word in the
00:30:51
respond d. into this other thing which we have here we use the also to operation
00:31:00
also to now we need to apply some more gymnastic because we have this flow
00:31:06
um hum of a shuffle word sorry
00:31:11
it's a triple damp and a promise
00:31:20
promise of this couple
00:31:26
which type inference was better and finally we have or a spongy
00:31:32
okay cool then we map that because we don't need all of that so we have to shuffle word
00:31:40
sorry for the shuffle word the promise and respond the we met that to shovel word only investment
00:31:47
because that's what we need for the sink right the sink it takes of the word and the spongy
00:31:53
so we can feed that to our would shove a sink
00:31:59
no no okay i screwed something up
00:32:03
i've got the case thank you that should no longer be nicer in body has to screw something up
00:32:10
anyway i was so it's absolution in one second it's probably just some braces and i don't
00:32:14
know and then finally what we should get back eh i'm here we use map i sink
00:32:25
i'm forty two again cause and here we have our case
00:32:31
a shuffle work promise was spongy oh by the way we don't need to sorry
00:32:37
don't need this you're going to promise promise taught future that should be it okay
00:32:45
and i screwed things up so let me just scroll here
00:32:51
to simple solution with should more less look the same hopefully
00:32:55
um as good something up here anyway so as you can see here um those
00:33:03
the lines allow you to feed 'em stuff
00:33:08
into this remote double other screams all using the
00:33:12
well that's just the boilerplate to create responding okay um
00:33:17
we use also to to feed that stuff into that's inc
00:33:21
and then we have met a sink and of course this is all generic coder so
00:33:25
uh we have a a library which does all of that and gives you an into
00:33:31
method you just call into the sink and all is good i
00:33:36
um well thank you so let's run that and see whether it
00:33:41
really works so in the main method i haven't shown here here
00:33:45
uh the main uh a class we are actually a running
00:33:50
this text software um with this box office thinking about to sink
00:33:55
is really running the process so this is this is actually
00:33:58
this this think you get so with two running processes um okay
00:34:09
who still running very good now finally left on one out we wanna go to
00:34:15
two nodes we wanted to pull a some stuff on other nodes are and then connect
00:34:24
different process these so how come you stream across class the notice of ten minutes but that should
00:34:29
that should be fine in order to do that we have to use in
00:34:32
crafts they have been added quite recently to august frames and they allow all
00:34:37
oh to stream across the network um here's a nice diagram or
00:34:44
it has been here wait a moment wasted scream rests come on
00:34:50
it's gone oh here well it's not so yeah i don't know whether you can can see that but um
00:34:57
you can look it up in docket docks that's house these
00:35:00
stream graphs work in the case of a sink ref essentially um
00:35:07
what we do is we use the a. p. i. stream ref start
00:35:13
to sink ref which has a source we can then use in a stream
00:35:18
are so we uh go to our sink and then we ram that particular
00:35:24
our flow we have to find we get back i think ref and the same graph can then be used
00:35:31
to send it around across the cluster and the stink ref
00:35:36
gives you sink and that's saying can be material us and
00:35:40
then um all the elements flowing into that's ink on the
00:35:43
remote note and out here in the sink on this node
00:35:49
is quite awesome huh is taking into consideration a lot of the the the problems that might
00:35:54
occur on the network like sequencing and buffering
00:35:58
delay it for for for for the latency and
00:36:01
it's pretty awesome um i and uh this is what we need
00:36:06
we also need to kill switch what do we need to kill
00:36:08
switch well we need that to walk into the coordinated shut down
00:36:15
where we run those uh uh remote double the flows so
00:36:21
example we have seen if earlier for the of for the workshop or was the merge top we had
00:36:27
a a single cool switch here so we can then call the shot on that on the kill switch
00:36:34
do recorded shut down and that will you short that
00:36:37
um all the elements which are already here in the process
00:36:42
we'll well um the continued all the requests which have ended up
00:36:47
here happen except will be completed before the whole thing is for them
00:36:54
and finally we need to restart the sink because when we are
00:36:58
a in the cluster when we are in the network things might
00:37:03
go wrong so are saying we get ones
00:37:08
might no longer be alive so we need to restart that let me show you how this is working
00:37:21
okay so what we have in place here for the workshop or
00:37:26
we have convert that into an actor which is a protocol called get sinker f. it's a command you send it
00:37:32
you get back a sink ref cool so whenever it receives this message gets a graph
00:37:40
we do what i've shown you with screamer have started saying graph
00:37:45
i thought the uh or i think it's a lot to think
00:37:50
sink and then we run it and that gives us a future
00:37:56
well just think ref so we have to do
00:37:57
the on complete okay okay success values and sink ref
00:38:06
send it back to our reply to actor
00:38:12
else we just um
00:38:18
log
00:38:30
blah blah blah doesn't matter i'm going of time sorry the exact error messages not that important so that is how we
00:38:40
could thought reply with the same graph um and we
00:38:44
have to use that in the text software and um
00:38:50
that is shown here so if we have a reference to
00:38:54
the workshop for we ask it to get a sink ref
00:39:00
with an ass time ought and so on and we also one recover with
00:39:05
trying again because this could of course go wrong for example you have
00:39:09
a ah cluster or shouting across a single whatever we're using to deploy it
00:39:13
the works of what actor um decide to
00:39:19
redeploy that actor on some other node or
00:39:22
if it gets we start on the same note after fading whatever so we we cover um and then
00:39:28
we have a future of this thing graph great so the last person peas is the the the um
00:39:35
the restart think because um when something goes
00:39:39
wrong while the sink is at work so we
00:39:43
have like um you know we have got it here it's working with our uh nice um
00:39:50
process down here but then on quinn is decides to redeploy the part
00:39:56
on it will no longer work so we need to we start to sink
00:40:01
to continue our processes so here we use results sync with
00:40:04
back off home we have to apply some back all us um
00:40:10
and then we have to provide factory function for this thing
00:40:15
ah unfortunately the a. p. i. e. r. k. p. i.
00:40:18
wants us to uh create this thing here there's an issue i've created
00:40:26
that if you just think we also work it's not get there so we would workshop
00:40:31
fleur scene graph college here and the now wait just sometime so with that it should compile
00:40:39
of course what program so let me do all next and we have some proper or time
00:40:45
outs here um and the final demonstration will show
00:40:50
you how this is really running on multiple nodes
00:41:01
okay that's also arrange to the yeah uh_huh
00:41:04
starting again
00:41:10
uh_huh
00:41:12
okay the first note is up so this should already work let me see
00:41:18
okay cool mm the word shuffle or actor by the way
00:41:27
he's deployed using cluster singleton so i've started the first note first so the words have
00:41:34
a actor with its processes sitting there um
00:41:38
on this node okay um let's start second note
00:41:45
which will uh listen on a second interface
00:41:51
if i have added i don't know
00:42:04
okay it's listing there so just in time we go second note
00:42:11
and right that does the remote streaming so let me go back to this picture here
00:42:20
what we're seeing now is this is node one this is no two we have sent a request to
00:42:25
know too that was talking to whatever which is sitting on no one um and we can even stop that
00:42:34
uh which should make home
00:42:38
this whole things to to uh work because we have the backup sink which now we connects
00:42:44
uh tries to get the news think ref it gets it
00:42:48
because cluster a singleton has moved the actor to node number two
00:42:53
and everything is working again alright there was the demo
00:42:59
and uh yeah i'm just in time that's great um we
00:43:03
have put these feature into uh the lab records three me
00:43:08
which is kinda lacking behind we haven't yet really used
00:43:11
to float context they're probably so something's a little different are
00:43:16
but nevertheless it's out there we can take a look and a look at the comic history and see all the
00:43:21
various things we try it and uh sometimes failed and then improved um and
00:43:28
oh well thank you for your attention you can take a look at them a code and the slides they are available get up
00:43:36
and i wish you are really nice uh entertaining studies conference thank you
00:43:49
adam around for questions up i think we write had run of time but
00:43:54
find me a while to you have to be they really replace it what okay so like that to be here
00:44:06
yeah
00:44:09
i
00:44:23
um instead of using plants isn't all the styles that ah why not is that i feel
00:44:29
like x. itself doesn't just actually that's it's it's constant cal
00:44:33
yeah that it's false this little see action the other section
00:44:38
oh sorry i didn't understand that actually expenses that you feel the actual flow
00:44:44
well that that someone actually spots in the l. y. notes use that model
00:44:48
instead all on this is speech like i don't see it all the access
00:44:52
that you have to actually okay so i think if i understand the question
00:44:56
correctly you're suggesting we should use hawkeye his sheep he has a layer no
00:45:03
okay so maybe we should then discuss that later because yeah so the in
00:45:06
terms of this approach is to really have two main processes which are only
00:45:11
sending around the main uh elements domain messages knowledge theories stuff but yeah we can discuss that later
00:45:20
i know that question
Conference Program
A Tour of Scala 3
Martin Odersky, Professor EPFL, Co-founder Lightbend
June 11, 2019 · 5:15 p.m.
8333 views
A story of unification: from Apache Spark to MLflow
Reynold Xin, Databricks
June 12, 2019 · 9:15 a.m.
1267 views
In Types We Trust
Bill Venners, Artima, Inc
June 12, 2019 · 10:15 a.m.
1569 views
Creating Native iOS and Android Apps in Scala without tears
Zahari Dichev, Bullet.io
June 12, 2019 · 10:16 a.m.
2231 views
Techniques for Teaching Scala
Noel Welsh, Inner Product and Underscore
June 12, 2019 · 10:17 a.m.
1294 views
Future-proofing Scala: the TASTY intermediate representation
Guillaume Martres, student at EPFL
June 12, 2019 · 10:18 a.m.
1156 views
Metals: rich code editing for Scala in VS Code, Vim, Emacs and beyond
Ólafur Páll Geirsson, Scala Center
June 12, 2019 · 11:15 a.m.
4695 views
Akka Streams to the Extreme
Heiko Seeberger, independent consultant
June 12, 2019 · 11:16 a.m.
1552 views
Scala First: Lessons from 3 student generations
Bjorn Regnell, Lund Univ., Sweden.
June 12, 2019 · 11:17 a.m.
577 views
Cellular Automata: How to become an artist with a few lines
Maciej Gorywoda, Wire, Berlin
June 12, 2019 · 11:18 a.m.
386 views
Why Netflix ❤'s Scala for Machine Learning
Jeremy Smith & Aish, Netflix
June 12, 2019 · 12:15 p.m.
5025 views
Massively Parallel Distributed Scala Compilation... And You!
Stu Hood, Twitter
June 12, 2019 · 12:16 p.m.
958 views
Polymorphism in Scala
Petra Bierleutgeb
June 12, 2019 · 12:17 p.m.
1113 views
sbt core concepts
Eugene Yokota, Scala Team at Lightbend
June 12, 2019 · 12:18 p.m.
1655 views
Double your performance: Scala's missing optimizing compiler
Li Haoyi, author Ammonite, Mill, FastParse, uPickle, and many more.
June 12, 2019 · 2:30 p.m.
837 views
Making Our Future Better
Viktor Klang, Lightbend
June 12, 2019 · 2:31 p.m.
1682 views
Testing in the postapocalyptic future
Daniel Westheide, INNOQ
June 12, 2019 · 2:32 p.m.
498 views
Context Buddy: the tool that knows your code better than you
Krzysztof Romanowski, sphere.it conference
June 12, 2019 · 2:33 p.m.
393 views
The Shape(less) of Type Class Derivation in Scala 3
Miles Sabin, Underscore Consulting
June 12, 2019 · 3:30 p.m.
2321 views
Refactor all the things!
Daniela Sfregola, organizer of the London Scala User Group meetup
June 12, 2019 · 3:31 p.m.
514 views
Integrating Developer Experiences - Build Server Protocol
Justin Kaeser, IntelliJ Scala
June 12, 2019 · 3:32 p.m.
551 views
Managing an Akka Cluster on Kubernetes
Markus Jura, MOIA
June 12, 2019 · 3:33 p.m.
735 views
Serverless Scala - Functions as SuperDuperMicroServices
Josh Suereth, Donna Malayeri & James Ward, Author of Scala In Depth; Google ; Google
June 12, 2019 · 4:45 p.m.
936 views
How are we going to migrate to Scala 3.0, aka Dotty?
Lukas Rytz, Lightbend
June 12, 2019 · 4:46 p.m.
709 views
Concurrent programming in 2019: Akka, Monix or ZIO?
Adam Warski, co-founders of SoftwareMill
June 12, 2019 · 4:47 p.m.
1974 views
ScalaJS and Typescript: an unlikely romance
Jeremy Hughes, Lightbend
June 12, 2019 · 4:48 p.m.
1376 views
Pure Functional Database Programming‚ without JDBC
Rob Norris
June 12, 2019 · 5:45 p.m.
6374 views
Why you need to be reviewing open source code
Gris Cuevas Zambrano & Holden Karau, Google Cloud;
June 12, 2019 · 5:46 p.m.
484 views
Develop seamless web services with Mu
Oli Makhasoeva, 47 Degrees
June 12, 2019 · 5:47 p.m.
785 views
Implementing the Scala 2.13 collections
Stefan Zeiger, Lightbend
June 12, 2019 · 5:48 p.m.
810 views
Introduction to day 2
June 13, 2019 · 9:10 a.m.
250 views
Sustaining open source digital infrastructure
Bogdan Vasilescu, Assistant Professor at Carnegie Mellon University's School of Computer Science, USA
June 13, 2019 · 9:16 a.m.
374 views
Building a Better Scala Community
Kelley Robinson, Developer Evangelist at Twilio
June 13, 2019 · 10:15 a.m.
245 views
Run Scala Faster with GraalVM on any Platform
Vojin Jovanovic, Oracle
June 13, 2019 · 10:16 a.m.
1340 views
ScalaClean - full program static analysis at scale
Rory Graves
June 13, 2019 · 10:17 a.m.
463 views
Flare & Lantern: Accelerators for Spark and Deep Learning
Tiark Rompf, Assistant Professor at Purdue University
June 13, 2019 · 10:18 a.m.
380 views
Metaprogramming in Dotty
Nicolas Stucki, Ph.D. student at LAMP
June 13, 2019 · 11:15 a.m.
1250 views
Fast, Simple Concurrency with Scala Native
Richard Whaling, data engineer based in Chicago
June 13, 2019 · 11:16 a.m.
624 views
Pick your number type with Spire
Denis Rosset, postdoctoral researcher at Perimeter Institute
June 13, 2019 · 11:17 a.m.
245 views
Scala.js and WebAssembly, a tale of the dangers of the sea
Sébastien Doeraene, Executive director of the Scala Center
June 13, 2019 · 11:18 a.m.
661 views
Performance tuning Twitter services with Graal and ML
Chris Thalinger, Twitter
June 13, 2019 · 12:15 p.m.
2003 views
Supporting the Scala Ecosystem: Stories from the Line
Justin Pihony, Lightbend
June 13, 2019 · 12:16 p.m.
163 views
Compiling to preserve our privacy
Manohar Jonnalagedda and Jakob Odersky, Inpher
June 13, 2019 · 12:17 p.m.
301 views
Building Scala with Bazel
Natan Silnitsky, wix.com
June 13, 2019 · 12:18 p.m.
565 views
Diversity and Inclusion Panel: Bring the Thunder!
Panel
June 13, 2019 · 2:30 p.m.
244 views
Asynchronous streams in direct style with and without macros
Philipp Haller, KTH Royal Institute of Technology in Stockholm
June 13, 2019 · 3:45 p.m.
304 views
Interactive Computing with Jupyter and Almond
Sören Brunk, USU Software AG
June 13, 2019 · 3:46 p.m.
681 views
Scala best practices I wish someone'd told me about
Nicolas Rinaudo, CTO of Besedo
June 13, 2019 · 3:47 p.m.
2702 views
High performance Privacy By Design using Matryoshka & Spark
Wiem Zine El Abidine and Olivier Girardot, Scala Backend Developer at MOIA / co-founder of Lateral Thoughts
June 13, 2019 · 3:48 p.m.
753 views
Immutable Sequential Maps – Keeping order while hashed
Odd Möller
June 13, 2019 · 4:45 p.m.
276 views
All the fancy things flexible dependency management can do
Alexandre Archambault, engineer at the Scala Center
June 13, 2019 · 4:46 p.m.
389 views
ScalaWebTest - integration testing made easy
Dani Rey, Unic AG
June 13, 2019 · 4:47 p.m.
468 views
Mellite: An Integrated Development Environment for Sound
Hanns Holger Rutz, Institute of Electronic Music and Acoustics (IEM), Graz
June 13, 2019 · 4:48 p.m.
213 views
Closing panel
Panel
June 13, 2019 · 5:54 p.m.
400 views