1
00:00:06,140 --> 00:00:10,910
Everybody has to go and this is Caleb with Deb's slopes dot com and in this video we're going to be

2
00:00:10,910 --> 00:00:13,470
talking about the data structure called the tree.

3
00:00:13,680 --> 00:00:14,220
OK.

4
00:00:14,450 --> 00:00:17,290
And we're going to learn how to build one in swift which is pretty awesome.

5
00:00:17,300 --> 00:00:22,770
So I'm going to first pull open a diagram to show you what a tree looks like visualized.

6
00:00:22,940 --> 00:00:25,630
And then we're going to dive into actually creating one.

7
00:00:25,730 --> 00:00:31,790
So here is how a tree is organized and if you're thinking this looks a lot like a family tree the data

8
00:00:31,880 --> 00:00:38,120
in a family tree is actually stored in pretty much the same exact way whereas you would have one family

9
00:00:38,120 --> 00:00:40,770
here your mom and dad and then maybe their children.

10
00:00:40,910 --> 00:00:45,680
Then this would be you know whomever they married and then their children et cetera et cetera going

11
00:00:45,680 --> 00:00:51,710
all the way down the family tree starting you know way back when in some other country perhaps or maybe

12
00:00:51,710 --> 00:00:53,440
you've been in the same country the whole time.

13
00:00:53,450 --> 00:00:54,720
Who knows anyway.

14
00:00:54,950 --> 00:00:59,630
So at the very top of our tree we have what is called the root.

15
00:00:59,720 --> 00:01:00,220
OK.

16
00:01:00,470 --> 00:01:08,840
And this is something that is applicable this or I guess we should say the data stored in the root is

17
00:01:08,840 --> 00:01:12,170
data that is applicable to all of the nodes below it.

18
00:01:12,170 --> 00:01:18,810
So the root note here is devices we're going to be using this tree to store different kinds of devices.

19
00:01:18,860 --> 00:01:23,940
And what I have done is I've branched off from my route and created some notes.

20
00:01:23,960 --> 00:01:28,840
Now the route we can call it the root node because it also is a node.

21
00:01:28,850 --> 00:01:34,670
But we're going to call it the root because it is unique in the fact that it is the very top of our

22
00:01:34,670 --> 00:01:36,080
chart where everything starts.

23
00:01:36,080 --> 00:01:40,330
So the first node over here on the left is Apple.

24
00:01:40,330 --> 00:01:41,880
So Apple devices.

25
00:01:42,050 --> 00:01:47,810
And then on the right we have a robot that will be Android devices but they're both devices right and

26
00:01:47,810 --> 00:01:53,270
so that's why the route here can relate to all of the other things in the tree.

27
00:01:53,270 --> 00:01:55,070
So they're all going to be devices.

28
00:01:55,190 --> 00:02:01,450
Now the Apple node we're going to call it a node that's kind of like a child in a heap.

29
00:02:01,460 --> 00:02:02,120
Right.

30
00:02:02,180 --> 00:02:05,180
It is a child of this parent root node.

31
00:02:05,270 --> 00:02:08,050
So this node is for Apple devices.

32
00:02:08,110 --> 00:02:08,820
OK.

33
00:02:08,930 --> 00:02:13,160
And if we branch off of Apple devices we have an iPhone and a MacBook.

34
00:02:13,160 --> 00:02:18,060
Now obviously there are many more Apple devices but just for this example I just used to.

35
00:02:18,170 --> 00:02:26,290
And so then if we branch off of the iPhone node we can see there is iPhone 10 iPhone 8 iPhone for us

36
00:02:26,300 --> 00:02:28,880
and we could go on and on and on and on and on.

37
00:02:29,660 --> 00:02:35,120
Alternatively on the Android side there are two nodes here one is for the Samsung Galaxy S 9 and the

38
00:02:35,120 --> 00:02:37,640
other is for some random Android tablet.

39
00:02:37,640 --> 00:02:39,980
There are too many to actually differentiate.

40
00:02:39,980 --> 00:02:47,620
So you're seeing the word leaf over here and a leaf is a node that does not have any children nodes

41
00:02:47,630 --> 00:02:54,440
so in this diagram the MacBook the Samsung Galaxy S 9 and this Android tablet are all examples of leaves

42
00:02:54,470 --> 00:02:58,280
because they have no children nodes that come off of them.

