WEBVTT

1
00:00:01.240 --> 00:00:04.870
So, we learned what AJAX and APIs are.

2
00:00:04.870 --> 00:00:07.993
We used a bunch of asynchronous code already

3
00:00:07.993 --> 00:00:11.150
and we learned all about promises.

4
00:00:11.150 --> 00:00:14.810
But what's missing is to finally understand how all

5
00:00:14.810 --> 00:00:18.278
of it really works behind the scenes of JavaScript.

6
00:00:18.278 --> 00:00:20.093
And so let's find out.

7
00:00:23.109 --> 00:00:26.090
And to start let's quickly review the JavaScript runtime

8
00:00:26.090 --> 00:00:29.380
that we talked about way back in the course,

9
00:00:29.380 --> 00:00:32.680
just to make sure that the rest of this lecture will make

10
00:00:32.680 --> 00:00:33.513
sense to you.

11
00:00:34.450 --> 00:00:38.810
So, a JavaScript runtime is basically a container

12
00:00:38.810 --> 00:00:41.200
which includes all the different pieces

13
00:00:41.200 --> 00:00:44.838
that are necessary to execute JavaScript code.

14
00:00:44.838 --> 00:00:49.838
Now, the heart of every JavaScript runtime is the engine.

15
00:00:50.230 --> 00:00:53.690
So, this is where code is actually executed

16
00:00:53.690 --> 00:00:57.070
and where objects are stored in memory.

17
00:00:57.070 --> 00:00:59.960
So, these two things happen in the call stack

18
00:00:59.960 --> 00:01:00.973
and in the heap.

19
00:01:01.820 --> 00:01:04.170
Now, what's important to note here is

20
00:01:04.170 --> 00:01:08.200
that JavaScript has only one threat of execution.

21
00:01:08.200 --> 00:01:11.560
And so it can only do one thing at a time.

22
00:01:11.560 --> 00:01:14.810
There is absolutely no multitasking happening

23
00:01:14.810 --> 00:01:17.170
in JavaScript itself.

24
00:01:17.170 --> 00:01:20.960
Now, other languages like Java can execute multiple pieces

25
00:01:20.960 --> 00:01:24.963
of code at the same time, but not JavaScript.

26
00:01:24.963 --> 00:01:29.963
But anyway, next we have the web APIs environment.

27
00:01:30.610 --> 00:01:34.050
These are some APIs provided to the engine,

28
00:01:34.050 --> 00:01:36.567
but which are actually not part of

29
00:01:36.567 --> 00:01:38.773
the JavaScript language itself.

30
00:01:40.510 --> 00:01:42.800
So, that's things like the DOM timers

31
00:01:42.800 --> 00:01:47.800
the fetch API, the geolocation API, and so on and so forth.

32
00:01:48.740 --> 00:01:51.630
Next up, there is the callback queue

33
00:01:51.630 --> 00:01:54.900
and this is a data structure that holds all the ready

34
00:01:54.900 --> 00:01:58.480
to be executed callback functions that are attached

35
00:01:58.480 --> 00:02:00.793
to some event that has occurred.

36
00:02:01.650 --> 00:02:04.800
Finally, whenever the call stack is empty

37
00:02:04.800 --> 00:02:08.220
the event loop takes callbacks from the callback queue

38
00:02:08.220 --> 00:02:12.710
and puts them into call stack so that they can be executed.

39
00:02:12.710 --> 00:02:14.900
So the event loop is the essential

40
00:02:14.900 --> 00:02:18.070
piece that makes asynchronous behavior possible

41
00:02:18.070 --> 00:02:19.660
in JavaScript.

42
00:02:19.660 --> 00:02:21.640
It's the reason why we can have a

43
00:02:21.640 --> 00:02:25.170
non blocking concurrency model in JavaScript.

44
00:02:25.170 --> 00:02:29.320
And a concurrency model is simply how a language handles

45
00:02:29.320 --> 00:02:32.840
multiple things happening at the same time.

46
00:02:32.840 --> 00:02:34.510
But now how does this

