Understanding Node.js: Core Concepts

Understand the Eventemitter object in Node.js, including how to define listeners with on, emit events, and inherit via ES6 classes; see how event driven, asynchronous patterns power Node apps.

Explore buffers in Node.js, connect to binary data and zeros and ones, and learn how buffers enable handling files and network requests while mastering binary, hexadecimal numbers, and character encodings.

Explore binary numbers and base two, learn how bits and bytes encode data, and convert binary to decimal using index positions and the least and most significant bits.

Explore the base-16 hexadecimal system, how each hex digit represents four bits, how to convert hex to binary in memory, and why 0x indicators simplify data work.

Explore using a programmer calculator to convert numbers between decimal, binary, hex, and octal, and see how the most and least significant bits shape 64-bit memory representation.

Map characters to numbers with character sets and encodings like UTF-8 and ASCII. Learn how encoders and decoders convert text to binary and why correct encoding matters.

Explore how node.js buffers provide fixed-size memory containers, where each element is a byte, allowing read, write, and fast data movement between sources like files or network streams.

Explore how Node.js buffers allocate memory, write and read eight-bit elements, and convert binary data to human readable text using hex and utf eight encodings, with hands-on logging examples.

Explore how to allocate huge buffers in Node.js, monitor memory usage with system monitor, and learn limits like four gigabytes max that can crash the operating system.

Explore the fastest ways to allocate buffers in Node.js, comparing buffer.alloc and buffer.allocUnsafe, and learn how buffer pool size and security implications affect performance and safety.

Explore the Node.js buffer API by reading the docs, understand buffers as fixed-length byte sequences, their inheritance from uint8 array, and learn common methods and encodings.

Explore how buffers handle binary data as it moves between sources and destinations, from file uploads to audio extraction and transcription with AI applications.

Explore how Node.js handles files using the fs module, reading a text file synchronously, and converting buffers to strings with utf-8 encoding, while understanding ascii and binary data.

A file is a sequence of bits whose meaning depends on decoding. Everything on your computer is a file, and Node.js handles files by type, data, protection, and path.

discover how node.js handles files by talking to the operating system through libuv and system calls, with the OS as a middleman to access hardware and manage file operations.

Explore the three ways Node.js handles file operations: promises, callbacks, and synchronous APIs. Prefer promises for clean async code, and avoid blocking with the synchronous API except at startup.

Learn to set up a Node.js app that watches a directory or a file using fs promises watch, handle change events for command.txt, and read the file contents on change.

Open the file with the fs promises API to obtain a file handle, read contents into a buffer using the file size, and close the file to prevent memory leaks.

clean up messy node code by using the file handle as an event emitter, defining and emitting a change event to drive a watcher.

Explore decoding raw data with a Node.js character decoder, understand the difference between encoder and decoder, and convert buffers to utf-8 strings while using third-party decoders for file operations.

Implement a create file command in Node.js by parsing the command and extracting the path. Handle absolute and relative paths, check file existence, and create an empty file with flags.

Defining and wiring the rest of the file commands in a Node.js project, outlining delete file, rename file, and add to file, plus a hands-on implementation challenge.

Explore implementing deleteFile in Node.js using promises and unlink, learn about symbolic links, POSIX standards, and alternative rm options for deleting files and directories.

Implement file renaming and moving with fs.rename in Node.js using promises and async/await, and handle errors such as no file at this path or destination doesn't exist, with logs.

Implement the addToFile function in node.js by opening the existing file and appending content with the A flag, then write to preserve existing data.

Complete the file system section and refine your fs module skills, noting bugs with special characters and non-production gaps. Prepare for the next section on streams in Node.js.

Master node streams by understanding and applying readable, duplex, and transform streams; learn to use existing streams and build your own for memory-efficient, high-performance applications.

Explore writing to files with Node.js's fs module and buffers, benchmark a million writes, compare promises, callbacks, and sync approaches, and preview how streams improve performance and memory usage.

Explore how streams improve performance by writing with a write stream instead of promises or callbacks, achieving much faster file output while examining memory usage and best practices.

