WEBVTT

1
00:00:00.120 --> 00:00:02.720
<v Speaker 1>Imagine you want to build a house, right, and your

2
00:00:02.759 --> 00:00:07.200
<v Speaker 1>contractor just hands you a single atom and says good luck.

3
00:00:07.559 --> 00:00:09.320
<v Speaker 2>Right, Yeah, that sounds like a nightmare.

4
00:00:09.439 --> 00:00:12.960
<v Speaker 1>It is, but honestly, that is exactly what learning a

5
00:00:13.000 --> 00:00:16.039
<v Speaker 1>traditional programming language often feels like. I mean, you open

6
00:00:16.079 --> 00:00:19.679
<v Speaker 1>a textbook, you memorize this giant dictionary of syntacy.

7
00:00:19.760 --> 00:00:23.280
<v Speaker 2>Oh, the semi collins forour loops, the brackets.

8
00:00:22.719 --> 00:00:24.960
<v Speaker 1>Exactly, and then you sit down, you open a blank

9
00:00:25.000 --> 00:00:27.359
<v Speaker 1>document and you're just staring at an empty void.

10
00:00:27.640 --> 00:00:30.600
<v Speaker 2>Yeah, that blank screen is just it's the ultimate barrier

11
00:00:30.640 --> 00:00:32.119
<v Speaker 2>to entry, you know, it really is.

12
00:00:32.399 --> 00:00:35.960
<v Speaker 1>You literally have to teach the computer absolutely everything from

13
00:00:36.000 --> 00:00:38.719
<v Speaker 1>scratch before you can even begin to build your house.

14
00:00:38.719 --> 00:00:41.640
<v Speaker 2>Which is why that information overloads stops so many people

15
00:00:41.719 --> 00:00:44.000
<v Speaker 2>dead in their tracks, like before they even get past

16
00:00:44.039 --> 00:00:47.200
<v Speaker 2>the first chapter. Right, The mental overhead required to just

17
00:00:48.320 --> 00:00:51.640
<v Speaker 2>set up a workspace, let alone execute an actual idea

18
00:00:51.840 --> 00:00:52.640
<v Speaker 2>is staggering.

19
00:00:52.759 --> 00:00:56.600
<v Speaker 1>Well, today we are completely bypassing that blank screen. We

20
00:00:56.679 --> 00:01:00.399
<v Speaker 1>are doing a custom tailored deep dive specifically for you,

21
00:01:00.679 --> 00:01:01.119
<v Speaker 1>the listener.

22
00:01:01.200 --> 00:01:03.679
<v Speaker 2>Yeah, if you're someone who's just insanely curious, this is

23
00:01:03.719 --> 00:01:05.480
<v Speaker 2>for you, exactly.

24
00:01:05.239 --> 00:01:08.560
<v Speaker 1>If you want those brilliant aha moments of understanding how

25
00:01:08.640 --> 00:01:11.120
<v Speaker 1>systems work. But you don't want to drown in the

26
00:01:11.159 --> 00:01:14.400
<v Speaker 1>technical drudgery of computer science. Stick around.

27
00:01:14.560 --> 00:01:16.159
<v Speaker 2>So what's our source material today?

28
00:01:16.599 --> 00:01:19.680
<v Speaker 1>Right? So we are looking at a book called an

29
00:01:19.719 --> 00:01:23.640
<v Speaker 1>Elementary Introduction to the Wolfram Language, written by Stephen Wolfrom

30
00:01:23.680 --> 00:01:24.879
<v Speaker 1>back in twenty seventeen.

31
00:01:25.079 --> 00:01:27.680
<v Speaker 2>You know, calling it a programming manual almost does it

32
00:01:27.680 --> 00:01:28.359
<v Speaker 2>a disservice?

33
00:01:28.840 --> 00:01:30.719
<v Speaker 1>Really? How so? Well?

34
00:01:31.000 --> 00:01:33.120
<v Speaker 2>I mean it's really a ground up introduction to just

35
00:01:33.120 --> 00:01:35.439
<v Speaker 2>a completely different paradigm of computation.

36
00:01:35.560 --> 00:01:38.560
<v Speaker 1>Okay, that makes sense because our mission today is to

37
00:01:38.719 --> 00:01:44.319
<v Speaker 1>explore the core principles of computational thinking, right, but through

38
00:01:44.359 --> 00:01:46.959
<v Speaker 1>the lens of a language that was specifically designed to

39
00:01:47.079 --> 00:01:50.959
<v Speaker 1>automate away the boring, repetitive parts of traditional coding.

40
00:01:51.120 --> 00:01:53.000
<v Speaker 2>Yeah, the drudgery exactly.

41
00:01:53.040 --> 00:01:55.040
<v Speaker 1>Okay, let's unpack this because we have to start with

42
00:01:55.040 --> 00:01:58.920
<v Speaker 1>the fundamental philosophy here. It completely upends how we usually

43
00:01:58.920 --> 00:01:59.560
<v Speaker 1>think about.

44
00:01:59.359 --> 00:02:02.319
<v Speaker 2>Software, really does. We're moving away from the idea of programming,

45
00:02:02.359 --> 00:02:05.359
<v Speaker 2>as you know, just giving blind instructions to a dumb.

46
00:02:05.079 --> 00:02:06.959
<v Speaker 1>Machine, right, a machine that knows nothing.

47
00:02:06.920 --> 00:02:09.960
<v Speaker 2>Exactly, and instead we're looking at programming as a collaboration

48
00:02:10.120 --> 00:02:12.039
<v Speaker 2>with a highly knowledgeable system.

49
00:02:12.400 --> 00:02:16.800
<v Speaker 1>Now, Stephen Wolfram spent what over thirty years developing.

50
00:02:16.319 --> 00:02:19.039
<v Speaker 2>This architecture, Yeah, originating all the way back with a

51
00:02:19.080 --> 00:02:21.560
<v Speaker 2>system called Mathematica in nineteen eighty eight.

52
00:02:21.840 --> 00:02:23.759
<v Speaker 1>Wow, nineteen eighty eight.

53
00:02:24.039 --> 00:02:27.759
<v Speaker 2>Yeah. And the defining characteristic of the wolf from language.

54
00:02:27.840 --> 00:02:31.479
<v Speaker 1>The thing that makes it different from like C plus plus.

55
00:02:31.199 --> 00:02:35.120
<v Speaker 2>Or Java exactly or Python. Yeah, the core trait is

56
00:02:35.120 --> 00:02:38.080
<v Speaker 2>that it is intrinsically quote unquote knowledge based.

57
00:02:38.520 --> 00:02:43.759
<v Speaker 1>Okay, knowledge based sounds a bit like like tech pro

58
00:02:43.960 --> 00:02:45.800
<v Speaker 1>marketing jargon. Honestly it does.

59
00:02:46.080 --> 00:02:46.400
<v Speaker 2>It does.

60
00:02:46.479 --> 00:02:48.560
<v Speaker 1>Let's ground that in reality. What does that actually mean

61
00:02:48.599 --> 00:02:49.439
<v Speaker 1>for the person.

62
00:02:49.159 --> 00:02:53.319
<v Speaker 2>Typing well in a traditional language. The computer is incredibly fast, right,

63
00:02:53.520 --> 00:02:55.439
<v Speaker 2>but it's born completely ignorant of the.

64
00:02:55.400 --> 00:02:57.479
<v Speaker 1>Real world, like a super fast newborn. Yeah.

65
00:02:57.520 --> 00:02:58.960
<v Speaker 2>I mean it knows how to add numbers, and it

66
00:02:59.000 --> 00:03:02.159
<v Speaker 2>knows how to shuttle data back and forth in its memory. Okay,

