WEBVTT

00:00.000 --> 00:21.240
Hey, hello.

00:21.240 --> 00:22.280
Okay.

00:22.280 --> 00:26.280
this guy who's like a must-be corpse and so on.

00:26.280 --> 00:30.280
Okay, I'm about to prove that I have to ask you the questions.

00:30.280 --> 00:36.280
But yeah, first of all, let's try to do the most of the issues.

00:36.280 --> 00:38.280
Do you know the name of the ship?

00:38.280 --> 00:40.280
Yes, it's how much we can get.

00:40.280 --> 00:42.280
No, we can give this a round.

00:42.280 --> 00:44.280
So do you know the name of the ship?

00:44.280 --> 00:46.280
Lang there.

00:46.280 --> 00:47.280
Going Merit.

00:47.280 --> 00:48.280
I don't know yet.

00:48.280 --> 00:59.280
So the thing is, I'll put this because this is a story about pirates.

00:59.280 --> 01:04.280
It's very, it's a bit stupid, but very inspired story about pirates.

01:04.280 --> 01:08.280
And the release of this is a check on the method about a dashing.

01:08.280 --> 01:12.280
So let's start.

01:12.280 --> 01:16.280
So you'll understand why I put this here.

01:16.280 --> 01:18.280
What is this about action tonight?

01:18.280 --> 01:20.280
It's actually already been very like about that.

01:20.280 --> 01:22.280
You see, you know, already has a lot of arguments.

01:22.280 --> 01:24.280
I don't know what I mean.

01:24.280 --> 01:26.280
I think it's a bit difficult.

01:28.280 --> 01:30.280
There is a link to that that we have checked.

01:30.280 --> 01:33.280
But today we'll dive a bit more deeper.

01:33.280 --> 01:35.280
We'll say a little bit further.

01:35.280 --> 01:38.280
So before we start, we'll see.

01:38.280 --> 01:40.280
The answer is questions about this.

01:40.280 --> 01:42.280
What I do is ask a little bit more.

01:42.280 --> 01:44.280
Why release?

01:44.280 --> 01:46.280
I do a little bit more.

01:46.280 --> 01:50.280
How are our existing panels, the panels?

01:50.280 --> 01:54.280
All problems, our existing technologies.

01:54.280 --> 01:56.280
This is based.

01:56.280 --> 01:58.280
And the ability is, you know, because,

01:58.280 --> 02:01.280
our example is, like, adding more now.

02:01.280 --> 02:03.280
So, like, a little bit more.

02:03.280 --> 02:09.280
So, why are we going to do this with systems?

02:10.280 --> 02:14.280
There is, like, a nice amount about the accuracy of transparency.

02:14.280 --> 02:19.280
The problem with this now is, this is just one thing.

02:19.280 --> 02:23.280
And as soon as someone blows with this topic,

02:23.280 --> 02:27.280
this action happens often with this story.

02:27.280 --> 02:33.280
There is no more, I don't know, for clarity.

02:33.280 --> 02:37.280
There is nothing.

02:37.280 --> 02:41.280
This, in reality, this is yourself.

02:41.280 --> 02:43.280
And you can, accidentally, or, like,

02:43.280 --> 02:46.280
you intentionally terminate the story.

02:46.280 --> 02:49.280
It could be your business competitor,

02:49.280 --> 02:53.280
just during the nights during the service.

02:53.280 --> 02:54.280
I don't know.

02:54.280 --> 02:59.280
What's it called?

03:00.280 --> 03:07.280
I'll try to do it faster now.

03:07.280 --> 03:11.280
I'll try to do it faster now.

03:11.280 --> 03:13.280
Yeah.

03:13.280 --> 03:17.280
So, the only way to solve this problem is,

03:17.280 --> 03:21.280
it turns out, in 22 notes, or, like, to add to notes,

03:21.280 --> 03:23.280
the problem.

03:23.280 --> 03:26.280
So, when one sees Eliminated,

03:26.280 --> 03:28.280
you always have the second one, which is a several.

03:28.280 --> 03:30.280
This is the fault tolerance.

03:30.280 --> 03:32.280
And basically, you can see the main thing that

