WEBVTT

1
00:00:00.120 --> 00:00:02.439
<v Speaker 1>Welcome to the deep Dive, where we cut through the

2
00:00:02.480 --> 00:00:06.240
<v Speaker 1>noise to get you well informed fast. Today we're plunging

3
00:00:06.280 --> 00:00:11.439
<v Speaker 1>into this invisible force that really powers our modern world code.

4
00:00:11.519 --> 00:00:12.560
<v Speaker 2>It really is everywhere.

5
00:00:12.679 --> 00:00:15.919
<v Speaker 1>Yeah, just think for a second, your smartphone, you're online, banking,

6
00:00:16.199 --> 00:00:19.839
<v Speaker 1>even the shows you stream, it's all built on programming. Fundamentally.

7
00:00:19.879 --> 00:00:23.519
<v Speaker 1>It's just pervasive, like a silent engine humming beneath well,

8
00:00:23.679 --> 00:00:26.960
<v Speaker 1>almost everything digital we touch. So this deep dive is

9
00:00:27.000 --> 00:00:32.240
<v Speaker 1>our exploration into the core concepts, the real heart of programming.

10
00:00:32.600 --> 00:00:36.920
<v Speaker 1>And we're pulling our insights directly from Python the Complete Guide.

11
00:00:37.079 --> 00:00:41.240
<v Speaker 1>It's a fantastic, really comprehensive resource from BDM's Definitive Guide series.

12
00:00:41.320 --> 00:00:44.159
<v Speaker 1>That's a solid guide, definitely our mission today. It's a

13
00:00:44.200 --> 00:00:46.920
<v Speaker 1>cut through the complexity, you know, the jargon that can

14
00:00:46.920 --> 00:00:49.479
<v Speaker 1>sometimes surround learning to code. We want to pull out

15
00:00:49.479 --> 00:00:51.840
<v Speaker 1>the most important bits of knowledge from this guide, give

16
00:00:51.840 --> 00:00:55.960
<v Speaker 1>you a shortcut basically to understanding what Python and C

17
00:00:56.079 --> 00:00:59.640
<v Speaker 1>plus plus are all about, and how well the guide

18
00:00:59.640 --> 00:01:03.119
<v Speaker 1>puts it brilliantly. A few simple lines of code can

19
00:01:03.159 --> 00:01:04.200
<v Speaker 1>create something amazing.

20
00:01:05.560 --> 00:01:08.920
<v Speaker 2>Okay, let's dive right in. Then the source really paints

21
00:01:08.959 --> 00:01:12.480
<v Speaker 2>this vivid picture of how code is just omnipresent and

22
00:01:12.519 --> 00:01:16.040
<v Speaker 2>why right now is such a great time to start

23
00:01:16.159 --> 00:01:17.959
<v Speaker 2>learning how to create with it.

24
00:01:17.959 --> 00:01:20.200
<v Speaker 1>It truly is, and the guide makes it clear. You know,

25
00:01:20.400 --> 00:01:22.599
<v Speaker 1>code isn't just one single thing. It comes in all

26
00:01:22.599 --> 00:01:25.159
<v Speaker 1>sorts of different forms, different programming languages, right.

27
00:01:25.040 --> 00:01:26.159
<v Speaker 2>Like tools in a toolbox.

28
00:01:26.239 --> 00:01:30.400
<v Speaker 1>Exactly, each language offers specific strengths. Maybe it's stability you need,

29
00:01:30.560 --> 00:01:33.959
<v Speaker 1>or blistering speed, or maybe the ability to handle really

30
00:01:33.959 --> 00:01:37.439
<v Speaker 1>complex algorithms. Okay, and this isn't just some niche skill

31
00:01:37.480 --> 00:01:40.920
<v Speaker 1>for tech guruers anymore. Understanding this foundation is actually crucial

32
00:01:40.959 --> 00:01:45.959
<v Speaker 1>because code is essential for well countless industries, everything from say,

33
00:01:46.239 --> 00:01:49.519
<v Speaker 1>satellite communications right down to entertainment. Wow, okay, it really

34
00:01:49.599 --> 00:01:53.359
<v Speaker 1>underscores the practical value. You know, Understanding these languages doesn't

35
00:01:53.400 --> 00:01:56.599
<v Speaker 1>matter what your background is. Absolutely, and when the guide

36
00:01:56.719 --> 00:02:00.719
<v Speaker 1>zeros in on specific languages, it highlights two heavyweights, Python

37
00:02:00.799 --> 00:02:04.840
<v Speaker 1>and C plus plus Core. Let's start with Python, Okay.

38
00:02:04.920 --> 00:02:08.120
<v Speaker 1>The source really celebrates its power as a truly multi

39
00:02:08.199 --> 00:02:12.240
<v Speaker 1>platform language, runs on Windows, Mac, Os, Linux.

40
00:02:12.599 --> 00:02:13.800
<v Speaker 2>And even Raspberry Pie.

41
00:02:13.919 --> 00:02:17.400
<v Speaker 1>Right, and those low cost devices like the Pie. It's

42
00:02:17.439 --> 00:02:19.560
<v Speaker 1>praise for being easy to use, especially if you're just

43
00:02:19.560 --> 00:02:20.120
<v Speaker 1>starting out.

44
00:02:20.280 --> 00:02:23.759
<v Speaker 2>Yeah, the learning curve is generally seen as gentler.

45
00:02:23.520 --> 00:02:26.479
<v Speaker 1>And it's incredibly broad in where you can use it.

46
00:02:26.520 --> 00:02:32.120
<v Speaker 1>We're talking mobile devices, PCs, max, smart TVs, gaming, web development,

47
00:02:32.240 --> 00:02:35.520
<v Speaker 1>even like heavy duty scientific work. The guy calls it

48
00:02:35.560 --> 00:02:37.280
<v Speaker 1>a high level language.

49
00:02:36.840 --> 00:02:40.400
<v Speaker 2>Which basically means it's closer to how humans think and

50
00:02:40.479 --> 00:02:42.759
<v Speaker 2>talk rather than the raw ones and zero's the computer

51
00:02:42.879 --> 00:02:45.080
<v Speaker 2>understands directly makes it way more accessible.

52
00:02:45.159 --> 00:02:47.479
<v Speaker 1>Okay, that makes sense. So it's not just about listing futures.

53
00:02:47.599 --> 00:02:50.560
<v Speaker 2>No, what's fascinating here is how the source emphasizes that

54
00:02:50.599 --> 00:02:54.960
<v Speaker 2>this versatility makes Python like your ultimate coding Swiss army knife.

55
00:02:55.039 --> 00:02:57.680
<v Speaker 2>Oh it lets you pivot, you know, maybe you start

56
00:02:57.680 --> 00:03:00.560
<v Speaker 2>with web stuff, then moving to data analysis, maybe even

57
00:03:00.560 --> 00:03:04.120
<v Speaker 2>try some basic game creation, all without needing to learn

58
00:03:04.159 --> 00:03:06.840
<v Speaker 2>a whole new language from scratch. That's the real power

59
00:03:07.120 --> 00:03:08.840
<v Speaker 2>for someone getting into programming today.

60
00:03:08.879 --> 00:03:11.599
<v Speaker 1>Gotcha. And then there's the other one. It highlights C plus.

61
00:03:11.400 --> 00:03:13.680
<v Speaker 2>Plus foon, right, C plus plus foon.

62
00:03:13.879 --> 00:03:17.479
<v Speaker 1>So while Python's the versatile one, C plus plus gets

63
00:03:17.479 --> 00:03:21.360
<v Speaker 1>spotlighted for raw power and performance.

64
00:03:21.400 --> 00:03:22.400
<v Speaker 2>Performance is key there.

65
00:03:22.400 --> 00:03:26.639
<v Speaker 1>It's another hugely popular language, widely used in demanding areas

66
00:03:26.680 --> 00:03:30.960
<v Speaker 1>like game development. Systems programming like building the core software for.

67
00:03:30.960 --> 00:03:33.240
<v Speaker 2>Computers, operating systems, that kind of thing.

68
00:03:33.199 --> 00:03:36.199
<v Speaker 1>Exactly, even operating systems themselves. The guide notes it started

69
00:03:36.240 --> 00:03:39.879
<v Speaker 1>way back in nineteen eighty three, and crucially its object

70
00:03:39.919 --> 00:03:40.919
<v Speaker 1>oriented nature.

71
00:03:41.280 --> 00:03:43.400
<v Speaker 2>Right. Oh oh, that's a big concept.

72
00:03:43.520 --> 00:03:45.759
<v Speaker 1>Can you impact that a bit? Object oriented?

73
00:03:45.840 --> 00:03:48.599
<v Speaker 2>Sure? At its core, it's a way to structure your code.

74
00:03:48.639 --> 00:03:52.000
<v Speaker 2>You organize it into reusable objects that kind of model

75
00:03:52.560 --> 00:03:55.560
<v Speaker 2>real world things or concepts. Think of it like building

76
00:03:55.560 --> 00:03:59.159
<v Speaker 2>with specialized components. It helps make really complex programs more

77
00:03:59.199 --> 00:04:01.000
<v Speaker 2>manageable and easier to scale up.

78
00:04:01.240 --> 00:04:04.960
<v Speaker 1>Okay, So, looking at the guide, it positions both Python

79
00:04:05.280 --> 00:04:09.319
<v Speaker 1>and C plus plus as these incredibly powerful tools. But

80
00:04:09.439 --> 00:04:11.680
<v Speaker 1>what really makes them stand out from each other? What's

81
00:04:11.719 --> 00:04:12.560
<v Speaker 1>the core difference?

