add javascript engine and environment

Author: brijeshkumar-chavda

25_asynchronous_javascript/1_asynchronous_operation/asynchronous_operation.md

@@ -7,9 +7,9 @@ What
 
 Why
 
-- **Improved Performance:** Prevents the program from freezing while waiting for long-running tasks.
-- **Better User Experience:** Maintains responsiveness and allows users to interact with the application while background tasks are in progress.
-- **Efficient Resource Utilization:** Enables handling multiple tasks concurrently.
+- Improved Performance: Prevents the program from freezing while waiting for long-running tasks.
+- Better User Experience: Maintains responsiveness and allows users to interact with the application while background tasks are in progress.
+- Efficient Resource Utilization: Enables handling multiple tasks concurrently.
 
 How
 
@@ -22,7 +22,7 @@ Example
 - The code can continue executing other tasks while waiting for the data to be retrieved.
 - Once the data is available, a callback function is called to process it.
 
-Important Note
+Note
 
 - Asynchronous programming can introduce complexities like callbacks, promises, or async/await. Careful handling is required to manage asynchronous code effectively.
 

README.md

@@ -126,59 +126,65 @@
    6. String Method
 
 8. Array
+
    1. Array Are Object
    2. Array Operation
    3. Array Destructure
    4. Array Iterate
    5. Array's method
       1. map()
 
-- Objects
-  - Object Iteration
-  - Object Computed Properties
-  - Object Destructure
-  - Object Cloning
-  - Optional Chaining
-
-1.  Object Oriented Programming
-
-    1.  Object
-    2.  Constructor Function
-    3.  `new` keyword
-    4.  What Is Oops?
-    5.  Class
-    6.  Constructor
-    7.  Class Method
-    8.  Factory Function
-    9.  Inheritance
+9. Objects
+
+   1. Object Iteration
+   2. Object Computed Properties
+   3. Object Destructure
+   4. Object Cloning
+   5. Optional Chaining
+
+10. Object Oriented Programming
+
+    1. Object
+    2. Constructor Function
+    3. `new` keyword
+    4. What Is Oops?
+    5. Class
+    6. Constructor
+    7. Class Method
+    8. Factory Function
+    9. Inheritance
     10. Encapsulation
     11. Abstraction
     12. Polymorphism
 
-1.  JavaScript Under the Hood
-
-    1.  Compiler
-    2.  Interpreter
-    3.  Compile Time
-    4.  Runtime
-
-1.  JavaScript Execution Context
-
-    1.  Context
-    2.  Execution Context
-        1.  Global Execution Context
-            1.  Memory Creation Phase
-            2.  Execution Phase
-        2.  Function Execution Context
-
-1.  Asynchronous JavaScript
-    1.  Asynchronous Operations
-    2.  setTimeout & setInterval
-    3.  Call back
-        1.  Call back function
-        2.  Call back hell
-    4.  Promise
-    5.  Fetch
+11. JavaScript Under the Hood
+
+    1. Compiler
+    2. Interpreter
+    3. Compile Time
+    4. Runtime
+    5. JavaScript Engine
+    6. JavaScript Environment
+    7. Just in time compilation (JIT)
+
+12. JavaScript Execution Context
+
+    1. Context
+    2. Execution Context
+       1. Global Execution Context
+          1. Memory Creation Phase
+          2. Execution Phase
+       2. Function Execution Context
+
+13. Asynchronous JavaScript
+    1. Asynchronous Operations
+    2. setTimeout & setInterval
+    3. Async and Await
+    4. Call back
+       1. Call back function
+       2. Call back hell
+    5. Promise
+    6. Fetch
 
 <!-- OOP -->
 

code_test_space.js

@@ -36,5 +36,5 @@ function mySecond() {
   console.log("Goodbye");
 }
 
-mySecond();
+mySecond(); 
 myFirst();

javascript_under_the_hood/javascript_engine.md

@@ -0,0 +1,25 @@
+# JavaScript Engine
+
+What
+
+- A JavaScript engine is a software component that executes JavaScript code. It's the core part of a JavaScript runtime environment.
+
+Why
+
+- Interprets JavaScript: Translates human-readable JavaScript code into machine-understandable instructions.
+- Optimizes performance: Employs techniques like Just-In-Time (JIT) compilation to improve execution speed.
+- Manages memory: Handles memory allocation and garbage collection.
+
+Example
+
+- V8: Used in Google Chrome and Node.js.
+- SpiderMonkey: Used in Mozilla Firefox.
+- JavaScriptCore: Used in Safari.
+
+Note
+
+- Modern JavaScript engines often use a combination of interpretation and compilation for optimal performance. They also include features like garbage collection to manage memory efficiently.
+
+Analogy
+
+- Think of a JavaScript engine as a translator that converts English (JavaScript) into a language the computer understands (machine code).

javascript_under_the_hood/javascript_environment.md

@@ -0,0 +1,31 @@
+# JavaScript Environment
+
+What
+
+- A JavaScript environment is the runtime context where JavaScript code executes. It provides the necessary tools and APIs for JavaScript to interact with the host environment (e.g., a web browser or server).
+
+Why
+
+- Provides APIs: Offers built-in functions and objects for interacting with the environment (e.g., DOM, network, file system).
+- Handles execution: Manages the call stack, heap, and event loop.
+- Creates a sandbox: Isolates JavaScript code from the underlying system for security.
+
+How
+- JavaScript Engine: The core component that interprets or compiles JavaScript code.
+- Web APIs: Provide access to browser features (DOM, BOM) or server-side functionalities.
+- Event Loop: Handles asynchronous operations and events.
+- Call Stack: Manages function calls and returns.
+- Heap: Stores objects and data.
+
+Example
+
+- Browser Environment: Provides DOM (Document Object Model) for manipulating HTML elements and BOM (Browser Object Model) for interacting with the browser window.
+- Node.js Environment: Offers modules for file system access, network communication, and server-side tasks.
+
+Note
+
+- Different environments provide different APIs and capabilities. Understanding the specific environment is crucial for effective JavaScript development.
+
+Analogy
+
+- Think of a JavaScript environment as a stage where a play (your JavaScript code) is performed. The stage provides the setting, props, and audience (APIs and runtime), while the actors (your code) interact with the environment to create the performance.