In C++, octal numbers play a crucial role in numerical representations. One intriguing aspect of octal numbers is the significance of leading zeros in their representation. While it might seem puzzling at first, the way C++ interprets these numbers carries underlying reasons that differentiate octal representations like 0467 from alternatives like 647. Let’s delve into the world of octal numbers in C++ and unravel why 0467 is considered as 423 while omitting the leading zero results in a different value.



Octal Number System Overview: The octal number system is a base-8 numeral system, utilizing digits from 0 to 7. Unlike the more commonly used decimal system (base-10), where digits range from 0 to 9, octal numbers’ uniqueness lies in their representation of values using a smaller set of digits.



Understanding Octal Representation in C++: In C++, when an integer literal starts with a leading zero (0), the compiler interprets it as an octal number. Thus, an integer literal such as 0467 is considered an octal representation. However, omitting the leading zero alters the interpretation of the number.



Consider the example:



0467 in C++ octal representation is read as 423.

647 is not considered an octal representation but a decimal number.

647 will be read as 647 but due to leading 0 , 0647 will be considered as an octal number.

The Role of Leading Zeros: The leading zero signifies to the C++ compiler that the number following it should be treated as an octal value. As a result, the value 0467 is interpreted in the octal system, where the digit ‘4’ in the hundreds place, ‘2’ in the tens place, and ‘3’ in the ones place yield the octal value 423.



However, when the leading zero is omitted, as in 647, the compiler doesn’t recognize it as an octal number but rather as a decimal one, resulting in a different interpretation and value altogether.



Potential Pitfalls and Clarifications: Novice programmers might inadvertently overlook the significance of leading zeros when dealing with octal numbers in C++. Omitting the leading zero can lead to erroneous interpretations, especially when expecting an octal representation.



It’s crucial to remember that the presence or absence of a leading zero fundamentally alters how the C++ compiler interprets numeric literals. Awareness of this distinction is vital to avoid unintended discrepancies in the representation of values.



Conclusion:



In C++, the inclusion or exclusion of leading zeros in numeric literals holds paramount importance, especially when dealing with octal numbers. Understanding why 0467 is considered as 423 while 647 represents a different value underscores the significance of these leading zeros in defining the numeral system’s interpretation by the compiler. Mastery of these intricacies enhances precision and accuracy in programming with octal numbers in C++.



Inspiration : Love Babbar


0647 read as 423 in C++


# KANKHAR: A Full Stack Friendwork (of Friendship)



In the silicon jungle of Bengaluru, where code monkeys swing from tree to tree, a legend was born. Not just any legend, mind you, but a full-stack legend - KANKHAR! 🐒💻

It all began in the aftermath of the great plague (aka COVID), when a brave soul ventured into the urban wilderness of Bengaluru. His name? **Ashutosh Anand Tiwari.**

![Ashutosh](/images/ashu.png "Ashutosh Anand Tiwari")

In November 2021, Ashutosh planted his flag at CodeMonk, becoming the first to join this fledgling banana republic of developers. Little did he know, he was about to become the nucleus of something far greater than himself.

As the calendar flipped to April 2022, Ashutosh found himself face-to-face with two "interns." But calling Nihal and Karan mere interns would be like calling a smartphone a fancy calculator.

![Nihal](/images/nihal.png "Nihal")

![Karan](/images/karan.png "Kishan ")

These code-slingin' savants turned CodeMonk upside down faster than you can say "runtime error." The trio formed a bond stronger than any merge conflict, fueled by endless plates of lemon rice and idly. But as any good developer knows, variety is the spice of life (and the bane of legacy code).

Enter the Litti Chokha Crusader, Ram Shankar!

![Ram](/images/ram.png "Ram")

With his arrival, the team's flavor profile expanded faster than an unoptimized for-loop. But something was still missing in this masala mix of talent.

Lo and behold, from the land of dhokla and garba, came the backend behemoth - Harshil!

![Harshil](/images/harshil.png "Harshil")

Now they had it all - North, South, and Gujarat. A pan-Indian papad of programming prowess! But wait, what's that sound? It's the honking of a Delhi metro, bringing with it the final piece of the puzzle.

Make way for Kavish, the dropout who could out-code a senior dev with one hand tied behind his back!

![Kavish](/images/kavish.png "Kavish")

The team was buzzing with energy, like a server farm on Red Bull. They thought they were complete, a full stack of talent reaching from frontend to backend. But oh, how wrong they were!

For in the heart of India, Madhya Pradesh, a crucial element was waiting to join the mix. Enter Atul, the nucleus that would bind this atom of awesomeness together!

![Atul](/images/atul.png "Atul")

And thus, KANKHAR was born - a full stack framework of friendship, talent, and enough inside jokes to fill a terabyte hard drive.

