1
00:00:05,270 --> 00:00:10,130
Welcome back, everyone, to this lecture on Django applications or Django apps.

2
00:00:11,570 --> 00:00:17,600
Jingo projects can have separated subcomponents called apps now, be careful not to get confused by

3
00:00:17,600 --> 00:00:23,750
this nomenclature because we've already used the term web app or web application a lot and typically

4
00:00:23,750 --> 00:00:28,340
a web app describes the full website or mobile application on the web.

5
00:00:28,790 --> 00:00:36,110
And specifically speaking, a jingo app is a subcomponent of a single jingo project that web application.

6
00:00:36,470 --> 00:00:41,420
So to try to clarify things instead of using the term web application from now on, when we're actually

7
00:00:41,420 --> 00:00:46,340
describing the final resulting project, we're going to call that our website.

8
00:00:46,340 --> 00:00:50,270
Since the way we present it here, it's pretty much always going to be a website in the browser so you

9
00:00:50,270 --> 00:00:56,030
can think of the Django project as your overall website and then Django apps as subcomponents of that

10
00:00:56,030 --> 00:00:56,510
website.

11
00:00:58,220 --> 00:01:03,860
So again, it often becomes much easier to organize your coat through the use of these Django apps.

12
00:01:04,129 --> 00:01:08,660
And it's Django app should cover a different key functionality for your website.

13
00:01:09,050 --> 00:01:13,400
And you should also keep in mind that if you're just beginning as a solo developer with a very simple

14
00:01:13,400 --> 00:01:19,250
website, sometimes it actually makes more sense to put every component of your website into a single

15
00:01:19,250 --> 00:01:24,140
Django app, depending on how complex your final Django project is going to be.

16
00:01:24,590 --> 00:01:30,530
The main use cases for separating your entire project into many Django apps is just going to be for

17
00:01:30,530 --> 00:01:31,520
organization.

18
00:01:31,760 --> 00:01:37,400
And also that way, other people looking at your code or yourself in the future can understand which

19
00:01:37,400 --> 00:01:40,250
components are referring to which key functionalities.

20
00:01:41,880 --> 00:01:46,500
So if we think about the jingo project structure, we have a single project and then within it, we

21
00:01:46,500 --> 00:01:51,600
have different applications for different functionalities and you can have as many applications as you

22
00:01:51,600 --> 00:01:53,580
want inside of a single project.

23
00:01:54,330 --> 00:01:58,650
For example, let's say we're trying to create the next Big Social Network website, which is going

24
00:01:58,650 --> 00:02:02,750
to be a single project then inside of the social network web site.

25
00:02:03,090 --> 00:02:09,090
Maybe you have a couple of applications, like an application that's just focused on the messaging functionality.

26
00:02:09,300 --> 00:02:15,060
User to user maybe have another application that's just focused on photos, maybe have another application

27
00:02:15,060 --> 00:02:21,170
that's focused on video, etc. Hopefully, this gives you an idea of why it's easier to separate applications.

28
00:02:21,180 --> 00:02:26,310
Imagine that social network website begins to grow, and we want to start working with other developers,

29
00:02:26,340 --> 00:02:29,070
maybe a developer that is really good at VIDEO.

30
00:02:29,250 --> 00:02:34,590
I don't want to put all this functionality into just some huge single folder, which has a single,

31
00:02:34,590 --> 00:02:36,450
huge codebase instead.

32
00:02:36,720 --> 00:02:42,870
I can separate out into jingo apps in order to keep these subcomponents organized by functionality.

33
00:02:44,300 --> 00:02:49,010
Now, to create a new app, we end up using the managed pie file created by the project.

34
00:02:49,400 --> 00:02:55,070
So we're to call Python Managed Pie star app and then your app name that first part that just calls

35
00:02:55,070 --> 00:02:57,890
the manage that pie file to run a command line execution.

36
00:02:58,370 --> 00:03:00,460
So we say python managed not pie.

37
00:03:00,470 --> 00:03:01,940
Run that straight at your command line.

38
00:03:02,270 --> 00:03:05,280
Be careful not to accidentally call Python by itself first.

39
00:03:05,300 --> 00:03:08,360
Otherwise, that initiates the Python interpreter recall.

40
00:03:08,390 --> 00:03:12,620
Here we're actually just running this as a python file with command line arguments.