03:32.280 --> 03:35.280
this, if you talk about this rule of practice,

03:35.280 --> 03:38.280
that's how we came up with this idea of the fault tolerance

03:38.280 --> 03:42.280
that came as a driving style.

03:42.280 --> 03:45.280
Oh, okay, now we have at least two.

03:45.280 --> 03:47.280
See some kind of currency, the problem is,

03:47.280 --> 03:49.280
this is one server, like, one seed.

03:49.280 --> 03:51.280
This is another seed.

03:51.280 --> 03:54.280
How we will find this challenge.

03:54.280 --> 03:56.280
It's like in a fork, you know, in the games,

03:56.280 --> 03:58.280
there's a fork of war.

03:58.280 --> 04:00.280
Someone will go and check.

04:00.280 --> 04:02.280
And, okay, there's, like, two seeds actually.

04:02.280 --> 04:04.280
I'm built in infrastructure for you.

04:04.280 --> 04:08.280
And it will look like there is no borders between those notes.

04:08.280 --> 04:11.280
It's just, I call this a little ocean,

04:11.280 --> 04:13.280
which actually consists of different seeds.

04:13.280 --> 04:19.280
And we're sailing on this, like, apartments between the seeds.

04:19.280 --> 04:25.280
So, this is, once again.

04:26.280 --> 04:30.280
So, this is how we end up with the theoretical systems.

04:30.280 --> 04:33.280
So, if we have, actually, instrument for that,

04:33.280 --> 04:35.280
this is called the suitable three.

04:35.280 --> 04:38.280
It's actually a language special, which consists of,

04:38.280 --> 04:41.280
it's different instruments to build the distributed system,

04:41.280 --> 04:43.280
and distributed actors.

04:43.280 --> 04:47.280
There's a link, what we mean by a different distributed system.

04:47.280 --> 04:50.280
There's a mindset is to bring your own runtime,

04:50.280 --> 04:55.280
means that you really breathe and build faster system for service

04:55.280 --> 04:58.280
or, like, for cars, you can build a faster system.

04:58.280 --> 05:00.280
And, this all be the same distributed actors,

05:00.280 --> 05:02.280
a little, just, a different system.

05:02.280 --> 05:04.280
Or, it's one of things.

05:04.280 --> 05:07.280
And, actually, there's an example on this,

05:07.280 --> 05:09.280
that, to say, really, for camera, actually.

05:09.280 --> 05:11.280
And, and, and, and, and, and, and,

05:11.280 --> 05:13.280
this example is the fact that fish game,

05:13.280 --> 05:15.280
and it already have two people,

05:15.280 --> 05:18.280
and this root system once is a very socket.

05:18.280 --> 05:20.280
The other one is based on Bonjour.

05:20.280 --> 05:23.280
I think that the framework from Apple.

05:23.280 --> 05:26.280
But, this is a simple distributed system.

05:26.280 --> 05:30.280
In reality, the distributed system is a complicated topic.

05:30.280 --> 05:32.280
It's a hard to correct thing, yeah.

05:32.280 --> 05:35.280
For example, how nodes are defined each other?

05:35.280 --> 05:37.280
What happens, like, sees defined each other?

05:37.280 --> 05:39.280
What happens when node dies?

05:39.280 --> 05:41.280
How messages are transmitted?

05:41.280 --> 05:44.280
How to behave when messages are failed, or,

05:44.280 --> 05:46.280
to deliver, yeah.

05:46.280 --> 05:48.280
There is actually a solution from the Apple.

05:48.280 --> 05:51.280
See, this is the active parcel library,

05:51.280 --> 05:55.280
which handles everything for you.

05:55.280 --> 05:58.280
So, it uses the, for, like,

05:58.280 --> 06:00.280
saved cluster membership based on,

06:00.280 --> 06:03.280
as we scale it with the consistent,

06:03.280 --> 06:06.280
infection-style membership for managing clusters.

06:06.280 --> 06:11.280
And, it also includes the utilization mechanism and the transfer player.

06:11.280 --> 06:15.280
And, let's, back, go back to this example.

06:15.280 --> 06:18.280
We had, and let's just update the game with the,

