CF

Understanding Node.js: Core Concepts

76h 58m 3s
English
Paid

Understanding Node.js: Core Concepts is a 221-lesson 76 hours 58 minutes self-paced course by Udemy. Understanding Node.

Course facts

Lessons
221
Duration
76 hours 58 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

Understanding Node.js: Core Concepts teaches you how Node.js works under the hood. You will study buffers, files, streams, networking, HTTP, and core back-end ideas without depending on extra NPM packages.

Course Overview

This course focuses on Node.js fundamentals and computer science basics. You will learn the ideas that help you build stronger back-end systems.

You will not start with Express or large frameworks. Instead, you will use Node.js core modules and learn what those tools are built on.

The goal is to help you understand Node.js at a lower level. This makes it easier to debug apps, read docs, and choose the right tools.

What You Will Learn

Each section works like a small course. You will study one core topic, then use it in code.

  • How buffers store and change binary data
  • How Node.js reads, writes, and manages files
  • How streams handle large data with low memory use
  • How TCP, UDP, DNS, and IP addresses work
  • How HTTP works on top of TCP
  • How web frameworks handle requests and responses
  • How to deploy simple Node.js apps on a Linux server

Core Node.js Topics

Buffers And Binary Data

You will learn what buffers are and why Node.js uses them. Buffers help you work with binary data such as files, network packets, and raw bytes.

This section gives you the base you need for streams, networking, and HTTP. You will learn how to read and change binary data directly.

File System Module

Back-end apps often work with files. You may save data, read logs, handle uploads, or process large files.

You will learn how Node.js handles files through the fs module. You will also practice common file tasks in real code.

Streams And Large Data

Streams help you process data in chunks. This lets your app work with large files without loading everything into memory.

You will build small projects that use streams in practical ways. One project is an encryption and decryption app that changes binary data directly.

This section prepares you for network apps. Streams are a key part of fast and memory-safe Node.js systems.

Networking Basics

Node.js was built for network applications. This section explains the network ideas you need as a back-end developer.

  • What a network is
  • How the internet works
  • MAC addresses
  • IPv4 and IPv6 addresses
  • TCP
  • UDP
  • DNS
  • Basic deployment steps

You will build a chat app and a file uploader using only Node.js. Both apps run directly on top of TCP.

You will also inspect network traffic with Wireshark. This helps you see the bytes sent between machines.

HTTP From TCP Up

This section connects everything you learned before. You will study HTTP from the TCP layer up.

You will learn about clients, servers, requests, responses, methods, status codes, MIME types, and headers. You will also see how these parts move across a network.

Then you will build a simple HTTP-like protocol with the net module. This helps you understand what happens during a request and response.

Build Your Own Framework

After you understand HTTP, you will build a small web framework. This shows how tools like Express work at a basic level.

You will handle routing, request bodies, responses, and common web app tasks. Then you will use your framework to build a working web application.

This approach makes NPM packages easier to understand. You will know what problems they solve and how they may work inside.

Projects You Will Build

  • Binary data examples with buffers
  • File system tools with the fs module
  • Stream-based data processing projects
  • An encryption and decryption app
  • A TCP chat app
  • A TCP file uploader
  • A basic HTTP implementation
  • A small Node.js web framework
  • A web app built with your own framework

Who This Course Helps

This course is for developers who want to understand Node.js beyond basic web servers. It also helps students who want clearer back-end fundamentals.

You should know basic JavaScript before starting. You do not need deep Node.js experience, but you should be ready to study low-level ideas.

Why These Concepts Matter

Frameworks change often, but core ideas last longer. Buffers, streams, files, networking, and HTTP are part of many back-end systems.

When you understand these ideas, you can debug problems with more confidence. You can also learn new tools faster because you know what they build on.

