- So at this point, you're probably wondering what all of these different files and folders are specifically for, but that's a lot of information to digest

at one particular point in time. So let's go and walk through it slowly, focusing specifically on the essentials at this point in time. So if we bring our terminal back up here,

we can see our server's still running. If we stop our server, let's clear our browser out and let's start it back up again, npm run dev. But let's watch what happens within the terminal

immediately after we run this command. It'll show just for a split second, but you'll see something actually happens. You'll see it runs a command, then it runs through some stuff that happens relatively quickly.

And then once we get to this point, our server's booted and ready to receive requests. That brief point in time between us running our command and this final info stating that our server's ready

is called the boot process. Small portions of our actual project structure actually play a part within that boot process. Although our AdonisJS server has one primary purpose,

which is to serve our web application that we'll be building, there's actually multiple different purposes that it could be started for. There is the command line interface called ACE that AdonisJS has.

So our server could be started specifically for ACE commands that are running. There is also a test environment that AdonisJS can start in from YAPA. So there's really three different environments

that our server could be starting for. And there's an entry point for each one of those within our bin. So you'll see console, which is for the ACLI, server, which is for our web server,

and test, which is for the YAPA tests. So within the boot process, whenever we start our server up, the first place it's going to hit within our project structure is the bin directory. One of these three files will execute

to actually start the underlying boot process for our server. And then once our server reaches the boot process, it will move out of the bin folder. And its next stop is gonna be the start directory.

The start directory is really all about registration. It's where we're gonna be registering our routes, middleware, events, so on and so forth. At the start of our project, if we go ahead and expand this folder,

you'll see that we have an env.ts, kernel, and a routes file. We'll talk more about the env.ts and kernel later on, but at a high level, the env.ts

is where we can define type safety requirements for underlying environment variables, which are defined within our .env file. If our .env file does not match the restrictions

that we have set within the env.ts, our server will fail to boot and it will warn us about the missing environment variables. This is really a safeguard measure

to prevent your server from starting without necessary information needed for it to run successfully. And then we have the kernel.ts, which is primarily for our middleware registration,

but it also registers our global exception handler as well. Again, more on those two later on. Finally, the routes file is probably the one

that you care about most at this point in time. It's where our route definitions are gonna take place. And if we take a look at this, we'll see one route already exists,

and that route is what's in charge of showing our homepage that displays it works. So if we hide our browser back away, we'll see that this reads pretty much like plain English. We have a router.

Whenever that router receives a request to slash, which is also known as our homepage, then it's telling it to render the file at pages/home.

Now, whenever we talk about render within our project, that's gonna be going through the EdgeJS template system. And by default, anytime that we provide page paths,

like we are right here with pages/home, it's gonna look for those within the resources directory. The resources directory contains our pages

as well as uncompiled CSS and JavaScript. Edge won't just look within resources though, it's also going to dive into the views directory. So if we expand our views directory,

there's our pages directory right there, and there's our home.edge file within there. So we can go ahead and give this page a click, and there's the HTML that makes up the page that we see within our browser,

specifically noted by the it works right here. Now, it's at this point in time, you might be realizing that your document doesn't quite look as colorful as mine.

It might be all one color. That's where extensions come into play for Visual Studio Code. We'll talk about that in the next lesson.