06:18.280 --> 06:22.280
the parcel with the latest parcel that Apple provides us.

06:22.280 --> 06:25.280
But, before we start, let's figure out how to form a node.

06:25.280 --> 06:27.280
It's actually very easy.

06:27.280 --> 06:30.280
We define cluster system one, cluster system two nodes.

06:30.280 --> 06:34.280
Then you define, you can just pound the active player.

06:34.280 --> 06:38.280
And then you manually say, okay, cluster during this node.

06:38.280 --> 06:42.280
But, this is a problem, because this node could be,

06:43.280 --> 06:44.280
it's okay.

06:44.280 --> 06:48.280
And one computer, but this node could be a completely different computer.

06:48.280 --> 06:51.280
So, there is a solution with a server discovery,

06:51.280 --> 06:54.280
and just say, okay, this is a server discovery.

06:54.280 --> 06:56.280
You can use a double-s Kubernetes,

06:56.280 --> 06:59.280
and it will be a part of it for you.

06:59.280 --> 07:02.280
For debugging, we will use the,

07:02.280 --> 07:04.280
the part of the game.

07:04.280 --> 07:08.280
It's a simple node discovery process.

07:09.280 --> 07:12.280
Still, you pull first, obviously, we can use it to learn

07:12.280 --> 07:14.280
because the parcel system soon.

07:14.280 --> 07:15.280
And that's it, actually.

07:15.280 --> 07:17.280
So, we pulled two nodes.

07:17.280 --> 07:21.280
And, yeah, the parcel system done.

07:21.280 --> 07:24.280
Now, back to the game.

07:24.280 --> 07:26.280
So, this is the game.

07:26.280 --> 07:27.280
You enter the game.

07:27.280 --> 07:31.280
You go to the matchmaking screen,

07:31.280 --> 07:33.280
and then you play the,

07:33.280 --> 07:36.280
that's it, that's it, that's it, that's it, that's it.

07:36.280 --> 07:41.280
So, this screen is a new one.

07:41.280 --> 07:43.280
We need to add the matchmaking.

07:43.280 --> 07:46.280
If you can use a bit of which is a game lobby.

07:46.280 --> 07:50.280
Writing the server to act with is not so different from writing an actor.

07:50.280 --> 07:52.280
The only thing you have to keep in mind,

07:52.280 --> 07:54.280
we need to provide a cluster system,

07:54.280 --> 07:56.280
that's where the actor system used.

07:56.280 --> 07:58.280
Which of these actors are to write on the,

07:58.280 --> 08:01.280
the other thing you need to define the function

08:01.280 --> 08:05.280
that communicate with other, which with each other's students.

08:05.280 --> 08:08.280
And they are probable comparing to the regular actors.

08:08.280 --> 08:11.280
Because in network, you can message to people,

08:11.280 --> 08:13.280
to people, to people.

08:13.280 --> 08:16.280
And now we just create a lobby.

08:16.280 --> 08:18.280
But there's a problem again.

08:18.280 --> 08:20.280
We created a problem.

08:20.280 --> 08:22.280
We created an actor.

08:22.280 --> 08:24.280
But this actor is some note.

08:24.280 --> 08:27.280
And how we actually communicate with each other.

08:27.280 --> 08:30.280
So, how we join this game lobby.

08:31.280 --> 08:33.280
Yeah, how.

08:33.280 --> 08:38.280
So, fortunately, there's a cluster single protocol.

08:38.280 --> 08:41.280
And when you can use it,

08:41.280 --> 08:46.280
and guarantee that there will be just one actor for all the systems.

08:46.280 --> 08:48.280
It's very easy to use.

08:48.280 --> 08:51.280
You just define a plug in,

08:51.280 --> 08:53.280
it's actually a very nice plug in.

08:53.280 --> 08:57.280
If you want to extend your cluster system functionality,

08:57.280 --> 09:00.280
you just can do this with different plug-ins.

09:00.280 --> 09:02.280
And it's very, you can write your own,

09:02.280 --> 09:05.280
you'll see, I wrote some, you'll see,

09:05.280 --> 09:07.280
sorry, I mean.