43
00:02:58,280 --> 00:03:06,200
Now we could go into greater detail in our tree here or we could go into the iPhone 10 and we could

44
00:03:06,200 --> 00:03:12,490
split you know a child node for the battery life we could split a child node off for the screen resolution

45
00:03:12,510 --> 00:03:17,700
etc etc. and we can dive into all of those specific details for all of those devices.

46
00:03:17,750 --> 00:03:23,040
The tree can just continue to grow and get increasingly complex with each level down the tree.

47
00:03:23,180 --> 00:03:25,700
But I think we should actually start to make one.

48
00:03:25,700 --> 00:03:31,640
So pull up an X code like Sue and get started with a new playground.

49
00:03:31,640 --> 00:03:33,790
Of course it goes to the wrong window anyway.

50
00:03:33,800 --> 00:03:37,820
So create a blank blank playground that can't even speak today.

51
00:03:37,910 --> 00:03:43,770
And we're going to go ahead and name this tree free that no just name it something and save it somewhere.

52
00:03:43,940 --> 00:03:50,480
And I'm going to make it full screen so delete everything in here and just import Foundation.

53
00:03:50,660 --> 00:03:56,540
That's what's most important for what we're doing today and we're going to go ahead and begin by creating

54
00:03:56,540 --> 00:03:58,380
a class called node.

55
00:03:58,580 --> 00:04:05,000
And like I said in our diagram here the route also qualifies as a node right because it has children

56
00:04:05,000 --> 00:04:07,790
nodes just like Android has children node.

57
00:04:08,000 --> 00:04:09,860
Apple has children nodes.

58
00:04:10,030 --> 00:04:13,130
The route while it is the very first node.

59
00:04:13,220 --> 00:04:14,720
It's also a node.

60
00:04:14,870 --> 00:04:21,740
So go ahead and create a class called node and give it some curly brackets there to open it up and we're

61
00:04:21,740 --> 00:04:27,930
going to basically first create a variable called value that is going to store the value of whatever

62
00:04:27,940 --> 00:04:32,870
in this node is whether it's the parent node whether it is the child node.

63
00:04:32,870 --> 00:04:36,440
Each node needs a value and it's going to be of type string.

64
00:04:36,530 --> 00:04:41,090
So go ahead and type var value of type string.

65
00:04:41,090 --> 00:04:41,570
All right.

66
00:04:41,570 --> 00:04:47,450
We're going to create an initializer later then we're going to need to create an array called Children

67
00:04:47,680 --> 00:04:50,990
K because our node has the potential to have children.

68
00:04:50,990 --> 00:04:53,530
So go ahead and say our children.

69
00:04:53,690 --> 00:04:59,500
And that's going to be an array of type node and we're going to just initialize it to be an empty array

70
00:04:59,510 --> 00:05:01,230
from the get go.

71
00:05:01,490 --> 00:05:05,000
Now we're going to go ahead and create a variable called Parent x.

72
00:05:05,000 --> 00:05:10,970
It's going to be optional and we're going to use the weak keyword so weak var parent type node and it's

73
00:05:10,970 --> 00:05:16,820
going to be optional because not every node actually has a parent like our root node.

74
00:05:16,970 --> 00:05:18,450
OK we're going to start somewhere.

75
00:05:18,560 --> 00:05:20,320
This no does not have a parent.

76
00:05:20,330 --> 00:05:25,560
So we need to make it optional because it is possible for a node not to have a parent.

77
00:05:25,560 --> 00:05:30,830
However we need to actually provide the option for our nodes to have children so that's why we have

78
00:05:30,830 --> 00:05:34,040
an empty array there so we can add them on very easily.

79
00:05:34,040 --> 00:05:39,650
So now we're going to go ahead and just create an initialiser like so we're going to pass in a value

80
00:05:39,650 --> 00:05:46,650
of type string and we're going to set self-taught value WIPs value to be equal to value.

81
00:05:46,790 --> 00:05:47,360
OK.

82
00:05:47,720 --> 00:05:49,260
So that sets that.

83
00:05:49,280 --> 00:05:55,100
But we want to be able to add a child node to whatever node this is.

84
00:05:55,100 --> 00:05:57,560
And so we're going to add a function here called add.

85
00:05:57,670 --> 00:06:03,350
So type phunk ad and we're going to just say child that's what we're going to call the parameter to

