Original subtitles

We learned the four main concepts that really made react take off.

It gave developers a whole new way to think about their applications and how we built them, and it

was architected in such a way that it made building large scale applications a lot more pleasant than

what we had before.

Now, since then, a lot of libraries have come out that have taken some of the concepts.

Angular was rewritten to a new version that is more in line with these concepts.

Libraries like View are also using these concepts because people have realized that these are some really

good principles.

So now you have things like react angular view that developers are using to build front end applications.

But react really had this initial jump and it's still the most popular library and the library with

the most job demand because it was the first to introduce these principles and the beauty.

Is that although we haven't written any code, you've now learned a little bit about some of the key

words that will encounter throughout this course, and don't worry, you're not supposed to get them

100 percent just now because all of these things are something that we need to practice code and build

projects with to really understand them.

But now when you hear the words like declarative components, state props, virtual dom, you'll have

an idea of what it is, because we've learned that react is a declarative paradigm.

That is, instead of telling our APS exactly what to do, we simply give it some state, some components

that are built with something called.

And these components sometimes receive properties which are called props, we give all that information,

a giant JavaScript object in a declarative way, which creates a virtual dom in JavaScript, and that

virtual dom is used by the React Library to update the DOM for us in a declarative way.

But your question is this how do I become the best reactive helper I can be?

And to be a great reactive helper, it actually comes down to three things, three things that really,

really good senior reactive helpers do well, and we're going to focus on these three skills throughout

the course.

The first one is to decide on components really good reactive Alpers, decide what is a component,

how much do we want to break down a component?

How do we build these reusable components as we've seen?

And deciding on how to break down the app into different components is a very important skill.

The next thing is to decide the state and where it lives.

Now we're going to explore this idea of state or data or app a lot more.

But this state can live in different locations in our virtual dorm.

So whether we put the state here or we put the state here or here or here or in multiple locations,

that decision is very important in architecting your app.

And really good developers do a really good job placing state in the appropriate component.

The third is what changes should we make when the state changes based on what this JavaScript object

called state is changed, we have to decide what to render, what part of the virtual dom changes.

And deciding on this is also important because it has huge effects on performance.

Now, don't worry, these are the things that we're going to really work on, but I want you to keep

this as a reference, because if you want to become a senior developer, these are the things that you

have to become really good at making these decisions and knowing when something is good, when when

something is bad.

We're going to explore that and a lot more.

The next section I'll see in the next one by.