09:07.280 --> 09:09.280
And then you just say, okay, the lobby,

09:09.280 --> 09:11.280
you're like, you know, a single phone.

09:11.280 --> 09:14.280
And then when interacting with a single phone,

09:14.280 --> 09:16.280
you need to do this with a plug-in.

09:16.280 --> 09:17.280
And that's it.

09:17.280 --> 09:18.280
You will have a game lobby,

09:18.280 --> 09:24.280
across all the cluster systems and other actors

09:24.280 --> 09:27.280
who just asked, okay, I will join you.

09:27.280 --> 09:29.280
And then, much making all, okay,

09:29.280 --> 09:32.280
you know, friends.

09:32.280 --> 09:35.280
So, what about game session screen?

09:35.280 --> 09:37.280
It's actually pretty straightforward.

09:37.280 --> 09:38.280
If you're wondering, just sort of the functions,

09:38.280 --> 09:40.280
play a move, and then,

09:40.280 --> 09:43.280
exactly if it's send a message.

09:43.280 --> 09:48.280
The problem is,

09:48.280 --> 09:50.280
let's think about the state as a lecture.

09:50.280 --> 09:52.280
So, it's a late state.

09:53.280 --> 09:55.280
There is a slight problem again,

09:55.280 --> 09:58.280
so we'll over-find the state on base.

09:58.280 --> 10:01.280
But as you see, the notes are actors could fail,

10:01.280 --> 10:06.280
or like, again, complexity could come and kill your note.

10:06.280 --> 10:09.280
But if you want to create an actor back,

10:09.280 --> 10:11.280
what state it should be?

10:11.280 --> 10:15.280
We want our mad rock back, this one.

10:17.280 --> 10:19.280
One solution is to use their systemsy,

10:19.280 --> 10:22.280
I mean, some database, external one.

10:22.280 --> 10:24.280
And then, the problem with this solution

10:24.280 --> 10:28.280
is that this becomes our single source of proof.

10:28.280 --> 10:31.280
And this works for small systems,

10:31.280 --> 10:34.280
but as soon as, for example, you imagine it has a big chat.

10:34.280 --> 10:37.280
It will be like a lot of messages going back and there,

10:37.280 --> 10:42.280
and people just increase your latency.

10:42.280 --> 10:45.280
One solution for that is just, actually,

10:45.280 --> 10:50.280
have memory in state, and then just save the updates

10:50.280 --> 10:54.280
to the state new states to the persistency.

10:54.280 --> 10:58.280
And when something like your island dies,

10:58.280 --> 11:00.280
you just then create a state,

11:00.280 --> 11:02.280
and then continue to go back.

11:02.280 --> 11:05.280
Problem with this approach that every actor

11:05.280 --> 11:07.280
to have their own state.

11:07.280 --> 11:10.280
And it means that there's like,

11:10.280 --> 11:13.280
this title of this state of home and whatever,

11:13.280 --> 11:16.280
and yeah, it's not very scalable.

11:16.280 --> 11:18.280
Can we somehow start this logic?

11:18.280 --> 11:21.280
Answer is yes, we can send, okay,

11:21.280 --> 11:24.280
event came, like, work out it.

11:24.280 --> 11:27.280
Another event, the second event, work net.

11:27.280 --> 11:29.280
And then when acted dies,

11:29.280 --> 11:32.280
we just send this event back sequentially,

11:32.280 --> 11:37.280
and then this actor, the state is a great group for it.

11:37.280 --> 11:39.280
What good about the solution,

11:39.280 --> 11:40.280
this could be possible,

11:40.280 --> 11:42.280
to rescue a MongoDB,

11:42.280 --> 11:44.280
we just abstract this event.

11:44.280 --> 11:46.280
This is called event sourcing.

11:46.280 --> 11:49.280
It's a design pattern in which state

11:49.280 --> 11:52.280
is the root by storing the second solution.

11:52.280 --> 11:56.280
Events, yeah.

11:56.280 --> 12:00.280
And again, I've implemented a plugin system for that.

12:00.280 --> 12:03.280
Plugging, not system for that,

12:03.280 --> 12:06.280
which is what passed the event sourcing.