Understand Node.js streams as an interface for streaming data. See how chunked writes, typically 16kB by default, improve memory efficiency and performance in copy operations, FFmpeg workflows, and network I/O.

Learn how Node.js streams work, including readable and writable streams, duplex and transform streams, and how internal buffers, high water marks, and draining optimize data flow.

Learn how to fix memory issues in Node.js by managing writable streams. Monitor high watermark, handle drain events, respect backpressure, and properly end streams to control memory usage.

Recap writable streams by reading Node.js docs, focusing on the fs module and key events like close, drain, error, finish, plus cork and uncork.

Demonstrate reading large files with readable streams in node.js using createReadStream. Manage data in chunks and backpressure with pause, resume, and drain events.

learn how to read a huge file with a readable stream, process data in chunks, and write only even numbers to the destination, avoiding memory issues.

Explains how data arrives in chunks and can lose digits at split points. Demonstrates saving trailing bytes and appending them to the next chunk to reconstruct numbers.

Implement a robust streaming solution in node.js by detecting and resolving splitting issues, converting string tokens to numbers, and extracting even numbers through a read/write stream workflow.

Explore node.js readable streams, including flowing and paused modes, switching with data events, resume, or pipe, and learn about end, error, and encoding.

Develop a custom streaming copy in Node.js by reading and writing in chunks, compare memory usage to whole-buffer copies, and preview Node.js streams and piping in the next video.

Explore Node.js streams and piping, including read and write streams, backpressure handling, and chaining, with a comparison to pipeline for robust error handling.

Develop a custom writable stream by extending the writable class, implementing constructors, highWaterMark, and the write, final, and destroy methods, to write buffers to a file with callbacks and finish events.

Create a custom readable stream by extending the readable class and implementing read to push data chunks and signal end with null. Use a high watermark and destroy on errors.

Explore how duplex streams combine readable and writable sides with two buffers. See how a transform stream processes written data into readable output for encryption or text transformation.

Create an encryption and decryption app using a Node.js transform stream. Pipe read and write streams through the transform to produce encrypted data and the corresponding decrypted output.

Explore streams in node.js, including object mode and high watermark, and learn through pg query stream and busboy while reading source code and exploring related packages.

Explore foundational networking concepts for backend development with Node.js, building a chat app and a file uploader using the net module and TCP, and learn deployment basics with AWS.

Explore how computers share information using switches, Ethernet cables, and MAC addresses; learn how a switch routes packets to the correct device and what MAC addresses and IP addresses mean.

Understand how routers on top of switches connect millions of computers across separate networks using IP addresses, ports, and ISPs to form the global internet.

Explore how networking layers from physical cables to the application layer guide data flow, addressing, and routing. Learn how Node.js uses TCP or UDP to build networked applications.

Develop a simple tcp server in node.js using the net module, listening on port 3099 at 127.0.0.1, and exchange data with a simple sender via duplex sockets.

Explore the transport layer with TCP and UDP: TCP ensures reliable delivery using a three-way handshake and sequence/acknowledgement numbers, while UDP favors speed and uses port numbers to reach applications.

Explore how devices on a home network communicate by using ip addresses, ports, and loopback: localhost and 127.0.0.1, and learn how node.js servers respond to requests on specific interfaces.

Explore how port numbers bridge the transport and application layers, covering TCP and UDP, well-known and user ports, port ranges, and practical examples with localhost and node apps.

Explore building a chat app with node's net module by creating a server and a client, using net.createServer and net.createConnection on port 3008.

Develop and extend a Node.js chat server using net.createServer and net.createConnection, manage multiple client sockets, broadcast messages to all connected clients, and use readline for console input.

Improve the chat app user interface by refining the console output in Node.js, clearing lines and moving the cursor, while converting callbacks to promises for cleaner logging.

Assign a unique ID to every connected client and send it back, so each chat message is tagged with its sender, enabling identity-aware messaging in the chat app.

Notify all clients when someone joins or leaves by broadcasting messages after a socket connects or ends, using user IDs and ES6 strings in a Node.js chat app.