41
00:03:13,070 --> 00:03:16,970
And then the managed up.I file can accept many different type of command line arguments.

42
00:03:17,270 --> 00:03:22,790
And the one we're working with here is the Start app, which is a specific command to run from the managed

43
00:03:22,910 --> 00:03:26,840
pie file, something to keep in mind, as well as to make sure you're in the correct directory.

44
00:03:27,050 --> 00:03:30,160
When you actually run this python, manage that py line.

45
00:03:30,960 --> 00:03:34,980
And then after that, it's whatever you want to call your application, so again, your custom name

46
00:03:34,980 --> 00:03:39,120
for your application, you should feel free to change it so it's relevant to the scope of an application.

47
00:03:39,390 --> 00:03:41,820
Maybe you could call one messaging underscore app.

48
00:03:42,060 --> 00:03:43,860
In other words, be video underscore app.

49
00:03:43,860 --> 00:03:48,660
And then you would just run this line as many times as you need for different applications.

50
00:03:48,930 --> 00:03:55,740
It often as a project grows, you start breaking up applications into sub applications, etc. So again,

51
00:03:55,770 --> 00:03:58,550
this is really dependent on the scope of your project.

52
00:03:58,560 --> 00:04:00,480
How many people are working with you on the project?

53
00:04:00,780 --> 00:04:06,510
Typically, the smaller your project is and the more solo focus it is, you're going to have less applications,

54
00:04:06,720 --> 00:04:09,510
the larger the project is and the more people you have working on it.

55
00:04:09,510 --> 00:04:12,480
You're going to have more applications for organization purposes.

56
00:04:13,440 --> 00:04:17,399
So we're going to do right now is we're going to create an example of an application and then we're

57
00:04:17,399 --> 00:04:21,149
going to do a little bit of exploring to see how to connect it to our IRL view.

58
00:04:21,450 --> 00:04:26,190
And I'll actually conclude this section and we're going to revisit all of this in the new section by

59
00:04:26,190 --> 00:04:27,720
starting a new project from scratch.

60
00:04:27,990 --> 00:04:33,300
So we're just going to very briefly cover views, URLs and Django applications.

61
00:04:33,510 --> 00:04:38,790
We're going to have a much deeper dive in the next section where we specifically focus on views and

62
00:04:38,790 --> 00:04:40,470
URLs and serving templates.

63
00:04:40,830 --> 00:04:41,160
OK.

64
00:04:41,490 --> 00:04:46,380
So let's go ahead and head out to Visual Studio code and show you an example of creating an application

65
00:04:46,560 --> 00:04:50,460
and then actually rendering some sort of view through a URL on that application.

66
00:04:51,990 --> 00:04:54,420
All right, so here I am at Visual Studio Code.

67
00:04:54,720 --> 00:04:57,400
Well, we're going to do is create our first application.

68
00:04:57,420 --> 00:05:02,400
We're going to write our first view, connect it through the URLs dot py file and then we'll actually

69
00:05:02,400 --> 00:05:03,810
visit the homepage.

70
00:05:03,840 --> 00:05:09,090
Again, we're gonna dive a lot deeper into things like views, URLs, templates and how that all works.

71
00:05:09,440 --> 00:05:12,930
Right now, we just want to do the very basis of creating an application.

72
00:05:13,440 --> 00:05:17,850
So the way we do that is first off, we have to make sure we're in the same directory as that man is

73
00:05:17,850 --> 00:05:24,390
dot py file so you can do lists to list if you are on Mac OS or Linux, or if you're on Windows, you

74
00:05:24,390 --> 00:05:31,350
type are run that and then just make sure that the output is going to match and say, OK, manage that

75
00:05:31,350 --> 00:05:31,670
pie.

76
00:05:31,980 --> 00:05:35,640
The reason this is so confusing sometimes is because recall we have these two folders.

77
00:05:35,880 --> 00:05:37,800
My site and my site with the same name.

78
00:05:38,070 --> 00:05:43,530
So often people are in the slower subdirectory of my site and they actually try to run managed up high,

79
00:05:43,710 --> 00:05:46,290
which is actually inside this upper level folder.

80
00:05:46,620 --> 00:05:50,070
OK, so I'm going to clear that out and let's run this.

81
00:05:50,070 --> 00:05:53,220
I'm going to say Python manage dot pie.

82
00:05:53,940 --> 00:05:58,830
And then what I'm going to do is, say, parsing the command line argument, start up.

