• Function-level granularity: You can deploy and manage functions independently, without having to package them into larger applications.
• Event-driven: FaaS functions are triggered by events, such as HTTP requests, API calls, or messages from other services.
• Automatic scaling: The platform automatically adjusts the number of instances based on demand, ensuring optimal performance and cost-efficiency.
• Pay-per-use: You only pay for the resources consumed by your functions, rather than paying for a fixed server capacity.

• Pay-per-use: You only pay for the resources consumed by your application, rather than paying for a fixed server capacity.
• Automatic scaling: The platform automatically adjusts the number of instances based on demand, ensuring optimal performance and cost-efficiency.
• Event-driven: Serverless functions are typically triggered by events, such as HTTP requests, API calls, or messages from other services.
• Managed infrastructure: The platform handles all the underlying infrastructure, including servers, networking, and security.

def add_items(n):
    return n + n + n
 
print add_items(10)

The O(N^2) time complexity means that the running time of an algorithm grows quadratically with the size of the input. It often involves nested loops, where each element in the input is compared with every other element.

def print_items(n):
    for i in range(n):
        for j in range(n):
            print(i,j) 

print_items(10)

def print_items(n):
    for i in range(n):
        for j in range(n):
            print(i,j)
    
    for k in range(n):
        print(k)

print_items(10)

def print_items(n):
    for i in range(n):
        print(i)

print_items(10)

• Best-Case Time Complexity: The minimum amount of time required by an algorithm to run, based on the given most suitable input is known as best-case complexity.
• Average Case Complexity: The average amount of time required by an algorithm to run, taking into consideration all the possible inputs is known as average-case complexity.
• Worst Case Complexity: The maximum amount of time required by an algorithm to run, taking into consideration possible worst case is known as worst-case complexity.

brew install redis

brew services start redis

redis-cli ping

// Custom Hook
const useProducts = () => {
  const [products, setProducts] = useState([]);

  useEffect(() => {
    fetch("/api/products")
      .then((res) => res.json())
      .then((data) => setProducts(data));
  }, []);

  return products;
};

// Container Component
function ProductContainer() {
  const products = useProducts();

  return <ProductList products={products} />;
}

// Presentational Component
function ProductList({ products }) {
  return (
    <ul>
      {products.map((product) => (
        <li key={product.id}>{product.name}</li>
      ))}
    </ul>
  );
}

ssh-keygen -t ed25519 -C "brisamedina05@gmail.com"

eval "$(ssh-agent -s)"

ssh-add ~/.ssh/id_ed25519

cat ~/.ssh/id_ed25519.pub

mkdir project-directory
cd project-directory

git clone git@github.com:your-organization/your-repository.git

cd your-repository
npm install

npm run dev

sudo apt install nodejs

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

rm -rf node_modules
npm install

npm run dev

• $match: Filters documents based on specified criteria.
• $project: Selects or excludes fields from documents.
• $group: Groups documents by a specified field and calculates aggregate values.
• $sort: Sorts documents by a specified field.
• $limit: Limits the number of documents returned.
• $skip: Skips a specified number of documents.
• $unwind: Unwinds an array field, creating a new document for each element in the array.
• $lookup: Joins two collections based on a specified field.
• $redact: Redacts fields in documents based on specified criteria.
• $bucket: Buckets documents into groups based on a specified field.
• $sample: Samples a random subset of documents.
• $geoNear: Finds documents near a specified point.

db.orders.aggregate([
  {
    $group: {
      _id: "$customer_id",
      total_spent: { $sum: "$price" },
      total_orders: { $count: {} }
    }
  },
  {
    $project: {
      average_order_value: { $divide: ["$total_spent", "$total_orders"] }
    }
  }
])

1. $group:
   • Groups the documents by customer_id.
   • Calculates the total spent for each customer using $sum.
   • Counts the total number of orders for each customer using $count.
2. $project:
   • Calculates the average order value by dividing total_spent by total_orders.

mongosh "mongodb+srv://{MONGO_COLLECTION_USER}:{MONGO_COLLECTION_PASSWORD}@{MONGO_APP_NAME}.yng1j.mongodb.net/?appName={MONGO_APP_NAME}"

// show databases
show dbs
// use database
use <db_name>
// show collections
show collections
// finally interact with them, for example
db.users.findOne()

• Performance: Precompiled code executes faster than executing statements directly.
• Modularity: Encapsulate complex logic, making code more organized and reusable.
• Security: Centralize security rules and permissions.
• Data validation: Enforce data integrity and consistency.

CREATE PROCEDURE GetCustomers
AS
BEGIN
    SELECT CustomerID, CustomerName, City
    FROM Customers;
END;

// How to use?

EXEC GetCustomers;

CREATE PROCEDURE GetCustomersByCity
    @City nvarchar(50)
AS
BEGIN
    SELECT CustomerID, CustomerName
    FROM Customers
    WHERE City = @City;
END;

// How to use?

EXEC GetCustomersByCity @City = 'London';

1. Index creation: To enable TTL for a collection, you create an index on a field that represents the expiration time. This field must be of type Date.
2. Expiration time setting: When creating the index, you specify the TTL value in seconds.
3. Document expiration: MongoDB periodically scans the collection and deletes documents whose expiration time has passed.

db.sessions.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 3600 });

• Session management: Store session data with a TTL to automatically expire inactive sessions.
• Temporary data: Keep temporary data for a limited time, such as cached results or temporary files.
• Data retention policies: Implement data retention policies by setting appropriate TTL values for different types of data.

db.products.explain("executionStats").find({ price: { $gt: 10 } });