1
00:00:00,270 --> 00:00:04,620
All right, so welcome back to another lecture in this lecture, we're actually just going to go off

2
00:00:04,620 --> 00:00:05,910
on a little side topic.

3
00:00:06,240 --> 00:00:09,380
And this same topic is going to be about exceptions.

4
00:00:09,390 --> 00:00:14,940
It's going to be a short lecture, but I felt like this kind of is a necessary part of programming.

5
00:00:16,020 --> 00:00:17,770
I kind of wanted to go over everything.

6
00:00:17,790 --> 00:00:22,230
Of course, for programming in general, in any language, we're using C++, right?

7
00:00:22,230 --> 00:00:24,600
But these are things that would be present.

8
00:00:24,600 --> 00:00:28,950
And the things that we want to cover in the course are things that you would use in many different programming

9
00:00:28,950 --> 00:00:29,430
languages.

10
00:00:29,430 --> 00:00:31,410
And exceptions are in a lot of languages.

11
00:00:31,420 --> 00:00:34,500
So we're going to definitely go ahead and cover that.

12
00:00:35,190 --> 00:00:37,020
So what are exceptions?

13
00:00:37,050 --> 00:00:42,600
Well, basically think about when you have an error in your program, right?

14
00:00:42,600 --> 00:00:50,130
Like you get some sort of undefined behavior you might try and like put a ton of different like conditional

15
00:00:50,130 --> 00:00:53,920
statements to do certain certain things to handle that.

16
00:00:54,630 --> 00:00:59,040
But, you know, after a while, that can get kind of kind of messy, right?

17
00:00:59,040 --> 00:01:02,940
And you just don't want like a ton of just straight up only conditionals and print statements.

18
00:01:02,950 --> 00:01:08,190
Maybe there's something later down the line that needs to be prevented by you handling errors on your

19
00:01:08,190 --> 00:01:13,770
own right instead of just encountering some error, having the program crash or having like a ton of

20
00:01:13,770 --> 00:01:20,680
spaghetti code trying to deal with like handling errors only with if and else if without anything else.

21
00:01:21,270 --> 00:01:28,350
So exceptions are something that we can kind of add into this game by using F and elseif and stuff like

22
00:01:28,350 --> 00:01:34,740
that, but also adding this other part where we can kind of catch errors and choose what to do when

23
00:01:34,740 --> 00:01:36,150
we catch those errors.

24
00:01:37,590 --> 00:01:41,340
So enough of me kind of just explaining that let me go ahead and show you.

25
00:01:41,700 --> 00:01:44,970
So I'm going to go ahead and just make a little example program here.

26
00:01:48,300 --> 00:01:53,250
I'm actually going to make a function prototype, so I'm going to go over just a couple of quick examples

27
00:01:53,250 --> 00:01:56,550
and they're going to be kind of trivial, but they'll illustrate the point, hopefully.

28
00:01:57,330 --> 00:02:03,990
So first off, I'm going to make something called like, I'm going to say I'm going to do and.

29
00:02:05,690 --> 00:02:10,610
And let's just say double, and let's just say.

30
00:02:12,780 --> 00:02:20,430
Like age divide by two or something like this, so you get an aged into this function and it divides

31
00:02:20,430 --> 00:02:27,480
it by two and tries to, you know, return return something.

32
00:02:27,510 --> 00:02:27,870
Right?

33
00:02:28,320 --> 00:02:28,710
So.

34
00:02:31,310 --> 00:02:38,090
Well, let's just get to let's get his age there by their age or something like that.

35
00:02:42,810 --> 00:02:49,620
So you get like age one and age two, you divide one age by another age.

36
00:02:50,790 --> 00:02:54,390
So let's go ahead and make a main function here.

37
00:02:55,620 --> 00:03:02,580
And so what I'm going to do is just say, into age one.

38
00:03:07,890 --> 00:03:13,500
So let's go ahead and see and let's go ahead and make some major change one.