82
00:04:13.120 --> 00:04:16.079
<v Speaker 2>That's the key distinction really. C plus plus is often

83
00:04:16.079 --> 00:04:19.079
<v Speaker 2>the choice when performance is absolutely.

84
00:04:18.439 --> 00:04:20.439
<v Speaker 1>Critical, like speed is everything.

85
00:04:20.240 --> 00:04:24.319
<v Speaker 2>Speed, memory usage. Yeah, think high end game engines or

86
00:04:24.360 --> 00:04:27.319
<v Speaker 2>the guts of an operating system, where every millisecond, every

87
00:04:27.319 --> 00:04:30.240
<v Speaker 2>byte counts. C plus plus gives you much a deeper

88
00:04:30.279 --> 00:04:32.319
<v Speaker 2>control over the computer's hardware itself.

89
00:04:32.480 --> 00:04:34.560
<v Speaker 1>Uh okay, more hands on with the.

90
00:04:34.519 --> 00:04:38.439
<v Speaker 2>Machine exactly, something Python doesn't offer to quite the same degree.

91
00:04:39.000 --> 00:04:41.759
<v Speaker 2>So the takeaway from the source, it's that difference in

92
00:04:41.839 --> 00:04:46.079
<v Speaker 2>focus Python four let's say, rapid development and broad application

93
00:04:46.680 --> 00:04:49.240
<v Speaker 2>and C plus plus when you need that high performance

94
00:04:49.279 --> 00:04:51.839
<v Speaker 2>and really granular system level control.

95
00:04:51.959 --> 00:04:55.000
<v Speaker 1>Okay, that clarifies things, so we know why they're powerful.

96
00:04:55.040 --> 00:04:57.439
<v Speaker 1>But like learning anything new, there's going to be a

97
00:04:57.519 --> 00:04:59.800
<v Speaker 1>learning curve, right, absolutely, And the guide spends a good

98
00:04:59.800 --> 00:05:04.560
<v Speaker 1>mine of time on common coding mistakes. Honestly, reading through

99
00:05:04.600 --> 00:05:06.920
<v Speaker 1>it felt a bit like seeing a highlight reel of

100
00:05:06.920 --> 00:05:08.439
<v Speaker 1>my own past coding phase plants.

101
00:05:08.680 --> 00:05:09.519
<v Speaker 2>We've all been there.

102
00:05:09.600 --> 00:05:12.680
<v Speaker 1>It groups them into general pitfalls and then one specific

103
00:05:12.680 --> 00:05:15.959
<v Speaker 1>to Python or C plus plus ways. Like, for instance,

104
00:05:15.959 --> 00:05:18.399
<v Speaker 1>the guide points out that pretty much every programmer stumbles

105
00:05:18.399 --> 00:05:23.399
<v Speaker 1>over basic stuff. They call it x mistake, print y errors.

106
00:05:23.480 --> 00:05:28.240
<v Speaker 2>Yeah, the simple typos forgetting a variable, messing up the syntax, like.

107
00:05:28.199 --> 00:05:30.199
<v Speaker 1>Mixing up ingredients in a recipe, bas exactly.

108
00:05:30.399 --> 00:05:33.240
<v Speaker 2>And a huge one the source really stresses is breaking

109
00:05:33.279 --> 00:05:36.360
<v Speaker 2>down big problems into small chunks.

110
00:05:36.279 --> 00:05:37.519
<v Speaker 1>Right, bite sized pieces.

111
00:05:37.639 --> 00:05:40.079
<v Speaker 2>Yeah, just tackle a massive coding challenge all at once.

112
00:05:40.160 --> 00:05:41.439
<v Speaker 2>It's just overwhelming.

113
00:05:41.639 --> 00:05:42.079
<v Speaker 1>Yeah.

114
00:05:42.120 --> 00:05:46.480
<v Speaker 2>Also, using easy variables, clear descriptive names. You'll thank yourself

115
00:05:46.519 --> 00:05:47.959
<v Speaker 2>later when you have to read your own code.

116
00:05:48.040 --> 00:05:53.160
<v Speaker 3>Oh, definitely readability and speaking of readability, comments non negotiable,

117
00:05:53.480 --> 00:05:55.920
<v Speaker 3>little notes in the code, explaining what's going on, and

118
00:05:55.959 --> 00:05:59.360
<v Speaker 3>planning ahead, having a solid plan before you start typing code.

119
00:05:59.800 --> 00:06:01.199
<v Speaker 2>Hell sire out bugs early.

120
00:06:01.360 --> 00:06:04.439
<v Speaker 1>That sounds proactive, says, headaches down the line a bit

121
00:06:04.600 --> 00:06:05.120
<v Speaker 1>big time.

122
00:06:05.680 --> 00:06:09.399
<v Speaker 2>The guide also mentions anticipating user error. What if someone

123
00:06:09.399 --> 00:06:12.360
<v Speaker 2>types hello when you need a number? Your code needs

124
00:06:12.360 --> 00:06:15.399
<v Speaker 2>to handle that gracefully. Okay, error handling and just good

125
00:06:15.399 --> 00:06:19.800
<v Speaker 2>work habits, backups, keeping data secure. That's fundamental. Oh, and

126
00:06:19.920 --> 00:06:24.000
<v Speaker 2>not reinventing wheels. If a good solution already exists, use it.

127
00:06:24.160 --> 00:06:26.199
<v Speaker 2>Don't build everything from scratch if you don't have to

128
00:06:26.439 --> 00:06:30.680
<v Speaker 2>makes sense, Leverage existing work and finally nowhere to find

129
00:06:30.879 --> 00:06:34.399
<v Speaker 2>help Online communities are great. And double check your maths.

130
00:06:35.000 --> 00:06:37.560
<v Speaker 2>Lots of programs rely on correct calculations.

131
00:06:37.680 --> 00:06:40.959
<v Speaker 1>Right, So this brings up a question, why is this

132
00:06:41.040 --> 00:06:43.519
<v Speaker 1>so important to focus on these mistakes right at the start.

133
00:06:43.639 --> 00:06:46.680
<v Speaker 2>That's a great point. The source really drives home that

134
00:06:46.759 --> 00:06:50.439
<v Speaker 2>seeing these potential pitfalls early isn't about discouraging you. It's

135
00:06:50.519 --> 00:06:54.519
<v Speaker 2>actually your fast track to writing better, cleaner, more reliable

136
00:06:54.560 --> 00:06:57.160
<v Speaker 2>code from the get go. You avoid common.

137
00:06:56.839 --> 00:06:59.360
<v Speaker 1>Traps learn from other's mistakes essentially precisely.

138
00:06:59.680 --> 00:07:02.639
<v Speaker 2>Now, Python being a bit unique with its white space rules.

139
00:07:02.639 --> 00:07:04.680
<v Speaker 1>Oh yes, the indentation exactly.

140
00:07:04.879 --> 00:07:07.480
<v Speaker 2>It has its own set of common beginner hurdles. First

141
00:07:07.759 --> 00:07:11.920
<v Speaker 2>understanding Python two versus Python three still relevant sometimes for

142
00:07:11.959 --> 00:07:16.800
<v Speaker 2>older code bases. Okay, version differences, and most critically indentse

143
00:07:17.160 --> 00:07:21.000
<v Speaker 2>tabs and spaces in Python. How you indent your code

144
00:07:21.040 --> 00:07:24.759
<v Speaker 2>actually defines its structure. Get it wrong, instant errors. It's

145
00:07:24.800 --> 00:07:27.160
<v Speaker 2>like uh, grammar for the computer.

146
00:07:27.120 --> 00:07:29.720
<v Speaker 1>Very strict grammar. H okay, what else for Python?

147
00:07:30.120 --> 00:07:33.560
<v Speaker 2>Other common things Counting loops correctly off by one errors

148
00:07:33.600 --> 00:07:36.480
<v Speaker 2>are classic forgetting the colon at the end of lines

149
00:07:36.560 --> 00:07:40.199
<v Speaker 2>like if or four statements. Remembering Python is case sensitive,

150
00:07:40.279 --> 00:07:41.759
<v Speaker 2>so myvar and myvar are.

151
00:07:41.639 --> 00:07:43.600
<v Speaker 1>Totally different, right, gotta be precise.

152
00:07:43.759 --> 00:07:47.680
<v Speaker 2>Proper use of brackets, parentheses, square brackets, curly braces all

153
00:07:48.000 --> 00:07:52.759
<v Speaker 2>mean different things. And just navigating minor differences across operating systems.

154
00:07:52.879 --> 00:07:56.079
<v Speaker 1>Okay, and C plus plus mistakes. Sounds like it might

155
00:07:56.079 --> 00:07:56.560
<v Speaker 1>be trickier.

156
00:07:56.800 --> 00:07:59.600
<v Speaker 2>It can be, Yeah, its structure is more complex, more explicit.

157
00:07:59.680 --> 00:08:02.240
<v Speaker 2>Begin often trip up on things like void functions.

158
00:08:02.319 --> 00:08:05.079
<v Speaker 1>Void sounds ominous, huh.

159
00:08:04.879 --> 00:08:06.720
<v Speaker 2>Not really, It just means a function that does a

160
00:08:06.800 --> 00:08:09.560
<v Speaker 2>task but doesn't return a specific value back like just

161
00:08:09.680 --> 00:08:13.680
<v Speaker 2>do this, no need to report back. Also undeclared identifiers,

162
00:08:13.680 --> 00:08:15.759
<v Speaker 2>forgetting to define a variable before you use it.

163
00:08:15.920 --> 00:08:18.519
<v Speaker 1>Ah okay, got it, declare things first.

