chore: add words (#76)

### Description
<!-- Please add PR description (don't leave blank) - example: This PR
[adds/removes/fixes/replaces] the [feature/bug/etc] -->

Adds more entries to the dictionary.

### Related Issue
<!-- Please prefix the issue number with Fixes/Resolves - example: Fixes
#123 or Resolves #123 -->

NA

### Screenshots/Screencasts
<!-- Please provide screenshots or video recording that demos your
changes (especially if it's a visual change) -->

NA

### Notes to Reviewer
<!-- Please state here if you added a new npm packages, or any extra
information that can help reviewer better review you changes -->

NA

Author: babblebey

src/content/dictionary/abstraction.mdx

@@ -0,0 +1,43 @@
+---
+layout: ../../layouts/word.astro
+title: "Abstraction"
+---
+Abstraction is a concept in programming that refers to the process of hiding complex implementation details and showing only the essential features of an object or system. It allows developers to work at a higher level of understanding without needing to know the intricate details of how things work internally. Abstraction is achieved through the use of abstract classes, interfaces, and other mechanisms that define a clear and simplified interface for interacting with a system or object.
+
+In software development, abstraction is used to manage complexity and improve code readability and maintainability. By abstracting away the unnecessary details, developers can focus on the essential aspects of a system or object, making it easier to understand and work with.
+
+**Example:**
+Consider a car. When you drive a car, you don't need to understand how the engine, transmission, and other components work in detail. Instead, you interact with the car through a simple interface, such as the steering wheel, pedals, and dashboard controls. This abstraction allows you to drive the car without needing to know the complexities of its internal mechanisms.
+
+**In JavaScript:**
+```javascript
+// Example of abstraction using classes
+class Shape {
+  constructor(color) {
+    this.color = color;
+  }
+
+  // Abstract method that must be implemented by subclasses
+  draw() {
+    throw new Error("Method 'draw' must be implemented.");
+  }
+}
+
+// Concrete subclass that implements the draw method
+class Circle extends Shape {
+  constructor(color, radius) {
+    super(color);
+    this.radius = radius;
+  }
+
+  draw() {
+    console.log(`Drawing a ${this.color} circle with radius ${this.radius}`);
+  }
+}
+
+// Usage
+let circle = new Circle("red", 10);
+circle.draw(); // Output: Drawing a red circle with radius 10
+```
+
+In this example, `Shape` is an abstract class that defines the interface for shapes. `Circle` is a concrete subclass of `Shape` that implements the `draw` method. The `draw` method is an abstraction that allows us to draw shapes without needing to know the details of how each shape is drawn.

src/content/dictionary/access-modifiers.mdx

@@ -0,0 +1,50 @@
+---
+layout: ../../layouts/word.astro
+title: "Access Modifiers"
+---
+Access modifiers are keywords in object-oriented programming languages that are used to control the visibility and accessibility of class members (variables and methods). They specify the level of access that other classes or code modules have to these members.
+
+Access modifiers help enforce encapsulation and data hiding, which are key principles of object-oriented programming. They determine whether a class member can be accessed from within the same class, from a subclass, from classes in the same package, or from classes in different packages.
+
+**Common Access Modifiers:**
+1. **Public:** Public members are accessible from any other class or code module. They have the least restrictive access level.
+2. **Private:** Private members are accessible only from within the same class. They are not visible to subclasses or classes in the same package.
+3. **Protected:** Protected members are accessible from within the same class, subclasses, and classes in the same package. They are not accessible from classes in different packages.
+4. **Default (Package-Private):** Default or package-private members are accessible only within the same package. They are not accessible from classes in different packages.
+
+**Example:**
+```java
+public class MyClass {
+    private int privateVar;
+    public int publicVar;
+    protected int protectedVar;
+    int defaultVar; // package-private
+    
+    private void privateMethod() {
+        // code here
+    }
+    
+    public void publicMethod() {
+        // code here
+    }
+    
+    protected void protectedMethod() {
+        // code here
+    }
+    
+    void defaultMethod() {
+        // code here
+    }
+}
+```
+
+In this example, `privateVar` and `privateMethod()` are only accessible within the `MyClass` class. `publicVar` and `publicMethod()` are accessible from any class. `protectedVar` and `protectedMethod()` are accessible within `MyClass`, its subclasses, and classes in the same package. `defaultVar` and `defaultMethod()` are accessible only within classes in the same package.
+
+**Benefits of Using Access Modifiers:**
+- **Encapsulation:** Access modifiers help enforce encapsulation by hiding implementation details and exposing only the necessary interface.
+- **Security:** By restricting access to certain class members, access modifiers help improve the security and integrity of the code.
+- **Code Readability:** Access modifiers make code more readable by clearly indicating the intended visibility and accessibility of class members.
+- **Maintainability:** Access modifiers help in maintaining and managing large codebases by controlling how classes interact with each other.
+
+**Use Cases:**
+Access modifiers are used in object-oriented programming languages such as Java, C++, C#, and others to control the visibility and accessibility of class members. They are essential for creating well-structured and maintainable code.

src/content/dictionary/accessibility.mdx

@@ -0,0 +1,36 @@
+---
+layout: ../../layouts/word.astro
+title: "Accessibility (A11Y)"
+---
+Accessibility (A11Y) in web development refers to the practice of designing and developing websites and applications that can be used by people of all abilities and disabilities. This includes designing for people with visual, auditory, motor, and cognitive disabilities, as well as those with temporary disabilities or situational limitations.
+
+Accessibility aims to ensure that all users can perceive, understand, navigate, and interact with websites and applications, regardless of their abilities. This involves following standards and guidelines, such as the Web Content Accessibility Guidelines (WCAG), which provide recommendations for making web content more accessible.
+
+**Examples of Accessibility Features:**
+- **Text Alternatives:** Providing alternative text for images and non-text content to assist screen readers.
+- **Keyboard Accessibility:** Ensuring that all functionality can be operated using a keyboard.
+- **Color Contrast:** Using sufficient color contrast to make content readable for users with low vision.
+- **Descriptive Links:** Using descriptive text for hyperlinks to provide context for screen reader users.
+- **Accessible Forms:** Using labels, placeholders, and error messages to help users understand and complete forms.
+
+**Importance of Accessibility:**
+- **Inclusivity:** Accessibility ensures that everyone, including people with disabilities, can access and use the web.
+- **Legal Compliance:** Many countries have laws and regulations that require websites to be accessible to people with disabilities.
+- **User Experience:** Improving accessibility often leads to a better user experience for all users, not just those with disabilities.
+- **SEO Benefits:** Following accessibility best practices can improve search engine optimization (SEO) and make your website more discoverable.
+
+**In JavaScript:**
+```javascript
+// Example: Adding keyboard accessibility to a button
+const button = document.getElementById('myButton');
+
+button.addEventListener('keydown', function(event) {
+  if (event.key === 'Enter' || event.key === 'Space') {
+    event.preventDefault();
+    // Perform button action
+    console.log('Button clicked');
+  }
+});
+```
+
+In this example, the button can be activated using the keyboard by pressing Enter or Space, in addition to being clickable with a mouse. This enhances the accessibility of the button for users who cannot use a mouse.

src/content/dictionary/ai.mdx

@@ -0,0 +1,13 @@
+---
+layout: ../../layouts/word.astro
+title: "Artificial Intelligence (AI)"
+---
+Artificial Intelligence (AI) is the field of computer science focused on creating systems capable of performing tasks that typically require human intelligence. These tasks include learning, reasoning, problem-solving, perception, understanding natural language, and even exhibiting creativity.
+
+AI encompasses a range of technologies and approaches aimed at mimicking cognitive functions. There are various branches of AI, including:
+
+- **Machine Learning (ML):** A subset of AI that enables systems to learn from data and improve their performance over time without being explicitly programmed.
+- **Natural Language Processing (NLP):** The ability of machines to understand and generate human language.
+- **Computer Vision:** The ability of machines to interpret and make decisions based on visual inputs from the world.
+- **Robotics:** The branch of AI focused on designing and operating robots that can perform physical tasks autonomously.
+- **Expert Systems:** AI systems that mimic the decision-making abilities of a human expert in specific domains.

src/content/dictionary/ajax.mdx

@@ -0,0 +1,84 @@
+---
+layout: ../../layouts/word.astro
+title: "AJAX (Asynchronous JavaScript and XML)"
+---
+Asynchronous JavaScript and XML (AJAX) is a technique for creating fast and dynamic web pages. It allows web pages to be updated asynchronously by exchanging small amounts of data with the server behind the scenes. This means that parts of a web page can be updated without reloading the entire page. Despite its name, AJAX can use various formats, including JSON, HTML, and plain text, not just XML.
+
+**Examples:**
+
+**JavaScript:**
+
+1. **Using XMLHttpRequest:**
+   ```javascript
+   // Create a new XMLHttpRequest object
+   let xhr = new XMLHttpRequest();
+
+   // Configure it: GET-request for the URL /article/.../load
+   xhr.open('GET', '/article/.../load', true);
+
+   // Send the request over the network
+   xhr.send();
+
+   // This will be called after the response is received
+   xhr.onload = function() {
+     if (xhr.status != 200) { // analyze HTTP response status
+       alert(`Error ${xhr.status}: ${xhr.statusText}`); // e.g. 404: Not Found
+     } else { // show the result
+       alert(`Done, got ${xhr.response.length} bytes`); // response is the server
+     }
+   };
+
+   xhr.onerror = function() {
+     alert("Request failed");
+   };
+   ```
+
+2. **Using Fetch API:**
+   ```javascript
+   // Perform a GET request
+   fetch('/article/.../load')
+     .then(response => {
+       if (!response.ok) {
+         throw new Error('Network response was not ok ' + response.statusText);
+       }
+       return response.json();
+     })
+     .then(data => {
+       console.log(data); // Process the data received from the server
+     })
+     .catch(error => {
+       console.error('There has been a problem with your fetch operation:', error);
+     });
+   ```
+
+3. **Sending Data with Fetch:**
+   ```javascript
+   // Data to be sent to the server
+   let userData = {
+     name: 'John Doe',
+     age: 30
+   };
+
+   // Perform a POST request
+   fetch('/submit', {
+     method: 'POST',
+     headers: {
+       'Content-Type': 'application/json'
+     },
+     body: JSON.stringify(userData)
+   })
+     .then(response => {
+       if (!response.ok) {
+         throw new Error('Network response was not ok ' + response.statusText);
+       }
+       return response.json();
+     })
+     .then(data => {
+       console.log(data); // Process the response from the server
+     })
+     .catch(error => {
+       console.error('There has been a problem with your fetch operation:', error);
+     });
+   ```
+
+AJAX is widely used for creating interactive and dynamic web applications, allowing for a smoother and more responsive user experience by enabling parts of a page to update without requiring a full page reload.

src/content/dictionary/api.mdx

@@ -0,0 +1,69 @@
+---
+layout: ../../layouts/word.astro
+title: "API (Application Programming Interface)"
+---
+An API, or Application Programming Interface, is a set of rules and definitions that allows different software applications to communicate with each other. APIs define the methods and data formats that applications can use to request and exchange information. They can be used for web services, libraries, operating systems, and more, providing a way for developers to interact with and use the functionalities of other software components or services.
+
+**Examples:**
+
+**JavaScript:**
+
+1. **Using a Web API with Fetch:**
+   ```javascript
+   // Example: Fetching data from a public API
+
+   // URL of the API endpoint
+   let apiUrl = 'https://api.example.com/data';
+
+   // Perform a GET request
+   fetch(apiUrl)
+     .then(response => {
+       if (!response.ok) {
+         throw new Error('Network response was not ok ' + response.statusText);
+       }
+       return response.json();
+     })
+     .then(data => {
+       console.log(data); // Process the data received from the API
+     })
+     .catch(error => {
+       console.error('There has been a problem with your fetch operation:', error);
+     });
+   ```
+
+2. **Using an API to Send Data:**
+   ```javascript
+   // Example: Sending data to a server API
+
+   // URL of the API endpoint
+   let apiUrl = 'https://api.example.com/submit';
+
+   // Data to be sent to the API
+   let payload = {
+     name: 'Jane Doe',
+     email: 'jane.doe@example.com'
+   };
+
+   // Perform a POST request
+   fetch(apiUrl, {
+     method: 'POST',
+     headers: {
+       'Content-Type': 'application/json'
+     },
+     body: JSON.stringify(payload)
+   })
+     .then(response => {
+       if (!response.ok) {
+         throw new Error('Network response was not ok ' + response.statusText);
+       }
+       return response.json();
+     })
+     .then(data => {
+       console.log(data); // Process the response from the API
+     })
+     .catch(error => {
+       console.error('There has been a problem with your fetch operation:', error);
+     });
+   ```
+
+APIs are essential for modern software development, enabling interoperability between different systems and allowing developers to build on existing technologies without needing to understand their internal workings. They are foundational for web development, cloud computing, mobile apps, and many other areas of technology.

src/content/dictionary/argument.mdx

@@ -0,0 +1,21 @@
+---
+layout: ../../layouts/word.astro
+title: "Argument"
+---
+In programming, an argument is a value that is passed to a function or method when it is called. Arguments are used to provide the function with the data it needs to perform its task. Functions can accept zero or more arguments, depending on their definition.
+
+When a function is called, the values of its arguments are copied into the function's parameters. The function can then use these values to perform calculations, make decisions, or return a result. Arguments can be of any data type, including numbers, strings, arrays, objects, or even other functions.
+
+**Examples:**
+```javascript
+// Function that takes two arguments and returns their sum
+function addNumbers(a, b) {
+  return a + b;
+}
+
+// Calling the function with arguments 5 and 10
+let result = addNumbers(5, 10);
+console.log(result); // Output: 15
+```
+
+In this example, the `addNumbers` function takes two arguments, `a` and `b`, and returns their sum. When the function is called with the arguments `5` and `10`, it returns `15`, which is then assigned to the `result` variable.

src/content/dictionary/aria.mdx

@@ -0,0 +1,21 @@
+---
+layout: ../../layouts/word.astro
+title: "ARIA"
+---
+ARIA, which stands for Accessible Rich Internet Applications, is a set of attributes that can be added to HTML elements to improve the accessibility of web content for users with disabilities. ARIA attributes provide additional information to assistive technologies, such as screen readers, in interpreting and presenting web content more effectively to users.
+
+ARIA is particularly useful for making dynamic web applications, such as those built with JavaScript frameworks like React or Angular, more accessible. It provides a way to enhance the semantics of web content beyond what is possible with standard HTML elements, making it easier for assistive technologies to understand and interact with complex web applications.
+
+**Examples:**
+- **aria-label:** Specifies a text label for an element that is not visible on the screen, such as an icon or image button.
+- **aria-describedby:** Identifies another element (or elements) on the page that provides a description or additional information about the current element.
+- **aria-hidden:** Indicates whether an element should be visible or hidden to assistive technologies.
+- **aria-live:** Indicates that an element should be treated as live content and updates to it should be announced to the user.
+
+**Use Case:**
+```html
+<!-- Example: Adding aria-label to a button -->
+<button aria-label="Close">X</button>
+```
+
+In this example, the `aria-label` attribute provides a text label ("Close") for a button that contains only an "X" icon. This label is important for users who rely on screen readers, as it allows them to understand the purpose of the button without relying on visual cues.

src/content/dictionary/array.mdx

@@ -0,0 +1,32 @@
+---
+layout: ../../layouts/word.astro
+title: "Array"
+---
+An array is a data structure that stores a collection of elements, where each element is identified by an index. Arrays are commonly used in programming to organize and manipulate collections of data. They can hold elements of the same type or of different types, depending on the programming language.
+
+Arrays provide a way to store multiple values in a single variable, making it easier to work with lists of data. Elements in an array are accessed by their index, which represents their position in the array. Arrays can be of fixed size (static array) or resizable (dynamic array), depending on the language and implementation.
+
+**Examples:**
+```javascript
+// Creating an array of numbers
+let numbers = [1, 2, 3, 4, 5];
+
+// Accessing elements in the array
+console.log(numbers[0]); // Output: 1
+console.log(numbers[2]); // Output: 3
+
+// Modifying elements in the array
+numbers[1] = 10;
+console.log(numbers);    // Output: [1, 10, 3, 4, 5]
+
+// Adding elements to the array
+numbers.push(6);
+console.log(numbers);    // Output: [1, 10, 3, 4, 5, 6]
+
+// Removing elements from the array
+let removed = numbers.pop();
+console.log(removed);    // Output: 6
+console.log(numbers);    // Output: [1, 10, 3, 4, 5]
+```
+
+Arrays are a fundamental concept in programming and are used in many different applications. They provide a flexible and efficient way to store and manipulate collections of data.