39
00:03:15,610 --> 00:03:21,750
Let's just say zero and age two equals zero.

40
00:03:22,230 --> 00:03:28,440
And then let's go ahead and say that we can't age one here.

41
00:03:30,660 --> 00:03:32,180
Actually, no, that's why I only do that one.

42
00:03:32,410 --> 00:03:36,480
And that so then we'll say into age to.

43
00:03:38,600 --> 00:03:38,990
Cool.

44
00:03:39,110 --> 00:03:42,500
So and then she managed to.

45
00:03:44,960 --> 00:03:48,500
And then let's go ahead and call this function, so we'll say A..

46
00:03:48,710 --> 00:03:52,040
By other age and I would just say age one age to

47
00:03:55,190 --> 00:03:59,800
finish this stuff right here and then we will go ahead and put this function right here.

48
00:04:00,030 --> 00:04:04,720
So maybe I like returned some like.

49
00:04:06,360 --> 00:04:11,880
Double, let's just say, you know, we'll just call these double so double h one.

50
00:04:14,120 --> 00:04:15,140
Double Page two.

51
00:04:15,320 --> 00:04:21,220
And all of this returns of double, I won't say age.

52
00:04:21,620 --> 00:04:24,110
Dave, it's this age due by their age.

53
00:04:25,880 --> 00:04:29,210
Their age actually should have this be camel case, right?

54
00:04:30,110 --> 00:04:33,200
Age to buy their age have a happy, probably.

55
00:04:34,040 --> 00:04:38,690
So we take this and age, I would say one.

56
00:04:38,690 --> 00:04:39,590
And no, not.

57
00:04:39,610 --> 00:04:41,970
And let's take doubles, right?

58
00:04:46,210 --> 00:04:47,410
So she's the devil.

59
00:04:49,540 --> 00:04:50,890
So let's take like.

60
00:04:55,930 --> 00:04:57,130
Make sure you get this right.

61
00:04:58,900 --> 00:05:03,250
Double one, double A2, right?

62
00:05:07,870 --> 00:05:08,920
Fumbling all over the place.

63
00:05:09,760 --> 00:05:13,180
So we take these and we just try and like return

64
00:05:15,980 --> 00:05:19,360
like A1 divided by a two, right?

65
00:05:20,620 --> 00:05:21,430
We just do that.

66
00:05:23,050 --> 00:05:32,140
So and then we'll go ahead and just say, like, see out this, right?

67
00:05:37,500 --> 00:05:40,200
So let's just say like.

68
00:05:42,940 --> 00:05:45,670
Age one over

69
00:05:49,010 --> 00:05:52,960
and by age to.

70
00:05:55,710 --> 00:05:59,310
Equals that right?

71
00:06:01,990 --> 00:06:02,380
Cool.

72
00:06:02,440 --> 00:06:09,010
So let's go ahead and just save this program, right, and let's go ahead and run this program, so

73
00:06:09,010 --> 00:06:09,850
I'll go down here.

74
00:06:10,090 --> 00:06:11,170
Safety First Bus

75
00:06:13,930 --> 00:06:17,730
called this exceptions exceptions to CBP.

76
00:06:18,290 --> 00:06:20,530
Uh, so eat out.

77
00:06:20,730 --> 00:06:22,600
Actually do that.

78
00:06:24,200 --> 00:06:30,380
OK, so I'm going to run this program now and listen to some ages, so what if I say, let's just do

79
00:06:30,380 --> 00:06:31,050
something simple, right?

80
00:06:31,610 --> 00:06:34,760
Let's just say like six and two.

81
00:06:35,750 --> 00:06:37,040
Yeah, that works fine, right?

82
00:06:37,040 --> 00:06:38,320
But like, let's try something else.

83
00:06:38,330 --> 00:06:42,440
What if I say zero and four?

84
00:06:43,680 --> 00:06:45,080
OK, well, that works.