83
00:05:59,130 --> 00:06:02,520
And let's call this my underscore app.

84
00:06:03,310 --> 00:06:04,060
Hit enter.

85
00:06:04,240 --> 00:06:11,580
And again, no output in the actual terminal, but you will see that we now get a new application,

86
00:06:11,590 --> 00:06:13,630
so we see we have my site.

87
00:06:13,690 --> 00:06:20,680
These are project level PI files and then we're going to end up having a folder up here called my app.

88
00:06:21,070 --> 00:06:25,720
And then we have in the admin apps, models, tests and views.

89
00:06:26,020 --> 00:06:29,290
And if we wanted to, we could keep creating more and more applications.

90
00:06:29,620 --> 00:06:34,720
So notice all your application folders are going to be underneath your very top level directory.

91
00:06:35,080 --> 00:06:40,210
And then along with that, you're going to have this folder that has your project level settings.

92
00:06:40,480 --> 00:06:40,870
All right.

93
00:06:40,900 --> 00:06:45,370
Now, before we actually end up creating a new view for application, I want to take a little bit of

94
00:06:45,370 --> 00:06:52,030
time to just go over in slide form what we're about to create as far as the files and directory structures.

95
00:06:52,420 --> 00:06:55,720
Don't worry too much if the rest of this lecture goes over your head.

96
00:06:55,960 --> 00:07:00,940
Pretty much all you have to learn from this lecture was that specific line of actually creating that

97
00:07:00,940 --> 00:07:03,850
app through the Python managed up high star app.

98
00:07:03,850 --> 00:07:07,300
And then your app name everything we're going to do right now for the rest of the lecture.

99
00:07:07,540 --> 00:07:12,580
We're going to start from scratch and then show and talk about views and URLs and applications in the

100
00:07:12,580 --> 00:07:13,570
next section of the course.

101
00:07:13,930 --> 00:07:15,760
But just so you're not completely off.

102
00:07:15,970 --> 00:07:19,690
Let me take a little bit of time to explain the three main things we're about to do inside of Visual

103
00:07:19,690 --> 00:07:20,350
Studio code.

104
00:07:21,070 --> 00:07:25,630
OK, so here I am back at the slides and we already learned that this critical line, which is pretty

105
00:07:25,630 --> 00:07:29,650
much the one thing I want you to learn from this lecture, which is in order to create new application

106
00:07:29,650 --> 00:07:33,340
you call Python, manage that PI start up and then your app name.

107
00:07:33,790 --> 00:07:35,560
Now what are we going to do for the rest of the lecture?

108
00:07:35,620 --> 00:07:41,230
We actually want to create a view inside an app and then connect it to the actual URL configuration

109
00:07:41,230 --> 00:07:43,420
in order to view that view.

110
00:07:44,080 --> 00:07:46,480
So how does this actually work inside our jingo project?

111
00:07:46,870 --> 00:07:53,440
Well, recall have the My Site directory, and that includes specific files that are running on a project

112
00:07:53,440 --> 00:07:58,930
level, so things like the settings on the project level or the administration on the project level.

113
00:07:59,110 --> 00:08:05,590
And then finally, the you are LS on a project level and that's going to come in handy later on.

114
00:08:06,280 --> 00:08:11,980
Now we also know I have the ability to create a bunch of applications app one, app two so on and so

115
00:08:11,980 --> 00:08:18,970
on, all the way to number of apps like a message app, a video app, etc. Now, in our specific example,

116
00:08:18,970 --> 00:08:25,330
we only have one application and for many simple Django projects, as you begin to learn Django, you're

117
00:08:25,330 --> 00:08:28,990
just going to be single application Django projects, which is OK.

118
00:08:29,440 --> 00:08:35,710
But something I want you to keep in mind is that this application is going to have its views that py

119
00:08:35,710 --> 00:08:36,130
file.

120
00:08:36,190 --> 00:08:42,280
And you can see that upon creating this application I've used up, my file was automatically created

121
00:08:42,280 --> 00:08:42,850
for you.

122
00:08:43,330 --> 00:08:49,870
Views, it turns out, is what's going to allow us to actually create something to be displayed inside

123
00:08:49,870 --> 00:08:50,620
your browser.

124
00:08:50,740 --> 00:08:57,520
You can think of a view as being analogous to a particular page on your website.