12:06.280 --> 12:08.280
It's again very easy to use,

12:08.280 --> 12:10.280
just to build a plugin and then,

12:10.280 --> 12:14.280
some store, like, it could be positive for a MongoDB store.

12:14.280 --> 12:17.280
In this example, it's the box store, it's a store in memory.

12:17.280 --> 12:19.280
And then, you say, okay, game session,

12:19.280 --> 12:20.280
you're in our event source.

12:20.280 --> 12:23.280
The only thing you need to provide is the idea,

12:23.280 --> 12:27.280
by which it could be persistent and the events,

12:27.280 --> 12:29.280
which will be stored.

12:29.280 --> 12:34.280
And then, how to handle events when they come back to the action.

12:34.280 --> 12:38.280
Then, the last thing is when we change the state,

12:38.280 --> 12:43.280
the first event, and then the time will run for a file.

12:43.280 --> 12:44.280
Again, that's it.

12:44.280 --> 12:49.280
So, we now have persistent sourcing actor.

12:49.280 --> 12:53.280
How to handle clients.

12:53.280 --> 12:58.280
So, this is, again, just create a sourcing actor.

12:58.280 --> 13:03.280
It's just taking, in example, from WC.

13:03.280 --> 13:07.280
And then, just update some stuff because you need to update it,

13:07.280 --> 13:11.280
it's not directly comparable.

13:11.280 --> 13:15.280
The problem with this approach that, how exactly,

13:15.280 --> 13:20.280
the success system is designed for the service.

13:20.280 --> 13:25.280
It's not designed to use with iOS apps or, like, web.

13:26.280 --> 13:30.280
Solution could be, to have stateless clients.

13:30.280 --> 13:33.280
And then, just send, and you'll see,

13:33.280 --> 13:36.280
back messages about the state state on the back.

13:36.280 --> 13:40.280
Again, the problem is that, if there's, like, a lot of requests,

13:40.280 --> 13:43.280
like, this will function, you need to define every,

13:43.280 --> 13:46.280
against solution is to use message streaming.

13:46.280 --> 13:49.280
And there's, like, a web software, as guys,

13:49.280 --> 13:51.280
to be presented to be streaming.

13:51.280 --> 13:54.280
And that's what we will use.

13:54.280 --> 13:57.280
So, yeah, this is a request.

13:57.280 --> 14:00.280
And what nice about the issue to be streaming,

14:00.280 --> 14:03.280
you can both send the body, which will, like,

14:03.280 --> 14:05.280
a client sending the messages.

14:05.280 --> 14:09.280
And then, in response, like, the receipt from the server.

14:09.280 --> 14:12.280
So, you can send messages, streaming to websites.

14:12.280 --> 14:15.280
And then, you just define the function,

14:15.280 --> 14:19.280
and this is regular asking streams, like, we'll switch to one.

14:20.280 --> 14:23.280
And the problem is, like, again, there's some problems.

14:23.280 --> 14:26.280
But you can't share the action stream.

14:26.280 --> 14:31.280
So, you can't store, like, you can't send the action stream to the actor.

14:31.280 --> 14:33.280
There is a solution.

14:33.280 --> 14:35.280
There can never be too few actors.

14:35.280 --> 14:38.280
And it's, this solution is actually, almost always helpful

14:38.280 --> 14:41.280
when you work with the actor, this rule of actors.

14:41.280 --> 14:44.280
Because you rely on the, so, pass the system,

14:44.280 --> 14:47.280
and abstracts all the messages for you.

14:47.280 --> 14:51.280
And you just can rely on this, and abstract.

14:51.280 --> 14:55.280
Again, I've already read all this logic,

14:55.280 --> 14:59.280
there's a, will be two pines, like, two stream,

14:59.280 --> 15:01.280
several streams, like, this will be back,

15:01.280 --> 15:04.280
and then regular actor, five stream, and then you can just,

15:04.280 --> 15:06.280
say, okay, this is network player,

15:06.280 --> 15:08.280
and handling all this messages from the stream,

15:08.280 --> 15:11.280
and then you define how to handle.