86
00:06:03,430 --> 00:06:06,320
pasan and that's going to be of type note.

87
00:06:06,630 --> 00:06:07,360
All righty.

88
00:06:07,550 --> 00:06:14,780
Now in order to add a child to this node we're going to go ahead and append children pen and we're going

89
00:06:14,780 --> 00:06:20,080
to pass in that child then we're going to need to set the parent of that child.

90
00:06:20,090 --> 00:06:26,230
So to do that we can just call child datt parent Keiko's child of course is of type node.

91
00:06:26,300 --> 00:06:27,900
It has an optional parent.

92
00:06:27,920 --> 00:06:35,330
We're going to set child up parent to be self K because whatever the child is this node whatever instance

93
00:06:35,330 --> 00:06:38,480
of this class will be that is who we're going to set the parent to.

94
00:06:38,480 --> 00:06:42,730
So we're kind of killing two birds with one stone here which is pretty cool.

95
00:06:42,740 --> 00:06:49,120
So we now have a node class and we are now ready to build a tree which is really really cool.

96
00:06:49,130 --> 00:06:57,820
So let's first try to model this actual tree itself by first creating the parent node.

97
00:06:57,830 --> 00:07:07,340
So we're going to just say let devices OK equal node and we're going to just pass in devices as the

98
00:07:07,370 --> 00:07:08,480
value already.

99
00:07:08,480 --> 00:07:14,080
And of course it shows up over here in the print out of type node which is pretty neat.

100
00:07:14,150 --> 00:07:17,670
And now we're going to go ahead and create some child nodes.

101
00:07:17,810 --> 00:07:19,510
So let's go ahead and create.

102
00:07:19,520 --> 00:07:26,730
Let Apple devices equals node and we're going to pass in a value of Apple.

103
00:07:26,730 --> 00:07:27,700
All righty.

104
00:07:27,870 --> 00:07:36,060
Let Android devices equals node and we're going to say Android Android.

105
00:07:36,500 --> 00:07:37,220
OK.

106
00:07:37,580 --> 00:07:46,420
And then all we need to do to add these two devices to our tree is call devices and pass an Apple devices

107
00:07:46,460 --> 00:07:47,300
and then do it again.

108
00:07:47,300 --> 00:07:50,810
Devices don't add and passen Android devices.

109
00:07:51,020 --> 00:07:53,450
So now we're going to see what it looks like when we print it out.

110
00:07:53,450 --> 00:07:55,260
So we're going to print books.

111
00:07:55,440 --> 00:08:01,670
Devices like so and when it prints out check out what we get.

112
00:08:01,670 --> 00:08:03,470
Nothing it just prints out Noad.

113
00:08:03,560 --> 00:08:09,020
So we need to actually set up a way to describe what is in the notes and we're going to actually write

114
00:08:09,020 --> 00:08:15,850
a quick little extension here of node that it conforms to the custom string convertible protocol.

115
00:08:16,100 --> 00:08:22,070
And we're going to create a quick little variable called description of type string but we're going

116
00:08:22,070 --> 00:08:27,240
to set some custom stuff inside so that we can check that or even our children.

117
00:08:27,320 --> 00:08:32,480
OK we're going to first print out the value of maybe the parent note on the top.

118
00:08:32,480 --> 00:08:39,260
The root node and then we're going to go ahead and say hey if the children array is not empty We're

119
00:08:39,260 --> 00:08:44,510
going to cycle through and we're going to add those in but we're going to add some curly brackets so

120
00:08:44,510 --> 00:08:50,540
that we can show the actual layers of the tree like so and so to do that we're going to go ahead and

121
00:08:50,540 --> 00:08:52,850
first create a variable called text.

122
00:08:53,070 --> 00:08:53,760
OK.

123
00:08:54,080 --> 00:08:59,460
And that's going to basically just be whatever the value variable is.

124
00:08:59,810 --> 00:09:05,420
So in the instance of our devices node this string devices is what would print out here so we're setting

125
00:09:05,420 --> 00:09:13,850
text to be devices then we're going to go ahead and say hey if children dot is empty and we want that

126
00:09:13,850 --> 00:09:14,520
to be false.

127
00:09:14,540 --> 00:09:18,380
So we're going to put the exclamation mark there to invert it.

128
00:09:18,380 --> 00:09:24,130
So if Children's is empty is not true meaning if there are children for this particular node we're going

129
00:09:24,140 --> 00:09:27,430
to go ahead and just take text and we're going to do.

130
00:09:27,500 --> 00:09:34,220
Plus equals there to append some text to the end of it and we're going to go ahead and append a space

131
00:09:34,310 --> 00:09:40,430
and a curly bracket so that we can basically describe the first item then we'll put a curly bracket

132
00:09:40,760 --> 00:09:46,170
and then we'll fit in the next set of values and put those inside of a curly bracket.

133
00:09:46,220 --> 00:09:46,900
OK.

134
00:09:47,150 --> 00:09:49,550
And that will basically show the different layers.

135
00:09:49,540 --> 00:09:50,240
You'll see what I mean.

136
00:09:50,240 --> 00:09:52,310
And the second one it actually prints out.

137
00:09:52,370 --> 00:09:58,860
Then we're going to go ahead and add that little you know chunk of a string to children.

138
00:09:59,120 --> 00:10:04,660
And what we're going to do is we're going to call map and K and map is a very cool function.

139
00:10:04,700 --> 00:10:10,610
That's going to allow us to actually iterate over every item in the array and then we're going to join

140
00:10:10,610 --> 00:10:15,710
each of those little items with a comma and a space then we're going to finish it off with brackets

141
00:10:15,710 --> 00:10:16,510
at the end.

142
00:10:16,580 --> 00:10:17,970
You'll see how it'll look in a second.

143
00:10:18,080 --> 00:10:18,740
Let's just do it.

144
00:10:18,760 --> 00:10:21,750
And then look at it and it'll it'll make sense I promise.

145
00:10:21,770 --> 00:10:25,350
So we're going to go ahead and map over every item.

146
00:10:25,400 --> 00:10:31,790
And when you map over each item you can use this temporary variable dollar sign zero or you know whatever

147
00:10:31,790 --> 00:10:34,030
you wanna call it zero dollars broke.

148
00:10:34,040 --> 00:10:36,990
Brooks broke broke Simbel I don't know.

149
00:10:37,010 --> 00:10:43,820
Dollar Signs zero dot and we can actually go ahead and pull out the description of whatever that item

150
00:10:43,820 --> 00:10:44,060
is.

151
00:10:44,060 --> 00:10:48,890
So remember text is going to basically you know get that description.

152
00:10:49,160 --> 00:10:56,410
And once we have that description we can call DOT joined with a separator and that separator is going

153
00:10:56,420 --> 00:10:58,940
to be comma space.

154
00:10:58,940 --> 00:11:04,910
Get rid of the little placeholder there and then after we separate all of the children with a comma

155
00:11:04,940 --> 00:11:12,190
and a space we're going to add another little string which will be a curly bracket to close and a space

156
00:11:12,800 --> 00:11:15,200
and then that is what we will actually set.

157
00:11:15,200 --> 00:11:19,280
So basically we're saying hey we're going to set the value of whatever it is.

158
00:11:19,280 --> 00:11:23,000
So for the devices no devices get set as text.

159
00:11:23,240 --> 00:11:29,580
Then if it doesn't have children this doesn't get called and we can just return that text.

160
00:11:29,690 --> 00:11:36,890
But if there are children we will first show the value so devices then we're going to show its children

161
00:11:37,250 --> 00:11:43,490
by putting them inside of curly brackets separating each one with a comma and then you know that those

162
00:11:43,490 --> 00:11:47,900
two elements are under the device's parent root node.

163
00:11:48,200 --> 00:11:49,980
And so now we have a description.

164
00:11:50,020 --> 00:11:54,810
It's printing out right here at the bottom can you see that we have devices as the root node.

165
00:11:54,890 --> 00:12:00,400
Then below that we have Apple which has one child node an Android which is another child node.

166
00:12:00,410 --> 00:12:07,030
Now I think would be really cool to add in our custom nodes and see how they look.

167
00:12:07,060 --> 00:12:13,970
So let's go ahead and below this we're going to go ahead and type Apple devices dot ad and I'm going

168
00:12:13,970 --> 00:12:21,830
to add in my first group of items which is iPhone and as it prints out you'll see it'll add a new bracket.

169
00:12:21,910 --> 00:12:23,700
So what's the problem.

170
00:12:23,950 --> 00:12:29,630
Ok ok so I forgot if we're going to add in a node we can't just pass in the string because the add function

