Hey, hello.
Okay.
this guy who's like a must-be corpse and so on.
Okay, I'm about to prove that I have to ask you the questions.
But yeah, first of all, let's try to do the most of the issues.
Do you know the name of the ship?
Yes, it's how much we can get.
No, we can give this a round.
So do you know the name of the ship?
Lang there.
Going Merit.
I don't know yet.
So the thing is, I'll put this because this is a story about pirates.
It's very, it's a bit stupid, but very inspired story about pirates.
And the release of this is a check on the method about a dashing.
So let's start.
So you'll understand why I put this here.
What is this about action tonight?
It's actually already been very like about that.
You see, you know, already has a lot of arguments.
I don't know what I mean.
I think it's a bit difficult.
There is a link to that that we have checked.
But today we'll dive a bit more deeper.
We'll say a little bit further.
So before we start, we'll see.
The answer is questions about this.
What I do is ask a little bit more.
Why release?
I do a little bit more.
How are our existing panels, the panels?
All problems, our existing technologies.
This is based.
And the ability is, you know, because,
our example is, like, adding more now.
So, like, a little bit more.
So, why are we going to do this with systems?
There is, like, a nice amount about the accuracy of transparency.
The problem with this now is, this is just one thing.
And as soon as someone blows with this topic,
this action happens often with this story.
There is no more, I don't know, for clarity.
There is nothing.
This, in reality, this is yourself.
And you can, accidentally, or, like,
you intentionally terminate the story.
It could be your business competitor,
just during the nights during the service.
I don't know.
What's it called?
I'll try to do it faster now.
Yeah.
So, the only way to solve this problem is,
it turns out, in 22 notes, or, like, to add to notes,
the problem.
So, when one sees Eliminated,
you always have the second one, which is a several.
This is the fault tolerance.
And basically, you can see the main thing that
this, if you talk about this rule of practice,
that's how we came up with this idea of the fault tolerance
that came as a driving style.
Oh, okay, now we have at least two.
See some kind of currency, the problem is,
this is one server, like, one seed.
This is another seed.
How we will find this challenge.
It's like in a fork, you know, in the games,
there's a fork of war.
Someone will go and check.
And, okay, there's, like, two seeds actually.
I'm built in infrastructure for you.
And it will look like there is no borders between those notes.
It's just, I call this a little ocean,
which actually consists of different seeds.
And we're sailing on this, like, apartments between the seeds.
So, this is, once again.
So, this is how we end up with the theoretical systems.
So, if we have, actually, instrument for that,
this is called the suitable three.
It's actually a language special, which consists of,
it's different instruments to build the distributed system,
and distributed actors.
There's a link, what we mean by a different distributed system.
There's a mindset is to bring your own runtime,
means that you really breathe and build faster system for service
or, like, for cars, you can build a faster system.
And, this all be the same distributed actors,
a little, just, a different system.
Or, it's one of things.
And, actually, there's an example on this,
that, to say, really, for camera, actually.
And, and, and, and, and, and, and,
this example is the fact that fish game,
and it already have two people,
and this root system once is a very socket.
The other one is based on Bonjour.
I think that the framework from Apple.
But, this is a simple distributed system.
In reality, the distributed system is a complicated topic.
It's a hard to correct thing, yeah.
For example, how nodes are defined each other?
What happens, like, sees defined each other?
What happens when node dies?
How messages are transmitted?
How to behave when messages are failed, or,
to deliver, yeah.
There is actually a solution from the Apple.
See, this is the active parcel library,
which handles everything for you.
So, it uses the, for, like,
saved cluster membership based on,
as we scale it with the consistent,
infection-style membership for managing clusters.
And, it also includes the utilization mechanism and the transfer player.
And, let's, back, go back to this example.
We had, and let's just update the game with the,
the parcel with the latest parcel that Apple provides us.
But, before we start, let's figure out how to form a node.
It's actually very easy.
We define cluster system one, cluster system two nodes.
Then you define, you can just pound the active player.
And then you manually say, okay, cluster during this node.
But, this is a problem, because this node could be,
it's okay.
And one computer, but this node could be a completely different computer.
So, there is a solution with a server discovery,
and just say, okay, this is a server discovery.
You can use a double-s Kubernetes,
and it will be a part of it for you.
For debugging, we will use the,
the part of the game.
It's a simple node discovery process.
Still, you pull first, obviously, we can use it to learn
because the parcel system soon.
And that's it, actually.
So, we pulled two nodes.
And, yeah, the parcel system done.
Now, back to the game.
So, this is the game.
You enter the game.
You go to the matchmaking screen,
and then you play the,
that's it, that's it, that's it, that's it, that's it.
So, this screen is a new one.
We need to add the matchmaking.
If you can use a bit of which is a game lobby.
Writing the server to act with is not so different from writing an actor.
The only thing you have to keep in mind,
we need to provide a cluster system,
that's where the actor system used.
Which of these actors are to write on the,
the other thing you need to define the function
that communicate with other, which with each other's students.
And they are probable comparing to the regular actors.
Because in network, you can message to people,
to people, to people.
And now we just create a lobby.
But there's a problem again.
We created a problem.
We created an actor.
But this actor is some note.
And how we actually communicate with each other.
So, how we join this game lobby.
Yeah, how.
So, fortunately, there's a cluster single protocol.
And when you can use it,
and guarantee that there will be just one actor for all the systems.
It's very easy to use.
You just define a plug in,
it's actually a very nice plug in.
If you want to extend your cluster system functionality,
you just can do this with different plug-ins.
And it's very, you can write your own,
you'll see, I wrote some, you'll see,
sorry, I mean.
And then you just say, okay, the lobby,
you're like, you know, a single phone.
And then when interacting with a single phone,
you need to do this with a plug-in.
And that's it.
You will have a game lobby,
across all the cluster systems and other actors
who just asked, okay, I will join you.
And then, much making all, okay,
you know, friends.
So, what about game session screen?
It's actually pretty straightforward.
If you're wondering, just sort of the functions,
play a move, and then,
exactly if it's send a message.
The problem is,
let's think about the state as a lecture.
So, it's a late state.
There is a slight problem again,
so we'll over-find the state on base.
But as you see, the notes are actors could fail,
or like, again, complexity could come and kill your note.
But if you want to create an actor back,
what state it should be?
We want our mad rock back, this one.
One solution is to use their systemsy,
I mean, some database, external one.
And then, the problem with this solution
is that this becomes our single source of proof.
And this works for small systems,
but as soon as, for example, you imagine it has a big chat.
It will be like a lot of messages going back and there,
and people just increase your latency.
One solution for that is just, actually,
have memory in state, and then just save the updates
to the state new states to the persistency.
And when something like your island dies,
you just then create a state,
and then continue to go back.
Problem with this approach that every actor
to have their own state.
And it means that there's like,
this title of this state of home and whatever,
and yeah, it's not very scalable.
Can we somehow start this logic?
Answer is yes, we can send, okay,
event came, like, work out it.
Another event, the second event, work net.
And then when acted dies,
we just send this event back sequentially,
and then this actor, the state is a great group for it.
What good about the solution,
this could be possible,
to rescue a MongoDB,
we just abstract this event.
This is called event sourcing.
It's a design pattern in which state
is the root by storing the second solution.
Events, yeah.
And again, I've implemented a plugin system for that.
Plugging, not system for that,
which is what passed the event sourcing.
It's again very easy to use,
just to build a plugin and then,
some store, like, it could be positive for a MongoDB store.
In this example, it's the box store, it's a store in memory.
And then, you say, okay, game session,
you're in our event source.
The only thing you need to provide is the idea,
by which it could be persistent and the events,
which will be stored.
And then, how to handle events when they come back to the action.
Then, the last thing is when we change the state,
the first event, and then the time will run for a file.
Again, that's it.
So, we now have persistent sourcing actor.
How to handle clients.
So, this is, again, just create a sourcing actor.
It's just taking, in example, from WC.
And then, just update some stuff because you need to update it,
it's not directly comparable.
The problem with this approach that, how exactly,
the success system is designed for the service.
It's not designed to use with iOS apps or, like, web.
Solution could be, to have stateless clients.
And then, just send, and you'll see,
back messages about the state state on the back.
Again, the problem is that, if there's, like, a lot of requests,
like, this will function, you need to define every,
against solution is to use message streaming.
And there's, like, a web software, as guys,
to be presented to be streaming.
And that's what we will use.
So, yeah, this is a request.
And what nice about the issue to be streaming,
you can both send the body, which will, like,
a client sending the messages.
And then, in response, like, the receipt from the server.
So, you can send messages, streaming to websites.
And then, you just define the function,
and this is regular asking streams, like, we'll switch to one.
And the problem is, like, again, there's some problems.
But you can't share the action stream.
So, you can't store, like, you can't send the action stream to the actor.
There is a solution.
There can never be too few actors.
And it's, this solution is actually, almost always helpful
when you work with the actor, this rule of actors.
Because you rely on the, so, pass the system,
and abstracts all the messages for you.
And you just can rely on this, and abstract.
Again, I've already read all this logic,
there's a, will be two pines, like, two stream,
several streams, like, this will be back,
and then regular actor, five stream, and then you can just,
say, okay, this is network player,
and handling all this messages from the stream,
and then you define how to handle.
And the last issue, we need to solve today.
So, you then trade two requests for, like,
matchmaking and the session.
The problem is, like, how exactly, so,
how to take the exact same, this will act,
how to say, okay, I want this network player.
Because in the class of system, the actor identity,
it uses is actually used for the process system.
So, what it means, when there's different ideas
of the actors, which this will pass the assigns
on the initialization of the actors.
But in reality, we want some ideas that we know,
but this one happens with processes,
which I see what I don't know,
because when it will act all day,
it will just be created, it will assign a new ID for it.
This is specifically just for the distributed actors.
Again, what should we do?
One trick is to use class of single-ton under section part.
So, the reception part is a receptionist,
because a single-to-hotel actor needs to protect him,
in order to add us to know,
they are available to meet him out.
So, you say, okay, I'm checking,
and then there's, like, someone,
through the lifecycle version,
and then through the receptionist,
Chinese, watching, and termination
on checking all these actors.
And then everyone check things,
and you get,
when you want some actor,
you will check, okay,
is this actor?
No, this one?
Yes, and then you can't communicate.
There's a side problem.
There's, like, millions of actors on,
like, tens of, no,
it will go for each of these actors,
and they will take something,
it will take me with sometimes.
How can we solve this?
There is actually a pattern for that,
it's also, like,
consistent passion,
picking,
but what it does,
puts notes on the hatchery,
and then when you ask, okay,
where's my island,
it will create a hatch full,
and it says, okay,
here's your note,
where your island is.
What nice about this technique is also,
full-tolerant,
by its nature,
so when one will digest,
it will rehash everything,
and it will put all the new keys to the,
you note,
and then when you ask a tool to say,
okay, it's there,
so again,
I've wrapped everything,
and there's a plug-in for that now,
I have feelings,
let's go quicker,
but it's the end, actually.
So, again,
if you provide the past little actors plug-in,
that's it.
Then you say,
okay, in the full-tolerant,
you're a virtual,
virtual,
and then there,
you need to provide us the final spawn function,
because I'll explain later.
As you've seen on the hatch ring,
for example,
you need some notes on this hatch ring,
so we create additional notes,
and then we ask system,
okay, here we are,
the actor with this ID.
We think why it's called virtual,
so you always assume there's an actor,
even if it's that,
and then you say,
okay, give me,
either it will give you already created,
and actually we'll act all of just created,
but that's why,
that's why there is a spawn function.
I mean, that's it,
that's,
but really,
I don't have time for them,
but I will share,
next speaker,
with the update,
for example.
So, building reliable,
let's tell you the apps,
with the specific access,
let's check,
so we have pasta system,
and then you can scale it,
horizontally,
or vertically,
that matter actually,
so we,
vertically,
at more memory just,
that's why it's done by sweet.
For example,
at more notes,
if something dies,
you just,
virtual actors,
okay,
this is in your acting out.
So, all things are checked,
and it's just three of things,
game session,
single,
game lobby,
air sources,
network play,
virtual actors.
And that's the way,
how to build scalable,
and the real,
apps,
with the students' access,
and,
unfortunately,
there's still some work,
I have to wait a second,
I know,
so,
we need to do some stuff,
there are,
like,
finalize,
but there's, like,
a call first,
make it port,
then you make it beautiful,
from your obstacle,
created airline,
and we have to make it beautiful,
we need to finish,
and then there's,
like,
this pattern you've seen,
there's,
you have,
status points,
this status points,
could be anything,
it could be a situation
a Pokemon post,
and this is my dream,
I want to create a framework
that will extract,
all the logic for you,
and then you just,
a big,
send,
say,
this updates,
that's it,
That's it,
that's what it is.
That's what it is,
that's what it is.
that's what it is,
that's what it's,
that's what it is,
that's what it's,