85
00:06:45,080 --> 00:06:48,350
But let's try four and zero.

86
00:06:49,400 --> 00:06:51,440
Yeah, this is kind of a weird problem, right?

87
00:06:51,500 --> 00:06:54,050
It's just like I and F.

88
00:06:54,230 --> 00:06:54,620
Right?

89
00:06:55,280 --> 00:06:59,100
That's because we can't really divide by zero.

90
00:06:59,120 --> 00:06:59,560
Right.

91
00:06:59,570 --> 00:07:02,810
So this is like some sort of divide by zero error.

92
00:07:03,470 --> 00:07:05,330
So how would we deal with that, right?

93
00:07:05,570 --> 00:07:19,360
Like, we could put some f in here and just say, if you know a two equals zero, then you could just

94
00:07:19,370 --> 00:07:33,200
see out like, hey, you know, zero age or hey, like, can't divide by zero.

95
00:07:35,000 --> 00:07:36,080
You know, like that.

96
00:07:38,900 --> 00:07:44,690
And then this could just be like, you know, we could just return right now or this could be like,

97
00:07:44,900 --> 00:07:45,770
this could be like.

98
00:07:49,180 --> 00:07:52,640
You know, we could just say return, blah blah blah.

99
00:07:52,660 --> 00:07:56,260
You know, we could like return something or like, maybe.

100
00:07:57,380 --> 00:08:04,220
We don't want to like actually do the division right, so we don't want to have this and else, but

101
00:08:04,220 --> 00:08:06,410
then we have to like return something, right?

102
00:08:08,450 --> 00:08:09,140
So.

103
00:08:13,560 --> 00:08:19,110
You know, because if this happens, you need to basically like you definitely want to like return something,

104
00:08:19,110 --> 00:08:19,360
right?

105
00:08:19,380 --> 00:08:20,850
You don't want to just like not return.

106
00:08:20,850 --> 00:08:28,050
So you can just be like, Oh, return, I don't know, return zero and then like.

107
00:08:30,010 --> 00:08:37,180
Then once you return that, then you have to, like, somehow put some some air here and see if it's

108
00:08:37,180 --> 00:08:44,320
zero, then like, I don't know, like don't print it out or something like that and like that word

109
00:08:44,320 --> 00:08:45,220
worked fine.

110
00:08:45,400 --> 00:08:45,810
Right.

111
00:08:45,820 --> 00:08:50,650
But imagine if you like this gets a lot more complex, like it becomes a bigger program and you need

112
00:08:50,650 --> 00:08:51,010
to.

113
00:08:52,640 --> 00:08:58,250
You need to like, you know, handle like a lot of different errors and stuff like this where you have

114
00:08:58,250 --> 00:09:02,390
unexpected behavior and you're just going to end up putting a ton of conditionals.

115
00:09:03,350 --> 00:09:10,570
There's actually a cleaner and more kind of well known way of doing this, like a specific way that

116
00:09:10,570 --> 00:09:14,800
you're supposed to handle these types of situations and that's using these exceptions.

117
00:09:15,700 --> 00:09:18,610
So let's change this into an exception.

118
00:09:19,120 --> 00:09:23,500
So what I'm going to do is I'm going to use a

119
00:09:27,130 --> 00:09:31,630
I'm going to use a keyword it special called Throw.

120
00:09:31,860 --> 00:09:40,210
So we like throw an error message and I'm just going to say, Hey, can't divide by zero, just kind

121
00:09:40,210 --> 00:09:41,650
of like what we did before.

122
00:09:44,370 --> 00:09:49,860
But what I'm going to do is I'm actually going to have a thing up here to be able to catch this error,

123
00:09:49,860 --> 00:09:54,360
and I'm going to try and do this function right here, right?

124
00:09:54,360 --> 00:09:58,500
So I'm going to put a try right here.

125
00:09:58,590 --> 00:10:00,390
So it's the keyword try.

