WEBVTT

1
00:00:01.200 --> 00:00:05.190
<v Jonas>So in the last lecture, we did a simple AJAX call</v>

2
00:00:05.190 --> 00:00:08.450
to fetch data from a country's API.

3
00:00:08.450 --> 00:00:10.810
So we created a function for that.

4
00:00:10.810 --> 00:00:13.570
And as we call the function multiple times,

5
00:00:13.570 --> 00:00:17.660
multiple AJAX calls were made at the same time.

6
00:00:17.660 --> 00:00:20.420
So they were basically running in parallel.

7
00:00:20.420 --> 00:00:23.680
And we could not control which one finished first,

8
00:00:23.680 --> 00:00:25.250
remember that?

9
00:00:25.250 --> 00:00:27.170
However, in this lecture,

10
00:00:27.170 --> 00:00:30.310
let's create a sequence of AJAX calls,

11
00:00:30.310 --> 00:00:31.650
so that the second one

12
00:00:31.650 --> 00:00:34.623
runs only after the first one has finished.

13
00:00:36.410 --> 00:00:38.440
And here's what we're gonna do.

14
00:00:38.440 --> 00:00:41.140
So in the countries data here,

15
00:00:41.140 --> 00:00:45.850
there is some property of the bordering countries.

16
00:00:45.850 --> 00:00:49.380
So you see, this one here has the code ESP,

17
00:00:49.380 --> 00:00:51.330
which stands for Spain.

18
00:00:51.330 --> 00:00:52.860
And so that's because Spain

19
00:00:52.860 --> 00:00:55.920
is a bordering country of Portugal.

20
00:00:55.920 --> 00:00:57.480
And so what we will do now

21
00:00:57.480 --> 00:01:00.590
is after the first AJAX call is completed,

22
00:01:00.590 --> 00:01:02.460
we will get this border.

23
00:01:02.460 --> 00:01:03.890
And then based on this code,

24
00:01:03.890 --> 00:01:06.710
we will also render the neighboring country

25
00:01:06.710 --> 00:01:09.950
right here besides the original country.

26
00:01:09.950 --> 00:01:11.230
And so in this case,

27
00:01:11.230 --> 00:01:15.370
the second AJAX call really depends on the first one,

28
00:01:15.370 --> 00:01:18.060
because the data about neighboring countries,

29
00:01:18.060 --> 00:01:21.240
is of course a result of the first call.

30
00:01:21.240 --> 00:01:22.930
So without the first call,

31
00:01:22.930 --> 00:01:25.440
we wouldn't even know which data to fetch,

32
00:01:25.440 --> 00:01:27.010
in the second call.

33
00:01:27.010 --> 00:01:32.010
And so what we need to implement is a sequence of AJAX call.

34
00:01:32.010 --> 00:01:33.610
So here, I already copied

35
00:01:33.610 --> 00:01:37.810
the function from the last lecture, which is still up here.

36
00:01:37.810 --> 00:01:39.976
And so let's call this one here now,

37
00:01:39.976 --> 00:01:44.976
getCountryAndNeighbor.

38
00:01:47.850 --> 00:01:52.060
So, again, we get the country as an input.

39
00:01:52.060 --> 00:01:55.150
And then here, we do the first AJAX call.

40
00:01:55.150 --> 00:01:58.070
And then once the load event is fired,

41
00:01:58.070 --> 00:02:01.460
when the data arrives, we then handle that data.

42
00:02:01.460 --> 00:02:04.513
And so everything that we have here is still the same.

43
00:02:05.460 --> 00:02:09.480
Now, we will do this part here another time.

44
00:02:09.480 --> 00:02:12.510
So basically, once the neighboring country arrives,

45
00:02:12.510 --> 00:02:15.080
we also will want to render this one.

46
00:02:15.080 --> 00:02:17.560
And so let's export this functionality

47
00:02:17.560 --> 00:02:18.993
into its own function.

48
00:02:20.290 --> 00:02:22.730
So that we don't have to copy it later.

49
00:02:22.730 --> 00:02:26.640
And this also makes this function a little bit cleaner.

50
00:02:26.640 --> 00:02:31.330
So renderCountry, that's gonna be a function,

