Learn and Understand NodeJS (V8, Express, MERN/PERN & more)

Explore processors, machine code, and why Node.js is implemented in C++, tied to the V8 JavaScript engine.

Explore how JavaScript engines follow the ECMAScript standard, with V8 powering Node.js. Understand how engines convert JavaScript into machine code according to the ECMA specification.

Explore Google's open source V8 engine, its C++ core, and ECMAScript implementation; view the source in a Git repository and inspect .cc and .h files in VS Code.

Embed V8 into a C++ program to extend JavaScript with features by binding C++ functions as new JavaScript keywords like print, load, and greet, enabling Node.js as a server technology.

Explore the client-server model and how Node.js lets you write server-side code in JavaScript, unifying client and server development and enabling shared libraries.

Node.js enables JavaScript to manage a web server by providing reusable code organization, file handling, database connectivity, internet communication, and request-response processing, while handling long-running tasks.

Examine the c++ core of node.js and how it embeds the v8 engine to extend JavaScript with native features like libuv and http parser.

Explore how Node.js blends a C++ core with a JavaScript layer, with wrappers and process.binding powering features like zlib and handy utilities in lib.

Install Node.js and npm from nodejs.org, verify with node -v, and run JavaScript in Node via an entry file like app.js; use Visual Studio Code for debugging with breakpoints.

Compare LTS and current Node.js versions, highlighting stability, maintenance updates, and potential breaking changes; favor the latest LTS for reliable systems while noting current for new features with risk.

Explore NodeJS modules, including exports and require, and understand CommonJS standards for reusable blocks of code that don't affect other code, and how these modules work under the hood.

Learn how JavaScript treats functions as first-class citizens and use function expressions to pass, invoke, and create functions on the fly within Node.js, enabling powerful patterns.

Build a self-contained Node.js module by creating greet.js and importing it into app.js with require, then expose functions via module.exports to enable reuse and clean code structure.

Master JavaScript objects and object literals by learning name/value pairs, object creation with literals, and how dot or bracket notation accesses properties and methods.

Understand prototypal inheritance in JavaScript, using function constructors and the ES6 class keyword to define prototypes in Node.js, explore the prototype chain, and share properties and methods across objects.

Explore how JavaScript passes values and objects to functions by value and by reference, and how this relates to modules and require, primitives versus objects, and memory effects.

Explore immediately invoked function expressions (IIFEs) to create protected scope and isolate variables. See how this scope behavior underpins modules in Node.js, guiding module.exports and require usage.

Explore how Node modules work with module.exports and require, including how Node wraps code in a function and exposes module.exports.

Explore json, JavaScript object notation, a text-based data format inspired by object literals. See how the v8 engine parses json into JavaScript objects using quoted names and curly braces.

Explore how the require function loads modules by file or folder, chain requires with index.js, and share code via module.exports, including using json data for greetings.

Learn practical Node.js module patterns using require and module.exports, including overriding exports, attaching methods, constructor patterns, and the revealing module pattern with caching insights.

Explore the difference between exports and module.exports in node.js, showing how require returns module.exports, the quirk of mutating versus replacing, and the author's recommendation to use module.exports.

Discover how the require function loads native core modules in Node.js. Learn to access utilities and other core features via require and consult the Node.js API for details.

Compare Ecmascript modules (ESM) with commonjs, learn export and import syntax, default exports, and aliasing, and see how Node.js supports both for modular code.

Explore the differences between ESM and CJS in node, configure module type in package.json, and learn when to use imports versus require for consistent, modern modular code.

Learn how Node.js extends JavaScript with modules, module.exports, and require to manage a server and build reusable components, enabled by the V8 engine.

Explore the concept of events in Node.js, distinguishing system events from libuv and custom events via the JavaScript event emitter, and build your own emitter to grasp core modules.

Explore object properties and methods, dynamic bracket access, and first class functions inside arrays, then loop with forEach to invoke functions, key concepts for understanding the event emitter.