126
00:10:00,870 --> 00:10:05,970
So we used a keyword that was special called throw down here, right up in Maine, where you're using

127
00:10:05,970 --> 00:10:07,040
something called Try.

128
00:10:07,050 --> 00:10:08,430
I put little braces.

129
00:10:10,010 --> 00:10:15,590
I'm going to copy this, and I'm going to put that in here.

130
00:10:17,450 --> 00:10:19,200
So I'm going to attempt this right.

131
00:10:19,220 --> 00:10:20,720
I'm going to try and do this.

132
00:10:21,910 --> 00:10:27,460
Which is like, you know, to print out this and then call this function and tell me the age, divide

133
00:10:27,460 --> 00:10:32,940
it by the other age so then I can catch.

134
00:10:34,760 --> 00:10:35,120
Right?

135
00:10:35,130 --> 00:10:37,480
I can go ahead here and I'm going to do a catch.

136
00:10:38,110 --> 00:10:41,050
So this is catching the thing that gets thrown right.

137
00:10:41,410 --> 00:10:44,230
This throw is basically throwing a message.

138
00:10:45,290 --> 00:10:51,020
The way to do this is you say that you're going to try it right and then the catch, if there is an

139
00:10:51,020 --> 00:10:57,020
error, it's going to catch this and what you have to put in here or this is just kind of a convention

140
00:10:59,090 --> 00:11:06,440
is to put a cost char plan basically to this message shows kind of like a array of characters, you

141
00:11:06,440 --> 00:11:07,930
know, pointing to an array of characters.

142
00:11:07,940 --> 00:11:09,380
I'm going to ask you the same message.

143
00:11:12,360 --> 00:11:17,390
And so when I put this constant message thing in here, it's going to grab these characters right here

144
00:11:17,400 --> 00:11:21,870
and we can actually print it out, so I'll just say, see our message.

145
00:11:25,460 --> 00:11:29,240
So you might be saying like, well, we could just do all these, you know, we can do this if and stuff.

146
00:11:29,310 --> 00:11:35,750
This is actually a cleaner and more professional way of doing this, and you'll notice that sometimes

147
00:11:35,750 --> 00:11:42,890
it can get quite like growth in the code when you're trying to handle like a bunch of different errors

148
00:11:42,890 --> 00:11:43,340
and stuff.

149
00:11:43,340 --> 00:11:49,250
But the cool thing is that you can try a bunch of stuff, you know and get this message thrown back.

150
00:11:49,940 --> 00:11:55,460
You can actually even make your own exception classes, but we're not going to go into that.

151
00:11:56,620 --> 00:12:00,430
Because that's kind of outside the scope of what we're trying to do here, but it's important that you

152
00:12:00,430 --> 00:12:02,770
knew how to at least handle semi some exceptions.

153
00:12:03,640 --> 00:12:05,670
So let's go ahead and try this out.

154
00:12:05,680 --> 00:12:06,250
Let's see.

155
00:12:06,260 --> 00:12:07,150
Let's see what happens.

156
00:12:09,050 --> 00:12:15,590
So we saw what it did before, right, like we got some like infinity or something like, you know,

157
00:12:15,590 --> 00:12:16,550
it just it was just set.

158
00:12:17,240 --> 00:12:17,510
Right?

159
00:12:17,990 --> 00:12:23,900
So let's go ahead and save this and we'll recompile it and see what happens now.

160
00:12:26,640 --> 00:12:33,990
So I'm going to enter age one, let's just say like nine and I introduced to zero and it actually says,

161
00:12:33,990 --> 00:12:37,590
Hey, can't divide by zero, so that's what gets printed out.

162
00:12:40,500 --> 00:12:44,030
So what it did was it said, Oh, hey, two is zero.

163
00:12:44,070 --> 00:12:46,620
I'm going to say, Hey, you can't divide by zero.

