wording fixes and linking refrences

sumn2u · sumn2u · commit ef6993094bce · 2024-06-27T11:14:00.000-05:00
diff --git a/en/browser-object-model-bom/README.md b/en/browser-object-model-bom/README.md
@@ -18,7 +18,16 @@ window.alert("Welcome to Learn JavaScript");
 alert("Welcome to Learn JavaScript")
 ```
 
-In a similar fashion, we can call other properties underneath the window object such as history, screen, navigator, location, and so on.
+In this chapter, we are going to talk about various properties and methods of browser object model.
+* [cookies](./cookies.md)
+* [history](./history.md)
+* [location](./location.md)
+* [navigator](./navigator.md)
+* [popup](./popup.md)
+* [screen](./screen.md)
+* [window](./window.md)
+
+
 
 
 
diff --git a/en/date-and-time.md b/en/date-and-time.md
@@ -8,7 +8,7 @@ description: The date object stores date and time and provides methods for manag
 # Chapter 10
 # Date and Time
 
-The `date` object stores date and time and provides methods for managing it. Date objects are static and use a browser's default timezone to display the date as a full-text string.
+The `date` object stores date and time and provides methods for managing it. `Date` objects are static and use a browser's default timezone to display the date as a full-text string.
 
 To create  `date` we use a `new Date()` constructor and can be created in the following ways.
 
diff --git a/en/es6-concepts/template-literals.md b/en/es6-concepts/template-literals.md
@@ -16,7 +16,7 @@ const dynamicString = `This is a dynamic string with ${expression}`;
 
 - `dynamicString`: This is where you store the dynamic string.
 
-- `${expression}`: This is where you embed JavaScript expressions, variables, or functions, which are evaluated and included within the string.
+- `${expression}`: This is where you embed JavaScript expressions, [variables](../basics/variables.md), or [functions](../functions/README.md), which are evaluated and included within the string.
 
 **Example:**
 
diff --git a/en/miscellaneous/api-ajax.md b/en/miscellaneous/api-ajax.md
@@ -11,7 +11,7 @@ In this section, we will discuss API and AJAX, the two important technologies th
 
 An **API** (Application Programming Interface) is a set of rules and protocols that allows different software applications to communicate with each other. It defines the methods and data formats that applications can use to request and exchange information.
 
-## Key Points
+### Key Points
 
 - APIs enable developers to access the functionality of other software components, services, or platforms without needing to understand their internal workings.
 
@@ -25,7 +25,7 @@ An **API** (Application Programming Interface) is a set of rules and protocols t
 
 - Examples of popular APIs include social media APIs (e.g., Facebook Graph API), payment gateway APIs (e.g., PayPal API), and cloud service APIs (e.g., AWS API).
 
-## Benefits of APIs
+### Benefits of APIs
 
 - **Interoperability:** APIs allow different software systems to work together, promoting compatibility and data exchange.
 
@@ -37,15 +37,15 @@ An **API** (Application Programming Interface) is a set of rules and protocols t
 
 - **Security:** APIs often include authentication and authorization mechanisms to ensure secure access to data and services.
 
-# AJAX (Asynchronous JavaScript and XML)
+## AJAX (Asynchronous JavaScript and XML)
 
 AJAX, short for **Asynchronous JavaScript and XML**, is a foundational technology in web development. It enables web applications to make asynchronous requests to a server, retrieve data, and update parts of a web page without requiring a full page reload. While the name suggests XML, AJAX can work with various data formats, with JSON being the most common.
 
-## What is AJAX?
+### What is AJAX?
 
 At its core, AJAX is a technique that allows web pages to communicate with a server in the background, without disrupting the user's interaction with the page. This asynchronous behavior is achieved using JavaScript and enables the development of more interactive and responsive web applications.
 
-## How does AJAX work?
+### How does AJAX work?
 
 1. **JavaScript**: AJAX heavily relies on JavaScript to initiate requests and handle responses asynchronously.
 
@@ -59,7 +59,7 @@ At its core, AJAX is a technique that allows web pages to communicate with a ser
 
 6. **Rendering**: The updated content is rendered on the web page without requiring a full page reload, resulting in a smoother user experience.
 
-## Benefits of AJAX
+### Benefits of AJAX
 
 - **Improved User Experience**: AJAX allows web applications to load and display data without the need for full page refreshes, making the user experience more seamless and interactive.
 
@@ -69,7 +69,7 @@ At its core, AJAX is a technique that allows web pages to communicate with a ser
 
 - **Dynamic Loading**: Content can be loaded on-demand, leading to faster initial page load times and more responsive applications.
 
-## Common Use Cases
+### Common Use Cases
 
 Some common scenarios where AJAX is used include:
 
@@ -81,26 +81,26 @@ Some common scenarios where AJAX is used include:
 
 - **Updating Content**: Dynamically updating content like news feeds, weather information, or sports scores without requiring manual page refreshes.
 
-# Fetching Weather Data with OpenWeatherMap API using AJAX
+## Fetching Weather Data with OpenWeatherMap API using AJAX
 
 In this example, we'll demonstrate how to use AJAX (Asynchronous JavaScript and XML) to fetch weather information from the OpenWeatherMap API and display it on a web page.
 
-## Introduction
+### Introduction
 
 The OpenWeatherMap API is a powerful tool for retrieving weather information for locations around the world. This example demonstrates how to use the API to fetch current weather data for a specific city and display it in your application or documentation.
 
-## API Key
+### API Key
 
 Before getting started, you need to sign up for an API key from [OpenWeatherMap](https://openweathermap.org/api) to access their weather data API. Replace `'YOUR_API_KEY'` in the code below with your actual API key.
 
 ```javascript
 const apiKey = 'YOUR_API_KEY';
 ```
-# Simple Weather App HTML
+### Simple Weather App HTML
 
 In this example, we'll provide the HTML structure for a simple weather app that fetches and displays weather data from the OpenWeatherMap API.
 
-## HTML Structure
+#### HTML Structure
 
 ```html
 <!DOCTYPE html>