15:11.280 --> 15:14.280
And the last issue, we need to solve today.

15:15.280 --> 15:18.280
So, you then trade two requests for, like,

15:18.280 --> 15:21.280
matchmaking and the session.

15:21.280 --> 15:25.280
The problem is, like, how exactly, so,

15:25.280 --> 15:28.280
how to take the exact same, this will act,

15:28.280 --> 15:31.280
how to say, okay, I want this network player.

15:31.280 --> 15:35.280
Because in the class of system, the actor identity,

15:35.280 --> 15:39.280
it uses is actually used for the process system.

15:39.280 --> 15:43.280
So, what it means, when there's different ideas

15:44.280 --> 15:48.280
of the actors, which this will pass the assigns

15:48.280 --> 15:52.280
on the initialization of the actors.

15:52.280 --> 15:57.280
But in reality, we want some ideas that we know,

15:57.280 --> 16:01.280
but this one happens with processes,

16:01.280 --> 16:03.280
which I see what I don't know,

16:03.280 --> 16:06.280
because when it will act all day,

16:06.280 --> 16:09.280
it will just be created, it will assign a new ID for it.

16:09.280 --> 16:12.280
This is specifically just for the distributed actors.

16:13.280 --> 16:16.280
Again, what should we do?

16:16.280 --> 16:20.280
One trick is to use class of single-ton under section part.

16:20.280 --> 16:23.280
So, the reception part is a receptionist,

16:23.280 --> 16:27.280
because a single-to-hotel actor needs to protect him,

16:27.280 --> 16:29.280
in order to add us to know,

16:29.280 --> 16:32.280
they are available to meet him out.

16:32.280 --> 16:34.280
So, you say, okay, I'm checking,

16:34.280 --> 16:36.280
and then there's, like, someone,

16:36.280 --> 16:37.280
through the lifecycle version,

16:37.280 --> 16:39.280
and then through the receptionist,

16:39.280 --> 16:41.280
Chinese, watching, and termination

16:41.280 --> 16:43.280
on checking all these actors.

16:43.280 --> 16:45.280
And then everyone check things,

16:45.280 --> 16:48.280
and you get,

16:48.280 --> 16:51.280
when you want some actor,

16:51.280 --> 16:52.280
you will check, okay,

16:52.280 --> 16:53.280
is this actor?

16:53.280 --> 16:54.280
No, this one?

16:54.280 --> 16:56.280
Yes, and then you can't communicate.

16:56.280 --> 16:58.280
There's a side problem.

16:58.280 --> 17:00.280
There's, like, millions of actors on,

17:00.280 --> 17:02.280
like, tens of, no,

17:02.280 --> 17:04.280
it will go for each of these actors,

17:04.280 --> 17:05.280
and they will take something,

17:05.280 --> 17:07.280
it will take me with sometimes.

17:08.280 --> 17:09.280
How can we solve this?

17:09.280 --> 17:11.280
There is actually a pattern for that,

17:11.280 --> 17:12.280
it's also, like,

17:12.280 --> 17:13.280
consistent passion,

17:13.280 --> 17:14.280
picking,

17:14.280 --> 17:16.280
but what it does,

17:16.280 --> 17:19.280
puts notes on the hatchery,

17:19.280 --> 17:20.280
and then when you ask, okay,

17:20.280 --> 17:22.280
where's my island,

17:22.280 --> 17:23.280
it will create a hatch full,

17:23.280 --> 17:24.280
and it says, okay,

17:24.280 --> 17:26.280
here's your note,

17:26.280 --> 17:28.280
where your island is.

17:28.280 --> 17:30.280
What nice about this technique is also,

17:30.280 --> 17:31.280
full-tolerant,

17:31.280 --> 17:33.280
by its nature,

17:33.280 --> 17:35.280
so when one will digest,

17:35.280 --> 17:37.280
it will rehash everything,

17:37.280 --> 17:41.280
and it will put all the new keys to the,

17:41.280 --> 17:42.280
you note,

17:42.280 --> 17:44.280
and then when you ask a tool to say,

17:44.280 --> 17:45.280
okay, it's there,

17:45.280 --> 17:46.280
so again,