164
00:12:47,460 --> 00:12:52,260
Instead of doing this, so this isn't even like an elf, you know, it just immediately throws this

165
00:12:52,260 --> 00:12:55,890
air so we don't have to deal with like any other returns, right?

166
00:12:56,310 --> 00:13:00,990
Or anything like that, we can just have our function be pretty clean and just return this one thing.

167
00:13:01,560 --> 00:13:04,740
If this actually is encountered, it'll just throw this air.

168
00:13:05,550 --> 00:13:06,170
It won't.

169
00:13:06,180 --> 00:13:08,830
It'll say, like, Hey, I tried to do this right?

170
00:13:09,300 --> 00:13:12,270
I tried it specifically tried to call this function.

171
00:13:12,510 --> 00:13:13,440
It didn't work out.

172
00:13:13,440 --> 00:13:19,320
So I caught whatever air was thrown from here, and that was what we were catching right here.

173
00:13:19,320 --> 00:13:20,270
Is this message, right?

174
00:13:20,280 --> 00:13:21,420
And I printed out the message.

175
00:13:23,780 --> 00:13:29,900
So you can do like similar things, you know, with, you know, filtering people's age in a different

176
00:13:29,900 --> 00:13:32,320
way, like you could add another one here.

177
00:13:32,330 --> 00:13:40,310
So let's say that you wanted it to be like, let's say like verify age.

178
00:13:42,510 --> 00:13:49,410
Let's just say, like verify ages and we go down here, and let's just say.

179
00:13:53,780 --> 00:13:55,760
Let's just say try.

180
00:14:01,600 --> 00:14:04,360
Ages are valid.

181
00:14:06,070 --> 00:14:08,200
Let's just say ages are valid.

182
00:14:13,590 --> 00:14:14,160
If.

183
00:14:16,080 --> 00:14:19,530
Let's just make some like let's make this like a Blu ray or something like that.

184
00:14:23,100 --> 00:14:24,660
So we'll verify ages.

185
00:14:27,220 --> 00:14:30,100
And then I'll just say, hi, return true.

186
00:14:30,700 --> 00:14:32,980
And what we will do is like.

187
00:14:35,210 --> 00:14:39,440
We'll just say, like our age is

188
00:14:42,020 --> 00:14:45,560
valid or something, we're actually just saying like.

189
00:14:49,390 --> 00:14:50,320
Pages are.

190
00:14:52,400 --> 00:14:53,870
Ages are valid, right?

191
00:15:01,680 --> 00:15:03,450
Let's just say if.

192
00:15:05,670 --> 00:15:10,410
I know this is kind of like ironic because I said, you don't really have to use that money if I'm not

193
00:15:10,410 --> 00:15:15,030
coming up with, like the best example here, but it's just something to illustrate a point of like

194
00:15:15,360 --> 00:15:15,460
that.

195
00:15:15,540 --> 00:15:17,760
You can do this, you know, in different ways.

196
00:15:18,570 --> 00:15:20,820
You can, like, handle multiple things.

197
00:15:21,300 --> 00:15:21,720
So.

198
00:15:23,080 --> 00:15:25,480
If this return is true, then we'll just say aid is a valid.

199
00:15:26,730 --> 00:15:33,090
And otherwise, you know, we'll just print out some stuff like if the ages are not within our parameters,

200
00:15:33,090 --> 00:15:38,370
so let's say if a two is less than zero.

201
00:15:41,840 --> 00:15:47,280
Or, let's say, actually eight one eight four eight one is less than zero or a two.

202
00:15:47,300 --> 00:15:48,290
It's less than zero.

203
00:15:49,760 --> 00:15:56,930
Then we'll just say like throw like can't have nega tive ages.

204
00:15:59,670 --> 00:16:08,850
And let's just say another thing like nothing else, if a one is greater than like 150 or something,

205
00:16:08,850 --> 00:16:10,260
I mean, that's like pretty, all right.