164
00:08:18.319 --> 00:08:22.480
<v Speaker 2>Yep, and not including using namespace STD if you forget that.

165
00:08:22.720 --> 00:08:26.319
<v Speaker 2>You have to type std before every Standard library command,

166
00:08:26.519 --> 00:08:28.879
<v Speaker 2>which gets TD as fast. It teaches you about.

167
00:08:28.680 --> 00:08:31.279
<v Speaker 1>Namespaces, though I see on the classic one.

168
00:08:31.199 --> 00:08:34.600
<v Speaker 2>Missing semi colon's at the end of statements a rite

169
00:08:34.600 --> 00:08:37.080
<v Speaker 2>of passage for C plus plus beginners.

170
00:08:36.879 --> 00:08:39.279
<v Speaker 1>It definitely sounds like C plus plus gives you, uh

171
00:08:40.039 --> 00:08:42.080
<v Speaker 1>maybe more ways to stumble early on.

172
00:08:42.240 --> 00:08:44.879
<v Speaker 2>It can feel that way. The source also mentions things

173
00:08:44.919 --> 00:08:48.240
<v Speaker 2>like compiler issues for Linux users GCC or C plus

174
00:08:48.240 --> 00:08:51.600
<v Speaker 2>plus problems with comments again using too many braces or

175
00:08:51.639 --> 00:08:55.159
<v Speaker 2>forgetting them, getting quotes wrong, not initializing variables.

176
00:08:55.440 --> 00:08:58.120
<v Speaker 1>What happens If you don't initialize a variable, it.

177
00:08:58.039 --> 00:09:00.960
<v Speaker 2>Can end up holding basically random Garbaea data, leading to

178
00:09:01.200 --> 00:09:04.440
<v Speaker 2>really weird unexpected program behavior. So you always want to

179
00:09:04.440 --> 00:09:06.399
<v Speaker 2>give variable as a starting value. And then there are

180
00:09:06.440 --> 00:09:09.679
<v Speaker 2>things like a dot out issues when compiling on Linux.

181
00:09:09.759 --> 00:09:12.879
<v Speaker 1>Okay, so what does all this mean for someone just

182
00:09:12.960 --> 00:09:16.399
<v Speaker 1>starting out feels like a minefield, but the guide seems

183
00:09:16.440 --> 00:09:18.000
<v Speaker 1>to provide the map too exactly.

184
00:09:18.039 --> 00:09:20.080
<v Speaker 2>It highlights the common issues so you can watch out

185
00:09:20.080 --> 00:09:20.519
<v Speaker 2>for them.

186
00:09:20.679 --> 00:09:23.399
<v Speaker 1>Right and speaking and starting out. What gear do you

187
00:09:23.480 --> 00:09:25.200
<v Speaker 1>actually need? Is it expensive?

188
00:09:25.440 --> 00:09:28.840
<v Speaker 2>Thankfully? No, not really to begin with, which is great

189
00:09:28.840 --> 00:09:32.080
<v Speaker 2>news for both Python and C plus plus A. You

190
00:09:32.200 --> 00:09:35.519
<v Speaker 2>mainly just need a computer. Any reasonably modern laptop or

191
00:09:35.519 --> 00:09:36.200
<v Speaker 2>desktop will do.

192
00:09:36.399 --> 00:09:37.679
<v Speaker 1>Okay, just a computer. What else?

193
00:09:37.759 --> 00:09:41.879
<v Speaker 2>An IDE integrated development environment is highly recommended. ID think

194
00:09:41.879 --> 00:09:44.919
<v Speaker 2>of it as your coding command center. It usually combines

195
00:09:44.960 --> 00:09:48.039
<v Speaker 2>a text editor specifically designed for code, a way to

196
00:09:48.120 --> 00:09:51.080
<v Speaker 2>run your code, the compiler or interpreter, and tools to

197
00:09:51.159 --> 00:09:55.200
<v Speaker 2>help find bugs, a debugger. It just makes life easier.

198
00:09:54.840 --> 00:09:56.360
<v Speaker 1>Okay, Any specific ones.

199
00:09:56.600 --> 00:09:59.519
<v Speaker 2>For Python, the guide mentions the built in Python shell

200
00:09:59.639 --> 00:10:02.960
<v Speaker 2>called i dl E. It's simple comes with Python. For

201
00:10:03.080 --> 00:10:06.120
<v Speaker 2>C plus plus AE, you might use something like code

202
00:10:06.120 --> 00:10:08.759
<v Speaker 2>dot blocks which works on Windows and Linux, or x

203
00:10:08.799 --> 00:10:09.480
<v Speaker 2>code if you're.

204
00:10:09.360 --> 00:10:13.159
<v Speaker 1>On a Mac, got it computer IDE anything else.

205
00:10:13.240 --> 00:10:16.399
<v Speaker 2>A basic text editor can be useful sometimes, and definitely

206
00:10:16.399 --> 00:10:18.840
<v Speaker 2>Internet access for looking things up and finding help, But

207
00:10:18.879 --> 00:10:23.120
<v Speaker 2>the guide really emphasizes two intangible things, time and patience.

208
00:10:23.320 --> 00:10:25.320
<v Speaker 2>Learning takes both huh.

209
00:10:24.960 --> 00:10:27.080
<v Speaker 1>Yes, I can imagine time and patience.

210
00:10:27.320 --> 00:10:30.320
<v Speaker 2>And it also mentions the Raspberry Pi is a really cool,

211
00:10:30.480 --> 00:10:33.679
<v Speaker 2>low cost option, especially great for Python projects.

212
00:10:33.720 --> 00:10:37.120
<v Speaker 1>It's good to know very accessible. The guide then gives

213
00:10:37.159 --> 00:10:41.559
<v Speaker 1>set by step set up instructions. Right Python on different systems.

214
00:10:41.240 --> 00:10:45.639
<v Speaker 2>Yep covers Windows, Linux, mac Key things are getting the

215
00:10:45.679 --> 00:10:48.320
<v Speaker 2>right version usually Python three these days, making sure it's

216
00:10:48.360 --> 00:10:50.559
<v Speaker 2>added to your system path so the computer can find

217
00:10:50.600 --> 00:10:53.440
<v Speaker 2>it easily, and getting comfortable with that IDL E shell

218
00:10:53.600 --> 00:10:53.919
<v Speaker 2>and for.

219
00:10:53.960 --> 00:10:56.600
<v Speaker 1>C plus plus D similar process.

220
00:10:56.639 --> 00:10:58.720
<v Speaker 2>Similar but you need to make sure you have a

221
00:10:58.759 --> 00:11:02.080
<v Speaker 2>C plus plus comps installed, which is the tool that

222
00:11:02.159 --> 00:11:05.639
<v Speaker 2>turns your C plus plus code into an executable program.

223
00:11:05.960 --> 00:11:09.840
<v Speaker 2>IDEs like code, dot blocks or xcode usually handles setting that.

224
00:11:09.840 --> 00:11:13.519
<v Speaker 1>Up for you. Okay, so setup is the first hurdle.

225
00:11:13.279 --> 00:11:15.799
<v Speaker 2>Indeed, But once you're set up, the real fun begins

226
00:11:15.840 --> 00:11:17.519
<v Speaker 2>writing your first lines of code.

227
00:11:17.320 --> 00:11:19.960
<v Speaker 1>Right, and for Python, the guide starts you off super simple,

228
00:11:20.039 --> 00:11:21.960
<v Speaker 1>right in the idle shell exactly.

229
00:11:22.000 --> 00:11:24.120
<v Speaker 2>You can just type command straight in. Your very first

230
00:11:24.120 --> 00:11:27.279
<v Speaker 2>code is usually the classic Hello everyone using the print.

231
00:11:27.039 --> 00:11:29.080
<v Speaker 1>Function digital wave to the world.

232
00:11:29.000 --> 00:11:32.240
<v Speaker 2>Precisely, and you can do basic math right there too,

233
00:11:32.320 --> 00:11:35.120
<v Speaker 2>like print two plus two. It just works. The source

234
00:11:35.120 --> 00:11:38.360
<v Speaker 2>shows how Python handles variables for calculations and also for

235
00:11:38.440 --> 00:11:40.879
<v Speaker 2>text or strings, so you can easily do something like

236
00:11:41.000 --> 00:11:44.159
<v Speaker 2>print name plus surname to join text together.

237
00:11:44.320 --> 00:11:45.919
<v Speaker 1>Seems really direct, straightforward.

238
00:11:46.000 --> 00:11:48.799
<v Speaker 2>It is. Then to make your code reusable, you learn

239
00:11:48.879 --> 00:11:50.679
<v Speaker 2>to save it in a file, usually with a dot

240
00:11:50.720 --> 00:11:51.960
<v Speaker 2>pi extension for Python.

241
00:11:52.039 --> 00:11:53.639
<v Speaker 1>Okay, save it as a file, and then you can

242
00:11:53.720 --> 00:11:54.080
<v Speaker 1>run that.

243
00:11:54.039 --> 00:11:57.200
<v Speaker 2>Whole file, either from the idle editor or from your

244
00:11:57.279 --> 00:12:01.480
<v Speaker 2>computer's command line or terminal, like typing pykeon three hello

245
00:12:01.559 --> 00:12:04.360
<v Speaker 2>dot pi would run your saved hello script.

246
00:12:04.480 --> 00:12:07.240
<v Speaker 1>Got it, so, after printing hello, what's next.

247
00:12:07.480 --> 00:12:13.080
<v Speaker 2>Numbers, numbers and expressions. Python handles math pretty elegantly. Normal