67
00:03:02.199 --> 00:03:04.080
<v Speaker 2>but if you want that computer to know what the

68
00:03:04.120 --> 00:03:08.360
<v Speaker 2>population of London is, or what the color yellow.

69
00:03:08.000 --> 00:03:10.080
<v Speaker 1>Looks like, or how to turn on a webcam.

70
00:03:09.879 --> 00:03:13.159
<v Speaker 2>Exactly, you have to build that knowledge yourself. You have

71
00:03:13.199 --> 00:03:17.759
<v Speaker 2>to write extensive code or import massive external libraries just

72
00:03:17.879 --> 00:03:20.000
<v Speaker 2>to teach the machine those basic.

73
00:03:19.759 --> 00:03:21.919
<v Speaker 1>Concepts and then you can finally manipulate them.

74
00:03:22.080 --> 00:03:25.479
<v Speaker 2>Right. But the Wolf from Language flips that entirely. It

75
00:03:25.560 --> 00:03:30.479
<v Speaker 2>has this vast encyclopedic amount of real world knowledge built

76
00:03:30.520 --> 00:03:31.800
<v Speaker 2>directly into its.

77
00:03:31.639 --> 00:03:34.319
<v Speaker 1>Core memory, like from the moment you boot it up, from.

78
00:03:34.159 --> 00:03:35.159
<v Speaker 2>The second you boot it up.

79
00:03:35.240 --> 00:03:38.400
<v Speaker 1>Yeah, which means the human sitting at the keyboard has

80
00:03:38.479 --> 00:03:42.879
<v Speaker 1>to explain significantly less to actually get a result exactly.

81
00:03:42.919 --> 00:03:44.759
<v Speaker 2>The computer already knows what you're talking about.

82
00:03:44.840 --> 00:03:46.879
<v Speaker 1>But okay, if you're listening to this, you might be

83
00:03:46.879 --> 00:03:48.919
<v Speaker 1>wondering about the obvious loophole.

84
00:03:48.520 --> 00:03:50.120
<v Speaker 2>Here, the plain English question.

85
00:03:50.520 --> 00:03:54.919
<v Speaker 1>Yeah, if the system already has so much built in knowledge,

86
00:03:55.159 --> 00:03:57.439
<v Speaker 1>why can't I just talk to it in plain English forever?

87
00:03:57.840 --> 00:03:58.719
<v Speaker 2>It's a fair question.

88
00:03:58.800 --> 00:04:00.560
<v Speaker 1>I mean, we already have Wolf from out Alpha right now.

89
00:04:00.680 --> 00:04:02.759
<v Speaker 1>You just type what is the distance to the moon

90
00:04:02.759 --> 00:04:04.680
<v Speaker 1>into a search bar and it gives you the answer.

91
00:04:05.520 --> 00:04:08.960
<v Speaker 1>Why force ourselves to learn as strict new syntax at all?

92
00:04:09.400 --> 00:04:13.960
<v Speaker 2>So Wolf from Alpha is brilliant for quick, isolated queries.

93
00:04:14.680 --> 00:04:18.319
<v Speaker 2>It parses human language incredibly well for those like single

94
00:04:18.360 --> 00:04:19.879
<v Speaker 2>shot questions.

95
00:04:19.399 --> 00:04:21.040
<v Speaker 1>Right, basic trivia or math.

96
00:04:21.279 --> 00:04:24.800
<v Speaker 2>Yeah, but the limitation appears when you want to execute

97
00:04:24.959 --> 00:04:28.079
<v Speaker 2>systematic multi step complexity what.

98
00:04:28.040 --> 00:04:29.560
<v Speaker 1>Does that look like in practice?

99
00:04:29.600 --> 00:04:31.879
<v Speaker 2>Well, imagine you want to take the data from your

100
00:04:31.920 --> 00:04:36.360
<v Speaker 2>first question, feed it into a visual analyzer filter that

101
00:04:36.480 --> 00:04:40.199
<v Speaker 2>visualization based on a live beta feed from a weather satellite.

102
00:04:40.319 --> 00:04:44.279
<v Speaker 2>Oh wow, and then output and interactive dashboard. Plain English

103
00:04:44.360 --> 00:04:48.120
<v Speaker 2>completely breaks down there because it's too messy exactly. Human

104
00:04:48.240 --> 00:04:51.839
<v Speaker 2>language is simply too ambiguous and imprecise to carry an

105
00:04:51.879 --> 00:04:54.399
<v Speaker 2>instruction through that many layers of logic.

106
00:04:54.639 --> 00:04:57.199
<v Speaker 1>The computer would just make a fatal assumption at some point, right.

107
00:04:57.079 --> 00:04:58.720
<v Speaker 2>It would guess what you meant and get it wrong.

108
00:04:58.920 --> 00:05:00.639
<v Speaker 1>I look at it like walking in a restaurant.

109
00:05:01.000 --> 00:05:01.759
<v Speaker 2>Okay, I like this.

110
00:05:02.160 --> 00:05:04.879
<v Speaker 1>Using Plain English with Wolf from Alpha is like ordering

111
00:05:04.920 --> 00:05:07.319
<v Speaker 1>off a menu. Yeah you can get a phenomenal meal,

112
00:05:07.439 --> 00:05:09.759
<v Speaker 1>but you are entirely limited to what the chef has

113
00:05:09.800 --> 00:05:11.920
<v Speaker 1>already decided to put on the menu for that day.

114
00:05:12.000 --> 00:05:14.680
<v Speaker 2>Yeah, you can't ask for something entirely new exactly.

115
00:05:15.279 --> 00:05:18.560
<v Speaker 1>But learning the wolfrom language is like getting the keys

116
00:05:18.879 --> 00:05:21.920
<v Speaker 1>to a world class kitchen, and the computer is your

117
00:05:21.920 --> 00:05:23.199
<v Speaker 1>Michelin star sous chef.

118
00:05:23.480 --> 00:05:25.120
<v Speaker 2>Oh that's a great analogy.

119
00:05:24.839 --> 00:05:29.079
<v Speaker 1>Right, This sious chef already knows the perfect knife techniques.

120
00:05:29.360 --> 00:05:32.920
<v Speaker 1>They have the exact boiling point of every liquid memorized.

121
00:05:32.519 --> 00:05:34.600
<v Speaker 2>But you still have to tell them what to make.

122
00:05:34.920 --> 00:05:38.920
<v Speaker 1>Yes, you need a highly precise system, like a rigid

123
00:05:38.959 --> 00:05:42.279
<v Speaker 1>shorthand to tell the chef exactly how to combine those

124
00:05:42.439 --> 00:05:46.879
<v Speaker 1>raw ingredients to create your own, unique, completely original recipe.

125
00:05:46.959 --> 00:05:49.120
<v Speaker 2>And the beauty of that kitchen scenario is how it

126
00:05:49.199 --> 00:05:51.720
<v Speaker 2>shifts the technical burden. You don't have to worry about

127
00:05:51.720 --> 00:05:54.000
<v Speaker 2>how the stove is wired or how the knife was

128
00:05:54.040 --> 00:05:57.000
<v Speaker 2>forged exactly. You only need to formulate your recipe in

129
00:05:57.079 --> 00:05:58.680
<v Speaker 2>computational terms.

130
00:05:58.399 --> 00:06:00.800
<v Speaker 1>So you're just focusing on the idea, right.

131
00:06:01.079 --> 00:06:03.360
<v Speaker 2>And the source points out that learning this is very

132
00:06:03.439 --> 00:06:06.800
<v Speaker 2>much like learning a human language, just immensely more systematic.

133
00:06:06.839 --> 00:06:08.879
<v Speaker 1>I mean, there are no weird exceptions.

