Name: NodeJS Internals and Architecture
Price: 9 USD
Availability: InStock

My favorite part of engineering is making complex systems transparent and understandable.

Node.js is one of the most popular runtimes for server development, yet it often remains a "black box" even for experienced developers. I myself have felt this many times.

This course is the result of months of work on dissecting the architecture and internal mechanisms of Node.js. It is designed for those engineers who cannot work with something opaque.

This course is for you if you:

Want to understand what's happening "under the hood" of Node.js
Enjoy dissecting one line of code into hundreds of lines of implementation
Wonder why the behavior of a Node program is sometimes unpredictable
Want to know why a Node process can terminate - or not terminate
Are curious why Node sometimes takes a long time to start
Value cross-platform compatibility and want to learn how Node works on all OS

For instance, by knowing how the HTTP module is constructed, you will be able to write a server that handles more requests. Understanding the event loop and its phases will allow you to restructure code logic for improved performance and stability.

If your code "crashes" 1% of the time for reasons that aren't clear - this course will give you an understanding of how to make program behavior predictable. Not with chaotic "quick fixes," but through a deep understanding of the internal workings of Node.

The course will teach you to go in the same direction as Node, rather than "fighting" with its mechanisms.

The course program includes:

Node.js Architecture

Phases of the event loop and what happens in each of them
How promises work and why they are just "new type of callbacks"
Module loading and its impact on performance
The structure of Node packages and how it affects your code

Inside Node.js

How Node implements asynchronous I/O through libuv
Protocols and their implementation in Node
Streams and processes: how Node handles concurrency at the OS level

Optimization and Performance

Tips on speeding up code based on architectural understanding
How to identify "bottlenecks" and work with them
When and how to use C++ extensions if JavaScript is no longer sufficient

This course is designed for developers with an intermediate level of knowledge in Node.js who want to deepen their understanding of its architecture and increase their confidence in working with it.

It's advisable to have a general understanding of OS basics, although this is not strictly necessary.

About the Authors

Hussein Nasser

At the beginning of my career, over 20 years ago, I was developing applications that worked with databases without fully understanding how they functioned internally. Performance issues, data races, and even data corruption often left me puzzled. I decided to understand how database management systems truly work—right down to comprehending each query sent from the application, its execution in the database, and which actions should be framed as transactions versus atomic operations. Since then, I have been fascinated by a deep understanding of internal processes in software. If you follow me here, you'll see analyses of backend architecture, databases, and operating systems. If you're interested in "what happens under the hood," I think you'll enjoy my courses.

udemy

By connecting students all over the world to the best instructors, Udemy is helping individuals reach their goals and pursue their dreams. Udemy is the leading global marketplace for teaching and learning, connecting millions of students to the skills they need to succeed. Udemy helps organizations of all kinds prepare for the ever-evolving future of work. Our curated collection of top-rated business and technical courses gives companies, governments, and nonprofits the power to develop in-house expertise and satisfy employees’ hunger for learning and development.

Watch Online 43 lessons

0:00

#1: Introduction

All Course Lessons (43)

#	Lesson Title	Duration
1	Introduction Demo	01:57
2	Who this course for?	03:06
3	Course Data	00:50
4	Course Outline	06:59
5	What do you need?	06:24
6	Node JS Architecture Intro	09:30
7	Interpreted Languages and V8	49:02
8	The Event Loop	24:14
9	The Main Module	19:39
10	Timers Phase	26:11
11	Pending Callbacks Phase	14:03
12	Idle, Prepare Phase	18:23
13	Poll Phase (Updated)	47:49
14	Check Phase	23:07
15	Close Callbacks Phase	24:08
16	Process.nextTick	16:46
17	How Promises work under the hood	22:44
18	Require, Import Event	34:12
19	Anatomy of Node Packages	32:35
20	When does Node terminate?	20:31
21	Node Internals Section Intro	06:42
22	libuv Overview	08:05
23	Asynchronous IO in the Operating System	29:35
24	Inside Node Network IO	43:36
25	Inside Node File IO	51:51
26	Inside Node HTTP	01:14:04
27	Inside Node HTTPS	01:00:56
28	Inside Node DNS	48:00
29	Inside Node TCP	48:37
30	Inside Node UDP	34:03
31	Inside Node Streams	01:03:12
32	Process vs Thread	01:00:38
33	Worker Threads	51:55
34	Child Process and Cluster	36:31
35	Optimization Section Intro	13:23
36	Node Performance	39:36
37	Debugging NodeJS	08:07
38	Capturing Node's Traffic	32:36
39	Request modules performance showdown	22:24
40	C++ Add-ons	39:22
41	Course Summary	08:39
42	Proxy vs Reverse Proxy	20:06
43	Memcachd and NodeJS	01:05:48

Unlock unlimited learning

Get instant access to all 42 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription