Event Loop in Node

Author: rohan-paul

Javascript/Prototypal-Inheritence/ES6-Function-definition-With-Class.js renamed to Javascript/OOP-Prototypal-Inheritence/ES6-Function-definition-With-Class.js

@@ -66,5 +66,7 @@ setTimeout's job, when called, is to immediately set a timer that will expire af
 
 setTimeout does not wait for the time interval to expire and then execute. setTimeout executes immediately. It is the callback function in setTimeout's first argument that waits/executes.
 
-Further Reading - https://medium.freecodecamp.org/3-questions-to-watch-out-for-in-a-javascript-interview-725012834ccb
+Further Reading -
+1. https://medium.freecodecamp.org/3-questions-to-watch-out-for-in-a-javascript-interview-725012834ccb
+
 */

Javascript/Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-Example-BEST.md renamed to Javascript/OOP-Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-Example-BEST.md

@@ -23,6 +23,8 @@ logText();
 /* When I run the above code, the first < console.log(text) > will print 'undefined' instead of 'outside' - Here's Why - when I have the variable 'text' declared and assigned both inside the function and outside the function -
 https://medium.com/backticks-tildes/understanding-hoisting-and-scoping-in-javascript-39ea7b41e31
 
+Variable Shadowing -
+
 In JavaScript, variables with the same name can be specified at multiple layers of nested scope. In such case local variables gain priority over global variables. If you declare a local variable and a global variable with the same name, the local variable will take precedence when you use it inside a function. This type of behavior is called shadowing. Simply put, the inner variable shadows the outer. This is how the Javascript interpreter finds a particular variable; it searches for the variable at the innermost scope being executed at the time, and continues until the first match is found, even if there are other variables with the same name in the outer scope.
 
 So in above, it takes the 'text' declared inside the inside the function, but then only variable declaration is hoisted and NOT variable-assignment. So here, I am trying to print the 'outside' variable before assigning a value to it. So it prints undefined.

Javascript/Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-Theory.md renamed to Javascript/OOP-Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-Theory.md

@@ -1,14 +1,13 @@
 /* call() and apply() methods with the same use case like the other file
 This time there is a car object without the displayDetails function, which is located in the globa */
 
-
 var car = {
-  regNo : 'GA123',
-  brand: 'Ford',
-}
+  regNo: "GA123",
+  brand: "Ford"
+};
 
-function displayDetails (ownerName) {
-    console.log(`${ownerName}, this is your car : ${this.regNo} ${this.brand}`);
+function displayDetails(ownerName) {
+  console.log(`${ownerName}, this is your car : ${this.regNo} ${this.brand}`);
 }
 
 displayDetails.apply(car, ["Paul"]);
@@ -23,4 +22,4 @@ arrow functions) doesn't create new functional context and use context of a call
 
 */
 
-displayDetails.call(car, "Steve");
+displayDetails.call(car, "Steve");

Javascript/Prototypal-Inheritence/Inheritence-with-classes-super-keyword-SIMPLEST-EXHAUSTIVE.md renamed to Javascript/OOP-Prototypal-Inheritence/Inheritence-with-classes-super-keyword-SIMPLEST-EXHAUSTIVE.md

@@ -1,52 +1,48 @@
 //Example -1 super simple example of custom callback. done() is a callback which I am definining seperately.
 done = () => {
-	console.log("Done from Callback");
-}
+  console.log("Done from Callback");
+};
 
 printNum = (num, callback) => {
+  for (let i = 0; i <= num; i++) {
+    console.log(i);
+  }
+  if (callback && typeof callback === "function") {
+    callback();
+  }
+};
 
-	for (let i = 0; i <= num; i++) {
-		console.log(i);
-	}
-	if (callback && typeof(callback) === "function") {
-		callback()
-	}
-}
-
-// printNum(5, done)
+printNum(5, done);
 
 // Example-2, where, I will pass the callback after invoking the function, without defining the callback separately
 mySandwitch = (a, b, callback) => {
-
-	console.log(`Started eating my sandwitch.\n\nIt has: ${a} and ${b}`);
-	callback()
-}
+  console.log(`Started eating my sandwitch.\n\nIt has: ${a} and ${b}`);
+  callback();
+};
 
 /*mySandwitch('cheese', 'ham', () => {
 	console.log('Finished eating my sandwitch');
 })*/
 
 // To make the callback optional, we can just do this:
 mySandwitchOptional = (a, b, callback) => {
+  console.log(`Started eating my sandwitch.\n\nIt has: ${a} and ${b}`);
 
-	console.log(`Started eating my sandwitch.\n\nIt has: ${a} and ${b}`);
-
-	if (callback && typeof(callback) === "function") {
-		callback()
-	}
-}
+  if (callback && typeof callback === "function") {
+    callback();
+  }
+};
 
 /* Write a custom callback function which returns the addition of its 2 arguments through a callback. That, the function would take 2 arguments and the third agument would be a callback function. And the final return output of that function would be with callback. - Was asked in Techolution interview */
 