47
00:02:34.510 --> 00:02:37.860
non blocking concurrency actually work?

48
00:02:37.860 --> 00:02:41.370
And why is the event loop so important?

49
00:02:41.370 --> 00:02:43.053
Well, let's find out.

50
00:02:44.950 --> 00:02:49.460
And let's focus on the essential parts of the runtime here.

51
00:02:49.460 --> 00:02:53.650
So, that's the call stack the event loop the web APIs

52
00:02:53.650 --> 00:02:55.620
and to callback queue.

53
00:02:55.620 --> 00:02:59.650
So, as you know, by now, a JavaScript engine is built

54
00:02:59.650 --> 00:03:02.720
around the idea of a single threat.

55
00:03:02.720 --> 00:03:06.860
But if there was only one thread of execution in the engine

56
00:03:06.860 --> 00:03:09.890
then how can asynchronous code be executed

57
00:03:09.890 --> 00:03:11.960
in a non blocking way?

58
00:03:11.960 --> 00:03:14.490
Well, that's actually the big question

59
00:03:14.490 --> 00:03:16.483
that we're gonna answer in this video.

60
00:03:17.370 --> 00:03:19.240
So, essentially you will learn

61
00:03:19.240 --> 00:03:22.450
how the JavaScript concurrency model really works

62
00:03:22.450 --> 00:03:25.480
behind the scenes, using all the parts of the

63
00:03:25.480 --> 00:03:28.630
JavaScript runtime that you already know.

64
00:03:28.630 --> 00:03:31.170
And as always, we will do this by looking

65
00:03:31.170 --> 00:03:33.780
at a real code example.

66
00:03:33.780 --> 00:03:35.730
So, let's walk through the code line

67
00:03:35.730 --> 00:03:40.009
by line and I will keep updating the call stack as we go,

68
00:03:40.009 --> 00:03:43.720
however, you already know how to call stack works.

69
00:03:43.720 --> 00:03:46.030
And so it's best that you focus more

70
00:03:46.030 --> 00:03:50.258
on the code and on the web APIs and callback queue.

71
00:03:50.258 --> 00:03:55.150
Okay, but now let's start by selecting this image element.

72
00:03:55.150 --> 00:03:56.800
And then in the next line

73
00:03:56.800 --> 00:04:01.643
we set the source attribute of that image to dog.jpg.

74
00:04:02.540 --> 00:04:06.250
And as we learned before this will now start to load

75
00:04:06.250 --> 00:04:10.040
this image asynchronously in the background.

76
00:04:10.040 --> 00:04:12.520
But this time we can actually understand

77
00:04:12.520 --> 00:04:15.955
what that mysterious background actually is.

78
00:04:15.955 --> 00:04:20.084
So, as you already know everything related to the DOM

79
00:04:20.084 --> 00:04:25.084
is not really part of JavaScript, but of the web APIs.

80
00:04:25.890 --> 00:04:29.100
And so it's in a web APIs environment where

81
00:04:29.100 --> 00:04:33.600
the asynchronous tasks related to the DOM will run.

82
00:04:33.600 --> 00:04:38.200
And in fact, the same is true for timers AJAX calls

83
00:04:38.200 --> 00:04:41.630
and really all other asynchronous tasks.

84
00:04:41.630 --> 00:04:45.440
So, again, these asynchronous tasks will all run

85
00:04:45.440 --> 00:04:48.443
in the web API environment of the browser.

86
00:04:49.360 --> 00:04:53.170
Now, if the image would be loading in a synchronous way

87
00:04:53.170 --> 00:04:56.280
it would be doing so right in the call stack

88
00:04:56.280 --> 00:05:00.090
blocking the execution of the rest of the code.

89
00:05:00.090 --> 00:05:03.970
But, as we already learned, that would be terrible.

90
00:05:03.970 --> 00:05:08.640
And that's why loading images in JavaScript is asynchronous.

91
00:05:08.640 --> 00:05:11.560
So it does not happen in the call stack.