51
00:02:31.330 --> 00:02:34.490
which simply takes in some data.

52
00:02:34.490 --> 00:02:37.380
And select this, we don't have to change,

53
00:02:37.380 --> 00:02:38.883
the variable names in here.

54
00:02:42.500 --> 00:02:47.103
And so now here, let's then actually call that function.

55
00:02:47.970 --> 00:02:51.963
So renderCountry with data.

56
00:02:52.930 --> 00:02:55.180
And now we get this error here,

57
00:02:55.180 --> 00:02:58.620
because of course, this function no longer exists.

58
00:02:58.620 --> 00:03:00.797
So getCountryAndNeighbor.

59
00:03:01.690 --> 00:03:05.560
So as I save this now, this should look the same as before.

60
00:03:05.560 --> 00:03:07.233
And so indeed it does.

61
00:03:08.932 --> 00:03:12.430
But now here, let's actually get the neighbor country.

62
00:03:13.710 --> 00:03:17.913
So let's write that, Get neighbor country.

63
00:03:18.871 --> 00:03:21.823
And here actually, let's also do some comments now.

64
00:03:25.300 --> 00:03:27.743
So Render country 1, let's say.

65
00:03:28.979 --> 00:03:32.033
And here I will say, AJAX call country 1.

66
00:03:38.740 --> 00:03:41.123
So the neighbor country will then be country 2.

67
00:03:44.800 --> 00:03:49.547
So the neighbor is gonna be data.borders, I believe.

68
00:03:53.630 --> 00:03:55.483
So let's just check that here again.

69
00:03:57.460 --> 00:03:59.730
And so this is actually an array.

70
00:03:59.730 --> 00:04:03.410
And so we will simply render the first element.

71
00:04:03.410 --> 00:04:06.360
So in the case of Portugal, there is just one border.

72
00:04:06.360 --> 00:04:09.090
But in other countries, like Germany,

73
00:04:09.090 --> 00:04:11.283
there's like 10 borders or something.

74
00:04:12.480 --> 00:04:14.850
So let's just destructor here,

75
00:04:14.850 --> 00:04:17.670
basically just take the first element.

76
00:04:17.670 --> 00:04:19.830
But of course, there are also countries

77
00:04:19.830 --> 00:04:22.080
which have no neighbors at all.

78
00:04:22.080 --> 00:04:24.520
So islands, basically.

79
00:04:24.520 --> 00:04:26.100
And so for these cases,

80
00:04:26.100 --> 00:04:30.123
let's simply make sure that we don't run into any mistakes.

81
00:04:31.150 --> 00:04:34.283
And so in that case, we simply return immediately.

82
00:04:35.250 --> 00:04:37.780
But of course, if the neighbor does exist,

83
00:04:37.780 --> 00:04:40.733
then now we can do the second AJAX call.

84
00:04:41.640 --> 00:04:43.313
And so let's copy all of this.

85
00:04:46.760 --> 00:04:50.440
And so here AJAX call 2

86
00:04:50.440 --> 00:04:53.660
and now here of course we don't want to use the country,

87
00:04:53.660 --> 00:04:55.800
but he wants to use the neighbor.

88
00:04:55.800 --> 00:04:58.400
But there is one particularity about that

89
00:04:59.330 --> 00:05:01.980
because here the border.

90
00:05:01.980 --> 00:05:03.860
So this one here, this country,

91
00:05:03.860 --> 00:05:06.760
actually doesn't come with the name of the country.

92
00:05:06.760 --> 00:05:08.023
But with this code.

93
00:05:09.920 --> 00:05:14.503
But using our API, we can actually also search by the code.

94
00:05:16.060 --> 00:05:18.763
So, right here we have that.

95
00:05:19.690 --> 00:05:21.750
So right now we are using the name.

96
00:05:21.750 --> 00:05:24.403
But as I said, we can also search for the code.

97
00:05:25.300 --> 00:05:27.970
And so all we have to change is basically here,

98
00:05:27.970 --> 00:05:29.633
from name to alpha.

99
00:05:31.710 --> 00:05:35.563
So that's alpha here, and then here, the neighbor.