134
00:06:08.399 --> 00:06:12.519
<v Speaker 2>Absolutely none. There are absolutely no irregular verbs to memorize.

135
00:06:12.680 --> 00:06:16.439
<v Speaker 2>Once you understand the core rules, those rules apply universally

136
00:06:16.480 --> 00:06:17.720
<v Speaker 2>across the entire system.

137
00:06:17.959 --> 00:06:21.160
<v Speaker 1>Okay, so how do we actually write this menu? Let's

138
00:06:21.199 --> 00:06:24.079
<v Speaker 1>look at the foundational building blocks of this code. Let's

139
00:06:24.079 --> 00:06:27.160
<v Speaker 1>do it in the wolf From language. Every single action

140
00:06:27.360 --> 00:06:31.519
<v Speaker 1>operates via functions, and there is an unbreakable rule for

141
00:06:31.600 --> 00:06:32.360
<v Speaker 1>these functions.

142
00:06:32.560 --> 00:06:34.319
<v Speaker 2>They always start with a capital letter.

143
00:06:34.240 --> 00:06:39.360
<v Speaker 1>Yes, capital letters, and the arguments the ingredients you are

144
00:06:39.360 --> 00:06:43.040
<v Speaker 1>passing into the function are always enclosed in square brackets.

145
00:06:43.120 --> 00:06:45.439
<v Speaker 2>That's the rigid shorthand you mentioned, right.

146
00:06:45.360 --> 00:06:46.519
<v Speaker 1>So if you want to add two and two, you

147
00:06:46.519 --> 00:06:49.000
<v Speaker 1>don't just use a plus sign. The engine under the

148
00:06:49.040 --> 00:06:52.800
<v Speaker 1>hood is processing the word plus with the capital.

149
00:06:52.480 --> 00:06:54.600
<v Speaker 2>P, then an open scare racket, then.

150
00:06:54.519 --> 00:06:57.240
<v Speaker 1>The numbers two and two, separated by a comma and

151
00:06:57.279 --> 00:06:58.680
<v Speaker 1>a close square bracket. Right.

152
00:06:58.959 --> 00:07:02.160
<v Speaker 2>Or if you need a random number, you use random managure.

153
00:07:01.839 --> 00:07:03.439
<v Speaker 1>With capital R and capital.

154
00:07:03.120 --> 00:07:06.480
<v Speaker 2>I exactly followed by square brackets containing your parameters.

155
00:07:06.680 --> 00:07:10.199
<v Speaker 1>So those functions are essentially the actions, right, they're the verbs,

156
00:07:10.360 --> 00:07:13.560
<v Speaker 1>and they need materials to act upon. And the fundamental

157
00:07:13.560 --> 00:07:16.000
<v Speaker 1>way to group materials in this language is a.

158
00:07:15.959 --> 00:07:19.199
<v Speaker 2>List, right, And lists are enclosed in curly braces.

159
00:07:19.519 --> 00:07:23.279
<v Speaker 1>Okay, curly braces. Something like open curly brace one, two, three,

160
00:07:23.480 --> 00:07:26.120
<v Speaker 1>close curly brace is a fully formed.

161
00:07:25.879 --> 00:07:29.000
<v Speaker 2>List, it is, And once you have items bundled in

162
00:07:29.000 --> 00:07:32.839
<v Speaker 2>those curly braces, you can deploy your capital letter functions

163
00:07:32.839 --> 00:07:33.720
<v Speaker 2>to manipulate them.

164
00:07:33.920 --> 00:07:36.839
<v Speaker 1>So you can use a function like range to automatically

165
00:07:36.920 --> 00:07:39.319
<v Speaker 1>generate a massive list of numbers. You don't have to

166
00:07:39.360 --> 00:07:40.439
<v Speaker 1>type them by hand.

167
00:07:40.199 --> 00:07:41.120
<v Speaker 2>Which is a life saver.

168
00:07:41.399 --> 00:07:44.160
<v Speaker 1>Yeah, and you can deploy the reverse function to flip

169
00:07:44.160 --> 00:07:45.680
<v Speaker 1>the entire list backward, or.

170
00:07:46.040 --> 00:07:49.279
<v Speaker 2>Use join to snap two completely different lists together.

171
00:07:49.439 --> 00:07:51.480
<v Speaker 1>And you can get surgical with it too. You can

172
00:07:51.519 --> 00:07:53.959
<v Speaker 1>ask for just the first item the last item, or

173
00:07:54.079 --> 00:07:57.319
<v Speaker 1>use the part function to extract the exact element sitting

174
00:07:57.399 --> 00:07:59.160
<v Speaker 1>at say position number forty two.

175
00:07:59.319 --> 00:08:02.000
<v Speaker 2>Yeah, you can even dismantle a single number, which I love.

176
00:08:02.120 --> 00:08:03.199
<v Speaker 1>Wait, how does that work?

177
00:08:03.319 --> 00:08:06.839
<v Speaker 2>You apply the integer digits function to let's say the

178
00:08:06.920 --> 00:08:09.639
<v Speaker 2>year nineteen eighty eight, it shatters it into a list

179
00:08:09.639 --> 00:08:12.079
<v Speaker 2>containing a one, A nine, and eight and an eight.

180
00:08:12.279 --> 00:08:14.279
<v Speaker 1>Oh wow, why would you need to do that?

181
00:08:14.519 --> 00:08:18.079
<v Speaker 2>Breaking integers down like that is a surprisingly powerful technique

182
00:08:18.079 --> 00:08:20.600
<v Speaker 2>when you're hunting for hidden patterns and large data sets.

183
00:08:20.920 --> 00:08:23.480
<v Speaker 1>That makes sense. But I have to challenge this swict

184
00:08:23.519 --> 00:08:24.600
<v Speaker 1>syntax for a second though.

185
00:08:24.639 --> 00:08:24.920
<v Speaker 2>Oh kay?

186
00:08:24.959 --> 00:08:28.639
<v Speaker 1>Bringing on if I type plus with a lowercase P,

187
00:08:29.399 --> 00:08:32.279
<v Speaker 1>or if I accidentally use parentheses instead of square brackets

188
00:08:32.320 --> 00:08:35.120
<v Speaker 1>to contain my numbers. Yeah, the system just throws an

189
00:08:35.159 --> 00:08:35.480
<v Speaker 1>air or.

190
00:08:35.600 --> 00:08:38.320
<v Speaker 2>It does read text everywhere it stares.

191
00:08:38.000 --> 00:08:41.159
<v Speaker 1>Back at me as red text. If the software is

192
00:08:41.200 --> 00:08:44.720
<v Speaker 1>supposed to be so incredibly smart and knowledgeable, shouldn't be

193
00:08:44.759 --> 00:08:46.360
<v Speaker 1>able to infer what I mean?

194
00:08:46.679 --> 00:08:50.320
<v Speaker 2>It feels frustrating at first. I know, but that strictness

195
00:08:50.360 --> 00:08:54.840
<v Speaker 2>exists for a critical architectural reason, which is think about

196
00:08:54.840 --> 00:08:58.720
<v Speaker 2>how we use parentheses in standard mathematics. We use them

197
00:08:58.759 --> 00:09:00.159
<v Speaker 2>strictly for grouping.

198
00:09:00.159 --> 00:09:02.519
<v Speaker 1>Like writing out two plus three four to ensure the

199
00:09:02.559 --> 00:09:03.639
<v Speaker 1>addition happens first.

200
00:09:03.799 --> 00:09:06.679
<v Speaker 2>Exactly if the woolf From language allowed you to use

201
00:09:06.720 --> 00:09:10.519
<v Speaker 2>parentheses for functions as well, the system would face massive