Explore how a tcp chat app exchanges ids and optional names through headers and messages, and learn why encryption, https, vpn, and authentication tokens matter for production deployment.

Deploy a node.js chat app to a public server on AWS, exploring EC2 instances, regions, security groups, and SSH access to connect clients over a public IP.

Distinguish IP from IP addresses, examine IPv4 structure (32 bits, four octets, 0–255), and learn subnet masks, CIDR, private ip addresses, NAT, and loopback.

Understand how the domain name system translates domain names into internet protocol addresses by querying servers, performing lookups, and connecting your browser to the correct host.

Explore how IPv6 addresses overcome IPv4 exhaustion with 128-bit hex addresses, using leading-zero suppression and double-colon compression, while preserving application-layer practices.

Create a tcp uploader with node's net, fs, and streams to send a file from client to server, saving it to storage while handling end events.

Handle backpressure in a Node.js uploader app by pausing writes when the internal buffer fills, listening for drain events, and resuming reads to control memory usage.

Learn to dynamically specify file names by reading the third arg with process.argv, extract the base name via path.basename, and send it over a tcp socket before streaming the file.

Learn to display file upload progress in a Node.js client by using fs.stat to obtain file size, track bytes read, compute a floor percentage, and update the screen.

Deploy a Node uploader app securely by enabling tls for https, then verify deployment with pm2 and real-world file uploads to a storage directory.

Design a simple UDP sender and receiver using the dgram module. Compare UDP with TCP and understand its connectionless, fast data transmission and potential data loss.

Review core networking concepts, including IPv4 and IPv6 addresses, network layers, TCP and UDP, and DNS, while exploring the Node.js net and gram modules and their low-level applications.

Explore http as the web’s main building block and how node packages rely on it. Build a butter framework to manage routes and middleware in a poster app.

Explore the idea of Http as the networking protocol built on tcp and udp, and learn how it governs data formats like Json, files, and form data for the web.

Learn to build a simple http server with node's http module, handle requests via events, and stream and log the method, url, headers, and request body.

Understand how http uses the client–server model to exchange requests and responses, with headers and body over a tcp connection, and how status codes signal success or errors.

Understand how http reuses tcp connections through keep-alive, how caching saves requests and responses, and how persistent connections differ across http versions.

Build a simple http client in node with the http module and a keepalive agent to reuse a TCP connection. Configure hostname, port, path, method, headers, and streaming request bodies.

Learn how to send a response to the client in Node.js by parsing json data and reading headers. Return a 200 status with content-type application/json describing the created post.

Learn how Postman sends http requests to test servers by configuring headers, bodies, and URLs, using methods like get, post, put, patch, and delete.

Explore the Node.js Http module documentation and learn the key objects and methods, including Http server, Http server response, Http client request, Http incoming/outgoing messages, and Http create server.

Explore sending a raw HTTP request over TCP with the net module, connecting to localhost:8050, and using Wireshark to observe the TCP handshake and HTTP data.

Demonstrates constructing and sending a raw http message over a tcp connection using node's net module, detailing headers, content-length, and body parsing with hex dumps.

Emulate a simple http server using the net module by creating a tcp server, sending requests via postman, parsing headers, and understanding utf-8 data and encryption.

Learn how media types, or mime types, guide HTTP content-type headers in interpreting message bodies, covering type/subtype format, parameters, and discrete vs multipart classes.

Explore how http methods tell servers what to do, covering get, post, put, patch, delete, head, and options, and learn about idempotency in rest api.

Explore how http status codes signal request outcomes, grouped into informational, successful, redirection, client error, and server error ranges, with examples like 301, 401, and 404 in restful APIs.

Create a simple Node.js HTTP server that serves an HTML page, clarifies web server versus HTTP server, and streams HTML content using HTTP and fs modules.

Serve CSS and JavaScript files from a Node.js server by routing get requests, sending text/css and text/javascript, and using a public folder to auto-serve assets.

Develop json routes in node.js, including a login post route returning json with content-type and 200 status, and a user put route with 200/401; plan refactoring into an express-like framework.

Add a file upload route in node.js, saving the request body to storage using streams, exploring content-type handling, and idempotence with put instead of post.