206
00:16:10,260 --> 00:16:17,940
Let's just say that's like a cap on some age or a two is over 150.

207
00:16:19,820 --> 00:16:23,840
Then we'll just like throw some air and say, I'm

208
00:16:28,430 --> 00:16:29,810
way too old.

209
00:16:30,380 --> 00:16:31,250
Yeah, right?

210
00:16:32,330 --> 00:16:34,020
You know, something like that, I don't know.

211
00:16:34,040 --> 00:16:36,860
I don't need these brackets, actually, since we just have one line.

212
00:16:40,570 --> 00:16:41,050
Cool.

213
00:16:41,890 --> 00:16:46,780
So it's difficult on here, so we could even take these old, I mean, I don't want to be that like,

214
00:16:48,070 --> 00:16:51,960
be that pessimistic, you know, but I don't know anyone that's lived that long, right?

215
00:16:51,970 --> 00:16:53,520
170 That's pretty crazy.

216
00:16:53,530 --> 00:16:58,900
So we can just like now, what we have is something they can verify ages and have a specific area that

217
00:16:58,900 --> 00:17:07,210
gets thrown if they exceed these bounds, you know, so and oh, we know how it's still pretty clean,

218
00:17:07,240 --> 00:17:07,600
right?

219
00:17:07,810 --> 00:17:08,800
It's still pretty clean.

220
00:17:10,370 --> 00:17:16,400
So this function really like could be doing something else, too, like maybe it actually still does.

221
00:17:18,380 --> 00:17:23,910
Age, divide by other age or something like that, let's just say we could even add another one, right?

222
00:17:23,930 --> 00:17:25,250
Like what if we do this?

223
00:17:25,250 --> 00:17:26,750
What if this is like an LCA?

224
00:17:28,110 --> 00:17:37,170
Here will change it back to even what it was before, so if a if a two equals zero, let's just say

225
00:17:37,170 --> 00:17:37,500
like

226
00:17:40,110 --> 00:17:43,470
throw can't divide by zero.

227
00:17:45,710 --> 00:17:46,070
Right.

228
00:17:46,700 --> 00:17:47,480
So.

229
00:17:49,820 --> 00:17:52,880
We're going to have all of these things, and we just change suspected devil, right?

230
00:17:54,260 --> 00:17:58,040
So we'll just return a one by a two.

231
00:17:59,730 --> 00:18:02,340
And now we have like extra checks, actually.

232
00:18:03,430 --> 00:18:04,480
So that's kind of cool, right?

233
00:18:05,110 --> 00:18:12,370
So we'll just say, like, we'll put this back to kind of how it was or just say like see out age one

234
00:18:13,660 --> 00:18:18,070
to five by age two equals and then we'll just stay.

235
00:18:21,420 --> 00:18:23,610
This is a positive by age, right?

236
00:18:25,140 --> 00:18:30,570
So let's just like put that back to how it was.

237
00:18:31,190 --> 00:18:40,680
Um, and yeah, we'll just say age, divide by age, each one age to.

238
00:18:44,190 --> 00:18:51,420
So I know it kind of went back, you know, I went on a little detour around and came back, but, you

239
00:18:51,420 --> 00:18:57,060
know, now we can catch multiple things, so we kind of set it up like, Oh, you know, the aid shouldn't

240
00:18:57,060 --> 00:19:01,610
be allowed to be, you know, zero because we can't abide by that.

241
00:19:01,620 --> 00:19:02,520
The age can.

242
00:19:02,520 --> 00:19:06,900
But at least like, you know, we want to make sure that it's not like negative, right, either because

243
00:19:06,900 --> 00:19:09,030
people shouldn't have negative ages.

244
00:19:11,060 --> 00:19:12,990
Can you say that specifically, right?

245
00:19:13,080 --> 00:19:18,030
Like people can have negative ages and then like this one that's just too old, you know?

246
00:19:20,260 --> 00:19:22,270
So now we can handle all those different ones.

