Browse

best practices .cursorrules strategies

Filters

Tech

Clear

Supabaar SQL

Nose-Js

novo-elements

Blade

Composer.

Luvi

Eloquent ORM

PHP 8.1

PSR-12

bun

code splitting

lazy loading

ORM

MikroORM

NestJS

ckeditor5

@emotion/styled

typescript

@prisma/client

react

next-auth

clsx

@types/react-dom

@ckeditor/ckeditor5-react

init

@emotion/react

@mui/material

@mui/styled-engine-sc

materialui

tailwindcss

aceternityui

@types/bcryptjs

@mui/icons-material

tailwind-merge

nodejs

ES

ES module

next-safe-action.

TanStack Router

TanStack Query

Tailwind.

Chrome Extension Development

Web APIs

spatie/laravel-package-tools

PHP 8.3

Pint

Vercel AI

Quokka

Tanstack query

Orval

Vercel middleware

ai-sdk-rsc

KV database

WASM

NextUI

Iconify

Telegram Bot API

Plasticode

Starknet React

Next.JS

supabase

SSR (Server-Side Rendering).

appErrors

AppError

Wagmi v2

Viem v2

Testing Library

NewSQL

REST

GCP

Protocol Buffers

gRPC

GitLab

Bitbucket

prefetch_related

select_related

shadcn/ui

Lucide React

REDCap

EEG signal processing

PyQt6

numpy

Jupyter

git

setuptools

beautifulsoup4

python-docx

PyPDF2

Pylint

spaCy

torch

watchdog

transformers

shutil

Black

pytest-mock

OpenBabel

Weights & Biases

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.