248
00:12:13.080 --> 00:12:15.399
<v Speaker 2>division usually gives you a float a number with a

249
00:12:15.440 --> 00:12:16.080
<v Speaker 2>decimal point.

250
00:12:16.200 --> 00:12:18.240
<v Speaker 1>Uh okay, not always a whole number, right.

251
00:12:18.480 --> 00:12:20.960
<v Speaker 2>You also learn about integer division if you only want

252
00:12:20.960 --> 00:12:24.399
<v Speaker 2>the whole number part, the modulo operator for finding remainders,

253
00:12:24.679 --> 00:12:27.519
<v Speaker 2>and using the double asterisk for exponents.

254
00:12:26.960 --> 00:12:30.200
<v Speaker 1>Like powers, the exponents remainders useful stuff.

255
00:12:30.080 --> 00:12:34.039
<v Speaker 2>And booleing expressions things that evaluate to either true or false.

256
00:12:34.480 --> 00:12:37.919
<v Speaker 2>These are the basis of decision making in code. The

257
00:12:37.919 --> 00:12:41.360
<v Speaker 2>guide even touches on converting numbers to binary or octal

258
00:12:41.399 --> 00:12:44.519
<v Speaker 2>formats using special prefixes like zero b.

259
00:12:45.320 --> 00:12:47.519
<v Speaker 1>It feels like you go from zero to doing actual

260
00:12:47.559 --> 00:12:48.720
<v Speaker 1>calculations pretty quickly.

261
00:12:48.799 --> 00:12:52.120
<v Speaker 2>You really do. What's also highlighted again is using comments

262
00:12:52.399 --> 00:12:55.960
<v Speaker 2>that hash symbol hashtag for single lines or triple quotes

263
00:12:55.960 --> 00:12:57.279
<v Speaker 2>for multiline comments.

264
00:12:57.360 --> 00:12:59.240
<v Speaker 1>Right the notes to self or others.

265
00:12:58.960 --> 00:13:02.000
<v Speaker 2>Exactly helps you remember what your code does, helps others

266
00:13:02.039 --> 00:13:04.320
<v Speaker 2>understand it. The guide has that funny quote, oh.

267
00:13:04.279 --> 00:13:06.360
<v Speaker 1>Yeah, the smelly Python experts one huh.

268
00:13:06.799 --> 00:13:10.679
<v Speaker 2>Yes, this is the best game ever developed by a

269
00:13:10.720 --> 00:13:13.639
<v Speaker 2>crack squad of Python experts who haven't slept or washed

270
00:13:13.639 --> 00:13:17.159
<v Speaker 2>in weeks. Despite being very smelly, the code at least

271
00:13:17.200 --> 00:13:18.519
<v Speaker 2>works really well.

272
00:13:18.600 --> 00:13:22.159
<v Speaker 1>It's memorable, kind of humanizes the process, you know, reminds

273
00:13:22.200 --> 00:13:24.080
<v Speaker 1>if people actually write this stuff late nights.

274
00:13:23.919 --> 00:13:27.080
<v Speaker 2>And all totally. After comments, you get into working with variables.

275
00:13:27.120 --> 00:13:31.080
<v Speaker 2>These are just named containers for your data, could be numbers, integers,

276
00:13:31.200 --> 00:13:36.039
<v Speaker 2>text strings, whatever, like labeled boxes perfect analogy. You learn

277
00:13:36.080 --> 00:13:38.679
<v Speaker 2>how to assign values to them, change them, and also

278
00:13:38.799 --> 00:13:42.879
<v Speaker 2>type casting, using functions like int or strer to convert

279
00:13:43.000 --> 00:13:46.360
<v Speaker 2>data from one type to another, like turning text five

280
00:13:46.519 --> 00:13:47.480
<v Speaker 2>into the number five.

281
00:13:47.559 --> 00:13:49.320
<v Speaker 1>Okay, converting types that seems.

282
00:13:49.080 --> 00:13:52.440
<v Speaker 2>Important, very especially when you start getting user input. The

283
00:13:52.519 --> 00:13:56.080
<v Speaker 2>guide introduces the input function for that. But the key

284
00:13:56.120 --> 00:13:59.279
<v Speaker 2>thing is input always gives you back text.

285
00:13:59.000 --> 00:14:01.759
<v Speaker 1>A string always tech even if the user types a

286
00:14:01.840 --> 00:14:02.440
<v Speaker 1>number yep.

287
00:14:02.679 --> 00:14:04.159
<v Speaker 2>So if you want to do math with it, you

288
00:14:04.240 --> 00:14:07.519
<v Speaker 2>have to explicitly convert it, maybe using int or float

289
00:14:07.720 --> 00:14:09.559
<v Speaker 2>for example float input enter the price.

290
00:14:09.639 --> 00:14:13.120
<v Speaker 1>Gotcha convert input if you need numbers. What about making

291
00:14:13.159 --> 00:14:14.000
<v Speaker 1>code reusable?

292
00:14:14.200 --> 00:14:17.320
<v Speaker 2>That's where creating functions comes in. Think of them as

293
00:14:17.320 --> 00:14:20.240
<v Speaker 2>many programs you can call whenever you need them. Python

294
00:14:20.279 --> 00:14:22.440
<v Speaker 2>has built in ones like len to get the length

295
00:14:22.480 --> 00:14:22.919
<v Speaker 2>of a string.

296
00:14:23.000 --> 00:14:24.279
<v Speaker 1>Okay, len for length.

297
00:14:24.159 --> 00:14:26.399
<v Speaker 2>But you learn to define your own functions to bundle

298
00:14:26.480 --> 00:14:28.879
<v Speaker 2>up chunks of code you use often, and you learn

299
00:14:28.919 --> 00:14:32.080
<v Speaker 2>to import modules like the math module to get access

300
00:14:32.080 --> 00:14:35.080
<v Speaker 2>to more advanced functions like squirt for square roots.

301
00:14:35.279 --> 00:14:39.679
<v Speaker 1>Ah. So, functions are like custom tools you build. It

302
00:14:39.720 --> 00:14:43.039
<v Speaker 1>really does feel like building with digital legos. Each function

303
00:14:43.159 --> 00:14:44.840
<v Speaker 1>is a special block you snap together.

304
00:14:44.960 --> 00:14:47.240
<v Speaker 2>That's a great way to put it and connecting this

305
00:14:47.320 --> 00:14:53.480
<v Speaker 2>to the bigger picture. These foundational concepts variables, input, functions, math.

306
00:14:54.480 --> 00:14:58.600
<v Speaker 2>They seem basic, but they are the absolute bedrock. Mastering

307
00:14:58.600 --> 00:15:01.120
<v Speaker 2>them early save so many head later. When you build

308
00:15:01.159 --> 00:15:02.279
<v Speaker 2>more complex.

309
00:15:01.879 --> 00:15:03.799
<v Speaker 1>Things, makes sense. Get the foundation solid.

310
00:15:04.120 --> 00:15:07.759
<v Speaker 2>Finally, in this basic section, the source covers conditions and loops.

311
00:15:08.120 --> 00:15:10.879
<v Speaker 2>This is where your program starts making decisions and repeating action.

312
00:15:11.080 --> 00:15:15.639
<v Speaker 2>The logic part exactly you learn if elif, which is else,

313
00:15:15.679 --> 00:15:19.200
<v Speaker 2>if and else statements. These let your program do different

314
00:15:19.200 --> 00:15:21.360
<v Speaker 2>things based on whether a condition is true or false,

315
00:15:21.600 --> 00:15:25.320
<v Speaker 2>like if age eighteen print adult okay, if this else that,

316
00:15:25.720 --> 00:15:28.200
<v Speaker 2>And for repeating things you get wild loops, which keep

317
00:15:28.240 --> 00:15:30.360
<v Speaker 2>going as long as the condition is true, and four loops,

318
00:15:30.399 --> 00:15:32.639
<v Speaker 2>which are great for going through a sequence of items,

319
00:15:32.679 --> 00:15:34.799
<v Speaker 2>like all the letters in a word or numbers in

320
00:15:34.840 --> 00:15:35.360
<v Speaker 2>a range.

321
00:15:35.440 --> 00:15:37.200
<v Speaker 1>So loops automate repetition.

322
00:15:37.519 --> 00:15:41.960
<v Speaker 2>Precisely, conditions and loops are what make programs dynamic and

323
00:15:42.120 --> 00:15:45.720
<v Speaker 2>well smart. They stop being just a fixed list of instructions.

324
00:15:46.000 --> 00:15:48.840
<v Speaker 1>Building on those foundations, the guide then really dives into

325
00:15:48.879 --> 00:15:52.879
<v Speaker 1>handling data. Right kicks off with that great Steve McConnell quote.

326
00:15:52.799 --> 00:15:56.039
<v Speaker 2>Ah, yeah, it's okay to figure out murder mysteries, but

327
00:15:56.120 --> 00:15:58.200
<v Speaker 2>you shouldn't need to figure out code. You should be

328
00:15:58.200 --> 00:15:58.759
<v Speaker 2>able to read.

329
00:15:58.759 --> 00:16:02.080
<v Speaker 1>It sets the stage perfectly for organizing your data clearly.

330
00:16:02.600 --> 00:16:05.840
<v Speaker 1>First up, it talks about lists, lists.

331
00:16:05.519 --> 00:16:08.679
<v Speaker 2>Are super versatile in Python. Think of them as ordered

332
00:16:08.679 --> 00:16:11.720
<v Speaker 2>collections of items. Could be numbers, strings, even.

333
00:16:11.559 --> 00:16:13.000
<v Speaker 1>Other lists like a shopping list.