Extract repetitive logic into a reusable butter framework inspired by express, then implement routing, middleware support, and request/response augmentation to serve files and handle routes.

Improve the framework’s robustness by detecting undefined routes, returning structured json errors with a 404 status, and simplifying routing logic to prevent server crashes and improve reliability.

Set up a real-world Node.js project using the butter framework, serve html css and javascript from a public folder, and add middleware, authentication, and a login/post system.

Set up a node.js server on port 8000, serve html, css, and js files, and create a mock api at /api/posts that merges user data to show post authors.

Implement the login route at /api/log in by parsing the Json body, validating the username and password against the users array, and returning 200 or 401.

Demonstrate how http proxies act as load balancers to route client requests across multiple node servers, using round-robin and health checks, and understand statelessness.

Understand how HTTP is stateless and how token-based sessions authenticate users across requests by using a token stored in a sessions table and sent in headers to access profile data.

Identify how cookies in http save data on the client and automatically attach to subsequent requests, using set-cookie headers to store token and card id.

Add sessions to remember authenticated users across requests by issuing a token in a cookie. Validate the token on subsequent requests to return user profile info.

Validate the token, fetch the user by session, and return the profile's username and name as json, preparing for middleware-powered authentication across routes.

Enhance a node.js framework with before-each middleware, using req, res, and next to run authentication and body-parsing steps in order before routes. Explore a recursive execution approach.

Explore building and refactoring middleware in Node.js to parse JSON bodies, authenticate users via token cookies, and serve index.html for multiple routes, yielding cleaner route logic.

Implement the create post, update user, and logout routes in Node.js, manage posts and users arrays with JSON parsing, and clear sessions and cookies on logout.

Conclude by reinforcing how the http module underpins popular node packages like express and body-parser, and preview topics such as compression, encryption, hashing, and clustering.

Explore Unix foundations and Node.js core concepts, including bash shells, IPC, process management, environment variables, and clustering, by building cross-language apps with Node.js, C, and FFmpeg.

Trace the origins of Unix at Bell Labs and its enduring influence. Understand how C made Unix portable, inspired Linux and BSD, and shaped Unix-based systems.

Learn why Unix matters for building and deploying Node.js apps—from composing specialized programs to portability, security, and performance optimization.

Learn how to set up a unix-based environment on Windows using WSL, install Ubuntu, access Windows files from Linux, and run node apps for development.

Explore the Node.js child_process module by using spawn and exec to run external commands, handle streams, and understand stdout and errors.

Explore how unix shells run as processes on the kernel, use system calls via C headers, and compare bash, zsh, sh, dash, and other shells through the terminal.

Learn how bash resolves commands through aliases, functions, built-ins, and path, with practical examples of defining, unsetting, and using them, plus how node's path and spawn differ.

Learn how unix file permissions assign read, write, and execute rights for owner, group, and others, and how to view, modify with ls -l and chmod to run scripts.

See how to divide bash scripts into files and include them by sourcing with source or dot, so functions, variables, and aliases become available in the current shell.

Explore how starting a new shell loads login and non-login, interactive and non-interactive configuration files. Learn to customize bash rc and zsh rc with aliases, functions, and prompts.

Understand how Unix creates and manages child processes, including PIDs and parent PIDs, how a parent spawns a child via the kernel, and how arguments and environment variables pass.

Explore environment variables, how they differ from arguments, and how a parent process passes them to child processes in bash and node, including viewing and exporting them.

Understand how Unix path system, current working directory, and absolute versus relative paths affect file operations in Node, and use path and fs to read and include files.

Explore Unix data streams by mastering stdin, stdout, and stderr, learn to pipe and redirect between processes, including Node.js apps, enabling efficient interprocess communication and file redirection.

Master bash piping and output redirection to connect processes, route standard out, standard in, and standard error, and manage files with >, <, 2>, and /dev/null.

Build a cat-like command line utility in node that reads from standard input or a file, writes to standard output, and processes arguments using streams and the fs module.

Build two-process architecture where a node app reads a file via streams and pipes data to a spawned c app that formats numbers as money with dollar sign and commas.

