Introduction to NodeJs

E1:  History of node js in depth



 

Now, let's focus on one of Node.js's best friends, the V8 Engine. It takes the code and runs it. Before doing anything, I just want you to read this carefully.

![image.png](/public/images/blogs/eoi82.png)

Alright, let’s move on to the session now. When the V8 engine processes the code, it happens in a few steps:

1. **Tokenizing/Lexing**: Your code is broken down into smaller tokens. You can explore this further by visiting [AST Explorer](http://astexplorer.net/). This is more on the academic side, so if you're interested in the details, you can check out the subject of Compiler Design (or just take a look at the screenshot provided). Also, read this article for more insight: [What are syntax and expressions in JavaScript](https://heyashu.in/digital-garden/blog/what-are-syntax-and-expressions-in-javascript).

![image.png](/public/images/blogs/epi83.png)

![image.png](/public/images/blogs/epi84.png)

![image.png](/public/images/blogs/epi85.png)

![](/public/images/blogs/epi86.png)

### Interpreted Language vs. Compiled Language

An interpreter reads and executes code line by line, while a compiler reads the entire code, compiles it, and then passes it to the engine for execution. JavaScript uses both a compiler and an interpreter to run the code, along with several optimizations like **JIT (Just-in-Time Compiler)**.

I highly recommend reading **[Scope and Closures by Kyle Simpson](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/README.md)** to dive deeper into these concepts. I am covering digital notes of these books seeding soon in the garden [here](https://heyashu.in/digital-garden/notes). The compiler used by V8 is called **Turbofan**, and its job is to optimize the code so that it runs faster, especially if the same section of code is executed multiple times.

Also, remember that **Garbage Collection** happens in parallel to free up memory. Below, I’ve listed the names of some garbage collectors used in the V8 engine—make sure to look them up and read about them.

### How Byte code looks like ?

![image.png](/public/images/blogs/epi87.png)

https://medium.com/dailyjs/understanding-v8s-bytecode-317d46c94775

- - -

### Search These Keywords

1. Turbofan
2. Ignition Interpreter
3. Bytecode
4. Optimized Code
5. JIT (Just-in-Time Compilation)
6. Deoptimization in Compilation
7. Inline Caching
8. Copy Elision
9. Orinoco Garbage Collector
10. Oilpan Garbage Collector
11. MCompact Garbage Collector
12. Scavenger Garbage Collector
13. Mark-and-Sweep Algorithm
14. [V8 Crankshaft Compiler](https://github.com/thlorenz/v8-perf/blob/master/crankshaft/compiler.md)

### Questions

1. How does the compiler optimize the code, and in what situations does it fail to optimize?
2. Research other algorithms similar to the **Mark-and-Sweep** algorithm. What do they do, and how do they differ?
3. Find out byte code in v8 engine github repo

### Useful Links

1. [AST Explorer](http://astexplorer.com/)
2. [V8 Turbofan Documentation](https://v8.dev/docs/turbofan)
3. https://github.com/thlorenz/v8-perf/blob/master/crankshaft/compiler.md
4. https://v8.dev/blog/launching-ignition-and-turbofan

### Tips

1. JavaScript is both an interpreted and compiled language, benefiting from various optimizations.
2. Read blogs of v8 website

And thats all for this session, I'm **Ashutosh Anand Tiwari,** and I'm writing digital notes on Node.js. If you enjoy these notes, please share them with your friends. If you find any errors or have improvements, feel free to contribute by clicking edit icon on top bar of this page[.](https://heyashu.in/admin) If you're interested in writing the next episode's notes, [visit this link](https://heyashu.in/admin). Let's learn together! Also, please consider giving a star to [this repo](https://github.com/ashumsd7/heyashu/tree/main/src/data). For any queries, [let's connect here](https://topmate.io/aat/1148709/pay). Thank you…


 Deep dive into v8 JS Engine

 E-8 Deep dive into v8 JS Engine




### About the Creator 
(The Boss, Akshay Saini)

Akshay started building websites in the 7th or 8th grade and has since worked at Paytm, Uber, Lendingkart, and multiple startups, where he learned how to develop large-scale projects. He even started a startup while still in college. Throughout his career, one of the key factors that has helped him succeed is being curious. He believes that having curiosity and the desire to learn new things will help you continually improve. He encourages you to ask questions, as this will significantly benefit your career. Akshay urges you to maintain this curiosity during the course as well.

### Requests from the Creator Before Starting the Course

1. Keep taking notes, either digitally or in a notebook, as you follow along with the videos.
2. Practice the concepts as you watch the videos.
3. You can write notes in Notion, Evernote, or on your personal website (this suggestion is from me, not the creator).
4. Focus during the videos. Silence your phones.
5. Plan and schedule your course, and stick to it.
6. Watch one episode, then take a break. Try to explore the concepts on the internet, implement them on your system, and then move on to the next one.
7. Join the Discord community (the link is available within the course).
8. Ask questions and help each other out.
9. Make friends.
10. Refer each other in your respective careers.
11. Give your full attention, focus, and practice to this course.

Okay… Let’s get started…

Here we go 😄


Welcome to the course

E0 Welcome to NamasteNodeJS







Watch [Namaste JavaScript](https://namastedev.com/learn/namaste-javascript) its Free










## What is Node JS
https://nodejs.org/en
Its a JS runtime  built on top of chrome v8 JS Engine. Node JS is Cross Platform ( Can run on different type of systems) , Open Source: Code is Open and Managed by Open JS Foundation ( Organization)
 and it **executes JavaScript outside the web browsers**. Node JS has an **event driven architecture ( will discuss later)** and capable of **Asynchronous / non blocking I/O**




![image.png](https://i.ibb.co/2MJPG76/1.jpg)
## History of NodeJS
### 2009:  Node JS born
First version came in 2009
developed by : [Ryan Dahl](https://en.wikipedia.org/wiki/Ryan_Dahl)
![image.png](https://i.ibb.co/fqBxHrG/2.jpg)
![image.png](https://i.ibb.co/CmLDDGx/3.jpg)
![image.png](https://i.ibb.co/5nLd5nV/4.jpg)


### 2010 :  NPM born
NPM came in the picture ( package manager )
Anyone can do a work and post in NPM for public use


### 2011: windows came
initially Node JS was developed it was just for Mac OS and Linux
in 2011 windows support came and ( Joyent + Microsoft ) they given
node js support for windows


### 2012: NPM NodeJS friendship
Joyent said they will not be managing Node JS now
Isaac Z. Schlueter  took over it and he was the creator of the NPM
[https://izs.me/](https://izs.me/)
![image.png](https://i.ibb.co/HnWLn7b/5.jpg)


### 2014:  Fedor Indutny forked and made IO.js
Because When development was slow nowadays because Joyent  has left
so people was started contributing it
 [Fedor Indutny](https://github.com/indutny) was one of those
![image.png](https://i.ibb.co/wRGRzGK/6.jpg)


Now everything was scattered because two versions of Node Js was running


![image.png](https://i.ibb.co/QJpyyK1/7.jpg)


### 2015 ( Sep) : Node.js Foundation Came


Node.js Foundation came and resolved all conflicts between io.js and others
a legal foundation started managing this


[https://github.com/nodejs/node/issues/1416](https://github.com/nodejs/node/issues/1416)


### 2019 : git merge two-foundations


There was two foundations and both are merged


![image.png](https://i.ibb.co/Thr37cH/8.jpg)


Now Open JS foundation is managing Node JS


## Feedback


Hey your feedback si required for me , please give  [this repo](https://github.com/ashumsd7/ashu-new-portfolio-website/blob/main/src/data/mardown/notes/namaste-node-js-s1-by-as/e1.js) a star 🌟 if you liked the blog
if you want to contribute in it please feel free to fork , You can see github link on top right corner of top bar or  [click here](https://github.com/ashumsd7/ashu-new-portfolio-website/blob/main/src/data/mardown/notes/namaste-node-js-s1-by-as/e1.js)


I am waiting for your feedback, See you in next episode,


Thanks 👋🏻




Do you know about SDLC, also known as the Waterfall Model? It stands for **Software Development Lifecycle,** a process that a project follows from start to finish. There are various models, and Waterfall is one of them. Here's a breakdown:

### SDLC (Waterfall Model)

1. **Requirement**: Managed by Project Managers, CTO/CEO, or senior staff in smaller companies. They collaborate with designers to define requirements.
2. **Design**: Engineers or tech leads handle high-level and low-level designs.
3. **Development**: Done by developers.
4. **Testing**: Managed by QA, with test cases sometimes written by developers.
5. **Deployment**: Managed by DevOps or senior developers.
6. **Maintenance**: Continuous process if new requirements arise, repeating the cycle.

[Read more Models Here](https://www.geeksforgeeks.org/top-8-software-development-models-used-in-industry/)

### Monolith vs. Microservices

![image.png](/public/images/blogs/2micormono.jpg)

### Monolith:

Monolith architecture is like building everything together in one big project. Imagine when you make a website; you write HTML, CSS, and JavaScript, then install packages, which brings `package.json`. You’ll add backend, database, and any services like sending emails within this same project. So, **everything is in one repo**, from frontend to backend and database. It’s like **all developers working on the same large codebase**—the **monorepo**. All functionalities are inside this one project.

### Microservices:

Now, let’s talk about microservices. First, understand that **a service** is a separate project that does a specific thing. For example, if you need to send an email, you can have a **microservice for email notifications**. This microservice will work as a standalone project, not part of the main app. So, in this approach, instead of everything living in one big project like monolith, you have **many small independent projects** (microservices) handling individual tasks. This helps when scaling or maintaining projects, and **services can run independently**.

So, whether to go for **monolith** or **microservices** depends on your project requirements.

### What to use?

Both Monolith and Microservices architectures come with their own pros and cons. I would suggest you read more about it, but here's a quick overview. First, it depends on the project requirements. Remember, in a Monolith architecture, code review and overall management become tough if you have a large codebase. Everything needs to be well-maintained, and running everything together may require a powerful system. I’ve experienced this firsthand when my system couldn't handle everything.

### What I love?

I don't have a personal laptop, so I use my company’s device, which is an Intel i5 processor. Once, I had to work on a Monolith repo on [Gluestack UI](https://gluestack.io/) that involved backend (Docker), frontend (React Native), and a component library. Believe it or not, my laptop kept freezing when I tried running both backend and frontend. That’s why **Microservices** work better for me. Debugging is smoother, and the overall experience is better. Maintenance is easier, you can independently assign work, and you can even change the tech stack for smaller services in Microservices, which is a huge plus!

[Read more differences here](https://www.simform.com/blog/monoliths-vs-microservices/)

ohk thats all about this topic, will continue with this , stay tuned, Good bye!


Microservices vs Monolith - How to Build a Project

e1: Microservices vs Monolith How to Build a Project

Welcome back! If you haven’t read the previous blog about the two friends, go and check that out first because things are getting more interesting. We’ve received an official FIR against Node.js, and when Node.js faced trouble, it called in its two best friends for help. One of them, V8, was already investigated in our last episode. Now, it’s time to bring in the second friend: **Libuv**.

Libuv is full of secrets, and this investigation won’t be easy. There are many things we don’t know yet. So, what are we waiting for? Let’s head to the police station and question Libuv until we find the answers. It’s time to close this case for Season 1!

We’ve already talked a lot about Libuv, but there are still a few questions we need answers to. Specifically, we haven't looked at the **idle**, **prepare**, and **pending callback** phases  These are important, and today, we’re going to clear them up.

Ready, detectives? Let’s dive in and solve these mysteries. You can also check the official Node.js documentation here: https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick

### Pending callback

As we know, all file and connection-related tasks are handled in the **poll phase**, right? But sometimes, there’s a possibility of a process getting stuck in the poll phase. This could happen for various reasons, like recursive calls, errors, or a large number of requests, which may cause delays. To avoid such situations, if there are any **pending callbacks**, they get executed in the **pending callback phase**.

This phase is not super important in everyday work, but academically, you should be aware of it. If you have the time, go ahead and read more about it. Essentially, it executes I/O callbacks that were deferred to the next iteration of the event loop.

### idle/prepare

In this phase, checks take place within the event loop, and it is performed internally. As I mentioned earlier, this phase is more for academic understanding. If you're interested, go ahead and read the [official Node.js documentation on the event loop](https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick). Keep in mind that the official docs might have different diagrams or images, but don’t get confused. Just focus on understanding the concept. You can also read more about libuv design here.

The **poll phase** is the most important phase of the event loop, and **idle/prepare** takes place right before it.

**Homework:** Can you find out where in the code the event loop waits at the poll phase if there's nothing to run?

### What is a Tick?

In Node.js, one complete cycle of the event loop is called a **tick**.

### Logic of Waiting in Poll Phase

Before the event loop enters the **poll phase**, it calculates how long it needs to wait there. The logic behind this is not too complex, but it can be tricky to explain without going into code examples. It’s best to explore this topic by reading the actual code and checking out blogs or videos available online. Best of luck with that!

Sorry, explaining this in writing can be tough, but in the future, when you're relaxing in a garden, I’ll think of a simpler way to explain this. Stay tuned! For now, just remember that the event loop is the master in **libuv**.

### Mystery of Thread Pool

We know that libuv handles different types of tasks, like DNS, cryptography, file access, OS-related tasks, and timers. These are complex tasks that are processed by libuv. For example, when libuv receives a file read request, it uses one of its threads from the thread pool to handle it. The request comes during the **poll phase**, and libuv sends it to the thread pool. The thread then transfers the file access to the OS and becomes available for new tasks. The same process happens for cryptography and other tasks.

### What is a Thread?

A thread is like a container that runs code. If you want to block it to perform some work, you can do that. Remember, this thread is different from the **main thread**. When we talk about the main thread, we are referring to the V8 engine's main thread, which runs plain JavaScript. On the other hand, the threads we are discussing here are part of the **thread pool** in libuv.

Libuv uses multiple threads. For example, if one file system request comes in, it will use one thread, and if another request comes in, it will use another thread. Requests keep coming, and these threads handle them by blocking and processing them as needed.

### Size of Thread Pool (UV Thread Pool)

By default, there are 4 threads in the UV thread pool. But what happens if we make 5 file system calls? It means the first 4 requests will block the 4 threads. Each thread will transfer its task to the OS, and once that task is handled, the thread becomes available again to take on the next request. The 5th request will wait until one of the threads is free and available in the UV thread pool.

![image.png](/public/images/blogs/threaadpoool.png)

### DNS Lookups / Crypto

Suppose a request comes for a DNS lookup. A DNS lookup is a heavy task, so it blocks one of the threads in the thread pool. If you request a cryptography task, it also uses the thread pool. Additionally, if anything else comes up that requires C++ code execution, it will also block one of the threads in the pool.

### Is Node.js Single-Threaded?

Come on! If you say Node.js is single-threaded, I’ll have to laugh, haha! Node.js can handle both asynchronous and synchronous code. While it runs JavaScript on a single main thread, it can use multiple threads for other tasks through libuv. So, it depends on what you're doing. You can't define Node.js simply as single or multi-threaded—it’s more flexible than that!

### Code Demo of Thread Pool

If you run the code below, it will take some time but the output will appear at the same time because it uses 2 out of the 4 available threads in the thread pool, and everything runs in parallel. The same thing will happen when you use all 4 threads.

```jsx
const fs= require('fs')
const crypto= require('crypto')
crypto.pbkdf2('password', 'salt', 5000000, 50, "sha512", function(err, key){
  console.log("1: CRYPTO PRIVATE KEY DONE");
} )

crypto.pbkdf2('password', 'salt', 5000000, 50, "sha512", function(err, key){
  console.log("2: CRYPTO PRIVATE KEY DONE");
} )

//OUTPUT
1: CRYPTO PRIVATE KEY DONE
2: CRYPTO PRIVATE KEY DONE
```

### Let's See What Happens with 5 Crypto Calls

If you make 5 cryptography calls, one request will be delayed because there are only 4 threads in the pool. The first 4 tasks will run on the available threads, and the 5th one will have to wait until a thread is free. The order of execution is not guaranteed, as the tasks finish based on when threads become available, and that depends on the complexity of each task.

```jsx
const fs= require('fs')
const crypto= require('crypto')
crypto.pbkdf2('password', 'salt', 5000000, 50, "sha512", function(err, key){
  console.log("1: CRYPTO PRIVATE KEY DONE");
} )

crypto.pbkdf2('password', 'salt', 5000000, 50, "sha512", function(err, key){
  console.log("2: CRYPTO PRIVATE KEY DONE");
} )
crypto.pbkdf2('password', 'salt', 5000000, 50, "sha512", function(err, key){
  console.log("3: CRYPTO PRIVATE KEY DONE");
} )

crypto.pbkdf2('password', 'salt', 5000000, 50, "sha512", function(err, key){
  console.log("4: CRYPTO PRIVATE KEY DONE");
} )
crypto.pbkdf2('password', 'salt', 5000000, 50, "sha512", function(err, key){
  console.log("5: CRYPTO PRIVATE KEY DONE");
} )

//output
2: CRYPTO PRIVATE KEY DONE
4: CRYPTO PRIVATE KEY DONE
3: CRYPTO PRIVATE KEY DONE
1: CRYPTO PRIVATE KEY DONE
5: CRYPTO PRIVATE KEY DONE
```

### Can We Change the Thread Pool Size?

The answer is **YES**! You can change the thread pool size by setting the `UV_THREADPOOL_SIZE` at the top of your file like this:

```jsx
process.env.UV_THREADPOOL_SIZE=2
```

### Networking in Node.js (45)

If a user sends an API request to your server, does that API request use the thread pool? The answer is **no**. API requests use **sockets**. For each incoming connection or API request, a new socket is created, not a thread. Unlike the "thread per connection" model, where each connection would require a new thread, Node.js uses a more efficient model.

Instead of creating a new thread for each request, Node.js uses scalable I/O event notification mechanisms like **epoll** (Linux) or **kqueue** (MacOS) to handle multiple requests at the same time without the need for hundreds of threads. This is what makes Node.js very efficient in handling high numbers of API requests.

### Scalable I/O Event Notification Mechanism (epoll/kqueue)

**epoll** (for Linux) and **kqueue** (for MacOS) are algorithms that handle multiple connections efficiently. When multiple connections are made, **epoll** keeps track of all of them. If there is any activity, like data to read or write on a connection, epoll will notify **libuv**. Libuv then triggers the appropriate callback, and V8 runs the callback.

This mechanism is scalable and efficient because it doesn’t create a new thread for every connection. Instead, **epoll** manages all the connections using file descriptors. This is what makes Node.js capable of handling a large number of requests without using too many system resources.

This is more on the academic side, related to operating systems, so it can take some time to fully understand. You can read more about it here and [here](https://medium.com/@avocadi/what-is-epoll-9bbc74272f7c).

### Learnings We Got Here

* Never block the **main thread** (V8's main thread).
* Avoid using **synchronous** methods on the main thread.
* Be cautious with **complex calculations**, like regex operations.
* Don't do heavy **JSON operations** on the main thread.
* **Data structures** are important because the core of libuv and other systems relies on them to manage tasks efficiently.
* A **min-heap algorithm** is used by timers in the queue.
* Naming is very important. Clear, descriptive names help make the code easier to understand.


LibUV Thread Pool: Deep Dive

E10: Thread Pools

We covered a lot of theory, investigating Node.js from its beginnings to 2025, and now it’s time to take action. But be patient — we'll start with some theory to set the context of what a server is, and then write something. Today, your VS Code or code editor won’t be alone. Node.js will be part of your code base, and we will write something. So, what are we waiting for? Let's begin! We'll read about servers, what development means, what a proxy server is, and what DNS is. Then, we’ll create a server

### What is Server?

When someone says "deploy to the server," it means we're referring to the hardware where the operating system and processors are. It means we're running our application, the one we've coded, on that machine. This hardware allows us to save something to the system and retrieve it. That’s what a server does. Deployment is all about saving and running our code on that hardware machine

### Can we use our systme as server?

The answer is yes, but the question is: will you be able to provide what a server from AWS offers? No, because you have limited RAM, limited memory, and no 24/7 access. So, while it's possible, it’s not practical. AWS and other servers run 24/7, have large-scale RAM and memory, and their processors are very powerful. Internet connection is also a concern.

### IP Address

A system can be identified by one address. For your computer, this address might change, but for servers, it does not. Servers have a dedicated IP address that never changes, which is why they are called servers. They are designed to serve, and they also have multiple hardware servers running in different locations. For example, when you create a Firebase server, it will ask where you want your server, such as Singapore. To create a real-time database server, you just click, and you’ll be asked to choose the physical location where you want to connect.

### Node Server

What we do now and in the future is create servers that can handle requests from the outside world. That’s what Node.js is all about. Now, let’s discuss the architecture and dive deeper into it.

### Client Sevrer Acrtictire

A client is simply a person or system trying to access your server. For example, if someone opens a browser on their laptop and tries to access a file, whenever a client hits a URL (e.g., [www.heyashu.com](http://www.heyashu.com/)), the browser (the client) wants to access files from Heyashu. A socket connection is opened, and there is something on the server side listening to these requests. An application deployed somewhere listens for these requests, and that machine or app is called the server. There might be multiple clients making similar requests to the server's assets. As we've seen with libuv and Node.js, the server handles these requests by receiving data through the socket connection and sending it back to the client. And that's the whole process.

![image.png](/public/images/blogs/e11p2.png)

### TCP IP Protocol/Web

Whenever data is sent, it uses the **Transfer Control Protocol (TCP)**. Again, this falls under the academic side of computer networking, so you can learn more about it by looking up **TCP/IP connections** on the internet. Multiple computers are connected to each other using the internet, which is why it’s called the web, and each has an address. But what does "protocol" mean? It means rules. Communication must follow some rules, that’s all. For example, if I start writing these notes in Chinese, you wouldn’t understand. By the way, I’m writing digital notes on Node.js in **Hinglish** — check here. So, rules are set, and that’s how communication works.

### Other protoals 24

HTTP, FTP, SMTP are different types of request protocols. Depending on the type of request, different rules are used to transfer data. It's like getting things from a shop — different items have different rules. For example, water needs a bottle, but vegetables need a packet. The same applies to requests in a server; the protocol defines the rules. For normal web requests, we use the **HTTP protocol** (Hypertext Transfer Protocol).

![image.png](/public/images/blogs/e11p3.png)

### How data is sent to the client? Data Transfer

Data is not sent in bulk; it is sent in chunks, which in computer network language are called **packets**.

There is also the concept of **streams** and **buffers**. A stream means a continuous connection, and a buffer means chunks of data. We will learn more about this later, but for now, just remember that **TCP/IP** is the protocol used to send data from server to client. In Node.js, the concept of **streams and buffers** is important, so go and learn it!

### Domain Name

Whenever you visit a server, you use something like a web address. For example, for these notes, you might type **[www.heyashu.in](http://www.heyashu.in/)**. You also know that the data is sent from a server because I’m not running my system 24/7 to serve these notes. I’m using a server, and that server has a unique IP address. If you type that IP address, you will get the same website. But **heyashu.in** is called a **DNS** (Domain Name System). **Google.com** is a DNS, and **namastedev** is a DNS. Got it? Now, try hitting this IP: **8.8.4.4** or this one: **142.250.217.78**. These are IP addresses, and if you hit **142.250.217.78**, you will get **google.com**.

![image.png](/public/images/blogs/e11p4.png)

It means **google.com** is mapped to this IP address. Got it? You are using domain names because it's tough for humans to remember these IP addresses. So, remember: first, the browser contacts the **DNS server**, which gives you the IP address, and then you connect to that IP. Got it?

### Can we have multiple HTTP servers?

Can we create multiple applications on the same server? Multiple servers on multiple machines? Confusing, right? Haha, I mean, is it possible to have multiple servers running to handle different things? Yes, it's possible! Now, suppose you have two HTTP servers, meaning two Node.js instances. Which server will handle the incoming request? It will be decided based on the **port**

### Ports in IP Addresses

A **port** decides which server will take the request. Now, suppose you're requesting **142.250.217.78:3000**—3000 is the port number. The server that listens on port 3000 will handle the request. The port is the decider, okay?

So, **a port is a number that identifies a specific application or service on a network-connected device and is used in conjunction with an IP address to send and receive messages.** For more, you can read up on computer networks, haha!

![image.png](/public/images/blogs/e11p5.png)

```jsx
 heyashu.in        /digital-garden 
 142.250.217.78:      3000 
  [IP Address]       [NodeJS app handling digital-garden code/ page]
```

So, actually, a proper website has different things hosted on different servers. For example, files might be hosted on one server, another server might handle images, and yet another one handles databases. You get it, right? This makes things faster, with one server dedicated to images, another for files, etc. We’ll be building all of this, so stay tuned!

### Socket vs Web Sockets

![image.png](/public/images/blogs/e11p6.png)

When we request something, a socket connection is opened, and data is received, involving the opening and closing of sockets. WebSocket connections are different—they stay open and allow two-way communication. You can explore different types of sockets. Normally, socket connections are made and closed, but WebSockets remain open, which makes them resource-heavy. Read more about it!

### Lets create a sever

Node.js has multiple built-in modules. **https** is one of them, and it's used to create a server. The **https** module has a function called `createServer`. Here’s a list of modules — whatever you see in this list are called **native modules** of Node.js. Sometimes, they are imported like `node:http` in the code. Wait and see!

```jsx
const http= require('http')
// const http= require('node:http')

// sever is an https and now can listen the requests
const sever= http.createServer(function(req,res){
  //req and res are the object you get 
  // .end to use to send the response
  res.end('You are getting this from heyashu.in')
})

// listen on post 7777
sever.listen(7777)
```

Now whe you will do `node file-name.js` in terminal then it will wait for the request. and got the browser’s url type [localhost:7777](http://localhost:7777) and you wll get this 

![image.png](/public/images/blogs/e11p7.png)

What if you need to identiy the url whatever /seed-a-plant

update the code like this

```jsx
const sever= http.createServer(function(req,res){
  //req and res are the object you get 
  // .end to use to send the response
  if(req.url ==='/seed-a-plant'){
    res.end('🌱 Plant Seeded, Wohoo  👏')
    return
  }
  res.end('You are getting this from heyashu.in')
})

// listen on post 7777
sever.listen(7777)
```

![image.png](/public/images/blogs/e11p8.png)

Creating a server using the **https** module can be tough for large-scale applications, so we’ll be using **Express.js**, a framework for Node.js, to make things simpler. Writing large-scale applications in plain JavaScript is challenging, which is why we use frameworks like **React**, **Vue**, and **Angular**. The same applies here. So let’s take a quick look at what Express.js is and the complications we might face. You can check this, or we will write more about it here in this digital garden and drop a link.

### Express JS

It’s a framework for **Node.js**. We will discuss it later.

### Things to Learn

1. **Socket connections**
2. **HTTPS vs HTTP**
3. **FTP**
4. **SMTP**
5. **TCP**
6. **Streams and buffers**
7. **Data packets**
8. **Load balancers**


Create a http server using Node JS

e11: Create a node js server

In computer science, a **database** is an organized collection of data, a structured way of collecting and storing information. It is based on the **DBMS** (Database Management System), which means you can create, delete, edit, and retrieve data. The DBMS software manages everything, including the storage.

### Types of Databases

1. Relational Databases (MySQL, PostgreSQL)
2. NoSQL Databases (MongoDB)
3. In-Memory Databases (Redis)
4. Distributed Databases (CockroachDB)
5. Time-Series Databases (InfluxDB)
6. Object-Oriented Databases (db40)
7. Graph Databases (Neo4J)
8. Hierarchical Databases (IBM IMS)
9. Network Databases (IDMS)
10. Cloud Databases (Amazon RDS)
11. Multi Model Database

I’m not diving deeper into this. You can read more by searching on the internet.

### RDBMS: Relational Databases (MySQL, PostgreSQL)

![image.png](/public/images/blogs/2e12db.png)

In 1970, **E.F. Codd** introduced Codd's 12 rules (actually 13, because they start from 0 to 12). He designed [these rules](https://prepinsta.com/dbms/codds-rules/)  to define what qualifies as a relational database. If a database follows these 12 rules, it falls into the category of a relational database. There are multiple databases that don’t strictly follow all these rules but are still called relational databases. **MySQL** and **PostgreSQL** are the most commonly used in this category.

### History of MySQL

MySQL was created by **Michael Widenius**. He has three daughters: My, Max, and Maria. **My** is the name of his eldest daughter, which is how **MySQL** got its name. Later, he created more databases, like **MaxDB** and **MariaDB**. MariaDB was a fork of MySQL. 

![image.png](/public/images/blogs/3e12db.png)

After some time, **Sun Microsystems** acquired MySQL, and later, Oracle acquired Sun Microsystems, so now Oracle manages MySQL. This isn't typically asked in interviews, but it's good to know for your curiosity! [read the full history](https://java366.wordpress.com/2018/05/22/http-www-papitv-com-mysql-mariadb-founder-michael-monty-widenius-interview-by-olga-show-chervyakova-kc-leung/)

### Postgres

Another scientist, **Michael Stonebraker**, was working on a project called **Ingres** at the University of California. 

![image.png](/public/images/blogs/4e12db.png)

He left the university around 1985 and started a new project called **Post Ingres**. This project focused on **SQL** (Structured Query Language), and eventually, it evolved into what we now know as **PostgreSQL**.

### SQL: Structured Query Language

Now that you know about different types of databases and their history, you understand they are organized and structured. To manage these databases — to create, read, update, and delete data — you need to perform operations called **queries**. For that, we use a language called **Structured Query Language (SQL)**.

![image.png](/public/images/blogs/5e12db.png)

 Don’t get confused with "sequel" or "prequel" — it's not related to movies! Some people pronounce SQL as "sequel," but it stands for **Structured Query Language**, not related to cinema, haha!

### NoSQL (MongoDB)

**Types of NoSQL:**

1. Document DB
2. Key-Value DB
3. Graph DB
4. Wide-Column DB
5. Multi-Model DB

MongoDB uses the **Document** type of NoSQL database. Some people call it "Not Only SQL" or "Non-SQL," but the naming varies. The key difference is that it doesn’t operate using **Structured Query Language (SQL)**. NoSQL databases came into existence around the 2000s.

### History of MongoDB

MongoDB was created in 2009 by a company called **10gen**. The name **Mongo** comes from the word **Gigante**, meaning "huge," because it can store a massive amount of data. Later, the company 10gen shifted its focus to MongoDB and renamed itself to **MongoDB Inc**.

![image.png](/public/images/blogs/6e12db.png)

 MongoDB quickly evolved and became popular, as it emerged around the same time as **Node.js**. It felt like Node.js and MongoDB were made for each other, which increased developer productivity. MongoDB is built using **C++** with some JavaScript code as well.

### Presentation of Database Tables

Relational databases store data in rows and columns. "Relational" means that there are relationships between different tables. For example, in a **student** table (as shown below), there might be another table called **hobbies**. The **student_id** in the hobbies table is related to the student table because each row in the hobbies table is linked to a student. The **student_id** is used as a **foreign key** to create this relationship, which is how relational databases work.

In **MongoDB**, we have **collections** that function like JavaScript objects or JSON data, but in MongoDB, they are called **Documents**. The keys in MongoDB are referred to as **fields**. In MongoDB, there is no need for **[data normalization](https://www.google.com/search?q=whatis+databse+normalization&sca_esv=0ee23696230f4fd0&sxsrf=ADLYWIJgBePNz9IXbOL4fpJ7-tgXmIkeHA%3A1726342963897&ei=M-flZt-9NsnR2roPn5nV6QM&ved=0ahUKEwifo_7YmMOIAxXJqFYBHZ9MNT0Q4dUDCA8&uact=5&oq=whatis+databse+normalization&gs_lp=Egxnd3Mtd2l6LXNlcnAiHHdoYXRpcyBkYXRhYnNlIG5vcm1hbGl6YXRpb24yBxAAGIAEGA0yBxAAGIAEGA0yBxAAGIAEGA0yBxAAGIAEGA0yBxAAGIAEGA0yBxAAGIAEGA0yBhAAGBYYHjIGEAAYFhgeMgYQABgWGB4yCBAAGBYYHhgPSJwqUABY3yhwAHgBkAEAmAHQA6ABjC2qAQowLjkuMTcuMC4xuAEDyAEA-AEBmAIboAKSLsICBBAjGCfCAgoQABiABBhDGIoFwgIQEAAYgAQYsQMYQxiDARiKBcICCxAAGIAEGLEDGIMBwgIIEAAYgAQYsQPCAgsQABiABBiRAhiKBcICDRAAGIAEGLEDGEMYigXCAg0QABiABBixAxjJAxgKwgIHEAAYgAQYCsICChAAGIAEGAIYywHCAgcQLhiABBgKwgIFEAAYgATCAgsQABiABBiSAxiKBcICDhAAGIAEGJECGLEDGIoFwgIKEAAYgAQYsQMYCsICChAAGIAEGLEDGA3CAgYQABgNGB6YAwDiAwUSATEgQJIHCjAuNy4xOS4wLjGgB_f2AQ&sclient=gws-wiz-serp)**  or joins, and there can be multiple collections.

### Difference between RDBMS and NoSQL

I am just pasting the image. Please Google it to learn more. To be honest, I’m tired today as I just came back from somewhere and don’t have the energy right now. Sorry this time, I’ve written quite a lot already.

![image.png](/public/images/blogs/7e12db.png)

### Queries to Query yourself

1. Why NoSQL recommended for social media Databses
2. [Read uber schemaless Databse blog](https://www.uber.com/en-IN/blog/schemaless-part-one-mysql-datastore/)


Databases and mongoDB

E12: Databases and mongoDB

Okay, it’s time to create a database. Go to the database website by clicking here. There are two ways to install the database:

1. **Download the file and install it**: Remember, MongoDB is cross-platform, so it works on Windows, Linux, and everywhere.
2. **Use a managed database service**: You can ask MongoDB to host and manage your data.

There are also two versions of MongoDB:

* **Community version**: This is free and available for developers to use.
* **Enterprise version**: This is for large companies, and you need to pay for it.

This version corrects the grammar while keeping the content clear and simple. Let me know if you'd like further adjustments!

### Self-Managed vs Mongo-Managed

With **self-managed**, you install, back up, and host everything yourself — that’s what self-manage means. But let's use the second approach where **MongoDB manages everything**. So, in this blog or notes (whatever you want to call it), we are using the **MongoDB Managed version**. If you want to know how to manage it yourself, plant a seed by writing a blog here. You can get started by [clicking here](https://www.mongodb.com/).

### Installing MongoDB

After clicking on download or installing **Atlas**, you’ll be asked to fill out a form with 2-3 fields. Fill that in, then proceed to the next step. Since this database is managed by MongoDB, they might adjust the setup based on your requirements. Rename your cluster — it’s currently named **Cluster 0**, but you’ll need to identify it later.

![image.png](/public/images/blogs/e13m2.png)

Click on **free MO** — remember in the last blog we learned that the server is hosted in a location? Check if **Mumbai** is written there. After clicking **Create Deployment**, a dialog will appear. Copy your username and password. You can create multiple users or just click on the **Create a Connection Method** button, where you can find your cluster name. As you can see in the screenshot, your cluster is created. Now, to use it, click on **Connect**. Remember, the website interface might look different depending on when you're using it, but the same keywords and steps apply consistently.

![image.png](/public/images/blogs/e13m3.png)

After clicking **Connect**, choose your driver. You should have a username and password; if not, create them in the dialog by clicking **Connect**. Copy the connection string and paste it into your file. We will create a `database.js` file and paste the string there, just like below. Make sure to replace `<db_password>` with your actual password.
recap 24:50

```jsx
const URI= 'mongodb+srv://heyashu:<db_password>@digiden.m6she.mongodb.net/?retryWrites=true&w=majority&appName=DigiDen'
```

### Visualize Database and Connect

To do this, download the software [MongoDB Compass](https://www.mongodb.com/products/tools/compass) to see and manage the database using a GUI. If you want to learn what GUI and CLI mean in Hindi, click here: [What is CLI vs GUI](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e4-cli-gui).

Or, you can click this link to watch a 1-minute video on [how to download MongoDB Compass](https://www.loom.com/embed/10015cb84fe242fd8e994130e9c88815). Once downloaded, paste the connection string URL you copied earlier and click **Connect**. You’ll see some sample data. From here, you can create a database directly in MongoDB Compass. Look for the **Create Database** green button.

![image.png](/public/images/blogs/e13m4.png)

After clicking on **Create Database**, I named it **Notes** and created a collection called **user**. I can see this after clicking on **Notes** from the sidebar and then clicking on **Add Data**. You can either import data from a JSON file or write the document (JSON) manually.

![image.png](/public/images/blogs/e13m5.png)

I have added this, and then click insert, so first user is created in Databse Notes and User collection, 

```jsx
/** 
* Paste one or more documents here
*/
{
  "firstName" :"heyashu",
  "website" : "heyashu.in",
  "city" :"ayodhya"

}
```

After clicking insert it will wlook like this, id is auto genreated

```jsx
_id
66e68c334a5d8d6956583843
firstName
"heyashu"
website
"heyashu.in"
city
"ayodhya"
```

### Now lets read using code

So lets go to editor wherever you have pasted your connection string install MonoDb node js driver using NPM, [what is npm](https://www.w3schools.com/whatis/whatis_npm.asp)

```jsx
npm install mongodb
```

It will add **node_modules**, **package.json**, and **package-lock.json**. We will discuss these later. If you’ve already done **git init**, it means you want to manage this whole code using Git. If not, run **git init** in your terminal.

```jsx
git init
```

then createa file .gitignore and paste

```
node_modules
```

In the sidebar, you’ll see many changes. Actually, **node_modules** contains the code of the packages you installed using npm, but we won’t push that to the Git repo. We need it only for development purposes. The **node_modules** folder itself is more than 50MB, so it's not good practice to host it. That’s why we add a **.gitignore** file, and **node_modules** will be ignored. Don’t worry, we’ll write more on this later. For now, just do it. Let’s focus on the database. Nice, right?

### Read the Data

[Read Mondo Node Document from here](https://www.mongodb.com/docs/drivers/node/current/) , ok now lets see how to read the data from DB and setup mongo things

Just Paste this code in you JS file, now if you file name is database.js, run `node database.js` in terminal

```
// Importing the MongoClient class from the mongodb package
const { MongoClient } = require("mongodb");

// MongoDB connection string (replace <username> and <password> with actual credentials)
const URI =
  "mongodb+srv://<username>:<password>@digiden.m6she.mongodb.net/?retryWrites=true&w=majority&appName=DigiDen";

// Create a new MongoClient instance using the connection URI
const client = new MongoClient(URI);

// Specify the name of the database
const dbname = "Notes";

// Main function to handle MongoDB operations
async function main() {
  // Connect to the MongoDB server
  await client.connect();
  console.log("Connected to MongoDB");

  // Access the database by its name
  const db = client.db(dbname);

  // Access the 'user' collection within the database
  const userCollection = db.collection("user");

  // Fetch all documents from the 'user' collection and convert them to an array
  const findRes = await userCollection.find({}).toArray();

  // Log the results (documents from the 'user' collection)
  console.log("findRes: ", findRes);

  // Return 'Done' when the operation is complete
  return "Done";
}

// Call the main function and handle the results
main()
  .then(console.log("DATA LOGGED")) // Log a message if the function is successful
  .catch(console.error) // Log any errors if they occur
  .finally(() =>

  
  //output
/* findRes:  [
  {
    _id: new ObjectId('66e68c334a5d8d6956583843'),
    firstName: 'heyashu',
    website: 'heyashu.in',
    city: 'ayodhya'
  }
] */
```

### Insert the data

Now you read the data suppose you want to insert the data now in our Collection

```jsx
 // insert the data
    const newData={
      firstName: "Mohan",
      website:'heyashu.in/digital-garden',
      city:'Ayodhya-2'
    }
  
  
    const insertResult= await userCollection.insertMany([newData])
    console.log("insertResult",insertResult);
    
    // now try to read the data as befor eyou will get
    //OUTPUT
    /* [
  {
    _id: new ObjectId('66e68c334a5d8d6956583843'),
    firstName: 'heyashu',
    website: 'heyashu.in',
    city: 'ayodhya'
  },
  {
    _id: new ObjectId('66e6a4c72f5bc23db4698a68'),
    firstName: 'Mohan',
    website: 'heyashu.in/digital-garden',
    city: 'Ayodhya-2'
  }
]*/
```

Later, we will see:

* How to index
* How to update the data
* How to delete the data
* Read what is **FindCursor**


Create MongoDB database using Node JS

e13: create mongo db database


As we know now JS can also run outside of browsers on server.

### What is server ?

JavaScript runs on a server, but what exactly is a server? A server is simply a remote computer. When you run your React app locally, you call it a "local server" because your system is serving the page. A server is just a machine that provides a service or serves a page. If the computer providing this service is in a different location, like another country, it's called a remote or cloud server. Hope that makes sense! Now, let's move on…

### Client Server Communication

Now, we know a server is just a computer located far from us that can handle requests. Suppose you're reading this blog on [heyashu.in](http://heyashu.in/). When you type this URL into your browser, your local computer sends a request. The internet processes this request and directs it to the server. Every domain is linked to an IP address through DNS because humans can't easily remember IP addresses like "54.161.234.33." DNS translates the domain name to the correct IP address, and the server serves your page. Domain name is what you buy from GoDady and Hostinger and other websites.

Running JavaScript on a server is a big advantage because it allows a single developer with JavaScript knowledge to manage both the frontend and backend. If you know JavaScript, you can become a full-stack engineer. Don't worry; you'll get there with this course or by reading the notes!

![image.png](https://i.ibb.co/brf7D7h/1.jpg)

[Image Credit](https://heyashu.in/tech/notes)

### Story about JS Engine and Node.js

You know how JavaScript runs in browsers? Guess, guess! It’s the JavaScript engine! 🧠 Every browser has its own JS engine. It takes the JS code and converts it. But wait, isn’t the JS engine also software? Yep, it’s a program! And what language is it written in? Hmm, what comes after C? D? Nope, it’s C++! 🤓. Most JS engines, like the V8 engine in Chrome, are written in C++. Check out the [GitHub repo of V8 JS engine](https://github.com/v8/v8). Over 70% of the code is in C++! 🚀
![image.png](https://i.ibb.co/w7kyPnm/2.jpg)

![image.png](https://i.ibb.co/BLNRTmS/3.jpg)

Image Credit :  [Guithub repo of v8 JS engine](https://github.com/v8/v8) 

### Story of v8 the chrome’s Engine

V8 is written in C++ and helps run JavaScript and WebAssembly. It executes JavaScript code, but it’s not the whole story! 🤔 You can learn more about WebAssembly by Googling it. V8 follows [ECMA standards](https://stackoverflow.com/questions/4269150/what-is-ecmascript) (they decide what features to add!). Every JS engine is written differently, converting JS code to machine code.

Imagine this: **Your JS code** ➡️ **V8 Engine (C++)** ➡️ **Machine Code**.

And guess what? V8 can be embedded in any C++ application. So, if your system runs C++, you can run JavaScript through V8! 🖥️ But wait, if V8 is the hero, what’s Node.js? 🤷‍♂️ Isn’t V8 enough? Well, V8 is just for JavaScript (ECMAScript) and is designed for the web. Node.js wraps around V8, giving it superpowers! Node.js adds the ability to handle HTTP requests, access databases, and more. It makes JavaScript capable of doing things beyond just running code.

And remember, Node.js is also written in... what comes after C? Yep, C++! Not D, haha! So, Node.js is built in C++, with V8 as a dependency, making it all powerful! 💥

### Node.Js Runtime

V8 + Node.js together create the **Node.js runtime** environment. This runtime allows JavaScript to run outside the browser, like on a server.

**NOTE**: Node.js isn't just C++ code. About 25% of its code is written in JavaScript, which you can see in the screenshot above. It also uses various JavaScript APIs and capabilities, combining both C++ and JavaScript to give developers the power to build versatile applications. 🚀

![image.png](https://i.ibb.co/J5M4TNX/4.jpg)

[Image Credit](https://wanganator414.github.io/2019/08/02/JSRuntime) 

### Why Node Js and v8 is written  C++ ?

As we know, computers understand only binary code—010101010! This is the language that directly talks to computer hardware. If you’re lost, just remember: binary (010101) is called a low-level or machine-level language. 🖥️

Then came middle-level languages, also called assembly languages, like \`ADD A, B\`. Now, let's talk about high-level languages—what comes after B? Tell, tell! Don’t say B++! 😂 No such language! After B, it’s C, then C++, and then Java, JavaScript, etc. These high-level languages are human-friendly.

V8 and other JS engines take JavaScript (high-level) and convert it into machine code. If you’re curious, Google assembly languages and get familiar with high, middle, and low-level languages. Enjoy learning!

![image.png](https://i.ibb.co/BCSK3VF/5.jpg)

[Image credit](https://www.cs.mtsu.edu/~xyang/2170/computerLanguages.html)

### Browsers and their engines

Here is an overview of popular browsers and their corresponding JavaScript engines:

![image.png](https://i.ibb.co/vLZWXVD/6.jpg)

[Image Credit](https://www.lambdatest.com/blog/browser-engines-the-crux-of-cross-browser-compatibility/)

### Other use full words

Remember and google these words to know more

- Web Assembly
- Crosss Platform
- ECMAScript ( ES6)
- Guthub repo of node js and v8 its dependency
- Arm Processor  and x86
- Microprocessor

---

And that's a wrap for this episode! 🎬 Now take a break, spread the word, and share this blog with your friends! Don’t forget to ⭐️ star [this repo](https://github.com/ashumsd7/heyashu/tree/main/src/data/mardown/notes/namaste-node-js-s1-by-as) if you found it helpful. And if you spot anything wrong, feel free to fork the repo and contribute!

Let's meet in the next episode! Until then, tb tak chalte hai duaao me yaad rakhna 🙏 

Goodbye from Ashu!


Read How Javascript works on sever , digital notes by Ashutosh anand tiwari

JavaScript on Server

E2: JS on Server

### Planning and Designing a Project: Dev Tinder

We're going to discuss the first steps in project development—planning and design. The project is **Dev Tinder**, similar to the classic Tinder app, but here, developers swipe profiles instead of dates. It’s like a coder’s version of matchmaking!

Just like regular [Tinder](https://tinder.com/), you sign up, create a profile with preferences and photos, and then start swiping cards left and right. Instead of matching dates, though, it's all about developer profiles, chats, and collaborations. It's Tinder for coders—fun, right? Let's swipe right on code matches! 😄

![image.png](/public/images/blogs/2debdes.jpg)

If you're writing out the steps for **Dev Tinder**, here's a structured plan:

1. **Create an account** – Sign up for a new account.
2. **Login** – Access the app with your credentials.
3. **Update your profile** – Add preferences and profile photos.
4. **Explore profiles** – Browse through the feed of developer profiles.
5. **Send connection requests** – Swipe right to connect with others.
6. **Receive connection requests** – View matches from those who connected with you.
7. **See sent requests** – Check who you’ve requested connections with.
8. **Update profile and logout** – Manage settings and log out.

You can keep adding more features beyond this, including custom notifications, chat features, and developer-specific tools.

After this, the tech team steps in to plan out the technology stack for the project. We will decide whether to use **Monolithic** or **Microservices** architecture. If you don’t know what Monolithic and Microservices architecture are, check out **[Microservices vs Monolith - How to Build a Project](https://heyashu.in/digital-garden/notes/namaste-node-js/e1-microservices-vs-monolith-how-to-build-a-project)**.

### Tech Plan

We will use **Microservices architecture**, and here’s the plan:

1. **Frontend**: React.
2. **Backend**: Node.js and MongoDB.

You can list other security-related things as part of the planning process.

Once these things are done, the tech team moves in, but before that, developers work on **LLD (Low-Level Design)**. If you plan well, writing code will be a breeze.

### LLD: Low-Level Design

![image.png](/public/images/blogs/3debdes.jpg)

From the backend perspective, two major things are important:

1. **DB Design**
2. **API Design**

### DB Design

Let's talk about **DB Design**. You will create a collection called **User Collection**:

1. **User Collection**:

   1. Name
   2. Gender
   3. Address
   4. Phone number
   5. Email ID, password, and many more

Similarly, you will keep creating collections, but make sure to establish relationships between collections to avoid unnecessary work and database usage.

1. **Connection Request Collection.**

![image.png](/public/images/blogs/2adebdes.jpg)

You know that users will send requests to each other, so you will need a **Connection Collection** to track who is sending requests to whom, how many requests one person has, and the status of those requests. What are the staus can be there , Accepted Rejected Ingnored ,Blocked, Pending and what ever you need you can put that feature in. As per your requirement you can change design , not full design but slightly you can.

### API Design  ( Rest APIs)

First, let's understand **API**: It stands for **Application Programming Interface**, which is a set of rules and protocols that allow different software applications to communicate with each other. Think of it as a bridge that lets your app interact with another app or service. There are different type of requests the server and client communicate over HTTP using standard methods like **GET**, **POST**, **PUT**,  **DELETE and PATCH**

What is the difference between PUT and PATCH

\*The main difference between PUT and PATCH is that **PUT replaces an entire resource with a new one, while PATCH only updates a resource partially***

### List of APIs

Here’s the list of APIs we'll implement in our project:

1. **Signup**: `POST` – Create a new user.
2. **Login**: `POST` – Authenticate the user.
3. **Profile**:

   * `GET` – Retrieve profile information.
   * `POST` – Create a user profile.
   * `PATCH` – Update user profile.
   * `DELETE` – Remove user profile.
4. **Connection**: `GET` / `DELETE` / `POST` / `UPDATE` – Manage connection requests.

These APIs follow the basic **CRUD** operations (Create, Read, Update, Delete), which are fundamental to web development. You can explore more about CRUD [here](https://www.traceable.ai/blog-post/what-is-a-crud-api).

That's all for this topic! I hope next time, before you start your project, you'll follow this process for smoother development. Let's begin our journey—take care and goodbye for now! See you soon!


How to Plan a project HLD LLD

e2: Plan a project HLD LLD


### Download Node.js

Go to [Node.js](https://nodejs.org/en) website and download the latest version,
If you are struggling in installing feel free to contact me , we can [schedule a 5min meeting](https://topmate.io/aat/1148709/pay) I will help you to download Node.js in to your system , Best way to download it , Go to Prebuilt installer and download a file and install it by executing by dowland file. There might be some issues specific to your system , do not panic google or gpt the error you are getting it will get solved , or I am here [Lets connect](https://topmate.io/aat/1148709/pay) :)

### Verify your installation

If you have already installed or just installed check version of node into your system, open you command line or terminal of vs code or your favorite editor, One more thing if you have downloaded node.js NPM will get installed automatically into your system. What is NPM, it is a node package manager, to manage repository and host it, NPM took care of node in initial days you remember right ? Check out [Episode 2 Notes](https://heyashu.in/tech/notes/namaste-node-js#Introduction%20to%20NodeJS) , lets celebrate

```jsx
node -v                //v18.12.0
```

![image.png](https://i.ibb.co/Msd8xQH/2.jpg)

### Let’s write code !

Lets know about repl : **read-eval-print-loop.**

if you just write node into your terminal and enter yoyou get entered some environment thats called repl, means read evaluate print and repeat it. so after writing node, you can write any code , and thats the node js runtime environment, let me bring one example with you you can see I have written node and then repl environment started and you can write JS code and its handled by v8 engines + node js and using c++ to run these 2+ 2 and other statement, Read more about [what is expression statement and syntax in JavaScript](https://heyashu.in/blogs/what-are-syntax-and-expressions-in-js), Note one more thing this repl env you see in your terminal is similar to your browsers console. both are almost same, but in browser has engine + browsers apis, terminal has engine (v8) + Node js APIs. Yeah, you have written first node js snippet, now lets move where we learn how to write node js code in repository.

![image.png](https://i.ibb.co/fDHCd6p/3.jpg)

### Open you Code Editor

Here i am using vs code and its also recommended by Akshay Saini and most of the frontend developers use it. so lets continue with it, there is something new in the market, [neovim](https://neovim.io/) a new editor , google it. ok now open you vs code create a folder and create a file \`app.js\` and start writing JavaScript in it. After writing you can open terminal, there is short cut ( CTRL + backtick this is character present around Esc key ~ \` and it will open vs code terminal, if terminal is open , just write , I am also giving screen shot of the terminal

```jsx
node app.js
```

![image.png](https://i.ibb.co/vHyGmq6/4.jpg)

### Global Object server vs client

In browsers when you type window you get access of multiple things its by browsers where you get power of fetching URL or som much things , but in server there is no browser thats why node js does not give you \`widnow\` as global object, but it has similar global object and its name is \`global\`  and this global is by node js not by v8, smiler in browsers window object is from browsers not from v8 and we know \`setTimeout\` is not from v8, v8 is just engine which runs js coide thats it, other things are from either browsers or node js if JS is running on server, JS engines follows ECMAScript and there is no setTimeout in ECMAScript. its part of global or widnow object.

If you will try to access window in node js you will get an error, same you will write global in chrome’s console you will get error , here is the screenshot when you type window in node js

![image.png](https://i.ibb.co/Ykr7dy2/5.jpg)

But if you will write global you will get something like yoyou get when you console window in browsers , I am pasting both screenshots you can visualize for you reference. the first screenshot below is from the terminal of vs code and 2nd one is from the browsers console what yoyou get from inspect mode.

![image.png](https://i.ibb.co/5sySj04/6.jpg)

![image.png](https://i.ibb.co/47PH8Ch/7.jpg)

### this keyword in node js & globalThis

Here its remember to worth, this keyword by default in node js does not point to global object, as in browsers self, this, frame and window points to the window object, in node js by default this will point to {} and empty object. there is \`globalThis\` in ES20, is present in every browser and node js env wherever JS runs, so no confusion. So for window globalThis will point to window object, and for node js env it will point to global object on node js. so now Name is similar now across all js platforms,

### Curious google these keywords.

Here are the new words and question that we can explore and these are  introduced in this episode, and some request from the creator. 

- [neovim](https://neovim.io/) Editor ( substitute of vs code by microsoft)
- repl
- what is self this frame and why its points to window object in the browsers why ?
- Web workers
- globalThis
- Object and something reference ( Google it)
- Google history of globalThis why it came ?
- read the node js code , go to github repo

---

![image.png](https://i.ibb.co/1bT9RJ4/8.jpg)

And thats all for this episode and writing first line of code in node js

My name is Ashutosh Anand Tiwari, and I am writing digital notes on node js, if you like the notes please share with you friends if anything wrong in the notes feel free to contribute and fork the repo right now. if you want to write next epidote note please [fork the repo and contribute](https://github.com/ashumsd7/heyashu/tree/main/src/data) to it lets write and learn together, and In last I am just requesting to give a star 🌟 to [this repo](https://github.com/ashumsd7/heyashu/tree/main/src/data), for any other query click here to contact [lets connect here.](https://topmate.io/aat/1148709/pay)

Take care, Good Bye :) [](https://topmate.io/aat/1148709/pay)


Here you will learn how to install node js and write first line of code

Let's write code 

E3: Write first line of node js code

As you saw in the last episode, we wrote our first line of code in Node.js. Now, we could just keep adding whatever we want to `app.js`, and technically, it would work. But that's not the best way to do things because the file would get cluttered and hard to manage. Instead, we need multiple files. Basically, there should be one main entry file that runs the code, and other files will be connected to it. So, you'll use `require` to include different modules into your main file.

![image.png](https://i.ibb.co/s567zyG/11.jpg)

### require

So, when you use `require` to include a new module into another module, the code in the required module runs first, and then the rest of the code in your file executes. You can use the `require` keyword anywhere in your Node.js code.

**Note:** You can’t directly access variables and functions from one module in another module just by using `require`. Even if the code runs, you can't directly access the code. For example, if a module `sum.js` has a function `getSum()`, and you import `sum.js`, you still can't access `getSum()` in your entry file. But why is that?

The reason is that Node.js modules are encapsulated, which means each module has its own scope. To access variables or functions from another module, you need to explicitly export them using `module.exports` or `exports`.

Modules protect their code by default. that one module be like: 

![image.png](https://i.ibb.co/j4bYskd/Capture.jpg)

Arey aise kaise nahi btayega, So to know variable and functions of that module, you have to export and import in the file you  want to import.

sum module

```jsx
console.log('I am sum module');

 function calculateSum(a,b){
  console.log("Sum is", a+b);
}

module.exports =calculateSum  // the way you export  ( remember its export+s not export )
```

app..js ( entry file )

```jsx
const calculateSum= require('./sum.js')  // the way you import
console.log("I am entry files");

calculateSum(4,5)   // 9 is the output
```

Now app.js be like

![image.png](https://i.ibb.co/gtXGg9j/2.jpg)

### How to export multiple data from a module

To export multiple things from a module in Node.js, you need to use an object to bundle them together and then import them as an object in another file. Here’s how you can do it with your `multipleExport.js` file:

```jsx
var name ='Mohan'

function sayHello(name){
    console.log(`Hello ${`name`}!`);
}

module.exports= {               // this is the way you export multiple things
  sayHello,
  name,
}
```

and this is the way you import in app.js

```jsx
// destructured : learn Destructuring
const {sayHello, name} = require('./multipleExport..js')   // this is the way you imported

sayHello('Ashutosh')    // Hello Ashutosh
console.log("Exported name is", name);   // Mohan

// what will you get if you print modile
console.log(module.export) // {}  emoty object 
```

### Common Js and ES Modules

What we've learned so far with **require** and **module.exports** is called **CommonJS Modules** or **CJS**. This is the traditional module system used in Node.js. But there's another module system called **ES Modules** (or **ESM**, **`mjs`**), which is the standard for JavaScript modules in modern web development.

To use ES Modules in Node.js, you need to set your project to use modules. Create a `package.json` file and include `"type": "module"` in it. This tells Node.js to use the ES Module system for your project.

```json
// package.json
{
  "type" : "module"
}
```

and now you can generally import and export as your front end projects

```jsx
// in sum js
export function calculateSum(){....}

// in app js
import {calculateSum) from './sum.js'  or './sum'
```

Remember: By default, Node.js uses the CommonJS (CJS) module pattern, which is the older way of handling modules. According to the JavaScript foundation, the future will favor ES Modules (ESM), but currently, most of the industry still uses CJS. CJS is synchronous, meaning it requires all files before running the next line of code, whereas ES6 Modules can be asynchronous, offering better performance. CJS runs in a non-strict mode, while ESM runs in strict mode. ES6/ESM is the default in React and new libraries. Printing `module.exports` in CJS returns an empty object by default.

![image.png](https://i.ibb.co/Ypv7mBL/3.jpg)

Node.js also comes with built-in modules that you can require and import directly into your code. These modules are pre-installed with Node.js and provide various functionalities like file handling, HTTP requests, and more. 

### Definition of Module

A module is essentially a collection of code that remains private unless explicitly exported. This means you can organize your code into different modules, keeping them isolated and secure, only sharing what's necessary by using the `exports` or `module.exports` keywords to make functions or variables accessible to other modules.

- - -

### Keys to learn

1. Object destructuring
2. Modules in JS
3. Strict mode
4. Difference between ES6 modules and CJS
5. In-built Modules

### Question to search

1. Reasons why modules are protected by default ?
2. Whats the difference between require and import and export vs module.exports

### Key findings

* Modules are protected by default after requiring it will run bu can't be access until you export
* These are protected to avoid conflicts from other modules
* Common Js, EJS  / ESModule , ESM,  MJS ES6 Modules are two module patterns to access data within modules
* In CJS code runs in non strict mode, but in ESM pattern code runs in strict mode

![image.png](https://i.ibb.co/DYZvYqP/5.jpg)

And thats all for this episode knowing modules and require

My name is Ashutosh Anand Tiwari, and I am writing digital notes on node js, if you like the notes please share with you friends if anything wrong in the notes feel free to contribute and fork the repo right now. if you want to write next epidote note please [fork the repo and contribute](https://github.com/ashumsd7/heyashu/tree/main/src/data) to it lets write and learn together, and In last I am just requesting to give a star 🌟 to [this repo](https://github.com/ashumsd7/heyashu/tree/main/src/data), for any other query click here to contact [lets connect here.](https://topmate.io/aat/1148709/pay)

Take care, Good Bye :) [](https://topmate.io/aat/1148709/pay)


Learn How node modules and exports works in node js

Module.exports & require

e4: Behind the scenes of Module exports and require in node js

### The principle of leave privilege (PoLP)

As we know, each module in Node.js has its own scope. How does Node.js achieve this? In JavaScript, we follow the Principle of Least Privilege (PoLP), which is related to functions and scope. If you're unfamiliar, you can Google it. The idea is to only expose what is necessary to the global scope, keeping everything else private. To achieve PoLP, wrap your code in a function or immediately invoke it (IIFE). This is how modules in Node.js work. You can learn more about PoLP from [this Stack Overflow post](https://stackoverflow.com/questions/6010211/in-node-js-how-would-i-follow-the-principle-of-least-privilege) or watch [this YouTube video](https://www.youtube.com/watch?v=lW_erSjyMeM&t=10s&pp=ygUYYmxvY2sgc2NvcGUgYW5kIHNob2FkaW5n). Here's a tip: mention PoLP in your next interview to impress the interviewer. Want a mock interview with me? [Click here to schedule one now](https://topmate.io/aat/).

[](https://topmate.io/aat/)

### How modules and require work ?

Now you understand that when you `require` something in Node.js, the entire code is wrapped in a function (essentially an IIFE). This is how PoLP works, making the code private and inaccessible to other modules unless explicitly exported. The `module` keyword in your file is available because Node.js passes it as an object to the IIFE while converting your module code. Below are two examples: one without PoLP and one with PoLP. Remember, PoLP is just about hiding code from the outside environment.

Without PoLP

```jsx
var x=10;
 // do something with x
 console.log('value is : ', x)
//Suppose till this scope you need x 

console.log(x) // 10; but here also you are getting x access thats not good
```

So to hide this we can wrap it in a function

```jsx
function() {  // <--- Add this

 var x=10;
 // do something with x
  console.log('value is : ', x)
 //Suppose till this scope you need x 
 
 
 
 }()          // <----Add this ( thats it IIFE done)
 
 console.log(x)   // ERROR ( now you cant access because its hidden now,  private 
  )
```

Lets see how this works with modules in node js

```jsx
function() {  

 var x=10;
 // do something with x
  console.log('value is : ', x)
 //Suppose till this scope you need x 
 
 modules.export= { x }
 
 }(modules)          // node js passing modules in IIFE while calling it
 
 console.log(x)   // ERROR ( now you cant access because its hidden now private now
  )
```

Behind the scenes, Node.js uses its capabilities, like wrapping code in an IIFE, and then the V8 engine executes the code. When you `require('./sum.js')` in another module, Node.js performs several steps to load and execute the module. There are five key steps involved in this process to ensure the module is properly loaded, compiled, and executed. Let's explore what these five steps are.

### 5 Steps to Load and Execute a Module

1. Require a Module
   Identifies the source of the module, whether it's a local file, built-in module, or JSON file.
2. Load the Module
   Accesses the module's content but does not execute it yet.
3. Wrap in IIFE
   Wraps the module code in an Immediately Invoked Function Expression (IIFE), as previously discussed.
4. Evaluate the Code
   Executes the code, allowing `module.exports` to return the exposed content.
5. Caching
   Caches the module to avoid re-execution, improving performance by reusing the cached result in subsequent requires.

![image.png](https://i.ibb.co/3TtmWXs/2.png)

Let me introduce you with one of superpower of NodeJs, we will discuss it later.

![image.png](https://i.ibb.co/whvQcYC/3.png)

Its time to open [Github repo of  Node JS](https://github1s.com/nodejs/node/blob/main/lib/internal/modules/helpers.js#L135)  and read about it. Here below you can see how NodeJS wraps the module code in IIFE , you can find this [code here in node Js repo](https://github1s.com/nodejs/node/blob/main/lib/internal/modules/cjs/loader.js#L324-L331)

```jsx
let wrap = function(script) { // eslint-disable-line func-style
  return Module.wrapper[0] + script + Module.wrapper[1];
};

const wrapper = [
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});',
];
```

### Search These Keywords

1. **IIFE** (Immediately Invoked Function Expression)
2. **PoLP** (Principle of Least Privilege)
3. **Caching in NodeJS**
4. **LibUV Library**

### Questions

1. How do you make a set of variables private?
2. What are the use cases for IIFEs?
3. Besides IIFEs, are there other methods to achieve the same functionality?
4. Find the code in the Node.js repository where modules are wrapped in IIFE.

### Useful Links

1. [NodeJS GitHub Repository (V8 Code)](https://github.com/nodejs/node/tree/main/deps/v8)
2. [LibUV Code - The Powerhouse of NodeJS](https://github.com/nodejs/node/tree/main/deps/uv)
3. [Require Function in Node.js Repository](https://github1s.com/nodejs/node/blob/main/lib/internal/modules/helpers.js#L128)

### Tips

1. Open any GitHub repository and press the . (full stop) key on your keyboard to open it in a VS Code-like editor directly in your browser.
2. Alternatively, add 1s before the URL in the repository link to open it in a browser-based editor. For example, https://github1s.com/.

- - -

And that's all for this episode!

I'm Ashutosh Anand Tiwari, and I'm writing digital notes on Node.js. If you enjoy these notes, please share them with your friends. If you find any errors or have improvements, feel free to contribute by forking the repo. If you're interested in writing the next episode's notes, [fork the repo and contribute](https://github.com/ashumsd7/heyashu/tree/main/src/data). Let's learn together! Also, please consider giving a star to [this repo](https://github.com/ashumsd7/heyashu/tree/main/src/data). For any queries, [let's connect here](https://topmate.io/aat/1148709/pay).

Take care, Good Bye :) [](https://topmate.io/aat/1148709/pay)

- - -


Let deep dive in to node js repo and get to know how things work

Diving into the NodpeJS Github repo

E5 : How Modules and require work 

If you read Node.js's definition, it mentions an event-driven architecture and its ability to handle asynchronous I/O. These two concepts are crucial to understand, so take your time to read and grasp them thoroughly. We know JavaScript is a synchronous, single-threaded language, meaning the code runs in one direction like a one-way road, with one task executing at a time. JavaScript code executes line by line, which is what makes it synchronous and single-threaded.

![](/public/images/blogs/2.png)



### Synchronous vs Asynchronous Code

Imagine a restaurant where you can get Coke, pizza, and noodles, which take 0 minutes, 10 minutes, and 5 minutes to prepare, respectively. Now, picture a line of 5 people (A, B, C, D, E) waiting to order. In a synchronous way, Person A orders Coke and gets it instantly. Person B orders noodles, taking 5 minutes. Person C, who wants pizza, has to wait 5 minutes before even placing the order, then waits another 10 minutes for the pizza. Meanwhile, Person D, who only wants a Coke, ends up waiting unnecessarily. This is how synchronous code works: one task at a time, causing delays.

### Asynchronous Way of Running Things

In an asynchronous way, tasks that take time (like preparing pizza or noodles) are handled separately, allowing the restaurant to serve quick orders (like Coke) immediately. So, A gets Coke instantly, while B and C (who ordered pizza and noodles) are moved to a different queue to wait. Meanwhile, D, who also wants Coke, gets served right away. This prevents unnecessary waiting. The completion of B and C's orders depends on the preparation time. Asynchronous operations in Node.js prevent blocking, improving efficiency, especially for quick tasks. JS Engines loves synchronous code because it can run that code in milliseconds. we will see some examples soon.

### How synchronous code runs in the JS engine?

The JS engine has components like the Call Stack, Garbage Collector, and Memory Heap. These aren't machines or hardware; they are just C++ code. When you run a code like `var a = 10;`, it executes in the Global Execution Context, which is created in a synchronous, single-threaded manner. When a function is called, a new execution context is created for that function, and the code runs. Let me give you an example to explain it further.



```jsx
var a=102;
var b=209;

function multiply(x,y){
  const  result= x*y
  return result;
}

var c= multiply(a,b)
```

When the JS engine executes code, it goes through several steps, such as parsing and tokenization. The compiler and scope work together during this phase. For example, when the compiler sees variables `a` and `b`, it checks with the scope if they exist. If not, they are declared and assigned values. This process occurs in the Global Execution Context within the Call Stack. When a function is called, a new execution context is created, runs, and then is popped off the stack. For more details, you can learn from blogs or videos by Akshay Saini on YouTube.

![image.png](/public/images/blogs/4.png)

### How Asynchronous Code Runs in the JS Engine

![image.png](/public/images/blogs/5.png)

Let me tell you something: JavaScript isn't just limited to running code. As a scripting language, it has many tasks it's not inherently capable of handling, such as interacting with the outside world, accessing files, or databases. A great example is managing time with `setTimeout`—this isn't actually a feature of JavaScript itself. Really? Yes! The JS engine can't inherently wait; it's not designed for that. The JS engine's responsibility is simply to take JavaScript code and convert it, that's it—no time management or other logic involved.

That's where Node.js comes into play with its superpowers. Node.js can execute timers, read files from the OS, access databases, connect to servers, and make internet requests. When all these operations are ready, only the JavaScript code runs on the V8 engine. These superpowers are managed by and connected to the V8 engine through libuv. Yes, my friend, libuv! Whenever a request for file access, an internet call, or a timer comes in, it goes to libuv, which communicates with the OS and then gets back to the V8 engine. And work is done by Js v8 engine in the callstack.

In simple terms, this is how Node.js operates.

![image.png](/public/images/blogs/6.png)

### What is libuv the Superhero

libuv is a C library that provides Node.js with an event-driven, asynchronous I/O model. It helps manage tasks like file reading, writing, networking, and timers in a non-blocking way, making it possible for Node.js to handle many tasks simultaneously without slowing down. Essentially, Libuv is what enables Node.js to be fast and efficient, handling multiple operations at once without waiting for each to finish. Libuv acts as a middleware b/w JS engine and Operating System. Libuv has thread pool and event loop will discuss in later blogs. just know if anything comes async or engine can’t handle it ask libuv to do it. find the libuv exact link to check the code of it written in c for your reference. actually libuv does so many things.

### Node.js is Asynchronous

If someone asks about Node.js behavior, tell them Node.js is overall asynchronous. However, V8, which is its JavaScript engine, operates synchronously. Node.js gains its asynchronous nature from superpowers like `libuv`, which enables non-blocking I/O operations. This is why Node.js is known for its non-blocking behavior, allowing I/O operations to be performed asynchronously. And don't forget to give a shoutout to the creator of Node.js, Ryan Dahl!

- - -

And that's all for this episode!

I'm Ashutosh Anand Tiwari, and I'm writing digital notes on Node.js. If you enjoy these notes, please share them with your friends. If you find any errors or have improvements, feel free to contribute by [visiting this link.](https://heyashu.in/admin) If you're interested in writing the next episode's notes, [visit this link](https://heyashu.in/admin). Let's learn together! Also, please consider giving a star to [this repo](https://github.com/ashumsd7/heyashu/tree/main/src/data). For any queries, [let's connect here](https://topmate.io/aat/1148709/pay).

- - -

### New words to search

1. IO
2. Async and sync
3. Garbage collector
4. Libuv

### Questions / Queries to research

1. Read the C code of libuv
2. How garbage collector works in JavaScript ?
3. Find the code of Garbage collector in Node Js github repo.

### Useful Tips

1. Node Js is asynchronousd and Js engine in syncronous,

### Useful links

1. https://github.com/nodejs/node/tree/main/deps/uv

- - -


![image.png](/public/images/blogs/7.png)


libuv & async IO in Node.js

e6: libuv & async IO

 

 In the last few sessions, we have seen how Node.js code runs. If something is synchronous, the V8 engine handles it, or in case of asynchronous tasks, libUV steps in. You can think of Node.js having two best friends, like Jai and Veeru. Whenever a problem (or code) comes in, they handle it accordingly.

Now, it’s time to look at a small example to see how these two friends—V8 engine (Jai) and libUV (Veeru)—manage the code.

Create file.txt and write something in it, and then in any JS file for example app.js right whatever I have written below in code block

```jsx
const fs = require("fs");
const https = require("https");

console.log("Kitne aadmi the ??");

const num1 = 2;
const num2 = 3;

https.get("https://dummyjson.com/todos/1", function callback(response) {
  // I am callback function which will run after the dummyJSON has been read from API server
  console.log("hey I am here");
});

setTimeout(function callback(){

  console.log("I will after 5 seconds Sarkaar!");
}, 5000);

fs.readFile('./file.txt', 'utf-8', function callback(err,response){
  console.log("This will get printed after file read ",response);
})

function kitneAadmiThe(a, b) {
  return a * b;
}

console.log('Sarkar kul aadmi the ...?', kitneAadmiThe(num1, num2));
```

Let's understand what's happening here. In this code, both asynchronous and synchronous operations are present, which means both "Jai" (the V8 engine) and "Veeru" (libUV) will come into play. Here's how:

1. The first two lines import the `https` and `fs` modules of Node.js. Got it?
2. Then, there's a console log: "Kitne aadmi the?". This is a synchronous operation, so Jai (the V8 engine) will handle it. It will print immediately.
3. Next, we have `https.get()`. Remember, this is asynchronous code, so Jai can't handle it. Veeru (libUV) steps in, and Node.js will ask libUV to fetch data from the API (`/todos/1`) without blocking the main thread. Once the data is ready, the callback function runs.
4. After that, there's `setTimeout()`. Again, this is asynchronous code, so Veeru (libUV) takes over. It waits for 5 seconds and runs the callback once the time is up, without blocking the main thread.
5. Now, we have `fs.readFile()`. Since reading files is also asynchronous, Veeru (libUV) handles it. The file is read, and once done, the callback runs, printing the file contents.
6. Finally, there's the `kitneAadmiThe()` function, which is synchronous. This is handled by the V8 engine (Jai) and runs immediately when called. The result is printed as "Sarkar kul aadmi the ...? 6".

To sum it up, the main thread runs all synchronous code, like `console.log` and `kitneAadmiThe()`, first. Then, Veeru (libUV) handles the asynchronous tasks like `https.get()`, `setTimeout()`, and `fs.readFile()` without blocking the execution. The callbacks of these async tasks will be processed once the main thread is clear.

Outout of above code

```jsx
// Kitne aadmi the ??
// Sarkar kul aadmi the ...? 6
// This will get printed after file read  Production code, in clients ke saamne mat fatna 
// hey I am here
// I will after 5 seconds Sarkaar
```

### readFileSync


We saw that `readFile` is asynchronous, meaning it doesn't block the main thread. But what if you want the next line of code to run only after the file is read? In that case, you'll need to wait for the file to be read. To do this, instead of using `readFile` (which doesn't wait), you can use `readFileSync`, which is synchronous and blocks the main thread. It will pause and wait until the file is read before moving to the next line of code.

This way, the output will change, and you’ll notice the file is read first before the code continues. The order of execution will be different.

```jsx
// change above code by these lines
fs.readFileSync('./file.txt', 'utf-8')
console.log("This will get printed after file read");

// output

//Kitne aadmi the ??
//This will get printed after file read
//Sarkar kul aadmi the ...? 6
//hey I am here
//I will after 5 seconds Sarkaar!
```

**Note:** Whenever you see "sync," it means the code will block and wait until the task is finished before moving on to the next line. and its not recommended to use

Now I hope you have understood how sync and async works in NodeJs

![image.png](/public/images/blogs/e82.png)

### setTimeout in Node.js

Remember this: I often ask this question in interviews about the order of `setTimeout`, even if it has 0 milliseconds. Just keep in mind, no matter if it's set to 0 milliseconds or 10 seconds, it won’t run immediately. `setTimeout` will be handled by libUV and will only execute after the main thread has finished everything. It doesn’t block the main thread. I am putting one JS question here, because I think you know  JS which runs on web thats why you are here,  read below snippets and guess the output send me Yes  [here](https://x.com/JavaScripterrr)  if you have guessed it correct . 

![image.png](/public/images/blogs/e83.png)

And thats all for this session, I'm **Ashutosh Anand Tiwari,** and I'm writing digital notes on Node.js. If you enjoy these notes, please share them with your friends. If you find any errors or have improvements, feel free to contribute by clicking edit icon on top bar of this page[.](https://heyashu.in/admin) If you're interested in writing the next episode's notes, [visit this link](https://heyashu.in/admin). Let's learn together! Also, please consider giving a star to [this repo](https://github.com/ashumsd7/heyashu/tree/main/src/data). For any queries, [let's connect here](https://topmate.io/aat/1148709/pay). Thank you…

### New words to search

- - -

1. utf-8
2. node: crypto

### UseFull Tips

1. Go to node js website check list of node js modules


sync, async, setTimeoutZero in Node.js

 E7 sync, async, setTimeoutZero - code

As we know, Node.js has two main parts, like the duo Jai and Veeru: the V8 engine and **libuv**. Let’s take a closer look at **libuv**. Just like the V8 engine has its hidden parts, you can learn more about it by [clicking here.](https://heyashu.in/digital-garden/notes/namaste-node-js/e-8-deep-dive-into-v8-js-engine) Now, let’s focus on **libuv**. Whenever V8 (Jai) can’t handle something—like file access, network calls, or timers—it gives the task to **libuv**. Also, when these tasks run, we often use callback functions, which are executed after **libuv** finishes the job.

```jsx
const fs = require('fs');

// Asynchronous file read operation using callback
fs.readFile('text.txt', 'utf8', (err, data) => {
    if (err) {
        console.error('Error reading file:', err);
        return;
    }
    console.log('File content:', data);
});

console.log('This will run before file reading because readFile is async');
```

Now, look at the example above where we have code that reads the content of `text.txt`. I want to emphasize that the V8 engine can't handle this because it doesn’t understand OS or file systems. The V8 engine is only responsible for running JavaScript code—nothing else. I hope that’s clear now.

So, just remember: things like file access, network calls, and timers are external tasks for V8. V8 is strictly for running JavaScript. That’s it.

In the example above, you’re reading a file, and if you look closely, there’s a callback function with `err` and `data` as arguments. This callback will only run once **libuv** completes reading the file. Then, **libuv** hands the callback function back to the V8 engine, and V8 runs it through the call stack like it would for any other function.

If you don’t know what a callback is, it’s like saying, "Call me back once the task is done." For example, "Call me back when the food is ready"—just kidding, don't get distracted!

But how does **libuv** ask the V8 engine to run this callback? That’s what we’re going to see. Because once the file is read, it’s not sent directly to V8—there’s a mechanism in place. This is where **libuv**’s other components, friends of Veeru (libuv), come into play, which Jai (V8) doesn’t know about.

![image.png](/public/images/blogs/ake9im1.png)

### Callback Quue

In **libuv**, there’s something called the callback queue (Veeru's responsibility), where all the callback functions wait in line. It’s like when the food is ready, but the food court is full, so you can’t enter directly because others are already eating. You have to wait in line—that’s the callback queue. Got it?

![image.png](/public/images/blogs/ake9im2.png)

Now, what if someone skips the line and starts eating? That would create chaos, right? So, there has to be someone to manage the queue, maintain order, decide who’s first, who’s last, and ensure everything runs smoothly.

Guess who does that? Yes, it’s **Shree Shree Event Loop ji**, one of the important friends of **libuv**, who keeps everything in line and makes sure the callbacks are executed in the right order.

### Event loop

The Event Loop’s job is to keep an eye on both the **call stack** and the **callback queue**. It ensures that no callback function can break the queue. Let’s leave the food court example for now, but imagine multiple callbacks waiting at the same time. What happens if two `setTimeout` functions finish at the same time?

![image.png](/public/images/blogs/ake9img3.png)

There’s a proper mechanism and algorithm in place to handle this situation. But remember, only when the "food court" (the V8 engine’s main thread) is empty, will the next callback from the queue get a chance to run. That means the V8 engine’s call stack needs to be empty before any callback from the queue is processed. This is exactly what the Event Loop does.

Now, let’s dive deeper into how the **Event Loop** operates!

### Outside Cycle of Event loop

The Event Loop operates in different **phases** during its cycle, each phase having a specific priority for handling tasks. Here's a simplified breakdown of the phases:

1. **Timer Phase**: This phase handles all the timers like `setTimeout` and `setInterval`. When their time expires, the corresponding callbacks are queued for execution in this phase.
2. **Poll Phase**: This is where most I/O-related callbacks (like internet requests, file system access, or crypto operations) are handled. It checks for completed I/O operations and pushes their callbacks for execution.
3. **Check Phase**: This phase deals with **setImmediate** callbacks. We'll go deeper into this later, but it’s used for immediate execution of functions once the poll phase is complete.
4. **Close Phase**: This phase manages tasks related to closing things down, like cleanup tasks or socket closures. We'll discuss more details on this later.

Each of these phases has its own role in making sure the Event Loop operates smoothly and efficiently!

### Inside Cycles of Event Loop

There are a few things we’ll cover later, but just know this: before each phase of the event loop’s outer cycle, two special tasks always run. Think of it like this—every time one person enters the "food court" (the call stack) from the queue, there's a special guest area that needs to be checked first.

These "special guests" are **process.nextTick()** and **promise callbacks**. Before moving on to the next phase of the event loop, the system checks if any of these special callbacks are waiting.

So, before checking `setTimeout` in the Timer phase, it first looks if there are any `nextTick` or promise callbacks. Before entering the Poll phase, it checks again if any of these special tasks are waiting. These tasks always happen **before** the regular phases of the event loop. Got it?

1. process.nextTick()
2. promise callabck

![image.png](/public/images/blogs/ake9im4.png)

### Callback in NodeJs

Below, I am pasting a code snippet that will show you how callbacks look in Node.js. Most of the time, they go and wait in the callback queue, get checked by the Event Loop, and are executed by the V8 engine. All callbacks wait there in the callback queue. Now, with this example, you can simply check the inner loop first, then the Timer phase, then again the inner loop (`nextTick` and promise callbacks), then the Poll phase, and then again the inner loop, followed by the Check phase, the inner loop again, then the Close phase, and then back to the inner loop. This process continues, creating an infinite loop of checks.

And here, also remember that for **nextTick** and Promises, two queues are maintained. Just think of it like two types of guests waiting in different rooms, and it's different from the callback queue, and remembers readig file might take time so order can be changed of output.

```jsx
// 1. File System Operations
fs.readFile('file.txt', 'utf8', cb);      // Reading a file asynchronously
fs.writeFile('file.txt', 'data', cb);     // Writing to a file asynchronously
fs.unlink('file.txt', cb);                // Deleting a file asynchronously

// 2. DNS Operations  ( will check later)
dns.lookup('example.com', cb);            // Resolving domain names
dns.resolve('example.com', cb);           // Resolving DNS records

// 3. Network Operations 
const server = http.createServer(cb);     // Creating a server (async)
server.listen(3000, cb);                  // Listening to a port asynchronously

// 4. Timers
setTimeout(cb, 1000);                     // Timer with a delay of 1000ms
setInterval(cb, 1000);                    // Repeated timer every 1000ms

// 5. Child Process Operations ( will check later)
const { exec } = require('child_process');
exec('ls', cb);                           // Executing a shell command asynchronously

// 6. I/O Operations
process.nextTick(cb);    
```

### Time to test what you have read till now

Below, I am pasting a snippet. Just execute it in the order you learned and write the output somewhere. Below the snippet, you'll get the answer after clicking on the link. Compare it with your expectations, and if it's wrong, ask ChatGPT what's incorrect and how it gets executed, or re-read this blog

```jsx
const fs = require('fs');
function normalFunction() {
    console.log('Normal function call executed.');
}
setImmediate(() => {
    console.log('setImmediate callback executed.');
});
fs.readFile('text.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log('fs.readFile callback executed.');
});
setTimeout(() => {
    console.log('setTimeout callback executed.');
}, 0);
console.log('Normal console.log executed.');
normalFunction();
```

[Click here to check the order](https://i.ibb.co/1M59GzL/outtt.png)

### Wait Wait ! yes party is not over yet

If there is nothing in the V8 engine’s call stack, and everything has run, including the `nextTick` queue, callback queues, and all phases except the Poll phase, and if a file is still being read with an I/O callback pending execution, then the Event Loop will not keep running. It will stop and wait at the Poll phase instead of continuously running. This is an important concept to understand in Node.js, which is different from the Event Loop in web browsers

### Improtant to know

Now, as we mentioned, the Event Loop will stop at the Poll phase, checking the file and waiting to push the file read callback into the V8 engine. An important thing to note is that after the file read is complete, it will resume from the **Check Phase** (not the Timer Phase). So remember, it doesn’t restart from the beginning (Timer Phase), but continues from where it left off. Let me show you a screen to better understand this. 

![image.png](/public/images/blogs/ake9m5.png)

After waiting at the Poll phase, the callback for the file read will begin registering. This means if there is any `setImmediate` and `setTimeout` in the callback queue, the `setImmediate` will run first because the next phase is the **Check Phase**, not the Timer Phase."

This makes it clear that the Event Loop continues from the Check Phase, giving priority to `setImmediate` before timers if event loop is waiting at loop phase.

### Trick of nextTick

Remember, if there’s any `process.nextTick()` inside a callback, and that callback has another `nextTick`, the Event Loop will keep checking and executing all the `nextTick` tasks before moving to the next phase. It will only proceed when the `nextTick` queue is completely empty, and this is a very important thing to note.

```jsx
process.nextTick(function () {
  process.nextTick(function () {
    process.nextTick(function () {
      console.log("Im inner inner process.nextTick");
    });

    console.log("Im inner process.nextTick");
  });

  console.log("nextTick callback executed.");
});

//output
//nextTick callback executed.
//Im inner process.nextTick
//Im inner inner process.nextTick
```

And thats all..

### Search These Keywords

1. nextTick
2. setImmediate
3. inner loop vs outer loop
4. algo used in the event loop

### Questions

1. Get multiple questions having statement of inner and out loops and try to solve

### Tips

1. Practice output based questions


libuv & Event Loop

e9 behind the scene libuv & Event Loop



### 🌟 Course Recommendation

If you're serious about mastering Node.js, I highly recommend starting with the [Namaste Node JS Course](https://namastedev.com/learn/namaste-node). It's packed with valuable insights that will take your skills to the next level!

### 🎬 Watch the Trailer

Curious about what’s in store? [Click here to watch the trailer](https://www.youtube.com/watch?v=ufHnsVixMEs) and get a sneak peek into the course content.

### 📝 Detailed Curriculum

Before enrolling, make sure to [check out the detailed curriculum](https://www.youtube.com/watch?v=uuabMDyj4Gk&t=32s) to see exactly what you’ll learn throughout the course.

### 📢 Follow Akshay Saini

Stay updated with the latest from Akshay Saini. Follow him on social media and subscribe to his YouTube channel for more valuable content:

* [YouTube](https://www.youtube.com/@akshaymarch7)
* [LinkedIn](https://www.linkedin.com/in/akshaymarch7)
* [Instagram](https://www.instagram.com/akshaymarch7)
* [Twitter](https://www.twitter.com/akshaymarch7)
* [Facebook](https://www.facebook.com/akshaymarch7)

### 📚 Explore More Namaste Courses

Interested in more courses? [Visit the NamasteDev website](https://namastedev.com/) for a complete list of offerings.


Get all digital notes here about namaste node js

Namaste Node JS S1

Namaste Node JS S2

Introduction to NodeJs

What is Node JS

History of NodeJS

2009: Node JS born

2010 : NPM born

2011: windows came

2012: NPM NodeJS friendship

2014: Fedor Indutny forked and made IO.js

2015 ( Sep) : Node.js Foundation Came

2019 : git merge two-foundations

Feedback