334
00:16:13.080 --> 00:16:16.320
<v Speaker 2>Maybe good analogy. Yeah, you learn how to create them,

335
00:16:16.559 --> 00:16:20.120
<v Speaker 2>get items out by their position, index, take slices or

336
00:16:20.159 --> 00:16:22.559
<v Speaker 2>portions of the list, add new items using a pen

337
00:16:23.200 --> 00:16:26.320
<v Speaker 2>stick list together with the plus sign, and remove items too.

338
00:16:26.759 --> 00:16:28.440
<v Speaker 2>They're your flexible container.

339
00:16:28.600 --> 00:16:32.600
<v Speaker 1>Okay, lists are flexible. Then there are tupoles tuples.

340
00:16:32.799 --> 00:16:35.159
<v Speaker 2>They're similar to lists, but the key difference is they

341
00:16:35.200 --> 00:16:36.039
<v Speaker 2>are immutable.

342
00:16:36.320 --> 00:16:38.720
<v Speaker 1>Immutable meaning meaning.

343
00:16:38.399 --> 00:16:41.720
<v Speaker 2>Once you create a tupole, you can't change it. Can't

344
00:16:41.720 --> 00:16:44.960
<v Speaker 2>add items, can't remove items, can't change existing items.

345
00:16:45.200 --> 00:16:47.519
<v Speaker 1>Why would you want that? Seems restrictive.

346
00:16:47.720 --> 00:16:50.919
<v Speaker 2>It's useful when you have data that shouldn't change, like

347
00:16:51.320 --> 00:16:55.600
<v Speaker 2>maybe coordinates x y or fixed settings. It guarantees the

348
00:16:55.679 --> 00:16:58.720
<v Speaker 2>data stays constant. The guide shows how to create them,

349
00:16:58.919 --> 00:17:01.320
<v Speaker 2>access elements, and pack them into variables.

350
00:17:01.480 --> 00:17:04.759
<v Speaker 1>Okay, so lists for changeable stuff tuples for fixed stuff.

351
00:17:04.880 --> 00:17:06.559
<v Speaker 1>Got it? What about dictionaries?

352
00:17:06.839 --> 00:17:11.240
<v Speaker 2>Dictionaries are different again. They store data as key value pairs.

353
00:17:11.079 --> 00:17:13.519
<v Speaker 1>Like a real dictionary, word and definition.

354
00:17:13.720 --> 00:17:16.759
<v Speaker 2>Exactly, you have a unique key like the word that

355
00:17:16.799 --> 00:17:19.599
<v Speaker 2>maps to a value like the definition. It's a really

356
00:17:19.680 --> 00:17:22.079
<v Speaker 2>efficient way to store and look up data when you

357
00:17:22.119 --> 00:17:26.559
<v Speaker 2>know the key. Think user profiles key, username value at

358
00:17:26.559 --> 00:17:27.160
<v Speaker 2>a lovelace.

359
00:17:27.480 --> 00:17:29.319
<v Speaker 1>Ah. I see, so you look things up by key,

360
00:17:29.400 --> 00:17:31.240
<v Speaker 1>not by position like in a list. Right.

361
00:17:31.519 --> 00:17:34.119
<v Speaker 2>The guide shows how to add new key value pairs,

362
00:17:34.240 --> 00:17:36.759
<v Speaker 2>remove them, and update the value associated with a key.

363
00:17:36.880 --> 00:17:38.680
<v Speaker 2>Super useful for structured information.

364
00:17:38.920 --> 00:17:41.519
<v Speaker 1>Makes sense. Then it moves on to handling text more.

365
00:17:42.039 --> 00:17:43.759
<v Speaker 1>Splitting and joining strings.

366
00:17:43.440 --> 00:17:46.400
<v Speaker 2>Yeah, really common tasks. Split lets you take a string,

367
00:17:46.640 --> 00:17:48.519
<v Speaker 2>say a sentence, and break it into a list of

368
00:17:48.519 --> 00:17:51.839
<v Speaker 2>individual words, usually splitting by spaces.

369
00:17:51.599 --> 00:17:53.480
<v Speaker 1>Okay, sends to list of words.

370
00:17:54.000 --> 00:17:57.119
<v Speaker 2>And join does the opposite takes a list of words

371
00:17:57.240 --> 00:18:00.000
<v Speaker 2>and joins them back together into a single string, maybe

372
00:18:00.079 --> 00:18:05.319
<v Speaker 2>putting spaces or commas between them. Fundamental for processing text data.

373
00:18:05.400 --> 00:18:09.440
<v Speaker 1>And formatting strings. That sounds important for making output look

374
00:18:09.480 --> 00:18:10.440
<v Speaker 1>good definitely.

375
00:18:10.799 --> 00:18:14.920
<v Speaker 2>This is about embedding variables or results of calculations smoothly

376
00:18:14.960 --> 00:18:17.960
<v Speaker 2>into your text. Python three has a nice way using

377
00:18:17.960 --> 00:18:21.880
<v Speaker 2>the format method or strings with curly brackets as placeholders, so.

378
00:18:21.839 --> 00:18:24.160
<v Speaker 1>Instead of messy string congatenation.

379
00:18:23.759 --> 00:18:26.799
<v Speaker 2>Exactly, It makes your code cleaner and your output much

380
00:18:26.880 --> 00:18:30.000
<v Speaker 2>nicer for the user. Like printing your score is dot

381
00:18:30.039 --> 00:18:32.799
<v Speaker 2>score instead of juggling plus signs nice?

382
00:18:33.160 --> 00:18:35.119
<v Speaker 1>What about time? Does it cover dates and times?

383
00:18:35.440 --> 00:18:38.440
<v Speaker 2>Yep? Using Python's built in time module, you can get

384
00:18:38.480 --> 00:18:40.960
<v Speaker 2>the current date and time format it in various ways

385
00:18:41.000 --> 00:18:43.720
<v Speaker 2>like day, month, year, or with hours and minutes, and

386
00:18:43.799 --> 00:18:48.319
<v Speaker 2>even calculate differences between times, essential for logging, scheduling, lots

387
00:18:48.319 --> 00:18:49.319
<v Speaker 2>of things, okay.

388
00:18:49.240 --> 00:18:52.279
<v Speaker 1>And data often lives in files. Right. Does it cover

389
00:18:52.359 --> 00:18:53.400
<v Speaker 1>reading and writing files?

390
00:18:53.680 --> 00:18:56.880
<v Speaker 2>Absolutely? The guide walks you through opening files using the

391
00:18:56.920 --> 00:19:00.960
<v Speaker 2>open function than methods like read to get the content,

392
00:19:01.039 --> 00:19:04.519
<v Speaker 2>whether it's plaintext or binary data like images, and.

393
00:19:04.440 --> 00:19:06.160
<v Speaker 1>Writing back out saving results.

394
00:19:06.240 --> 00:19:09.119
<v Speaker 2>Yep. Covers writing to files too, How to open a

395
00:19:09.119 --> 00:19:11.640
<v Speaker 2>file and write mode, use the right method to put

396
00:19:11.759 --> 00:19:16.240
<v Speaker 2>data in, and crucially close the file afterwards to make

397
00:19:16.240 --> 00:19:17.640
<v Speaker 2>sure everything is saved properly.

398
00:19:17.880 --> 00:19:20.640
<v Speaker 1>It really seems like the source emphasizes that data is

399
00:19:20.720 --> 00:19:24.640
<v Speaker 1>central in Python, managing lists, dictionaries, files.

400
00:19:24.720 --> 00:19:28.640
<v Speaker 2>It really is. Python gives you powerful yet relatively straightforward

401
00:19:28.720 --> 00:19:31.200
<v Speaker 2>tools to manage and interact with information in all these

402
00:19:31.200 --> 00:19:31.799
<v Speaker 2>different forms.

403
00:19:32.079 --> 00:19:34.799
<v Speaker 1>But what happens when things go wrong, like you try

404
00:19:34.799 --> 00:19:37.240
<v Speaker 1>to read a file? It isn't there a good question?

405
00:19:37.799 --> 00:19:41.720
<v Speaker 2>That's where exceptions come in Python's way of handling errors gracefully.

406
00:19:41.799 --> 00:19:45.079
<v Speaker 1>Gracefully so the program doesn't just crash ideally.

407
00:19:45.240 --> 00:19:48.160
<v Speaker 2>Know, you learn to use try and accept blocks. You

408
00:19:48.319 --> 00:19:50.480
<v Speaker 2>try the code that might cause an error, and if

409
00:19:50.519 --> 00:19:53.440
<v Speaker 2>it does, the accept block catches that specific error like

410
00:19:53.480 --> 00:19:56.039
<v Speaker 2>a file not found or as your division error, and

411
00:19:56.119 --> 00:19:58.279
<v Speaker 2>lets you handle it, maybe by printing a message or

412
00:19:58.319 --> 00:19:59.160
<v Speaker 2>trying something else.

413
00:19:59.359 --> 00:20:02.759
<v Speaker 1>So you antisy paid problems and plan for them. That's smart.

414
00:20:02.880 --> 00:20:05.759
<v Speaker 2>It's how you build robust, reliable software.

415
00:20:06.079 --> 00:20:10.720
<v Speaker 1>Okay, one last thing in this section. Python graphics sounds fun.

416
00:20:10.880 --> 00:20:13.640
<v Speaker 2>Yeah, it gives a taste of it. The Turtle module

417
00:20:13.720 --> 00:20:16.400
<v Speaker 2>is mentioned. It's a simple, fun way to draw shapes

418
00:20:16.559 --> 00:20:19.759
<v Speaker 2>like circles and squares by commanding a little virtual turtle