Create a simple node-style event emitter with a function constructor, an events map, and on and emit methods. Register listeners for events and emit to run them.

Explore the Node.js event emitter by examining the built-in events module, using on and emit to manage listeners, and centralizing event names to avoid magic strings.

Explore how Object.create and prototypes establish a prototype chain for inheritance, enabling shared greet methods across John and Jane derived from a person prototype, with event emitters in Node.js.

Learn how to inherit from the EventEmitter in Node.js by using util.inherits and Object.create to build a Greetr object with event handling methods.

Explore how Node and ES6 unlock modern JavaScript features like template literals with backticks and ${}, and how Babel enables browser compatibility while Node with V8 supports these features.

Explore how JavaScript call and apply invoke functions by borrowing the this keyword from another object, using ES6 template literals, and passing parameters as an array or as comma-separated values.

Highlight how to inherit from EventEmitter by calling EventEmitter.call(this) for instance properties and using util.inherits for prototype sharing, with Person and Policeman examples.

Explore ES6 classes as syntactic sugar for prototypal inheritance in JavaScript and compare them with function constructors and prototypes in Node.

Update node code from util.inherits to ES6 classes by extending EventEmitter and using super. Export the class as a module, convert prototype methods to class methods, and note syntactic sugar.

Explore how Node.js handles asynchronous operations alongside the synchronous V8 engine, and connect streams, buffers, and files through the event loop.

Explore how libuv powers Node.js with the event loop and non-blocking I/O, coordinating OS events, callbacks, and V8-driven JavaScript to run code asynchronously.

Understand how streams deliver data over time and how buffers hold data chunks as they move. Learn to process data as it arrives, using buffering to enable streaming in node.

Explore binary data, character sets, and encodings in node.js for server work. Learn how Unicode and utf-8 map code points to characters and how v8 enables raw binary handling.

Explore how Node.js handles binary data with buffers, converting between strings and binary using utf-8 and base64, while noting the deprecation of new Buffer and using from and alloc.

Discover ES6 typed arrays and array buffers for binary data in JavaScript, using views like Int32Array to read and write 32-bit numbers within an underlying 64-bit buffer.

Master JavaScript callbacks by passing functions to other functions and invoking the callback later. Learn to handle a parameter, such as data.name, in different callback scenarios.

Explore how Node.js's built-in fs module reads files using synchronous and asynchronous methods, including buffers, encoding, and error-first callbacks, and understand why asynchronous patterns boost performance and memory efficiency.

Explore how Node handles streams as chunks and how readable and writable streams derive from event emitters. See a file copy using read and write streams and chunked buffering.

Explore how pipes connect two streams by piping chunks from a readable stream to a writeable stream, then chain pipes to move data through multiple streams.

Explore how Node.js pipes connect readable and writable streams to transfer data efficiently, including duplex and transform streams, with gzip compression via zlib and method chaining.

Explore why promises exist in JavaScript and how Node.js supports them alongside callbacks. Learn how promises and async and await simplify asynchronous code, and adopt ECMAScript modules over require.

Explore asynchronous file operations in node using promise-based fs, adopt ecmascript modules over commonjs, and implement async/await with readFile to produce readable, maintainable code.

Explore streams and promises in Node.js by converting callback style file copying to promises and async/await, using the promises API open, and iterating with for await.

Show the promises version of node pipelines, replacing callbacks with async/await and Promise.all. Read, compress with gzip, and write to outputs using pipeline for clearer async flow.

Explore the tcp/ip foundation of web communication, including ip addresses, sockets, packets, and streams, and see how Node enables building a web server with these protocols.

Learn how a server directs incoming packets to the correct program using ports and socket addresses, mapping IPs and domain names to the listening Node.js process.

Explore how http governs web data transfer, detailing requests, responses, headers, and status lines. Learn how mime types like json, html, and image/jpeg guide browsers to render content.

Discover how Node.js parses http requests and responses with the built-in http-parser, inspect its C core and JavaScript wrappers, and learn to build servers using http.js.