171
00:12:29,720 --> 00:12:34,580
expects that a node is being passed in so we're going to go ahead and just create a node when we pass

172
00:12:34,580 --> 00:12:37,450
it in and pass in iPhone.

173
00:12:37,460 --> 00:12:44,600
So now when we print it out we'll see that devices has a child called Apple and Apple has a child called

174
00:12:44,630 --> 00:12:46,090
iPhone do you see how this works.

175
00:12:46,130 --> 00:12:49,000
We're basically nesting all of our items.

176
00:12:49,250 --> 00:12:54,560
So obviously it's not as visual like this with know the circles and the lines but if you look at it

177
00:12:54,560 --> 00:12:56,870
it's organized in exactly the same way.

178
00:12:56,870 --> 00:13:03,410
So I'm going to copy and paste this just for time's sake and I'm going to add in a mac book Noad of

179
00:13:03,410 --> 00:13:06,730
course that will update and you see it show up in the print right there.

180
00:13:06,770 --> 00:13:08,540
So cool.

181
00:13:08,540 --> 00:13:13,280
And so now we can start to add nodes to our Android device node.

182
00:13:13,400 --> 00:13:22,670
So Android devices that add we can create a node and pasan maybe galaxy as a node for the Galaxy phones

183
00:13:23,090 --> 00:13:30,500
and then we can copy this and we can just say tablets I guess.

184
00:13:30,710 --> 00:13:35,940
But as you can see when it prints out what we're going to have is devices is the root node.

185
00:13:36,050 --> 00:13:41,780
Below that is Apple and inside Apple there is iPhone and Mac book Inside Android there is Galaxy and

186
00:13:41,780 --> 00:13:42,740
tablets.

187
00:13:43,010 --> 00:13:45,320
Now we can go even further we can say

188
00:13:48,320 --> 00:13:56,750
oh no you know what I just realized we're not going to be able to add nodes to our iPhone node because

189
00:13:57,170 --> 00:13:58,870
we have not actually.

190
00:13:58,880 --> 00:13:59,730
Well we could.

191
00:13:59,780 --> 00:14:00,880
There is a way we could do it.

192
00:14:00,890 --> 00:14:05,510
But I think it's going to be better actually if we.

193
00:14:05,870 --> 00:14:09,850
Yeah let's go ahead and cut this and let's just say let iPhone.

194
00:14:10,130 --> 00:14:14,780
We're going to set that to a node and pass it and we're actually going to be able to work with these

195
00:14:14,780 --> 00:14:18,380
properties and then add value to them.

196
00:14:18,380 --> 00:14:29,160
So let's go ahead and let's cut this node and say let's MacBook equals node and then passen MacBook.

197
00:14:29,780 --> 00:14:30,660
Cool.

198
00:14:30,830 --> 00:14:39,290
And now just for the example I'm going to go ahead and say iPhone ad and I'm going to pass in a note

199
00:14:39,320 --> 00:14:43,470
here for the iPhone 10.

200
00:14:43,520 --> 00:14:45,810
Here we are.

201
00:14:47,340 --> 00:14:56,960
Then I'm going to go ahead and do iPhone add child node and we're going to pass in iPhone 8 and you'll

202
00:14:56,960 --> 00:14:59,680
probably see a printout below you'll see it's doing what it's supposed to do.

203
00:14:59,690 --> 00:15:02,790
But I just think it's really cool how it works.

204
00:15:03,170 --> 00:15:04,990
Noad value.

205
00:15:05,000 --> 00:15:14,330
And I said the iPhone 4 ES I think is for us there we go and we print out the devices you can see that

206
00:15:14,420 --> 00:15:20,210
we have devices under devices we have Apple under apple we have iPhone under iPhone we have iPhone 10

207
00:15:20,270 --> 00:15:24,280
8 and for us then there's MacBook which at this point is a leaf node.

208
00:15:24,350 --> 00:15:24,610
Right.

209
00:15:24,620 --> 00:15:27,050
Because there's no children attached to it.

210
00:15:27,050 --> 00:15:28,880
And then we have Android galaxy and tablet.

211
00:15:28,880 --> 00:15:34,220
So at this point we have faithfully recreated our tree in code which is really neat.

212
00:15:34,400 --> 00:15:39,850
But what good is a tree if we're not able to search for items.