125
00:08:58,150 --> 00:09:00,190
Now what I could do is directly connect.

126
00:09:00,190 --> 00:09:05,050
This views that py file to the URLs on a project level.

127
00:09:05,470 --> 00:09:09,700
But as we get more and more applications, this could start to get pretty confusing.

128
00:09:09,970 --> 00:09:12,070
It depends on the scope of your project.

129
00:09:12,340 --> 00:09:16,900
It is also totally reasonable just to do this direct connection if the project is small enough.

130
00:09:17,260 --> 00:09:22,450
So you may see some projects just operate like this or the views are directly connected into URLs,

131
00:09:22,450 --> 00:09:22,990
not pie.

132
00:09:23,830 --> 00:09:31,810
However, for more complex projects, it probably makes more sense to create a URLs that py file inside

133
00:09:32,080 --> 00:09:38,650
the application and then organize things there to connect to the views and then connect that URLs that

134
00:09:38,650 --> 00:09:46,510
pie inside the application to the URLs that pie inside the site or project level directory.

135
00:09:46,840 --> 00:09:53,650
So you often see something working like this or working like this when you have a larger project where

136
00:09:53,650 --> 00:09:59,650
every single application not only gets its own set of views, but also gets its own set of routings

137
00:09:59,650 --> 00:10:04,540
and URL configuration, which is later on connected on a project level.

138
00:10:04,870 --> 00:10:08,500
And typically for larger projects, this is the easier way to organize things.

139
00:10:08,740 --> 00:10:12,880
That isn't to say that this approach is completely 100 percent incorrect.

140
00:10:13,090 --> 00:10:17,830
You will see this exists for smaller Django projects, but right now we're going to do is we're going

141
00:10:17,830 --> 00:10:23,770
explore this particular organization structure, which is to create a view inside an application, rooted

142
00:10:23,770 --> 00:10:29,560
it with its own URLs that pie file inside that application and then connect that to the project level

143
00:10:29,590 --> 00:10:30,250
URLs.

144
00:10:30,640 --> 00:10:36,070
Keep in mind the URLs that py file for the application is not automatically created for us, so we'll

145
00:10:36,070 --> 00:10:37,900
have to construct that and create that ourselves.

146
00:10:38,200 --> 00:10:38,530
OK?

147
00:10:38,680 --> 00:10:43,720
Let's head back to Visual Studio code and complete these three main steps of creating the view cream

148
00:10:43,720 --> 00:10:47,140
the URLs for the application and connecting that on a project level.

149
00:10:48,040 --> 00:10:50,590
All right, so here we're back at Visual Studio code.

150
00:10:50,980 --> 00:10:58,840
I'm going to open up my app, open up views, Dot Pi and let's create our first view.

151
00:10:59,440 --> 00:11:04,180
There are many different types of views we can create, such as function based views or class based

152
00:11:04,180 --> 00:11:04,600
views.

153
00:11:04,990 --> 00:11:09,520
We will eventually move on to class based views, but for right now, just to learn the basics, we're

154
00:11:09,520 --> 00:11:14,170
going to start off with kind of the simplest view possible, which is going to be a function.

155
00:11:14,740 --> 00:11:16,300
We're going to call this function index.

156
00:11:16,540 --> 00:11:23,590
It takes in a request to actually check out that view, and then we're going to return an HDP response

157
00:11:24,100 --> 00:11:25,400
to actually return that response.

158
00:11:25,420 --> 00:11:27,340
I do need to import this from Django.

159
00:11:28,930 --> 00:11:35,000
So we say from Django, the 8TB import http response.

160
00:11:35,020 --> 00:11:40,870
You can actually see we can actually return back things like a for a for a bad request, forbidden,

161
00:11:40,870 --> 00:11:43,390
etc. So lots of things you can actually return here.

162
00:11:43,690 --> 00:11:48,910
But we're just going to return a response which we can then pass in a string to and then that will display

163
00:11:48,910 --> 00:11:49,860
on the actual page.

164
00:11:49,900 --> 00:11:50,890
So we're going to return.

165
00:11:51,840 --> 00:11:54,300
HTP response and then say.

166
00:11:55,300 --> 00:11:55,900
Hello.

167
00:11:56,410 --> 00:11:59,920
This is a view inside my app.

168
00:12:01,030 --> 00:12:04,930
OK, so we save this and we have our very first view.