202
00:09:10.559 --> 00:09:12.720
<v Speaker 2>ambiguity every time it read a line of code.

203
00:09:12.759 --> 00:09:14.799
<v Speaker 1>Oh, I see, it wouldn't know if you were grouping

204
00:09:14.840 --> 00:09:17.200
<v Speaker 1>a mathematical operation or trying to execute.

205
00:09:16.840 --> 00:09:22.200
<v Speaker 2>A command precisely. By rigidly separating square brackets for functions,

206
00:09:22.639 --> 00:09:27.200
<v Speaker 2>curly braces for lists, and parentheses for math, the language

207
00:09:27.200 --> 00:09:31.720
<v Speaker 2>can process infantly complex nested structures without ever getting confused.

208
00:09:31.840 --> 00:09:34.080
<v Speaker 1>That makes total sense. It's almost like a factory floor.

209
00:09:34.159 --> 00:09:35.240
<v Speaker 2>A factory floor.

210
00:09:35.320 --> 00:09:38.639
<v Speaker 1>Yeah, think about it. The functions those capital letter square

211
00:09:38.639 --> 00:09:42.919
<v Speaker 1>bracket commands are highly specialized machines, okay, and the lists

212
00:09:43.120 --> 00:09:46.799
<v Speaker 1>the curly brace structures are the conveyor belts transporting raw

213
00:09:46.840 --> 00:09:48.720
<v Speaker 1>materials between those machines. Oh.

214
00:09:48.759 --> 00:09:49.240
<v Speaker 2>I like that.

215
00:09:49.360 --> 00:09:52.399
<v Speaker 1>The syntax has to be strict because the raw materials

216
00:09:52.480 --> 00:09:57.039
<v Speaker 1>must be inserted into the machine in the exact correct orientation.

217
00:09:56.720 --> 00:10:00.360
<v Speaker 2>Or the entire assembly line DRAMs exactly, that factory visualzation

218
00:10:00.480 --> 00:10:03.200
<v Speaker 2>hits the nail on the head. But we need to

219
00:10:03.279 --> 00:10:07.240
<v Speaker 2>explore the real genius of the materials on those conveyor belts.

220
00:10:07.279 --> 00:10:07.720
<v Speaker 1>What do you mean?

221
00:10:07.879 --> 00:10:11.679
<v Speaker 2>This is the core reason the entire architecture functions so seamlessly.

222
00:10:12.120 --> 00:10:14.879
<v Speaker 2>The Wolf Firm language is fundamentally from the ground up,

223
00:10:14.919 --> 00:10:16.279
<v Speaker 2>a symbolic language.

224
00:10:16.360 --> 00:10:19.320
<v Speaker 1>A symbolic language. Let's break symbolic depth. What does that

225
00:10:19.399 --> 00:10:21.759
<v Speaker 1>actually mean when you are sitting at the keyboard.

226
00:10:22.000 --> 00:10:25.559
<v Speaker 2>So in a conventional coding language, you use arrays, which

227
00:10:25.559 --> 00:10:28.600
<v Speaker 2>are basically their version of lists, but you generally have

228
00:10:28.679 --> 00:10:31.200
<v Speaker 2>to declare what kind of data that array is allowed

229
00:10:31.240 --> 00:10:34.360
<v Speaker 2>to hold. You have to explicitly warn the computer this

230
00:10:34.480 --> 00:10:37.360
<v Speaker 2>array will only hold integers, or this array will only

231
00:10:37.399 --> 00:10:38.879
<v Speaker 2>old text.

232
00:10:38.679 --> 00:10:41.120
<v Speaker 1>So the computer can allocate the right amount of memory.

233
00:10:41.159 --> 00:10:44.639
<v Speaker 2>Exactly, it allocates memory based on those strict data types.

234
00:10:45.159 --> 00:10:49.200
<v Speaker 2>But in a symbolic language, a list can hold absolutely anything,

235
00:10:49.240 --> 00:10:52.360
<v Speaker 2>anything at all. Anything. The system doesn't care about rigid

236
00:10:52.399 --> 00:10:55.440
<v Speaker 2>data types because it treats everything simply as a symbol.

237
00:10:55.559 --> 00:10:56.679
<v Speaker 1>Okay, give me an example.

238
00:10:56.799 --> 00:10:59.720
<v Speaker 2>A list can hold numbers, It can hold text, It

239
00:10:59.759 --> 00:11:04.480
<v Speaker 2>can hold completely undefined algebraic variables like just an A,

240
00:11:04.720 --> 00:11:07.240
<v Speaker 2>B and a C without defining what A is, right,

241
00:11:07.320 --> 00:11:09.720
<v Speaker 2>it just treats it as the symbol A. And it

242
00:11:09.759 --> 00:11:13.440
<v Speaker 2>can even hold fully formed geometric graphs, three D spheres,

243
00:11:13.559 --> 00:11:14.519
<v Speaker 2>and audio.

244
00:11:14.159 --> 00:11:16.080
<v Speaker 1>Clips wait all mixed together, all.

245
00:11:15.960 --> 00:11:18.440
<v Speaker 2>Mixed together in the exact same list at the same time.

246
00:11:18.679 --> 00:11:21.440
<v Speaker 1>So my conveyor belt could literally be carrying a list

247
00:11:21.480 --> 00:11:24.480
<v Speaker 1>that contains the number one, the color red, a photograph

248
00:11:24.480 --> 00:11:27.679
<v Speaker 1>of a cat, and an interactive pie chart, all sitting

249
00:11:27.799 --> 00:11:28.799
<v Speaker 1>right next to each other.

250
00:11:28.879 --> 00:11:32.600
<v Speaker 2>Precisely to the Wolfram engine. They are all just symbolic

251
00:11:32.679 --> 00:11:34.519
<v Speaker 2>expressions being passed along the belt.

252
00:11:34.600 --> 00:11:35.399
<v Speaker 1>That is wild.

253
00:11:35.559 --> 00:11:39.200
<v Speaker 2>It's a massive departure from traditional computer science, and it's

254
00:11:39.240 --> 00:11:42.960
<v Speaker 2>the underlying secret that makes the language so deeply flexible.

255
00:11:43.200 --> 00:11:46.919
<v Speaker 1>Okay, so we have a factory running smoothly moving abstract

256
00:11:46.919 --> 00:11:50.480
<v Speaker 1>symbols along a belt. But computation is useless if human

257
00:11:50.519 --> 00:11:52.240
<v Speaker 1>brains can't comprehend the output.

258
00:11:52.559 --> 00:11:54.879
<v Speaker 2>Right, A massive list of one thousand numbers on a

259
00:11:54.919 --> 00:11:56.879
<v Speaker 2>screen is just exhausting to look at.

260
00:11:57.000 --> 00:11:59.480
<v Speaker 1>We need to see it. Well, how does the language

261
00:11:59.480 --> 00:12:02.840
<v Speaker 1>turn raw awe abstract symbols into something visual.

262
00:12:03.000 --> 00:12:07.080
<v Speaker 2>Well, the language is designed to make visualization almost comically effortless.

263
00:12:07.080 --> 00:12:09.120
<v Speaker 1>Comical effortless, I'll be the judge of that.

264
00:12:09.200 --> 00:12:11.279
<v Speaker 2>I mean it. If you have that massive list of numbers,

265
00:12:11.320 --> 00:12:13.600
<v Speaker 2>you don't need to write a rendoing engine, Okay, you

266
00:12:13.639 --> 00:12:17.240
<v Speaker 2>simply pass that list through a function called list line plot,

267
00:12:17.519 --> 00:12:20.600
<v Speaker 2>and instantly you have a fully rendered chart just one word,

268
00:12:20.919 --> 00:12:23.879
<v Speaker 2>one word. You can pass it through barchart or pie

