Browse

multiprocessing .cursorrules prompt files

Multiprocessing is a computing technique that uses multiple processors to execute tasks in parallel, increasing computational efficiency and speed for complex operations.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

shadcn-ui

@mui/styled-engine-sc

@mui/material

bcryptjs

@emotion/react

init

@ckeditor/ckeditor5-react

@types/react-dom

clsx

next-auth

react

prisma

@prisma/client

typescript

framer-motion

@emotion/styled

ckeditor5

NestJS

MikroORM

WCAG

React.FC

React.ReactNode

ORM

fetch API

lazy loading

SEO

code splitting

bun

Livewire

PSR-12

PHP 8.1

Eloquent ORM

Luvi

Alpine.js

Composer.

Blade

novo-elements

Nose-Js

Supabaar SQL

Shaden UE

Gutenberg editor blocks

Guzzle

WP REST endpoint

HTTP client

Vue

Bash

AMD ROCm

Nvidia CUDA

react-spring

react-window

next/image

sqlalchemy

pydantic

fastapi-users

Python 3.12

fastapi-jwt-auth

alembic

fastapi-pagination

fastapi-cache

fastapi

fastapi-limiter

fastapi-mail

Ruby

Rails

DragonRuby Game Toolkit

NextJS

Replit

PNPM

zod

Large Language Models

axios

GPU

Knative

htmx

Typesense

React Remix Components

Next.js.

immutability

composability

pure functions

declarative

functional

DRY

imperative

D1 serverless database

R2

Cloudflare

KV

AI

wrangler

DrizzleORM

MkDocs

cloud native technologies

Chrome's i18n API

Chrome's alarms API

Chrome APIs

Chrome's identity API

Chrome's storage API

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.