Browse

Dockerfile .cursorrules prompt files

A Dockerfile is a script containing instructions to build a Docker image, facilitating consistent and efficient application deployment across different environments.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

Chrome extension APIs

Tanstack Query

expo-secure-store

Expo SDK

expo-notifications

Server Components

Lucide

NativeWind

react-native.

Github

Stripe

Server Actions

Replicate

Anthropic

Deepgram

docker-compose

LSM tree

MVCC (Multi-Version Concurrency Control)

containerization technologies

Dockerfile

cProfile

database algorithms

asyncio

B+ tree

WAL (Write-Ahead Logging)

multiprocessing

B-tree

functional programming

GitHub Actions.

boto3

python

flask-cors

FUE5

flask

conda

SVG

gunicorn

svgwrite

CSS.

Clerk Auth

mySQL

tailwindcss.

Flask-RESTful

Flask-Caching

Flask-SQLAlchemy

Flasgger.

Flask-JWT-Extended

Flask-RESTX

Flask-Migrate

SplashScreen

react-native-i18n

React's Suspense

Views

Blueprints

expo-error-reporter

React Native

expo-updates

expo-constants

react-native-gesture-handler

react-native-safe-area-context

React Context

Redux Toolkit

react-native-encrypted-storage

expo-permissions

AppLoading

expo-localization

Extensions.

react-native-reanimated

react-query

expo-linking

useReducer

Symfony

postgres

Sqlite3

SQLAlchemy 2.0

Magic UI

Go's testing package

net/http

ServeMux

log

HTTP

React three fiber

Three.js

Cypress.

Cloudflare Workers

Cloudflare D1

EAS

Jotai

Deno

@tanstack/react-query

react-copy-to-clipboard

@rainbow-me/rainbowkit

react-hot-toast

nextjs

eslint-config-prettier

eslint

daisyui

abitype

vercel

@types/nprogress

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.