Merge branch 'main' into issues

Author: Tanishashrivas

blog/authors.yml

@@ -64,3 +64,9 @@ santhosh-siddhardha:
   title: Software Engineer
   url: "https://github.com/Santhosh-Siddhardha"
   image_url: https://avatars.githubusercontent.com/u/103999924?v=4
+
+nayanika-mukherjee:
+  name: Nayanika Mukherjee
+  title: Full Stack Developer
+  url: "https://github.com/Nayanika1402"
+  image_url: https://avatars.githubusercontent.com/u/132455412?v=4

blog/automating-tasks-with-python.md

@@ -0,0 +1,119 @@
+---
+title: 'Automating Tasks with Python: Using the OS and Subprocess Modules'
+sidebar_label: Automating Tasks with Python
+authors: [nayanika-mukherjee]
+tags: [automation, Python, OS module, Subprocess module, technology]
+date: 2024-07-13
+hide_table_of_contents: true
+---
+
+## Introduction
+
+Automation is a powerful way to boost productivity and efficiency by minimizing manual intervention in repetitive tasks. Python, with its versatile libraries and modules, provides an excellent framework for task automation. This blog explores how to use Python's OS and Subprocess modules to automate various system-level tasks, including file and directory operations and executing system commands.
+
+## What is Task Automation?
+
+Task automation involves using software to perform tasks without human intervention. Python is a popular choice for automation due to its simplicity, readability, and extensive standard library. Common automation tasks include file management, data processing, and executing system commands. Automating these tasks can save time, reduce errors, and improve consistency.
+
+## Using the OS Module for File and Directory Operations
+
+The OS module in Python provides a way to interact with the operating system. It allows you to perform tasks such as creating, deleting, and modifying files and directories. Here are some key functions of the OS module:
+
+### File Operations
+
+- **Creating a File**: `os.open()` and `os.close()`
+- **Reading from a File**: `os.read()`
+- **Writing to a File**: `os.write()`
+- **Deleting a File**: `os.remove()`
+
+### Directory Operations
+
+- **Creating a Directory**: `os.mkdir()`
+- **Listing Directory Contents**: `os.listdir()`
+- **Changing the Current Directory**: `os.chdir()`
+- **Removing a Directory**: `os.rmdir()`
+
+### Example: Creating and Listing Directories
+
+```python
+import os
+
+# Create a new directory
+os.mkdir('new_directory')
+
+# Change the current directory
+os.chdir('new_directory')
+
+# List contents of the current directory
+print(os.listdir('.'))
+```
+
+## Running System Commands with the Subprocess Module
+
+The Subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This is particularly useful for running system commands and scripts from within a Python program.
+
+### Key Functions in the Subprocess Module
+
+- **subprocess.run()**: Run a command and wait for it to complete.
+- **subprocess.Popen()**: Execute a child program in a new process.
+
+### Example: Running a Simple Command
+
+```python
+import subprocess
+
+# Run a simple system command
+result = subprocess.run(['echo', 'Hello, World!'], capture_output=True, text=True)
+print(result.stdout)
+```
+
+### Example: Executing a Script
+
+```python
+import subprocess
+
+# Execute a Python script
+result = subprocess.run(['python', 'script.py'], capture_output=True, text=True)
+print(result.stdout)
+```
+
+## Combining OS and Subprocess Modules for Complex Tasks
+
+You can combine the functionalities of the OS and Subprocess modules to automate more complex workflows. For example, you might use the OS module to navigate the file system and the Subprocess module to execute a series of commands or scripts based on the files and directories found.
+
+### Example: Automating a Backup Process
+
+```python
+import os
+import subprocess
+import shutil
+
+# Create a backup directory
+backup_dir = 'backup'
+if not os.path.exists(backup_dir):
+    os.mkdir(backup_dir)
+
+# Copy files to the backup directory
+for file_name in os.listdir('.'):
+    if os.path.isfile(file_name):
+        shutil.copy(file_name, backup_dir)
+
+# Compress the backup directory using a system command
+subprocess.run(['zip', '-r', 'backup.zip', backup_dir])
+```
+
+## Conclusion
+
+Automating tasks with Python using the OS and Subprocess modules can significantly enhance productivity by reducing the need for manual intervention in repetitive tasks. Whether you're managing files and directories or running system commands, these modules provide powerful tools for developing efficient automation scripts. By leveraging Python's capabilities, you can streamline workflows, improve accuracy, and free up time for more critical tasks.
+
+With the foundational knowledge provided in this blog, you're well-equipped to start exploring and implementing your own task automation solutions using Python.
+
+## Additional Resources
+
+To further deepen your understanding of Python's automation capabilities, consider exploring the following resources:
+
+- [Python's OS Module Documentation](https://docs.python.org/3/library/os.html)
+- [Python's Subprocess Module Documentation](https://docs.python.org/3/library/subprocess.html)
+- [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/)
+
+By delving into these materials, you'll gain more insights and practical skills to enhance your automation projects.

blog/Introduction to Cryptography and Cyber security.md renamed to blog/introduction-to-cryptography-and-cyber-security.md

@@ -1,5 +1,5 @@
 ---
-title: 'Cryptography and Its Use in Cyber Security'
+title: "Cryptography and Its Use in Cyber Security"
 sidebar_label: Cryptography and Cyber Security
 authors: [pujan-sarkar]
 tags: [cryptography, cyber security, encryption, technology]
@@ -81,4 +81,3 @@ Zero-knowledge proofs enable one party to prove to another that a statement is t
 ## Conclusion
 
 Cryptography is a cornerstone of cyber security, providing the means to protect data and maintain privacy in an increasingly interconnected world. As technology advances and new threats emerge, the field of cryptography will continue to evolve, offering innovative solutions to ensure the security and integrity of our digital lives. By understanding and implementing cryptographic techniques, individuals and organizations can safeguard their information and build a secure future.
-

blog/Introduction to the Linux development and Cyber security renamed to blog/introduction-to-the-Linux-development-and-cyber-security.md

@@ -0,0 +1,85 @@
+---
+title: 'Introduction to WebAssembly: Enhancing Web Performance'
+sidebar_label: WebAssembly and Web Performance
+authors: [nayanika-mukherjee]
+tags: [webassembly, wasm, web performance, technology]
+date: 2024-07-21
+hide_table_of_contents: true
+---
+
+## Introduction
+
+WebAssembly (Wasm) is a binary instruction format that provides near-native performance for web applications. Designed as a portable compilation target for high-level languages like C, C++, and Rust, WebAssembly enables efficient execution of code on modern web browsers. This documentation introduces WebAssembly, its benefits, and how to get started with Wasm development.
+
+## What is WebAssembly (Wasm)?
+
+WebAssembly is a low-level, assembly-like language with a compact binary format that runs with near-native performance. It provides a new way to run code written in multiple languages on the web at near-native speed, allowing for powerful web applications.
+
+## Why Use WebAssembly?
+
+WebAssembly offers several advantages:
+
+- **Performance:** Wasm code executes at near-native speeds, making it ideal for performance-critical applications like games, simulations, and complex calculations.
+- **Portability:** Code compiled to Wasm can run on any modern web browser, providing a consistent execution environment across different platforms.
+- **Interoperability:** Wasm integrates seamlessly with JavaScript, enabling the use of existing web technologies and frameworks.
+- **Security:** Wasm operates in a safe, sandboxed execution environment, reducing the risk of security vulnerabilities.
+
+## How WebAssembly Works
+
+WebAssembly works by compiling high-level code into a binary format that can be executed by the browser's virtual machine. The process involves several steps:
+
+1. **Source Code:** Write your code in a high-level language like C, C++, or Rust.
+2. **Compilation:** Use a compiler to convert the source code into WebAssembly binary format (`.wasm` file).
+3. **Execution:** The browser's virtual machine executes the Wasm binary, providing near-native performance.
+
+## Setting Up Your Environment
+
+To start developing with WebAssembly, you'll need to set up your development environment. This includes installing the necessary tools and compilers.
+
+### Setting Up a Development Environment
+
+1. **Install Node.js:** Node.js is required for various Wasm development tools.
+2. **Install a Compiler:** Depending on your source language, install a suitable compiler. For C/C++, install Emscripten. For Rust, install the Rust toolchain.
+
+### Compiling to WebAssembly
+
+To compile your code to WebAssembly, follow these steps:
+
+1. **Write Your Code:** Write your application in C, C++, Rust, or another supported language.
+2. **Compile:** Use your compiler to generate the Wasm binary. For example, with Emscripten, use the following command:
+   ```bash
+   emcc your_code.c -o your_code.wasm
+   ```
+For Rust:
+```
+rustc --target wasm32-unknown-unknown -O your_code.rs
+```
+## Interfacing with JavaScript
+
+WebAssembly can interact with JavaScript, enabling you to call Wasm functions from JavaScript and vice versa. Use the JavaScript WebAssembly API to load and instantiate Wasm modules.
+
+## Debugging WebAssembly Code
+
+Debugging Wasm code involves using browser developer tools and other utilities:
+
+- Browser DevTools: Modern browsers provide debugging support for WebAssembly, including breakpoints, step execution, and variable inspection.
+- Source Maps: Generate source maps to map Wasm code back to the original source code for easier debugging.
+- Optimizing WebAssembly Performance
+
+To optimize Wasm performance:
+
+- Optimize Code: Write efficient, performance-oriented code in the source language.
+- Compiler Flags: Use compiler optimization flags to improve the performance of the generated Wasm binary.
+- Profiling: Use profiling tools to identify and address performance bottlenecks.
+
+## Case Studies and Real-World Examples
+
+Explore case studies and real-world examples of WebAssembly in action:
+
+- Gaming: High-performance games running in the browser.
+- Data Visualization: Complex data visualizations with real-time interactivity.
+- Scientific Simulations: Web-based simulations for scientific research and education.
+
+## Conclusion
+
+WebAssembly is a powerful technology that enhances web performance and expands the capabilities of web applications. By leveraging Wasm, developers can build high-performance, portable, and secure applications that run seamlessly across different browsers and platforms. This documentation provides a comprehensive guide to getting started with WebAssembly, covering essential concepts, tools, and best practices.

blog/introduction-to-web-assembly.md

@@ -0,0 +1,60 @@
+---
+id: lesson-1
+title: "Advanced Forms in Angular"
+sidebar_label: Advanced Forms
+sidebar_position: 1
+description: "Advanced Forms in Angular"
+tags: [courses,Advanced-level,Form,Introduction]
+---
+ 
+Angular's reactive forms provide powerful tools for creating complex form structures and handling user input efficiently. Here are some advanced concepts you can leverage in Angular forms.
+
+#### Dynamic Forms
+
+Dynamic forms allow you to create forms whose structure can change at runtime based on user actions or external data.
+
+1. **Creating Dynamic Forms**:
+   ```typescript
+   import { FormBuilder, FormGroup, FormArray } from '@angular/forms';
+   import { Component } from '@angular/core';
+
+   @Component({
+     selector: 'app-dynamic-form',
+     templateUrl: './dynamic-form.component.html',
+   })
+   export class DynamicFormComponent {
+     form: FormGroup;
+
+     constructor(private fb: FormBuilder) {
+       this.form = this.fb.group({
+         items: this.fb.array([])
+       });
+     }
+
+     get items(): FormArray {
+       return this.form.get('items') as FormArray;
+     }
+
+     addItem() {
+       const item = this.fb.control('');
+       this.items.push(item);
+     }
+
+     removeItem(index: number) {
+       this.items.removeAt(index);
+     }
+   }
+   ```
+
+2. **Dynamic Form Template**:
+   ```html
+   <form [formGroup]="form">
+     <div formArrayName="items">
+       <div *ngFor="let item of items.controls; let i = index">
+         <input [formControlName]="i" placeholder="Item"/>
+         <button (click)="removeItem(i)">Remove</button>
+       </div>
+     </div>
+     <button (click)="addItem()">Add Item</button>
+   </form>
+   ```

courses/Angular/Advance-level/Advanced-Forms/Dynamic.md

@@ -0,0 +1,55 @@
+---
+id: lesson-2
+title: "Custom Form Controls"
+sidebar_label: Form Controls
+sidebar_position: 2
+description: "Custom Form Controls"
+tags: [courses,Advanced-level,Form Controls,Introduction]
+---
+
+
+
+Creating custom form controls allows you to encapsulate complex form logic and UI in reusable components.
+
+1. **Creating a Custom Control**:
+   ```typescript
+   import { Component, forwardRef } from '@angular/core';
+   import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
+
+   @Component({
+     selector: 'app-custom-input',
+     template: `<input [(ngModel)]="value" (ngModelChange)="onChange($event)" />`,
+     providers: [
+       {
+         provide: NG_VALUE_ACCESSOR,
+         useExisting: forwardRef(() => CustomInputComponent),
+         multi: true
+       }
+     ]
+   })
+   export class CustomInputComponent implements ControlValueAccessor {
+     value: string;
+
+     onChange = (value: string) => {};
+     onTouched = () => {};
+
+     writeValue(value: string): void {
+       this.value = value;
+     }
+
+     registerOnChange(fn: any): void {
+       this.onChange = fn;
+     }
+
+     registerOnTouched(fn: any): void {
+       this.onTouched = fn;
+     }
+   }
+   ```
+
+2. **Using Custom Control in a Form**:
+   ```html
+   <form [formGroup]="form">
+     <app-custom-input formControlName="customField"></app-custom-input>
+   </form>
+   ```

courses/Angular/Advance-level/Advanced-Forms/Form-Control.md

@@ -0,0 +1,37 @@
+---
+id: lesson-3
+title: "Form Arrays"
+sidebar_label: Async
+sidebar_position: 3
+description: "Form Arrays"
+tags: [courses,Advanced-level,Form Arrays,Introduction]
+---
+ 
+
+Form arrays are used to manage an array of form controls or groups, allowing you to build complex forms.
+
+1. **Creating a Form Array**:
+   ```typescript
+   import { FormArray, FormGroup, FormBuilder } from '@angular/forms';
+
+   this.form = this.fb.group({
+     users: this.fb.array([
+       this.fb.group({ name: '', age: '' }),
+       this.fb.group({ name: '', age: '' })
+     ])
+   });
+   ```
+
+2. **Template for Form Array**:
+   ```html
+   <form [formGroup]="form">
+     <div formArrayName="users">
+       <div *ngFor="let user of form.get('users').controls; let i = index">
+         <div [formGroupName]="i">
+           <input formControlName="name" placeholder="Name"/>
+           <input formControlName="age" placeholder="Age"/>
+         </div>
+       </div>
+     </div>
+   </form>
+   ```