As you can probably tell by now,
JavaScript is an extremely important programming language
as a web developer
because we can use it both in the browser,
so on the frontend, as well as on the backend
when we write server-side code with Node,
and possibly with Express as a third-party library
as we did it in the previous sections.
Therefore, since JavaScript is that important,
in this course section,
we are going to dive deeper into it.
And I explicitly wanna emphasize
that we are diving into advanced JavaScript in general.
What you'll learn in this course section applies
to both the browser side, so frontend JavaScript
if you use JavaScript in the browser,
as well as backend server-side JavaScript with NodeJS.
And I mean, in general, up to this point,
the vast majority of things you saw applied
to both sides; the key certain tags,
and the core features apply to both sides.
It's only specific functionalities,
like requiring our files as we did it
in the previous sections, requiring packages,
working with something like the file system;
these are things which are exclusive to NodeJS.
But working with constants, with functions,
loops, if statements;
that is all general JavaScript code.
And in this course section as mentioned,
we are going to dive deeper into general JavaScript code.
Now for that, in this course section,
we are going to take a closer look at Functions again,
and learn about some new features,
and concepts are related to functions.
And we will also take another look at Objects
and Arrays and learn a couple of new things
about those concepts.
We are also going to take a look
behind the scenes of JavaScript,
and take a look at Reference and Primitive Values,
and learn what exactly that is, and why it matters,
and why you should understand it.
And last but not least, we are also going to explore
a concept called Asynchronous Code:
Something we haven't really used up to this point,
but something we will often need,
especially when writing NodeJS code,
but also in certain scenarios on the frontend
which we'll explore later in the course.
In this course section,
I'm going to introduce you to Asynchronous Code,
show you what that is, and how we can write
such asynchronous code with JavaScript.
Now, there's one important thing about this module
which I wanna get out of the way right away:
This course section will be challenging.
There are many advanced concepts in here,
which I will explain as simple examples,
but because the examples are simple,
it will not always be easy to see why that concept exists.
Because of those simple examples,
we don't really face any problems that would be solved
by these more complex concepts.
Now, we'll see the more problematic cases
later in the course.
But in order to then tackle them appropriately,
I already wanna introduce these more advanced concepts
here since later course sections will
mainly focus on other tasks.
But therefore, don't feel overwhelmed
if some concept or the reason for the existence
of some concept is not immediately clear
in this course section.
We'll see all the concepts taught in this section
over and over again in later course sections again.
And therefore, this course section here
also acts kind of like a reference
for a later course sections.
And you can come back to this course module
if some concepts taught in this module should still be
unclear at a later point in the course.
Attached to the last lecture of this course section,
you also find a written summary, a cheat sheet
which you can also use to look up certain concepts
at a later point of time or to also have
a written version in case the videos are not enough.
Now for all of that,
I'm in a brand new empty project,
and we will write some JavaScript code here,
which we execute with Node,
but we will not build a complete Node web server;
instead, we'll just leverage the fact
that we can use the Node command to execute
JavaScript files since that saves us the hassle
of adding an extra HTML file,
which we then have to open and evaluate
in the browser all the time.
Nonetheless, as emphasized everything
I show you here applies to both the browser side,
as well as the backend.