Merge branch 'main' into Dictionary-app

Author: ajay-dhangar

README.md

@@ -24,6 +24,10 @@ At CodeHarborHub, our mission is clear: to provide accessible and comprehensive
 - **Inspiring Showcases**: Explore inspiring showcases of real-world projects and innovative web solutions.
 - **Engaging Community**: Connect with a vibrant community of developers, share knowledge, and collaborate on projects.
 
+## Announcement:
+
+**New Project:** Loan Calculator! Check it out on [LinkedIn](https://www.linkedin.com/posts/ajay-dhangar_loan-calculator-activity-7221402171957768195-1WYs?utm_source=share&utm_medium=member_desktop) 🚀
+
 ## Discord Channel for GSSoC 2024 Contributors
 
 Now, resolve your all doubts and communicate with our all contributors.

blog/getting-started-with-serverless-architecture.md

@@ -0,0 +1,206 @@
+---
+title: 'Getting Started with Serverless Architecture Using AWS Lambda'
+sidebar_label: Serverless Architecture and AWS Lambda
+authors: [nayanika-mukherjee]
+tags: [serverless, AWS Lambda, cloud computing, Python, technology]
+date: 2024-07-22
+hide_table_of_contents: true
+---
+
+## Introduction
+
+Serverless architecture is a cloud computing execution model where the cloud provider dynamically manages the allocation and provisioning of servers. AWS Lambda, a key component of serverless architecture, allows you to run code without provisioning or managing servers. This guide will introduce you to AWS Lambda and provide a step-by-step approach to getting started with serverless architecture.
+
+## Key Concepts
+
+### What is AWS Lambda?
+
+AWS Lambda is a compute service that lets you run code in response to events and automatically manages the compute resources required by that code. You pay only for the compute time you consume.
+
+### Serverless Benefits
+
+- **No Server Management:** No need to provision or manage servers.
+- **Scalability:** Automatically scales your application by running code in response to each trigger.
+- **Cost Efficiency:** Pay only for the compute time you consume.
+
+### Event Sources
+
+Lambda can be triggered by various AWS services such as S3, DynamoDB, Kinesis, SNS, and more.
+
+## Setting Up AWS Lambda
+
+### Prerequisites
+
+- An AWS account.
+- AWS CLI installed and configured.
+- Basic knowledge of Python (or the language you choose for your Lambda functions).
+
+### Creating an IAM Role
+
+Before creating a Lambda function, you need an IAM role that Lambda assumes when it executes your function.
+
+```bash
+aws iam create-role --role-name lambda-execution-role --assume-role-policy-document file://trust-policy.json
+```
+`trust-policy.json`:
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "lambda.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole"
+    }
+  ]
+}
+```
+Attach the necessary policies to the role:
+```bash
+aws iam attach-role-policy --role-name lambda-execution-role --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+```
+
+## Writing and Deploying Lambda Functions
+
+### Basic Lambda Function
+Here is a simple Python function that returns a greeting.
+
+`lambda_function.py`:
+```python
+def lambda_handler(event, context):
+    return {
+        'statusCode': 200,
+        'body': 'Hello, World!'
+    }
+```
+
+### Creating and Deploying the Function
+- Create a ZIP file containing your code:
+```bash
+zip function.zip lambda_function.py
+```
+
+- Deploy the Lambda Function:
+```bash
+aws lambda create-function --function-name HelloWorldFunction \
+--zip-file fileb://function.zip --handler lambda_function.lambda_handler \
+--runtime python3.8 --role arn:aws:iam::123456789012:role/lambda-execution-role
+```
+
+## Lambda Execution Model
+
+Lambda functions have an execution model that includes:
+
+- Invocation: Functions can be invoked synchronously or asynchronously.
+- Concurrency: Lambda automatically scales to handle the incoming requests.
+- Execution Duration: You can configure the timeout for your function (default is 3 seconds, maximum is 15 minutes).
+
+## Managing Lambda Functions
+- Updating a Function
+To update the function code:
+```bash
+zip function.zip lambda_function.py
+aws lambda update-function-code --function-name HelloWorldFunction --zip-file fileb://function.zip
+```
+
+- Monitoring and Logging
+AWS Lambda integrates with Amazon CloudWatch to provide monitoring and logging. You can view logs by navigating to the CloudWatch Logs in the AWS Management Console.
+
+## Advanced Topics
+
+### Environment Variables
+You can use environment variables to pass configuration settings to your Lambda function.
+```bash
+aws lambda update-function-configuration --function-name HelloWorldFunction \
+--environment "Variables={ENV_VAR1=value1,ENV_VAR2=value2}"
+```
+### Layers
+Lambda layers allow you to package libraries and other dependencies separately from your function code.
+
+- Create a layer:
+```bash
+zip -r myLayer.zip python/
+aws lambda publish-layer-version --layer-name myLayer --zip-file fileb://myLayer.zip
+```
+### VPC Integration
+You can configure your Lambda function to access resources in a VPC.
+```bash
+aws lambda update-function-configuration --function-name HelloWorldFunction \
+--vpc-config SubnetIds=subnet-abc123,SecurityGroupIds=sg-abc123
+```
+
+## Performance and Scaling
+
+### Cold Starts
+A cold start occurs when a new instance of the function is invoked after being idle. To mitigate cold starts:
+
+- Optimize initialization code.
+- Use Provisioned Concurrency for predictable performance.
+
+### Concurrency Limits
+You can configure reserved concurrency to limit the number of concurrent executions:
+```bash
+aws lambda put-function-concurrency --function-name HelloWorldFunction --reserved-concurrent-executions 10
+```
+## Testing and Debugging
+
+### Local Testing
+Use the AWS SAM CLI to test Lambda functions locally:
+```bash
+sam local invoke HelloWorldFunction -e event.json
+```
+
+### Debugging
+Utilize CloudWatch Logs to debug issues by adding log statements in your code:
+```python
+import logging
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+def lambda_handler(event, context):
+    logger.info("Event: %s", event)
+    return {
+        'statusCode': 200,
+        'body': 'Hello, World!'
+    }
+```
+## Real-World Examples
+
+### S3 Event Trigger
+Trigger a Lambda function when an object is uploaded to an S3 bucket:
+```python
+import json
+
+def lambda_handler(event, context):
+    for record in event['Records']:
+        s3 = record['s3']
+        bucket = s3['bucket']['name']
+        key = s3['object']['key']
+        print(f'Received event. Bucket: {bucket}, Key: {key}')
+    return {
+        'statusCode': 200,
+        'body': json.dumps('Processed S3 event')
+    }
+```
+
+### DynamoDB Stream
+Process DynamoDB stream events:
+```python
+import json
+
+def lambda_handler(event, context):
+    for record in event['Records']:
+        if record['eventName'] == 'INSERT':
+            new_image = record['dynamodb']['NewImage']
+            print(f'New item added: {new_image}')
+    return {
+        'statusCode': 200,
+        'body': json.dumps('Processed DynamoDB stream event')
+    }
+```
+
+## Conclusion
+
+AWS Lambda provides a powerful and flexible way to build serverless applications. By understanding its key concepts, setting up your environment, and leveraging advanced features, you can build scalable and cost-efficient solutions. This guide serves as a starting point for your journey into serverless architecture using AWS Lambda.

courses/C++ /advance-Level/Advance-File-Handling/File-locking.md

@@ -0,0 +1,105 @@
+---
+id: lesson-1
+title: "Advanced File Handling in C++"
+sidebar_label: Advanced File Handling 
+sidebar_position: 1
+description: "Learn Advanced File Handling in C++"
+tags: [courses,Advance-level,Introduction]
+---   
+ 
+
+Advanced file handling techniques allow for better control, performance optimization, and handling of large files. Let's explore these techniques:
+
+### Flowchart
+
+```mermaid
+graph TD;
+    A[Start] --> B[File Locking Mechanisms];
+    B --> C[File I/O Performance Optimization];
+    C --> D[Handling Large Files];
+    D --> E[Working with Memory-Mapped Files];
+    E --> F[End];
+```
+
+#### 1. File Locking Mechanisms
+
+File locking prevents simultaneous access to a file, which can cause data corruption. It ensures that only one process can write to a file at a time.
+
+##### Example: File Locking with `fcntl`
+
+```cpp
+#include <iostream>
+#include <fcntl.h>
+#include <unistd.h>
+
+int main() {
+    int fd = open("example.txt", O_RDWR | O_CREAT, 0666);
+    if (fd == -1) {
+        std::cerr << "Failed to open file" << std::endl;
+        return 1;
+    }
+
+    struct flock lock;
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0; // Lock the whole file
+
+    if (fcntl(fd, F_SETLK, &lock) == -1) {
+        std::cerr << "Failed to lock file" << std::endl;
+        close(fd);
+        return 1;
+    }
+
+    std::cout << "File locked. Press Enter to unlock..." << std::endl;
+    std::cin.get();
+
+    lock.l_type = F_UNLCK;
+    if (fcntl(fd, F_SETLK, &lock) == -1) {
+        std::cerr << "Failed to unlock file" << std::endl;
+    }
+
+    close(fd);
+    return 0;
+}
+```
+
+#### 2. File I/O Performance Optimization
+
+Optimizing file I/O can significantly improve performance, especially when dealing with large files or high-frequency I/O operations.
+
+:::tip
+- **Buffering**: Use buffered I/O for efficient data handling.
+- **Asynchronous I/O**: Perform non-blocking I/O operations to avoid waiting for I/O completion.
+- **Memory Mapping**: Use memory-mapped files for direct memory access to file contents.
+:::
+
+#### 3. Handling Large Files
+
+Handling large files efficiently is crucial for applications that deal with massive datasets.
+
+##### Example: Reading Large Files in Chunks
+
+```cpp
+#include <iostream>
+#include <fstream>
+
+int main() {
+    std::ifstream file("largefile.txt", std::ios::in | std::ios::binary);
+    if (!file) {
+        std::cerr << "Failed to open file" << std::endl;
+        return 1;
+    }
+
+    const size_t bufferSize = 1024 * 1024; // 1 MB buffer
+    char buffer[bufferSize];
+
+    while (file.read(buffer, bufferSize) || file.gcount() > 0) {
+        // Process buffer contents
+        std::cout.write(buffer, file.gcount());
+    }
+
+    file.close();
+    return 0;
+}
+```

courses/C++ /advance-Level/Advance-File-Handling/_category_.json

@@ -0,0 +1,8 @@
+{
+    "label": "Advance File Handling",
+    "position": 5,
+    "link": {
+      "type": "generated-index",
+      "description": "Learn Advance File Handling."
+    }
+  }

courses/C++ /advance-Level/Advance-File-Handling/memory-mapped.md

@@ -0,0 +1,62 @@
+---
+id: lesson-2
+title: "Working with Memory-Mapped Files"
+sidebar_label: Working with Memory-Mapped Files
+sidebar_position: 2
+description: "Learn Working with Memory-Mapped Files"
+tags: [courses,Advance-level,Introduction]
+---   
+  
+
+Memory-mapped files allow for efficient file access by mapping a file's contents to memory. This technique is useful for large files and random access patterns.
+
+##### Example: Memory-Mapped File Access
+
+```cpp
+#include <iostream>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+int main() {
+    int fd = open("largefile.txt", O_RDONLY);
+    if (fd == -1) {
+        std::cerr << "Failed to open file" << std::endl;
+        return 1;
+    }
+
+    struct stat sb;
+    if (fstat(fd, &sb) == -1) {
+        std::cerr << "Failed to get file size" << std::endl;
+        close(fd);
+        return 1;
+    }
+
+    size_t fileSize = sb.st_size;
+    char *mapped = static_cast<char *>(mmap(NULL, fileSize, PROT_READ, MAP_PRIVATE, fd, 0));
+    if (mapped == MAP_FAILED) {
+        std::cerr << "Failed to map file" << std::endl;
+        close(fd);
+        return 1;
+    }
+
+    // Access the file content through the mapped memory
+    std::cout.write(mapped, fileSize);
+
+    if (munmap(mapped, fileSize) == -1) {
+        std::cerr << "Failed to unmap file" << std::endl;
+    }
+
+    close(fd);
+    return 0;
+}
+```
+:::tip
+- **File Locking**: Use file locking mechanisms to prevent concurrent write operations.
+- **Buffered I/O**: Implement buffering to reduce the number of I/O operations.
+- **Asynchronous I/O**: Utilize asynchronous I/O for non-blocking operations.
+- **Memory Mapping**: Use memory-mapped files for efficient access to large files.
+:::
+
+