269
00:12:23.960 --> 00:12:24.960
<v Speaker 2>chart just as easily.

270
00:12:25.360 --> 00:12:28.639
<v Speaker 1>Actually, the source notes a brilliant little detail about the

271
00:12:28.639 --> 00:12:32.039
<v Speaker 1>pie chart function that really highlights the built in intelligence.

272
00:12:32.159 --> 00:12:33.559
<v Speaker 2>Oh, the nine o'clock rule.

273
00:12:33.840 --> 00:12:38.279
<v Speaker 1>Yes, when you execute that command, the language automatically knows

274
00:12:38.320 --> 00:12:41.639
<v Speaker 1>to start the very first wedge of the pie exactly

275
00:12:41.639 --> 00:12:44.720
<v Speaker 1>at the nine o'clock position and read clockwise. It's just a.

276
00:12:44.720 --> 00:12:46.759
<v Speaker 2>Standard design principle, but it knows it by.

277
00:12:46.679 --> 00:12:50.519
<v Speaker 1>Default, and it autonomously selects a highly readable sequence of

278
00:12:50.559 --> 00:12:53.159
<v Speaker 1>colors for the wedges. You didn't have to code the

279
00:12:53.200 --> 00:12:56.600
<v Speaker 1>geometry of a circle, calculate the angles of the wedges,

280
00:12:56.759 --> 00:12:59.159
<v Speaker 1>or like define the hex codes for the colors.

281
00:12:59.279 --> 00:13:01.360
<v Speaker 2>Right, the system is inherently knows what a good pie

282
00:13:01.399 --> 00:13:02.399
<v Speaker 2>chart is supposed to look like.

283
00:13:02.440 --> 00:13:03.320
<v Speaker 1>I save so much time.

284
00:13:03.440 --> 00:13:07.159
<v Speaker 2>It does. And speaking of colors, they're treated as computational objects,

285
00:13:07.240 --> 00:13:08.399
<v Speaker 2>not just text labels.

286
00:13:08.440 --> 00:13:11.000
<v Speaker 1>So you don't type the word red as a string

287
00:13:11.039 --> 00:13:11.559
<v Speaker 1>in quotes.

288
00:13:11.679 --> 00:13:13.919
<v Speaker 2>No, you use it as a standalone symbol. You just

289
00:13:14.000 --> 00:13:16.120
<v Speaker 2>evaluate red with a capital R.

290
00:13:16.399 --> 00:13:16.879
<v Speaker 1>Wow.

291
00:13:17.000 --> 00:13:20.120
<v Speaker 2>You can pass colors into a function like blend, handing

292
00:13:20.200 --> 00:13:23.159
<v Speaker 2>it a list of yellow, pink, and green, and it

293
00:13:23.240 --> 00:13:26.039
<v Speaker 2>mathematically computes the resulting mixture.

294
00:13:25.919 --> 00:13:27.639
<v Speaker 1>So it blends the colors like actual paint.

295
00:13:27.720 --> 00:13:30.120
<v Speaker 2>Exactly. You can run color negate on the symbol yellow

296
00:13:30.399 --> 00:13:33.039
<v Speaker 2>and the system instantly outputs a blue square.

297
00:13:33.159 --> 00:13:36.679
<v Speaker 1>Okay, But to really take advantage of visualization, you need

298
00:13:36.720 --> 00:13:39.320
<v Speaker 1>a way to generate large amounts of structured data on

299
00:13:39.360 --> 00:13:41.600
<v Speaker 1>the fly. Right. You don't want to type out one

300
00:13:41.600 --> 00:13:43.720
<v Speaker 1>thousand numbers manually just to make a chart.

301
00:13:43.919 --> 00:13:47.279
<v Speaker 2>No, nobody wants to do that. For that, the text

302
00:13:47.399 --> 00:13:49.279
<v Speaker 2>introduces the table function.

303
00:13:49.559 --> 00:13:52.759
<v Speaker 1>Okay. The table function uses something called an iterator, which

304
00:13:52.840 --> 00:13:55.559
<v Speaker 1>honestly sounds incredibly intimidating to a newcomer.

305
00:13:55.679 --> 00:13:57.159
<v Speaker 2>It sounds like math jargon.

306
00:13:57.399 --> 00:14:01.039
<v Speaker 1>It does. If I type table open breads and squared,

307
00:14:01.440 --> 00:14:06.480
<v Speaker 1>comma open curly brace and comma ten close curly brace,

308
00:14:06.679 --> 00:14:10.159
<v Speaker 1>close bracket, what is actually happening inside the machine.

309
00:14:10.200 --> 00:14:12.799
<v Speaker 2>Okay, an iterator is really just a set of instructions

310
00:14:12.799 --> 00:14:15.720
<v Speaker 2>for counting discounting. Yeah, the system looks at the variable

311
00:14:15.759 --> 00:14:18.519
<v Speaker 2>you've chosen, which is N. The iterator is the part

312
00:14:18.559 --> 00:14:22.000
<v Speaker 2>inside the curly braces N Tenkay. It's basically telling the

313
00:14:22.039 --> 00:14:25.279
<v Speaker 2>engine take this variable, end, start its value at one,

314
00:14:25.399 --> 00:14:28.159
<v Speaker 2>and count up to ten. And for every single one

315
00:14:28.200 --> 00:14:30.919
<v Speaker 2>of those ten steps, it executes the first part of

316
00:14:30.919 --> 00:14:34.320
<v Speaker 2>your instruction. It calculates N squared, So.

317
00:14:34.360 --> 00:14:37.519
<v Speaker 1>In a fraction of a second, it computes one, four, nine, sixteen,

318
00:14:37.720 --> 00:14:39.279
<v Speaker 1>all the way to one hundred exactly.

319
00:14:39.519 --> 00:14:41.879
<v Speaker 2>It bundles them into a neat list on your conveyor

320
00:14:41.879 --> 00:14:43.120
<v Speaker 2>belt and hands them back to you.

321
00:14:43.279 --> 00:14:46.399
<v Speaker 1>Generating data is great, and charting it is even better.

322
00:14:46.759 --> 00:14:49.159
<v Speaker 1>But what if we want to physically interact with that data?

323
00:14:49.240 --> 00:14:50.360
<v Speaker 2>This is my favorite part.

324
00:14:50.559 --> 00:14:53.919
<v Speaker 1>The text introduces a function called manipulate, and this is

325
00:14:53.919 --> 00:14:55.559
<v Speaker 1>where the entire paradigm shifts.

326
00:14:55.639 --> 00:14:56.399
<v Speaker 2>It really does.

327
00:14:56.519 --> 00:14:58.639
<v Speaker 1>If you take any piece of code, let's say a

328
00:14:58.679 --> 00:15:02.279
<v Speaker 1>table generating a series of orange squares, and you wrap

329
00:15:02.320 --> 00:15:05.879
<v Speaker 1>the manipulate function around it, you instantly magically have a

330
00:15:05.960 --> 00:15:06.720
<v Speaker 1>user interface.

331
00:15:06.919 --> 00:15:10.360
<v Speaker 2>Yeah, you pass it manipulate, then your code, then the

332
00:15:10.399 --> 00:15:12.039
<v Speaker 2>parameters for a slider.

333
00:15:11.960 --> 00:15:15.399
<v Speaker 1>And instead of spitting out a static, unchanging image of orange.

334
00:15:15.120 --> 00:15:18.679
<v Speaker 2>Squares, the system outputs a graphical slider on your screen,

335
00:15:19.240 --> 00:15:21.519
<v Speaker 2>and as you click and drag that slider back and

336
00:15:21.559 --> 00:15:24.120
<v Speaker 2>forth from one to five, the number of orange squares