92
00:05:11.560 --> 00:05:14.900
So, not in the main thread of execution,

93
00:05:14.900 --> 00:05:17.600
but really in the web APIs environment

94
00:05:17.600 --> 00:05:18.903
as I mentioned before.

95
00:05:19.780 --> 00:05:22.700
Now, if we want to do something after the image

96
00:05:22.700 --> 00:05:24.230
has finished loading,

97
00:05:24.230 --> 00:05:27.150
then we need to listen to the load event.

98
00:05:27.150 --> 00:05:31.600
And so that's exactly what we do in the next line of code.

99
00:05:31.600 --> 00:05:33.780
So, here we attach an event listener

100
00:05:33.780 --> 00:05:36.520
to the load event of that image

101
00:05:36.520 --> 00:05:39.193
and pass an a callback function as always.

102
00:05:40.060 --> 00:05:43.610
In practice, this means to register this callback

103
00:05:43.610 --> 00:05:46.060
in the web APIs environment,

104
00:05:46.060 --> 00:05:48.970
exactly where the image is loading.

105
00:05:48.970 --> 00:05:51.000
And to callback will stay there

106
00:05:51.000 --> 00:05:53.456
until the load event is emitted.

107
00:05:53.456 --> 00:05:56.690
So, we're handling asynchronous behavior here

108
00:05:56.690 --> 00:05:59.831
with a callback just as we learned before,

109
00:05:59.831 --> 00:06:03.740
but anyway, let's go back to the code.

110
00:06:03.740 --> 00:06:07.284
And so, in the next line, we make an AJAX call using

111
00:06:07.284 --> 00:06:09.640
the fetch API.

112
00:06:09.640 --> 00:06:13.900
And as always the asynchronous fetch operation will happen

113
00:06:13.900 --> 00:06:16.470
in the web APIs environment.

114
00:06:16.470 --> 00:06:20.200
And again, that's because otherwise we would be blocking

115
00:06:20.200 --> 00:06:24.613
the call stack and create a huge lag in our application.

116
00:06:25.450 --> 00:06:29.160
Finally, we use the then method on the promise returned

117
00:06:29.160 --> 00:06:30.950
by the fetch function.

118
00:06:30.950 --> 00:06:33.520
And this will also register a callback

119
00:06:33.520 --> 00:06:37.410
in the web API environment so that we can react

120
00:06:37.410 --> 00:06:41.320
to the future resolved value of the promise.

121
00:06:41.320 --> 00:06:44.530
So this callback is associated with a promise

122
00:06:44.530 --> 00:06:47.350
that is fetching the data from the API.

123
00:06:47.350 --> 00:06:49.493
And that's gonna be important later on.

124
00:06:50.770 --> 00:06:53.920
So, with this, we have now executed all the

125
00:06:53.920 --> 00:06:55.500
top level of code.

126
00:06:55.500 --> 00:06:59.250
So, all the code that is not inside any callback function

127
00:06:59.250 --> 00:07:01.760
in asynchronous way.

128
00:07:01.760 --> 00:07:04.760
We also have the image loading in the background

129
00:07:04.760 --> 00:07:08.070
and some data being fetched from an API.

130
00:07:08.070 --> 00:07:11.965
And so now it's time for this to get really interesting.

131
00:07:11.965 --> 00:07:15.320
Let's say the image has finished loading

132
00:07:15.320 --> 00:07:19.890
and therefore the load event is emitted on that image.

133
00:07:19.890 --> 00:07:21.200
What happens next,

134
00:07:21.200 --> 00:07:24.310
is that the callback for this event is put

135
00:07:24.310 --> 00:07:25.513
into callback queue.

136
00:07:26.410 --> 00:07:29.870
And the callback queue is basically an ordered list

137
00:07:29.870 --> 00:07:32.010
of all the callback functions that are

138
00:07:32.010 --> 00:07:34.540
in line to be executed.

139
00:07:34.540 --> 00:07:37.360
And you can think of this callback queue,

140
00:07:37.360 --> 00:07:39.350
as a to do list that you would write