Who teaches Understanding Node.js: Core Concepts? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Understanding Node.js: Core Concepts?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 221 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1.1. Course Overview
All Course Lessons (221)
#Lesson TitleDurationAccess
1
1.1. Course Overview Demo
29:44
2
1.2. Setting Up - For Windows Users Only
49:41
3
1.3. Setting Up - For Mac Users Only
59:57
4
1.4. Setting Up - For Linux Users Only
53:06
5
1.5. Introduction to the Command Line
40:47
6
1.6. Learning NVM & Node.js Versions
15:24
7
1.7. Node.js Under the Hood
01:36:02
8
2.1. Understanding EventEmitter
34:06
9
3.1. Introdcution
06:48
10
3.2. Understanding Binary Numbers
13:32
11
3.3. Understanding Hexadecimal Numbers
21:10
12
3.4. Using a Programming Calculator
11:49
13
3.5. Understanding Character Encodings
25:21
14
3.6. The Concept of Buffers
07:35
15
3.7. Buffers in Action
38:47
16
3.8. Allocating Huge Buffers
18:15
17
3.9. Fastest Way of Allocating Buffers
20:59
18
3.10. Reading the Node.js Docs
14:02
19
3.11. Outro
02:09
20
4.1. Introduction
11:19
21
4.2. What Exactly Is a File
07:32
22
4.3. How Node.js Deals with Files
04:06
23
4.4. Three Different Ways of Doing the Same Thing
14:43
24
4.6. Watching the Command File for Changes
13:33
25
4.7. Reading the Content of the Command File
18:41
26
4.8. Cleaning Up the Code using EventEmitter
04:23
27
4.9. Making Sense Out of the Read Data
03:54
28
4.10. Implementing the Create File Command
15:37
29
4.11. Defining the Rest of the Commands
15:21
30
4.12. Solution - Implementing the deleteFile Function
11:07
31
4.13. Solution - Implementing the renameFile Function
03:39
32
4.14. Solution - Implementing the addToFile Function
11:07
33
4.15. Outro
01:07
34
5.1. Introduction
04:52
35
5.2. Benchmarking Writing a Million Times to a File
26:26
36
5.3. Using Streams Naively in Our Solution
07:58
37
5.4. So What Exactly Are Streams
08:59
38
5.5. Understanding Different Types of Streams
17:53
39
5.6. Fixing the Memory Issue in Our Program
36:55
40
5.7. Reading Writable Streams Node.js Docs and Recap
09:49
41
5.8. Readable Streams in Action
21:36
42
5.9. Selectively Writing Our Data from the Readable Stream
09:18
43
5.10. Understanding the Splitting Issue
16:57
44
5.11. Implementing the Solution and Resolving the Splitting Issue
16:28
45
5.12. Reading Node.js Docs and Recap
08:04
46
5.13. Building Our Own Streaming Solution Using Buffers
23:31
47
5.14. Understanding Piping
25:43
48
5.15. Implementing Our Own Writable Stream
42:29
49
5.16. Implementing Our Own Readable Stream
20:02
50
5.17. Understanding Duplex and Transform Streams
17:27
51
5.18. Creating an EncryptionDecryption Application
39:03
52
5.19. Final Notes
26:05
53
6.1. Introduction
12:00
54
6.2. Understanding MAC Addresses and Switches
15:03
55
6.3. Understanding Routers and How the Internet Works
15:16
56
6.4. Understanding Networking Layers
16:29
57
6.6. Creating a Simple TCP Application in Node.js
24:44
58
6.7. Understanding the Transport Layer - TCPUDP
13:03
59
6.8. A Networking Scenario in Action
25:19
60
6.9. Understanding Port Numbers
12:03
61
6.11. Creating a Chat Application PART 1
29:47
62
6.12. Creating a Chat Application PART 2
34:19
63
6.13. Improving the UI of our Chat App
21:35
64
6.14. Identifying Users in the Chat App
18:47
65
6.15. Notifying Everyone When Somebody JoinsLeaves the Chat
04:10
66
6.17. Some Final Notes About the Chat App
15:27
67
6.18. Deploying our Chat App to AWS
34:31
68
6.20. Understanding IPv4 Addresses
40:10
69
6.21. Understanding DNS
31:37
70
6.22. Understanding IPv6 Addresses
26:45
71
6.24. Creating an Uploader Application
26:03
72
6.25. Taking Care of Backpressures in the Uploader App
33:16
73
6.26. Getting the File Names Dynamically in the Uploader App
20:44
74
6.27. Displaying the Upload Progress in Our Uploader App
16:03
75
6.28. Deploying our Uploader App
20:06
76
6.30. Understanding UDP and the Dgram Module
32:38
77
6.31. Outro
01:31
78
7.1. Introduction
10:39
79
7.2. The Idea of HTTP
07:01
80
7.3. Creating a Simple HTTP Server in Node
15:10
81
7.4. Understanding HTTP Messages, Requests & Responses
12:52
82
7.5. Understanding Connection Types
16:13
83
7.6. Building our Client and Sending a Request
21:11
84
7.7. Sending a Response to the Client
12:44
85
7.8. Learning Postman & Testing Our Server with It
25:36
86
7.9. Reading Some Docs
28:34
87
7.10. Sending an HTTP Request Directly on Top of TCP! PART 1
20:06
88
7.11. Sending an HTTP Request Directly on Top of TCP! PART 2
22:06
89
7.12. Emulating our HTTP Server Using the Net Module
11:20
90
7.13. Understanding Media Types (MIME Types)
16:52
91
7.14. Understanding HTTP Methods
21:37
92
7.15. Understanding HTTP status codes
15:05
93
7.16. Creating a Simple Web Server in Node
18:23
94
7.17. Serving a CSS and JavaScript File
22:06
95
7.18. Adding Some JSON Routes
07:55
96
7.19. Adding a File Upload Route
13:02
97
7.20. Creating our Own Little Mini-Express Framework!
23:19
98
7.21. Making our Framework More Robust
15:05
99
7.22. Getting Ready for Our Next Project
11:26
100
7.23. Using Our Framework to Create a Web App
16:16
101
7.24. Adding the Login Route
21:16
102
7.25. Understanding HTTP Proxies
18:19
103
7.26. HTTP is Stateless
12:58
104
7.27. Understanding Cookies
13:08
105
7.28. Recognizing Users for Future Requests after Logging In
18:16
106
7.29. Sending the User’s Info in Profile
09:15
107
7.30. Enhancing Our Framework with Middleware Support
23:05
108
7.31. Defining the Middleware Functions
18:08
109
7.32. Implementing the Create Post, Update User, and Logout Routes
25:03
110
7.33. Outro
02:54
111
8.1. Introduction
13:10
112
8.2. What Is Unix
10:50
113
8.3. Why Should We Care About Unix
04:41
114
8.4. Setting Up Unix on Windows (WSL) - For Windows Users Only
20:18
115
8.5. A First Look at the Child Process Module
16:07
116
8.6. Understanding Unix Shells
40:07
117
8.7. Demystifying Bash Execution Order Aliases, Functions, Built-ins, and Path
27:03
118
8.8. A Few Notes about Unix File Permissions
14:20
119
8.9. Sourcing in Bash
05:12
120
8.10. Understanding Shell Config Files
38:09
121
8.11. What Exactly is a Child Process
24:09
122
8.12. Understanding Environment Variables
14:10
123
8.13. Understanding Unix File System, Paths & CWD
49:07
124
8.14. Understanding Stdout, Stdin, and Stderr
33:03
125
8.15. Understanding Pipes and Output Redirection in Bash
12:09
126
8.16. Building a Command Line Utility with Node.js
17:08
127
8.17. Building Massive Communication App - Node Part
18:30
128
8.18. Intro to the C Part
11:06
129
8.19. Learning C - Our First App
12:33
130
8.20. Learning C - Static Types & Our Memory
42:34
131
8.21. Learning C - Memory Allocation
31:15
132
8.22. Learning C - Reading the Arguments
04:37
133
8.23. Building Massive Communication App - C Part
50:40
134
8.24. Only Watch if You Skipped the C Part
09:49
135
8.25. Another Way of IPC - Unix Domain Sockets
21:30
136
8.26. Understanding Clustering
32:59
137
8.27. Clustering in Action
45:33
138
8.28. Installing & Building FFmpeg from Source Code
12:12
139
8.29. Video Editor App - Setup & Walkthrough
38:00
140
8.30. Adding the Upload Route
35:48
141
8.31. Quick Intro to FFmpeg and Video Files
20:03
142
8.31. River
00:19
143
8.32. Making a Thumbnail and Getting the Dimensions After an Upload
25:16
144
8.33. Returning the List of Uploaded Videos
04:16
145
8.34. Adding a Route for Returning the Video Assets
23:58
146
8.35. Adding a Route to Extract the Audio of a Video File
15:50
147
8.36. Adding the Resize Route
19:21
148
8.37. Scheduling the Resizes
25:28
149
8.38. More on Queue-based Processing
16:32
150
8.39. Resuming Scheduled Resize Operations Upon App Restart
19:28
151
8.40. Running Our Application in Cluster Mode
31:17
152
8.41. Refactor from Cpeak to Express in Less than 20 Minutes!
07:41
153
8.42. Outro
22:43
154
9.1. Introduction
24:04
155
9.2. How Does a Lossless Compression Work
29:40
156
9.3. Lossy Compression
21:01
157
9.4. Gzip, Brotli and Deflate
30:50
158
9.5. Compression in HTTP
18:12
159
9.6. Compression vs. Minification
06:00
160
9.7. Deploying Compression onto Our Apps
24:13
161
9.8. Final Notes
11:38
162
10.1. Introduction
12:23
163
10.2. Guide for Skilled Multi-Threaded Developers
11:16
164
10.3. What Exactly Is a Thread
39:59
165
10.4. How to Monitor Threads on Your Operating System
07:50
166
10.5. Understanding CPU Usage
09:00
167
10.6. Spawning Threads
23:25
168
10.7. Thread Communication through Message-Passing
33:28
169
10.8. Introduction to Our CPU-Intensive Program
11:58
170
10.9. Enhancing Performance with Multi-Threading
23:03
171
10.10. Handling CPU-Intensive Operations in an HTTP Server
30:41
172
10.11. isMainThread
06:19
173
10.12. CPU-Intensive vs. IO-Intensive
10:41
174
10.13. Examining a Crypto-Heavy Multi-Threaded App
18:47
175
10.14. Node.js Thread Pool
17:46
176
10.15. Developing a Thread Pool From Scratch
30:52
177
10.16. Event Loop Utilization and Main Thread
11:46
178
10.17. Keep the Main Thread Light with Batch Processing
21:47
179
10.18. Effortlessly Expanding Our Thread Pool Capabilities
06:01
180
10.19. Don’t Block the Worker Pool!
07:39
181
10.20. Handling Billions of HTTP Requests
35:11
182
10.21. Communication Through Shared Memory
19:29
183
10.22. ArrayBuffers, SharedArrayBuffers, and TypedArrays
16:50
184
10.23. Race Conditions
17:26
185
10.24. Understanding Atomic Operations
18:11
186
10.25. Understanding Mutual Exclusion
22:48
187
10.26. Deadlocks
21:03
188
10.27. Enhancing Performance Through Shared Memory
21:03
189
10.28. Native Multi-Threading with CC++ Addons
43:33
190
10.29. A Deeper Look at the Event Loop PART 1
37:12
191
10.30. A Deeper Look at the Event Loop PART 2
34:19
192
10.31. Outro
03:00
193
11.1. Introduction
39:47
194
11.2. Introduction to Symmetric Encryption
12:08
195
11.3. The Unbreakable Encryption - OTP From Scratch
26:47
196
11.4. How AES Encryption Works
32:02
197
11.5. Understanding AES Modes
42:47
198
11.6. What It Takes to Break AES
17:14
199
11.7. What About Brute-Forcing OTP
07:05
200
11.8. History of AES
07:49
201
11.9. Understanding Hashing
44:10
202
11.10. SHA-256 From Scratch
10:53
203
11.11. What It Takes to Break SHA-256
22:23
204
11.12. Message Authentication Codes
30:30
205
11.13. Understanding Key Derivation Functions
23:56
206
11.14. Building a File Encryption Application
40:06
207
11.15. Introduction to Asymmetric Cryptography
17:30
208
11.16. A Note about OpenSSL & Setup
08:30
209
11.18. RSA in Action
28:53
210
11.19. Understanding RSA
33:20
211
11.20. Implementing RSA From Scratch
33:39
212
11.21. Understanding Digital Signatures
18:21
213
11.22. Digital Certificates
25:28
214
11.23. Manually Verifying an HTTPS Certificate
27:31
215
11.24. Setting Up HTTPS from Scratch
32:53
216
11.25. Understanding TLS
39:55
217
11.26. Diffie-Hellman and Elliptic Curve Key Exchange
31:38
218
11.27. Elliptic Curve Digital Signatures
18:04
219
11.28. RSA, DH and EC Security
12:12
220
11.30. Outro
11:00
221
12.2. How to Securely Store User Passwords
28:43
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to Understanding Node.js: Core Concepts?