337
00:15:24.200 --> 00:15:27.039
<v Speaker 2>drawn on your screen actively grows and shrinks in real time.

338
00:15:27.399 --> 00:15:31.639
<v Speaker 1>It completely reframes the coding experience. I mean, traditional coding

339
00:15:31.720 --> 00:15:34.279
<v Speaker 1>is like setting up a photograph. How so well you

340
00:15:34.360 --> 00:15:38.200
<v Speaker 1>meticulously arrange your subjects, You calculate the lighting, you hit

341
00:15:38.240 --> 00:15:39.279
<v Speaker 1>the shutter button.

342
00:15:39.120 --> 00:15:41.440
<v Speaker 2>Which is the equivalent of compiling your code.

343
00:15:41.200 --> 00:15:45.919
<v Speaker 1>Exactly, and you get a static, permanent picture. If you

344
00:15:46.000 --> 00:15:48.759
<v Speaker 1>realize you want one subject move slightly to the left,

345
00:15:49.080 --> 00:15:52.759
<v Speaker 1>you have to rearrange the entire physical scene, recompile the code,

346
00:15:52.879 --> 00:15:54.600
<v Speaker 1>and take a whole new photograph.

347
00:15:54.639 --> 00:15:58.679
<v Speaker 2>That's a really accurate description of traditional UI development, right.

348
00:15:58.799 --> 00:16:01.519
<v Speaker 1>But wrapping your code in manipulate is like sculpting with

349
00:16:01.559 --> 00:16:02.159
<v Speaker 1>wet clay.

350
00:16:02.320 --> 00:16:03.080
<v Speaker 2>Oh I like that.

351
00:16:03.399 --> 00:16:06.879
<v Speaker 1>You drag a slider and instantly watch how changing one

352
00:16:06.960 --> 00:16:10.240
<v Speaker 1>single variable alters the slope of an entire.

353
00:16:10.000 --> 00:16:13.519
<v Speaker 2>Bar chart, or modifies the hue of a three D sphere.

354
00:16:13.240 --> 00:16:15.240
<v Speaker 1>Or adjusts the radius of a geometric cone.

355
00:16:15.399 --> 00:16:19.039
<v Speaker 2>It's fluid, and the sheer amount of engineering automated away

356
00:16:19.120 --> 00:16:21.840
<v Speaker 2>by that single command is staggering. I can imagine I mean,

357
00:16:21.879 --> 00:16:24.919
<v Speaker 2>in almost any other widespread language, building a user interface

358
00:16:24.960 --> 00:16:28.559
<v Speaker 2>with a functioning slider that dynamically updates a graphic that

359
00:16:28.679 --> 00:16:31.519
<v Speaker 2>requires hundreds of lines of tdsuy code.

360
00:16:31.320 --> 00:16:32.039
<v Speaker 1>Just for a slider.

361
00:16:32.240 --> 00:16:36.000
<v Speaker 2>Oh yeah, you have to write event listeners to detect

362
00:16:36.000 --> 00:16:38.759
<v Speaker 2>the mouse click. You have to manage state changes in

363
00:16:38.759 --> 00:16:42.039
<v Speaker 2>the computer's memory. You have to build render loops to

364
00:16:42.159 --> 00:16:45.039
<v Speaker 2>redraw the graphics sixty times a second so the animation

365
00:16:45.120 --> 00:16:45.799
<v Speaker 2>looks smooth.

366
00:16:46.200 --> 00:16:47.200
<v Speaker 1>And in this system.

367
00:16:47.279 --> 00:16:50.240
<v Speaker 2>In this system, all of that infrastructure is handled invisibly.

368
00:16:50.799 --> 00:16:53.879
<v Speaker 2>You are freed up to simply explore the parameter space

369
00:16:53.919 --> 00:16:57.399
<v Speaker 2>of your problem interactively without ever breaking your train of thought.

370
00:16:57.559 --> 00:17:00.440
<v Speaker 1>Okay, so we've built an incredible theoretical tool kid. So

371
00:17:00.480 --> 00:17:03.879
<v Speaker 1>far we can generate numbers, plot them, and interact with

372
00:17:03.879 --> 00:17:07.440
<v Speaker 1>geometric shapes the basics, but pure math can feel a

373
00:17:07.480 --> 00:17:11.079
<v Speaker 1>bit sterile. Let's look at how this language handles the messy,

374
00:17:11.319 --> 00:17:15.559
<v Speaker 1>unstructured reality of the physical world. Specifically, how does it

375
00:17:15.599 --> 00:17:17.960
<v Speaker 1>compute images in human language.

376
00:17:18.359 --> 00:17:20.640
<v Speaker 2>This is where the built in knowledge base really flexes

377
00:17:20.680 --> 00:17:23.799
<v Speaker 2>its muscles. Let's look at image processing first. Okay, to

378
00:17:23.880 --> 00:17:26.759
<v Speaker 2>this language, a photograph isn't just a static file sitting

379
00:17:26.759 --> 00:17:29.200
<v Speaker 2>in a folder. It is an active data set ready

380
00:17:29.240 --> 00:17:30.039
<v Speaker 2>to be computed.

381
00:17:30.160 --> 00:17:32.640
<v Speaker 1>So you can open your notebook and type current image

382
00:17:32.680 --> 00:17:34.519
<v Speaker 1>with empty square brackets and it.

383
00:17:34.480 --> 00:17:37.759
<v Speaker 2>Will instantly pull a live frame from your computer's webcam

384
00:17:38.079 --> 00:17:38.480
<v Speaker 2>just like that.

385
00:17:38.680 --> 00:17:41.480
<v Speaker 1>Yeah, and because we were in a symbolic system, you

386
00:17:41.480 --> 00:17:44.640
<v Speaker 1>can apply math like functions directly to the pixels of

387
00:17:44.640 --> 00:17:45.119
<v Speaker 1>your face.

388
00:17:45.440 --> 00:17:48.960
<v Speaker 2>Exactly. You can pass the image through pellernegate to get

389
00:17:49.000 --> 00:17:51.039
<v Speaker 2>this eerie inverted picture.

390
00:17:51.839 --> 00:17:54.200
<v Speaker 1>But wait, how does the computer actually know how to

391
00:17:54.200 --> 00:17:57.920
<v Speaker 1>do something like blur or edge detect? I mean, it's

392
00:17:57.920 --> 00:18:00.839
<v Speaker 1>not a human eye, So what does haveing? Mathematically?

393
00:18:00.880 --> 00:18:03.720
<v Speaker 2>That's a great question. The system views your photograph as

394
00:18:03.759 --> 00:18:07.559
<v Speaker 2>a massive grid, a matrix of numbers, okay, a grid

395
00:18:07.559 --> 00:18:11.119
<v Speaker 2>of numbers, right, where each number represents the color value

396
00:18:11.160 --> 00:18:14.480
<v Speaker 2>of a specific pixel. When you pass that matrix into

397
00:18:14.480 --> 00:18:17.440
<v Speaker 2>the blur function, the system looks at the numerical value

398
00:18:17.440 --> 00:18:20.119
<v Speaker 2>of a single pixel, then looks at the numbers of

399
00:18:20.200 --> 00:18:24.319
<v Speaker 2>all the pixels immediately surrounding it, and mathematically averages them together.

400
00:18:24.559 --> 00:18:27.480
<v Speaker 2>Oh wow, and it does this for every single pixel

401
00:18:27.519 --> 00:18:31.319
<v Speaker 2>in the grid simultaneously, which visually softens the image.

402
00:18:31.359 --> 00:18:33.119
<v Speaker 1>That's brilliant. What about edge detect.

403
00:18:33.319 --> 00:18:36.079
<v Speaker 2>Edge detect works on a similar principle. It scans the

404
00:18:36.079 --> 00:18:39.759
<v Speaker 2>matrix looking for massive numerical differences between neighboring pixels, because.

405
00:18:39.519 --> 00:18:41.799
<v Speaker 1>A massive difference means a sharp contrast, right, like a

406
00:18:41.880 --> 00:18:43.119
<v Speaker 1>dark line on a white.

407
00:18:42.920 --> 00:18:46.519
<v Speaker 2>Background, exactly, And when it finds those contrasts, it mathematically

408
00:18:46.559 --> 00:18:48.960
<v Speaker 2>strips away everything else, leaving you with something that looks

409
00:18:48.960 --> 00:18:50.000
<v Speaker 2>like a pencil sket.

410
00:18:49.880 --> 00:18:52.799
<v Speaker 1>You can even use the binarize function, which forces every

411
00:18:52.799 --> 00:18:55.400
<v Speaker 1>single pixel in the image to become either pure black

412
00:18:55.519 --> 00:18:58.920
<v Speaker 1>or pure white based on a specific numerical threshold.

413
00:18:59.160 --> 00:19:02.160
<v Speaker 2>Right, because we just discussed the power of manipulate.

414
00:19:02.720 --> 00:19:05.680
<v Speaker 1>Oh right, you can wrap that bindarize function in a slider.

415
00:19:05.839 --> 00:19:10.160
<v Speaker 2>Yes, suddenly you are dragging a slider to dynamically adjust

416
00:19:10.240 --> 00:19:13.759
<v Speaker 2>the contrast threshold of a live webcam feed in real time.

417
00:19:13.880 --> 00:19:16.000
<v Speaker 1>It is so cool. But wait, if I can use

418
00:19:16.039 --> 00:19:18.680
<v Speaker 1>a function like image ad to combine two photographs together

419
00:19:18.960 --> 00:19:22.400
<v Speaker 1>almost exactly like I'm adding two plus two, does the

420
00:19:22.480 --> 00:19:25.920
<v Speaker 1>software even differentiate between a picture of my dog and

421
00:19:25.960 --> 00:19:27.559
<v Speaker 1>an algebraic equation at.

422
00:19:27.400 --> 00:19:29.920
<v Speaker 2>The foundational level? No, it all circles back to that

423
00:19:29.960 --> 00:19:33.000
<v Speaker 2>symbolic architecture we talked about. The engine doesn't possess a

424
00:19:33.000 --> 00:19:36.799
<v Speaker 2>completely separate logic system for handling a photograph versus an equation,

425
00:19:37.039 --> 00:19:37.480
<v Speaker 2>so it's.

426
00:19:37.359 --> 00:19:39.839
<v Speaker 1>All just symbols on the conveyor belt exactly.

427
00:19:40.359 --> 00:19:43.920
<v Speaker 2>It views an image as a symbolic grid of color values.

428
00:19:44.400 --> 00:19:48.759
<v Speaker 2>It views an equation as a symbolic tree of mathematical operators.

429
00:19:49.200 --> 00:19:53.279
<v Speaker 1>Because everything rests on this shared symbolic foundation, you apply

430
00:19:53.359 --> 00:19:56.440
<v Speaker 1>the exact same functional logic to a photo of your

431
00:19:56.480 --> 00:19:59.400
<v Speaker 1>dog as you do to a calculus problem.

432
00:19:59.519 --> 00:20:02.519
<v Speaker 2>It creates. It's a profoundly unified way of interacting with

433
00:20:02.599 --> 00:20:04.240
<v Speaker 2>different types of data it does.

434
00:20:04.599 --> 00:20:08.680
<v Speaker 1>And that unified approach extends directly to human language.

435
00:20:08.319 --> 00:20:12.319
<v Speaker 2>Too, which brings us to natural language processing. Right, text

436
00:20:12.480 --> 00:20:16.839
<v Speaker 2>is treated as data strings enclosed in quotation marks. You

437
00:20:16.839 --> 00:20:19.880
<v Speaker 2>can run basicnipulations like stream reverse to flip a word

438
00:20:19.920 --> 00:20:23.400
<v Speaker 2>backward or to uppercase you're basic text stuff. But because

439
00:20:23.440 --> 00:20:27.400
<v Speaker 2>the language is knowledge based, it actually grasps the structural

440
00:20:27.440 --> 00:20:28.440
<v Speaker 2>meaning of the text.

441
00:20:28.680 --> 00:20:31.519
<v Speaker 1>Yes, you can pass a giant paragraph into a function

442
00:20:31.640 --> 00:20:35.480
<v Speaker 1>like text sentences or text words, and it will automatically

443
00:20:35.519 --> 00:20:37.880
<v Speaker 1>parse the grammar and break the block of text down

444
00:20:37.920 --> 00:20:40.039
<v Speaker 1>into a clean list of its component parts.

445
00:20:40.359 --> 00:20:43.640
<v Speaker 2>And the capabilities extend far beyond just local text parsing

446
00:20:43.680 --> 00:20:44.400
<v Speaker 2>on your hard drive.

447
00:20:44.480 --> 00:20:48.119
<v Speaker 1>Oh absolutely, the language is fundamentally wired into massive external

448
00:20:48.160 --> 00:20:51.200
<v Speaker 1>knowledge bases. The examples of this in the text are wild.

449
00:20:51.720 --> 00:20:55.000
<v Speaker 1>You can take Wikipedia data, open a square bracket, type

450
00:20:55.000 --> 00:20:58.279
<v Speaker 1>the word computers in quotes, and close the bracket, and

451
00:20:58.279 --> 00:21:02.079
<v Speaker 1>what happens. The system reaches out, locates the Wikipedia article

452
00:21:02.119 --> 00:21:06.680
<v Speaker 1>on computers and pulls the entire text directly into your code.

453
00:21:06.880 --> 00:21:08.039
<v Speaker 2>Just boom, it's there.

454
00:21:08.279 --> 00:21:10.880
<v Speaker 1>Yeah, And you can then wrap that command in the

455
00:21:10.880 --> 00:21:14.319
<v Speaker 1>word cloud function with one single line of code. The

456
00:21:14.359 --> 00:21:17.519
<v Speaker 1>system retrieves an article from the Internet, parses the text,

457
00:21:17.799 --> 00:21:20.759
<v Speaker 1>counts the frequency of every word, and generates a visual

458
00:21:20.799 --> 00:21:22.880
<v Speaker 1>graphic of the most commonly used terms.

459
00:21:23.119 --> 00:21:25.720
<v Speaker 2>I mean, just think about the computational friction that usually

460
00:21:25.759 --> 00:21:26.359
<v Speaker 2>exists there.

461
00:21:26.599 --> 00:21:28.319
<v Speaker 1>How would a normal programmer do that?

462
00:21:28.480 --> 00:21:31.559
<v Speaker 2>A traditional programmer would have to locate a Wikipedia API,

463
00:21:32.119 --> 00:21:35.960
<v Speaker 2>authenticate their access, write an asynchronous network request.

464
00:21:36.119 --> 00:21:37.400
<v Speaker 1>How's exhausting already?

465
00:21:37.440 --> 00:21:41.720
<v Speaker 2>It is, then parse the resulting Jason data payload, strip

466
00:21:41.720 --> 00:21:45.079
<v Speaker 2>out the HTML formatting, and then finally begin writing a

467
00:21:45.079 --> 00:21:47.720
<v Speaker 2>custom algorithm to count the words, and here.

468
00:21:47.559 --> 00:21:51.119
<v Speaker 1>That friction is just eradicated. The distance between having an

469
00:21:51.160 --> 00:21:53.759
<v Speaker 1>idea and seeing the result is essentially zero.