141
00:07:39.350 --> 00:07:43.540
for yourself with all the tasks that you have to complete.

142
00:07:43.540 --> 00:07:47.615
So, the callback queue is also a to do list of a kind,

143
00:07:47.615 --> 00:07:51.260
but with tasks that the call stack will eventually

144
00:07:51.260 --> 00:07:52.951
have to complete.

145
00:07:52.951 --> 00:07:56.160
Now, in this example, there are no other callbacks

146
00:07:56.160 --> 00:07:59.670
in the queue yet, but there could be of course.

147
00:07:59.670 --> 00:08:02.540
So, if there were already other callbacks waiting

148
00:08:02.540 --> 00:08:06.630
in line, then this new callback would of course go straight

149
00:08:06.630 --> 00:08:08.670
to the end of the queue.

150
00:08:08.670 --> 00:08:11.570
And there it would sit patiently for its turn

151
00:08:11.570 --> 00:08:12.763
to finally run.

152
00:08:13.620 --> 00:08:16.703
And this actually has big implications.

153
00:08:16.703 --> 00:08:21.480
So, imagine that you set a timer for five seconds.

154
00:08:21.480 --> 00:08:25.650
And so after five seconds that timer's callback will be put

155
00:08:25.650 --> 00:08:28.420
on the callback queue, right.

156
00:08:28.420 --> 00:08:31.960
And let's say there were already other callbacks awaiting.

157
00:08:31.960 --> 00:08:34.970
And let's also say that it took one second

158
00:08:34.970 --> 00:08:37.690
to run all of those callbacks.

159
00:08:37.690 --> 00:08:41.580
Then, in that case, your timers callback would only run

160
00:08:41.580 --> 00:08:45.390
after six seconds and not after five.

161
00:08:45.390 --> 00:08:49.130
So, these six seconds are the five seconds that passed

162
00:08:49.130 --> 00:08:52.830
for the timer, plus the one second that it took

163
00:08:52.830 --> 00:08:56.070
to run all the other callbacks that were already waiting

164
00:08:56.070 --> 00:08:59.300
in line in front of your timer.

165
00:08:59.300 --> 00:09:02.540
So, what this means is that the timers duration

166
00:09:02.540 --> 00:09:05.980
that you define is not a guarantee.

167
00:09:05.980 --> 00:09:08.810
The only guarantee is that the timers callback

168
00:09:08.810 --> 00:09:11.610
will not run before five seconds,

169
00:09:11.610 --> 00:09:15.957
but it might very well run after five seconds have passed.

170
00:09:15.957 --> 00:09:19.970
So, it all depends on the state of the callback queue.

171
00:09:19.970 --> 00:09:22.870
And also another queue that we're gonna learn about

172
00:09:22.870 --> 00:09:24.470
in a second.

173
00:09:24.470 --> 00:09:27.890
Now, another thing that's important to mention here

174
00:09:27.890 --> 00:09:31.560
is that the callback queue also contains callbacks coming

175
00:09:31.560 --> 00:09:36.560
from DOM events like clicks or key presses or whatever.

176
00:09:36.900 --> 00:09:40.400
Now, we learned before that DOM events are not really

177
00:09:40.400 --> 00:09:43.390
asynchronous behavior, but they still use the

178
00:09:43.390 --> 00:09:46.870
callback queue to run their attached callbacks.

179
00:09:46.870 --> 00:09:51.360
So, if a click happens on a button with addEventListener

180
00:09:51.360 --> 00:09:55.240
then what will happen is just like what I illustrated here

181
00:09:55.240 --> 00:09:58.116
with the asynchronous load event.

182
00:09:58.116 --> 00:10:02.130
But anyway now it's time to finally learn about

183
00:10:02.130 --> 00:10:03.860
the event loop.

184
00:10:03.860 --> 00:10:06.870
So, here is what the event loop does.

185
00:10:06.870 --> 00:10:10.170
It looks into the call stack and determines whether

186
00:10:10.170 --> 00:10:11.730
it's empty or not.