100
00:05:40.240 --> 00:05:43.830
And so now just like before, we have to then list them

101
00:05:43.830 --> 00:05:47.050
for the load event on this new request.

102
00:05:47.050 --> 00:05:49.470
And let's call this request 2,

103
00:05:49.470 --> 00:05:52.800
because of course, we can't do that on the same request

104
00:05:52.800 --> 00:05:54.500
that we did here in the beginning.

105
00:05:56.690 --> 00:06:00.143
So request 2 addEventListener.

106
00:06:01.830 --> 00:06:06.830
Load, and then, or callback function.

107
00:06:08.390 --> 00:06:12.750
And so you're starting to see now that the second AJAX call

108
00:06:12.750 --> 00:06:14.950
now in the way we are setting it up here

109
00:06:14.950 --> 00:06:17.980
is really dependent on the first one.

110
00:06:17.980 --> 00:06:21.340
So that's because basically we are firing of,

111
00:06:21.340 --> 00:06:24.670
the second AJAX call here, in the callback function

112
00:06:24.670 --> 00:06:27.840
of the first one, right?

113
00:06:27.840 --> 00:06:30.620
So basically, inside of this callback function,

114
00:06:30.620 --> 00:06:34.580
we are now adding a new EventListener for the new request.

115
00:06:34.580 --> 00:06:35.810
And so here, we now have

116
00:06:35.810 --> 00:06:38.163
one callback inside of the other one.

117
00:06:41.471 --> 00:06:43.490
And so we will talk about that

118
00:06:43.490 --> 00:06:45.950
once we have this code working.

119
00:06:45.950 --> 00:06:50.310
But for now, let's actually take a look at the result here.

120
00:06:50.310 --> 00:06:53.070
And so that's gonna be, request

121
00:06:53.070 --> 00:06:55.220
or actually just a disk keyword.

122
00:06:55.220 --> 00:06:58.673
So this.responseText.

123
00:07:00.460 --> 00:07:01.830
So let's see.

124
00:07:01.830 --> 00:07:05.110
And, indeed, now we get data about Spain.

125
00:07:05.110 --> 00:07:08.190
And no matter how many times we reload the page,

126
00:07:08.190 --> 00:07:12.093
it will now always, always appear after Portugal.

127
00:07:14.010 --> 00:07:18.190
Because there is no way that this AJAX call here can be made

128
00:07:18.190 --> 00:07:20.023
before the one on Portugal.

129
00:07:22.180 --> 00:07:25.900
Okay, and so now, well, let's just do the same

130
00:07:25.900 --> 00:07:26.863
as we did here.

131
00:07:28.330 --> 00:07:29.683
So we don't need this,

132
00:07:30.750 --> 00:07:35.750
let's say data2 should be JSON.parse, and then this.

133
00:07:41.210 --> 00:07:43.960
And of course, we need to also the destructure it then,

134
00:07:46.140 --> 00:07:47.673
logging into the Console.

135
00:07:48.780 --> 00:07:50.513
But now we get some error here.

136
00:07:52.090 --> 00:07:54.760
So let's just take a look at the result itself

137
00:07:54.760 --> 00:07:56.333
without any destructuring.

138
00:07:57.220 --> 00:07:59.790
Oh, and so now it works.

139
00:07:59.790 --> 00:08:03.660
And the reason for that is that the response of this API

140
00:08:03.660 --> 00:08:08.180
is actually no longer an array, when we search for the code.

141
00:08:08.180 --> 00:08:10.750
So here we have this alpha, remember,

142
00:08:10.750 --> 00:08:13.690
and so this time, we are searching for country codes,

143
00:08:13.690 --> 00:08:15.640
and not for country names.

144
00:08:15.640 --> 00:08:18.050
And so the country codes are unique.

145
00:08:18.050 --> 00:08:21.510
And so therefore, they can always just be one result.

146
00:08:21.510 --> 00:08:25.310
And so that's the reason why no array is returned.

147
00:08:25.310 --> 00:08:28.513
And probably it says here so, in the documentation.

148
00:08:29.700 --> 00:08:31.640
Well, it doesn't say so.

149
00:08:31.640 --> 00:08:34.540
But if we would have just simply inspected