470
00:21:54.039 --> 00:21:57.000
<v Speaker 2>Yeah, the system even understands language translation natively.

471
00:21:57.119 --> 00:22:00.119
<v Speaker 1>Oh right. You can type inage your name with the

472
00:22:00.200 --> 00:22:03.759
<v Speaker 1>number fifty six and it returns the English text fifty six.

473
00:22:04.079 --> 00:22:06.240
<v Speaker 2>Or you can ask for the Roman numeral of nineteen

474
00:22:06.240 --> 00:22:07.039
<v Speaker 2>eighty eight, or.

475
00:22:07.119 --> 00:22:10.519
<v Speaker 1>Use the transliterate function to take an English word and

476
00:22:10.680 --> 00:22:13.279
<v Speaker 1>instantly convert it into the characters of the Russian.

477
00:22:12.960 --> 00:22:17.680
<v Speaker 2>Alphabet without installing any plugins. The engine natively accesses linguistic

478
00:22:17.759 --> 00:22:20.839
<v Speaker 2>databases and handles the complex character mappings for you.

479
00:22:21.279 --> 00:22:23.599
<v Speaker 1>So what does this all mean for us? Let's synthesize

480
00:22:23.640 --> 00:22:24.160
<v Speaker 1>this journey.

481
00:22:24.200 --> 00:22:25.160
<v Speaker 2>Okay, let's zoom out.

482
00:22:25.359 --> 00:22:28.400
<v Speaker 1>We started with the grim reality that learning to code

483
00:22:28.480 --> 00:22:31.720
<v Speaker 1>usually feels like memorizing a dictionary just to place a

484
00:22:31.759 --> 00:22:32.680
<v Speaker 1>single brick.

485
00:22:32.480 --> 00:22:33.240
<v Speaker 2>The empty void.

486
00:22:33.480 --> 00:22:37.759
<v Speaker 1>Right, But we've explored how a knowledge based symbolic language

487
00:22:38.000 --> 00:22:42.559
<v Speaker 1>fundamentally flips that dynamic. We started with simple arithmetic, understanding

488
00:22:42.640 --> 00:22:46.440
<v Speaker 1>how functions and lists operate as powerful machines and conveyor.

489
00:22:46.079 --> 00:22:48.839
<v Speaker 2>Belts the foundational building blocks exactly.

490
00:22:49.119 --> 00:22:52.000
<v Speaker 1>We discovered how easily that raw data can be visualized,

491
00:22:52.279 --> 00:22:55.359
<v Speaker 1>and how the manipulate function turns static code into interactive

492
00:22:55.359 --> 00:22:56.200
<v Speaker 1>wet clay.

493
00:22:56.079 --> 00:22:57.920
<v Speaker 2>With zero UI coding zero.

494
00:22:59.279 --> 00:23:02.839
<v Speaker 1>And finally we saw how the messy, unstructured reality of

495
00:23:02.920 --> 00:23:06.920
<v Speaker 1>webcam images, natural language, and foreign alphabets can be computed

496
00:23:06.960 --> 00:23:09.920
<v Speaker 1>with the exact same ease as adding two numbers together.

497
00:23:10.279 --> 00:23:13.319
<v Speaker 2>I think the overarching theme here is the democratization of

498
00:23:13.359 --> 00:23:15.240
<v Speaker 2>advanced computation.

499
00:23:14.880 --> 00:23:17.079
<v Speaker 1>The democratization of it. Say more about.

500
00:23:16.839 --> 00:23:21.079
<v Speaker 2>That, Well, when you automate away the drudgery of traditional

501
00:23:21.160 --> 00:23:23.519
<v Speaker 2>computer science, you know, when you no longer have to

502
00:23:23.559 --> 00:23:29.039
<v Speaker 2>manually manage memory, declare variable types, or build complex rendering loops,

503
00:23:29.119 --> 00:23:34.160
<v Speaker 2>what's left, What remains is pure unadulterated computational thinking. You

504
00:23:34.200 --> 00:23:36.880
<v Speaker 2>stop fighting the limitations of the machine and you start

505
00:23:36.880 --> 00:23:39.000
<v Speaker 2>collaborating with its vast capabilities.

506
00:23:39.079 --> 00:23:41.519
<v Speaker 1>Right for you listening to this, the true value of

507
00:23:41.519 --> 00:23:44.200
<v Speaker 1>this deep dive isn't just about adding a new programming

508
00:23:44.279 --> 00:23:47.039
<v Speaker 1>language to your toolkit, not at all. It's about recognizing

509
00:23:47.079 --> 00:23:49.839
<v Speaker 1>a completely different way to solve problems. Whether you are

510
00:23:49.880 --> 00:23:53.559
<v Speaker 1>a biologist trying to analyze the complex geometry of cell shapes,

511
00:23:54.119 --> 00:23:57.640
<v Speaker 1>a historian tracking the evolution of word usage across centuries

512
00:23:57.680 --> 00:24:01.000
<v Speaker 1>of literature, or simply someone who is in insanely curious

513
00:24:01.039 --> 00:24:01.640
<v Speaker 1>about the world.

514
00:24:01.880 --> 00:24:03.440
<v Speaker 2>You now know there's a tool out there for.

515
00:24:03.440 --> 00:24:06.119
<v Speaker 1>You, exactly. Yeah, you know there is a system that

516
00:24:06.160 --> 00:24:10.400
<v Speaker 1>allows you to turn raw, abstract ideas into tangible reality

517
00:24:10.599 --> 00:24:12.400
<v Speaker 1>without needing a computer science degree.

518
00:24:12.480 --> 00:24:13.839
<v Speaker 2>It's incredibly empowering.

519
00:24:14.200 --> 00:24:16.000
<v Speaker 1>It is I want to leave you with a final

520
00:24:16.039 --> 00:24:19.119
<v Speaker 1>thought to mull Over. We began by talking about how

521
00:24:19.160 --> 00:24:22.359
<v Speaker 1>traditional programming is like being handed a single atom and

522
00:24:22.400 --> 00:24:25.680
<v Speaker 1>told to build a universe. But in a knowledge based

523
00:24:25.759 --> 00:24:28.519
<v Speaker 1>symbolic system, the universe is already built in.

524
00:24:28.920 --> 00:24:29.720
<v Speaker 2>It's waiting for you.

525
00:24:29.920 --> 00:24:33.480
<v Speaker 1>Yeah. If every aspect of our human experience, our language,

526
00:24:33.480 --> 00:24:37.079
<v Speaker 1>our visual art, our historical data are photographs, If all

527
00:24:37.119 --> 00:24:40.039
<v Speaker 1>of that can be cleanly translated into symbolic lists and

528
00:24:40.119 --> 00:24:44.480
<v Speaker 1>functions that a machine can infinitely manipulate, where exactly is

529
00:24:44.519 --> 00:24:48.359
<v Speaker 1>the line between mathematical computation and human creativity?

530
00:24:48.480 --> 00:24:49.559
<v Speaker 2>Well that's a deep question.

531
00:24:49.759 --> 00:24:52.359
<v Speaker 1>If a single line of text can pull human history

532
00:24:52.359 --> 00:24:55.440
<v Speaker 1>from the Internet, pars its grammar, translate it into a

533
00:24:55.440 --> 00:24:58.680
<v Speaker 1>foreign alphabet, and render it into a visual masterpiece on

534
00:24:58.720 --> 00:25:01.759
<v Speaker 1>your screen, and a fraction of a second, what will

535
00:25:01.799 --> 00:25:04.680
<v Speaker 1>you choose to build when the barrier to entry is

536
00:25:04.720 --> 00:25:05.680
<v Speaker 1>completely removed,