187
00:10:11.730 --> 00:10:15.000
Except of course for the global context,

188
00:10:15.000 --> 00:10:17.819
then if the stack is indeed empty

189
00:10:17.819 --> 00:10:22.600
which means that there's currently no code being executed

190
00:10:22.600 --> 00:10:26.610
then it will take the first callback from the callback queue

191
00:10:26.610 --> 00:10:30.690
and put it on the call stack two will be executed.

192
00:10:30.690 --> 00:10:33.510
And this is called an event loop tick.

193
00:10:33.510 --> 00:10:36.330
So each time the event loop takes a callback

194
00:10:36.330 --> 00:10:37.960
from the callback queue.

195
00:10:37.960 --> 00:10:41.480
We say that there was an event loop tick.

196
00:10:41.480 --> 00:10:44.340
So, as we can see here the event loop

197
00:10:44.340 --> 00:10:46.650
has the extremely important task

198
00:10:46.650 --> 00:10:49.900
of doing coordination between the call stack

199
00:10:49.900 --> 00:10:52.630
and to callbacks in the callback queue.

200
00:10:52.630 --> 00:10:56.120
So, the event loop is basically who decides exactly

201
00:10:56.120 --> 00:10:58.675
when each callback is executed.

202
00:10:58.675 --> 00:11:03.050
We can also say that the event loop does the orchestration

203
00:11:03.050 --> 00:11:05.773
of this entire JavaScript runtime.

204
00:11:05.773 --> 00:11:09.943
Another thing that becomes clear from this whole explanation

205
00:11:09.943 --> 00:11:14.000
is that the JavaScript language itself has actually

206
00:11:14.000 --> 00:11:16.340
no sense of time.

207
00:11:16.340 --> 00:11:19.440
That's because everything that is asynchronous

208
00:11:19.440 --> 00:11:21.860
does not happen in the engine.

209
00:11:21.860 --> 00:11:25.740
It's the runtime who manages all the asynchronous behavior.

210
00:11:25.740 --> 00:11:27.970
And it's the event loop who decides

211
00:11:27.970 --> 00:11:30.810
which code will be executed next.

212
00:11:30.810 --> 00:11:33.400
But the engine itself simply executes

213
00:11:33.400 --> 00:11:35.333
whatever code it has given.

214
00:11:38.740 --> 00:11:42.517
Okay, so, this is of course, a lot to take in.

215
00:11:42.517 --> 00:11:46.246
So let's try to recap what's happened here.

216
00:11:46.246 --> 00:11:49.690
So, the image started loading asynchronously

217
00:11:49.690 --> 00:11:51.920
in the web APIs environment

218
00:11:51.920 --> 00:11:54.570
and not in the call stack, right.

219
00:11:54.570 --> 00:11:57.990
We then used addEventListener to attach

220
00:11:57.990 --> 00:12:01.330
a callback function to the image load event.

221
00:12:01.330 --> 00:12:05.390
And this callback is basically or asynchronous code

222
00:12:05.390 --> 00:12:08.640
it's code that we deferred into the future

223
00:12:08.640 --> 00:12:11.760
because we only want to execute it once the image

224
00:12:11.760 --> 00:12:13.520
has loaded.

225
00:12:13.520 --> 00:12:17.740
And in the meantime, the rest of the code kept running.

226
00:12:17.740 --> 00:12:21.710
Now addEventListener did not put the callback directly

227
00:12:21.710 --> 00:12:23.460
in the callback queue.

228
00:12:23.460 --> 00:12:27.270
It simply registered the callback, which then kept waiting

229
00:12:27.270 --> 00:12:30.790
in the web APIs environment until the load event

230
00:12:30.790 --> 00:12:32.570
was fired off.

231
00:12:32.570 --> 00:12:35.843
Only then the environment put the call back into queue.

232
00:12:36.800 --> 00:12:40.060
Then while in the queue the callback kept waiting

233
00:12:40.060 --> 00:12:42.190
for the event loop to pick it up

