Instructor: Now, in order to set the stage
for the next couple of lectures,
let's start by learning a bit about Node architecture.
So let's represent that architecture here
in terms of Node's dependencies,
which are just a couple of libraries
that Node depends on in order to work properly.
So the Node run time has several dependencies,
and the most important ones are
the V8 (mumbles) engine and libuv.
Now we said before that Node is a JavaScript run time
based on Google's V8 engine, right?
And so, that is why it appears here as a dependency.
If it wasn't for V8, Node would have absolutely no
way of understanding the JavaScript code that we write.
And therefore, V8 is a fundamental part
in the Node architecture.
So again, the V8 engine is what converts JavaScript code
into machine code that a computer can actually understand.
Okay, but that alone is not enough to create a whole
server side framework like Node.
And so that is why we also have libuv in Node.
And libuv is an open source library with a
strong focus on asynchronous IO.
So, input output.
This layer is what gives Node access to the
underlying computer operating system,
file system, networking, and more.
Besides that, libuv also implements two extremely
important features of Node.JS
which are the event loop and also the thread pool.
And in simple terms, the event loop is responsible
for handling easy tasks like executing call backs
and network IO while the thread pool is for more heavy work
like file access or compression or something like that.
But you'll learn all about that,
so about the event loop and the thread pool,
in the next couple of videos.
One important thing to note here
is that libuv is actually completely written
in C++ and not in JavaScript.
And V8 itself, also uses C++ code besides JavaScript.
So therefore, Node itself is a program written
in C++ and JavaScript and not just in JavaScript
as you might expect, right?
Now the beauty of this is that Node.JS ties all
these libraries together, no matter if written
in C++ or JavaScript and then gives us
developers access to their functions in pure JavaScript.
So it really provides us with a very nice layer
of abstraction in order to make our lives a lot easier
instead of us like having to mess with C++ code.
That would be a terrible experience, right?
So again, this architecture allows us to write
100 percent pure JavaScript code,
running in Node.JS and still access functions like
for file reading, which behind the scenes are
actually implemented in libuv or
other libraries in the C++ language.
And speaking of other libraries,
Node does actually not only rely on V8 and libuv,
but also on http-parser for parsing http,
c-ares or something like that for some DNS request stuff,
OpenSSL for keptography, and also zlib for compression.
And these are not that important to understand, alright?
So in the end, when we have all these pieces nicely
fit together, we end up with Node.JS ready to be used
on the server side all four applications.
And next up, you will learn more about threads
in Node and the thread pool.
So stay tuned for that one.