419
00:20:19.839 --> 00:20:22.440
<v Speaker 2>on the screen. Great for visual learners.

420
00:20:22.079 --> 00:20:23.680
<v Speaker 1>Turtle graphics, I remember those.

421
00:20:23.640 --> 00:20:27.119
<v Speaker 2>Ah yeah. And for more serious stuff. It introduces the

422
00:20:27.160 --> 00:20:30.240
<v Speaker 2>peg game module that's a popular library for making two

423
00:20:30.319 --> 00:20:32.880
<v Speaker 2>D games and more complex graphical applications.

424
00:20:33.039 --> 00:20:35.160
<v Speaker 1>What kind of things does pig game handle?

425
00:20:35.799 --> 00:20:39.039
<v Speaker 2>Loading images often called sprites in game dev, like your

426
00:20:39.079 --> 00:20:40.519
<v Speaker 2>characters are objects?

427
00:20:40.519 --> 00:20:40.680
<v Speaker 1>Ok.

428
00:20:40.920 --> 00:20:44.960
<v Speaker 2>Handling user input like keyboard presses or mouse clicks for movement,

429
00:20:45.240 --> 00:20:48.720
<v Speaker 2>Drawing things to the screen, playing sounds. It's a gateway

430
00:20:48.799 --> 00:20:51.000
<v Speaker 2>to game development and multimedia in Python.

431
00:20:51.160 --> 00:20:54.960
<v Speaker 1>Cool. So from data structures to air handling to even

432
00:20:55.039 --> 00:20:57.559
<v Speaker 1>drawing pictures, Python seems to cover a lot of ground.

433
00:20:57.799 --> 00:20:59.880
<v Speaker 2>It really does, and a lot of that power comes

434
00:20:59.880 --> 00:21:03.759
<v Speaker 2>from its modularity, which the guide dives into next. What's

435
00:21:03.799 --> 00:21:06.640
<v Speaker 2>fascinating here is this power of modularity. It means you're

436
00:21:06.640 --> 00:21:08.519
<v Speaker 2>not constantly reinventing.

437
00:21:07.920 --> 00:21:10.880
<v Speaker 1>The wheel, right, You build on existing stuff exactly.

438
00:21:11.359 --> 00:21:14.720
<v Speaker 2>You leverage countless pre built tools these modules, and you

439
00:21:14.759 --> 00:21:17.480
<v Speaker 2>can even create your own. It's a core principle for

440
00:21:17.519 --> 00:21:21.720
<v Speaker 2>writing code efficiently. The guide really gets into mastering modules here.

441
00:21:21.839 --> 00:21:24.000
<v Speaker 1>So what are modules? Essentially just pre written code?

442
00:21:24.039 --> 00:21:27.359
<v Speaker 2>Pretty much? There are libraries of functions and tools related

443
00:21:27.359 --> 00:21:30.240
<v Speaker 2>to a specific task. You just import the module into

444
00:21:30.279 --> 00:21:32.799
<v Speaker 2>your script and boom you have access to all its capabilities.

445
00:21:32.960 --> 00:21:34.799
<v Speaker 2>Saves tons of time and effort.

446
00:21:34.599 --> 00:21:36.480
<v Speaker 1>Like adding new tools to your toolbox.

447
00:21:36.599 --> 00:21:40.599
<v Speaker 2>Perfect analogy. For instance, the guide mentions the calendar module.

448
00:21:41.039 --> 00:21:44.319
<v Speaker 2>Need to display a calendar for a specific month or year,

449
00:21:44.440 --> 00:21:46.759
<v Speaker 2>or check a few year is a leap year. Just

450
00:21:46.960 --> 00:21:50.680
<v Speaker 2>import calendar and use its functions. No need to figure

451
00:21:50.680 --> 00:21:52.839
<v Speaker 2>out all that complex date logic yourself.

452
00:21:53.000 --> 00:21:54.519
<v Speaker 1>That's handy. What other examples.

453
00:21:54.559 --> 00:21:57.799
<v Speaker 2>Does it give the OS module. This one's incredibly useful.

454
00:21:57.839 --> 00:22:01.839
<v Speaker 2>It's Python's way of talking to your computer's operating.

455
00:22:01.400 --> 00:22:03.559
<v Speaker 1>System, like telling the computer what to do.

456
00:22:03.799 --> 00:22:05.480
<v Speaker 2>Kind of. If you can find out the current directory

457
00:22:05.519 --> 00:22:09.319
<v Speaker 2>your script is in, os dot get CWD, change directories,

458
00:22:09.400 --> 00:22:14.680
<v Speaker 2>os dot COWR, create new folders, os dot MKDR, rename files,

459
00:22:14.759 --> 00:22:18.160
<v Speaker 2>delete things. It's essential for scripts that need to manage

460
00:22:18.279 --> 00:22:19.240
<v Speaker 2>files and folders.

461
00:22:19.279 --> 00:22:22.319
<v Speaker 1>Okay, so interacting with the filesystem that seems powerful.

462
00:22:22.759 --> 00:22:27.079
<v Speaker 2>It is. Then there's the random module, essential for games, simulations,

463
00:22:27.200 --> 00:22:29.119
<v Speaker 2>or anytime you need unpredictability.

464
00:22:29.319 --> 00:22:30.559
<v Speaker 1>Generating random numbers.

465
00:22:30.640 --> 00:22:33.240
<v Speaker 2>Yeah, random numbers, picking a random item from a list,

466
00:22:33.519 --> 00:22:36.519
<v Speaker 2>shuffling a list into a random order, all sorts of

467
00:22:36.559 --> 00:22:39.000
<v Speaker 2>handy randomization to one, I could see that being useful.

468
00:22:39.039 --> 00:22:43.519
<v Speaker 1>What about making programs look nicer, like with buttons and stuff.

469
00:22:43.200 --> 00:22:47.000
<v Speaker 2>Ah, graphical user interfaces or GUIs. The guide introduces the

470
00:22:47.079 --> 00:22:51.079
<v Speaker 2>tinter module for that. It's Pythons standard built in library

471
00:22:51.119 --> 00:22:55.599
<v Speaker 2>for creating GUIs. It lets you add buttons, textboxes, checkboxes, menus,

472
00:22:55.680 --> 00:22:58.559
<v Speaker 2>all the visual elements people expect in a desktop application.

473
00:22:58.960 --> 00:23:00.880
<v Speaker 2>So your program isn't just a console.

474
00:23:00.960 --> 00:23:04.279
<v Speaker 1>Okay, So tinterer for basic GUIs what about the gaming

475
00:23:04.279 --> 00:23:06.000
<v Speaker 1>one again, pig game, Right.

476
00:23:06.000 --> 00:23:08.920
<v Speaker 2>The guide goes a bit deeper into the pie game module.

477
00:23:09.440 --> 00:23:12.279
<v Speaker 2>It builds on the graphics intro, showing more about setting

478
00:23:12.359 --> 00:23:15.039
<v Speaker 2>up the game window, loading those sprites we talked about,

479
00:23:15.319 --> 00:23:20.119
<v Speaker 2>characters and objects exactly, and crucially handling user input for

480
00:23:20.200 --> 00:23:23.680
<v Speaker 2>interactive control, making a character move when you press arrow keys,

481
00:23:23.720 --> 00:23:27.920
<v Speaker 2>for example. It even demonstrates basic animation like making a

482
00:23:27.920 --> 00:23:30.920
<v Speaker 2>ball bounce or simulating a simple star fuel effect.

483
00:23:31.000 --> 00:23:33.160
<v Speaker 1>Wow, so you can actually make things move on screen

484
00:23:33.200 --> 00:23:34.200
<v Speaker 1>fairly easily.

485
00:23:33.920 --> 00:23:36.680
<v Speaker 2>With libraries like pig game. Yes, it handles a lot

486
00:23:36.680 --> 00:23:39.079
<v Speaker 2>of the low level graphics complexity for you.

487
00:23:39.440 --> 00:23:42.200
<v Speaker 1>That's amazing. Makes creating visual things seem much more.

488
00:23:42.119 --> 00:23:45.720
<v Speaker 2>Achievable definitely, And maybe the most empowering part is that

489
00:23:45.759 --> 00:23:48.200
<v Speaker 2>the source teaches you about creating your own.

490
00:23:48.160 --> 00:23:50.400
<v Speaker 1>Modules, making your own reusable tool.

491
00:23:50.480 --> 00:23:54.680
<v Speaker 2>Precisely as your programs get bigger, you don't want one gigantic,

492
00:23:54.799 --> 00:23:58.559
<v Speaker 2>unmanageable file. You learn to break your code down into logical,

493
00:23:58.680 --> 00:24:02.640
<v Speaker 2>smaller files, your own modules, focusing on specific tasks.

494
00:24:02.200 --> 00:24:06.240
<v Speaker 1>Like one module for handling user data, another for calculations exactly.

495
00:24:06.720 --> 00:24:09.359
<v Speaker 2>Then in your main program you just import the modules

496
00:24:09.440 --> 00:24:12.920
<v Speaker 2>you need. It makes code so much more organized, easier

497
00:24:12.920 --> 00:24:16.079
<v Speaker 2>to test, easier to maintain, and easier to reuse in

498
00:24:16.200 --> 00:24:19.359
<v Speaker 2>other projects. It's fundamental to good software design.

499
00:24:19.480 --> 00:24:21.920
<v Speaker 1>Okay, that makes a lot of sense. So from using

500
00:24:21.920 --> 00:24:25.119
<v Speaker 1>Python's built in tools and third party libraries, we then