234
00:12:42.190 --> 00:12:44.690
and put it on the call stack.

235
00:12:44.690 --> 00:12:48.730
And this happened as soon as the callback was first in line

236
00:12:48.730 --> 00:12:51.260
and the call stack was empty.

237
00:12:51.260 --> 00:12:52.768
And, that's it actually.

238
00:12:52.768 --> 00:12:57.400
So, all this happened so that the image did not have to load

239
00:12:57.400 --> 00:13:00.110
in the call stack, but in the background

240
00:13:00.110 --> 00:13:01.693
in a non blocking way.

241
00:13:02.760 --> 00:13:06.270
So, in a nutshell, the web APIs environment,

242
00:13:06.270 --> 00:13:07.510
the callback queue

243
00:13:07.510 --> 00:13:11.200
and the event loop, all together, make it possible

244
00:13:11.200 --> 00:13:15.850
that asynchronous code can be executed in a non blocking way

245
00:13:15.850 --> 00:13:19.663
even with only one thread of execution in the engine.

246
00:13:20.810 --> 00:13:24.820
Wow, that was already a lot to understand,

247
00:13:24.820 --> 00:13:26.910
but we're not done yet.

248
00:13:26.910 --> 00:13:29.360
Because we still have to fetch function

249
00:13:29.360 --> 00:13:33.420
getting data from the AJAX call in the background.

250
00:13:33.420 --> 00:13:36.850
And this is basically happening with a promise.

251
00:13:36.850 --> 00:13:41.390
Remember, now with promises things work in a slightly

252
00:13:41.390 --> 00:13:45.290
different way which is why I included this promise example

253
00:13:45.290 --> 00:13:46.750
as well.

254
00:13:46.750 --> 00:13:50.350
So, let's say that the data has now finally arrived.

255
00:13:50.350 --> 00:13:53.130
And so the fetch is done.

256
00:13:53.130 --> 00:13:55.725
Now, callbacks related to promises

257
00:13:55.725 --> 00:13:58.530
like this one that we registered with the

258
00:13:58.530 --> 00:14:00.400
promises then method.

259
00:14:00.400 --> 00:14:04.100
Do actually not go into the callback queue.

260
00:14:04.100 --> 00:14:07.960
So, again this callback did we still have here,

261
00:14:07.960 --> 00:14:11.990
which is coming from a promise will not be moved into the

262
00:14:11.990 --> 00:14:13.450
callback queue.

263
00:14:13.450 --> 00:14:17.330
Instead, callbacks of promises have a special queue

264
00:14:17.330 --> 00:14:21.913
for themselves, which is the so called microtasks queue.

265
00:14:23.030 --> 00:14:26.990
Now, what is special about the microtasks queue is

266
00:14:26.990 --> 00:14:31.140
that it basically has priority over the callback queue.

267
00:14:31.140 --> 00:14:33.940
So, at the end of an event loop tick,

268
00:14:33.940 --> 00:14:36.270
so after a callback has been taken

269
00:14:36.270 --> 00:14:39.760
from the callback queue, the event loop will check

270
00:14:39.760 --> 00:14:43.750
if there are any callbacks in the microtasks queue.

271
00:14:43.750 --> 00:14:46.890
And if there are, it will run all of them

272
00:14:46.890 --> 00:14:49.410
before it will run any more callbacks

273
00:14:49.410 --> 00:14:51.353
from the regular callback queue.

274
00:14:52.270 --> 00:14:54.670
And, by the way, we call these callbacks

275
00:14:54.670 --> 00:14:57.300
from promises microtasks.

276
00:14:57.300 --> 00:15:00.700
And therefore the name microtasks queue.

277
00:15:00.700 --> 00:15:03.480
And there are actually other microtasks

278
00:15:03.480 --> 00:15:05.959
but that's not relevant here.

279
00:15:05.959 --> 00:15:08.930
So going back to our example,

280
00:15:08.930 --> 00:15:12.650
currently, we actually do have a microtask sitting

281
00:15:12.650 --> 00:15:17.063
in a microtasks queue, the call stack is also empty.

