All right, my friends, I think that we understand the basics of sex pretty well.
So in this video, we're going to start to move on to our next big topic.
Now, I'm really excited for this section and the next couple of videos because this is where we get
to start taking the training wheels off and start to write a lot more code and move more quickly.
So let's talk about what we're going to be covering in this video and the next couple.
All right, here we go.
So three big, important concepts for us to understand.
Component nesting reusability and configuration.
These are all tenets of the react ecosystem.
And they're going to govern how we design react applications.
Let's talk about each one of these in turn and then we'll go through a couple of quick code examples.
So first off, component nesting so far throughout all the code you and I have written, we've only
been creating one component at a time.
But for a real react application, we usually make many different components.
When we make many different components, we then nest them or essentially place them in each other to
make an actual usable react application.
So we're going to very quickly start to look at a couple examples of how we nest different components
inside of each other.
The next thing we're going to start to discuss is component reusability.
I want you to think about a typical Web application that you might use every single day.
Chances are you use a Web application that has some buttons or text fields or menus inside of it.
Now, I got a quick question for you.
Do any of those buttons really look different from each other?
Well, chances are they don't.
Just about every button inside of a single react application is always going to have some very similar
and identical functionality.
It's going to show some text and then do something when a user clicks on it.
So rather than making a separate component or essentially write out some different code for every single
button or every single menu or every single text input that you might put into an application, we instead
strive to make reusable components or little pieces of code that can be reused several different times
inside of our single application.
Again, we'll take a look at a couple of examples on how we might achieve reusability.
And then finally, and this is very tightly coupled with reusability component configuration.
So I just gave you an example of a button.
Yeah, most buttons look very similar, but there's little tiny pieces about every single button that
need to be customized in some very specific way.
For example, one button might need to have the text submit and another button might need to have the
text click on me.
And both those buttons might need to do different things.
So we need to make sure that when we create different components, we have the ability to somehow customize
them when they are created.
All right.
So these are the three big topics that we're going to start to dive into.
And like I said, I'm really excited because this is where things start to get really interesting.
So let's take a quick pause right here.
When we come back, the next section, we're going to start talking about nesting reusability and configuration.