More courses by Udemy

Frequently asked questions

What are the prerequisites for enrolling in this Node.js course?
This course is designed for individuals who have a basic understanding of programming concepts. Familiarity with JavaScript is beneficial but not mandatory. The course includes an introduction to the command line and setting up Node.js on various operating systems, which will help beginners get started.
What projects will I build during the course?
Throughout the course, you will build projects that reinforce the core concepts of Node.js. These include a file management system using Node.js commands, a streaming solution using buffers, and a simple TCP application. These projects are designed to deepen your understanding of Node.js and its practical applications.
Who is the target audience for this Node.js course?
The course is ideal for aspiring back-end engineers and software developers who want to deepen their understanding of Node.js and related computer science concepts. It is suitable for those who wish to excel in back-end engineering and drive innovation within the industry.
How does the depth of this course compare to other Node.js courses?
This course offers an intense focus on the core concepts of Node.js and related computer science fundamentals. Unlike other courses that may cover a broad range of tools and NPM packages, this course dives deep into Node.js itself and essential topics like buffers, streams, and networking.
What specific tools or platforms are covered in this course?
The course centers around Node.js and its core functionalities. It includes lessons on using the command line, Node.js EventEmitter, buffers, streams, and TCP/UDP networking. The focus is on understanding these tools deeply rather than covering external NPM packages.
What topics are not covered in this Node.js course?
This course does not cover front-end development or external NPM packages. The primary focus is on mastering Node.js core concepts and essential computer science topics relevant to back-end engineering.
What is the expected time commitment for completing the course?
The course consists of 110 lessons. While the total runtime is not specified, students should expect an intensive learning experience that requires a significant time commitment to fully grasp the in-depth material and complete the practical projects.