213
00:15:39,890 --> 00:15:44,380
So we're going to go ahead and actually add an extension to our node.

214
00:15:44,390 --> 00:15:51,650
We're going to add some extra functionality to allow us to search for particular node in our tree so

215
00:15:51,860 --> 00:15:57,050
go ahead and type extension node at the bottom and I'm going to make some more space here so we can

216
00:15:57,050 --> 00:15:58,570
actually see what we're doing.

217
00:15:59,060 --> 00:16:01,540
And we're going to write a function that will search our trees.

218
00:16:01,550 --> 00:16:08,270
So go ahead right phunk search and we're going to actually pass in a value of type string and that is

219
00:16:08,270 --> 00:16:13,820
going to actually return the node object which of course is going to be optional because we may not

220
00:16:13,820 --> 00:16:17,320
actually return the node that we are hoping to return.

221
00:16:17,330 --> 00:16:28,160
So go ahead and basically check if the value is equal to self value meaning you know if our instance

222
00:16:28,160 --> 00:16:36,410
of node if we're searching for a value and it's equal to the value that we are you know if we're searching

223
00:16:36,410 --> 00:16:41,420
for devices and the value of the particular node is devices we're just going to go ahead and return

224
00:16:41,420 --> 00:16:42,220
that value.

225
00:16:42,350 --> 00:16:45,890
So return self just like that.

226
00:16:46,010 --> 00:16:51,170
But if that's not the case we're going to go ahead and basically cycle through all the children and

227
00:16:51,200 --> 00:16:53,160
if one is found we will return it.

228
00:16:53,240 --> 00:16:57,350
And if nothing else works we're going to just return nil meaning there is no search result that was

229
00:16:57,350 --> 00:16:57,650
found.

230
00:16:57,650 --> 00:17:05,270
So for child in children remember we're reading an extension so we have access to the children array

231
00:17:05,960 --> 00:17:11,500
and so we can say hey for every child in children if let.

232
00:17:11,500 --> 00:17:17,100
Found equals child search for that value.

233
00:17:17,350 --> 00:17:23,240
OK so we're going to just basically call search upon that child and if that value is found we return

234
00:17:23,240 --> 00:17:24,270
it right.

235
00:17:24,380 --> 00:17:32,510
If that is found We're going to return found wups and then if that doesn't work if all else fails meaning

236
00:17:32,690 --> 00:17:36,400
the search did not end up returning anything we're going to return nil.

237
00:17:36,410 --> 00:17:42,880
Now what we can do is if we want to search a particular portion of our node like let's say I wanted

238
00:17:42,880 --> 00:17:49,190
to search the entire device's node I could create a variable called search result or I guess a constant

239
00:17:50,510 --> 00:17:59,930
and then type devices search and I could search for iPhone and see what happens.

240
00:18:00,140 --> 00:18:02,600
It returns the entire iPhone node.

241
00:18:02,640 --> 00:18:03,310
You see that.

242
00:18:03,470 --> 00:18:10,820
So now I've returned the entire node and now I could go ahead and just say hey.

243
00:18:11,030 --> 00:18:19,070
Search results and maybe if I go in here I could say you know children and print out the first item

244
00:18:19,100 --> 00:18:24,060
in the search result for children and that's going to print out iPhone 10.

245
00:18:24,080 --> 00:18:28,910
Obviously it's optional you'd have to do some work maybe a guard or a way to verify that that value

246
00:18:28,910 --> 00:18:30,380
came back the way you wanted.

247
00:18:30,590 --> 00:18:36,350
But we can now search our tree and pull out an individual node and all of its sub values which is a

248
00:18:36,350 --> 00:18:37,770
really really cool way to do things.

249
00:18:37,780 --> 00:18:43,850
Now I could search devices for iPhone 10 specifically and that's going to actually return the iPhone

250
00:18:43,850 --> 00:18:47,250
10 child right there which is so cool.

251
00:18:47,270 --> 00:18:54,860
So we have now successfully created a tree data structure in swift very very simply and we have seen

252
00:18:54,860 --> 00:18:55,690
how it works.

253
00:18:55,730 --> 00:19:00,400
I'm sure you can imagine how this is helpful for organizing data in a very structured way.

254
00:19:00,570 --> 00:19:02,520
And yeah very cool stuff guys.

255
00:19:02,540 --> 00:19:05,680
This is Caleb with slopes dot com and I'll see in the next video.