English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 124 lectures (36h 07m) | 18.72 GB
Understanding Node.js without any other NPM packages. Let’s take your back-end engineering skills to the next level!
Welcome to the most comprehensive Node.js course on the internet!
In this course, we’re going to do a deep dive into Node.js itself without cluttering our minds with other tools and NPM packages and truly master this powerful technology.
This course is heavily focused on computer science topics and fundamentals that are crucial to understand for becoming a great back-end engineer. You can only properly understand Node.js and unlock its full power if you understand these other computer science topics. So that’s why we will also learn these other vital topics so that you can truly master Node.js and take your back-end engineering skills to a whole new level.
We will also use all these vital concepts that we’ll learn in practice by building various exciting projects just using Node.js.
This is an intense course for people who want to get to the top of the field and get to a level of driving innovation and making an impact within the industry instead of just scratching the surface and following a few software trends and tools.
Each section of the course is like its own mini-course, and by completing each section, you’ll learn some essential Node.js, computer science and back-end engineering concepts that will help you not just if you want to use Node.js but throughout your whole career as a software engineer. These things will stay with you for years and decades to come.
Let’s do a quick walkthrough about what you will accomplish after completing some of the sections:
Understanding Buffers: Here, we will deeply understand buffers and how to work directly with binary data, which is essential for all the other sections.
Understanding File System: As a back-end developer, you’ll work with files a lot, be it saving some data to disk, handling file uploads and many other examples, so it’s essential to have a good understanding of them, which you’ll gain after completing this section. We’ll also learn how Node.js deals with files and master the “fs” module.
Understanding Streams: In this section, we’re going to master Streams, which will allow us to develop highly-performant apps capable of handling terabytes of data with ease while having great memory usage. We’ll build many mini-projects throughout the section, including an encryption-decryption app from scratch that could encrypt terabytes of data by directly modifying the binary data. This section lays the foundation for future sections where we’ll utilize Streams heavily to create powerful and efficient network applications.
Understanding Networking: Node.js was primarily designed to create network applications, so it’s of utmost importance that we gain a decent understanding of networking, which we will do after completing this section. Here’s a list of items we’ll learn in this section:
- What exactly a network is
- How the internet works
- Mac Addresses
- IPV4 & IPv6 Addresses
- TCP
- UDP
- DNS
- Fundamentals of deployment
We’ll build 2 low-level apps using only Node.js, a chat and a file uploader app directly on top of TCP! And then, we’ll deploy them to a Linux server in the most basic way without using unnecessary tools.
We’ll see exactly what happens in our network card, every single 0s and 1s exchanged for a particular thing using Wireshark, and gain a much better understanding of networking and how most of the well-known protocols like HTTP, FTP, Email protocols, SSH, DNS and many others work. This section will broaden your horizons, and you’ll realize that there are far more things that you can do with Node.js than just creating web servers.
Understanding HTTP: In this section, we’ll utilize and combine all that we’ve learned from previous sections and finally deeply understand HTTP once and for all! We won’t be learning how to use Express; instead, we will build something similar ourselves!
We’ll start by understanding the most important HTTP concepts, such as connection types, client-server model, messages, requests, responses, HTTP Methods, status codes, mime types, necessary headers and so much more. And then emulate an HTTP protocol directly on top of TCP using the net module and see precisely every single 0s and 1s that get exchanged for an HTTP request and response interaction!
Once we understand the fundamentals of HTTP and the “http” module, we’ll take things to the next level and start building our framework. And then, using our framework, we’ll make a fully functional web application.
This section will take your web development skills to the next level. You’ll have a much better understanding of how all these popular NPM packages, like Express, body-parser, Multer, cors, etc., that are built on top of the “http” module work. Well, you’ll learn how to make them from scratch, just using them will not be that much of a problem!
What you’ll learn
- Learn some of the vital concepts of back-end engineering
- Get to a level capable of easily learning various NodeJS frameworks and libraries
- Truly and deeply understand what exactly NodeJS is and see its full potentials far beyond just creating web servers
- Understand and master NodeJS as it is without using any other NPM packages
- Understand some of the most important operating systems concepts that every back-end developer needs to understand
- Be able to easily learn and understand the NodeJS documentation
- Learn how to directly deal with binary data and manipulate the 0s and 1s however you want
- Learn the most important Networking concepts and understand where NodeJS exactly comes into play
- Learn exactly what happens when you deploy your back-end applications rather than focusing on a few tools
- Learn how to create low-level network applications directly on top of TCP or UDP and develop your own protocols
- Deeply understand what HTTP really is and how it works
- Get a deep understanding of the File System
- Master Streams to develop highly performant and memory-efficient applications capable of dealing with terabytes of data with ease
- Understand the EventEmitter object
Table of Contents
Introduction
1 Course Overview
2 A Note About the Sections In Production
3 Setting Up – For Windows Users Only
4 Setting Up – For Mac Users Only
5 Setting Up – For Linux Users Only
6 Introduction to the Command Line
7 Learning NVM & Node.js Versions
8 Node.js Under the Hood
Understanding EventEmitter
9 Understanding EventEmitter
Understanding Buffers
10 Introdcution
11 Understanding Binary Numbers
12 Understanding Hexadecimal Numbers
13 Using a Programming Calculator
14 Understanding Character Encodings
15 The Concept of Buffers
16 Buffers in Action
17 Allocating Huge Buffers
18 Fastest Way of Allocating Buffers
19 Reading the Node.js Docs
20 Outro
Understanding File System
21 Introduction
22 What Exactly Is a File
23 How Node.js Deals with Files
24 Three Different Ways of Doing the Same Thing
25 Starting Point for Building Our Application
26 Watching the Command File for Changes
27 Reading the Content of the Command File
28 Making Sense Out of the Read Data
29 Cleaning Up the Code using EventEmitter
30 Implementing the Create File Command
31 Defining the Rest of the Commands
32 Solution – Implementing the deleteFile Function
33 Solution – Implementing the renameFile Function
34 Solution – Implementing the addToFile Function
35 Outro
Understanding Streams
36 Introduction
37 Benchmarking Writing a Million Times to a File
38 Using Streams Naively in Our Solution
39 So What Exactly Are Streams
40 Reading Writable Streams Node.js Docs and Recap
41 Understanding Different Types of Streams
42 Fixing the Memory Issue in Our Program
43 Readable Streams in Action
44 Selectively Writing Our Data from the Readable Stream
45 Understanding the Splitting Issue
46 Implementing the Solution and Resolving the Splitting Issue
47 Reading Node.js Docs and Recap
48 Building Our Own Streaming Solution Using Buffers
49 Understanding Piping
50 Implementing Our Own Writable Stream
51 Implementing Our Own Readable Stream
52 Understanding Duplex and Transform Streams
53 Creating an EncryptionDecryption Application
54 Final Notes
Understanding Networking
55 Introduction
56 Understanding MAC Addresses and Switches
57 Understanding Routers and How the Internet Works
58 Understanding Networking Layers
59 Creating a Simple TCP Application in Node.js
60 Understanding the Transport Layer – TCPUDP
61 A Networking Scenario in Action
62 Understanding Port Numbers
63 Starting Point for Building Our Chat App
64 Creating a Chat Application PART 1
65 Creating a Chat Application PART 2
66 Improving the UI of our Chat App
67 Identifying Users in the Chat App
68 Notifying Everyone When Somebody JoinsLeaves the Chat
69 A Note About the ‘end’ Event on Windows
70 Some Final Notes About the Chat App
71 Deploying our Chat App to AWS
72 Commands Used for Installing NVM
73 Understanding IPv4 Addresses
74 Understanding DNS
75 Understanding IPv6 Addresses
76 Starting Point for Building Our Uploader App
77 Creating an Uploader Application
78 Taking Care of Backpressures in the Uploader App
79 Getting the File Names Dynamically in the Uploader App
80 Displaying the Upload Progress in Our Uploader App
81 Deploying our Uploader App
82 AWS Cost Warning – Server Termination Reminder
83 Understanding UDP and the Dgram Module
84 Outro
Understanding HTTP
85 Introduction
86 The Idea of HTTP
87 Creating a Simple HTTP Server in Node
88 Understanding HTTP Messages, Requests & Responses
89 Understanding Connection Types
90 Building our Client and Sending a Request
91 Sending a Response to the Client
92 Learning Postman & Testing Our Server with It
93 Reading Some Docs
94 Sending an HTTP Request Directly on Top of TCP! PART 1
95 Sending an HTTP Request Directly on Top of TCP! PART 2
96 Emulating our HTTP Server Using the Net Module
97 Understanding Media Types (MIME Types)
98 Understanding HTTP Methods
99 Understanding HTTP status codes
100 Creating a Simple Web Server in Node
101 Serving a CSS and JavaScript File
102 Adding Some JSON Routes
103 Adding a File Upload Route
104 Creating our Own Little Mini-Express Framework!
105 Making our Framework More Robust
106 Getting Ready for Our Next Project
107 Using Our Framework to Create a Web App
108 Adding the Login Route
109 Understanding HTTP Proxies
110 HTTP is Stateless
111 Understanding Cookies
112 Recognizing Users for Future Requests after Logging In
113 Sending the User’s Info in Profile
114 Enhancing Our Framework with Middleware Support
115 Defining the Middleware Functions
116 Implementing the Create Post, Update User, and Logout Routes
117 Outro
Understanding Cryptography
118 Sneak Peek into What’s Next
Understanding Compression
119 Sneak Peek into What’s Next
Understanding Child Processes
120 Sneak Peek into What’s Next
Understanding Worker Threads & Multi-Threading
121 Sneak Peek into What’s Next
Security
122 Sneak Peek into What’s Next
Setting Up the TBD Project
123 Sneak Peek into What’s Next
Deploying the TBD Project
124 Sneak Peek into What’s Next
Resolve the captcha to access the links!