Explore how node's HTTP parser evolved from the legacy implementation to WL, via TypeScript and eventual C code, while preserving the same import and usage for developers.

Build a web server in node using the core http module to handle requests and send responses with writeHead, headers, and a text/plain body on localhost:1337.

Learn to output html from a node server by reading index.htm with fs and delivering text/html responses. Explore dynamic templates by replacing placeholders before sending the response.

Learn how to use streams to boost Node.js performance by piping a readable file stream to the response, sending data in chunks rather than buffering the whole file.

Explore APIs and endpoints, including how URLs become endpoints that send and receive data via HTTP and TCP/IP, with headers and JSON shaping behavior.

Learn how to output JSON from a Node API, set the mime type to application/json, and serialize data with JSON.stringify for client-server exchange.

Learn routing in NodeJS by mapping http requests to content based on the url, streaming files or data from a database, and returning json for api endpoints.

Explore routing in Node.js using CommonJS callbacks and ECMAScript modules with promises, demonstrating createServer, createReadStream, and pipeline, plus async/await for asynchronous tasks.

Explore how Express streamlines serving http requests and responses on a Node web server, and how Node modules, buffers, and streams are enabled by npm and the npm registry.

Explore the npm ecosystem and how packages, ready-to-use code, rely on a package management system to install, update, and manage dependencies and versions.

Explore semantic versioning (semver) and how version numbers convey meaning: major, minor, and patch updates, backward compatibility, and potential breaking changes in package management.

Explore the npm registry and package manager, learn how to use other people's code with npm install, and evaluate packages by documentation, version, licence, downloads, issues, and open source activity.

Learn to manage node projects with npm init, install moment from the npm registry, and track dependencies in package.json, with node_modules and require accessing the module.

Explore npm package.json usage, dependencies and dev dependencies, and how to install and manage packages locally or globally with nodemon and node_modules for development and server deployment.

Compare built-in node --watch with nodemon for auto-restarts on file changes. Use node --watch for simple cases; watch path supports directories on macOS and Windows, while nodemon config handles projects.

Learn to evaluate external code from npm by inspecting sources and GitHub issues. Be judicious with dependencies, and note that semantic versioning isn't always followed.

Learn to install express with npm and build a web server with Node.js. Create routes with app.get and app.post, respond with res.send and res.json, and use environment variables for ports.

Learn how Express routes match URLs, handle requests, and extract variables with route parameters like /person/:id using req.params. Discover pattern matching and multiple variables for flexible routing.

Learn how NodeJS and Express use app.use and express.static middleware to bridge requests and responses, serve static files, and chain middleware with next to handle assets in a public folder.

Learn how Express supports templates and template engines to generate HTML on the fly, using view engines like EJS, render, and data objects from the views folder.

Explore how express now provides body parsing built-in, replacing the separate body-parser, and learn to manage dependencies and open-source updates by inspecting module usage.

Explore how RESTful APIs use HTTP verbs and intuitive URLs to perform CRUD operations with JSON data. Learn how Express maps HTTP methods to routes to build simple, predictable APIs.

Explore structuring an Express app across multiple files using modules, routers, and controllers, and compare approaches with the Express Generator to improve scalability and maintainability.

Explore how relational databases store tabular data in tables, normalize to reduce repetition, and use SQL to query data, then map results to JavaScript objects.

Connect a Node.js app to a MySQL database using the mysql npm package, run queries, and receive tabular data as JavaScript objects via an asynchronous callback.

Explore NoSQL concepts and document databases like MongoDB, where data stored as documents (json) enables on-the-fly schema flexibility. Understand the trade-off between storage and adaptability in modern databases.

Connect Node.js applications to a MongoDB Atlas database, using collections and documents to store data, and query with JavaScript, while securing the connection string via environment variables.

Explore node's web server checklist, covering modules, asynchronous files, HTTP requests and responses, streams, buffers, databases, and how MERN and PERN stacks enable building websites and web apps with JavaScript.