150
00:08:34.540 --> 00:08:35.810
the response here,

151
00:08:35.810 --> 00:08:39.920
then we would have understood that as well.

152
00:08:39.920 --> 00:08:41.960
But anyway, now it worked.

153
00:08:41.960 --> 00:08:46.053
And so let's now render, this country here as well.

154
00:08:47.840 --> 00:08:52.840
So data2 and now let's wait, and there it is, great.

155
00:08:54.350 --> 00:08:57.050
Now Actually, I created a special class,

156
00:08:57.050 --> 00:08:59.140
here for the neighboring country,

157
00:08:59.140 --> 00:09:01.393
so that it appears a little bit smaller.

158
00:09:02.700 --> 00:09:04.180
And so when it is the neighbor,

159
00:09:04.180 --> 00:09:06.963
we want to attach some class here to the country.

160
00:09:07.950 --> 00:09:11.193
And so let's pass that class in.

161
00:09:12.700 --> 00:09:14.400
So let's say className.

162
00:09:14.400 --> 00:09:17.100
And by default, we set it to nothing.

163
00:09:17.100 --> 00:09:20.430
So here, we will just edit to the string, like this.

164
00:09:23.930 --> 00:09:25.530
And now when it is a neighbor,

165
00:09:25.530 --> 00:09:30.530
we can just pass in, neighbor like this.

166
00:09:32.180 --> 00:09:36.640
Give it a safe, and yeah, so that looks a bit nicer.

167
00:09:36.640 --> 00:09:39.623
We get information that this is a neighbor country.

168
00:09:40.750 --> 00:09:45.750
And so now let's try this, for example, for the USA as well.

169
00:09:46.480 --> 00:09:48.853
But now I just want to do one at a time.

170
00:09:49.800 --> 00:09:52.723
So here we should probably get Mexico or Canada.

171
00:09:53.650 --> 00:09:55.190
And indeed, here it is.

172
00:09:55.190 --> 00:09:59.010
Here is Canada, the neighboring country of the US.

173
00:09:59.010 --> 00:10:00.170
And so one more time.

174
00:10:00.170 --> 00:10:03.110
This second AJAX call would not have been possible

175
00:10:03.110 --> 00:10:04.570
without the first one.

176
00:10:04.570 --> 00:10:06.610
Because otherwise, how would we know

177
00:10:06.610 --> 00:10:09.973
that the second country here needed to be Canada?

178
00:10:12.130 --> 00:10:15.450
So, again, we have one AJAX call here

179
00:10:15.450 --> 00:10:17.870
that depends on another one.

180
00:10:17.870 --> 00:10:20.630
And so what we have here is one callback function

181
00:10:20.630 --> 00:10:22.303
inside of another one.

182
00:10:23.380 --> 00:10:26.640
So you see here, we attach the first callback function.

183
00:10:26.640 --> 00:10:30.690
And then inside of that, we have yet another one.

184
00:10:30.690 --> 00:10:34.720
So in other words, here, we have nested callbacks.

185
00:10:34.720 --> 00:10:36.500
But now imagine that we wanted

186
00:10:36.500 --> 00:10:39.020
to do more requests in sequence,

187
00:10:39.020 --> 00:10:41.890
like the neighbor of the neighbor of the neighbor,

188
00:10:41.890 --> 00:10:44.040
and like 10 times over.

189
00:10:44.040 --> 00:10:45.790
So in that case, we would end up

190
00:10:45.790 --> 00:10:49.200
with callbacks inside of callbacks inside of callbacks,

191
00:10:49.200 --> 00:10:51.060
like 10 times.

192
00:10:51.060 --> 00:10:53.600
And actually, for that kind of structure.

193
00:10:53.600 --> 00:10:57.040
And for that kind of behavior, we have a special name.

194
00:10:57.040 --> 00:11:00.400
And that special name is callback hell.

195
00:11:00.400 --> 00:11:02.570
So basically, callback hell

196
00:11:02.570 --> 00:11:05.460
is when we have a lot of nested callbacks

197
00:11:05.460 --> 00:11:09.690
in order to execute asynchronous tasks in sequence.