17:46.280 --> 17:47.280
I've wrapped everything,

17:47.280 --> 17:49.280
and there's a plug-in for that now,

17:49.280 --> 17:50.280
I have feelings,

17:50.280 --> 17:52.280
let's go quicker,

17:52.280 --> 17:53.280
but it's the end, actually.

17:53.280 --> 17:55.280
So, again,

17:55.280 --> 17:58.280
if you provide the past little actors plug-in,

17:58.280 --> 17:59.280
that's it.

17:59.280 --> 18:00.280
Then you say,

18:00.280 --> 18:01.280
okay, in the full-tolerant,

18:01.280 --> 18:02.280
you're a virtual,

18:02.280 --> 18:03.280
virtual,

18:04.280 --> 18:06.280
and then there,

18:06.280 --> 18:09.280
you need to provide us the final spawn function,

18:09.280 --> 18:12.280
because I'll explain later.

18:12.280 --> 18:16.280
As you've seen on the hatch ring,

18:16.280 --> 18:17.280
for example,

18:17.280 --> 18:19.280
you need some notes on this hatch ring,

18:19.280 --> 18:22.280
so we create additional notes,

18:22.280 --> 18:24.280
and then we ask system,

18:24.280 --> 18:26.280
okay, here we are,

18:26.280 --> 18:29.280
the actor with this ID.

18:29.280 --> 18:31.280
We think why it's called virtual,

18:31.280 --> 18:33.280
so you always assume there's an actor,

18:33.280 --> 18:34.280
even if it's that,

18:34.280 --> 18:35.280
and then you say,

18:35.280 --> 18:36.280
okay, give me,

18:36.280 --> 18:38.280
either it will give you already created,

18:38.280 --> 18:40.280
and actually we'll act all of just created,

18:40.280 --> 18:41.280
but that's why,

18:41.280 --> 18:43.280
that's why there is a spawn function.

18:43.280 --> 18:44.280
I mean, that's it,

18:44.280 --> 18:45.280
that's,

18:45.280 --> 18:46.280
but really,

18:46.280 --> 18:49.280
I don't have time for them,

18:49.280 --> 18:51.280
but I will share,

18:51.280 --> 18:52.280
next speaker,

18:52.280 --> 18:53.280
with the update,

18:53.280 --> 18:54.280
for example.

18:54.280 --> 18:55.280
So, building reliable,

18:55.280 --> 18:56.280
let's tell you the apps,

18:56.280 --> 18:57.280
with the specific access,

18:57.280 --> 18:58.280
let's check,

18:58.280 --> 19:00.280
so we have pasta system,

19:01.280 --> 19:03.280
and then you can scale it,

19:04.280 --> 19:05.280
horizontally,

19:05.280 --> 19:06.280
or vertically,

19:06.280 --> 19:07.280
that matter actually,

19:07.280 --> 19:08.280
so we,

19:08.280 --> 19:09.280
vertically,

19:09.280 --> 19:10.280
at more memory just,

19:10.280 --> 19:11.280
that's why it's done by sweet.

19:11.280 --> 19:12.280
For example,

19:12.280 --> 19:13.280
at more notes,

19:13.280 --> 19:14.280
if something dies,

19:14.280 --> 19:15.280
you just,

19:15.280 --> 19:16.280
virtual actors,

19:16.280 --> 19:17.280
okay,

19:17.280 --> 19:18.280
this is in your acting out.

19:18.280 --> 19:20.280
So, all things are checked,

19:20.280 --> 19:22.280
and it's just three of things,

19:22.280 --> 19:23.280
game session,

19:23.280 --> 19:24.280
single,

19:24.280 --> 19:25.280
game lobby,

19:25.280 --> 19:26.280
air sources,

19:26.280 --> 19:27.280
network play,

19:27.280 --> 19:28.280
virtual actors.

19:29.280 --> 19:30.280
And that's the way,

19:30.280 --> 19:31.280
how to build scalable,

19:31.280 --> 19:32.280
and the real,

19:32.280 --> 19:33.280
apps,

19:33.280 --> 19:34.280
with the students' access,

19:34.280 --> 19:35.280
and,