Learn how to implement the second part of a massive communication app in C, while exploring optional Node.js pathways and how to install a C compiler on macOS and Linux.

Write and compile your first C application using gcc, creating app.c and stdio.h headers, define main, print output with printf, and run the Unix executable.

Explore static typing and memory management in C, covering integer, size_t, char, float, and unsigned types, memory layout, addresses, pointers, dereferencing, and printf format specifiers.

Explore how memory is allocated in C by creating variables and using malloc to allocate heap memory. Understand pointers, addresses, and dereferencing, plus typecasting and memory layout.

Learn how to read command line arguments in C using argc and argv, iterate over them, and print each argument, mirroring Node's argv and handling options.

Learn to integrate Node.js with a C component in a massive communication app, handling streams, end-of-file signaling, and memory management while formatting numbers.

Run the second part of the massive communication app in both C and Node.js, showing data streams enable cross-language collaboration and how to choose and execute either version.

Explore inter process communication in Node.js using Unix domain sockets via the net module, compare IPC sockets with data streams and pipes, and review Node.js and C examples.

Learn clustering in node with the cluster module to spawn multiple processes that use all CPU cores, coordinate with a parent and children, and balance requests with round-robin.

Explore how to run a Node.js app in cluster mode by forking workers from a primary process and sharing ports across CPU cores. Use IPC and PM2.

Install FFmpeg and FFprobe on macOS and Linux using multiple methods, add the executables to your PATH, and explore building FFmpeg from source for a lean, customized build.

Set up the video editor app and walkthrough its features, clone starter code, review the Node.js backend and React client, and test upload, extract audio, resize, and download assets.

Add a post route for uploading videos, save files under a random video id, create a thumbnail, and update the database with name, extension, and user id.

Explore how video files are built from frames, streams, and codecs, and learn how FFmpeg and ffprobe extract data and modify formats for web-ready playback.

Use ffmpeg via node's child_process spawn to create a video thumbnail and extract dimensions after an upload, with reusable utilities for make thumbnail and get dimensions.

Learn how to implement the get videos route to return the current user's uploaded videos by filtering the database where video user ID matches req.userId.

Add a get video assets route to serve thumbnails, original videos, audio, and resized assets with proper mime types and content headers.

Add a patch route to extract audio from a video using ffmpeg, saving as audio.aac in the video folder and revealing a download option after successful extraction.

Add a resize route in a Node.js app to process video resizes one at a time using ffmpeg, track progress, and prepare a queue for scheduling future heavy tasks.

Schedule resizes in a background job queue, enqueueing resize tasks and dequeuing them one at a time to process with ffmpeg, improving resource management and user experience.

Explores a queue-based processing design in Node.js, detailing a job queue with enqueue and execute next, handling current jobs and empty queue states.

Learn to resume scheduled resize operations after app restart by scanning the database for processing true jobs, enqueuing them in the job queue, and continuing FFmpeg-based resizing.

Run your Node.js app in cluster mode using the cluster module to leverage cores, coordinating resize tasks via a job queue so only one ffmpeg operation runs at a time.

Refactor from Cpic to Express in a Node.js project in under 20 minutes, migrating middleware, static serving, and JSON parsing while preserving routes, controllers, and cluster support.

Explore Unix tools like ImageMagick, PDF utilities, OpenCV, and Whisper to extend Node.js capabilities; master Bash, Vim, regular expressions, and DevOps practices for building powerful, scalable applications.

Explore how compression reduces data sizes with lossless methods, the zlib module, and gzip, plus lossy concepts, through practical Node.js streaming examples.

Explore how lossless compression works by examining gzip, brotli, and deflate, and learn Huffman coding and the LZ77 family with practical Node examples.

Explore how lossy compression reduces data and quality for multimedia, with JPEG, MP3, AAC, and video codecs. Text stays intact while node delegates to external tools like FFmpeg.

Explore gzip, brotli, and deflate using zlib in Node.js, compare compression ratios and speeds, and learn tradeoffs for real-world HTTP compression.