Through thick and thin, from marathon coding sessions to food comas induced by excessive litti chokha consumption, KANKHAR stood strong. Some moved to work from home, others chased bigger paychecks (we're looking at you, litti chokha deserters!), but the bond remained unbroken.

Now, as December approaches and wedding bells ring for Harshil in Gujarat, the KANKHAR framework prepares for a joyous reunion. It's proof that no matter the distance, no matter the job changes, no matter how many times you have to explain to your relatives what a "full stack developer" actually does, KANKHAR endures.

![](/images/all.png)

So here's to KANKHAR - may your code be bug-free, your deployments smooth, and your friendships eternal. Now, if you'll excuse me, I have a train to catch at 4... and it's already 3:45! Time flies when you're compiling heartwarming stories about coding companions.

Catch you on the flip side, from the land of garba and git pushes! 🚂💨


KANKHAR a full stack friendwork

### **About myself**

Hello my name is Prince Tiwari, I am going to write about my recent experience in NDA exam, actually this was my 2nd attempt, so I am going to writes all mistakes I have done , all positive that happened to me while preparing for this exam...

> Writing soon.....
>
> Sorry, but I will write soon


My NDA experience.

My experience of NDA exam..

This is the content for the test Blog on heyayush.in !


That's crazy

Testing

### How do we communicate?



As we know, when developing something, we write code. When we want a computer to perform a task, we give it instructions. For example, if you want to use the calculator on your computer, you open the app and type something like \`2 + 2\`, and the system will give you the output \`4\`. This means you have given an instruction to the computer, and it has provided you with the output.

Now, lets discuss more about the instructions you provide to computers or any software. Generally, we communicate with someone in a language they understand.

For instance, if you meet a Chinese person and start speaking in Tamil, will they understand? The answer is NO.

![image.png](https://i.ibb.co/WGg3T42/ex2.jpg)

Similarly, when you write \`2 + 2\` in your system, does the system understand it directly? The answer is also NO.

So, how is it possible for a Chinese person to understand Tamil or for your system to understand \`2 + 2\`?

The first thing that comes to mind is that you need some kind of mediator or translator who translates Tamil into Chinese and \`2 + 2\` into a language that the computer can understand.

Here comes the role of Compilers/Translators, which translate one type of input into another type of instruction so that the target person/system can understand.

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

But there's one more thing we have to notice. Guess what?

The input you are giving, whether it's Tamil or \`2 + 2\`, should follow some rules. Otherwise, your translator will be confused, right?

That's why the language you're writing or speaking should also have some rules. Isn't it?

So, you have already got the definition of syntax.

### Syntax

The rules of valid format and combination of instructions in a computer language are called syntax.

### Statement

In the English language, as you know, a statement is a group of meaningful words. Similarly, in computer language, a statement is a group of words, numbers, and operators (like \`+\`, \`-\`, \`/\`, \`*\`) that perform a specific task.

```
a = b * 5;    // is a statement

// where = and * are operators
// a and b are variables
// 5 is a literal value or fixed value

```

### Expression

If you want to remember this forever, here's a trick for you: "E" comes before "S" in the alphabet. So, statements are made from one or more expressions.

An expression is just a variable, a value, or a combination of both.

```
2 is : literal value expression
b is  : variable expression
b * 2 : arithmetic expression
a = b * 2 : assignment expression

```

We will discuss more on Function Expression and Declaration in the next blog.


Be healthy and keep smiling. Bye-bye 👋!




Syntax, Expression, and Statement in JavaScript

What are syntax and expressions in javascript

I will be writing my journey from Delhi to Bangalore, thank you.


My journy from Delhi to Bangalore

Delhi to Bangalore

![Data Types](https://i.ibb.co/DQf1k4k/data-types.jpg)

There are total **8 built** in data types in JavaScript.

1. string
2. number
3. boolean
4. null
5. undefined
6. object
7. symbol ( ES6 feature)
8. bigInt 

### typeof Operator

JavaScripts Provides typeof operator to check the value and its type

```jsx
var a;

typeof a; // undefined ( because there is no value in it)

a ='JS Snippets'
typeof a; // string

a=23;
typeof a; // number

a= undefined;
typeof a; // undefiend

a= true;
typeof a; // boolean

a= null;
typeof a; // object ( this is bug in JS, Google it to learn more about it)

a= {name:'Ashutosh'}
typeof a; // object
```


Data Types in JavaScript

**Course mein aapka bahut swagat hai!**  Node.js ko hum bahut detail mein samjhenge, aur Express aur MongoDB ko bhi achhe se cover karenge. Course lamba aur deep hone wala hai, aur hum Node.js ke core concepts ko 2024 ke end tak complete karenge. Main course ko regularly update karta rahunga, aapko bas dheere dheere padhna hai. Kabhi kabhi ek-do din ka gap ho sakta hai.

### Request from Anurag Bhaiya (Procdrr):

* Notes Jaroor banaye, chahe digital ya copy,
* WebSockets aur WebHooks bhi isme cover honge.
* Community mein active rahiye aur Discord par bhi active rahiye.
* Documents aur queries ke liye, logo se puchiye aur unke jawab dijiye.
* [App.procoderr.com](App.procoderr.com) par jaake bhi aap help maang sakte ho ya Discord mein ye kar sakte ho.
* Aao ab prerequisites ke bare me jante hain in Markdown

### Request from Notes Creator

 Dekho maine kitni pyari notes banayi hain aapke liye, aap bhi aage ki notes likh sakte ho kyunki ye notes github se hai aur open sourced hai, [ ye rahi link](https://github.com/ashumsd7/heyashu/) ab jaake github par star kro iss repo ko aur padhna jaari rakho , Dhanywaad


Welcome to Node.Js Course

e1: welcome

**Terminal:** Yeh ek tarike ka app hai jiske through aap apne system ko operate karte ho. Jaise kai tarah ke browsers hote hain, waise hi kai tarah ke terminals bhi hote hain.

Achha, ab kaise open karein? Iske liye aap apne keyboard par **Start** key ko press karein aur search bar mein **Terminal** ya **PowerShell** type karein. Aur bas, open ho jayega!

Ye terminal me kai tarah ke **shell** hote hain, jaise **Command Prompt** aur **Windows PowerShell** — yeh Windows mein milte hain. Agar aap **Linux** use karoge, to wahan aapko **Bash** shell dikhega. MacOS mein aapko **Terminal** app mein **zsh~** shell milega.

Hum aage **Bash shell** hi use karenge.

### Install bash shell

Chalo, ab VS Code mein chalte hain aur ek file banate hain **terminal.js**. Terminal ko open karne ke liye **Ctrl + J** press karo, jahan hum apna code run karte hain, wahi terminal hota hai. Ab waha right side aapko option milega select karne ka, ki aap kya use karna chahte ho — **Git Bash** select karo ya agar download nahi kiya, to [iss link pe click karke](https://git-scm.com/downloads) Git download kar lo.

VS Code ko reopen karoge, to **Git Bash** bhi dikhne lagega.

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

Git install hua ki nahi ye janne ke liye aap check kr skte ho aise, terminal me

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ git -v
git version 2.45.0.windows.1
```

Chrome mein aur har ek OS mein ek terminal by default aata hai, lekin **Git Bash** shell ek best options mein se ek hai, aur yahi hum use karne wale hain.


 Introduction to Terminal and Shell

E:10 Introduction to Terminal and Shell

Now let see few commands of the shell,

```jsx
echo heyashu
```

### echo

echo is same as console.log() just printing what you typed

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo heyashu
heyashu

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo $num

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ num=8

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo $num
8
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo $((num+2))
10
```

So, aapne dekha ki Bash ke andar hum bahut kuch kar pa rahe hain. Actually, Bash bhi ek tarike ki scripting language hai, isme bhi loops hote hain aur bahut kuch. Bash file ka extension hota hai **.sh**, aur koi bhi file aap **.sh** se bana ke run kar sakte ho, aur saara code waha likh sakte ho.

```jsx
//test.sh

num1=2
num2=3

echo $((num1+node2))
echo "KAHTAM'

// ab terminal pe jaake likh do ./test.sh aur aapki file run ho jayegi
```

### pwd : print working Directory/ Folder

Iska full form hai **print working directory**, ye aapko current folder ka naam print kar deta hai.

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ pwd
/c/Users/Ashutosh Tiwari/Desktop/ME/node-js-by-procodrr
```

### whoami

ye user ka naam print kr deti hai

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ whoami
Ashutosh Tiwari
```

### cd

Iska naam hai **change directory**. Ek directory se pichhle ya agle mein jaane ke liye. Dekho, aap ek level upar bhi ja sakte ho aur next directory mein type karke ja sakte ho, ya fir aap pichhe ja sakte ho. To kuch commands likh deta hu, aap apne terminal mein try kariye. Haan, aur Bash hi use kariye, PowerShell nahi.

```jsx
cd ../
cd <press tab>
cd ..
cd <type file name>
```

Achha, ek cheez, agar aap **cd ../** karte jaoge to aap root directory par pahunch jaoge, aur last mein **~** sign dikhega aapko. Aur agar kahin se bhi aapko home directory mein aana hai, to aapko terminal mein sirf **cd** likhna hoga.

```jsx
~/
```

achh aapko kaise pta chalega kitne next folder hai directories hai mere curr directory ke andar

### ls : List

ye hai list command aapke type krte hi jitne folder ya diretcories hai wo list ho jayengi

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me
$ ls
ashu-port-2024/  delete/  namaste-node-js-by-ashutosh/  node-js-by-procodrr/  test/

//yad rakhein
./  represents current directory and
../ parent directory
```

### ls -la ( will discuss later)

```jsx
// i will drop a link in the heading , keep visiting 
$ ls -la
total 5
drwxr-xr-x 1 Ashutosh Tiwari 197121  0 Sep 18 13:10 ./
drwxr-xr-x 1 Ashutosh Tiwari 197121  0 Sep 18 10:42 ../
-rw-r--r-- 1 Ashutosh Tiwari 197121  0 Sep 18 10:43 terminal.js
-rw-r--r-- 1 Ashutosh Tiwari 197121 46 Sep 18 13:11 test.sh
```

### Creating , Copying Moving and Deleting using commands

Ab hum dekhne ja rhe hain files ko copy move rename aur delete kaise kr sakte hian ?

### touch : Create File

**touch** ka use karke aap ek nayi file create kar sakte ho. Agar folder yaani directory create karni ho, to **mkdir** command ka use karna padega.

```jsx
//go to you command and write 
touch index.html
// ye index.html ban jayegi same root pe, aap sape deke kayi file likh sakte  ho
```

### mkdir : Make Directory / Folder

Iska full form hai **make directory**, aur jab aap iske baad kuch likhte ho, to wo folder ke roop mein create ho jata hai. Niche jo command likhi hai, usse same root mein **src** folder ban jayega.

```jsx
$ mkdir src 
```

### cp : Copy Files

**cp** file copy karne ke liye use kiya jata hai, aur aapko do paths dene hote hain. Ye dhyan rakhna, agar aap path likh rahe ho to quotes me likhna.

```jsx
// cp <kya krna hai uska path> <jaha carna hai uska path>

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ cp index.html src
// isse index.html src me copy ho jayegi/

// example with full path
$ cp index.html "C:\Users\Ashutosh Tiwari\Desktop\mera-project\src"
```

### mv : Move files

ye bhi same hai bs 

```jsx
// mv <kya krna hai uska path> <jaha carna hai uska path>
```

### Rename the files

Yeha abhi same command use hoti hai bs aapko file ka naam likhna hai jaise

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ mv test.sh  abc.sh
// test.sh abc.sh se rename ho jayegi.. aap yaha par path bhi de skte ho kaha move krne hai aur kya rename 
//krna hai bs baat ke aage file na rename wala naame likh do
```

Dhyan rakhiyega, yaha **Ctrl + Z** kaam nahi karta hai. Har cheez permanently remove, delete, aur rename hoti hai.

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

### rm: Remove a file

```jsx
rm fileName

// for multiple files
rm fileName1 fileName2
```

### rmdir : Remove a Directory / folder

**rmdir folderName** se sirf empty directory ya folder hi delete hoga. Agar uske andar kuch hai to wo delete nahi hoga.

```jsx
rmdir emptyFolderName // deletes empty folder 

rmdir -r anyFolderName // r denotes recursive flag ( mtlb jabardasti )

// ek aur flag hota hai -f ( force ) joki bad me dekhenge
```

### Create Multiple files

Agar humein bahut saari files ek sath banani ho, to hum Bash mein loop bhi chala sakte hain.

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr/src
$ for i in {1..50}; do touch app$i.js; done
```

Aur aap delete bhi kar sakte ho, bas previous command me **touch** ki jagah **rm** likh do.

### cat : Files read

Agar bahut badi file ho, to ye concatenate karke print kar deta hai.

```jsx
cat test.sh
// niche saara content print ho jayega
```

### nano : a Editor

Ye ek tareeke ka editor hai. Iske aage koi file likhoge, to wo ek editor me khul jayegi aur aap kuch bhi edit kar sakte ho. Ye kya hota hai aur kyu hota hai, aap internet pe search kar lijiyega.

```jsx
nano abc.sh
// niche screen me jo aapko ^ dikh rha hai, use command kahte hain.+
```

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

### vim : ye bhi ek editor hai

Vim ek aur editor hai jo **nano** se zyada powerful hai. Exit karne ke liye kuch tarike hote hain. Actually, Vim mein do modes hote hain — **insert** mode aur **command** mode. Jab aap bahar aana chahte ho ya jo bhi likha hai usko save karna chahte ho, to sabse pehle **ESC** press karo, fir likhne ke liye `:w` likho. Iska matlab hai jo aapne edit kiya hai, usse save karo. Fir `:q` likho aur enter press karo, to quit ho jaoge. Agar aap **I** press karoge to insert mode mein aa jaoge. Aap `:wq` bhi likh sakte ho, jo save aur quit dono ek saath karta hai. Vim bahut powerful hai, lekin isme bahut saari aur powerful cheezein bhi hain.

```jsx
vim app.js
```

To aapne dekha, agar server pe koi cheez aapko edit karni hai jaha sirf **CLI** hai, koi **UI** nahi, to aapko **vim** ya **nano** editor use karna hoga. **vi editor** ke baare mein bhi jaake padhiye, bahut khoobsurat cheez hai. Maza aayega! Jaake padhiyega **vi editor**, **vim editor**, aur unki history.


Basic shell commands

E11 Basic shell commands

Ab humne **GUI**, **CLI**, aur commands ke baare mein kaafi achhe se jaan liya hai. Ab baari hai ye jaanne ki **prompt** kya hota hai.

## **What is a command prompt?**

A command prompt is the input field in a text-based [user interface](https://www.techtarget.com/searchapparchitecture/definition/user-interface-UI) screen for an operating system (OS) or program. The prompt is designed to elicit an action. The command prompt consists of a brief text string followed by a blinking [cursor](https://www.techtarget.com/whatis/definition/cursor), which is where the user types command prompt commands.  [This is copied from](https://www.techtarget.com/whatis/definition/command-prompt). 
Jab hum koi bhi terminal open karte hain, jaise **Start** button par click karke **PowerShell** open karte hain, to aapko waha ek **PS** likha hua milega, jaise ye:

```jsx
PS C:\Users\heyashu>
```

Aapko pata hai ye **PS** kya hota hai? PS ka full form hota hai **Prompt String**. PS ko nahi, but `C:\Users\heyashu>` isse **Prompt** kehte hain. PS ka matlab **Prompt String** hai.

Ab aao, jaante hain prompt ko kaise customize karein?

Dekho, Bash mein **PS1** aur **PS2** naam se variables hote hain. To chalo, print karke dekhte hain. Kaise print karenge? Using `$`.

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ echo $PS1
\[\]\[\033]0;$TITLEPREFIX:$PWD\007\]\n\[\033[32m\]\u@\h \[\033[35m\]$MSYSTEM \[\033[33m\]\w\[\033[36m\]`__git_ps1`\[\033[0m\]\n$ \[\]
```

to ps1 ke andar wo stored ahi badi si string, ab isko hum rename ekr sate hain kaise??

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ PS1=ashu
ashu
ashu
ashu

// ab upar wali string badal ke ashu ho gyi. lekin ye permanant nahi fix hua 
// bad me permanant krenge modify isko
```

### Configure Terminal

To agar hume **PS1** aur **PS2** ko permanently change karna hai, to aaye dekhte hain kaise possible hoga.

Ek file hoti hai **home directory** ke andar. Achha, aapko kaise pata chalega home directory kya hai? To aap terminal mein jaayein aur likhiye:

```jsx
~ explorer .
// enter kriye aur aapka home directory fataak se file explorere me khul jayegi
// note: agar aap linux pe hai to ./ use karye after explorer
```

to ab folder open hua ab agar `.bashrc` file na ho waha to aapko banani padegi aise, ya fir normally

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~
$ touch .bashrc
```

ab file create ho jayegi..

ab us `.bashrc` ko vs code ya kisi editor me open kr lijiye, ab iss bash rc me jo bhi likh denge aap wo har naye terminal pe run hoga , ab aap likh dijiye .bashrc me

```jsx
//.bashrc
echo "heyyyy"
PS1='hello=> '
```

ab har bar naye terminal me mere hello print hoga

```jsx
// in terminal
heyyyy
hello=> 
```

### Alias

Iska use tab hota hai jab aapko koi bahut badi command baar-baar likhni padti ho, to aap usko ek naam de sakte ho. Jaise, `git add .` aur aap nahi chahte baar-baar ye command likho, to iska ek upnaam (alias) de do, jaise mera naam Ashutosh hai aur aap mujhe **Ashu** bula sakte ho waise. Ab aapko **.bashrc** file mein likhna hoga.

To chalo, sabse pehle **.bashrc** ko **source** karte hain aur run karte hain.

```jsx
// in terminal
source ~./.bashrc
```

ab jaise maine bashrc me likh diya hai 

```
// .bashrc
alias hey='echo 1233445'
```

ab jaise aapne source ~/.bashrc kiya to wo file run kr jayegi aur saara content print ho jayega, ab jaise aap hey likhge 1233445 print ho jayega

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ hey
1233445
```

aise aap git ki commnds ko bhi customize kr sakte ho, aurr bahut kuchh, ab dekho aise aap bahut customize kr sakte ho,. kuchh error aaye mujhe contact kro ya fi google kariye, Dhanywaad


Promt in Terminal

E16: Promt in terminal

Jaise hum JavaScript ko web pe run karte hain aur browser ki capabilities jaante hain, jaise document aur aur bhi cheezen, waise hi **Node.js** bhi JavaScript hai, lekin jab run hoti hai, to usko **OS** yani hardware ka access hota hai. Matlab, Node.js ko operating system ke resources tak pohoch hoti hai.

Yeh samajhna zaroori hai ki kaise yeh sab kaam karta hai, kyunki agar aapko OS basics acche se aate hain, to aap ek pro developer ban sakte ho. Isi liye OS ki understanding bahut important hai Node.js development mein.

### CPU: Central Processing Unit

Jo abhi aapke dimaag me image aa rahi hai, wo CPU nahi hai. Wo **CPU ka dabba** hota hai, jise cabinet bolte hain. CPU actually uska chhota sa hissa hota hai jo **motherboard** ke upar laga rehta hai.

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

**Cabinet** ke andar **Motherboard** hota hai, aur Motherboard pe hi **SSD** laga hota hai. **OS** inhi cheezon pe run karta hai.

### Core kya hoti hai?

**CPU** me **cores** hoti hain, lekin unhe aankhon se nahi dekh sakte. Pehle zamane me sirf **single core** hoti thi, aur ek baar me sirf ek hi program run ho sakta tha. Aaj kal **4 cores** hoti hain, jinka matlab yeh hai ki ek baar me multiple tasks perform ho sakte hain.

### Logical Cores

Agar hamare system me 4 **logical cores** hain, to modern technology se unhe **8** cores tak badha diya jata hai. Is tarah se manage kiya jata hai ki 4 cores ka kaam **8 cores** jaisa ho jata hai. Ye sab processor ke manufacturer manage karte hain, aur **operating system** bas inhe operate karta hai. Apne system me ye information dekhne ke liye **Task Manager** open kariye, aur **CPU** tab pe jayiye — aapko sari details wahan mil jayengi.

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

Ab aao dekhte hain yeh sab **Node.js** se kaise pata karte hain. Apne **terminal** me jayiye, aur likhiye `node`, phir enter press karke Node.js environment me aayiye.

```jsx
🕑 23:46  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 node
Welcome to Node.js v22.2.0.
Type ".help" for more information.
> os.availableParallelism()
8  // ye hai cores 
>
```

### Operating System kya hai?

**OS** bas ek software hota hai. Yeh ek special software hai jo hardware ko manage karta hai. Yeh decide karta hai kaunsi app kitne time ke liye kaunsa hardware use karegi. Basically, OS ek manager hai jo sab applications ke liye kaam karta hai.

### Kernel kya hai?

Operating System ka ek chhota sa hissa **Kernel** kehlata hai. Kernel OS ka core part hota hai, aur yeh hardware aur OS ke beech kaam karta hai.

### Single Core ka kya matlab hota hai?

Kya iska matlab sirf ek app run hoga? Agar ek **core** sirf ek hi kaam kare, to ek time pe sirf ek hi cheez process ho sakti hai. Yeh baat 100% sahi hai, lekin iska yeh matlab nahi hai ki agar 8 logical cores hain to sirf 8 hi apps open ho sakti hain. Aap 8 se zyada apps bhi khol sakte ho.

Agar aapne 10 apps kholi hain lekin sabko ek saath use nahi kar rahe, to OS kya karta hai? OS in apps ko processor se baar-baar sync karta rehta hai, mtlb update ke liye inhe core me daal ke check karta hai. Jaise **VS Code** ko OS ne pick kiya, process pe daal ke kaam kar liya aur nikaal diya. Yeh sab ek process ke cycle me hota hai.

Do processors honge to ek baar me zyada programs handle kar paayenge, lekin iska matlab yeh nahi ki sirf 2 hi apps handle kar sakte hain. Yeh sab **context switching** ke through hota hai. Waise yeh academic concept hai, lekin context switching ko dekhna hai to aap padh sakte ho.

### Ye sb Search kr skte ho

1. C Mos kya hota hai
2. GPU kya hota hai



.....baki aage mai  kal likhta hu, aapko likhne ka man hai aage to likhiye.... edit page par click kr dijiye upar


Basic OS feat Node JS

E19 Basic OS feat Node JS


### Prerequisites
Basics of Frontend (Not covered in the course)
**HTML/CSS**: Basic knowledge of HTML and CSS is useful since we'll be using Node.js for web development.


### Good Knowledge of JavaScript (Not covered in the course)
**Syntax and Basics**: You should be comfortable with JavaScript syntax, variables, loops, conditionals, functions, and error handling.
**Advanced JavaScript Concepts**: Understanding concepts like closures, callbacks, promises, async/await, classes & OOPs, JSON, and event handling is crucial since Node.js heavily relies on asynchronous programming.


### Basics of Terminal (Covered in the course)
**Shell Commands**: You should be comfortable using basic shell commands to navigate directories, manage files, and execute scripts.


### Basics of OS (Covered in the course)
**CPU and Cores**: You should have a basic understanding of CPU and Cores.
Process, Threads and Kernel: You should have a basic understanding of Process, Threads and Kernel.


**File Systems and Paths**: Understanding file paths, relative vs absolute paths, and file permissions. Environment Variables: Knowing what environment variables are and how to set them in different operating systems.
Environment Variables: Knowing what environment variables are and how to set them in different operating systems.


### Basics of Computer Networking (Covered in the course)
**IP Addresses, Ports, and DNS**: Understanding how IP addresses, ports, and DNS work is helpful when dealing with networking in Node.js.


Above content is copied from [https://procodrr.com/nodejs/section-1_introduction/1_prerequisites/](https://procodrr.com/nodejs/section-1_introduction/1_prerequisites/) :

Prerequisite

e2:  prerequisite

Process ek unit of execution hota hai, matlab ek aisa program, code ka piece ya application jiska apna memory allocation hota hai aur jo processor ko use karke computation yani kuch kaam kar sakta hai. Har process apni life cycle ke dauran alag-alag states se guzarta hai, jaise ready state, waiting state, running state, terminated state, aur sleep state. Ye states process ki current condition ko define karti hain.

Agar aapko ye states dekhni hain ya kisi process ko monitor karna hai, to aap Windows mein Task Manager khol sakte hain, macOS mein Activity Monitor ya Linux mein System Monitor open kar sakte hain.

Har process ki apni ek unique ID hoti hai, jise Process ID (PID) kehte hain.

![image.png](/public/images/blogs/1osprocess1.jpg)

Ab in sab mein kuch important details jo humne pehle discuss ki hain, jaise Execution Context aur doosri cheezein, wo aapko dikh nahi rahi hongi. Inhe dekhne ke liye aap kuch additional apps install kar sakte hain jo in details ko monitor karne mein madad karte hain. Un apps mein se ek popular app hai **Process Explorer**.

Is app ko install karke aap har process ki in-depth information jaise CPU usage, memory consumption, aur execution context ka analysis kar sakte hain. Iske alawa, aap **htop** (Linux ke liye) aur **Activity Monitor** (macOS ke liye) jaise tools bhi use kar sakte hain.

https://learn.microsoft.com/en-us/sysinternals/downloads/process-explorer

https://processhacker.sourceforge.io/downloads.php : isme windows ka setup download kr lijiye

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

Yaha se aap **context switches** bhi dekh sakte hain. Kisi bhi subprocess pe click karke jo dialog open hoga, usse aap yeh check kar sakte ho ki uska **parent process** kya tha aur **current process** kya hai. Ab ek kaam karte hain, chaliye dekhte hain **Node.js** ka process kaise hota hai aur kitna CPU aur memory consume karta hai.

Terminal pe jaake `node` start kar dijiye. Jaise hi aap `node` start karte ho, wo **REPL environment** (Read-Eval-Print Loop) ko start kar deta hai, jiska matlab hai aap waha directly commands likh ke unhe execute kar sakte ho. 

Ab yaha se hum dekh sakte hain Node.js ka process kaise behave karta hai.   **[REPL : Read-Eval-Print Loop](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e6-installing-node-js)**

```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node
Welcome to Node.js v22.2.0.       
Type ".help" for more information.
>
```

Ye screen shot niche dekhiye, hum **Node.js** ka process observe kar rahe hain, jiska **context switch** 2004 hai, yaani ki bahut zyada nahi hai. Context switch ka matlab hota hai ki processor kitni baar ek process se dusre process me switch karta hai. 

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

ab aap while(true){} ye likh dijiye node js ke terminal me

```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node
Welcome to Node.js v22.2.0.       
Type ".help" for more information.
>while(true){}
```

Node ke REPL, yani terminal me, agar aapne ek **infinite loop** chal diya, toh ab ye **Node.js** ki process aapke ek core ko poora use karegi. Ab kya hoga? Mere paas total 8 cores hain, aur ye ek core ko use kar raha hai. Toh kitna percentage hua?

100/8 = 12.5% max, na?

Ab aap niche screen shot me dekhiye, wahi dikh raha hai. Aur ab **context switch** ka jo number hai, woh count bhi badh chuka hai. Aur bas yahi pura khel hai, ki kaise ek process ek core ko fully utilize kar ke performance ko impact karti hai.

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

Aap process pe right-click karke uski **priority ko "realtime"** kar sakte ho, isse ye 12.5% tak pahunch jayega, yani max utilization. Agar aapne aise 8 processes Node ke open kar diye aur unki priority ko realtime kar doge, to aapka system **Siachen Glacier** ki tarah freeze ho jayega, ekdum jam ho jayega. Phir aap kuchh nahi kar paoge, haha!

4o

### Process vairable

Accha iska alawa hamare pass node js env me process variable bhi rahta hai, aap 

```jsx
console.log(process)
// aapko dikhega
  pid: 16328,
  ppid: 23832,
  execPath: 'C:\\Program Files\\nodejs\\node.exe',
  debugPort: 9229,
```

Aap console ya debugger laga ke process ko check kar sakte ho, aur usme aapko **PID** (Process ID) aur **PPID** (Parent Process ID) bhi dikh jayegi.

Aur ab milte hai, lekin isse pehle aapko ek question ka jawab pta karna hai: **Node.js single-threaded hai ya multi-threaded?** Soch ke jawab do!

Milte hain agle blog mein..


What is process ?

e21: what is process in operation system

### Dekh rahe ho Vinod? kaa bhaiya, kaise thread ghoom rha hai ?

Achha, hum yeh toh jaante hain ki ek process ek core par execute hota hai. Lekin kya ek process sirf ek core par hi chalta hai? Nahin! Ek process ke kai sare threads ho sakte hain. Jaise Chrome mein kai tabs hote hain—ek tab mein video chal raha hota hai, aur doosre tab mein aap email likh rahe hote ho. Dono alag-alag threads mein kaam kar rahe hote hain.

Jab koi process start hota hai, toh hum kehte hain process ko "spawn" karna. Jab ek parent process apne child process ko banata hai, toh usse "spawn" kehate hain. Ye baat toh suna hi hoga? Process kai threads create kar sakta hai. Threads ko spawn karna fast hota hai, jabki process ko spawn karna kaafi expensive (mehenga) hota hai.

Baki details aap online padh sakte ho. Socho, ek Chrome jisme do tabs hain, dono alag threads par chal rahe hain, aur yeh threads alag-alag cores par run kar sakte hain. Lekin agar CPU mein sirf ek hi core hai, toh kya fayda hoga do threads banane ka? Haan, fayda hoga! Thread banane ka fayda yeh hai ki OS (Operating System) kaam efficient banata hai.

Threads ke saath kaam karne se context switches (yaad hai?) jaldi-jaldi hote rehte hain. Matlab, ek thread ke execute hone ka intezaar nahin karna padta. Samajh rahe ho? Jaise aapke do bacche (threads) ek ke baad ek kaam kar rahe hain, bina time waste kiye.

Isliye, multi-threading single core CPU par bhi possible hoti hai. Process hi thread create karta hai, isliye ise "worker thread" kehte hain, kyunki thread process ka worker hota hai. Aise samjho, aap ek boss ho (process) aur aapke do naukar hain (threads), jo bina rukhe kaam karte ja rahe hain.

Ab aao, samajhte hain kaise system mein threads ko dekh sakte hain!

### Threads in Task Manager

Ab aap Task Manager open kar lijiye... aur "Details" section mein chale jayein. Agar aapko "Threads" column nahi mil raha hai, toh kisi bhi column ke upar right-click karke "Threads" ko select kar lijiye. Isse aap dekh sakte hain ki har process mein kitne threads chal rahe hain.

Aur yeh sab aap apne third-party software mein bhi dekh sakte hain. Iske liye aap "System Informer" jaisa software download kar sakte hain. Jaise maine apne pichle blog mein bataya tha, aap yaha se bhi check kar sakte hain: [Check this](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e21-what-is-process-in-operation-system).

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

### Create Thread in Node.js

Aao ab Node.js me thread create karte hain aur system me observe karte hain. Ab aap Node.js me jo bhi threads dekh rahe hain, unhe aap Task Manager ya System Informer me filter kar sakte hain. Jaise hi niche diya gaya code aap VS Code ke terminal me run karenge, aapke process ka number badh jayega. Ye isliye hoga kyunki Node.js in tino loops ko lagatar run karega, aur single thread me run karega.

```
console.time();
for (let i = 0; i < 1000000000; i++) {
  if (i % 400000000 == 0) {
    console.log("loop 1 " + i);
  }
}

for (let i = 0; i < 1000000000; i++) {
  if (i % 400000000 == 0) {
    console.log("loop 2 " + i);
  }
}
for (let i = 0; i < 1000000000; i++) {
  if (i % 400000000 == 0) {
    console.log("loop 3 " + i);
  }
}
console.timeEnd(); // 4.001s
```

### Multi-threading in Node.js

Ab socho agar CPU me bahut saari cores hain, aur hamare paas ye teen kaam hain, to ab Node.js jo ki ek process hai, kaise efficiently run karega? Kaise? Ye loop ko kaise threads me efficiently dalta hai? Agar aap ye code run karke observe karenge, to aapko threads dikhaai dengi. Aao dekhte hain kaise alag-alag threads me rakhte hain.

Aao pehle 3 files banate hain `a.js`, `b.js`, aur `c.js`, aur in teeno files me hum loops paste karenge.

```jsx
console.time();

const {Worker}= require('worker_threads')

new Worker("./a.js") // pahla thread
new Worker("./b.js")  // dosora thread
new Worker("./c.js")   // teesra thread

console.timeEnd();
```

'worker_threads' ek module hai jiska use karke humne thread create kiya hai. Ab thread count bhi 3 se badh jayega, aur CPU ka usage bhi teen guna ho jayega, kyunki CPU cores block ho jayengi ab. Ye hai multi-threading... hahahahahahaha.

Soch ke dekho, agar teeno loops ek hi thread me rakh ke run karoge to 12% CPU consume hoga kyunki mere paas total 8 cores hain, to 12% * 8 = lagbhag 100%.

Lekin abhi aapne kya kiya? 3 alag-alag threads bana diye aur teeno cores block kar diye. To ab CPU usage kitna ho jayega? 12% * 3 = lagbhag 37-38% ke aas-paas dikhai dega!

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

Actually, teeno threads parallel run kar rahe hain… isse threads ka parallel run hona kehte hain.

### Concurrency aur Parallelism

Concurrency ka matlab hota hai ki ek thread thoda sa instance run karta hai, aur context switching hoti hai. Jaise, pehle thread 1 run hota hai, phir thread 2, aur phir thread 3. Matlab, multiple threads create karke hum experience smooth karte hain. Concurrency ka matlab hai sabko ek-ek karke chance milta hai, sabka time aata hai — jaise ek-ek turn lena.

Lekin Parallelism ka matlab hota hai concurrency ke saath, lekin teeno threads ek saath parallel run honge, mtlb sabka time aayega, lekin sab sath-sath run karenge. Toh threads se cheeje to concurrent hoti hain, lekin wo parallel hongi ya non-parallel, ye depend karta hai. Lekin context switching apni jagah hoti hai.

Dekh lo bhai, mai fir bol raha hoon, ye koi academic class nahi hai, aap isko achhe se padh sakte ho aur apko maza aa raha hoga yaha... hai ki nahi? Jao aur repo ko star do... hahaha, arey yaar, parallelly!

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

### Node.js single-threaded hai ya multi-threaded?

Node.js bhai saab, multi-threaded hai, lekin default mein yeh single-threaded environment mein kaam karta hai. Haan, agar aap chaho to multi-threading bhi use kar sakte ho with the help of modules like `worker_threads`. Matlab, marzi aapki hai—chahe to single-threaded mein kaam karo ya multi-threading ka maza lo. Jaise ke kehna ho, "Mere account mein ek crore rupaye hain, lekin aap bol rahe ho ki main sirf ek rupaya hi kharch karun!"

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

Haan, bilkul sahi kaha! Node.js ke version 10 ke pehle multi-threading ka support nahi tha, isliye log ise single-threaded hi maante the. 2019 ke baad `worker_threads` module ke aane se multi-threading possible ho gayi. Matlab, ab developer bhi khud se multiple threads create kar sakte hain aur unhe efficiently manage kar sakte hain. Pehle sirf asynchronous model tha, lekin ab hum real multi-threading ka faayda utha sakte hain.

Dekha na, ab aap multiple threads easily create kar pa rahe ho aur system ka full utilization bhi kar sakte ho!



Haan, bilkul! Ab ek kaam karo, jo loop abhi humne create kiya tha, usse ek alag file me paste karke run karo. Phir dekho CPU usage kaise badhta hai aur single-thread ke comparison me multi-thread ke andar CPU ka usage zyada hota hai, lekin time kam lagta hai.

### **Kya Process Bina Thread Ke Exist Kar Sakta Hai?**

Jab koi process execute hota hai, to kya wo bina kisi thread ke chal sakta hai? Aisa bilkul nahi hota. Jab koi process start hota hai, to uska ek thread zaroor hota hai, jo "main thread" kehlata hai. Ye main thread hi hota hai jo baaki worker threads ko start karta hai. Mtlb, ek Node.js process me hamesha ek thread hoti hi hai, aur wo main thread hota hai. Agar aap Task Manager me dekhenge, to har process ke sath kam se kam ek thread zaroor hoti hai.

Ye hi hai multi-threading ka faayda, thread banaiye aur efficiently kaam complete kariye.
 
![image.png](/public/images/blogs/6trhead.jpg)

Aur dekho bhai, mera CPU to ab ghoom gaya hai, raat ke 3 baj rahe hain aur ab sone ka mann bhi kar raha hai 😅.

To chalo, milte hain next blog me, tab tak ke liye Dhanyawaad! Keep experimenting and exploring!


Duniya Threads ki !

e22: Thread, Concurrency, and Parallelism



Server ek tarike ka computer hi hota hai. Maine iske baare mein pehle hi kaafi likh rakha hai, aap [yaha click karke](https://heyashu.in/digital-garden/notes/namaste-node-js/e2-js-on-server) padh sakte hain. Uske baad yaha aake continue kar sakte hain.

Ek front-end application ko run karne ke liye ek server hona zaroori hota hai. Jab hum VS Code mein live server use karke run karte hain, to wo Node.js ka code use karke hi run hota hai. Ye live server ka GitHub repo hai, waha jaake aap isko padh sakte hain, ye Node.js ka hi code likha gaya hai.


[https://procodrr.com/nodejs/section-1_introduction/1_prerequisites](https://procodrr.com/nodejs/section-1_introduction/1_prerequisites)

What is backend & client server

e3 what-is-back-end-client-server



CLI ka full form hota hai **Command Line Interface** aur GUI ka **Graphical User Interface**. Dono tarike ke apps hote hain. Kuchh aisi applications hoti hain jinka interface nahi hota, jaise **git**. Git ko run karne ke liye command yaani terminal application use hoti hai. Jaise aapne likha `git pull`, iska koi GUI (graphical interface) nahi hai, saari cheezein commands se hi hoti hain, hai ki nahi?

Jaise ek aur library hai jiska koi UI nahi hai, lekin command ke through aap saare YouTube ke videos download kar sakte ho, iska link yeh hai: [yt-dlp GitHub](https://github.com/yt-dlp/yt-dlp).

**For example:**

```jsx

//first Python install kar lo from using the official website.
//Aur phir yeh code use karo:
yt-dlp -f "bestvideo[height<=1080]+bestaudio/best[height<=1080]" --merge-output-format mp4 -o "%(playlist_title)s/%(playlist_index)s - %(title)s.%(ext)s"

```

Baaki kaise install hota hai, yeh sab aap jaake inke Discord pe dekh sakte ho. Abhi ke liye itna jaan lo ki aisa possible hai, aur baaki hum aage dekhenge. To bas, yeh ek example tha CLI ka aur commands se kaam karne ka. Windows mein start button dabake `cmd` likho to ek CLI open ho jaata hai. Linux mein terminal hota hai, toh yahi sab hota hai.

Hum bhi aisi applications Node.js ki madad se bana sakte hain, CLI bana sakte hain. Jaise Operating Systems hote hain, kuch terminal-based hote hain jaise **MS-DOS**, **UNIX**, jo ki command-based interfaces hain (CLI). Aur inhi ke upar **macOS** aur **Linux** bane hain jo graphical user interfaces (GUI) hain. Windows bhi ek GUI, yaani Graphical User Interface, hai.

Aage Node.js mein bhi hum CLI use karenge. Aur front-end mein bhi aapne git toh use kiya hoga, hai ki nahi?



CLI vs GUI

e4: cli gui 



Node.js ka use karke aap JavaScript ko browser ke bahar bhi run kar sakte hain. JS pehle sirf browser ke liye bani thi, lekin jab JS ko browser ke bahar run karte hain, toh yeh bahut powerful ho jaata hai.

NPM Node.js ka ek package manager hai, aur Vue ka CLI, Next.js ka CLI, aur Create React App sab Node.js ka use karke hi banaye gaye hain. Chalo, main aapko dikhata hoon:

[Create React App GitHub Repo](https://github.com/facebook/create-react-app)


![image.png](https://i.ibb.co/8g2JGSG/ssssss.png)

Jaake TypeScript aur saare CLI ka code GitHub pe dekho. Scroll karoge toh aapko dikh jayega ki jo JavaScript browser mein nahi chal rahi, wo Node.js mein chal rahi hogi. JavaScript sirf browser tak simit nahi hai.

Bas aap itna samajh lijiye ki yeh bahut interesting hai aur aane wale videos mein hum Node.js ke deeper concepts ko explore karenge. Toh tayaar rahiye, kyunki hum Node.js ke "**muh dikhayi**" karenge aur installation process bhi dekhenge. Milte hain agle blog mein!


What Is Node.js ?

e5-what-node-js 




Agar aapke system mein Node.js installed hai toh bhi is article ko skip mat kariye, kyunki yeh kaafi helpful ho sakta hai seekhne ke liye. Aapko bas apne VS Code editor mein ek `script.js` file banani hai aur usme yeh code likhna hai jo maine neeche diya hai.



```jsx
//script.js  (included in index.html) 
 
console.log("Sanjana Air lines");
let a=5;
let b=4;
console.log(a+b)
```


Aapko pata hoga ki hum `index.html` ya `live server` ka use karke `script.js` ko attach karte hain aur fir Chrome ya kisi aur browser ke DevTools mein check karte hain ki sab sahi se kaam kar raha hai ya nahi. Neeche diye gaye screenshot mein aap dekh sakte hain ki kaise hota hai. Toh sabse pehle aap apni `index.html` file mein `script.js` ko attach karke `live server` ke through `5500` port par run kar lijiye: `http://localhost:5500/index.html`. Isse aapko kuch aisa interface dikhega console me.


![image.png](https://i.ibb.co/Wxzs1nb/e7p2.png)


### Debugging in VS Code (Web App)


Lekin yaha pe "Chrome" ka koi role nahi hai, kyunki hum backend seekh rahe hain, yani browser ko ab side mein rakho. Samajhiye ki ab humne browser se V8 engine ko alag kar liya hai aur usko Node.js mein use kar rahe hain. Ab baat yeh hai ki hum kaise JavaScript ko Node.js ke andar run karenge, kyunki Node.js humein JavaScript ko browser ke bahar run karne ki power deta hai.


Ab aapko VS Code mein jaana hai aur ye teen steps follow karne hain:


1. **Run and Debug** option ko kholiye ya (Ctrl + Shift + D) press kariye.
2. "Run and Debug" wale full-width button pe click kariye.
3. Ab dropdown me se Web App chrome select kariye aur aapka app chrome pe chal rha hai


![image.png](https://i.ibb.co/JccYjLf/proe7e4.png)


Jab aap debugging setup karenge aur dropdown pe click karenge, to ek file automatic generate ho jaayegi `.vscode` folder ke andar, jisme ek `launch.json` file hogi. Is file mein aap apne project ke debugging configurations ko set kar sakte hain.


Aapko port ko 5500 set karna hai, ya fir aap niche ka code `launch.json` file mein paste kar sakte hain: Dhyan rakhiye, `program` key mein jo path hai, usse aap apni main file ka path set kar sakte hain, jaise `app.js` ya `server.js` depending on aapka project structure. agar vs code folder aur aapki js file ek level pe hai to koi jarurat nahi hai.


Yeh setup karne ke baad, aap "Run and Debug" kar sakte hain apne Node.js application ko.


```jsx
{
  // Use IntelliSense to learn about possible attributes.
  // Hover to view descriptions of existing attributes.
  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
  "configurations": [
    {
      "type": "chrome",
      "request": "launch",
      "name": "Launch Chrome against localhost",
      "url": "http://localhost:5500",
      "webRoot": "${workspaceFolder}"
    }
  ]
}
```


Ab iske baad, aap jo 1, 2, 3, 4 lines dekh rahe hain, waha cursor le jaake debugger laga sakte ho. Debugger set karne ke baad, aap apne app ko launch kar sakte ho. Neeche diye gaye screenshot mein aap dekh sakte ho kaise ye process hota hai. Phir "Launch Program" select karke, 3 number ke highlighted area se debugging kar sakte ho.


Yeh controls bilkul Chrome DevTools jaise hi hain. Agar aapko inke baare mein zyada knowledge nahi hai, toh aap YouTube videos dekh sakte ho ya koi blog padh sakte ho.


![image.png](https://i.ibb.co/MfQ2zPq/proe7p4.png)


Debugger lagane ke baad, aapko kya karna hai:


1. Niche screenshot mein diye gaye dropdown se "Node.js" select kariye.
2. Phir green play button par click kariye.
3. Jab aap next-next steps follow karenge, to green button press karte hi ek nayi window open hogi (jo Chrome environment hoga), aur waha aapka app run hoga.
4. Is waqt aapka code debugger ke point par aa ke ruk jayega, jahan aap apna code step by step debug kar sakte hain.


Yeh process aapko real-time debugging ka experience dega, aur aap asani se apne code ke flow ko samajh paenge.


![image.png](https://i.ibb.co/QJc7N5d/proe7p5.png)


Aur jab aap apne code ke upar hover karenge, to aap variables ka current value dekh paenge. Is tarah, aap apne code ko step-by-step samajh sakte hain aur debugging process ka maza le sakte hain. Debugger lagate rahiye aur apne code ke har part ko explore kariye.


![image.png](https://i.ibb.co/vzzGYdr/proe7p6.png)


### Debugging in VS Code (NodeJS Code)


To ab tak humne dekha ki kaise VS Code ka live server chalake, JavaScript jo ki `index.html` mein thi, usse humne Chrome pe debug kiya aur VS Code mein bhi debugger laga ke debugging kar li. Lekin agar `index.html` file na ho toh pure Node.js ko kaise debug karoge?


Isse pehle, do kaam kariye:


1. `.vscode` folder ko delete kar dijiye.
2. `index.html` file bhi delete kar dijiye.


Ab jab aap play button press karenge toh error aayegi, kyunki ab humare paas frontend (HTML file) nahi hai. Ab aapko **Debugging in VS Code (Web App)** section ke upar jaake screen shots follow karne honge, aur aapko error dikhegi. to ab kaise run karein , to dono fiiles ko delete krne ke baad aap kuchh krna nahi bs, same last step run and debug point ko click karke **chrome** na select krke ab nodejs/ javascript select krna hai aur Play green button par click kr dena hai, dhyaan rahe aap debug kr  rhe hain to debug mark lagana na bhuliye. see screenshot for saare steps, Output aapko down side terminal ke **Debug console** me dikhega

![image.png](https://i.ibb.co/999XTVt/eproe7last.png)


Yeh steps follow karne ke baad aap samajh payenge ki pure Node.js application ko kaise debug kiya jaata hai bina kisi HTML file ke


### Node Js code in terminal


Ab jab VS Code open hai, toh ```Ctrl + \`` ya``` Ctrl + J` press kariye, isse terminal open ho jayega. Terminal kuchh aisa dikhega, jahan aap apne Node.js commands ya scripts run kar sakte hain.


Isse aap direct terminal se apne project ko manage kar paenge aur Node.js ko run karne ke liye commands execute kar sakte hain.


![image.png](https://i.ibb.co/0FkT16k/proe7p8.png)


Lekin iske pahle aapko nodejs download krna padega


### Install node js from the website


Yaha jaiyie https://nodejs.org/en/download/prebuilt-installer aur node js dwnload kr liye 


![image.png](https://i.ibb.co/ZBx739c/proe7p9.png)


ab jaise hi terminal pe aap liklhoge node kuchh aise diekhega


```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node
Welcome to Node.js v22.2.0.       
Type ".help" for more information.
>2*6
12
```


Aur ab ye REPL environment open ho gaya hai. **[REPL kya hota hai](https://www.digitalocean.com/community/tutorials/what-is-repl)**?

### REPL : Read-Eval-Print Loop
REPL ek aisa environment hota hai jahan aap kuch bhi JavaScript code run kar sakte ho bina kisi browser ke. REPL ka full form hota hai **Read-Eval-Print Loop**, jisme code ko read, execute, aur output display kiya jata hai. Ye environment Node.js ke saath aata hai, jahan aap real-time mein apna JavaScript code run aur test kar sakte ho.


Is REPL environment ko aap `Ctrl + D` press karke band kar sakte ho, jab aapko debugging ya testing complete ho jaye.


![image.png](https://i.ibb.co/9pt1wGp/proe7p10.png)


Aur ab agar aap kisi file ko run karna chahte hain jo aapne banayi thi, jaise `script.js`, toh bas terminal mein likhiye:


```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node script.js
Sanjana Air lines
9
```


To abhi tak humne live server ke saath, `index.html` ke sath, aur bina `index.html` ke bhi JavaScript ka code kaise run kiya, yeh sab samjha. Aapne Node.js aur VS Code debugging ko efficiently use karna seekha hai.


Agle session mein milte hain. Thank you




Node JS ki muh dikhaayi 👰

e6 installing node js 



"Chalo ek file `text.txt` banate hain apne VS Code mein aur waha kuch likhte hain, jaise ki 'hello.'

Uske baad `script.js`, jo ki `text.txt` ke bagal mein hi hai, usse run karna hai. Aapko [pichhle session mein dekh sakte ho kaise run karein](http://localhost:3001/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e6-installing-node-js) ya fir F5 press karo ya `fn + F5` press karo. Haan, debugger lagana mat bhuliye, aur aapko input mil jayega. Output niche code editor mein dekhna hai, aur yaad rakho output debugger console mein hi dikhega."

```
// create a text.txt file and paste hello
// create a script.js and paste till last console.log

const fs = require('fs');
const text= fs.readFileSync('./text.txt')
console.log("text",text);

console.log("yes file aa gyi ");

//ouput in Debugger console
text Buffer(5) [72, 101, 108, 108, 111, buffer: ArrayBuffer(8192), byteLength: 5, byteOffset: 288, length: 5, Symbol(Symbol.toStringTag): 'Uint8Array']
script.js:9
arg1 =
Buffer(5) [72, 101, 108, 108, 111, buffer: ArrayBuffer(8192), byteLength: 5, byteOffset: 288, length: 5, Symbol(Symbol.toStringTag): 'Uint8Array']
0 =
72
1 =
101
2 =
108
3 =
108
4 =
111
buffer =
ƒ buffer()
byteLength =
ƒ byteLength()
byteOffset =
ƒ byteOffset()
```

So, abhi aapko buffer mila hai, aur yeh file se related hai, khaane-peene se nahi. Toh yaha dhyan dijiye! Ab yeh buffer kya hai? Actually, yeh wohi file ka data hai jisme jo bhi content present hai. Ab kaise read karein?

Niche screenshot mein diye gaye steps follow kariye. Number 1 pe hover karke ek extension install kijiye, aur fir buffer ko read karte hain.

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

Install aap [iss link](https://marketplace.visualstudio.com/items?itemName=ms-vscode.hexeditor) se bhi kar sakte hain, lekin view tabhi hoga jab aap debug kar rahe honge, yani red mark file ke console pe rakhiyega. Extension installation ke baad yeh result aayega (baad me dekhenge)

![image.png](/public/images/blogs/pro-e772.png)

Ab aap itna samjhiye ki aap file read kar paa rahe hain. Kya aap ye simple JS se browser environment mein file read kar sakte hain? Answer is **nahiii**! Toh ye ek best benefit hai aur power hai Node.js ki, ki using JS, we can read the file. Aur bhi bahut kuchh kar sakte hain, jo hum aage ke session mein dekhenge.

### Global Object in Node.js

Jaise browser mein `window` global variable hota hai, waise hi Node.js mein `global` naam se global variable hota hai

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

Confuse ho gaye? Rukiye, main aapko dikhata hoon. Left side VS Code mein aapko 'Run and Debug' option dikh raha hoga, waha `Global` object dikhai dega. Usko expand karke dekhiye, aapko `global` object ki sari details dikhengi. Ya fir, aap `script.js` file mein code likh dijiye, aur terminal open karne ke liye ```Ctrl + \`` ya``` Ctrl + J` press kariye, fir likhiye: (Pichle session mein humne ye dekha tha.) Aapko console mein output dikh jayega. Filhaal, main screenshot dono jagah ka niche daal raha hoon.

Iss Global aur window ke baare me english me [yaha se padh sakte hain](https://heyashu.in/digital-garden/notes/namaste-node-js/e3-write-first-line-of-node-js-code).

```jsx
console.log(global)

// output
```

![image.png](/public/images/blogs/pro-e77-p-5.png)

So, yeh jaan lena zaroori hai ki web browsers mein `global` naam ka koi variable nahi hota, aur `window` ka concept Node.js mein nahi hai. Haan, community ne ek default variable create kiya hai jo dono environments (browser aur Node.js) mein related content deta hai. Lekin, bas naam same hai, so no confusion. 

Ab miltey hain next episode me.


First Line in Node Js

e7: running first line of code.

JS browser ke bahar bhi bahut kuchh kar sakti hai, chalo kuch examples dekhte hain.”

```jsx
const fs= require('fs');
fs.writeFileSync('hello.txt','Aur kaise ho??')
const text= fs.readFileSync('hello.txt')
console.log("text read", text);
```

FS ke bahut saare methods hain, bas itna samajh lijiye ki JavaScript Node.js me file delete, write, edit, aur create kar sakti hai. Aage hum isko detail me padhenge. Hum kisi bhi application ko bhi open kar sakte hain, jaise ab ek example dekhte hain kaise Chrome ko open karein.

```jsx
const {exec}= require('child_process')

exec('start chrome')
```

### Networking capabilities

JS Node.js me server bhi start kar sakti hai. Ek file banao aur usme likho

```jsx
const http= require('http')

const server= http.createServer((req,res)=>{
  res.end("hello world")
})

server.listen('3000')

// isko krne ke baad terminal me node script.likho 
// debugger se on kro
// browser pe jaake localhost:3000 hit kro
// browser me aisaa dikhega
```

![image.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/f04e628e-4c39-4f41-b348-53c143900880/78cad77f-52c8-45b2-9c60-7f859188e732/image.png)

Server ka code debug se run karne ke liye, aap left top pe green play button ko click kar sakte hain. Dhyan rahe, aapke `launch.json` file me ye code hona chahiye. Yani, `program` me aapke file ka naam hona chahiye. Mere file ka naam `script.js` hai, to maine `script` likha hai

```
  // .vscode/launch.json
  "version": "0.2.0",
  "configurations": [

    {
      "type": "node",
      "request": "launch",
      "name": "Launch Program",
      "skipFiles": [
        "<node_internals>/**"
      ],
      "program": "${workspaceFolder}\\server.js"
    }
  ]
}
```

* Process management kr sakte hain
* Operating system se interact kr sakte hain node js se

aur bahut saari cheeje ….


Why we should use Node Js

e8: Why Node JS

2008-2009 ke aas-paas ek developer Apache servers ke sath kaam karta tha, jahan har request ke liye ek naya thread create hota tha, jo blocking hota tha. Iska matlab ye tha ki jab ek request process hoti, tab tak doosri request wait karti. Is problem ko solve karne ke liye, 2009 me us developer ne JavaScript ko server pe run karne ka socha aur non-blocking approach ko adopt kiya, jisme ek hi thread multiple requests handle kar sakta tha bina block kiye. Usne **Chrome** ke JavaScript engine **V8** ka use karke JavaScript ko server-side pe run kiya.

Is experiment ke baad, 2010 me **NPM** (Node Package Manager) launch hua, jo JavaScript libraries aur modules ko manage karne ka ek asaan tarika ban gaya. Phir 2011 me Node.js ka Windows version release hua, aur iske baad Node.js ki popularity aur badh gayi.

Ek company, **Joyent**, ne Node.js ke creator, **Ryan Dahl**, ko hire kiya. Ryan ne 2009 me Node.js banaya tha, aur ab Node.js ka development kaafi strong ho gaya. Lekin, 2014 me ek challenge aaya jab kuch developers ne Node.js se alag ek project banaya jiska naam tha **IO.js**. Dono ka focus server-side JavaScript tha, lekin alag-alag development ho raha tha, jiski wajah se confusion badhne laga.

2015 me **Node.js Foundation** banayi gayi jisme Node.js aur IO.js ko merge karke ek single project banaya gaya—Node.js. Is foundation ne Node.js ko organize kiya aur **LTS** (Long-Term Support) version ke sath stable releases shuru kiye. Sab kuch theek hone laga.

2019 me **OpenJS Foundation** banayi gayi, jo web aur server-side JavaScript frameworks ko manage karti hai, aur aaj Node.js **OpenJS Foundation** ke under managed hota hai.

[agar aapko english me padhna hai to yaha click kariye](https://heyashu.in/digital-garden/notes/namaste-node-js/e1-history-of-node-js-in-depth)


History of Node Js

e9: History of node js



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

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 👋🏻




Introduction to NodeJs

E1:  History of node js in depth

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


### 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

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

 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/YourVueJS)  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

Buy The Course

Meet my father **Mr. Awdhesh kumar Tiwari**

(Got government job in last chance of eligibility criteria)



My father's qualification is B.A. M.A. And B.ed .As a simple man, he was searching for a job for himself after completing his B.ed. Many vacancies had been released, but he was not selected because of less marks in his 10th and graduation; almost about 60% and the other reason was that he was a general category candidate. He applied many times for many teacher jobs but he always failed. He taught in many convent schools in the beginning and he used to get an amount of Rs.1000 per month. And last I remember his salary as a private teacher in an aided school was 4000 Rs per month. He taught English to intermediate students, and gave maths coaching to 8th grade students at our home and also taught in college. It seemed that he won't ever get a govt. job.

A life changing twist came in 2011 when he was 39 years and 10 months old.

You know in general category if you are 40 years old, you can't get a government job. In 2011 November, 72825 vacancies came for primary teachers during Mayawati government. In TET exam.. My Papa gave that exam and scored 121 out of 150. We were sure that happy times were about to come. But in 2012 when Akhilesh Government came in power, vacancies were cancelled. 2 years later, in 2014 , an order came from court to fill those vacancies. Then Akhilesh said that a candidate can apply in a district with 500 Rs per Demand Draft or each of the districts simultaneously.



This was the last chance for my father, he was 42 years old but fortunately he was in because vacancies came in 2011 when he was eligible. My father took a loan of almost 20000 Rs from a bank and applied in more than 40 districts. Result came and that day was the happiest day for my family. My father had a chance to go to more than 35 districts. And he selected Gonda which is at a 100 km distance from my home near Ayodhya. And now he is a teacher in a government primary school, and his salary is 30k per month. This is the story of my father.



Thanks.


Blogs 38