-addTwoArgs = ( a, b, callback) => {
-
-	if (callback && typeof(callback) === 'function') {
-		return callback()
-	}
-}
+addTwoArgs = (a, b, callback) => {
+  if (callback && typeof callback === "function") {
+    return callback();
+  }
+};
 
 let result = addTwoArgs(2, 5, () => {
-	return 2 + 5
-})
+  return 2 + 5;
+});
 
-console.log(result);
+console.log(result);

Javascript/Prototypal-Inheritence/OOP-Basics-1.md renamed to Javascript/OOP-Prototypal-Inheritence/OOP-Basics-1.md

@@ -13,3 +13,18 @@ console.log('1 == "1" is ', 1 == "1"); // => true
 // console.log({0: 1} == {0: 1}); // => false
 
 // console.log({0: 1} === {0: 1}); // => false
+
+/*
+Explanation - 1 - Why console.log([1] == [1]); // => false
+
+They are not equal because a new array is being created in each of these statements, each being a brand new array object with just identical contents. If you create two new objects:
+
+var a = {};
+var b = {};
+
+a === b // false
+
+When you create new objects, arrays, functions, etc., a brand new object is placed into memory. Creating a new object with the same internals as another object will not magically cause that object to point to one that already exists. The objects may look the same, but they do not point to the same instance.
+
+
+ */

Javascript/Prototypal-Inheritence/OOP-Encapsulation-Theory.md renamed to Javascript/OOP-Prototypal-Inheritence/OOP-Encapsulation-Theory.md

@@ -8,4 +8,12 @@ null
 undefined
 NaN
 
+Everything else is truthy. That includes:
+
+'0' (a string containing a single zero)
+'false' (a string containing the text “false”)
+[] (an empty array)
+{} (an empty object)
+function(){} (an “empty” function)
+
 */

Javascript/Prototypal-Inheritence/OOP-Encapsulation-example-1.md renamed to Javascript/OOP-Prototypal-Inheritence/OOP-Encapsulation-example-1.md

@@ -2,7 +2,7 @@
 
 <img src=" Asynchronicity-Event-Loop.png">
 
-Any of the web APIs pushes the callback on to the task queue when it's done. Finally we get to the event loop, title of the talk, what the heck is the event loop is like the simplest little piece in this whole equation, and it has one very simple job. The event loop's job is to look at the stack and look at the task queue. If the stack is empty it takes the first thing on the queue and pushes it on to the stack which effectively run it. So here we can see that now the stack is clear, there's a callback on the task queue, the event loop runs, it says, oh, I get to do something, pushes the callback on to the stack.
+The event loop's job is to look at the stack and look at the task queue. If the stack is empty it takes the first thing on the queue and pushes it on to the stack which effectively run it. So here we can see that now the stack is clear, there's a callback on the task queue, the event loop runs, it says, oh, I get to do something, pushes the callback on to the stack.
 
 - Push main() onto the call stack.
 - Push console.log() onto the call stack. This then runs right away, and gets popped.

Javascript/Prototypal-Inheritence/OOP-Encapsulation-example-2.md renamed to Javascript/OOP-Prototypal-Inheritence/OOP-Encapsulation-example-2.md

@@ -2,17 +2,43 @@
 
 [The official Doc](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/) has some very good explanation.
 
-## 1> Some Key points noted on 10-June-2018 >>
+## 1> Some Key points >>
 
 - A> The simple ans is - With callback function and event-loop
 
-- B> With callback function and event-loop, Node transfer execution of the callback function (like, in setTimeout, Promise, fs.readFile) to a queue the output of which follows a FIFO design, while the rest of the code, will get executed. So that’s how its node is non-blocking.
+- B> With callback function and event-loop, Node transfer execution of the callback function (like, in setTimeout, Promise, fs.readFile) to a queue the output of which follows a FIFO design, while the rest of the code, will get executed. So that’s how node is non-blocking.
 
-And whatever was transferred to the separate queue for those callbacks will be executed on a FIFO basis, so an the code that was in the queue first, will return its result first. And then the next one in the queue.
+And whatever was transferred to the separate queue for those callbacks will be executed on a FIFO basis, so the code that was in the queue first, will return its result first. And then the next one in the queue.
 
 ## 2> https://codeburst.io/how-node-js-single-thread-mechanism-work-understanding-event-loop-in-nodejs-230f7440b0ea
 
