Browse

LSM tree .cursorrules prompt files

An LSM tree is a data structure that optimizes write performance on disk-based databases by batching writes and merging data in the background.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

RBAC

obsidian

Discord.py

Loguru

VCRPy

Pytest

CliRunner

Pytest-Recording

Clear

Database management

Code optimization

Type-safe APIs

Test driven development

AI agents

Next.js 14

Operational management

Project adaptability

Code review

Java Core Principles

Java Naming Conventions

Ethical and Professional Practices

Best Practices for Java Programming

Modern Java Features

Java Documentation Practices

Java Project Organization

Code Structure and Organization

File Naming Conventions

Java Source Code Management

Entity Component System (ECS)

Simulation Games

3D Game Development

Middleware

Database Integration

Communication tools

Agent frameworks

Automation tools

AI development

CSS styling

JavaScript conventions

Code documentation

ARIA

Responsive design

YAML Configuration

Minimalist JavaScript

Website Design

Progressive Enhancement

Logging and Metrics

Backend.

Frontend

Flutter Development

Code Guidelines

Monitoring and Logging

API Gateway

Serverless Deployment

Observability

Frontend Design

Cloud Architecture

Monorepo

Testing Strategy

Database Optimization

Frontend Optimization

Security Audit

Module Bundling

Backend

Web Performance Optimization

Code Styling and Structure

Code Style Guidelines

Video Application

Testing and Documentation

React Programming Patterns

Subscription Management

CSS Best Practices

Modern JavaScript

Nuxt.js

Application Development

User Dashboard

Code Standards

React Hooks

Folder Structure

Agent Framework

HTTP Methods

Input Validation

Rate Limiting

Standard Library Usage

Go Best Practices

Mechanical keyboard

JavaScript coding

Screen recording

Audio recording

React development

Open source development

HTML coding

User Interface design

Database Operations

Image and Audio Matching

Hardware Integration

Raspberry Pi

Low-Spec Hardware Compatibility

Image Processing

PEP 8 Style Guidelines

Audio Processing

react components

styling

Shopify API Best Practices

Polaris and Tailwind CSS Integration

Prisma Usage

Linters and Tools

Modern JavaScript Practices

CSS Guidelines

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

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.