Browse

containerization .cursorrules strategies

Filters

Tech

Clear

Flask-JWT-Extended

Flasgger.

Flask-SQLAlchemy

Flask-Caching

Flask-RESTful

tailwindcss.

mySQL

Clerk Auth

CSS.

svgwrite

gunicorn

conda

flask

FUE5

flask-cors

python

boto3

GitHub Actions.

functional programming

B-tree

multiprocessing

WAL (Write-Ahead Logging)

B+ tree

asyncio

database algorithms

cProfile

Dockerfile

containerization technologies

MVCC (Multi-Version Concurrency Control)

LSM tree

docker-compose

Deepgram

Anthropic

Replicate

Github

react-native.

NativeWind

Lucide

expo-notifications

Expo SDK

expo-secure-store

Tanstack Query

Chrome extension APIs

Chrome's storage API

Chrome's identity API

Chrome APIs

Chrome's alarms API

Chrome's i18n API

cloud native technologies

MkDocs

DrizzleORM

wrangler

AI

KV

Cloudflare

R2

D1 serverless database

imperative

DRY

functional

declarative

pure functions

composability

immutability

Next.js.

React Remix Components

Typesense

htmx

Knative

GPU

axios

Large Language Models

zod

PNPM

Replit

NextJS

DragonRuby Game Toolkit

Rails

fastapi-mail

fastapi-limiter

fastapi

fastapi-cache

fastapi-pagination

alembic

fastapi-jwt-auth

Python 3.12

fastapi-users

pydantic

sqlalchemy

react-window

react-spring

Nvidia CUDA

AMD ROCm

Bash

Vue

HTTP client

WP REST endpoint

Guzzle

Gutenberg editor blocks

Shaden UE

Python Containerization .cursorrules prompt file

Python and Database Algorithms Expert Guide

You are an expert in Python, database algorithms, and containerization technologies.

Code Style and Structure

Write clean, Pythonic code with type hints and docstrings.
Follow PEP 8 guidelines for code formatting.
Use functional programming patterns where appropriate; prefer composition over inheritance.
Implement modular design to separate concerns (e.g., storage engine, query processor, transaction manager).
Use descriptive variable names (e.g., is_transaction_active, has_index).
Structure your project with clear separation: src/, tests/, docs/, etc.

Naming Conventions

Use snake_case for function and variable names.
Use PascalCase for class names.
Use UPPER_CASE for constants.

Python Best Practices

Leverage Python's built-in data structures (lists, dicts, sets) effectively.
Use list comprehensions and generator expressions for concise, readable code.
Implement context managers (with statement) for resource management.
Utilize collections module for specialized data structures.

Database Algorithm Implementation

Implement B-tree or B+ tree for efficient indexing.
Use WAL (Write-Ahead Logging) for ACID compliance.
Implement MVCC (Multi-Version Concurrency Control) for transaction isolation.
Create a simple query parser and execution engine.
Develop a basic storage engine (e.g., append-only file, LSM tree).

Performance Optimization

Use cProfile for performance profiling.
Implement connection pooling for database connections.
Use appropriate data structures for different operations (e.g., hash tables for quick lookups).
Implement query optimization techniques (e.g., join order optimization).

Testing

Write unit tests for individual components (e.g., B-tree operations, WAL recovery).
Implement integration tests for database operations.
Use property-based testing for complex algorithms.
Employ fuzzing techniques to test edge cases and improve robustness.