198
00:11:09.690 --> 00:11:13.400
And in fact, this happens for all asynchronous tasks,

199
00:11:13.400 --> 00:11:15.520
which are handled by callbacks.

200
00:11:15.520 --> 00:11:18.060
And not just AJAX calls.

201
00:11:18.060 --> 00:11:22.373
So for example, let's say we have a set timeout function.

202
00:11:25.190 --> 00:11:29.170
And then here, we want to log something to the Console,

203
00:11:29.170 --> 00:11:33.310
like 1 second passed, but then also,

204
00:11:33.310 --> 00:11:35.463
we want to start another timeout.

205
00:11:36.760 --> 00:11:38.863
Let's just set 1000 here.

206
00:11:40.010 --> 00:11:41.623
So let's copy this one here.

207
00:11:42.650 --> 00:11:45.200
And so as I just said, let's say,

208
00:11:45.200 --> 00:11:47.620
that here we wanted to start a new timer

209
00:11:47.620 --> 00:11:49.883
after the first timer has finished.

210
00:11:51.190 --> 00:11:53.423
So here, we can say 2 seconds passed.

211
00:11:54.610 --> 00:11:57.190
And we can even add another one.

212
00:11:57.190 --> 00:12:01.561
So never mind about what just happened in the Console.

213
00:12:01.561 --> 00:12:04.763
And here, why not add yet another one?

214
00:12:07.690 --> 00:12:11.083
And so now they should appear like one, two, three, four.

215
00:12:12.310 --> 00:12:15.960
And so here to of course, we have callback hell.

216
00:12:15.960 --> 00:12:19.700
And in fact, callback hell is pretty easy to identify

217
00:12:19.700 --> 00:12:24.700
by this triangular shape that is formed here, you see that.

218
00:12:25.150 --> 00:12:28.453
And also the same is starting to appear here.

219
00:12:30.640 --> 00:12:32.633
So if we had more callbacks in here,

220
00:12:32.633 --> 00:12:36.310
then we would start to see a lot more indentation here.

221
00:12:36.310 --> 00:12:40.400
And then this triangular shape, would also appear there.

222
00:12:40.400 --> 00:12:42.280
Now, the problem with callback hell

223
00:12:42.280 --> 00:12:45.430
is that it makes our code look very messy.

224
00:12:45.430 --> 00:12:47.000
But even more important,

225
00:12:47.000 --> 00:12:49.380
it makes our code harder to maintain,

226
00:12:49.380 --> 00:12:53.340
and very difficult to understand, and to reason about,

227
00:12:53.340 --> 00:12:55.760
and code that is hard to understand

228
00:12:55.760 --> 00:12:57.670
and difficult to reason about.

229
00:12:57.670 --> 00:13:01.500
Will have more bugs, and it's just worse code.

230
00:13:01.500 --> 00:13:03.410
So this is a great rule

231
00:13:03.410 --> 00:13:06.410
that you should always remember and keep in mind.

232
00:13:06.410 --> 00:13:10.690
So again, the rule is that code that's hard to understand,

233
00:13:10.690 --> 00:13:14.620
is basically bad code, because it will have more bugs,

234
00:13:14.620 --> 00:13:17.050
because the harder it is to understand code

235
00:13:17.050 --> 00:13:18.860
and to reason about the code,

236
00:13:18.860 --> 00:13:22.080
the more difficult it will be to add new features

237
00:13:22.080 --> 00:13:25.400
and to add more functionality to the application.

238
00:13:25.400 --> 00:13:29.280
But anyway, given all these problems with callback hell,

239
00:13:29.280 --> 00:13:32.810
we of course, need a way to solve callback hell.

240
00:13:32.810 --> 00:13:36.020
And fortunately for us, since ES6,

241
00:13:36.020 --> 00:13:39.660
there is actually a way of escaping callback hell

242
00:13:39.660 --> 00:13:42.570
by using something called promises.

243
00:13:42.570 --> 00:13:44.690
And so let's now take the next step

244
00:13:44.690 --> 00:13:48.000
in our journey of asynchronous JavaScript,

245
00:13:48.000 --> 00:13:50.493
which is to learn all about promises.