@@ -121,7 +121,7 @@ In this example, we'll provide the HTML structure for a simple weather app that
 </html>
 ```
 
-## JavaScript (script.js)
+#### JavaScript (script.js)
 
 Create a JavaScript file named `script.js` to handle the AJAX request and update the weather data on the page:
 
@@ -155,7 +155,7 @@ xhr.onload = function () {
 
 xhr.send();
 ```
-## Result
+### Result
 
 When you open the HTML file in a web browser, it will display the weather information for the specified location (New York in this case). Make sure to replace `'YOUR_API_KEY'` with your actual OpenWeatherMap API key.
 
diff --git a/en/miscellaneous/callback.md b/en/miscellaneous/callback.md
@@ -8,19 +8,19 @@ description: A callback is a function passed as an argument to another function,
 
 Callback functions are a fundamental concept in JavaScript, enabling asynchronous and event-driven programming. This Markdown document provides an in-depth explanation of callback functions, their purpose, and how to use them effectively.
 
-## What is a Callback Function?
+### What is a Callback Function?
 
 - A **callback function** is a JavaScript function that is passed as an argument to another function.
 - It is typically invoked or executed at a later time, often after some asynchronous operation or event.
 - Callbacks are essential for handling tasks like data retrieval, event handling, and dealing with asynchronous behavior.
 
-## Why Use Callback Functions?
+### Why Use Callback Functions?
 
 - **Asynchronous Operations**: Callbacks are crucial for managing asynchronous operations like file reading, API requests, and timers.
 - **Event Handling**: They are used to respond to events like button clicks, user input, or network responses.
 - **Modular Code**: Callbacks help write modular and reusable code by separating concerns and promoting the single-responsibility principle.
 
-## Anatomy of a Callback Function
+### Anatomy of a Callback Function
 
 A typical callback function has the following structure:
 