Learn how HTTP compression boosts performance by sending compressed responses, controlled via accept-encoding and content-encoding headers, with gzip, deflate, and brotli.

Learn how minification differs from compression and why you should apply both to JavaScript, CSS, and HTML; see how removing comments, whitespace, and shortening variable names reduces file sizes.

Enable compression in node apps using zlib and gzip, and set content-encoding after checking accept-encoding. Evaluate performance gains and avoid compressing sensitive data when using https.

Explore Node compression with gzip, deflate, and brotli, understand the Node streams API, manage a thread pool, and apply caching and memory tuning to optimize performance.

Discover true multithreading in Node.js with kernel-level threads, worker threads, and a thread pool to boost performance and enable shared memory. Debunk the single-threaded myth and explore clustering and cores.

This guide for skilled multi-threaded developers explains Node.js worker threads, spawning and communicating via message channels and shared memory, with focus on atomics, mutexes, and race conditions.

Understand what a thread is and how the CPU schedules processes and threads through ready, running, and sleep states. Compare concurrency and parallelism and learn why threads boost Node.js performance.

Compute core utilization as the active time over total time for each core, yielding 0–100% per core, and learn two methods for process CPU utilization.

Learn how to spawn worker threads in Node.js with the worker_threads module, create new workers, run separate calc.js instances, and understand thread isolation, event loops, and communication.

Demonstrate offloading a cpu-intensive prime generation from the main http server thread to worker threads within the heavy server, preventing blocking and boosting responsiveness.

Differentiate cpu intensive from io intensive operations in node apps, using worker threads for cpu tasks and relying on node for io tasks like network, files, and databases.

Demonstrates a multithreaded node app that uses the crypto module to generate random numbers, shows a bottleneck, and explores batching to improve CPU-bound performance across threads.

Learn how batching long-running tasks in a Node.js thread pool prevents main thread blocking, reduces memory growth, and improves event loop performance while generating primes.

Learn how to extend a Node.js thread pool by adding a factorial task alongside prime generation, handling bigints, and scheduling diverse work efficiently.

Learn to avoid blocking the event loop and the libuv worker pool by batching, caching, and offloading heavy tasks to separate servers when needed.

Explore how to scale Node.js HTTP requests through batching, worker threads, and multi-process clustering, highlighting IO-intensive versus CPU-intensive workloads and Node.js's async IO efficiency.

Explore communication through shared memory in node, contrasting it with message passing, and learn to use buffers and arraybuffer to coordinate inter-thread data while addressing race conditions and deadlocks.

Learn how array buffers, shared array buffers, and typed arrays handle binary data in Node.js. Discover buffers as views over underlying data, pool allocation, and endianness for shared memory.

Understand race conditions in Node.js by examining how multiple executions read and write a shared resource, causing unpredictable final values, and learn about critical sections and basic synchronization.

Learn how atomic operations guarantee indivisible updates and prevent race conditions in multi-threaded JavaScript, using the Atomics API with typed arrays and shared memory, including wait and notify.

Explore how mutual exclusion protects critical sections from race conditions using spinlocks and atomic operations. Learn how compare and exchange, atomics wait/notify, semaphores, and mutexes prevent concurrent access.

Understand deadlocks in multi-threading, where threads lock shared resources like mutexes or semaphores, causing permanent blocking; prevent them by reordering locking and unlocking to avoid circular wait.

Explore how shared memory boosts performance by refactoring a worker pool to generate primes using shared buffers and locks, comparing against message passing and illustrating CPU versus memory intensive scenarios.

Explore native multithreading in node by integrating C/C++ addons, compare performance with pure JavaScript, and learn how to bind native code into a node process for asynchronous execution.

Explore the event loop and async work across stages, microtasks, and callback queues. See how process.nextTick, promises, setTimeout, and set immediate schedule tasks and how threads and libuv drive concurrency.

Explore how the Node event loop processes timers, poll phase, checks, and process.nextTick, and how setImmediate, setTimeout, and promises influence callback ordering.

master the core node concepts by exploring threads, message passing, shared memory, and the event loop with async work, learning when to use multithreading for cpu- and io-intensive tasks.