247
00:19:22,420 --> 00:19:25,870
All those different messages can just be caught and displayed right here.

248
00:19:26,350 --> 00:19:27,970
And it's pretty clean looking, right?

249
00:19:28,570 --> 00:19:33,010
Otherwise, we can just do our normal division and just kind of like, you know, carry on with our

250
00:19:33,010 --> 00:19:35,080
code like it would go ahead and just.

251
00:19:36,020 --> 00:19:40,800
You run this and it would skip the catch and keep going if we had like, you know, more co down here.

252
00:19:41,880 --> 00:19:43,770
So let's go ahead and try this out then.

253
00:19:45,540 --> 00:19:47,850
So I'm going to compile this again.

254
00:19:49,260 --> 00:19:52,550
So let's do something like, let's do a normal age, right?

255
00:19:52,570 --> 00:19:57,660
So we'll just say like 60 and 20.

256
00:19:58,470 --> 00:20:01,530
You know, it's just it's like age old divides two is three.

257
00:20:01,530 --> 00:20:02,790
So that that works fine, right?

258
00:20:02,790 --> 00:20:11,580
But let's put something like, let's say, like, uh, like negative four and like Negative 20 or something

259
00:20:11,580 --> 00:20:12,810
or like Negative 20.

260
00:20:13,470 --> 00:20:16,130
So says, Hey, people can't have negative ages, right?

261
00:20:17,800 --> 00:20:24,730
And then we go in here and we say, like, you know, one hundred and ninety and then like ten, you

262
00:20:24,730 --> 00:20:27,910
know, this person in age one 190 is like way too old.

263
00:20:27,910 --> 00:20:28,450
Yeah, right?

264
00:20:28,750 --> 00:20:33,250
So it was able to catch that right and then we can still do our normal on, you know, and it's like,

265
00:20:33,700 --> 00:20:38,920
let's say it's just like 40 and then zero, it says can't fly by zero.

266
00:20:39,100 --> 00:20:42,250
So we're catching all of these problems, right?

267
00:20:42,640 --> 00:20:48,070
Things that wouldn't really work very well if we had some sort of system that was keeping track of like

268
00:20:48,130 --> 00:20:49,360
people's data, right?

269
00:20:49,450 --> 00:20:55,330
We wouldn't want any of these successfully entered into some database or some system and get processed

270
00:20:55,330 --> 00:20:56,080
later on.

271
00:20:56,320 --> 00:21:01,180
We'd rather just like throw some air and then, you know, we could kind of handle things however we

272
00:21:01,180 --> 00:21:03,430
want at that point after this gets thrown like.

273
00:21:04,270 --> 00:21:04,630
But.

274
00:21:05,730 --> 00:21:10,510
The point is, is that it throws this message and doesn't doesn't do anything else.

275
00:21:10,530 --> 00:21:10,890
You know?

276
00:21:12,400 --> 00:21:15,310
So kind of cool, right?

277
00:21:15,340 --> 00:21:20,920
A little bit of a sidetrack, but an important topic, you'll find these exceptions and air handling

278
00:21:20,920 --> 00:21:25,720
things and a lot of other languages like Python and stuff like that.

279
00:21:25,720 --> 00:21:27,970
So really important.

280
00:21:28,210 --> 00:21:29,110
Good to know about it.

281
00:21:29,110 --> 00:21:31,840
And these will be translatable skills.

282
00:21:31,840 --> 00:21:36,580
You know how slightly different syntax, of course, another language, but it'll be cool that you know

283
00:21:36,580 --> 00:21:37,060
about it.

284
00:21:37,060 --> 00:21:42,010
So when you start adding some other languages under your belt, you'll be able to kind of know that

285
00:21:42,010 --> 00:21:43,330
this is a tool that you can use.

286
00:21:44,440 --> 00:21:44,710
All right.

287
00:21:44,720 --> 00:21:46,720
So with that, I will see you in the next lesson.