169
00:12:05,320 --> 00:12:11,380
Again, we'll cover views and a lot more detail later on, but our returning is a simple HTP response.

170
00:12:12,010 --> 00:12:16,750
Then we're going to do is inside my app directory.

171
00:12:17,170 --> 00:12:22,060
I'm going to create a new file and this file will be URLs dot pie.

172
00:12:22,570 --> 00:12:27,970
Make sure to create this inside my app, not inside my site, since that already exists.

173
00:12:28,450 --> 00:12:29,830
So again, look at the pathway.

174
00:12:29,830 --> 00:12:30,380
I'm out here.

175
00:12:30,400 --> 00:12:31,900
My site, my app.

176
00:12:32,080 --> 00:12:33,340
Your URLs, dot pi.

177
00:12:34,000 --> 00:12:42,520
Then what we're going to do is the following I'll say from jingo dot URLs import path.

178
00:12:43,510 --> 00:12:49,810
And because I'm in the same directory as my views inside my app, I can simply say from the import.

179
00:12:51,540 --> 00:12:56,790
Views the other way you could do this to say from views import index, but typically you do it this

180
00:12:56,790 --> 00:12:59,910
way so you don't need to call each individual of you by name.

181
00:13:00,450 --> 00:13:02,580
Then we set up a Europe patterns list.

182
00:13:02,760 --> 00:13:03,390
So I say you are.

183
00:13:03,390 --> 00:13:09,000
All patterns is equal to a list and then you pass in the paths you want inside that list.

184
00:13:09,300 --> 00:13:10,950
We really only have one view.

185
00:13:11,070 --> 00:13:12,150
So I'm going to say path.

186
00:13:12,960 --> 00:13:15,990
We pass in the string routing, which will be an empty string.

187
00:13:16,140 --> 00:13:22,140
You'll see why later than we pass in the view we actually want to show that is that HDP response.

188
00:13:22,590 --> 00:13:27,420
So we say views that index, remember our already imported views.

189
00:13:27,840 --> 00:13:32,010
And then after that, you give it a string name, which will be more important later on.

190
00:13:32,010 --> 00:13:36,630
But right now we'll just match it to the actual function name, which is typical.

191
00:13:37,640 --> 00:13:42,080
OK, so we have your patterns and then we connected this path.

192
00:13:42,440 --> 00:13:48,200
It's just going to be an empty string, which essentially means this is going to show up at forward

193
00:13:48,200 --> 00:13:55,520
slash my apps when we later connect it to the project level URLs that PI file and you'll see how it

194
00:13:55,520 --> 00:13:56,600
do that in just a second.

195
00:13:56,960 --> 00:13:58,430
Remember to save these changes.

196
00:13:59,360 --> 00:14:04,460
Then finally, we're going to open up your old stock pie and there my site says the project level.

197
00:14:04,490 --> 00:14:05,420
You're all not pie.

198
00:14:05,840 --> 00:14:09,710
You'll notice it actually has a bunch of directions on how to set up your views.

199
00:14:10,160 --> 00:14:17,420
There is a function of use class based views and then including another URL configuration, which is

200
00:14:17,420 --> 00:14:19,190
technically what we're doing in this last one.

201
00:14:19,700 --> 00:14:29,120
So in the My App URLs pie, we set up a function based view connected to the URLs, which was actually

202
00:14:29,180 --> 00:14:34,280
kind of the first instructions here, which is say, OK, import that particular view and then set up

203
00:14:34,280 --> 00:14:34,760
the path.

204
00:14:35,030 --> 00:14:39,920
You could technically do this a project based level and just set up views based on the project and not

205
00:14:39,920 --> 00:14:41,480
even use Django apps.

206
00:14:41,900 --> 00:14:48,050
Depending on how big your site is next, what we could do is separate out those URLs, as I mentioned

207
00:14:48,050 --> 00:14:51,730
inside of my app, which then means we follow these directions.

208
00:14:51,740 --> 00:14:57,800
We import the include function and then we just set up the path to include the URLs that phi pie file

209
00:14:57,800 --> 00:14:58,820
for the application.

210
00:14:59,060 --> 00:15:04,220
So we can come back up here and follow the directions and not import just path, but also import include.

211
00:15:05,470 --> 00:15:11,650
And then I'll connect the application URLs up high file to my project URLs that profile.