-Node is single threaded and it is doing magical things with this model. Some of the popular server side technology like PHP, ASP.NET, Ruby & Java Servers all follow Multi-threaded where each client request results in the instantiation of a new thread or even a process, but in Node.js, requests are run on the same thread The main event loop is single-threaded but most of the I/O works run on separate threads, because the I/O APIs in Node.js are asynchronous/non-blocking by design, in order to accommodate the event loop.
+Some of the popular server side technology like PHP, ASP.NET, Ruby & Java Servers all follow Multi-threaded where each client request results in the instantiation of a new thread or even a process, but in Node.js, requests are run on the same thread.
+
+##### Misconception 1: The event loop runs in a separate thread than the user code -
+Many think, there is a main thread where the JavaScript code of the user (userland code) runs in and another one that runs the event loop. Every time an asynchronous operation takes place, the main thread will hand over the work to the event loop thread and once it is done, the event loop thread will ping the main thread to execute a callback.
+
+#### Reality
+**There is only one thread that executes JavaScript code AND ALSO the the event loop. The execution of callbacks (know that every userland code in a running Node.js application is a callback) is done by the event loop.**
+
+
+### Event Loop vs Worker Pool (Thread Pool)
+
+[https://nodejs.org/ja/docs/guides/dont-block-the-event-loop/(https://nodejs.org/ja/docs/guides/dont-block-the-event-loop/)
+
+Node uses a small number of threads to handle many clients. In Node there are two types of threads: one Event Loop (aka the main loop, main thread, event thread, etc.), and a pool of k Workers in a Worker Pool (aka the threadpool). Node uses the Event-Driven Architecture: it has an Event Loop for orchestration and a Worker Pool for expensive tasks.
+Event Loop executes the JavaScript callbacks registered for events, and is also responsible for fulfilling non-blocking asynchronous requests like network I/O.
+
+#### What code runs on the Worker Pool?
+
+Node's Worker Pool is implemented in libuv (docs), which exposes a general task submission API.
+
+Node uses the Worker Pool to handle "expensive" tasks. This includes I/O for which an operating system does not provide a non-blocking version, as well as particularly CPU-intensive tasks.
+
+Event loop is the mechanism that takes callbacks (functions) and registers them to be executed at some point in the future. It operates in the same thread as the proper JavaScript code. When a JavaScript operation blocks the thread, the event loop is blocked as well.
+
+Worker pool is an execution model that spawns and handles separate threads, which then synchronously perform the task and return the result to the event loop. The event loop then executes the provided callback with said result.
+
+===============================
 
 ## 3> Single Threaded Event Loop Model Processing Steps:
 
@@ -131,4 +157,7 @@ Node has a pool of Thread and you must be scratching your head wondering if Node
 
 Generally the web server and the database server are 2 different machines, because of Async nature, the event loop gets free after forwarding the read/write request to database server. That is why, a Node JS HTTP server can handle a large number of requests while the process of complex read/write operations could be inprocess on database server(s).
 
-### Further Resources - https://youtu.be/8aGhZQkoFbQ - Very famous video
+###
+
+- 1. Further Resources - https://youtu.be/8aGhZQkoFbQ - Very famous video
+- 2. [https://nodejs.org/ja/docs/guides/dont-block-the-event-loop/](https://nodejs.org/ja/docs/guides/dont-block-the-event-loop/)

Javascript/Prototypal-Inheritence/OOP-basics-2.md renamed to Javascript/OOP-Prototypal-Inheritence/OOP-basics-2.md

@@ -0,0 +1,39 @@
+**JavaScript is single threaded, that means only one statement is executed at a time. As the JS engine processes our script line by line, it uses this single Call-Stack to keep track of codes that are supposed to run in their respective order.**
+
+Like what a stack does, a data structure which records lines of executable instructions and executes them in LIFO manner. So say if the engine steps into a function foo(){ it PUSH-es foo() into the stack and when the execution of foo()return; } is over foo() is POP-ped out of the call-stack.
+
+<img src="./sequential-execution-1.png">
+
+EXERCISE 1: So from the above diagram shows how a typical line by line execution happens. When the script of three console.log() statements is thrown at JS — 
+
+- Step 1: The console.log("Print 1") is pushed into the call stack and executed, once done with execution, it is then popped out of the stack. Now the stack is empty and ready for any next instruction to be executed.
+
+- Step 2: console.log("Print 2"); // is the next instruction is pushed and the same thing repeats until
+
+- Step 3: is executed and there is nothing left to push and execute.
+
+Lets take an example to understand it better, its a famous Interview question as well. In the logText() function, I am only doing console.log() three times.
+
+```js
+const logText = () => {
+    console.log('A');
+    setTimeout(() => {
+        console.log('B');
+    }, 0);
+    console.log('C');
+}
+
+logText()
+```
+
+The output
+A
+C
+B
+
+**Explanation** - Even though, I am passing 0 to the setTimeout() for the waiting period, because setTimeout() invokes a callback function - this callback function will be passed to an Event Loop. And we we know that - The event loop as a process is a set of phases with specific tasks that are processed in a round-robin manner - so the callback function will go through those phases and ultimately get executed. But during this process Node being Node, will be non-blocking, and so would NOT block the next lines of code which is the third line < console.log('C') >
+
+#### Further Reading
+
+https://medium.com/@siddharthac6/javascript-execution-of-synchronous-and-asynchronous-codes-40f3a199e687
+Worker pool is an execution model that spawns and handles separate threads, which then synchronously perform the task and return the result to the event loop. The event loop then executes the provided callback with said result.