19:35.280 --> 19:36.280
unfortunately,

19:36.280 --> 19:37.280
there's still some work,

19:37.280 --> 19:38.280
I have to wait a second,

19:38.280 --> 19:39.280
I know,

19:39.280 --> 19:40.280
so,

19:40.280 --> 19:41.280
we need to do some stuff,

19:41.280 --> 19:42.280
there are,

19:42.280 --> 19:43.280
like,

19:43.280 --> 19:44.280
finalize,

19:44.280 --> 19:45.280
but there's, like,

19:45.280 --> 19:46.280
a call first,

19:46.280 --> 19:47.280
make it port,

19:47.280 --> 19:48.280
then you make it beautiful,

19:48.280 --> 19:49.280
from your obstacle,

19:49.280 --> 19:50.280
created airline,

19:50.280 --> 19:51.280
and we have to make it beautiful,

19:51.280 --> 19:52.280
we need to finish,

19:52.280 --> 19:53.280
and then there's,

19:53.280 --> 19:54.280
like,

19:54.280 --> 19:55.280
this pattern you've seen,

19:55.280 --> 19:56.280
there's,

19:56.280 --> 19:57.280
you have,

19:57.280 --> 19:58.280
status points,

19:58.280 --> 19:59.280
this status points,

19:59.280 --> 20:00.280
could be anything,

20:00.280 --> 20:01.280
it could be a situation

20:01.280 --> 20:02.280
a Pokemon post,

20:02.280 --> 20:03.280
and this is my dream,

20:03.280 --> 20:05.280
I want to create a framework

20:05.280 --> 20:06.280
that will extract,

20:06.280 --> 20:07.280
all the logic for you,

20:07.280 --> 20:08.280
and then you just,

20:08.280 --> 20:09.280
a big,

20:09.280 --> 20:10.280
send,

20:10.280 --> 20:11.280
say,

20:11.280 --> 20:12.280
this updates,

20:12.280 --> 20:13.280
that's it,

20:13.280 --> 20:14.280
that's it,

20:14.280 --> 20:15.280
that's it,

20:15.280 --> 20:16.280
that's it,

20:16.280 --> 20:17.280
that's it,

20:17.280 --> 20:18.280
that's it,

20:18.280 --> 20:19.280
that's it,

20:19.280 --> 20:20.280
that's it,

20:20.280 --> 20:21.280
that's it,

20:21.280 --> 20:22.280
that's it,

20:22.280 --> 20:24.280
that's it,

20:24.280 --> 20:25.280
that's it,

20:25.280 --> 20:26.280
that's it,

20:27.280 --> 20:27.780
that's it,

20:27.780 --> 20:28.780
that's it,

20:28.780 --> 20:30.120
that's it,

20:30.120 --> 20:30.780
that's it,

20:30.780 --> 20:31.280
that's it,

20:31.280 --> 20:31.780
that's it,

20:31.780 --> 20:32.280
That's it,

20:32.280 --> 20:33.280
that's what it is.

20:33.280 --> 20:33.780
That's what it is,

20:33.780 --> 20:34.780
that's what it is.

20:34.780 --> 20:35.780
that's what it is,

20:35.780 --> 20:36.280
that's what it's,

20:36.280 --> 20:37.220
that's what it's,

20:37.220 --> 20:38.280
that's what it is,

20:38.280 --> 20:39.260
that's what it is,

20:39.260 --> 20:40.260
that's what it's,

20:40.260 --> 20:41.280
that's what it's,

20:41.280 --> 20:42.260
that's what it's,

20:42.280 --> 20:43.280
that's what it's,

20:43.280 --> 20:44.300
that's what it's,

20:44.300 --> 20:45.300
that's what it's,

20:45.300 --> 20:47.300
that's what it's,

20:47.300 --> 20:48.280
that's what it's,

20:48.280 --> 20:49.300
that's what it's,

20:49.300 --> 20:50.300
that's what it's,

20:50.300 --> 20:51.280
that's what it's,

20:51.280 --> 20:52.300
that's what it's,

20:52.300 --> 20:53.300
that's what it's,

20:53.300 --> 20:54.300
that's what it's,