501
00:24:25.200 --> 00:24:28.240
<v Speaker 1>shift gears in the guide to C plus plus.

502
00:24:28.400 --> 00:24:31.359
<v Speaker 2>Y right, a different beast in some ways, but built

503
00:24:31.440 --> 00:24:34.519
<v Speaker 2>on many of the same core programming principles.

504
00:24:34.039 --> 00:24:35.759
<v Speaker 1>And the guide takes you right from the start again

505
00:24:35.799 --> 00:24:37.559
<v Speaker 1>your first C plus plus.

506
00:24:37.319 --> 00:24:41.200
<v Speaker 2>Program yep, the classic Hello World, but C plus plus

507
00:24:41.240 --> 00:24:45.599
<v Speaker 2>style using kount HelloWorld dot n probably within an ide

508
00:24:45.799 --> 00:24:48.960
<v Speaker 2>like code dot blocks. It's your entry into this language

509
00:24:49.000 --> 00:24:49.400
<v Speaker 2>known for.

510
00:24:49.359 --> 00:24:51.759
<v Speaker 1>Its speed out instead of print, okay, and.

511
00:24:51.720 --> 00:24:53.960
<v Speaker 2>It immediately breaks down the basic structure of a C

512
00:24:54.079 --> 00:24:56.880
<v Speaker 2>plus plus program. Things you pretty much always need, like

513
00:24:57.039 --> 00:25:00.279
<v Speaker 2>hashtag include iostream, which brings in the library for inputs and.

514
00:25:00.200 --> 00:25:02.720
<v Speaker 1>Output oustream input output stream.

515
00:25:02.480 --> 00:25:07.039
<v Speaker 2>Exactly, and using namespace std which saves you typing std everywhere.

516
00:25:07.079 --> 00:25:09.880
<v Speaker 2>And the int main function that's the mandatory starting point

517
00:25:09.880 --> 00:25:11.960
<v Speaker 2>for every C plus plus program.

518
00:25:12.039 --> 00:25:15.599
<v Speaker 1>Okay, so a bit more setup required than Python simple print, a.

519
00:25:15.559 --> 00:25:16.440
<v Speaker 2>Little more boilerplate.

520
00:25:16.519 --> 00:25:16.759
<v Speaker 1>Yeah.

521
00:25:17.200 --> 00:25:20.559
<v Speaker 2>Then it covers how to compile, and execute. Unlike Python,

522
00:25:20.599 --> 00:25:23.599
<v Speaker 2>which is often interpreted, C plus plus code needs to

523
00:25:23.640 --> 00:25:26.839
<v Speaker 2>be compiled translated into machine code into an executable file

524
00:25:26.960 --> 00:25:28.519
<v Speaker 2>first before you can run it.

525
00:25:28.599 --> 00:25:33.200
<v Speaker 1>Compile first, then run got it? And comments still important

526
00:25:33.279 --> 00:25:34.319
<v Speaker 1>absolutely vital.

527
00:25:34.640 --> 00:25:37.519
<v Speaker 2>C plus plus uses for single line comments similar to

528
00:25:37.559 --> 00:25:42.079
<v Speaker 2>Python's hashtag, and followed by for multiline blocks of comments.

529
00:25:42.799 --> 00:25:45.960
<v Speaker 2>What's fascinating here is how the guide walks you through

530
00:25:46.200 --> 00:25:49.480
<v Speaker 2>C plus plus step by step, really highlighting its power,

531
00:25:49.519 --> 00:25:52.640
<v Speaker 2>but also the key differences from Python right from the beginning.

532
00:25:52.759 --> 00:25:55.319
<v Speaker 1>Yeah, you notice the differences immediately.

533
00:25:55.000 --> 00:25:58.119
<v Speaker 2>Which raises an interesting question. The syntax looks different, sure,

534
00:25:58.319 --> 00:26:00.240
<v Speaker 2>but what similarity is do you start to say? See

535
00:26:00.319 --> 00:26:03.160
<v Speaker 2>in the actual concepts between Python and C plus plus

536
00:26:03.200 --> 00:26:06.440
<v Speaker 2>plus it really points to those universal programming ideas.

537
00:26:06.720 --> 00:26:07.400
<v Speaker 1>Like variables.

538
00:26:07.400 --> 00:26:09.640
<v Speaker 2>They both have variables, right, they do, but in C

539
00:26:09.720 --> 00:26:12.480
<v Speaker 2>plus plus play you have to explicitly declare the variables

540
00:26:12.519 --> 00:26:14.240
<v Speaker 2>data type before you use it.

541
00:26:14.359 --> 00:26:17.839
<v Speaker 1>Unlike Python, where it often figures it out automatically.

542
00:26:17.559 --> 00:26:19.640
<v Speaker 2>Exactly in C plus plus A you have to say,

543
00:26:19.839 --> 00:26:22.640
<v Speaker 2>this is an int integer, this is a float decimal number,

544
00:26:22.680 --> 00:26:26.519
<v Speaker 2>this is a char single character, and so on. The

545
00:26:26.599 --> 00:26:30.119
<v Speaker 2>guide details these fundamental types This choice matters more and

546
00:26:30.200 --> 00:26:33.640
<v Speaker 2>C plus plus because it directly affects memory usage and performance.

547
00:26:34.039 --> 00:26:37.240
<v Speaker 1>Ah, so you're making more deliberate choices about how data

548
00:26:37.279 --> 00:26:38.319
<v Speaker 1>is stored precisely.

549
00:26:38.799 --> 00:26:41.759
<v Speaker 2>String sequences of characters are also handled, though C plus

550
00:26:41.759 --> 00:26:44.039
<v Speaker 2>plus has its own ways of working with them. Compared

551
00:26:44.039 --> 00:26:48.599
<v Speaker 2>to Python and C plus plus maths pretty similar operations additions, subtraction,

552
00:26:48.680 --> 00:26:52.200
<v Speaker 2>et cetera, but you often need to explicitly include the

553
00:26:52.359 --> 00:26:55.400
<v Speaker 2>key map header file to get functions like pow for

554
00:26:55.480 --> 00:26:57.319
<v Speaker 2>powers or square for square roots.

555
00:26:57.359 --> 00:26:59.839
<v Speaker 1>Okay, include cmath for advanced math. How about talking to

556
00:26:59.880 --> 00:27:01.680
<v Speaker 1>the user? Input and output?

557
00:27:01.880 --> 00:27:05.400
<v Speaker 2>C plus plus uses sin c for input and count

558
00:27:05.440 --> 00:27:08.039
<v Speaker 2>see out. For output, you'll see code like sinage to

559
00:27:08.079 --> 00:27:10.960
<v Speaker 2>read input into a variable or cout hello to display

560
00:27:10.960 --> 00:27:13.279
<v Speaker 2>outputs sin in count got it. And for reading whole

561
00:27:13.319 --> 00:27:17.359
<v Speaker 2>lines of text, including spaces, there's get line. The guide

562
00:27:17.400 --> 00:27:21.200
<v Speaker 2>also covers character literals and escape sequences. Those special codes

563
00:27:21.279 --> 00:27:22.880
<v Speaker 2>like N for a new line or t for a

564
00:27:22.880 --> 00:27:27.119
<v Speaker 2>tab used inside strings to control formatting, same idea as

565
00:27:27.119 --> 00:27:29.480
<v Speaker 2>in Python. Just fundamental text control.

566
00:27:29.400 --> 00:27:32.559
<v Speaker 1>Right and for new line and constants values that don't

567
00:27:32.640 --> 00:27:33.519
<v Speaker 1>change yep.

568
00:27:33.599 --> 00:27:36.319
<v Speaker 2>C plus plus has ways to define constants too, using

569
00:27:36.359 --> 00:27:39.640
<v Speaker 2>either hashtag, define, an older preprocessor directive, or the more

570
00:27:39.640 --> 00:27:42.839
<v Speaker 2>modern constant keyword. And just like Python, C plus plus

571
00:27:42.880 --> 00:27:45.880
<v Speaker 2>needs ways to do file input, output, reading from and

572
00:27:45.920 --> 00:27:49.759
<v Speaker 2>writing to files, typically using objects called if stream input

573
00:27:49.799 --> 00:27:52.559
<v Speaker 2>filestream and obstream output filestreams.

574
00:27:52.559 --> 00:27:54.440
<v Speaker 1>The file handling is there too. What about the logic,

575
00:27:54.480 --> 00:27:55.920
<v Speaker 1>loops and decisions.

576
00:27:55.440 --> 00:27:58.319
<v Speaker 2>Same fundamental concepts again. C plus plus has a wile loop,

577
00:27:58.400 --> 00:28:00.960
<v Speaker 2>a four loop, and also adu while, which is slightly

578
00:28:01.000 --> 00:28:03.119
<v Speaker 2>different because it always runs the loop body at least

579
00:28:03.200 --> 00:28:05.319
<v Speaker 2>once before checking the condition okay, do.

580
00:28:05.400 --> 00:28:07.240
<v Speaker 1>Out, while guarantees one run yep.

581
00:28:07.759 --> 00:28:10.960
<v Speaker 2>And for decision making you've got the if statement if

582
00:28:11.000 --> 00:28:13.680
<v Speaker 2>dot else and the if if dot l structure for

583
00:28:13.799 --> 00:28:17.599
<v Speaker 2>handling multiple conditions. The syntax looks different from pythons, but

584
00:28:17.680 --> 00:28:19.880
<v Speaker 2>the logical purpose is exactly the same.

585
00:28:20.359 --> 00:28:23.799
<v Speaker 1>It's really clear that learning one language helps you understand

