Now that we've got some initial set up of our application complete, we can start to think about writing
code for our actual application.
So in this video, I want to focus on the overall project structure we're going to use in general for
all the applications you and I are going to build.
We're going to create a collection of different files.
Every different file is going to contain one single class in each of those classes represents one different
thing inside of our project.
Now, in some cases, I'm going to have you kind of figure out the different schema or the different
classes we're going to create.
But in this case, we're going to do it together.
So when I look at this mock up right here, I really see three different things going on.
I see one type of object for our user.
So I think we should probably create a single file called Class Dot or some user dots that will hold
a user class inside of it.
That user class is going to have some methods and properties associated with it that define exactly
what it means to be a user.
Next up, I see a company thing inside of here as well, so likewise, I think we should create a separate
file to house a company class that will also represent what a company is inside of our application.
And then finally, the last obvious piece that we have here is the map itself.
So I think we should probably create some separate file that's going to hold a class to represent the
map and probably have some methods attached to it to actually get the map to show up on the screen and
render some markers on it.
So in total, I think we've got three separate classes here.
We've got like a map file, a user file and a company file then to actually get all these different
classes to work together.
We will import them into our route indexed dots file, and that's where we're going to actually initialize
our project, create a map, create a user, create a company and have some code to actually show the
user and the company on that map.
So that's the general idea.
So right now, let's get started on our users, it's back inside my code editor.
I'm going to find my SIRC folder, and inside there I'm going to make a new file called User Dotts.
And one thing I want to point out right away, you'll notice that I called the file index starts with
a lowercase I but user I labeled with a capital U.
So what's with the difference there?
Well, by convention, any time we have a file whose primary purpose is to create and export a class,
we're usually going to give it a capital name.
So in this case, capital, you user, because we're going to create and export a class from this file.
However, in index tortillas, we're not going to have any classes.
We're going to have just some code to import some classes and then use those to actually make something
happen.
You're going to most commonly see lower case file names any time you have a file that either serves
as something like the index dots file.
So like kind of the root of your application where a file that exports plain objects, plain functions
or constants.
All right, so now we've got the user doctor's file.
I'm going to get started inside of here by declaring a new class called User Like So.
And that's where we're going to leave it for right now, so let's take a quick pause with just this
inside of here.
By the way, if you see any air inside of this file right now, when we save this, that's totally fine.
We're going to fix it up in just a second.
So let's take a quick pause right here.
And I'll see you in just a minute.