282
00:15:17.063 --> 00:15:21.170
And therefore the event loop will now take this callback

283
00:15:21.170 --> 00:15:24.470
and put it in the call stack just like it does with

284
00:15:24.470 --> 00:15:27.350
callbacks from the callback queue.

285
00:15:27.350 --> 00:15:31.560
And it doesn't matter if the callback queue is empty or not.

286
00:15:31.560 --> 00:15:34.573
So, this would have worked the exact same way

287
00:15:34.573 --> 00:15:38.580
even if there were some callbacks in the callback queue.

288
00:15:38.580 --> 00:15:43.196
And again, that's because microtasks always have priority.

289
00:15:43.196 --> 00:15:47.380
In practice, this means that microtasks can basically

290
00:15:47.380 --> 00:15:51.960
cut in line before all other regular callbacks.

291
00:15:51.960 --> 00:15:55.640
Now, if one microtask adds a new microtask

292
00:15:55.640 --> 00:15:59.050
then that new microtask is also executed

293
00:15:59.050 --> 00:16:02.210
before any callbacks from the callback queue.

294
00:16:02.210 --> 00:16:05.220
And this means that the microtasks queue

295
00:16:05.220 --> 00:16:08.240
can essentially starve the callback queue.

296
00:16:08.240 --> 00:16:11.710
Because if we keep adding more and more microtasks,

297
00:16:11.710 --> 00:16:16.220
then callbacks in the callback queue can never execute.

298
00:16:16.220 --> 00:16:18.730
Now, this is usually never a problem

299
00:16:18.730 --> 00:16:23.050
but I just wanted to mention this possibility here anyways,

300
00:16:23.050 --> 00:16:26.570
who knows maybe this will be an interview question

301
00:16:26.570 --> 00:16:28.100
for you someday.

302
00:16:28.100 --> 00:16:31.113
And if so, you'd now know the answer.

303
00:16:32.040 --> 00:16:35.720
But anyway, as you can hopefully see the idea

304
00:16:35.720 --> 00:16:39.190
of running asynchronous code with regular callbacks

305
00:16:39.190 --> 00:16:44.060
and with microtasks coming from promises is very similar.

306
00:16:44.060 --> 00:16:47.710
The only difference is that they go into different queues

307
00:16:47.710 --> 00:16:51.430
and that the event loop gives microtasks priority

308
00:16:51.430 --> 00:16:53.273
over regular callbacks.

309
00:16:54.520 --> 00:16:57.890
All right, and thats finally it.

310
00:16:57.890 --> 00:17:00.000
that's all you need to know about how

311
00:17:00.000 --> 00:17:04.010
asynchronous JavaScript really works behind the scenes.

312
00:17:04.010 --> 00:17:06.760
And I'm sure that this knowledge is gonna be

313
00:17:06.760 --> 00:17:09.820
extremely helpful and valuable to you.

314
00:17:09.820 --> 00:17:12.740
Because you're gonna be way more confident writing

315
00:17:12.740 --> 00:17:14.186
asynchronous code now.

316
00:17:14.186 --> 00:17:18.420
And also you will ace any job interview question

317
00:17:18.420 --> 00:17:21.490
about asynchronous JavaScript.

318
00:17:21.490 --> 00:17:25.190
And actually so many JavaScript developers don't know

319
00:17:25.190 --> 00:17:26.870
anything about this.

320
00:17:26.870 --> 00:17:29.720
So, I'm sure that this knowledge will put you

321
00:17:29.720 --> 00:17:34.720
into the top 10% or even top 5% of JavaScript developers.

322
00:17:36.300 --> 00:17:40.650
And that's just amazing on itself, right.

323
00:17:40.650 --> 00:17:43.020
But anyway, let's no finish here

324
00:17:43.020 --> 00:17:45.890
and try out some of this stuff in practice,

325
00:17:45.890 --> 00:17:48.070
so that you see for yourself

326
00:17:48.070 --> 00:17:50.273
that I didn't just make this stuff up.