212
00:15:11,680 --> 00:15:12,700
This is quite simple to do.

213
00:15:13,060 --> 00:15:14,110
We simply say path.

214
00:15:14,920 --> 00:15:15,700
And then what?

215
00:15:15,700 --> 00:15:19,750
Routing we want all those URLs to go to, which would probably go under my app.

216
00:15:21,070 --> 00:15:27,160
And let's make sure it doesn't start with a backslash that's automatic, it should end with a forward

217
00:15:27,160 --> 00:15:27,520
slash.

218
00:15:27,550 --> 00:15:28,030
There we go.

219
00:15:28,600 --> 00:15:31,270
And then we're going to pass in include.

220
00:15:33,310 --> 00:15:40,210
And here we put in my app, the URLs, we just passed the Senate as a string Django Jingo smart enough

221
00:15:40,210 --> 00:15:45,070
to connect, Oh, you have an application called My App Folder and then inside there you have a URL

222
00:15:45,070 --> 00:15:45,880
stop py file.

223
00:15:46,030 --> 00:15:48,280
So that's all done automatically by Django.

224
00:15:48,550 --> 00:15:52,540
Again, don't worry too much if this line is going over your head, we're going to talk about it in

225
00:15:52,540 --> 00:15:53,740
a lot more detail later on.

226
00:15:54,100 --> 00:15:58,510
Lastly, don't forget this comma because this is a list you don't want actually get some sort of syntax

227
00:15:58,510 --> 00:16:00,610
error with that URL patterns list.

228
00:16:00,880 --> 00:16:01,840
Save that chains.

229
00:16:01,870 --> 00:16:04,180
And we should be good to go as quick review.

230
00:16:04,540 --> 00:16:08,500
We created a very simple, function based view inside of my app.

231
00:16:09,040 --> 00:16:12,940
I created a new URLs that file also inside of my app.

232
00:16:13,420 --> 00:16:21,250
Then I used my site level or project level URLs that profile and included and connected the other URL

233
00:16:21,250 --> 00:16:24,670
configuration through these following lines of code.

234
00:16:25,240 --> 00:16:29,290
Next, we're going to do is actually run the server, make sure you've saved all your changes and say

235
00:16:29,290 --> 00:16:32,800
Python managed pie run server.

236
00:16:34,150 --> 00:16:34,850
Hit enter.

237
00:16:35,710 --> 00:16:38,920
And you should see maybe a warning about an applied migration.

238
00:16:38,950 --> 00:16:41,960
Don't worry about that right now, since we're not working off any models.

239
00:16:41,980 --> 00:16:45,940
Just go to one two seven zero zero eight thousand.

240
00:16:47,710 --> 00:16:49,330
And I'm going to bring that right now.

241
00:16:50,470 --> 00:16:51,670
And let me bring that in.

242
00:16:52,090 --> 00:16:57,940
So you may get something that says if you just go to that homepage saying, Hey, page not found four

243
00:16:57,940 --> 00:16:59,260
or four, I don't see anything.

244
00:16:59,350 --> 00:17:04,839
And recall, that's because right now we only have views connecting to my app.

245
00:17:05,140 --> 00:17:10,780
So actually, say the following forward slash my app for slash hit enter.

246
00:17:11,109 --> 00:17:12,700
And now you actually see.

247
00:17:13,000 --> 00:17:13,480
Hello.

248
00:17:13,510 --> 00:17:15,369
This is a view inside my app.

249
00:17:15,849 --> 00:17:21,220
So clearly still a lot more to learn because we don't want the Project Home page to just be, Hey,

250
00:17:21,220 --> 00:17:22,800
this empty thing.

251
00:17:22,810 --> 00:17:26,920
So we still have to connect other views for kind of a project level homepage.

252
00:17:27,250 --> 00:17:33,610
But we do see how we connected a separate application on a project based level, so there's still a

253
00:17:33,610 --> 00:17:39,460
lot more to come on views and URLs, projects versus applications, et cetera.

254
00:17:39,490 --> 00:17:44,710
But you get the idea of how you would be able to break up your project into multiple applications,

255
00:17:44,950 --> 00:17:50,670
and each application could include its own views and its own URL routing configuration filing.

256
00:17:51,140 --> 00:17:53,680
OK, that's it for this lecture.

257
00:17:53,950 --> 00:17:55,090
I'll see you at the next one.