@@ -36,29 +36,29 @@ function callbackFunction(arg1, arg2, ..., callback) {
 - **callbackFunction** is the function that takes a callback as an argument.It may perform some operations asynchronously.
 - It eventually calls the **callback** function, passing it a result or an error.
 
-## Handling Errors in Callbacks
+### Handling Errors in Callbacks
 
 In JavaScript, callback functions can handle errors by convention. It's common to pass an error object as the first argument or use the second argument to represent errors. Developers should check for errors and handle them appropriately within the callback function.
 
-## Alternative Approaches to Callbacks
+### Alternative Approaches to Callbacks
 
 1. **Promises**: Promises offer a structured way to handle asynchronous code and errors. They have three states: pending, fulfilled, and rejected. Promises use the `.then()` and `.catch()` methods to handle success and error scenarios.
 
 2. **Async/Await**: Async/await is a more recent addition to JavaScript. It simplifies asynchronous code by allowing developers to write it in a more synchronous style. It's built on top of Promises and is especially useful for handling asynchronous operations with a more linear code flow.
 
 3. **Event Emitters**: In Node.js, the `EventEmitter` class allows you to create custom event-driven architectures for handling asynchronous tasks.
 
-# Callback Hell (Callback Pyramid) and Example
+## Callback Hell (Callback Pyramid)
 
 Callback hell, also known as the "pyramid of doom," is a common issue in JavaScript when working with deeply nested callback functions. This phenomenon occurs when multiple asynchronous operations are chained one after the other, making the code difficult to read and maintain. This Markdown document explains callback hell and provides a simple example.
 
-## What is Callback Hell?
+### What is Callback Hell?
 
 - **Callback hell** occurs when asynchronous functions are nested within each other, leading to deeply indented code structures.
 - It makes code harder to understand, debug, and maintain due to excessive indentation levels.
 - Callback hell often results from handling multiple asynchronous operations sequentially, such as making API requests or reading/writing files.
 
-## Example of Callback Hell
+#### Example
 
 ```javascript
 asyncOperation1(function (result1) {
@@ -78,29 +78,29 @@ asyncOperation1(function (result1) {
     });
 });
 ```
-## Problems with Callback Hell
+### Problems with Callback Hell
 
 - **Readability**: Callback hell leads to deeply indented code, making it challenging to read and understand. This can hinder code reviews and collaboration.
 
 - **Maintainability**: As more asynchronous operations are added, callback hell makes the codebase difficult to maintain. Modifying existing functionality or adding new features becomes error-prone.
 
 - **Error Handling**: Managing errors becomes complex in nested callbacks. Handling exceptions and propagating errors to higher levels can be challenging.
 
-## Mitigating Callback Hell
+### Mitigating Callback Hell
 
-### 1. Named Functions
+#### 1. Named Functions
 
 - Break down callback functions into separate, named functions. This improves code readability by giving meaningful names to individual functions.
 
-### 2. Promises
+#### 2. Promises
 
 - Promises provide a more structured way to handle asynchronous code. They allow you to chain asynchronous operations, making the code more linear and easier to read.
 
-### 3. Async/Await
+#### 3. Async/Await
 
 - Async/await is a more recent addition to JavaScript. It simplifies asynchronous code by allowing you to write it in a more synchronous style. It is built on top of Promises and is especially useful for handling asynchronous operations with a more linear code flow.
 
-### 4. Modularization
+#### 4. Modularization
 
 - Organize code into smaller, reusable modules. This reduces the complexity of individual functions and makes it easier to manage asynchronous operations.
 
diff --git a/en/miscellaneous/debugging.md b/en/miscellaneous/debugging.md
@@ -5,7 +5,7 @@ description: In programming, errors can occur while writing code. It could be du
 ---
 # Debugging
 
-In programming, errors can occur while writing code. It could be due to syntactical or logical errors. The process of finding errors can be time-consuming and tricky and is called *code debugging*.
+In programming, errors can occur while writing code. It could be due to syntactical or logical errors. The process of finding errors can be time-consuming and tricky and is called **code debugging**.
 
 Fortunately, most modern browsers come with built-in debuggers. These debuggers can be switched on and off, forcing errors to be reported. It is also possible to set up breakpoints during the execution of code to stop execution and examine variables. For this one has to open a debugging window and place the `debugger` keyword in the JavaScript code. The code execution is stopped in each breakpoint, allowing developers to examine the JavaScript values and, resume the execution of code.
 
diff --git a/en/miscellaneous/hoisting.md b/en/miscellaneous/hoisting.md
@@ -5,7 +5,7 @@ description: Hosting is a default behavior in JavaScript of moving declarations
 ---
 # Hoisting
 
-Hosting is a default behavior in JavaScript of moving declarations at the top.  While executing a code, it creates a global execution context:  creation and execution.  In the creation phase, JavaScript moves the variable and function declaration to the top of the page, which is known as hoisting.&#x20;
+Hosting is a default behavior in JavaScript of moving declarations at the top.  While executing a code, it creates a global execution context:  **creation** and **execution**.  In the creation phase, JavaScript moves the variable and function declaration to the top of the page, which is known as hoisting.&#x20;
 
 ```javascript
 // variable hoisting
diff --git a/en/miscellaneous/linked-list.md b/en/miscellaneous/linked-list.md
@@ -21,7 +21,7 @@ There are three different types of linked lists:
 2. **Doubly Linked Lists:**  There are two pointers at each node, one to the next node and one to the previous node.
 3. **Circular Linked Lists:**  A circular linked list forms a loop by having the last node pointing to the first node or any other node before it.
 
-# Add
+## Add
 
 The `add` method is created here to add value to a linked list.
 
@@ -52,7 +52,7 @@ class LinkedList {
 }
 ```
 
-# Pop
+## Pop
 
 Here, a `pop` method is created to remove a value from the linked list.
 
@@ -78,7 +78,7 @@ class LinkedList {
 }
 ```
 
-# Prepend
+## Prepend
 
 Here, a `prepend` method is created to add a value before the first child of the linked list.
 
@@ -107,7 +107,7 @@ class LinkedList {
 }
 ```
 
-# Shift
+## Shift
 
 Here, the `shift` method is created to remove the first element of the Linked List.
 
diff --git a/en/miscellaneous/single-thread-nature.md b/en/miscellaneous/single-thread-nature.md
@@ -24,7 +24,7 @@ Here are some key points to understand about JavaScript's single-threaded execut
 
 6. **Browser and Environment Interaction:** In web development, JavaScript interacts with the browser's Document Object Model (DOM) and other browser APIs. To maintain a responsive user interface, JavaScript code must execute quickly and efficiently and delegate time-consuming operations to separate threads when necessary.
 
-## Single-Threaded Asynchronous Example
+## Example
 
 ```javascript
 // Simulating an asynchronous operation with a callback
diff --git a/en/modules.md b/en/modules.md
@@ -14,7 +14,7 @@ _Modules_ come to avoid these problems. A `module` specifies which pieces of cod
 
 * **AMD** - one of the oldest module systems, initially used by [require.js](https://requirejs.org/).
 * **CommonJS** - module system created for Node.js server.
-* **UMD** - module system that is compatible with AMD and CommonJS.
+* **UMD** - module system that is compatible with [AMD](https://requirejs.org/docs/whyamd.html#amd) and [CommonJS](https://requirejs.org/docs/whyamd.html#commonjs).
 
 Modules can load each other, and use special directives `import` and `export` to interchange functionality, and call functions of each other.
 
diff --git a/en/objects/README.md b/en/objects/README.md
@@ -25,10 +25,10 @@ In javascript the objects are **mutable** because we change the values pointed b
     ```
 
     > _**Note:**_ it's almost like Java.
-3.  **and using `object.create`**
+3.  **using `object.create`**
 
     ```javascript
     let object = Object.create(proto[, propertiesObject]);
     ```
 
-    > _**Note:**_ it creates a new object with the specified prototype object and properties.
+    > _**Note:**_ It creates a new object with the specified prototype object and properties.
diff --git a/en/objects/prototype.md b/en/objects/prototype.md
@@ -15,14 +15,14 @@ let adult = { age: 26 },
 // The line above
 ```
 
-First, the interpreter looks through every property the object itself has. For example, `adult` has only one own property — `age`. But besides that one, it actually has a few more properties, which were inherited from `Object.prototype.`
+First, the interpreter looks through every property the object itself has. For example, `adult` has only one own property—`age`. However, it also has several properties inherited from `Object.prototype`.
 
 ```javascript
 let stringRepresentation = adult.toString();
 // the variable has value of '[object Object]'
 ```
 
-The `toString` is an Object.prototype's property, which was inherited. It has a value of a function, which returns a string representation of the object. If you want it to return a more meaningful representation, then you can override it. Simply add a new property to the adult object.
+The `toString` is an `Object.prototype`'s property, which was inherited. It has a value of a function, which returns a string representation of the object. If you want it to return a more meaningful representation, then you can override it. Simply add a new property to the adult object.
 
 ```javascript
 adult.toString = function () {