586
00:28:23.799 --> 00:28:27.039
<v Speaker 1>the core idea is in another, even if the spelling

587
00:28:27.079 --> 00:28:27.519
<v Speaker 1>is different.

588
00:28:27.640 --> 00:28:32.400
<v Speaker 2>Absolutely, the underlying concepts of variables, loops, conditions, functions they

589
00:28:32.440 --> 00:28:33.319
<v Speaker 2>are universal.

590
00:28:33.799 --> 00:28:37.039
<v Speaker 1>So after laying all this groundwork in Python and C

591
00:28:37.160 --> 00:28:40.480
<v Speaker 1>plus plus A, where does the guide suggest you go next?

592
00:28:40.799 --> 00:28:42.880
<v Speaker 1>It can't just end there, right, Learning to code is

593
00:28:42.880 --> 00:28:44.279
<v Speaker 1>ongoing exactly.

594
00:28:44.400 --> 00:28:47.559
<v Speaker 2>It's a continuous journey and the guide emphasizes this strongly,

595
00:28:47.640 --> 00:28:51.519
<v Speaker 2>and it's where to go next section. First point, simply

596
00:28:51.759 --> 00:28:53.160
<v Speaker 2>keep learning, never stop.

597
00:28:53.400 --> 00:28:55.240
<v Speaker 1>Makes sense, tech changes fast.

598
00:28:55.039 --> 00:28:58.079
<v Speaker 2>And engage with the community. It suggests using platforms like

599
00:28:58.119 --> 00:29:00.920
<v Speaker 2>Twitter to follow other developers, get tips, see what people

600
00:29:00.960 --> 00:29:02.720
<v Speaker 2>are working on. Stay connected.

601
00:29:02.839 --> 00:29:05.359
<v Speaker 1>Community is important. What about practicing.

602
00:29:05.119 --> 00:29:07.799
<v Speaker 2>Huge emphasis on practice. One great way is contributing to

603
00:29:08.000 --> 00:29:10.119
<v Speaker 2>open projects open source software.

604
00:29:10.119 --> 00:29:11.200
<v Speaker 1>How does that help you get to.

605
00:29:11.119 --> 00:29:14.960
<v Speaker 2>See real world often large scale code. You learn collaboration.

606
00:29:15.079 --> 00:29:17.720
<v Speaker 2>By working with others, you can make small fixes or

607
00:29:17.759 --> 00:29:21.920
<v Speaker 2>add features, building experience in your portfolio. It's invaluable.

608
00:29:21.960 --> 00:29:24.880
<v Speaker 1>Okay, contributing to open source sounds like a good step.

609
00:29:25.039 --> 00:29:30.880
<v Speaker 2>And fundamentally, keep coding, build things, anything, small projects, fun experiments.

610
00:29:31.160 --> 00:29:35.279
<v Speaker 2>Just keep exercising those coding muscles. Consistency is key, practice

611
00:29:35.279 --> 00:29:39.359
<v Speaker 2>practice practice, also share skills. The guide mentions platforms like

612
00:29:39.359 --> 00:29:43.160
<v Speaker 2>stack Exchange, which includes stack overflow. Helping others solve their

613
00:29:43.200 --> 00:29:45.799
<v Speaker 2>coding problems is actually one of the best ways to

614
00:29:45.839 --> 00:29:47.279
<v Speaker 2>deepen your own understanding.

615
00:29:47.519 --> 00:29:49.599
<v Speaker 1>Teaching reinforces learning precisely.

616
00:29:50.160 --> 00:29:53.599
<v Speaker 2>Then, it suggests exploring new areas like going mobile learning

617
00:29:53.599 --> 00:29:56.799
<v Speaker 2>to develop apps for iOS or Android, or building a

618
00:29:56.799 --> 00:29:58.640
<v Speaker 2>strong portfolio of your projects.

619
00:29:58.720 --> 00:30:02.079
<v Speaker 1>Your portfolio, it's like your proof of skill for jobs, right.

620
00:30:01.960 --> 00:30:05.519
<v Speaker 2>Exactly, it's your digital resume showing what you can actually do.

621
00:30:05.759 --> 00:30:09.319
<v Speaker 2>The guide also mentions leveraging online courses for structured learning

622
00:30:09.359 --> 00:30:13.160
<v Speaker 2>in new areas, and even considering trying to teach code yourself,

623
00:30:13.200 --> 00:30:15.759
<v Speaker 2>maybe to friends or in a local group to solidify

624
00:30:15.799 --> 00:30:16.880
<v Speaker 2>your knowledge.

625
00:30:16.680 --> 00:30:21.200
<v Speaker 4>Teach code interesting idea, and finally share code maybe on

626
00:30:21.279 --> 00:30:25.720
<v Speaker 4>platforms like GitHub, and explore hardware projects using your coding

627
00:30:25.759 --> 00:30:28.319
<v Speaker 4>skills with things like Raspberry Pie or Arduino.

628
00:30:28.480 --> 00:30:30.119
<v Speaker 2>To interact with the physical world.

629
00:30:30.240 --> 00:30:32.400
<v Speaker 1>Wow, lots of avenues to explore.

630
00:30:32.559 --> 00:30:36.319
<v Speaker 2>Yeah, And connecting this to the bigger picture, the guide

631
00:30:36.319 --> 00:30:39.119
<v Speaker 2>doesn't just dump syntax on you and leave. It genuinely

632
00:30:39.240 --> 00:30:44.680
<v Speaker 2>encourages this mindset of lifelong learning, curiosity, and engagement, which

633
00:30:44.720 --> 00:30:46.680
<v Speaker 2>is absolutely vital in technology.

634
00:30:46.720 --> 00:30:48.799
<v Speaker 1>It feels less like an instruction manual and more like

635
00:30:48.839 --> 00:30:50.119
<v Speaker 1>a roadmap for a journey.

636
00:30:50.160 --> 00:30:53.359
<v Speaker 2>Exactly. It brings to mind that quote attributed to Bill

637
00:30:53.400 --> 00:30:56.920
<v Speaker 2>Gates measuring programming progress by lines of code is like

638
00:30:56.920 --> 00:30:58.920
<v Speaker 2>measuring aircraft building progress by.

639
00:30:58.759 --> 00:31:02.119
<v Speaker 1>Weight, Meaning more code isn't always better, right.

640
00:31:02.039 --> 00:31:04.319
<v Speaker 2>It's not about the sheer volume of code you write.

641
00:31:04.319 --> 00:31:07.640
<v Speaker 2>It's about the elegance, the efficiency, the impact, the functionality

642
00:31:07.640 --> 00:31:10.079
<v Speaker 2>of what you create. Quality over quantity.

643
00:31:10.240 --> 00:31:13.519
<v Speaker 1>That's a great perspective. So we've really covered a lot today.

644
00:31:13.519 --> 00:31:17.000
<v Speaker 1>We've taken this deep dive into the pretty fascinating world

645
00:31:17.000 --> 00:31:20.640
<v Speaker 1>of programming, exploring the foundations of Python and c plus

646
00:31:21.079 --> 00:31:23.759
<v Speaker 1>using Python the Complete Guide as our source.

647
00:31:24.720 --> 00:31:27.559
<v Speaker 2>From the basic syntax, navigating those common.

648
00:31:27.240 --> 00:31:29.400
<v Speaker 1>Mistakes, oh yeah, the mistakes.

649
00:31:29.119 --> 00:31:34.880
<v Speaker 2>To handling data with lists, dictionaries, files, using powerful modules,

650
00:31:34.880 --> 00:31:37.240
<v Speaker 2>and understanding the core structures in both languages.

651
00:31:37.440 --> 00:31:40.240
<v Speaker 1>We've seen how these languages really empower you to create

652
00:31:40.279 --> 00:31:45.039
<v Speaker 1>stuff from simple calculations right up to complex graphics, maybe

653
00:31:45.119 --> 00:31:46.440
<v Speaker 1>even full applications.

654
00:31:46.599 --> 00:31:49.680
<v Speaker 2>And it's clear I think that understanding code isn't just

655
00:31:49.720 --> 00:31:53.920
<v Speaker 2>some narrow technical skill anymore. It's really a fundamental way

656
00:31:53.960 --> 00:31:56.519
<v Speaker 2>to approach logical thinking, problem.

657
00:31:56.200 --> 00:31:58.799
<v Speaker 1>Solving, and just bringing ideas to life, right right in

658
00:31:58.799 --> 00:31:59.599
<v Speaker 1>this digital world.

659
00:31:59.480 --> 00:32:01.519
<v Speaker 2>Absolutely bringing ideas to life.

660
00:32:01.680 --> 00:32:05.519
<v Speaker 1>The source emphasizes near the end that once you start learning,

661
00:32:05.559 --> 00:32:09.680
<v Speaker 1>you'll soon be able to create amazing code. So as

662
00:32:09.720 --> 00:32:12.119
<v Speaker 1>you move forward from this deep dive, maybe consider this,

663
00:32:12.519 --> 00:32:16.079
<v Speaker 1>coding isn't just about typing instructions for a machine. It's

664
00:32:16.200 --> 00:32:20.680
<v Speaker 1>really about crafting solutions, expressing creativity, and maybe even shaping

665
00:32:20.720 --> 00:32:23.039
<v Speaker 1>the future a little bit around you. So the question is,

666
00:32:23.079 --> 00:32:25.319
<v Speaker 1>what problem will you solve or what amazing thing will

667
00:32:25.359 --> 00:32:27.279
<v Speaker 1>you create now that you've got a glimpse of these

668
00:32:27.319 --> 00:32:28.119
<v Speaker 1>powerful tools.
